@ricsam/formula-engine 0.0.1

package/dist/cjs/core/managers/range-eval-order-builder.cjs

@@ -0,0 +1,644 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/core/managers/range-eval-order-builder.ts
+var exports_range_eval_order_builder = {};
+__export(exports_range_eval_order_builder, {
+  buildRangeEvalOrder: () => buildRangeEvalOrder
+});
+module.exports = __toCommonJS(exports_range_eval_order_builder);
+var import_types = require("../types.cjs");
+var import_utils = require("../utils.cjs");
+var import_workbook_manager = require("./workbook-manager.cjs");
+var import_evaluation_error = require("src/evaluator/evaluation-error");
+function buildRangeEvalOrder(lookupOrder, lookupRange) {
+  const sheet = this.getSheet(lookupRange);
+  if (!sheet) {
+    throw new import_evaluation_error.EvaluationError(import_types.FormulaError.REF, `Sheet ${lookupRange.sheetName} not found`);
+  }
+  const result = [];
+  const startRow = lookupRange.range.start.row;
+  const startCol = lookupRange.range.start.col;
+  const occupiedCells = new Map;
+  let maxRow = startRow;
+  let maxCol = startCol;
+  for (const cellAddr of this.iterateCellsInRange(lookupRange)) {
+    occupiedCells.set(import_utils.getCellReference(cellAddr), cellAddr);
+    maxRow = Math.max(maxRow, cellAddr.rowIndex);
+    maxCol = Math.max(maxCol, cellAddr.colIndex);
+  }
+  if (lookupRange.range.end.row.type === "infinity" || lookupRange.range.end.col.type === "infinity") {
+    const allCells = this.iterateCellsInRange({
+      workbookName: lookupRange.workbookName,
+      sheetName: lookupRange.sheetName,
+      range: {
+        start: { row: 0, col: 0 },
+        end: {
+          row: { type: "infinity", sign: "positive" },
+          col: { type: "infinity", sign: "positive" }
+        }
+      }
+    });
+    for (const cellAddr of allCells) {
+      maxRow = Math.max(maxRow, cellAddr.rowIndex);
+      maxCol = Math.max(maxCol, cellAddr.colIndex);
+    }
+  }
+  const endRow = lookupRange.range.end.row.type === "number" ? lookupRange.range.end.row.value : maxRow;
+  const endCol = lookupRange.range.end.col.type === "number" ? lookupRange.range.end.col.value : maxCol;
+  const isInfinite = lookupRange.range.end.row.type === "infinity" || lookupRange.range.end.col.type === "infinity";
+  if (isInfinite && occupiedCells.size === 0) {
+    const leftCandidates = new Map;
+    const aboveCandidates = new Map;
+    const diagonalCandidates = new Map;
+    const allCells = this.iterateCellsInRange({
+      workbookName: lookupRange.workbookName,
+      sheetName: lookupRange.sheetName,
+      range: {
+        start: { row: 0, col: 0 },
+        end: {
+          row: { type: "infinity", sign: "positive" },
+          col: { type: "infinity", sign: "positive" }
+        }
+      }
+    });
+    for (const cellAddr of allCells) {
+      const cellRef = import_utils.getCellReference(cellAddr);
+      const content = sheet.content.get(cellRef);
+      if (typeof content === "string" && content.startsWith("=")) {
+        const isLeftCandidate = cellAddr.colIndex < startCol && cellAddr.rowIndex >= startRow;
+        const isAboveCandidate = cellAddr.rowIndex < startRow && cellAddr.colIndex >= startCol;
+        const isDiagonalCandidate = cellAddr.rowIndex < startRow && cellAddr.colIndex < startCol;
+        if (isLeftCandidate) {
+          leftCandidates.set(cellRef, cellAddr);
+        } else if (isAboveCandidate) {
+          aboveCandidates.set(cellRef, cellAddr);
+        } else if (isDiagonalCandidate) {
+          diagonalCandidates.set(cellRef, cellAddr);
+        }
+      }
+    }
+    const candidateMap = new Map;
+    if (leftCandidates.size > 0 || aboveCandidates.size > 0) {
+      for (const [ref, addr] of leftCandidates) {
+        candidateMap.set(ref, addr);
+      }
+      for (const [ref, addr] of aboveCandidates) {
+        candidateMap.set(ref, addr);
+      }
+    } else {
+      for (const [ref, addr] of diagonalCandidates) {
+        candidateMap.set(ref, addr);
+      }
+    }
+    const candidates = sortCandidates(Array.from(candidateMap.values()), lookupOrder);
+    result.push({
+      type: "empty_range",
+      address: lookupRange,
+      candidates
+    });
+    return result;
+  }
+  if (lookupOrder === "row-major") {
+    const indexes = this.getSheetIndexes({
+      workbookName: lookupRange.workbookName,
+      sheetName: lookupRange.sheetName
+    });
+    for (let row = startRow;row <= endRow; row++) {
+      const hasOccupiedInRow = indexes.rowGroups.has(row);
+      if (!hasOccupiedInRow && lookupRange.range.end.col.type === "infinity") {
+        const firstCell = {
+          rowIndex: row,
+          colIndex: startCol,
+          sheetName: lookupRange.sheetName,
+          workbookName: lookupRange.workbookName
+        };
+        const candidates = findCandidatesForCell.call(this, firstCell, sheet, lookupOrder);
+        result.push({
+          type: "empty_range",
+          address: {
+            workbookName: lookupRange.workbookName,
+            sheetName: lookupRange.sheetName,
+            range: {
+              start: {
+                row,
+                col: startCol
+              },
+              end: {
+                row: { type: "number", value: row },
+                col: lookupRange.range.end.col
+              }
+            }
+          },
+          candidates
+        });
+        continue;
+      }
+      processRowMajorRow.call(this, row, startCol, endCol, lookupRange, occupiedCells, sheet, result, indexes);
+      if (lookupRange.range.end.col.type === "infinity") {
+        const nextCol = endCol + 1;
+        const firstCellBeyondEnd = {
+          rowIndex: row,
+          colIndex: nextCol,
+          sheetName: lookupRange.sheetName,
+          workbookName: lookupRange.workbookName
+        };
+        const candidates = findCandidatesForCell.call(this, firstCellBeyondEnd, sheet, lookupOrder);
+        result.push({
+          type: "empty_range",
+          address: {
+            workbookName: lookupRange.workbookName,
+            sheetName: lookupRange.sheetName,
+            range: {
+              start: {
+                row,
+                col: nextCol
+              },
+              end: {
+                row: { type: "number", value: row },
+                col: lookupRange.range.end.col
+              }
+            }
+          },
+          candidates
+        });
+      }
+    }
+    if (lookupRange.range.end.row.type === "infinity") {
+      const nextRow = endRow + 1;
+      const firstCellInNextRow = {
+        rowIndex: nextRow,
+        colIndex: startCol,
+        sheetName: lookupRange.sheetName,
+        workbookName: lookupRange.workbookName
+      };
+      const candidates = findCandidatesForCell.call(this, firstCellInNextRow, sheet, lookupOrder);
+      result.push({
+        type: "empty_range",
+        address: {
+          workbookName: lookupRange.workbookName,
+          sheetName: lookupRange.sheetName,
+          range: {
+            start: {
+              row: nextRow,
+              col: startCol
+            },
+            end: {
+              row: lookupRange.range.end.row,
+              col: lookupRange.range.end.col
+            }
+          }
+        },
+        candidates
+      });
+    }
+  } else {
+    const indexes = this.getSheetIndexes({
+      workbookName: lookupRange.workbookName,
+      sheetName: lookupRange.sheetName
+    });
+    for (let col = startCol;col <= endCol; col++) {
+      const hasOccupiedInColumn = indexes.colGroups.has(col);
+      if (!hasOccupiedInColumn && lookupRange.range.end.row.type === "infinity") {
+        const firstCell = {
+          rowIndex: startRow,
+          colIndex: col,
+          sheetName: lookupRange.sheetName,
+          workbookName: lookupRange.workbookName
+        };
+        const candidates = findCandidatesForCell.call(this, firstCell, sheet, lookupOrder);
+        result.push({
+          type: "empty_range",
+          address: {
+            workbookName: lookupRange.workbookName,
+            sheetName: lookupRange.sheetName,
+            range: {
+              start: {
+                row: startRow,
+                col
+              },
+              end: {
+                row: lookupRange.range.end.row,
+                col: { type: "number", value: col }
+              }
+            }
+          },
+          candidates
+        });
+        continue;
+      }
+      processColMajorColumn.call(this, col, startRow, endRow, lookupRange, occupiedCells, sheet, result, indexes);
+      if (lookupRange.range.end.row.type === "infinity") {
+        const nextRow = endRow + 1;
+        const firstCellBeyondEnd = {
+          rowIndex: nextRow,
+          colIndex: col,
+          sheetName: lookupRange.sheetName,
+          workbookName: lookupRange.workbookName
+        };
+        const candidates = findCandidatesForCell.call(this, firstCellBeyondEnd, sheet, lookupOrder);
+        result.push({
+          type: "empty_range",
+          address: {
+            workbookName: lookupRange.workbookName,
+            sheetName: lookupRange.sheetName,
+            range: {
+              start: {
+                row: nextRow,
+                col
+              },
+              end: {
+                row: lookupRange.range.end.row,
+                col: { type: "number", value: col }
+              }
+            }
+          },
+          candidates
+        });
+      }
+    }
+    if (lookupRange.range.end.col.type === "infinity") {
+      const nextCol = endCol + 1;
+      const firstCellInNextCol = {
+        rowIndex: startRow,
+        colIndex: nextCol,
+        sheetName: lookupRange.sheetName,
+        workbookName: lookupRange.workbookName
+      };
+      const candidates = findCandidatesForCell.call(this, firstCellInNextCol, sheet, lookupOrder);
+      result.push({
+        type: "empty_range",
+        address: {
+          workbookName: lookupRange.workbookName,
+          sheetName: lookupRange.sheetName,
+          range: {
+            start: {
+              row: startRow,
+              col: nextCol
+            },
+            end: {
+              row: lookupRange.range.end.row,
+              col: lookupRange.range.end.col
+            }
+          }
+        },
+        candidates
+      });
+    }
+  }
+  return result;
+}
+function processRowMajorRow(row, startCol, endCol, lookupRange, occupiedCells, sheet, result, indexes) {
+  let col = startCol;
+  while (col <= endCol) {
+    const cellAddr = {
+      rowIndex: row,
+      colIndex: col,
+      sheetName: lookupRange.sheetName,
+      workbookName: lookupRange.workbookName
+    };
+    const cellRef = import_utils.getCellReference(cellAddr);
+    if (occupiedCells.has(cellRef)) {
+      result.push({
+        type: "value",
+        address: cellAddr
+      });
+      col++;
+    } else {
+      const emptyRangeStart = col;
+      let emptyRangeEnd = endCol;
+      const rowGroup = indexes.rowGroups.get(row);
+      if (rowGroup) {
+        const nextCellIdx = import_workbook_manager.IndexEntryBinarySearch.findFirstGreaterOrEqual(rowGroup, col + 1);
+        if (nextCellIdx !== -1) {
+          emptyRangeEnd = rowGroup[nextCellIdx].number - 1;
+        }
+      }
+      const allCandidates = findAllCandidatesForRange(this, {
+        workbookName: lookupRange.workbookName,
+        sheetName: lookupRange.sheetName,
+        range: {
+          start: { row, col: emptyRangeStart },
+          end: {
+            row: { type: "number", value: row },
+            col: { type: "number", value: emptyRangeEnd }
+          }
+        }
+      }, sheet, "row-major");
+      if (emptyRangeStart === emptyRangeEnd) {
+        result.push({
+          type: "empty_cell",
+          address: cellAddr,
+          candidates: allCandidates
+        });
+      } else {
+        result.push({
+          type: "empty_range",
+          address: {
+            workbookName: lookupRange.workbookName,
+            sheetName: lookupRange.sheetName,
+            range: {
+              start: {
+                row,
+                col: emptyRangeStart
+              },
+              end: {
+                row: { type: "number", value: row },
+                col: { type: "number", value: emptyRangeEnd }
+              }
+            }
+          },
+          candidates: allCandidates
+        });
+      }
+      col = emptyRangeEnd + 1;
+    }
+  }
+}
+function processColMajorColumn(col, startRow, endRow, lookupRange, occupiedCells, sheet, result, indexes) {
+  let row = startRow;
+  while (row <= endRow) {
+    const cellAddr = {
+      rowIndex: row,
+      colIndex: col,
+      sheetName: lookupRange.sheetName,
+      workbookName: lookupRange.workbookName
+    };
+    const cellRef = import_utils.getCellReference(cellAddr);
+    if (occupiedCells.has(cellRef)) {
+      result.push({
+        type: "value",
+        address: cellAddr
+      });
+      row++;
+    } else {
+      const emptyRangeStart = row;
+      let emptyRangeEnd = endRow;
+      const colGroup = indexes.colGroups.get(col);
+      if (colGroup) {
+        const nextCellIdx = import_workbook_manager.IndexEntryBinarySearch.findFirstGreaterOrEqual(colGroup, row + 1);
+        if (nextCellIdx !== -1) {
+          emptyRangeEnd = colGroup[nextCellIdx].number - 1;
+        }
+      }
+      const allCandidates = findAllCandidatesForRange(this, {
+        workbookName: lookupRange.workbookName,
+        sheetName: lookupRange.sheetName,
+        range: {
+          start: { row: emptyRangeStart, col },
+          end: {
+            row: { type: "number", value: emptyRangeEnd },
+            col: { type: "number", value: col }
+          }
+        }
+      }, sheet, "col-major");
+      if (emptyRangeStart === emptyRangeEnd) {
+        result.push({
+          type: "empty_cell",
+          address: cellAddr,
+          candidates: allCandidates
+        });
+      } else {
+        result.push({
+          type: "empty_range",
+          address: {
+            workbookName: lookupRange.workbookName,
+            sheetName: lookupRange.sheetName,
+            range: {
+              start: {
+                row: emptyRangeStart,
+                col
+              },
+              end: {
+                row: { type: "number", value: emptyRangeEnd },
+                col: { type: "number", value: col }
+              }
+            }
+          },
+          candidates: allCandidates
+        });
+      }
+      row = emptyRangeEnd + 1;
+    }
+  }
+}
+function findAllCandidatesForRange(manager, emptyRange, sheet, lookupOrder) {
+  const candidateMap = new Map;
+  const startRow = emptyRange.range.start.row;
+  const startCol = emptyRange.range.start.col;
+  const endRow = emptyRange.range.end.row.type === "number" ? emptyRange.range.end.row.value : startRow;
+  const endCol = emptyRange.range.end.col.type === "number" ? emptyRange.range.end.col.value : startCol;
+  const positionsToCheck = [];
+  if (startRow === endRow) {
+    for (let col = startCol;col <= endCol; col++) {
+      positionsToCheck.push({ row: startRow, col });
+    }
+  } else if (startCol === endCol) {
+    const maxSamples = 100;
+    const numRows = endRow - startRow + 1;
+    if (numRows <= maxSamples) {
+      for (let row = startRow;row <= endRow; row++) {
+        positionsToCheck.push({ row, col: startCol });
+      }
+    } else {
+      positionsToCheck.push({ row: startRow, col: startCol });
+      positionsToCheck.push({ row: endRow, col: startCol });
+      const indexes = manager.getSheetIndexes({
+        workbookName: emptyRange.workbookName,
+        sheetName: emptyRange.sheetName
+      });
+      const seenRows = new Set;
+      for (let c = 0;c < startCol; c++) {
+        const colGroup = indexes.colGroups.get(c);
+        if (colGroup) {
+          const startIdx = import_workbook_manager.IndexEntryBinarySearch.findFirstGreaterOrEqual(colGroup, startRow);
+          if (startIdx !== -1) {
+            for (let i = startIdx;i < colGroup.length; i++) {
+              const entry = colGroup[i];
+              if (!entry || entry.number > endRow)
+                break;
+              if (!seenRows.has(entry.number)) {
+                seenRows.add(entry.number);
+                positionsToCheck.push({ row: entry.number, col: startCol });
+              }
+            }
+          }
+        }
+      }
+    }
+  } else {
+    positionsToCheck.push({ row: startRow, col: startCol });
+    positionsToCheck.push({ row: startRow, col: endCol });
+    positionsToCheck.push({ row: endRow, col: startCol });
+    positionsToCheck.push({ row: endRow, col: endCol });
+  }
+  for (const pos of positionsToCheck) {
+    const candidates = findCandidatesForCell.call(manager, {
+      rowIndex: pos.row,
+      colIndex: pos.col,
+      sheetName: emptyRange.sheetName,
+      workbookName: emptyRange.workbookName
+    }, sheet, lookupOrder);
+    for (const cand of candidates) {
+      candidateMap.set(import_utils.getCellReference(cand), cand);
+    }
+  }
+  return sortCandidates(Array.from(candidateMap.values()), lookupOrder);
+}
+function findCandidatesForCell(cellAddr, sheet, lookupOrder) {
+  const leftCandidate = findNearestLeftAnchor.call(this, cellAddr, sheet);
+  const aboveCandidate = findNearestAboveAnchor.call(this, cellAddr, sheet);
+  if (leftCandidate || aboveCandidate) {
+    const candidates = [];
+    if (leftCandidate)
+      candidates.push(leftCandidate);
+    if (aboveCandidate)
+      candidates.push(aboveCandidate);
+    return sortCandidates(candidates, lookupOrder);
+  }
+  const diagonalCandidates = findAllDiagonalStepCandidates.call(this, cellAddr, sheet);
+  return sortCandidates(diagonalCandidates, lookupOrder);
+}
+function sortCandidates(candidates, lookupOrder) {
+  return candidates.sort((a, b) => {
+    if (lookupOrder === "row-major") {
+      if (a.colIndex !== b.colIndex)
+        return a.colIndex - b.colIndex;
+      return a.rowIndex - b.rowIndex;
+    } else {
+      if (a.rowIndex !== b.rowIndex)
+        return a.rowIndex - b.rowIndex;
+      return a.colIndex - b.colIndex;
+    }
+  });
+}
+function findNearestLeftAnchor(targetCell, sheet) {
+  const row = targetCell.rowIndex;
+  const targetCol = targetCell.colIndex;
+  const indexes = this.getSheetIndexes({
+    workbookName: targetCell.workbookName,
+    sheetName: targetCell.sheetName
+  });
+  const rowGroup = indexes.rowGroups.get(row);
+  if (!rowGroup) {
+    return null;
+  }
+  for (let i = rowGroup.length - 1;i >= 0; i--) {
+    const entry = rowGroup[i];
+    if (!entry || entry.number >= targetCol) {
+      continue;
+    }
+    const content = sheet.content.get(entry.key);
+    if (typeof content === "string" && content.startsWith("=")) {
+      return {
+        rowIndex: row,
+        colIndex: entry.number,
+        sheetName: targetCell.sheetName,
+        workbookName: targetCell.workbookName
+      };
+    }
+  }
+  return null;
+}
+function findNearestAboveAnchor(targetCell, sheet) {
+  const col = targetCell.colIndex;
+  const targetRow = targetCell.rowIndex;
+  const indexes = this.getSheetIndexes({
+    workbookName: targetCell.workbookName,
+    sheetName: targetCell.sheetName
+  });
+  const colGroup = indexes.colGroups.get(col);
+  if (!colGroup) {
+    return null;
+  }
+  for (let i = colGroup.length - 1;i >= 0; i--) {
+    const entry = colGroup[i];
+    if (!entry || entry.number >= targetRow) {
+      continue;
+    }
+    const content = sheet.content.get(entry.key);
+    if (typeof content === "string" && content.startsWith("=")) {
+      return {
+        rowIndex: entry.number,
+        colIndex: col,
+        sheetName: targetCell.sheetName,
+        workbookName: targetCell.workbookName
+      };
+    }
+  }
+  return null;
+}
+function findAllDiagonalStepCandidates(targetCell, sheet) {
+  const targetRow = targetCell.rowIndex;
+  const targetCol = targetCell.colIndex;
+  const allCandidates = [];
+  const indexes = this.getSheetIndexes({
+    workbookName: targetCell.workbookName,
+    sheetName: targetCell.sheetName
+  });
+  for (let col = 0;col < targetCol; col++) {
+    const colGroup = indexes.colGroups.get(col);
+    if (!colGroup) {
+      continue;
+    }
+    for (const entry of colGroup) {
+      if (entry.number >= targetRow) {
+        break;
+      }
+      const content = sheet.content.get(entry.key);
+      if (typeof content === "string" && content.startsWith("=")) {
+        allCandidates.push({
+          rowIndex: entry.number,
+          colIndex: col,
+          sheetName: targetCell.sheetName,
+          workbookName: targetCell.workbookName
+        });
+      }
+    }
+  }
+  allCandidates.sort((a, b) => {
+    if (a.rowIndex !== b.rowIndex)
+      return b.rowIndex - a.rowIndex;
+    return b.colIndex - a.colIndex;
+  });
+  const unblockedCandidates = [];
+  let maxColSeen = -1;
+  let prevRow = -1;
+  for (const candidate of allCandidates) {
+    if (candidate.rowIndex !== prevRow) {
+      if (candidate.colIndex > maxColSeen) {
+        unblockedCandidates.push(candidate);
+        maxColSeen = candidate.colIndex;
+      }
+      prevRow = candidate.rowIndex;
+    }
+  }
+  return unblockedCandidates;
+}
+
+//# debugId=5275BD56EBC306E164756E2164756E21