@workbench-kit/shell-react 0.0.2-prototype.0.2.6

package/src/workbench-startup-gate.tsx

@@ -0,0 +1,136 @@
+import { useEffect, useMemo, useRef, type ReactNode } from 'react';
+import {
+  WorkbenchBootstrapGate,
+  useWorkbenchBootstrap,
+  type WorkbenchBootstrapTaskDefinition,
+} from '@workbench-kit/react/workbench/bootstrap';
+import type { VirtualWorkspaceInitialState } from '@workbench-kit/workspace';
+import { useWorkbench } from './provider.js';
+
+export interface WorkbenchStartupGateProps {
+  children: ReactNode;
+  className?: string | undefined;
+  footer?: ReactNode;
+  heading?: string | undefined;
+  onFailed?: ((error: Error) => void) | undefined;
+  onReady?: (() => void) | undefined;
+  renderBootstrap?:
+    ((bootstrap: ReturnType<typeof useWorkbenchBootstrap>) => ReactNode) | undefined;
+  subtitle?: string | undefined;
+  tasks?: readonly WorkbenchBootstrapTaskDefinition[] | undefined;
+  workspaceInit?: VirtualWorkspaceInitialState | undefined;
+}
+
+function countWorkspaceEntries(
+  workspaceInit: VirtualWorkspaceInitialState | undefined,
+): string | undefined {
+  if (!workspaceInit) {
+    return undefined;
+  }
+
+  const fileCount = workspaceInit.files?.length ?? 0;
+  const folderCount = workspaceInit.folders?.length ?? 0;
+  const parts: string[] = [];
+
+  if (fileCount > 0) {
+    parts.push(`${fileCount} file${fileCount === 1 ? '' : 's'}`);
+  }
+
+  if (folderCount > 0) {
+    parts.push(`${folderCount} folder${folderCount === 1 ? '' : 's'}`);
+  }
+
+  return parts.length > 0 ? parts.join(', ') : undefined;
+}
+
+export function WorkbenchStartupGate({
+  children,
+  className,
+  footer,
+  heading = 'Preparing workbench',
+  onFailed,
+  onReady,
+  renderBootstrap,
+  subtitle = 'Loading extensions and preparing your workspace.',
+  tasks,
+  workspaceInit,
+}: WorkbenchStartupGateProps) {
+  const { executeCommand, missingExtensionIds, waitForExtensionStartup } = useWorkbench();
+  const bootstrap = useWorkbenchBootstrap();
+  const startedRef = useRef(false);
+  const workspaceDetail = countWorkspaceEntries(workspaceInit);
+
+  const startupTasks = useMemo<readonly WorkbenchBootstrapTaskDefinition[]>(() => {
+    if (tasks) {
+      return tasks;
+    }
+
+    const resolvedTasks: WorkbenchBootstrapTaskDefinition[] = [
+      {
+        detail:
+          missingExtensionIds.length > 0 ? `${missingExtensionIds.length} missing` : undefined,
+        id: 'extensions',
+        label: 'Loading extensions',
+        run: async () => {
+          await waitForExtensionStartup();
+        },
+      },
+    ];
+
+    if (workspaceInit) {
+      resolvedTasks.push({
+        detail: workspaceDetail,
+        id: 'workspace',
+        label: 'Preparing workspace',
+        run: async () => {
+          await executeCommand('workspace.init', workspaceInit);
+        },
+      });
+    }
+
+    return resolvedTasks;
+  }, [
+    executeCommand,
+    missingExtensionIds.length,
+    tasks,
+    waitForExtensionStartup,
+    workspaceDetail,
+    workspaceInit,
+  ]);
+
+  useEffect(() => {
+    if (startedRef.current) {
+      return;
+    }
+
+    startedRef.current = true;
+    void bootstrap.run(startupTasks).catch((error: unknown) => {
+      onFailed?.(error instanceof Error ? error : new Error('Startup failed.'));
+    });
+  }, [bootstrap, onFailed, startupTasks]);
+
+  useEffect(() => {
+    if (bootstrap.isReady) {
+      onReady?.();
+    }
+  }, [bootstrap.isReady, onReady]);
+
+  useEffect(() => {
+    if (bootstrap.status === 'failed' && bootstrap.error) {
+      onFailed?.(new Error(bootstrap.error));
+    }
+  }, [bootstrap.error, bootstrap.status, onFailed]);
+
+  return (
+    <WorkbenchBootstrapGate
+      bootstrap={bootstrap}
+      className={className}
+      footer={footer}
+      heading={heading}
+      renderBootstrap={renderBootstrap}
+      subtitle={subtitle}
+    >
+      {children}
+    </WorkbenchBootstrapGate>
+  );
+}

package/src/workbench-status-sections.ts

@@ -0,0 +1,43 @@
+import type {
+  StatusBarItemModel,
+  StatusBarSectionModel,
+} from '@workbench-kit/react/workbench/shell';
+
+export interface WorkspaceResourceStatusItemsInput {
+  fileCount: number;
+  fileItemId?: string | undefined;
+  fileTitle?: string | undefined;
+  folderCount: number;
+  folderItemId?: string | undefined;
+  folderTitle?: string | undefined;
+}
+
+export function createWorkspaceResourceStatusItems({
+  fileCount,
+  fileItemId = 'workbench.workspace.files',
+  fileTitle = 'Workspace files',
+  folderCount,
+  folderItemId = 'workbench.workspace.folders',
+  folderTitle = 'Workspace folders',
+}: WorkspaceResourceStatusItemsInput): StatusBarItemModel[] {
+  return [
+    {
+      icon: 'files',
+      id: fileItemId,
+      label: `${fileCount} files`,
+      title: fileTitle,
+    },
+    {
+      icon: 'folder',
+      id: folderItemId,
+      label: `${folderCount} folders`,
+      title: folderTitle,
+    },
+  ];
+}
+
+export function mergeWorkbenchStatusSections(
+  ...sectionGroups: ReadonlyArray<readonly StatusBarSectionModel[]>
+): StatusBarSectionModel[] {
+  return sectionGroups.flat().filter((section) => section.items.length > 0);
+}

package/src/workbench-user-commands.ts

@@ -0,0 +1,46 @@
+import type {
+  WorkbenchUserCommandAction,
+  WorkbenchUserCommandDefinition,
+} from '@workbench-kit/workbench-config';
+import type { ExtensionRegistry } from '@workbench-kit/workbench-core';
+
+export async function executeWorkbenchUserCommandAction(
+  action: WorkbenchUserCommandAction,
+  executeCommand: (commandId: string, ...args: unknown[]) => Promise<unknown>,
+): Promise<unknown> {
+  if (action.type === 'executeCommand') {
+    return executeCommand(action.command, ...(action.args !== undefined ? [action.args] : []));
+  }
+
+  let lastResult: unknown;
+  for (const step of action.steps) {
+    lastResult = await executeWorkbenchUserCommandAction(step, executeCommand);
+  }
+
+  return lastResult;
+}
+
+export function registerWorkbenchUserCommands(
+  extensionRegistry: ExtensionRegistry,
+  userCommands: readonly WorkbenchUserCommandDefinition[],
+): { dispose(): void } {
+  const disposables = userCommands.map((userCommand) =>
+    extensionRegistry.commands.registerCommand({
+      category: userCommand.category,
+      handler: () =>
+        executeWorkbenchUserCommandAction(userCommand.action, (commandId, ...args) =>
+          extensionRegistry.executeCommand(commandId, ...args),
+        ),
+      id: userCommand.command,
+      title: userCommand.title,
+    }),
+  );
+
+  return {
+    dispose() {
+      for (const disposable of disposables) {
+        disposable.dispose();
+      }
+    },
+  };
+}

package/src/workspace-view-state.ts

@@ -0,0 +1,35 @@
+import { useEffect, useState } from 'react';
+import type {
+  VirtualWorkspaceState,
+  WorkspaceChangeEvent,
+  WorkspaceResourceService,
+} from '@workbench-kit/workspace';
+
+export function isWorkspaceResourceService(value: unknown): value is WorkspaceResourceService {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    typeof (value as WorkspaceResourceService).getState === 'function' &&
+    typeof (value as WorkspaceResourceService).onDidChangeWorkspace === 'function'
+  );
+}
+
+export function useWorkspaceResourceState(
+  workspaceService: WorkspaceResourceService | undefined,
+): VirtualWorkspaceState | undefined {
+  const [state, setState] = useState(() => workspaceService?.getState());
+
+  useEffect(() => {
+    if (!workspaceService) {
+      setState(undefined);
+      return undefined;
+    }
+
+    setState(workspaceService.getState());
+    return workspaceService.onDidChangeWorkspace((event: WorkspaceChangeEvent) => {
+      setState(event.state);
+    });
+  }, [workspaceService]);
+
+  return state;
+}