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

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

@@ -2,90 +2,77 @@ 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;
-        };
-        runWithBackoff(run, [4, 20]);
-        return;
+          }
+        },
+      });
+      return true;
     };
+    runWithBackoff(run, [4, 20]);
+    return;
+  };
 };

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

@@ -1,5 +1,7 @@
 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,43 +1,40 @@
 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,5 +1,7 @@
 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,27 +1,20 @@
 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,5 +1,7 @@
 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,88 +1,77 @@
 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,5 +1,14 @@
 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,19 +1,18 @@
 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,40 +1,38 @@
 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;
+  };
 };