@gridsheet/core 3.0.0-rc.8

package/dist/lib/operation.js

@@ -0,0 +1,36 @@
+const t = 1, l = 2, n = 4, c = 8, R = 16, r = 32, i = 64, u = 128, f = 256, h = 512, w = 8192, I = 1024, C = 16384, S = 32768, m = 65536, a = 131072, y = 0, M = 192, b = 157440, d = 12, p = 48, v = 60, L = 3, F = 157695, A = 229376, O = 524288, g = 255999, e = (s, o) => s === void 0 ? !1 : (s & o) === o, z = (s) => {
+  const o = [];
+  return e(s, 1) && o.push("RemoveRow"), e(s, 2) && o.push("RemoveCol"), e(s, 4) && o.push("InsertRowAbove"), e(s, 8) && o.push("InsertRowBelow"), e(s, 16) && o.push("InsertColLeft"), e(s, 32) && o.push("InsertColRight"), e(s, 64) && o.push("MoveFrom"), e(s, 128) && o.push("MoveTo"), e(s, 256) && o.push("Write"), e(s, 512) && o.push("Style"), e(s, 1024) && o.push("Resize"), e(s, 16384) && o.push("SetPolicy"), e(s, 131072) && o.push("SetLabel"), e(s, 32768) && o.push("Sort"), e(s, 65536) && o.push("Filter"), o;
+};
+export {
+  v as Add,
+  A as ColumnMenu,
+  w as Copy,
+  L as Delete,
+  m as Filter,
+  p as InsertCols,
+  R as InsertColsLeft,
+  r as InsertColsRight,
+  d as InsertRows,
+  n as InsertRowsAbove,
+  c as InsertRowsBelow,
+  M as Move,
+  i as MoveFrom,
+  u as MoveTo,
+  y as NoOperation,
+  F as ReadOnly,
+  l as RemoveCols,
+  t as RemoveRows,
+  I as Resize,
+  O as RowMenu,
+  a as SetLabel,
+  C as SetPolicy,
+  S as Sort,
+  h as Style,
+  b as Update,
+  g as ViewOnly,
+  f as Write,
+  z as debugOperations,
+  e as hasOperation
+};
+//# sourceMappingURL=operation.js.map

package/dist/lib/operation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operation.js","sources":["../../src/lib/operation.ts"],"sourcesContent":["import { OperationType as operations } from '../types';\n\nexport const RemoveRows: operations = 0b00000000000000000000000000000000000000000000000000001; // 1\nexport const RemoveCols: operations = 0b00000000000000000000000000000000000000000000000000010; // 2\nexport const InsertRowsAbove: operations = 0b00000000000000000000000000000000000000000000000000100; // 4\nexport const InsertRowsBelow: operations = 0b00000000000000000000000000000000000000000000000001000; // 8\nexport const InsertColsLeft: operations = 0b00000000000000000000000000000000000000000000000010000; // 16\nexport const InsertColsRight: operations = 0b00000000000000000000000000000000000000000000000100000; // 32\nexport const MoveFrom: operations = 0b00000000000000000000000000000000000000000000001000000; // 64\nexport const MoveTo: operations = 0b00000000000000000000000000000000000000000000010000000; // 128\nexport const Write: operations = 0b00000000000000000000000000000000000000000000100000000; // 256\nexport const Style: operations = 0b00000000000000000000000000000000000000000001000000000; // 512\nexport const Copy: operations = 0b00000000000000000000000000000000000000010000000000000; // 8192\nexport const Resize: operations = 0b00000000000000000000000000000000000000000010000000000; // 1024\nexport const SetPolicy: operations = 0b00000000000000000000000000000000000000100000000000000; // 16384\nexport const Sort: operations = 0b00000000000000000000000000000000000001000000000000000; // 32768\nexport const Filter: operations = 0b00000000000000000000000000000000000010000000000000000; // 65536\nexport const SetLabel: operations = 0b00000000000000000000000000000000000100000000000000000; // 131072\n\nexport const NoOperation: operations = 0;\n\nexport const Move: operations = MoveFrom | MoveTo; // 192\n\nexport const Update: operations = Write | Style | Copy | Resize | SetPolicy | SetLabel;\n\nexport const InsertRows: operations = InsertRowsAbove | InsertRowsBelow; // 12\n\nexport const InsertCols: operations = InsertColsLeft | InsertColsRight; // 48\n\nexport const Add: operations = InsertRows | InsertCols; // 60\n\nexport const Delete: operations = RemoveRows | RemoveCols; // 3\n\nexport const ReadOnly: operations = Update | Delete | Add | Move;\n\nexport const ColumnMenu: operations = Filter | Sort | SetLabel;\n\nexport const RowMenu: operations = 0b00000000000000000000000000000000010000000000000000000; // 524288\n\nexport const ViewOnly: operations = ReadOnly | ColumnMenu;\n\nexport const hasOperation = (operation: operations | undefined, flag: operations) => {\n  if (operation === undefined) {\n    return false;\n  }\n  return (operation & flag) === flag;\n};\n\n// Don't use this function in production\nexport const debugOperations = (prevention: operations | undefined) => {\n  const operations: string[] = [];\n  if (hasOperation(prevention, RemoveRows)) {\n    operations.push('RemoveRow');\n  }\n  if (hasOperation(prevention, RemoveCols)) {\n    operations.push('RemoveCol');\n  }\n  if (hasOperation(prevention, InsertRowsAbove)) {\n    operations.push('InsertRowAbove');\n  }\n  if (hasOperation(prevention, InsertRowsBelow)) {\n    operations.push('InsertRowBelow');\n  }\n  if (hasOperation(prevention, InsertColsLeft)) {\n    operations.push('InsertColLeft');\n  }\n  if (hasOperation(prevention, InsertColsRight)) {\n    operations.push('InsertColRight');\n  }\n  if (hasOperation(prevention, MoveFrom)) {\n    operations.push('MoveFrom');\n  }\n  if (hasOperation(prevention, MoveTo)) {\n    operations.push('MoveTo');\n  }\n  if (hasOperation(prevention, Write)) {\n    operations.push('Write');\n  }\n  if (hasOperation(prevention, Style)) {\n    operations.push('Style');\n  }\n  if (hasOperation(prevention, Resize)) {\n    operations.push('Resize');\n  }\n  if (hasOperation(prevention, SetPolicy)) {\n    operations.push('SetPolicy');\n  }\n  if (hasOperation(prevention, SetLabel)) {\n    operations.push('SetLabel');\n  }\n  if (hasOperation(prevention, Sort)) {\n    operations.push('Sort');\n  }\n  if (hasOperation(prevention, Filter)) {\n    operations.push('Filter');\n  }\n  return operations;\n};\n"],"names":["RemoveRows","RemoveCols","InsertRowsAbove","InsertRowsBelow","InsertColsLeft","InsertColsRight","MoveFrom","MoveTo","Write","Style","Copy","Resize","SetPolicy","Sort","Filter","SetLabel","NoOperation","Move","Update","InsertRows","InsertCols","Add","Delete","ReadOnly","ColumnMenu","RowMenu","ViewOnly","hasOperation","operation","flag","debugOperations","prevention","operations"],"mappings":"AAEO,MAAMA,IAAyB,GACzBC,IAAyB,GACzBC,IAA8B,GAC9BC,IAA8B,GAC9BC,IAA6B,IAC7BC,IAA8B,IAC9BC,IAAuB,IACvBC,IAAqB,KACrBC,IAAoB,KACpBC,IAAoB,KACpBC,IAAmB,MACnBC,IAAqB,MACrBC,IAAwB,OACxBC,IAAmB,OACnBC,IAAqB,OACrBC,IAAuB,QAEvBC,IAA0B,GAE1BC,IAAmB,KAEnBC,IAAqB,QAErBC,IAAyB,IAEzBC,IAAyB,IAEzBC,IAAkB,IAElBC,IAAqB,GAErBC,IAAuB,QAEvBC,IAAyB,QAEzBC,IAAsB,QAEtBC,IAAuB,QAEvBC,IAAe,CAACC,GAAmCC,MAC1DD,MAAc,SACT,MAEDA,IAAYC,OAAUA,GAInBC,IAAkB,CAACC,MAAuC;AACrE,QAAMC,IAAuB,CAAC;AAC1B,SAAAL,EAAaI,GAAY,CAAU,KACrCC,EAAW,KAAK,WAAW,GAEzBL,EAAaI,GAAY,CAAU,KACrCC,EAAW,KAAK,WAAW,GAEzBL,EAAaI,GAAY,CAAe,KAC1CC,EAAW,KAAK,gBAAgB,GAE9BL,EAAaI,GAAY,CAAe,KAC1CC,EAAW,KAAK,gBAAgB,GAE9BL,EAAaI,GAAY,EAAc,KACzCC,EAAW,KAAK,eAAe,GAE7BL,EAAaI,GAAY,EAAe,KAC1CC,EAAW,KAAK,gBAAgB,GAE9BL,EAAaI,GAAY,EAAQ,KACnCC,EAAW,KAAK,UAAU,GAExBL,EAAaI,GAAY,GAAM,KACjCC,EAAW,KAAK,QAAQ,GAEtBL,EAAaI,GAAY,GAAK,KAChCC,EAAW,KAAK,OAAO,GAErBL,EAAaI,GAAY,GAAK,KAChCC,EAAW,KAAK,OAAO,GAErBL,EAAaI,GAAY,IAAM,KACjCC,EAAW,KAAK,QAAQ,GAEtBL,EAAaI,GAAY,KAAS,KACpCC,EAAW,KAAK,WAAW,GAEzBL,EAAaI,GAAY,MAAQ,KACnCC,EAAW,KAAK,UAAU,GAExBL,EAAaI,GAAY,KAAI,KAC/BC,EAAW,KAAK,MAAM,GAEpBL,EAAaI,GAAY,KAAM,KACjCC,EAAW,KAAK,QAAQ,GAEnBA;AACT;"}

package/dist/lib/palette.d.ts

@@ -0,0 +1,2 @@
+export declare const COLOR_PALETTE: string[];
+//# sourceMappingURL=palette.d.ts.map

package/dist/lib/palette.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"palette.d.ts","sourceRoot":"","sources":["../../src/lib/palette.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,UAqBzB,CAAC"}

package/dist/lib/palette.js

@@ -0,0 +1,26 @@
+const F = [
+  // orange
+  "#FF6600",
+  // purple
+  "#AA44FF",
+  // emeraldblue
+  "#00CCCC",
+  // peach
+  "#EEAAEE",
+  // yellow
+  "#DDDD00",
+  // winered
+  "#AA4444",
+  // lightgreen
+  "#00FF00",
+  // pink
+  "#FF00FF",
+  // navy
+  "#3366FF",
+  // cyan
+  "#008888"
+];
+export {
+  F as COLOR_PALETTE
+};
+//# sourceMappingURL=palette.js.map

package/dist/lib/palette.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"palette.js","sources":["../../src/lib/palette.ts"],"sourcesContent":["export const COLOR_PALETTE = [\n  // orange\n  '#FF6600',\n  // purple\n  '#AA44FF',\n  // emeraldblue\n  '#00CCCC',\n  // peach\n  '#EEAAEE',\n  // yellow\n  '#DDDD00',\n  // winered\n  '#AA4444',\n  // lightgreen\n  '#00FF00',\n  // pink\n  '#FF00FF',\n  // navy\n  '#3366FF',\n  // cyan\n  '#008888',\n];\n"],"names":["COLOR_PALETTE"],"mappings":"AAAO,MAAMA,IAAgB;AAAA;AAAA,EAE3B;AAAA;AAAA,EAEA;AAAA;AAAA,EAEA;AAAA;AAAA,EAEA;AAAA;AAAA,EAEA;AAAA;AAAA,EAEA;AAAA;AAAA,EAEA;AAAA;AAAA,EAEA;AAAA;AAAA,EAEA;AAAA;AAAA,EAEA;AACF;"}

package/dist/lib/popup.d.ts

@@ -0,0 +1,24 @@
+/**
+ * lib/popup.ts
+ *
+ * Utility functions for computing the position of floating UI elements
+ * (tooltips, dropdowns, autocomplete lists, function guides, etc.)
+ * so they don't overflow the viewport.
+ */
+export type HAlign = 'left' | 'right';
+export type VAlign = 'top' | 'bottom';
+export type PopupPosition = {
+    x: number;
+    y: number;
+    hAlign: HAlign;
+};
+export declare const calcBelowPosition: (rect: DOMRect, maxWidth?: number, margin?: number) => PopupPosition;
+export declare const clampLeft: (left: number, width: number, margin?: number) => number;
+export type SideStyle = {
+    left: string;
+    right: string;
+};
+export declare const calcSideStyle: (el: HTMLElement, gap?: number) => SideStyle;
+export declare const clampPopup: (el: HTMLElement) => void;
+export declare const hAlignTransform: (hAlign: HAlign) => string;
+//# sourceMappingURL=popup.d.ts.map

package/dist/lib/popup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"popup.d.ts","sourceRoot":"","sources":["../../src/lib/popup.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAQH,MAAM,MAAM,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AACtC,MAAM,MAAM,MAAM,GAAG,KAAK,GAAG,QAAQ,CAAC;AAEtC,MAAM,MAAM,aAAa,GAAG;IAC1B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAgBF,eAAO,MAAM,iBAAiB,GAAI,MAAM,OAAO,EAAE,iBAAc,EAAE,eAAe,KAAG,aAKlF,CAAC;AAUF,eAAO,MAAM,SAAS,GAAI,MAAM,MAAM,EAAE,OAAO,MAAM,EAAE,eAAe,KAAG,MAIxE,CAAC;AAgBF,MAAM,MAAM,SAAS,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAExD,eAAO,MAAM,aAAa,GAAI,IAAI,WAAW,EAAE,YAAY,KAAG,SAc7D,CAAC;AAYF,eAAO,MAAM,UAAU,GAAI,IAAI,WAAW,KAAG,IAW5C,CAAC;AASF,eAAO,MAAM,eAAe,GAAI,QAAQ,MAAM,KAAG,MAA6D,CAAC"}

package/dist/lib/popup.js

@@ -0,0 +1,21 @@
+const r = (t, n = 260, o = 8) => t.right - n >= o ? { x: t.right, y: t.bottom, hAlign: "right" } : { x: Math.max(t.left, o), y: t.bottom, hAlign: "left" }, c = (t, n, o = 8) => {
+  const e = t + n - (window.innerWidth - o);
+  return e > 0 ? t - e : t;
+}, l = (t, n = 8) => {
+  if (t.style.left = `calc(100% + ${n}px)`, t.style.right = "auto", t.getBoundingClientRect().right > window.innerWidth - 8) {
+    const i = { left: "auto", right: `calc(100% + ${n}px)` };
+    return t.style.left = i.left, t.style.right = i.right, i;
+  }
+  return { left: `calc(100% + ${n}px)`, right: "auto" };
+}, s = (t) => {
+  const n = t.getBoundingClientRect(), o = window.innerWidth, i = window.innerHeight;
+  n.right > o - 8 && (t.style.left = `${parseFloat(t.style.left || "0") - (n.right - (o - 8))}px`), n.bottom > i - 8 && (t.style.top = `${parseFloat(t.style.top || "0") - (n.bottom - (i - 8))}px`);
+}, h = (t) => t === "right" ? "translateX(-100%)" : "none";
+export {
+  r as calcBelowPosition,
+  l as calcSideStyle,
+  c as clampLeft,
+  s as clampPopup,
+  h as hAlignTransform
+};
+//# sourceMappingURL=popup.js.map

package/dist/lib/popup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"popup.js","sources":["../../src/lib/popup.ts"],"sourcesContent":["/**\n * lib/popup.ts\n *\n * Utility functions for computing the position of floating UI elements\n * (tooltips, dropdowns, autocomplete lists, function guides, etc.)\n * so they don't overflow the viewport.\n */\n\nconst MARGIN = 8; // px gap from the viewport edge\n\n// ---------------------------------------------------------------------------\n// Types\n// ---------------------------------------------------------------------------\n\nexport type HAlign = 'left' | 'right';\nexport type VAlign = 'top' | 'bottom';\n\nexport type PopupPosition = {\n  x: number;\n  y: number;\n  hAlign: HAlign;\n};\n\n// ---------------------------------------------------------------------------\n// calcBelowPosition\n//\n// Places a popup BELOW an anchor rect.\n// Prefers aligning the popup's RIGHT edge to rect.right (hAlign='right'),\n// but falls back to aligning its LEFT edge to rect.left (hAlign='left')\n// when there is not enough room on the left side of the viewport.\n//\n// In the 'right' case the caller should apply  translateX(-100%) to shift the\n// popup leftward so its right edge lands at x.\n// In the 'left' case x is the desired left edge directly.\n//\n// Usage: error triangle tooltip, any anchored-to-element popup.\n// ---------------------------------------------------------------------------\nexport const calcBelowPosition = (rect: DOMRect, maxWidth = 260, margin = MARGIN): PopupPosition => {\n  if (rect.right - maxWidth >= margin) {\n    return { x: rect.right, y: rect.bottom, hAlign: 'right' };\n  }\n  return { x: Math.max(rect.left, margin), y: rect.bottom, hAlign: 'left' };\n};\n\n// ---------------------------------------------------------------------------\n// clampLeft\n//\n// Given the desired left position of a popup and its rendered width,\n// returns an adjusted left value that keeps the popup within the viewport.\n//\n// Usage: EditorOptions dropdown, FunctionGuide floating panel.\n// ---------------------------------------------------------------------------\nexport const clampLeft = (left: number, width: number, margin = MARGIN): number => {\n  const rightEdge = left + width;\n  const overflow = rightEdge - (window.innerWidth - margin);\n  return overflow > 0 ? left - overflow : left;\n};\n\n// ---------------------------------------------------------------------------\n// calcSidePosition\n//\n// Places a popup to the LEFT or RIGHT of an anchor element.\n// Prefers the right side; falls back to the left side if the right side\n// overflows the viewport.\n//\n// Resets the element to the preferred (right-side) position BEFORE measuring,\n// so that stale styles from a previous render don't corrupt the measurement.\n//\n// Applies the final styles directly to the element and also returns them.\n//\n// Usage: FunctionGuide guide1 (option tooltip panel).\n// ---------------------------------------------------------------------------\nexport type SideStyle = { left: string; right: string };\n\nexport const calcSideStyle = (el: HTMLElement, gap = MARGIN): SideStyle => {\n  // 1. Reset to preferred position so getBoundingClientRect reflects the right side.\n  el.style.left = `calc(100% + ${gap}px)`;\n  el.style.right = 'auto';\n\n  // 2. Measure after reset.\n  const rect = el.getBoundingClientRect();\n  if (rect.right > window.innerWidth - MARGIN) {\n    const flipped: SideStyle = { left: 'auto', right: `calc(100% + ${gap}px)` };\n    el.style.left = flipped.left;\n    el.style.right = flipped.right;\n    return flipped;\n  }\n  return { left: `calc(100% + ${gap}px)`, right: 'auto' };\n};\n\n// ---------------------------------------------------------------------------\n// clampPopup\n//\n// Adjusts a rendered popup element's position so it stays within the viewport.\n// Applies left/top corrections directly as inline styles to avoid re-renders.\n// Call this inside useLayoutEffect with no dependency array so it runs after\n// every render (content changes may change the popup dimensions).\n//\n// Usage: ContextMenu, FunctionGuide guide2, any popup that can change size.\n// ---------------------------------------------------------------------------\nexport const clampPopup = (el: HTMLElement): void => {\n  const rect = el.getBoundingClientRect();\n  const vw = window.innerWidth;\n  const vh = window.innerHeight;\n\n  if (rect.right > vw - MARGIN) {\n    el.style.left = `${parseFloat(el.style.left || '0') - (rect.right - (vw - MARGIN))}px`;\n  }\n  if (rect.bottom > vh - MARGIN) {\n    el.style.top = `${parseFloat(el.style.top || '0') - (rect.bottom - (vh - MARGIN))}px`;\n  }\n};\n\n// ---------------------------------------------------------------------------\n// hAlignTransform\n//\n// Returns the CSS transform string for a popup based on its horizontal alignment.\n// 'right' → shift left by full width so the popup's right edge sits at x.\n// 'left'  → no transform needed.\n// ---------------------------------------------------------------------------\nexport const hAlignTransform = (hAlign: HAlign): string => (hAlign === 'right' ? 'translateX(-100%)' : 'none');\n"],"names":["calcBelowPosition","rect","maxWidth","margin","clampLeft","left","width","overflow","calcSideStyle","el","gap","flipped","clampPopup","vw","vh","hAlignTransform","hAlign"],"mappings":"AAqCO,MAAMA,IAAoB,CAACC,GAAeC,IAAW,KAAKC,IAAS,MACpEF,EAAK,QAAQC,KAAYC,IACpB,EAAE,GAAGF,EAAK,OAAO,GAAGA,EAAK,QAAQ,QAAQ,QAAQ,IAEnD,EAAE,GAAG,KAAK,IAAIA,EAAK,MAAME,CAAM,GAAG,GAAGF,EAAK,QAAQ,QAAQ,OAAO,GAW7DG,IAAY,CAACC,GAAcC,GAAeH,IAAS,MAAmB;AAE3E,QAAAI,IADYF,IAAOC,KACK,OAAO,aAAaH;AAC3C,SAAAI,IAAW,IAAIF,IAAOE,IAAWF;AAC1C,GAkBaG,IAAgB,CAACC,GAAiBC,IAAM,MAAsB;AAOzE,MALGD,EAAA,MAAM,OAAO,eAAeC,CAAG,OAClCD,EAAG,MAAM,QAAQ,QAGJA,EAAG,sBAAsB,EAC7B,QAAQ,OAAO,aAAa,GAAQ;AAC3C,UAAME,IAAqB,EAAE,MAAM,QAAQ,OAAO,eAAeD,CAAG,MAAM;AACvE,WAAAD,EAAA,MAAM,OAAOE,EAAQ,MACrBF,EAAA,MAAM,QAAQE,EAAQ,OAClBA;AAAA,EAAA;AAET,SAAO,EAAE,MAAM,eAAeD,CAAG,OAAO,OAAO,OAAO;AACxD,GAYaE,IAAa,CAACH,MAA0B;AAC7C,QAAAR,IAAOQ,EAAG,sBAAsB,GAChCI,IAAK,OAAO,YACZC,IAAK,OAAO;AAEd,EAAAb,EAAK,QAAQY,IAAK,MACpBJ,EAAG,MAAM,OAAO,GAAG,WAAWA,EAAG,MAAM,QAAQ,GAAG,KAAKR,EAAK,SAASY,IAAK,GAAQ,OAEhFZ,EAAK,SAASa,IAAK,MACrBL,EAAG,MAAM,MAAM,GAAG,WAAWA,EAAG,MAAM,OAAO,GAAG,KAAKR,EAAK,UAAUa,IAAK,GAAQ;AAErF,GASaC,IAAkB,CAACC,MAA4BA,MAAW,UAAU,sBAAsB;"}

package/dist/lib/reference.d.ts

@@ -0,0 +1,19 @@
+import { CellsByIdType, Id } from '../types';
+import { Sheet } from './sheet';
+export declare class ReferencePreserver {
+    map: {
+        [id: Id]: Id;
+    };
+    private sheet;
+    private dependentIds;
+    constructor(sheet: Sheet);
+    collectDependents(...ids: Id[]): void;
+    /**
+     * Compare two idMatrix snapshots (`before` and `after`) and populate
+     * `this.map` and collect dependents for every position where the occupying
+     * cell ID changed. Works for any rearrangement (sort, move, etc.).
+     */
+    buildMap(before: Id[], after: Id[]): void;
+    resolveDependents(operation?: 'move' | 'removeRows' | 'removeCols'): CellsByIdType;
+}
+//# sourceMappingURL=reference.d.ts.map

package/dist/lib/reference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reference.d.ts","sourceRoot":"","sources":["../../src/lib/reference.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,qBAAa,kBAAkB;IACtB,GAAG,EAAE;QAAE,CAAC,EAAE,EAAE,EAAE,GAAG,EAAE,CAAA;KAAE,CAAM;IAClC,OAAO,CAAC,KAAK,CAAQ;IACrB,OAAO,CAAC,YAAY,CAA0B;gBAElC,KAAK,EAAE,KAAK;IAIxB,iBAAiB,CAAC,GAAG,GAAG,EAAE,EAAE,EAAE;IAQ9B;;;;OAIG;IACH,QAAQ,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE;IAWlC,iBAAiB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,YAAY,GAAG,YAAY,GAAG,aAAa;CAmBnF"}

package/dist/lib/reference.js

@@ -0,0 +1,40 @@
+class h {
+  constructor(t) {
+    this.map = {}, this.dependentIds = /* @__PURE__ */ new Set(), this.sheet = t;
+  }
+  collectDependents(...t) {
+    t.forEach((n) => {
+      var e, s;
+      (s = (e = this.sheet.registry.systems[n]) == null ? void 0 : e.dependents) == null || s.forEach((r) => {
+        this.dependentIds.add(r);
+      });
+    });
+  }
+  /**
+   * Compare two idMatrix snapshots (`before` and `after`) and populate
+   * `this.map` and collect dependents for every position where the occupying
+   * cell ID changed. Works for any rearrangement (sort, move, etc.).
+   */
+  buildMap(t, n) {
+    for (let e = 0; e < t.length; e++) {
+      const s = t[e], r = n[e];
+      s != null && r != null && s !== r && (this.collectDependents(s, r), this.map[s] = r);
+    }
+  }
+  resolveDependents(t) {
+    this.sheet.clearAddressCaches();
+    const n = {};
+    return this.dependentIds.forEach((e) => {
+      const s = this.sheet.registry.data[e];
+      s != null && (n[e] = { ...s }, this.sheet.clearDependencies(e), s.value = this.sheet.processFormula(s.value, {
+        dependency: e,
+        idMap: this.map,
+        operation: t
+      }));
+    }), n;
+  }
+}
+export {
+  h as ReferencePreserver
+};
+//# sourceMappingURL=reference.js.map

package/dist/lib/reference.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reference.js","sources":["../../src/lib/reference.ts"],"sourcesContent":["import { CellsByIdType, Id } from '../types';\nimport { Sheet } from './sheet';\n\nexport class ReferencePreserver {\n  public map: { [id: Id]: Id } = {};\n  private sheet: Sheet;\n  private dependentIds: Set<Id> = new Set<Id>();\n\n  constructor(sheet: Sheet) {\n    this.sheet = sheet;\n  }\n\n  collectDependents(...ids: Id[]) {\n    ids.forEach((id) => {\n      this.sheet.registry.systems[id]?.dependents?.forEach((did) => {\n        this.dependentIds.add(did);\n      });\n    });\n  }\n\n  /**\n   * Compare two idMatrix snapshots (`before` and `after`) and populate\n   * `this.map` and collect dependents for every position where the occupying\n   * cell ID changed. Works for any rearrangement (sort, move, etc.).\n   */\n  buildMap(before: Id[], after: Id[]) {\n    for (let i = 0; i < before.length; i++) {\n      const prevId = before[i];\n      const currId = after[i];\n      if (prevId != null && currId != null && prevId !== currId) {\n        this.collectDependents(prevId, currId);\n        this.map[prevId] = currId;\n      }\n    }\n  }\n\n  resolveDependents(operation?: 'move' | 'removeRows' | 'removeCols'): CellsByIdType {\n    this.sheet.clearAddressCaches();\n    const diffBefore: CellsByIdType = {};\n    this.dependentIds.forEach((id) => {\n      const dep = this.sheet.registry.data[id];\n      if (dep == null) {\n        return;\n      }\n      diffBefore[id] = { ...dep };\n      this.sheet.clearDependencies(id);\n      dep.value = this.sheet.processFormula(dep.value, {\n        dependency: id,\n        idMap: this.map,\n        operation,\n      });\n    });\n\n    return diffBefore;\n  }\n}\n"],"names":["ReferencePreserver","sheet","ids","id","_a","_b","did","before","after","i","prevId","currId","operation","diffBefore","dep"],"mappings":"AAGO,MAAMA,EAAmB;AAAA,EAK9B,YAAYC,GAAc;AAJ1B,SAAO,MAAwB,CAAC,GAExB,KAAA,mCAA4B,IAAQ,GAG1C,KAAK,QAAQA;AAAA,EAAA;AAAA,EAGf,qBAAqBC,GAAW;AAC1B,IAAAA,EAAA,QAAQ,CAACC,MAAO;AAVjB,UAAAC,GAAAC;AAWI,OAAAA,KAAAD,IAAA,KAAA,MAAM,SAAS,QAAQD,CAAE,MAAzB,gBAAAC,EAA4B,eAA5B,QAAAC,EAAwC,QAAQ,CAACC,MAAQ;AACvD,aAAA,aAAa,IAAIA,CAAG;AAAA,MAAA;AAAA,IAC1B,CACF;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQH,SAASC,GAAcC,GAAa;AAClC,aAASC,IAAI,GAAGA,IAAIF,EAAO,QAAQE,KAAK;AAChC,YAAAC,IAASH,EAAOE,CAAC,GACjBE,IAASH,EAAMC,CAAC;AACtB,MAAIC,KAAU,QAAQC,KAAU,QAAQD,MAAWC,MAC5C,KAAA,kBAAkBD,GAAQC,CAAM,GAChC,KAAA,IAAID,CAAM,IAAIC;AAAA,IACrB;AAAA,EACF;AAAA,EAGF,kBAAkBC,GAAiE;AACjF,SAAK,MAAM,mBAAmB;AAC9B,UAAMC,IAA4B,CAAC;AAC9B,gBAAA,aAAa,QAAQ,CAACV,MAAO;AAChC,YAAMW,IAAM,KAAK,MAAM,SAAS,KAAKX,CAAE;AACvC,MAAIW,KAAO,SAGXD,EAAWV,CAAE,IAAI,EAAE,GAAGW,EAAI,GACrB,KAAA,MAAM,kBAAkBX,CAAE,GAC/BW,EAAI,QAAQ,KAAK,MAAM,eAAeA,EAAI,OAAO;AAAA,QAC/C,YAAYX;AAAA,QACZ,OAAO,KAAK;AAAA,QACZ,WAAAS;AAAA,MAAA,CACD;AAAA,IAAA,CACF,GAEMC;AAAA,EAAA;AAEX;"}