scratch-blocks 2.0.3 → 2.0.4

package/src/recyclable_block_flyout_inflater.ts

@@ -2,8 +2,8 @@
  * Copyright 2024 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import * as Blockly from 'blockly/core'
 import { RecyclableBlockFlyoutInflater as BlocklyRecyclableBlockFlyoutInflater } from '@blockly/continuous-toolbox'
+import * as Blockly from 'blockly/core'
 import { CheckboxBubble } from './checkbox_bubble'
 
 /**

package/src/renderer/path_object.ts

@@ -17,11 +17,15 @@ export class PathObject extends Blockly.zelos.PathObject {
   override applyColour(block: Blockly.BlockSvg) {
     super.applyColour(block)
 
-    // These blocks are special in that, while they are technically shadow
-    // blocks when contained in a procedure definition/prototype, their parent
-    // (the sample procedure caller block embedded in the definition block) is
-    // also a shadow, so they need to use normal block colors in order to
-    // provide contrast with it.
+    // The prototype block is no longer a Blockly shadow, but it should still
+    // visually appear as one (using colourSecondary, the shadow fill colour).
+    if (block.type === 'procedures_prototype') {
+      this.svgPath.setAttribute('fill', this.style.colourSecondary)
+    }
+
+    // Argument reporter blocks sit inside the prototype (which now renders with
+    // the shadow/secondary colour), so they need the full primary colour to
+    // stand out, just as they did when the prototype was a real shadow block.
     if (block.type === 'argument_reporter_string_number' || block.type === 'argument_reporter_boolean') {
       this.svgPath.setAttribute('fill', this.style.colourPrimary)
     }

package/src/renderer/render_info.ts

@@ -36,16 +36,16 @@ export class RenderInfo extends Blockly.zelos.RenderInfo {
       // bowler hat block.
       // Bowler hat blocks always have exactly one statement row and one input
       // element, so these find() calls are guaranteed to succeed.
-      const statementRow = this.rows.find(r => r.hasStatement)!
+      const statementRow = this.rows.find((r) => r.hasStatement)!
       this.width =
         statementRow.widthWithConnectedBlocks -
-        statementRow.elements.find(e => Blockly.blockRendering.Types.isInput(e))!.width +
+        statementRow.elements.find((e) => Blockly.blockRendering.Types.isInput(e))!.width +
         this.constants_.MEDIUM_PADDING
 
       // The bowler hat's width is the same as the block's width, so it can't
       // be derived from the constants like a normal hat and has to be set here.
       // populateTopRow_ always adds a hat element for bowler hat blocks.
-      const hat = this.topRow.elements.find(e => Blockly.blockRendering.Types.isHat(e))!
+      const hat = this.topRow.elements.find((e) => Blockly.blockRendering.Types.isHat(e))!
       hat.width = this.width
       this.topRow.measure()
     }

package/src/scratch_connection_checker.ts

@@ -8,6 +8,21 @@ 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.

package/src/scratch_continuous_category.ts

@@ -2,8 +2,8 @@
  * Copyright 2024 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import * as Blockly from 'blockly/core'
 import { ContinuousCategory } from '@blockly/continuous-toolbox'
+import * as Blockly from 'blockly/core'
 
 type StatusIndicatorCategoryInfo = Blockly.utils.toolbox.CategoryInfo & {
   showStatusButton?: string

package/src/scratch_continuous_toolbox.ts

@@ -2,8 +2,8 @@
  * Copyright 2024 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import * as Blockly from 'blockly/core'
 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'
 

package/src/scratch_dragger.ts

@@ -84,16 +84,20 @@ export class ScratchDragger extends Blockly.dragging.Dragger {
    * @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)
@@ -140,8 +144,8 @@ export class ScratchDragger extends Blockly.dragging.Dragger {
   }
 
   /**
-   * 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.
    */
@@ -149,7 +153,10 @@ 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()) {
+    if (
+      draggable instanceof Blockly.BlockSvg &&
+      (draggable.isShadow() || draggable.type === 'procedures_prototype')
+    ) {
       return draggable.getParent()
     }
 

package/src/scratch_variable_map.ts

@@ -14,7 +14,7 @@ class ScratchVariableMap extends Blockly.VariableMap {
     // is identical to the one requested.
     const variables = this.getVariablesOfType(type ?? '')
     if (!variables.length) return null
-    return variables.find(v => v.getName() === name) ?? null
+    return variables.find((v) => v.getName() === name) ?? null
   }
 }