scratch-blocks 2.0.2 → 2.0.4

package/src/scratch_connection_checker.ts

@@ -1,38 +1,43 @@
 /**
- * @license
  * Copyright 2024 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-
-import * as Blockly from "blockly/core";
+import * as Blockly from 'blockly/core'
 
 /**
  * Custom connection checker to restrict which blocks can be connected.
  */
 class ScratchConnectionChecker extends Blockly.ConnectionChecker {
+  override canConnectWithReason(
+    a: Blockly.Connection | null,
+    b: Blockly.Connection | null,
+    isDragging: boolean,
+    opt_distance?: number,
+  ): number {
+    // The prototype block is visual-only and should not accept any connections.
+    const isPrototypeConnection = (c: Blockly.Connection | null) =>
+      c?.getSourceBlock().type === 'procedures_prototype'
+    if (isPrototypeConnection(a) || isPrototypeConnection(b)) {
+      return Blockly.Connection.REASON_CHECKS_FAILED
+    }
+    return super.canConnectWithReason(a, b, isDragging, opt_distance)
+  }
+
   /**
    * Returns whether or not the two connections should be allowed to connect.
-   *
    * @param a One of the connections to check.
    * @param b The other connection to check.
    * @param distance The maximum allowable distance between connections.
    * @returns True if the connections should be allowed to connect.
    */
-  doDragChecks(
-    a: Blockly.RenderedConnection,
-    b: Blockly.RenderedConnection,
-    distance: number
-  ): boolean {
+  doDragChecks(a: Blockly.RenderedConnection, b: Blockly.RenderedConnection, distance: number): boolean {
     // This check prevents dragging a block into the slot occupied by the
     // procedure caller example block in a procedure definition block.
-    if (
-      b.getSourceBlock().type === "procedures_definition" &&
-      b.getParentInput()?.name === "custom_block"
-    ) {
-      return false;
+    if (b.getSourceBlock().type === 'procedures_definition' && b.getParentInput()?.name === 'custom_block') {
+      return false
     }
 
-    return super.doDragChecks(a, b, distance);
+    return super.doDragChecks(a, b, distance)
   }
 }
 
@@ -40,5 +45,5 @@ Blockly.registry.register(
   Blockly.registry.Type.CONNECTION_CHECKER,
   Blockly.registry.DEFAULT,
   ScratchConnectionChecker,
-  true
-);
+  true,
+)

package/src/scratch_continuous_category.ts

@@ -1,15 +1,13 @@
 /**
- * @license
  * Copyright 2024 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-
-import * as Blockly from "blockly/core";
-import { ContinuousCategory } from "@blockly/continuous-toolbox";
+import { ContinuousCategory } from '@blockly/continuous-toolbox'
+import * as Blockly from 'blockly/core'
 
 type StatusIndicatorCategoryInfo = Blockly.utils.toolbox.CategoryInfo & {
-  showStatusButton?: string;
-};
+  showStatusButton?: string
+}
 
 /**
  * Selectable category shown in the Scratch toolbox.
@@ -20,10 +18,10 @@ export class ScratchContinuousCategory extends ContinuousCategory {
    * in the flyout, typically for extensions that interface with hardware
    * devices.
    */
-  private showStatusButton = false;
+  private showStatusButton = false
 
-  /** Creates a new ScratchContinuousCategory.
-   *
+  /**
+   * Creates a new ScratchContinuousCategory.
    * @param toolboxItemDef A toolbox item definition.
    * @param parentToolbox The toolbox this category is being added to.
    * @param opt_parent The parent toolbox category, if any.
@@ -31,10 +29,10 @@ export class ScratchContinuousCategory extends ContinuousCategory {
   constructor(
     toolboxItemDef: StatusIndicatorCategoryInfo,
     parentToolbox: Blockly.Toolbox,
-    opt_parent?: Blockly.ICollapsibleToolboxItem
+    opt_parent?: Blockly.ICollapsibleToolboxItem,
   ) {
-    super(toolboxItemDef, parentToolbox, opt_parent);
-    this.showStatusButton = toolboxItemDef["showStatusButton"] === "true";
+    super(toolboxItemDef, parentToolbox, opt_parent)
+    this.showStatusButton = toolboxItemDef.showStatusButton === 'true'
   }
 
   /**
@@ -43,14 +41,14 @@ export class ScratchContinuousCategory extends ContinuousCategory {
    */
   createIconDom_(): HTMLElement {
     if (this.toolboxItemDef_.iconURI) {
-      const icon = document.createElement("img");
-      icon.src = this.toolboxItemDef_.iconURI;
-      icon.className = "categoryIconBubble";
-      return icon;
+      const icon = document.createElement('img')
+      icon.src = this.toolboxItemDef_.iconURI
+      icon.className = 'categoryIconBubble'
+      return icon
     } else {
-      const icon = super.createIconDom_();
-      icon.style.border = `1px solid ${this.toolboxItemDef_["secondaryColour"]}`;
-      return icon;
+      const icon = super.createIconDom_()
+      icon.style.border = `1px solid ${this.toolboxItemDef_.secondaryColour}`
+      return icon
     }
   }
 
@@ -59,29 +57,27 @@ export class ScratchContinuousCategory extends ContinuousCategory {
    * @param isSelected True if this category is selected.
    */
   setSelected(isSelected: boolean) {
-    super.setSelected(isSelected);
+    super.setSelected(isSelected)
     // Prevent hardcoding the background color to grey.
-    this.rowDiv_.style.backgroundColor = "";
+    this.rowDiv_.style.backgroundColor = ''
   }
 
   /**
    * Returns whether or not this category's label in the flyout should display
    * status indicators.
+   * @returns True if the status indicator button should be shown.
    */
   shouldShowStatusButton() {
-    return this.showStatusButton;
+    return this.showStatusButton
   }
 }
 
 /** Registers this toolbox category and unregisters the default one. */
 export function registerScratchContinuousCategory() {
-  Blockly.registry.unregister(
-    Blockly.registry.Type.TOOLBOX_ITEM,
-    ScratchContinuousCategory.registrationName
-  );
+  Blockly.registry.unregister(Blockly.registry.Type.TOOLBOX_ITEM, ScratchContinuousCategory.registrationName)
   Blockly.registry.register(
     Blockly.registry.Type.TOOLBOX_ITEM,
     ScratchContinuousCategory.registrationName,
-    ScratchContinuousCategory
-  );
+    ScratchContinuousCategory,
+  )
 }

package/src/scratch_continuous_toolbox.ts

@@ -1,13 +1,11 @@
 /**
- * @license
  * Copyright 2024 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-
-import * as Blockly from "blockly/core";
-import { ContinuousToolbox } from "@blockly/continuous-toolbox";
-import { ScratchContinuousCategory } from "./scratch_continuous_category";
-import { STATUS_INDICATOR_LABEL_TYPE } from "./status_indicator_label_flyout_inflater";
+import { ContinuousToolbox } from '@blockly/continuous-toolbox'
+import * as Blockly from 'blockly/core'
+import { ScratchContinuousCategory } from './scratch_continuous_category'
+import { STATUS_INDICATOR_LABEL_TYPE } from './status_indicator_label_flyout_inflater'
 
 /**
  * A toolbox that displays items from all categories in one scrolling list.
@@ -16,7 +14,7 @@ export class ScratchContinuousToolbox extends ContinuousToolbox {
   /**
    * List of functions to run after the next time the toolbox renders.
    */
-  private postRenderCallbacks: (() => void)[] = [];
+  private postRenderCallbacks: (() => void)[] = []
 
   refreshSelection() {
     // Intentionally a no-op, Scratch manually manages refreshing the toolbox
@@ -26,37 +24,33 @@ export class ScratchContinuousToolbox extends ContinuousToolbox {
   /**
    * Converts the given toolbox item to a corresponding array of items that
    * should appear in the flyout.
-   *
-   * @param toolboxItem The toolbox item to convert.
+   * @param toolboxItem The toolbox item to translate into flyout content.
    * @returns An array of flyout item definitions.
    */
   protected convertToolboxItemToFlyoutItems(
-    toolboxItem: Blockly.IToolboxItem
+    toolboxItem: Blockly.IToolboxItem,
   ): Blockly.utils.toolbox.FlyoutItemInfoArray {
-    const contents = super.convertToolboxItemToFlyoutItems(toolboxItem);
-    if (
-      toolboxItem instanceof ScratchContinuousCategory &&
-      toolboxItem.shouldShowStatusButton()
-    ) {
+    const contents = super.convertToolboxItemToFlyoutItems(toolboxItem)
+    if (toolboxItem instanceof ScratchContinuousCategory && toolboxItem.shouldShowStatusButton()) {
       contents.splice(0, 1, {
         kind: STATUS_INDICATOR_LABEL_TYPE,
         id: toolboxItem.getId(),
         text: toolboxItem.getName(),
-      });
+      })
     }
-    return contents;
+    return contents
   }
 
   /**
    * Forcibly rerenders the toolbox, preserving selection when possible.
    */
   forceRerender() {
-    const selectedCategoryName = this.selectedItem_?.getName();
-    this.getFlyout().show(this.getInitialFlyoutContents());
-    this.selectCategoryByName(selectedCategoryName);
-    let callback;
+    const selectedCategoryName = this.selectedItem_?.getName()
+    this.getFlyout().show(this.getInitialFlyoutContents())
+    this.selectCategoryByName(selectedCategoryName)
+    let callback
     while ((callback = this.postRenderCallbacks.shift())) {
-      callback();
+      callback()
     }
   }
 
@@ -65,22 +59,21 @@ export class ScratchContinuousToolbox extends ContinuousToolbox {
    * @param callback A callback to run whenever the toolbox next rerenders.
    */
   runAfterRerender(callback: () => void) {
-    this.postRenderCallbacks.push(callback);
+    this.postRenderCallbacks.push(callback)
   }
 
   /**
    * Returns whether or not the given item should be deselected.
    * Prevents items from being deselected without a replacement.
-   *
    * @param oldItem The item that was previously selected.
    * @param newItem The item that is proposed to be selected instead.
    * @returns True if the old item should be allowed to be deselected.
    */
   shouldDeselectItem_(
     oldItem: Blockly.ISelectableToolboxItem | null,
-    newItem: Blockly.ISelectableToolboxItem | null
+    newItem: Blockly.ISelectableToolboxItem | null,
   ) {
-    if (!newItem) return false;
-    return super.shouldDeselectItem_(oldItem, newItem);
+    if (!newItem) return false
+    return super.shouldDeselectItem_(oldItem, newItem)
   }
 }

package/src/scratch_dragger.ts

@@ -1,18 +1,16 @@
 /**
- * @license
  * Copyright 2024 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-
-import * as Blockly from "blockly/core";
-import { BlockDragOutside } from "./events/events_block_drag_outside";
-import { BlockDragEnd } from "./events/events_block_drag_end";
-import { isProcedureBlock, getCallers } from "./procedures";
+import * as Blockly from 'blockly/core'
+import { BlockDragEnd } from './events/events_block_drag_end'
+import { BlockDragOutside } from './events/events_block_drag_outside'
+import { isProcedureBlock, getCallers } from './procedures'
 
 /**
  * CSS class that allows the workspace to overflow its bounds when set.
  */
-const BOUNDLESS_CLASS = "boundless";
+const BOUNDLESS_CLASS = 'boundless'
 
 /**
  * Class responsible for managing dragging items on the workspace.
@@ -21,138 +19,119 @@ export class ScratchDragger extends Blockly.dragging.Dragger {
   /**
    * Whether or not the current drag location is outside of the main workspace.
    */
-  draggedOutOfBounds = false;
+  draggedOutOfBounds = false
 
   /**
    * Whether or not the current drag started from the flyout.
    */
-  originatedFromFlyout = false;
+  originatedFromFlyout = false
 
   /**
    * Sets the current item being dragged.
-   *
    * @param draggable The item being dragged.
    */
   setDraggable(draggable: Blockly.IDraggable) {
-    this.draggable = draggable;
+    this.draggable = draggable
   }
 
   /**
    * Handles the start of a drag operation.
-   *
    * @param event The event that triggered the drag.
    */
   onDragStart(event: PointerEvent) {
-    super.onDragStart(event);
+    super.onDragStart(event)
     if (this.draggable instanceof Blockly.BlockSvg) {
-      this.workspace.addClass(BOUNDLESS_CLASS);
-      const absoluteMetrics = this.workspace
-        .getMetricsManager()
-        .getAbsoluteMetrics();
-      const viewMetrics = this.workspace.getMetricsManager().getViewMetrics();
+      this.workspace.addClass(BOUNDLESS_CLASS)
+      const absoluteMetrics = this.workspace.getMetricsManager().getAbsoluteMetrics()
+      const viewMetrics = this.workspace.getMetricsManager().getViewMetrics()
       if (
         this.workspace.RTL
-          ? event.clientX >
-            this.workspace.getParentSvg().getBoundingClientRect().left +
-              viewMetrics.width
+          ? event.clientX > this.workspace.getParentSvg().getBoundingClientRect().left + viewMetrics.width
           : event.clientX < absoluteMetrics.left
       ) {
-        this.originatedFromFlyout = true;
+        this.originatedFromFlyout = true
       }
     }
   }
 
   /**
    * Handles motion during an ongoing drag operation.
-   *
    * @param event The event that triggered this call.
    * @param totalDelta The change in pointer position since the last invocation.
    */
   onDrag(event: PointerEvent, totalDelta: Blockly.utils.Coordinate) {
-    super.onDrag(event, totalDelta);
-    this.updateOutOfBoundsState(event);
+    super.onDrag(event, totalDelta)
+    this.updateOutOfBoundsState(event)
   }
 
   /**
    * Records whether or not the current drag is out of the workspace's bounds.
-   *
    * @param event The event that triggered this call.
    */
   updateOutOfBoundsState(event: PointerEvent) {
     if (this.draggable instanceof Blockly.BlockSvg) {
-      const outOfBounds = !this.isInsideWorkspace(event);
+      const outOfBounds = !this.isInsideWorkspace(event)
       if (outOfBounds !== this.draggedOutOfBounds) {
-        const event = new BlockDragOutside(
-          this.getDragRoot(this.draggable) as Blockly.BlockSvg,
-          outOfBounds
-        );
-        Blockly.Events.fire(event);
-        this.draggedOutOfBounds = outOfBounds;
+        const event = new BlockDragOutside(this.getDragRoot(this.draggable) as Blockly.BlockSvg, outOfBounds)
+        Blockly.Events.fire(event)
+        this.draggedOutOfBounds = outOfBounds
       }
     }
   }
 
   /**
    * Handles the end of a drag.
-   *
    * @param event The event that ended the drag.
    */
   onDragEnd(event: PointerEvent) {
+    // When the prototype block is dragged (via its DelegateToParentDraggable
+    // strategy), this.draggable is the prototype, but getDragRoot returns the
+    // definition. Handle both cases for the "procedure is in use" check.
+    const dragRoot = this.getDragRoot(this.draggable)
     if (
-      this.draggable instanceof Blockly.BlockSvg &&
-      this.draggable.type === "procedures_definition" &&
-      this.wouldDeleteDraggable(event, this.draggable.getRootBlock())
+      dragRoot instanceof Blockly.BlockSvg &&
+      dragRoot.type === 'procedures_definition' &&
+      this.wouldDeleteDraggable(event, dragRoot.getRootBlock())
     ) {
-      const prototype = this.draggable
-        .getInput("custom_block")!
-        .connection!.targetBlock();
+      const prototype = dragRoot.getInput('custom_block')!.connection!.targetBlock()
       const hasCaller =
         prototype instanceof Blockly.BlockSvg &&
         isProcedureBlock(prototype) &&
-        getCallers(
-          prototype.getProcCode(),
-          this.draggable.workspace,
-          this.draggable.getRootBlock(),
-          false
-        ).length > 0;
+        getCallers(prototype.getProcCode(), dragRoot.workspace, dragRoot.getRootBlock(), false).length > 0
 
       if (hasCaller) {
-        Blockly.dialog.alert(Blockly.Msg.PROCEDURE_USED);
-        this.draggable.revertDrag();
-        this.draggable.endDrag();
-        return;
+        Blockly.dialog.alert(Blockly.Msg.PROCEDURE_USED)
+        this.draggable.revertDrag()
+        this.draggable.endDrag()
+        return
       }
     }
 
-    super.onDragEnd(event);
+    super.onDragEnd(event)
 
-    this.updateOutOfBoundsState(event);
+    this.updateOutOfBoundsState(event)
     if (this.draggable instanceof Blockly.BlockSvg) {
-      const event = new BlockDragEnd(
-        this.getDragRoot(this.draggable) as Blockly.BlockSvg,
-        this.draggedOutOfBounds
-      );
-      Blockly.Events.fire(event);
+      const event = new BlockDragEnd(this.getDragRoot(this.draggable) as Blockly.BlockSvg, this.draggedOutOfBounds)
+      Blockly.Events.fire(event)
       // If this block was dragged out of the flyout and dropped outside of
       // the workspace (e.g. on a different sprite), the block that was created
       // on the workspace in order to depict the block mid-drag needs to be
       // deleted.
       if (this.originatedFromFlyout && this.draggedOutOfBounds) {
         Blockly.renderManagement.finishQueuedRenders().then(() => {
-          const rootBlock = this.getDragRoot(this.draggable);
+          const rootBlock = this.getDragRoot(this.draggable)
           if (rootBlock instanceof Blockly.BlockSvg) {
-            rootBlock.dispose();
+            rootBlock.dispose()
           }
-        });
+        })
       }
     }
-    this.workspace.removeClass(BOUNDLESS_CLASS);
+    this.workspace.removeClass(BOUNDLESS_CLASS)
   }
 
   /**
    * Returns whether or not the dragged item should return to its starting
    * position.
-   *
    * @param event The drag event that triggered this check.
    * @param rootDraggable The topmost item being dragged.
    * @returns True if the draggable should return to its starting position.
@@ -161,15 +140,12 @@ export class ScratchDragger extends Blockly.dragging.Dragger {
     // If a block is dragged out of the workspace to be e.g. dropped on another
     // sprite, it should remain in the same place on the workspace where it was,
     // rather than being moved to an invisible part of the workspace.
-    return (
-      this.draggedOutOfBounds || super.shouldReturnToStart(event, rootDraggable)
-    );
+    return this.draggedOutOfBounds || super.shouldReturnToStart(event, rootDraggable)
   }
 
   /**
-   * Returns the root element being dragged. For shadow blocks, this is the
-   * parent block.
-   *
+   * Returns the root element being dragged. For shadow blocks and the
+   * procedures_prototype block, this is the parent block.
    * @param draggable The element being dragged directly.
    * @returns The element being dragged, or its parent.
    */
@@ -177,35 +153,27 @@ export class ScratchDragger extends Blockly.dragging.Dragger {
     // We can't just use getRootBlock() here because, when blocks are detached
     // from a stack via dragging, getRootBlock() still returns the root of that
     // stack.
-    if (draggable instanceof Blockly.BlockSvg && draggable.isShadow()) {
-      return draggable.getParent();
+    if (
+      draggable instanceof Blockly.BlockSvg &&
+      (draggable.isShadow() || draggable.type === 'procedures_prototype')
+    ) {
+      return draggable.getParent()
     }
 
-    return draggable;
+    return draggable
   }
 
   /**
    * Returns whether or not the given event occurred within the bounds of the
    * workspace.
-   *
    * @param event The event to check.
    * @returns True if the event occurred inside the workspace.
    */
   isInsideWorkspace(event: PointerEvent) {
-    const bounds = this.workspace.getParentSvg().getBoundingClientRect();
-    const workspaceRect = new Blockly.utils.Rect(
-      bounds.top,
-      bounds.bottom,
-      bounds.left,
-      bounds.right
-    );
-    return workspaceRect.contains(event.clientX, event.clientY);
+    const bounds = this.workspace.getParentSvg().getBoundingClientRect()
+    const workspaceRect = new Blockly.utils.Rect(bounds.top, bounds.bottom, bounds.left, bounds.right)
+    return workspaceRect.contains(event.clientX, event.clientY)
   }
 }
 
-Blockly.registry.register(
-  Blockly.registry.Type.BLOCK_DRAGGER,
-  Blockly.registry.DEFAULT,
-  ScratchDragger,
-  true
-);
+Blockly.registry.register(Blockly.registry.Type.BLOCK_DRAGGER, Blockly.registry.DEFAULT, ScratchDragger, true)

package/src/scratch_insertion_marker_previewer.ts

@@ -1,10 +1,8 @@
 /**
- * @license
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-
-import * as Blockly from "blockly/core";
+import * as Blockly from 'blockly/core'
 
 /**
  * Displays an indicator of where a block being dragged will be connected.
@@ -13,7 +11,6 @@ class ScratchInsertionMarkerPreviewer extends Blockly.InsertionMarkerPreviewer {
   /**
    * Transforms the given block into a JSON representation used to construct an
    * insertion marker.
-   *
    * @param block The block to serialize and use as an insertion marker.
    * @returns A JSON-formatted string corresponding to a serialized
    *     representation of the given block suitable for use as an insertion
@@ -25,15 +22,13 @@ class ScratchInsertionMarkerPreviewer extends Blockly.InsertionMarkerPreviewer {
       addInputBlocks: true,
       addNextBlocks: false,
       doFullSerialization: false,
-    });
+    })
 
     if (!blockJson) {
-      throw new Error(
-        `Failed to serialize source block. ${block.toDevString()}`
-      );
+      throw new Error(`Failed to serialize source block. ${block.toDevString()}`)
     }
 
-    return blockJson;
+    return blockJson
   }
 }
 
@@ -41,5 +36,5 @@ Blockly.registry.register(
   Blockly.registry.Type.CONNECTION_PREVIEWER,
   Blockly.registry.DEFAULT,
   ScratchInsertionMarkerPreviewer,
-  true
-);
+  true,
+)

package/src/scratch_variable_map.ts

@@ -1,10 +1,8 @@
 /**
- * @license
  * Copyright 2024 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-
-import * as Blockly from "blockly/core";
+import * as Blockly from 'blockly/core'
 
 /**
  * Class that provides storage for variables.
@@ -14,15 +12,10 @@ class ScratchVariableMap extends Blockly.VariableMap {
     // Variable names in Blockly are case-insensitive, but case sensitive in
     // Scratch. Override the implementation to only return a variable whose name
     // is identical to the one requested.
-    const variables = this.getVariablesOfType(type ?? "");
-    if (!variables.length) return null;
-    return variables.find((v) => v.getName() === name) ?? null;
+    const variables = this.getVariablesOfType(type ?? '')
+    if (!variables.length) return null
+    return variables.find((v) => v.getName() === name) ?? null
   }
 }
 
-Blockly.registry.register(
-  Blockly.registry.Type.VARIABLE_MAP,
-  Blockly.registry.DEFAULT,
-  ScratchVariableMap,
-  true
-);
+Blockly.registry.register(Blockly.registry.Type.VARIABLE_MAP, Blockly.registry.DEFAULT, ScratchVariableMap, true)

package/src/scratch_variable_model.ts

@@ -1,10 +1,8 @@
 /**
- * @license
  * Copyright 2024 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-
-import * as Blockly from "blockly/core";
+import * as Blockly from 'blockly/core'
 
 /**
  * Class that represents a variable with extra fields for Scratch.
@@ -16,15 +14,10 @@ export class ScratchVariableModel extends Blockly.VariableModel {
     type?: string,
     id?: string,
     public isLocal = false,
-    public isCloud = false
+    public isCloud = false,
   ) {
-    super(workspace, name, type, id);
+    super(workspace, name, type, id)
   }
 }
 
-Blockly.registry.register(
-  Blockly.registry.Type.VARIABLE_MODEL,
-  Blockly.registry.DEFAULT,
-  ScratchVariableModel,
-  true
-);
+Blockly.registry.register(Blockly.registry.Type.VARIABLE_MODEL, Blockly.registry.DEFAULT, ScratchVariableModel, true)