@1771technologies/lytenyte-pro 1.0.0-beta.36 → 1.0.0-beta.37

package/dist/state/api/edit-begin.js

@@ -2,77 +2,90 @@ import { focusCell, isFullWidthMap } from "@1771technologies/lytenyte-shared";
 import { runWithBackoff } from "@1771technologies/lytenyte-js-utils";
 import { editOnChange } from "../helpers/edit-on-change.js";
 export const makeEditBegin = (grid) => {
-  return (params) => {
-    if (grid.state.editCellMode.get() === "readonly" || grid.state.columnPivotMode.get()) return;
-    // Start by canceling existing edits
-    grid.api.editEnd();
-    // We must be editing a valid cell location
-    const rowCount = grid.state.rowDataStore.rowCount.get();
-    if (params.rowIndex < 0 || params.rowIndex >= rowCount) return;
-    const i = grid.internal;
-    const meta = grid.state.columnMeta.get();
-    // The column must be presently rendered for it to be editable
-    let column;
-    if (typeof params.column === "string") column = meta.columnLookup.get(params.column);
-    else if (typeof params.column === "number") column = meta.columnsVisible.at(params.column);
-    else column = meta.columnsVisible.find((c) => c.id === params.column.id);
-    if (!column) return;
-    const rowNode = grid.state.rowDataSource.get().rowByIndex(params.rowIndex);
-    if (!rowNode) return;
-    // The column must have its editable state set to true
-    const base = grid.state.columnBase.get();
-    const editable = column.editable ?? base.editable;
-    if (!editable) return;
-    if (typeof editable === "function") {
-      if (!editable({ grid, column, row: rowNode, rowIndex: params.rowIndex })) return;
-    }
-    grid.api.scrollIntoView({ column, row: params.rowIndex });
-    // Let's try begin the cell edit.
-    const run = () => {
-      const layout = i.layout.get();
-      const row = layout.get(params.rowIndex);
-      if (!row) return false;
-      if (isFullWidthMap(row)) return true;
-      const columnIndex = meta.columnsVisible.indexOf(column);
-      const cell = layout.get(columnIndex);
-      if (!cell) return false;
-      focusCell({
-        layout,
-        focusActive: i.focusActive,
-        id: grid.state.gridId.get(),
-        colIndex: columnIndex,
-        rowIndex: params.rowIndex,
-        scrollIntoView: grid.api.scrollIntoView,
-        vp: grid.state.viewport.get(),
-        postFocus: () => {
-          let prevented = false;
-          grid.api.eventFire("editBegin", {
-            column,
-            rowIndex: params.rowIndex,
-            preventDefault: () => {
-              prevented = true;
-            },
-          });
-          if (prevented) return;
-          const activeData = structuredClone(rowNode.data);
-          i.editActivePos.set({ column, rowIndex: params.rowIndex });
-          i.editData.set(activeData);
-          if (params.init != null) {
-            editOnChange({
-              value: params.init,
-              activeData,
-              base,
-              column,
-              grid,
-              row: rowNode,
-              rowIndex: params.rowIndex,
+    return (params) => {
+        if (grid.state.editCellMode.get() === "readonly" || grid.state.columnPivotMode.get())
+            return;
+        // Start by canceling existing edits
+        grid.api.editEnd();
+        // We must be editing a valid cell location
+        const rowCount = grid.state.rowDataStore.rowCount.get();
+        if (params.rowIndex < 0 || params.rowIndex >= rowCount)
+            return;
+        const i = grid.internal;
+        const meta = grid.state.columnMeta.get();
+        // The column must be presently rendered for it to be editable
+        let column;
+        if (typeof params.column === "string")
+            column = meta.columnLookup.get(params.column);
+        else if (typeof params.column === "number")
+            column = meta.columnsVisible.at(params.column);
+        else
+            column = meta.columnsVisible.find((c) => c.id === params.column.id);
+        if (!column)
+            return;
+        const rowNode = grid.state.rowDataSource.get().rowByIndex(params.rowIndex);
+        if (!rowNode)
+            return;
+        // The column must have its editable state set to true
+        const base = grid.state.columnBase.get();
+        const editable = column.editable ?? base.editable;
+        if (!editable)
+            return;
+        if (typeof editable === "function") {
+            if (!editable({ grid, column, row: rowNode, rowIndex: params.rowIndex }))
+                return;
+        }
+        grid.api.scrollIntoView({ column, row: params.rowIndex });
+        // Let's try begin the cell edit.
+        const run = () => {
+            const layout = i.layout.get();
+            const row = layout.get(params.rowIndex);
+            if (!row)
+                return false;
+            if (isFullWidthMap(row))
+                return true;
+            const columnIndex = meta.columnsVisible.indexOf(column);
+            const cell = layout.get(columnIndex);
+            if (!cell)
+                return false;
+            focusCell({
+                layout,
+                focusActive: i.focusActive,
+                id: grid.state.gridId.get(),
+                colIndex: columnIndex,
+                rowIndex: params.rowIndex,
+                scrollIntoView: grid.api.scrollIntoView,
+                vp: grid.state.viewport.get(),
+                postFocus: () => {
+                    let prevented = false;
+                    grid.api.eventFire("editBegin", {
+                        column,
+                        rowIndex: params.rowIndex,
+                        preventDefault: () => {
+                            prevented = true;
+                        },
+                    });
+                    if (prevented)
+                        return;
+                    const activeData = structuredClone(rowNode.data);
+                    i.editActivePos.set({ column, rowIndex: params.rowIndex });
+                    i.editData.set(activeData);
+                    if (params.init != null) {
+                        editOnChange({
+                            value: params.init,
+                            activeData,
+                            base,
+                            column,
+                            grid,
+                            row: rowNode,
+                            rowIndex: params.rowIndex,
+                        });
+                    }
+                },
             });
-          }
-        },
-      });
-      return true;
+            return true;
+        };
+        runWithBackoff(run, [4, 20]);
+        return;
     };
-    runWithBackoff(run, [4, 20]);
-    return;
-  };
 };

package/dist/state/api/edit-end.d.ts

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

package/dist/state/api/edit-end.js

@@ -1,40 +1,43 @@
 export const makeEditEnd = (grid) => {
-  return (cancel) => {
-    const active = grid.internal.editActivePos.get();
-    if (!active) return;
-    const data = grid.internal.editData.get();
-    if (cancel) {
-      grid.internal.editActivePos.set(null);
-      grid.internal.editData.set(null);
-      grid.api.eventFire("editCancel", { column: active.column, rowIndex: active.rowIndex, data });
-      return;
-    }
-    const validation = grid.internal.editValidation.get();
-    if (!validation || Object.keys(validation).length >= 1) {
-      grid.api.eventFire("editError", {
-        column: active.column,
-        rowIndex: active.rowIndex,
-        data,
-        validation,
-      });
-      return;
-    }
-    try {
-      const ds = grid.state.rowDataSource.get();
-      ds.rowUpdate(new Map([[active.rowIndex, data]]));
-      grid.api.eventFire("editEnd", { column: active.column, rowIndex: active.rowIndex, data });
-    } catch (e) {
-      grid.api.eventFire("editError", {
-        column: active.column,
-        rowIndex: active.rowIndex,
-        data,
-        validation,
-        error: e,
-      });
-    } finally {
-      grid.internal.editActivePos.set(null);
-      grid.internal.editData.set(null);
-      grid.internal.editValidation.set(true);
-    }
-  };
+    return (cancel) => {
+        const active = grid.internal.editActivePos.get();
+        if (!active)
+            return;
+        const data = grid.internal.editData.get();
+        if (cancel) {
+            grid.internal.editActivePos.set(null);
+            grid.internal.editData.set(null);
+            grid.api.eventFire("editCancel", { column: active.column, rowIndex: active.rowIndex, data });
+            return;
+        }
+        const validation = grid.internal.editValidation.get();
+        if (!validation || Object.keys(validation).length >= 1) {
+            grid.api.eventFire("editError", {
+                column: active.column,
+                rowIndex: active.rowIndex,
+                data,
+                validation,
+            });
+            return;
+        }
+        try {
+            const ds = grid.state.rowDataSource.get();
+            ds.rowUpdate(new Map([[active.rowIndex, data]]));
+            grid.api.eventFire("editEnd", { column: active.column, rowIndex: active.rowIndex, data });
+        }
+        catch (e) {
+            grid.api.eventFire("editError", {
+                column: active.column,
+                rowIndex: active.rowIndex,
+                data,
+                validation,
+                error: e,
+            });
+        }
+        finally {
+            grid.internal.editActivePos.set(null);
+            grid.internal.editData.set(null);
+            grid.internal.editValidation.set(true);
+        }
+    };
 };

package/dist/state/api/edit-is-cell-active.d.ts

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

package/dist/state/api/edit-is-cell-active.js

@@ -1,20 +1,27 @@
 import { isFullWidthMap } from "@1771technologies/lytenyte-shared";
 export const makeEditIsCellActive = (grid) => {
-  return (params) => {
-    const active = grid.internal.editActivePos.get();
-    if (!active) return false;
-    const meta = grid.state.columnMeta.get();
-    let column;
-    if (typeof params.column === "string") column = meta.columnLookup.get(params.column);
-    else if (typeof params.column === "number") column = meta.columnsVisible.at(params.column);
-    else column = meta.columnsVisible.find((c) => c.id === params.column.id);
-    if (!column) return false;
-    const layout = grid.internal.layout.get();
-    const row = layout.get(params.rowIndex);
-    if (!row || isFullWidthMap(row)) return false;
-    const colIndex = meta.columnsVisible.indexOf(column);
-    const cell = row.get(colIndex);
-    if (!cell) return false;
-    return active.column.id === column.id && active.rowIndex === params.rowIndex;
-  };
+    return (params) => {
+        const active = grid.internal.editActivePos.get();
+        if (!active)
+            return false;
+        const meta = grid.state.columnMeta.get();
+        let column;
+        if (typeof params.column === "string")
+            column = meta.columnLookup.get(params.column);
+        else if (typeof params.column === "number")
+            column = meta.columnsVisible.at(params.column);
+        else
+            column = meta.columnsVisible.find((c) => c.id === params.column.id);
+        if (!column)
+            return false;
+        const layout = grid.internal.layout.get();
+        const row = layout.get(params.rowIndex);
+        if (!row || isFullWidthMap(row))
+            return false;
+        const colIndex = meta.columnsVisible.indexOf(column);
+        const cell = row.get(colIndex);
+        if (!cell)
+            return false;
+        return active.column.id === column.id && active.rowIndex === params.rowIndex;
+    };
 };

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

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

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

@@ -1,77 +1,88 @@
 import { editOnChange } from "../helpers/edit-on-change.js";
 export const makeEditUpdate = (grid) => {
-  return (params) => {
-    if (grid.state.editCellMode.get() === "readonly" || grid.state.columnPivotMode.get()) return;
-    // We must be editing a valid cell location
-    const rowCount = grid.state.rowDataStore.rowCount.get();
-    if (params.rowIndex < 0 || params.rowIndex >= rowCount) return;
-    const i = grid.internal;
-    const meta = grid.state.columnMeta.get();
-    // The column must be presently rendered for it to be editable
-    let column;
-    if (typeof params.column === "string") column = meta.columnLookup.get(params.column);
-    else if (typeof params.column === "number") column = meta.columnsVisible.at(params.column);
-    else column = meta.columnsVisible.find((c) => c.id === params.column.id);
-    if (!column) return;
-    const rowNode = grid.state.rowDataSource.get().rowByIndex(params.rowIndex);
-    if (!rowNode) return;
-    // The column must have its editable state set to true
-    const base = grid.state.columnBase.get();
-    const editable = column.editable ?? base.editable;
-    if (!editable) return;
-    if (typeof editable === "function") {
-      if (!editable({ grid, column, row: rowNode, rowIndex: params.rowIndex })) return;
-    }
-    const activeData = structuredClone(rowNode.data);
-    const currentValidation = i.editValidation.get();
-    const currentData = i.editData.get();
-    editOnChange({
-      value: params.value,
-      activeData,
-      base,
-      column,
-      grid,
-      row: rowNode,
-      rowIndex: params.rowIndex,
-    });
-    const updatedData = i.editData.get();
-    const updatedValidation = i.editValidation.get();
-    i.editValidation.set(currentValidation);
-    i.editData.set(currentData);
-    let prevent = false;
-    grid.api.eventFire("editBegin", {
-      column,
-      rowIndex: params.rowIndex,
-      preventDefault: () => {
-        prevent = true;
-      },
-    });
-    if (prevent) return;
-    if (!updatedValidation || Object.keys(updatedValidation).length > 1) {
-      grid.api.eventFire("editError", {
-        column: column,
-        rowIndex: params.rowIndex,
-        data: updatedData,
-        validation: updatedValidation,
-      });
-      return;
-    }
-    try {
-      const ds = grid.state.rowDataSource.get();
-      ds.rowUpdate(new Map([[params.rowIndex, updatedData]]));
-      grid.api.eventFire("editEnd", {
-        column: column,
-        rowIndex: params.rowIndex,
-        data: updatedData,
-      });
-    } catch (e) {
-      grid.api.eventFire("editError", {
-        column: column,
-        rowIndex: params.rowIndex,
-        data: updatedData,
-        validation: updatedValidation,
-        error: e,
-      });
-    }
-  };
+    return (params) => {
+        if (grid.state.editCellMode.get() === "readonly" || grid.state.columnPivotMode.get())
+            return;
+        // We must be editing a valid cell location
+        const rowCount = grid.state.rowDataStore.rowCount.get();
+        if (params.rowIndex < 0 || params.rowIndex >= rowCount)
+            return;
+        const i = grid.internal;
+        const meta = grid.state.columnMeta.get();
+        // The column must be presently rendered for it to be editable
+        let column;
+        if (typeof params.column === "string")
+            column = meta.columnLookup.get(params.column);
+        else if (typeof params.column === "number")
+            column = meta.columnsVisible.at(params.column);
+        else
+            column = meta.columnsVisible.find((c) => c.id === params.column.id);
+        if (!column)
+            return;
+        const rowNode = grid.state.rowDataSource.get().rowByIndex(params.rowIndex);
+        if (!rowNode)
+            return;
+        // The column must have its editable state set to true
+        const base = grid.state.columnBase.get();
+        const editable = column.editable ?? base.editable;
+        if (!editable)
+            return;
+        if (typeof editable === "function") {
+            if (!editable({ grid, column, row: rowNode, rowIndex: params.rowIndex }))
+                return;
+        }
+        const activeData = structuredClone(rowNode.data);
+        const currentValidation = i.editValidation.get();
+        const currentData = i.editData.get();
+        editOnChange({
+            value: params.value,
+            activeData,
+            base,
+            column,
+            grid,
+            row: rowNode,
+            rowIndex: params.rowIndex,
+        });
+        const updatedData = i.editData.get();
+        const updatedValidation = i.editValidation.get();
+        i.editValidation.set(currentValidation);
+        i.editData.set(currentData);
+        let prevent = false;
+        grid.api.eventFire("editBegin", {
+            column,
+            rowIndex: params.rowIndex,
+            preventDefault: () => {
+                prevent = true;
+            },
+        });
+        if (prevent)
+            return;
+        if (!updatedValidation || Object.keys(updatedValidation).length > 1) {
+            grid.api.eventFire("editError", {
+                column: column,
+                rowIndex: params.rowIndex,
+                data: updatedData,
+                validation: updatedValidation,
+            });
+            return;
+        }
+        try {
+            const ds = grid.state.rowDataSource.get();
+            ds.rowUpdate(new Map([[params.rowIndex, updatedData]]));
+            grid.api.eventFire("editEnd", {
+                column: column,
+                rowIndex: params.rowIndex,
+                data: updatedData,
+            });
+        }
+        catch (e) {
+            grid.api.eventFire("editError", {
+                column: column,
+                rowIndex: params.rowIndex,
+                data: updatedData,
+                validation: updatedValidation,
+                error: e,
+            });
+        }
+    };
 };

package/dist/state/api/event-listeners.d.ts

@@ -1,14 +1,5 @@
 export declare const makeEventListeners: <T>() => {
-  eventAddListener: <K extends keyof import("../../+types").GridEvents<T_1>>(
-    name: K,
-    cb: (event: Parameters<Required<import("../../+types").GridEvents<T>>[K]>[0]) => void,
-  ) => () => boolean;
-  eventFire: <K extends keyof import("../../+types").GridEvents<T_1>>(
-    name: K,
-    event: Parameters<Required<import("../../+types").GridEvents<T>>[K]>[0],
-  ) => void;
-  eventRemoveListener: <K extends keyof import("../../+types").GridEvents<T_1>>(
-    name: K,
-    cb: (event: Parameters<Required<import("../../+types").GridEvents<T>>[K]>[0]) => void,
-  ) => void;
+    eventAddListener: <K extends keyof import("../../+types").GridEvents<T_1>>(name: K, cb: (event: Parameters<Required<import("../../+types").GridEvents<T>>[K]>[0]) => void) => () => boolean;
+    eventFire: <K extends keyof import("../../+types").GridEvents<T_1>>(name: K, event: Parameters<Required<import("../../+types").GridEvents<T>>[K]>[0]) => void;
+    eventRemoveListener: <K extends keyof import("../../+types").GridEvents<T_1>>(name: K, cb: (event: Parameters<Required<import("../../+types").GridEvents<T>>[K]>[0]) => void) => void;
 };

package/dist/state/api/event-listeners.js

@@ -1,18 +1,19 @@
 export const makeEventListeners = () => {
-  const events = {};
-  return {
-    eventAddListener: (name, cb) => {
-      events[name] ??= new Set();
-      events[name].add(cb);
-      return () => events[name].delete(cb);
-    },
-    eventFire: (name, ...args) => {
-      const listeners = events[name];
-      if (!listeners) return;
-      listeners.forEach((c) => c(...args));
-    },
-    eventRemoveListener: (name, cb) => {
-      events[name]?.delete(cb);
-    },
-  };
+    const events = {};
+    return {
+        eventAddListener: (name, cb) => {
+            events[name] ??= new Set();
+            events[name].add(cb);
+            return () => events[name].delete(cb);
+        },
+        eventFire: (name, ...args) => {
+            const listeners = events[name];
+            if (!listeners)
+                return;
+            listeners.forEach((c) => c(...args));
+        },
+        eventRemoveListener: (name, cb) => {
+            events[name]?.delete(cb);
+        },
+    };
 };

package/dist/state/api/export-csv.js

@@ -1,38 +1,40 @@
 import { getDataRect } from "../helpers/get-data-rect.js";
 export const makeExportCsv = (grid) => {
-  return async (p) => {
-    const visible = grid.state.columnMeta.get().columnsVisible;
-    const rowCount = grid.state.rowDataStore.rowCount.get();
-    const rowStart = p?.dataRect?.rowStart ?? 0;
-    const rowEnd = p?.dataRect?.rowEnd ?? rowCount;
-    const columnStart = p?.dataRect?.columnStart ?? 0;
-    const columnEnd = p?.dataRect?.columnEnd ?? visible.length;
-    const rows = [];
-    for (let i = rowStart; i < rowEnd; i++) {
-      rows.push(grid.api.rowByIndex(i) ?? null);
-    }
-    const { data, groupHeaders, headers } = getDataRect({
-      rows,
-      columnField: grid.api.columnField,
-      visible,
-      columnStart,
-      columnEnd,
-      uniformGroupHeaders: p?.uniformGroupHeaders,
-    });
-    const final = [...data];
-    if (p?.includeHeader) final.unshift(headers);
-    if (p?.includeGroupHeaders) final.unshift(...groupHeaders);
-    return final
-      .map((c) => {
-        return c.map((x) => `"${x}"`).join(p?.delimiter ?? ",");
-      })
-      .join("\n");
-  };
+    return async (p) => {
+        const visible = grid.state.columnMeta.get().columnsVisible;
+        const rowCount = grid.state.rowDataStore.rowCount.get();
+        const rowStart = p?.dataRect?.rowStart ?? 0;
+        const rowEnd = p?.dataRect?.rowEnd ?? rowCount;
+        const columnStart = p?.dataRect?.columnStart ?? 0;
+        const columnEnd = p?.dataRect?.columnEnd ?? visible.length;
+        const rows = [];
+        for (let i = rowStart; i < rowEnd; i++) {
+            rows.push(grid.api.rowByIndex(i) ?? null);
+        }
+        const { data, groupHeaders, headers } = getDataRect({
+            rows,
+            columnField: grid.api.columnField,
+            visible,
+            columnStart,
+            columnEnd,
+            uniformGroupHeaders: p?.uniformGroupHeaders,
+        });
+        const final = [...data];
+        if (p?.includeHeader)
+            final.unshift(headers);
+        if (p?.includeGroupHeaders)
+            final.unshift(...groupHeaders);
+        return final
+            .map((c) => {
+            return c.map((x) => `"${x}"`).join(p?.delimiter ?? ",");
+        })
+            .join("\n");
+    };
 };
 export const makeExportCsvFile = (grid) => {
-  return async (p) => {
-    const csv = await grid.api.exportCsv(p);
-    const blob = new Blob([csv], { type: "text/csv" });
-    return blob;
-  };
+    return async (p) => {
+        const csv = await grid.api.exportCsv(p);
+        const blob = new Blob([csv], { type: "text/csv" });
+        return blob;
+    };
 };