@workbench-kit/shell-react 0.0.2-prototype.0.2.41 → 0.0.2-prototype.0.2.43

package/src/workbench/command-host.tsx

@@ -1,14 +1,6 @@
 import {
-  createCommandRegistryFromContributions,
-  type CommandRegistry,
-} from '@workbench-kit/platform';
-import {
-  WorkbenchCommandPalette,
-  WorkbenchQuickOpen,
-  WorkbenchShortcutCommandBridge,
   createWorkbenchShellCommands,
   createWorkspaceFilesQuickOpenProvider,
-  resolveQuickOpenItemPath,
   type QuickOpenItem,
   type QuickOpenProvider,
   type QuickOpenSelectContext,
@@ -20,21 +12,23 @@ import {
   matchesWorkbenchCommandPaletteShortcut,
   matchesWorkbenchQuickAccessShortcut,
 } from '@workbench-kit/react/workbench/command-ui';
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react';
 
 import { useContextKeyRevision } from '../commands/use-context-key-revision.js';
 import { useWorkbench } from '../shell/provider.js';
+import { WorkbenchCommandHostController } from './command-host-controller.js';
 import { registerWorkbenchShellCommandHandlers } from './shell-command-registration.js';
 import {
   buildWorkbenchPaletteCommands,
   collectExtensionCommandFeaturesById,
   resolveShellCommandActivities,
 } from './command-palette.js';
-import { resolveExtensionKeybindingCommand } from './keybinding-bridge.js';
+import {
+  normalizeExtensionKeybindingCandidates,
+  resolveExtensionKeybindingCommand,
+} from './keybinding-bridge.js';
 import { isWorkspaceResourceService, useWorkspaceResourceState } from './workspace-view-state.js';
 
-const WORKSPACE_OPEN_COMMAND_ID = 'workspace.open' as const;
-
 export interface WorkbenchCommandHostProps {
   additionalCommands?: readonly WorkbenchCommandDescriptor[];
   /** Override command palette close control label (default English). */
@@ -108,21 +102,55 @@ export function WorkbenchCommandHost({
     extensionCatalog,
     keybindings,
     keybindingOverrides,
+    keybindingPlatform,
+    keybindingProjection,
     layoutService,
     views,
     workspaceHostPort,
   } = useWorkbench();
-  const [paletteOpen, setPaletteOpen] = useState(false);
-  const [paletteQuery, setPaletteQuery] = useState('');
-  const [quickOpenOpen, setQuickOpenOpen] = useState(false);
-  const [quickOpenQuery, setQuickOpenQuery] = useState('');
   const [layout, setLayout] = useState(() => layoutService.getState());
+  const [extensionKeybindingRevision, setExtensionKeybindingRevision] = useState(
+    () => keybindings.revision,
+  );
   const shellContextRef = useRef<WorkbenchShellCommandContext | undefined>(undefined);
   const contextKeyRevision = useContextKeyRevision(contextKeyService);
   const contextKeySnapshot = useMemo(
     () => contextKeyService.createSnapshot(),
     [contextKeyRevision, contextKeyService],
   );
+  const genericKeybindingCommandIds = useMemo(
+    () => new Set(keybindingProjection.defaults.map((binding) => binding.command)),
+    [keybindingProjection.defaults],
+  );
+  useLayoutEffect(() => {
+    const disposable = keybindings.onDidChangeKeybindings(() => {
+      setExtensionKeybindingRevision(keybindings.revision);
+    });
+    setExtensionKeybindingRevision(keybindings.revision);
+    return () => disposable.dispose();
+  }, [keybindings]);
+  const extensionOnlyCommandIds = useMemo(() => {
+    const commandIds = new Set<string>();
+    for (const binding of keybindings.getKeybindings()) {
+      if (
+        !genericKeybindingCommandIds.has(binding.command) &&
+        normalizeExtensionKeybindingCandidates(binding.key, keybindingPlatform, true).length > 0
+      ) {
+        commandIds.add(binding.command);
+      }
+    }
+    return commandIds;
+  }, [extensionKeybindingRevision, genericKeybindingCommandIds, keybindingPlatform, keybindings]);
+  const runtimeKeybindingProjection = useMemo(() => {
+    if (!enableExtensionKeybindings) return keybindingProjection;
+
+    return Object.freeze({
+      commands: Object.freeze(
+        keybindingProjection.commands.filter((command) => !extensionOnlyCommandIds.has(command.id)),
+      ),
+      defaults: keybindingProjection.defaults,
+    });
+  }, [enableExtensionKeybindings, extensionOnlyCommandIds, keybindingProjection]);
 
   const workspaceService = isWorkspaceResourceService(workspaceHostPort?.service)
     ? workspaceHostPort.service
@@ -176,14 +204,6 @@ export function WorkbenchCommandHost({
     [managedShellActivities],
   );
 
-  const shellCommandRegistry = useMemo(
-    () =>
-      createCommandRegistryFromContributions<WorkbenchShellCommandContext>([
-        { commands: shellCommandDefinitions },
-      ]),
-    [shellCommandDefinitions],
-  );
-
   const shellContext = useMemo<WorkbenchShellCommandContext>(
     () => ({
       isFocusModeActive: layoutService.isFocusModeActive(),
@@ -261,101 +281,16 @@ export function WorkbenchCommandHost({
     ];
   }, [quickOpenProviders, quickOpenRecentPaths, workspaceService, workspaceState?.files]);
 
-  const closePalette = useCallback(() => {
-    setPaletteOpen(false);
-  }, []);
-
-  const openPalette = useCallback((query = '') => {
-    setQuickOpenOpen(false);
-    setPaletteQuery(query);
-    setPaletteOpen(true);
-  }, []);
-
-  const closeQuickOpen = useCallback(() => {
-    setQuickOpenOpen(false);
-  }, []);
-
-  const openQuickOpen = useCallback((query = '') => {
-    setPaletteOpen(false);
-    setQuickOpenQuery(query);
-    setQuickOpenOpen(true);
-  }, []);
-
-  const runPaletteCommand = useCallback(
-    (command: WorkbenchCommandDescriptor, context: WorkbenchCommandRunContext) => {
-      const finish = () => {
-        closePalette();
-      };
-
-      if (onRunCommand?.(command, context)) {
-        finish();
-        return;
-      }
-
-      void executeCommand(command.id).finally(finish);
-    },
-    [closePalette, executeCommand, onRunCommand],
-  );
-
-  const runQuickOpenItem = useCallback(
-    (item: QuickOpenItem, context: QuickOpenSelectContext) => {
-      const finish = () => {
-        closeQuickOpen();
-      };
-
-      if (onOpenQuickOpenItem?.(item, context)) {
-        finish();
-        return;
-      }
-
-      const path = resolveQuickOpenItemPath(item);
-      if (!path) {
-        finish();
-        return;
-      }
-
-      void executeCommand(WORKSPACE_OPEN_COMMAND_ID, { path }).finally(finish);
-    },
-    [closeQuickOpen, executeCommand, onOpenQuickOpenItem],
-  );
-
   useEffect(() => {
-    if (!enableCommandPalette && !enableQuickOpen) {
+    if (!enableExtensionKeybindings) {
       return undefined;
     }
 
     const onKeyDown = (event: KeyboardEvent) => {
-      if (enableCommandPalette && matchesWorkbenchCommandPaletteShortcut(event)) {
-        event.preventDefault();
-        openPalette('>');
+      if (isActiveShortcutCaptureTarget(event)) {
         return;
       }
 
-      if (matchesWorkbenchQuickAccessShortcut(event)) {
-        event.preventDefault();
-        if (enableQuickOpen) {
-          openQuickOpen();
-          return;
-        }
-
-        if (enableCommandPalette) {
-          openPalette();
-        }
-      }
-    };
-
-    window.addEventListener('keydown', onKeyDown);
-    return () => {
-      window.removeEventListener('keydown', onKeyDown);
-    };
-  }, [enableCommandPalette, enableQuickOpen, openPalette, openQuickOpen]);
-
-  useEffect(() => {
-    if (!enableExtensionKeybindings) {
-      return undefined;
-    }
-
-    const onKeyDown = (event: KeyboardEvent) => {
       if (
         matchesWorkbenchCommandPaletteShortcut(event) ||
         matchesWorkbenchQuickAccessShortcut(event)
@@ -363,7 +298,14 @@ export function WorkbenchCommandHost({
         return;
       }
 
-      const match = resolveExtensionKeybindingCommand(keybindings, event, {}, keybindingOverrides);
+      const match = resolveExtensionKeybindingCommand(
+        keybindings,
+        event,
+        {},
+        keybindingOverrides,
+        keybindingPlatform,
+        genericKeybindingCommandIds,
+      );
       if (!match) {
         return;
       }
@@ -376,45 +318,53 @@ export function WorkbenchCommandHost({
     return () => {
       window.removeEventListener('keydown', onKeyDown);
     };
-  }, [enableExtensionKeybindings, executeCommand, keybindings, keybindingOverrides]);
+  }, [
+    enableExtensionKeybindings,
+    executeCommand,
+    genericKeybindingCommandIds,
+    keybindings,
+    keybindingOverrides,
+    keybindingPlatform,
+  ]);
+
+  return (
+    <WorkbenchCommandHostController
+      commandPaletteCloseLabel={commandPaletteCloseLabel}
+      commandPaletteEmptyLabel={commandPaletteEmptyLabel}
+      commandPalettePlaceholder={commandPalettePlaceholder}
+      commandPaletteTitle={commandPaletteTitle}
+      commands={paletteCommands}
+      enableCommandPalette={enableCommandPalette}
+      enableQuickOpen={enableQuickOpen}
+      executeCommand={executeCommand}
+      quickOpenCloseLabel={quickOpenCloseLabel}
+      quickOpenEmptyLabel={quickOpenEmptyLabel}
+      quickOpenPlaceholder={quickOpenPlaceholder}
+      quickOpenProviders={resolvedQuickOpenProviders}
+      quickOpenTitle={quickOpenTitle}
+      shortcutBridge={
+        enableShortcutBridge
+          ? {
+              context: undefined,
+              keybindingOverrides,
+              keybindingProjection: runtimeKeybindingProjection,
+              platform: keybindingPlatform,
+              preventDefault: true,
+              registry: commands,
+            }
+          : false
+      }
+      {...(onOpenQuickOpenItem === undefined ? {} : { onOpenQuickOpenItem })}
+      {...(onRunCommand === undefined ? {} : { onRunCommand })}
+    />
+  );
+}
 
+function isActiveShortcutCaptureTarget(event: Event): boolean {
+  const target = event.target;
   return (
-    <>
-      {enableShortcutBridge ? (
-        <WorkbenchShortcutCommandBridge
-          context={shellContext}
-          preventDefault
-          registry={shellCommandRegistry as CommandRegistry<WorkbenchShellCommandContext>}
-        />
-      ) : null}
-      {enableCommandPalette ? (
-        <WorkbenchCommandPalette
-          closeLabel={commandPaletteCloseLabel}
-          commands={paletteCommands}
-          emptyLabel={commandPaletteEmptyLabel}
-          open={paletteOpen}
-          placeholder={commandPalettePlaceholder}
-          query={paletteQuery}
-          title={commandPaletteTitle}
-          onClose={closePalette}
-          onQueryChange={setPaletteQuery}
-          onRunCommand={runPaletteCommand}
-        />
-      ) : null}
-      {enableQuickOpen ? (
-        <WorkbenchQuickOpen
-          closeLabel={quickOpenCloseLabel}
-          emptyLabel={quickOpenEmptyLabel}
-          open={quickOpenOpen}
-          placeholder={quickOpenPlaceholder}
-          providers={resolvedQuickOpenProviders}
-          query={quickOpenQuery}
-          title={quickOpenTitle}
-          onClose={closeQuickOpen}
-          onQueryChange={setQuickOpenQuery}
-          onSelectItem={runQuickOpenItem}
-        />
-      ) : null}
-    </>
+    typeof Element !== 'undefined' &&
+    target instanceof Element &&
+    target.closest('[data-workbench-shortcut-capture-recording="true"]') !== null
   );
 }

package/src/workbench/keybinding-bridge.ts

@@ -1,32 +1,21 @@
-import type { ContextKeyValue, KeybindingRegistry } from '@workbench-kit/platform';
-import { resolveKeybindingWithOverrides, type KeybindingDefinition } from '@workbench-kit/platform';
-
-function normalizeKeyToken(token: string): string {
-  const key = token.trim().toLowerCase();
-  if (key === 'del') return 'delete';
-  if (key === 'esc') return 'escape';
-  if (key === 'return') return 'enter';
-  if (key === 'spacebar' || key === 'space') return 'space';
-  return key.length === 1 ? key : key;
-}
+import {
+  evaluateWhenClause,
+  normalizeWorkbenchShortcutCandidates,
+  normalizeWorkbenchShortcutFromEvent,
+  resolveWorkbenchShortcutPlatform,
+  workbenchShortcutsOverlap,
+  type ContextKeyValue,
+  type KeybindingDefinition,
+  type KeybindingMatch,
+  type KeybindingRegistry,
+  type WorkbenchShortcutPlatform,
+} from '@workbench-kit/platform';
 
 export function normalizeKeybindingKeyFromEvent(
   event: Pick<KeyboardEvent, 'altKey' | 'ctrlKey' | 'key' | 'metaKey' | 'shiftKey'>,
+  platform: WorkbenchShortcutPlatform = resolveWorkbenchShortcutPlatform(),
 ): string {
-  const parts: string[] = [];
-
-  if (event.ctrlKey || event.metaKey) {
-    parts.push('ctrl');
-  }
-  if (event.altKey) {
-    parts.push('alt');
-  }
-  if (event.shiftKey) {
-    parts.push('shift');
-  }
-
-  parts.push(normalizeKeyToken(event.key));
-  return parts.join('+');
+  return normalizeWorkbenchShortcutFromEvent(event, platform) ?? '';
 }
 
 export function resolveExtensionKeybindingCommand(
@@ -34,21 +23,78 @@ export function resolveExtensionKeybindingCommand(
   event: Pick<KeyboardEvent, 'altKey' | 'ctrlKey' | 'key' | 'metaKey' | 'shiftKey'>,
   contextKeys: Readonly<Record<string, ContextKeyValue>> = {},
   overrides: readonly KeybindingDefinition[] = [],
-) {
-  const key = normalizeKeybindingKeyFromEvent(event);
+  platform: WorkbenchShortcutPlatform = resolveWorkbenchShortcutPlatform(),
+  excludedCommandIds: ReadonlySet<string> = new Set(),
+): KeybindingMatch | undefined {
+  const key = normalizeKeybindingKeyFromEvent(event, platform);
+  if (!key) return undefined;
 
-  if (overrides.length > 0) {
-    const match = resolveKeybindingWithOverrides(
-      registry.getKeybindings(),
-      overrides,
+  const defaults = registry
+    .getKeybindings()
+    .filter(
+      (binding) =>
+        !excludedCommandIds.has(binding.command) &&
+        normalizeExtensionKeybindingCandidates(binding.key, platform, true).length > 0,
+    );
+  const ownedCommandIds = new Set(defaults.map((binding) => binding.command));
+  const ownedOverrides = overrides.filter((binding) => ownedCommandIds.has(binding.command));
+  const overriddenCommands = new Set(ownedOverrides.map((binding) => binding.command));
+  const userMatches = ownedOverrides.filter((binding) =>
+    bindingMatchesEvent(
+      binding,
       key,
       contextKeys,
-    );
-    if (match) {
-      return match;
-    }
-  }
+      platform,
+      binding.when !== undefined || (binding.args?.length ?? 0) > 0,
+    ),
+  );
+  const defaultMatches = defaults.filter(
+    (binding) =>
+      !overriddenCommands.has(binding.command) &&
+      bindingMatchesEvent(binding, key, contextKeys, platform, true),
+  );
+
+  return [...userMatches, ...defaultMatches]
+    .map((binding) => ({
+      ...binding,
+      specificity: binding.when ? binding.when.length : 0,
+    }))
+    .sort((left, right) => right.specificity - left.specificity)[0];
+}
 
-  const matches = registry.resolveKeybindings(key, contextKeys);
-  return matches[0];
+function bindingMatchesEvent(
+  binding: KeybindingDefinition,
+  eventKey: string,
+  contextKeys: Readonly<Record<string, ContextKeyValue>>,
+  platform: WorkbenchShortcutPlatform,
+  preserveLegacyMacPrimaryCompatibility: boolean,
+): boolean {
+  return (
+    (workbenchShortcutsOverlap(binding.key, eventKey, platform) ||
+      normalizeExtensionKeybindingCandidates(
+        binding.key,
+        platform,
+        preserveLegacyMacPrimaryCompatibility,
+      ).some((candidate) => workbenchShortcutsOverlap(candidate, eventKey, platform))) &&
+    evaluateWhenClause(binding.when, contextKeys)
+  );
+}
+
+export function normalizeExtensionKeybindingCandidates(
+  shortcut: string,
+  platform: WorkbenchShortcutPlatform,
+  preserveLegacyMacPrimaryCompatibility = false,
+): readonly string[] {
+  return normalizeWorkbenchShortcutCandidates(shortcut, platform).flatMap((candidate) => {
+    const tokens = candidate.split('+');
+    if (
+      !preserveLegacyMacPrimaryCompatibility ||
+      platform !== 'mac' ||
+      !tokens.includes('ctrl') ||
+      tokens.includes('meta')
+    ) {
+      return [candidate];
+    }
+    return [candidate, tokens.map((token) => (token === 'ctrl' ? 'meta' : token)).join('+')];
+  });
 }

package/src/workbench/shell-command-registration.ts

@@ -1,4 +1,8 @@
-import type { CommandDefinition, CommandRegistry } from '@workbench-kit/platform';
+import {
+  resolveCommandValue,
+  type CommandDefinition,
+  type CommandRegistry,
+} from '@workbench-kit/platform';
 import type { WorkbenchShellCommandContext } from '@workbench-kit/react/workbench';
 
 export interface WorkbenchShellCommandRegistration {
@@ -14,16 +18,34 @@ export function registerWorkbenchShellCommandHandlers(
     const handler = () => {
       command.run?.(getContext());
     };
+    const isEnabled = command.isEnabled
+      ? () => command.isEnabled?.(getContext()) ?? true
+      : undefined;
+    const run = () => {
+      command.run?.(getContext());
+    };
+    const shortcut = resolveCommandValue(command.shortcut, getContext());
     const existing = registry.getCommand(command.id);
 
     if (existing) {
       const previousHandler = existing.handler;
+      const previousIsEnabled = existing.isEnabled;
+      const previousRun = existing.run;
+      const previousShortcut = existing.shortcut;
       existing.handler = handler;
+      existing.isEnabled = isEnabled;
+      existing.run = run;
+      existing.shortcut = shortcut;
+      registry.notifyCommandChanged(command.id);
 
       return {
         dispose() {
-          if (existing.handler === handler) {
+          if (registry.getCommand(command.id) === existing && existing.handler === handler) {
             existing.handler = previousHandler;
+            existing.isEnabled = previousIsEnabled;
+            existing.run = previousRun;
+            existing.shortcut = previousShortcut;
+            registry.notifyCommandChanged(command.id);
           }
         },
       };
@@ -34,6 +56,9 @@ export function registerWorkbenchShellCommandHandlers(
       handler,
       icon: resolveStaticCommandIcon(command),
       id: command.id,
+      isEnabled,
+      run,
+      shortcut,
       title: resolveStaticCommandTitle(command),
     });
   });