persian-data-grid 0.5.0 → 0.6.0

package/dist/chunk-MT3KLB2Q.cjs

@@ -0,0 +1,944 @@
+'use strict';
+
+var chunkNTV2UUAJ_cjs = require('./chunk-NTV2UUAJ.cjs');
+
+// domain/events/index.ts
+var CellChanged = class {
+  constructor(rowId, columnId, newValue, previousValue) {
+    this.rowId = rowId;
+    this.columnId = columnId;
+    this.newValue = newValue;
+    this.previousValue = previousValue;
+    this.type = "CELL_CHANGED";
+  }
+};
+var DisplayChanged = class {
+  constructor(rowId, columnId, newValue) {
+    this.rowId = rowId;
+    this.columnId = columnId;
+    this.newValue = newValue;
+    this.type = "DISPLAY_CHANGED";
+  }
+};
+var DescriptionSaved = class {
+  constructor(rowId, flag) {
+    this.rowId = rowId;
+    this.flag = flag;
+    this.type = "DESCRIPTION_SAVED";
+  }
+};
+var ColumnReordered = class {
+  constructor(sourceIndex, destIndex) {
+    this.sourceIndex = sourceIndex;
+    this.destIndex = destIndex;
+    this.type = "COLUMN_REORDERED";
+  }
+};
+var RowAdded = class {
+  constructor(rowId) {
+    this.rowId = rowId;
+    this.type = "ROW_ADDED";
+  }
+};
+var RowDeleted = class {
+  constructor(rowId) {
+    this.rowId = rowId;
+    this.type = "ROW_DELETED";
+  }
+};
+var RowRemoved = class {
+  constructor(rowId) {
+    this.rowId = rowId;
+    this.type = "NEW_ROW_REMOVED";
+  }
+};
+var MinimumRowConstraintViolated = class {
+  constructor(rowId) {
+    this.rowId = rowId;
+    this.type = "NEW_AND_FIRST_ROW_CAN_NOT_BE_REMOVE";
+  }
+};
+var RowRestored = class {
+  constructor(rowId) {
+    this.rowId = rowId;
+    this.type = "ROW_RESTORED";
+  }
+};
+var RowReordered = class {
+  constructor(draggedRowNum, droppedRowNum) {
+    this.draggedRowNum = draggedRowNum;
+    this.droppedRowNum = droppedRowNum;
+    this.type = "ROW_REORDERED";
+  }
+};
+
+// domain/entities/Cell.ts
+function unwrap(value) {
+  if (value instanceof chunkNTV2UUAJ_cjs.CellValue) return value.value;
+  if (value instanceof chunkNTV2UUAJ_cjs.CellDisplay) return value.value;
+  return value;
+}
+var Cell = class _Cell {
+  constructor(rowId, columnId, value, originalValue, display) {
+    this.rowId = rowId;
+    this.columnId = columnId;
+    this.value = unwrap(value);
+    this.originalValue = unwrap(originalValue);
+    this.display = unwrap(display);
+  }
+  changeValue(newValue) {
+    const previousValue = this.value;
+    this.value = unwrap(newValue);
+    return new CellChanged(this.rowId, this.columnId, this.value, previousValue);
+  }
+  changeDisplay(newValue) {
+    const next = unwrap(newValue);
+    if (this.display === next) return null;
+    this.display = next;
+    return new DisplayChanged(this.rowId, this.columnId, next);
+  }
+  changeOriginalValue(newValue) {
+    const next = unwrap(newValue);
+    if (this.originalValue === next) return null;
+    const previousValue = this.originalValue;
+    this.originalValue = next;
+    return new CellChanged(this.rowId, this.columnId, next, previousValue);
+  }
+  getValue() {
+    return this.value;
+  }
+  getValueObject() {
+    return new chunkNTV2UUAJ_cjs.CellValue(this.value);
+  }
+  getDisplay() {
+    return this.display;
+  }
+  getDisplayObject() {
+    return new chunkNTV2UUAJ_cjs.CellDisplay(this.display);
+  }
+  getOriginalValue() {
+    return new chunkNTV2UUAJ_cjs.CellValue(this.originalValue);
+  }
+  clone() {
+    return new _Cell(
+      this.rowId,
+      this.columnId,
+      this.value,
+      this.originalValue,
+      this.display
+    );
+  }
+};
+
+// domain/entities/Collection.ts
+var Collection = class {
+  constructor(name = "default", rows, columns) {
+    this.name = name;
+    this.rows = rows;
+    this.columns = columns;
+  }
+  setCollectionName(name) {
+    this.name = name;
+  }
+  getCollectionName() {
+    return this.name;
+  }
+  getRows() {
+    return this.rows;
+  }
+  setRows(rows) {
+    this.rows = rows;
+  }
+  getColumns() {
+    return this.columns;
+  }
+};
+
+// domain/entities/Row.ts
+var Row = class _Row {
+  constructor(id, cells, rowState, changeFields = /* @__PURE__ */ new Set(), visibilityCondition, collection = "default", isSaveDescription, data, sourceId) {
+    this.id = id;
+    this.cells = cells;
+    this.rowState = rowState;
+    this.changeFields = changeFields;
+    this.visibilityCondition = visibilityCondition;
+    this.collection = collection;
+    this.isSaveDescription = isSaveDescription;
+    this.data = data;
+    this.sourceId = sourceId;
+  }
+  updateChangeFields(columnId) {
+    const cell = this.getCell(columnId.value);
+    if (!cell) return;
+    const value = cell.getValueObject();
+    const originalValue = cell.getOriginalValue();
+    if (this.rowState.value !== "Add" /* Added */) {
+      if (!value.equals(originalValue)) {
+        this.changeFields.add(columnId.value);
+      } else {
+        this.changeFields.delete(columnId.value);
+      }
+      if (this.changeFields.size > 0) {
+        this.rowState = new chunkNTV2UUAJ_cjs.RowState("Update" /* Modified */);
+      } else {
+        this.rowState = new chunkNTV2UUAJ_cjs.RowState("None" /* Unchanged */);
+      }
+    }
+  }
+  getCollection() {
+    return this.collection;
+  }
+  setCollection(collection) {
+    this.collection = collection;
+  }
+  getChangeFields() {
+    return Array.from(this.changeFields);
+  }
+  getSnapshotChangeFields() {
+    return Array.from(this.changeFields).map(
+      (field) => field.replace("index", "RowNum")
+    );
+  }
+  changeCell(columnId, value) {
+    const cell = this.getCell(columnId.value);
+    if (!cell) return null;
+    return cell.changeValue(value);
+  }
+  saveDescription(flag) {
+    this.isSaveDescription = flag;
+    return new DescriptionSaved(this.id, flag);
+  }
+  changeDisplay(columnId, value) {
+    const cell = this.getCell(columnId.value);
+    if (!cell) return null;
+    return cell.changeDisplay(value);
+  }
+  getCells() {
+    return new Map(this.cells);
+  }
+  /**
+   * Return a cell without materializing from host `data` (PR-101).
+   */
+  peekCell(columnId) {
+    return this.cells.get(columnId);
+  }
+  /**
+   * Lazy host cells (PR-101): when `rowData` left values on `data`, materialize
+   * a Cell on first read and cache it.
+   */
+  getCell(columnId) {
+    const existing = this.cells.get(columnId);
+    if (existing) return existing;
+    if (!this.data || typeof this.data !== "object") return void 0;
+    if (columnId === "index") return void 0;
+    const record = this.data;
+    if (!Object.prototype.hasOwnProperty.call(record, columnId)) {
+      return void 0;
+    }
+    const value = record[columnId];
+    const cell = new Cell(
+      this.id,
+      chunkNTV2UUAJ_cjs.ColumnId.for(columnId),
+      value,
+      value,
+      value
+    );
+    this.cells.set(columnId, cell);
+    return cell;
+  }
+  /**
+   * Read a cell value without allocating a Cell when the host object still
+   * holds the canonical value (PR-101 hot path for sort/filter/quick filter).
+   */
+  readValue(columnId) {
+    const existing = this.cells.get(columnId);
+    if (existing) return existing.getValue();
+    if (columnId === "index") return void 0;
+    if (this.data && typeof this.data === "object") {
+      const record = this.data;
+      if (Object.prototype.hasOwnProperty.call(record, columnId)) {
+        return record[columnId];
+      }
+    }
+    return void 0;
+  }
+  readDisplay(columnId) {
+    const existing = this.cells.get(columnId);
+    if (existing) return existing.getDisplay();
+    return this.readValue(columnId);
+  }
+  ensureCell(columnId, defaultValue, displayValue) {
+    if (this.cells.has(columnId.value)) return;
+    const newCell = new Cell(this.id, columnId, defaultValue, defaultValue, displayValue);
+    this.cells.set(columnId.value, newCell);
+  }
+  setRowId(rowId) {
+    this.id.set(rowId);
+  }
+  setVisibilityCondition(Condition) {
+    this.visibilityCondition = Condition;
+  }
+  getVisibilityCondition() {
+    return this.visibilityCondition;
+  }
+  removeCell(columnId) {
+    this.cells.delete(columnId.value);
+  }
+  setData(data) {
+    this.data = data;
+  }
+  getData() {
+    return this.data;
+  }
+  clone() {
+    const clonedCells = /* @__PURE__ */ new Map();
+    for (const [k, cell] of this.cells.entries()) {
+      const clonedCell = cell.clone();
+      clonedCells.set(k, clonedCell);
+    }
+    return new _Row(
+      this.id,
+      clonedCells,
+      this.rowState,
+      this.changeFields,
+      this.visibilityCondition,
+      this.collection,
+      this.isSaveDescription,
+      this.data,
+      this.sourceId
+    );
+  }
+};
+
+// domain/entities/Table.ts
+var Table = class _Table {
+  constructor(id, collection, pagination, action, activeCollection = "default") {
+    this.id = id;
+    this.collection = collection;
+    this.pagination = pagination;
+    this.action = action;
+    this.activeCollection = activeCollection;
+    /**
+     * Page-window mode (persistence 'paged-idb'): the Collection row Maps hold
+     * ONLY the current page; Pagination.totalRows is the source of truth for
+     * totals. In the default mode the Maps hold every row and pagination slices.
+     */
+    this.pageWindow = false;
+  }
+  isPageWindow() {
+    return this.pageWindow;
+  }
+  setPageWindow(enabled) {
+    this.pageWindow = enabled;
+    return this;
+  }
+  // ─── Collection accessor helper ───────────────────────────────────────────
+  getActiveCollection() {
+    const collection = this.collection.get(this.activeCollection);
+    if (!collection) throw new Error(`Collection "${this.activeCollection}" not found`);
+    return collection;
+  }
+  getCollection(collectionName) {
+    const collection = this.collection.get(collectionName);
+    if (!collection) throw new Error(`Collection "${collectionName}" not found`);
+    return collection;
+  }
+  /** Finds which Collection currently owns a given column id (if any). */
+  findCollectionForColumn(columnKey) {
+    for (const col of this.collection.values()) {
+      if (col.getColumns().has(columnKey)) return col;
+    }
+    return void 0;
+  }
+  getCollections() {
+    return this.collection;
+  }
+  // ─── Column helpers ───────────────────────────────────────────────────────
+  getColumnSchema(columnId) {
+    return this.getActiveCollection().getColumns().get(columnId.value);
+  }
+  getActiveCollectionName() {
+    return this.activeCollection;
+  }
+  setActiveCollection(activeCollection) {
+    this.activeCollection = activeCollection;
+  }
+  getRowCollection(rowId) {
+    return this.getActiveCollection().getRows().get(rowId)?.getCollection();
+  }
+  setRowCollection(rowId, collection) {
+    this.getActiveCollection().getRows().get(rowId)?.setCollection(collection);
+  }
+  setColumnSchema(columnId, DetailColumnConfig) {
+    const prev = this.getActiveCollection().getColumns().get(columnId.value);
+    this.getActiveCollection().getColumns().set(columnId.value, DetailColumnConfig);
+    return prev;
+  }
+  getColumns() {
+    return Array.from(this.getActiveCollection().getColumns().values());
+  }
+  getActiveCollectionColumns() {
+    const allColumns = this.getActiveCollection().getColumns();
+    return Array.from(allColumns.values()).sort(
+      (a, b) => (a.order ?? 0) - (b.order ?? 0)
+    );
+  }
+  getColumnsForCollectionScope(collectionScope = "active") {
+    if (collectionScope === "active") return this.getActiveCollectionColumns();
+    const names = collectionScope === "all" ? Array.from(this.collection.keys()) : collectionScope;
+    const merged = /* @__PURE__ */ new Map();
+    for (const name of names) {
+      for (const [id, col] of this.getCollection(name).getColumns()) {
+        merged.set(id, col);
+      }
+    }
+    return Array.from(merged.values());
+  }
+  getColumnValues(colId) {
+    const result = [];
+    for (const row of this.getActiveCollection().getRows().values()) {
+      const cell = row.getCell(colId);
+      if (!cell) continue;
+      result.push(cell.getValue());
+    }
+    return result;
+  }
+  setColumns(newColumns) {
+    const existingByField = new Map(this.getActiveCollection().getColumns());
+    for (const col of this.collection.values()) {
+      col.getColumns().clear();
+    }
+    for (const col of newColumns) {
+      const existing = existingByField.get(col.fieldName);
+      const targetCollectionKey = col.fieldCollection ?? this.activeCollection;
+      const updatedCol = {
+        ...col,
+        fieldCollection: targetCollectionKey,
+        // Prefer explicit hidden from caller; otherwise keep persisted visibility.
+        hidden: col.hidden ?? existing?.hidden ?? false,
+        // PR-61: keep user/domain order across host schema refresh.
+        order: existing?.order ?? col.order
+      };
+      const targetCollection = this.collection.get(targetCollectionKey);
+      if (targetCollection) {
+        targetCollection.getColumns().set(col.fieldName, updatedCol);
+      }
+    }
+    for (const row of this.getActiveCollection().getRows().values()) {
+      for (const col of newColumns) {
+        if (!row.getCells().has(col.fieldName)) {
+          const defaultValue = col.fieldType === "number" ? new chunkNTV2UUAJ_cjs.CellValue(0) : new chunkNTV2UUAJ_cjs.CellValue("");
+          const defaultDisplay = col.fieldType === "number" ? new chunkNTV2UUAJ_cjs.CellValue(0) : new chunkNTV2UUAJ_cjs.CellValue("");
+          row.ensureCell(new chunkNTV2UUAJ_cjs.ColumnId(col.fieldName), defaultValue, defaultDisplay);
+        }
+      }
+    }
+  }
+  // ─── Cell mutations ───────────────────────────────────────────────────────
+  changeCell(rowId, columnId, value) {
+    const row = this.getActiveCollection().getRows().get(rowId.value);
+    if (!row) return null;
+    const ev = row.changeCell(columnId, value);
+    if (ev) row.updateChangeFields(columnId);
+    return ev;
+  }
+  changeDisplay(rowId, columnId, value) {
+    const row = this.getActiveCollection().getRows().get(rowId.value);
+    if (!row) return null;
+    return row.changeDisplay(columnId, value);
+  }
+  saveDescription(rowId, flag) {
+    const row = this.getActiveCollection().getRows().get(rowId.value);
+    if (!row) return null;
+    return row.saveDescription(flag);
+  }
+  // ─── Row operations ───────────────────────────────────────────────────────
+  duplicateRow(rowId) {
+    const col = this.getActiveCollection();
+    const target = col.getRows().get(rowId.value);
+    if (!target) throw new Error("Row not found");
+    const rowsArray = Array.from(col.getRows().values());
+    const targetIndex = rowsArray.findIndex((r) => r.id.value === rowId.value);
+    const nextRow = targetIndex < rowsArray.length - 1 ? rowsArray[targetIndex + 1] : void 0;
+    const targetIndexValue = target.getCell("index")?.getValue();
+    let x;
+    if (!nextRow) {
+      x = targetIndexValue + 1;
+    } else {
+      const nextIndexValue = nextRow.getCell("index")?.getValue();
+      x = (targetIndexValue + nextIndexValue) / 2;
+    }
+    const newRowId = new chunkNTV2UUAJ_cjs.RowId(Math.floor((1 + Math.random()) * 18446744073709552e3));
+    const newCells = /* @__PURE__ */ new Map();
+    const newIndex = new chunkNTV2UUAJ_cjs.CellValue(x);
+    const newDisplay = new chunkNTV2UUAJ_cjs.CellDisplay(x);
+    for (const [colId, cell] of target.getCells().entries()) {
+      if (colId === "index") {
+        newCells.set(colId, new Cell(newRowId, new chunkNTV2UUAJ_cjs.ColumnId(colId), newIndex, newIndex, newDisplay));
+      } else {
+        newCells.set(
+          colId,
+          new Cell(
+            newRowId,
+            new chunkNTV2UUAJ_cjs.ColumnId(colId),
+            cell.getValueObject(),
+            cell.getValueObject(),
+            cell.getDisplayObject()
+          )
+        );
+      }
+    }
+    const newRow = new Row(
+      newRowId,
+      newCells,
+      new chunkNTV2UUAJ_cjs.RowState("Add" /* Added */),
+      /* @__PURE__ */ new Set(),
+      target.visibilityCondition,
+      target.collection,
+      target.isSaveDescription
+    );
+    rowsArray.sort(
+      (a, b) => a.getCell("index")?.getValue() - b.getCell("index")?.getValue()
+    );
+    rowsArray.splice(targetIndex + 1, 0, newRow);
+    col.setRows(new Map(rowsArray.map((r) => [r.id.value, r])));
+    return new RowAdded(newRowId);
+  }
+  addRow(targetRowId, placedRowId) {
+    const col = this.getActiveCollection();
+    const target = col.getRows().get(targetRowId);
+    if (!target) throw new Error("Row not found");
+    const rowsArray = Array.from(col.getRows().values()).sort(
+      (a, b) => a.getCell("index")?.getValue() - b.getCell("index")?.getValue()
+    );
+    let placeIndex;
+    let x = 0;
+    if (placedRowId !== void 0) {
+      placeIndex = rowsArray.findIndex((r) => r.id.value === placedRowId);
+      const placedRow = rowsArray[placeIndex];
+      const placeIndexValue = placedRow?.getCell("index")?.getValue();
+      const nextRow = placeIndex < rowsArray.length - 1 ? rowsArray[placeIndex + 1] : void 0;
+      if (nextRow) {
+        const nextIndexValue = nextRow.getCell("index")?.getValue();
+        x = (placeIndexValue + nextIndexValue) / 2;
+      } else {
+        x = placeIndexValue + 1;
+      }
+    } else {
+      const lastRowIndexValue = rowsArray[rowsArray.length - 1].getCell("index")?.getValue();
+      x = lastRowIndexValue + 1;
+    }
+    const newRowId = new chunkNTV2UUAJ_cjs.RowId(Math.floor((1 + Math.random()) * 18446744073709552e3));
+    const newCells = /* @__PURE__ */ new Map();
+    const newIndex = new chunkNTV2UUAJ_cjs.CellValue(x);
+    const newDisplay = new chunkNTV2UUAJ_cjs.CellDisplay(x);
+    for (const [colId, cell] of target.getCells().entries()) {
+      if (colId === "index") {
+        newCells.set("index", new Cell(newRowId, new chunkNTV2UUAJ_cjs.ColumnId("index"), newIndex, newIndex, newDisplay));
+      } else {
+        newCells.set(
+          colId,
+          new Cell(
+            newRowId,
+            new chunkNTV2UUAJ_cjs.ColumnId(colId),
+            cell.getValueObject(),
+            cell.getValueObject(),
+            cell.getDisplayObject()
+          )
+        );
+      }
+    }
+    const newRow = new Row(
+      newRowId,
+      newCells,
+      new chunkNTV2UUAJ_cjs.RowState("Add" /* Added */),
+      /* @__PURE__ */ new Set(),
+      target.visibilityCondition,
+      target.collection,
+      target.isSaveDescription
+    );
+    rowsArray.splice((placeIndex ?? 0) + 1, 0, newRow);
+    col.setRows(new Map(rowsArray.map((r) => [r.id.value, r])));
+    return new RowAdded(newRowId);
+  }
+  addNewRow(data, nextIndex) {
+    const col = this.getActiveCollection();
+    const newRowId = new chunkNTV2UUAJ_cjs.RowId(Math.floor((1 + Math.random()) * 18446744073709552e3));
+    const rowId = new chunkNTV2UUAJ_cjs.RowId(newRowId.value);
+    const cells = /* @__PURE__ */ new Map();
+    const dataMap = data ? new Map(data.map((kv) => [kv.key, kv])) : void 0;
+    this.getColumns().forEach((column) => {
+      const columnId = column.fieldName;
+      let value = null;
+      let display = null;
+      if (columnId === "index") {
+        if (nextIndex != null) {
+          value = nextIndex;
+          display = value;
+        } else {
+          const rows = Array.from(col.getRows().values());
+          const maxIndex = rows.length ? Math.max(
+            ...rows.map(
+              (r) => Number(r.getCell("index")?.getValue() ?? 0)
+            )
+          ) : 0;
+          value = maxIndex + 1;
+          display = value;
+        }
+      } else if (dataMap?.has(columnId)) {
+        const item = dataMap.get(columnId);
+        value = item?.value;
+        display = item?.display;
+      }
+      const cellValue = new chunkNTV2UUAJ_cjs.CellValue(value);
+      const cellDisplay = new chunkNTV2UUAJ_cjs.CellValue(display);
+      cells.set(columnId, new Cell(rowId, new chunkNTV2UUAJ_cjs.ColumnId(columnId), cellValue, cellValue, cellDisplay));
+    });
+    const newRow = new Row(
+      newRowId,
+      cells,
+      new chunkNTV2UUAJ_cjs.RowState("Add" /* Added */),
+      /* @__PURE__ */ new Set(),
+      {},
+      this.activeCollection,
+      false
+    );
+    col.getRows().set(newRowId.value, newRow);
+    if (this.pageWindow) {
+      const totalRows = this.pagination.totalRows + 1;
+      const lastPage = Math.max(1, Math.ceil(totalRows / this.pagination.pageSize));
+      this.pagination = new chunkNTV2UUAJ_cjs.Pagination(lastPage, this.pagination.pageSize, totalRows);
+    } else {
+      const totalRows = col.getRows().size;
+      const lastPage = Math.ceil(totalRows / this.pagination.pageSize);
+      this.changePage(lastPage);
+    }
+    return new RowAdded(newRowId);
+  }
+  addNewRows(cmd) {
+    const events = [];
+    const existingValues = new Set(
+      this.getRows().map((r) => r.getCell(cmd.detailFieldKey)?.getValue())
+    );
+    for (const data of cmd.rows) {
+      const incomingValue = data.find((kv) => kv.key === cmd.detailFieldKey)?.value;
+      if (incomingValue !== void 0 && !existingValues.has(incomingValue)) {
+        events.push(this.addNewRow(data));
+        existingValues.add(incomingValue);
+      }
+    }
+    return events;
+  }
+  addColumns(newColumns) {
+    const added = [];
+    const allColumns = this.getActiveCollection().getColumns();
+    for (const incoming of newColumns) {
+      const key = incoming.fieldName;
+      const existing = allColumns.get(key);
+      const targetCollectionKey = incoming.fieldCollection ?? this.activeCollection;
+      const targetCollection = this.collection.get(targetCollectionKey);
+      if (!targetCollection) continue;
+      if (existing) {
+        const shouldUnhide = existing.hidden === true;
+        targetCollection.getColumns().set(key, {
+          ...existing,
+          editable: incoming.editable ?? existing.editable,
+          hidden: shouldUnhide ? false : existing.hidden
+        });
+        if (shouldUnhide) added.push(new chunkNTV2UUAJ_cjs.ColumnId(incoming.fieldName));
+        continue;
+      }
+      targetCollection.getColumns().set(key, {
+        ...incoming,
+        fieldCollection: targetCollectionKey,
+        hidden: incoming.hidden ?? false
+      });
+      added.push(new chunkNTV2UUAJ_cjs.ColumnId(incoming.fieldName));
+      for (const row of this.getActiveCollection().getRows().values()) {
+        const defaultValue = incoming.fieldType === "number" ? new chunkNTV2UUAJ_cjs.CellValue(0) : new chunkNTV2UUAJ_cjs.CellValue("");
+        const defaultDisplay = incoming.fieldType === "number" ? new chunkNTV2UUAJ_cjs.CellValue(0) : new chunkNTV2UUAJ_cjs.CellValue("");
+        row.ensureCell(new chunkNTV2UUAJ_cjs.ColumnId(incoming.fieldName), defaultValue, defaultDisplay);
+      }
+    }
+    return { added };
+  }
+  setColumnHidden(columnId, hidden) {
+    const cols = this.getActiveCollection().getColumns();
+    const existing = cols.get(columnId);
+    if (!existing) return false;
+    if (Boolean(existing.hidden) === hidden) return false;
+    cols.set(columnId, { ...existing, hidden });
+    return true;
+  }
+  /** Runtime pin on `columnDef.pinned` (PR-114). Index column is not mutable. */
+  setColumnPinned(columnId, pinned) {
+    const cols = this.getActiveCollection().getColumns();
+    const existing = cols.get(columnId);
+    if (!existing) return false;
+    const bridge = { ...existing.columnDef ?? {} };
+    if (pinned == null) delete bridge.pinned;
+    else bridge.pinned = pinned;
+    const nextPinned = bridge.pinned ?? null;
+    const prevPinned = existing.columnDef?.pinned ?? null;
+    if (nextPinned === prevPinned) return false;
+    cols.set(columnId, { ...existing, columnDef: bridge });
+    return true;
+  }
+  removeColumns(columnIds) {
+    const removed = [];
+    for (const colId of columnIds) {
+      const ownerCollection = this.findCollectionForColumn(colId.value);
+      if (!ownerCollection) continue;
+      const schema = ownerCollection.getColumns().get(colId.value);
+      if (!schema || schema.hidden) continue;
+      ownerCollection.getColumns().set(colId.value, { ...schema, hidden: true });
+      removed.push(colId);
+    }
+    return { removed };
+  }
+  // ─── Row reads ────────────────────────────────────────────────────────────
+  getRows(collectionScope = "active") {
+    if (collectionScope === "all") {
+      const rows = [];
+      for (const col of this.collection.values()) {
+        rows.push(...col.getRows().values());
+      }
+      return rows;
+    }
+    if (Array.isArray(collectionScope)) {
+      const rows = [];
+      for (const name of collectionScope) {
+        const collection = this.getCollection(name);
+        rows.push(...collection.getRows().values());
+      }
+      return rows;
+    }
+    return Array.from(this.getActiveCollection().getRows().values());
+  }
+  getCollectionsRows(collections) {
+    const rows = [];
+    for (const name of collections) {
+      const collection = this.getCollection(name);
+      rows.push(...collection.getRows().values());
+    }
+    return rows;
+  }
+  getRow(rowId) {
+    return this.getActiveCollection().getRows().get(rowId);
+  }
+  /** Host `rowData` sync (PR-82) — put without going through add/undo. */
+  hostPutRow(row) {
+    this.getActiveCollection().getRows().set(row.id.value, row);
+  }
+  /** Host `rowData` sync (PR-82) — drop to match the host array. */
+  hostRemoveRow(rowId) {
+    this.getActiveCollection().getRows().delete(rowId);
+  }
+  addRows(newRows) {
+    const rows = this.getActiveCollection().getRows();
+    newRows.forEach((r) => rows.set(r.id.value, r));
+  }
+  // ─── Pagination ───────────────────────────────────────────────────────────
+  getPagination() {
+    return this.pagination;
+  }
+  setPagination(pagination) {
+    this.pagination = pagination;
+  }
+  changePage(page) {
+    this.pagination = this.pagination.changePage(page);
+  }
+  changePageSize(size) {
+    this.pagination = this.pagination.changePageSize(size).changePage(1);
+  }
+  /**
+   * Rows currently held in RAM for the active collection.
+   * With page-window storage the Collection Map already contains only the
+   * current page — do not slice by pagination offsets.
+   */
+  getVisibleRows() {
+    const filteredRows = this.getRows().filter((r) => r.collection === this.activeCollection);
+    if (this.pageWindow) return filteredRows;
+    const start = (this.pagination.page - 1) * this.pagination.pageSize;
+    return filteredRows.slice(start, start + this.pagination.pageSize);
+  }
+  // ─── Actions ──────────────────────────────────────────────────────────────
+  setTableAction(action) {
+    this.action = action;
+  }
+  getTableAction() {
+    return this.action;
+  }
+  // ─── Delete / restore ─────────────────────────────────────────────────────
+  /**
+   * Re-inserts a previously Added row after hard-remove (undo of ADD → redo).
+   * Preserves rowId and cell values; no-ops if the id already exists.
+   */
+  restoreAddedRow(params) {
+    const col = this.getActiveCollection();
+    const existing = col.getRows().get(params.rowId);
+    if (existing) {
+      return new RowAdded(existing.id);
+    }
+    const rowId = new chunkNTV2UUAJ_cjs.RowId(params.rowId);
+    const cells = /* @__PURE__ */ new Map();
+    for (const [columnId, snap] of Object.entries(params.cells)) {
+      const value = new chunkNTV2UUAJ_cjs.CellValue(snap.value);
+      const original = new chunkNTV2UUAJ_cjs.CellValue(
+        snap.originalValue !== void 0 ? snap.originalValue : snap.value
+      );
+      const display = new chunkNTV2UUAJ_cjs.CellDisplay(
+        snap.display !== void 0 ? snap.display : snap.value
+      );
+      cells.set(
+        columnId,
+        new Cell(rowId, new chunkNTV2UUAJ_cjs.ColumnId(columnId), value, original, display)
+      );
+    }
+    for (const column of this.getColumns()) {
+      if (cells.has(column.fieldName)) continue;
+      const empty = new chunkNTV2UUAJ_cjs.CellValue(null);
+      cells.set(
+        column.fieldName,
+        new Cell(
+          rowId,
+          new chunkNTV2UUAJ_cjs.ColumnId(column.fieldName),
+          empty,
+          empty,
+          new chunkNTV2UUAJ_cjs.CellDisplay(null)
+        )
+      );
+    }
+    const newRow = new Row(
+      rowId,
+      cells,
+      new chunkNTV2UUAJ_cjs.RowState("Add" /* Added */),
+      /* @__PURE__ */ new Set(),
+      {},
+      params.collection ?? this.activeCollection,
+      params.isSaveDescription ?? false
+    );
+    col.getRows().set(rowId.value, newRow);
+    return new RowAdded(rowId);
+  }
+  /**
+   * Delete semantics:
+   * - `Added` → hard-remove from the table (physically gone).
+   * - `Deleted` → restore (قابل برگرداندن).
+   * - otherwise (`Unchanged` / `Modified`) → soft-delete (`rowState = Deleted`).
+   */
+  deleteRow(rowId) {
+    const col = this.getActiveCollection();
+    const rows = col.getRows();
+    const row = rows.get(rowId.value);
+    if (!row) return null;
+    if (row.rowState.value === "Add" /* Added */) {
+      if (rows.size === 1) {
+        rows.delete(rowId.value);
+        this.addNewRow();
+        return new MinimumRowConstraintViolated(rowId);
+      }
+      rows.delete(rowId.value);
+      return new RowRemoved(rowId);
+    }
+    if (row.rowState.value === "Delete" /* Deleted */) {
+      const otherChanges = row.getChangeFields().filter((field) => field !== "RowState");
+      row.rowState = new chunkNTV2UUAJ_cjs.RowState(
+        otherChanges.length > 0 ? "Update" /* Modified */ : "None" /* Unchanged */
+      );
+      row.updateChangeFields(new chunkNTV2UUAJ_cjs.ColumnId("RowState"));
+      return new RowRestored(rowId);
+    }
+    row.rowState = new chunkNTV2UUAJ_cjs.RowState("Delete" /* Deleted */);
+    row.updateChangeFields(new chunkNTV2UUAJ_cjs.ColumnId("RowState"));
+    return new RowDeleted(rowId);
+  }
+  // ─── Reorder ──────────────────────────────────────────────────────────────
+  reorderRows(draggedRowNum, droppedRowNum, position = "after") {
+    if (draggedRowNum === droppedRowNum) return new RowReordered(draggedRowNum, droppedRowNum);
+    const col = this.getActiveCollection();
+    const rowsArray = Array.from(col.getRows().values()).sort(
+      (a, b) => a.getCell("index")?.getValue() - b.getCell("index")?.getValue()
+    );
+    const fromIndex = rowsArray.findIndex((r) => r.id.value === draggedRowNum);
+    const toIndex = rowsArray.findIndex((r) => r.id.value === droppedRowNum);
+    if (fromIndex === -1 || toIndex === -1)
+      throw new Error(`Row ${draggedRowNum} or ${droppedRowNum} does not exist`);
+    const [moved] = rowsArray.splice(fromIndex, 1);
+    let insertIndex = toIndex;
+    if (position === "after") {
+      insertIndex = toIndex + 1;
+      if (fromIndex < toIndex) insertIndex -= 1;
+    } else {
+      if (fromIndex < toIndex) insertIndex -= 1;
+    }
+    let newIndex;
+    if (insertIndex === 0) {
+      newIndex = rowsArray[0]?.getCell("index")?.getValue() / 2;
+    } else if (insertIndex >= rowsArray.length) {
+      newIndex = rowsArray[rowsArray.length - 1]?.getCell("index")?.getValue() + 1;
+    } else {
+      const prevIndex = rowsArray[insertIndex - 1].getCell("index")?.getValue();
+      const nextIndex = rowsArray[insertIndex].getCell("index")?.getValue();
+      newIndex = (prevIndex + nextIndex) / 2;
+    }
+    moved.changeCell(new chunkNTV2UUAJ_cjs.ColumnId("index"), newIndex);
+    rowsArray.splice(insertIndex, 0, moved);
+    col.setRows(new Map(rowsArray.map((r) => [r.id.value, r])));
+    moved.updateChangeFields(new chunkNTV2UUAJ_cjs.ColumnId("index"));
+    return new RowReordered(draggedRowNum, droppedRowNum);
+  }
+  reorderColumns(sourceIndex, destIndex) {
+    const activeCollection = this.getActiveCollection();
+    const colsMap = activeCollection.getColumns();
+    const colsArray = Array.from(colsMap.values()).sort(
+      (a, b) => (a.order ?? 0) - (b.order ?? 0)
+    );
+    const [moved] = colsArray.splice(sourceIndex, 1);
+    if (!moved) {
+      return new ColumnReordered(sourceIndex, destIndex);
+    }
+    colsArray.splice(destIndex, 0, moved);
+    colsMap.clear();
+    for (let i = 0; i < colsArray.length; i += 1) {
+      const col = colsArray[i];
+      if (!col) continue;
+      colsMap.set(col.fieldName, { ...col, order: i });
+    }
+    return new ColumnReordered(sourceIndex, destIndex);
+  }
+  // ─── Clone ────────────────────────────────────────────────────────────────
+  clone() {
+    const clonedCollection = /* @__PURE__ */ new Map();
+    for (const [collectionName, col] of this.collection.entries()) {
+      const clonedRows = /* @__PURE__ */ new Map();
+      for (const [k, row] of col.getRows().entries()) {
+        clonedRows.set(k, row.clone());
+      }
+      clonedCollection.set(
+        collectionName,
+        new Collection(
+          col.getCollectionName(),
+          clonedRows,
+          new Map(col.getColumns())
+        )
+      );
+    }
+    return new _Table(
+      this.id,
+      clonedCollection,
+      this.pagination,
+      this.action,
+      this.activeCollection
+    ).setPageWindow(this.pageWindow);
+  }
+};
+
+exports.Cell = Cell;
+exports.Collection = Collection;
+exports.MinimumRowConstraintViolated = MinimumRowConstraintViolated;
+exports.Row = Row;
+exports.RowRemoved = RowRemoved;
+exports.Table = Table;
+//# sourceMappingURL=chunk-MT3KLB2Q.cjs.map
+//# sourceMappingURL=chunk-MT3KLB2Q.cjs.map