@gridsheet/react-core 1.4.0-alpha.2 → 1.4.0-alpha.3

package/dist/lib/input.js

@@ -0,0 +1,52 @@
+import { Lexer } from "../formula/evaluator.js";
+const insertTextAtCursor = (input, text) => {
+  var _a;
+  input.focus();
+  const deprecated = !((_a = document.execCommand) == null ? void 0 : _a.call(document, "insertText", false, text));
+  if (!deprecated) {
+    return;
+  }
+  input.setRangeText(text, input.selectionStart, input.selectionEnd, "end");
+  return;
+};
+const insertRef = (input, ref, dryRun = false) => {
+  var _a;
+  if (!((_a = input == null ? void 0 : input.value) == null ? void 0 : _a.startsWith("=")) || input.selectionStart === 0) {
+    return false;
+  }
+  const lexer = new Lexer(input.value.substring(1));
+  lexer.tokenize();
+  const tokenIndex = lexer.getTokenIndexByCharPosition(input.selectionStart - 1);
+  let token = lexer.tokens[tokenIndex];
+  if ((token == null ? void 0 : token.type) === "SPACE") {
+    token = lexer.tokens[tokenIndex - 1];
+  }
+  if (token == null || token.type === "OPEN" || token.type === "COMMA" || token.type === "INFIX_OPERATOR" || token.type === "PREFIX_OPERATOR") {
+    if (!dryRun) {
+      insertTextAtCursor(input, ref);
+    }
+  } else if (token.type === "REF" || token.type === "RANGE") {
+    if (!dryRun) {
+      const [start, end] = lexer.getTokenPositionRange(tokenIndex + 1, 1);
+      input.setSelectionRange(start, end);
+      insertTextAtCursor(input, ref);
+    }
+  } else {
+    return false;
+  }
+  return true;
+};
+const isRefInsertable = (input) => {
+  return insertRef(input, "", true);
+};
+const expandInput = (input) => {
+  input.style.width = `${input.scrollWidth}px`;
+  input.style.height = `${input.scrollHeight}px`;
+};
+export {
+  expandInput,
+  insertRef,
+  insertTextAtCursor,
+  isRefInsertable
+};
+//# sourceMappingURL=input.js.map

package/dist/lib/input.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"input.js","sources":["../../lib/input.ts"],"sourcesContent":["import { Lexer } from '../formula/evaluator';\n\nexport const insertTextAtCursor = (input: HTMLTextAreaElement, text: string) => {\n  input.focus();\n  const deprecated = !document.execCommand?.('insertText', false, text);\n  if (!deprecated) {\n    return;\n  }\n  input.setRangeText(text, input.selectionStart, input.selectionEnd, 'end');\n  return;\n};\n\nexport const insertRef = (input: HTMLTextAreaElement | null, ref: string, dryRun = false): boolean => {\n  // dryRun is used to check if the ref can be inserted without actually inserting it\n  if (!input?.value?.startsWith('=') || input.selectionStart === 0) {\n    return false;\n  }\n  const lexer = new Lexer(input.value.substring(1));\n  lexer.tokenize();\n  const tokenIndex = lexer.getTokenIndexByCharPosition(input.selectionStart - 1);\n  let token = lexer.tokens[tokenIndex];\n  if (token?.type === 'SPACE') {\n    token = lexer.tokens[tokenIndex - 1];\n  }\n  if (\n    token == null ||\n    token.type === 'OPEN' ||\n    token.type === 'COMMA' ||\n    token.type === 'INFIX_OPERATOR' ||\n    token.type === 'PREFIX_OPERATOR'\n  ) {\n    if (!dryRun) {\n      insertTextAtCursor(input, ref);\n    }\n  } else if (token.type === 'REF' || token.type === 'RANGE') {\n    if (!dryRun) {\n      const [start, end] = lexer.getTokenPositionRange(tokenIndex + 1, 1);\n      input.setSelectionRange(start, end);\n      insertTextAtCursor(input, ref);\n    }\n  } else {\n    return false;\n  }\n  return true;\n};\n\nexport const isRefInsertable = (input: HTMLTextAreaElement | null): boolean => {\n  return insertRef(input, '', true);\n};\n\nexport const expandInput = (input: HTMLTextAreaElement) => {\n  input.style.width = `${input.scrollWidth}px`;\n  input.style.height = `${input.scrollHeight}px`;\n};\n"],"names":[],"mappings":";AAEa,MAAA,qBAAqB,CAAC,OAA4B,SAAiB;;AAC9E,QAAM,MAAM;AACZ,QAAM,aAAa,GAAC,cAAS,gBAAT,kCAAuB,cAAc,OAAO;AAChE,MAAI,CAAC,YAAY;AACf;AAAA,EAAA;AAEF,QAAM,aAAa,MAAM,MAAM,gBAAgB,MAAM,cAAc,KAAK;AACxE;AACF;AAEO,MAAM,YAAY,CAAC,OAAmC,KAAa,SAAS,UAAmB;;AAEhG,MAAA,GAAC,oCAAO,UAAP,mBAAc,WAAW,SAAQ,MAAM,mBAAmB,GAAG;AACzD,WAAA;AAAA,EAAA;AAET,QAAM,QAAQ,IAAI,MAAM,MAAM,MAAM,UAAU,CAAC,CAAC;AAChD,QAAM,SAAS;AACf,QAAM,aAAa,MAAM,4BAA4B,MAAM,iBAAiB,CAAC;AACzE,MAAA,QAAQ,MAAM,OAAO,UAAU;AAC/B,OAAA,+BAAO,UAAS,SAAS;AACnB,YAAA,MAAM,OAAO,aAAa,CAAC;AAAA,EAAA;AAErC,MACE,SAAS,QACT,MAAM,SAAS,UACf,MAAM,SAAS,WACf,MAAM,SAAS,oBACf,MAAM,SAAS,mBACf;AACA,QAAI,CAAC,QAAQ;AACX,yBAAmB,OAAO,GAAG;AAAA,IAAA;AAAA,EAC/B,WACS,MAAM,SAAS,SAAS,MAAM,SAAS,SAAS;AACzD,QAAI,CAAC,QAAQ;AACL,YAAA,CAAC,OAAO,GAAG,IAAI,MAAM,sBAAsB,aAAa,GAAG,CAAC;AAC5D,YAAA,kBAAkB,OAAO,GAAG;AAClC,yBAAmB,OAAO,GAAG;AAAA,IAAA;AAAA,EAC/B,OACK;AACE,WAAA;AAAA,EAAA;AAEF,SAAA;AACT;AAEa,MAAA,kBAAkB,CAAC,UAA+C;AACtE,SAAA,UAAU,OAAO,IAAI,IAAI;AAClC;AAEa,MAAA,cAAc,CAAC,UAA+B;AACzD,QAAM,MAAM,QAAQ,GAAG,MAAM,WAAW;AACxC,QAAM,MAAM,SAAS,GAAG,MAAM,YAAY;AAC5C;"}

package/dist/lib/palette.js

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

package/dist/lib/palette.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"palette.js","sources":["../../lib/palette.ts"],"sourcesContent":["export const REF_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];\n"],"names":[],"mappings":"AAAO,MAAM,cAAc;AAAA;AAAA,EAEzB;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/prevention.js

@@ -0,0 +1,82 @@
+const DeleteRow = 1, DeleteCol = 2, AddRowAbove = 4, AddRowBelow = 8, AddColLeft = 16, AddColRight = 32, MoveFrom = 64, MoveTo = 128, Write = 256, Style = 512, Resize = 1024, SetRenderer = 2048, SetParser = 4096;
+const Move = MoveFrom | MoveTo;
+const Update = Write | Style | Resize | SetRenderer | SetParser;
+const AddRow = AddRowAbove | AddRowBelow;
+const AddCol = AddColLeft | AddColRight;
+const Add = AddRow | AddCol;
+const Delete = DeleteRow | DeleteCol;
+const ReadOnly = Update | Delete | Add | Move;
+const isPrevented = (prevention, flag) => {
+  if (prevention === void 0) {
+    return false;
+  }
+  return (prevention & flag) === flag;
+};
+const debugOperations = (prevention) => {
+  const preventions = [];
+  if (isPrevented(prevention, DeleteRow)) {
+    preventions.push("DeleteRow");
+  }
+  if (isPrevented(prevention, DeleteCol)) {
+    preventions.push("DeleteCol");
+  }
+  if (isPrevented(prevention, AddRowAbove)) {
+    preventions.push("AddRowAbove");
+  }
+  if (isPrevented(prevention, AddRowBelow)) {
+    preventions.push("AddRowBelow");
+  }
+  if (isPrevented(prevention, AddColLeft)) {
+    preventions.push("AddColLeft");
+  }
+  if (isPrevented(prevention, AddColRight)) {
+    preventions.push("AddColRight");
+  }
+  if (isPrevented(prevention, MoveFrom)) {
+    preventions.push("MoveFrom");
+  }
+  if (isPrevented(prevention, MoveTo)) {
+    preventions.push("MoveTo");
+  }
+  if (isPrevented(prevention, Write)) {
+    preventions.push("Write");
+  }
+  if (isPrevented(prevention, Style)) {
+    preventions.push("Style");
+  }
+  if (isPrevented(prevention, Resize)) {
+    preventions.push("Resize");
+  }
+  if (isPrevented(prevention, SetRenderer)) {
+    preventions.push("SetRenderer");
+  }
+  if (isPrevented(prevention, SetParser)) {
+    preventions.push("SetParser");
+  }
+  return preventions;
+};
+export {
+  Add,
+  AddCol,
+  AddColLeft,
+  AddColRight,
+  AddRow,
+  AddRowAbove,
+  AddRowBelow,
+  Delete,
+  DeleteCol,
+  DeleteRow,
+  Move,
+  MoveFrom,
+  MoveTo,
+  ReadOnly,
+  Resize,
+  SetParser,
+  SetRenderer,
+  Style,
+  Update,
+  Write,
+  debugOperations,
+  isPrevented
+};
+//# sourceMappingURL=prevention.js.map

package/dist/lib/prevention.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prevention.js","sources":["../../lib/prevention.ts"],"sourcesContent":["import { Prevention } from '../types';\n\nexport const DeleteRow: Prevention = 0b00000000000000000000000000000000000000000000000000001, // 1\n  DeleteCol: Prevention = 0b00000000000000000000000000000000000000000000000000010, // 2\n  AddRowAbove: Prevention = 0b00000000000000000000000000000000000000000000000000100, // 4\n  AddRowBelow: Prevention = 0b00000000000000000000000000000000000000000000000001000, // 8\n  AddColLeft: Prevention = 0b00000000000000000000000000000000000000000000000010000, // 16\n  AddColRight: Prevention = 0b00000000000000000000000000000000000000000000000100000, // 32\n  MoveFrom: Prevention = 0b00000000000000000000000000000000000000000000001000000, // 64\n  MoveTo: Prevention = 0b00000000000000000000000000000000000000000000010000000, // 128\n  Write: Prevention = 0b00000000000000000000000000000000000000000000100000000, // 256\n  Style: Prevention = 0b00000000000000000000000000000000000000000001000000000, // 512\n  Resize: Prevention = 0b00000000000000000000000000000000000000000010000000000, // 1024\n  SetRenderer: Prevention = 0b00000000000000000000000000000000000000000100000000000, // 2048\n  SetParser: Prevention = 0b00000000000000000000000000000000000000001000000000000; // 4096\n\nexport const Move: Prevention = MoveFrom | MoveTo; // 192\n\nexport const Update: Prevention = Write | Style | Resize | SetRenderer | SetParser; // 1792\n\nexport const AddRow: Prevention = AddRowAbove | AddRowBelow; // 12\n\nexport const AddCol: Prevention = AddColLeft | AddColRight; // 48\n\nexport const Add: Prevention = AddRow | AddCol; // 60\n\nexport const Delete: Prevention = DeleteRow | DeleteCol; // 3\n\nexport const ReadOnly: Prevention = Update | Delete | Add | Move; //\n\nexport const isPrevented = (prevention: Prevention | undefined, flag: Prevention) => {\n  if (prevention === undefined) {\n    return false;\n  }\n  return (prevention & flag) === flag;\n};\n\n// Don't use this function in production\nexport const debugOperations = (prevention: Prevention | undefined) => {\n  const preventions: string[] = [];\n  if (isPrevented(prevention, DeleteRow)) {\n    preventions.push('DeleteRow');\n  }\n  if (isPrevented(prevention, DeleteCol)) {\n    preventions.push('DeleteCol');\n  }\n  if (isPrevented(prevention, AddRowAbove)) {\n    preventions.push('AddRowAbove');\n  }\n  if (isPrevented(prevention, AddRowBelow)) {\n    preventions.push('AddRowBelow');\n  }\n  if (isPrevented(prevention, AddColLeft)) {\n    preventions.push('AddColLeft');\n  }\n  if (isPrevented(prevention, AddColRight)) {\n    preventions.push('AddColRight');\n  }\n  if (isPrevented(prevention, MoveFrom)) {\n    preventions.push('MoveFrom');\n  }\n  if (isPrevented(prevention, MoveTo)) {\n    preventions.push('MoveTo');\n  }\n  if (isPrevented(prevention, Write)) {\n    preventions.push('Write');\n  }\n  if (isPrevented(prevention, Style)) {\n    preventions.push('Style');\n  }\n  if (isPrevented(prevention, Resize)) {\n    preventions.push('Resize');\n  }\n  if (isPrevented(prevention, SetRenderer)) {\n    preventions.push('SetRenderer');\n  }\n  if (isPrevented(prevention, SetParser)) {\n    preventions.push('SetParser');\n  }\n  return preventions;\n};\n"],"names":[],"mappings":"AAEa,MAAA,YAAwB,GACnC,YAAwB,GACxB,cAA0B,GAC1B,cAA0B,GAC1B,aAAyB,IACzB,cAA0B,IAC1B,WAAuB,IACvB,SAAqB,KACrB,QAAoB,KACpB,QAAoB,KACpB,SAAqB,MACrB,cAA0B,MAC1B,YAAwB;AAEnB,MAAM,OAAmB,WAAW;AAEpC,MAAM,SAAqB,QAAQ,QAAQ,SAAS,cAAc;AAElE,MAAM,SAAqB,cAAc;AAEzC,MAAM,SAAqB,aAAa;AAExC,MAAM,MAAkB,SAAS;AAEjC,MAAM,SAAqB,YAAY;AAEjC,MAAA,WAAuB,SAAS,SAAS,MAAM;AAE/C,MAAA,cAAc,CAAC,YAAoC,SAAqB;AACnF,MAAI,eAAe,QAAW;AACrB,WAAA;AAAA,EAAA;AAET,UAAQ,aAAa,UAAU;AACjC;AAGa,MAAA,kBAAkB,CAAC,eAAuC;AACrE,QAAM,cAAwB,CAAC;AAC3B,MAAA,YAAY,YAAY,SAAS,GAAG;AACtC,gBAAY,KAAK,WAAW;AAAA,EAAA;AAE1B,MAAA,YAAY,YAAY,SAAS,GAAG;AACtC,gBAAY,KAAK,WAAW;AAAA,EAAA;AAE1B,MAAA,YAAY,YAAY,WAAW,GAAG;AACxC,gBAAY,KAAK,aAAa;AAAA,EAAA;AAE5B,MAAA,YAAY,YAAY,WAAW,GAAG;AACxC,gBAAY,KAAK,aAAa;AAAA,EAAA;AAE5B,MAAA,YAAY,YAAY,UAAU,GAAG;AACvC,gBAAY,KAAK,YAAY;AAAA,EAAA;AAE3B,MAAA,YAAY,YAAY,WAAW,GAAG;AACxC,gBAAY,KAAK,aAAa;AAAA,EAAA;AAE5B,MAAA,YAAY,YAAY,QAAQ,GAAG;AACrC,gBAAY,KAAK,UAAU;AAAA,EAAA;AAEzB,MAAA,YAAY,YAAY,MAAM,GAAG;AACnC,gBAAY,KAAK,QAAQ;AAAA,EAAA;AAEvB,MAAA,YAAY,YAAY,KAAK,GAAG;AAClC,gBAAY,KAAK,OAAO;AAAA,EAAA;AAEtB,MAAA,YAAY,YAAY,KAAK,GAAG;AAClC,gBAAY,KAAK,OAAO;AAAA,EAAA;AAEtB,MAAA,YAAY,YAAY,MAAM,GAAG;AACnC,gBAAY,KAAK,QAAQ;AAAA,EAAA;AAEvB,MAAA,YAAY,YAAY,WAAW,GAAG;AACxC,gBAAY,KAAK,aAAa;AAAA,EAAA;AAE5B,MAAA,YAAY,YAAY,SAAS,GAAG;AACtC,gBAAY,KAAK,WAAW;AAAA,EAAA;AAEvB,SAAA;AACT;"}

package/dist/lib/structs.js

@@ -0,0 +1,276 @@
+import { a2p, c2x, x2c, p2a } from "./converters.js";
+const superposeArea = (srcArea, dstArea) => {
+  const { height: srcHeight, width: srcWidth } = areaShape(srcArea);
+  const { height: dstHeight, width: dstWidth } = areaShape(dstArea);
+  return {
+    height: srcHeight > dstHeight ? srcHeight : dstHeight,
+    width: srcWidth > dstWidth ? srcWidth : dstWidth
+  };
+};
+const concatAreas = (area1, area2) => {
+  const result = { ...area1 };
+  if (area2.left < area1.left) {
+    result.left = area2.left;
+  }
+  if (area2.right > area1.right) {
+    result.right = area2.right;
+  }
+  if (area2.top < area1.top) {
+    result.top = area2.top;
+  }
+  if (area2.bottom > area1.bottom) {
+    result.bottom = area2.bottom;
+  }
+  return result;
+};
+const zoneToArea = (zone) => {
+  if (zone.endY === -1 || zone.endX === -1) {
+    return { top: -1, left: -1, bottom: -1, right: -1 };
+  }
+  const [top, bottom] = zone.startY < zone.endY ? [zone.startY, zone.endY] : [zone.endY, zone.startY];
+  const [left, right] = zone.startX < zone.endX ? [zone.startX, zone.endX] : [zone.endX, zone.startX];
+  return { top, left, bottom, right };
+};
+const areaToZone = (area) => {
+  return {
+    startY: area.top,
+    startX: area.left,
+    endY: area.bottom,
+    endX: area.right
+  };
+};
+const areaToRange = (area) => {
+  const { top, left, bottom, right } = area;
+  return `${p2a({ y: top, x: left })}:${p2a({
+    y: bottom,
+    x: right
+  })}`;
+};
+const between = (range2, index) => {
+  if (range2.start === -1 || range2.end === -1) {
+    return false;
+  }
+  return range2.start <= index && index <= range2.end || range2.end <= index && index <= range2.start;
+};
+const among = (area, point) => {
+  if (area.top === -1 || area.left === -1 || area.bottom === -1 || area.right === -1) {
+    return false;
+  }
+  const { y, x } = point;
+  const { top, left, bottom, right } = area;
+  return top <= y && y <= bottom && left <= x && x <= right;
+};
+const zoneShape = ({ base = 0, ...zone }) => {
+  return {
+    height: base + Math.abs(zone.startY - zone.endY),
+    width: base + Math.abs(zone.startX - zone.endX)
+  };
+};
+const areaShape = ({ base = 0, ...area }) => {
+  return {
+    height: base + Math.abs(area.top - area.bottom),
+    width: base + Math.abs(area.left - area.right)
+  };
+};
+const matrixShape = ({ base = 0, matrix }) => {
+  const h = matrix.length;
+  if (h === 0) {
+    return { height: 0, width: 0 };
+  }
+  return { height: base + h, width: base + matrix[0].length };
+};
+const makeSequence = (start, stop, step = 1) => {
+  return Array.from({ length: (stop - start - 1) / step + 1 }, (_, i) => start + i * step);
+};
+const oa2aa = (oa, fields) => {
+  const aa = [];
+  oa.forEach((o) => {
+    const a = [];
+    fields.forEach((field) => {
+      a.push(o[field]);
+    });
+    aa.push(a);
+  });
+  return aa;
+};
+const aa2oa = (aa, fields) => {
+  const oa = [];
+  aa.forEach((a) => {
+    const o = {};
+    a.forEach((v, i) => {
+      if (i >= fields.length) {
+        return;
+      }
+      const field = fields[i];
+      o[field] = v;
+    });
+    oa.push(o);
+  });
+  return oa;
+};
+const putMatrix = (dst, src, dstArea, filter = () => true) => {
+  const lostRows = {};
+  const { top, left, bottom, right } = dstArea;
+  const { height: dstNumRows, width: dstNumCols } = matrixShape({
+    matrix: dst,
+    base: 1
+  });
+  for (let y = top; y <= bottom; y++) {
+    const lostRow = [];
+    for (let x = left; x <= right; x++) {
+      const value = src[y - top][x - left];
+      if (y < dstNumRows - 1 && x < dstNumCols - 1) {
+        if (filter(value, dst[y][x])) {
+          dst[y][x] = value;
+        }
+        continue;
+      }
+      if (lostRow.length === 0) {
+        lostRows[p2a({ y, x })] = [lostRow];
+      }
+      lostRow.push(value);
+    }
+  }
+  return lostRows;
+};
+const createMatrix = (numRows, numCols, fill) => {
+  return [...Array(numRows)].map(() => Array(numCols).fill(fill));
+};
+const constructInitialCellsOrigin = ({
+  cells = {},
+  ensured = {},
+  matrix = [],
+  flattenAs = "value"
+}) => {
+  return constructInitialCells({
+    cells,
+    ensured,
+    matrices: { A1: matrix },
+    flattenAs
+  });
+};
+const constructInitialCells = ({
+  cells = {},
+  ensured = {},
+  matrices = {},
+  flattenAs = "value"
+} = {}) => {
+  upsert({ cells, flattenAs, matrices });
+  const { numRows, numCols } = Object.assign({ numRows: 1, numCols: 1 }, ensured);
+  const rightBottom = p2a({ y: numRows, x: numCols });
+  if (cells[rightBottom] == null) {
+    cells[rightBottom] = {};
+  }
+  return cells;
+};
+const upsert = ({
+  cells = {},
+  matrices = {},
+  flattenAs
+}) => {
+  Object.keys(matrices).forEach((baseAddress) => {
+    const matrix = matrices[baseAddress];
+    const { y: baseY, x: baseX } = a2p(baseAddress);
+    matrix.forEach((row, y) => {
+      row.forEach((e, x) => {
+        const id = p2a({ y: baseY + y, x: baseX + x });
+        if (flattenAs) {
+          const cell = cells[id];
+          cells[id] = { [flattenAs]: e, ...cell };
+        } else {
+          cells[id] = e;
+        }
+      });
+    });
+  });
+  return cells;
+};
+const getMaxSizesFromCells = (cells = {}) => {
+  let [lastY, lastX] = [0, 0];
+  Object.keys(cells).map((address) => {
+    const { y, x } = a2p(address);
+    if (lastY < y) {
+      lastY = y;
+    }
+    if (lastX < x) {
+      lastX = x;
+    }
+  });
+  return { numRows: lastY, numCols: lastX };
+};
+const range = (start, end) => {
+  const list = [];
+  for (let i = start; i <= end; i++) {
+    list.push(i);
+  }
+  return list;
+};
+const complementSelectingArea = (selectingArea, choosing) => {
+  if (selectingArea.left === -1) {
+    selectingArea = {
+      left: choosing.x,
+      top: choosing.y,
+      right: choosing.x,
+      bottom: choosing.y
+    };
+  }
+  return selectingArea;
+};
+const expandRange = (range2) => {
+  if (range2.indexOf(":") === -1) {
+    return [range2];
+  }
+  const result = [];
+  const isRowRange = /^\d+\:\d+$/.test(range2);
+  if (isRowRange) {
+    const [startRow2, endRow2] = range2.split(":").map(Number);
+    for (let row = startRow2; row <= endRow2; row++) {
+      result.push(`${row}`);
+    }
+    return result;
+  }
+  const match = range2.match(/^([A-Z]*)(\d+)?\:([A-Z]*)(\d+)?$/);
+  if (!match) {
+    console.error("Invalid range format", range2);
+    return [range2];
+  }
+  const [, startCol, startRow, endCol, endRow] = match;
+  const startColIndex = startCol ? c2x(startCol) : 1;
+  const endColIndex = endCol ? c2x(endCol) : 1;
+  for (let col = startColIndex; col <= endColIndex; col++) {
+    const currentColumn = startCol || endCol ? x2c(col) : "";
+    if (startRow && endRow) {
+      for (let row = Number(startRow); row <= Number(endRow); row++) {
+        result.push(`${currentColumn}${row}`);
+      }
+    } else if (!startRow && !endRow) {
+      result.push(currentColumn);
+    }
+  }
+  return result;
+};
+export {
+  aa2oa,
+  among,
+  areaShape,
+  areaToRange,
+  areaToZone,
+  between,
+  complementSelectingArea,
+  concatAreas,
+  constructInitialCells,
+  constructInitialCellsOrigin,
+  createMatrix,
+  expandRange,
+  getMaxSizesFromCells,
+  makeSequence,
+  matrixShape,
+  oa2aa,
+  putMatrix,
+  range,
+  superposeArea,
+  upsert,
+  zoneShape,
+  zoneToArea
+};
+//# sourceMappingURL=structs.js.map

package/dist/lib/structs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"structs.js","sources":["../../lib/structs.ts"],"sourcesContent":["import type {\n  MatrixType,\n  AreaType,\n  ZoneType,\n  RangeType,\n  PointType,\n  Y,\n  X,\n  CellsByAddressType,\n  ShapeType,\n  MatricesByAddress,\n  CellType,\n  Address,\n} from '../types';\nimport { a2p, p2a, x2c, c2x } from './converters';\n\nexport const slideArea = (area: AreaType, y: Y, x: X): AreaType => {\n  const { top, left, bottom, right } = area;\n  return { top: top + y, left: left + x, bottom: bottom + y, right: right + x };\n};\n\nexport const superposeArea = (srcArea: AreaType, dstArea: AreaType): ShapeType => {\n  const { height: srcHeight, width: srcWidth } = areaShape(srcArea);\n  const { height: dstHeight, width: dstWidth } = areaShape(dstArea);\n\n  // biggerHeight, biggerWidth\n  return {\n    height: srcHeight > dstHeight ? srcHeight : dstHeight,\n    width: srcWidth > dstWidth ? srcWidth : dstWidth,\n  };\n};\n\nexport const concatAreas = (area1: AreaType, area2: AreaType): AreaType => {\n  const result: AreaType = { ...area1 };\n  if (area2.left < area1.left) {\n    result.left = area2.left;\n  }\n  if (area2.right > area1.right) {\n    result.right = area2.right;\n  }\n  if (area2.top < area1.top) {\n    result.top = area2.top;\n  }\n  if (area2.bottom > area1.bottom) {\n    result.bottom = area2.bottom;\n  }\n  return result;\n};\n\nexport const zoneToArea = (zone: ZoneType): AreaType => {\n  if (zone.endY === -1 || zone.endX === -1) {\n    return { top: -1, left: -1, bottom: -1, right: -1 };\n  }\n  const [top, bottom] = zone.startY < zone.endY ? [zone.startY, zone.endY] : [zone.endY, zone.startY];\n  const [left, right] = zone.startX < zone.endX ? [zone.startX, zone.endX] : [zone.endX, zone.startX];\n  return { top, left, bottom, right };\n};\n\nexport const areaToZone = (area: AreaType): ZoneType => {\n  return {\n    startY: area.top,\n    startX: area.left,\n    endY: area.bottom,\n    endX: area.right,\n  };\n};\n\nexport const areaToRange = (area: AreaType): string => {\n  const { top, left, bottom, right } = area;\n  return `${p2a({ y: top, x: left })}:${p2a({\n    y: bottom,\n    x: right,\n  })}`;\n};\n\nexport const between = (range: RangeType, index: number) => {\n  if (range.start === -1 || range.end === -1) {\n    return false;\n  }\n  return (range.start <= index && index <= range.end) || (range.end <= index && index <= range.start);\n};\n\nexport const among = (area: AreaType, point: PointType) => {\n  if (area.top === -1 || area.left === -1 || area.bottom === -1 || area.right === -1) {\n    return false;\n  }\n  const { y, x } = point;\n  const { top, left, bottom, right } = area;\n  return top <= y && y <= bottom && left <= x && x <= right;\n};\n\ntype ShapeExtension = { base?: number };\n\nexport const zoneShape = ({ base = 0, ...zone }: ZoneType & ShapeExtension): ShapeType => {\n  return {\n    height: base + Math.abs(zone.startY - zone.endY),\n    width: base + Math.abs(zone.startX - zone.endX),\n  };\n};\n\nexport const areaShape = ({ base = 0, ...area }: AreaType & ShapeExtension): ShapeType => {\n  return {\n    height: base + Math.abs(area.top - area.bottom),\n    width: base + Math.abs(area.left - area.right),\n  };\n};\n\nexport const matrixShape = ({ base = 0, matrix }: { matrix: MatrixType } & ShapeExtension): ShapeType => {\n  const h = matrix.length;\n  if (h === 0) {\n    return { height: 0, width: 0 };\n  }\n  return { height: base + h, width: base + matrix[0].length };\n};\n\nexport const makeSequence = (start: number, stop: number, step: number = 1) => {\n  return Array.from({ length: (stop - start - 1) / step + 1 }, (_, i) => start + i * step);\n};\n\nexport const oa2aa = (oa: { [s: string]: any }[], fields: string[]): MatrixType => {\n  const aa: any[][] = [];\n  oa.forEach((o) => {\n    const a: any[] = [];\n    fields.forEach((field) => {\n      a.push(o[field]);\n    });\n    aa.push(a);\n  });\n  return aa;\n};\n\nexport const aa2oa = (aa: MatrixType, fields: string[]): { [s: string]: any }[] => {\n  const oa: { [s: string]: any }[] = [];\n  aa.forEach((a) => {\n    const o: { [s: string]: any } = {};\n    a.forEach((v, i) => {\n      if (i >= fields.length) {\n        return;\n      }\n      const field = fields[i];\n      o[field] = v;\n    });\n    oa.push(o);\n  });\n  return oa;\n};\n\nexport const putMatrix = <T = any>(\n  dst: T[][],\n  src: T[][],\n  dstArea: AreaType,\n  filter: (newValue: T, currentValue: T) => boolean = () => true,\n) => {\n  const lostRows: MatricesByAddress<T> = {};\n  const { top, left, bottom, right } = dstArea;\n  const { height: dstNumRows, width: dstNumCols } = matrixShape({\n    matrix: dst,\n    base: 1,\n  });\n  for (let y = top; y <= bottom; y++) {\n    const lostRow: T[] = [];\n    for (let x = left; x <= right; x++) {\n      const value = src[y - top][x - left];\n      // -1 means excluding headers\n      if (y < dstNumRows - 1 && x < dstNumCols - 1) {\n        if (filter(value, dst[y][x])) {\n          dst[y][x] = value;\n        }\n        continue;\n      }\n      if (lostRow.length === 0) {\n        lostRows[p2a({ y, x })] = [lostRow];\n      }\n      lostRow.push(value);\n    }\n  }\n  return lostRows;\n};\n\nexport const createMatrix = <T = any>(numRows: number, numCols: number, fill?: T): T[][] => {\n  return [...Array(numRows)].map(() => Array(numCols).fill(fill));\n};\n\nexport const cropMatrix = <T = any>(matrix: T[][], area: AreaType): T[][] => {\n  const { top, left, bottom, right } = area;\n  return matrix.slice(top, bottom + 1).map((cols) => cols.slice(left, right + 1));\n};\n\nexport const constructInitialCellsOrigin = ({\n  cells = {},\n  ensured = {},\n  matrix = [],\n  flattenAs = 'value',\n}: {\n  cells?: CellsByAddressType;\n  ensured?: {\n    numRows?: number;\n    numCols?: number;\n  };\n  flattenAs?: keyof CellType;\n  matrix?: MatrixType;\n}) => {\n  return constructInitialCells({\n    cells,\n    ensured,\n    matrices: { A1: matrix },\n    flattenAs,\n  });\n};\n\nexport const constructInitialCells = ({\n  cells = {},\n  ensured = {},\n  matrices = {},\n  flattenAs = 'value',\n}: {\n  cells?: CellsByAddressType;\n  ensured?: {\n    numRows?: number;\n    numCols?: number;\n  };\n  flattenAs?: keyof CellType;\n  matrices?: MatricesByAddress<any>;\n} = {}) => {\n  upsert({ cells, flattenAs, matrices });\n  const { numRows, numCols } = Object.assign({ numRows: 1, numCols: 1 }, ensured);\n  const rightBottom = p2a({ y: numRows, x: numCols });\n  if (cells[rightBottom] == null) {\n    cells[rightBottom] = {};\n  }\n  return cells;\n};\n\nexport const upsert = <T>({\n  cells = {},\n  matrices = {},\n  flattenAs,\n}: {\n  cells?: CellsByAddressType;\n  flattenAs?: keyof CellType;\n  matrices?: MatricesByAddress<T>;\n}) => {\n  Object.keys(matrices).forEach((baseAddress) => {\n    const matrix = matrices[baseAddress];\n    const { y: baseY, x: baseX } = a2p(baseAddress);\n    matrix.forEach((row, y) => {\n      row.forEach((e, x) => {\n        const id = p2a({ y: baseY + y, x: baseX + x });\n        if (flattenAs) {\n          const cell = cells[id];\n          cells[id] = { [flattenAs]: e, ...cell };\n        } else {\n          cells[id] = e as CellType;\n        }\n      });\n    });\n  });\n  return cells;\n};\n\nexport const getMaxSizesFromCells = (cells: CellsByAddressType = {}) => {\n  let [lastY, lastX] = [0, 0];\n  Object.keys(cells).map((address) => {\n    const { y, x } = a2p(address);\n    if (lastY < y) {\n      lastY = y;\n    }\n    if (lastX < x) {\n      lastX = x;\n    }\n  });\n  return { numRows: lastY, numCols: lastX };\n};\n\nexport const range = (start: number, end: number) => {\n  const list: number[] = [];\n  for (let i = start; i <= end; i++) {\n    list.push(i);\n  }\n  return list;\n};\n\nexport const complementSelectingArea = (selectingArea: AreaType, choosing: PointType) => {\n  if (selectingArea.left === -1) {\n    selectingArea = {\n      left: choosing.x,\n      top: choosing.y,\n      right: choosing.x,\n      bottom: choosing.y,\n    };\n  }\n  return selectingArea;\n};\n\nexport const isSameArea = (area1: AreaType, area2: AreaType) => {\n  if (area1.top !== area2.top) {\n    return false;\n  }\n  if (area1.left !== area2.left) {\n    return false;\n  }\n  if (area1.bottom !== area2.bottom) {\n    return false;\n  }\n  if (area1.right !== area2.right) {\n    return false;\n  }\n  return true;\n};\n\nexport const expandRange = (range: string): Address[] => {\n  if (range.indexOf(':') === -1) {\n    return [range];\n  }\n\n  const result: Address[] = [];\n\n  const isRowRange = /^\\d+\\:\\d+$/.test(range);\n\n  if (isRowRange) {\n    const [startRow, endRow] = range.split(':').map(Number);\n    for (let row = startRow; row <= endRow; row++) {\n      result.push(`${row}`);\n    }\n    return result;\n  }\n\n  const match = range.match(/^([A-Z]*)(\\d+)?\\:([A-Z]*)(\\d+)?$/);\n  if (!match) {\n    console.error('Invalid range format', range);\n    return [range];\n  }\n\n  const [, startCol, startRow, endCol, endRow] = match;\n  const startColIndex = startCol ? c2x(startCol) : 1;\n  const endColIndex = endCol ? c2x(endCol) : 1;\n\n  for (let col = startColIndex; col <= endColIndex; col++) {\n    const currentColumn = startCol || endCol ? x2c(col) : '';\n    if (startRow && endRow) {\n      for (let row = Number(startRow); row <= Number(endRow); row++) {\n        result.push(`${currentColumn}${row}`);\n      }\n    } else if (!startRow && !endRow) {\n      result.push(currentColumn);\n    }\n  }\n  return result;\n};\n"],"names":["range","startRow","endRow"],"mappings":"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"}