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

package/dist/state/helpers/column-marker.js

@@ -0,0 +1,43 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { COLUMN_MARKER_ID } from "@1771technologies/lytenyte-shared";
+import { itemsWithIdToMap } from "@1771technologies/lytenyte-js-utils";
+export function columnHandleMarker({ columns, marker, markerEnabled, }) {
+    const lookup = itemsWithIdToMap(columns);
+    if (markerEnabled && !lookup.has(COLUMN_MARKER_ID)) {
+        columns = [
+            {
+                id: COLUMN_MARKER_ID,
+                name: "",
+                pin: "start",
+                width: marker.width ?? 30,
+                widthMin: 24,
+                cellRenderer: marker.cellRenderer,
+                headerRenderer: marker.headerRenderer ?? HeaderRenderer,
+                floatingRenderer: marker.floatingRenderer ?? FloatingRenderer,
+                uiHints: marker.uiHints,
+            },
+            ...columns,
+        ];
+        lookup.set(COLUMN_MARKER_ID, columns[0]);
+    }
+    else if (!markerEnabled && lookup.has(COLUMN_MARKER_ID)) {
+        const index = columns.findIndex((c) => c.id === COLUMN_MARKER_ID);
+        columns.splice(index, 1);
+    }
+    if (markerEnabled) {
+        const column = lookup.get(COLUMN_MARKER_ID);
+        // The marker column must always be the first column displayed in the grid.
+        const index = columns.findIndex((c) => c.id === COLUMN_MARKER_ID);
+        if (index !== 0) {
+            columns.splice(index, 1);
+            columns.unshift(column);
+        }
+    }
+    return columns;
+}
+function HeaderRenderer() {
+    return (_jsx(_Fragment, { children: _jsx("div", { style: { overflow: "hidden", opacity: 0, width: "100%", height: "100%" }, children: "Marker column default" }) }));
+}
+function FloatingRenderer() {
+    return _jsx(_Fragment, {});
+}

package/dist/state/helpers/column-view.d.ts

@@ -0,0 +1,21 @@
+import { type PathTableItem } from "@1771technologies/lytenyte-shared";
+import type { Column, ColumnBase, ColumnGroupMeta } from "../../+types";
+export interface MakeColumnViewArgs<T> {
+    readonly columns: Column<T>[];
+    readonly base: ColumnBase<T>;
+    readonly groupExpansions: Record<string, boolean>;
+    readonly groupJoinDelimiter: string;
+    readonly groupExpansionDefault: boolean;
+}
+export interface MakeColumnViewReturn<T> {
+    meta: ColumnGroupMeta;
+    maxRow: number;
+    maxCol: number;
+    combinedView: PathTableItem<Column<T>>[][];
+    visibleColumns: Column<T>[];
+    lookup: Map<string, Column<T>>;
+    startCount: number;
+    endCount: number;
+    centerCount: number;
+}
+export declare function makeColumnView<T>({ columns, base, groupExpansions, groupJoinDelimiter, groupExpansionDefault, }: MakeColumnViewArgs<T>): MakeColumnViewReturn<T>;

package/dist/state/helpers/column-view.js

@@ -0,0 +1,33 @@
+import { computePathTable, getMaxHeaderDepth, getVisibleColumns, getVisibleColumnsWithGroups, makeColumnGroupMetadata, partitionColumnsByPinState, } from "@1771technologies/lytenyte-shared";
+export function makeColumnView({ columns, base, groupExpansions, groupJoinDelimiter, groupExpansionDefault, }) {
+    const lookup = new Map(columns.map((c) => [c.id, c]));
+    const columnsNotHidden = getVisibleColumns(columns, base);
+    const groupMetadata = makeColumnGroupMetadata(columnsNotHidden, groupJoinDelimiter);
+    const visible = getVisibleColumnsWithGroups(columnsNotHidden, groupMetadata, groupExpansions, groupExpansionDefault);
+    const { start, center, end } = partitionColumnsByPinState(visible);
+    const seenMap = {};
+    const maxDepth = getMaxHeaderDepth(visible);
+    const endOffset = start.length + center.length;
+    const startTable = computePathTable(start, maxDepth, seenMap, groupJoinDelimiter, 0).table;
+    const centerTable = computePathTable(center, maxDepth, seenMap, groupJoinDelimiter, start.length).table;
+    const endTable = computePathTable(end, maxDepth, seenMap, groupJoinDelimiter, endOffset).table;
+    const combinedView = [];
+    for (let i = 0; i <= maxDepth; i++) {
+        const row = [];
+        row.push(...(startTable[i] ?? []));
+        row.push(...(centerTable[i] ?? []));
+        row.push(...(endTable[i] ?? []));
+        combinedView.push(row);
+    }
+    return {
+        meta: groupMetadata,
+        maxRow: maxDepth + 1,
+        maxCol: visible.length,
+        combinedView,
+        visibleColumns: [...start, ...center, ...end],
+        lookup,
+        startCount: start.length,
+        endCount: end.length,
+        centerCount: center.length,
+    };
+}

package/dist/state/helpers/edit-on-change.d.ts

@@ -0,0 +1,15 @@
+import type { InternalAtoms } from "../+types";
+import type { Column, ColumnBase, Grid, RowNode } from "../../+types";
+interface EditOnChangeArgs<T> {
+    readonly column: Column<T>;
+    readonly base: ColumnBase<T>;
+    readonly activeData: any;
+    readonly row: RowNode<T>;
+    readonly value: any;
+    readonly grid: Grid<T> & {
+        internal: InternalAtoms;
+    };
+    readonly rowIndex: number;
+}
+export declare function editOnChange<T>({ value: c, grid, rowIndex, column, base, row, activeData, }: EditOnChangeArgs<T>): void;
+export {};

package/dist/state/helpers/edit-on-change.js

@@ -0,0 +1,26 @@
+export function editOnChange({ value: c, grid, rowIndex, column, base, row, activeData, }) {
+    const field = column.field ?? column.id;
+    let next = structuredClone(activeData);
+    if (row.kind !== "branch" && typeof field === "number")
+        next[field] = c;
+    else if (row.kind !== "branch" && typeof field === "string")
+        next[field] = c;
+    else {
+        const setter = column.editSetter ?? base.editSetter;
+        if (!setter) {
+            console.error("A column with a non-trivial field must provide a corresponding editSetter to be editable.");
+            return;
+        }
+        next = setter({
+            column,
+            data: next,
+            grid: grid,
+            row,
+            rowIndex,
+        });
+    }
+    const validator = grid.state.editRowValidatorFn.get();
+    const result = validator.fn({ grid: grid, rowIndex: rowIndex, data: next, row });
+    grid.internal.editData.set(next);
+    grid.internal.editValidation.set(result);
+}

package/dist/state/helpers/empty-row-data-source.d.ts

@@ -0,0 +1,2 @@
+import type { RowDataSource } from "../../+types";
+export declare const emptyRowDataSource: RowDataSource<any>;

package/dist/state/helpers/empty-row-data-source.js

@@ -0,0 +1,17 @@
+export const emptyRowDataSource = {
+    init: () => { },
+    rowById: () => null,
+    rowByIndex: () => null,
+    rowExpand: () => { },
+    rowUpdate: () => { },
+    rowToIndex: () => null,
+    rowAllChildIds: () => [],
+    rowSelect: () => { },
+    rowSelectAll: () => { },
+    rowAdd: () => { },
+    rowDelete: () => { },
+    rowSetBotData: () => { },
+    rowSetTopData: () => { },
+    rowAreAllSelected: () => false,
+    inFilterItems: () => [],
+};

package/dist/state/helpers/get-data-rect.d.ts

@@ -0,0 +1,13 @@
+import type { Column, ExportDataRectResult, RowNode } from "../../+types";
+export interface GetDataRectArgs {
+    readonly columnStart: number;
+    readonly columnEnd: number;
+    readonly rows: (RowNode<any> | null | undefined)[];
+    readonly uniformGroupHeaders?: boolean;
+    readonly visible: Column<any>[];
+    readonly columnField: (c: Column<any>, row: {
+        kind: string;
+        data: unknown;
+    }) => unknown;
+}
+export declare function getDataRect({ rows, columnStart, columnEnd, uniformGroupHeaders, visible, columnField, }: GetDataRectArgs): ExportDataRectResult<any>;

package/dist/state/helpers/get-data-rect.js

@@ -0,0 +1,65 @@
+import { COLUMN_MARKER_ID, computePathMatrix, GROUP_COLUMN_PREFIX, } from "@1771technologies/lytenyte-shared";
+export function getDataRect({ rows, columnStart, columnEnd, uniformGroupHeaders, visible, columnField, }) {
+    const data = [];
+    const columns = [];
+    for (let i = columnStart; i < columnEnd && i < visible.length; i++) {
+        const column = visible[i];
+        if (column.id === COLUMN_MARKER_ID)
+            continue;
+        columns.push(column);
+    }
+    const groupHeaders = [];
+    const hierarchy = computePathMatrix(visible);
+    for (let levelIndex = 0; levelIndex < hierarchy.length; levelIndex++) {
+        const level = hierarchy[levelIndex];
+        const seen = new Set();
+        const header = [];
+        for (let i = 0; i < columns.length; i++) {
+            const value = level[i];
+            if (!value) {
+                header.push(null);
+                continue;
+            }
+            if (seen.has(value.idOccurrence)) {
+                header.push("");
+                continue;
+            }
+            if (!uniformGroupHeaders)
+                seen.add(value.idOccurrence);
+            const group = value.groupPath.at(-1);
+            header.push(group);
+        }
+        groupHeaders.push(header);
+    }
+    let headers = [];
+    headers = [];
+    for (const v of columns) {
+        headers.push(v.name ?? v.id);
+    }
+    for (const row of Object.values(rows)) {
+        const dataForRow = [];
+        for (const column of columns) {
+            let field;
+            if (!row) {
+                field = null;
+            }
+            else if (column.id.startsWith(GROUP_COLUMN_PREFIX)) {
+                if (row.kind === "branch")
+                    field = row.key;
+                else
+                    field = "";
+            }
+            else {
+                field = columnField(column, { kind: row.kind, data: row.data });
+            }
+            dataForRow.push(field);
+        }
+        data.push(dataForRow);
+    }
+    return {
+        data,
+        groupHeaders,
+        columns,
+        headers,
+    };
+}

package/dist/state/helpers/get-full-width-callback.d.ts

@@ -0,0 +1,2 @@
+import type { Grid, RowDataSource, RowFullWidthPredicate } from "../../+types";
+export declare function getFullWidthCallback<T>(rds: RowDataSource<T>, predicate: RowFullWidthPredicate<T>, grid: Grid<T>): (r: number) => boolean;

package/dist/state/helpers/get-full-width-callback.js

@@ -0,0 +1,8 @@
+export function getFullWidthCallback(rds, predicate, grid) {
+    return (r) => {
+        const rowNode = rds.rowByIndex(r);
+        if (!rowNode)
+            return false;
+        return predicate({ grid, row: rowNode, rowIndex: r });
+    };
+}

package/dist/state/helpers/get-span-callback.d.ts

@@ -0,0 +1,2 @@
+import type { Column, Grid, RowDataSource } from "../../+types";
+export declare function getSpanFn<T>(rds: RowDataSource<T>, grid: Grid<T>, visibleColumns: Column<T>[], span: "row" | "col"): (r: number, c: number) => number;

package/dist/state/helpers/get-span-callback.js

@@ -0,0 +1,20 @@
+export function getSpanFn(rds, grid, visibleColumns, span) {
+    return (r, c) => {
+        const row = rds.rowByIndex(r);
+        const column = visibleColumns[c];
+        if (!row || !column)
+            return 1;
+        const spanFn = span === "col" ? column.colSpan : column.rowSpan;
+        if (!spanFn)
+            return 1;
+        if (typeof spanFn === "number") {
+            if (span === "col") {
+                return c % spanFn === 0 ? spanFn : 1;
+            }
+            else {
+                return r % spanFn === 0 ? spanFn : 1;
+            }
+        }
+        return spanFn({ grid, rowIndex: r, colIndex: c, row });
+    };
+}

package/dist/state/helpers/resolve-column.d.ts

@@ -0,0 +1,4 @@
+import type { Column, ColumnMeta } from "../../+types";
+export declare function resolveColumn(c: string | number | Column<any>, errorRef: {
+    current: boolean;
+}, meta: ColumnMeta<any>): string | undefined;

package/dist/state/helpers/resolve-column.js

@@ -0,0 +1,22 @@
+export function resolveColumn(c, errorRef, meta) {
+    if (typeof c === "string") {
+        if (!meta.columnLookup.has(c)) {
+            errorRef.current = true;
+            console.error(`Invalid column ${c}`);
+        }
+        return c;
+    }
+    if (typeof c === "number") {
+        const col = meta.columnsVisible.at(c);
+        if (!col) {
+            errorRef.current = true;
+            console.error(`Invalid column at index ${c}`);
+        }
+        return col?.id;
+    }
+    if (!meta.columnLookup.has(c.id)) {
+        errorRef.current = true;
+        console.error(`Invalid column ${c.id}`);
+    }
+    return c.id;
+}

package/dist/state/helpers/row-layout/get-focus-criteria.d.ts

@@ -0,0 +1,17 @@
+import type { SpanLayout } from "@1771technologies/lytenyte-shared";
+import type { PositionUnion } from "../../../+types";
+interface FocusLayoutCriteria {
+    readonly kind: "cell" | "full-width";
+    readonly isTop: boolean;
+    readonly isBot: boolean;
+    readonly isRowCenterBefore: boolean;
+    readonly isRowCenterAfter: boolean;
+    readonly isStart: boolean;
+    readonly isEnd: boolean;
+    readonly isColCenterBefore: boolean;
+    readonly isColCenterAfter: boolean;
+    readonly rowIndex: number;
+    readonly colIndex: number;
+}
+export declare function getFocusCriteria(n: SpanLayout, f: PositionUnion | null): FocusLayoutCriteria;
+export {};

package/dist/state/helpers/row-layout/get-focus-criteria.js

@@ -0,0 +1,62 @@
+const NOT_FOCUSED = {
+    kind: "cell",
+    isTop: false,
+    isBot: false,
+    isColCenterBefore: false,
+    isColCenterAfter: false,
+    isEnd: false,
+    isStart: false,
+    isRowCenterAfter: false,
+    isRowCenterBefore: false,
+    rowIndex: -1,
+    colIndex: -1,
+};
+export function getFocusCriteria(n, f) {
+    if (!f || (f.kind !== "full-width" && f.kind !== "cell")) {
+        return NOT_FOCUSED;
+    }
+    if (f.kind === "full-width") {
+        const isTop = f.rowIndex < n.rowTopEnd;
+        const isBot = f.rowIndex >= n.rowBotStart;
+        const isRowCenterBefore = f.rowIndex >= n.rowTopEnd && f.rowIndex < n.rowCenterStart;
+        const isRowCenterAfter = f.rowIndex >= n.rowCenterEnd && f.rowIndex < n.rowCenterLast;
+        return {
+            kind: "full-width",
+            isTop,
+            isBot,
+            isRowCenterBefore,
+            isRowCenterAfter,
+            isColCenterAfter: false,
+            isColCenterBefore: false,
+            isEnd: false,
+            isStart: false,
+            rowIndex: f.rowIndex,
+            colIndex: f.rowIndex,
+        };
+    }
+    const rowIndex = f.root?.rowIndex ?? f.rowIndex;
+    const colIndex = f.root?.colIndex ?? f.colIndex;
+    const isTop = rowIndex < n.rowTopEnd;
+    const isBot = rowIndex >= n.rowBotStart;
+    const isRowCenterBefore = n.rowTopEnd === 0
+        ? rowIndex < n.rowCenterStart
+        : rowIndex >= n.rowTopEnd && rowIndex < n.rowCenterStart;
+    const isRowCenterAfter = rowIndex >= n.rowCenterEnd && rowIndex < n.rowCenterLast;
+    const isStart = colIndex < n.colStartEnd;
+    const isEnd = colIndex >= n.colEndStart;
+    const isColCenterAfter = colIndex >= n.colCenterEnd && colIndex < n.colCenterLast;
+    const isColCenterBefore = colIndex >= n.colStartEnd && colIndex < n.colCenterStart;
+    return {
+        kind: "cell",
+        isTop,
+        isBot,
+        isRowCenterAfter,
+        isRowCenterBefore,
+        isStart,
+        isEnd,
+        isColCenterAfter,
+        isColCenterBefore,
+        rowIndex: f.rowIndex,
+        colIndex: f.colIndex,
+    };
+}

package/dist/state/helpers/row-layout/row-layout.d.ts

@@ -0,0 +1,18 @@
+import { type LayoutMap, type SpanLayout } from "@1771technologies/lytenyte-shared";
+import type { Column, PositionUnion, RowDataStore, RowLayout } from "../../../+types";
+interface MakeRowViewArgs<T> {
+    layout: SpanLayout;
+    layoutMap: LayoutMap;
+    rds: RowDataStore<T>;
+    columns: Column<T>[];
+    focus: PositionUnion | null;
+}
+/**
+ * This is quite a complex function so read each part carefully.
+ */
+export declare function makeRowLayout<T>({ layout: n, layoutMap, rds, columns, focus, }: MakeRowViewArgs<T>): {
+    top: RowLayout<T>[];
+    center: RowLayout<T>[];
+    bottom: RowLayout<T>[];
+};
+export {};