scratch-blocks 2.0.3 → 2.0.5

package/src/procedures.ts

@@ -32,8 +32,8 @@ import * as Constants from './constants'
 function allProcedureMutations(root: Blockly.WorkspaceSvg): Element[] {
   const blocks = root.getAllBlocks()
   return blocks
-    .filter(b => b.type === Constants.PROCEDURES_PROTOTYPE_BLOCK_TYPE)
-    .map(b => b.mutationToDom!(/* opt_generateShadows */ true))
+    .filter((b) => b.type === Constants.PROCEDURES_PROTOTYPE_BLOCK_TYPE)
+    .map((b) => b.mutationToDom!(/* opt_generateShadows */ true))
 }
 
 /**
@@ -118,7 +118,7 @@ export function getCallers(
   definitionRoot: Blockly.BlockSvg,
   allowRecursive: boolean,
 ): Blockly.BlockSvg[] {
-  return workspace.getTopBlocks().flatMap(block => {
+  return workspace.getTopBlocks().flatMap((block) => {
     if (block.id === definitionRoot.id && !allowRecursive) {
       return []
     }
@@ -126,7 +126,7 @@ export function getCallers(
     return block
       .getDescendants(false)
       .filter(
-        descendant =>
+        (descendant) =>
           isProcedureBlock(descendant) &&
           descendant.type === Constants.PROCEDURES_CALL_BLOCK_TYPE &&
           descendant.getProcCode() === name,
@@ -151,7 +151,7 @@ function mutateCallersAndPrototype(name: string, workspace: Blockly.WorkspaceSvg
   const callers = getCallers(name, defineBlock.workspace, defineBlock, true /* allowRecursive */)
   callers.push(prototypeBlock)
   Blockly.Events.setGroup(true)
-  callers.forEach(caller => {
+  callers.forEach((caller) => {
     const oldMutationDom = caller.mutationToDom!()
     const oldMutation = oldMutationDom && Blockly.Xml.domToText(oldMutationDom)
     caller.domToMutation!(mutation)
@@ -174,7 +174,7 @@ function mutateCallersAndPrototype(name: string, workspace: Blockly.WorkspaceSvg
  */
 function getDefineBlock(procCode: string, workspace: Blockly.WorkspaceSvg): Blockly.BlockSvg | undefined {
   // Assume that a procedure definition is a top block.
-  return workspace.getTopBlocks(false).find(block => {
+  return workspace.getTopBlocks(false).find((block) => {
     if (block.type === Constants.PROCEDURES_DEFINITION_BLOCK_TYPE) {
       const prototypeBlock = block.getInput('custom_block')!.connection!.targetBlock() as Blockly.BlockSvg
       return isProcedureBlock(prototypeBlock) && prototypeBlock.getProcCode() === procCode
@@ -237,9 +237,9 @@ function createProcedureCallbackFactory(workspace: Blockly.WorkspaceSvg): (mutat
       <xml>
         <block type="procedures_definition">
           <statement name="custom_block">
-            <shadow type="procedures_prototype">
+            <block type="procedures_prototype">
               ${Blockly.Xml.domToText(mutation)}
-            </shadow>
+            </block>
           </statement>
         </block>
       </xml>`
@@ -285,7 +285,7 @@ function editProcedureCallback(block: Blockly.BlockSvg) {
       return
     }
     const innerBlock = conn.targetBlock()
-    if (!innerBlock || innerBlock.type !== Constants.PROCEDURES_PROTOTYPE_BLOCK_TYPE) {
+    if (innerBlock?.type !== Constants.PROCEDURES_PROTOTYPE_BLOCK_TYPE) {
       alert('Bad inner block') // TODO: Decide what to do about this.
       return
     }

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,22 @@ 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's next connection is visual-only and should not accept any connections.
+    const isPrototypeNextConn = (c: Blockly.Connection | null) =>
+      c?.type === Blockly.ConnectionType.NEXT_STATEMENT &&
+      c.getSourceBlock().type === 'procedures_prototype'
+    if (isPrototypeNextConn(a) || isPrototypeNextConn(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
   }
 }