@1771technologies/lytenyte-pro 1.0.12-dev.1 → 1.0.12-dev.3

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

@@ -0,0 +1,26 @@
+import { Root } from "./root.js";
+import { SortRow } from "./sort-row.js";
+import { SortRows } from "./sort-rows.js";
+import { useSortManager } from "./hooks/use-sort-manager.js";
+import { SortColumnSelect } from "./sort-column-select.js";
+import { SortValueSelect } from "./sort-value-select.js";
+import { SortDirectionSelect } from "./sort-direction-select.js";
+import { SortAdd } from "./sort-add.js";
+import { SortRemove } from "./sort-remove.js";
+import { SortCancel } from "./sort-cancel.js";
+import { SortClear } from "./sort-clear.js";
+import { SortApply } from "./sort-apply.js";
+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 as?: 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.js";
+export const SortRemove = forwardRef(function SortRemove({ as, ...props }, forwarded) {
+    const row = useSortRowCtx();
+    const renderer = useSlot({
+        props: [typeof as !== "function" ? { onClick: row.onDelete } : {}, props],
+        ref: forwarded,
+        slot: as ?? _jsx("button", { 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.js";
+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.js";
+import { rowContext } from "./context.js";
+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.js";
+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 as?: 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.js";
+export const SortValueSelect = forwardRef(function SortValueSelect({ as, ...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: as ?? 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.js";
+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,62 @@
+export function sortItemsToSortModel(sortItems, lookup) {
+    return sortItems
+        .filter((c) => {
+        if (c.isCustom)
+            return true;
+        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 (c.isCustom) {
+            return c.originalSort;
+        }
+        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.js";
+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,50 @@
+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,
+                originalSort: c,
+            };
+        }
+        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,35 @@
+import type { LayoutState, WriteSignal } from "@1771technologies/lytenyte-shared";
+import type { Column, EditActivePosition, GridAtom, GridAtomReadonly, HeaderGroupCellLayout, PositionUnion, VirtualTarget } from "../+types";
+import type { DataRectSplit } from "../cell-selection/split-cell-selection-rect";
+export interface InternalAtoms {
+    readonly headerRows: GridAtomReadonly<number>;
+    readonly headerCols: GridAtomReadonly<number>;
+    readonly headerHeightTotal: GridAtomReadonly<number>;
+    readonly xScroll: GridAtom<number>;
+    readonly yScroll: GridAtom<number>;
+    readonly layout: LayoutState;
+    readonly hasSpans: GridAtomReadonly<boolean>;
+    readonly colBounds: GridAtomReadonly<[number, number]>;
+    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: WriteSignal<Set<string>>;
+    readonly rowSelectionPivot: GridAtom<string | null>;
+    readonly rowSelectionLastWasDeselect: GridAtom<boolean>;
+    readonly rowGroupColumnState: GridAtom<Record<string, Partial<Column<any>>>>;
+    readonly draggingHeader: GridAtom<HeaderGroupCellLayout | null>;
+    readonly dialogFrames: GridAtom<Record<string, any>>;
+    readonly popoverFrames: GridAtom<Record<string, {
+        target: HTMLElement | VirtualTarget;
+        context: any;
+    }>>;
+    readonly cellSelectionPivot: GridAtom<DataRectSplit | null>;
+    readonly cellSelectionAdditiveRects: GridAtom<DataRectSplit[] | null>;
+    readonly cellSelectionIsDeselect: GridAtom<boolean>;
+    readonly cellSelectionSplits: GridAtomReadonly<DataRectSplit[]>;
+}

package/dist/state/+types.js

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

package/dist/state/api/cell-root.d.ts

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

package/dist/state/api/cell-root.js

@@ -0,0 +1,64 @@
+import { CONTAINS_DEAD_CELLS, FULL_WIDTH, updateLayout } from "@1771technologies/lytenyte-shared";
+import { getSpanFn } from "../helpers/get-span-callback.js";
+import { getFullWidthCallback } from "../helpers/get-full-width-callback.js";
+export const makeCellRoot = (grid) => {
+    return (row, column) => {
+        const l = grid.internal.layout;
+        const meta = grid.state.columnMeta.get();
+        const ds = grid.state.rowDataStore;
+        // Is this a valid position.
+        if (row < 0 || row >= ds.rowCount.get())
+            return null;
+        if (column < 0 || column >= meta.columnsVisible.length)
+            return null;
+        const rds = grid.state.rowDataSource.get();
+        const columns = meta.columnsVisible;
+        const rowFullWidthPredicate = grid.state.rowFullWidthPredicate.get();
+        if (!l.computed[row]) {
+            updateLayout({
+                base: l.base,
+                computed: l.computed,
+                lookup: l.lookup,
+                special: l.special,
+                botCount: ds.rowBottomCount.get(),
+                topCount: ds.rowTopCount.get(),
+                startCount: meta.columnVisibleStartCount,
+                centerCount: meta.columnVisibleCenterCount,
+                endCount: meta.columnVisibleEndCount,
+                computeColSpan: getSpanFn(rds, grid, columns, "col"),
+                computeRowSpan: getSpanFn(rds, grid, columns, "row"),
+                isFullWidth: getFullWidthCallback(rds, rowFullWidthPredicate.fn, grid),
+                isRowCutoff: (r) => {
+                    const row = rds.rowByIndex(r);
+                    return !row || row.kind === "branch";
+                },
+                rowStart: row,
+                rowEnd: row + 1,
+                rowMax: ds.rowCenterCount.get() + ds.rowTopCount.get(),
+                rowScanDistance: grid.state.rowScanDistance.get(),
+            });
+        }
+        const status = l.special[row];
+        if (status === FULL_WIDTH) {
+            return { kind: "full-width", rowIndex: row, colIndex: 0 };
+        }
+        if (status === CONTAINS_DEAD_CELLS) {
+            const spec = l.lookup.get(row);
+            // This cell is not covered
+            if (!spec || spec[column * 4] !== 0) {
+                return { kind: "cell", rowIndex: row, colIndex: column, root: null };
+            }
+            const rowSpan = spec[column * 4];
+            const colSpan = spec[column * 4 + 1];
+            const rowIndex = spec[column * 4 + 2];
+            const colIndex = spec[column * 4 + 3];
+            return {
+                kind: "cell",
+                rowIndex: row,
+                colIndex: column,
+                root: { colIndex, colSpan, rowIndex, rowSpan },
+            };
+        }
+        return { kind: "cell", rowIndex: row, colIndex: column, root: null };
+    };
+};

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

@@ -0,0 +1,5 @@
+import type { InternalAtoms } from "../+types.js";
+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.js";
+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 && (typeof c === "string" ? grid.api.columnById(c) : 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 makeColumnByIndex: (grid: Grid<any>) => GridApi<any>["columnByIndex"];

package/dist/state/api/column-from-index.js

@@ -0,0 +1,6 @@
+export const makeColumnByIndex = (grid) => {
+    return (index) => {
+        const v = grid.state.columnMeta.get().columnsVisible;
+        return v[index] ?? null;
+    };
+};

package/dist/state/api/column-group-toggle.d.ts

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

package/dist/state/api/column-group-toggle.js

@@ -0,0 +1,10 @@
+export const makeColumnGroupToggle = (grid) => {
+    return (group, state) => {
+        const delimiter = grid.state.columnGroupJoinDelimiter.get();
+        const id = typeof group === "string" ? group : group.join(delimiter);
+        const currentExpansions = grid.state.columnGroupExpansions.get();
+        const currentState = currentExpansions[id] ?? grid.state.columnGroupDefaultExpansion.get();
+        const next = state ?? !currentState;
+        grid.state.columnGroupExpansions.set((prev) => ({ ...prev, [id]: next }));
+    };
+};

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

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

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

@@ -0,0 +1,7 @@
+export const makeColumnIndex = (grid) => {
+    return (columnOrId) => {
+        const v = grid.state.columnMeta.get().columnsVisible;
+        const id = typeof columnOrId === "string" ? columnOrId : columnOrId.id;
+        return v.findIndex((c) => c.id === id);
+    };
+};

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

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

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

@@ -0,0 +1,49 @@
+import { resolveColumn } from "../helpers/resolve-column.js";
+export const makeColumnMove = (grid) => {
+    return (params) => {
+        const meta = grid.state.columnMeta.get();
+        const errorRef = { current: false };
+        const colSet = new Set(params.moveColumns.map((c) => {
+            return resolveColumn(c, errorRef, meta);
+        }));
+        const dest = resolveColumn(params.moveTarget, errorRef, meta);
+        if (errorRef.current)
+            return;
+        if (colSet.has(dest)) {
+            console.error(`Destination column cannot be in the move columns`);
+            return;
+        }
+        const columns = grid.state.columns.get();
+        const columnsToMove = columns.filter((c) => colSet.has(c.id));
+        const nextColumns = columns.filter((c) => !colSet.has(c.id));
+        const indexOfDest = nextColumns.findIndex((c) => c.id === dest);
+        const destCol = nextColumns[indexOfDest];
+        let stop = false;
+        grid.api.eventFire("columnMoveBegin", {
+            grid,
+            before: !!params.before,
+            moveColumns: columnsToMove,
+            moveTarget: destCol,
+            preventDefault: () => {
+                stop = true;
+            },
+            updatePinState: !!params.updatePinState,
+        });
+        if (stop)
+            return;
+        const offset = params.before ? 0 : 1;
+        nextColumns.splice(indexOfDest + offset, 0, ...columnsToMove);
+        grid.state.columns.set(nextColumns);
+        if (params.updatePinState) {
+            const updates = Object.fromEntries(columnsToMove.map((c) => [c.id, { pin: destCol.pin ?? null }]));
+            grid.api.columnUpdate(updates);
+        }
+        grid.api.eventFire("columnMoveEnd", {
+            grid,
+            before: !!params.before,
+            moveColumns: columnsToMove,
+            moveTarget: destCol,
+            updatePinState: !!params.updatePinState,
+        });
+    };
+};

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

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

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

@@ -0,0 +1,9 @@
+export const makeColumnResize = (grid) => {
+    return (updates) => {
+        const api = grid.api;
+        const columnUpdates = Object.fromEntries(Object.entries(updates)
+            .map(([c, v]) => [c, { width: v }])
+            .filter((c) => api.columnById(c[0])));
+        api.columnUpdate(columnUpdates);
+    };
+};

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

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

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

@@ -0,0 +1,26 @@
+import { GROUP_COLUMN_PREFIX } from "@1771technologies/lytenyte-shared";
+export const makeColumnUpdate = (grid) => {
+    return (updates) => {
+        const columns = [...grid.state.columns.get()];
+        const groupColumns = grid.state.columnMeta
+            .get()
+            .columnsVisible.filter((c) => c.id.startsWith(GROUP_COLUMN_PREFIX));
+        const groupState = { ...grid.internal.rowGroupColumnState.get() };
+        for (let i = 0; i < groupColumns.length; i++) {
+            const column = groupColumns[i];
+            if (updates[column.id]) {
+                const next = { ...groupState[column.id], ...updates[column.id] };
+                groupState[column.id] = next;
+            }
+        }
+        grid.internal.rowGroupColumnState.set(groupState);
+        for (let i = 0; i < columns.length; i++) {
+            const column = columns[i];
+            if (updates[column.id]) {
+                const next = { ...column, ...updates[column.id] };
+                columns[i] = next;
+            }
+        }
+        grid.state.columns.set(columns);
+    };
+};

package/dist/state/api/dialog-frame.d.ts

@@ -0,0 +1,8 @@
+import type { InternalAtoms } from "../+types.js";
+import type { Grid, GridApi } from "../../+types";
+export declare const makeDialogFrameOpen: (grid: Grid<any> & {
+    internal: InternalAtoms;
+}) => GridApi<any>["dialogFrameOpen"];
+export declare const makeDialogFrameClose: (grid: Grid<any> & {
+    internal: InternalAtoms;
+}) => GridApi<any>["dialogFrameClose"];

package/dist/state/api/dialog-frame.js

@@ -0,0 +1,16 @@
+export const makeDialogFrameOpen = (grid) => {
+    return (id, context) => {
+        grid.internal.dialogFrames.set((prev) => ({ ...prev, [id]: context }));
+    };
+};
+export const makeDialogFrameClose = (grid) => {
+    return (id) => {
+        grid.internal.dialogFrames.set((prev) => {
+            if (!id)
+                return {};
+            const next = { ...prev };
+            delete next[id];
+            return next;
+        });
+    };
+};