@graphvideo/workbench 1.0.0

package/dist/commands/commandRegistry.d.ts

@@ -0,0 +1,15 @@
+export type CommandHandler<T = unknown> = (payload: T) => void | Promise<void>;
+export declare class CommandRegistry {
+    private readonly handlers;
+    register<T>(id: string, handler: CommandHandler<T>, owner?: string): void;
+    assertCanReplace(owner: string, entries: Array<{
+        id: string;
+        handler: CommandHandler<any>;
+    }>): void;
+    replaceOwner(owner: string, entries: Array<{
+        id: string;
+        handler: CommandHandler<any>;
+    }>): void;
+    unregisterOwner(owner: string): void;
+    execute<T>(id: string, payload: T): void | Promise<void>;
+}

package/dist/context/WorkbenchHostContext.d.ts

@@ -0,0 +1,26 @@
+import type { CommandRegistry } from '../commands/commandRegistry';
+import type { PanelRegistry } from '../registry/panelRegistry';
+import type { ExtensionRegistry } from '../registry/extensionRegistry';
+import type { EventRegistry } from '../registry/eventRegistry';
+import type { ServiceRegistry } from '../registry/serviceRegistry';
+import type { ElementStateRegistry } from '../registry/stateRegistry';
+import type { ElementRuntimeManager } from '../elements/runtimeManager';
+import type { WorkbenchContextStore } from './workbenchContextStore';
+import type { ClientWorkspaceState } from '../dock/workspaceTypes';
+export interface WorkbenchServices {
+    commands: CommandRegistry;
+    panels: PanelRegistry;
+    extensions: ExtensionRegistry;
+    elementEvents: EventRegistry;
+    elementServices: ServiceRegistry;
+    elementStates: ElementStateRegistry;
+    elementRuntimes: ElementRuntimeManager;
+    contexts: WorkbenchContextStore;
+}
+export interface WorkbenchHostAdapter {
+    services: WorkbenchServices;
+    useWorkspaceState<T>(selector: (state: ClientWorkspaceState) => T): T;
+}
+export declare const WorkbenchHostContext: import("react").Context<WorkbenchHostAdapter | null>;
+export declare function useWorkbenchServices(): WorkbenchServices;
+export declare function useWorkbenchWorkspace<T>(selector: (state: ClientWorkspaceState) => T): T;

package/dist/context/types.d.ts

@@ -0,0 +1,26 @@
+declare const workbenchContextValue: unique symbol;
+export type WorkbenchContextScope = 'application' | 'project' | 'workspace' | 'instance';
+export interface WorkbenchContextToken<T> {
+    readonly id: string;
+    readonly scope: WorkbenchContextScope;
+    readonly initialValue: T;
+    readonly [workbenchContextValue]?: (value: T) => T;
+}
+export interface WorkbenchContextBinding {
+    projectId?: string | null;
+    workspaceId?: string;
+    instanceId?: string;
+}
+export interface WorkbenchContextHandle<T> {
+    read(): T;
+    write(value: T | ((current: T) => T)): void;
+    subscribe(listener: () => void): () => void;
+}
+export interface WorkbenchContextAccessor {
+    get<T>(token: WorkbenchContextToken<T>, binding?: WorkbenchContextBinding): WorkbenchContextHandle<T>;
+}
+export declare function defineWorkbenchContext<T>(id: string, options: {
+    scope: WorkbenchContextScope;
+    initialValue: T;
+}): WorkbenchContextToken<T>;
+export {};

package/dist/context/workbenchContextStore.d.ts

@@ -0,0 +1,26 @@
+import type { WorkbenchContextBinding, WorkbenchContextHandle, WorkbenchContextToken } from './types';
+/** Renderer-only shared interaction context. It never owns projected business facts. */
+export declare class WorkbenchContextStore {
+    private readonly cells;
+    private getOrCreateCell;
+    get<T>(token: WorkbenchContextToken<T>, binding?: WorkbenchContextBinding): WorkbenchContextHandle<T>;
+    purgeNamespace(namespace: string): void;
+    clearPluginContexts(pluginOrManifest: string | {
+        id: string;
+        contributes?: {
+            elements?: readonly string[];
+            workspaces?: readonly string[];
+        };
+    }): void;
+    /** Final plugin teardown: notify mounted consumers, then release cells for clean reinstallation. */
+    disposePluginContexts(manifest: {
+        id: string;
+        contributes?: {
+            elements?: readonly string[];
+            workspaces?: readonly string[];
+        };
+    }): void;
+    clearScope(scope: 'workspace' | 'instance' | 'project', id: string): void;
+    clearAll(): void;
+    private cellKey;
+}

package/dist/dock/AreaShell.d.ts

@@ -0,0 +1,9 @@
+import type { AreaState } from './workspaceTypes';
+interface AreaShellProps {
+    workspaceId: string;
+    area: AreaState;
+    floating?: boolean;
+    onFloatToggle?(areaId: string): void;
+}
+export declare function AreaShell({ workspaceId, area, floating, onFloatToggle }: AreaShellProps): import("react").JSX.Element;
+export {};

package/dist/dock/Workspace.d.ts

@@ -0,0 +1,5 @@
+export interface WorkspaceProps {
+    workspaceId: string;
+    active: boolean;
+}
+export declare const Workspace: import("react").NamedExoticComponent<WorkspaceProps>;

package/dist/dock/floatingWindow.d.ts

@@ -0,0 +1,7 @@
+export interface FloatingDocument {
+    container: HTMLDivElement;
+    disconnect(): void;
+}
+export declare function isOutsideViewport(x: number, y: number, width: number, height: number): boolean;
+export declare function synchronizeFloatingRoot(source: HTMLElement, target: HTMLElement): void;
+export declare function prepareFloatingWindow(popup: Window, title: string): FloatingDocument;

package/dist/dock/layout.d.ts

@@ -0,0 +1,14 @@
+import type { AreaState, DockNode, DockSplitState } from './workspaceTypes';
+export declare function listAreas(node: DockNode): AreaState[];
+export declare function findArea(node: DockNode, areaId: string): AreaState | null;
+export declare function excludeAreas(node: DockNode, excludedAreaIds: ReadonlySet<string>): DockNode | null;
+export declare function canCloseArea(layout: DockNode, areaId: string): boolean;
+export declare function switchAreaPanel(layout: DockNode, areaId: string, panelId: string, instanceId: string): DockNode;
+export declare function splitArea(layout: DockNode, areaId: string, direction: DockSplitState['direction'], ids: {
+    areaId: string;
+    splitId: string;
+    panelInstanceId: string;
+}): DockNode;
+export declare function closeArea(layout: DockNode, areaId: string): DockNode;
+export declare function resizeSplit(layout: DockNode, splitId: string, ratio: number): DockNode;
+export declare function swapAreaPanels(layout: DockNode, firstId: string, secondId: string): DockNode;

package/dist/dock/splitResizeGesture.d.ts

@@ -0,0 +1,23 @@
+import type { DockSplitState } from './workspaceTypes';
+interface SplitBounds {
+    width: number;
+    height: number;
+}
+interface SplitResizeGestureOptions {
+    direction: DockSplitState['direction'];
+    bounds: SplitBounds;
+    initialRatio: number;
+    startX: number;
+    startY: number;
+    scheduleFrame(callback: () => void): number;
+    cancelFrame(frameId: number): void;
+    preview(ratio: number): void;
+    commit(ratio: number): void;
+    cancel(): void;
+}
+export declare function createSplitResizeGesture(options: SplitResizeGestureOptions): {
+    move(clientX: number, clientY: number): void;
+    finish(clientX: number, clientY: number): void;
+    abort(notify?: boolean): void;
+};
+export {};

package/dist/dock/workspaceTypes.d.ts

@@ -0,0 +1,28 @@
+export interface AreaState {
+    kind: 'area';
+    id: string;
+    activePanelId: string;
+    panelHistory: string[];
+    panelInstanceIds: Record<string, string>;
+}
+export interface DockSplitState {
+    kind: 'split';
+    id: string;
+    direction: 'horizontal' | 'vertical';
+    ratio: number;
+    first: DockNode;
+    second: DockNode;
+}
+export type DockNode = AreaState | DockSplitState;
+export interface WorkspaceRuntimeState {
+    id: string;
+    name: string;
+    order: number;
+    layout: DockNode;
+    focusedAreaId: string;
+    maximizedAreaId: string | null;
+}
+export interface ClientWorkspaceState {
+    activeWorkspaceId: string;
+    items: Record<string, WorkspaceRuntimeState>;
+}

package/dist/elements/ExtensionSlot.d.ts

@@ -0,0 +1,5 @@
+import type { ExtensionProps } from './types';
+export declare function ExtensionSlot({ point, className, ...props }: ExtensionProps & {
+    point: string;
+    className?: string;
+}): import("react").JSX.Element | null;

package/dist/elements/dispose.d.ts

@@ -0,0 +1,3 @@
+import type { ElementDispose } from './types';
+/** Consume owned cleanups once, in reverse acquisition order. One failure cannot leak siblings. */
+export declare function disposeReverse(disposers: ElementDispose[]): Promise<void>;

package/dist/elements/elementLoader.d.ts

@@ -0,0 +1,45 @@
+import type { CommandRegistry } from '../commands/commandRegistry';
+import type { ExtensionRegistry } from '../registry/extensionRegistry';
+import type { EventRegistry } from '../registry/eventRegistry';
+import type { PanelRegistry } from '../registry/panelRegistry';
+import type { ServiceRegistry } from '../registry/serviceRegistry';
+import type { ElementStateRegistry } from '../registry/stateRegistry';
+import type { ElementRuntimeManager } from './runtimeManager';
+import { WorkbenchContextStore } from '../context/workbenchContextStore';
+import type { ElementCandidate, ElementHostApi, ElementPackageManifest } from './types';
+interface ElementLoaderRegistries {
+    panels: PanelRegistry;
+    extensions: ExtensionRegistry;
+    commands: CommandRegistry;
+    states: ElementStateRegistry;
+    events: EventRegistry;
+    services: ServiceRegistry;
+    runtimes: ElementRuntimeManager;
+    host: ElementHostApi;
+    application?: unknown;
+    contexts?: WorkbenchContextStore;
+}
+export declare class ElementLoader {
+    private readonly registries;
+    private readonly loaded;
+    private readonly listeners;
+    private errors;
+    private version;
+    private readonly contexts;
+    constructor(registries: ElementLoaderRegistries);
+    readonly subscribe: (listener: () => void) => () => boolean;
+    readonly getSnapshot: () => number;
+    listErrors(): string[];
+    listLoaded(): {
+        manifest: ElementPackageManifest;
+        owner: string;
+        version: string;
+    }[];
+    reconcile(candidates: ElementCandidate[]): Promise<void>;
+    reportError(error: string): void;
+    unload(owner: string): Promise<void>;
+    private load;
+    private stage;
+    private emit;
+}
+export {};

package/dist/elements/manifest.d.ts

@@ -0,0 +1,2 @@
+import type { ElementPackageManifest } from './types';
+export declare function parseElementManifest(manifestText: string): ElementPackageManifest;

package/dist/elements/runtimeManager.d.ts

@@ -0,0 +1,28 @@
+import type { ElementStateRegistry } from '../registry/stateRegistry';
+import type { EventRegistry } from '../registry/eventRegistry';
+import type { ServiceRegistry } from '../registry/serviceRegistry';
+import type { ElementHostApi, ElementRuntimeFactory, ElementRuntimeHandle } from './types';
+import { WorkbenchContextStore } from '../context/workbenchContextStore';
+export declare class ElementRuntimeManager {
+    private readonly states;
+    private readonly host;
+    private readonly services;
+    private readonly events;
+    private readonly contexts;
+    private readonly factories;
+    private readonly instances;
+    private readonly listeners;
+    private version;
+    private readonly pendingCleanups;
+    constructor(states: ElementStateRegistry, host: ElementHostApi, services: ServiceRegistry, events: EventRegistry, contexts?: WorkbenchContextStore);
+    readonly subscribe: (listener: () => void) => () => boolean;
+    readonly getSnapshot: () => number;
+    getOrCreate(elementId: string, instanceId: string): ElementRuntimeHandle<unknown>;
+    replaceFactory(elementId: string, factory: ElementRuntimeFactory | null): Promise<void>;
+    removeElement(elementId: string): Promise<void>;
+    disposeAll(): Promise<void>;
+    listInstances(): ElementRuntimeHandle<unknown>[];
+    private createEntry;
+    private key;
+    private emit;
+}

package/dist/elements/sourceCatalog.d.ts

@@ -0,0 +1,24 @@
+export interface SourceElementDescriptor {
+    elementId: string;
+    manifestText: string;
+    version: string;
+    pluginId: string;
+}
+export interface SourceWorkspaceDescriptor {
+    workspaceId: string;
+    definitionText: string;
+    version: string;
+    pluginId: string;
+}
+export interface ElementSourceCatalog {
+    elements: SourceElementDescriptor[];
+    workspaces: SourceWorkspaceDescriptor[];
+    plugins: SourcePluginDescriptor[];
+}
+export interface SourcePluginDescriptor {
+    pluginId: string;
+    version: string;
+    hasBackend: boolean;
+    elements: string[];
+    workspaces: string[];
+}

package/dist/elements/types.d.ts

@@ -0,0 +1,133 @@
+import type * as ReactRuntime from 'react';
+import type { ComponentType } from 'react';
+import type { EventListener, EventToken } from '../registry/eventRegistry';
+import type { ServiceToken } from '../registry/serviceRegistry';
+import type { WorkbenchContextAccessor } from '../context/types';
+export type ElementStateScope = 'application' | 'project' | 'workspace' | 'instance';
+export interface ElementStateDefinition<T = unknown> {
+    id: string;
+    scope: ElementStateScope;
+    initialValue: T;
+}
+export interface ElementStateBinding {
+    projectId?: string | null;
+    workspaceId?: string;
+    instanceId?: string;
+}
+export interface ElementStateHandle<T> {
+    read(): T;
+    write(value: T | ((current: T) => T)): void;
+    subscribe(listener: () => void): () => void;
+}
+export interface ElementRuntimeStateAccessor {
+    get<T>(stateId: string, binding?: Pick<ElementStateBinding, 'projectId' | 'workspaceId'>): ElementStateHandle<T>;
+}
+export interface ElementServiceAccessor {
+    get<T>(token: ServiceToken<T>): T;
+    has<T>(token: ServiceToken<T>): boolean;
+}
+export interface ElementServiceRegistration extends ElementServiceAccessor {
+    provide<T>(token: ServiceToken<T>, provider: T): void;
+}
+export interface ElementEventEmitter {
+    emit<T>(event: EventToken<T>, payload: Readonly<T>): void;
+}
+export interface ElementEventRegistration extends ElementEventEmitter {
+    on<T>(event: EventToken<T>, listener: EventListener<T>): void;
+}
+export interface ElementRuntimeHandle<T = unknown> {
+    elementId: string;
+    instanceId: string;
+    value: T;
+    states: ElementRuntimeStateAccessor;
+    attach(viewId: string): void;
+    detach(viewId: string): void;
+}
+export interface PanelProps {
+    workspaceId: string;
+    areaId: string;
+    viewId: string;
+    instanceId: string;
+    runtime: ElementRuntimeHandle;
+}
+export interface PanelIconProps {
+    size?: number;
+    className?: string;
+}
+export interface PanelDefinition {
+    id: string;
+    title: string;
+    icon: ComponentType<PanelIconProps>;
+    component: ComponentType<PanelProps>;
+}
+export interface ExtensionProps extends PanelProps {
+    panelId: string;
+}
+export interface ExtensionDefinition {
+    id: string;
+    point: string;
+    component: ComponentType<ExtensionProps>;
+}
+export interface ElementPackageManifest {
+    id: string;
+    name: string;
+    apiVersion: 1;
+    entry: string;
+}
+export interface ElementHostApi {
+    getProjectId(): string | null;
+    executeCommand<T>(id: string, payload: T): void | Promise<void>;
+}
+export interface ElementRuntimeContext {
+    elementId: string;
+    instanceId: string;
+    host: ElementHostApi;
+    events: ElementEventEmitter;
+    services: ElementServiceAccessor;
+    states: ElementRuntimeStateAccessor;
+    contexts: WorkbenchContextAccessor;
+    onDispose(dispose: ElementDispose): void;
+}
+export interface ElementRuntimeValue {
+    dispose?(): void | Promise<void>;
+    [key: string]: unknown;
+}
+export interface ElementRuntimeFactory {
+    create(context: ElementRuntimeContext): ElementRuntimeValue | void;
+}
+export interface ElementRegistrationContext<TApplication = unknown> {
+    readonly manifest: ElementPackageManifest;
+    readonly react: typeof ReactRuntime;
+    readonly host: ElementHostApi;
+    readonly application?: TApplication;
+    events: ElementEventRegistration;
+    services: ElementServiceRegistration;
+    contexts: WorkbenchContextAccessor;
+    panels: {
+        register(panel: PanelDefinition): void;
+    };
+    extensions: {
+        register(extension: ExtensionDefinition): void;
+    };
+    commands: {
+        register<T>(id: string, handler: (payload: T) => void | Promise<void>): void;
+    };
+    states: {
+        define<T>(state: ElementStateDefinition<T>): void;
+    };
+    runtime: {
+        define(factory: ElementRuntimeFactory): void;
+    };
+    onDispose(dispose: ElementDispose): void;
+}
+export type ElementDispose = () => void | Promise<void>;
+export interface ElementModule<TApplication = unknown> {
+    register(context: ElementRegistrationContext<TApplication>): void | ElementDispose | Promise<void | ElementDispose>;
+}
+export interface ElementCandidate {
+    owner: string;
+    manifestText: string;
+    version: string;
+    load(manifest: ElementPackageManifest): Promise<ElementModule<any>> | ElementModule<any>;
+}
+export declare function defineElement<TApplication = unknown>(module: ElementModule<TApplication>): ElementModule<TApplication>;

package/dist/index.d.ts

@@ -0,0 +1,36 @@
+import './styles/index.css';
+export { CommandRegistry, type CommandHandler } from './commands/commandRegistry';
+export { WorkbenchContextStore } from './context/workbenchContextStore';
+export { defineWorkbenchContext } from './context/types';
+export * from './context/WorkbenchHostContext';
+export type { WorkbenchContextBinding, WorkbenchContextHandle, WorkbenchContextScope, WorkbenchContextToken, } from './context/types';
+export { Workspace, type WorkspaceProps } from './dock/Workspace';
+export { AreaShell } from './dock/AreaShell';
+export * from './dock/workspaceTypes';
+export * from './dock/layout';
+export * from './dock/floatingWindow';
+export * from './dock/splitResizeGesture';
+export { ElementLoader } from './elements/elementLoader';
+export { ElementRuntimeManager } from './elements/runtimeManager';
+export { ExtensionSlot } from './elements/ExtensionSlot';
+export { parseElementManifest } from './elements/manifest';
+export * from './elements/types';
+export * from './elements/sourceCatalog';
+export { PluginRuntimeManager, type PluginRuntimeManagerOptions } from './plugins/pluginManager';
+export { PanelRegistry } from './registry/panelRegistry';
+export { ServiceRegistry, defineService, type ServiceToken, type ServiceProviderDefinition } from './registry/serviceRegistry';
+export { EventRegistry, defineEvent, type EventToken, type EventListener, type EventListenerDefinition } from './registry/eventRegistry';
+export { ElementStateRegistry } from './registry/stateRegistry';
+export { ExtensionRegistry } from './registry/extensionRegistry';
+export { OwnedRegistry } from './registry/ownedRegistry';
+export { AudioPlayer } from './ui/AudioPlayer';
+export { FloatingScrollbars } from './ui/FloatingScrollbars';
+export { InlineSelect } from './ui/InlineSelect';
+export { LargeTextEditorDialog, type LargeTextEditorDialogProps } from './ui/LargeTextEditorDialog';
+export * from './workspaces/layoutPreferences';
+export * from './workspaces/manifest';
+export { WorkspaceTabs } from './workspaces/WorkspaceTabs';
+export { WorkspacePages } from './workspaces/WorkspacePages';
+export { registerWorkspaceCommands, type WorkspaceCommandTarget, } from './workspaces/workspaceCommands';
+export * from './preferences/themePreferences';
+export * from './preferences/typographyPreferences';