@workbench-kit/shell-react 0.0.2-prototype.0.2.33 → 0.0.2-prototype.0.2.35

package/src/management/use-command-management.ts

@@ -1,5 +1,5 @@
 import { useEffect, useMemo, useReducer, useState } from 'react';
-import type { ExtensionCommandFeatureSpec, ExtensionRegistry } from '@workbench-kit/workbench-core';
+import type { ExtensionCommandFeatureSpec } from '@workbench-kit/workbench-core';
 import {
   buildCommandManagementGroups,
   countCommandManagementEntries,
@@ -8,14 +8,15 @@ import {
 import { createWorkbenchShellCommands } from '@workbench-kit/react/workbench';
 
 import { useContextKeyRevision } from '../commands/use-context-key-revision.js';
-import { useWorkbench } from '../shell/provider.js';
+import { useWorkbench, type WorkbenchContextValue } from '../shell/provider.js';
 import {
   collectExtensionCommandFeaturesById,
   resolveShellCommandActivities,
 } from '../workbench/command-palette.js';
 
 export function useCommandManagementModel() {
-  const { contextKeyService, executeCommand, extensionRegistry } = useWorkbench();
+  const workbench = useWorkbench();
+  const { commands, contextKeyService, executeCommand } = workbench;
   const contextKeyRevision = useContextKeyRevision(contextKeyService);
   const contextKeySnapshot = useMemo(
     () => contextKeyService.createSnapshot(),
@@ -25,18 +26,18 @@ export function useCommandManagementModel() {
   const [refreshToken, refreshRegistry] = useReducer((count: number) => count + 1, 0);
 
   useEffect(() => {
-    const commandDisposable = extensionRegistry.commands.onDidChangeCommands(() => {
+    const commandDisposable = commands.onDidChangeCommands(() => {
       refreshRegistry();
     });
 
     return () => {
       commandDisposable.dispose();
     };
-  }, [extensionRegistry]);
+  }, [commands]);
 
   const groups = useMemo(
-    () => buildCommandManagementModelGroups(extensionRegistry, refreshToken, contextKeySnapshot),
-    [contextKeySnapshot, extensionRegistry, refreshToken],
+    () => buildCommandManagementModelGroups(workbench, refreshToken, contextKeySnapshot),
+    [contextKeySnapshot, refreshToken, workbench],
   );
 
   const totalCount = countCommandManagementEntries(groups);
@@ -75,12 +76,12 @@ export function useCommandManagementModel() {
 }
 
 export function buildCommandManagementModelGroups(
-  extensionRegistry: ExtensionRegistry,
+  access: CommandManagementAccess,
   _refreshToken = 0,
   contextKeys?: object | undefined,
 ) {
   const managedShellCommands = createWorkbenchShellCommands({
-    activities: resolveShellCommandActivities(extensionRegistry),
+    activities: resolveShellCommandActivities(access),
     includeSettings: true,
     includeSidebarToggle: true,
   });
@@ -89,26 +90,25 @@ export function buildCommandManagementModelGroups(
     contextKeys === undefined
       ? managedShellCommands
       : createWorkbenchShellCommands({
-          activities: resolveShellCommandActivities(extensionRegistry, contextKeys),
+          activities: resolveShellCommandActivities(access, contextKeys),
           includeSettings: true,
           includeSidebarToggle: true,
         });
-  const commandFeaturesById = collectExtensionCommandFeaturesById(extensionRegistry);
+  const commandFeaturesById = collectExtensionCommandFeaturesById(
+    access.extensionCatalog.getFeatureSpecs(),
+  );
 
   return buildCommandManagementGroups({
     extensionCommands: collectExtensionCommandEntries(
-      extensionRegistry,
+      access,
       managedShellCommandIds,
       commandFeaturesById,
     ),
-    keybindingsByCommandId: collectKeybindingsByCommandId(extensionRegistry),
-    menuSurfacesByCommandId: collectMenuSurfacesByCommandId(extensionRegistry),
+    keybindingsByCommandId: collectKeybindingsByCommandId(access),
+    menuSurfacesByCommandId: collectMenuSurfacesByCommandId(access),
     shellCommands: shellCommands.map((command) => ({
       category: command.category ?? 'Workbench',
-      handler:
-        extensionRegistry.commands.getCommand(command.id)?.handler ??
-        command.handler ??
-        command.run,
+      handler: access.commands.getCommand(command.id)?.handler ?? command.handler ?? command.run,
       id: command.id,
       label: typeof command.label === 'string' ? command.label : (command.title ?? command.id),
     })),
@@ -116,7 +116,7 @@ export function buildCommandManagementModelGroups(
 }
 
 function collectExtensionCommandEntries(
-  extensionRegistry: ExtensionRegistry,
+  access: CommandManagementAccess,
   skippedCommandIds: ReadonlySet<string>,
   commandFeaturesById: ReadonlyMap<string, ExtensionCommandFeatureSpec>,
 ) {
@@ -131,11 +131,11 @@ function collectExtensionCommandEntries(
   }> = [];
   const seen = new Set<string>();
 
-  for (const feature of extensionRegistry.getFeatureSpecs()) {
+  for (const feature of access.extensionCatalog.getFeatureSpecs()) {
     const extensionLabel = feature.displayName;
 
     for (const contribution of feature.commands) {
-      const command = extensionRegistry.commands.getCommand(contribution.id);
+      const command = access.commands.getCommand(contribution.id);
       if (!command || seen.has(contribution.id) || skippedCommandIds.has(contribution.id)) {
         continue;
       }
@@ -153,7 +153,7 @@ function collectExtensionCommandEntries(
     }
   }
 
-  for (const command of extensionRegistry.commands.getCommands()) {
+  for (const command of access.commands.getCommands()) {
     if (seen.has(command.id) || skippedCommandIds.has(command.id)) {
       continue;
     }
@@ -172,10 +172,10 @@ function collectExtensionCommandEntries(
   return entries;
 }
 
-function collectKeybindingsByCommandId(extensionRegistry: ExtensionRegistry) {
+function collectKeybindingsByCommandId(access: CommandManagementAccess) {
   const keybindingsByCommandId: Record<string, string> = {};
 
-  for (const keybinding of extensionRegistry.keybindings.getKeybindings()) {
+  for (const keybinding of access.keybindings.getKeybindings()) {
     if (!keybindingsByCommandId[keybinding.command]) {
       keybindingsByCommandId[keybinding.command] = keybinding.key;
     }
@@ -184,10 +184,10 @@ function collectKeybindingsByCommandId(extensionRegistry: ExtensionRegistry) {
   return keybindingsByCommandId;
 }
 
-function collectMenuSurfacesByCommandId(extensionRegistry: ExtensionRegistry) {
+function collectMenuSurfacesByCommandId(access: CommandManagementAccess) {
   const menuSurfacesByCommandId = new Map<string, Set<string>>();
 
-  for (const menuItem of extensionRegistry.menus.getMenuItems()) {
+  for (const menuItem of access.menus.getMenuItems()) {
     if (!menuItem.menu || !menuItem.command) {
       continue;
     }
@@ -204,3 +204,8 @@ function collectMenuSurfacesByCommandId(extensionRegistry: ExtensionRegistry) {
     ]),
   );
 }
+
+type CommandManagementAccess = Pick<
+  WorkbenchContextValue,
+  'activities' | 'commands' | 'extensionCatalog' | 'keybindings' | 'menus' | 'views'
+>;

package/src/management/use-keybinding-management.ts

@@ -1,32 +1,40 @@
 import { useMemo } from 'react';
 import { buildKeybindingManagementEntries } from '@workbench-kit/platform';
 import { createWorkbenchShellCommands } from '@workbench-kit/react/workbench';
-import type { ExtensionRegistry } from '@workbench-kit/workbench-core';
 
-import { useWorkbench } from '../shell/provider.js';
+import { useWorkbench, type WorkbenchContextValue } from '../shell/provider.js';
 import { resolveShellCommandActivities } from '../workbench/command-palette.js';
 
 export function useKeybindingManagementModel() {
   const {
-    extensionRegistry,
+    activities,
+    commands,
+    extensionCatalog,
+    keybindings,
     keybindingOverrides,
     resetCommandKeybindingOverride,
     setCommandKeybindingOverride,
+    views,
   } = useWorkbench();
 
   const defaults = useMemo(
-    () => extensionRegistry.keybindings.getKeybindings(),
-    [extensionRegistry, keybindingOverrides.length],
+    () => keybindings.getKeybindings(),
+    [keybindingOverrides.length, keybindings],
   );
 
   const entries = useMemo(
     () =>
       buildKeybindingManagementEntries({
-        commands: collectKeybindingManagementCommands(extensionRegistry),
+        commands: collectKeybindingManagementCommands({
+          activities,
+          commands,
+          extensionCatalog,
+          views,
+        }),
         defaults,
         overrides: keybindingOverrides,
       }),
-    [defaults, extensionRegistry, keybindingOverrides],
+    [activities, commands, defaults, extensionCatalog, keybindingOverrides, views],
   );
 
   const overrideCount = keybindingOverrides.length;
@@ -49,7 +57,7 @@ export function useKeybindingManagementModel() {
   };
 }
 
-function collectKeybindingManagementCommands(extensionRegistry: ExtensionRegistry) {
+function collectKeybindingManagementCommands(access: KeybindingManagementAccess) {
   const commands: Array<{
     category?: string | undefined;
     id: string;
@@ -58,17 +66,17 @@ function collectKeybindingManagementCommands(extensionRegistry: ExtensionRegistr
   }> = [];
   const seen = new Set<string>();
   const shellCommands = createWorkbenchShellCommands({
-    activities: resolveShellCommandActivities(extensionRegistry),
+    activities: resolveShellCommandActivities(access),
     includeSettings: true,
     includeSidebarToggle: true,
   });
   const shellCommandIds = new Set(shellCommands.map((command) => command.id));
 
-  for (const extension of extensionRegistry.getExtensions()) {
+  for (const extension of access.extensionCatalog.getExtensions()) {
     const extensionLabel = extension.manifest.displayName ?? extension.manifest.id;
 
     for (const contribution of extension.manifest.contributes?.commands ?? []) {
-      const command = extensionRegistry.commands.getCommand(contribution.command);
+      const command = access.commands.getCommand(contribution.command);
       if (!command || seen.has(contribution.command) || shellCommandIds.has(contribution.command)) {
         continue;
       }
@@ -83,7 +91,7 @@ function collectKeybindingManagementCommands(extensionRegistry: ExtensionRegistr
     }
   }
 
-  for (const command of extensionRegistry.commands.getCommands()) {
+  for (const command of access.commands.getCommands()) {
     if (seen.has(command.id) || shellCommandIds.has(command.id)) {
       continue;
     }
@@ -119,3 +127,8 @@ function collectKeybindingManagementCommands(extensionRegistry: ExtensionRegistr
 
   return commands;
 }
+
+type KeybindingManagementAccess = Pick<
+  WorkbenchContextValue,
+  'activities' | 'commands' | 'extensionCatalog' | 'views'
+>;

package/src/shell/focused-extension-services.ts

@@ -0,0 +1,138 @@
+import {
+  WORKBENCH_SETTINGS_CAPABILITY_ID,
+  type ExtensionDependencyDiagnostic,
+  type ExtensionFeatureInspection,
+  type ExtensionFeatureSpec,
+  type WorkbenchExtensionDescription,
+  type WorkbenchSettingsCapability,
+} from '@workbench-kit/workbench-core';
+
+interface DisposableLike {
+  dispose(): void;
+}
+
+interface ExtensionActivationRegistry {
+  activateView(viewId: string): Promise<readonly { readonly extensionId: string }[]>;
+  getActiveExtensions(): readonly { readonly extensionId: string }[];
+  onDidActivateExtension(listener: () => void): DisposableLike;
+  onDidDeactivateExtension(listener: () => void): DisposableLike;
+}
+
+interface ExtensionCatalogRegistry {
+  readonly capabilityRegistry: {
+    listProviderIds(): readonly string[];
+  };
+  getDependencyDiagnostics(): readonly ExtensionDependencyDiagnostic[];
+  getExtension(extensionId: string): WorkbenchExtensionDescription | undefined;
+  getExtensions(): readonly WorkbenchExtensionDescription[];
+  getFeatureInspections(): readonly ExtensionFeatureInspection[];
+  getFeatureSpecs(): readonly ExtensionFeatureSpec[];
+}
+
+interface SettingsCapabilityRegistry {
+  has(capabilityId: string): boolean;
+  register(registration: {
+    readonly get: () => WorkbenchSettingsCapability;
+    readonly id: string;
+  }): DisposableLike;
+}
+
+export interface WorkbenchExtensionActivationAccess {
+  activateView(viewId: string): Promise<readonly { readonly extensionId: string }[]>;
+  onDidActivateExtension(listener: () => void): DisposableLike;
+  waitForStartup(): Promise<void>;
+}
+
+export interface WorkbenchExtensionActivationStateReader {
+  getActiveExtensions(): readonly { readonly extensionId: string }[];
+  onDidChangeActiveExtensions(listener: () => void): DisposableLike;
+}
+
+export interface WorkbenchExtensionCatalogReader {
+  getDependencyDiagnostics(): readonly ExtensionDependencyDiagnostic[];
+  getExtension(extensionId: string): WorkbenchExtensionDescription | undefined;
+  getExtensions(): readonly WorkbenchExtensionDescription[];
+  getFeatureInspections(): readonly ExtensionFeatureInspection[];
+  getFeatureSpecs(): readonly ExtensionFeatureSpec[];
+  listCapabilityProviderIds(): readonly string[];
+}
+
+export type WorkbenchSettingsCapabilityPublication =
+  | { readonly kind: 'already-registered' }
+  | { readonly disposable: DisposableLike; readonly kind: 'registered' };
+
+export interface WorkbenchSettingsCapabilityPublisher {
+  publishSettingsCapability(
+    capability: WorkbenchSettingsCapability,
+  ): WorkbenchSettingsCapabilityPublication;
+}
+
+export function createWorkbenchExtensionActivationAccess(
+  registry: ExtensionActivationRegistry,
+  waitForStartup: () => Promise<void>,
+): WorkbenchExtensionActivationAccess {
+  return {
+    activateView: (viewId) => registry.activateView(viewId),
+    onDidActivateExtension: (listener) => registry.onDidActivateExtension(listener),
+    waitForStartup,
+  };
+}
+
+export function createWorkbenchExtensionActivationStateReader(
+  registry: ExtensionActivationRegistry,
+): WorkbenchExtensionActivationStateReader {
+  return {
+    getActiveExtensions: () =>
+      registry.getActiveExtensions().map(({ extensionId }) => ({ extensionId })),
+    onDidChangeActiveExtensions: (listener) => {
+      const activation = registry.onDidActivateExtension(listener);
+      const deactivation = registry.onDidDeactivateExtension(listener);
+      return {
+        dispose() {
+          deactivation.dispose();
+          activation.dispose();
+        },
+      };
+    },
+  };
+}
+
+export function createWorkbenchExtensionCatalogReader(
+  registry: ExtensionCatalogRegistry,
+): WorkbenchExtensionCatalogReader {
+  return {
+    getDependencyDiagnostics: () => registry.getDependencyDiagnostics(),
+    getExtension: (extensionId) => registry.getExtension(extensionId),
+    getExtensions: () => registry.getExtensions(),
+    getFeatureInspections: () => registry.getFeatureInspections(),
+    getFeatureSpecs: () => registry.getFeatureSpecs(),
+    listCapabilityProviderIds: () => registry.capabilityRegistry.listProviderIds(),
+  };
+}
+
+export function createWorkbenchSettingsCapabilityPublisher(
+  registry: SettingsCapabilityRegistry,
+): WorkbenchSettingsCapabilityPublisher {
+  return {
+    publishSettingsCapability: (capability) => {
+      if (registry.has(WORKBENCH_SETTINGS_CAPABILITY_ID)) {
+        return { kind: 'already-registered' };
+      }
+
+      try {
+        return {
+          disposable: registry.register({
+            id: WORKBENCH_SETTINGS_CAPABILITY_ID,
+            get: () => capability,
+          }),
+          kind: 'registered',
+        };
+      } catch (error) {
+        if (registry.has(WORKBENCH_SETTINGS_CAPABILITY_ID)) {
+          return { kind: 'already-registered' };
+        }
+        throw error;
+      }
+    },
+  };
+}

package/src/shell/host-shell.tsx

@@ -59,7 +59,14 @@ export function WorkbenchHostShell({
   themePreset,
   titleBar,
 }: WorkbenchHostShellProps) {
-  const { contextKeyService, executeCommand, extensionRegistry, layoutService } = useWorkbench();
+  const {
+    activities: activityRegistry,
+    contextKeyService,
+    executeCommand,
+    layoutService,
+    statusBar,
+    views,
+  } = useWorkbench();
   const contextKeyRevision = useContextKeyRevision(contextKeyService);
   const [, forceRender] = useReducer((count: number) => count + 1, 0);
   const rerender = useCallback(() => forceRender(), []);
@@ -69,20 +76,16 @@ export function WorkbenchHostShell({
   );
   const layout = layoutService.getState();
   const activities = useMemo(
-    () =>
-      filterActivitiesByWhenClause(
-        extensionRegistry.activities.getActivities(),
-        contextKeySnapshot,
-      ),
-    [contextKeySnapshot, extensionRegistry],
+    () => filterActivitiesByWhenClause(activityRegistry.getActivities(), contextKeySnapshot),
+    [activityRegistry, contextKeySnapshot],
   );
   const activityItems = filterActivityBarItems(
     sortActivityBarItems(
       createWorkbenchShellActivityItems({
         activeViewContainerId: layout.sideBar.activeViewContainer,
         activities,
-        viewContainers: extensionRegistry.views.getViewContainers('activitybar'),
-        views: extensionRegistry.views.getViews(),
+        viewContainers: views.getViewContainers('activitybar'),
+        views: views.getViews(),
       }),
       layout.activityBar.itemOrder,
     ),
@@ -136,7 +139,7 @@ export function WorkbenchHostShell({
       }
       compactStatus={compactStatus}
       onStatusItemActivate={(item) => {
-        const contributed = extensionRegistry.statusBar.getStatusBarItem(item.id);
+        const contributed = statusBar.getStatusBarItem(item.id);
         if (contributed?.command) {
           void executeCommand(contributed.command).catch(() => undefined);
           return;

package/src/shell/persistence-diagnostic-context.ts

@@ -0,0 +1,11 @@
+import { createContext, useContext } from 'react';
+import type { WorkbenchPersistenceDiagnosticHandler } from '@workbench-kit/workbench-core';
+
+export const WorkbenchPersistenceDiagnosticContext = createContext<
+  WorkbenchPersistenceDiagnosticHandler | undefined
+>(undefined);
+
+export function useWorkbenchPersistenceDiagnosticHandler():
+  WorkbenchPersistenceDiagnosticHandler | undefined {
+  return useContext(WorkbenchPersistenceDiagnosticContext);
+}