scratch-blocks 2.1.13 → 2.1.15

package/dist/types/src/blocks/procedures.d.ts

@@ -30,6 +30,7 @@ type ConnectionMap = Record<string, {
 /**
  * Possible types for procedure arguments.
  */
+type ArgumentDefault = string | number | boolean | null;
 declare enum ArgumentType {
     STRING = "s",
     NUMBER = "n",
@@ -50,7 +51,7 @@ interface ProcedureBlock extends Blockly.BlockSvg {
 }
 export interface ProcedureDeclarationBlock extends ProcedureBlock {
     displayNames_: string[];
-    argumentDefaults_: string[];
+    argumentDefaults_: ArgumentDefault[];
     removeFieldCallback: (field: Blockly.Field) => void;
     createArgumentEditor_: (argumentType: ArgumentType, displayName: string) => Blockly.BlockSvg;
     focusLastEditor_: () => void;

package/dist/types/src/blocks/procedures.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"procedures.d.ts","sourceRoot":"","sources":["../../../../src/blocks/procedures.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH;;GAEG;AACH,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AAIvC;;GAEG;AACH,KAAK,aAAa,GAAG,MAAM,CACzB,MAAM,EACN;IACE,MAAM,EAAE,OAAO,GAAG,SAAS,CAAA;IAC3B,KAAK,EAAE,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAA;CAC/B,GAAG,IAAI,CACT,CAAA;AAED;;GAEG;AACH,aAAK,YAAY;IACf,MAAM,MAAM;IACZ,MAAM,MAAM;IACZ,OAAO,MAAM;CACd;AA8vCD,UAAU,cAAe,SAAQ,OAAO,CAAC,QAAQ;IAC/C,SAAS,EAAE,MAAM,CAAA;IACjB,YAAY,EAAE,MAAM,EAAE,CAAA;IACtB,KAAK,EAAE,OAAO,CAAA;IACd,WAAW,EAAE,MAAM,MAAM,CAAA;IACzB,gBAAgB,EAAE,MAAM,IAAI,CAAA;IAC5B,oBAAoB,EAAE,MAAM,aAAa,CAAA;IACzC,sBAAsB,EAAE,CAAC,aAAa,EAAE,aAAa,KAAK,IAAI,CAAA;IAC9D,gBAAgB,EAAE,CAAC,aAAa,EAAE,aAAa,KAAK,IAAI,CAAA;IACxD,cAAc,EAAE,MAAM,IAAI,CAAA;IAC1B,iBAAiB,EAAE,CACjB,IAAI,EAAE,YAAY,EAClB,KAAK,EAAE,MAAM,EACb,aAAa,EAAE,aAAa,EAC5B,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,OAAO,CAAC,KAAK,KACjB,IAAI,CAAA;IACT,kBAAkB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;CAC3C;AAED,MAAM,WAAW,yBAA0B,SAAQ,cAAc;IAC/D,aAAa,EAAE,MAAM,EAAE,CAAA;IACvB,iBAAiB,EAAE,MAAM,EAAE,CAAA;IAC3B,mBAAmB,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,KAAK,KAAK,IAAI,CAAA;IACnD,qBAAqB,EAAE,CAAC,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC,QAAQ,CAAA;IAC5F,gBAAgB,EAAE,MAAM,IAAI,CAAA;IAC5B,OAAO,EAAE,MAAM,OAAO,CAAA;IACtB,OAAO,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAA;IAChC,gBAAgB,EAAE,MAAM,IAAI,CAAA;IAC5B,kBAAkB,EAAE,MAAM,IAAI,CAAA;IAC9B,uBAAuB,EAAE,MAAM,IAAI,CAAA;IACnC,UAAU,EAAE,MAAM,IAAI,CAAA;CACvB"}
+{"version":3,"file":"procedures.d.ts","sourceRoot":"","sources":["../../../../src/blocks/procedures.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH;;GAEG;AACH,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AAIvC;;GAEG;AACH,KAAK,aAAa,GAAG,MAAM,CACzB,MAAM,EACN;IACE,MAAM,EAAE,OAAO,GAAG,SAAS,CAAA;IAC3B,KAAK,EAAE,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAA;CAC/B,GAAG,IAAI,CACT,CAAA;AAED;;GAEG;AACH,KAAK,eAAe,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAA;AAEvD,aAAK,YAAY;IACf,MAAM,MAAM;IACZ,MAAM,MAAM;IACZ,OAAO,MAAM;CACd;AAgwCD,UAAU,cAAe,SAAQ,OAAO,CAAC,QAAQ;IAC/C,SAAS,EAAE,MAAM,CAAA;IACjB,YAAY,EAAE,MAAM,EAAE,CAAA;IACtB,KAAK,EAAE,OAAO,CAAA;IACd,WAAW,EAAE,MAAM,MAAM,CAAA;IACzB,gBAAgB,EAAE,MAAM,IAAI,CAAA;IAC5B,oBAAoB,EAAE,MAAM,aAAa,CAAA;IACzC,sBAAsB,EAAE,CAAC,aAAa,EAAE,aAAa,KAAK,IAAI,CAAA;IAC9D,gBAAgB,EAAE,CAAC,aAAa,EAAE,aAAa,KAAK,IAAI,CAAA;IACxD,cAAc,EAAE,MAAM,IAAI,CAAA;IAC1B,iBAAiB,EAAE,CACjB,IAAI,EAAE,YAAY,EAClB,KAAK,EAAE,MAAM,EACb,aAAa,EAAE,aAAa,EAC5B,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,OAAO,CAAC,KAAK,KACjB,IAAI,CAAA;IACT,kBAAkB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;CAC3C;AAED,MAAM,WAAW,yBAA0B,SAAQ,cAAc;IAC/D,aAAa,EAAE,MAAM,EAAE,CAAA;IACvB,iBAAiB,EAAE,eAAe,EAAE,CAAA;IACpC,mBAAmB,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,KAAK,KAAK,IAAI,CAAA;IACnD,qBAAqB,EAAE,CAAC,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC,QAAQ,CAAA;IAC5F,gBAAgB,EAAE,MAAM,IAAI,CAAA;IAC5B,OAAO,EAAE,MAAM,OAAO,CAAA;IACtB,OAAO,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAA;IAChC,gBAAgB,EAAE,MAAM,IAAI,CAAA;IAC5B,kBAAkB,EAAE,MAAM,IAAI,CAAA;IAC9B,uBAAuB,EAAE,MAAM,IAAI,CAAA;IACnC,UAAU,EAAE,MAAM,IAAI,CAAA;CACvB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scratch-blocks",
-  "version": "2.1.13",
+  "version": "2.1.15",
   "description": "Scratch Blocks is a library for building creative computing interfaces.",
   "author": "Massachusetts Institute of Technology",
   "license": "Apache-2.0",
@@ -41,17 +41,17 @@
     "@vitest/browser": "4.1.4",
     "@vitest/browser-playwright": "4.1.4",
     "eslint": "9.39.4",
-    "eslint-config-scratch": "14.1.7",
+    "eslint-config-scratch": "14.1.11",
     "husky": "9.1.7",
     "playwright": "1.59.1",
-    "prettier": "3.8.2",
+    "prettier": "3.8.3",
     "scratch-semantic-release-config": "4.0.1",
     "semantic-release": "25.0.3",
     "source-map-loader": "5.0.0",
     "ts-loader": "9.5.7",
     "typescript": "5.9.3",
     "vitest": "4.1.4",
-    "webpack": "5.106.1",
+    "webpack": "5.106.2",
     "webpack-cli": "6.0.1",
     "webpack-dev-server": "5.2.3"
   },

package/src/blocks/procedures.ts

@@ -37,6 +37,8 @@ type ConnectionMap = Record<
 /**
  * Possible types for procedure arguments.
  */
+type ArgumentDefault = string | number | boolean | null
+
 enum ArgumentType {
   STRING = 's',
   NUMBER = 'n',
@@ -75,39 +77,17 @@ function getRequiredMutationAttribute(xmlElement: Element, name: string): string
   return value
 }
 
-/**
- * Parse a required mutation attribute as JSON, then validate its type.
- * @param xmlElement The mutation element that should contain required attributes.
- * @param name The specific mutation attribute to retrieve and parse.
- * @param parse Validates and narrows the parsed JSON value.
- * @returns Parsed and validated mutation attribute value.
- */
-function parseRequiredMutationJson<T>(
-  xmlElement: Element,
-  name: string,
-  parse: (value: unknown, name: string) => T,
-): T {
-  const rawValue = getRequiredMutationAttribute(xmlElement, name)
-  let parsedValue: unknown
-  try {
-    parsedValue = JSON.parse(rawValue)
-  } catch {
-    throw new Error(`Invalid JSON in mutation attribute: ${name}`)
-  }
-  return parse(parsedValue, name)
-}
-
 /**
  * Parse an optional mutation attribute as JSON, returning a fallback when the
- * attribute is absent. Use this only for attributes that can be safely
- * defaulted in isolation, without invalidating structural invariants that
- * relate them to other attributes on the same mutation. A present-but-malformed
- * attribute still throws, since that indicates corruption rather than an older
- * schema.
+ * attribute is absent or malformed. Older saved projects may omit attributes
+ * that current serialization always writes, and some projects in the wild
+ * contain attributes whose values are not valid for the expected type.
+ * Returning the fallback in both cases lets the project load rather than
+ * aborting the entire workspace parse.
  * @param xmlElement The mutation element that may contain the attribute.
  * @param name The specific mutation attribute to retrieve and parse.
  * @param parse Validates and narrows the parsed JSON value.
- * @param fallback Value to return when the attribute is absent.
+ * @param fallback Value to return when the attribute is absent or malformed.
  * @returns Parsed and validated mutation attribute value, or `fallback`.
  */
 function parseOptionalMutationJson<T>(
@@ -120,13 +100,12 @@ function parseOptionalMutationJson<T>(
   if (rawValue === null) {
     return fallback
   }
-  let parsedValue: unknown
   try {
-    parsedValue = JSON.parse(rawValue)
+    return parse(JSON.parse(rawValue), name)
   } catch {
-    throw new Error(`Invalid JSON in mutation attribute: ${name}`)
+    console.warn(`Invalid or unexpected mutation attribute "${name}", using default. Raw value: ${rawValue}`)
+    return fallback
   }
-  return parse(parsedValue, name)
 }
 
 /**
@@ -155,6 +134,26 @@ function parseStringArrayMutationValue(value: unknown, name: string): string[] {
   return value
 }
 
+/**
+ * Validate a parsed mutation value as an array of primitives. Argument
+ * defaults from older projects (especially Scratch 2.0 conversions) contain
+ * mixed types — strings for text arguments, numbers for numeric arguments,
+ * and booleans for boolean arguments (e.g. `["",1,1,1,1]`). The old fork
+ * stored these via untyped `JSON.parse` with no validation, and the VM
+ * passes them through as-is.
+ * @param value Parsed mutation value.
+ * @param name Attribute name used in error messages.
+ * @returns Validated array value.
+ */
+function parsePrimitiveArrayMutationValue(value: unknown, name: string): ArgumentDefault[] {
+  const isArgumentDefault = (entry: unknown): entry is ArgumentDefault =>
+    entry === null || typeof entry === 'string' || typeof entry === 'number' || typeof entry === 'boolean'
+  if (!Array.isArray(value) || !value.every(isArgumentDefault)) {
+    throw new Error(`Expected ArgumentDefault[] JSON value in mutation attribute: ${name}`)
+  }
+  return value
+}
+
 /**
  * A drag strategy for the procedures_prototype block that delegates all drag
  * operations to its parent (the procedures_definition block). This lets the
@@ -308,7 +307,7 @@ function callerDomToMutation(this: ProcedureCallBlock, xmlElement: Element) {
   this.procCode_ = getRequiredMutationAttribute(xmlElement, 'proccode')
   const generateshadows = xmlElement.getAttribute('generateshadows')
   this.generateShadows_ = generateshadows !== null ? JSON.parse(generateshadows) === true : false
-  this.argumentIds_ = parseRequiredMutationJson(xmlElement, 'argumentids', parseStringArrayMutationValue)
+  this.argumentIds_ = parseOptionalMutationJson(xmlElement, 'argumentids', parseStringArrayMutationValue, [])
   this.warp_ = parseOptionalMutationJson(xmlElement, 'warp', parseBooleanMutationValue, false)
   this.updateDisplay_()
 }
@@ -349,9 +348,14 @@ function definitionDomToMutation(this: ProcedurePrototypeBlock | ProcedureDeclar
   const prevArgIds = this.argumentIds_
   const prevDisplayNames = this.displayNames_
 
-  this.argumentIds_ = parseRequiredMutationJson(xmlElement, 'argumentids', parseStringArrayMutationValue)
-  this.displayNames_ = parseRequiredMutationJson(xmlElement, 'argumentnames', parseStringArrayMutationValue)
-  this.argumentDefaults_ = parseRequiredMutationJson(xmlElement, 'argumentdefaults', parseStringArrayMutationValue)
+  this.argumentIds_ = parseOptionalMutationJson(xmlElement, 'argumentids', parseStringArrayMutationValue, [])
+  this.displayNames_ = parseOptionalMutationJson(xmlElement, 'argumentnames', parseStringArrayMutationValue, [])
+  this.argumentDefaults_ = parseOptionalMutationJson(
+    xmlElement,
+    'argumentdefaults',
+    parsePrimitiveArrayMutationValue,
+    [],
+  )
 
   // During full XML deserialization (Blockly.Xml.domToWorkspace), the mutation element
   // is part of the parsed XML tree and its parent element also contains <value> children
@@ -1341,7 +1345,7 @@ interface ProcedureBlock extends Blockly.BlockSvg {
 
 export interface ProcedureDeclarationBlock extends ProcedureBlock {
   displayNames_: string[]
-  argumentDefaults_: string[]
+  argumentDefaults_: ArgumentDefault[]
   removeFieldCallback: (field: Blockly.Field) => void
   createArgumentEditor_: (argumentType: ArgumentType, displayName: string) => Blockly.BlockSvg
   focusLastEditor_: () => void
@@ -1361,7 +1365,7 @@ interface ProcedureCallBlock extends ProcedureBlock {
 
 interface ProcedurePrototypeBlock extends ProcedureBlock {
   displayNames_: string[]
-  argumentDefaults_: string[]
+  argumentDefaults_: ArgumentDefault[]
   skipArgumentReporters_: boolean
   createArgumentReporter_: (argumentType: ArgumentType, displayName: string) => Blockly.BlockSvg
   updateArgumentReporterNames_: (prevArgIds: string[], prevDisplayNames: string[]) => void

package/src/scratch_c_block_wrap.ts

@@ -81,9 +81,10 @@ Reflect.set(
     // Restore a real block from a statement input to nextConnection so that
     // unplug(true) can heal the stack correctly.  Conditions:
     //   - marker is mid-stack (has a predecessor)
-    //   - marker.nextConnection is empty (displaced block is NOT already there)
+    //   - marker.nextConnection is either empty or absent (cap blocks do not
+    //     have a bottom connector, so the displaced block is NOT already there)
     //   - a non-marker block is sitting in a statement input
-    if (markerPreviousConnection?.isConnected() && markerNextConnection && !markerNextConnection.isConnected()) {
+    if (markerPreviousConnection?.isConnected() && !markerNextConnection?.isConnected()) {
       for (const input of marker.inputList) {
         const conn = input.connection
         const connType = conn?.type as Blockly.ConnectionType | undefined
@@ -97,7 +98,19 @@ Reflect.set(
             continue
           }
           prev.disconnect()
-          markerNextConnection.connect(prev)
+          if (markerNextConnection) {
+            markerNextConnection.connect(prev)
+          } else {
+            // Blocks without a bottom connector (e.g. forever) have no nextConnection. Reconnect
+            // the displaced block directly to the connection the marker's
+            // previousConnection is plugged into, then detach the marker
+            // so unplug() has nothing left to heal.
+            const aboveConn = markerPreviousConnection.targetConnection
+            if (aboveConn) {
+              markerPreviousConnection.disconnect()
+              aboveConn.connect(prev)
+            }
+          }
           break
         }
       }

package/src/scratch_connection_checker.ts

@@ -44,6 +44,32 @@ class ScratchConnectionChecker extends Blockly.ConnectionChecker {
       return false
     }
 
+    // Blockly's base doDragChecks rejects inserting a block with no
+    // nextConnection into the middle of a stack (NEXT_STATEMENT case) because
+    // it assumes the displaced blocks have nowhere to go. Our
+    // getConnectionForOrphanedConnection patch routes displaced blocks into
+    // statement inputs, so we allow the connection when a suitable statement
+    // input exists on the dragging block.
+    if (
+      (b.type as Blockly.ConnectionType) === Blockly.ConnectionType.NEXT_STATEMENT &&
+      b.isConnected() &&
+      !(a.getSourceBlock() as Blockly.Block).nextConnection
+    ) {
+      const orphan = b.targetBlock()
+      const orphanPrev = (orphan as Blockly.Block | null)?.previousConnection
+      if (orphan && !orphan.isShadow() && orphanPrev) {
+        const canWrap = !!Blockly.Connection.getConnectionForOrphanedConnection(a.getSourceBlock(), orphanPrev)
+        if (canWrap) {
+          // Skip the base class NEXT_STATEMENT check (which would reject
+          // this) but still apply the other generic guards it uses.
+          if ('distanceFrom' in a && a.distanceFrom(b) > distance) return false
+          if (b.getSourceBlock().isInsertionMarker()) return false
+          if (Blockly.common.draggingConnections.includes(b)) return false
+          return true
+        }
+      }
+    }
+
     return super.doDragChecks(a, b, distance)
   }
 }