@vuu-ui/vuu-shell 4.0.0-alpha.24 → 4.0.0-alpha.26

package/types/src/shell.d.ts

@@ -0,0 +1,17 @@
+import { VuuUser } from "@vuu-ui/vuu-utils";
+import { type HTMLAttributes, type ReactNode } from "react";
+import { ShellLayoutProps } from "./shell-layout-templates";
+import { SettingsSchema } from "./user-settings";
+import { WorkspaceProps } from "./workspace-management";
+export type LayoutTemplateName = "full-height" | "inlay";
+export interface ShellProps extends HTMLAttributes<HTMLDivElement> {
+    shellLayoutProps?: ShellLayoutProps;
+    userSettingsSchema?: SettingsSchema;
+    workspaceProps?: WorkspaceProps;
+    children?: ReactNode;
+    logout?: () => void;
+    saveUrl?: string;
+    serverUrl?: string;
+    user: VuuUser;
+}
+export declare const Shell: ({ logout, user, userSettingsSchema, workspaceProps, ...props }: ShellProps) => import("react").JSX.Element;

package/types/src/theme-switch/ThemeSwitch.d.ts

@@ -0,0 +1,8 @@
+import { HTMLAttributes } from "react";
+import { ThemeMode } from "@vuu-ui/vuu-utils";
+export interface ThemeSwitchProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange"> {
+    defaultMode?: ThemeMode;
+    mode?: ThemeMode;
+    onChange: (mode: ThemeMode) => void;
+}
+export declare const ThemeSwitch: ({ className: classNameProp, defaultMode: defaultModeProp, mode: modeProp, onChange, ...htmlAttributes }: ThemeSwitchProps) => import("react").JSX.Element;

package/types/src/theme-switch/index.d.ts

@@ -0,0 +1 @@
+export * from "./ThemeSwitch";

package/types/src/user-settings/SettingsForm.d.ts

@@ -0,0 +1,46 @@
+import type { VuuRowDataItemType } from "@vuu-ui/vuu-protocol-types";
+import { type Settings } from "@vuu-ui/vuu-utils";
+import { type DropdownProps } from "@salt-ds/core";
+import { type FormEventHandler, type HTMLAttributes } from "react";
+export interface SettingsSchema {
+    properties: SettingsProperty[];
+}
+export type OptionType<T> = {
+    label: string;
+    value: T;
+};
+export declare const isOption: (value: OptionType<number | string> | number | string) => value is OptionType<number | string>;
+export interface BaseProperty {
+    name: string;
+    label: string;
+}
+export interface StringProperty extends BaseProperty {
+    values?: string[] | OptionType<string>[];
+    defaultValue?: string;
+    type: "string";
+}
+export interface NumericProperty extends BaseProperty {
+    values?: number[] | OptionType<number>[];
+    defaultValue?: number;
+    type: "number";
+}
+export interface BooleanProperty extends BaseProperty {
+    defaultValue?: boolean;
+    type: "boolean";
+}
+export type SettingsProperty = StringProperty | NumericProperty | BooleanProperty;
+export declare const isBooleanProperty: (property: SettingsProperty) => property is BooleanProperty;
+export declare const isStringOrNumber: (value: unknown) => value is string | number;
+export declare function FormControl({ property, changeHandler, selectHandler, inputHandler, currentValue, }: {
+    property: SettingsProperty;
+    changeHandler: FormEventHandler;
+    selectHandler: DropdownProps["onSelectionChange"];
+    inputHandler: FormEventHandler;
+    currentValue: VuuRowDataItemType;
+}): import("react").JSX.Element | null;
+export interface SettingsFormProps extends HTMLAttributes<HTMLDivElement> {
+    settingsSchema: SettingsSchema;
+    settings: Settings;
+    onSettingChanged: (propertyName: string, value: string | number | boolean) => void;
+}
+export declare const SettingsForm: ({ className, settingsSchema, settings, onSettingChanged, ...htmlAttributes }: SettingsFormProps) => import("react").JSX.Element;

package/types/src/user-settings/UserSettingsPanel.d.ts

@@ -0,0 +1,3 @@
+import { HTMLAttributes } from "react";
+export type UserSettingsPanelProps = HTMLAttributes<HTMLDivElement>;
+export declare const UserSettingsPanel: ({ ...htmlAttributes }: UserSettingsPanelProps) => import("react").JSX.Element | null;

package/types/src/user-settings/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./UserSettingsPanel";
+export * from "./SettingsForm";

package/types/src/workspace-management/LayoutList.d.ts

@@ -0,0 +1,2 @@
+import { HTMLAttributes } from "react";
+export declare const LayoutList: ({ className, title, ...htmlAttributes }: HTMLAttributes<HTMLDivElement>) => import("react").JSX.Element;

package/types/src/workspace-management/LayoutTile.d.ts

@@ -0,0 +1,7 @@
+import { LayoutJSON, LayoutMetadata, SystemLayoutMetadata } from "@vuu-ui/vuu-utils";
+import { HTMLAttributes } from "react";
+export interface LayoutTileProps extends HTMLAttributes<HTMLDivElement> {
+    metadata: LayoutMetadata | SystemLayoutMetadata;
+    onLoadLayout: (layoutId?: string, layoutJSON?: LayoutJSON) => void;
+}
+export declare const LayoutTile: ({ metadata, onLoadLayout, ...htmlAttributes }: LayoutTileProps) => import("react").JSX.Element;

package/types/src/workspace-management/SaveLayoutPanel.d.ts

@@ -0,0 +1,9 @@
+import { LayoutMetadataDto } from "@vuu-ui/vuu-utils";
+type SaveLayoutPanelProps = {
+    componentId?: string;
+    defaultTitle?: string;
+    onCancel: () => void;
+    onSave: (layoutMetadata: LayoutMetadataDto) => void;
+};
+export declare const SaveLayoutPanel: (props: SaveLayoutPanelProps) => import("react").JSX.Element;
+export {};

package/types/src/workspace-management/WorkspaceProvider.d.ts

@@ -0,0 +1,52 @@
+import { LayoutMetadata, LayoutMetadataDto, type ApplicationSetting, type ApplicationSettings, type LayoutJSON } from "@vuu-ui/vuu-utils";
+import { ReactElement } from "react";
+import { type WorkspaceStackProps } from "./defaultWorkspaceJSON";
+export type WorkspaceProps = WorkspaceStackProps & {
+    layoutPlaceholderJSON?: LayoutJSON;
+    /**
+     * layoutJSON defines the default layout to render on first load and until such time as
+     * layout state has been persisted. After that, the persisted state will be rendered.
+     */
+    layoutJSON?: LayoutJSON | LayoutJSON[];
+    activeLayoutIndex?: number;
+    /**
+     * The Vuu workspace is the container into which layouts are loaded. By default, it will be
+     * a Tabbed Panel (Stack + Tabstrip), showing a tab per Layout.
+     */
+    workspaceJSON?: LayoutJSON | LayoutJSON[];
+};
+export interface WorkspaceProviderProps extends WorkspaceProps {
+    children: ReactElement | ReactElement[];
+    /**
+     * layoutPlaceholderJSON defines the layout to render when a new workspace layout is created.
+     */
+    layoutPlaceholderJSON?: LayoutJSON;
+}
+/**
+ * LayoutManagementProvider supplies an API for loading and saving layout documents.
+ * Initial layout is automatically loaded on startup. Because this hook is responsible
+ * only for loading and saving layouts, it only triggers a render when content is loaded.
+ *
+ * Initial layout displays a loading state
+ * User may supply a default layout. This will not be displayed until call has been made to
+ * persistenceManager to retrieve stored layout state. If no stored state is returned, the
+ * default layout provided by user will be set as current state (and hence rendered). If no
+ * default layout has been provided by user, the sysem default will be used (simple PlaceHolder)
+ * If saved layout state has been returned, that will be set as current state (and rendered)
+ *
+ */
+export declare const WorkspaceProvider: ({ TabstripProps, children, layoutJSON, activeLayoutIndex, layoutPlaceholderJSON, showTabs, workspaceJSON: customWorkspaceJSON, }: WorkspaceProviderProps) => import("react").JSX.Element;
+export declare const useWorkspace: () => {
+    layoutMetadata: LayoutMetadata[];
+    layoutPlaceholderJSON?: LayoutJSON;
+    getApplicationSettings: (key?: keyof ApplicationSettings) => ApplicationSettings | ApplicationSetting | undefined;
+    loadLayoutById: (id: string) => void;
+    saveApplicationSettings: (settings: ApplicationSettings | ApplicationSetting, key?: keyof ApplicationSettings) => void;
+    saveLayout: (n: LayoutMetadataDto) => void;
+    saveApplicationLayout: (layout: LayoutJSON) => void;
+    workspaceJSON: LayoutJSON<{
+        [key: string]: any;
+    }>[] | LayoutJSON<{
+        [key: string]: any;
+    }>;
+};

package/types/src/workspace-management/defaultWorkspaceJSON.d.ts

@@ -0,0 +1,10 @@
+import { StackProps } from "@vuu-ui/vuu-layout";
+import { LayoutJSON } from "@vuu-ui/vuu-utils";
+export type WorkspaceStackProps = Pick<StackProps, "showTabs" | "TabstripProps">;
+export declare const warningLayout: LayoutJSON;
+export declare const loadingJSON: Readonly<LayoutJSON>;
+export declare const defaultWorkspaceJSON: LayoutJSON<StackProps & {
+    preserve: boolean;
+}>;
+export declare const getStackWorkspaceJSON: (activeLayoutIndex?: number) => LayoutJSON;
+export declare const getWorkspaceWithLayoutJSON: (customWorkspaceJSON?: LayoutJSON | LayoutJSON[], layoutJSON?: LayoutJSON | LayoutJSON[], activeLayoutIndex?: number, stackProps?: WorkspaceStackProps) => LayoutJSON | LayoutJSON[];

package/types/src/workspace-management/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./SaveLayoutPanel";
+export * from "./LayoutList";
+export * from "./WorkspaceProvider";
+export * from "./defaultWorkspaceJSON";
+export * from "./useWorkspaceContextMenuItems";

package/types/src/workspace-management/screenshot-utils.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Takes a screenshot of the given node and returns the base64 encoded image url
+ * @param node HTMLElement to take screenshot of
+ * @returns Base64 encoded image url
+ */
+export declare const takeScreenshot: (node: HTMLElement) => Promise<string>;

package/types/src/workspace-management/useWorkspaceContextMenuItems.d.ts

@@ -0,0 +1,5 @@
+import { MenuActionHandler, MenuBuilder } from "@vuu-ui/vuu-context-menu";
+export declare const useWorkspaceContextMenuItems: () => {
+    buildMenuOptions: MenuBuilder;
+    handleMenuAction: MenuActionHandler;
+};

package/types/user-settings/SettingsForm.d.ts

@@ -0,0 +1,46 @@
+import type { VuuRowDataItemType } from "@vuu-ui/vuu-protocol-types";
+import { type Settings } from "@vuu-ui/vuu-utils";
+import { type DropdownProps } from "@salt-ds/core";
+import { type FormEventHandler, type HTMLAttributes } from "react";
+export interface SettingsSchema {
+    properties: SettingsProperty[];
+}
+export type OptionType<T> = {
+    label: string;
+    value: T;
+};
+export declare const isOption: (value: OptionType<number | string> | number | string) => value is OptionType<number | string>;
+export interface BaseProperty {
+    name: string;
+    label: string;
+}
+export interface StringProperty extends BaseProperty {
+    values?: string[] | OptionType<string>[];
+    defaultValue?: string;
+    type: "string";
+}
+export interface NumericProperty extends BaseProperty {
+    values?: number[] | OptionType<number>[];
+    defaultValue?: number;
+    type: "number";
+}
+export interface BooleanProperty extends BaseProperty {
+    defaultValue?: boolean;
+    type: "boolean";
+}
+export type SettingsProperty = StringProperty | NumericProperty | BooleanProperty;
+export declare const isBooleanProperty: (property: SettingsProperty) => property is BooleanProperty;
+export declare const isStringOrNumber: (value: unknown) => value is string | number;
+export declare function FormControl({ property, changeHandler, selectHandler, inputHandler, currentValue, }: {
+    property: SettingsProperty;
+    changeHandler: FormEventHandler;
+    selectHandler: DropdownProps["onSelectionChange"];
+    inputHandler: FormEventHandler;
+    currentValue: VuuRowDataItemType;
+}): import("react/jsx-runtime").JSX.Element | null;
+export interface SettingsFormProps extends HTMLAttributes<HTMLDivElement> {
+    settingsSchema: SettingsSchema;
+    settings: Settings;
+    onSettingChanged: (propertyName: string, value: string | number | boolean) => void;
+}
+export declare const SettingsForm: ({ className, settingsSchema, settings, onSettingChanged, ...htmlAttributes }: SettingsFormProps) => import("react/jsx-runtime").JSX.Element;

package/types/user-settings/UserSettingsPanel.d.ts

@@ -0,0 +1,3 @@
+import { HTMLAttributes } from "react";
+export type UserSettingsPanelProps = HTMLAttributes<HTMLDivElement>;
+export declare const UserSettingsPanel: ({ ...htmlAttributes }: UserSettingsPanelProps) => import("react/jsx-runtime").JSX.Element | null;

package/types/user-settings/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./UserSettingsPanel";
+export * from "./SettingsForm";

package/types/workspace-management/WorkspaceProvider.d.ts

@@ -1,63 +1,52 @@
-import { type GridComponentRendererRegistry, type GridComponentSettingsRegistry, type JsonValue } from "@vuu-ui/grid-layout";
-import type { LayoutJSON } from "@vuu-ui/vuu-utils";
-import { type ReactElement, type ReactNode } from "react";
-import { type WorkspacePersistenceService } from "../persistence-manager";
-import { WorkspaceController } from "./WorkspaceController";
-import { type NamedWorkspaceDefinitionV1, type NamedWorkspaceMetadataV1, type WorkspaceSnapshotV1 } from "./workspace-schemas";
-export declare const emptyWorkspaceSnapshot: WorkspaceSnapshotV1;
-export type WorkspaceStatus = "empty" | "error" | "loading" | "ready";
-export interface WorkspaceProps {
-    /** @deprecated Migrate this layout to defaultWorkspace. */
-    readonly activeLayoutIndex?: number;
-    readonly componentRenderers?: GridComponentRendererRegistry;
-    readonly defaultWorkspace?: WorkspaceSnapshotV1;
-    /** @deprecated Migrate this layout to defaultWorkspace. */
-    readonly layoutJSON?: LayoutJSON | readonly LayoutJSON[];
-    /** @deprecated Workspace snapshots contain their own placeholders. */
-    readonly layoutPlaceholderJSON?: LayoutJSON;
-    readonly settingsCodecs?: GridComponentSettingsRegistry;
-    /** @deprecated Tabs are managed by WorkspaceHost. */
-    readonly showTabs?: boolean | "left" | "right";
-    readonly systemWorkspaces?: readonly NamedWorkspaceDefinitionV1[];
-    /** @deprecated Tabs are managed by WorkspaceHost. */
-    readonly TabstripProps?: Readonly<Record<string, unknown>>;
-    /** @deprecated Migrate this layout to defaultWorkspace. */
-    readonly workspaceJSON?: LayoutJSON | readonly LayoutJSON[];
-}
+import { LayoutMetadata, LayoutMetadataDto, type ApplicationSetting, type ApplicationSettings, type LayoutJSON } from "@vuu-ui/vuu-utils";
+import { ReactElement } from "react";
+import { type WorkspaceStackProps } from "./defaultWorkspaceJSON";
+export type WorkspaceProps = WorkspaceStackProps & {
+    layoutPlaceholderJSON?: LayoutJSON;
+    /**
+     * layoutJSON defines the default layout to render on first load and until such time as
+     * layout state has been persisted. After that, the persisted state will be rendered.
+     */
+    layoutJSON?: LayoutJSON | LayoutJSON[];
+    activeLayoutIndex?: number;
+    /**
+     * The Vuu workspace is the container into which layouts are loaded. By default, it will be
+     * a Tabbed Panel (Stack + Tabstrip), showing a tab per Layout.
+     */
+    workspaceJSON?: LayoutJSON | LayoutJSON[];
+};
 export interface WorkspaceProviderProps extends WorkspaceProps {
-    readonly children: ReactNode;
-    readonly persistenceService?: WorkspacePersistenceService;
-    readonly userId?: string;
-}
-export interface WorkspaceContextValue {
-    readonly activeWorkspace?: WorkspaceController;
-    readonly activeWorkspaceInstanceId: string | null;
-    readonly closeWorkspace: (instanceId: string) => Promise<void>;
-    readonly componentRenderers?: GridComponentRendererRegistry;
-    readonly controllers: readonly WorkspaceController[];
-    readonly createWorkspaceFromSnapshot: (snapshot: WorkspaceSnapshotV1, title?: string) => Promise<string>;
-    readonly deleteNamedWorkspace: (definitionId: string) => Promise<void>;
-    readonly error?: Error;
-    readonly getApplicationSetting: (key: string) => JsonValue | undefined;
-    readonly getApplicationSettings: (key?: string) => JsonValue | Readonly<Record<string, JsonValue>> | undefined;
-    readonly namedWorkspaces: readonly NamedWorkspaceMetadataV1[];
-    readonly openNamedWorkspace: (definitionId: string) => Promise<void>;
-    readonly openSystemWorkspace: (definition: NamedWorkspaceDefinitionV1) => Promise<void>;
-    readonly renameWorkspace: (instanceId: string, title: string) => Promise<void>;
-    readonly saveActiveWorkspaceAs: (name: string, description?: string) => Promise<void>;
-    readonly saveApplicationSettings: (settings: JsonValue, key?: string) => Promise<void>;
-    readonly selectWorkspace: (instanceId: string) => Promise<void>;
-    readonly setApplicationSetting: (key: string, value: JsonValue) => Promise<void>;
-    readonly settings: Readonly<Record<string, JsonValue>>;
-    readonly settingsCodecs?: GridComponentSettingsRegistry;
-    /** Identifies the authenticated persistence scope. Changes synchronously on a scope transition. */
-    readonly scopeIdentity: string;
-    readonly status: WorkspaceStatus;
-    readonly systemWorkspaces: readonly NamedWorkspaceDefinitionV1[];
-    readonly resetApplication: () => Promise<void>;
-}
-export declare class StaleWorkspaceScopeError extends Error {
-    constructor();
+    children: ReactElement | ReactElement[];
+    /**
+     * layoutPlaceholderJSON defines the layout to render when a new workspace layout is created.
+     */
+    layoutPlaceholderJSON?: LayoutJSON;
 }
-export declare const WorkspaceProvider: ({ activeLayoutIndex, children, componentRenderers, defaultWorkspace, layoutJSON, layoutPlaceholderJSON, persistenceService: serviceProp, settingsCodecs, showTabs, systemWorkspaces, TabstripProps, userId, workspaceJSON, }: WorkspaceProviderProps) => ReactElement;
-export declare const useWorkspace: () => WorkspaceContextValue;
+/**
+ * LayoutManagementProvider supplies an API for loading and saving layout documents.
+ * Initial layout is automatically loaded on startup. Because this hook is responsible
+ * only for loading and saving layouts, it only triggers a render when content is loaded.
+ *
+ * Initial layout displays a loading state
+ * User may supply a default layout. This will not be displayed until call has been made to
+ * persistenceManager to retrieve stored layout state. If no stored state is returned, the
+ * default layout provided by user will be set as current state (and hence rendered). If no
+ * default layout has been provided by user, the sysem default will be used (simple PlaceHolder)
+ * If saved layout state has been returned, that will be set as current state (and rendered)
+ *
+ */
+export declare const WorkspaceProvider: ({ TabstripProps, children, layoutJSON, activeLayoutIndex, layoutPlaceholderJSON, showTabs, workspaceJSON: customWorkspaceJSON, }: WorkspaceProviderProps) => import("react/jsx-runtime").JSX.Element;
+export declare const useWorkspace: () => {
+    workspaceJSON: LayoutJSON<{
+        [key: string]: any;
+    }> | LayoutJSON<{
+        [key: string]: any;
+    }>[];
+    layoutMetadata: LayoutMetadata[];
+    layoutPlaceholderJSON?: LayoutJSON;
+    getApplicationSettings: (key?: keyof ApplicationSettings) => ApplicationSettings | ApplicationSetting | undefined;
+    loadLayoutById: (id: string) => void;
+    saveApplicationSettings: (settings: ApplicationSettings | ApplicationSetting, key?: keyof ApplicationSettings) => void;
+    saveLayout: (n: LayoutMetadataDto) => void;
+    saveApplicationLayout: (layout: LayoutJSON) => void;
+};

package/types/workspace-management/index.d.ts

@@ -1,13 +1,10 @@
 export * from "./SaveLayoutPanel";
 export * from "./LayoutList";
-export * from "./WorkspaceProvider";
 export * from "./defaultWorkspaceJSON";
 export * from "./useWorkspaceContextMenuItems";
-export * from "./workspace-schemas";
-export * from "./WorkspaceRepository";
-export * from "./WorkspacePersistentState";
-export * from "./WorkspaceController";
-export * from "./workspace-component-registry";
-export * from "./WorkspaceHost";
-export * from "./WorkspaceStartPanel";
 export * from "./shell-workspace-components";
+/**
+ * The workspace model now lives in @vuu-ui/core. These re-exports keep
+ * existing @vuu-ui/vuu-shell imports working.
+ */
+export { APPLICATION_SESSION_VERSION, type ApplicationSessionV1, type ComponentPersistentStateV1, type ComponentStateUpdate, cloneWorkspaceValue, createWorkspaceComponentRegistries, emptyWorkspaceSnapshot, jsonValueWorkspaceComponentCodec, NAMED_WORKSPACE_DEFINITION_VERSION, type NamedWorkspaceDefinitionV1, type NamedWorkspaceMetadataV1, type OpenWorkspaceInstanceV1, StaleWorkspaceScopeError, useComponentPersistentState, useWorkspace, useWorkspacePersistentStateStore, validateApplicationSessionV1, validateNamedWorkspaceDefinitionV1, validateNamedWorkspaceMetadataV1, validateWorkspaceSnapshotRecordV1, validateWorkspaceSnapshotV1, WORKSPACE_SNAPSHOT_RECORD_VERSION, WORKSPACE_SNAPSHOT_VERSION, type WorkspaceComponentRegistration, type WorkspaceComponentRegistries, type WorkspaceContextValue, WorkspaceController, type WorkspaceControllerOptions, WorkspaceHost, type WorkspaceKind, workspaceMetadata, WorkspacePersistentStateProvider, type WorkspacePersistentStateProviderProps, WorkspacePersistentStateStore, type WorkspaceProps, WorkspaceProvider, type WorkspaceProviderProps, WorkspaceRepository, WorkspaceRepositoryDisposedError, type WorkspaceSchemaName, type WorkspaceSnapshotRecordV1, type WorkspaceSnapshotV1, WorkspaceStartPanel, type WorkspaceStatus, type WorkspaceSummary, WorkspaceValidationError, type WorkspaceValidationIssue, } from "@vuu-ui/core";

package/types/workspace-management/shell-workspace-components.d.ts

@@ -1,2 +1,2 @@
-import type { WorkspaceComponentRegistration } from "./workspace-component-registry";
+import type { WorkspaceComponentRegistration } from "@vuu-ui/core";
 export declare const shellWorkspaceComponentRegistrations: readonly WorkspaceComponentRegistration<unknown>[];

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 };