@devmm/puredocs-excel-formula 1.0.1 → 1.0.2

package/dist/index.js

@@ -2356,6 +2356,7 @@ function datedif(a, c) {
 function registerLookup(r) {
   r.register("VLOOKUP", vlookup, 3, 4);
   r.register("HLOOKUP", hlookup, 3, 4);
+  r.register("XLOOKUP", xlookup, 3, 6);
   r.register("LOOKUP", lookup, 2, 3);
   r.register("INDEX", index_, 2, 3);
   r.register("MATCH", match, 2, 3);
@@ -2432,6 +2433,104 @@ function hlookup(a, c) {
   }
   return best >= 0 ? tbl.get(rowIdx, best) : FormulaValue.errorNA;
 }
+function wildcardRegex(pattern) {
+  let out = "";
+  for (let i = 0; i < pattern.length; i++) {
+    const ch = pattern[i];
+    if (ch === "~" && i + 1 < pattern.length) {
+      const next = pattern[++i];
+      out += next.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    } else if (ch === "*") out += ".*";
+    else if (ch === "?") out += ".";
+    else out += ch.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  return new RegExp(`^${out}$`, "i");
+}
+function findMatch(n, get, lookupVal, matchMode, searchMode) {
+  if ((searchMode === 2 || searchMode === -2) && matchMode !== 2) {
+    const at = searchMode === 2 ? get : (j) => get(n - 1 - j);
+    let lo = 0, hi = n - 1, lastLE = -1, firstGE = -1;
+    while (lo <= hi) {
+      const mid2 = lo + hi >>> 1;
+      const cmp = FormulaValue.compare(at(mid2), lookupVal);
+      if (cmp === 0) return searchMode === 2 ? mid2 : n - 1 - mid2;
+      if (cmp < 0) {
+        lastLE = mid2;
+        lo = mid2 + 1;
+      } else {
+        firstGE = mid2;
+        hi = mid2 - 1;
+      }
+    }
+    const idx = matchMode === -1 ? lastLE : matchMode === 1 ? firstGE : -1;
+    return idx < 0 ? -1 : searchMode === 2 ? idx : n - 1 - idx;
+  }
+  const reverse = searchMode === -1;
+  const order = reverse ? Array.from({ length: n }, (_, k) => n - 1 - k) : Array.from({ length: n }, (_, k) => k);
+  if (matchMode === 2) {
+    const re = wildcardRegex(lookupVal.asText());
+    for (const i of order) if (re.test(get(i).asText())) return i;
+    return -1;
+  }
+  if (matchMode === 0) {
+    for (const i of order) if (FormulaValue.areEqual(get(i), lookupVal)) return i;
+    return -1;
+  }
+  let best = -1;
+  let bestVal = null;
+  for (const i of order) {
+    const v = get(i);
+    const cmp = FormulaValue.compare(v, lookupVal);
+    if (cmp === 0) return i;
+    if (matchMode === -1 && cmp < 0) {
+      if (bestVal === null || FormulaValue.compare(v, bestVal) > 0) {
+        best = i;
+        bestVal = v;
+      }
+    } else if (matchMode === 1 && cmp > 0) {
+      if (bestVal === null || FormulaValue.compare(v, bestVal) < 0) {
+        best = i;
+        bestVal = v;
+      }
+    }
+  }
+  return best;
+}
+function xlookup(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 returnRaw = a[2].evaluate(c);
+  if (returnRaw.isError) return returnRaw;
+  const matchMode = a.length > 4 ? num2(a, c, 4) : { ok: true, n: 0 };
+  if (!matchMode.ok) return matchMode.e;
+  const searchMode = a.length > 5 ? num2(a, c, 5) : { ok: true, n: 1 };
+  if (!searchMode.ok) return searchMode.e;
+  const mm = Math.trunc(matchMode.n), sm = Math.trunc(searchMode.n);
+  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, mm, sm);
+  if (idx < 0) {
+    return a.length > 3 ? a[3].evaluate(c) : FormulaValue.errorNA;
+  }
+  const ret = returnRaw.isArray ? returnRaw.arrayVal : ArrayValue.fromScalar(returnRaw);
+  if (vertical) {
+    if (ret.rows !== n) return FormulaValue.errorValue;
+    if (ret.columns === 1) return ret.get(idx, 0);
+    const out2 = new ArrayValue(1, ret.columns);
+    for (let col = 0; col < ret.columns; col++) out2.set(0, col, ret.get(idx, col));
+    return FormulaValue.array(out2);
+  }
+  if (ret.columns !== n) return FormulaValue.errorValue;
+  if (ret.rows === 1) return ret.get(0, idx);
+  const out = new ArrayValue(ret.rows, 1);
+  for (let r = 0; r < ret.rows; r++) out.set(r, 0, ret.get(r, idx));
+  return FormulaValue.array(out);
+}
 function index_(a, c) {
   const arrVal = a[0].evaluate(c);
   if (arrVal.isError) return arrVal;
@@ -2965,6 +3064,10 @@ function registerFinance(r) {
   r.register("PV", pv, 3, 5);
   r.register("NPV", npv, 2);
   r.register("IRR", irr, 1, 2);
+  r.register("RATE", rate, 3, 6);
+  r.register("NPER", nper, 3, 5);
+  r.register("XNPV", xnpv, 3, 3);
+  r.register("XIRR", xirr, 2, 3);
 }
 function arg(a, c, idx, dflt) {
   if (idx >= a.length) return { ok: true, n: dflt };
@@ -2972,17 +3075,17 @@ function arg(a, c, idx, dflt) {
   return r.ok ? { ok: true, n: r.value } : { ok: false, e: r.error };
 }
 function pmt(a, c) {
-  const rate = arg(a, c, 0, 0);
-  if (!rate.ok) return rate.e;
-  const nper = arg(a, c, 1, 0);
-  if (!nper.ok) return nper.e;
+  const rate2 = arg(a, c, 0, 0);
+  if (!rate2.ok) return rate2.e;
+  const nper2 = arg(a, c, 1, 0);
+  if (!nper2.ok) return nper2.e;
   const pvv = arg(a, c, 2, 0);
   if (!pvv.ok) return pvv.e;
   const fvv = arg(a, c, 3, 0);
   if (!fvv.ok) return fvv.e;
   const type = arg(a, c, 4, 0);
   if (!type.ok) return type.e;
-  const r = rate.n, n = nper.n, present = pvv.n, future = fvv.n, t = type.n;
+  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);
@@ -2991,46 +3094,46 @@ function pmt(a, c) {
   return FormulaValue.number(payment);
 }
 function fv(a, c) {
-  const rate = arg(a, c, 0, 0);
-  if (!rate.ok) return rate.e;
-  const nper = arg(a, c, 1, 0);
-  if (!nper.ok) return nper.e;
+  const rate2 = arg(a, c, 0, 0);
+  if (!rate2.ok) return rate2.e;
+  const nper2 = arg(a, c, 1, 0);
+  if (!nper2.ok) return nper2.e;
   const pmtv = arg(a, c, 2, 0);
   if (!pmtv.ok) return pmtv.e;
   const pvv = arg(a, c, 3, 0);
   if (!pvv.ok) return pvv.e;
   const type = arg(a, c, 4, 0);
   if (!type.ok) return type.e;
-  const r = rate.n, n = nper.n, payment = pmtv.n, present = pvv.n, t = type.n;
+  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));
 }
 function pv(a, c) {
-  const rate = arg(a, c, 0, 0);
-  if (!rate.ok) return rate.e;
-  const nper = arg(a, c, 1, 0);
-  if (!nper.ok) return nper.e;
+  const rate2 = arg(a, c, 0, 0);
+  if (!rate2.ok) return rate2.e;
+  const nper2 = arg(a, c, 1, 0);
+  if (!nper2.ok) return nper2.e;
   const pmtv = arg(a, c, 2, 0);
   if (!pmtv.ok) return pmtv.e;
   const fvv = arg(a, c, 3, 0);
   if (!fvv.ok) return fvv.e;
   const type = arg(a, c, 4, 0);
   if (!type.ok) return type.e;
-  const r = rate.n, n = nper.n, payment = pmtv.n, future = fvv.n, t = type.n;
+  const r = rate2.n, n = nper2.n, payment = pmtv.n, future = fvv.n, t = type.n;
   if (r === 0) return FormulaValue.number(-(future + payment * n));
   const pow = Math.pow(1 + r, n);
   return FormulaValue.number(-(future + payment * (1 + r * t) * (pow - 1) / r) / pow);
 }
 function npv(a, c) {
-  const rate = FormulaHelper.evalDouble(a[0], c);
-  if (!rate.ok) return rate.error;
-  if (rate.value === -1) return FormulaValue.errorDiv0;
+  const rate2 = FormulaHelper.evalDouble(a[0], c);
+  if (!rate2.ok) return rate2.error;
+  if (rate2.value === -1) return FormulaValue.errorDiv0;
   const flows = FormulaHelper.collectNumbers(a.slice(1), c);
   if (!flows.ok) return flows.error;
   let total = 0;
   for (let i = 0; i < flows.values.length; i++) {
-    total += flows.values[i] / Math.pow(1 + rate.value, i + 1);
+    total += flows.values[i] / Math.pow(1 + rate2.value, i + 1);
   }
   return FormulaValue.number(total);
 }
@@ -3045,27 +3148,177 @@ function irr(a, c) {
     if (!g.ok) return g.error;
     guess = g.value;
   }
-  const npvAt = (rate2) => {
+  const npvAt = (rate3) => {
     let sum2 = 0;
-    for (let i = 0; i < flows.length; i++) sum2 += flows[i] / Math.pow(1 + rate2, i);
+    for (let i = 0; i < flows.length; i++) sum2 += flows[i] / Math.pow(1 + rate3, i);
     return sum2;
   };
-  let rate = guess;
+  let rate2 = guess;
+  for (let iter = 0; iter < 100; iter++) {
+    const f = npvAt(rate2);
+    if (Math.abs(f) < 1e-7) return FormulaValue.number(rate2);
+    const h = 1e-6;
+    const deriv = (npvAt(rate2 + h) - f) / h;
+    if (deriv === 0) break;
+    const next = rate2 - f / deriv;
+    if (!isFinite(next) || next <= -1) break;
+    if (Math.abs(next - rate2) < 1e-9) {
+      rate2 = next;
+      break;
+    }
+    rate2 = next;
+  }
+  if (Math.abs(npvAt(rate2)) < 1e-6) return FormulaValue.number(rate2);
+  return FormulaValue.errorNum;
+}
+function tvm(r, n, pmt2, pv2, fv2, type) {
+  if (r === 0) return pv2 + pmt2 * n + fv2;
+  const pow = Math.pow(1 + r, n);
+  return pv2 * pow + pmt2 * (1 + r * type) * (pow - 1) / r + fv2;
+}
+function rate(a, c) {
+  const nper2 = arg(a, c, 0, 0);
+  if (!nper2.ok) return nper2.e;
+  const pmtv = arg(a, c, 1, 0);
+  if (!pmtv.ok) return pmtv.e;
+  const pvv = arg(a, c, 2, 0);
+  if (!pvv.ok) return pvv.e;
+  const fvv = arg(a, c, 3, 0);
+  if (!fvv.ok) return fvv.e;
+  const type = arg(a, c, 4, 0);
+  if (!type.ok) return type.e;
+  const gs = arg(a, c, 5, 0.1);
+  if (!gs.ok) return gs.e;
+  const n = nper2.n, pmt2 = pmtv.n, pv2 = pvv.n, fv2 = fvv.n, t = type.n;
+  if (n === 0) return FormulaValue.errorNum;
+  let r = gs.n;
   for (let iter = 0; iter < 100; iter++) {
-    const f = npvAt(rate);
-    if (Math.abs(f) < 1e-7) return FormulaValue.number(rate);
+    const f = tvm(r, n, pmt2, pv2, fv2, t);
+    if (Math.abs(f) < 1e-8) return FormulaValue.number(r);
     const h = 1e-6;
-    const deriv = (npvAt(rate + h) - f) / h;
+    const deriv = (tvm(r + h, n, pmt2, pv2, fv2, t) - f) / h;
     if (deriv === 0) break;
-    const next = rate - f / deriv;
+    const next = r - f / deriv;
     if (!isFinite(next) || next <= -1) break;
-    if (Math.abs(next - rate) < 1e-9) {
-      rate = next;
+    if (Math.abs(next - r) < 1e-10) {
+      r = next;
       break;
     }
-    rate = next;
+    r = next;
   }
-  if (Math.abs(npvAt(rate)) < 1e-6) return FormulaValue.number(rate);
+  if (Math.abs(tvm(r, n, pmt2, pv2, fv2, t)) < 1e-6) return FormulaValue.number(r);
+  return FormulaValue.errorNum;
+}
+function nper(a, c) {
+  const rate2 = arg(a, c, 0, 0);
+  if (!rate2.ok) return rate2.e;
+  const pmtv = arg(a, c, 1, 0);
+  if (!pmtv.ok) return pmtv.e;
+  const pvv = arg(a, c, 2, 0);
+  if (!pvv.ok) return pvv.e;
+  const fvv = arg(a, c, 3, 0);
+  if (!fvv.ok) return fvv.e;
+  const type = arg(a, c, 4, 0);
+  if (!type.ok) return type.e;
+  const r = rate2.n, pmt2 = pmtv.n, pv2 = pvv.n, fv2 = fvv.n, t = type.n;
+  if (r === 0) {
+    if (pmt2 === 0) return FormulaValue.errorNum;
+    return FormulaValue.number(-(pv2 + fv2) / pmt2);
+  }
+  const adj = pmt2 * (1 + r * t);
+  const num5 = adj - fv2 * r;
+  const den = adj + pv2 * r;
+  if (den === 0 || num5 / den <= 0) return FormulaValue.errorNum;
+  const result = Math.log(num5 / den) / Math.log(1 + r);
+  if (!isFinite(result)) return FormulaValue.errorNum;
+  return FormulaValue.number(result);
+}
+function flatNumbers(node, c) {
+  const v = node.evaluate(c);
+  if (v.isError) return { ok: false, e: v };
+  const out = [];
+  const push = (item) => {
+    if (item.isError) return item;
+    const d = item.tryAsDouble();
+    if (!d.ok) return FormulaValue.errorValue;
+    out.push(d.value);
+    return null;
+  };
+  if (v.isArray) {
+    for (const item of v.arrayVal.values()) {
+      const err = push(item);
+      if (err) return { ok: false, e: err };
+    }
+  } else {
+    const err = push(v);
+    if (err) return { ok: false, e: err };
+  }
+  return { ok: true, values: out };
+}
+function xnpvAt(rate2, values, days2) {
+  let sum2 = 0;
+  for (let i = 0; i < values.length; i++) {
+    sum2 += values[i] / Math.pow(1 + rate2, days2[i] / 365);
+  }
+  return sum2;
+}
+function xnpv(a, c) {
+  const rateRes = FormulaHelper.evalDouble(a[0], c);
+  if (!rateRes.ok) return rateRes.error;
+  const rate2 = rateRes.value;
+  if (rate2 <= -1) return FormulaValue.errorNum;
+  const valsRes = flatNumbers(a[1], c);
+  if (!valsRes.ok) return valsRes.e;
+  const datesRes = flatNumbers(a[2], c);
+  if (!datesRes.ok) return datesRes.e;
+  const values = valsRes.values;
+  const dates = datesRes.values;
+  if (values.length === 0 || values.length !== dates.length) return FormulaValue.errorNum;
+  const base = Math.trunc(dates[0]);
+  const days2 = dates.map((d) => Math.trunc(d) - base);
+  if (days2.some((d) => d < 0)) return FormulaValue.errorNum;
+  return FormulaValue.number(xnpvAt(rate2, values, days2));
+}
+function xirr(a, c) {
+  const valsRes = flatNumbers(a[0], c);
+  if (!valsRes.ok) return valsRes.e;
+  const datesRes = flatNumbers(a[1], c);
+  if (!datesRes.ok) return datesRes.e;
+  const values = valsRes.values;
+  const dates = datesRes.values;
+  if (values.length < 2 || values.length !== dates.length) return FormulaValue.errorNum;
+  let guess = 0.1;
+  if (a.length > 2) {
+    const g = FormulaHelper.evalDouble(a[2], c);
+    if (!g.ok) return g.error;
+    guess = g.value;
+  }
+  const base = Math.trunc(dates[0]);
+  const days2 = dates.map((d) => Math.trunc(d) - base);
+  if (days2.some((d) => d < 0)) return FormulaValue.errorNum;
+  const derivAt = (rate3) => {
+    let sum2 = 0;
+    for (let i = 0; i < values.length; i++) {
+      const e = days2[i] / 365;
+      sum2 += -e * values[i] / Math.pow(1 + rate3, e + 1);
+    }
+    return sum2;
+  };
+  let rate2 = guess;
+  for (let iter = 0; iter < 100; iter++) {
+    const f = xnpvAt(rate2, values, days2);
+    if (Math.abs(f) < 1e-7) return FormulaValue.number(rate2);
+    const deriv = derivAt(rate2);
+    if (deriv === 0) break;
+    const next = rate2 - f / deriv;
+    if (!isFinite(next) || next <= -1) break;
+    if (Math.abs(next - rate2) < 1e-9) {
+      rate2 = next;
+      break;
+    }
+    rate2 = next;
+  }
+  if (Math.abs(xnpvAt(rate2, values, days2)) < 1e-6) return FormulaValue.number(rate2);
   return FormulaValue.errorNum;
 }
 
@@ -3403,6 +3656,7 @@ function registerArray(r) {
   r.register("SEQUENCE", sequence, 1, 4);
   r.register("UNIQUE", unique, 1, 3);
   r.register("SORT", sort, 1, 4);
+  r.register("SORTBY", sortBy, 2);
   r.register("FILTER", filter, 2, 3);
   r.register("MMULT", mmult, 2, 2);
   r.register("TEXTSPLIT", textSplit, 2, 6);
@@ -3497,6 +3751,58 @@ function sort(a, c) {
   const out = fromRows(sorted);
   return byCol2 ? FormulaValue.array(out.arrayVal.transpose()) : out;
 }
+function sortBy(a, c) {
+  const v = a[0].evaluate(c);
+  if (v.isError) return v;
+  const data = asArray2(v);
+  const keys = [];
+  let i = 1;
+  while (i < a.length) {
+    const byVal = a[i].evaluate(c);
+    if (byVal.isError) return byVal;
+    i++;
+    let dir = 1;
+    if (i < a.length) {
+      const maybeOrder = a[i].evaluate(c);
+      if (maybeOrder.isError) return maybeOrder;
+      if (!maybeOrder.isArray && maybeOrder.isNumeric) {
+        const d = maybeOrder.tryAsDouble();
+        if (d.ok) {
+          dir = d.value < 0 ? -1 : 1;
+          i++;
+        }
+      }
+    }
+    keys.push({ vals: [...asArray2(byVal).values()], dir });
+  }
+  if (keys.length === 0) return FormulaValue.errorValue;
+  const n = keys[0].vals.length;
+  if (keys.some((k) => k.vals.length !== n)) return FormulaValue.errorValue;
+  const byRow2 = n === data.rows;
+  const byColumn = !byRow2 && n === data.columns;
+  if (!byRow2 && !byColumn) return FormulaValue.errorValue;
+  const perm = Array.from({ length: n }, (_, k) => k);
+  perm.sort((x, y) => {
+    for (const key of keys) {
+      const cmp = FormulaValue.compare(key.vals[x], key.vals[y]) * key.dir;
+      if (cmp !== 0) return cmp;
+    }
+    return x - y;
+  });
+  const out = new ArrayValue(data.rows, data.columns);
+  if (byRow2) {
+    for (let r = 0; r < data.rows; r++) {
+      const src = perm[r];
+      for (let col = 0; col < data.columns; col++) out.set(r, col, data.get(src, col));
+    }
+  } else {
+    for (let col = 0; col < data.columns; col++) {
+      const src = perm[col];
+      for (let r = 0; r < data.rows; r++) out.set(r, col, data.get(r, src));
+    }
+  }
+  return FormulaValue.array(out);
+}
 function filter(a, c) {
   const v = a[0].evaluate(c);
   if (v.isError) return v;