@freighttech/ui 0.13.18

package/dist/backend/dynamic-table/store/index.js

@@ -0,0 +1,611 @@
+function createCellStore(initialData, columns) {
+  const rowDataMap = /* @__PURE__ */ new Map();
+  const revisions = /* @__PURE__ */ new Map();
+  const subscribers = /* @__PURE__ */ new Map();
+  const saveStates = /* @__PURE__ */ new Map();
+  const newRowFlags = /* @__PURE__ */ new Set();
+  const columnWidths = /* @__PURE__ */ new Map();
+  const columnStretch = /* @__PURE__ */ new Map();
+  const storeSubscribers = /* @__PURE__ */ new Set();
+  let currentColumns = columns;
+  let selection = { type: null, anchor: null, focus: null };
+  let fillPreview = null;
+  let clipboardMarker = null;
+  let editingCell = null;
+  let hoveredCell = null;
+  const UNDO_LIMIT = 100;
+  const undoStack = [];
+  const redoStack = [];
+  let undoGroup = null;
+  let suppressUndo = false;
+  let rowCount = initialData.length;
+  let storeRevision = 0;
+  let selectionRevision = 0;
+  const selectionSubscribers = /* @__PURE__ */ new Set();
+  const editingSubscribers = /* @__PURE__ */ new Set();
+  let tableRef = null;
+  let boundsCache = null;
+  const getCellId = (row, col) => `${row}:${col}`;
+  const calcBounds = () => {
+    if (!selection.anchor || !selection.focus) return null;
+    if (selection.type === "rowRange") {
+      return {
+        startRow: Math.min(selection.anchor.row, selection.focus.row),
+        endRow: Math.max(selection.anchor.row, selection.focus.row),
+        startCol: 0,
+        endCol: currentColumns.length - 1
+      };
+    }
+    if (selection.type === "colRange") {
+      return {
+        startRow: 0,
+        endRow: rowCount - 1,
+        startCol: Math.min(selection.anchor.col, selection.focus.col),
+        endCol: Math.max(selection.anchor.col, selection.focus.col)
+      };
+    }
+    return {
+      startRow: Math.min(selection.anchor.row, selection.focus.row),
+      endRow: Math.max(selection.anchor.row, selection.focus.row),
+      startCol: Math.min(selection.anchor.col, selection.focus.col),
+      endCol: Math.max(selection.anchor.col, selection.focus.col)
+    };
+  };
+  const notify = (row, col) => {
+    const id = getCellId(row, col);
+    const subs = subscribers.get(id);
+    if (subs) {
+      subs.forEach((cb) => cb());
+    }
+  };
+  const bumpRevision = (row, col) => {
+    const id = getCellId(row, col);
+    revisions.set(id, (revisions.get(id) ?? 0) + 1);
+    notify(row, col);
+  };
+  const bumpRevisions = (cells) => {
+    cells.forEach(({ row, col }) => {
+      const id = getCellId(row, col);
+      revisions.set(id, (revisions.get(id) ?? 0) + 1);
+    });
+    cells.forEach(({ row, col }) => notify(row, col));
+  };
+  const bumpRowRevisions = (row, colCount) => {
+    const cells = [];
+    for (let col = 0; col < colCount; col++) {
+      cells.push({ row, col });
+    }
+    bumpRevisions(cells);
+  };
+  const notifyStoreSubscribers = () => {
+    storeSubscribers.forEach((cb) => cb());
+  };
+  const notifySelectionSubscribers = () => {
+    selectionSubscribers.forEach((cb) => cb());
+  };
+  const notifyEditingSubscribers = () => {
+    editingSubscribers.forEach((cb) => cb());
+  };
+  const bumpStoreRevision = () => {
+    storeRevision++;
+    notifyStoreSubscribers();
+  };
+  const bumpSelectionRevision = () => {
+    selectionRevision++;
+    notifySelectionSubscribers();
+  };
+  const isCellInBounds = (row, col, bounds) => {
+    return row >= bounds.startRow && row <= bounds.endRow && col >= bounds.startCol && col <= bounds.endCol;
+  };
+  const getRangeEdges = (row, col, bounds) => ({
+    top: row === bounds.startRow,
+    bottom: row === bounds.endRow,
+    left: col === bounds.startCol,
+    right: col === bounds.endCol
+  });
+  const someColumnFillable = (bounds) => {
+    for (let c = bounds.startCol; c <= bounds.endCol; c++) {
+      const col = currentColumns[c];
+      if (col && !col.readOnly && !col.disableFill) return true;
+    }
+    return false;
+  };
+  const repaintUnion = (a, b) => {
+    const affected = [];
+    const add = (bounds) => {
+      if (!bounds) return;
+      for (let r = bounds.startRow; r <= bounds.endRow; r++) {
+        for (let c = bounds.startCol; c <= bounds.endCol; c++) affected.push({ row: r, col: c });
+      }
+    };
+    add(a);
+    add(b);
+    const seen = /* @__PURE__ */ new Set();
+    const unique = affected.filter(({ row, col }) => {
+      const id = getCellId(row, col);
+      if (seen.has(id)) return false;
+      seen.add(id);
+      return true;
+    });
+    bumpRevisions(unique);
+  };
+  const initializeData = (data) => {
+    rowDataMap.clear();
+    rowCount = data.length;
+    data.forEach((row, rowIndex) => {
+      rowDataMap.set(rowIndex, row);
+    });
+  };
+  initializeData(initialData);
+  currentColumns.forEach((col, idx) => {
+    if (col.width) {
+      columnWidths.set(idx, col.width);
+    }
+  });
+  const store = {
+    // --- Reads ---
+    getCellValue(row, col) {
+      const colDef = currentColumns[col];
+      if (!colDef) return void 0;
+      return rowDataMap.get(row)?.[colDef.data];
+    },
+    getRowData(row) {
+      return rowDataMap.get(row);
+    },
+    getRowCount() {
+      return rowCount;
+    },
+    getSelection() {
+      return selection;
+    },
+    getSelectionBounds() {
+      if (!boundsCache) {
+        boundsCache = calcBounds();
+      }
+      return boundsCache;
+    },
+    getFillPreview() {
+      return fillPreview;
+    },
+    getClipboardMarker() {
+      return clipboardMarker;
+    },
+    getEditingCell() {
+      return editingCell;
+    },
+    getSaveState(row, col) {
+      return saveStates.get(getCellId(row, col)) ?? null;
+    },
+    isNewRow(row) {
+      return newRowFlags.has(row);
+    },
+    hasNewRows() {
+      return newRowFlags.size > 0;
+    },
+    getColumnWidth(col) {
+      return (columnWidths.get(col) ?? currentColumns[col]?.width ?? 100) + (columnStretch.get(col) ?? 0);
+    },
+    getBaseColumnWidth(col) {
+      return columnWidths.get(col) ?? currentColumns[col]?.width ?? 100;
+    },
+    getColumnWidths() {
+      return new Map(columnWidths);
+    },
+    setColumnStretch(next) {
+      const normalized = /* @__PURE__ */ new Map();
+      next.forEach((extra, col) => {
+        if (extra > 0) normalized.set(col, extra);
+      });
+      let changed = normalized.size !== columnStretch.size;
+      if (!changed) {
+        for (const [col, extra] of normalized) {
+          if (columnStretch.get(col) !== extra) {
+            changed = true;
+            break;
+          }
+        }
+      }
+      if (!changed) return;
+      columnStretch.clear();
+      normalized.forEach((extra, col) => columnStretch.set(col, extra));
+      bumpStoreRevision();
+    },
+    getStoreRevision() {
+      return storeRevision;
+    },
+    getSelectionRevision() {
+      return selectionRevision;
+    },
+    getCellState(row, col) {
+      const bounds = this.getSelectionBounds();
+      const isInRange = bounds ? isCellInBounds(row, col, bounds) : false;
+      const isSelected = selection.type === "cell" && selection.anchor?.row === row && selection.anchor?.col === col;
+      const isFillPreview = !!fillPreview && isCellInBounds(row, col, fillPreview.bounds);
+      const isFillTarget = isFillPreview && !!fillPreview && !isCellInBounds(row, col, fillPreview.source);
+      const isFillClearing = !!fillPreview && !!fillPreview.cleared && isCellInBounds(row, col, fillPreview.cleared);
+      const isFillOrigin = !!bounds && row === bounds.endRow && col === bounds.endCol && !editingCell && someColumnFillable(bounds);
+      const cellId = getCellId(row, col);
+      const isClipboardSource = !!clipboardMarker && isCellInBounds(row, col, clipboardMarker.bounds);
+      return {
+        value: this.getCellValue(row, col),
+        isSelected,
+        isInRange,
+        rangeEdges: isInRange && bounds ? getRangeEdges(row, col, bounds) : {},
+        isEditing: editingCell?.row === row && editingCell?.col === col,
+        saveState: this.getSaveState(row, col),
+        isNewRow: this.isNewRow(row),
+        isFillPreview,
+        isFillTarget,
+        isFillClearing,
+        isFillOrigin,
+        fillEdges: isFillPreview && fillPreview ? getRangeEdges(row, col, fillPreview.bounds) : {},
+        isClipboardSource,
+        clipboardEdges: isClipboardSource && clipboardMarker ? getRangeEdges(row, col, clipboardMarker.bounds) : {},
+        clipboardMode: isClipboardSource && clipboardMarker ? clipboardMarker.mode : null,
+        isHovered: hoveredCell?.row === row && hoveredCell?.col === col
+      };
+    },
+    getCellsInSelection() {
+      const bounds = this.getSelectionBounds();
+      if (!bounds) return [];
+      return this.getCellsInRect(bounds);
+    },
+    getCellsInRect(bounds) {
+      const cells = [];
+      for (let r = bounds.startRow; r <= bounds.endRow; r++) {
+        for (let c = bounds.startCol; c <= bounds.endCol; c++) {
+          cells.push({ row: r, col: c, value: this.getCellValue(r, c) });
+        }
+      }
+      return cells;
+    },
+    // --- Writes ---
+    setCellValue(row, col, value) {
+      const rowData = rowDataMap.get(row);
+      if (rowData && currentColumns[col]) {
+        rowData[currentColumns[col].data] = value;
+      }
+      bumpRevision(row, col);
+    },
+    setRowData(row, data) {
+      rowDataMap.set(row, data);
+      bumpRowRevisions(row, currentColumns.length);
+    },
+    setSelection(newSelection) {
+      const oldBounds = this.getSelectionBounds();
+      selection = newSelection;
+      boundsCache = null;
+      const newBounds = this.getSelectionBounds();
+      const affected = [];
+      const addBoundsCells = (bounds) => {
+        if (!bounds) return;
+        for (let r = bounds.startRow; r <= bounds.endRow; r++) {
+          for (let c = bounds.startCol; c <= bounds.endCol; c++) {
+            affected.push({ row: r, col: c });
+          }
+        }
+      };
+      addBoundsCells(oldBounds);
+      addBoundsCells(newBounds);
+      const seen = /* @__PURE__ */ new Set();
+      const unique = affected.filter(({ row, col }) => {
+        const id = getCellId(row, col);
+        if (seen.has(id)) return false;
+        seen.add(id);
+        return true;
+      });
+      bumpRevisions(unique);
+      bumpSelectionRevision();
+    },
+    setFillPreview(preview) {
+      const prev = fillPreview;
+      fillPreview = preview;
+      repaintUnion(prev ? prev.bounds : null, preview ? preview.bounds : null);
+    },
+    setClipboardMarker(marker) {
+      const prev = clipboardMarker;
+      if (!prev && !marker) return;
+      clipboardMarker = marker;
+      repaintUnion(prev?.bounds ?? null, marker?.bounds ?? null);
+    },
+    // --- Undo / redo ---
+    recordCellChange(change) {
+      if (suppressUndo) return;
+      if (undoGroup) {
+        undoGroup.push(change);
+      } else {
+        undoStack.push({ changes: [change] });
+        if (undoStack.length > UNDO_LIMIT) undoStack.shift();
+        redoStack.length = 0;
+      }
+    },
+    beginUndoGroup() {
+      undoGroup = [];
+    },
+    endUndoGroup() {
+      const group = undoGroup;
+      undoGroup = null;
+      if (group && group.length > 0) {
+        undoStack.push({ changes: group });
+        if (undoStack.length > UNDO_LIMIT) undoStack.shift();
+        redoStack.length = 0;
+      }
+    },
+    popUndo() {
+      return undoStack.pop() ?? null;
+    },
+    popRedo() {
+      return redoStack.pop() ?? null;
+    },
+    pushUndo(entry) {
+      undoStack.push(entry);
+      if (undoStack.length > UNDO_LIMIT) undoStack.shift();
+    },
+    pushRedo(entry) {
+      redoStack.push(entry);
+    },
+    canUndo() {
+      return undoStack.length > 0;
+    },
+    canRedo() {
+      return redoStack.length > 0;
+    },
+    setUndoSuppressed(suppressed) {
+      suppressUndo = suppressed;
+    },
+    findRowIndexById(idColumnName, id) {
+      if (id == null) return -1;
+      for (const [index, rowData] of rowDataMap) {
+        if (rowData?.[idColumnName] === id) return index;
+      }
+      return -1;
+    },
+    setEditingCell(row, col) {
+      const prev = editingCell;
+      editingCell = { row, col };
+      if (prev) {
+        bumpRevision(prev.row, prev.col);
+      }
+      bumpRevision(row, col);
+      if (!prev || prev.row !== row || prev.col !== col) notifyEditingSubscribers();
+    },
+    setHoveredCell(cell) {
+      const prev = hoveredCell;
+      if (prev && cell && prev.row === cell.row && prev.col === cell.col) return;
+      if (!prev && !cell) return;
+      hoveredCell = cell;
+      if (prev) bumpRevision(prev.row, prev.col);
+      if (cell) bumpRevision(cell.row, cell.col);
+    },
+    clearEditing() {
+      if (editingCell) {
+        const { row, col } = editingCell;
+        editingCell = null;
+        bumpRevision(row, col);
+        notifyEditingSubscribers();
+      }
+    },
+    setSaveState(row, col, state) {
+      const id = getCellId(row, col);
+      if (state === null) {
+        saveStates.delete(id);
+      } else {
+        saveStates.set(id, state);
+      }
+      bumpRevision(row, col);
+    },
+    setColumnWidth(col, width) {
+      columnWidths.set(col, width);
+      columnStretch.delete(col);
+      bumpStoreRevision();
+    },
+    setData(data) {
+      if (clipboardMarker && data.length !== rowCount) {
+        const stale = clipboardMarker;
+        clipboardMarker = null;
+        repaintUnion(stale.bounds, null);
+      }
+      initializeData(data);
+      newRowFlags.clear();
+      subscribers.forEach((_, id) => {
+        const [row, col] = id.split(":").map(Number);
+        bumpRevision(row, col);
+      });
+      bumpStoreRevision();
+    },
+    setColumns(newColumns) {
+      if (clipboardMarker) {
+        const stale = clipboardMarker;
+        clipboardMarker = null;
+        repaintUnion(stale.bounds, null);
+      }
+      const widthsByData = /* @__PURE__ */ new Map();
+      currentColumns.forEach((col, idx) => {
+        const w = columnWidths.get(idx);
+        if (w != null) widthsByData.set(col.data, w);
+      });
+      currentColumns = newColumns;
+      columnWidths.clear();
+      columnStretch.clear();
+      newColumns.forEach((col, idx) => {
+        const carried = widthsByData.get(col.data);
+        if (carried != null) columnWidths.set(idx, carried);
+        else if (col.width) columnWidths.set(idx, col.width);
+      });
+      saveStates.clear();
+      bumpStoreRevision();
+    },
+    reinitColumnWidths() {
+      columnWidths.clear();
+      columnStretch.clear();
+      currentColumns.forEach((col, idx) => {
+        if (col.width) columnWidths.set(idx, col.width);
+      });
+      bumpStoreRevision();
+    },
+    addRow(rowData, atIndex = 0) {
+      const newRowDataMap = /* @__PURE__ */ new Map();
+      const newRevisions = /* @__PURE__ */ new Map();
+      const newSaveStates = /* @__PURE__ */ new Map();
+      const newNewRowFlags = /* @__PURE__ */ new Set();
+      rowDataMap.forEach((data, idx) => {
+        const newIdx = idx >= atIndex ? idx + 1 : idx;
+        newRowDataMap.set(newIdx, data);
+      });
+      revisions.forEach((rev, id) => {
+        const [r, c] = id.split(":").map(Number);
+        const newR = r >= atIndex ? r + 1 : r;
+        newRevisions.set(getCellId(newR, c), rev);
+      });
+      saveStates.forEach((state, id) => {
+        const [r, c] = id.split(":").map(Number);
+        const newR = r >= atIndex ? r + 1 : r;
+        newSaveStates.set(getCellId(newR, c), state);
+      });
+      newRowFlags.forEach((idx) => {
+        newNewRowFlags.add(idx >= atIndex ? idx + 1 : idx);
+      });
+      rowDataMap.clear();
+      revisions.clear();
+      saveStates.clear();
+      newRowFlags.clear();
+      newRowDataMap.forEach((data, idx) => rowDataMap.set(idx, data));
+      newRevisions.forEach((rev, id) => revisions.set(id, rev));
+      newSaveStates.forEach((state, id) => saveStates.set(id, state));
+      newNewRowFlags.forEach((idx) => newRowFlags.add(idx));
+      currentColumns.forEach((col) => {
+        if (rowData[col.data] == null) rowData[col.data] = "";
+      });
+      rowDataMap.set(atIndex, rowData);
+      rowCount++;
+      newRowFlags.add(atIndex);
+      subscribers.forEach((_, id) => {
+        const [row, col] = id.split(":").map(Number);
+        bumpRevision(row, col);
+      });
+      bumpStoreRevision();
+    },
+    removeRow(rowIndex) {
+      const newRowDataMap = /* @__PURE__ */ new Map();
+      const newRevisions = /* @__PURE__ */ new Map();
+      const newSaveStates = /* @__PURE__ */ new Map();
+      const newNewRowFlags = /* @__PURE__ */ new Set();
+      rowDataMap.forEach((data, idx) => {
+        if (idx < rowIndex) {
+          newRowDataMap.set(idx, data);
+        } else if (idx > rowIndex) {
+          newRowDataMap.set(idx - 1, data);
+        }
+      });
+      revisions.forEach((rev, id) => {
+        const [r, c] = id.split(":").map(Number);
+        if (r < rowIndex) {
+          newRevisions.set(getCellId(r, c), rev);
+        } else if (r > rowIndex) {
+          newRevisions.set(getCellId(r - 1, c), rev);
+        }
+      });
+      saveStates.forEach((state, id) => {
+        const [r, c] = id.split(":").map(Number);
+        if (r < rowIndex) {
+          newSaveStates.set(getCellId(r, c), state);
+        } else if (r > rowIndex) {
+          newSaveStates.set(getCellId(r - 1, c), state);
+        }
+      });
+      newRowFlags.forEach((idx) => {
+        if (idx < rowIndex) {
+          newNewRowFlags.add(idx);
+        } else if (idx > rowIndex) {
+          newNewRowFlags.add(idx - 1);
+        }
+      });
+      rowDataMap.clear();
+      revisions.clear();
+      saveStates.clear();
+      newRowFlags.clear();
+      newRowDataMap.forEach((data, idx) => rowDataMap.set(idx, data));
+      newRevisions.forEach((rev, id) => revisions.set(id, rev));
+      newSaveStates.forEach((state, id) => saveStates.set(id, state));
+      newNewRowFlags.forEach((idx) => newRowFlags.add(idx));
+      rowCount--;
+      subscribers.forEach((_, id) => {
+        const [row, col] = id.split(":").map(Number);
+        bumpRevision(row, col);
+      });
+      bumpStoreRevision();
+    },
+    markRowAsNew(rowIndex, isNew) {
+      if (isNew) {
+        newRowFlags.add(rowIndex);
+      } else {
+        newRowFlags.delete(rowIndex);
+      }
+      bumpRowRevisions(rowIndex, currentColumns.length);
+      bumpStoreRevision();
+    },
+    markRowAsSaved(rowIndex, savedData) {
+      newRowFlags.delete(rowIndex);
+      rowDataMap.set(rowIndex, savedData);
+      bumpRowRevisions(rowIndex, currentColumns.length);
+      bumpStoreRevision();
+    },
+    // --- Subscriptions ---
+    subscribe(row, col, callback) {
+      const id = getCellId(row, col);
+      if (!subscribers.has(id)) {
+        subscribers.set(id, /* @__PURE__ */ new Set());
+      }
+      subscribers.get(id).add(callback);
+      return () => {
+        const subs = subscribers.get(id);
+        if (subs) {
+          subs.delete(callback);
+          if (subs.size === 0) {
+            subscribers.delete(id);
+          }
+        }
+      };
+    },
+    subscribeToStore(callback) {
+      storeSubscribers.add(callback);
+      return () => {
+        storeSubscribers.delete(callback);
+      };
+    },
+    subscribeToSelection(callback) {
+      selectionSubscribers.add(callback);
+      return () => {
+        selectionSubscribers.delete(callback);
+      };
+    },
+    subscribeToEditing(callback) {
+      editingSubscribers.add(callback);
+      return () => {
+        editingSubscribers.delete(callback);
+      };
+    },
+    getRevision(row, col) {
+      return revisions.get(getCellId(row, col)) ?? 0;
+    },
+    // --- Table container focus management ---
+    setTableRef(ref) {
+      tableRef = ref;
+    },
+    focusTable() {
+      tableRef?.current?.focus();
+    },
+    blurTable() {
+      tableRef?.current?.blur();
+    },
+    bumpRevision,
+    bumpRevisions,
+    bumpRowRevisions,
+    bumpStoreRevision
+  };
+  return store;
+}
+export {
+  createCellStore
+};
+//# sourceMappingURL=index.js.map