@1771technologies/lytenyte-pro 0.9.4 → 1.0.0-beta.0

package/dist/sort-manager/root.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useMemo } from "react";
+import { context } from "./context";
+export function Root({ sortItems, setSortItems, grid, mode, children, }) {
+    const value = useMemo(() => {
+        return {
+            sortItems,
+            setSortItems,
+            grid,
+            mode,
+        };
+    }, [grid, mode, setSortItems, sortItems]);
+    return _jsx(context.Provider, { value: value, children: children });
+}

package/dist/sort-manager/sort-add.d.ts

@@ -0,0 +1,8 @@
+import { type SlotComponent } from "@1771technologies/lytenyte-react-hooks";
+export interface SortAddProps {
+    readonly slot?: SlotComponent<{
+        onAdd: () => void;
+        disabled: boolean;
+    }>;
+}
+export declare const SortAdd: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLButtonElement> & import("react").ButtonHTMLAttributes<HTMLButtonElement> & SortAddProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;

package/dist/sort-manager/sort-add.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useSlot } from "@1771technologies/lytenyte-react-hooks";
+import { forwardRef } from "react";
+import { useSortRowCtx } from "./context";
+export const SortAdd = forwardRef(function SortAdd({ slot, ...props }, forwarded) {
+    const row = useSortRowCtx();
+    const renderer = useSlot({
+        props: [props],
+        ref: forwarded,
+        slot: slot ?? (_jsx("button", { onClick: row.onAdd, disabled: !row.canAdd, children: "+" })),
+        state: { onAdd: row.onAdd, disabled: !row.canAdd },
+    });
+    return renderer;
+});

package/dist/sort-manager/sort-apply.d.ts

@@ -0,0 +1,7 @@
+import { type SlotComponent } from "@1771technologies/lytenyte-react-hooks";
+export interface SortApplyProps {
+    readonly slot?: SlotComponent<{
+        onApply: () => void;
+    }>;
+}
+export declare const SortApply: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLButtonElement> & import("react").ButtonHTMLAttributes<HTMLButtonElement> & SortApplyProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;

package/dist/sort-manager/sort-apply.js

@@ -0,0 +1,24 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEvent, useSlot } from "@1771technologies/lytenyte-react-hooks";
+import { forwardRef } from "react";
+import { useSortManagerCtx } from "./context";
+import { itemsWithIdToMap } from "@1771technologies/lytenyte-js-utils";
+import { sortItemsToSortModel } from "./utils/sort-item-to-sort-model";
+export const SortApply = forwardRef(function SortApply({ slot, ...props }, forwarded) {
+    const ctx = useSortManagerCtx();
+    const onApply = useEvent(() => {
+        const lookup = itemsWithIdToMap(ctx.mode ? ctx.grid.state.columnPivotColumns.get() : ctx.grid.state.columns.get());
+        const model = sortItemsToSortModel(ctx.sortItems, lookup);
+        if (ctx.mode)
+            ctx.grid.state.columnPivotModel.set((prev) => ({ ...prev, sort: model }));
+        else
+            ctx.grid.state.sortModel.set(model);
+    });
+    const renderer = useSlot({
+        props: [props],
+        ref: forwarded,
+        slot: slot ?? _jsx("button", { onClick: onApply }),
+        state: { onApply },
+    });
+    return renderer;
+});

package/dist/sort-manager/sort-cancel.d.ts

@@ -0,0 +1,7 @@
+import { type SlotComponent } from "@1771technologies/lytenyte-react-hooks";
+export interface SortCancelProps {
+    readonly slot?: SlotComponent<{
+        onCancel: () => void;
+    }>;
+}
+export declare const SortCancel: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLButtonElement> & import("react").ButtonHTMLAttributes<HTMLButtonElement> & SortCancelProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;

package/dist/sort-manager/sort-cancel.js

@@ -0,0 +1,27 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEvent, useSlot } from "@1771technologies/lytenyte-react-hooks";
+import { forwardRef } from "react";
+import { useSortManagerCtx } from "./context";
+import { sortModelToSortItems } from "./utils/sort-model-to-sort-items";
+import { itemsWithIdToMap } from "@1771technologies/lytenyte-js-utils";
+export const SortCancel = forwardRef(function SortCancel({ slot, ...props }, forwarded) {
+    const ctx = useSortManagerCtx();
+    const onCancel = useEvent(() => {
+        const model = ctx.mode
+            ? ctx.grid.state.columnPivotModel.get().sorts
+            : ctx.grid.state.sortModel.get();
+        const lookup = itemsWithIdToMap(ctx.mode ? ctx.grid.state.columnPivotColumns.get() : ctx.grid.state.columns.get());
+        const state = sortModelToSortItems(model, lookup);
+        if (!state.length)
+            ctx.setSortItems([{ isCustom: false, sortDirection: "ascending" }]);
+        else
+            ctx.setSortItems(state);
+    });
+    const renderer = useSlot({
+        props: [props],
+        ref: forwarded,
+        slot: slot ?? _jsx("button", { onClick: onCancel }),
+        state: { onCancel },
+    });
+    return renderer;
+});

package/dist/sort-manager/sort-clear.d.ts

@@ -0,0 +1,7 @@
+import { type SlotComponent } from "@1771technologies/lytenyte-react-hooks";
+export interface SortClearProps {
+    readonly slot?: SlotComponent<{
+        onClear: () => void;
+    }>;
+}
+export declare const SortClear: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLButtonElement> & import("react").ButtonHTMLAttributes<HTMLButtonElement> & SortClearProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;

package/dist/sort-manager/sort-clear.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEvent, useSlot } from "@1771technologies/lytenyte-react-hooks";
+import { forwardRef } from "react";
+import { useSortManagerCtx } from "./context";
+export const SortClear = forwardRef(function SortClear({ slot, ...props }, forwarded) {
+    const ctx = useSortManagerCtx();
+    const onClear = useEvent(() => {
+        if (ctx.mode) {
+            ctx.grid.state.columnPivotModel.set((prev) => ({ ...prev, sorts: [] }));
+        }
+        else {
+            ctx.grid.state.sortModel.set([]);
+        }
+    });
+    const renderer = useSlot({
+        props: [props],
+        ref: forwarded,
+        slot: slot ?? _jsx("button", { onClick: onClear }),
+        state: { onClear },
+    });
+    return renderer;
+});

package/dist/sort-manager/sort-column-select.d.ts

@@ -0,0 +1,10 @@
+import { type SlotComponent } from "@1771technologies/lytenyte-react-hooks";
+import type { Option } from "./+types";
+export interface SortColumnSelectProps {
+    readonly slot?: SlotComponent<{
+        options: Option[];
+        onSelect: (v: Option | null) => void;
+        value: Option | null;
+    }>;
+}
+export declare const SortColumnSelect: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & SortColumnSelectProps, "ref"> & import("react").RefAttributes<HTMLSelectElement>>;

package/dist/sort-manager/sort-column-select.js

@@ -0,0 +1,20 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useSlot } from "@1771technologies/lytenyte-react-hooks";
+import { forwardRef } from "react";
+import { useSortRowCtx } from "./context";
+export const SortColumnSelect = forwardRef(function SortColumnSelect({ slot, ...props }, forwarded) {
+    const row = useSortRowCtx();
+    const el = (_jsxs("select", { "aria-label": "Select column to sort", value: row.columnItem?.value ?? "", onChange: (e) => {
+            const item = row.columnOptions.find((c) => c.value === e.target.value);
+            row.columnOnSelect(item ?? null);
+        }, children: [_jsx("option", { value: "", children: "Select..." }), row.columnOptions.map((c) => {
+                return (_jsx("option", { value: c.value, children: c.label }, c.value));
+            })] }));
+    const renderer = useSlot({
+        props: [props],
+        ref: forwarded,
+        slot: slot ?? el,
+        state: { options: row.columnOptions, onSelect: row.columnOnSelect, value: row.columnSelected },
+    });
+    return renderer;
+});

package/dist/sort-manager/sort-direction-select.d.ts

@@ -0,0 +1,10 @@
+import { type SlotComponent } from "@1771technologies/lytenyte-react-hooks";
+import type { Option } from "./+types";
+export interface SortDirectionSelectProps {
+    readonly slot?: SlotComponent<{
+        options: Option[];
+        onSelect: (v: Option | null) => void;
+        value: Option | null;
+    }>;
+}
+export declare const SortDirectionSelect: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & SortDirectionSelectProps, "ref"> & import("react").RefAttributes<HTMLSelectElement>>;

package/dist/sort-manager/sort-direction-select.js

@@ -0,0 +1,24 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useSlot } from "@1771technologies/lytenyte-react-hooks";
+import { forwardRef } from "react";
+import { useSortRowCtx } from "./context";
+export const SortDirectionSelect = forwardRef(function SortDirectionSelect({ slot, ...props }, forwarded) {
+    const row = useSortRowCtx();
+    const el = (_jsx("select", { "aria-label": "Select sort direction", value: row.sortDirectionSelected?.value ?? "", onChange: (e) => {
+            const item = row.sortDirectionOptions.find((c) => c.value === e.target.value);
+            row.sortDirectionOnSelect(item ?? null);
+        }, children: row.sortDirectionOptions.map((c) => {
+            return (_jsx("option", { value: c.value, children: c.label }, c.value));
+        }) }));
+    const renderer = useSlot({
+        props: [props],
+        ref: forwarded,
+        slot: slot ?? el,
+        state: {
+            options: row.sortDirectionOptions,
+            onSelect: row.sortDirectionOnSelect,
+            value: row.sortDirectionSelected,
+        },
+    });
+    return renderer;
+});

package/dist/sort-manager/sort-manager.d.ts

@@ -0,0 +1,16 @@
+import { Root } from "./root";
+import { useSortManager } from "./hooks/use-sort-manager";
+export declare const SortManager: {
+    Root: typeof Root;
+    Row: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & import("./sort-row").SortRowProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    Rows: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    ColumnSelect: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & import("./sort-column-select").SortColumnSelectProps, "ref"> & import("react").RefAttributes<HTMLSelectElement>>;
+    ValueSelect: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & import("./sort-value-select").SortValueSelectProps, "ref"> & import("react").RefAttributes<HTMLSelectElement>>;
+    DirectionSelect: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & import("./sort-direction-select").SortDirectionSelectProps, "ref"> & import("react").RefAttributes<HTMLSelectElement>>;
+    Add: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLButtonElement> & import("react").ButtonHTMLAttributes<HTMLButtonElement> & import("./sort-add").SortAddProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    Remove: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLButtonElement> & import("react").ButtonHTMLAttributes<HTMLButtonElement> & import("./sort-remove").SortRemoveProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    Cancel: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLButtonElement> & import("react").ButtonHTMLAttributes<HTMLButtonElement> & import("./sort-cancel").SortCancelProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    Clear: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLButtonElement> & import("react").ButtonHTMLAttributes<HTMLButtonElement> & import("./sort-clear").SortClearProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    Apply: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLButtonElement> & import("react").ButtonHTMLAttributes<HTMLButtonElement> & import("./sort-apply").SortApplyProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    useSortManager: typeof useSortManager;
+};

package/dist/sort-manager/sort-manager.js

@@ -0,0 +1,26 @@
+import { Root } from "./root";
+import { SortRow } from "./sort-row";
+import { SortRows } from "./sort-rows";
+import { useSortManager } from "./hooks/use-sort-manager";
+import { SortColumnSelect } from "./sort-column-select";
+import { SortValueSelect } from "./sort-value-select";
+import { SortDirectionSelect } from "./sort-direction-select";
+import { SortAdd } from "./sort-add";
+import { SortRemove } from "./sort-remove";
+import { SortCancel } from "./sort-cancel";
+import { SortClear } from "./sort-clear";
+import { SortApply } from "./sort-apply";
+export const SortManager = {
+    Root,
+    Row: SortRow,
+    Rows: SortRows,
+    ColumnSelect: SortColumnSelect,
+    ValueSelect: SortValueSelect,
+    DirectionSelect: SortDirectionSelect,
+    Add: SortAdd,
+    Remove: SortRemove,
+    Cancel: SortCancel,
+    Clear: SortClear,
+    Apply: SortApply,
+    useSortManager,
+};

package/dist/sort-manager/sort-remove.d.ts

@@ -0,0 +1,7 @@
+import { type SlotComponent } from "@1771technologies/lytenyte-react-hooks";
+export interface SortRemoveProps {
+    readonly slot?: SlotComponent<{
+        onRemove: () => void;
+    }>;
+}
+export declare const SortRemove: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLButtonElement> & import("react").ButtonHTMLAttributes<HTMLButtonElement> & SortRemoveProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;

package/dist/sort-manager/sort-remove.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useSlot } from "@1771technologies/lytenyte-react-hooks";
+import { forwardRef } from "react";
+import { useSortRowCtx } from "./context";
+export const SortRemove = forwardRef(function SortRemove({ slot, ...props }, forwarded) {
+    const row = useSortRowCtx();
+    const renderer = useSlot({
+        props: [props],
+        ref: forwarded,
+        slot: slot ?? _jsx("button", { onClick: row.onDelete, children: "x" }),
+        state: { onAdd: row.onDelete },
+    });
+    return renderer;
+});

package/dist/sort-manager/sort-row.d.ts

@@ -0,0 +1,5 @@
+import type { SortRowItem } from "./hooks/use-sort-row-item";
+export interface SortRowProps {
+    readonly row: SortRowItem;
+}
+export declare const SortRow: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & SortRowProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;

package/dist/sort-manager/sort-row.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef } from "react";
+import { Item } from "../listbox/item";
+import { rowContext } from "./context";
+export const SortRow = forwardRef(function SortRow({ row, ...props }, forwarded) {
+    return (_jsx(rowContext.Provider, { value: row, children: _jsx(Item, { ...props, ref: forwarded }) }));
+});

package/dist/sort-manager/sort-rows.d.ts

@@ -0,0 +1 @@
+export declare const SortRows: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;

package/dist/sort-manager/sort-rows.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef } from "react";
+import { Panel } from "../listbox/panel";
+export const SortRows = forwardRef(function SortRows(props, forwarded) {
+    return _jsx(Panel, { ...props, ref: forwarded });
+});

package/dist/sort-manager/sort-value-select.d.ts

@@ -0,0 +1,11 @@
+import { type SlotComponent } from "@1771technologies/lytenyte-react-hooks";
+import type { Option } from "./+types";
+export interface SortValueSelectProps {
+    readonly slot?: SlotComponent<{
+        options: Option[];
+        onSelect: (v: Option | null) => void;
+        value: Option | null;
+        disabled: boolean;
+    }>;
+}
+export declare const SortValueSelect: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & SortValueSelectProps, "ref"> & import("react").RefAttributes<HTMLSelectElement>>;

package/dist/sort-manager/sort-value-select.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useSlot } from "@1771technologies/lytenyte-react-hooks";
+import { forwardRef } from "react";
+import { useSortRowCtx } from "./context";
+export const SortValueSelect = forwardRef(function SortValueSelect({ slot, ...props }, forwarded) {
+    const row = useSortRowCtx();
+    const el = (_jsxs("select", { "aria-label": "Select sort value", value: row.sortSelected?.value ?? "", onChange: (e) => {
+            const item = row.sortOptions.find((c) => c.value === e.target.value);
+            row.sortOnSelect(item ?? null);
+        }, disabled: !row.sortOptions.length, children: [_jsx("option", { value: "", children: "Select..." }), row.sortOptions.map((c) => {
+                return (_jsx("option", { value: c.value, children: c.label }, c.value));
+            })] }));
+    const renderer = useSlot({
+        props: [props],
+        ref: forwarded,
+        slot: slot ?? el,
+        state: {
+            options: row.sortOptions,
+            value: row.sortSelected,
+            onSelect: row.sortOnSelect,
+            disabled: !row.sortOptions.length,
+        },
+    });
+    return renderer;
+});

package/dist/sort-manager/utils/sort-item-to-sort-model.d.ts

@@ -0,0 +1,3 @@
+import type { SortItem } from "../+types";
+import type { Column, SortModelItem } from "../../+types";
+export declare function sortItemsToSortModel(sortItems: SortItem[], lookup: Map<string, Column<any>>): SortModelItem<any>[];

package/dist/sort-manager/utils/sort-item-to-sort-model.js

@@ -0,0 +1,57 @@
+export function sortItemsToSortModel(sortItems, lookup) {
+    return sortItems
+        .filter((c) => {
+        if (!c.columnId)
+            return false;
+        if (!c.sortOn)
+            return false;
+        if (!lookup.has(c.columnId))
+            return false;
+        return true;
+    })
+        .map((c) => {
+        const col = lookup.get(c.columnId);
+        if (col.type === "number") {
+            return {
+                columnId: col.id,
+                isDescending: c.sortDirection === "descending",
+                sort: {
+                    columnId: col.id,
+                    kind: "number",
+                    options: {
+                        absoluteValue: c.sortOn.includes("absolute"),
+                        nullsFirst: c.sortOn.includes("nulls_first"),
+                    },
+                },
+            };
+        }
+        if (col.type === "date" || col.type === "datetime") {
+            return {
+                columnId: col.id,
+                isDescending: c.sortDirection === "descending",
+                sort: {
+                    columnId: col.id,
+                    kind: "date",
+                    options: {
+                        includeTime: col.type === "datetime",
+                        nullsFirst: c.sortOn.includes("nulls_first"),
+                    },
+                },
+            };
+        }
+        return {
+            columnId: col.id,
+            isDescending: c.sortDirection === "descending",
+            sort: {
+                columnId: col.id,
+                kind: "string",
+                options: {
+                    caseInsensitive: c.sortOn?.includes("insensitive"),
+                    ignorePunctuation: c.sortOn?.includes("ignore"),
+                    nullsFirst: c.sortOn?.includes("nulls_first"),
+                    trimWhitespace: c.sortOn?.includes("trim"),
+                },
+            },
+        };
+    });
+}

package/dist/sort-manager/utils/sort-model-to-sort-items.d.ts

@@ -0,0 +1,3 @@
+import type { Column, SortModelItem } from "../../+types";
+import type { SortItem } from "../+types";
+export declare function sortModelToSortItems<T>(items: SortModelItem<T>[], lookup: Map<string, Column<T>>): SortItem[];

package/dist/sort-manager/utils/sort-model-to-sort-items.js

@@ -0,0 +1,49 @@
+export function sortModelToSortItems(items, lookup) {
+    return items
+        .map((c) => {
+        const columnId = c.columnId;
+        const sortDirection = c.isDescending ? "descending" : "ascending";
+        if (c.sort.kind === "custom") {
+            return {
+                isCustom: true,
+                sortDirection,
+                columnId: c.columnId ?? undefined,
+            };
+        }
+        const column = lookup.get(columnId);
+        if (!column)
+            return;
+        let value = "values";
+        if (c.sort.kind === "string") {
+            const opts = c.sort.options;
+            if (opts?.nullsFirst)
+                value += "_nulls_first";
+            if (opts?.caseInsensitive)
+                value += "_insensitive";
+            if (opts?.ignorePunctuation)
+                value += "_ignore";
+            if (opts?.trimWhitespace)
+                value += "trim";
+        }
+        if (c.sort.kind === "number") {
+            const opts = c.sort.options;
+            if (opts?.nullsFirst)
+                value += "_nulls_first";
+            if (opts?.absoluteValue)
+                value += "_absolute";
+        }
+        if (c.sort.kind === "date") {
+            const opts = c.sort.options;
+            if (opts?.nullsFirst)
+                value += "_nulls_first";
+        }
+        return {
+            isCustom: false,
+            columnId,
+            sortDirection,
+            label: column?.name ?? column?.id,
+            sortOn: value,
+        };
+    })
+        .filter((c) => c != null);
+}

package/dist/state/+types.d.ts

@@ -0,0 +1,34 @@
+import type { LayoutMap } from "@1771technologies/lytenyte-shared";
+import type { DataRect, EditActivePosition, GridAtom, GridAtomReadonly, HeaderGroupCellLayout, PositionUnion, VirtualTarget } from "../+types";
+import type { Atom, createStore } from "@1771technologies/atom";
+export interface InternalAtoms {
+    readonly headerRows: GridAtomReadonly<number>;
+    readonly headerCols: GridAtomReadonly<number>;
+    readonly headerHeightTotal: GridAtomReadonly<number>;
+    readonly xScroll: GridAtom<number>;
+    readonly yScroll: GridAtom<number>;
+    readonly refreshKey: GridAtom<number>;
+    readonly layout: GridAtomReadonly<LayoutMap>;
+    readonly focusActive: GridAtom<PositionUnion | null>;
+    readonly focusPrevColIndex: GridAtom<number | null>;
+    readonly focusPrevRowIndex: GridAtom<number | null>;
+    readonly editActivePos: GridAtom<EditActivePosition<any> | null>;
+    readonly editData: GridAtom<any>;
+    readonly editValidation: GridAtom<Record<string, any> | boolean>;
+    readonly rowAutoHeightCache: GridAtom<Record<number, number>>;
+    readonly rowDetailAutoHeightCache: GridAtom<Record<number, number>>;
+    readonly rowSelectedIds: Atom<Set<string>>;
+    readonly rowSelectionPivot: GridAtom<string | null>;
+    readonly rowSelectionLastWasDeselect: GridAtom<boolean>;
+    readonly draggingHeader: GridAtom<HeaderGroupCellLayout | null>;
+    readonly dialogFrames: GridAtom<Record<string, any>>;
+    readonly popoverFrames: GridAtom<Record<string, {
+        target: HTMLElement | VirtualTarget;
+        context: any;
+    }>>;
+    readonly cellSelectionPivot: GridAtom<DataRect | null>;
+    readonly cellSelectionAdditiveRects: GridAtom<DataRect[] | null>;
+    readonly cellSelectionIsDeselect: GridAtom<boolean>;
+    readonly cellSelectionSplits: GridAtomReadonly<DataRect[]>;
+    readonly store: ReturnType<typeof createStore>;
+}

package/dist/state/+types.js

@@ -0,0 +1 @@
+export {};

package/dist/state/api/column-autosize.d.ts

@@ -0,0 +1,5 @@
+import type { InternalAtoms } from "../+types";
+import type { Grid, GridApi } from "../../+types";
+export declare const makeColumnAutosize: (grid: Grid<any> & {
+    internal: InternalAtoms;
+}) => GridApi<any>["columnAutosize"];

package/dist/state/api/column-autosize.js

@@ -0,0 +1,72 @@
+import { measureText } from "@1771technologies/lytenyte-shared";
+import { resolveColumn } from "../helpers/resolve-column";
+export const makeColumnAutosize = (grid) => {
+    return (params) => {
+        const errorRef = { current: false };
+        const meta = grid.state.columnMeta.get();
+        const columns = params.columns
+            ?.map((c) => resolveColumn(c, errorRef, meta))
+            .map((c) => c && grid.api.columnById(c))
+            .filter(Boolean) ?? grid.state.columnMeta.get().columnsVisible;
+        if (errorRef.current) {
+            console.error("Invalid column autosize column params");
+            return {};
+        }
+        if (columns.length === 0)
+            return {};
+        const base = grid.state.columnBase.get();
+        const result = {};
+        const bounds = grid.state.viewBounds.get();
+        const rowFirstVisible = bounds.rowCenterStart;
+        const rowLastVisible = bounds.rowCenterEnd;
+        const rowTopCount = grid.state.rowDataStore.rowTopCount.get();
+        const rowBottomCount = grid.state.rowDataStore.rowBottomCount.get();
+        const rowCount = grid.state.rowDataStore.rowCount.get();
+        const rowStart = Math.max(rowFirstVisible, 0);
+        const rowEnd = rowLastVisible === 0 ? Math.min(50, rowCount - rowBottomCount) : rowLastVisible;
+        calculateWidths(rowStart, rowEnd);
+        if (rowTopCount)
+            calculateWidths(0, rowTopCount);
+        if (rowBottomCount)
+            calculateWidths(rowCount - rowBottomCount, rowCount);
+        if (params?.includeHeader) {
+            for (let columnIndex = 0; columnIndex < columns.length; columnIndex++) {
+                const column = columns[columnIndex];
+                const autoFn = column.autosizeHeaderFn ?? base.autosizeHeaderFn ?? defaultAutosizeHeader;
+                const width = autoFn({ grid, column: column });
+                if (width != null)
+                    result[column.id] = Math.max(width, result[column.id]);
+            }
+        }
+        if (params?.dryRun)
+            return result;
+        const updates = Object.fromEntries(Object.entries(result).map(([key, v]) => [key, { width: v }]));
+        grid.api.columnUpdate(updates);
+        return result;
+        function calculateWidths(start, end) {
+            for (let rowIndex = start; rowIndex < end; rowIndex++) {
+                const row = grid.api.rowByIndex(rowIndex);
+                if (!row)
+                    continue;
+                for (let i = 0; i < columns.length; i++) {
+                    const column = columns[i];
+                    const autoFn = column.autosizeCellFn ?? base.autosizeCellFn ?? defaultAutosize;
+                    const width = autoFn({ column, grid, row });
+                    result[column.id] ??= 0;
+                    if (width != null)
+                        result[column.id] = Math.max(width, result[column.id]);
+                }
+            }
+        }
+    };
+};
+function defaultAutosize(c) {
+    const field = c.grid.api.columnField(c.column, c.row.kind === "leaf"
+        ? { kind: "leaf", data: c.row.data }
+        : { kind: "branch", data: c.row.data, key: c.row.key });
+    return measureText(`${field}`, c.grid.state.viewport.get() ?? undefined).width + 8;
+}
+function defaultAutosizeHeader(c) {
+    const text = c.column.name ?? c.column.id;
+    return measureText(text, c.grid.state.viewport.get() ?? undefined).width + 8;
+}

package/dist/state/api/column-by-id.d.ts

@@ -0,0 +1,2 @@
+import type { Grid, GridApi } from "../../+types";
+export declare const makeColumnById: (grid: Grid<any>) => GridApi<any>["columnById"];

package/dist/state/api/column-by-id.js

@@ -0,0 +1,6 @@
+export const makeColumnById = (grid) => {
+    return (id) => {
+        const lookup = grid.state.columnMeta.get();
+        return lookup.columnLookup.get(id);
+    };
+};

package/dist/state/api/column-field.d.ts

@@ -0,0 +1,2 @@
+import type { Grid, GridApi } from "../../+types";
+export declare const makeColumnField: (grid: Grid<any>) => GridApi<any>["columnField"];

package/dist/state/api/column-field.js

@@ -0,0 +1,23 @@
+import { get } from "@1771technologies/lytenyte-js-utils";
+export const makeColumnField = (grid) => {
+    return (c, d) => {
+        const meta = grid.state.columnMeta.get();
+        const column = typeof c === "string" ? meta.columnLookup.get(c) : c;
+        if (!column) {
+            console.error(`Attempting to compute the field of a column that is not defined: ${c}`);
+            return null;
+        }
+        const field = column.field ?? column.id;
+        if (d.kind === "branch") {
+            if (typeof field === "function")
+                return field({ column, data: d, grid });
+            return d.data?.[column.id];
+        }
+        const fieldType = typeof field;
+        if (fieldType === "string" || fieldType === "number")
+            return d.data?.[field];
+        if (fieldType === "object")
+            return get(d.data, field.path);
+        return field({ column, data: d, grid });
+    };
+};

package/dist/state/api/column-from-index.d.ts

@@ -0,0 +1,2 @@
+import type { Grid, GridApi } from "../../+types";
+export declare const makeColumnFromIndex: (grid: Grid<any>) => GridApi<any>["columnFromIndex"];