@pixerate/editor 0.26.1 → 0.28.0

package/dist/{chunk-X7HXL2SB.js → chunk-3RPOW4CS.js}

@@ -1,9 +1,3 @@
-import {
-  parseCsv,
-  parseTsv,
-  serializeCsv,
-  serializeTsv
-} from "./chunk-664LQYFJ.js";
 import {
   FormulaEvaluator,
   NumberFormat,
@@ -32,6 +26,12 @@ import {
   toText,
   tokenizeFormula
 } from "./chunk-ZRNHGAQT.js";
+import {
+  parseCsv,
+  parseTsv,
+  serializeCsv,
+  serializeTsv
+} from "./chunk-664LQYFJ.js";
 
 // src/spreadsheet/formula/dependency-graph.ts
 function extractNameDependencies(node) {
@@ -863,6 +863,27 @@ function remapFormulaReferences(formula, moveCell, options = {}) {
     return `${formatPart({ ...start, row: minR, col: minC })}:${formatPart({ ...end, row: maxR, col: maxC })}`;
   });
 }
+function transposeFormulaReferences(formula, anchor, block) {
+  const t = { row: block.startRow + (anchor.col - block.startCol), col: block.startCol + (anchor.row - block.startRow) };
+  return mapFormulaReferences(formula, (text, info) => {
+    const parts = text.split(":").map(parsePart);
+    if (parts.some((p) => p === null || p.row === null)) return text;
+    const moved = [];
+    for (const part of parts) {
+      const row = part.row;
+      const colAbs = !!part.colAbs;
+      const rowAbs = !!part.rowAbs;
+      if ((colAbs || rowAbs) && info.sheet !== void 0) return text;
+      if (colAbs && (part.col < block.startCol || part.col > block.endCol)) return text;
+      if (rowAbs && (row < block.startRow || row > block.endRow)) return text;
+      const newRow = colAbs ? block.startRow + (part.col - block.startCol) : t.row + (part.col - anchor.col);
+      const newCol = rowAbs ? block.startCol + (row - block.startRow) : t.col + (row - anchor.row);
+      if (newRow < 0 || newCol < 0) return "#REF!";
+      moved.push({ colAbs: part.rowAbs, col: newCol, rowAbs: part.colAbs, row: newRow });
+    }
+    return moved.map(formatPart).join(":");
+  });
+}
 var CELL_LIKE = /^[A-Za-z]{1,3}\d{1,7}$/;
 var isCellLike = (name) => {
   if (!CELL_LIKE.test(name)) return false;
@@ -1781,6 +1802,175 @@ function parseRuleRanges(text) {
   }
   return out;
 }
+function mergeRuleRanges(ranges) {
+  const join = (list, across) => {
+    const [lo, hi, fixedLo, fixedHi] = across === "row" ? ["startRow", "endRow", "startCol", "endCol"] : ["startCol", "endCol", "startRow", "endRow"];
+    const sorted = list.map(normalizeRange).sort((a, b) => a[fixedLo] - b[fixedLo] || a[fixedHi] - b[fixedHi] || a[lo] - b[lo]);
+    const out = [];
+    for (const r of sorted) {
+      const last = out[out.length - 1];
+      if (last && last[fixedLo] === r[fixedLo] && last[fixedHi] === r[fixedHi] && r[lo] <= last[hi] + 1) {
+        last[hi] = Math.max(last[hi], r[hi]);
+      } else {
+        out.push({ ...r });
+      }
+    }
+    return out;
+  };
+  return join(join(ranges, "row"), "col").sort((a, b) => a.startRow - b.startRow || a.startCol - b.startCol);
+}
+function sortRuleRanges(ranges, block, newRowOf) {
+  const b = normalizeRange(block);
+  let changed = false;
+  const pieces = [];
+  const moved = /* @__PURE__ */ new Map();
+  for (const range of ranges) {
+    const r = normalizeRange(range);
+    const top = Math.max(r.startRow, b.startRow);
+    const bottom = Math.min(r.endRow, b.endRow);
+    const left = Math.max(r.startCol, b.startCol);
+    const right = Math.min(r.endCol, b.endCol);
+    if (top > bottom || left > right || top === b.startRow && bottom === b.endRow) {
+      pieces.push(r);
+      continue;
+    }
+    changed = true;
+    pieces.push(...subtractRange(r, b));
+    const key = `${left}:${right}`;
+    let entry = moved.get(key);
+    if (!entry) moved.set(key, entry = { startCol: left, endCol: right, rows: [] });
+    for (let row = top; row <= bottom; row++) entry.rows.push(newRowOf(row));
+  }
+  if (!changed) return null;
+  for (const { startCol, endCol, rows } of moved.values()) {
+    rows.sort((x, y) => x - y);
+    let start = rows[0];
+    for (let i = 1; i <= rows.length; i++) {
+      if (i < rows.length && rows[i] <= rows[i - 1] + 1) continue;
+      pieces.push({ startRow: start, startCol, endRow: rows[i - 1], endCol });
+      start = rows[i];
+    }
+  }
+  return mergeRuleRanges(pieces);
+}
+function transposeRuleRanges(ranges, block, target) {
+  const s = normalizeRange(block);
+  const t = normalizeRange(target);
+  if (!ranges.some((r) => rangesIntersect(r, s) || rangesIntersect(r, t))) return null;
+  const inside = [];
+  for (const range of ranges) {
+    const r = normalizeRange(range);
+    if (!rangesIntersect(r, s)) continue;
+    const top = Math.max(r.startRow, s.startRow);
+    const bottom = Math.min(r.endRow, s.endRow);
+    const left = Math.max(r.startCol, s.startCol);
+    const right = Math.min(r.endCol, s.endCol);
+    inside.push({
+      startRow: s.startRow + (left - s.startCol),
+      endRow: s.startRow + (right - s.startCol),
+      startCol: s.startCol + (top - s.startRow),
+      endCol: s.startCol + (bottom - s.startRow)
+    });
+  }
+  const outside = subtractRangeFromRanges(subtractRangeFromRanges(ranges, s), t);
+  return { inside: mergeRuleRanges(inside), outside: mergeRuleRanges(outside) };
+}
+function reanchorRuleFormula(formula, from, to) {
+  if (from.row === to.row && from.col === to.col) return formula;
+  const hadEquals = formula.trimStart().startsWith("=");
+  const moved = ruleFormulaAt(formula, from, to.row, to.col);
+  return hadEquals ? moved : moved.slice(1);
+}
+function transposeRuleFormula(formula, anchor, block) {
+  const hadEquals = formula.trimStart().startsWith("=");
+  const out = transposeFormulaReferences(withEquals(formula), anchor, normalizeRange(block));
+  return hadEquals ? out : out.slice(1);
+}
+var isFormulaText = (text) => text !== void 0 && text.trimStart().startsWith("=");
+function mapConditionalFormatFormulas(rule, fn) {
+  const anchor = (value) => value.type === "formula" ? { ...value, formula: fn(value.formula) } : value;
+  const next = { ...rule };
+  if (next.type === "expression") next.formula = fn(next.formula);
+  if (next.type === "cellIs") {
+    if (isFormulaText(next.value)) next.value = fn(next.value);
+    if (isFormulaText(next.value2)) next.value2 = fn(next.value2);
+  }
+  if (next.type === "colorScale") next.stops = next.stops.map((s) => ({ ...s, value: anchor(s.value) }));
+  if (next.type === "dataBar") {
+    if (next.min) next.min = anchor(next.min);
+    if (next.max) next.max = anchor(next.max);
+  }
+  if (next.type === "iconSet" && next.thresholds) next.thresholds = next.thresholds.map(anchor);
+  return next;
+}
+function mapDataValidationFormulas(rule, fn) {
+  const next = { ...rule };
+  if (isFormulaText(next.formula1)) next.formula1 = fn(next.formula1);
+  if (isFormulaText(next.formula2)) next.formula2 = fn(next.formula2);
+  return next;
+}
+function hasRuleFormulas(rule, mapFormulas) {
+  let found = false;
+  mapFormulas(rule, (f) => {
+    found = true;
+    return f;
+  });
+  return found;
+}
+var sameCell = (a, b) => a.row === b.row && a.col === b.col;
+function sortRules(rules, block, newRowOf, mapFormulas) {
+  let changed = false;
+  const out = rules.map((rule) => {
+    const ranges = sortRuleRanges(rule.ranges, block, newRowOf);
+    if (!ranges) return rule;
+    changed = true;
+    const from = ruleAnchor(rule.ranges);
+    const to = ruleAnchor(ranges);
+    const next = { ...rule, ranges };
+    return sameCell(from, to) ? next : mapFormulas(next, (f) => reanchorRuleFormula(f, from, to));
+  });
+  return changed ? out : rules;
+}
+function transposeRules(rules, block, target, mapFormulas, newId) {
+  const s = normalizeRange(block);
+  let changed = false;
+  const out = [];
+  for (const rule of rules) {
+    const moved = transposeRuleRanges(rule.ranges, s, target);
+    if (!moved) {
+      out.push(rule);
+      continue;
+    }
+    changed = true;
+    const { inside, outside } = moved;
+    const from = ruleAnchor(rule.ranges);
+    const withFormulas = hasRuleFormulas(rule, mapFormulas);
+    const stayed = () => {
+      const to = ruleAnchor(outside);
+      const next = { ...rule, ranges: outside };
+      return withFormulas && !sameCell(from, to) ? mapFormulas(next, (f) => reanchorRuleFormula(f, from, to)) : next;
+    };
+    const transposed = () => {
+      const next = { ...rule, ranges: inside };
+      if (!withFormulas) return next;
+      const first2 = rule.ranges.map(normalizeRange).find((r) => rangesIntersect(r, s));
+      const at = { row: Math.max(first2.startRow, s.startRow), col: Math.max(first2.startCol, s.startCol) };
+      const atT = { row: s.startRow + (at.col - s.startCol), col: s.startCol + (at.row - s.startRow) };
+      const to = ruleAnchor(inside);
+      return mapFormulas(next, (f) => reanchorRuleFormula(transposeRuleFormula(reanchorRuleFormula(f, from, at), at, s), atT, to));
+    };
+    if (inside.length === 0) {
+      if (outside.length > 0) out.push(stayed());
+    } else if (outside.length === 0) {
+      out.push(transposed());
+    } else if (!withFormulas) {
+      out.push({ ...rule, ranges: mergeRuleRanges([...outside, ...inside]) });
+    } else {
+      out.push(stayed(), { ...transposed(), id: newId() });
+    }
+  }
+  return changed ? out : rules;
+}
 
 // src/spreadsheet/conditional-format/icons.ts
 var RED = "#d9534f";
@@ -1877,13 +2067,13 @@ function defaultIconThresholds(set) {
   return Array.from({ length: k }, (_, i) => ({ type: "percent", value: Math.round(i * 100 / k) }));
 }
 var usesStats = (rule) => rule.type === "colorScale" || rule.type === "dataBar" || rule.type === "iconSet" || rule.type === "top10" || rule.type === "aboveAverage" || rule.type === "duplicate" || rule.type === "unique";
-var isFormulaText = (text) => !!text && text.trimStart().startsWith("=");
+var isFormulaText2 = (text) => !!text && text.trimStart().startsWith("=");
 function usesFormulas(rule) {
   switch (rule.type) {
     case "expression":
       return true;
     case "cellIs":
-      return isFormulaText(rule.value) || isFormulaText(rule.value2);
+      return isFormulaText2(rule.value) || isFormulaText2(rule.value2);
     case "colorScale":
       return rule.stops.some((s) => s.value.type === "formula");
     case "dataBar":
@@ -2056,7 +2246,7 @@ var ConditionalFormatEngine = class {
   /** The operand of a `cellIs` rule: a formula result, or typed input. */
   operand(text, rule, row, col) {
     if (text === void 0) return "";
-    if (isFormulaText(text)) return this.evalFormula(text, rule, row, col);
+    if (isFormulaText2(text)) return this.evalFormula(text, rule, row, col);
     return parseCellInput(text).value;
   }
   /** Combines every rule that applies to (row, col). */
@@ -2826,6 +3016,33 @@ var createRuntime = (doc) => ({
   selectedRange: null
 });
 var sameName3 = (a, b) => a.toUpperCase() === b.toUpperCase();
+var nameKey = (n) => `${n.sheetId ?? ""}!${n.name.toUpperCase()}`;
+function normalizeSavedName(n, sheetId) {
+  if (!n || typeof n.name !== "string" || typeof n.refersTo !== "string" || n.name === "") return null;
+  const { sheetId: _ignored, ...rest } = n;
+  return {
+    ...rest,
+    refersTo: n.refersTo.startsWith("=") ? n.refersTo : `=${n.refersTo}`,
+    ...sheetId !== void 0 ? { sheetId } : {}
+  };
+}
+function namesFromDocument(doc, sheetId) {
+  if (!Array.isArray(doc?.names)) return [];
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const saved of doc.names) {
+    const n = normalizeSavedName(saved, saved?.sheetId !== void 0 ? sheetId : void 0);
+    if (!n || seen.has(nameKey(n))) continue;
+    seen.add(nameKey(n));
+    out.push(n);
+  }
+  return out;
+}
+function withoutNames(doc) {
+  if (!("names" in doc)) return doc;
+  const { names: _names, ...rest } = doc;
+  return rest;
+}
 var DEFAULT_MAX_HISTORY_BYTES = 64 * 1024 * 1024;
 var AST_CACHE_SIZE = 1e5;
 var RANGE_CACHE_MIN_CELLS = 256;
@@ -2952,11 +3169,13 @@ var SpreadsheetController = class {
       ...options.document?.table ? { table: options.document.table } : {}
     };
     if (options.workbook && options.workbook.sheets.length > 0) {
-      this.setWorkbookState(options.workbook, false);
+      this.setWorkbookState({ ...options.workbook, sheets: options.workbook.sheets.map((doc) => ({ ...doc })) }, false);
     } else {
       this.runtimes = [createRuntime(first2)];
       this.active = this.ctx = this.runtimes[0];
+      this.names = namesFromDocument(options.document, first2.id);
     }
+    this.syncDocumentNames();
     this.boundSheetId = this.runtimes[0].doc.id;
     this.primaryDataSourceId = options.primaryDataSourceId;
     this.maxHistoryBytes = Math.max(0, options.maxHistoryBytes ?? DEFAULT_MAX_HISTORY_BYTES);
@@ -3068,6 +3287,7 @@ var SpreadsheetController = class {
       for (const n of this.names) if (n.sheetId === previousId) n.sheetId = loaded.id;
       if (this.boundSheetId === previousId) this.boundSheetId = loaded.id;
     }
+    if (Array.isArray(document.names)) this.loadDocumentNames(document, loaded.id);
     this.activeCell = null;
     this.selectedRange = null;
     this.editingCell = null;
@@ -3080,9 +3300,40 @@ var SpreadsheetController = class {
     this.notifyChange();
   }
   // --- Workbook: loading and saving ---
-  /** A deep copy of the workbook: every sheet, the active sheet and the defined names. */
+  /**
+   * Installs the names saved in a document loaded into sheet `sheetId`: they
+   * replace that sheet's own names and, when it is the only sheet, the
+   * workbook names; with other sheets, its workbook names are added (or
+   * replace the same name) and the others are kept.
+   */
+  loadDocumentNames(document, sheetId) {
+    const saved = namesFromDocument(document, sheetId);
+    const onlySheet = this.runtimes.length === 1;
+    const keys = new Set(saved.map(nameKey));
+    this.names = this.names.filter(
+      (n) => n.sheetId !== sheetId && !(n.sheetId === void 0 && (onlySheet || keys.has(nameKey(n))))
+    );
+    this.names.push(...saved);
+  }
+  /**
+   * Writes every sheet's current names into its document (`doc.names`), so
+   * documents passed to `onDocumentChange` or read from `document` carry them.
+   */
+  syncDocumentNames() {
+    for (const rt of this.runtimes) {
+      const names = this.names.filter((n) => n.sheetId === void 0 || n.sheetId === rt.doc.id).map((n) => ({ ...n }));
+      if (names.length > 0) rt.doc.names = names;
+      else delete rt.doc.names;
+    }
+  }
+  /**
+   * A deep copy of the workbook: every sheet, the active sheet and the
+   * defined names. The names are in `names` only (not repeated in each
+   * sheet's `names`).
+   */
   getWorkbook() {
-    return JSON.parse(JSON.stringify(this.workbookSnapshot()));
+    const snapshot = this.workbookSnapshot();
+    return JSON.parse(JSON.stringify({ ...snapshot, sheets: snapshot.sheets.map(withoutNames) }));
   }
   /** Replaces the whole workbook (sheets, names, active sheet). Clears undo history. */
   loadWorkbook(workbook) {
@@ -3099,6 +3350,11 @@ var SpreadsheetController = class {
     this.notifyChange();
     this.onSelectionChange?.(this.activeCell, this.selectedRange);
   }
+  /** The workbook as undo data; sheets leave out their copies of the names. */
+  serializeWorkbookSnapshot() {
+    const snapshot = this.workbookSnapshot();
+    return JSON.stringify({ ...snapshot, sheets: snapshot.sheets.map(withoutNames) });
+  }
   workbookSnapshot() {
     return {
       sheets: this.runtimes.map((rt) => rt.doc),
@@ -3127,7 +3383,19 @@ var SpreadsheetController = class {
     });
     this.runtimes = runtimes;
     this.active = this.ctx = runtimes.find((rt) => rt.doc.id === workbook.activeSheetId) ?? runtimes[0];
-    this.names = (workbook.names ?? []).filter((n) => n.sheetId === void 0 || ids.has(n.sheetId)).map((n) => ({ ...n, refersTo: n.refersTo.startsWith("=") ? n.refersTo : `=${n.refersTo}` }));
+    const seen = /* @__PURE__ */ new Set();
+    this.names = [];
+    const add = (n) => {
+      if (!n || seen.has(nameKey(n))) return;
+      seen.add(nameKey(n));
+      this.names.push(n);
+    };
+    for (const n of workbook.names ?? []) {
+      if (n?.sheetId === void 0 || ids.has(n.sheetId)) add(normalizeSavedName(n, n?.sheetId));
+    }
+    for (const rt of runtimes) {
+      for (const n of namesFromDocument(rt.doc, rt.doc.id)) add(n);
+    }
     if (resetSelection) {
       this.activeCell = null;
       this.selectedRange = null;
@@ -4464,6 +4732,10 @@ var SpreadsheetController = class {
         if (target === void 0 || col < startCol || col > endCol) return null;
         return { row: target, col };
       });
+      this.moveRulesForSort(
+        { startRow, startCol, endRow, endCol: wholeRows ? Number.MAX_SAFE_INTEGER : endCol },
+        (row) => newIndexOf.get(row) ?? row
+      );
       if (wholeRows) {
         const moved = sorted.map((r) => this.document.rows[r]);
         this.document.rows.splice(startRow, moved.length, ...moved);
@@ -4890,6 +5162,7 @@ var SpreadsheetController = class {
         if (!rangeContains(s, row, col)) return null;
         return { row: s.startRow + (col - s.startCol), col: s.startCol + (row - s.startRow) };
       });
+      this.moveRulesForTranspose(s, t);
       const rowId = (r) => this.document.rows[r].id;
       const colId = (c) => this.document.columns[c].id;
       const moved = [];
@@ -4997,6 +5270,10 @@ var SpreadsheetController = class {
       id,
       name
     };
+    const existingNames = new Set(this.names.map(nameKey));
+    for (const n of namesFromDocument(options.document, id)) {
+      if (!existingNames.has(nameKey(n))) this.names.push(n);
+    }
     const rt = createRuntime(doc);
     const index = Math.max(0, Math.min(options.index ?? this.runtimes.length, this.runtimes.length));
     this.runtimes.splice(index, 0, rt);
@@ -5084,6 +5361,7 @@ var SpreadsheetController = class {
     doc.id = this.generateSheetId();
     doc.name = name;
     doc.createdAt = doc.updatedAt = Date.now();
+    delete doc.names;
     const copies = this.names.filter((n) => n.sheetId === source.doc.id).map((n) => ({ ...n, sheetId: doc.id, refersTo: renameSheetInFormula(n.refersTo, source.doc.name, name) }));
     this.names.push(...copies);
     const rt = createRuntime(doc);
@@ -5283,7 +5561,7 @@ var SpreadsheetController = class {
   }
   recordWorkbookSnapshot() {
     if (this.isApplyingHistory || this.batching) return;
-    this.pushUndo({ kind: "workbook", data: JSON.stringify(this.workbookSnapshot()) });
+    this.pushUndo({ kind: "workbook", data: this.serializeWorkbookSnapshot() });
   }
   pushUndo(entry) {
     this.undoStack.push(entry);
@@ -5363,7 +5641,7 @@ var SpreadsheetController = class {
           this.activateRuntime(rt);
         }
       } else {
-        to.push({ kind: "workbook", data: JSON.stringify(this.workbookSnapshot()) });
+        to.push({ kind: "workbook", data: this.serializeWorkbookSnapshot() });
         const previousActive = this.active.doc.id;
         const selection = { activeCell: this.activeCell, selectedRange: this.selectedRange };
         const saved = new Map(this.runtimes.map((rt) => [rt.doc.id, rt]));
@@ -5394,6 +5672,7 @@ var SpreadsheetController = class {
   notifyChange() {
     if (!this.cfIncremental) this.cfDirty = "all";
     this.invalidCircles = null;
+    this.syncDocumentNames();
     this.onDocumentChange?.(this.active.doc);
     if (this.onWorkbookChange) {
       const snapshot = this.workbookSnapshot();
@@ -5477,6 +5756,43 @@ var SpreadsheetController = class {
       }).filter((rule) => rule.ranges.length > 0);
     }
   }
+  /**
+   * Moves conditional formats and validations with sorted rows: per-row
+   * parts follow their rows, parts spanning every sorted row stay (Excel).
+   */
+  moveRulesForSort(block, newRowOf) {
+    const table = this.document.table;
+    if (!table) return;
+    if (table.conditionalFormats?.length) {
+      table.conditionalFormats = sortRules(table.conditionalFormats, block, newRowOf, mapConditionalFormatFormulas);
+    }
+    if (table.dataValidations?.length) {
+      table.dataValidations = sortRules(table.dataValidations, block, newRowOf, mapDataValidationFormulas);
+    }
+  }
+  /** Moves conditional formats and validations of a transposed block with its cells. */
+  moveRulesForTranspose(block, target) {
+    const table = this.document.table;
+    if (!table) return;
+    if (table.conditionalFormats?.length) {
+      table.conditionalFormats = transposeRules(
+        table.conditionalFormats,
+        block,
+        target,
+        mapConditionalFormatFormulas,
+        () => this.generateRuleId("cf")
+      );
+    }
+    if (table.dataValidations?.length) {
+      table.dataValidations = transposeRules(
+        table.dataValidations,
+        block,
+        target,
+        mapDataValidationFormulas,
+        () => this.generateRuleId("dv")
+      );
+    }
+  }
   /** Conditional formats of the sheet, highest priority first. */
   getConditionalFormats() {
     return this.document.table?.conditionalFormats ?? [];
@@ -6355,6 +6671,7 @@ export {
   mapFormulaReferences,
   offsetFormulaReferences,
   remapFormulaReferences,
+  transposeFormulaReferences,
   sheetNameNeedsQuotes,
   quoteSheetName,
   formatSheetPrefix,
@@ -6411,6 +6728,15 @@ export {
   forEachRangeCell,
   formatRuleRanges,
   parseRuleRanges,
+  mergeRuleRanges,
+  sortRuleRanges,
+  transposeRuleRanges,
+  reanchorRuleFormula,
+  transposeRuleFormula,
+  mapConditionalFormatFormulas,
+  mapDataValidationFormulas,
+  sortRules,
+  transposeRules,
   CONDITIONAL_FORMAT_ICON_SETS,
   conditionalFormatIconCount,
   getConditionalFormatIcon,
@@ -6475,4 +6801,4 @@ export {
   getSpreadsheetScrollToCell,
   sameSpreadsheetViewWindow
 };
-//# sourceMappingURL=chunk-X7HXL2SB.js.map
+//# sourceMappingURL=chunk-3RPOW4CS.js.map