@vuu-ui/vuu-layout 0.0.26

package/types/layout-reducer/layoutTypes.d.ts

@@ -0,0 +1,193 @@
+import { NamedFilter } from "@vuu-ui/vuu-filter-types";
+import { CSSProperties, ReactElement } from "react";
+import { DragDropRect, DragInstructions } from "../drag-drop";
+import { DropTarget } from "../drag-drop/DropTarget";
+import { ContributionLocation } from "../layout-view-actions";
+export interface WithProps {
+    props?: {
+        [key: string]: any;
+    };
+}
+export interface WithType {
+    props?: any;
+    title?: string;
+    type: string;
+}
+export interface LayoutRoot extends WithProps {
+    active?: number;
+    children?: ReactElement[];
+    type: string;
+}
+export type ValueOf<T> = T[keyof T];
+export interface ApplicationSettings {
+    leftNav?: {
+        activeTabIndex: number;
+        expanded: boolean;
+    };
+    /**
+     * filters are keyed by MODULE:tablename
+     */
+    filters?: {
+        [key: string]: NamedFilter[];
+    };
+}
+export type ApplicationSetting = ValueOf<ApplicationSettings>;
+export interface ApplicationJSON {
+    layout: LayoutJSON;
+    settings?: ApplicationSettings;
+}
+export interface LayoutJSON extends WithType {
+    active?: number;
+    children?: LayoutJSON[];
+    id?: string;
+    props?: {
+        [key: string]: any;
+    };
+    state?: any;
+    type: string;
+    style?: CSSProperties;
+}
+export interface WithActive {
+    active?: number;
+}
+export type LayoutModel = LayoutRoot | ReactElement | WithType;
+export type layoutType = "Flexbox" | "View" | "DraggableLayout" | "Stack";
+export declare const LayoutActionType: {
+    readonly ADD: "add";
+    readonly DRAG_START: "drag-start";
+    readonly DRAG_DROP: "drag-drop";
+    readonly LAYOUT_RESIZE: "layout-resize";
+    readonly MAXIMIZE: "maximize";
+    readonly MINIMIZE: "minimize";
+    readonly MOVE_CHILD: "move-child";
+    readonly QUERY: "query";
+    readonly REMOVE: "remove";
+    readonly REPLACE: "replace";
+    readonly RESTORE: "restore";
+    readonly SAVE: "save";
+    readonly SET_PROP: "set-prop";
+    readonly SET_PROPS: "set-props";
+    readonly SET_TITLE: "set-title";
+    readonly SPLITTER_RESIZE: "splitter-resize";
+    readonly SWITCH_TAB: "switch-tab";
+    readonly TEAROUT: "tearout";
+};
+export type AddAction = {
+    component: any;
+    path: string;
+    type: typeof LayoutActionType.ADD;
+};
+export type DragDropAction = {
+    draggedReactElement: ReactElement;
+    dragInstructions: any;
+    dropTarget: Partial<DropTarget>;
+    type: typeof LayoutActionType.DRAG_DROP;
+};
+export type MaximizeAction = {
+    path?: string;
+    type: typeof LayoutActionType.MAXIMIZE;
+};
+export type MinimizeAction = {
+    path?: string;
+    type: typeof LayoutActionType.MINIMIZE;
+};
+export type MoveChildAction = {
+    fromIndex: number;
+    toIndex: number;
+    path: string;
+    type: typeof LayoutActionType.MOVE_CHILD;
+};
+export type QueryAction = {
+    path?: string;
+    query: string;
+    type: typeof LayoutActionType.QUERY;
+};
+export type RemoveAction = {
+    path?: string;
+    type: typeof LayoutActionType.REMOVE;
+};
+export type ReplaceAction = {
+    replacement: any;
+    target: any;
+    type: typeof LayoutActionType.REPLACE;
+};
+export type RestoreAction = {
+    path?: string;
+    type: typeof LayoutActionType.RESTORE;
+};
+export type SetPropAction = {
+    path: string;
+    propName: string;
+    propValue: string | number | boolean;
+    type: typeof LayoutActionType.SET_PROP;
+};
+export type SetPropsAction = {
+    path: string;
+    props: {
+        [key: string]: unknown;
+    };
+    type: typeof LayoutActionType.SET_PROPS;
+};
+export type SetTitleAction = {
+    path: string;
+    title: string;
+    type: typeof LayoutActionType.SET_TITLE;
+};
+export type SplitterResizeAction = {
+    path: string;
+    sizes: {
+        currentSize: number;
+        flexBasis: number;
+    }[];
+    type: typeof LayoutActionType.SPLITTER_RESIZE;
+};
+export type LayoutResizeAction = {
+    path: string;
+    size: number;
+    type: typeof LayoutActionType.LAYOUT_RESIZE;
+};
+export type SwitchTabAction = {
+    id?: string;
+    nextIdx: number;
+    path: string;
+    type: typeof LayoutActionType.SWITCH_TAB;
+};
+export type TearoutAction = {
+    path?: string;
+    type: typeof LayoutActionType.TEAROUT;
+};
+export type LayoutReducerAction = AddAction | DragDropAction | LayoutResizeAction | MaximizeAction | MinimizeAction | MoveChildAction | RemoveAction | ReplaceAction | RestoreAction | SetPropAction | SetPropsAction | SetTitleAction | SplitterResizeAction | SwitchTabAction;
+export type SaveAction = {
+    type: typeof LayoutActionType.SAVE;
+};
+export type AddToolbarContributionViewAction = {
+    content: ReactElement;
+    location: ContributionLocation;
+    type: "add-toolbar-contribution";
+};
+export type RemoveToolbarContributionViewAction = {
+    location: ContributionLocation;
+    type: "remove-toolbar-contribution";
+};
+export type MousedownViewAction = {
+    preDragActivity?: any;
+    index?: number;
+    type: "mousedown";
+};
+export type DragStartAction = {
+    payload?: ReactElement;
+    dragContainerPath?: string;
+    dragElement?: HTMLElement;
+    dragRect: DragDropRect;
+    dropTargets?: string[];
+    evt: MouseEvent;
+    instructions?: DragInstructions;
+    path: string;
+    type: typeof LayoutActionType.DRAG_START;
+};
+export type LayoutLevelChange = "switch-active-tab" | "edit-feature-title" | "save-feature-props" | "resize-component" | "remove-component" | "drag-drop-operation";
+export type ApplicationLevelChange = "switch-active-layout" | "open-layout" | "close-layout" | "rename-layout" | "resize-application-chrome";
+export type LayoutChangeReason = LayoutLevelChange | ApplicationLevelChange;
+export type LayoutChangeHandler = (layout: LayoutJSON, layoutChangeReason: LayoutChangeReason) => void;
+export declare const isApplicationLevelChange: (layoutChangeReason: LayoutChangeReason) => layoutChangeReason is ApplicationLevelChange;
+export declare const isLayoutLevelChange: (layoutChangeReason: LayoutChangeReason) => layoutChangeReason is LayoutLevelChange;

package/types/layout-reducer/layoutUtils.d.ts

@@ -0,0 +1,38 @@
+import { dimension } from "@vuu-ui/vuu-utils";
+import React, { CSSProperties, ReactElement } from "react";
+import { ComponentWithId } from "../registry/ComponentRegistry";
+import { TabLabelFactory } from "../stack";
+import { LayoutJSON, LayoutModel, layoutType } from "./layoutTypes";
+export declare const getManagedDimension: (style: CSSProperties) => [dimension, dimension];
+export declare const applyLayoutProps: (component: ReactElement, path?: string) => React.ReactElement<any, string | React.JSXElementConstructor<any>>;
+export interface LayoutProps extends ComponentWithId {
+    active?: number;
+    "data-path"?: string;
+    children?: ReactElement[];
+    column?: any;
+    dropTarget?: any;
+    key: string;
+    layout?: any;
+    path?: string;
+    resizeable?: boolean;
+    style: CSSProperties;
+    type?: string;
+    version?: number;
+}
+/**
+ * parse the declarative JSX and clone adding layout attributes
+ */
+export declare const processLayoutElement: (layoutElement: ReactElement, previousLayout?: ReactElement) => ReactElement;
+export declare const applyLayout: (type: layoutType, props: LayoutProps, previousLayout?: LayoutModel) => LayoutModel;
+export declare function layoutFromJson({ id, type, children, props, state }: LayoutJSON, path: string): ReactElement;
+export declare function layoutToJSON(component: ReactElement): LayoutJSON;
+export declare function componentToJson(component: ReactElement): LayoutJSON;
+export declare function serializeProps(props?: LayoutProps): {
+    [key: string]: any;
+} | undefined;
+export type LayoutQuery = "PARENT_CONTAINER";
+export declare const layoutQuery: (query: LayoutQuery, path?: string, layoutRoot?: ReactElement) => {
+    parentContainerId: any;
+    parentContainerType: string | undefined;
+} | undefined;
+export declare const getDefaultTabLabel: TabLabelFactory;

package/types/layout-reducer/move-layout-element.d.ts

@@ -0,0 +1,3 @@
+import { ReactElement } from "react";
+import { MoveChildAction } from "./layoutTypes";
+export declare function moveChild(layoutRoot: ReactElement, { fromIndex, path, toIndex }: MoveChildAction): ReactElement<any, string | import("react").JSXElementConstructor<any>>;

package/types/layout-reducer/remove-layout-element.d.ts

@@ -0,0 +1,3 @@
+import React, { ReactElement } from "react";
+import { RemoveAction } from "./layoutTypes";
+export declare function removeChild(layoutRoot: ReactElement, { path }: RemoveAction): React.ReactElement<any, string | React.JSXElementConstructor<any>>;

package/types/layout-reducer/replace-layout-element.d.ts

@@ -0,0 +1,6 @@
+import React, { ReactElement } from 'react';
+import { ReplaceAction } from './layoutTypes';
+import { LayoutProps } from './layoutUtils';
+export declare function replaceChild(model: ReactElement, { target, replacement }: ReplaceAction): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
+export declare function _replaceChild(model: ReactElement, child: ReactElement, replacement: ReactElement<LayoutProps>): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
+export declare function swapChild(model: ReactElement, child: ReactElement, replacement: ReactElement, op?: 'maximize' | 'minimize' | 'restore'): ReactElement;

package/types/layout-reducer/resize-flex-children.d.ts

@@ -0,0 +1,4 @@
+import React, { ReactElement } from "react";
+import { LayoutResizeAction, SplitterResizeAction } from "./layoutTypes";
+export declare function resizeFlexChild(layoutRoot: ReactElement, { path, size }: LayoutResizeAction): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
+export declare function resizeFlexChildren(layoutRoot: ReactElement, { path, sizes }: SplitterResizeAction): React.ReactElement<any, string | React.JSXElementConstructor<any>>;

package/types/layout-reducer/wrap-layout-element.d.ts

@@ -0,0 +1,9 @@
+import { ReactElement } from "react";
+import { DropPos } from "../drag-drop/dragDropTypes";
+import { DropTarget } from "../drag-drop/DropTarget";
+export interface LayoutSpec {
+    type: "Stack" | "Flexbox";
+    flexDirection: "column" | "row";
+    showTabs?: boolean;
+}
+export declare function wrap(container: ReactElement, existingComponent: ReactElement, newComponent: any, pos: DropPos, clientRect?: DropTarget["clientRect"], dropRect?: DropTarget["dropRect"]): ReactElement;

package/types/layout-view/View.d.ts

@@ -0,0 +1,10 @@
+import { ForwardedRef, ReactElement } from "react";
+import { ViewProps } from "./viewTypes";
+interface ViewComponentType {
+    (props: ViewProps & {
+        ref?: ForwardedRef<HTMLDivElement>;
+    }): ReactElement<ViewProps>;
+    displayName?: string;
+}
+declare const MemoView: ViewComponentType;
+export { MemoView as View };

package/types/layout-view/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./View";
+export * from "./viewTypes";

package/types/layout-view/useView.d.ts

@@ -0,0 +1,21 @@
+import { RefObject } from "react";
+export interface ViewHookProps {
+    id: string;
+    rootRef: RefObject<HTMLDivElement>;
+    path?: string;
+    dropTargets?: string[];
+    title?: string;
+}
+export declare const useView: ({ id, rootRef, path, dropTargets, title: titleProp, }: ViewHookProps) => {
+    contributions: import("../layout-view-actions/useViewActionDispatcher").Contribution[] | undefined;
+    dispatchViewAction: import("..").ViewDispatch;
+    load: (key?: string) => any;
+    loadSession: (key?: string) => any;
+    onConfigChange: ({ type: key, ...config }: any) => void;
+    onEditTitle: (title: string) => void;
+    purge: (key: any) => void;
+    restoredState: any;
+    save: (state: any, key: any) => void;
+    saveSession: (state: any, key: any) => void;
+    title: any;
+};

package/types/layout-view/useViewResize.d.ts

@@ -0,0 +1,7 @@
+import { RefObject } from "react";
+export interface ViewResizeHookProps {
+    mainRef: RefObject<HTMLDivElement>;
+    resize?: "defer" | "responsive";
+    rootRef: RefObject<HTMLDivElement>;
+}
+export declare const useViewResize: ({ mainRef, resize, rootRef, }: ViewResizeHookProps) => void;

package/types/layout-view/viewTypes.d.ts

@@ -0,0 +1,21 @@
+import { FunctionComponent, HTMLAttributes } from "react";
+import { HeaderProps } from "../layout-header";
+import { AddToolbarContributionViewAction, MaximizeAction, MinimizeAction, MousedownViewAction, QueryAction, RemoveAction, RemoveToolbarContributionViewAction, RestoreAction, TearoutAction } from "../layout-reducer";
+export type ViewAction = MaximizeAction | MinimizeAction | MousedownViewAction | QueryAction | RemoveAction | RestoreAction | TearoutAction | AddToolbarContributionViewAction | RemoveToolbarContributionViewAction;
+export type ResizeStrategy = "defer" | "responsive";
+export interface ViewProps extends HTMLAttributes<HTMLDivElement> {
+    Header?: FunctionComponent<HeaderProps>;
+    closeable?: boolean;
+    collapsed?: boolean;
+    "data-path"?: string;
+    "data-resizeable"?: boolean;
+    dropTargets?: string[];
+    expanded?: boolean;
+    flexFill?: boolean;
+    header?: boolean | Partial<HeaderProps>;
+    orientation?: "vertical" | "horizontal";
+    path?: string;
+    resize?: ResizeStrategy;
+    resizeable?: boolean;
+    tearOut?: boolean;
+}

package/types/layout-view-actions/ViewContext.d.ts

@@ -0,0 +1,33 @@
+import React, { SyntheticEvent } from "react";
+import { ViewAction } from "../layout-view/viewTypes";
+export type QueryReponse = {
+    [key: string]: unknown;
+};
+export type ViewDispatch = <Action extends ViewAction = ViewAction>(action: Action, evt?: SyntheticEvent) => Promise<boolean | QueryReponse | void>;
+/**
+ * This API is available to any Feature hosted within Vuu (as all Features are wrapped
+ * with View component). It offers metadata about the View as well as access to the
+ * Vuu persistencew API;
+ */
+export interface ViewContextAPI {
+    /**
+     * dispatcher for View actions. These are a subset of LayoutActions, specifically for
+     * View manipulation
+     */
+    dispatch?: ViewDispatch | null;
+    id?: string;
+    load?: (key?: string) => unknown;
+    loadSession?: (key?: string) => unknown;
+    onConfigChange?: (config: unknown) => void;
+    path?: string;
+    purge?: (key: string) => void;
+    save?: (state: unknown, key: string) => void;
+    saveSession?: (state: unknown, key: string) => void;
+    setComponentProps: (props: {
+        [key: string]: unknown;
+    }) => void;
+    title?: string;
+}
+export declare const ViewContext: React.Context<ViewContextAPI>;
+export declare const useViewDispatch: () => ViewDispatch | null;
+export declare const useViewContext: () => ViewContextAPI;

package/types/layout-view-actions/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./useViewActionDispatcher";
+export * from "./ViewContext";

package/types/layout-view-actions/useViewActionDispatcher.d.ts

@@ -0,0 +1,9 @@
+import { ReactElement, RefObject } from "react";
+import { ViewDispatch } from "./ViewContext";
+export type ContributionLocation = "post-title" | "pre-title";
+export type Contribution = {
+    index?: number;
+    location?: ContributionLocation;
+    content: ReactElement;
+};
+export declare const useViewActionDispatcher: (id: string, root: RefObject<HTMLDivElement>, viewPath?: string, dropTargets?: string[]) => [ViewDispatch, Contribution[] | undefined];

package/types/palette/Palette.d.ts

@@ -0,0 +1,21 @@
+import { ListItemProps, ListProps } from "@vuu-ui/vuu-ui-controls";
+import { HTMLAttributes, ReactElement } from "react";
+import { ViewProps } from "../layout-view";
+export interface PaletteItemProps extends ListItemProps {
+    children: ReactElement;
+    closeable?: boolean;
+    header?: boolean;
+    idx?: number;
+    resize?: "defer";
+    resizeable?: boolean;
+}
+export declare const PaletteItem: import("react").MemoExoticComponent<({ className, children: component, idx, resizeable, header, closeable, ...props }: PaletteItemProps) => JSX.Element>;
+export interface PaletteProps extends Omit<HTMLAttributes<HTMLDivElement>, "onDragStart" | "onDrop" | "onSelect"> {
+    ListProps?: Partial<ListProps>;
+    ViewProps?: Partial<ViewProps>;
+    children: ReactElement[];
+    itemHeight?: number;
+    orientation: "horizontal" | "vertical";
+    selection?: string;
+}
+export declare const Palette: ({ ListProps, ViewProps, children, className, itemHeight, orientation, ...props }: PaletteProps) => JSX.Element;

package/types/palette/index.d.ts

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

package/types/placeholder/LayoutStartPanel.d.ts

@@ -0,0 +1,5 @@
+import { HTMLAttributes } from "react";
+export interface LayoutStartPanelProps extends HTMLAttributes<HTMLDivElement> {
+    label?: string;
+}
+export declare const LayoutStartPanel: (htmlAttributes: LayoutStartPanelProps) => JSX.Element | null;

package/types/placeholder/Placeholder.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="react" />
+import { ViewProps } from "../layout-view";
+export interface PlaceholderProps extends ViewProps {
+    closeable?: boolean;
+    flexFill?: boolean;
+    resizeable?: boolean;
+    showStartMenu?: boolean;
+    /**
+     * shim is only when we're dealing with intrinsically sized children, which is never
+     * in an actual application. Intrinsic sizing is still experimental.
+     */
+    shim?: boolean;
+}
+export declare const Placeholder: {
+    ({ className: classNameProp, showStartMenu, ...viewProps }: PlaceholderProps): JSX.Element;
+    displayName: string;
+};

package/types/placeholder/index.d.ts

@@ -0,0 +1 @@
+export * from './Placeholder';

package/types/registry/ComponentRegistry.d.ts

@@ -0,0 +1,13 @@
+import { FunctionComponent } from "react";
+export type layoutComponentType = "component" | "container" | "view";
+export interface ComponentWithId {
+    id: string;
+    [key: string]: unknown;
+}
+export declare const ComponentRegistry: {
+    [key: string]: FunctionComponent<ComponentWithId>;
+};
+export declare function isContainer(componentType: string): boolean;
+export declare function isView(componentType: string): boolean;
+export declare const isLayoutComponent: (type: string) => boolean;
+export declare function registerComponent(componentName: string, component: FunctionComponent<any>, type?: layoutComponentType): void;

package/types/registry/index.d.ts

@@ -0,0 +1 @@
+export * from './ComponentRegistry';

package/types/responsive/breakpoints.d.ts

@@ -0,0 +1,4 @@
+import { BreakPointsProp } from "../flexbox/flexboxTypes";
+export type BreakPointRamp = [string, number, number];
+export declare const breakpointRamp: (breakpoints: BreakPointsProp) => BreakPointRamp[];
+export declare const getBreakPoints: (themeName?: string) => BreakPointRamp[];

package/types/responsive/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./use-breakpoints";
+export * from "./useResizeObserver";
+export * from "./utils";

package/types/responsive/measureMinimumNodeSize.d.ts

@@ -0,0 +1 @@
+export declare function measureMinimumNodeSize(node: HTMLElement, dimension?: 'width' | 'height'): number;

package/types/responsive/overflowUtils.d.ts

@@ -0,0 +1,2 @@
+export function getOverflowedItems(containerRef: any, height?: number): any[][];
+export function findFirstOverflow(elements: any, height: any): number;

package/types/responsive/use-breakpoints.d.ts

@@ -0,0 +1,7 @@
+import { RefObject } from "react";
+import { BreakPointsProp } from "../flexbox/flexboxTypes";
+export interface BreakpointsHookProps {
+    breakPoints?: BreakPointsProp;
+    smallerThan?: string;
+}
+export declare const useBreakpoints: ({ breakPoints: breakPointsProp, smallerThan }: BreakpointsHookProps, ref: RefObject<HTMLElement>) => string | boolean;

package/types/responsive/useResizeObserver.d.ts

@@ -0,0 +1,13 @@
+import { RefObject } from "react";
+export declare const WidthHeight: string[];
+export declare const HeightOnly: string[];
+export declare const WidthOnly: string[];
+export type measurements<T = string | number> = {
+    height?: T;
+    scrollHeight?: T;
+    scrollWidth?: T;
+    width?: T;
+};
+export type ResizeHandler = (measurements: measurements<number>) => void;
+export declare const resizeObserver: ResizeObserver;
+export declare function useResizeObserver(ref: RefObject<Element | HTMLElement | null>, dimensions: string[], onResize: ResizeHandler, reportInitialSize?: boolean): void;

package/types/responsive/utils.d.ts

@@ -0,0 +1,6 @@
+export declare const isResponsiveAttribute: (propName: string) => boolean;
+type Props = {
+    [key: string]: any;
+};
+export declare const extractResponsiveProps: (props: Props) => [Props, Props];
+export {};

package/types/stack/Stack.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import { StackProps } from "./stackTypes";
+export declare const Stack: React.ForwardRefExoticComponent<StackProps & React.RefAttributes<HTMLDivElement>>;

package/types/stack/StackLayout.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+import { StackProps } from "./stackTypes";
+export declare const StackLayout: {
+    (props: StackProps): JSX.Element;
+    displayName: string;
+};

package/types/stack/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./Stack";
+export * from "./StackLayout";
+export * from "./stackTypes";

package/types/stack/stackTypes.d.ts

@@ -0,0 +1,22 @@
+import { TabstripProps } from "@vuu-ui/vuu-ui-controls";
+import { HTMLAttributes, MouseEvent, ReactElement, ReactNode } from "react";
+export type TabLabelFactory = (component: ReactElement, index: number, existingLabels: string[]) => string;
+export type TabPosition = "top" | "left" | "right" | "bottom";
+export interface StackProps extends Omit<HTMLAttributes<HTMLDivElement>, "onMouseDown"> {
+    active?: number;
+    createNewChild?: (index: number) => ReactElement;
+    getTabIcon?: (component: ReactElement, index: number) => string | undefined;
+    getTabLabel?: TabLabelFactory;
+    keyBoardActivation?: "automatic" | "manual";
+    onAddTab?: () => void;
+    onMoveTab?: (fromIndex: number, toIndex: number) => void;
+    onMouseDown?: (e: MouseEvent, tabIndex: number) => void;
+    onTabClose?: (tabIndex: number) => void;
+    onTabEdit?: (tabIndex: number, label: string) => void;
+    onTabSelectionChanged?: (nextIndex: number) => void;
+    path?: string;
+    /** should the Stack display a Tabstrip and where ? default top */
+    showTabs?: false | TabPosition;
+    toolbarContent?: ReactNode;
+    TabstripProps?: Partial<TabstripProps>;
+}

package/types/tabs/TabPanel.d.ts

@@ -0,0 +1,7 @@
+import { HTMLAttributes } from 'react';
+import './TabPanel.css';
+export interface TabPanelProps extends HTMLAttributes<HTMLDivElement> {
+    ariaLabelledBy: string;
+}
+declare const TabPanel: ({ ariaLabelledBy, children, id }: TabPanelProps) => JSX.Element;
+export default TabPanel;

package/types/tabs/index.d.ts

@@ -0,0 +1 @@
+export { default as TabPanel } from './TabPanel';

package/types/tools/config-wrapper/ConfigWrapper.d.ts

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

package/types/tools/config-wrapper/index.d.ts

@@ -0,0 +1 @@
+export * from './ConfigWrapper';

package/types/tools/devtools-box/layout-configurator.d.ts

@@ -0,0 +1,31 @@
+export function XXXnormalizeStyles(layoutStyle?: {}, visualStyle?: {}): {};
+export namespace MARGIN_STYLES {
+    const margin: boolean;
+    const marginTop: boolean;
+    const marginRight: boolean;
+    const marginBottom: boolean;
+    const marginLeft: boolean;
+}
+export namespace PADDING_STYLES {
+    const padding: boolean;
+    const paddingTop: boolean;
+    const paddingRight: boolean;
+    const paddingBottom: boolean;
+    const paddingLeft: boolean;
+}
+export namespace BORDER_STYLES {
+    const border: boolean;
+    const borderColor: boolean;
+    const borderWidth: boolean;
+    const borderTopWidth: boolean;
+    const borderRightWidth: boolean;
+    const borderBottomWidth: boolean;
+    const borderLeftWidth: boolean;
+}
+export function LayoutConfigurator({ height, managedStyle, onChange, style, width, }: {
+    height: any;
+    managedStyle: any;
+    onChange: any;
+    style: any;
+    width: any;
+}): JSX.Element;

package/types/tools/devtools-tree/layout-tree-viewer.d.ts

@@ -0,0 +1,5 @@
+export function LayoutTreeViewer({ layout, onSelect, style }: {
+    layout: any;
+    onSelect: any;
+    style: any;
+}): JSX.Element;

package/types/tools/index.d.ts

@@ -0,0 +1,3 @@
+export * from './config-wrapper';
+export * from './devtools-box/layout-configurator';
+export * from './devtools-tree/layout-tree-viewer';

package/types/use-persistent-state.d.ts

@@ -0,0 +1,11 @@
+export declare const getPersistentState: (id: string) => any;
+export declare const hasPersistentState: (id: string) => boolean;
+export declare const setPersistentState: (id: string, value: any) => Map<string, any>;
+export declare const usePersistentState: () => {
+    loadSessionState: (id: any, key: any) => any;
+    loadState: (id: string, key?: string) => any;
+    saveSessionState: (id: any, key: any, data: any) => void;
+    saveState: (id: string, key: string | undefined, data: unknown) => void;
+    purgeState: (id: string, key?: string) => void;
+    purgeSessionState: (id: string, key?: string) => void;
+};

package/types/utils/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./pathUtils";
+export * from "./propUtils";
+export * from "./refUtils";
+export * from "./styleUtils";
+export * from "./typeOf";