@noy-db/hub 0.2.0-pre.15 → 0.2.0-pre.17

package/dist/aggregate/index.cjs

@@ -163,6 +163,88 @@ function buildLiveAggregation(recompute, upstreams) {
 }
 
 // src/money/fixed-point.ts
+function expandExponent(s) {
+  const m = /^([+-]?)(\d+)(?:\.(\d+))?[eE]([+-]?\d+)$/.exec(s);
+  if (!m) return s;
+  const sign = m[1] === "-" ? "-" : "";
+  const intp = m[2];
+  const frac = m[3] ?? "";
+  const exp = Number(m[4]);
+  const digits = intp + frac;
+  const pointPos = intp.length + exp;
+  let body;
+  if (pointPos <= 0) {
+    body = "0." + "0".repeat(-pointPos) + digits;
+  } else if (pointPos >= digits.length) {
+    body = digits + "0".repeat(pointPos - digits.length);
+  } else {
+    body = digits.slice(0, pointPos) + "." + digits.slice(pointPos);
+  }
+  return sign + body;
+}
+function toCanonicalDecimalString(input) {
+  let s;
+  if (typeof input === "number") {
+    if (!Number.isFinite(input)) return null;
+    s = String(input);
+  } else {
+    s = input.trim();
+  }
+  s = expandExponent(s);
+  if (s.startsWith("+")) s = s.slice(1);
+  if (!/^-?(\d+(\.\d*)?|\.\d+)$/.test(s)) return null;
+  return s;
+}
+function shouldRoundUp(negative, lastKeptDigit, firstDiscarded, hasMoreNonZeroAfterFirst, mode) {
+  switch (mode) {
+    case "up":
+      return true;
+    case "down":
+      return false;
+    case "ceil":
+      return !negative;
+    case "floor":
+      return negative;
+    case "half-up":
+      return firstDiscarded >= 5;
+    case "half-down":
+      return firstDiscarded > 5 || firstDiscarded === 5 && hasMoreNonZeroAfterFirst;
+    case "half-even":
+      if (firstDiscarded > 5) return true;
+      if (firstDiscarded < 5) return false;
+      return hasMoreNonZeroAfterFirst || lastKeptDigit % 2 === 1;
+  }
+}
+function parseToScaledInt(input, scale, rounding) {
+  const canonical = toCanonicalDecimalString(input);
+  if (canonical === null) return { ok: false, reason: "nonfinite" };
+  const negative = canonical.startsWith("-");
+  const unsigned = negative ? canonical.slice(1) : canonical;
+  const dot = unsigned.indexOf(".");
+  const intPart = dot === -1 ? unsigned : unsigned.slice(0, dot);
+  const fracPart = dot === -1 ? "" : unsigned.slice(dot + 1);
+  const intDigits = intPart === "" ? "0" : intPart;
+  if (fracPart.length <= scale) {
+    const keep2 = fracPart.padEnd(scale, "0");
+    const magnitude2 = BigInt(intDigits + keep2);
+    return { ok: true, value: negative && magnitude2 !== 0n ? -magnitude2 : magnitude2 };
+  }
+  const keep = fracPart.slice(0, scale);
+  const tail = fracPart.slice(scale);
+  const magnitudeDigits = intDigits + keep;
+  let magnitude = BigInt(magnitudeDigits);
+  if (/^0+$/.test(tail)) {
+    return { ok: true, value: negative && magnitude !== 0n ? -magnitude : magnitude };
+  }
+  if (rounding === void 0) return { ok: false, reason: "precision" };
+  const lastKeptDigit = Number(magnitudeDigits[magnitudeDigits.length - 1]);
+  const firstDiscarded = Number(tail[0]);
+  const hasMoreNonZeroAfterFirst = /[1-9]/.test(tail.slice(1));
+  if (shouldRoundUp(negative, lastKeptDigit, firstDiscarded, hasMoreNonZeroAfterFirst, rounding)) {
+    magnitude += 1n;
+  }
+  return { ok: true, value: negative && magnitude !== 0n ? -magnitude : magnitude };
+}
 function formatScaledInt(value, scale) {
   const negative = value < 0n;
   const abs = (negative ? -value : value).toString();
@@ -302,13 +384,22 @@ function canonicalGroupKey(fields, row) {
 }
 
 // src/money/money-reducer.ts
-function toScaledInt(v) {
-  if (typeof v === "string" || typeof v === "number" || typeof v === "bigint") {
-    try {
-      return BigInt(v);
-    } catch {
-      return null;
+function toScaledIntFromAny(v, scale) {
+  if (typeof v === "bigint") return v;
+  if (typeof v === "number") {
+    const r = parseToScaledInt(v, scale);
+    return r.ok ? r.value : null;
+  }
+  if (typeof v === "string") {
+    if (!v.includes(".")) {
+      try {
+        return BigInt(v);
+      } catch {
+        return null;
+      }
     }
+    const r = parseToScaledInt(v, scale);
+    return r.ok ? r.value : null;
   }
   return null;
 }
@@ -316,13 +407,15 @@ function readMoney(record, field, desc) {
   const raw = readPath(record, field);
   if (raw === null || raw === void 0) return null;
   if (desc.mode === "fixed") {
-    const value2 = toScaledInt(raw);
-    return value2 === null ? null : { currency: desc.fixedCurrency, value: value2 };
+    const cur = desc.fixedCurrency;
+    const value2 = toScaledIntFromAny(raw, desc.scaleFor(cur));
+    return value2 === null ? null : { currency: cur, value: value2 };
   }
   if (typeof raw !== "object") return null;
   const o = raw;
   if (typeof o.currency !== "string") return null;
-  const value = toScaledInt(o.amount);
+  const scale = desc.allows(o.currency) ? desc.scaleFor(o.currency) : 0;
+  const value = toScaledIntFromAny(o.amount, scale);
   return value === null ? null : { currency: o.currency, value };
 }
 function targetScaleFor(desc, currency) {
@@ -543,11 +636,14 @@ var GroupedQueryN = class extends GroupedQueryBase {
     );
   }
 };
-function groupAndReduce(records, fieldOrFields, spec) {
+function groupAndReduce(records, fieldOrFields, spec, moneyFields) {
   const fields = typeof fieldOrFields === "string" ? [fieldOrFields] : fieldOrFields;
   if (fields.length === 0) {
     throw new Error(".groupBy() requires at least one field");
   }
+  if (moneyFields) {
+    spec = wrapMoneyReducers(spec, moneyFields);
+  }
   const buckets = /* @__PURE__ */ new Map();
   const fieldLabel = fields.length === 1 ? fields[0] : `[${fields.join(", ")}]`;
   for (const record of records) {