@konitif/workbench-runtime 0.284.1

package/dist/workbench/workbenchShellPersistence.js

@@ -0,0 +1,124 @@
+export function createLocalWorkbenchShellPersistence(options) {
+    return {
+        load(fallback) {
+            if (!isEnabled(options) || typeof localStorage === 'undefined') {
+                return fallback;
+            }
+            try {
+                const rawShell = localStorage.getItem(options.storageKey);
+                if (!rawShell) {
+                    return fallback;
+                }
+                return normalizePersistedShellState(JSON.parse(rawShell), fallback, {
+                    shellWidgetCatalog: options.shellWidgetCatalog
+                });
+            }
+            catch {
+                return fallback;
+            }
+        },
+        save(shell) {
+            if (!isEnabled(options) || typeof localStorage === 'undefined') {
+                return;
+            }
+            localStorage.setItem(options.storageKey, serializeShellState(shell));
+        },
+        serialize: serializeShellState,
+        normalize(input, fallback) {
+            return normalizePersistedShellState(input, fallback, {
+                shellWidgetCatalog: options.shellWidgetCatalog
+            });
+        }
+    };
+}
+export function serializeShellState(shell) {
+    return JSON.stringify(shell);
+}
+export function normalizePersistedShellState(input, fallback, options = {}) {
+    if (!input || typeof input !== 'object' || Array.isArray(input)) {
+        return fallback;
+    }
+    const persistedRegions = input.regions;
+    if (!persistedRegions || typeof persistedRegions !== 'object' || Array.isArray(persistedRegions)) {
+        return fallback;
+    }
+    const regionIds = ['left', 'right', 'bottom'];
+    return {
+        regions: Object.fromEntries(regionIds.map((regionId) => {
+            const fallbackRegion = fallback.regions[regionId];
+            const persistedRegion = persistedRegions[regionId];
+            if (!persistedRegion || typeof persistedRegion !== 'object' || Array.isArray(persistedRegion)) {
+                return [regionId, fallbackRegion];
+            }
+            const nextWidgetIds = normalizePersistedShellWidgetIds(persistedRegion.widgetIds, fallbackRegion.widgetIds, options.shellWidgetCatalog);
+            const isVisible = typeof persistedRegion.isVisible === 'boolean'
+                ? persistedRegion.isVisible
+                : fallbackRegion.isVisible;
+            const activeWidgetId = typeof persistedRegion.activeWidgetId === 'string' && nextWidgetIds.includes(persistedRegion.activeWidgetId)
+                ? persistedRegion.activeWidgetId
+                : nextWidgetIds.includes(fallbackRegion.activeWidgetId ?? '')
+                    ? fallbackRegion.activeWidgetId
+                    : nextWidgetIds[0] ?? null;
+            const minimumSize = regionId === 'bottom' ? 140 : 180;
+            const size = typeof persistedRegion.size === 'number' && Number.isFinite(persistedRegion.size)
+                ? Math.max(minimumSize, Math.round(persistedRegion.size))
+                : fallbackRegion.size;
+            const hiddenWidgetIds = normalizePersistedShellWidgetIds(persistedRegion.hiddenWidgetIds, [], options.shellWidgetCatalog).filter((widgetId) => nextWidgetIds.includes(widgetId));
+            const presentation = persistedRegion.presentation === 'stack' || persistedRegion.presentation === 'tabs'
+                ? persistedRegion.presentation
+                : fallbackRegion.presentation;
+            const axis = persistedRegion.axis === 'horizontal' || persistedRegion.axis === 'vertical'
+                ? persistedRegion.axis
+                : fallbackRegion.axis;
+            const visibleWidgetIds = nextWidgetIds.filter((widgetId) => !hiddenWidgetIds.includes(widgetId));
+            const visibleActiveWidgetId = activeWidgetId && visibleWidgetIds.includes(activeWidgetId)
+                ? activeWidgetId
+                : visibleWidgetIds[0] ?? null;
+            return [
+                regionId,
+                {
+                    ...fallbackRegion,
+                    isVisible: visibleWidgetIds.length > 0 && isVisible,
+                    isOpen: visibleWidgetIds.length > 0 && isVisible
+                        ? typeof persistedRegion.isOpen === 'boolean'
+                            ? persistedRegion.isOpen
+                            : fallbackRegion.isOpen
+                        : false,
+                    size,
+                    activeWidgetId: visibleActiveWidgetId,
+                    widgetIds: nextWidgetIds,
+                    hiddenWidgetIds,
+                    presentation,
+                    axis
+                }
+            ];
+        }))
+    };
+}
+function isEnabled(options) {
+    return options.isEnabled?.() ?? true;
+}
+function normalizePersistedShellWidgetIds(input, fallbackWidgetIds, shellWidgetCatalog) {
+    if (!Array.isArray(input)) {
+        return fallbackWidgetIds;
+    }
+    const normalizedWidgetIds = [];
+    for (const value of input) {
+        if (typeof value !== 'string') {
+            continue;
+        }
+        const widgetId = value.trim();
+        if (widgetId &&
+            !normalizedWidgetIds.includes(widgetId) &&
+            isKnownShellWidgetId(widgetId, fallbackWidgetIds, shellWidgetCatalog)) {
+            normalizedWidgetIds.push(widgetId);
+        }
+    }
+    return normalizedWidgetIds;
+}
+function isKnownShellWidgetId(widgetId, fallbackWidgetIds, shellWidgetCatalog) {
+    if (fallbackWidgetIds.includes(widgetId)) {
+        return true;
+    }
+    return Boolean(shellWidgetCatalog?.getDefinition(widgetId));
+}

package/dist/workbench/workbenchStateFactory.d.ts

@@ -0,0 +1,22 @@
+import { type LayoutInteractionState, type ShellRegionId, type ShellState, type ShellWidgetCatalog, type ToolCatalog, type Workspace, type WorkspaceSessionState } from '@konitif/workbench/workspace-contracts';
+import type { InitialWorkbenchWorkspaceMode } from "./workbenchWorkspaceActions.js";
+export interface WorkbenchState {
+    workspace: WorkspaceSessionState['workspace'];
+    focus: WorkspaceSessionState['focus'];
+    shell: ShellState;
+    layoutInteraction: LayoutInteractionState;
+}
+export interface CreateWorkbenchStateFactoryInput {
+    initialToolId: string;
+    toolCatalog: ToolCatalog;
+    shellWidgetCatalog: ShellWidgetCatalog;
+    initialWorkspaceMode?: InitialWorkbenchWorkspaceMode;
+    initialStackHeaderVisible?: boolean;
+    defaultOpenShellRegions?: ShellRegionId[];
+}
+export interface WorkbenchStateFactory {
+    createInitialWorkspace(mode?: InitialWorkbenchWorkspaceMode): Workspace;
+    createShellFallback(): ShellState;
+    createWorkbenchState(workspaceSession?: WorkspaceSessionState, shellState?: ShellState, layoutInteraction?: LayoutInteractionState): WorkbenchState;
+}
+export declare function createWorkbenchStateFactory(input: CreateWorkbenchStateFactoryInput): WorkbenchStateFactory;

package/dist/workbench/workbenchStateFactory.js

@@ -0,0 +1,47 @@
+import { createLayoutInteractionState, createShellState, createWorkspace, createWorkspaceSessionState, normalizeWorkspaceFullscreenPanel } from '@konitif/workbench/workspace-contracts';
+export function createWorkbenchStateFactory(input) {
+    function createInitialWorkspace(mode = input.initialWorkspaceMode ?? 'tool') {
+        const workspace = mode === 'empty'
+            ? createWorkspace()
+            : createWorkspace(input.toolCatalog, { initialToolId: input.initialToolId });
+        return applyInitialWorkspacePreferences(workspace);
+    }
+    function createShellFallback() {
+        return createShellState(input.shellWidgetCatalog, { openRegionIds: input.defaultOpenShellRegions });
+    }
+    function createWorkbenchState(workspaceSession = createWorkspaceSessionState(createInitialWorkspace()), shellState = createShellFallback(), layoutInteraction = createLayoutInteractionState()) {
+        const normalizedWorkspace = normalizeWorkspaceFullscreenPanel(workspaceSession.workspace);
+        const normalizedSession = createWorkspaceSessionState(normalizedWorkspace, workspaceSession.focus);
+        return {
+            workspace: normalizedSession.workspace,
+            focus: normalizedSession.focus,
+            shell: shellState,
+            layoutInteraction
+        };
+    }
+    function applyInitialWorkspacePreferences(workspace) {
+        if (typeof input.initialStackHeaderVisible !== 'boolean') {
+            return workspace;
+        }
+        return {
+            ...workspace,
+            windows: workspace.windows.map((window) => {
+                if (window.id !== workspace.activeWindowId || window.root.kind !== 'stack') {
+                    return window;
+                }
+                return {
+                    ...window,
+                    root: {
+                        ...window.root,
+                        headerVisible: input.initialStackHeaderVisible
+                    }
+                };
+            })
+        };
+    }
+    return {
+        createInitialWorkspace,
+        createShellFallback,
+        createWorkbenchState
+    };
+}

package/dist/workbench/workbenchToolRuntimeActions.d.ts

@@ -0,0 +1,23 @@
+import { createWorkspaceSessionState, type LayoutInteractionState, type ShellState, type ToolCatalog, type ToolPanelLoadingState, type ToolResourceLoadingState, type ToolRuntimeHostActions, type ToolShellStatus, type Workspace, type WorkspaceFocus } from '@konitif/workbench/workspace-contracts';
+import type { WorkbenchHistoryScope, WorkspaceHistoryController } from "./workspaceHistoryController.js";
+export interface WorkbenchToolRuntimeState {
+    workspace: Workspace;
+    focus: WorkspaceFocus;
+    shell: ShellState;
+    layoutInteraction: LayoutInteractionState;
+}
+export interface CreateWorkbenchToolRuntimeActionsInput<TState extends WorkbenchToolRuntimeState, TSnapshot> {
+    toolCatalog: ToolCatalog;
+    workspaceHistory: WorkspaceHistoryController<TSnapshot>;
+    getWorkbenchState(): TState;
+    createHistorySnapshot(state: TState): TSnapshot;
+    restoreHistorySnapshot(snapshot: TSnapshot): TState;
+    createWorkbenchState(workspaceSession: ReturnType<typeof createWorkspaceSessionState>, shell: ShellState, layoutInteraction: LayoutInteractionState): TState;
+    updateWorkbenchState(updater: (state: TState) => TState, historyScope?: WorkbenchHistoryScope): void;
+    setWorkbenchState(nextState: TState, historyScope?: WorkbenchHistoryScope): void;
+    syncHistoryStatus(): void;
+    setToolPanelLoadingState(toolInstanceId: string, nextLoading: ToolPanelLoadingState | null): boolean;
+    setToolResourceLoadingState(toolInstanceId: string, nextLoading: ToolResourceLoadingState | null): boolean;
+    setToolShellStatusState(toolInstanceId: string, nextStatus: ToolShellStatus | null): boolean;
+}
+export declare function createWorkbenchToolRuntimeActions<TState extends WorkbenchToolRuntimeState, TSnapshot>(input: CreateWorkbenchToolRuntimeActionsInput<TState, TSnapshot>): ToolRuntimeHostActions;

package/dist/workbench/workbenchToolRuntimeActions.js

@@ -0,0 +1,98 @@
+import { createWorkspaceSessionState, dispatchWorkspaceCommand, runToolShellCommand, setToolPanelTitleOverride, updateToolState } from '@konitif/workbench/workspace-contracts';
+export function createWorkbenchToolRuntimeActions(input) {
+    return {
+        updateToolState(toolInstanceId, nextState) {
+            let didUpdate = false;
+            input.updateWorkbenchState((state) => {
+                const nextWorkspace = updateToolState(state.workspace, { toolInstanceId, nextState });
+                didUpdate = nextWorkspace !== state.workspace;
+                return didUpdate
+                    ? input.createWorkbenchState(createWorkspaceSessionState(nextWorkspace, state.focus), state.shell, state.layoutInteraction)
+                    : state;
+            }, 'app');
+            return didUpdate;
+        },
+        setToolPanelTitleOverride(panelId, toolInstanceId, nextTitle) {
+            let didUpdate = false;
+            input.updateWorkbenchState((state) => {
+                const nextWorkspace = setToolPanelTitleOverride(state.workspace, {
+                    panelId,
+                    toolInstanceId,
+                    panelTitleOverride: nextTitle
+                }, input.toolCatalog);
+                didUpdate = nextWorkspace !== state.workspace;
+                return didUpdate
+                    ? input.createWorkbenchState(createWorkspaceSessionState(nextWorkspace, state.focus), state.shell, state.layoutInteraction)
+                    : state;
+            }, 'app');
+            return didUpdate;
+        },
+        setToolShellStatus(toolInstanceId, nextStatus) {
+            const toolInstance = input.getWorkbenchState().workspace.toolInstances[toolInstanceId];
+            if (!toolInstance)
+                return false;
+            const definition = input.toolCatalog.getDefinition(toolInstance.toolId);
+            // A status rendered by the Tool itself has no shell consumer. Publishing
+            // it globally would invalidate every panel for a purely local projection.
+            if (definition?.shell?.statusPlacement === 'tool-header')
+                return true;
+            return input.setToolShellStatusState(toolInstanceId, nextStatus);
+        },
+        setToolPanelLoading(toolInstanceId, nextLoading) {
+            return input.setToolPanelLoadingState(toolInstanceId, nextLoading);
+        },
+        setToolResourceLoading(toolInstanceId, nextLoading) {
+            return input.setToolResourceLoadingState(toolInstanceId, nextLoading);
+        },
+        runToolCommand(panelId, toolInstanceId, commandId) {
+            let didUpdate = false;
+            input.updateWorkbenchState((state) => {
+                const nextWorkspace = runToolShellCommand(state.workspace, {
+                    panelId,
+                    toolInstanceId,
+                    commandId
+                }, input.toolCatalog);
+                didUpdate = nextWorkspace !== state.workspace;
+                return didUpdate
+                    ? input.createWorkbenchState(createWorkspaceSessionState(nextWorkspace, state.focus), state.shell, state.layoutInteraction)
+                    : state;
+            }, 'app');
+            return didUpdate;
+        },
+        openTool(toolId) {
+            let didUpdate = false;
+            input.updateWorkbenchState((state) => {
+                const nextSession = dispatchWorkspaceCommand(state, { type: 'open-tool', toolId }, { toolCatalog: input.toolCatalog });
+                didUpdate = nextSession.workspace !== state.workspace || nextSession.focus !== state.focus;
+                return didUpdate
+                    ? input.createWorkbenchState(nextSession, state.shell, state.layoutInteraction)
+                    : state;
+            }, 'app');
+            return didUpdate;
+        },
+        canUndoHistory() {
+            return input.workspaceHistory.getStatus().app.canUndo;
+        },
+        canRedoHistory() {
+            return input.workspaceHistory.getStatus().app.canRedo;
+        },
+        undoHistory() {
+            const snapshot = input.workspaceHistory.undo('app', input.createHistorySnapshot(input.getWorkbenchState()));
+            if (!snapshot) {
+                return false;
+            }
+            input.setWorkbenchState(input.restoreHistorySnapshot(snapshot), 'none');
+            input.syncHistoryStatus();
+            return true;
+        },
+        redoHistory() {
+            const snapshot = input.workspaceHistory.redo('app', input.createHistorySnapshot(input.getWorkbenchState()));
+            if (!snapshot) {
+                return false;
+            }
+            input.setWorkbenchState(input.restoreHistorySnapshot(snapshot), 'none');
+            input.syncHistoryStatus();
+            return true;
+        }
+    };
+}

package/dist/workbench/workbenchToolRuntimeUiStore.d.ts

@@ -0,0 +1,17 @@
+import { writable } from 'svelte/store';
+import { type ToolPanelLoadingState, type ToolResourceLoadingState, type ToolShellStatus, type Workspace } from '@konitif/workbench/workspace-contracts';
+export interface ToolRuntimeUiState {
+    panelLoading: ToolPanelLoadingState | null;
+    resourceLoading: ToolResourceLoadingState | null;
+    shellStatus?: ToolShellStatus | null;
+}
+export type ToolRuntimeUiStateMap = Record<string, ToolRuntimeUiState | undefined>;
+export interface WorkbenchToolRuntimeUiStore {
+    store: ReturnType<typeof writable<ToolRuntimeUiStateMap>>;
+    reset(): void;
+    prune(toolInstances: Workspace['toolInstances']): void;
+    setToolPanelLoadingState(toolInstanceId: string, nextLoading: ToolPanelLoadingState | null): boolean;
+    setToolResourceLoadingState(toolInstanceId: string, nextLoading: ToolResourceLoadingState | null): boolean;
+    setToolShellStatus(toolInstanceId: string, nextStatus: ToolShellStatus | null): boolean;
+}
+export declare function createWorkbenchToolRuntimeUiStore(getWorkspace: () => Workspace): WorkbenchToolRuntimeUiStore;

package/dist/workbench/workbenchToolRuntimeUiStore.js

@@ -0,0 +1,85 @@
+import { get, writable } from 'svelte/store';
+import { normalizeToolShellStatus, normalizeToolPanelLoadingState, normalizeToolResourceLoadingState } from '@konitif/workbench/workspace-contracts';
+function samePanelLoadingState(left, right) {
+    return left?.label === right?.label && left?.detail === right?.detail;
+}
+function sameResourceLoadingState(left, right) {
+    return (left?.label === right?.label &&
+        left?.detail === right?.detail &&
+        left?.progress === right?.progress);
+}
+export function createWorkbenchToolRuntimeUiStore(getWorkspace) {
+    const store = writable({});
+    function updateToolRuntimeUiState(toolInstanceId, updater) {
+        const workspace = getWorkspace();
+        if (!workspace.toolInstances[toolInstanceId]) {
+            return false;
+        }
+        const entries = get(store);
+        const nextEntry = updater(entries[toolInstanceId] ?? { panelLoading: null, resourceLoading: null });
+        if (!nextEntry.panelLoading && !nextEntry.resourceLoading && nextEntry.shellStatus === undefined) {
+            if (!(toolInstanceId in entries)) {
+                return false;
+            }
+            const { [toolInstanceId]: _removed, ...rest } = entries;
+            store.set(rest);
+            return true;
+        }
+        const previousEntry = entries[toolInstanceId];
+        if (samePanelLoadingState(previousEntry?.panelLoading ?? null, nextEntry.panelLoading) &&
+            sameResourceLoadingState(previousEntry?.resourceLoading ?? null, nextEntry.resourceLoading) &&
+            previousEntry?.shellStatus?.label === nextEntry.shellStatus?.label &&
+            previousEntry?.shellStatus?.tone === nextEntry.shellStatus?.tone &&
+            (previousEntry ? 'shellStatus' in previousEntry : false) === ('shellStatus' in nextEntry)) {
+            return false;
+        }
+        store.set({
+            ...entries,
+            [toolInstanceId]: nextEntry
+        });
+        return true;
+    }
+    return {
+        store,
+        reset() {
+            store.set({});
+        },
+        prune(toolInstances) {
+            const activeToolInstanceIds = new Set(Object.keys(toolInstances));
+            store.update((entries) => {
+                let didChange = false;
+                const nextEntries = {};
+                for (const [toolInstanceId, entry] of Object.entries(entries)) {
+                    if (activeToolInstanceIds.has(toolInstanceId)) {
+                        nextEntries[toolInstanceId] = entry;
+                    }
+                    else {
+                        didChange = true;
+                    }
+                }
+                return didChange ? nextEntries : entries;
+            });
+        },
+        setToolPanelLoadingState(toolInstanceId, nextLoading) {
+            return updateToolRuntimeUiState(toolInstanceId, (state) => ({
+                ...state,
+                panelLoading: normalizeToolPanelLoadingState(nextLoading)
+            }));
+        },
+        setToolResourceLoadingState(toolInstanceId, nextLoading) {
+            return updateToolRuntimeUiState(toolInstanceId, (state) => ({
+                ...state,
+                resourceLoading: normalizeToolResourceLoadingState(nextLoading)
+            }));
+        },
+        setToolShellStatus(toolInstanceId, nextStatus) {
+            const normalizedStatus = normalizeToolShellStatus(nextStatus);
+            if (nextStatus !== null && normalizedStatus === null)
+                return false;
+            return updateToolRuntimeUiState(toolInstanceId, (state) => ({
+                ...state,
+                shellStatus: normalizedStatus
+            }));
+        }
+    };
+}

package/dist/workbench/workbenchWindowRuntime.d.ts

@@ -0,0 +1,19 @@
+import type { WorkbenchDetachedWindowHost } from "./workbenchDetachedWindowHost.js";
+import { createWorkspaceSessionState, type LayoutInteractionState, type ShellState, type Workspace, type WorkspaceFocus } from '@konitif/workbench/workspace-contracts';
+import type { WorkbenchHistoryScope } from "./workspaceHistoryController.js";
+export interface WorkbenchWindowActionState {
+    workspace: Workspace;
+    focus: WorkspaceFocus;
+    shell: ShellState;
+    layoutInteraction: LayoutInteractionState;
+}
+export interface CreateWorkbenchWindowRuntimeInput<TState extends WorkbenchWindowActionState> {
+    detachedWindows: WorkbenchDetachedWindowHost | null;
+    createWorkbenchState(workspaceSession: ReturnType<typeof createWorkspaceSessionState>, shellState: ShellState, layoutInteraction: LayoutInteractionState): TState;
+    updateWorkbenchState(updater: (state: TState) => TState, historyScope?: WorkbenchHistoryScope): void;
+    flushWorkspacePersistence(): void;
+}
+export declare function createWorkbenchWindowRuntime<TState extends WorkbenchWindowActionState>(input: CreateWorkbenchWindowRuntimeInput<TState>): {
+    disposeDetachedWindowTracking(): void;
+    detachPanelToWindow(panelId: string): string | null;
+};

package/dist/workbench/workbenchWindowRuntime.js

@@ -0,0 +1,85 @@
+import { createWorkspaceSessionState, detachPanelToWindow as detachPanelToWindowCore, dismissLayoutInteraction, getPreferredFocusedPanelId, reattachWorkspaceWindow } from '@konitif/workbench/workspace-contracts';
+export function createWorkbenchWindowRuntime(input) {
+    if (input.detachedWindows === undefined)
+        throw new TypeError('detachedWindows must be supplied explicitly.');
+    const subscriptions = new Set();
+    function recover(target) {
+        input.updateWorkbenchState((state) => {
+            const workspace = reattachWorkspaceWindow(state.workspace, target);
+            if (workspace === state.workspace)
+                return state;
+            return input.createWorkbenchState(createWorkspaceSessionState(workspace, { activePanelId: getPreferredFocusedPanelId(workspace) }), state.shell, dismissLayoutInteraction());
+        }, 'app');
+        input.flushWorkspacePersistence();
+    }
+    function observeClosed(opening, target) {
+        let active = true;
+        let unsubscribe;
+        const stop = () => {
+            if (!active)
+                return;
+            active = false;
+            subscriptions.delete(stop);
+            unsubscribe?.();
+        };
+        subscriptions.add(stop);
+        try {
+            unsubscribe = opening.observeClosed(() => {
+                if (!active)
+                    return;
+                stop();
+                recover(target);
+            });
+            // A provider may notify synchronously during subscription.
+            if (!active)
+                unsubscribe();
+        }
+        catch (error) {
+            stop();
+            throw error;
+        }
+    }
+    return {
+        disposeDetachedWindowTracking() {
+            for (const stop of [...subscriptions])
+                stop();
+        },
+        detachPanelToWindow(panelId) {
+            if (input.detachedWindows === null)
+                return null;
+            let detachedWindowId = null;
+            let recoveryTarget = null;
+            input.updateWorkbenchState((state) => {
+                const result = detachPanelToWindowCore(state.workspace, { panelId });
+                if (!result) {
+                    return state;
+                }
+                detachedWindowId = result.windowId;
+                recoveryTarget = result;
+                const nextFocusedPanelId = state.focus.activePanelId === panelId
+                    ? getPreferredFocusedPanelId(result.workspace)
+                    : state.focus.activePanelId;
+                return input.createWorkbenchState(createWorkspaceSessionState(result.workspace, { activePanelId: nextFocusedPanelId ?? null }), state.shell, dismissLayoutInteraction());
+            }, 'app');
+            if (detachedWindowId) {
+                input.flushWorkspacePersistence();
+                let opening;
+                try {
+                    opening = input.detachedWindows.open(detachedWindowId);
+                }
+                catch (error) {
+                    if (recoveryTarget)
+                        recover(recoveryTarget);
+                    throw error;
+                }
+                if (recoveryTarget && opening.status === 'blocked') {
+                    recover(recoveryTarget);
+                    detachedWindowId = null;
+                }
+                else if (recoveryTarget && opening.status === 'opened')
+                    observeClosed(opening, recoveryTarget);
+            }
+            return detachedWindowId;
+        }
+    };
+}

package/dist/workbench/workbenchWorkspaceActions.d.ts

@@ -0,0 +1,30 @@
+import { type DesignSystemThemeSession, type LayoutInteractionState, type ShellState, type ToolCatalog, type Workspace, type WorkspaceCommand, type WorkspaceFocus, type WorkspacePresetId, type WorkspacePresetArtifact, type WorkspaceSessionState, type WorkspaceSnapshotImportResult } from '@konitif/workbench/workspace-contracts';
+import type { WorkbenchHistoryScope } from "./workspaceHistoryController.js";
+export type InitialWorkbenchWorkspaceMode = 'tool' | 'empty';
+export interface WorkbenchWorkspaceActionState {
+    workspace: Workspace;
+    focus: WorkspaceFocus;
+    shell: ShellState;
+    layoutInteraction: LayoutInteractionState;
+}
+export interface CreateWorkbenchWorkspaceActionsInput<TState extends WorkbenchWorkspaceActionState> {
+    toolCatalog: ToolCatalog;
+    initialWorkspaceMode?: InitialWorkbenchWorkspaceMode;
+    createInitialWorkspace(mode?: InitialWorkbenchWorkspaceMode): Workspace;
+    getWorkbenchState(): TState;
+    createWorkbenchState(workspaceSession?: WorkspaceSessionState, shellState?: ShellState, layoutInteraction?: LayoutInteractionState): TState;
+    updateWorkbenchState(updater: (state: TState) => TState, historyScope?: WorkbenchHistoryScope): void;
+    setWorkbenchState(nextState: TState, historyScope?: WorkbenchHistoryScope): void;
+    resolveWorkspaceCommandHistoryScope(command: WorkspaceCommand): WorkbenchHistoryScope;
+}
+export declare function createWorkbenchWorkspaceActions<TState extends WorkbenchWorkspaceActionState>(input: CreateWorkbenchWorkspaceActionsInput<TState>): {
+    applyWorkspaceSession(workspaceSession: WorkspaceSessionState, historyScope?: WorkbenchHistoryScope): void;
+    applyWorkspacePresetArtifact(artifact: WorkspacePresetArtifact): void;
+    dispatchCommand(command: WorkspaceCommand): void;
+    resetWorkspace(mode?: InitialWorkbenchWorkspaceMode | "initial"): void;
+    loadPreset(presetId: WorkspacePresetId): void;
+    exportWorkspaceSnapshot(): string;
+    importWorkspaceSnapshot(source: string): WorkspaceSnapshotImportResult;
+    setFullscreenPanel(panelId: string | null): void;
+    setDesignSystemThemeSession(nextSession: DesignSystemThemeSession | null): void;
+};

package/dist/workbench/workbenchWorkspaceActions.js

@@ -0,0 +1,55 @@
+import { createWorkspaceSessionFromPreset, createWorkspaceSessionState, dismissLayoutInteraction, dispatchWorkspaceCommand, exportWorkspaceSnapshot as serializeWorkspaceSnapshot, importWorkspaceSnapshot as parseWorkspaceSnapshotSource, setDesignSystemThemeSession, setWorkspaceFullscreenPanel } from '@konitif/workbench/workspace-contracts';
+export function createWorkbenchWorkspaceActions(input) {
+    return {
+        applyWorkspaceSession(workspaceSession, historyScope = 'both') {
+            input.updateWorkbenchState((state) => input.createWorkbenchState(workspaceSession, state.shell, state.layoutInteraction), historyScope);
+        },
+        applyWorkspacePresetArtifact(artifact) {
+            const workspaceSession = createWorkspaceSessionState({
+                ...artifact.workspaceSession.workspace,
+                presetProvenance: {
+                    id: artifact.id,
+                    version: artifact.version,
+                    status: 'exact'
+                }
+            }, artifact.workspaceSession.focus);
+            input.setWorkbenchState(input.createWorkbenchState(workspaceSession, artifact.shellState), 'both');
+        },
+        dispatchCommand(command) {
+            input.updateWorkbenchState((state) => input.createWorkbenchState(dispatchWorkspaceCommand(state, command, { toolCatalog: input.toolCatalog }), state.shell, dismissLayoutInteraction()), input.resolveWorkspaceCommandHistoryScope(command));
+        },
+        resetWorkspace(mode = 'initial') {
+            const workspaceMode = mode === 'initial' ? (input.initialWorkspaceMode ?? 'tool') : mode;
+            input.setWorkbenchState(input.createWorkbenchState(createWorkspaceSessionState(input.createInitialWorkspace(workspaceMode))), 'core');
+        },
+        loadPreset(presetId) {
+            if (presetId === 'default') {
+                input.setWorkbenchState(input.createWorkbenchState(createWorkspaceSessionState(input.createInitialWorkspace('tool'))), 'core');
+                return;
+            }
+            input.setWorkbenchState(input.createWorkbenchState(createWorkspaceSessionFromPreset(input.toolCatalog, presetId)), 'core');
+        },
+        exportWorkspaceSnapshot() {
+            return serializeWorkspaceSnapshot(input.getWorkbenchState().workspace);
+        },
+        importWorkspaceSnapshot(source) {
+            const result = parseWorkspaceSnapshotSource(source);
+            if (result.ok && result.workspace) {
+                const importedWorkspace = result.workspace;
+                input.updateWorkbenchState((state) => input.createWorkbenchState(createWorkspaceSessionState(importedWorkspace), state.shell, dismissLayoutInteraction()), 'core');
+            }
+            return result;
+        },
+        setFullscreenPanel(panelId) {
+            input.updateWorkbenchState((state) => input.createWorkbenchState(createWorkspaceSessionState(setWorkspaceFullscreenPanel(state.workspace, panelId), state.focus), state.shell, state.layoutInteraction), 'none');
+        },
+        setDesignSystemThemeSession(nextSession) {
+            input.updateWorkbenchState((state) => {
+                const nextWorkspace = setDesignSystemThemeSession(state.workspace, nextSession);
+                return nextWorkspace === state.workspace
+                    ? state
+                    : input.createWorkbenchState(createWorkspaceSessionState(nextWorkspace, state.focus), state.shell, state.layoutInteraction);
+            }, 'app');
+        }
+    };
+}

package/dist/workbench/workspaceHistoryController.d.ts

@@ -0,0 +1,28 @@
+export type WorkbenchHistoryScope = 'none' | 'app' | 'core' | 'both';
+export type WorkbenchHistoryChannel = 'app' | 'core';
+export interface WorkbenchHistoryStatus {
+    app: {
+        canUndo: boolean;
+        canRedo: boolean;
+    };
+    core: {
+        canUndo: boolean;
+        canRedo: boolean;
+    };
+}
+export interface WorkspaceHistoryController<TSnapshot> {
+    getStatus(): WorkbenchHistoryStatus;
+    reset(): void;
+    recordTransition(previousSnapshot: TSnapshot, nextSnapshot: TSnapshot, scope: WorkbenchHistoryScope): void;
+    beginTransaction(channel: WorkbenchHistoryChannel, snapshot: TSnapshot): void;
+    commitTransaction(channel: WorkbenchHistoryChannel, currentSnapshot: TSnapshot): void;
+    cancelTransaction(channel: WorkbenchHistoryChannel): TSnapshot | null;
+    undo(channel: WorkbenchHistoryChannel, currentSnapshot: TSnapshot): TSnapshot | null;
+    redo(channel: WorkbenchHistoryChannel, currentSnapshot: TSnapshot): TSnapshot | null;
+}
+interface WorkspaceHistoryControllerOptions<TSnapshot> {
+    isChanged: (left: TSnapshot, right: TSnapshot) => boolean;
+    maxEntries?: number;
+}
+export declare function createWorkspaceHistoryController<TSnapshot>(options: WorkspaceHistoryControllerOptions<TSnapshot>): WorkspaceHistoryController<TSnapshot>;
+export {};