@ai-matrx/office 0.8.21 → 0.8.22

package/dist/collab-sheets-transform.d.cts

@@ -45,7 +45,7 @@ interface SheetRange {
  * column width, worksheet name. C5b: formula text in cells (`f`, array `ref`) and defined names. Shared
  * formulas (`si`) stay barriers (see transform.ts cellBarrier); ranged resources are C5c.
  */
-type SheetFamily = "cell" | "structure" | "merge" | "size" | "name" | "defname" | "numfmt" | "count" | "sheet";
+type SheetFamily = "cell" | "structure" | "merge" | "size" | "name" | "defname" | "numfmt" | "count" | "sheet" | "sort";
 interface CoveredEntry {
     readonly kind: "covered";
     readonly family: SheetFamily;

package/dist/collab-sheets-transform.d.ts

@@ -45,7 +45,7 @@ interface SheetRange {
  * column width, worksheet name. C5b: formula text in cells (`f`, array `ref`) and defined names. Shared
  * formulas (`si`) stay barriers (see transform.ts cellBarrier); ranged resources are C5c.
  */
-type SheetFamily = "cell" | "structure" | "merge" | "size" | "name" | "defname" | "numfmt" | "count" | "sheet";
+type SheetFamily = "cell" | "structure" | "merge" | "size" | "name" | "defname" | "numfmt" | "count" | "sheet" | "sort";
 interface CoveredEntry {
     readonly kind: "covered";
     readonly family: SheetFamily;

package/dist/collab-sheets-transform.js

@@ -32,6 +32,7 @@ var SHEET_MUTATIONS = {
   "sheet.mutation.insert-sheet": covered("sheet", "index", "sheet"),
   "sheet.mutation.remove-sheet": covered("sheet", "sheetIndex", "sheetsLeft"),
   "sheet.mutation.set-worksheet-order": covered("sheet", "fromOrder", "toOrder"),
+  "sheet.mutation.reorder-range": covered("sort", "range", "order"),
   // ── never travels ────────────────────────────────────────────────────────────────────────────────
   "formula.mutation.set-formula-calculation-start": never(FORMULA_RESULT),
   "formula.mutation.set-trigger-formula-calculation-start": never(FORMULA_RESULT),
@@ -65,7 +66,6 @@ var SHEET_MUTATIONS = {
   "thread-comment.mutation.resolve-comment": never(UNIVER_COMMENTS),
   "thread-comment.mutation.delete-comment": never(UNIVER_COMMENTS),
   // ── barriers: X (no transform yet, design §10) ───────────────────────────────────────────────────
-  "sheet.mutation.reorder-range": barrier("X", "sort: a permutation, not transformed yet"),
   "sheet.mutation.move-range": barrier("X", "cut-paste carries the sender's cell matrices"),
   "sheet.mutation.set-worksheet-hidden": barrier("X", "sheet-level setting: not in C5a"),
   "sheet.mutation.set-tab-color": barrier("X", "sheet-level setting: not in C5a"),
@@ -508,7 +508,8 @@ var ID = {
   colCount: "sheet.mutation.set-worksheet-column-count",
   insertSheet: "sheet.mutation.insert-sheet",
   removeSheet: "sheet.mutation.remove-sheet",
-  sheetOrder: "sheet.mutation.set-worksheet-order"
+  sheetOrder: "sheet.mutation.set-worksheet-order",
+  sort: "sheet.mutation.reorder-range"
 };
 var PAIR_BARRIERS = {};
 var pairKey = (a, b) => a < b ? `${a}|${b}` : `${b}|${a}`;
@@ -1305,6 +1306,119 @@ function inlineSheetStyles(sheet, styleOf) {
   }
   return out;
 }
+var isSort = (m) => m.id === ID.sort;
+function sortOf(m) {
+  const P = /* @__PURE__ */ new Map();
+  for (const [t, src] of Object.entries(m.params.order ?? {})) P.set(Number(t), Number(src));
+  return { range: { ...m.params.range }, P };
+}
+var sortQ = (o) => new Map([...o.P].map(([t, s0]) => [s0, t]));
+function buildSort(template, o) {
+  const order = {};
+  for (const [t, s0] of [...o.P].sort((a, b) => a[0] - b[0])) if (t !== s0) order[t] = s0;
+  if (!Object.keys(order).length || o.range.startRow > o.range.endRow || o.range.startColumn > o.range.endColumn) return [];
+  return [{ id: template.id, params: { ...template.params, range: o.range, order } }];
+}
+var inSortCols = (o, c) => c >= o.range.startColumn && c <= o.range.endColumn;
+function sortThrough(o, st) {
+  const r = o.range;
+  if (st.axis === "col") {
+    if (st.op.kind === "move") {
+      const { from, count, to } = st.op;
+      const touches = !(from + count - 1 < r.startColumn || from > r.endColumn) || to > r.startColumn && to <= r.endColumn;
+      if (touches) return null;
+      const spans3 = spanThrough(st.op, r.startColumn, r.endColumn);
+      return spans3.length === 1 ? { range: { ...r, startColumn: spans3[0][0], endColumn: spans3[0][1] }, P: o.P } : null;
+    }
+    const spans2 = spanThrough(st.op, r.startColumn, r.endColumn);
+    if (!spans2.length) return { range: { ...r, startColumn: 1, endColumn: 0 }, P: /* @__PURE__ */ new Map() };
+    return { range: { ...r, startColumn: spans2[0][0], endColumn: spans2[spans2.length - 1][1] }, P: o.P };
+  }
+  const op = st.op;
+  if (op.kind === "move") {
+    const touches = !(op.from + op.count - 1 < r.startRow || op.from > r.endRow) || op.to > r.startRow && op.to <= r.endRow;
+    if (touches) return null;
+  }
+  if (op.kind === "insert" || op.kind === "move") {
+    const P2 = /* @__PURE__ */ new Map();
+    for (const [t, s0] of o.P) P2.set(mapIndex(op, t), mapIndex(op, s0));
+    const spans2 = spanThrough(op, r.startRow, r.endRow);
+    return { range: { ...r, startRow: spans2[0][0], endRow: spans2[spans2.length - 1][1] }, P: P2 };
+  }
+  const removed = (i) => i >= op.start && i < op.start + op.count;
+  const Q = sortQ(o);
+  const goneTargets = [];
+  for (let i = op.start; i < op.start + op.count; i++) goneTargets.push(Q.get(i) ?? i);
+  goneTargets.sort((a, b) => a - b);
+  const compact = (t) => t - goneTargets.filter((g) => g < t).length;
+  const P = /* @__PURE__ */ new Map();
+  for (const [t, s0] of o.P) if (!removed(s0)) P.set(compact(t), mapIndex(op, s0));
+  const spans = spanThrough(op, r.startRow, r.endRow);
+  if (!spans.length) return { range: { ...r, startRow: 1, endRow: 0 }, P: /* @__PURE__ */ new Map() };
+  return { range: { ...r, startRow: spans[0][0], endRow: spans[spans.length - 1][1] }, P };
+}
+function sortPair(x, y, sx, sy) {
+  const xs = isSort(x);
+  const ys = isSort(y);
+  if (!xs && !ys) return null;
+  if (xs && ys) {
+    const a = sortOf(x).range;
+    const b = sortOf(y).range;
+    const overlap = a.startRow <= b.endRow && b.startRow <= a.endRow && a.startColumn <= b.endColumn && b.startColumn <= a.endColumn;
+    return overlap ? barrier2("two sorts of overlapping ranges at once") : ok([x]);
+  }
+  if (xs) {
+    if (sy) {
+      const t = sortThrough(sortOf(x), sy);
+      return t ? ok(buildSort(x, t)) : barrier2("a row or column move through a sorted range");
+    }
+    return ok([x]);
+  }
+  const o = sortOf(y);
+  const Q = sortQ(o);
+  const moved = (r) => r >= o.range.startRow && r <= o.range.endRow && Q.has(r);
+  if (sx) {
+    if (sx.axis === "col") return sx.op.kind === "move" && !sortThrough(o, sx) ? barrier2("a column move through a sorted range") : ok([x]);
+    if (sx.op.kind === "insert") return ok([x]);
+    if (sx.op.kind === "move") return sortThrough(o, sx) ? ok([x]) : barrier2("a row move through a sorted range");
+    const rows = [];
+    let partial = false;
+    for (let i = sx.op.start; i < sx.op.start + sx.op.count; i++) {
+      if (moved(i)) partial = true;
+      rows.push(Q.get(i) ?? i);
+    }
+    if (partial) return barrier2("a row remove against a concurrent sort of those rows");
+    return ok([x]);
+  }
+  if (x.id === ID.values) {
+    const out = {};
+    let changed = false;
+    forEachCell(cellsOf(x), (r, c, v) => {
+      if (inSortCols(o, c) && moved(r)) {
+        putCell(out, Q.get(r), c, v);
+        changed = true;
+      } else putCell(out, r, c, v);
+    });
+    return changed ? ok([cellsMutation(x, out)]) : ok([x]);
+  }
+  if (isNumfmt(x)) {
+    const parts = nfParts(x).map((p) => {
+      const ranges = [];
+      for (const rc of p.ranges) {
+        const inner = { ...rc, startRow: Math.max(rc.startRow, o.range.startRow), endRow: Math.min(rc.endRow, o.range.endRow), startColumn: Math.max(rc.startColumn, o.range.startColumn), endColumn: Math.min(rc.endColumn, o.range.endColumn) };
+        if (inner.startRow > inner.endRow || inner.startColumn > inner.endColumn) {
+          ranges.push(rc);
+          continue;
+        }
+        ranges.push(...rectMinus(rc, inner));
+        for (let r = inner.startRow; r <= inner.endRow; r++) ranges.push({ ...inner, startRow: Q.get(r) ?? r, endRow: Q.get(r) ?? r });
+      }
+      return { ...p, ranges };
+    });
+    return ok(nfBuild(x, parts));
+  }
+  return ok([x]);
+}
 function familyOf(id) {
   const e = SHEET_MUTATIONS[id];
   return e && e.kind === "covered" ? e.family : "";
@@ -1330,6 +1444,8 @@ function transformMutation(x, y, side) {
   const fy = familyOf(y.id);
   const sy = structuralOf(y);
   const sx = structuralOf(x);
+  const sortp = sortPair(x, y, sx, sy);
+  if (sortp) return sortp;
   const cp = countPair(x, y, sy);
   if (cp) return cp;
   const np = numfmtPair(x, y, side, sx, sy);