Merge branch 'main' into field-edit-focus-style

Author: microbit-matt-hillsdon

.github/workflows/pages.yml

@@ -64,7 +64,7 @@ jobs:
         uses: actions/upload-pages-artifact@v3
         with:
           # Upload build folder
-          path: './blockly-keyboard-experimentation/dist'
+          path: './blockly-keyboard-experimentation/build'
 
   deploy:
     environment:

package.json

@@ -5,12 +5,12 @@
   "scripts": {
     "audit:fix": "blockly-scripts auditFix",
     "build": "blockly-scripts build",
-    "ghpages": "webpack",
     "clean": "blockly-scripts clean",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "format": "prettier --write .",
     "format:check": "prettier --check .",
+    "ghpages": "node scripts/deploy.js",
     "predeploy": "blockly-scripts predeploy",
     "prepublishOnly": "npm login --registry https://wombat-dressing-room.appspot.com",
     "start": "blockly-scripts start",

scripts/deploy.js

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const execSync = require('child_process').execSync;
+const fs = require('fs');
+
+console.log(`Preparing test page for gh-pages deployment.`);
+
+execSync(`npm run build && npm run predeploy`, {stdio: 'pipe'});
+
+// Copy test/index.html to build/ directory.
+// Update the path at which the test_bundle can be found.
+let testPage = fs.readFileSync('./test/index.html').toString();
+testPage = testPage.replace('../build/test_bundle.js', 'test_bundle.js');
+fs.writeFileSync('build/index.html', testPage, 'utf-8');
+console.log(
+  `Open 'build/index.html' in a browser to see results, or upload the 'build' directory to ghpages.`,
+);

src/actions/duplicate.ts

@@ -0,0 +1,145 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  BlockSvg,
+  clipboard,
+  ContextMenuRegistry,
+  ICopyable,
+  ShortcutRegistry,
+  utils,
+  comments,
+  ICopyData,
+} from 'blockly';
+import * as Constants from '../constants';
+import {getMenuItem} from '../shortcut_formatting';
+
+/**
+ * Duplicate action that adds a keyboard shortcut for duplicate and overrides
+ * the context menu item to show it if the context menu item is registered.
+ */
+export class DuplicateAction {
+  private duplicateShortcut: ShortcutRegistry.KeyboardShortcut | null = null;
+  private uninstallHandlers: Array<() => void> = [];
+
+  /**
+   * Install the shortcuts and override context menu entries.
+   *
+   * No change is made if there's already a 'duplicate' shortcut.
+   */
+  install() {
+    this.duplicateShortcut = this.registerDuplicateShortcut();
+    if (this.duplicateShortcut) {
+      this.uninstallHandlers.push(
+        overrideContextMenuItemForShortcutText(
+          'blockDuplicate',
+          Constants.SHORTCUT_NAMES.DUPLICATE,
+        ),
+      );
+      this.uninstallHandlers.push(
+        overrideContextMenuItemForShortcutText(
+          'commentDuplicate',
+          Constants.SHORTCUT_NAMES.DUPLICATE,
+        ),
+      );
+    }
+  }
+
+  /**
+   * Unregister the shortcut and reinstate the original context menu entries.
+   */
+  uninstall() {
+    this.uninstallHandlers.forEach((handler) => handler());
+    this.uninstallHandlers.length = 0;
+    if (this.duplicateShortcut) {
+      ShortcutRegistry.registry.unregister(this.duplicateShortcut.name);
+    }
+  }
+
+  /**
+   * Create and register the keyboard shortcut for the duplicate action.
+   * Same behaviour as for the core context menu.
+   * Skipped if there is a shortcut with a matching name already.
+   */
+  private registerDuplicateShortcut(): ShortcutRegistry.KeyboardShortcut | null {
+    if (
+      ShortcutRegistry.registry.getRegistry()[
+        Constants.SHORTCUT_NAMES.DUPLICATE
+      ]
+    ) {
+      return null;
+    }
+
+    const shortcut: ShortcutRegistry.KeyboardShortcut = {
+      name: Constants.SHORTCUT_NAMES.DUPLICATE,
+      // Equivalent to the core context menu entry.
+      preconditionFn(workspace, scope) {
+        const {focusedNode} = scope;
+        if (focusedNode instanceof BlockSvg) {
+          return (
+            !focusedNode.isInFlyout &&
+            focusedNode.isDeletable() &&
+            focusedNode.isMovable() &&
+            focusedNode.isDuplicatable()
+          );
+        } else if (focusedNode instanceof comments.RenderedWorkspaceComment) {
+          return focusedNode.isMovable();
+        }
+        return false;
+      },
+      callback(workspace, e, shortcut, scope) {
+        const copyable = scope.focusedNode as ICopyable<ICopyData>;
+        const data = copyable.toCopyData();
+        if (!data) return false;
+        return !!clipboard.paste(data, workspace);
+      },
+      keyCodes: [utils.KeyCodes.D],
+    };
+    ShortcutRegistry.registry.register(shortcut);
+    return shortcut;
+  }
+}
+
+/**
+ * Replace a context menu item to add shortcut text to its displayText.
+ *
+ * Nothing happens if there is not a matching context menu item registered.
+ *
+ * @param registryId Context menu registry id to replace if present.
+ * @param shortcutName The corresponding shortcut name.
+ * @returns A function to reinstate the original context menu entry.
+ */
+function overrideContextMenuItemForShortcutText(
+  registryId: string,
+  shortcutName: string,
+): () => void {
+  const original = ContextMenuRegistry.registry.getItem(registryId);
+  if (!original || 'separator' in original) {
+    return () => {};
+  }
+
+  const override: ContextMenuRegistry.RegistryItem = {
+    ...original,
+    displayText: (scope: ContextMenuRegistry.Scope) => {
+      const displayText =
+        typeof original.displayText === 'function'
+          ? original.displayText(scope)
+          : original.displayText;
+      if (displayText instanceof HTMLElement) {
+        // We can't cope in this scenario.
+        return displayText;
+      }
+      return getMenuItem(displayText, shortcutName);
+    },
+  };
+  ContextMenuRegistry.registry.unregister(registryId);
+  ContextMenuRegistry.registry.register(override);
+
+  return () => {
+    ContextMenuRegistry.registry.unregister(registryId);
+    ContextMenuRegistry.registry.register(original);
+  };
+}

src/actions/enter.ts

@@ -16,13 +16,15 @@ import {
   icons,
   FocusableTreeTraverser,
   renderManagement,
+  comments,
+  getFocusManager,
 } from 'blockly/core';
 
 import type {Block} from 'blockly/core';
 
 import * as Constants from '../constants';
 import type {Navigation} from '../navigation';
-import {Mover} from './mover';
+import {Mover, MoveType} from './mover';
 import {
   showConstrainedMovementHint,
   showHelpHint,
@@ -124,10 +126,13 @@ export class EnterAction {
     ) {
       return !workspace.isReadOnly();
     }
-    if (curNode instanceof BlockSvg) return true;
     // Returning true is sometimes incorrect for icons, but there's no API to check.
-    if (curNode instanceof icons.Icon) return true;
-    return false;
+    return (
+      curNode instanceof BlockSvg ||
+      curNode instanceof icons.Icon ||
+      curNode instanceof comments.CommentBarButton ||
+      curNode instanceof comments.RenderedWorkspaceComment
+    );
   }
 
   /**
@@ -159,9 +164,20 @@ export class EnterAction {
       // opening a bubble of some sort. We then need to wait for the bubble to
       // appear before attempting to navigate into it.
       curNode.onClick();
-      renderManagement.finishQueuedRenders().then(() => {
-        cursor?.in();
-      });
+      // This currently only works for MutatorIcons.
+      // See icon_navigation_policy.
+      if (curNode instanceof icons.MutatorIcon) {
+        renderManagement.finishQueuedRenders().then(() => {
+          cursor?.in();
+        });
+      }
+      return true;
+    } else if (curNode instanceof comments.CommentBarButton) {
+      curNode.performAction();
+      return true;
+    } else if (curNode instanceof comments.RenderedWorkspaceComment) {
+      curNode.setCollapsed(false);
+      getFocusManager().focusNode(curNode.getEditorFocusableNode());
       return true;
     }
     return false;
@@ -194,13 +210,19 @@ export class EnterAction {
     const insertStartPoint = stationaryNode
       ? this.navigation.findInsertStartPoint(stationaryNode, newBlock)
       : null;
+
     if (workspace.getTopBlocks().includes(newBlock)) {
       this.positionNewTopLevelBlock(workspace, newBlock);
     }
 
     workspace.setResizesEnabled(true);
 
-    this.mover.startMove(workspace, newBlock, insertStartPoint);
+    this.mover.startMove(
+      workspace,
+      newBlock,
+      MoveType.Insert,
+      insertStartPoint,
+    );
 
     const isStartBlock =
       !newBlock.outputConnection &&