scratch-blocks 2.1.14 → 2.1.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scratch-blocks",
-  "version": "2.1.14",
+  "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.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/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)
   }
 }