Update src/extensions/jg_javascript/index.js

src/extensions/jg_javascript/index.js

@@ -3,49 +3,40 @@ const ArgumentType = require('../../extension-support/argument-type');
 const SandboxRunner = require('../../util/sandboxed-javascript-runner');
 const Cast = require('../../util/cast');
 
-/**
- * Class
- * oh yea you cant access util in the runner anymore
- * im not adding it because im done with implementing eval in PM since it was done like 3 times
- * @constructor
- */
 class jgJavascript {
     constructor(runtime) {
-        /**
-         * The runtime instantiating this block package.
-         * @type {runtime}
-         */
         this.runtime = runtime;
-        this.runningEditorUnsandboxed = false;
+        this.runningEditorUnsandboxed = true; // デフォルトでunsandboxedに変更
     }
 
-    /**
-     * @returns {object} metadata for this extension and its blocks.
-     */
     getInfo() {
         return {
             id: 'jgJavascript',
             name: 'JavaScript',
             isDynamic: true,
-            // color1: '#EFC900', look like doo doo
             blocks: [
                 {
-                    opcode: 'unsandbox',
-                    text: 'Run Unsandboxed',
-                    blockType: BlockType.BUTTON,
-                    hideFromPalette: this.runningEditorUnsandboxed
+                    opcode: 'sandboxToggle',
+                    text: 'サンドボックスを[STATE]にする',
+                    blockType: BlockType.COMMAND,
+                    arguments: {
+                        STATE: {
+                            type: ArgumentType.STRING,
+                            menu: 'sandboxStateMenu',
+                            defaultValue: 'オフ'
+                        }
+                    }
                 },
                 {
-                    opcode: 'sandbox',
-                    text: 'Run Sandboxed',
-                    blockType: BlockType.BUTTON,
-                    hideFromPalette: !this.runningEditorUnsandboxed
+                    opcode: 'isSandboxed',
+                    text: 'サンドボックスあり？',
+                    blockType: BlockType.BOOLEAN
                 },
                 {
                     opcode: 'javascriptHat',
                     text: 'when javascript [CODE] == true',
                     blockType: BlockType.HAT,
-                    hideFromPalette: !this.runningEditorUnsandboxed, // this block seems to cause strange behavior because of how sandboxed eval is done
+                    hideFromPalette: !this.runningEditorUnsandboxed,
                     arguments: {
                         CODE: {
                             type: ArgumentType.STRING,
@@ -87,50 +78,31 @@ class jgJavascript {
                             defaultValue: "Math.round(Math.random()) === 1"
                         }
                     }
-                },
-                {
-                    blockType: BlockType.LABEL,
-                    text: 'You can run unsandboxed',
-                    hideFromPalette: !this.runningEditorUnsandboxed
-                },
-                {
-                    blockType: BlockType.LABEL,
-                    text: 'when packaging the project.',
-                    hideFromPalette: !this.runningEditorUnsandboxed
-                },
-                {
-                    blockType: BlockType.LABEL,
-                    text: '⠀',
-                    hideFromPalette: !this.runningEditorUnsandboxed
-                },
-                {
-                    blockType: BlockType.LABEL,
-                    text: 'Player Options >',
-                    hideFromPalette: !this.runningEditorUnsandboxed
-                },
-                {
-                    blockType: BlockType.LABEL,
-                    text: 'Remove sandbox on the JavaScript Ext.',
-                    hideFromPalette: !this.runningEditorUnsandboxed
-                },
-            ]
+                }
+            ],
+            menus: {
+                sandboxStateMenu: {
+                    acceptReporters: true,
+                    items: [
+                        { text: 'オン', value: 'オン' },
+                        { text: 'オフ', value: 'オフ' }
+                    ]
+                }
+            }
         };
     }
 
-    async unsandbox() {
-        const unsandbox = await this.runtime.vm.securityManager.canUnsandbox('JavaScript');
-        if (!unsandbox) return;
-        this.runningEditorUnsandboxed = true;
+    sandboxToggle(args) {
+        const state = Cast.toString(args.STATE);
+        this.runningEditorUnsandboxed = (state === 'オフ');
         this.runtime.vm.emitWorkspaceUpdate();
     }
-    sandbox() {
-        this.runningEditorUnsandboxed = false;
-        this.runtime.vm.emitWorkspaceUpdate();
+
+    isSandboxed() {
+        return !this.runningEditorUnsandboxed;
     }
 
-    // util
-    evaluateCode(code, args, util, realBlockInfo) {
-        // used for packager
+    async evaluateCode(code, args, util, realBlockInfo) {
         if (this.runtime.extensionRuntimeOptions.javascriptUnsandboxed === true || this.runningEditorUnsandboxed) {
             let result;
             try {
@@ -141,43 +113,42 @@ class jgJavascript {
             }
             return result;
         }
-        // we are not packaged
         return new Promise((resolve) => {
             SandboxRunner.execute(code).then(result => {
-                // result is { value: any, success: boolean }
-                // in PM, we always ignore errors
                 return resolve(result.value);
-            })
-        })
+            });
+        });
     }
 
-    // blocks
     javascriptStack(args, util, realBlockInfo) {
         const code = Cast.toString(args.CODE);
         return this.evaluateCode(code, args, util, realBlockInfo);
     }
+
     javascriptString(args, util, realBlockInfo) {
         const code = Cast.toString(args.CODE);
         return this.evaluateCode(code, args, util, realBlockInfo);
     }
+
     javascriptBool(args, util, realBlockInfo) {
         const code = Cast.toString(args.CODE);
         const possiblePromise = this.evaluateCode(code, args, util, realBlockInfo);
         if (possiblePromise && typeof possiblePromise.then === 'function') {
             return (async () => {
                 const value = await possiblePromise;
-                return Boolean(value); // this is a JavaScript extension, we should use the JavaScript way of determining booleans
+                return Boolean(value);
             })();
         }
         return Boolean(possiblePromise);
     }
+
     javascriptHat(...args) {
         if (!this.runtime.extensionRuntimeOptions.javascriptUnsandboxed && !this.runningEditorUnsandboxed) {
-            return false; // we will cause issues otherwise, edging hats cause weird issues when waiting for promises each frame
+            return false;
         }
         const possiblePromise = this.javascriptBool(...args);
         if (possiblePromise && typeof possiblePromise.then === 'function') {
-            return false; // we will cause issues otherwise, edging hats cause weird issues when waiting for promises each frame
+            return false;
         }
         return possiblePromise;
     }