@vuu-ui/vuu-shell 4.0.0-alpha.9 → 4.0.0-beta.1

package/src/persistence-manager/LocalWorkspacePersistenceService.js

@@ -1,129 +0,0 @@
-import { WorkspaceValidationError, cloneWorkspaceValue, validateApplicationSessionV1, validateNamedWorkspaceDefinitionV1, validateNamedWorkspaceMetadataV1, validateWorkspaceSnapshotRecordV1, workspaceMetadata } from "../workspace-management/workspace-schemas.js";
-import { WorkspacePersistenceError } from "./WorkspacePersistenceService.js";
-const validateScope = (scope)=>{
-    for (const [name, value] of Object.entries(scope))if (!value) throw new WorkspacePersistenceError(`Persistence scope ${name} must not be empty`, "construct");
-};
-const requireId = (id, operation)=>{
-    if (!id) throw new WorkspacePersistenceError("Entity id must not be empty", operation);
-    return id;
-};
-class LocalWorkspacePersistenceService {
-    scope;
-    #storage;
-    #prefix;
-    constructor(scope, storage = localStorage){
-        validateScope(scope);
-        this.scope = Object.freeze({
-            ...scope
-        });
-        this.#storage = storage;
-        this.#prefix = [
-            "vuu-workspace",
-            scope.applicationNamespace,
-            scope.applicationId,
-            scope.userId
-        ].map(encodeURIComponent).join(":");
-    }
-    async loadApplicationSession() {
-        return this.#read("application-session", void 0, validateApplicationSessionV1);
-    }
-    async saveApplicationSession(session) {
-        this.#write("application-session", void 0, validateApplicationSessionV1(session));
-    }
-    async deleteApplicationSession() {
-        this.#remove("application-session");
-    }
-    async listWorkspaceSnapshots() {
-        return this.#ids("snapshot").map((id)=>{
-            const snapshot = this.#read("snapshot", id, validateWorkspaceSnapshotRecordV1);
-            if (!snapshot) throw new WorkspacePersistenceError(`Snapshot index references missing workspace "${id}"`, "listWorkspaceSnapshots");
-            return snapshot;
-        });
-    }
-    async loadWorkspaceSnapshot(workspaceInstanceId) {
-        return this.#read("snapshot", requireId(workspaceInstanceId, "loadWorkspaceSnapshot"), validateWorkspaceSnapshotRecordV1);
-    }
-    async saveWorkspaceSnapshot(snapshot) {
-        const validated = validateWorkspaceSnapshotRecordV1(snapshot);
-        this.#write("snapshot", validated.workspaceInstanceId, validated);
-        this.#addId("snapshot", validated.workspaceInstanceId);
-    }
-    async deleteWorkspaceSnapshot(workspaceInstanceId) {
-        const id = requireId(workspaceInstanceId, "deleteWorkspaceSnapshot");
-        this.#remove("snapshot", id);
-        this.#deleteId("snapshot", id);
-    }
-    async listNamedWorkspaceMetadata() {
-        return this.#ids("definition").map((id)=>{
-            const metadata = this.#read("definition-metadata", id, validateNamedWorkspaceMetadataV1);
-            if (!metadata) throw new WorkspacePersistenceError(`Definition index references missing metadata "${id}"`, "listNamedWorkspaceMetadata");
-            return metadata;
-        });
-    }
-    async loadNamedWorkspaceDefinition(id) {
-        return this.#read("definition", requireId(id, "loadNamedWorkspaceDefinition"), validateNamedWorkspaceDefinitionV1);
-    }
-    async saveNamedWorkspaceDefinition(definition) {
-        const validated = validateNamedWorkspaceDefinitionV1(definition);
-        this.#write("definition", validated.id, validated);
-        this.#write("definition-metadata", validated.id, workspaceMetadata(validated));
-        this.#addId("definition", validated.id);
-    }
-    async deleteNamedWorkspaceDefinition(id) {
-        const validatedId = requireId(id, "deleteNamedWorkspaceDefinition");
-        this.#remove("definition", validatedId);
-        this.#remove("definition-metadata", validatedId);
-        this.#deleteId("definition", validatedId);
-    }
-    #key(entity, id) {
-        return `${this.#prefix}:${encodeURIComponent(entity)}${void 0 === id ? "" : `:${encodeURIComponent(id)}`}`;
-    }
-    #read(entity, id, validator) {
-        const stored = this.#storage.getItem(this.#key(entity, id));
-        if (null === stored) return;
-        let parsed;
-        try {
-            parsed = JSON.parse(stored);
-        } catch (error) {
-            if (!(error instanceof SyntaxError)) throw error;
-            throw new WorkspacePersistenceError(`Stored ${entity} is not valid JSON: ${error.message}`, `load:${entity}`);
-        }
-        try {
-            return cloneWorkspaceValue(validator(parsed));
-        } catch (error) {
-            if (!(error instanceof WorkspaceValidationError)) throw error;
-            throw new WorkspacePersistenceError(`Stored ${entity} is invalid: ${error.message}`, `load:${entity}`);
-        }
-    }
-    #write(entity, id, value) {
-        this.#storage.setItem(this.#key(entity, id), JSON.stringify(cloneWorkspaceValue(value)));
-    }
-    #remove(entity, id) {
-        this.#storage.removeItem(this.#key(entity, id));
-    }
-    #ids(entity) {
-        const stored = this.#storage.getItem(this.#key(`${entity}-index`));
-        if (null === stored) return [];
-        let parsed;
-        try {
-            parsed = JSON.parse(stored);
-        } catch (error) {
-            if (!(error instanceof SyntaxError)) throw error;
-            throw new WorkspacePersistenceError(`Stored ${entity} index is not valid JSON: ${error.message}`, `list:${entity}`);
-        }
-        if (!Array.isArray(parsed) || parsed.some((id)=>"string" != typeof id || !id) || new Set(parsed).size !== parsed.length) throw new WorkspacePersistenceError(`Stored ${entity} index is invalid`, `list:${entity}`);
-        return parsed;
-    }
-    #addId(entity, id) {
-        const ids = this.#ids(entity);
-        if (!ids.includes(id)) this.#storage.setItem(this.#key(`${entity}-index`), JSON.stringify([
-            ...ids,
-            id
-        ]));
-    }
-    #deleteId(entity, id) {
-        const ids = this.#ids(entity).filter((existing)=>existing !== id);
-        this.#storage.setItem(this.#key(`${entity}-index`), JSON.stringify(ids));
-    }
-}
-export { LocalWorkspacePersistenceService };

package/src/persistence-manager/RemoteWorkspacePersistenceService.js

@@ -1,112 +0,0 @@
-import { cloneWorkspaceValue, validateApplicationSessionV1, validateNamedWorkspaceDefinitionV1, validateNamedWorkspaceMetadataV1, validateWorkspaceSnapshotRecordV1 } from "../workspace-management/workspace-schemas.js";
-import { WorkspacePersistenceError } from "./WorkspacePersistenceService.js";
-const trimSlash = (value)=>value.replace(/\/+$/, "");
-const requireId = (id, operation)=>{
-    if (!id) throw new WorkspacePersistenceError("Entity id must not be empty", operation);
-    return encodeURIComponent(id);
-};
-class RemoteWorkspacePersistenceService {
-    scope;
-    #baseUrl;
-    #requestInit;
-    #requestInitProvider;
-    #fetch;
-    constructor(scope, { baseUrl, requestInit, requestInitProvider, fetch: fetchImplementation = globalThis.fetch }){
-        if (!scope.applicationNamespace || !scope.applicationId || !scope.userId || !baseUrl) throw new WorkspacePersistenceError("Remote persistence scope and base URL must not be empty", "construct");
-        this.scope = Object.freeze({
-            ...scope
-        });
-        this.#baseUrl = trimSlash(baseUrl);
-        this.#requestInit = requestInit;
-        this.#requestInitProvider = requestInitProvider;
-        this.#fetch = fetchImplementation;
-    }
-    async loadApplicationSession() {
-        return this.#optional("loadApplicationSession", "application-session", validateApplicationSessionV1);
-    }
-    async saveApplicationSession(session) {
-        await this.#void("saveApplicationSession", "application-session", "PUT", validateApplicationSessionV1(session));
-    }
-    async deleteApplicationSession() {
-        await this.#void("deleteApplicationSession", "application-session", "DELETE");
-    }
-    async listWorkspaceSnapshots() {
-        const value = await this.#json("listWorkspaceSnapshots", "snapshots");
-        if (!Array.isArray(value)) throw new WorkspacePersistenceError("Remote snapshot list response must be an array", "listWorkspaceSnapshots");
-        return value.map(validateWorkspaceSnapshotRecordV1);
-    }
-    async loadWorkspaceSnapshot(workspaceInstanceId) {
-        return this.#optional("loadWorkspaceSnapshot", `snapshots/${requireId(workspaceInstanceId, "loadWorkspaceSnapshot")}`, validateWorkspaceSnapshotRecordV1);
-    }
-    async saveWorkspaceSnapshot(snapshot) {
-        const validated = validateWorkspaceSnapshotRecordV1(snapshot);
-        await this.#void("saveWorkspaceSnapshot", `snapshots/${encodeURIComponent(validated.workspaceInstanceId)}`, "PUT", validated);
-    }
-    async deleteWorkspaceSnapshot(workspaceInstanceId) {
-        await this.#void("deleteWorkspaceSnapshot", `snapshots/${requireId(workspaceInstanceId, "deleteWorkspaceSnapshot")}`, "DELETE");
-    }
-    async listNamedWorkspaceMetadata() {
-        const value = await this.#json("listNamedWorkspaceMetadata", "named-workspaces");
-        if (!Array.isArray(value)) throw new WorkspacePersistenceError("Remote workspace metadata response must be an array", "listNamedWorkspaceMetadata");
-        return value.map(validateNamedWorkspaceMetadataV1);
-    }
-    async loadNamedWorkspaceDefinition(id) {
-        return this.#optional("loadNamedWorkspaceDefinition", `named-workspaces/${requireId(id, "loadNamedWorkspaceDefinition")}`, validateNamedWorkspaceDefinitionV1);
-    }
-    async saveNamedWorkspaceDefinition(definition) {
-        const validated = validateNamedWorkspaceDefinitionV1(definition);
-        await this.#void("saveNamedWorkspaceDefinition", `named-workspaces/${encodeURIComponent(validated.id)}`, "PUT", validated);
-    }
-    async deleteNamedWorkspaceDefinition(id) {
-        await this.#void("deleteNamedWorkspaceDefinition", `named-workspaces/${requireId(id, "deleteNamedWorkspaceDefinition")}`, "DELETE");
-    }
-    async #optional(operation, path, validator) {
-        const response = await this.#request(operation, path, "GET");
-        if (404 === response.status) return;
-        await this.#assertOk(response, operation);
-        return cloneWorkspaceValue(validator(await response.json()));
-    }
-    async #json(operation, path) {
-        const response = await this.#request(operation, path, "GET");
-        await this.#assertOk(response, operation);
-        return response.json();
-    }
-    async #void(operation, path, method, body) {
-        const response = await this.#request(operation, path, method, body);
-        await this.#assertOk(response, operation);
-    }
-    async #request(operation, path, method, body) {
-        const provided = this.#requestInitProvider ? await this.#requestInitProvider() : {};
-        const configured = this.#requestInit ?? {};
-        const headers = new Headers(configured.headers);
-        new Headers(provided.headers).forEach((value, key)=>{
-            headers.set(key, value);
-        });
-        headers.set("Accept", "application/json");
-        headers.set("X-Vuu-Application-Namespace", this.scope.applicationNamespace);
-        headers.set("X-Vuu-Application-Id", this.scope.applicationId);
-        headers.set("X-Vuu-User-Id", this.scope.userId);
-        if (void 0 !== body) headers.set("Content-Type", "application/json");
-        const scopePath = [
-            this.scope.applicationNamespace,
-            this.scope.applicationId,
-            this.scope.userId
-        ].map(encodeURIComponent).join("/");
-        try {
-            return await this.#fetch(`${this.#baseUrl}/${scopePath}/${path}`, {
-                ...configured,
-                ...provided,
-                headers,
-                method,
-                body: void 0 === body ? void 0 : JSON.stringify(cloneWorkspaceValue(body))
-            });
-        } catch (error) {
-            if (!(error instanceof Error)) throw error;
-            throw new WorkspacePersistenceError(error.message, operation);
-        }
-    }
-    async #assertOk(response, operation) {
-        if (!response.ok) throw new WorkspacePersistenceError(response.statusText || `Remote persistence request failed (${response.status})`, operation, response.status);
-    }
-}
-export { RemoteWorkspacePersistenceService };

package/src/persistence-manager/WorkspacePersistenceService.js

@@ -1,9 +0,0 @@
-class WorkspacePersistenceError extends Error {
-    operation;
-    status;
-    constructor(message, operation, status){
-        super(message), this.operation = operation, this.status = status;
-        this.name = "WorkspacePersistenceError";
-    }
-}
-export { WorkspacePersistenceError };

package/src/shell-layout-templates/context-panel/ApplicationSettingsContextPanel.js

@@ -1,24 +0,0 @@
-import { jsx } from "react/jsx-runtime";
-import { useCallback } from "react";
-import { useWorkspace } from "../../workspace-management/index.js";
-import { ContextPanel } from "./ContextPanel.js";
-const ApplicationSettingsContextPanel = ()=>{
-    const { getApplicationSetting, setApplicationSetting } = useWorkspace();
-    const expanded = true === getApplicationSetting("applicationSettings.panelOpen");
-    const handleClose = useCallback(()=>{
-        setApplicationSetting("applicationSettings.panelOpen", false);
-    }, [
-        setApplicationSetting
-    ]);
-    return /*#__PURE__*/ jsx(ContextPanel, {
-        content: /*#__PURE__*/ jsx("div", {
-            children: "Application settings"
-        }),
-        expanded: expanded,
-        id: "vuu-context-panel",
-        onClose: handleClose,
-        overlay: true,
-        title: "Settings"
-    });
-};
-export { ApplicationSettingsContextPanel };

package/src/workspace-management/WorkspaceController.js

@@ -1,73 +0,0 @@
-import { GridLayoutDocumentController } from "@vuu-ui/grid-layout";
-import { WorkspacePersistentStateStore } from "./WorkspacePersistentState.js";
-import { WorkspaceRepository } from "./WorkspaceRepository.js";
-import { WORKSPACE_SNAPSHOT_VERSION } from "./workspace-schemas.js";
-class WorkspaceController {
-    definitionId;
-    documentController;
-    instanceId;
-    name;
-    persistentState;
-    renderers;
-    repository;
-    settingsCodecs;
-    #disposed = false;
-    #savingStructure = false;
-    #onError;
-    #unsubscribe;
-    constructor(options){
-        this.definitionId = options.definitionId;
-        this.instanceId = options.instanceId;
-        this.name = options.name;
-        this.renderers = options.renderers;
-        this.settingsCodecs = options.settingsCodecs;
-        this.#onError = options.onError;
-        this.repository = new WorkspaceRepository(options.service, options.instanceId, void 0 === options.revision ? void 0 : {
-            revision: options.revision,
-            snapshot: options.snapshot,
-            version: 1,
-            workspaceInstanceId: options.instanceId
-        });
-        this.persistentState = new WorkspacePersistentStateStore(options.snapshot.componentState);
-        this.documentController = new GridLayoutDocumentController(options.snapshot.layout);
-        this.#unsubscribe = this.persistentState.subscribe(()=>{
-            if (!this.#savingStructure) this.#save();
-        });
-    }
-    get snapshot() {
-        const layout = this.documentController.getSnapshot();
-        if (!layout) throw new Error(`Workspace "${this.instanceId}" has no layout document`);
-        return {
-            version: WORKSPACE_SNAPSHOT_VERSION,
-            layout,
-            componentState: this.persistentState.getSnapshot()
-        };
-    }
-    handleDocumentChange = (document, change)=>{
-        if (this.#disposed) return;
-        this.documentController.replace(document);
-        this.#savingStructure = true;
-        try {
-            for (const componentId of change.removedComponentInstanceIds)this.persistentState.purge(componentId);
-        } finally{
-            this.#savingStructure = false;
-        }
-        this.#save();
-    };
-    rename(name) {
-        this.name = name;
-    }
-    dispose() {
-        if (!this.#disposed) {
-            this.#disposed = true;
-            this.#unsubscribe();
-        }
-        return this.repository.dispose();
-    }
-    #save() {
-        if (!this.#disposed) this.repository.save(this.snapshot).catch((cause)=>{
-            if (!this.#disposed) this.#onError(cause instanceof Error ? cause : new Error("Workspace snapshot persistence failed"));
-        });
-    }
-}
-export { WorkspaceController };

package/src/workspace-management/WorkspaceHost.js

@@ -1,194 +0,0 @@
-import { jsx, jsxs } from "react/jsx-runtime";
-import { GridLayout, GridLayoutProvider } from "@vuu-ui/grid-layout";
-import { Tab, Tabstrip } from "@vuu-ui/vuu-ui-controls";
-import { useCallback, useRef, useState } from "react";
-import { WorkspacePersistentStateProvider, WorkspacePersistentStateStore } from "./WorkspacePersistentState.js";
-import { emptyWorkspaceSnapshot, useWorkspace } from "./WorkspaceProvider.js";
-import { WorkspaceStartPanel } from "./WorkspaceStartPanel.js";
-import { WORKSPACE_SNAPSHOT_VERSION } from "./workspace-schemas.js";
-const WorkspaceGrid = ({ active, controller })=>{
-    const [isEmpty, setIsEmpty] = useState(0 === controller.snapshot.layout.components.length);
-    const handleDocumentError = useCallback((error)=>{
-        throw new Error(`Invalid workspace document at ${error.path}: ${error.message}`);
-    }, []);
-    const handleDocumentChange = useCallback((document, change)=>{
-        setIsEmpty(0 === document.components.length);
-        controller.handleDocumentChange(document, change);
-    }, [
-        controller
-    ]);
-    return /*#__PURE__*/ jsx("section", {
-        "aria-hidden": !active,
-        "aria-labelledby": `${controller.instanceId}-tab`,
-        className: "vuuWorkspaceHost-workspace",
-        "data-workspace-instance-id": controller.instanceId,
-        hidden: !active,
-        id: controller.instanceId,
-        role: "tabpanel",
-        children: /*#__PURE__*/ jsx(WorkspacePersistentStateProvider, {
-            store: controller.persistentState,
-            children: /*#__PURE__*/ jsx(GridLayoutProvider, {
-                componentRenderers: controller.renderers,
-                document: controller.snapshot.layout,
-                documentController: controller.documentController,
-                onDocumentChange: handleDocumentChange,
-                onDocumentError: handleDocumentError,
-                settingsCodecs: controller.settingsCodecs,
-                children: /*#__PURE__*/ jsx(GridLayout, {
-                    id: controller.snapshot.layout.layout.id,
-                    placeholderContent: isEmpty ? /*#__PURE__*/ jsx(WorkspaceStartPanel, {}) : void 0
-                })
-            })
-        })
-    });
-};
-const EmptyWorkspaceDropTarget = ()=>{
-    const { componentRenderers, createWorkspaceFromSnapshot, settingsCodecs } = useWorkspace();
-    const creating = useRef(false);
-    const [creationPending, setCreationPending] = useState(false);
-    const [generation, setGeneration] = useState(0);
-    const [persistentState, setPersistentState] = useState(()=>new WorkspacePersistentStateStore());
-    const handleDocumentError = useCallback((error)=>{
-        throw new Error(`Invalid empty workspace document at ${error.path}: ${error.message}`);
-    }, []);
-    const handleDocumentChange = useCallback((document)=>{
-        if (creating.current || 0 === document.components.length) return;
-        creating.current = true;
-        setCreationPending(true);
-        createWorkspaceFromSnapshot({
-            componentState: persistentState.getSnapshot(),
-            layout: document,
-            version: WORKSPACE_SNAPSHOT_VERSION
-        }, "Untitled").catch(()=>{
-            creating.current = false;
-            setCreationPending(false);
-            setPersistentState(new WorkspacePersistentStateStore());
-            setGeneration((current)=>current + 1);
-        });
-    }, [
-        createWorkspaceFromSnapshot,
-        persistentState
-    ]);
-    if (!componentRenderers || !settingsCodecs) return /*#__PURE__*/ jsx("div", {
-        className: "vuuWorkspaceHost-state",
-        role: "alert",
-        children: "Workspace component registries are not configured."
-    });
-    if (creationPending) return /*#__PURE__*/ jsx("div", {
-        className: "vuuWorkspaceHost-empty",
-        children: /*#__PURE__*/ jsx("div", {
-            className: "vuuWorkspaceHost-state",
-            role: "status",
-            children: "Creating workspace…"
-        })
-    });
-    return /*#__PURE__*/ jsx("div", {
-        className: "vuuWorkspaceHost-empty",
-        children: /*#__PURE__*/ jsx(WorkspacePersistentStateProvider, {
-            store: persistentState,
-            children: /*#__PURE__*/ jsx(GridLayoutProvider, {
-                componentRenderers: componentRenderers,
-                onDocumentChange: handleDocumentChange,
-                onDocumentError: handleDocumentError,
-                settingsCodecs: settingsCodecs,
-                children: /*#__PURE__*/ jsx(GridLayout, {
-                    className: "vuuWorkspaceHost-emptyGrid",
-                    colsAndRows: {
-                        cols: [
-                            "1fr"
-                        ],
-                        rows: [
-                            "1fr"
-                        ]
-                    },
-                    id: emptyWorkspaceSnapshot.layout.layout.id,
-                    placeholderContent: /*#__PURE__*/ jsx(WorkspaceStartPanel, {})
-                })
-            }, generation)
-        })
-    });
-};
-const WorkspaceHost = ()=>{
-    const { activeWorkspaceInstanceId, closeWorkspace, controllers, createWorkspaceFromSnapshot, error, renameWorkspace, selectWorkspace, status } = useWorkspace();
-    const [tabRevision, setTabRevision] = useState(0);
-    const activeWorkspaceIndex = controllers.findIndex(({ instanceId })=>instanceId === activeWorkspaceInstanceId);
-    const handleActiveChange = useCallback((tabIndex)=>{
-        const controller = controllers[tabIndex];
-        if (controller) selectWorkspace(controller.instanceId);
-    }, [
-        controllers,
-        selectWorkspace
-    ]);
-    const handleCloseTab = useCallback((tabIndex)=>{
-        const controller = controllers[tabIndex];
-        if (controller) closeWorkspace(controller.instanceId);
-    }, [
-        closeWorkspace,
-        controllers
-    ]);
-    const handleAddTab = useCallback(()=>{
-        const titles = new Set(controllers.map(({ name })=>name));
-        let suffix = 1;
-        let title = "Untitled";
-        while(titles.has(title)){
-            suffix += 1;
-            title = `Untitled ${suffix}`;
-        }
-        createWorkspaceFromSnapshot(emptyWorkspaceSnapshot, title).catch(()=>void 0);
-    }, [
-        controllers,
-        createWorkspaceFromSnapshot
-    ]);
-    const handleExitEditMode = useCallback((originalTitle, title, _allowDeactivation, tabIndex)=>{
-        const controller = controllers[tabIndex];
-        if (controller && title !== originalTitle) renameWorkspace(controller.instanceId, title).catch(()=>{
-            setTabRevision((revision)=>revision + 1);
-        });
-    }, [
-        controllers,
-        renameWorkspace
-    ]);
-    if ("loading" === status) return /*#__PURE__*/ jsx("div", {
-        className: "vuuWorkspaceHost-state",
-        role: "status",
-        children: "Loading workspaces…"
-    });
-    if ("error" === status) return /*#__PURE__*/ jsx("div", {
-        className: "vuuWorkspaceHost-state",
-        role: "alert",
-        children: error?.message ?? "Unable to load workspaces"
-    });
-    return /*#__PURE__*/ jsxs("div", {
-        className: "vuuWorkspaceHost vuu-workspace-tabs",
-        children: [
-            /*#__PURE__*/ jsx(Tabstrip, {
-                activeTabIndex: activeWorkspaceIndex,
-                allowAddTab: true,
-                allowCloseTab: true,
-                allowRenameTab: true,
-                animateSelectionThumb: false,
-                "aria-label": "Workspace Tabs",
-                className: "vuuTabHeader",
-                onActiveChange: handleActiveChange,
-                onAddTab: handleAddTab,
-                onCloseTab: handleCloseTab,
-                onExitEditMode: handleExitEditMode,
-                variant: "primary",
-                children: controllers.map((controller)=>/*#__PURE__*/ jsx(Tab, {
-                        ariaControls: controller.instanceId,
-                        id: `${controller.instanceId}-tab`,
-                        label: controller.name,
-                        onClose: ()=>void closeWorkspace(controller.instanceId)
-                    }, `${controller.instanceId}-${tabRevision}`))
-            }),
-            /*#__PURE__*/ jsx("div", {
-                className: "vuuWorkspaceHost-content",
-                children: "empty" === status ? /*#__PURE__*/ jsx(EmptyWorkspaceDropTarget, {}) : controllers.map((controller)=>/*#__PURE__*/ jsx(WorkspaceGrid, {
-                        active: controller.instanceId === activeWorkspaceInstanceId,
-                        controller: controller
-                    }, controller.instanceId))
-            })
-        ]
-    });
-};
-export { WorkspaceHost };

package/src/workspace-management/WorkspacePersistentState.js

@@ -1,67 +0,0 @@
-import { createContext, createElement, useContext, useSyncExternalStore } from "react";
-import { cloneWorkspaceValue } from "./workspace-schemas.js";
-class WorkspacePersistentStateStore {
-    #state;
-    #listeners = new Set();
-    constructor(initialState = {}){
-        this.#state = Object.freeze(cloneWorkspaceValue(initialState));
-    }
-    getSnapshot = ()=>this.#state;
-    subscribe = (listener)=>{
-        this.#listeners.add(listener);
-        return ()=>this.#listeners.delete(listener);
-    };
-    get(componentInstanceId) {
-        const value = this.#state[componentInstanceId];
-        return void 0 === value ? void 0 : cloneWorkspaceValue(value);
-    }
-    update(componentInstanceId, update) {
-        if (!componentInstanceId) throw new Error("componentInstanceId must not be empty");
-        const next = "function" == typeof update ? update(this.get(componentInstanceId)) : update;
-        const captured = cloneWorkspaceValue(next);
-        if (!captured.componentType || !Number.isInteger(captured.schemaVersion) || captured.schemaVersion < 1) throw new Error("Component persistent state metadata is invalid");
-        this.#state = Object.freeze({
-            ...this.#state,
-            [componentInstanceId]: captured
-        });
-        this.#emit();
-    }
-    purge(componentInstanceId) {
-        if (void 0 === componentInstanceId) {
-            if (Object.keys(this.#state).length > 0) {
-                this.#state = Object.freeze({});
-                this.#emit();
-            }
-            return;
-        }
-        if (void 0 !== this.#state[componentInstanceId]) {
-            const { [componentInstanceId]: removed, ...remaining } = this.#state;
-            this.#state = Object.freeze(remaining);
-            this.#emit();
-        }
-    }
-    #emit() {
-        this.#listeners.forEach((listener)=>{
-            listener();
-        });
-    }
-}
-const WorkspacePersistentStateContext = /*#__PURE__*/ createContext(null);
-const WorkspacePersistentStateProvider = ({ children, store })=>/*#__PURE__*/ createElement(WorkspacePersistentStateContext.Provider, {
-        value: store
-    }, children);
-const useWorkspacePersistentStateStore = ()=>{
-    const store = useContext(WorkspacePersistentStateContext);
-    if (!store) throw new Error("useWorkspacePersistentStateStore requires WorkspacePersistentStateProvider");
-    return store;
-};
-const useComponentPersistentState = (componentInstanceId)=>{
-    const store = useWorkspacePersistentStateStore();
-    const state = useSyncExternalStore(store.subscribe, ()=>store.getSnapshot()[componentInstanceId], ()=>store.getSnapshot()[componentInstanceId]);
-    return [
-        state,
-        (update)=>store.update(componentInstanceId, update),
-        ()=>store.purge(componentInstanceId)
-    ];
-};
-export { WorkspacePersistentStateProvider, WorkspacePersistentStateStore, useComponentPersistentState, useWorkspacePersistentStateStore };