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

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

@@ -0,0 +1,18 @@
+export const emptyRowDataSource = {
+    init: () => { },
+    rowById: () => null,
+    rowByIndex: () => null,
+    rowExpand: () => { },
+    rowUpdate: () => { },
+    rowToIndex: () => null,
+    rowAllChildIds: () => [],
+    rowSelect: () => { },
+    rowSelectAll: () => { },
+    rowAdd: () => { },
+    rowDelete: () => { },
+    rowSetBotData: () => { },
+    rowSetCenterData: () => { },
+    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> | null, grid: Grid<T>): ((r: number) => boolean) | null;

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

@@ -0,0 +1,10 @@
+export function getFullWidthCallback(rds, predicate, grid) {
+    if (!predicate)
+        return null;
+    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) | null;

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

@@ -0,0 +1,22 @@
+export function getSpanFn(rds, grid, visibleColumns, span) {
+    if (visibleColumns.every((c) => !(span === "col" ? c.colSpan : c.rowSpan)))
+        return null;
+    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 | Column<any> | undefined;

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

@@ -0,0 +1,29 @@
+import { GROUP_COLUMN_PREFIX } from "@1771technologies/lytenyte-shared";
+export function resolveColumn(c, errorRef, meta) {
+    if (typeof c === "string") {
+        if (c.startsWith(GROUP_COLUMN_PREFIX)) {
+            return meta.columnsVisible.find((x) => x.id === c);
+        }
+        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 (c.id.startsWith(GROUP_COLUMN_PREFIX)) {
+        return meta.columnsVisible.find((x) => x.id === c.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,19 @@
+import { type LayoutState, type SpanLayout } from "@1771technologies/lytenyte-shared";
+import type { Column, PositionUnion, RowDataStore, RowLayout } from "../../../+types";
+interface MakeRowViewArgs<T> {
+    view: SpanLayout;
+    layout: LayoutState;
+    viewCache: Map<number, RowLayout<T>>;
+    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>({ view: n, viewCache, layout, rds, columns }: MakeRowViewArgs<T>): {
+    top: RowLayout<T>[];
+    center: RowLayout<T>[];
+    bottom: RowLayout<T>[];
+};
+export {};

package/dist/state/helpers/row-layout/row-layout.js

@@ -0,0 +1,181 @@
+import { CONTAINS_DEAD_CELLS, FULL_WIDTH, } from "@1771technologies/lytenyte-shared";
+/**
+ * This is quite a complex function so read each part carefully.
+ */
+export function makeRowLayout({ view: n, viewCache, layout, rds, columns }) {
+    // Initializes the layout sections for the view.
+    const top = [];
+    const center = [];
+    const bottom = [];
+    handleViewLayout({
+        columns,
+        container: top,
+        layout,
+        rowStart: n.rowTopStart,
+        rowEnd: n.rowTopEnd,
+        rowForIndex: rds.rowForIndex,
+        rowPin: "top",
+        spanLayout: n,
+        viewCache,
+    });
+    handleViewLayout({
+        columns,
+        container: center,
+        layout,
+        rowStart: n.rowCenterStart,
+        rowEnd: n.rowCenterEnd,
+        rowForIndex: rds.rowForIndex,
+        rowPin: null,
+        spanLayout: n,
+        viewCache,
+    });
+    handleViewLayout({
+        columns,
+        container: bottom,
+        layout,
+        rowStart: n.rowBotStart,
+        rowEnd: n.rowBotEnd,
+        rowForIndex: rds.rowForIndex,
+        rowPin: "bottom",
+        spanLayout: n,
+        viewCache,
+    });
+    /**
+     * BOTTOM ROW LAYOUT END
+     */
+    return {
+        top: top.map((t) => partition(n, t)),
+        center: center.map((t) => partition(n, t)),
+        bottom: bottom.map((t) => partition(n, t)),
+    };
+}
+const partition = (n, row) => {
+    if (row.kind === "full-width")
+        return row;
+    let found = false;
+    const cells = [
+        ...row.cells.slice(0, n.colStartEnd),
+        ...row.cells.slice(n.colCenterStart, n.colCenterEnd).map((c) => {
+            if (!found && c.isDeadCol && !c.isDeadRow)
+                return { ...c, isDeadCol: false, isDeadRow: true };
+            found = true;
+            return c;
+        }),
+        ...row.cells.slice(n.colEndStart, n.colEndEnd),
+    ];
+    return {
+        ...row,
+        cells,
+    };
+};
+function handleViewLayout({ columns, spanLayout: n, rowStart, rowEnd, rowPin, layout, viewCache, container, rowForIndex, }) {
+    for (let r = rowStart; r < rowEnd; r++) {
+        const status = layout.special[r];
+        const computed = layout.computed[r];
+        if (!computed)
+            continue;
+        if (viewCache.has(r)) {
+            container.push(viewCache.get(r));
+            continue;
+        }
+        const node = rowForIndex(r);
+        if (!node)
+            break;
+        const rowLastPinTop = n.rowTopEnd - 1 === r ? true : undefined;
+        if (status === FULL_WIDTH) {
+            const row = {
+                get id() {
+                    return node.get()?.id ?? `${r}`;
+                },
+                rowIndex: r,
+                kind: "full-width",
+                rowPin,
+                row: node,
+                rowLastPinTop,
+            };
+            viewCache.set(r, row);
+            container.push(row);
+            continue;
+        }
+        const cellSpec = layout.lookup.get(r);
+        const cellLayout = [];
+        const hasDead = status === CONTAINS_DEAD_CELLS;
+        for (let c = n.colStartStart; c < n.colStartEnd; c++) {
+            const ci = c * 4;
+            const isDeadRow = hasDead && cellSpec?.[ci] === -1;
+            const isDeadCol = hasDead && cellSpec?.[ci] === 0;
+            const colSpan = cellSpec?.[c * 4 + 1] || 1;
+            cellLayout.push({
+                id: columns[c].id,
+                kind: "cell",
+                colIndex: c,
+                rowIndex: r,
+                rowSpan: cellSpec?.[c * 4] || 1,
+                colSpan,
+                rowPin,
+                colPin: "start",
+                isDeadCol,
+                isDeadRow,
+                colLastStartPin: c + colSpan === n.colStartEnd ? true : undefined,
+                rowLastPinTop,
+                row: node,
+                column: columns[c],
+            });
+        }
+        for (let c = n.colStartEnd; c < n.colCenterLast; c++) {
+            const ci = c * 4;
+            const isDeadRow = hasDead && cellSpec?.[ci] === -1;
+            const isDeadCol = hasDead && cellSpec?.[ci] === 0;
+            const colSpan = cellSpec?.[c * 4 + 1] || 1;
+            cellLayout.push({
+                id: columns[c].id,
+                kind: "cell",
+                colIndex: c,
+                rowIndex: r,
+                rowSpan: cellSpec?.[c * 4] || 1,
+                colSpan,
+                rowPin,
+                colPin: null,
+                isDeadCol,
+                isDeadRow,
+                rowLastPinTop,
+                row: node,
+                column: columns[c],
+            });
+        }
+        for (let c = n.colEndStart; c < n.colEndEnd; c++) {
+            const ci = c * 4;
+            const isDeadRow = hasDead && cellSpec?.[ci] === -1;
+            const isDeadCol = hasDead && cellSpec?.[ci] === 0;
+            cellLayout.push({
+                id: columns[c].id,
+                kind: "cell",
+                colIndex: c,
+                rowIndex: r,
+                rowSpan: cellSpec?.[c * 4] || 1,
+                colSpan: cellSpec?.[c * 4 + 1] || 1,
+                rowPin,
+                colPin: "end",
+                isDeadCol,
+                isDeadRow,
+                colFirstEndPin: c === n.colCenterLast ? true : undefined,
+                rowLastPinTop,
+                row: node,
+                column: columns[c],
+            });
+        }
+        const row = {
+            get id() {
+                return node.get()?.id ?? `${r}`;
+            },
+            rowIndex: r,
+            kind: "row",
+            cells: cellLayout,
+            rowPin,
+            row: node,
+            rowLastPinTop,
+        };
+        viewCache.set(r, row);
+        container.push(row);
+    }
+}

package/dist/state/use-lytenyte.d.ts

@@ -0,0 +1,3 @@
+import { type Grid, type UseLyteNyteProps } from "../+types.js";
+export declare function makeLyteNyte<T>(p: UseLyteNyteProps<T>): Grid<T>;
+export declare function useLyteNyte<T>(p: UseLyteNyteProps<T>): Grid<T>;