@noy-db/hub 0.3.0-pre.1 → 0.3.0-pre.11

package/dist/chunk-LV7M27WM.js

@@ -1,702 +0,0 @@
-import {
-  MoneyUnsupportedError,
-  formatScaledInt,
-  parseToScaledInt,
-  readPath,
-  scaleForCurrency
-} from "./chunk-M2YKN37S.js";
-import {
-  applyI18nLocale
-} from "./chunk-5LUY7UTV.js";
-import {
-  GroupCardinalityError
-} from "./chunk-ZYUC53LT.js";
-
-// src/with-lookup/aggregate/reducers.ts
-function count(opts) {
-  const _seed = opts?.seed;
-  void _seed;
-  return {
-    op: "count",
-    init: () => 0,
-    step: (state) => state + 1,
-    remove: (state) => state - 1,
-    finalize: (state) => state,
-    merge: (a, b) => a + b
-  };
-}
-function sum(field, opts) {
-  const _seed = opts?.seed;
-  void _seed;
-  return {
-    op: "sum",
-    field,
-    // Money-only metadata, read by `wrapMoneyReducers`. No effect on a
-    // generic numeric sum.
-    ...opts?.convertTo !== void 0 ? { convertTo: opts.convertTo } : {},
-    ...opts?.fx !== void 0 ? { fx: opts.fx } : {},
-    init: () => 0,
-    step: (state, record) => state + readNumber(record, field),
-    remove: (state, record) => state - readNumber(record, field),
-    finalize: (state) => state,
-    merge: (a, b) => a + b
-  };
-}
-function avg(field, opts) {
-  const _seed = opts?.seed;
-  void _seed;
-  return {
-    op: "avg",
-    field,
-    init: () => ({ sum: 0, count: 0 }),
-    step: (state, record) => ({
-      sum: state.sum + readNumber(record, field),
-      count: state.count + 1
-    }),
-    remove: (state, record) => ({
-      sum: state.sum - readNumber(record, field),
-      count: state.count - 1
-    }),
-    finalize: (state) => state.count === 0 ? null : state.sum / state.count,
-    merge: (a, b) => ({ sum: a.sum + b.sum, count: a.count + b.count })
-  };
-}
-function pushValue(state, value) {
-  return { values: [...state.values, value] };
-}
-function removeValue(state, value) {
-  const idx = state.values.indexOf(value);
-  if (idx < 0) return state;
-  const next = state.values.slice();
-  next.splice(idx, 1);
-  return { values: next };
-}
-function min(field, opts) {
-  const _seed = opts?.seed;
-  void _seed;
-  return {
-    op: "min",
-    field,
-    init: () => ({ values: [] }),
-    step: (state, record) => pushValue(state, readNumber(record, field)),
-    remove: (state, record) => removeValue(state, readNumber(record, field)),
-    finalize: (state) => {
-      if (state.values.length === 0) return null;
-      let out = state.values[0];
-      for (let i = 1; i < state.values.length; i++) {
-        const v = state.values[i];
-        if (v < out) out = v;
-      }
-      return out;
-    },
-    merge: (a, b) => ({ values: [...a.values, ...b.values] })
-  };
-}
-function max(field, opts) {
-  const _seed = opts?.seed;
-  void _seed;
-  return {
-    op: "max",
-    field,
-    init: () => ({ values: [] }),
-    step: (state, record) => pushValue(state, readNumber(record, field)),
-    remove: (state, record) => removeValue(state, readNumber(record, field)),
-    finalize: (state) => {
-      if (state.values.length === 0) return null;
-      let out = state.values[0];
-      for (let i = 1; i < state.values.length; i++) {
-        const v = state.values[i];
-        if (v > out) out = v;
-      }
-      return out;
-    },
-    merge: (a, b) => ({ values: [...a.values, ...b.values] })
-  };
-}
-function moneySum(field, opts) {
-  return sum(field, opts);
-}
-function moneyMin(field, opts) {
-  return min(field, opts);
-}
-function moneyMax(field, opts) {
-  return max(field, opts);
-}
-var reducerBuilder = {
-  count,
-  // The generic F parameter on sum/min/max in the interface is type-only; the
-  // standalone factories are plain `(field: string)` functions. With M=never the
-  // conditional return collapses to the numeric branch, matching the factories'
-  // return type, but TypeScript cannot verify that collapse for a generic method
-  // signature — so each factory is cast directly to the method's type.
-  sum,
-  avg,
-  min,
-  max,
-  moneySum,
-  moneyMin,
-  moneyMax
-};
-function readNumber(record, field) {
-  const value = readPath(record, field);
-  if (typeof value === "object" && value !== null && "amount" in value && "currency" in value) {
-    throw new Error(
-      `aggregate: field "${field}" holds a money value but was not money-aware \u2014 declare it in the collection's moneyFields so sum/min/max stay exact`
-    );
-  }
-  return typeof value === "number" && Number.isFinite(value) ? value : 0;
-}
-
-// src/with-lookup/aggregate/aggregation.ts
-function reduceRecords(records, spec) {
-  const state = {};
-  for (const key of Object.keys(spec)) {
-    state[key] = spec[key].init();
-  }
-  for (const record of records) {
-    for (const key of Object.keys(spec)) {
-      state[key] = spec[key].step(state[key], record);
-    }
-  }
-  const result = {};
-  for (const key of Object.keys(spec)) {
-    result[key] = spec[key].finalize(state[key]);
-  }
-  return result;
-}
-var LiveAggregationImpl = class {
-  constructor(recompute, upstreams) {
-    this.recompute = recompute;
-    try {
-      this.value = recompute();
-      this.error = void 0;
-    } catch (err) {
-      this.value = void 0;
-      this.error = err;
-    }
-    for (const upstream of upstreams) {
-      const unsub = upstream.subscribe(() => this.refresh());
-      this.unsubscribes.push(unsub);
-    }
-  }
-  recompute;
-  value;
-  error;
-  listeners = /* @__PURE__ */ new Set();
-  unsubscribes = [];
-  stopped = false;
-  refresh() {
-    if (this.stopped) return;
-    try {
-      this.value = this.recompute();
-      this.error = void 0;
-    } catch (err) {
-      this.error = err;
-    }
-    for (const listener of this.listeners) {
-      try {
-        listener();
-      } catch (err) {
-        console.warn("[noy-db] LiveAggregation listener threw:", err);
-      }
-    }
-  }
-  subscribe(cb) {
-    if (this.stopped) {
-      return () => {
-      };
-    }
-    this.listeners.add(cb);
-    return () => {
-      this.listeners.delete(cb);
-    };
-  }
-  stop() {
-    if (this.stopped) return;
-    this.stopped = true;
-    for (const unsub of this.unsubscribes) {
-      try {
-        unsub();
-      } catch (err) {
-        console.warn("[noy-db] LiveAggregation upstream unsubscribe threw:", err);
-      }
-    }
-    this.unsubscribes.length = 0;
-    this.listeners.clear();
-  }
-};
-var Aggregation = class {
-  constructor(executeRecords, spec, upstreams) {
-    this.executeRecords = executeRecords;
-    this.spec = spec;
-    this.upstreams = upstreams;
-  }
-  executeRecords;
-  spec;
-  upstreams;
-  /**
-   * Execute the query and reduce the results synchronously.
-   * Returns the reduced shape matching the spec — e.g. a spec of
-   * `{ total: sum('amount'), n: count() }` returns
-   * `{ total: number, n: number }`.
-   */
-  run() {
-    return reduceRecords(this.executeRecords(), this.spec);
-  }
-  /**
-   * Build a reactive `LiveAggregation<R>` that re-runs the reduction
-   * whenever any upstream source notifies of a change. The initial
-   * value is computed eagerly in the constructor, so consumers can
-   * read `live.value` immediately after calling `.live()`.
-   *
-   * Always call `live.stop()` when finished — it tears down the
-   * upstream subscriptions. Vue's `onUnmounted` is the canonical
-   * place.
-   *
-   * **Implementation note:** every upstream change triggers a full
-   * re-reduction. Incremental maintenance (O(1) per delta for
-   * sum/count/avg via the reducer protocol's `remove()` method) is a
-   * planned follow-up optimization — the protocol already supports
-   * it, but the executor doesn't drive it yet. Consumers get
-   * correct, reactive values today; future PRs can switch to
-   * delta-based maintenance without changing this API.
-   */
-  live() {
-    const recompute = () => reduceRecords(this.executeRecords(), this.spec);
-    return new LiveAggregationImpl(recompute, this.upstreams);
-  }
-};
-function buildLiveAggregation(recompute, upstreams) {
-  return new LiveAggregationImpl(recompute, upstreams);
-}
-
-// src/with-lookup/aggregate/canonical-key.ts
-function canonicalGroupKey(fields, row) {
-  const sorted = [...fields].sort();
-  const parts = [];
-  for (const name of sorted) {
-    const v = row[name];
-    const serialised = v === void 0 ? "undefined" : JSON.stringify(v);
-    parts.push(`${name}=${serialised}`);
-  }
-  return parts.join("|");
-}
-
-// src/with-shape/money/money-reducer.ts
-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;
-}
-function readMoney(record, field, desc) {
-  const raw = readPath(record, field);
-  if (raw === null || raw === void 0) return null;
-  if (desc.mode === "fixed") {
-    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 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) {
-  if (desc.allows(currency)) return desc.scaleFor(currency);
-  const s = scaleForCurrency(currency);
-  if (s === null) {
-    throw new Error(`money: cannot determine scale for conversion target "${currency}"`);
-  }
-  return s;
-}
-function parseRate(rate) {
-  const s = String(rate).trim();
-  const neg = s.startsWith("-");
-  const body = neg ? s.slice(1) : s;
-  const dot = body.indexOf(".");
-  const intPart = dot === -1 ? body : body.slice(0, dot);
-  const fracPart = dot === -1 ? "" : body.slice(dot + 1);
-  const int = BigInt((intPart === "" ? "0" : intPart) + fracPart);
-  return { int: neg ? -int : int, scale: fracPart.length };
-}
-function divRoundHalfEven(n, d) {
-  const q = n / d;
-  const r = n % d;
-  const twiceR = (r < 0n ? -r : r) * 2n;
-  if (twiceR < d) return q;
-  if (twiceR > d) return q + (n < 0n ? -1n : 1n);
-  return q % 2n === 0n ? q : q + (n < 0n ? -1n : 1n);
-}
-function convertScaled(value, srcScale, rate, targetScale) {
-  const { int: rateInt, scale: rateScale } = parseRate(rate);
-  const product = value * rateInt;
-  const curScale = srcScale + rateScale;
-  if (curScale === targetScale) return product;
-  if (curScale < targetScale) return product * 10n ** BigInt(targetScale - curScale);
-  return divRoundHalfEven(product, 10n ** BigInt(curScale - targetScale));
-}
-function finalizeSum(state, desc, convertTo, fx) {
-  if (convertTo !== void 0) {
-    if (fx === void 0) {
-      throw new Error(`money: sum convertTo "${convertTo}" requires an fx rate map`);
-    }
-    const targetScale = targetScaleFor(desc, convertTo);
-    let total = 0n;
-    for (const [cur, v] of state) {
-      if (cur === convertTo) {
-        total += convertScaled(v, desc.scaleFor(cur), 1, targetScale);
-        continue;
-      }
-      const rate = fx[`${cur}->${convertTo}`];
-      if (rate === void 0) {
-        throw new Error(`money: no fx rate for "${cur}->${convertTo}"`);
-      }
-      total += convertScaled(v, desc.scaleFor(cur), rate, targetScale);
-    }
-    return formatScaledInt(total, targetScale);
-  }
-  if (desc.mode === "fixed") {
-    const cur = desc.fixedCurrency;
-    return formatScaledInt(state.get(cur) ?? 0n, desc.scaleFor(cur));
-  }
-  const out = {};
-  for (const [cur, v] of state) out[cur] = formatScaledInt(v, desc.scaleFor(cur));
-  return out;
-}
-function moneySumReducer(field, desc, convertTo, fx) {
-  return {
-    op: "sum",
-    field,
-    init: () => /* @__PURE__ */ new Map(),
-    step: (state, record) => {
-      const m = readMoney(record, field, desc);
-      if (m) state.set(m.currency, (state.get(m.currency) ?? 0n) + m.value);
-      return state;
-    },
-    remove: (state, record) => {
-      const m = readMoney(record, field, desc);
-      if (m) state.set(m.currency, (state.get(m.currency) ?? 0n) - m.value);
-      return state;
-    },
-    finalize: (state) => finalizeSum(state, desc, convertTo, fx)
-  };
-}
-function extremum(values, op) {
-  let out = values[0];
-  for (let i = 1; i < values.length; i++) {
-    const v = values[i];
-    if (op === "min" ? v < out : v > out) out = v;
-  }
-  return out;
-}
-function moneyMinMaxReducer(op, field, desc) {
-  return {
-    op,
-    field,
-    init: () => /* @__PURE__ */ new Map(),
-    step: (state, record) => {
-      const m = readMoney(record, field, desc);
-      if (m) {
-        const arr = state.get(m.currency);
-        if (arr) arr.push(m.value);
-        else state.set(m.currency, [m.value]);
-      }
-      return state;
-    },
-    remove: (state, record) => {
-      const m = readMoney(record, field, desc);
-      if (m) {
-        const arr = state.get(m.currency);
-        if (arr) {
-          const idx = arr.indexOf(m.value);
-          if (idx >= 0) arr.splice(idx, 1);
-        }
-      }
-      return state;
-    },
-    finalize: (state) => {
-      if (desc.mode === "fixed") {
-        const cur = desc.fixedCurrency;
-        const arr = state.get(cur);
-        if (!arr || arr.length === 0) return null;
-        return formatScaledInt(extremum(arr, op), desc.scaleFor(cur));
-      }
-      const out = {};
-      for (const [cur, arr] of state) {
-        if (arr.length > 0) out[cur] = formatScaledInt(extremum(arr, op), desc.scaleFor(cur));
-      }
-      return out;
-    }
-  };
-}
-function wrapMoneyReducers(spec, moneyFields) {
-  let changed = false;
-  const out = {};
-  for (const [key, reducer] of Object.entries(spec)) {
-    const field = reducer.field;
-    const desc = field ? moneyFields[field] : void 0;
-    if (desc && reducer.op === "avg") {
-      throw new MoneyUnsupportedError(
-        field,
-        `avg() is not supported on money field "${field}" in v1 \u2014 use sum() and count() and divide at the boundary.`
-      );
-    }
-    if (desc && (reducer.op === "sum" || reducer.op === "min" || reducer.op === "max")) {
-      changed = true;
-      out[key] = reducer.op === "sum" ? moneySumReducer(field, desc, reducer.convertTo, reducer.fx) : moneyMinMaxReducer(reducer.op, field, desc);
-    } else {
-      out[key] = reducer;
-    }
-  }
-  return changed ? out : spec;
-}
-
-// src/with-lookup/aggregate/groupby.ts
-var GROUPBY_WARN_CARDINALITY = 1e4;
-var GROUPBY_MAX_CARDINALITY = 1e5;
-var warnedCardinalityFields = /* @__PURE__ */ new Set();
-function warnCardinalityApproaching(fields, observed) {
-  const key = JSON.stringify([...fields].sort());
-  if (warnedCardinalityFields.has(key)) return;
-  warnedCardinalityFields.add(key);
-  const label = `[${fields.join(", ")}]`;
-  console.warn(
-    `[noy-db] .groupBy(${label}) produced ${observed} distinct groups, ${Math.round(observed / GROUPBY_MAX_CARDINALITY * 100)}% of the ${GROUPBY_MAX_CARDINALITY}-group ceiling. Narrow the query with .where() before grouping, or switch to a lower-cardinality field.`
-  );
-}
-function resetGroupByWarnings() {
-  warnedCardinalityFields.clear();
-}
-var GroupedQueryBase = class {
-  constructor(executeRecords, fieldOrFields, upstreams, dictLabelResolver, moneyFields) {
-    this.executeRecords = executeRecords;
-    this.upstreams = upstreams;
-    this.dictLabelResolver = dictLabelResolver;
-    this.moneyFields = moneyFields;
-    this.fields = typeof fieldOrFields === "string" ? [fieldOrFields] : [...fieldOrFields];
-  }
-  executeRecords;
-  upstreams;
-  dictLabelResolver;
-  moneyFields;
-  /**
-   * Field set this grouped query buckets on. Stored in declaration
-   * order — the same order is preserved on every result row by
-   * `groupAndReduce`. For the single-field constructor, this is
-   * `[field]`.
-   */
-  fields;
-  /** Apply money-aware reducer rewriting when money fields are declared. */
-  wrapSpec(spec) {
-    return this.moneyFields ? wrapMoneyReducers(spec, this.moneyFields) : spec;
-  }
-};
-var GroupedQuery = class extends GroupedQueryBase {
-  aggregate(specOrBuild) {
-    const spec = typeof specOrBuild === "function" ? specOrBuild(reducerBuilder) : specOrBuild;
-    return new GroupedAggregation(
-      this.executeRecords,
-      this.fields,
-      this.wrapSpec(spec),
-      this.upstreams,
-      this.dictLabelResolver
-    );
-  }
-};
-var GroupedQueryN = class extends GroupedQueryBase {
-  aggregate(specOrBuild) {
-    const spec = typeof specOrBuild === "function" ? specOrBuild(reducerBuilder) : specOrBuild;
-    return new GroupedAggregation(
-      this.executeRecords,
-      this.fields,
-      this.wrapSpec(spec),
-      this.upstreams,
-      this.dictLabelResolver
-    );
-  }
-};
-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) {
-    const keyValues = {};
-    for (const f of fields) {
-      keyValues[f] = readPath(record, f);
-    }
-    const dedupKey = canonicalGroupKey(fields, keyValues);
-    let bucket = buckets.get(dedupKey);
-    if (bucket === void 0) {
-      if (buckets.size >= GROUPBY_MAX_CARDINALITY) {
-        throw new GroupCardinalityError(
-          fieldLabel,
-          buckets.size + 1,
-          GROUPBY_MAX_CARDINALITY
-        );
-      }
-      bucket = { keyValues, records: [] };
-      buckets.set(dedupKey, bucket);
-    }
-    bucket.records.push(record);
-  }
-  if (buckets.size >= GROUPBY_WARN_CARDINALITY) {
-    warnCardinalityApproaching(fields, buckets.size);
-  }
-  const reducerKeys = Object.keys(spec);
-  const out = [];
-  for (const bucket of buckets.values()) {
-    const state = {};
-    for (const rk of reducerKeys) {
-      state[rk] = spec[rk].init();
-    }
-    for (const record of bucket.records) {
-      for (const rk of reducerKeys) {
-        state[rk] = spec[rk].step(state[rk], record);
-      }
-    }
-    const row = {};
-    for (const f of fields) {
-      row[f] = bucket.keyValues[f];
-    }
-    for (const rk of reducerKeys) {
-      row[rk] = spec[rk].finalize(state[rk]);
-    }
-    out.push(row);
-  }
-  return out;
-}
-var GroupedAggregation = class {
-  constructor(executeRecords, fields, spec, upstreams, dictLabelResolver) {
-    this.executeRecords = executeRecords;
-    this.spec = spec;
-    this.upstreams = upstreams;
-    this.dictLabelResolver = dictLabelResolver;
-    this.fields = typeof fields === "string" ? [fields] : [...fields];
-  }
-  executeRecords;
-  spec;
-  upstreams;
-  dictLabelResolver;
-  fields;
-  /**
-   * Execute the query, group, reduce, and return an array of rows.
-   *
-   * `opts` (query-form MV grouping): when a `locale` + `i18nFields` are
-   * given, the declared group-key `i18nText` fields are resolved to that locale
-   * at the `mv` layer BEFORE bucketing — so an i18n group key is a stable string
-   * instead of a raw `{locale}` map. The MV executor passes the MV's
-   * `i18nLocale`/`i18nFields`; ordinary `.run()` callers pass nothing and are
-   * unaffected.
-   */
-  run(opts) {
-    let records = this.executeRecords();
-    if (opts?.locale !== void 0 && opts.i18nFields !== void 0) {
-      const groupI18n = {};
-      for (const f of this.fields) {
-        const d = opts.i18nFields[f];
-        if (d !== void 0) groupI18n[f] = d;
-      }
-      if (Object.keys(groupI18n).length > 0) {
-        records = records.map((r) => applyI18nLocale(r, groupI18n, opts.locale, void 0, "mv"));
-      }
-    }
-    return groupAndReduce(records, this.fields, this.spec);
-  }
-  /**
-   * Execute the query, group, reduce, and resolve `<field>Label` for
-   * each result row when the grouping field is a `dictKey` and a
-   * `locale` is provided. Returns `R[]` synchronously when
-   * no locale is specified (identical to `.run()`).
-   *
-   * The `<field>Label` field is appended to each row. Rows whose group
-   * key has no dictionary entry get `<field>Label: undefined`.
-   *
-   * Dict-label resolution is single-field only — multi-key groupings
-   * do not produce a `<field>Label`. The resolver is only attached
-   * by the builder when `fields.length === 1`.
-   */
-  async runAsync(opts) {
-    const rows = groupAndReduce(this.executeRecords(), this.fields, this.spec);
-    if (!opts?.locale || !this.dictLabelResolver || this.fields.length !== 1) return rows;
-    const resolve = this.dictLabelResolver;
-    const locale = opts.locale;
-    const fallback = opts.fallback;
-    const field = this.fields[0];
-    const labelKey = `${field}Label`;
-    return Promise.all(
-      rows.map(async (row) => {
-        const key = row[field];
-        if (typeof key !== "string") return row;
-        const label = await resolve(key, locale, fallback);
-        return { ...row, [labelKey]: label };
-      })
-    );
-  }
-  /**
-   * Build a reactive `LiveAggregation<R[]>` that re-runs the full
-   * group-and-reduce pipeline whenever any upstream source notifies
-   * of a change. Same error-isolation and idempotent-stop contract
-   * as `Aggregation.live()` — the implementation delegates to the
-   * same `LiveAggregationImpl` class by threading a fresh
-   * recompute closure through the existing constructor.
-   *
-   * uses naive full re-run on every change. Incremental
-   * per-bucket maintenance (apply `step` on inserted records,
-   * `remove` on deleted records, route by bucket key) is a future
-   * optimization — the reducer protocol admits it, but wiring
-   * delta-aware source subscriptions is a separate PR.
-   *
-   * Always call `live.stop()` when finished.
-   */
-  live() {
-    const recompute = () => groupAndReduce(this.executeRecords(), this.fields, this.spec);
-    return buildLiveAggregation(recompute, this.upstreams);
-  }
-};
-
-export {
-  count,
-  sum,
-  avg,
-  min,
-  max,
-  moneySum,
-  moneyMin,
-  moneyMax,
-  reducerBuilder,
-  wrapMoneyReducers,
-  reduceRecords,
-  Aggregation,
-  buildLiveAggregation,
-  canonicalGroupKey,
-  GROUPBY_WARN_CARDINALITY,
-  GROUPBY_MAX_CARDINALITY,
-  resetGroupByWarnings,
-  GroupedQuery,
-  GroupedQueryN,
-  groupAndReduce,
-  GroupedAggregation
-};
-//# sourceMappingURL=chunk-LV7M27WM.js.map