scratch-blocks 2.0.0-spork.2 → 2.0.0-spork.3

package/src/procedures.js

@@ -1,425 +0,0 @@
-/**
- * @license
- * Visual Blocks Editor
- *
- * Copyright 2012 Google Inc.
- * https://developers.google.com/blockly/
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/**
- * @fileoverview Utility functions for handling procedures.
- * @author fraser@google.com (Neil Fraser)
- */
-
-import * as Blockly from "blockly/core";
-import * as Constants from "./constants.js";
-import * as scratchBlocksUtils from "../src/scratch_blocks_utils.js";
-
-/**
- * Find all user-created procedure definition mutations in a workspace.
- * @param {!Blockly.Workspace} root Root workspace.
- * @return {!Array.<Element>} Array of mutation xml elements.
- * @package
- */
-function allProcedureMutations(root) {
-  var blocks = root.getAllBlocks();
-  var mutations = [];
-  for (var i = 0; i < blocks.length; i++) {
-    if (blocks[i].type == Constants.PROCEDURES_PROTOTYPE_BLOCK_TYPE) {
-      var mutation = blocks[i].mutationToDom(/* opt_generateShadows */ true);
-      if (mutation) {
-        mutations.push(mutation);
-      }
-    }
-  }
-  return mutations;
-}
-
-/**
- * Sorts an array of procedure definition mutations alphabetically.
- * (Does not mutate the given array.)
- * @param {!Array.<Element>} mutations Array of mutation xml elements.
- * @return {!Array.<Element>} Sorted array of mutation xml elements.
- * @private
- */
-function sortProcedureMutations_(mutations) {
-  var newMutations = mutations.slice();
-
-  newMutations.sort(function (a, b) {
-    var procCodeA = a.getAttribute("proccode");
-    var procCodeB = b.getAttribute("proccode");
-
-    return scratchBlocksUtils.compareStrings(procCodeA, procCodeB);
-  });
-
-  return newMutations;
-}
-
-/**
- * Construct the blocks required by the flyout for the procedure category.
- * @param {!Blockly.Workspace} workspace The workspace containing procedures.
- * @return {!Array.<!Element>} Array of XML block elements.
- */
-function getProceduresCategory(workspace) {
-  var xmlList = [];
-
-  addCreateButton_(workspace, xmlList);
-
-  // Create call blocks for each procedure defined in the workspace
-  var mutations = allProcedureMutations(workspace);
-  mutations = sortProcedureMutations_(mutations);
-  for (var i = 0; i < mutations.length; i++) {
-    var mutation = mutations[i];
-    // <block type="procedures_call">
-    //   <mutation ...></mutation>
-    // </block>
-    var block = document.createElement("block");
-    block.setAttribute("type", "procedures_call");
-    block.setAttribute("gap", 16);
-    block.appendChild(mutation);
-    xmlList.push(block);
-  }
-  return xmlList;
-}
-
-/**
- * Create the "Make a Block..." button.
- * @param {!Blockly.Workspace} workspace The workspace contianing procedures.
- * @param {!Array.<!Element>} xmlList Array of XML block elements to add to.
- * @private
- */
-function addCreateButton_(workspace, xmlList) {
-  var button = document.createElement("button");
-  var msg = Blockly.Msg.NEW_PROCEDURE;
-  var callbackKey = "CREATE_PROCEDURE";
-  var callback = function () {
-    // Run the callback after a delay to avoid it getting captured by the React
-    // modal in scratch-gui and being registered as a click on the scrim that
-    // dismisses the dialog.
-    requestAnimationFrame(() => {
-      setTimeout(() => {
-        createProcedureDefCallback(workspace);
-      });
-    });
-  };
-  button.setAttribute("text", msg);
-  button.setAttribute("callbackKey", callbackKey);
-  workspace.registerButtonCallback(callbackKey, callback);
-  xmlList.push(button);
-}
-
-/**
- * Find all callers of a named procedure.
- * @param {string} name Name of procedure (procCode in scratch-blocks).
- * @param {!Blockly.Workspace} ws The workspace to find callers in.
- * @param {!Blockly.Block} definitionRoot The root of the stack where the
- *     procedure is defined.
- * @param {boolean} allowRecursive True if the search should include recursive
- *     procedure calls.  False if the search should ignore the stack starting
- *     with definitionRoot.
- * @return {!Array.<!Blockly.Block>} Array of caller blocks.
- * @package
- */
-function getCallers(name, ws, definitionRoot, allowRecursive) {
-  var allBlocks = [];
-  var topBlocks = ws.getTopBlocks();
-
-  // Start by deciding which stacks to investigate.
-  for (var i = 0; i < topBlocks.length; i++) {
-    var block = topBlocks[i];
-    if (block.id == definitionRoot.id && !allowRecursive) {
-      continue;
-    }
-    allBlocks.push.apply(allBlocks, block.getDescendants(false));
-  }
-
-  var callers = [];
-  for (var i = 0; i < allBlocks.length; i++) {
-    var block = allBlocks[i];
-    if (block.type == Constants.PROCEDURES_CALL_BLOCK_TYPE) {
-      var procCode = block.getProcCode();
-      if (procCode && procCode == name) {
-        callers.push(block);
-      }
-    }
-  }
-  return callers;
-}
-
-/**
- * Find and edit all callers with a procCode using a new mutation.
- * @param {string} name Name of procedure (procCode in scratch-blocks).
- * @param {!Blockly.Workspace} ws The workspace to find callers in.
- * @param {!Element} mutation New mutation for the callers.
- * @package
- */
-function mutateCallersAndPrototype(name, ws, mutation) {
-  var defineBlock = getDefineBlock(name, ws);
-  var prototypeBlock = getPrototypeBlock(name, ws);
-  if (defineBlock && prototypeBlock) {
-    var callers = getCallers(
-      name,
-      defineBlock.workspace,
-      defineBlock,
-      true /* allowRecursive */
-    );
-    callers.push(prototypeBlock);
-    Blockly.Events.setGroup(true);
-    for (var i = 0, caller; (caller = callers[i]); i++) {
-      var oldMutationDom = caller.mutationToDom();
-      var oldMutation = oldMutationDom && Blockly.Xml.domToText(oldMutationDom);
-      caller.domToMutation(mutation);
-      var newMutationDom = caller.mutationToDom();
-      var newMutation = newMutationDom && Blockly.Xml.domToText(newMutationDom);
-      if (oldMutation != newMutation) {
-        Blockly.Events.fire(
-          new Blockly.Events.BlockChange(
-            caller,
-            "mutation",
-            null,
-            oldMutation,
-            newMutation
-          )
-        );
-      }
-    }
-    Blockly.Events.setGroup(false);
-  } else {
-    alert("No define block on workspace"); // TODO decide what to do about this.
-  }
-}
-
-/**
- * Find the definition block for the named procedure.
- * @param {string} procCode The identifier of the procedure.
- * @param {!Blockly.Workspace} workspace The workspace to search.
- * @return {Blockly.Block} The procedure definition block, or null not found.
- * @package
- */
-function getDefineBlock(procCode, workspace) {
-  // Assume that a procedure definition is a top block.
-  var blocks = workspace.getTopBlocks(false);
-  for (var i = 0; i < blocks.length; i++) {
-    if (blocks[i].type == Constants.PROCEDURES_DEFINITION_BLOCK_TYPE) {
-      var prototypeBlock = blocks[i]
-        .getInput("custom_block")
-        .connection.targetBlock();
-      if (
-        prototypeBlock.getProcCode &&
-        prototypeBlock.getProcCode() == procCode
-      ) {
-        return blocks[i];
-      }
-    }
-  }
-  return null;
-}
-
-/**
- * Find the prototype block for the named procedure.
- * @param {string} procCode The identifier of the procedure.
- * @param {!Blockly.Workspace} workspace The workspace to search.
- * @return {Blockly.Block} The procedure prototype block, or null not found.
- * @package
- */
-function getPrototypeBlock(procCode, workspace) {
-  var defineBlock = getDefineBlock(procCode, workspace);
-  if (defineBlock) {
-    return defineBlock.getInput("custom_block").connection.targetBlock();
-  }
-  return null;
-}
-
-/**
- * Create a mutation for a brand new custom procedure.
- * @return {Element} The mutation for a new custom procedure
- * @package
- */
-function newProcedureMutation() {
-  var mutationText =
-    "<xml>" +
-    "<mutation" +
-    ' proccode="' +
-    Blockly.Msg["PROCEDURE_DEFAULT_NAME"] +
-    '"' +
-    ' argumentids="[]"' +
-    ' argumentnames="[]"' +
-    ' argumentdefaults="[]"' +
-    ' warp="false">' +
-    "</mutation>" +
-    "</xml>";
-  return Blockly.utils.xml.textToDom(mutationText).firstChild;
-}
-
-/**
- * Callback to create a new procedure custom command block.
- * @param {!Blockly.Workspace} workspace The workspace to create the new procedure on.
- * @private
- */
-function createProcedureDefCallback(workspace) {
-  ScratchProcedures.externalProcedureDefCallback(
-    newProcedureMutation(),
-    createProcedureCallbackFactory_(workspace)
-  );
-}
-
-/**
- * Callback factory for adding a new custom procedure from a mutation.
- * @param {!Blockly.Workspace} workspace The workspace to create the new procedure on.
- * @return {function(?Element)} callback for creating the new custom procedure.
- * @private
- */
-function createProcedureCallbackFactory_(workspace) {
-  return function (mutation) {
-    if (mutation) {
-      var blockText =
-        "<xml>" +
-        '<block type="procedures_definition">' +
-        '<statement name="custom_block">' +
-        '<shadow type="procedures_prototype">' +
-        Blockly.Xml.domToText(mutation) +
-        "</shadow>" +
-        "</statement>" +
-        "</block>" +
-        "</xml>";
-      var blockDom = Blockly.utils.xml.textToDom(blockText).firstChild;
-      Blockly.Events.setGroup(true);
-      var block = Blockly.Xml.domToBlock(blockDom, workspace);
-      Blockly.renderManagement.finishQueuedRenders().then(() => {
-        var scale = workspace.scale; // To convert from pixel units to workspace units
-        // Position the block so that it is at the top left of the visible workspace,
-        // padded from the edge by 30 units. Position in the top right if RTL.
-        var posX = -workspace.scrollX;
-        if (workspace.RTL) {
-          posX += workspace.getMetrics().contentWidth - 30;
-        } else {
-          posX += 30;
-        }
-        block.moveBy(posX / scale, (-workspace.scrollY + 30) / scale);
-        block.scheduleSnapAndBump();
-        Blockly.Events.setGroup(false);
-      });
-    }
-  };
-}
-
-/**
- * Callback to open the modal for editing custom procedures.
- * @param {!Blockly.Block} block The block that was right-clicked.
- * @private
- */
-function editProcedureCallback_(block) {
-  // Edit can come from one of three block types (call, define, prototype)
-  // Normalize by setting the block to the prototype block for the procedure.
-  if (block.type == Constants.PROCEDURES_DEFINITION_BLOCK_TYPE) {
-    var input = block.getInput("custom_block");
-    if (!input) {
-      alert("Bad input"); // TODO: Decide what to do about this.
-      return;
-    }
-    var conn = input.connection;
-    if (!conn) {
-      alert("Bad connection"); // TODO: Decide what to do about this.
-      return;
-    }
-    var innerBlock = conn.targetBlock();
-    if (
-      !innerBlock ||
-      !innerBlock.type == Constants.PROCEDURES_PROTOTYPE_BLOCK_TYPE
-    ) {
-      alert("Bad inner block"); // TODO: Decide what to do about this.
-      return;
-    }
-    block = innerBlock;
-  } else if (block.type == Constants.PROCEDURES_CALL_BLOCK_TYPE) {
-    // This is a call block, find the prototype corresponding to the procCode.
-    // Make sure to search the correct workspace, call block can be in flyout.
-    var workspaceToSearch = block.workspace.isFlyout
-      ? block.workspace.targetWorkspace
-      : block.workspace;
-    block = getPrototypeBlock(block.getProcCode(), workspaceToSearch);
-  }
-  // Block now refers to the procedure prototype block, it is safe to proceed.
-  ScratchProcedures.externalProcedureDefCallback(
-    block.mutationToDom(),
-    editProcedureCallbackFactory_(block)
-  );
-}
-
-/**
- * Callback factory for editing an existing custom procedure.
- * @param {!Blockly.Block} block The procedure prototype block being edited.
- * @return {function(?Element)} Callback for editing the custom procedure.
- * @private
- */
-function editProcedureCallbackFactory_(block) {
-  return function (mutation) {
-    if (mutation) {
-      mutateCallersAndPrototype(block.getProcCode(), block.workspace, mutation);
-    }
-  };
-}
-
-/**
- * Make a context menu option for editing a custom procedure.
- * This appears in the context menu for procedure definitions and procedure
- * calls.
- * @param {!Blockly.BlockSvg} block The block where the right-click originated.
- * @return {!Object} A menu option, containing text, enabled, and a callback.
- * @package
- */
-function makeEditOption(block) {
-  var editOption = {
-    enabled: true,
-    text: Blockly.Msg.EDIT_PROCEDURE,
-    callback: function () {
-      editProcedureCallback_(block);
-    },
-  };
-  return editOption;
-}
-
-/**
- * Callback to try to delete a custom block definitions.
- * @param {string} procCode The identifier of the procedure to delete.
- * @param {!Blockly.Block} definitionRoot The root block of the stack that
- *     defines the custom procedure.
- * @return {boolean} True if the custom procedure was deleted, false otherwise.
- * @package
- */
-function deleteProcedureDefCallback(procCode, definitionRoot) {
-  const callers = getCallers(
-    procCode,
-    definitionRoot.workspace,
-    definitionRoot,
-    false /* allowRecursive */
-  );
-  if (callers.length > 0) {
-    return false;
-  }
-
-  const workspace = definitionRoot.workspace;
-  Blockly.BlockSvg.prototype.checkAndDelete.call(definitionRoot);
-  return true;
-}
-
-const ScratchProcedures = {
-  externalProcedureDefCallback: null,
-  createProcedureDefCallback,
-  deleteProcedureDefCallback,
-  getProceduresCategory,
-  makeEditOption,
-};
-export { ScratchProcedures };

package/src/renderer/renderer.js

@@ -1,74 +0,0 @@
-/**
- * @license
- * Copyright 2024 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import * as Blockly from "blockly/core";
-import { Drawer } from "./drawer.js";
-import { RenderInfo } from "./render_info.js";
-import { ConstantProvider } from "./constants.js";
-import { PathObject } from "./path_object.js";
-
-/**
- * Custom renderer for Scratch-style blocks.
- */
-export class ScratchRenderer extends Blockly.zelos.Renderer {
-  /**
-   * Create a new instance of the renderer's drawer.
-   *
-   * @param {!Blockly.BlockSvg} block The block to render.
-   * @param info {!Blockly.blockRendering.RenderInfo} An object containing all
-   *     information needed to render this block.
-   * @returns {!Drawer} The drawer.
-   */
-  makeDrawer_(block, info) {
-    return new Drawer(block, info);
-  }
-
-  /**
-   * Create a new instance of the renderer's render info object.
-   *
-   * @param {!Blockly.BlockSvg} block The block to measure.
-   * @returns {!RenderInfo} The render info object.
-   */
-  makeRenderInfo_(block) {
-    return new RenderInfo(this, block);
-  }
-
-  /**
-   * Create a new instance of the renderer's constant provider.
-   *
-   * @returns {!ConstantProvider} The constant provider.
-   */
-  makeConstants_() {
-    return new ConstantProvider();
-  }
-
-  /**
-   * Create a new instance of a renderer path object.
-   *
-   * @param {!SVGElement} root The root SVG element.
-   * @param {!Blockly.BlockStyle} style The style object to use for colouring.
-   * @returns {!PathObject} The renderer path object.
-   */
-  makePathObject(root, style) {
-    return new PathObject(root, style, this.getConstants());
-  }
-
-  /**
-   * Determine whether or not to highlight a connection.
-   *
-   * @param {!Blockly.RenderedConnection} connection The connection to determine
-   *     whether or not to highlight.
-   * @returns {boolean} True if we should highlight the connection.
-   */
-  shouldHighlightConnection(connection) {
-    return (
-      connection.type === Blockly.ConnectionType.INPUT_VALUE &&
-      connection.getCheck()?.includes("Boolean")
-    );
-  }
-}
-
-Blockly.blockRendering.register("scratch", ScratchRenderer);

package/src/scratch_blocks_utils.js

@@ -1,148 +0,0 @@
-/**
- * @license
- * Visual Blocks Editor
- *
- * Copyright 2018 Google Inc.
- * https://developers.google.com/blockly/
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/**
- * @fileoverview Utility methods for Scratch Blocks but not Blockly.
- * @author fenichel@google.com (Rachel Fenichel)
- */
-import * as Blockly from "blockly/core";
-
-/**
- * Re-assign obscured shadow blocks new IDs to prevent collisions
- * Scratch specific to help the VM handle deleting obscured shadows.
- * @param {Blockly.Block} block the root block to be processed.
- * @package
- */
-export function changeObscuredShadowIds(block) {
-  var blocks = block.getDescendants(false);
-  for (var i = blocks.length - 1; i >= 0; i--) {
-    var descendant = blocks[i];
-    for (var j = 0; j < descendant.inputList.length; j++) {
-      var connection = descendant.inputList[j].connection;
-      if (connection) {
-        var shadowDom = connection.getShadowDom();
-        if (shadowDom) {
-          shadowDom.setAttribute("id", Blockly.utils.genUid());
-          connection.setShadowDom(shadowDom);
-        }
-      }
-    }
-  }
-}
-
-/**
- * Compare strings with natural number sorting.
- * @param {string} str1 First input.
- * @param {string} str2 Second input.
- * @return {number} -1, 0, or 1 to signify greater than, equality, or less than.
- */
-export function compareStrings(str1, str2) {
-  return str1.localeCompare(str2, [], {
-    sensitivity: "base",
-    numeric: true,
-  });
-}
-
-/**
- * Creates a callback function for a click on the "duplicate" context menu
- * option in Scratch Blocks.  The block is duplicated and attached to the mouse,
- * which acts as though it were pressed and mid-drag.  Clicking the mouse
- * releases the new dragging block.
- * @param {!Blockly.BlockSvg} oldBlock The block that will be duplicated.
- * @param {!Event} event Event that caused the context menu to open.
- * @return {Function} A callback function that duplicates the block and starts a
- *     drag.
- * @package
- */
-export function duplicateAndDragCallback(oldBlock, event) {
-  var isMouseEvent =
-    Blockly.Touch.getTouchIdentifierFromEvent(event) === "mouse";
-  return function (e) {
-    // Give the context menu a chance to close.
-    setTimeout(function () {
-      var ws = oldBlock.workspace;
-      var svgRootOld = oldBlock.getSvgRoot();
-      if (!svgRootOld) {
-        throw new Error("oldBlock is not rendered.");
-      }
-
-      // Create the new block by cloning the block in the flyout (via XML).
-      var xml = Blockly.Xml.blockToDom(oldBlock);
-      // The target workspace would normally resize during domToBlock, which
-      // will lead to weird jumps.
-      // Resizing will be enabled when the drag ends.
-      ws.setResizesEnabled(false);
-
-      // Disable events and manually emit events after the block has been
-      // positioned and has had its shadow IDs fixed (Scratch-specific).
-      Blockly.Events.disable();
-      try {
-        // Using domToBlock instead of domToWorkspace means that the new block
-        // will be placed at position (0, 0) in main workspace units.
-        var newBlock = Blockly.Xml.domToBlock(xml, ws);
-
-        // Scratch-specific: Give shadow dom new IDs to prevent duplicating on paste
-        changeObscuredShadowIds(newBlock);
-
-        var svgRootNew = newBlock.getSvgRoot();
-        if (!svgRootNew) {
-          throw new Error("newBlock is not rendered.");
-        }
-
-        // The position of the old block in workspace coordinates.
-        var oldBlockPosWs = oldBlock.getRelativeToSurfaceXY();
-
-        // Place the new block as the same position as the old block.
-        // TODO: Offset by the difference between the mouse position and the upper
-        // left corner of the block.
-        newBlock.moveBy(oldBlockPosWs.x, oldBlockPosWs.y);
-        if (!isMouseEvent) {
-          var offsetX = ws.RTL ? -100 : 100;
-          var offsetY = 100;
-          newBlock.moveBy(offsetX, offsetY); // Just offset the block for touch.
-        }
-      } finally {
-        Blockly.Events.enable();
-      }
-      if (Blockly.Events.isEnabled()) {
-        Blockly.Events.fire(new Blockly.Events.BlockCreate(newBlock));
-      }
-
-      if (isMouseEvent) {
-        // e is not a real mouseEvent/touchEvent/pointerEvent.  It's an event
-        // created by the context menu and has the coordinates of the mouse
-        // click that opened the context menu.
-        var fakeEvent = {
-          clientX: event.clientX,
-          clientY: event.clientY,
-          type: "mousedown",
-          preventDefault: function () {
-            e.preventDefault();
-          },
-          stopPropagation: function () {
-            e.stopPropagation();
-          },
-          target: e.target,
-        };
-        ws.startDragWithFakeEvent(fakeEvent, newBlock);
-      }
-    }, 0);
-  };
-}

package/src/scratch_connection_checker.js

@@ -1,29 +0,0 @@
-/**
- * @license
- * Copyright 2024 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import * as Blockly from "blockly/core";
-
-class ScratchConnectionChecker extends Blockly.ConnectionChecker {
-  // This check prevents dragging a block into the slot occupied by the
-  // procedure caller example block in a procedure definition block.
-  doDragChecks(a, b, distance) {
-    if (
-      b.getSourceBlock().type === "procedures_definition" &&
-      b.getParentInput()?.name === "custom_block"
-    ) {
-      return false;
-    }
-
-    return super.doDragChecks(a, b, distance);
-  }
-}
-
-Blockly.registry.register(
-  Blockly.registry.Type.CONNECTION_CHECKER,
-  Blockly.registry.DEFAULT,
-  ScratchConnectionChecker,
-  true
-);

package/src/scratch_variable_model.js

@@ -1,24 +0,0 @@
-/**
- * @license
- * Copyright 2024 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import * as Blockly from "blockly/core";
-
-class ScratchVariableModel extends Blockly.VariableModel {
-  constructor(workspace, name, type, id, isLocal, isCloud) {
-    super(workspace, name, type, id);
-    // isLocal and isCloud may not be passed when creating broadcast message
-    // variables, which conveniently are neither local nor cloud.
-    this.isLocal = !!isLocal;
-    this.isCloud = !!isCloud;
-  }
-}
-
-Blockly.registry.register(
-  Blockly.registry.Type.VARIABLE_MODEL,
-  Blockly.registry.DEFAULT,
-  ScratchVariableModel,
-  true
-);