scratch-blocks 2.1.4 → 2.1.6

package/src/blocks/procedures.ts

@@ -29,8 +29,8 @@ import type { ScratchDragger } from '../scratch_dragger'
 type ConnectionMap = Record<
   string,
   {
-    shadow: Element
-    block: Blockly.BlockSvg
+    shadow: Element | undefined
+    block: Blockly.BlockSvg | null
   } | null
 >
 
@@ -43,6 +43,86 @@ enum ArgumentType {
   BOOLEAN = 'b',
 }
 
+/**
+ * Parse a serialized procedure argument type token.
+ * @param value Serialized token from procCode.
+ * @returns The matching argument type.
+ */
+function parseArgumentType(value: string): ArgumentType {
+  switch (value) {
+    case 'n':
+      return ArgumentType.NUMBER
+    case 'b':
+      return ArgumentType.BOOLEAN
+    case 's':
+      return ArgumentType.STRING
+    default:
+      throw new Error(`Found a custom procedure with an invalid type: ${value}`)
+  }
+}
+
+/**
+ * Read a required mutation attribute or throw if missing.
+ * @param xmlElement The mutation element that should contain required attributes.
+ * @param name The specific mutation attribute to retrieve.
+ * @returns Attribute value.
+ */
+function getRequiredMutationAttribute(xmlElement: Element, name: string): string {
+  const value = xmlElement.getAttribute(name)
+  if (value === null) {
+    throw new Error(`Missing required mutation attribute: ${name}`)
+  }
+  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)
+}
+
+/**
+ * Validate a parsed mutation value as a boolean.
+ * @param value Parsed mutation value.
+ * @param name Attribute name used in error messages.
+ * @returns Validated boolean value.
+ */
+function parseBooleanMutationValue(value: unknown, name: string): boolean {
+  if (typeof value !== 'boolean') {
+    throw new Error(`Expected boolean JSON value in mutation attribute: ${name}`)
+  }
+  return value
+}
+
+/**
+ * Validate a parsed mutation value as a string array.
+ * @param value Parsed mutation value.
+ * @param name Attribute name used in error messages.
+ * @returns Validated string array value.
+ */
+function parseStringArrayMutationValue(value: unknown, name: string): string[] {
+  if (!Array.isArray(value) || !value.every((entry) => typeof entry === 'string')) {
+    throw new Error(`Expected string[] 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
@@ -193,10 +273,10 @@ function callerMutationToDom(this: ProcedureCallBlock): Element {
  * @param xmlElement XML storage element.
  */
 function callerDomToMutation(this: ProcedureCallBlock, xmlElement: Element) {
-  this.procCode_ = xmlElement.getAttribute('proccode')!
-  this.generateShadows_ = JSON.parse(xmlElement.getAttribute('generateshadows')!)
-  this.argumentIds_ = JSON.parse(xmlElement.getAttribute('argumentids')!)
-  this.warp_ = JSON.parse(xmlElement.getAttribute('warp')!)
+  this.procCode_ = getRequiredMutationAttribute(xmlElement, 'proccode')
+  this.generateShadows_ = parseRequiredMutationJson(xmlElement, 'generateshadows', parseBooleanMutationValue)
+  this.argumentIds_ = parseRequiredMutationJson(xmlElement, 'argumentids', parseStringArrayMutationValue)
+  this.warp_ = parseRequiredMutationJson(xmlElement, 'warp', parseBooleanMutationValue)
   this.updateDisplay_()
 }
 
@@ -230,15 +310,15 @@ function definitionMutationToDom(
  * @param xmlElement XML storage element.
  */
 function definitionDomToMutation(this: ProcedurePrototypeBlock | ProcedureDeclarationBlock, xmlElement: Element) {
-  this.procCode_ = xmlElement.getAttribute('proccode')!
-  this.warp_ = JSON.parse(xmlElement.getAttribute('warp')!)
+  this.procCode_ = getRequiredMutationAttribute(xmlElement, 'proccode')
+  this.warp_ = parseRequiredMutationJson(xmlElement, 'warp', parseBooleanMutationValue)
 
   const prevArgIds = this.argumentIds_
   const prevDisplayNames = this.displayNames_
 
-  this.argumentIds_ = JSON.parse(xmlElement.getAttribute('argumentids')!)
-  this.displayNames_ = JSON.parse(xmlElement.getAttribute('argumentnames')!)
-  this.argumentDefaults_ = JSON.parse(xmlElement.getAttribute('argumentdefaults')!)
+  this.argumentIds_ = parseRequiredMutationJson(xmlElement, 'argumentids', parseStringArrayMutationValue)
+  this.displayNames_ = parseRequiredMutationJson(xmlElement, 'argumentnames', parseStringArrayMutationValue)
+  this.argumentDefaults_ = parseRequiredMutationJson(xmlElement, 'argumentdefaults', parseStringArrayMutationValue)
 
   // 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
@@ -308,13 +388,11 @@ function disconnectOldBlocks_(this: ProcedureBlock): ConnectionMap {
   const connectionMap: ConnectionMap = {}
   for (const input of this.inputList) {
     if (input.connection) {
-      const target = input.connection.targetBlock() as Blockly.BlockSvg
-      const saveInfo = {
-        shadow: input.connection.getShadowDom(true)!,
-        block: target,
+      const target = input.connection.targetBlock()
+      connectionMap[input.name] = {
+        shadow: input.connection.getShadowDom(true) ?? undefined,
+        block: target as Blockly.BlockSvg | null,
       }
-      connectionMap[input.name] = saveInfo
-
       if (target) {
         input.connection.disconnect()
       }
@@ -349,16 +427,7 @@ function createAllInputs_(this: ProcedureBlock, connectionMap: ConnectionMap) {
   for (const component of procComponents) {
     let labelText
     if (component.startsWith('%')) {
-      const argumentType = component.substring(1, 2)
-      if (
-        !(
-          argumentType === ArgumentType.NUMBER ||
-          argumentType === ArgumentType.BOOLEAN ||
-          argumentType === ArgumentType.STRING
-        )
-      ) {
-        throw new Error('Found an custom procedure with an invalid type: ' + argumentType)
-      }
+      const argumentType = parseArgumentType(component.substring(1, 2))
       labelText = component.substring(2).trim()
 
       const id = this.argumentIds_[argumentCount]
@@ -386,19 +455,20 @@ function createAllInputs_(this: ProcedureBlock, connectionMap: ConnectionMap) {
  *     connected to those IDs at the beginning of the mutation.
  */
 function disposeObsoleteBlocks_(this: ProcedureBlock, connectionMap: ConnectionMap) {
-  for (const id in connectionMap) {
-    const saveInfo = connectionMap[id]
-    if (saveInfo) {
-      const block = saveInfo.block
-      const isOrphanedArgumentReporter =
-        this.type === 'procedures_prototype' &&
-        (block.type === 'argument_reporter_string_number' || block.type === 'argument_reporter_boolean')
-      if (block.isShadow() || isOrphanedArgumentReporter) {
-        block.dispose()
-        connectionMap[id] = null
-        // At this point we know which shadow DOMs are about to be orphaned in
-        // the VM.  What do we do with that information?
-      }
+  for (const [id, saveInfo] of Object.entries(connectionMap)) {
+    const block = saveInfo?.block
+    if (!block) {
+      continue
+    }
+
+    const isOrphanedArgumentReporter =
+      this.type === 'procedures_prototype' &&
+      (block.type === 'argument_reporter_string_number' || block.type === 'argument_reporter_boolean')
+    if (block.isShadow() || isOrphanedArgumentReporter) {
+      block.dispose()
+      connectionMap[id] = null
+      // At this point we know which shadow DOMs are about to be orphaned in
+      // the VM.  What do we do with that information?
     }
   }
 }
@@ -458,6 +528,9 @@ function buildShadowDom_(type: ArgumentType): Element {
  */
 function attachShadow_(this: ProcedureCallBlock, input: Blockly.Input, argumentType: ArgumentType) {
   if (argumentType === ArgumentType.NUMBER || argumentType === ArgumentType.STRING) {
+    if (!input.connection) {
+      throw new Error(`Expected input connection for argument ${String(argumentType)}`)
+    }
     const blockType = argumentType === ArgumentType.NUMBER ? 'math_number' : 'text'
     Blockly.Events.disable()
     let newBlock
@@ -479,7 +552,7 @@ function attachShadow_(this: ProcedureCallBlock, input: Blockly.Input, argumentT
     if (Blockly.Events.isEnabled()) {
       Blockly.Events.fire(new (Blockly.Events.get(Blockly.Events.BLOCK_CREATE))(newBlock))
     }
-    newBlock.outputConnection.connect(input.connection!)
+    newBlock.outputConnection.connect(input.connection)
   }
 }
 
@@ -516,7 +589,7 @@ function createArgumentReporter_(
     Blockly.Events.enable()
   }
   if (Blockly.Events.isEnabled()) {
-    Blockly.Events.fire(new (Blockly.Events.get(Blockly.Events.BLOCK_CREATE))(newBlock))
+    void Blockly.Events.fire(new (Blockly.Events.get(Blockly.Events.BLOCK_CREATE))(newBlock))
   }
   return newBlock
 }
@@ -538,21 +611,25 @@ function populateArgumentOnCaller_(
   id: string,
   input: Blockly.Input,
 ) {
-  let oldBlock: Blockly.BlockSvg | undefined
+  let oldBlock: Blockly.BlockSvg | null | undefined
   let oldShadow: Element | undefined
-  if (connectionMap && id in connectionMap) {
+  if (id in connectionMap) {
     const saveInfo = connectionMap[id]
     oldBlock = saveInfo?.block
     oldShadow = saveInfo?.shadow
   }
 
-  if (connectionMap && oldBlock) {
+  const conn = input.connection
+  if (!conn) {
+    throw new Error(`Expected caller input connection for argument id ${id}`)
+  }
+  if (oldBlock) {
     // Reattach the old block and shadow DOM.
     connectionMap[input.name] = null
-    oldBlock.outputConnection.connect(input.connection!)
+    oldBlock.outputConnection.connect(conn)
     if (type !== ArgumentType.BOOLEAN && this.generateShadows_) {
-      const shadowDom = oldShadow || this.buildShadowDom_(type)
-      input.connection!.setShadowDom(shadowDom)
+      const shadowDom = oldShadow ?? this.buildShadowDom_(type)
+      conn.setShadowDom(shadowDom)
     }
   } else if (this.generateShadows_) {
     this.attachShadow_(input, type)
@@ -584,7 +661,12 @@ function populateArgumentOnPrototype_(
   }
 
   let oldBlock: Blockly.BlockSvg | null = null
-  if (connectionMap && id in connectionMap) {
+  const conn = input.connection
+  if (!conn) {
+    throw new Error(`Expected prototype input connection for argument id ${id}`)
+  }
+
+  if (id in connectionMap) {
     const saveInfo = connectionMap[id]
     oldBlock = saveInfo?.block ?? null
   }
@@ -594,7 +676,7 @@ function populateArgumentOnPrototype_(
 
   // Decide which block to attach.
   let argumentReporter: Blockly.BlockSvg
-  if (connectionMap && oldBlock && oldTypeMatches) {
+  if (oldBlock && oldTypeMatches) {
     // Update the text if needed. The old argument reporter is the same type,
     // and on the same input, but the argument's display name may have changed.
     argumentReporter = oldBlock
@@ -605,7 +687,7 @@ function populateArgumentOnPrototype_(
   }
 
   // Attach the block.
-  input.connection!.connect(argumentReporter.outputConnection)
+  conn.connect(argumentReporter.outputConnection)
 }
 
 /**
@@ -627,13 +709,17 @@ function populateArgumentOnDeclaration_(
   input: Blockly.Input,
 ) {
   let oldBlock: Blockly.BlockSvg | null = null
-  if (connectionMap && id in connectionMap) {
+  if (id in connectionMap) {
     const saveInfo = connectionMap[id]
     oldBlock = saveInfo?.block ?? null
   }
 
   const oldTypeMatches = checkOldEditorTypeMatches_(oldBlock, type)
   const displayName = this.displayNames_[index]
+  const conn = input.connection
+  if (!conn) {
+    throw new Error(`Expected declaration input connection for argument id ${id}`)
+  }
 
   // Decide which block to attach.
   let argumentEditor: Blockly.BlockSvg
@@ -646,7 +732,7 @@ function populateArgumentOnDeclaration_(
   }
 
   // Attach the block.
-  input.connection!.connect(argumentEditor.outputConnection)
+  conn.connect(argumentEditor.outputConnection)
 }
 
 /**
@@ -721,13 +807,13 @@ function createArgumentEditor_(
     newBlock.setShadow(true)
     if (!this.isInsertionMarker()) {
       newBlock.initSvg()
-      newBlock.queueRender()
+      void newBlock.queueRender()
     }
   } finally {
     Blockly.Events.enable()
   }
   if (Blockly.Events.isEnabled()) {
-    Blockly.Events.fire(new (Blockly.Events.get(Blockly.Events.BLOCK_CREATE))(newBlock))
+    void Blockly.Events.fire(new (Blockly.Events.get(Blockly.Events.BLOCK_CREATE))(newBlock))
   }
   return newBlock
 }
@@ -749,8 +835,11 @@ function updateDeclarationProcCode_(this: ProcedureDeclarationBlock) {
       this.procCode_ += input.fieldRow[0].getValue()
     } else if (input.type === Blockly.inputs.inputTypes.VALUE) {
       // Inspect the argument editor.
-      const target = input.connection!.targetBlock()!
-      this.displayNames_.push(target.getFieldValue('TEXT'))
+      const target = input.connection?.targetBlock()
+      if (!target) {
+        throw new Error(`Expected argument editor block on input ${input.name}`)
+      }
+      this.displayNames_.push(String(target.getFieldValue('TEXT')))
       this.argumentIds_.push(input.name)
       if (target.type === 'argument_editor_boolean') {
         this.procCode_ += '%b'
@@ -758,7 +847,7 @@ function updateDeclarationProcCode_(this: ProcedureDeclarationBlock) {
         this.procCode_ += '%s'
       }
     } else {
-      throw new Error('Unexpected input type on a procedure mutator root: ' + input.type)
+      throw new Error(`Unexpected input type on a procedure mutator root: ${String(input.type)}`)
     }
   }
 }
@@ -773,8 +862,15 @@ function focusLastEditor_(this: ProcedureDeclarationBlock) {
       newInput.fieldRow[0].showEditor()
     } else if (newInput.type === Blockly.inputs.inputTypes.VALUE) {
       // Inspect the argument editor.
-      const target = newInput.connection!.targetBlock()!
-      target.getField('TEXT')!.showEditor()
+      const target = newInput.connection?.targetBlock()
+      if (!target) {
+        throw new Error(`Expected argument editor block on input ${newInput.name}`)
+      }
+      const field = target.getField('TEXT')
+      if (!field) {
+        throw new Error(`Expected TEXT field on argument editor block ${target.id}`)
+      }
+      field.showEditor()
     }
   }
 }
@@ -843,16 +939,15 @@ function removeFieldCallback(this: ProcedureDeclarationBlock, field: Blockly.Fie
     return
   }
   let inputNameToRemove = null
-  for (let n = 0; n < this.inputList.length; n++) {
-    const input = this.inputList[n]
+  for (const input of this.inputList) {
     if (input.connection) {
-      const target = input.connection.targetBlock()!
-      if (field.name && target.getField(field.name) === field) {
+      const target = input.connection.targetBlock()
+      if (target && field.name && target.getField(field.name) === field) {
         inputNameToRemove = input.name
       }
     } else {
-      for (let j = 0; j < input.fieldRow.length; j++) {
-        if (input.fieldRow[j] === field) {
+      for (const inputField of input.fieldRow) {
+        if (inputField === field) {
           inputNameToRemove = input.name
         }
       }
@@ -875,9 +970,7 @@ function removeArgumentCallback_(
   field: Blockly.Field,
 ) {
   const parent = this.getParent()
-  if (parent && parent.removeFieldCallback) {
-    parent.removeFieldCallback(field)
-  }
+  ;(parent as ProcedureDeclarationBlock | null)?.removeFieldCallback(field)
 }
 
 /**

package/src/blocks/sensing.ts

@@ -17,7 +17,6 @@
  * limitations under the License.
  */
 import * as Blockly from 'blockly/core'
-import * as Constants from '../constants'
 
 Blockly.Blocks.sensing_touchingobject = {
   /**

package/src/blocks/vertical_extensions.ts

@@ -156,14 +156,14 @@ const OUTPUT_BOOLEAN = function (this: Blockly.Block) {
  */
 const MONITOR_BLOCK = function (this: Blockly.BlockSvg) {
   this.addIcon(new FlyoutCheckboxIcon(this))
-  ;(this as any).checkboxInFlyout = true
+  ;(this as Blockly.BlockSvg & { checkboxInFlyout?: boolean }).checkboxInFlyout = true
 }
 
 /**
  * Mixin to add a context menu for a procedure definition block.
  * It adds the "edit" option and removes the "duplicate" option.
  */
-const PROCEDURE_DEF_CONTEXTMENU = function (this: Blockly.Block) {
+const PROCEDURE_DEF_CONTEXTMENU = function (this: Blockly.BlockSvg) {
   /**
    * Add the "edit" option and removes the "duplicate" option from the context
    * menu.
@@ -172,6 +172,7 @@ const PROCEDURE_DEF_CONTEXTMENU = function (this: Blockly.Block) {
   this.mixin(
     {
       customContextMenu: function (
+        this: Blockly.BlockSvg,
         menuOptions: (
           | Blockly.ContextMenuRegistry.ContextMenuOption
           | Blockly.ContextMenuRegistry.LegacyContextMenuOption
@@ -181,18 +182,20 @@ const PROCEDURE_DEF_CONTEXTMENU = function (this: Blockly.Block) {
         menuOptions.push(ScratchProcedures.makeEditOption(this))
 
         // Find and remove the duplicate option
-        for (let i = 0, option; (option = menuOptions[i]); i++) {
-          if (option.text == Blockly.Msg.DUPLICATE_BLOCK) {
+        for (let i = 0; i < menuOptions.length; i++) {
+          if (menuOptions[i].text == Blockly.Msg.DUPLICATE_BLOCK) {
             menuOptions.splice(i, 1)
             break
           }
         }
       },
-      checkAndDelete: function () {
+      checkAndDelete: function (this: Blockly.BlockSvg) {
         const input = this.getInput('custom_block')
         // this is the root block, not the shadow block.
-        if (input?.connection?.targetBlock()) {
-          const procCode = input.connection.targetBlock().getProcCode()
+        const targetBlock = input?.connection?.targetBlock()
+        const targetWithProcCode = targetBlock as (Blockly.Block & { getProcCode?(): string }) | null
+        if (targetWithProcCode?.getProcCode) {
+          const procCode = targetWithProcCode.getProcCode()
           const didDelete = ScratchProcedures.deleteProcedureDefCallback(procCode, this)
           if (!didDelete) {
             alert(Blockly.Msg.PROCEDURE_USED)
@@ -227,7 +230,7 @@ const PROCEDURE_CALL_CONTEXTMENU = {
 }
 
 const SCRATCH_EXTENSION = function (this: Blockly.Block) {
-  ;(this as any).isScratchExtension = true
+  ;(this as Blockly.Block & { isScratchExtension?: boolean }).isScratchExtension = true
 }
 
 /**

package/src/checkable_continuous_flyout.ts

@@ -2,13 +2,29 @@
  * Copyright 2024 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { ContinuousFlyout } from '@blockly/continuous-toolbox'
+import { ContinuousFlyout, type LabelFlyoutItem } from '@blockly/continuous-toolbox'
 import * as Blockly from 'blockly/core'
 import { CheckboxBubble } from './checkbox_bubble'
 import { StatusIndicatorLabel } from './status_indicator_label'
 import { STATUS_INDICATOR_LABEL_TYPE } from './status_indicator_label_flyout_inflater'
 
+interface ReflowElement extends Blockly.BlockSvg {
+  checkboxInFlyout?: boolean
+}
+
+interface CheckboxIcon {
+  setChecked: (value: boolean) => void
+}
+
+function isCheckboxIcon(icon: Blockly.IIcon | undefined): icon is Blockly.IIcon & CheckboxIcon {
+  return !!icon && typeof (icon as { setChecked?: unknown }).setChecked === 'function'
+}
+
 export class CheckableContinuousFlyout extends ContinuousFlyout {
+  declare protected tabWidth_: number
+  declare MARGIN: number
+  declare GAP_Y: number
+
   /**
    * Creates a new CheckableContinuousFlyout.
    * @param workspaceOptions Configuration options for the flyout workspace.
@@ -42,7 +58,16 @@ export class CheckableContinuousFlyout extends ContinuousFlyout {
    * @param value Value to set the checkbox to.
    */
   setCheckboxState(blockId: string, value: boolean) {
-    this.getWorkspace().getBlockById(blockId)?.getIcon('checkbox')?.setChecked(value)
+    const icon = this.getWorkspace().getBlockById(blockId)?.getIcon('checkbox')
+    if (!icon) {
+      return
+    }
+    if (!isCheckboxIcon(icon)) {
+      throw new Error(
+        `[CheckableContinuousFlyout.setCheckboxState] Expected checkbox icon with setChecked for block ${blockId}`,
+      )
+    }
+    icon.setChecked(value)
   }
 
   getFlyoutScale() {
@@ -61,14 +86,18 @@ export class CheckableContinuousFlyout extends ContinuousFlyout {
       // contents, and adjusts blocks in RTL mode accordingly. In Scratch, the
       // flyout width is fixed (and blocks may exceed it), so re-adjust blocks
       // accordingly based on the actual fixed width.
-      for (const item of this.getContents()) {
-        const oldX = item.getElement().getBoundingRectangle().left
-        let newX =
-          this.getWidth() / this.workspace_.scale - item.getElement().getBoundingRectangle().getWidth() - this.MARGIN
-        if ('checkboxInFlyout' in item.getElement() && item.getElement().checkboxInFlyout) {
+      const flyoutItems = this.getContents()
+      for (const item of flyoutItems) {
+        const element = item.getElement()
+        if (!(element instanceof Blockly.BlockSvg)) {
+          continue
+        }
+        const oldX = element.getBoundingRectangle().left
+        let newX = this.getWidth() / this.workspace_.scale - element.getBoundingRectangle().getWidth() - this.MARGIN
+        if ('checkboxInFlyout' in element && (element as ReflowElement).checkboxInFlyout) {
           newX -= CheckboxBubble.CHECKBOX_SIZE + CheckboxBubble.CHECKBOX_MARGIN
         }
-        item.getElement().moveBy(newX - oldX, 0)
+        element.moveBy(newX - oldX, 0)
       }
     }
   }
@@ -78,8 +107,11 @@ export class CheckableContinuousFlyout extends ContinuousFlyout {
    * @param item The toolbox item to check.
    * @returns True if the item represents a label in the flyout.
    */
-  protected toolboxItemIsLabel(item: Blockly.FlyoutItem) {
-    return item.getType() === STATUS_INDICATOR_LABEL_TYPE || super.toolboxItemIsLabel(item)
+  protected toolboxItemIsLabel(item: Blockly.FlyoutItem): item is LabelFlyoutItem {
+    if (item.getType() === STATUS_INDICATOR_LABEL_TYPE) {
+      return true
+    }
+    return super.toolboxItemIsLabel(item)
   }
 
   /**
@@ -87,8 +119,9 @@ export class CheckableContinuousFlyout extends ContinuousFlyout {
    */
   refreshStatusButtons() {
     for (const item of this.contents) {
-      if (item.element instanceof StatusIndicatorLabel) {
-        item.element.refreshStatus()
+      const element = item.getElement()
+      if (element instanceof StatusIndicatorLabel) {
+        element.refreshStatus()
       }
     }
   }

package/src/checkbox_bubble.ts

@@ -155,10 +155,10 @@ export class CheckboxBubble implements Blockly.IBubble, Blockly.IRenderedElement
    * Returns whether or not the specified block has its checkbox checked.
    *
    * This method is patched by scratch-gui to query the VM state.
-   * @param blockId The ID of the block in question.
+   * @param _blockId The ID of the block in question.
    * @returns True if the block's checkbox should be checked.
    */
-  isChecked(blockId: string): boolean {
+  isChecked(_blockId: string): boolean {
     return false
   }
 
@@ -252,17 +252,17 @@ export class CheckboxBubble implements Blockly.IBubble, Blockly.IRenderedElement
   // to its block and is not draggable by the user.
   showContextMenu() {}
 
-  setDragging(dragging: boolean) {}
+  setDragging(_dragging: boolean) {}
 
-  startDrag(event: PointerEvent) {}
+  startDrag(_event: PointerEvent) {}
 
-  drag(newLocation: Blockly.utils.Coordinate, event: PointerEvent) {}
+  drag(_newLocation: Blockly.utils.Coordinate, _event: PointerEvent) {}
 
-  moveDuringDrag(newLocation: Blockly.utils.Coordinate) {}
+  moveDuringDrag(_newLocation: Blockly.utils.Coordinate) {}
 
   endDrag() {}
 
   revertDrag() {}
 
-  setDeleteStyle(enable: boolean) {}
+  setDeleteStyle(_enable: boolean) {}
 }

package/src/colours.ts

@@ -62,13 +62,15 @@ const Colours = {
  * @param prefix A prefix to prepend to the CSS variables.
  * @returns A string containing CSS variable definitions for the colours.
  */
-function varify(coloursObj: object, prefix = '--colour'): string {
+function varify(coloursObj: Record<string, unknown>, prefix = '--colour'): string {
   return Object.entries(coloursObj)
     .map(([key, colour]) => {
       if (typeof colour === 'string') {
         return `${prefix}-${key}: ${colour};`
+      } else if (typeof colour === 'object' && colour !== null) {
+        return varify(colour as Record<string, unknown>, `${prefix}-${key}`)
       } else {
-        return varify(colour, `${prefix}-${key}`)
+        return ''
       }
     })
     .join('\n')