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

package/src/json-form-source-patch.ts

@@ -0,0 +1,323 @@
+export type JsonFormPath = readonly (string | number)[];
+
+export interface JsonTextRange {
+  readonly end: number;
+  readonly start: number;
+}
+
+export function replaceJsonValueAtPath(
+  source: string,
+  path: JsonFormPath,
+  nextValue: unknown,
+): string {
+  if (path.length === 0) {
+    return JSON.stringify(nextValue);
+  }
+
+  const range = findJsonValueRangeAtPath(source, path);
+  if (!range) {
+    return fallbackSerializeJsonPathEdit(source, path, nextValue);
+  }
+
+  return `${source.slice(0, range.start)}${JSON.stringify(nextValue)}${source.slice(range.end)}`;
+}
+
+function fallbackSerializeJsonPathEdit(
+  source: string,
+  path: JsonFormPath,
+  nextValue: unknown,
+): string {
+  const parsed: unknown = JSON.parse(source);
+  const nextRecord = updateJsonPathValue(parsed, path, nextValue);
+  return JSON.stringify(nextRecord, null, detectJsonIndent(source));
+}
+
+function detectJsonIndent(source: string): number {
+  return /\n[ \t]+"/.test(source) ? 2 : 0;
+}
+
+function updateJsonPathValue(value: unknown, path: JsonFormPath, nextValue: unknown): unknown {
+  if (path.length === 0) {
+    return nextValue;
+  }
+
+  const [head, ...tail] = path;
+
+  if (Array.isArray(value) && typeof head === 'number') {
+    const nextArray = [...value];
+    nextArray[head] = updateJsonPathValue(nextArray[head], tail, nextValue);
+    return nextArray;
+  }
+
+  if (isJsonRecord(value) && typeof head === 'string') {
+    return {
+      ...value,
+      [head]: updateJsonPathValue(value[head], tail, nextValue),
+    };
+  }
+
+  return value;
+}
+
+function isJsonRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+export function findJsonValueRangeAtPath(source: string, path: JsonFormPath): JsonTextRange | null {
+  const start = skipWhitespace(source, 0);
+  if (start >= source.length) {
+    return null;
+  }
+
+  return locateJsonValueRange(source, start, path, 0);
+}
+
+function locateJsonValueRange(
+  source: string,
+  index: number,
+  path: JsonFormPath,
+  pathIndex: number,
+): JsonTextRange | null {
+  index = skipWhitespace(source, index);
+
+  if (pathIndex >= path.length) {
+    const end = scanJsonValueEnd(source, index);
+    return end < 0 ? null : { start: index, end };
+  }
+
+  const segment = path[pathIndex];
+  if (typeof segment === 'number') {
+    if (source[index] !== '[') {
+      return null;
+    }
+
+    return locateJsonValueInArray(source, index + 1, path, pathIndex, segment);
+  }
+
+  if (typeof segment === 'string') {
+    if (source[index] !== '{') {
+      return null;
+    }
+
+    return locateJsonValueInObject(source, index + 1, path, pathIndex, segment);
+  }
+
+  return null;
+}
+
+function locateJsonValueInObject(
+  source: string,
+  index: number,
+  path: JsonFormPath,
+  pathIndex: number,
+  key: string,
+): JsonTextRange | null {
+  let cursor = skipWhitespace(source, index);
+
+  while (cursor < source.length && source[cursor] !== '}') {
+    const keyRange = scanJsonStringToken(source, cursor);
+    if (!keyRange) {
+      return null;
+    }
+
+    const parsedKey = JSON.parse(source.slice(keyRange.start, keyRange.end)) as string;
+    cursor = skipWhitespace(source, keyRange.end);
+
+    if (source[cursor] !== ':') {
+      return null;
+    }
+
+    cursor = skipWhitespace(source, cursor + 1);
+
+    if (parsedKey === key) {
+      return locateJsonValueRange(source, cursor, path, pathIndex + 1);
+    }
+
+    const valueEnd = scanJsonValueEnd(source, cursor);
+    if (valueEnd < 0) {
+      return null;
+    }
+
+    cursor = skipWhitespace(source, valueEnd);
+    if (source[cursor] === ',') {
+      cursor = skipWhitespace(source, cursor + 1);
+      continue;
+    }
+
+    if (source[cursor] === '}') {
+      return null;
+    }
+
+    return null;
+  }
+
+  return null;
+}
+
+function locateJsonValueInArray(
+  source: string,
+  index: number,
+  path: JsonFormPath,
+  pathIndex: number,
+  targetIndex: number,
+): JsonTextRange | null {
+  let cursor = skipWhitespace(source, index);
+  let currentIndex = 0;
+
+  while (cursor < source.length && source[cursor] !== ']') {
+    if (currentIndex === targetIndex) {
+      return locateJsonValueRange(source, cursor, path, pathIndex + 1);
+    }
+
+    const valueEnd = scanJsonValueEnd(source, cursor);
+    if (valueEnd < 0) {
+      return null;
+    }
+
+    currentIndex += 1;
+    cursor = skipWhitespace(source, valueEnd);
+
+    if (source[cursor] === ',') {
+      cursor = skipWhitespace(source, cursor + 1);
+      continue;
+    }
+
+    if (source[cursor] === ']') {
+      return null;
+    }
+
+    return null;
+  }
+
+  return null;
+}
+
+function scanJsonValueEnd(source: string, index: number): number {
+  index = skipWhitespace(source, index);
+  if (index >= source.length) {
+    return -1;
+  }
+
+  const char = source[index];
+
+  if (char === '"') {
+    const stringToken = scanJsonStringToken(source, index);
+    return stringToken?.end ?? -1;
+  }
+
+  if (char === '{') {
+    return scanJsonContainerEnd(source, index, '{', '}');
+  }
+
+  if (char === '[') {
+    return scanJsonContainerEnd(source, index, '[', ']');
+  }
+
+  if (source.startsWith('true', index)) {
+    return index + 4;
+  }
+
+  if (source.startsWith('false', index)) {
+    return index + 5;
+  }
+
+  if (source.startsWith('null', index)) {
+    return index + 4;
+  }
+
+  let cursor = index;
+  while (cursor < source.length && !',]} \t\r\n'.includes(source[cursor] ?? '')) {
+    cursor += 1;
+  }
+
+  return cursor > index ? cursor : -1;
+}
+
+function scanJsonContainerEnd(
+  source: string,
+  index: number,
+  openChar: '{' | '[',
+  closeChar: '}' | ']',
+): number {
+  let depth = 0;
+  let cursor = index;
+  let inString = false;
+  let escaped = false;
+
+  while (cursor < source.length) {
+    const char = source[cursor];
+
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === '\\') {
+        escaped = true;
+      } else if (char === '"') {
+        inString = false;
+      }
+
+      cursor += 1;
+      continue;
+    }
+
+    if (char === '"') {
+      inString = true;
+      cursor += 1;
+      continue;
+    }
+
+    if (char === openChar) {
+      depth += 1;
+    } else if (char === closeChar) {
+      depth -= 1;
+      if (depth === 0) {
+        return cursor + 1;
+      }
+    }
+
+    cursor += 1;
+  }
+
+  return -1;
+}
+
+function scanJsonStringToken(source: string, index: number): JsonTextRange | null {
+  if (source[index] !== '"') {
+    return null;
+  }
+
+  let cursor = index + 1;
+  let escaped = false;
+
+  while (cursor < source.length) {
+    const char = source[cursor];
+
+    if (escaped) {
+      escaped = false;
+      cursor += 1;
+      continue;
+    }
+
+    if (char === '\\') {
+      escaped = true;
+      cursor += 1;
+      continue;
+    }
+
+    if (char === '"') {
+      return { start: index, end: cursor + 1 };
+    }
+
+    cursor += 1;
+  }
+
+  return null;
+}
+
+function skipWhitespace(source: string, index: number): number {
+  while (index < source.length && /\s/.test(source[index] ?? '')) {
+    index += 1;
+  }
+
+  return index;
+}

package/src/jsonata-transform.ts

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

package/src/keybinding-management-settings.tsx

@@ -0,0 +1,16 @@
+import { KeybindingManagementPanel } from '@workbench-kit/react/workbench/management';
+
+import { useKeybindingManagementModel } from './use-keybinding-management.js';
+
+export function WorkbenchKeybindingManagementSettings() {
+  const { entries, overrideCount, resetKeybinding, setKeybinding } = useKeybindingManagementModel();
+
+  return (
+    <KeybindingManagementPanel
+      entries={entries}
+      summaryLabel={`${entries.length} command${entries.length === 1 ? '' : 's'} · ${overrideCount} user override${overrideCount === 1 ? '' : 's'}`}
+      onResetKeybinding={resetKeybinding}
+      onSetKeybinding={setKeybinding}
+    />
+  );
+}

package/src/keybinding-overrides-storage.ts

@@ -0,0 +1,57 @@
+import {
+  parseWorkbenchKeybindingsConfig,
+  type WorkbenchKeybindingDefinition,
+} from '@workbench-kit/workbench-config';
+import type { WorkbenchStorageReader, WorkbenchStorageWriter } from '@workbench-kit/workbench-core';
+
+export const DEFAULT_WORKBENCH_KEYBINDING_STORAGE_KEY = 'workbench-kit/.workbench/keybindings';
+
+export function isWorkbenchKeybindingPersistenceAvailable(): boolean {
+  try {
+    return typeof globalThis.localStorage !== 'undefined';
+  } catch {
+    return false;
+  }
+}
+
+export function readPersistedKeybindingOverrides(
+  storageKey = DEFAULT_WORKBENCH_KEYBINDING_STORAGE_KEY,
+  storage?: WorkbenchStorageReader,
+): readonly WorkbenchKeybindingDefinition[] {
+  const resolvedStorage = storage ?? getBrowserLocalStorage();
+  if (!resolvedStorage) {
+    return [];
+  }
+
+  try {
+    const raw = resolvedStorage.getItem(storageKey);
+    if (!raw) {
+      return [];
+    }
+
+    return parseWorkbenchKeybindingsConfig(JSON.parse(raw) as unknown);
+  } catch {
+    return [];
+  }
+}
+
+export function writePersistedKeybindingOverrides(
+  overrides: readonly WorkbenchKeybindingDefinition[],
+  storageKey = DEFAULT_WORKBENCH_KEYBINDING_STORAGE_KEY,
+  storage?: WorkbenchStorageWriter,
+): void {
+  const resolvedStorage = storage ?? getBrowserLocalStorage();
+  if (!resolvedStorage) {
+    return;
+  }
+
+  resolvedStorage.setItem(storageKey, JSON.stringify(overrides, null, 2));
+}
+
+function getBrowserLocalStorage(): (WorkbenchStorageReader & WorkbenchStorageWriter) | undefined {
+  try {
+    return globalThis.localStorage;
+  } catch {
+    return undefined;
+  }
+}

package/src/management-palette-commands.ts

@@ -0,0 +1,38 @@
+import type { WorkbenchCommandDescriptor } from '@workbench-kit/react/workbench';
+
+import {
+  MANAGE_ACCOUNTS_COMMAND_ID,
+  MANAGE_COMMANDS_COMMAND_ID,
+  MANAGE_EXTENSIONS_COMMAND_ID,
+  MANAGE_KEYBINDINGS_COMMAND_ID,
+} from './management-settings-ids.js';
+
+/** Pure helper — kept out of React component modules for Fast Refresh. */
+export function createWorkbenchManagementPaletteCommands(): readonly WorkbenchCommandDescriptor[] {
+  return [
+    {
+      category: 'Workbench',
+      icon: 'codicon-terminal',
+      id: MANAGE_COMMANDS_COMMAND_ID,
+      label: 'Manage Commands',
+    },
+    {
+      category: 'Workbench',
+      icon: 'codicon-keyboard',
+      id: MANAGE_KEYBINDINGS_COMMAND_ID,
+      label: 'Keyboard Shortcuts',
+    },
+    {
+      category: 'Workbench',
+      icon: 'codicon-extensions',
+      id: MANAGE_EXTENSIONS_COMMAND_ID,
+      label: 'Extensions',
+    },
+    {
+      category: 'Accounts',
+      icon: 'codicon-account',
+      id: MANAGE_ACCOUNTS_COMMAND_ID,
+      label: 'Manage Linked Accounts',
+    },
+  ];
+}

package/src/management-settings-ids.ts

@@ -0,0 +1,12 @@
+export const WORKBENCH_COMMANDS_SETTINGS_CATEGORY_ID =
+  'workbench-kit.shell.command-management' as const;
+export const WORKBENCH_KEYBINDINGS_SETTINGS_CATEGORY_ID =
+  'workbench-kit.shell.keybinding-management' as const;
+export const WORKBENCH_ACCOUNTS_SETTINGS_CATEGORY_ID =
+  'workbench-kit.shell.account-management' as const;
+export const WORKBENCH_EXTENSIONS_SETTINGS_CATEGORY_ID =
+  'workbench-kit.shell.extension-management' as const;
+export const MANAGE_COMMANDS_COMMAND_ID = 'workbench-kit.shell.commands.manage' as const;
+export const MANAGE_KEYBINDINGS_COMMAND_ID = 'workbench-kit.shell.keybindings.manage' as const;
+export const MANAGE_EXTENSIONS_COMMAND_ID = 'workbench-kit.shell.extensions.manage' as const;
+export const MANAGE_ACCOUNTS_COMMAND_ID = 'workbench-kit.builtin.accounts.manage' as const;

package/src/management-settings.tsx

@@ -0,0 +1,75 @@
+import {
+  AccountManagementPanel,
+  CommandManagementPanel,
+  ExtensionManagementPanel,
+  type AccountManagementEntry,
+} from '@workbench-kit/react/workbench/management';
+
+import { useCommandManagementModel } from './use-command-management.js';
+import { useExtensionManagementModel } from './use-extension-management.js';
+import { WorkbenchKeybindingManagementSettings } from './keybinding-management-settings.js';
+
+export { WorkbenchKeybindingManagementSettings };
+
+export interface WorkbenchAccountManagementInput {
+  accounts: readonly AccountManagementEntry[];
+  activeAccountId?: string | undefined;
+  automationHint?: string | undefined;
+  emptyLabel?: string | undefined;
+  onSignOut?: ((accountId: string) => void) | undefined;
+  sessionLabel?: string | undefined;
+}
+
+/** Component-only module so Vite Fast Refresh can accept this boundary. */
+export function WorkbenchCommandManagementSettings() {
+  const { groups, lastRun, runCommand, totalCount } = useCommandManagementModel();
+
+  return (
+    <CommandManagementPanel
+      groups={groups}
+      lastRun={lastRun}
+      summaryLabel={`${totalCount} registered command${totalCount === 1 ? '' : 's'} · auto-updated from extensions`}
+      onRunCommand={runCommand}
+    />
+  );
+}
+
+export function WorkbenchExtensionManagementSettings({
+  catalogUrl,
+}: {
+  catalogUrl?: string | undefined;
+}) {
+  const {
+    browseEntries,
+    catalogError,
+    catalogLoading,
+    installCatalogEntry,
+    installedEntries,
+    toggleInstalledEntry,
+  } = useExtensionManagementModel({ catalogUrl });
+
+  return (
+    <ExtensionManagementPanel
+      browseEntries={browseEntries}
+      catalogError={catalogError}
+      catalogLoading={catalogLoading}
+      installedEntries={installedEntries}
+      onInstall={installCatalogEntry}
+      onToggleEnabled={toggleInstalledEntry}
+    />
+  );
+}
+
+export function WorkbenchAccountManagementSettings({
+  accountManagement,
+}: {
+  accountManagement: WorkbenchAccountManagementInput;
+}) {
+  return (
+    <AccountManagementPanel
+      automationHint="Linked accounts are project integrations exposed by extensions or host providers. Your Workbench service profile is managed from the profile menu."
+      emptyLabel="No linked project accounts are configured."
+      {...accountManagement}
+    />
+  );
+}

package/src/preference-settings-storage.ts

@@ -0,0 +1,58 @@
+import {
+  parseWorkbenchSettingsConfig,
+  type WorkbenchSettingsConfig,
+} from '@workbench-kit/workbench-config';
+import type { WorkbenchStorageReader, WorkbenchStorageWriter } from '@workbench-kit/workbench-core';
+
+export const DEFAULT_WORKBENCH_LOCAL_PREFERENCE_STORAGE_KEY =
+  'workbench-kit/.workbench/settings.local';
+
+export function isWorkbenchLocalPreferencePersistenceAvailable(): boolean {
+  try {
+    return typeof globalThis.localStorage !== 'undefined';
+  } catch {
+    return false;
+  }
+}
+
+export function readPersistedLocalPreferences(
+  storageKey = DEFAULT_WORKBENCH_LOCAL_PREFERENCE_STORAGE_KEY,
+  storage?: WorkbenchStorageReader,
+): WorkbenchSettingsConfig {
+  const resolvedStorage = storage ?? getBrowserLocalStorage();
+  if (!resolvedStorage) {
+    return {};
+  }
+
+  try {
+    const raw = resolvedStorage.getItem(storageKey);
+    if (!raw) {
+      return {};
+    }
+
+    return parseWorkbenchSettingsConfig(JSON.parse(raw) as unknown);
+  } catch {
+    return {};
+  }
+}
+
+export function writePersistedLocalPreferences(
+  values: WorkbenchSettingsConfig,
+  storageKey = DEFAULT_WORKBENCH_LOCAL_PREFERENCE_STORAGE_KEY,
+  storage?: WorkbenchStorageWriter,
+): void {
+  const resolvedStorage = storage ?? getBrowserLocalStorage();
+  if (!resolvedStorage) {
+    return;
+  }
+
+  resolvedStorage.setItem(storageKey, JSON.stringify(values, null, 2));
+}
+
+function getBrowserLocalStorage(): (WorkbenchStorageReader & WorkbenchStorageWriter) | undefined {
+  try {
+    return globalThis.localStorage;
+  } catch {
+    return undefined;
+  }
+}