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

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/use-persisted-appearance.ts

@@ -0,0 +1,33 @@
+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

@@ -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/workbench/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;
+}