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

package/src/extensions/canonical-extension-descriptions.ts

@@ -0,0 +1,58 @@
+import {
+  computeWorkbenchExtensionManifestIntegrity,
+  type WorkbenchExtensionDescription,
+} from '@workbench-kit/workbench-core';
+
+export interface CanonicalExtensionDescriptionSnapshot {
+  readonly ambiguousExtensionIds: readonly string[];
+  readonly descriptions: readonly WorkbenchExtensionDescription[];
+  getDescription(extensionId: string): WorkbenchExtensionDescription | undefined;
+}
+
+export function createCanonicalExtensionDescriptionSnapshot({
+  availableExtensions,
+  liveExtensions,
+}: {
+  readonly availableExtensions: readonly WorkbenchExtensionDescription[];
+  readonly liveExtensions: readonly WorkbenchExtensionDescription[];
+}): CanonicalExtensionDescriptionSnapshot {
+  const descriptionsById = new Map<string, WorkbenchExtensionDescription>();
+  const ambiguousExtensionIds = new Set<string>();
+
+  for (const description of [...availableExtensions, ...liveExtensions]) {
+    const extensionId = description.manifest.id;
+    const existing = descriptionsById.get(extensionId);
+    if (!existing) {
+      descriptionsById.set(extensionId, description);
+      continue;
+    }
+    if (!areEquivalentDescriptions(existing, description)) {
+      ambiguousExtensionIds.add(extensionId);
+    }
+  }
+
+  const descriptions = [...descriptionsById.values()].sort((left, right) =>
+    left.manifest.id.localeCompare(right.manifest.id),
+  );
+  const ambiguousIds = [...ambiguousExtensionIds].sort((left, right) => left.localeCompare(right));
+
+  return {
+    ambiguousExtensionIds: ambiguousIds,
+    descriptions,
+    getDescription(extensionId) {
+      return ambiguousExtensionIds.has(extensionId) ? undefined : descriptionsById.get(extensionId);
+    },
+  };
+}
+
+function areEquivalentDescriptions(
+  left: WorkbenchExtensionDescription,
+  right: WorkbenchExtensionDescription,
+): boolean {
+  return (
+    left.extensionPath === right.extensionPath &&
+    left.module === right.module &&
+    computeWorkbenchExtensionManifestIntegrity(left.manifest) ===
+      computeWorkbenchExtensionManifestIntegrity(right.manifest)
+  );
+}

package/src/extensions/context-menu.ts

@@ -1,33 +1,36 @@
 import type { ContextMenuItem } from '@workbench-kit/react/overlay';
 import { commandMenuItemsToContextMenuItems } from '@workbench-kit/react/workbench/commands';
+import type { CommandRegistry } from '@workbench-kit/platform';
 import {
   resolveWorkbenchMenuContributions,
-  type ExtensionRegistry,
+  type MenuRegistry,
 } from '@workbench-kit/workbench-core';
 
 export interface ExtensionContextMenuInput {
+  readonly commands?: CommandRegistry | undefined;
   readonly contextKeys?: object | undefined;
   readonly executeCommand?: ((commandId: string) => unknown) | undefined;
-  readonly extensionRegistry?: ExtensionRegistry | undefined;
   readonly menu: string;
+  readonly menus?: MenuRegistry | undefined;
 }
 
 export function createExtensionContextMenuItems({
+  commands,
   contextKeys,
   executeCommand,
-  extensionRegistry,
   menu,
+  menus,
 }: ExtensionContextMenuInput): ContextMenuItem[] {
-  if (!extensionRegistry || !executeCommand) {
+  if (!commands || !menus || !executeCommand) {
     return [];
   }
 
   const menuItems = resolveWorkbenchMenuContributions({
-    commandRegistry: extensionRegistry.commands,
+    commandRegistry: commands,
     context: undefined,
     contextKeys,
     menu,
-    menuItems: extensionRegistry.menus.getMenuItems(menu),
+    menuItems: menus.getMenuItems(menu),
   });
 
   return commandMenuItemsToContextMenuItems([...menuItems], (commandId) => {

package/src/extensions/extension-enablement-context.ts

@@ -0,0 +1,15 @@
+import { createContext, useContext } from 'react';
+
+import type { ExtensionEnablementController } from './extension-enablement-controller.js';
+
+export const ExtensionEnablementContext = createContext<ExtensionEnablementController | undefined>(
+  undefined,
+);
+
+export function useExtensionEnablementController(): ExtensionEnablementController {
+  const controller = useContext(ExtensionEnablementContext);
+  if (!controller) {
+    throw new Error('Extension enablement must be used inside WorkbenchProvider.');
+  }
+  return controller;
+}

package/src/extensions/extension-enablement-controller.ts

@@ -0,0 +1,453 @@
+import {
+  loadInstalledExtensionsResult,
+  saveInstalledExtensionsResult,
+  type ExtensionRegistry,
+  type InstalledExtensionRecord,
+  type WorkbenchExtensionDescription,
+  type WorkbenchPersistenceDiagnosticHandler,
+  type WorkbenchStorageAdapter,
+} from '@workbench-kit/workbench-core';
+
+import type { ThemeSelectionProtectionSnapshot } from './theme-selection-protection.js';
+import { createCanonicalExtensionDescriptionSnapshot } from './canonical-extension-descriptions.js';
+import {
+  createExtensionUninstallEvaluation,
+  type ExtensionUninstallEligibility,
+} from './uninstall-eligibility.js';
+
+interface DisposableLike {
+  dispose(): void;
+}
+
+export interface ExtensionRegistrationLifetime extends DisposableLike {
+  add<T extends DisposableLike>(disposable: T): T;
+  getRegistration(extensionId: string): DisposableLike | undefined;
+}
+
+export type ExtensionEnablementTransitionResult =
+  | {
+      readonly enabled: boolean;
+      readonly extensionId: string;
+      readonly kind: 'applied';
+      readonly message: string;
+    }
+  | {
+      readonly enabled: boolean;
+      readonly extensionId: string;
+      readonly kind: 'reloadRequired';
+      readonly message: string;
+    }
+  | {
+      readonly enabled: boolean;
+      readonly extensionId: string;
+      readonly kind: 'failed';
+      readonly message: string;
+    };
+
+export type ExtensionUninstallActionResult =
+  | ExtensionEnablementTransitionResult
+  | ({ readonly extensionId: string } & Exclude<
+      ExtensionUninstallEligibility,
+      { readonly kind: 'eligible' }
+    >);
+
+export interface ExtensionEnablementControllerOptions {
+  readonly availableExtensions: readonly WorkbenchExtensionDescription[];
+  readonly initialEnabledExtensions: readonly WorkbenchExtensionDescription[];
+  readonly initialInstalledRecords: readonly InstalledExtensionRecord[];
+  readonly installedExtensionsStorage?: WorkbenchStorageAdapter | undefined;
+  readonly installedExtensionsStorageKey: string;
+  readonly integrityAcceptedExtensionIds: ReadonlySet<string>;
+  readonly onPersistenceDiagnostic?: WorkbenchPersistenceDiagnosticHandler | undefined;
+  readonly registrationLifetime: ExtensionRegistrationLifetime;
+  readonly registry: ExtensionRegistry;
+}
+
+/** Provider-owned live installed/enabled state for the narrow theme lifecycle. */
+export class ExtensionEnablementController implements DisposableLike {
+  private readonly availableExtensions: readonly WorkbenchExtensionDescription[];
+  private readonly availableExtensionsById: ReadonlyMap<string, WorkbenchExtensionDescription>;
+  private readonly integrityAcceptedExtensionIds: ReadonlySet<string>;
+  private readonly listeners = new Set<() => void>();
+  private readonly onPersistenceDiagnostic: WorkbenchPersistenceDiagnosticHandler | undefined;
+  private readonly registrationHandles = new Map<string, DisposableLike>();
+  private readonly registrationLifetime: ExtensionRegistrationLifetime;
+  private readonly registry: ExtensionRegistry;
+  private readonly storage: WorkbenchStorageAdapter | undefined;
+  private readonly storageKey: string;
+  private installedRecords: readonly InstalledExtensionRecord[];
+  private themeSelectionProtection: ThemeSelectionProtectionSnapshot | undefined;
+  private disposed = false;
+
+  constructor({
+    availableExtensions,
+    initialEnabledExtensions,
+    initialInstalledRecords,
+    installedExtensionsStorage,
+    installedExtensionsStorageKey,
+    integrityAcceptedExtensionIds,
+    onPersistenceDiagnostic,
+    registrationLifetime,
+    registry,
+  }: ExtensionEnablementControllerOptions) {
+    this.availableExtensions = [...availableExtensions];
+    this.availableExtensionsById = new Map(
+      availableExtensions.map((description) => [description.manifest.id, description]),
+    );
+    this.installedRecords = [...initialInstalledRecords];
+    this.integrityAcceptedExtensionIds = integrityAcceptedExtensionIds;
+    this.onPersistenceDiagnostic = onPersistenceDiagnostic;
+    this.registrationLifetime = registrationLifetime;
+    this.registry = registry;
+    this.storage = installedExtensionsStorage;
+    this.storageKey = installedExtensionsStorageKey;
+
+    for (const description of initialEnabledExtensions) {
+      const extensionId = description.manifest.id;
+      const registration = registrationLifetime.getRegistration(extensionId);
+      if (registration) {
+        this.registrationHandles.set(extensionId, registration);
+      }
+    }
+  }
+
+  getInstalledRecordsSnapshot = (): readonly InstalledExtensionRecord[] => this.installedRecords;
+
+  subscribeInstalledRecords = (listener: () => void): (() => void) => {
+    if (this.disposed) {
+      return () => undefined;
+    }
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  };
+
+  setThemeSelectionProtection(snapshot: ThemeSelectionProtectionSnapshot | undefined): void {
+    this.themeSelectionProtection =
+      snapshot?.kind === 'known'
+        ? { ...snapshot, protectedThemeIds: [...snapshot.protectedThemeIds] }
+        : snapshot;
+  }
+
+  commitInstalledRecords(
+    records: readonly InstalledExtensionRecord[],
+    extensionId: string,
+  ): ExtensionEnablementTransitionResult {
+    const persistence = this.persist(records);
+    if (!persistence) {
+      return this.failed(extensionId, this.isRecordEnabled(extensionId));
+    }
+
+    this.publishInstalledRecords(records);
+    return this.reloadRequired(extensionId, this.isRecordEnabled(extensionId));
+  }
+
+  uninstallInstalledExtension(extensionId: string): ExtensionUninstallActionResult {
+    const persisted = loadInstalledExtensionsResult(this.storageKey, this.storage, {
+      onDiagnostic: this.onPersistenceDiagnostic,
+    });
+    if (persisted.diagnostic) {
+      return this.failed(extensionId, this.isRecordEnabled(extensionId));
+    }
+    const canonicalDescriptions = createCanonicalExtensionDescriptionSnapshot({
+      availableExtensions: this.availableExtensions,
+      liveExtensions: this.registry.getExtensions(),
+    });
+    const eligibility = createExtensionUninstallEvaluation({
+      canonicalDescriptions,
+      installedRecords: persisted.value,
+    }).getEligibility(extensionId);
+    if (eligibility.kind !== 'eligible') {
+      return { ...eligibility, extensionId };
+    }
+
+    const target = persisted.value.find((record) => record.id === extensionId);
+    if (!target) {
+      return {
+        diagnosticExtensionIds: [extensionId],
+        extensionId,
+        kind: 'ineligibleTarget',
+        reason: 'notInstalled',
+      };
+    }
+
+    const next = persisted.value.filter((record) => record.id !== extensionId);
+    if (!this.persist(next)) {
+      return this.failed(extensionId, target.enabled);
+    }
+
+    this.publishInstalledRecords(next);
+    return this.reloadRequired(extensionId, false);
+  }
+
+  toggleInstalledExtension(
+    extensionId: string,
+    enabled: boolean,
+  ): ExtensionEnablementTransitionResult {
+    const current = this.installedRecords.find((record) => record.id === extensionId);
+    if (!current || extensionId.startsWith('workbench-kit.builtin.')) {
+      return this.failed(extensionId, current?.enabled ?? false);
+    }
+    if (current.enabled === enabled) {
+      return {
+        enabled,
+        extensionId,
+        kind: 'applied',
+        message: 'The extension is already in the requested state.',
+      };
+    }
+
+    const next = this.installedRecords.map((record) =>
+      record.id === extensionId ? { ...record, enabled } : record,
+    );
+    const eligibility = this.getSoftThemeEligibility(extensionId, enabled);
+    if (!eligibility.eligible) {
+      if (eligibility.kind === 'failed') {
+        return this.failed(extensionId, current.enabled);
+      }
+      if (!eligibility.commitRequestedState) {
+        return this.reloadRequired(extensionId, current.enabled);
+      }
+      if (!this.persist(next)) {
+        return this.failed(extensionId, current.enabled);
+      }
+      this.publishInstalledRecords(next);
+      return this.reloadRequired(extensionId, enabled);
+    }
+
+    return enabled
+      ? this.enableThemeExtension(eligibility.description, next)
+      : this.disableThemeExtension(eligibility.description, next);
+  }
+
+  dispose(): void {
+    if (this.disposed) {
+      return;
+    }
+    this.disposed = true;
+    this.listeners.clear();
+    this.registrationHandles.clear();
+    this.registrationLifetime.dispose();
+  }
+
+  private enableThemeExtension(
+    description: WorkbenchExtensionDescription,
+    nextRecords: readonly InstalledExtensionRecord[],
+  ): ExtensionEnablementTransitionResult {
+    const extensionId = description.manifest.id;
+    let registration: DisposableLike;
+    try {
+      registration = this.registry.registerExtension(description);
+      this.registrationLifetime.add(registration);
+      if (!this.areThemesVisible(description)) {
+        registration.dispose();
+        return this.failed(extensionId, false);
+      }
+    } catch {
+      return this.failed(extensionId, false);
+    }
+
+    if (!this.persist(nextRecords)) {
+      try {
+        registration.dispose();
+      } catch {
+        // The failed transition below never publishes the requested enabled state.
+      }
+      return this.failed(extensionId, false);
+    }
+
+    this.registrationHandles.set(extensionId, registration);
+    this.publishInstalledRecords(nextRecords);
+    return {
+      enabled: true,
+      extensionId,
+      kind: 'applied',
+      message: 'Applied without reloading the workbench.',
+    };
+  }
+
+  private disableThemeExtension(
+    description: WorkbenchExtensionDescription,
+    nextRecords: readonly InstalledExtensionRecord[],
+  ): ExtensionEnablementTransitionResult {
+    const extensionId = description.manifest.id;
+    const registration = this.registrationHandles.get(extensionId);
+    if (!registration) {
+      return this.reloadRequired(extensionId, false);
+    }
+
+    this.registrationHandles.delete(extensionId);
+    try {
+      registration.dispose();
+    } catch {
+      this.restoreRegistration(description, registration);
+      return this.failed(extensionId, true);
+    }
+    if (this.areThemesVisible(description)) {
+      this.restoreRegistration(description, registration);
+      return this.failed(extensionId, true);
+    }
+
+    if (!this.persist(nextRecords)) {
+      this.restoreRegistration(description);
+      return this.failed(extensionId, true);
+    }
+
+    this.publishInstalledRecords(nextRecords);
+    return {
+      enabled: false,
+      extensionId,
+      kind: 'applied',
+      message: 'Applied without reloading the workbench.',
+    };
+  }
+
+  private restoreRegistration(
+    description: WorkbenchExtensionDescription,
+    existingRegistration?: DisposableLike,
+  ): void {
+    const extensionId = description.manifest.id;
+    if (this.registry.getExtension(extensionId) && this.areThemesVisible(description)) {
+      if (existingRegistration) {
+        this.registrationHandles.set(extensionId, existingRegistration);
+      }
+      return;
+    }
+
+    try {
+      const restored = this.registry.registerExtension(description);
+      this.registrationLifetime.add(restored);
+      this.registrationHandles.set(extensionId, restored);
+    } catch {
+      // A failed compensation is still surfaced as `failed`; no success is claimed.
+    }
+  }
+
+  private getSoftThemeEligibility(
+    extensionId: string,
+    enabled: boolean,
+  ):
+    | { readonly eligible: true; readonly description: WorkbenchExtensionDescription }
+    | {
+        readonly commitRequestedState: boolean;
+        readonly eligible: false;
+        readonly kind: 'failed' | 'reloadRequired';
+      } {
+    const description = this.availableExtensionsById.get(extensionId);
+    if (!description) {
+      return { commitRequestedState: true, eligible: false, kind: 'reloadRequired' };
+    }
+    if (!this.integrityAcceptedExtensionIds.has(extensionId)) {
+      return { commitRequestedState: false, eligible: false, kind: 'failed' };
+    }
+    if (!isThemeOnlyDeclarativeExtension(description)) {
+      return { commitRequestedState: true, eligible: false, kind: 'reloadRequired' };
+    }
+
+    const selectionProtection = this.themeSelectionProtection;
+    if (
+      selectionProtection?.kind !== 'known' ||
+      selectionProtection.themeRegistryRevision !== this.registry.themes.getRevision()
+    ) {
+      return { commitRequestedState: false, eligible: false, kind: 'reloadRequired' };
+    }
+
+    const protectedThemeIds = new Set(selectionProtection.protectedThemeIds);
+
+    const themes = description.manifest.contributes?.themes ?? [];
+    if (themes.some((theme) => protectedThemeIds.has(theme.id))) {
+      return { commitRequestedState: true, eligible: false, kind: 'reloadRequired' };
+    }
+
+    const registeredHardDependent = [...this.registrationHandles.keys()].some((candidateId) => {
+      if (candidateId === extensionId) {
+        return false;
+      }
+      return this.availableExtensionsById
+        .get(candidateId)
+        ?.manifest.extensionDependencies?.includes(extensionId);
+    });
+    if (registeredHardDependent) {
+      return { commitRequestedState: true, eligible: false, kind: 'reloadRequired' };
+    }
+
+    const hasRegistration = this.registrationHandles.has(extensionId);
+    if ((enabled && hasRegistration) || (!enabled && !hasRegistration)) {
+      return { commitRequestedState: true, eligible: false, kind: 'reloadRequired' };
+    }
+
+    return { eligible: true, description };
+  }
+
+  private areThemesVisible(description: WorkbenchExtensionDescription): boolean {
+    return (description.manifest.contributes?.themes ?? []).every(
+      (theme) => this.registry.themes.getTheme(theme.id)?.extensionId === description.manifest.id,
+    );
+  }
+
+  private persist(records: readonly InstalledExtensionRecord[]): boolean {
+    return saveInstalledExtensionsResult(records, this.storageKey, this.storage, {
+      onDiagnostic: this.onPersistenceDiagnostic,
+    }).committed;
+  }
+
+  private publishInstalledRecords(records: readonly InstalledExtensionRecord[]): void {
+    this.installedRecords = [...records];
+    for (const listener of [...this.listeners]) {
+      listener();
+    }
+  }
+
+  private isRecordEnabled(extensionId: string): boolean {
+    return this.installedRecords.find((record) => record.id === extensionId)?.enabled ?? false;
+  }
+
+  private reloadRequired(
+    extensionId: string,
+    enabled: boolean,
+  ): ExtensionEnablementTransitionResult {
+    return {
+      enabled,
+      extensionId,
+      kind: 'reloadRequired',
+      message: 'Reload required to finish applying this extension change.',
+    };
+  }
+
+  private failed(extensionId: string, enabled: boolean): ExtensionEnablementTransitionResult {
+    return {
+      enabled,
+      extensionId,
+      kind: 'failed',
+      message: 'The extension change failed. The previous state was retained.',
+    };
+  }
+}
+
+function isThemeOnlyDeclarativeExtension(description: WorkbenchExtensionDescription): boolean {
+  const contributes = description.manifest.contributes;
+  if (!contributes?.themes?.length || description.module !== undefined) {
+    return false;
+  }
+  if (
+    (description.manifest.capabilities?.provides?.length ?? 0) > 0 ||
+    (description.manifest.capabilities?.requires?.length ?? 0) > 0 ||
+    (description.manifest.extensionDependencies?.length ?? 0) > 0
+  ) {
+    return false;
+  }
+
+  return Object.entries(contributes).every(([key, value]) => {
+    if (key === 'themes') {
+      return Array.isArray(value) && value.length > 0;
+    }
+    if (Array.isArray(value)) {
+      return value.length === 0;
+    }
+    if (value && typeof value === 'object') {
+      return Object.keys(value).length === 0;
+    }
+    return value === undefined;
+  });
+}