@vuu-ui/vuu-utils 0.8.76 → 0.8.77

package/types/vuu-shell/src/feature-provider/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./FeatureProvider";
+export * from "./useVuuFeatures";

package/types/vuu-shell/src/feature-provider/useVuuFeatures.d.ts

@@ -0,0 +1,9 @@
+import { Features, FilterTableFeatureProps } from "@vuu-ui/vuu-utils";
+import { FeatureProps } from "../feature/Feature";
+export interface FeaturesHookProps {
+    features: Features;
+}
+export declare const useVuuFeatures: ({ features, }: FeaturesHookProps) => [
+    FeatureProps[],
+    FeatureProps<FilterTableFeatureProps>[]
+];

package/types/vuu-shell/src/index.d.ts

@@ -0,0 +1,16 @@
+export * from "./application-provider";
+export * from "./app-header";
+export * from "./connection-status";
+export * from "./datasource-provider";
+export * from "./feature";
+export * from "./feature-provider";
+export * from "./left-nav";
+export * from "./login";
+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/vuu-shell/src/left-nav/LeftNav.d.ts

@@ -0,0 +1,18 @@
+import { FilterTableFeatureProps } from "@vuu-ui/vuu-utils";
+import { HTMLAttributes } from "react";
+import { FeatureProps } from "../feature";
+export type NavDisplayStatus = "menu-full" | "menu-icons" | "menu-full-content" | "menu-icons-content";
+export type NavDisplayStatusHandler = (navDisplayStatus: NavDisplayStatus) => void;
+export interface LeftNavProps extends HTMLAttributes<HTMLDivElement> {
+    "data-path"?: string;
+    defaultActiveTabIndex?: number;
+    defaultExpanded?: boolean;
+    features?: FeatureProps[];
+    onActiveChange?: (activeTabIndex: number) => void;
+    onTogglePrimaryMenu?: (expanded: boolean) => void;
+    sizeCollapsed?: number;
+    sizeContent?: number;
+    sizeExpanded?: number;
+    tableFeatures?: FeatureProps<FilterTableFeatureProps>[];
+}
+export declare const LeftNav: (props: LeftNavProps) => JSX.Element;

package/types/vuu-shell/src/left-nav/index.d.ts

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

package/types/vuu-shell/src/login/LoginPanel.d.ts

@@ -0,0 +1,7 @@
+import { HTMLAttributes } from "react";
+export interface LoginPanelProps extends Omit<HTMLAttributes<HTMLDivElement>, "onSubmit"> {
+    appName?: string;
+    onSubmit: (username: string, password?: string) => void;
+    requirePassword?: boolean;
+}
+export declare const LoginPanel: ({ appName, className, requirePassword, onSubmit, ...htmlAttributes }: LoginPanelProps) => JSX.Element;

package/types/vuu-shell/src/login/VuuLogo.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const VuuLogo: () => JSX.Element;

package/types/vuu-shell/src/login/index.d.ts

@@ -0,0 +1,2 @@
+export * from './LoginPanel';
+export * from './login-utils';

package/types/vuu-shell/src/login/login-utils.d.ts

@@ -0,0 +1,4 @@
+export declare const getAuthModeFromCookies: () => string;
+export declare const getAuthDetailsFromCookies: () => [string, string];
+export declare const redirectToLogin: (loginUrl?: string) => void;
+export declare const logout: (loginUrl?: string) => void;

package/types/vuu-shell/src/persistence-manager/LocalPersistenceManager.d.ts

@@ -0,0 +1,21 @@
+import { ApplicationJSON, LayoutJSON, Settings, Layout, LayoutMetadata, LayoutMetadataDto } from "@vuu-ui/vuu-utils";
+import { IPersistenceManager } from "./PersistenceManager";
+export declare class LocalPersistenceManager implements IPersistenceManager {
+    #private;
+    metadataSaveLocation: string;
+    layoutsSaveLocation: string;
+    constructor(urlKey?: string);
+    createLayout(metadata: LayoutMetadataDto, layout: LayoutJSON): Promise<LayoutMetadata>;
+    updateLayout(id: string, newMetadata: LayoutMetadataDto, newLayout: LayoutJSON): Promise<void>;
+    deleteLayout(id: string): Promise<void>;
+    loadLayout(id: string): Promise<LayoutJSON>;
+    loadMetadata(): Promise<LayoutMetadata[]>;
+    loadApplicationJSON(): Promise<ApplicationJSON | undefined>;
+    saveApplicationJSON(applicationJSON: ApplicationJSON): Promise<void>;
+    loadLayouts: () => Promise<Layout[]>;
+    saveLayoutsWithMetadata: (layouts: Layout[], metadata: LayoutMetadata[]) => void;
+    validateIds: (id: string) => Promise<void>;
+    validateId: (id: string, dataType: "metadata" | "layout") => Promise<void>;
+    getUserSettings(): Promise<Settings>;
+    saveUserSettings(userSettings: Settings): void;
+}

package/types/vuu-shell/src/persistence-manager/PersistenceManager.d.ts

@@ -0,0 +1,66 @@
+import type { ApplicationJSON, LayoutJSON, LayoutMetadata, LayoutMetadataDto, Settings } from "@vuu-ui/vuu-utils";
+export interface IPersistenceManager {
+    /**
+     * Saves a new layout and its corresponding metadata
+     *
+     * @param metadata - Metadata about the layout to be saved
+     * @param layout   - Full JSON representation of the layout to be saved
+     *
+     * @returns Unique identifier assigned to the saved layout
+     */
+    createLayout: (metadata: LayoutMetadataDto, layout: LayoutJSON) => Promise<LayoutMetadata>;
+    /**
+     * Overwrites an existing layout and its corresponding metadata with the provided information
+     *
+     * @param id       - Unique identifier of the existing layout to be updated
+     * @param metadata - Metadata describing the new layout to overwrite with
+     * @param layout   - Full JSON representation of the new layout to overwrite with
+     */
+    updateLayout: (id: string, metadata: LayoutMetadataDto, layout: LayoutJSON) => Promise<void>;
+    /**
+     * Deletes an existing layout and its corresponding metadata
+     *
+     * @param id - Unique identifier of the existing layout to be deleted
+     */
+    deleteLayout: (id: string) => Promise<void>;
+    /**
+     * Retrieves an existing layout
+     *
+     * @param id - Unique identifier of the existing layout to be retrieved
+     *
+     * @returns Full JSON representation of the layout corresponding to the provided ID
+     */
+    loadLayout: (id: string) => Promise<LayoutJSON>;
+    /**
+     * Retrieves metadata for all existing layouts
+     *
+     * @returns an array of all persisted layout metadata
+     */
+    loadMetadata: () => Promise<LayoutMetadata[]>;
+    /**
+     * Retrieves the application JSON. This includes the application layout,
+     * which describes all layouts on screen
+     *
+     * @returns Full JSON representation of the application json
+     */
+    loadApplicationJSON: () => Promise<ApplicationJSON | undefined>;
+    /**
+     * Saves the application JSON.  This includes the application layout,
+     * which describes all layouts on screen
+     *
+     * @param layout - Full JSON representation of the application layout to be saved
+     */
+    saveApplicationJSON: (layout: ApplicationJSON) => Promise<void>;
+    /**
+     * Save user settings. These get saved within the Application JSON.
+     *
+     * @param userSettings
+     */
+    saveUserSettings: (userSettings: Settings) => void;
+    /**
+     * Get the user settings. These are stored within Application JSON.
+     *
+     * @returns userSettings
+     */
+    getUserSettings: () => Promise<Settings>;
+}

package/types/vuu-shell/src/persistence-manager/PersistenceProvider.d.ts

@@ -0,0 +1,11 @@
+import { ReactElement, ReactNode } from "react";
+import { IPersistenceManager } from ".";
+export interface PersistenceContextProps {
+    persistenceManager?: IPersistenceManager;
+}
+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 usePersistenceManager: () => IPersistenceManager | undefined;

package/types/vuu-shell/src/persistence-manager/RemotePersistenceManager.d.ts

@@ -0,0 +1,23 @@
+import { ApplicationJSON, LayoutJSON, LayoutMetadata, LayoutMetadataDto, Settings } from "@vuu-ui/vuu-utils";
+import { IPersistenceManager } from "./PersistenceManager";
+export type CreateLayoutResponseDto = {
+    metadata: LayoutMetadata;
+};
+export type GetLayoutResponseDto = {
+    definition: LayoutJSON;
+};
+export type GetApplicationResponseDto = {
+    definition: ApplicationJSON;
+};
+export declare class RemotePersistenceManager implements IPersistenceManager {
+    username: string;
+    createLayout(metadata: LayoutMetadataDto, layout: LayoutJSON): Promise<LayoutMetadata>;
+    updateLayout(id: string, metadata: LayoutMetadataDto, newLayoutJson: LayoutJSON): Promise<void>;
+    deleteLayout(id: string): Promise<void>;
+    loadLayout(id: string): Promise<LayoutJSON>;
+    loadMetadata(): Promise<LayoutMetadata[]>;
+    saveApplicationJSON(applicationJSON: ApplicationJSON): Promise<void>;
+    loadApplicationJSON(): Promise<ApplicationJSON>;
+    getUserSettings(): Promise<{}>;
+    saveUserSettings(userSettings: Settings): void;
+}

package/types/vuu-shell/src/persistence-manager/StaticPersistenceManager.d.ts

@@ -0,0 +1,21 @@
+import { ApplicationJSON, LayoutJSON, LayoutMetadata, Settings } from "@vuu-ui/vuu-utils";
+import { IPersistenceManager } from "./PersistenceManager";
+export declare class StaticPersistenceManager implements IPersistenceManager {
+    #private;
+    constructor({ applicationJSON, applicationLoadDelay, layoutMetadata, }: {
+        applicationJSON?: ApplicationJSON;
+        applicationLoadDelay?: number;
+        layoutMetadata?: LayoutMetadata[];
+    });
+    createLayout(): Promise<LayoutMetadata>;
+    updateLayout(): Promise<void>;
+    deleteLayout(): Promise<void>;
+    loadLayout(id: string): Promise<LayoutJSON<{
+        [key: string]: any;
+    }>>;
+    loadMetadata(): Promise<LayoutMetadata[]>;
+    loadApplicationJSON(): Promise<ApplicationJSON | undefined>;
+    saveApplicationJSON(applicationJson: ApplicationJSON): Promise<void>;
+    getUserSettings(): Promise<Settings>;
+    saveUserSettings(userSettings: Settings): void;
+}

package/types/vuu-shell/src/persistence-manager/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./PersistenceManager";
+export * from "./PersistenceProvider";
+export * from "./LocalPersistenceManager";
+export * from "./RemotePersistenceManager";
+export * from "./StaticPersistenceManager";

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

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import { LayoutJSON } from "@vuu-ui/vuu-utils";
+export interface ContextPanelProps {
+    [key: string]: unknown;
+    className?: string;
+    content?: LayoutJSON;
+    expanded?: boolean;
+    id?: string;
+    overlay?: boolean;
+}
+export declare const ContextPanel: ({ className: classNameProp, expanded, content: contentProp, id, overlay, title, }: ContextPanelProps) => JSX.Element;

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

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

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

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

package/types/vuu-shell/src/shell-layout-templates/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./context-panel";
+export * from "./useShellLayout";
+export * from "./side-panel";

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

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

package/types/vuu-shell/src/shell-layout-templates/side-panel/SidePanel.d.ts

@@ -0,0 +1,8 @@
+import { HTMLAttributes } from "react";
+export interface SidePanelProps extends HTMLAttributes<HTMLDivElement> {
+    open?: boolean;
+    path?: string;
+    sizeOpen?: number;
+    sizeClosed?: number;
+}
+export declare const SidePanel: ({ children, open, sizeClosed, sizeOpen, style: styleProp, ...htmlAttributes }: SidePanelProps) => JSX.Element;

package/types/vuu-shell/src/shell-layout-templates/side-panel/index.d.ts

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

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

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

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

@@ -0,0 +1,41 @@
+import { HTMLAttributes, ReactElement, ReactNode } from "react";
+import { SidePanelProps } from "./side-panel";
+declare const LayoutHook: {
+    "full-height": ShellLayoutTemplateHook;
+    inlay: ShellLayoutTemplateHook;
+    "simple-content-pane": ShellLayoutTemplateHook;
+};
+export type LayoutTemplateId = keyof typeof LayoutHook;
+export type ShellLayoutTemplateProps = Omit<ShellLayoutProps, "layoutTemplateId">;
+export type ShellLayoutTemplateHook = (props: ShellLayoutTemplateProps) => ReactElement;
+/**
+ * The Shell Layout is the outermost 'chrome' of the appliciation,
+ * enclosing the main content area. It will be rendered by one of
+ * two available templates, determined by the layoutTemplateId,
+ */
+export interface ShellLayoutProps {
+    /**
+     * App Header will be rendered in position determined by layout-template
+     */
+    appHeader?: ReactNode;
+    /**
+     * HTML attributes that will be applied to root div.
+     */
+    htmlAttributes?: HTMLAttributes<HTMLDivElement>;
+    /**
+     * identifier for shell layout template to be used. Default template
+     * will be "inlay"
+     */
+    layoutTemplateId?: LayoutTemplateId;
+    /**
+     * If template renders SidePanel, these props will be provided
+     */
+    LeftSidePanelProps?: SidePanelProps;
+}
+/**
+ * This hook acts as a stub for the actual shell layout
+ * template hooks. It will delegate to the appropriate shell
+ * layout hook, based on the value of layoutTemplateId.
+ */
+export declare const useShellLayout: ({ layoutTemplateId, ...props }: ShellLayoutProps) => ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+export {};

package/types/vuu-shell/src/shell.d.ts

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

package/types/vuu-shell/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) => JSX.Element;

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

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

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

@@ -0,0 +1,47 @@
+import { VuuRowDataItemType } from "@vuu-ui/vuu-protocol-types";
+import { Settings } from "@vuu-ui/vuu-utils";
+import { DropdownProps, Option } from "@salt-ds/core";
+import { FormEventHandler, HTMLAttributes } from "react";
+export interface SettingsSchema {
+    properties: SettingsProperty[];
+}
+export interface SettingsProps {
+    settingsSchema: SettingsSchema;
+    settings: Settings;
+    onSettingChanged: (propertyName: string, value: string | number | boolean) => void;
+}
+export type Option<T> = {
+    label: string;
+    value: T;
+};
+export declare const isOption: (value: Option<number | string> | number | string) => value is Option<string | number>;
+export interface BaseProperty {
+    name: string;
+    label: string;
+}
+export interface StringProperty extends BaseProperty {
+    values?: string[] | Option<string>[];
+    defaultValue?: string;
+    type: "string";
+}
+export interface NumericProperty extends BaseProperty {
+    values?: number[] | Option<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;
+}): JSX.Element | null;
+export type SettingsFormProps = SettingsProps & HTMLAttributes<HTMLDivElement>;
+export declare const SettingsForm: ({ settingsSchema, settings, onSettingChanged, ...htmlAttributes }: SettingsFormProps) => JSX.Element;

package/types/vuu-shell/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) => JSX.Element | null;

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

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

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

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

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

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

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

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+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) => JSX.Element;
+export {};

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

@@ -0,0 +1,53 @@
+/// <reference types="react" />
+import { LayoutMetadata, LayoutMetadataDto, type ApplicationSetting, type ApplicationSettings, type LayoutJSON } from "@vuu-ui/vuu-utils";
+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;
+    /**
+     * 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;
+};
+export interface WorkspaceProviderProps extends WorkspaceProps {
+    children: JSX.Element | JSX.Element[];
+    /**
+     * 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, layoutPlaceholderJSON, showTabs, workspaceJSON: customWorkspaceJSON, }: WorkspaceProviderProps) => JSX.Element;
+export declare const useWorkspace: () => {
+    workspaceJSON: LayoutJSON<{
+        [key: string]: any;
+    }>;
+    layoutMetadata: LayoutMetadata[];
+    layoutPlaceholderJSON?: LayoutJSON<{
+        [key: string]: any;
+    }> | undefined;
+    getApplicationSettings: (key?: keyof ApplicationSettings | undefined) => ApplicationSettings | ApplicationSetting;
+    loadLayoutById: (id: string) => void;
+    saveApplicationSettings: (settings: ApplicationSettings | ApplicationSetting, key?: keyof ApplicationSettings | undefined) => void;
+    saveLayout: (n: LayoutMetadataDto) => void;
+    saveApplicationLayout: (layout: LayoutJSON<{
+        [key: string]: any;
+    }>) => void;
+};

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

@@ -0,0 +1,9 @@
+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 stackWorkspaceJSON: LayoutJSON<StackProps & {
+    preserve: boolean;
+}>;
+export declare const getWorkspaceWithLayoutJSON: (customWorkspaceJSON?: LayoutJSON, layoutJSON?: LayoutJSON | LayoutJSON[], stackProps?: WorkspaceStackProps) => LayoutJSON;

package/types/vuu-shell/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/vuu-shell/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/vuu-shell/src/workspace-management/useWorkspaceContextMenuItems.d.ts

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

package/types/vuu-utils/src/ShellContext.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import { RpcResponseHandler } from "packages/vuu-data-types";
+import { LookupTableProvider } from "packages/vuu-shell/src";
+import { DefaultColumnConfiguration, DefaultTableConfiguration } from "packages/vuu-table-types";
+export interface ShellContextProps {
+    getDefaultColumnConfig?: DefaultColumnConfiguration;
+    getDefaultTableConfig?: DefaultTableConfiguration;
+    getLookupValues?: LookupTableProvider;
+    handleRpcResponse?: RpcResponseHandler;
+}
+export declare const ShellContext: import("react").Context<ShellContextProps>;
+export declare const useShellContext: () => ShellContextProps;

package/types/vuu-utils/src/context-definitions/WorkspaceContext.d.ts

@@ -0,0 +1,17 @@
+import React from "react";
+import { ApplicationSetting, ApplicationSettings, LayoutJSON } from "../json-types";
+import { LayoutMetadata, LayoutMetadataDto } from "../layout-types";
+export interface WorkspaceContextProps {
+    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;
+}
+export declare const WorkspaceContext: React.Context<WorkspaceContextProps>;
+export declare const usePlaceholderJSON: () => LayoutJSON<{
+    [key: string]: any;
+}> | undefined;

package/types/{index.d.ts → vuu-utils/src/index.d.ts}

@@ -27,6 +27,7 @@ export * from "./json-types";
 export * from "./json-utils";
 export * from "./keyboard-utils";
 export * from "./keyset";
+export * from "./layout-types";
 export * from "./list-utils";
 export * from "./local-storage-utils";
 export * from "./logging-utils";
@@ -50,3 +51,6 @@ export * from "./url-utils";
 export * from "./useId";
 export * from "./user-types";
 export * from "./useLayoutEffectSkipFirst";
+/** Context declarations hosted in utils to minimize intra package dependencies */
+export * from "./ShellContext";
+export * from "./context-definitions/WorkspaceContext";

package/types/{json-types.d.ts → vuu-utils/src/json-types.d.ts}

@@ -40,7 +40,7 @@ export interface WithType {
 }
 export type LayoutModel = LayoutRoot | ReactElement | WithType;
 export interface LayoutJSON<T extends object = {
-    [key: string]: unknown;
+    [key: string]: any;
 }> extends WithType {
     active?: number;
     children?: LayoutJSON[];

package/types/vuu-utils/src/layout-types.d.ts

@@ -0,0 +1,19 @@
+import { LayoutJSON } from "@vuu-ui/vuu-utils";
+export interface WithId {
+    id: string;
+}
+export interface LayoutMetadata extends WithId {
+    name: string;
+    group: string;
+    screenshot: string;
+    user: string;
+    created: string;
+}
+export type LayoutMetadataDto = Omit<LayoutMetadata, "id" | "created">;
+export interface Layout extends WithId {
+    json: LayoutJSON;
+}
+export type ApplicationLayout = {
+    username: string;
+    definition: LayoutJSON;
+};