blockly-fluid 1.2.10 → 1.2.12

package/fields/FieldMultilineInput.js

@@ -0,0 +1,36 @@
+module.exports = (Blockly) => {
+  class FieldMultilineInput extends Blockly.Field {
+    constructor(text) {
+      super(text);
+      this.multiline = true;
+    };
+
+    static fromJson(options) {
+      return new FieldMultilineInput(options["text"]);
+    };
+
+    showEditor_() {
+      const div = Blockly.DropDownDiv.getContentDiv();
+
+      Blockly.utils.dom.clear(div);
+
+      const textarea = document.createElement("textarea");
+
+      textarea.value = this.getValue();
+      textarea.rows = 5;
+      textarea.style.resize = "both";
+
+      div.appendChild(textarea);
+
+      textarea.focus();
+
+      textarea.addEventListener("input", () => {
+        this.setValue(textarea.value);
+      });
+
+      Blockly.DropDownDiv.showPositionedByField(this, this.sourceBlock_);
+    };
+  };
+
+  Blockly.fieldRegistry.register("field_multiline_input", FieldMultilineInput);
+};

package/index.js

@@ -63,27 +63,33 @@ module.exports = (Blockly, { generator: languageGeneratorFallback, generators: l
 
                   const dropdownId = encodeURIComponent(JSON.stringify([input.default, ...((Array.isArray(input.options)) ? input.options.map((option) => [option, option]) : Object.entries(input.options)).map(([name, text]) => [translate((typeof text === "function") ? text() : text), (typeof name === "function") ? name() : name])]));
 
-                  Blocks[`shadow_dropdown_${dropdownId}`] = {
-                    layout: "DROPDOWN",
-                    fields: {
-                      DROPDOWN: {
-                        type: "dropdown",
-                        default: input.default,
-                        options: input.options
-                      }
-                    },
-                    color,
-                    output: true,
-
-                    generator: ({ DROPDOWN = `""` }) => [
-                      `"${DROPDOWN}"`,
-                      "atomic"
-                    ]
+                  if (!Blocks[`shadow_dropdown_${dropdownId}`]) {
+                    Blocks[`shadow_dropdown_${dropdownId}`] = {
+                      layout: "DROPDOWN",
+                      fields: {
+                        DROPDOWN: {
+                          type: "dropdown",
+                          default: input.default,
+                          options: input.options
+                        }
+                      },
+                      color,
+                      output: true,
+
+                      generator: ({ DROPDOWN }) => [
+                        `"${DROPDOWN}"`,
+                        "atomic"
+                      ]
+                    };
                   };
 
                   valueInput.connection.setShadowDom(new DOMParser().parseFromString(`<shadow type="shadow_dropdown_${dropdownId}"></shadow>`, "text/xml").firstChild);
                 };
 
+                if (input.variable) {
+                  valueInput.connection.setShadowDom(new DOMParser().parseFromString(`<shadow type="shadow_variable"><field name="VARIABLE">${input.variable}</field></shadow>`, "text/xml").firstChild);
+                };
+
                 if (input.shadow) {
                   if (typeof input.shadow === "function") (input.shadow = input.shadow());
 
@@ -98,12 +104,16 @@ module.exports = (Blockly, { generator: languageGeneratorFallback, generators: l
                       translate((typeof field.default === "function") ? field.default() : (field.default || "")),
                       ...(field.validator) ? [field.validator] : []
                     ]), token);
+
                     break;
                   case "multiline":
+                    if (!Blockly.FieldMultilineInput) require("./fields/FieldMultilineInput.js")(Blockly);
+
                     dummy.appendField(new Blockly.FieldMultilineInput(...[
                       translate((typeof field.default === "function") ? field.default() : (field.default || "")),
                       ...(field.validator) ? [field.validator] : []
                     ]), token);
+
                     break;
                   case "dropdown":
                     if (typeof field.options === "function") (field.options = field.options());
@@ -112,12 +122,14 @@ module.exports = (Blockly, { generator: languageGeneratorFallback, generators: l
                       ((Array.isArray(field.options)) ? field.options.map((option) => [option, option]) : Object.entries(field.options)).map(([name, text]) => [translate((typeof text === "function") ? text() : text), (typeof name === "function") ? name() : name]),
                       ...(field.validator) ? [field.validator] : []
                     ]), token);
+
                     break;
                   case "variable":
                     dummy.appendField(new Blockly.FieldVariable(...[
                       translate((typeof field.default === "function") ? field.default() : (field.default || "")),
                       ...(field.validator) ? [field.validator] : []
                     ]), token);
+
                     break;
                   default:
                     dummy.appendField(translate(token));
@@ -255,39 +267,57 @@ module.exports = (Blockly, { generator: languageGeneratorFallback, generators: l
     }
   });
 
-  Blocks["shadow_string"] = {
-    layout: "TEXT",
-    fields: {
-      TEXT: {
-        type: "text"
-      }
-    },
-    output: true,
+  if (!Blocks["shadow_string"]) {
+    Blocks["shadow_string"] = {
+      layout: "TEXT",
+      fields: {
+        TEXT: {
+          type: "text"
+        }
+      },
+      output: true,
+
+      generator: ({ TEXT  }) => [
+        `"${TEXT}"`,
+        "atomic"
+      ]
+    };
+  };
 
-    generator: ({ TEXT = `""` }) => [
-      `"${TEXT}"`,
-      "atomic"
-    ]
+  if (!Blocks["shadow_number"]) {
+    Blocks["shadow_number"] = {
+      layout: "NUMBER",
+      fields: {
+        NUMBER: {
+          type: "text",
+          default: "0",
+          validator: (value) => {
+            if (!value) return "0";
+            if (/^-?\d*\.?\d*$/.test(value)) return value;
+          }
+        }
+      },
+      output: Number,
+
+      generator: ({ NUMBER }) => [
+        NUMBER,
+        "atomic"
+      ]
+    };
   };
 
-  Blocks["shadow_number"] = {
-    layout: "NUMBER",
-    fields: {
-      NUMBER: {
-        type: "text",
-        default: "0",
-        validator: (value) => {
-          if (!value) return "0";
-          if (/^-?\d*\.?\d*$/.test(value)) return value;
+  if (!Blocks["shadow_variable"]) {
+    Blocks["shadow_variable"] = {
+      layout: "VARIABLE",
+      fields: {
+        VARIABLE: {
+          type: "variable"
         }
-      }
-    },
-    output: Number,
+      },
+      output: true,
 
-    generator: ({ NUMBER = 0 }) => [
-      NUMBER,
-      "atomic"
-    ]
+      generator: ({ VARIABLE }) => VARIABLE
+    };
   };
 
   return Blocks;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blockly-fluid",
-  "version": "1.2.10",
+  "version": "1.2.12",
   "description": "A flexible proxy wrapper for Blockly blocks.",
   "main": "index.js",
   "scripts": {