@vuu-ui/grid-layout 4.0.0-alpha.1

package/types/GridSnapshot.d.ts

@@ -0,0 +1,49 @@
+export type GridId = string;
+export type GridItemId = string;
+export type StackId = string;
+export type ComponentInstanceId = string;
+export type GridTrackSize = `${number}fr` | `${number}px`;
+export type GridItemResizeable = "h" | "v" | "hv" | false;
+export interface GridTrackSnapshot {
+    readonly size: GridTrackSize;
+}
+export interface GridSpanSnapshot {
+    readonly span: number;
+    readonly start: number;
+}
+export interface GridItemSnapshot {
+    readonly column: GridSpanSnapshot;
+    readonly componentInstanceId?: ComponentInstanceId;
+    readonly contentVisible?: boolean;
+    readonly dropTarget?: boolean | string;
+    readonly header?: boolean;
+    readonly id: GridItemId;
+    readonly minHeight?: number;
+    readonly minWidth?: number;
+    readonly resizeable?: GridItemResizeable;
+    readonly row: GridSpanSnapshot;
+    readonly title?: string;
+}
+export interface GridStackSnapshot {
+    readonly id: StackId;
+    readonly itemIds: readonly GridItemId[];
+    readonly selectedItemId: GridItemId;
+}
+export interface GridSnapshot {
+    readonly columns: readonly GridTrackSnapshot[];
+    readonly gridId: GridId;
+    readonly items: readonly GridItemSnapshot[];
+    readonly revision: number;
+    readonly rows: readonly GridTrackSnapshot[];
+    readonly stacks: readonly GridStackSnapshot[];
+}
+export type GridSnapshotValidationCode = "DUPLICATE_ID" | "EMPTY_ID" | "INVALID_FIELD" | "INVALID_REVISION" | "INVALID_SPAN" | "INVALID_STACK_MEMBERSHIP" | "INVALID_STACK_POSITION" | "INVALID_STACK_SELECTION" | "INVALID_STRUCTURE" | "INVALID_TRACK_REFERENCE" | "MALFORMED_GRID_AREA" | "MALFORMED_TRACK" | "UNEXPECTED_FIELD";
+export interface GridSnapshotValidationIssue {
+    readonly code: GridSnapshotValidationCode;
+    readonly message: string;
+    readonly path: string;
+}
+export declare class GridSnapshotValidationError extends Error {
+    readonly issues: readonly GridSnapshotValidationIssue[];
+    constructor(issues: readonly GridSnapshotValidationIssue[]);
+}

package/types/GridSplitter.d.ts

@@ -0,0 +1,10 @@
+import { HTMLAttributes } from "react";
+import { AriaOrientation } from "./GridModel";
+import { ResizeOrientation } from "./grid-dom-utils";
+export interface GridSplitterProps extends HTMLAttributes<HTMLDivElement> {
+    "aria-controls": string;
+    ariaOrientation: AriaOrientation;
+    offsetStart?: boolean;
+    orientation: ResizeOrientation;
+}
+export declare const GridSplitter: ({ "aria-controls": ariaControls, ariaOrientation, offsetStart, orientation, ...htmlAttributes }: GridSplitterProps) => import("react").JSX.Element;

package/types/GridStack.d.ts

@@ -0,0 +1,160 @@
+import { type GridItemId, type GridItemResizeable, type GridSnapshotValidationIssue, type GridSpanSnapshot, type GridStackSnapshot, type StackId } from "./GridSnapshot";
+/**
+ * Canonical stack state and the pure transitions that own stack semantics:
+ * membership, order, stable identity, selection, placement and lifecycle.
+ *
+ * Nothing in this module knows about React, the DOM, event emitters or the
+ * legacy runtime models. `GridModel`, `TabState` and `TabStrip` are hydrated
+ * from the transitions declared here; they never compute stack semantics.
+ */
+/** A stack with fewer members than this dissolves into a plain grid item. */
+export declare const MIN_GRID_STACK_MEMBERS = 2;
+/**
+ * The grid area occupied by a stack. Every member of a stack occupies exactly
+ * this area, which is what makes the stack a single placement on the grid.
+ */
+export interface GridStackArea {
+    readonly column: GridSpanSnapshot;
+    readonly row: GridSpanSnapshot;
+}
+/**
+ * A stack member. Identity is the (stable) `id`; `label` and `title` are
+ * durable metadata, never used to identify, order or select a member.
+ */
+export interface GridStackMember {
+    readonly id: GridItemId;
+    readonly label: string;
+    readonly title?: string;
+}
+/** Durable stack metadata required by descriptors and layout commands. */
+export interface GridStackMetadata {
+    readonly minHeight?: number;
+    readonly minWidth?: number;
+    readonly resizeable?: GridItemResizeable;
+}
+export interface GridStackState {
+    readonly area: GridStackArea;
+    readonly id: StackId;
+    /** ordered membership; order is explicit and independent of title/label */
+    readonly members: readonly GridStackMember[];
+    readonly metadata: GridStackMetadata;
+    readonly selectedItemId: GridItemId;
+}
+export type GridStackOperation = "add" | "create" | "remove" | "rename" | "reorder" | "select";
+export interface GridStackTransition {
+    readonly added: readonly GridStackMember[];
+    /** false for a no-op, so callers can avoid publishing a durable revision */
+    readonly changed: boolean;
+    /**
+     * true when the stack ceases to exist. `state` then describes the residual
+     * membership, which the projection unstacks.
+     */
+    readonly dissolved: boolean;
+    readonly operation: GridStackOperation;
+    readonly orderChanged: boolean;
+    /** true when an added member was placed relative to an existing member */
+    readonly positioned: boolean;
+    readonly previous: GridStackState | undefined;
+    readonly removed: readonly GridStackMember[];
+    readonly selectionChanged: boolean;
+    readonly stackId: StackId;
+    readonly state: GridStackState;
+}
+export type GridStackErrorCode = "DUPLICATE_ITEM_ID" | "INVALID_ITEM" | "INVALID_TARGET" | "STACK_NOT_FOUND" | "TAB_NOT_FOUND";
+export interface GridStackError {
+    readonly code: GridStackErrorCode;
+    readonly message: string;
+}
+export type GridStackResult<T> = {
+    readonly ok: true;
+    readonly value: T;
+} | {
+    readonly error: GridStackError;
+    readonly ok: false;
+};
+/** A detached copy, so canonical state never aliases legacy runtime state. */
+export declare const cloneGridStackState: (state: GridStackState) => GridStackState;
+export declare const gridStackItemIds: (state: GridStackState) => readonly GridItemId[];
+export declare const findGridStackMember: (state: GridStackState, itemId: GridItemId) => GridStackMember | undefined;
+export declare const gridStackMemberIndex: (state: GridStackState, itemId: GridItemId) => number;
+export declare const gridStackSelectedIndex: (state: GridStackState) => number;
+/** Project canonical state onto the persisted snapshot contract. */
+export declare const toGridStackSnapshot: (state: GridStackState) => GridStackSnapshot;
+export declare const isSameGridStackState: (left: GridStackState, right: GridStackState) => boolean;
+/**
+ * Deterministically repair a state hydrated from the legacy runtime: drop
+ * empty or duplicated ids and fall back to the first member when the selected
+ * item is not (or no longer) a member.
+ */
+export declare const normalizeGridStackState: (state: GridStackState) => GridStackState;
+export interface GridStackValidationOptions {
+    /**
+     * The grid area of each known grid item. When provided, membership and
+     * placement are validated against the wider layout.
+     */
+    readonly itemAreas?: ReadonlyMap<GridItemId, GridStackArea>;
+    readonly path?: string;
+}
+export declare const validateGridStackState: (state: GridStackState, { itemAreas, path }?: GridStackValidationOptions) => readonly GridSnapshotValidationIssue[];
+export declare const assertValidGridStackState: (state: GridStackState, options?: GridStackValidationOptions) => GridStackState;
+export interface GridStackCreateRequest {
+    readonly area: GridStackArea;
+    readonly id: StackId;
+    readonly members: readonly GridStackMember[];
+    readonly metadata?: GridStackMetadata;
+    readonly selectedItemId?: GridItemId;
+}
+/**
+ * Create a stack from two or more existing grid items. The stack id is stable
+ * from this point on: it never changes when members are added, removed,
+ * renamed or reordered.
+ */
+export declare const createGridStack: (request: GridStackCreateRequest) => GridStackResult<GridStackTransition>;
+export interface GridStackPosition {
+    readonly placement: "after" | "before";
+    readonly targetItemId: GridItemId;
+}
+export interface GridStackAddRequest {
+    readonly member: GridStackMember;
+    readonly position?: GridStackPosition;
+    /**
+     * Select the added member. Defaults to true for a positioned add, matching
+     * the legacy tabstrip drop, and to false for an appended add.
+     */
+    readonly select?: boolean;
+}
+/** Add a member, optionally positioned relative to an existing member. */
+export declare const addGridStackItem: (state: GridStackState, { member, position, select }: GridStackAddRequest) => GridStackResult<GridStackTransition>;
+export interface GridStackRemoveRequest {
+    readonly itemId: GridItemId;
+}
+/**
+ * Remove a member. When the removed member was selected, selection falls back
+ * deterministically to the member that takes its position, or to the new last
+ * member when it was the last. A stack that drops below the minimum membership
+ * dissolves.
+ */
+export declare const removeGridStackItem: (state: GridStackState, { itemId }: GridStackRemoveRequest) => GridStackResult<GridStackTransition>;
+export interface GridStackSelectRequest {
+    readonly itemId: GridItemId;
+}
+/** Select a member by its stable id, never by title or label. */
+export declare const selectGridStackItem: (state: GridStackState, { itemId }: GridStackSelectRequest) => GridStackResult<GridStackTransition>;
+export interface GridStackReorderRequest {
+    /** select the moved member as part of the reorder */
+    readonly activate?: boolean;
+    readonly itemId: GridItemId;
+    readonly placement: "after" | "before";
+    readonly targetItemId: GridItemId;
+}
+/**
+ * Move a member relative to another member. Selection is carried by id, so a
+ * reorder never changes which item is selected unless `activate` asks for it.
+ */
+export declare const reorderGridStackItem: (state: GridStackState, { activate, itemId, placement, targetItemId, }: GridStackReorderRequest) => GridStackResult<GridStackTransition>;
+export interface GridStackRenameRequest {
+    readonly itemId: GridItemId;
+    readonly title: string;
+}
+/** Rename a member. Identity, order and selection are unaffected. */
+export declare const renameGridStackItem: (state: GridStackState, { itemId, title }: GridStackRenameRequest) => GridStackResult<GridStackTransition>;

package/types/Icon.d.ts

@@ -0,0 +1,6 @@
+import { HTMLAttributes } from "react";
+export interface IconProps extends HTMLAttributes<HTMLSpanElement> {
+    name: string;
+    size?: number;
+}
+export declare const Icon: ({ className, name, size, style: styleProp, ...htmlAttributes }: IconProps) => import("react").JSX.Element;

package/types/IconButton.d.ts

@@ -0,0 +1,6 @@
+import { ButtonProps } from "@salt-ds/core";
+export interface IconButtonProps extends Omit<ButtonProps, "children"> {
+    icon: string;
+    size?: number;
+}
+export declare const IconButton: import("react").ForwardRefExoticComponent<IconButtonProps & import("react").RefAttributes<HTMLButtonElement>>;

package/types/TabDialog.d.ts

@@ -0,0 +1,9 @@
+import { CSSProperties } from "react";
+export declare const TabDialog: ({ open, onConfirm, onCancel, style, tabLabel, title, }: {
+    open?: boolean;
+    onConfirm: (value: string) => void;
+    onCancel: () => void;
+    style?: CSSProperties;
+    tabLabel?: string;
+    title?: string;
+}) => import("react").JSX.Element;

package/types/TabMenu.d.ts

@@ -0,0 +1,7 @@
+export interface TabMenuProps {
+    allowClose?: boolean;
+    allowRename?: boolean;
+    layoutItemId: string;
+    tabLabel: string;
+}
+export declare const TabMenu: ({ allowClose, allowRename, layoutItemId, tabLabel, }: TabMenuProps) => import("react").JSX.Element;

package/types/componentToJson.d.ts

@@ -0,0 +1,38 @@
+import { type CSSProperties, type ReactElement } from "react";
+export type LayoutJSONChild = LayoutJSON | number | string;
+export interface LayoutJSON<T extends object = object> {
+    active?: number;
+    children?: LayoutJSONChild[];
+    id?: string;
+    props?: T;
+    state?: unknown;
+    style?: CSSProperties;
+    title?: string;
+    type: string;
+}
+export interface LayoutProps {
+    active?: number;
+    "data-path"?: string;
+    children?: ReactElement[];
+    /**
+     * indicates flexDirection for Flexbox
+     */
+    column?: boolean;
+    dropTarget?: boolean;
+    i8d: string;
+    key: string;
+    path?: string;
+    resizeable?: boolean;
+    style: CSSProperties;
+    type?: string;
+    version?: number;
+}
+/**
+ * @deprecated GridLayout persistence must use typed component settings and
+ * encodeGridLayoutDocument. This function is retained for legacy UI templates.
+ */
+export declare function componentToJson(element: ReactElement): LayoutJSON;
+/** @deprecated Generic React-prop persistence is a legacy compatibility path. */
+export declare function serializeProps(props?: LayoutProps): {
+    [key: string]: unknown;
+} | undefined;

package/types/drag-drop-next/DragContextNext.d.ts

@@ -0,0 +1,92 @@
+import { EventEmitter, type orientationType } from "@vuu-ui/vuu-utils";
+import { type DragSource } from "../GridLayoutContext";
+import type { TemplateDragSession } from "./TemplateDragSession";
+type DragSourceDescriptor = {
+    dropTargets: string[];
+    orientation?: orientationType;
+    payloadType?: string;
+};
+export type DropPosition = {
+    position: "before" | "after";
+    target: string;
+};
+export type DragSources = {
+    [key: string]: DragSourceDescriptor;
+};
+export type DropProps<T extends DragSource = DragSource> = {
+    dragSource: T;
+    toId?: string;
+    tabsId?: string;
+    dropPosition?: DropPosition;
+};
+export type DropHandler<T extends DragSource = DragSource> = (dropProps: DropProps<T>) => void;
+export type DragContextDropEvent = {
+    type: "drop";
+    dragSource: DragSource;
+    tabsId: string;
+    dropPosition: DropPosition;
+};
+export type DragContextDetachTabEvent = {
+    gridId: string;
+    itemId: string;
+    type: "detach-tab";
+    tabsId: string;
+    value: string;
+};
+export type DragContextCancelTabDragEvent = Omit<DragContextDetachTabEvent, "type"> & {
+    type: "cancel-tab-drag";
+};
+export type DragContextCancelTabDragHandler = (evt: DragContextCancelTabDragEvent) => void;
+export type DragContextDropHandler = (evt: DragContextDropEvent) => void;
+export type DragContextDetachTabHandler = (evt: DragContextDetachTabEvent) => void;
+export type DragContextEvents = {
+    "cancel-tab-drag": DragContextCancelTabDragHandler;
+    drop: DragContextDropHandler;
+    "detach-tab": DragContextDetachTabHandler;
+};
+export declare class DragContext extends EventEmitter<DragContextEvents> {
+    #private;
+    private readonly templateDragSession?;
+    constructor(templateDragSession?: TemplateDragSession | undefined);
+    beginDrag(e: DragEvent, dragSource: DragSource): void;
+    endDrag(): void;
+    beginDrop(): void;
+    cancelDrag(): void;
+    completeDrop(): void;
+    /**
+     * A 'detached' tab is one that has been dragged from its place in tabstrip
+     * but not yet dropped. If it is the selected tab, we want to avoid unmounting
+     * the react component in the associated TabPanel. By marking it as 'detached'
+     * the TabPanel is still rendered but not visible. When the tab is dropped, the
+     * TabPanel can be assigned its new location (might still be within tabstrip, might
+     * not be) and made visible, without ever having to unmount/remount.
+     */
+    detachTab(gridId: string, tabsId: string, itemId: string, value: string): void;
+    drop: ({ tabsId, dropPosition, }: Pick<DragContextDropEvent, "tabsId" | "dropPosition">) => void;
+    registerTabsForDragDrop: (id: string) => () => void;
+    registerDragStateCleanup: (cleanup: () => void) => () => boolean;
+    cleanupDragState(): void;
+    get draggedElement(): HTMLElement;
+    get dragElementWidth(): number;
+    get dragLabelWidth(): number;
+    get dragSource(): import("../GridLayoutContext").ComponentDragSource | import("../GridLayoutContext").TabbedComponentDragSource | (import("..").LegacyComponentTemplate & {
+        element: HTMLElement;
+        layoutId: string;
+        type: "template";
+    }) | (import("..").TypedComponentTemplate & {
+        element: HTMLElement;
+        layoutId: string;
+        type: "template";
+    }) | undefined;
+    get internalDragSources(): Map<string, DragSourceDescriptor>;
+    set dragSources(dragSources: DragSources);
+    get dropped(): boolean;
+    get dropPending(): boolean;
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    get ownsDrag(): boolean;
+    private buildDragSources;
+}
+export {};

package/types/drag-drop-next/DragDropProviderNext.d.ts

@@ -0,0 +1,23 @@
+import { type ReactNode } from "react";
+import { DragContext, type DragContextCancelTabDragHandler, type DragContextDetachTabHandler, type DragContextDropHandler, type DragSources } from "./DragContextNext";
+export type DragDropRegistrationFn = (id: string) => void;
+export type DragDropBeginDrag = (id: string, draggedElement: HTMLElement) => void;
+export type DragDropEndDrag = (id: string) => void;
+export type DragSourceRegistrationHandler = (id: string) => void;
+export interface DragDropNextProviderProps {
+    children: ReactNode;
+    dragSources: DragSources;
+    onCancelDrag?: () => void;
+    onCancelTabDrag: DragContextCancelTabDragHandler;
+    onDetachTab: DragContextDetachTabHandler;
+    onDrop: DragContextDropHandler;
+}
+export type MeasuredTarget = {
+    bottom: number;
+    left: number;
+    right: number;
+    top: number;
+};
+export declare const DragDropProviderNext: ({ children, onCancelDrag, onCancelTabDrag, onDetachTab, onDrop, }: DragDropNextProviderProps) => import("react").JSX.Element;
+export declare const useDragContext: () => DragContext;
+export declare const useOptionalDragContext: () => DragContext | undefined;

package/types/drag-drop-next/SpaceMan.d.ts

@@ -0,0 +1,35 @@
+import type { RefCallback } from "react";
+import { type orientationType } from "@vuu-ui/vuu-utils";
+import type { DragContext, DropPosition } from "./DragContextNext";
+export type State = "initial" | "away" | "1spacer" | "2spacer";
+type Direction = "fwd" | "bwd";
+export declare class SpaceMan {
+    #private;
+    id: string;
+    constructor(dragContext: DragContext, id: string, orientation?: orientationType);
+    get mouseOffset(): {
+        x: number;
+        y: number;
+    };
+    set mouseOffset(offset: {
+        x: number;
+        y: number;
+    });
+    get dropPosition(): DropPosition | undefined;
+    get positionRelativeToTargetTab(): "before" | "after";
+    setDragContainer: RefCallback<HTMLElement>;
+    enterDragContainer(): void;
+    leaveDragContainer(): void;
+    dragStart(index: number | string): void;
+    dragEnter(index: number, direction: Direction): void;
+    insertSpacer(index: number | string, size: number, direction?: Direction): void;
+    private clearSpacers;
+    private clearDragStartTimer;
+    cleanup(): void;
+    drop(x: number, y: number): Promise<void>;
+    private getPositionOfDragContainer;
+    private getPositionOfDropTarget;
+    private setSpacerSizes;
+    private createDragSpacer;
+}
+export {};

package/types/drag-drop-next/TemplateDragSession.d.ts

@@ -0,0 +1,21 @@
+import type { TemplateSource } from "../GridLayoutContext";
+export type TemplateDragMetrics = {
+    elementHeight: number;
+    elementWidth: number;
+    labelWidth: number;
+    x: number;
+    y: number;
+};
+export declare class TemplateDragSession {
+    #private;
+    begin(source: TemplateSource, metrics: TemplateDragMetrics): void;
+    completeDrop(): void;
+    end(): void;
+    get dropped(): boolean;
+    get metrics(): TemplateDragMetrics | undefined;
+    get source(): TemplateSource | undefined;
+    set x(value: number);
+    set y(value: number);
+}
+export declare const TemplateDragSessionContext: import("react").Context<TemplateDragSession | undefined>;
+export declare const useTemplateDragSession: () => TemplateDragSession | undefined;

package/types/drag-drop-next/tabstrip-drag-drop.d.ts

@@ -0,0 +1,3 @@
+import { type orientationType } from "@vuu-ui/vuu-utils";
+import type { DragContext } from "./DragContextNext";
+export declare function initializeDragContainer(containerEl: HTMLElement, dragContext: DragContext, orientation?: orientationType, tabsId?: string): () => void;

package/types/grid-dom-utils.d.ts

@@ -0,0 +1,17 @@
+import { GridLayoutModelPosition, GridLayoutResizeDirection } from "./GridLayoutModel";
+import { GridModelChildItem } from "./GridModel";
+export declare const classNameLayoutItem = "vuuGridLayoutItem";
+export declare const classNameGridSplitter = "vuuGridSplitter";
+export type ResizeOrientation = "horizontal" | "vertical";
+type GridPos = [number, number];
+export declare const getGridSplitter: (el: HTMLElement) => HTMLElement;
+export declare const getGridLayoutItem: (el: HTMLElement) => HTMLElement;
+export declare const getColumn: (el: HTMLElement) => GridPos;
+export declare const getRow: (el: HTMLElement | undefined) => GridPos;
+export declare const getRowIndex: (el: HTMLElement) => number;
+export declare const setGridColumn: (target: string | HTMLElement, { start, end }: GridLayoutModelPosition) => void;
+export declare const setGridRow: (target: string | HTMLElement, { start, end }: GridLayoutModelPosition) => void;
+export declare const spansMultipleTracks: (gridItem: GridModelChildItem, direction: GridLayoutResizeDirection) => boolean;
+export declare function getClosestGridLayout(source: string): string;
+export declare function getClosestGridLayout(source: HTMLElement): string;
+export {};

package/types/grid-layout-utils.d.ts

@@ -0,0 +1,18 @@
+import type { GridLayoutChildItemDescriptor, GridLayoutModelCoordinates, GridModelChildItem, GridModelCoordinates, ISplitter, TrackType } from "./GridModel";
+/**
+ * Geometry and track algorithms live in GridGeometry, which is pure and
+ * immutable. The helpers here bridge the runtime (React/DOM) layer to the
+ * mutable model instances.
+ */
+/**
+ *
+ * @param moveBy positive or negative number
+ * @param adjustmentAmount positive number, never greater than abs(moveBy)
+ * @returns
+ */
+export declare const adjustDistance: (moveBy: number, adjustmentAmount: number) => number;
+export declare const getGridArea: ({ column, row }: GridLayoutModelCoordinates) => string;
+export declare const getActiveIndex: (childItems: GridModelChildItem[]) => number;
+export declare const getSharedGridPosition: (childItems: GridModelChildItem[]) => GridLayoutModelCoordinates;
+export declare const getGridPosition: (gridArea: GridLayoutChildItemDescriptor["gridArea"]) => GridModelCoordinates;
+export declare const getTrackType: (splitter: ISplitter) => TrackType;

package/types/grid-matrix.d.ts

@@ -0,0 +1,5 @@
+import { GridModelChildItem } from "./GridModel";
+export type GridMatrix = number[][];
+export declare const getGridMatrix: (gridItems: GridModelChildItem[], rowCount: number, colCount: number) => GridMatrix;
+export declare const printGrid: (grid: number[][]) => void;
+export declare function getEmptyExtents(grid: GridMatrix): GridModelChildItem[];

package/types/grid-snapshot-adapters.d.ts

@@ -0,0 +1,22 @@
+import type { GridLayoutChildItemDescriptor, GridLayoutDescriptor } from "./GridModel";
+import { type ComponentInstanceId, type GridSnapshot, type GridSnapshotValidationIssue } from "./GridSnapshot";
+import { type GridStackState } from "./GridStack";
+export interface GridLayoutDescriptorSnapshotOptions {
+    readonly gridId: string;
+    readonly revision?: number;
+}
+export interface GridLayoutDescriptorV1 extends Omit<GridLayoutDescriptor, "gridLayoutItems"> {
+    readonly gridLayoutItems?: Record<string, GridLayoutChildItemDescriptor & {
+        readonly componentId?: ComponentInstanceId;
+    }>;
+}
+export declare const validateGridSnapshot: (value: unknown) => readonly GridSnapshotValidationIssue[];
+export declare const normalizeGridSnapshot: (snapshot: GridSnapshot) => GridSnapshot;
+export declare const gridLayoutDescriptorToSnapshot: (descriptor: GridLayoutDescriptorV1, { gridId, revision }: GridLayoutDescriptorSnapshotOptions) => GridSnapshot;
+export declare const gridSnapshotToGridLayoutDescriptor: (snapshot: GridSnapshot) => GridLayoutDescriptorV1;
+/**
+ * Read canonical stack state from a snapshot. Membership, order and selection
+ * come from the snapshot stacks; placement and durable metadata come from the
+ * stack members, which all occupy the same grid area.
+ */
+export declare const gridSnapshotToGridStackStates: (snapshot: GridSnapshot) => readonly GridStackState[];

package/types/index.d.ts

@@ -0,0 +1,24 @@
+export type { DragSources, DropHandler, } from "./drag-drop-next/DragContextNext";
+export { DragDropProviderNext, useOptionalDragContext, } from "./drag-drop-next/DragDropProviderNext";
+export { GridLayout, type GridResizeDistribution } from "./GridLayout";
+export { GridDragCoordinator, createGridDropPlan, type GridDragCoordinatorError, type GridDragCoordinatorErrorCode, type GridDragCoordinatorResult, type GridDragCoordinatorState, type GridDragSource, type GridDropIntent, type GridDropPlan, type GridDropTarget, } from "./GridDragCoordinator";
+export { GridController, type GridCommittedTransition, type GridCommittedTransitionListener, type GridControllerError, type GridControllerErrorCode, type GridControllerListener, type GridTransactionCloseResult, type GridTransactionKind, type GridTransactionStartResult, type GridTransaction, } from "./GridController";
+export { GridCommandExecutionError, throwForGridCommandFailure, type GridCommand, type GridCommandError, type GridCommandErrorCode, type GridCommandItem, type GridCommandResizeConstraint, type GridCommandResult, type GridTrackResize, } from "./GridCommand";
+export { useGridLayoutDispatch, useGridLayoutDragStartHandler, useGridController, useGridModel, useGridSnapshot, type ComponentTemplate, type ComponentTemplateWithoutLabel, type LegacyComponentTemplate, type DragSource, type TemplateSource, type TypedComponentTemplate, } from "./GridLayoutContext";
+export { useGridControllerSnapshot } from "./useGridControllerSnapshot";
+export { GridLayoutItem } from "./GridLayoutItem";
+export { GridLayoutProvider, GridLayoutDocumentController, type GridLayoutDocumentChange, type GridLayoutDocumentChangeHandler, type GridLayoutDocumentStoreListener, type GridLayoutProviderProps, } from "./GridLayoutProvider";
+export { createSequentialGridLayoutIdAllocator, remapGridLayoutDocumentIds, type GridLayoutIdAllocator, type GridLayoutIdKind, type GridLayoutIdRemapping, type RemappedGridLayoutDocument, } from "./GridLayoutDocumentIds";
+export * as GridLayoutLegacyCompatibility from "./GridLayoutLegacyCompatibility";
+export { createLegacyGridLayoutReader, decodeLegacySerializedGridLayout, type LegacyDeserializedGridLayout, type LegacyGridLayoutDecodeResult, type LegacyGridLayoutDocument, type LegacyGridLayoutReader, type LegacySerializedComponentMap, type SerializedGridLayout, } from "./GridLayoutLegacyCompatibility";
+export { GridComponentRendererRegistry, GridComponentSettingsRegistry, GridLayoutContentRegistry, type DecodedGridComponentSettings, type EncodedGridComponentSettings, type GridComponentRenderer, type GridComponentSettingsCodec, type GridComponentSettingsError, type GridComponentSettingsErrorCode, type GridComponentSettingsInput, type GridComponentSettingsResult, type GridSettingsCodecIssue, type GridSettingsCodecResult, } from "./GridComponentSettings";
+export { GRID_LAYOUT_DOCUMENT_KIND, GRID_LAYOUT_DOCUMENT_VERSION, GridLayoutDocumentCodecError, decodeGridLayoutDocument, encodeGridLayoutDocument, immutableGridLayoutDocument, type DecodedGridLayoutDocument, type EncodeGridLayoutDocumentOptions, type GridLayoutDocument, type GridLayoutDocumentError, type GridLayoutDocumentErrorCode, type GridLayoutDocumentResult, type GridLayoutDocumentV1, type PersistedGridLayout, } from "./GridLayoutDocument";
+export { toJsonValue, type JsonPrimitive, type JsonValue, type JsonValueErrorCode, type JsonValueIssue, type JsonValueResult, } from "./json-value";
+export { GridLayoutStackedItem } from "./GridLayoutStackedtem";
+export { gridLayoutDescriptorToSnapshot, gridSnapshotToGridLayoutDescriptor, gridSnapshotToGridStackStates, normalizeGridSnapshot, validateGridSnapshot, type GridLayoutDescriptorSnapshotOptions, type GridLayoutDescriptorV1, } from "./grid-snapshot-adapters";
+export { GridSnapshotValidationError, type ComponentInstanceId, type GridId, type GridItemId, type GridItemResizeable, type GridItemSnapshot, type GridSnapshot, type GridSnapshotValidationCode, type GridSnapshotValidationIssue, type GridSpanSnapshot, type GridStackSnapshot, type GridTrackSize, type GridTrackSnapshot, type StackId, } from "./GridSnapshot";
+export { MIN_GRID_STACK_MEMBERS, addGridStackItem, assertValidGridStackState, cloneGridStackState, createGridStack, findGridStackMember, gridStackItemIds, gridStackMemberIndex, gridStackSelectedIndex, isSameGridStackState, normalizeGridStackState, removeGridStackItem, renameGridStackItem, reorderGridStackItem, selectGridStackItem, toGridStackSnapshot, validateGridStackState, type GridStackAddRequest, type GridStackArea, type GridStackCreateRequest, type GridStackError, type GridStackErrorCode, type GridStackMember, type GridStackMetadata, type GridStackOperation, type GridStackPosition, type GridStackRemoveRequest, type GridStackRenameRequest, type GridStackReorderRequest, type GridStackResult, type GridStackSelectRequest, type GridStackState, type GridStackTransition, type GridStackValidationOptions, } from "./GridStack";
+export type { GridLayoutChangeHandler, GridLayoutDescriptor, TrackSize, } from "./GridModel";
+export { layoutFromJson } from "./layoutFromJson";
+export { useDraggable } from "./useDraggable";
+export { GridPlaceholder } from "./GridPlaceholder";

package/types/json-value.d.ts

@@ -0,0 +1,23 @@
+export type JsonPrimitive = boolean | number | string | null;
+export type JsonValue = JsonPrimitive | readonly JsonValue[] | {
+    readonly [key: string]: JsonValue;
+};
+export type JsonValueErrorCode = "CYCLE" | "INVALID_NUMBER" | "NON_PLAIN_OBJECT" | "UNSUPPORTED_VALUE";
+export interface JsonValueIssue {
+    readonly code: JsonValueErrorCode;
+    readonly message: string;
+    readonly path: string;
+}
+export type JsonValueResult = {
+    readonly ok: true;
+    readonly value: JsonValue;
+} | {
+    readonly error: JsonValueIssue;
+    readonly ok: false;
+};
+/**
+ * Validate and detach data at the persistence boundary. JSON.stringify is not
+ * used because it silently drops unsupported values and coerces non-finite
+ * numbers.
+ */
+export declare const toJsonValue: (value: unknown, path?: string) => JsonValueResult;

package/types/layoutFromJson.d.ts

@@ -0,0 +1,4 @@
+import { type ReactElement } from "react";
+import type { LayoutJSON } from "./componentToJson";
+/** @deprecated Use GridLayoutProvider document plus renderer registries. */
+export declare function layoutFromJson({ active, id, type, children, props, }: LayoutJSON): ReactElement;

package/types/layoutToJson.d.ts

@@ -0,0 +1,3 @@
+import type { ReactElement } from "react";
+/** @deprecated Use encodeGridLayoutDocument for GridLayout persistence. */
+export declare function layoutToJSON(component: ReactElement): import("./componentToJson").LayoutJSON<object>;

package/types/propUtils.d.ts

@@ -0,0 +1,5 @@
+import { ReactElement } from "react";
+import { LayoutModel } from "@vuu-ui/vuu-utils";
+export declare const getProp: (component: LayoutModel | undefined, propName: string) => any;
+export declare const getProps: (component?: LayoutModel) => {};
+export declare const getChildProp: (container: LayoutModel) => ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | undefined;

package/types/react-element-utils.d.ts

@@ -0,0 +1,3 @@
+import React, { ReactElement } from "react";
+export declare const getGridItemChild: (gridItems: ReactElement[], gridItemId: string) => ReactElement;
+export declare const addChildToStackedGridItem: (stackElement: ReactElement, childElement: ReactElement) => ReactElement<unknown, string | React.JSXElementConstructor<any>>;

package/types/src/AddTabDialog.d.ts

@@ -0,0 +1,5 @@
+export declare const AddTabDialog: ({ open, onConfirm, onCancel, }: {
+    open?: boolean;
+    onConfirm: (value: string) => void;
+    onCancel: () => void;
+}) => import("react").JSX.Element;

package/types/src/GridLayout.d.ts

@@ -0,0 +1,14 @@
+import { HTMLAttributes, ReactElement } from "react";
+import { GridLayoutItemProps } from "./GridLayoutItem";
+import { GridColumnsAndRows, GridLayoutChangeHandler } from "./GridModel";
+export type GridResizeable = "h" | "v" | "hv";
+export interface GridLayoutProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange"> {
+    children?: ReactElement<GridLayoutItemProps> | ReactElement<GridLayoutItemProps>[];
+    "full-page"?: boolean;
+    colsAndRows?: GridColumnsAndRows;
+    onChange?: GridLayoutChangeHandler;
+}
+export declare function GridLayout({ id: idProp, children: childrenProp, className, "full-page": fullPage, colsAndRows, onClick, onChange, style: styleProp, ...htmlAttributes }: GridLayoutProps): import("react").JSX.Element;
+export declare namespace GridLayout {
+    var displayName: string;
+}