@devmm/puredocs-excel-formula 1.0.2 → 1.0.4

package/dist/index.js

@@ -2360,6 +2360,7 @@ function registerLookup(r) {
   r.register("LOOKUP", lookup, 2, 3);
   r.register("INDEX", index_, 2, 3);
   r.register("MATCH", match, 2, 3);
+  r.register("XMATCH", xmatch, 2, 4);
   r.register("CHOOSE", choose, 2);
   r.register("ADDRESS", address, 2, 5);
   r.register("ROW", row, 0, 1);
@@ -2531,6 +2532,23 @@ function xlookup(a, c) {
   for (let r = 0; r < ret.rows; r++) out.set(r, 0, ret.get(r, idx));
   return FormulaValue.array(out);
 }
+function xmatch(a, c) {
+  const lookupVal = a[0].evaluate(c);
+  if (lookupVal.isError) return lookupVal;
+  const lookupRaw = a[1].evaluate(c);
+  if (lookupRaw.isError) return lookupRaw;
+  const matchMode = a.length > 2 ? num2(a, c, 2) : { ok: true, n: 0 };
+  if (!matchMode.ok) return matchMode.e;
+  const searchMode = a.length > 3 ? num2(a, c, 3) : { ok: true, n: 1 };
+  if (!searchMode.ok) return searchMode.e;
+  const la = lookupRaw.isArray ? lookupRaw.arrayVal : ArrayValue.fromScalar(lookupRaw);
+  if (la.rows > 1 && la.columns > 1) return FormulaValue.errorValue;
+  const vertical = !(la.rows === 1 && la.columns > 1);
+  const n = vertical ? la.rows : la.columns;
+  const get = vertical ? (i) => la.get(i, 0) : (i) => la.get(0, i);
+  const idx = findMatch(n, get, lookupVal, Math.trunc(matchMode.n), Math.trunc(searchMode.n));
+  return idx < 0 ? FormulaValue.errorNA : FormulaValue.number(idx + 1);
+}
 function index_(a, c) {
   const arrVal = a[0].evaluate(c);
   if (arrVal.isError) return arrVal;
@@ -3068,6 +3086,20 @@ function registerFinance(r) {
   r.register("NPER", nper, 3, 5);
   r.register("XNPV", xnpv, 3, 3);
   r.register("XIRR", xirr, 2, 3);
+  r.register("IPMT", ipmt, 4, 6);
+  r.register("PPMT", ppmt, 4, 6);
+}
+function pmtValue(r, n, pv2, fv2, type) {
+  if (r === 0) return -(pv2 + fv2) / n;
+  const pow = Math.pow(1 + r, n);
+  let payment = (-fv2 - pv2 * pow) * r / (pow - 1);
+  if (type === 1) payment /= 1 + r;
+  return payment;
+}
+function fvValue(r, n, pmt2, pv2, type) {
+  if (r === 0) return -(pv2 + pmt2 * n);
+  const pow = Math.pow(1 + r, n);
+  return -(pv2 * pow + pmt2 * (1 + r * type) * (pow - 1) / r);
 }
 function arg(a, c, idx, dflt) {
   if (idx >= a.length) return { ok: true, n: dflt };
@@ -3087,11 +3119,7 @@ function pmt(a, c) {
   if (!type.ok) return type.e;
   const r = rate2.n, n = nper2.n, present = pvv.n, future = fvv.n, t = type.n;
   if (n === 0) return FormulaValue.errorNum;
-  if (r === 0) return FormulaValue.number(-(present + future) / n);
-  const pow = Math.pow(1 + r, n);
-  let payment = (-future - present * pow) * r / (pow - 1);
-  if (t === 1) payment /= 1 + r;
-  return FormulaValue.number(payment);
+  return FormulaValue.number(pmtValue(r, n, present, future, t));
 }
 function fv(a, c) {
   const rate2 = arg(a, c, 0, 0);
@@ -3105,9 +3133,7 @@ function fv(a, c) {
   const type = arg(a, c, 4, 0);
   if (!type.ok) return type.e;
   const r = rate2.n, n = nper2.n, payment = pmtv.n, present = pvv.n, t = type.n;
-  if (r === 0) return FormulaValue.number(-(present + payment * n));
-  const pow = Math.pow(1 + r, n);
-  return FormulaValue.number(-(present * pow + payment * (1 + r * t) * (pow - 1) / r));
+  return FormulaValue.number(fvValue(r, n, payment, present, t));
 }
 function pv(a, c) {
   const rate2 = arg(a, c, 0, 0);
@@ -3233,6 +3259,49 @@ function nper(a, c) {
   if (!isFinite(result)) return FormulaValue.errorNum;
   return FormulaValue.number(result);
 }
+function interestForPeriod(r, per, n, pv2, fv2, t) {
+  const pay = pmtValue(r, n, pv2, fv2, t);
+  if (t === 1) {
+    if (per === 1) return 0;
+    return fvValue(r, per - 2, pay, pv2, 1) * r / (1 + r);
+  }
+  return fvValue(r, per - 1, pay, pv2, 0) * r;
+}
+function ipmt(a, c) {
+  const rate2 = arg(a, c, 0, 0);
+  if (!rate2.ok) return rate2.e;
+  const perv = arg(a, c, 1, 0);
+  if (!perv.ok) return perv.e;
+  const nper2 = arg(a, c, 2, 0);
+  if (!nper2.ok) return nper2.e;
+  const pvv = arg(a, c, 3, 0);
+  if (!pvv.ok) return pvv.e;
+  const fvv = arg(a, c, 4, 0);
+  if (!fvv.ok) return fvv.e;
+  const type = arg(a, c, 5, 0);
+  if (!type.ok) return type.e;
+  const r = rate2.n, per = perv.n, n = nper2.n, pv2 = pvv.n, fv2 = fvv.n, t = type.n;
+  if (n === 0 || per < 1 || per > n) return FormulaValue.errorNum;
+  return FormulaValue.number(interestForPeriod(r, per, n, pv2, fv2, t));
+}
+function ppmt(a, c) {
+  const rate2 = arg(a, c, 0, 0);
+  if (!rate2.ok) return rate2.e;
+  const perv = arg(a, c, 1, 0);
+  if (!perv.ok) return perv.e;
+  const nper2 = arg(a, c, 2, 0);
+  if (!nper2.ok) return nper2.e;
+  const pvv = arg(a, c, 3, 0);
+  if (!pvv.ok) return pvv.e;
+  const fvv = arg(a, c, 4, 0);
+  if (!fvv.ok) return fvv.e;
+  const type = arg(a, c, 5, 0);
+  if (!type.ok) return type.e;
+  const r = rate2.n, per = perv.n, n = nper2.n, pv2 = pvv.n, fv2 = fvv.n, t = type.n;
+  if (n === 0 || per < 1 || per > n) return FormulaValue.errorNum;
+  const pay = pmtValue(r, n, pv2, fv2, t);
+  return FormulaValue.number(pay - interestForPeriod(r, per, n, pv2, fv2, t));
+}
 function flatNumbers(node, c) {
   const v = node.evaluate(c);
   if (v.isError) return { ok: false, e: v };
@@ -3660,7 +3729,13 @@ function registerArray(r) {
   r.register("FILTER", filter, 2, 3);
   r.register("MMULT", mmult, 2, 2);
   r.register("TEXTSPLIT", textSplit, 2, 6);
+  r.register("VSTACK", vstack, 1);
+  r.register("HSTACK", hstack, 1);
+  r.register("TOCOL", toCol, 1, 3);
+  r.register("TOROW", toRow, 1, 3);
 }
+var MAX_ROWS = 1048576;
+var MAX_COLS = 16384;
 var asArray2 = (v) => v.isArray ? v.arrayVal : ArrayValue.fromScalar(v);
 function fromRows(rows2) {
   const nr = rows2.length;
@@ -3707,26 +3782,53 @@ function sequence(a, c) {
   }
   return FormulaValue.array(arr);
 }
-function rowsEqual(x, y) {
-  if (x.length !== y.length) return false;
-  for (let i = 0; i < x.length; i++) if (!FormulaValue.areEqual(x[i], y[i])) return false;
-  return true;
+function cellKey(v) {
+  switch (v.kind) {
+    case "number":
+      return "n" + (v.numberValue === 0 ? "0" : String(v.numberValue));
+    case "text":
+      return "t" + v.textValue.toUpperCase();
+    // case-insensitive
+    case "boolean":
+      return v.booleanValue ? "b1" : "b0";
+    case "blank":
+      return "B";
+    case "error":
+      return "e" + v.errorCode;
+    default:
+      return "x";
+  }
 }
 function unique(a, c) {
   const v = a[0].evaluate(c);
   if (v.isError) return v;
   const byCol2 = a.length > 1 ? a[1].evaluate(c).coerceToBool().booleanValue : false;
   const exactlyOnce = a.length > 2 ? a[2].evaluate(c).coerceToBool().booleanValue : false;
-  let rows2 = toRows(byCol2 ? asArray2(v).transpose() : asArray2(v));
-  const counts = rows2.map((r) => rows2.filter((o) => rowsEqual(o, r)).length);
-  const seen = [];
+  const base = byCol2 ? asArray2(v).transpose() : asArray2(v);
+  const map = /* @__PURE__ */ new Map();
+  const order = [];
+  for (let r = 0; r < base.rows; r++) {
+    const cells = new Array(base.columns);
+    let key = "";
+    for (let col = 0; col < base.columns; col++) {
+      const cell = base.get(r, col);
+      cells[col] = cell;
+      const k = cellKey(cell);
+      key += k.length + ":" + k;
+    }
+    const hit = map.get(key);
+    if (hit) hit.count++;
+    else {
+      map.set(key, { cells, count: 1 });
+      order.push(key);
+    }
+  }
   const result = [];
-  rows2.forEach((r, i) => {
-    if (seen.some((o) => rowsEqual(o, r))) return;
-    seen.push(r);
-    if (exactlyOnce && counts[i] > 1) return;
-    result.push(r);
-  });
+  for (const key of order) {
+    const e = map.get(key);
+    if (exactlyOnce && e.count > 1) continue;
+    result.push(e.cells);
+  }
   if (result.length === 0) return FormulaValue.error(8 /* Calc */);
   const out = fromRows(result);
   return byCol2 ? FormulaValue.array(out.arrayVal.transpose()) : out;
@@ -3884,6 +3986,89 @@ function textSplit(a, c) {
   });
   return fromRows(rows2);
 }
+function vstack(a, c) {
+  const parts = [];
+  let totalRows = 0, maxCols = 0;
+  for (const node of a) {
+    const arr = asArray2(node.evaluate(c));
+    parts.push(arr);
+    totalRows += arr.rows;
+    if (arr.columns > maxCols) maxCols = arr.columns;
+  }
+  if (totalRows > MAX_ROWS || maxCols > MAX_COLS) return FormulaValue.errorNum;
+  const out = new ArrayValue(totalRows, maxCols);
+  let rowOff = 0;
+  for (const arr of parts) {
+    for (let r = 0; r < arr.rows; r++) {
+      for (let col = 0; col < maxCols; col++) {
+        out.set(rowOff + r, col, col < arr.columns ? arr.get(r, col) : FormulaValue.errorNA);
+      }
+    }
+    rowOff += arr.rows;
+  }
+  return FormulaValue.array(out);
+}
+function hstack(a, c) {
+  const parts = [];
+  let totalCols = 0, maxRows = 0;
+  for (const node of a) {
+    const arr = asArray2(node.evaluate(c));
+    parts.push(arr);
+    totalCols += arr.columns;
+    if (arr.rows > maxRows) maxRows = arr.rows;
+  }
+  if (maxRows > MAX_ROWS || totalCols > MAX_COLS) return FormulaValue.errorNum;
+  const out = new ArrayValue(maxRows, totalCols);
+  let colOff = 0;
+  for (const arr of parts) {
+    for (let col = 0; col < arr.columns; col++) {
+      for (let r = 0; r < maxRows; r++) {
+        out.set(r, colOff + col, r < arr.rows ? arr.get(r, col) : FormulaValue.errorNA);
+      }
+    }
+    colOff += arr.columns;
+  }
+  return FormulaValue.array(out);
+}
+function flatten(a, c) {
+  const arr = asArray2(a[0].evaluate(c));
+  const ig = num4(a, c, 1, 0);
+  if (!ig.ok) return { ok: false, e: ig.e };
+  const ignore = Math.trunc(ig.n);
+  const byCol2 = a.length > 2 ? a[2].evaluate(c).coerceToBool().booleanValue : false;
+  const skip = (x) => (ignore & 1) !== 0 && x.isBlank || (ignore & 2) !== 0 && x.isError;
+  const values = [];
+  if (byCol2) {
+    for (let col = 0; col < arr.columns; col++)
+      for (let r = 0; r < arr.rows; r++) {
+        const x = arr.get(r, col);
+        if (!skip(x)) values.push(x);
+      }
+  } else {
+    for (let r = 0; r < arr.rows; r++)
+      for (let col = 0; col < arr.columns; col++) {
+        const x = arr.get(r, col);
+        if (!skip(x)) values.push(x);
+      }
+  }
+  return { ok: true, values };
+}
+function toCol(a, c) {
+  const f = flatten(a, c);
+  if (!f.ok) return f.e;
+  if (f.values.length === 0) return FormulaValue.errorNA;
+  const out = new ArrayValue(f.values.length, 1);
+  for (let i = 0; i < f.values.length; i++) out.set(i, 0, f.values[i]);
+  return FormulaValue.array(out);
+}
+function toRow(a, c) {
+  const f = flatten(a, c);
+  if (!f.ok) return f.e;
+  if (f.values.length === 0) return FormulaValue.errorNA;
+  const out = new ArrayValue(1, f.values.length);
+  for (let i = 0; i < f.values.length; i++) out.set(0, i, f.values[i]);
+  return FormulaValue.array(out);
+}
 
 // src/function-registry.ts
 var _default, _functions, _FunctionRegistry_instances, registerBuiltIns_fn;
@@ -4686,8 +4871,8 @@ writeResult_fn = function(e) {
     for (let dc = 0; dc < cols && !collides; dc++) {
       if (dr === 0 && dc === 0) continue;
       const r = e.row + dr, c = e.col + dc;
-      const cellKey = keyOf(e.sheet, cellRefFromRowCol(r, c));
-      if (__privateMethod(this, _RecalcEngine_instances, isOccupied_fn).call(this, cellKey, e.sheetName, cellRefFromRowCol(r, c), anchorKey, prevSpill)) {
+      const cellKey2 = keyOf(e.sheet, cellRefFromRowCol(r, c));
+      if (__privateMethod(this, _RecalcEngine_instances, isOccupied_fn).call(this, cellKey2, e.sheetName, cellRefFromRowCol(r, c), anchorKey, prevSpill)) {
         collides = true;
       }
     }
@@ -4708,9 +4893,9 @@ writeResult_fn = function(e) {
       __privateGet(this, _model).setCellValue(e.sheetName, ref, arr.get(dr, dc).toObject());
       changed.push({ sheet: e.sheet, row: r, col: c });
       if (dr !== 0 || dc !== 0) {
-        const cellKey = keyOf(e.sheet, ref);
-        newSpill.add(cellKey);
-        __privateGet(this, _spillOwner).set(cellKey, anchorKey);
+        const cellKey2 = keyOf(e.sheet, ref);
+        newSpill.add(cellKey2);
+        __privateGet(this, _spillOwner).set(cellKey2, anchorKey);
       }
     }
   }
@@ -4730,11 +4915,11 @@ writeResult_fn = function(e) {
   };
 };
 /** Whether a target cell already holds content that blocks a spill. */
-isOccupied_fn = function(cellKey, sheetName, ref, anchorKey, prevSpill) {
-  if (__privateGet(this, _formulas).has(cellKey) && cellKey !== anchorKey) return true;
-  const owner = __privateGet(this, _spillOwner).get(cellKey);
+isOccupied_fn = function(cellKey2, sheetName, ref, anchorKey, prevSpill) {
+  if (__privateGet(this, _formulas).has(cellKey2) && cellKey2 !== anchorKey) return true;
+  const owner = __privateGet(this, _spillOwner).get(cellKey2);
   if (owner && owner !== anchorKey) return true;
-  if (prevSpill.has(cellKey)) return false;
+  if (prevSpill.has(cellKey2)) return false;
   const v = __privateGet(this, _model).getCellValue(sheetName, ref);
   return v !== null && v !== void 0 && v !== "";
 };
@@ -4742,10 +4927,10 @@ isOccupied_fn = function(cellKey, sheetName, ref, anchorKey, prevSpill) {
 clearSpill_fn = function(anchorKey, changed) {
   const spill = __privateGet(this, _spills).get(anchorKey);
   if (!spill) return;
-  for (const cellKey of spill) {
-    const cell = parseKey(cellKey);
+  for (const cellKey2 of spill) {
+    const cell = parseKey(cellKey2);
     __privateGet(this, _model).setCellValue(__privateGet(this, _sheetNames).get(cell.sheet) ?? cell.sheet, cell.ref, null);
-    __privateGet(this, _spillOwner).delete(cellKey);
+    __privateGet(this, _spillOwner).delete(cellKey2);
     changed.push({ sheet: cell.sheet, row: cell.row, col: cell.col });
   }
   __privateGet(this, _spills).delete(anchorKey);