scratch-blocks 2.1.5 → 2.1.6

package/src/fields/scratch_field_variable.ts

@@ -29,6 +29,13 @@ import { createVariable, renameVariable } from '../variables'
 export class ScratchFieldVariable extends Blockly.FieldVariable {
   private originalStyle!: string
 
+  private getSourceWorkspaceSvg_(sourceBlock: Blockly.Block): Blockly.WorkspaceSvg {
+    if (!(sourceBlock.workspace instanceof Blockly.WorkspaceSvg)) {
+      throw new Error('[scratch_field_variable] Expected source block workspace to be a WorkspaceSvg')
+    }
+    return sourceBlock.workspace
+  }
+
   constructor(
     varName: string | null | typeof Blockly.Field.SKIP_SETUP,
     validator?: Blockly.FieldVariableValidator,
@@ -40,14 +47,15 @@ export class ScratchFieldVariable extends Blockly.FieldVariable {
     // dropdownCreate returns MenuOption[] rather than Blockly.MenuGenerator's
     // MenuOption[][] variant; the cast is needed to satisfy FieldVariable's
     // menuGenerator_ type while the actual runtime shape is compatible.
-    this.menuGenerator_ = ScratchFieldVariable.dropdownCreate as unknown as Blockly.MenuGenerator
+    this.menuGenerator_ = ScratchFieldVariable.dropdownCreate.bind(this) as unknown as Blockly.MenuGenerator
   }
 
   initModel() {
     if (!this.getVariable()) {
       const sourceBlock = this.getSourceBlock()
       if (sourceBlock) {
-        const broadcastVariable = this.initFlyoutBroadcast(sourceBlock.workspace as Blockly.WorkspaceSvg)
+        const sourceWorkspace = this.getSourceWorkspaceSvg_(sourceBlock)
+        const broadcastVariable = this.initFlyoutBroadcast(sourceWorkspace)
         if (broadcastVariable) {
           this.doValueUpdate_(broadcastVariable.getId())
           return
@@ -96,7 +104,8 @@ export class ScratchFieldVariable extends Blockly.FieldVariable {
         if (option[1] === Blockly.RENAME_VARIABLE_ID) {
           return [ScratchMsgs.translate('RENAME_LIST'), option[1]]
         } else if (option[1] === Blockly.DELETE_VARIABLE_ID) {
-          return [ScratchMsgs.translate('DELETE_LIST').replace('%1', this.getText()), option[1]]
+          const fieldText = (this as Blockly.FieldVariable).getText()
+          return [String(ScratchMsgs.translate('DELETE_LIST')).replace('%1', fieldText), option[1]]
         }
         return option
       })
@@ -118,8 +127,9 @@ export class ScratchFieldVariable extends Blockly.FieldVariable {
     if (sourceBlock && !sourceBlock.isDeadOrDying()) {
       const selectedItem = menuItem.getValue()
       if (selectedItem === Constants.NEW_BROADCAST_MESSAGE_ID) {
+        const sourceWorkspace = this.getSourceWorkspaceSvg_(sourceBlock)
         createVariable(
-          sourceBlock.workspace as Blockly.WorkspaceSvg,
+          sourceWorkspace,
           (varId) => {
             if (varId) {
               this.setValue(varId)
@@ -129,7 +139,7 @@ export class ScratchFieldVariable extends Blockly.FieldVariable {
         )
         return
       } else if (selectedItem === Blockly.RENAME_VARIABLE_ID) {
-        renameVariable(sourceBlock.workspace as Blockly.WorkspaceSvg, this.getVariable() as ScratchVariableModel)
+        renameVariable(sourceBlock.workspace, this.getVariable() as ScratchVariableModel)
         return
       }
     }
@@ -138,26 +148,30 @@ export class ScratchFieldVariable extends Blockly.FieldVariable {
 
   showEditor_(event: PointerEvent) {
     super.showEditor_(event)
-    const sourceBlock = this.getSourceBlock()!
+    const sourceBlock = this.getSourceBlock()
+    if (!sourceBlock) {
+      throw new Error('[scratch_field_variable] Missing source block in showEditor_')
+    }
+    const sourceWorkspace = this.getSourceWorkspaceSvg_(sourceBlock)
     const styleName = sourceBlock.getStyleName()
-    const style = (sourceBlock.workspace as Blockly.WorkspaceSvg)
-      .getRenderer()
-      .getConstants()
-      .getBlockStyle(styleName)
+    const style = sourceWorkspace.getRenderer().getConstants().getBlockStyle(styleName)
     if (sourceBlock.isShadow()) {
       this.originalStyle = styleName
       sourceBlock.setStyle(`${this.originalStyle}_selected`)
     } else if (this.borderRect_) {
       this.borderRect_.setAttribute(
         'fill',
-        'colourQuaternary' in style ? `${style.colourQuaternary}` : style.colourTertiary,
+        'colourQuaternary' in style ? String(style.colourQuaternary) : style.colourTertiary,
       )
     }
   }
 
   dropdownDispose_() {
     super.dropdownDispose_()
-    const sourceBlock = this.getSourceBlock()!
+    const sourceBlock = this.getSourceBlock()
+    if (!sourceBlock) {
+      throw new Error('[scratch_field_variable] Missing source block in dropdownDispose_')
+    }
     if (sourceBlock.isShadow()) {
       sourceBlock.setStyle(this.originalStyle)
     }

package/src/flyout_checkbox_icon.ts

@@ -9,7 +9,7 @@ import { CheckboxBubble } from './checkbox_bubble'
  * Invisible icon that exists solely to host the corresponding checkbox bubble.
  */
 export class FlyoutCheckboxIcon extends Blockly.icons.Icon implements Blockly.IHasBubble {
-  private checkboxBubble!: CheckboxBubble
+  private checkboxBubble?: CheckboxBubble
   private type = new Blockly.icons.IconType('checkbox')
 
   constructor(protected override sourceBlock: Blockly.BlockSvg) {
@@ -36,7 +36,7 @@ export class FlyoutCheckboxIcon extends Blockly.icons.Icon implements Blockly.IH
     return this.sourceBlock.workspace.isFlyout
   }
 
-  onLocationChange(blockOrigin: Blockly.utils.Coordinate) {
+  onLocationChange(_blockOrigin: Blockly.utils.Coordinate) {
     this.checkboxBubble?.updateLocation()
   }
 
@@ -52,16 +52,20 @@ export class FlyoutCheckboxIcon extends Blockly.icons.Icon implements Blockly.IH
   // These methods are required by the interfaces, but intentionally have no
   // implementation, largely because this icon has no visual representation.
 
-  async setBubbleVisible(visible: boolean) {}
+  setBubbleVisible(_visible: boolean): Promise<void> {
+    return Promise.resolve()
+  }
 
-  initView(pointerDownListener: (e: PointerEvent) => void) {}
+  initView(_pointerDownListener: (e: PointerEvent) => void) {
+    return
+  }
 
   canBeFocused() {
     return false
   }
 
   getBubble() {
-    return this.checkboxBubble
+    return this.checkboxBubble ?? null
   }
 }
 

package/src/glows.ts

@@ -4,6 +4,7 @@
  */
 import * as Blockly from 'blockly/core'
 import { Colours } from './colours'
+import { getBlockSvgById, getRequiredMainWorkspaceSvg } from './workspace_block_lookup'
 
 /**
  * Glow/unglow a stack in the workspace.
@@ -11,11 +12,10 @@ import { Colours } from './colours'
  * @param isGlowingStack Whether to glow the stack.
  */
 export function glowStack(id: string, isGlowingStack: boolean) {
-  const block = (Blockly.getMainWorkspace().getBlockById(id) ||
-    (Blockly.getMainWorkspace() as Blockly.WorkspaceSvg)
-      .getFlyout()
-      ?.getWorkspace()
-      ?.getBlockById(id)) as Blockly.BlockSvg
+  const mainWorkspace = getRequiredMainWorkspaceSvg()
+  const flyout = mainWorkspace.getFlyout()
+  const flyoutBlock = flyout ? getBlockSvgById(flyout.getWorkspace(), id) : null
+  const block = getBlockSvgById(mainWorkspace, id) ?? flyoutBlock
   if (!block) {
     throw new Error('Tried to glow block that does not exist.')
   }

package/src/index.ts

@@ -159,7 +159,7 @@ export function isContentNodeFocused(): boolean {
   return Blockly.getFocusManager().getFocusedNode() !== null
 }
 
-registerContinuousToolbox()
+;(registerContinuousToolbox as () => void)()
 Blockly.Scrollbar.scrollbarThickness = Blockly.Touch.TOUCH_ENABLED ? 14 : 11
 Blockly.FlyoutButton.TEXT_MARGIN_X = 40
 Blockly.FlyoutButton.TEXT_MARGIN_Y = 10
@@ -169,12 +169,23 @@ Blockly.ContextMenuItems.registerCommentOptions()
 // Blockly hides "Add Comment" for simple reporters because comments can't be
 // read in the default renderer. In Scratch they're shown differently, so
 // remove that restriction by dropping the isFullBlockField check.
-Blockly.ContextMenuRegistry.registry.getItem('blockComment')!.preconditionFn = (scope) => {
-  const block = scope.block
-  if (block && !block.isInFlyout && block.workspace.options.comments && !block.isCollapsed() && block.isEditable()) {
-    return 'enabled'
+const blockCommentMenuItem = Blockly.ContextMenuRegistry.registry.getItem('blockComment')
+if (!blockCommentMenuItem) {
+  console.error('[index] Missing context menu item: blockComment')
+} else {
+  blockCommentMenuItem.preconditionFn = (scope) => {
+    const block = scope.block
+    if (
+      block &&
+      !block.isInFlyout &&
+      block.workspace.options.comments &&
+      !block.isCollapsed() &&
+      block.isEditable()
+    ) {
+      return 'enabled'
+    }
+    return 'hidden'
   }
-  return 'hidden'
 }
 Blockly.ContextMenuRegistry.registry.unregister('blockDelete')
 contextMenuItems.registerDeleteBlock()
@@ -191,6 +202,7 @@ Blockly.comments.CommentView.defaultCommentSize = new Blockly.utils.Size(200, 20
 // to the workspace itself (whose onNodeFocus is a no-op) rather than to a
 // specific block, so deleting a block doesn't reset the scroll position.
 // We may need to re-evaluate this when we explicitly work on keyboard navigation.
+// eslint-disable-next-line @typescript-eslint/unbound-method -- preserve original prototype method for patched wrapper
 const originalGetRestoredFocusableNode = Blockly.WorkspaceSvg.prototype.getRestoredFocusableNode
 Blockly.WorkspaceSvg.prototype.getRestoredFocusableNode = function (previousNode) {
   if (!previousNode && !this.isFlyout) return null

package/src/procedures.ts

@@ -33,7 +33,12 @@ 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))
+    .map((b) => {
+      if (!b.mutationToDom) {
+        throw new Error(`Expected mutationToDom on procedure prototype block ${b.id}`)
+      }
+      return b.mutationToDom(/* opt_generateShadows */ true)
+    })
 }
 
 /**
@@ -44,8 +49,11 @@ function allProcedureMutations(root: Blockly.WorkspaceSvg): Element[] {
  */
 function sortProcedureMutations(mutations: Element[]): Element[] {
   return mutations.slice().sort((a, b) => {
-    const procCodeA = a.getAttribute('proccode')!
-    const procCodeB = b.getAttribute('proccode')!
+    const procCodeA = a.getAttribute('proccode')
+    const procCodeB = b.getAttribute('proccode')
+    if (!procCodeA || !procCodeB) {
+      throw new Error('Expected proccode attribute in procedure mutation element')
+    }
 
     return scratchBlocksUtils.compareStrings(procCodeA, procCodeB)
   })
@@ -114,23 +122,19 @@ function addCreateButton(workspace: Blockly.WorkspaceSvg, xmlList: Element[]) {
  */
 export function getCallers(
   name: string,
-  workspace: Blockly.WorkspaceSvg,
-  definitionRoot: Blockly.BlockSvg,
+  workspace: Blockly.Workspace,
+  definitionRoot: Pick<Blockly.Block, 'id'>,
   allowRecursive: boolean,
-): Blockly.BlockSvg[] {
+): ProcedureBlock[] {
   return workspace.getTopBlocks().flatMap((block) => {
     if (block.id === definitionRoot.id && !allowRecursive) {
       return []
     }
 
-    return block
-      .getDescendants(false)
-      .filter(
-        (descendant) =>
-          isProcedureBlock(descendant) &&
-          descendant.type === Constants.PROCEDURES_CALL_BLOCK_TYPE &&
-          descendant.getProcCode() === name,
-      )
+    const procedureDescendants = block.getDescendants(false).filter(isProcedureBlock)
+    return procedureDescendants.filter(
+      (descendant) => descendant.type === Constants.PROCEDURES_CALL_BLOCK_TYPE && descendant.getProcCode() === name,
+    )
   })
 }
 
@@ -147,16 +151,22 @@ function mutateCallersAndPrototype(name: string, workspace: Blockly.WorkspaceSvg
     alert('No define block on workspace') // TODO decide what to do about this.
     return
   }
+  if (!isProcedureBlock(prototypeBlock)) {
+    throw new Error(`Expected procedure prototype block for procCode ${name}`)
+  }
 
   const callers = getCallers(name, defineBlock.workspace, defineBlock, true /* allowRecursive */)
   callers.push(prototypeBlock)
   Blockly.Events.setGroup(true)
   callers.forEach((caller) => {
-    const oldMutationDom = caller.mutationToDom!()
-    const oldMutation = oldMutationDom && Blockly.Xml.domToText(oldMutationDom)
-    caller.domToMutation!(mutation)
-    const newMutationDom = caller.mutationToDom!()
-    const newMutation = newMutationDom && Blockly.Xml.domToText(newMutationDom)
+    if (!caller.mutationToDom || !caller.domToMutation) {
+      throw new Error(`Expected mutation APIs on block ${caller.id} (${caller.type})`)
+    }
+    const oldMutationDom = caller.mutationToDom()
+    const oldMutation = Blockly.Xml.domToText(oldMutationDom)
+    caller.domToMutation(mutation)
+    const newMutationDom = caller.mutationToDom()
+    const newMutation = Blockly.Xml.domToText(newMutationDom)
     if (oldMutation !== newMutation) {
       Blockly.Events.fire(
         new (Blockly.Events.get(Blockly.Events.BLOCK_CHANGE))(caller, 'mutation', null, oldMutation, newMutation),
@@ -172,16 +182,31 @@ function mutateCallersAndPrototype(name: string, workspace: Blockly.WorkspaceSvg
  * @param workspace The workspace to search.
  * @returns The procedure definition block, or undefined if not found.
  */
-function getDefineBlock(procCode: string, workspace: Blockly.WorkspaceSvg): Blockly.BlockSvg | undefined {
+function getDefineBlock(procCode: string, workspace: Blockly.Workspace): Blockly.BlockSvg | undefined {
   // Assume that a procedure definition is a top block.
-  return workspace.getTopBlocks(false).find((block) => {
+  for (const block of workspace.getTopBlocks(false)) {
     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
+      const input = block.getInput('custom_block')
+      if (!input?.connection) {
+        throw new Error(`Expected custom_block input connection on block ${block.id}`)
+      }
+      const raw = input.connection.targetBlock()
+      if (!raw) {
+        throw new Error(`Expected custom_block target block on block ${block.id}`)
+      }
+      if (!(raw instanceof Blockly.BlockSvg)) {
+        throw new Error(`Expected custom_block target BlockSvg on block ${block.id}`)
+      }
+      const prototypeBlock = raw
+      if (isProcedureBlock(prototypeBlock) && prototypeBlock.getProcCode() === procCode) {
+        if (!(block instanceof Blockly.BlockSvg)) {
+          throw new Error(`Expected procedure definition BlockSvg for block ${block.id}`)
+        }
+        return block
+      }
     }
-
-    return false
-  })
+  }
+  return undefined
 }
 
 /**
@@ -190,10 +215,21 @@ function getDefineBlock(procCode: string, workspace: Blockly.WorkspaceSvg): Bloc
  * @param workspace The workspace to search.
  * @returns The procedure prototype block, or undefined if not found.
  */
-function getPrototypeBlock(procCode: string, workspace: Blockly.WorkspaceSvg): Blockly.BlockSvg | undefined {
+function getPrototypeBlock(procCode: string, workspace: Blockly.Workspace): Blockly.BlockSvg | undefined {
   const defineBlock = getDefineBlock(procCode, workspace)
   if (defineBlock) {
-    return defineBlock.getInput('custom_block')!.connection!.targetBlock() as Blockly.BlockSvg
+    const input = defineBlock.getInput('custom_block')
+    if (!input?.connection) {
+      throw new Error(`Expected custom_block input connection on block ${defineBlock.id}`)
+    }
+    const target = input.connection.targetBlock()
+    if (!target) {
+      throw new Error(`Expected custom_block target block on block ${defineBlock.id}`)
+    }
+    if (!(target instanceof Blockly.BlockSvg)) {
+      throw new Error(`Expected custom_block target BlockSvg on block ${defineBlock.id}`)
+    }
+    return target
   }
   return undefined
 }
@@ -213,7 +249,9 @@ function newProcedureMutation(): Element {
         warp="false">
       </mutation>
     </xml>`
-  return Blockly.utils.xml.textToDom(mutationText).firstElementChild!
+  const el = Blockly.utils.xml.textToDom(mutationText).firstElementChild
+  if (!el) throw new Error('Failed to parse mutation XML')
+  return el
 }
 
 /**
@@ -221,7 +259,11 @@ function newProcedureMutation(): Element {
  * @param workspace The workspace to create the new procedure on.
  */
 function createProcedureDefCallback(workspace: Blockly.WorkspaceSvg) {
-  ScratchProcedures.externalProcedureDefCallback!(newProcedureMutation(), createProcedureCallbackFactory(workspace))
+  const callback = ScratchProcedures.externalProcedureDefCallback
+  if (!callback) {
+    throw new Error('ScratchProcedures.externalProcedureDefCallback is not set')
+  }
+  callback(newProcedureMutation(), createProcedureCallbackFactory(workspace))
 }
 
 /**
@@ -243,10 +285,13 @@ function createProcedureCallbackFactory(workspace: Blockly.WorkspaceSvg): (mutat
           </statement>
         </block>
       </xml>`
-    const blockDom = Blockly.utils.xml.textToDom(blockText).firstElementChild!
+    const blockDom = Blockly.utils.xml.textToDom(blockText).firstElementChild
+    if (!blockDom) {
+      throw new Error('Failed to parse procedure definition XML')
+    }
     Blockly.Events.setGroup(true)
     const block = Blockly.Xml.domToBlock(blockDom, workspace) as Blockly.BlockSvg
-    Blockly.renderManagement.finishQueuedRenders().then(() => {
+    void Blockly.renderManagement.finishQueuedRenders().then(() => {
       // To convert from pixel units to workspace units
       const scale = workspace.scale
       // Position the block so that it is at the top left of the visible
@@ -293,7 +338,9 @@ function editProcedureCallback(block: Blockly.BlockSvg) {
   } else if (block.type === Constants.PROCEDURES_CALL_BLOCK_TYPE && isProcedureBlock(block)) {
     // This is a call block, find the prototype corresponding to the procCode.
     // Make sure to search the correct workspace, call block can be in flyout.
-    const workspaceToSearch = block.workspace.isFlyout ? block.workspace.targetWorkspace! : block.workspace
+    const workspaceToSearch = block.workspace.isFlyout
+      ? (block.workspace.targetWorkspace ?? block.workspace)
+      : block.workspace
     const foundBlock = getPrototypeBlock(block.getProcCode(), workspaceToSearch)
     if (!foundBlock) {
       console.warn('editProcedureCallback: could not find prototype for', block.getProcCode())
@@ -304,10 +351,14 @@ function editProcedureCallback(block: Blockly.BlockSvg) {
     prototypeBlock = block
   }
   // Block now refers to the procedure prototype block, it is safe to proceed.
-  ScratchProcedures.externalProcedureDefCallback!(
-    prototypeBlock.mutationToDom!(),
-    editProcedureCallbackFactory(prototypeBlock),
-  )
+  const callback = ScratchProcedures.externalProcedureDefCallback
+  if (!callback) {
+    throw new Error('ScratchProcedures.externalProcedureDefCallback is not set')
+  }
+  if (!prototypeBlock.mutationToDom) {
+    throw new Error(`Expected mutationToDom on block ${prototypeBlock.id} (${prototypeBlock.type})`)
+  }
+  callback(prototypeBlock.mutationToDom(), editProcedureCallbackFactory(prototypeBlock))
 }
 
 /**
@@ -349,15 +400,14 @@ function makeEditOption(block: Blockly.BlockSvg): Blockly.ContextMenuRegistry.Co
  *     procedure.
  * @returns True if the custom procedure was deleted, false otherwise.
  */
-function deleteProcedureDefCallback(procCode: string, definitionRoot: Blockly.BlockSvg): boolean {
+function deleteProcedureDefCallback(procCode: string, definitionRoot: Blockly.Block): boolean {
   const callers = getCallers(procCode, definitionRoot.workspace, definitionRoot, false /* allowRecursive */)
   if (callers.length > 0) {
     return false
   }
 
-  const workspace = definitionRoot.workspace
   // Bypass the checkAndDelete provided by the procedure block mixin
-  Blockly.BlockSvg.prototype.checkAndDelete.call(definitionRoot)
+  Blockly.BlockSvg.prototype.checkAndDelete.call(definitionRoot as Blockly.BlockSvg)
   return true
 }
 
@@ -366,7 +416,7 @@ function deleteProcedureDefCallback(procCode: string, definitionRoot: Blockly.Bl
  * @param block The block to check.
  * @returns True if the block is a procedure block, otherwise false.
  */
-export function isProcedureBlock(block: Blockly.BlockSvg): block is ProcedureBlock {
+export function isProcedureBlock(block: Blockly.Block): block is ProcedureBlock {
   return (
     block.type === Constants.PROCEDURES_CALL_BLOCK_TYPE ||
     block.type === Constants.PROCEDURES_DECLARATION_BLOCK_TYPE ||
@@ -378,7 +428,7 @@ export function isProcedureBlock(block: Blockly.BlockSvg): block is ProcedureBlo
  * Interface for procedure blocks, which have the getProcCode method added
  * through an extension.
  */
-interface ProcedureBlock extends Blockly.BlockSvg {
+interface ProcedureBlock extends Blockly.Block {
   getProcCode(): string
 }
 

package/src/recyclable_block_flyout_inflater.ts

@@ -13,13 +13,14 @@ export class RecyclableBlockFlyoutInflater extends BlocklyRecyclableBlockFlyoutI
   /**
    * Creates a block on the flyout workspace from the given block definition.
    * @param state A JSON representation of a block to load.
-   * @param flyoutWorkspace The workspace on which the block will be inflated.
+   * @param flyout The flyout on which the block will be inflated.
    * @returns The newly created block.
    */
-  load(state: Blockly.utils.toolbox.BlockInfo, flyoutWorkspace: Blockly.WorkspaceSvg): Blockly.FlyoutItem {
-    const flyoutItem = super.load(state, flyoutWorkspace)
+  load(state: object, flyout: Blockly.IFlyout): Blockly.FlyoutItem {
+    const flyoutItem = super.load(state, flyout)
     const block = flyoutItem.getElement()
-    if ('checkboxInFlyout' in block && block.checkboxInFlyout) {
+    const flyoutWorkspace = flyout.getWorkspace()
+    if (block instanceof Blockly.BlockSvg && 'checkboxInFlyout' in block && block.checkboxInFlyout === true) {
       block.moveBy(
         (flyoutWorkspace.RTL ? -1 : 1) * (CheckboxBubble.CHECKBOX_SIZE + CheckboxBubble.CHECKBOX_MARGIN),
         0,

package/src/renderer/cat/cat_face.ts

@@ -33,7 +33,7 @@ const setVisibility = (element: SVGElement, visible: boolean) => {
  * Owned by the PathObject with similar lifetime.
  */
 export class CatFace {
-  faceGroup_!: SVGElement
+  faceGroup_: SVGElement | null = null
   parts_ = {} as Record<FacePart, SVGElement>
   pathEarState: CatPathState
   constants_: ConstantProvider

package/src/renderer/cat/drawer.ts

@@ -52,6 +52,9 @@ export class Drawer extends ClassicDrawer {
       return super.makeReplacementTop_()
     }
     const pathObject = this.block_.pathObject as PathObject
-    return this.constants_.makeCatPath(this.info_.width, pathObject.catFace!.pathEarState)
+    if (!pathObject.catFace) {
+      throw new Error('[renderer/cat/drawer] Missing catFace while drawing hat block')
+    }
+    return this.constants_.makeCatPath(this.info_.width, pathObject.catFace.pathEarState)
   }
 }

package/src/renderer/constants.ts

@@ -27,10 +27,10 @@ export class ConstantProvider extends Blockly.zelos.ConstantProvider {
         root.style.setProperty(varKey, colour)
       } else {
         const style = {
-          colourPrimary: 'colourQuaternary' in colour ? `${colour.colourQuaternary}` : colour.colourTertiary,
-          colourSecondary: 'colourQuaternary' in colour ? `${colour.colourQuaternary}` : colour.colourTertiary,
-          colourTertiary: 'colourQuaternary' in colour ? `${colour.colourQuaternary}` : colour.colourTertiary,
-          colourQuaternary: 'colourQuaternary' in colour ? `${colour.colourQuaternary}` : colour.colourTertiary,
+          colourPrimary: 'colourQuaternary' in colour ? String(colour.colourQuaternary) : colour.colourTertiary,
+          colourSecondary: 'colourQuaternary' in colour ? String(colour.colourQuaternary) : colour.colourTertiary,
+          colourTertiary: 'colourQuaternary' in colour ? String(colour.colourQuaternary) : colour.colourTertiary,
+          colourQuaternary: 'colourQuaternary' in colour ? String(colour.colourQuaternary) : colour.colourTertiary,
           hat: '',
         }
         theme.setBlockStyle(`${key}_selected`, style)
@@ -52,38 +52,43 @@ export class ConstantProvider extends Blockly.zelos.ConstantProvider {
    * @returns The shape object for the given connection.
    */
   override shapeFor(connection: Blockly.RenderedConnection): ReturnType<Blockly.zelos.ConstantProvider['shapeFor']> {
+    const connectionType = connection.type as Blockly.ConnectionType
     let checks = connection.getCheck()
+    const hexagonal = this.HEXAGONAL
+    const rounded = this.ROUNDED
+    const squared = this.SQUARED
+    if (!hexagonal || !rounded || !squared) return super.shapeFor(connection)
     if (!checks && connection.targetConnection) {
       checks = connection.targetConnection.getCheck()
     }
 
-    if (connection.type === Blockly.ConnectionType.OUTPUT_VALUE) {
+    if (connectionType === Blockly.ConnectionType.OUTPUT_VALUE) {
       const outputShape = connection.getSourceBlock().getOutputShape()
       if (outputShape !== null) {
         switch (outputShape) {
           case this.SHAPES.HEXAGONAL:
-            return this.HEXAGONAL!
+            return hexagonal
           case this.SHAPES.ROUND:
-            return this.ROUNDED!
+            return rounded
           case this.SHAPES.SQUARE:
-            return this.SQUARED!
+            return squared
         }
       }
     }
 
     // For INPUT_VALUE (and OUTPUT_VALUE fallthrough), use connection checks.
-    if (checks?.includes('Boolean')) return this.HEXAGONAL!
-    if (checks?.includes('Number')) return this.ROUNDED!
-    if (checks?.includes('String')) return this.ROUNDED!
+    if (checks?.includes('Boolean')) return hexagonal
+    if (checks?.includes('Number')) return rounded
+    if (checks?.includes('String')) return rounded
     // For INPUT_VALUE or OUTPUT_VALUE with unrecognized checks, default to
     // ROUNDED. Don't call super.shapeFor() here: the base implementation
     // uses getSourceBlock().getOutputShape(), which would incorrectly return
     // HEXAGONAL for inputs inside Boolean reporters (e.g. `<a = b>`).
     if (
-      connection.type === Blockly.ConnectionType.INPUT_VALUE ||
-      connection.type === Blockly.ConnectionType.OUTPUT_VALUE
+      connectionType === Blockly.ConnectionType.INPUT_VALUE ||
+      connectionType === Blockly.ConnectionType.OUTPUT_VALUE
     ) {
-      return this.ROUNDED!
+      return rounded
     }
     return super.shapeFor(connection)
   }

package/src/renderer/drawer.ts

@@ -64,7 +64,8 @@ export class Drawer extends Blockly.zelos.Drawer {
    */
   override drawConnectionHighlightPath(measurable: Blockly.blockRendering.Connection) {
     const conn = measurable.connectionModel
-    if (conn.type === Blockly.ConnectionType.INPUT_VALUE && measurable.isDynamicShape) {
+    const connectionType = conn.type as Blockly.ConnectionType
+    if (connectionType === Blockly.ConnectionType.INPUT_VALUE && measurable.isDynamicShape) {
       const input = measurable as Blockly.blockRendering.InlineInput
       const EXPAND_X = 0.5
       const EXPAND_Y = 2

package/src/renderer/render_info.ts

@@ -36,16 +36,20 @@ 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)!
-      this.width =
-        statementRow.widthWithConnectedBlocks -
-        statementRow.elements.find((e) => Blockly.blockRendering.Types.isInput(e))!.width +
-        this.constants_.MEDIUM_PADDING
+      const statementRow = this.rows.find((r) => r.hasStatement)
+      const input = statementRow?.elements.find((e) => Blockly.blockRendering.Types.isInput(e))
+      if (!statementRow || !input) {
+        throw new Error('[renderer/render_info] Missing statement row or input for bowler hat block')
+      }
+      this.width = statementRow.widthWithConnectedBlocks - input.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))
+      if (!hat) {
+        throw new Error('[renderer/render_info] Missing hat measurable for bowler hat block')
+      }
       hat.width = this.width
       this.topRow.measure()
     }
@@ -57,7 +61,7 @@ export class RenderInfo extends Blockly.zelos.RenderInfo {
   ): number {
     if (
       this.isBowlerHatBlock() &&
-      ((prev && Blockly.blockRendering.Types.isHat(prev)) || (next && Blockly.blockRendering.Types.isHat(next)))
+      (Blockly.blockRendering.Types.isHat(prev) || Blockly.blockRendering.Types.isHat(next))
     ) {
       // Bowler hat rows have no spacing/gaps, just the hat.
       return 0
@@ -82,8 +86,7 @@ export class RenderInfo extends Blockly.zelos.RenderInfo {
       this.block_.isScratchExtension &&
       Blockly.blockRendering.Types.isField(elem) &&
       elem.field instanceof Blockly.FieldImage &&
-      elem.field === this.block_.inputList[0].fieldRow[0] &&
-      this.block_.previousConnection
+      elem.field === this.block_.inputList[0].fieldRow[0]
     ) {
       // Vertically center the icon on extension blocks.
       return super.getElemCenterline_(row, elem) + this.constants_.GRID_UNIT

package/src/renderer/renderer.ts

@@ -65,7 +65,7 @@ export class ScratchRenderer extends Blockly.zelos.Renderer {
    * @returns True if we should highlight the connection.
    */
   override shouldHighlightConnection(connection: Blockly.RenderedConnection): boolean {
-    return connection.type === Blockly.ConnectionType.INPUT_VALUE
+    return (connection.type as Blockly.ConnectionType) === Blockly.ConnectionType.INPUT_VALUE
   }
 }
 

package/src/scratch_blocks_utils.ts

@@ -20,8 +20,6 @@
  * @file Utility methods for Scratch Blocks but not Blockly.
  * @author fenichel@google.com (Rachel Fenichel)
  */
-import * as Blockly from 'blockly/core'
-
 /**
  * Compare strings with natural number sorting.
  * @param str1 First input.