@vuu-ui/vuu-shell 4.1.0 → 5.0.0-alpha.2

package/src/workspace-management/LayoutList.js

@@ -1,15 +1,10 @@
 import { jsx, jsxs } from "react/jsx-runtime";
-import { createElement, useCallback, useMemo } from "react";
-import { IconButton } from "@vuu-ui/vuu-ui-controls";
 import { ListBox, Option } from "@salt-ds/core";
-import { VuuShellLocation } from "@vuu-ui/vuu-utils";
 import { useComponentCssInjection } from "@salt-ds/styles";
 import { useWindow } from "@salt-ds/window";
+import { IconButton } from "@vuu-ui/vuu-ui-controls";
 import clsx from "clsx";
-import { LayoutTile } from "./LayoutTile.js";
-import { useWorkspace } from "./WorkspaceProvider.js";
-import { useLayouts } from "../feature-and-layout-provider/index.js";
-import { layoutFromJson, useLayoutProviderDispatch } from "@vuu-ui/vuu-layout";
+import { useWorkspace } from "@vuu-ui/core";
 import LayoutList from "./LayoutList.css";
 const classBase = "vuuLayoutList";
 const NO_SELECTION = [];
@@ -20,108 +15,73 @@ const LayoutList_LayoutList = ({ className, title, ...htmlAttributes })=>{
         css: LayoutList,
         window: targetWindow
     });
-    const { layoutMetadata, loadLayoutById } = useWorkspace();
-    const { systemLayouts } = useLayouts();
-    const handleLoadLayout = useCallback((layoutId)=>{
-        if (layoutId) loadLayoutById(layoutId);
-    }, [
-        loadLayoutById
-    ]);
-    const dispatch = useLayoutProviderDispatch();
-    const handleLoadSysLayout = (layoutId, layoutJSON)=>{
-        if (layoutJSON) dispatch({
-            type: "add",
-            path: `#${VuuShellLocation.Workspace}`,
-            component: layoutFromJson(layoutJSON, "0")
-        });
-        else throw Error("layoutJSON is required for system layouts");
-    };
-    const layoutsByGroup = layoutMetadata.reduce((acc, cur)=>{
-        if (acc[cur.group]) return {
-            ...acc,
-            [cur.group]: [
-                ...acc[cur.group],
-                cur
-            ]
-        };
-        return {
-            ...acc,
-            [cur.group]: [
-                cur
-            ]
-        };
-    }, {});
-    let sysContent = [];
-    if (systemLayouts) sysContent = [
-        /*#__PURE__*/ jsxs("div", {
-            className: `${classBase}-group`,
-            children: [
-                /*#__PURE__*/ jsx("div", {
-                    className: `${classBase}-groupHeader`,
-                    children: "System Layout"
-                }),
-                /*#__PURE__*/ jsx(ListBox, {
-                    selected: NO_SELECTION,
-                    children: systemLayouts.map((layout)=>/*#__PURE__*/ jsx(Option, {
-                            value: layout,
-                            children: /*#__PURE__*/ createElement(LayoutTile, {
-                                ...htmlAttributes,
-                                key: layout.id,
-                                metadata: layout,
-                                onLoadLayout: handleLoadSysLayout
-                            })
-                        }, layout.id))
-                })
-            ]
-        }, 0)
-    ];
-    const content = useMemo(()=>Object.entries(layoutsByGroup).map(([heading, layoutMetadata], index)=>/*#__PURE__*/ jsxs("div", {
-                className: `${classBase}-group`,
-                children: [
-                    /*#__PURE__*/ jsx("div", {
-                        className: `${classBase}-groupHeader`,
-                        children: heading
-                    }),
-                    /*#__PURE__*/ jsx(ListBox, {
-                        selected: NO_SELECTION,
-                        children: layoutMetadata.map((layout)=>/*#__PURE__*/ jsxs(Option, {
-                                value: layout,
-                                children: [
-                                    /*#__PURE__*/ createElement(LayoutTile, {
-                                        ...htmlAttributes,
-                                        key: layout.id,
-                                        metadata: layout,
-                                        onLoadLayout: handleLoadLayout
-                                    }),
-                                    /*#__PURE__*/ jsx(IconButton, {
-                                        className: `${classBase}-menu`,
-                                        "data-embedded": true,
-                                        icon: "more-vert",
-                                        appearance: "transparent",
-                                        sentiment: "neutral"
-                                    })
-                                ]
-                            }, layout.id))
-                    })
-                ]
-            }, index)), [
-        handleLoadLayout,
-        htmlAttributes,
-        layoutsByGroup
-    ]);
+    const { deleteNamedWorkspace, namedWorkspaces, openNamedWorkspace, openSystemWorkspace, status, systemWorkspaces } = useWorkspace();
     return /*#__PURE__*/ jsxs("div", {
         ...htmlAttributes,
-        className: clsx(classBase, "vuuScrollable"),
+        className: clsx(classBase, className, "vuuScrollable"),
         children: [
             /*#__PURE__*/ jsx("div", {
                 className: `${classBase}-header`,
                 children: title
             }),
-            /*#__PURE__*/ jsx("div", {
+            /*#__PURE__*/ jsxs("div", {
                 className: `${classBase}-content`,
                 children: [
-                    sysContent,
-                    ...content
+                    "loading" === status ? /*#__PURE__*/ jsx("div", {
+                        role: "status",
+                        children: "Loading layouts…"
+                    }) : null,
+                    systemWorkspaces.length > 0 ? /*#__PURE__*/ jsxs("div", {
+                        className: `${classBase}-group`,
+                        children: [
+                            /*#__PURE__*/ jsx("div", {
+                                className: `${classBase}-groupHeader`,
+                                children: "System Layouts"
+                            }),
+                            /*#__PURE__*/ jsx(ListBox, {
+                                selected: NO_SELECTION,
+                                children: systemWorkspaces.map((definition)=>/*#__PURE__*/ jsx(Option, {
+                                        value: definition.id,
+                                        children: /*#__PURE__*/ jsx("button", {
+                                            onClick: ()=>void openSystemWorkspace(definition),
+                                            type: "button",
+                                            children: definition.name
+                                        })
+                                    }, definition.id))
+                            })
+                        ]
+                    }) : null,
+                    /*#__PURE__*/ jsxs("div", {
+                        className: `${classBase}-group`,
+                        children: [
+                            /*#__PURE__*/ jsx("div", {
+                                className: `${classBase}-groupHeader`,
+                                children: "My Layouts"
+                            }),
+                            0 === namedWorkspaces.length && "loading" !== status ? /*#__PURE__*/ jsx("div", {
+                                children: "No saved workspaces"
+                            }) : /*#__PURE__*/ jsx(ListBox, {
+                                selected: NO_SELECTION,
+                                children: namedWorkspaces.map((definition)=>/*#__PURE__*/ jsxs(Option, {
+                                        value: definition.id,
+                                        children: [
+                                            /*#__PURE__*/ jsx("button", {
+                                                onClick: ()=>void openNamedWorkspace(definition.id),
+                                                type: "button",
+                                                children: definition.name
+                                            }),
+                                            /*#__PURE__*/ jsx(IconButton, {
+                                                "aria-label": `Delete ${definition.name}`,
+                                                appearance: "transparent",
+                                                icon: "delete",
+                                                onClick: ()=>void deleteNamedWorkspace(definition.id),
+                                                sentiment: "neutral"
+                                            })
+                                        ]
+                                    }, definition.id))
+                            })
+                        ]
+                    })
                 ]
             })
         ]

package/src/workspace-management/SaveLayoutPanel.js

@@ -2,10 +2,10 @@ import { jsx, jsxs } from "react/jsx-runtime";
 import { Button, ComboBox, FormField, FormFieldLabel, Input, Option, Text } from "@salt-ds/core";
 import { useComponentCssInjection } from "@salt-ds/styles";
 import { useWindow } from "@salt-ds/window";
+import { useAuthenticatedUser } from "@vuu-ui/core";
 import { useCallback, useEffect, useMemo, useState } from "react";
 import { takeScreenshot } from "./screenshot-utils.js";
 import SaveLayoutPanel from "./SaveLayoutPanel.css";
-import { useApplicationUser } from "../application-provider/index.js";
 const classBase = "vuuSaveLayoutPanel";
 const groups = [
     "Group 1",
@@ -26,7 +26,7 @@ const SaveLayoutPanel_SaveLayoutPanel = (props)=>{
     const [group, setGroup] = useState("");
     const [screenshot, setScreenshot] = useState();
     const [screenshotErrorMessage, setScreenshotErrorMessage] = useState();
-    const { username } = useApplicationUser();
+    const { userName } = useAuthenticatedUser();
     useEffect(()=>{
         if (componentId) takeScreenshot(document.getElementById(componentId)).then((screenshot)=>{
             setScreenshot(screenshot);
@@ -41,7 +41,7 @@ const SaveLayoutPanel_SaveLayoutPanel = (props)=>{
             name: layoutName,
             group,
             screenshot: screenshot ?? "",
-            user: username
+            user: userName
         });
     };
     const screenshotContent = useMemo(()=>{

package/src/workspace-management/index.js

@@ -1,5 +1,6 @@
 export * from "./SaveLayoutPanel.js";
 export * from "./LayoutList.js";
-export * from "./WorkspaceProvider.js";
 export * from "./defaultWorkspaceJSON.js";
 export * from "./useWorkspaceContextMenuItems.js";
+export * from "./shell-workspace-components.js";
+export { APPLICATION_SESSION_VERSION, NAMED_WORKSPACE_DEFINITION_VERSION, StaleWorkspaceScopeError, WORKSPACE_SNAPSHOT_RECORD_VERSION, WORKSPACE_SNAPSHOT_VERSION, WorkspaceController, WorkspaceHost, WorkspacePersistentStateProvider, WorkspacePersistentStateStore, WorkspaceProvider, WorkspaceRepository, WorkspaceRepositoryDisposedError, WorkspaceStartPanel, WorkspaceValidationError, cloneWorkspaceValue, createWorkspaceComponentRegistries, emptyWorkspaceSnapshot, jsonValueWorkspaceComponentCodec, useComponentPersistentState, useWorkspace, useWorkspacePersistentStateStore, validateApplicationSessionV1, validateNamedWorkspaceDefinitionV1, validateNamedWorkspaceMetadataV1, validateWorkspaceSnapshotRecordV1, validateWorkspaceSnapshotV1, workspaceMetadata } from "@vuu-ui/core";

package/src/workspace-management/shell-workspace-components.js

@@ -0,0 +1,59 @@
+import { jsx } from "react/jsx-runtime";
+import { featureFromJson } from "@vuu-ui/vuu-utils";
+import { Feature } from "../feature/index.js";
+const isRecord = (value)=>"object" == typeof value && null !== value && !Array.isArray(value);
+const dynamicFeatureCodec = {
+    decode: (value)=>isRecord(value) && "string" == typeof value.mfComponent && "string" == typeof value.mfScope && "string" == typeof value.mfUrl ? {
+            ok: true,
+            value: value
+        } : {
+            error: {
+                code: "INVALID_DYNAMIC_FEATURE",
+                message: "dynamic feature settings require mfComponent, mfScope and mfUrl",
+                path: "$"
+            },
+            ok: false
+        },
+    encode: (value)=>({
+            ok: true,
+            value
+        }),
+    isSettings: (value)=>"object" == typeof value && null !== value && "mfComponent" in value && "mfScope" in value && "mfUrl" in value && "string" == typeof value.mfComponent && "string" == typeof value.mfScope && "string" == typeof value.mfUrl,
+    version: 1
+};
+const staticFeatureCodec = {
+    decode: (value)=>isRecord(value) && "string" == typeof value.type ? {
+            ok: true,
+            value: {
+                type: value.type
+            }
+        } : {
+            error: {
+                code: "INVALID_STATIC_FEATURE",
+                message: "static feature settings require a component type",
+                path: "$.type"
+            },
+            ok: false
+        },
+    encode: (value)=>({
+            ok: true,
+            value
+        }),
+    isSettings: (value)=>"object" == typeof value && null !== value && "type" in value && "string" == typeof value.type,
+    version: 1
+};
+const shellWorkspaceComponentRegistrations = [
+    {
+        codec: dynamicFeatureCodec,
+        render: (settings)=>/*#__PURE__*/ jsx(Feature, {
+                ...settings
+            }),
+        type: "vuu-dynamic-feature"
+    },
+    {
+        codec: staticFeatureCodec,
+        render: (settings)=>featureFromJson(settings),
+        type: "vuu-static-feature"
+    }
+];
+export { shellWorkspaceComponentRegistrations };

package/src/workspace-management/useWorkspaceContextMenuItems.js

@@ -1,10 +1,9 @@
 import { jsx } from "react/jsx-runtime";
-import { useModal } from "@vuu-ui/vuu-ui-controls";
+import { useModal, useWorkspace } from "@vuu-ui/core";
 import { useCallback, useMemo } from "react";
 import { SaveLayoutPanel } from "./SaveLayoutPanel.js";
-import { useWorkspace } from "./WorkspaceProvider.js";
 const useWorkspaceContextMenuItems = ()=>{
-    const { saveLayout } = useWorkspace();
+    const { activeWorkspace, closeWorkspace, saveActiveWorkspaceAs } = useWorkspace();
     const { showDialog, closeDialog } = useModal();
     const handleCloseDialog = useCallback(()=>{
         closeDialog();
@@ -12,11 +11,11 @@ const useWorkspaceContextMenuItems = ()=>{
         closeDialog
     ]);
     const handleSave = useCallback((layoutMetadata)=>{
-        saveLayout(layoutMetadata);
+        saveActiveWorkspaceAs(layoutMetadata.name);
         closeDialog();
     }, [
-        saveLayout,
-        closeDialog
+        closeDialog,
+        saveActiveWorkspaceAs
     ]);
     const [buildMenuOptions, handleMenuAction] = useMemo(()=>[
             (location, options)=>{
@@ -27,8 +26,8 @@ const useWorkspaceContextMenuItems = ()=>{
                     id: "save-layout",
                     options
                 }, {
-                    label: "Layout Settings",
-                    id: "layout-settings",
+                    label: "Close Workspace",
+                    id: "close-workspace",
                     options
                 });
                 return menuDescriptors;
@@ -43,9 +42,15 @@ const useWorkspaceContextMenuItems = ()=>{
                     }), "Save Layout", [], true);
                     return true;
                 }
+                if ("close-workspace" === menuItemId && activeWorkspace) {
+                    closeWorkspace(activeWorkspace.instanceId);
+                    return true;
+                }
                 return false;
             }
         ], [
+        activeWorkspace,
+        closeWorkspace,
         handleCloseDialog,
         handleSave,
         showDialog

package/types/app-header/AppHeader.d.ts

@@ -1,5 +1,5 @@
 import type { ThemeMode } from "@vuu-ui/vuu-utils";
-import { HTMLAttributes } from "react";
+import { type HTMLAttributes } from "react";
 export interface AppHeaderProps extends HTMLAttributes<HTMLDivElement> {
     themeMode?: ThemeMode;
 }

package/types/application-provider/ApplicationContext.d.ts

@@ -1,11 +1,6 @@
-import type { Settings, VuuUser } from "@vuu-ui/vuu-utils";
-import { VuuRowDataItemType } from "@vuu-ui/vuu-protocol-types";
-import { SettingsSchema } from "../user-settings";
+import type { VuuRowDataItemType } from "@vuu-ui/vuu-protocol-types";
 export interface ApplicationContextProps {
     onUserSettingChanged: (propertyName: string, value: VuuRowDataItemType) => void;
     logout?: () => void;
-    userSettings?: Settings;
-    userSettingsSchema?: SettingsSchema;
-    user: VuuUser;
 }
 export declare const ApplicationContext: import("react").Context<ApplicationContextProps>;

package/types/application-provider/ApplicationProvider.d.ts

@@ -1,17 +1,8 @@
-import { VuuRowDataItemType } from "@vuu-ui/vuu-protocol-types";
-import { Density, ThemeContextProps } from "@salt-ds/core";
-import { ReactElement, ReactNode } from "react";
-import { ApplicationContextProps } from "./ApplicationContext";
-export interface ApplicationProviderProps extends Partial<Pick<ThemeContextProps, "theme" | "mode">>, Partial<Omit<ApplicationContextProps, "userSettings">> {
+import { type Density, type ThemeContextProps } from "@salt-ds/core";
+import { type ReactElement, type ReactNode } from "react";
+import { type ApplicationContextProps } from "./ApplicationContext";
+export interface ApplicationProviderProps extends Partial<Pick<ThemeContextProps, "theme" | "mode">>, Partial<ApplicationContextProps> {
     children: ReactNode;
     density?: Density;
 }
-export declare const ApplicationProvider: ({ children, density: densityProp, logout, mode, theme, userSettingsSchema: userSettingsSchema, user, }: ApplicationProviderProps) => ReactElement | null;
-export declare const useApplicationUser: () => import("@vuu-ui/vuu-utils").VuuUser;
-export declare const useApplicationSettings: () => {
-    onUserSettingChanged: (propertyName: string, value: VuuRowDataItemType) => void;
-    userSettings: import("@vuu-ui/vuu-utils").Settings | undefined;
-    userSettingsSchema: import("..").SettingsSchema | undefined;
-};
-export declare const useUserSetting: () => import("@vuu-ui/vuu-utils").Settings | undefined;
-export declare const useLogout: () => (() => void) | undefined;
+export declare const ApplicationProvider: ({ children, density: densityProp, logout, mode, theme, }: ApplicationProviderProps) => ReactElement | null;

package/types/feature/Feature.d.ts

@@ -1,10 +1,2 @@
-import { type DynamicFeatureProps } from "@vuu-ui/vuu-utils";
-import React from "react";
-declare function RawFeature<Params extends object | undefined>({ url, css, ComponentProps: params, ...props }: DynamicFeatureProps<Params>): React.JSX.Element;
-/**
-  Feature is a wrapper around React Lazy Loading. It will load a component
-  from the given url. That url must resolve to a javascript bundle with a
-  single default export. That export must be a React component.
- */
-export declare const Feature: React.MemoExoticComponent<typeof RawFeature>;
-export {};
+/** @deprecated Use RemoteModule from @vuu-ui/core/portal. */
+export declare const Feature: import("react").MemoExoticComponent<(props: import("@vuu-ui/core/portal").RemoteModuleProps) => import("react").JSX.Element>;

package/types/feature/index.d.ts

@@ -1 +1,2 @@
-export * from './Feature';
+export * from "./Feature";
+export { RemoteModule, type RemoteModuleProps, } from "@vuu-ui/core/portal";

package/types/feature-list/FeatureList.d.ts

@@ -1,7 +1,7 @@
-import { DynamicFeatureProps, StaticFeatureDescriptor } from "@vuu-ui/vuu-utils";
-import { HTMLAttributes } from "react";
+import { type DynamicFeatureProps, type StaticFeatureDescriptor } from "@vuu-ui/vuu-utils";
+import { type HTMLAttributes } from "react";
 export type GroupedFeatureProps<P extends object | undefined = object> = Record<string, DynamicFeatureProps<P>[]>;
 export interface FeatureListProps extends HTMLAttributes<HTMLDivElement> {
-    features: DynamicFeatureProps[] | GroupedFeatureProps | StaticFeatureDescriptor[];
+    readonly features: DynamicFeatureProps[] | GroupedFeatureProps | StaticFeatureDescriptor[];
 }
 export declare const FeatureList: ({ features, title, ...htmlAttributes }: FeatureListProps) => import("react").JSX.Element;

package/types/index.d.ts

@@ -1,14 +1,14 @@
-export * from "./application-provider";
 export * from "./app-header";
+export * from "./application-provider";
 export * from "./feature";
 export * from "./feature-and-layout-provider";
+export * from "./feature-list";
 export * from "./left-nav";
 export { LoginPanel, type LoginPanelProps } from "./login/LoginPanel";
+export { getRegisteredModules } from './module-registry/getRegisteredModules';
 export * from "./persistence-manager";
 export * from "./shell";
 export * from "./shell-layout-templates";
 export * from "./ShellContextProvider";
-export * from "./feature-list";
 export * from "./theme-switch";
-export * from "./user-settings";
 export * from "./workspace-management";

package/types/left-nav/LeftNav.d.ts

@@ -7,6 +7,7 @@ export interface LeftNavProps extends HTMLAttributes<HTMLDivElement> {
     defaultExpanded?: boolean;
     onActiveChange?: (activeTabIndex: number) => void;
     onTogglePrimaryMenu?: (expanded: boolean) => void;
+    onWidthChange?: (width: number) => void;
     sizeCollapsed?: number;
     sizeContent?: number;
     sizeExpanded?: number;

package/types/persistence-manager/PersistenceProvider.d.ts

@@ -1,11 +1,14 @@
-import { ReactElement, ReactNode } from "react";
-import { IPersistenceManager } from ".";
+import { type WorkspacePersistenceService } from "@vuu-ui/core";
+import { type ReactElement, type ReactNode } from "react";
+import type { IPersistenceManager } from "./PersistenceManager";
+export { useOptionalWorkspacePersistenceService, useWorkspacePersistenceService, } from "@vuu-ui/core";
 export interface PersistenceContextProps {
     persistenceManager?: IPersistenceManager;
+    workspacePersistenceService?: WorkspacePersistenceService;
 }
 export declare const PersistenceContext: import("react").Context<PersistenceContextProps>;
 export interface PersistenceProviderProps extends PersistenceContextProps {
     children: ReactNode;
 }
-export declare const PersistenceProvider: ({ children, persistenceManager, }: PersistenceProviderProps) => ReactElement;
+export declare const PersistenceProvider: ({ children, persistenceManager, workspacePersistenceService, }: PersistenceProviderProps) => ReactElement;
 export declare const usePersistenceManager: () => IPersistenceManager | undefined;

package/types/persistence-manager/index.d.ts

@@ -3,3 +3,4 @@ export * from "./PersistenceProvider";
 export * from "./LocalPersistenceManager";
 export * from "./RemotePersistenceManager";
 export * from "./StaticPersistenceManager";
+export { LocalWorkspacePersistenceService, type PersistenceScope, type RemoteWorkspacePersistenceOptions, RemoteWorkspacePersistenceService, type UserPersistenceScope, WorkspacePersistenceError, type WorkspacePersistenceService, type WorkspaceRequestInitProvider, } from "@vuu-ui/core";

package/types/shell-layout-templates/context-panel/ApplicationSettingsContextPanel.d.ts

@@ -1 +1 @@
-export declare const ApplicationSettingsContextPanel: () => import("react/jsx-runtime").JSX.Element;
+export declare const ApplicationSettingsContextPanel: () => import("react").JSX.Element;

package/types/shell-layout-templates/context-panel/ContextPanel.d.ts

@@ -1,13 +1,11 @@
-import { LayoutJSON } from "@vuu-ui/vuu-utils";
-import React, { ReactElement, ReactNode } from "react";
+import { type ReactElement, type ReactNode } from "react";
 export interface ContextPanelProps {
-    [key: string]: unknown;
-    className?: string;
-    content?: ReactElement | LayoutJSON;
-    expanded?: boolean;
-    id?: string;
-    onClose?: () => void;
-    overlay?: boolean;
-    title?: ReactNode;
+    readonly className?: string;
+    readonly content?: ReactElement;
+    readonly expanded?: boolean;
+    readonly id?: string;
+    readonly onClose?: () => void;
+    readonly overlay?: boolean;
+    readonly title?: ReactNode;
 }
-export declare const ContextPanel: ({ className: classNameProp, expanded, content: contentProp, id, onClose, overlay, title, }: ContextPanelProps) => React.JSX.Element;
+export declare const ContextPanel: ({ className, content, expanded, id, onClose, overlay, title, }: ContextPanelProps) => import("react").JSX.Element;

package/types/shell-layout-templates/context-panel/index.d.ts

@@ -1 +1,2 @@
 export * from "./ContextPanel";
+export * from "./ApplicationSettingsContextPanel";

package/types/shell-layout-templates/full-height-left-panel/useFullHeightLeftPanel.d.ts

@@ -1,2 +1,2 @@
-import { ShellLayoutTemplateHook } from "../useShellLayout";
+import type { ShellLayoutTemplateHook } from "../useShellLayout";
 export declare const useFullHeightLeftPanel: ShellLayoutTemplateHook;

package/types/shell-layout-templates/inlay-left-panel/useInlayLeftPanel.d.ts

@@ -1,2 +1,2 @@
-import { ShellLayoutTemplateHook } from "../useShellLayout";
+import type { ShellLayoutTemplateHook } from "../useShellLayout";
 export declare const useInlayLeftPanel: ShellLayoutTemplateHook;

package/types/shell-layout-templates/left-main-tabs/useLeftMainTabs.d.ts

@@ -1,2 +1,2 @@
-import { ShellLayoutTemplateHook } from "../useShellLayout";
+import type { ShellLayoutTemplateHook } from "../useShellLayout";
 export declare const useLeftMainTabs: ShellLayoutTemplateHook;

package/types/shell-layout-templates/simple-content-pane/useSimpleContentPane.d.ts

@@ -1,2 +1,2 @@
-import { ShellLayoutTemplateHook } from "../useShellLayout";
+import type { ShellLayoutTemplateHook } from "../useShellLayout";
 export declare const useSimpleContentPane: ShellLayoutTemplateHook;

package/types/shell-layout-templates/useShellLayout.d.ts

@@ -1,5 +1,5 @@
-import { HTMLAttributes, ReactElement, ReactNode } from "react";
-import { SidePanelProps as ShellSidePanelProps } from "./side-panel";
+import type { HTMLAttributes, ReactElement, ReactNode } from "react";
+import type { SidePanelProps as ShellSidePanelProps } from "./side-panel";
 declare const LayoutHook: {
     "full-height": ShellLayoutTemplateHook;
     inlay: ShellLayoutTemplateHook;
@@ -41,6 +41,8 @@ export interface ShellLayoutProps {
      * If template renders Toolbar, these props will be provided
      */
     ToolbarProps?: ShellToolbarProps;
+    /** Supplied by Shell; application code should not normally set this. */
+    workspaceHost?: ReactNode;
 }
 /**
  * This hook acts as a stub for the actual shell layout

package/types/shell.d.ts

@@ -1,17 +1,21 @@
-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;
+import { type ShellLayoutProps } from "./shell-layout-templates";
+import { type WorkspaceProps } from "./workspace-management";
+export interface ShellProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange"> {
+    readonly appHeader?: ReactNode;
+    readonly children?: ReactNode;
+    readonly leftNavWidth?: number;
+    readonly logout?: () => void;
+    readonly saveUrl?: string;
+    readonly serverUrl?: string;
+    /** @deprecated The shell now uses one canonical static GridLayout structure. */
+    readonly shellLayoutProps?: ShellLayoutProps;
+    readonly workspaceProps?: WorkspaceProps;
 }
-export declare const Shell: ({ logout, user, userSettingsSchema, workspaceProps, ...props }: ShellProps) => import("react").JSX.Element;
+export interface StaticShellLayoutProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange"> {
+    readonly appHeader?: ReactNode;
+    readonly leftNavWidth?: number;
+    readonly workspaceHost?: ReactNode;
+}
+export declare const StaticShellLayout: ({ appHeader, className, leftNavWidth: initialLeftNavWidth, style, workspaceHost, ...htmlAttributes }: StaticShellLayoutProps) => import("react").JSX.Element;
+export declare const Shell: ({ appHeader, children, leftNavWidth, logout, saveUrl: _saveUrl, serverUrl: _serverUrl, shellLayoutProps, workspaceProps, ...htmlAttributes }: ShellProps) => import("react").JSX.Element;

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

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

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

@@ -1,4 +1,4 @@
-import { LayoutMetadataDto } from "@vuu-ui/vuu-utils";
+import type { LayoutMetadataDto } from "@vuu-ui/vuu-utils";
 type SaveLayoutPanelProps = {
     componentId?: string;
     defaultTitle?: string;

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

@@ -1,10 +1,11 @@
-import { StackProps } from "@vuu-ui/vuu-layout";
-import { LayoutJSON } from "@vuu-ui/vuu-utils";
-export type WorkspaceStackProps = Pick<StackProps, "showTabs" | "TabstripProps">;
+import type { HTMLAttributes } from "react";
+import { type LayoutJSON } from "@vuu-ui/vuu-utils";
+export interface WorkspaceStackProps {
+    readonly showTabs?: boolean | "left" | "right";
+    readonly TabstripProps?: HTMLAttributes<HTMLDivElement>;
+}
 export declare const warningLayout: LayoutJSON;
 export declare const loadingJSON: Readonly<LayoutJSON>;
-export declare const defaultWorkspaceJSON: LayoutJSON<StackProps & {
-    preserve: boolean;
-}>;
+export declare const defaultWorkspaceJSON: LayoutJSON;
 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/workspace-management/index.d.ts

@@ -1,5 +1,10 @@
 export * from "./SaveLayoutPanel";
 export * from "./LayoutList";
-export * from "./WorkspaceProvider";
 export * from "./defaultWorkspaceJSON";
 export * from "./useWorkspaceContextMenuItems";
+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/useWorkspaceContextMenuItems.d.ts

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