scratch-blocks 2.1.14 → 2.1.16

package/dist/types/src/checkable_continuous_flyout.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"checkable_continuous_flyout.d.ts","sourceRoot":"","sources":["../../../src/checkable_continuous_flyout.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,gBAAgB,EAAE,KAAK,eAAe,EAAE,MAAM,6BAA6B,CAAA;AACpF,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AAiBvC,qBAAa,yBAA0B,SAAQ,gBAAgB;IAC7D,UAAkB,SAAS,EAAE,MAAM,CAAA;IAC3B,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;IAErB;;;OAGG;gBACS,gBAAgB,EAAE,OAAO,CAAC,OAAO;IAQ7C;;;;OAIG;IACH,SAAS,CAAC,cAAc,CAAC,KAAK,EAAE,OAAO,CAAC,QAAQ;IAUhD;;;;OAIG;IACH,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO;IAahD,cAAc;IAId,QAAQ;IAIR,SAAS,CAAC,eAAe;IAwBzB;;;;OAIG;IACH,SAAS,CAAC,kBAAkB,CAAC,IAAI,EAAE,OAAO,CAAC,UAAU,GAAG,IAAI,IAAI,eAAe;IAO/E;;OAEG;IACH,oBAAoB;IASpB,QAAQ,CAAC,QAAQ,EAAE,MAAM;CAG1B"}
+{"version":3,"file":"checkable_continuous_flyout.d.ts","sourceRoot":"","sources":["../../../src/checkable_continuous_flyout.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,gBAAgB,EAAE,KAAK,eAAe,EAAE,MAAM,6BAA6B,CAAA;AACpF,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AAsCvC,qBAAa,yBAA0B,SAAQ,gBAAgB;IAC7D,UAAkB,SAAS,EAAE,MAAM,CAAA;IAC3B,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;IAErB;;;OAGG;gBACS,gBAAgB,EAAE,OAAO,CAAC,OAAO;IAQ7C;;;;OAIG;IACH,SAAS,CAAC,cAAc,CAAC,KAAK,EAAE,OAAO,CAAC,QAAQ;IAWhD;;;;OAIG;IACH,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO;IAahD,cAAc;IAId,QAAQ;IAIR,SAAS,CAAC,eAAe;IAwBzB;;;;OAIG;IACH,SAAS,CAAC,kBAAkB,CAAC,IAAI,EAAE,OAAO,CAAC,UAAU,GAAG,IAAI,IAAI,eAAe;IAO/E;;OAEG;IACH,oBAAoB;IASpB,QAAQ,CAAC,QAAQ,EAAE,MAAM;CAG1B"}

package/dist/types/src/xml.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"xml.d.ts","sourceRoot":"","sources":["../../../src/xml.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AAGvC;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAAC,GAAG,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO,CAAC,YAAY,GAAG,MAAM,EAAE,CAkDpG"}
+{"version":3,"file":"xml.d.ts","sourceRoot":"","sources":["../../../src/xml.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AAwEvC;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAAC,GAAG,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO,CAAC,YAAY,GAAG,MAAM,EAAE,CAkDpG"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scratch-blocks",
-  "version": "2.1.14",
+  "version": "2.1.16",
   "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.8",
+    "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/checkable_continuous_flyout.ts

@@ -20,6 +20,27 @@ function isCheckboxIcon(icon: Blockly.IIcon | undefined): icon is Blockly.IIcon
   return !!icon && typeof (icon as { setChecked?: unknown }).setChecked === 'function'
 }
 
+/**
+ * Recursively strip `id` properties from a serialized block state tree
+ * so that every block (including shadows and nested inputs) gets a fresh
+ * ID when deserialized onto the workspace.
+ * @param state A serialized block state object.
+ */
+function stripIds(state: Blockly.serialization.blocks.State): void {
+  delete state.id
+  if (state.inputs) {
+    for (const inputName in state.inputs) {
+      const conn = state.inputs[inputName]
+      if (conn.shadow) stripIds(conn.shadow)
+      if (conn.block) stripIds(conn.block)
+    }
+  }
+  if (state.next) {
+    if (state.next.shadow) stripIds(state.next.shadow)
+    if (state.next.block) stripIds(state.next.block)
+  }
+}
+
 export class CheckableContinuousFlyout extends ContinuousFlyout {
   declare protected tabWidth_: number
   declare MARGIN: number
@@ -44,11 +65,12 @@ export class CheckableContinuousFlyout extends ContinuousFlyout {
    */
   protected serializeBlock(block: Blockly.BlockSvg) {
     const json = super.serializeBlock(block)
-    // Delete the serialized block's ID so that a new one is generated when it is
-    // placed on the workspace. Otherwise, the block on the workspace may be
-    // indistinguishable from the one in the flyout, which can cause reporter blocks
-    // to have their value dropdown shown in the wrong place.
-    delete json.id
+    // Strip all IDs so every block in the tree (including shadows) gets a
+    // fresh ID when placed on the workspace. Without this, disposed shadows
+    // from a previous copy can reuse the flyout's IDs, causing two workspace
+    // blocks to share the same shadow in the VM. Deleting one then destroys
+    // the other's shadow (bug 878291).
+    stripIds(json)
     return json
   }
 

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)
   }
 }

package/src/xml.ts

@@ -5,6 +5,75 @@
 import * as Blockly from 'blockly/core'
 import { ScratchVariableModel } from './scratch_variable_model'
 
+// Blockly's blockToDom has a bug where the `empty` flag for an input's
+// container element is only set to false when a non-shadow target block
+// exists. If a connection has shadow DOM but no target block (which can
+// happen transiently during connect/disconnect operations or if shadow
+// respawn fails), the shadow clone IS appended to the <value> container
+// but the container is never appended to the output because `empty`
+// stays true. This causes the input to silently disappear from the XML,
+// which corrupts the VM's block representation on the next save/load.
+//
+// We fix this by wrapping blockToDom: after the original runs, we check
+// each value/statement input. If the connection has shadow state but the
+// output XML is missing the corresponding <value>/<statement> element,
+// we serialize the shadow ourselves and inject it.
+const originalBlockToDom = Blockly.Xml.blockToDom.bind(Blockly.Xml)
+
+Blockly.Xml.blockToDom = function blockToDomFixed(
+  block: Blockly.Block,
+  opt_noId?: boolean,
+): Element | DocumentFragment {
+  const result = originalBlockToDom(block, opt_noId)
+  if (!(result instanceof Element)) return result
+
+  for (const input of block.inputList) {
+    if (!input.connection) continue
+
+    const name = input.name
+    // Check if this input already appears in the serialized XML.
+    // Use localName for case-insensitive comparison across DOM implementations.
+    const alreadySerialized = Array.from(result.children).some((child) => {
+      const tag = child.localName
+      return (tag === 'value' || tag === 'statement') && child.getAttribute('name') === name
+    })
+    if (alreadySerialized) continue
+
+    // The input is missing from the XML. Check if there's shadow state
+    // that should have been included.
+    if (!input.connection.getShadowState()) continue
+
+    // If shadow DOM is still available on the connection, clone that DOM
+    // into a new container and append it to the serialized output.
+    const existingShadowDom = input.connection.getShadowDom()
+    if (existingShadowDom) {
+      const tagName = input.type === Blockly.inputs.inputTypes.VALUE ? 'value' : 'statement'
+      const doc = result.ownerDocument
+      const container = doc.createElementNS(result.namespaceURI, tagName)
+      container.setAttribute('name', name)
+      const importedShadow = doc.importNode(existingShadowDom, true)
+      if (opt_noId) {
+        importedShadow.removeAttribute('id')
+        for (const el of importedShadow.querySelectorAll('[id]')) {
+          el.removeAttribute('id')
+        }
+      }
+      container.appendChild(importedShadow)
+      result.appendChild(container)
+      console.warn(
+        `[scratch-blocks] blockToDom fix: recovered missing input "${name}" on ${block.type} (${block.id})`,
+      )
+    } else {
+      console.warn(
+        `[scratch-blocks] blockToDom fix: input "${name}" on ${block.type} (${block.id}) has shadow state` +
+          ` but no shadow DOM — cannot recover`,
+      )
+    }
+  }
+
+  return result
+}
+
 /**
  * Clears the workspace and loads the given serialized state.
  * @param xml XML representation of a Blockly workspace.