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

package/src/{workbench-startup-gate.tsx → workbench/startup-gate.tsx}

@@ -1,136 +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>
-  );
-}
+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 '../shell/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 → workbench/status-sections.ts}

@@ -1,43 +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);
-}
+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/{use-persisted-workbench-appearance.ts → workbench/use-persisted-appearance.ts}

@@ -1,33 +1,33 @@
-import { useEffect, useState } from 'react';
-import type { WorkbenchStorageAdapter } from '@workbench-kit/workbench-core';
-
-import {
-  readPersistedWorkbenchAppearance,
-  writePersistedWorkbenchAppearance,
-  type WorkbenchAppearanceSettings,
-} from './workbench-appearance-storage.js';
-
-export interface UsePersistedWorkbenchAppearanceOptions {
-  persist?: boolean | undefined;
-  storage?: WorkbenchStorageAdapter | undefined;
-  storageKey?: string | undefined;
-}
-
-export function usePersistedWorkbenchAppearance(
-  options: UsePersistedWorkbenchAppearanceOptions = {},
-): [WorkbenchAppearanceSettings, (settings: WorkbenchAppearanceSettings) => void] {
-  const { persist = true, storage, storageKey } = options;
-  const [appearance, setAppearance] = useState(() =>
-    readPersistedWorkbenchAppearance(storageKey, storage),
-  );
-
-  useEffect(() => {
-    if (!persist) {
-      return;
-    }
-
-    writePersistedWorkbenchAppearance(appearance, storageKey, storage);
-  }, [appearance, persist, storage, storageKey]);
-
-  return [appearance, setAppearance];
-}
+import { useEffect, useState } from 'react';
+import type { WorkbenchStorageAdapter } from '@workbench-kit/workbench-core';
+
+import {
+  readPersistedWorkbenchAppearance,
+  writePersistedWorkbenchAppearance,
+  type WorkbenchAppearanceSettings,
+} from './appearance-storage.js';
+
+export interface UsePersistedWorkbenchAppearanceOptions {
+  persist?: boolean | undefined;
+  storage?: WorkbenchStorageAdapter | undefined;
+  storageKey?: string | undefined;
+}
+
+export function usePersistedWorkbenchAppearance(
+  options: UsePersistedWorkbenchAppearanceOptions = {},
+): [WorkbenchAppearanceSettings, (settings: WorkbenchAppearanceSettings) => void] {
+  const { persist = true, storage, storageKey } = options;
+  const [appearance, setAppearance] = useState(() =>
+    readPersistedWorkbenchAppearance(storageKey, storage),
+  );
+
+  useEffect(() => {
+    if (!persist) {
+      return;
+    }
+
+    writePersistedWorkbenchAppearance(appearance, storageKey, storage);
+  }, [appearance, persist, storage, storageKey]);
+
+  return [appearance, setAppearance];
+}

package/src/{workbench-user-commands.ts → workbench/user-commands.ts}

@@ -1,46 +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();
-      }
-    },
-  };
-}
+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 → workbench/workspace-view-state.ts}

@@ -1,35 +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;
-}
+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;
+}

package/src/jsonata-transform.ts

@@ -1,36 +0,0 @@
-import jsonata from 'jsonata';
-import type { ValueTransformDefinition } from '@workbench-kit/field-remap';
-
-/** Host-registered JSONata expression transform (Stedi-style advanced mapping). */
-export const JSONATA_TRANSFORM_ID = 'expr:jsonata' as const;
-
-export const jsonataValueTransform: ValueTransformDefinition = {
-  id: JSONATA_TRANSFORM_ID,
-  label: 'JSONata expression',
-  description: 'Evaluate a JSONata expression against the source value (host-registered).',
-  category: 'expression',
-  inputTypes: ['string', 'number', 'boolean', 'object', 'array', 'unknown'],
-  outputType: 'unknown',
-  optionFields: [
-    {
-      key: 'expression',
-      label: 'Expression',
-      kind: 'string',
-    },
-  ],
-  apply: (value, context) => {
-    const expression =
-      typeof context.options?.expression === 'string' ? context.options.expression.trim() : '';
-    if (!expression) {
-      return value;
-    }
-    try {
-      const compiled = jsonata(expression);
-      // jsonata@1.x evaluate is synchronous (2.x returns a Promise).
-      const result = compiled.evaluate(value) as unknown;
-      return result;
-    } catch {
-      return value;
-    }
-  },
-};