@mulmoclaude/core 0.13.1 → 0.15.0

package/dist/deriveAll-CMFXDQ_G.js

@@ -1,506 +0,0 @@
-//#region src/collection/core/schema.ts
-/** Declarative retriever kinds a Feed's `ingest.kind` may declare. The host's
-*  feeds engine dispatches on these; they live here (with the schema contract)
-*  so the schema validator can enforce them. The host re-exports these from
-*  `server/workspace/feeds/ingestTypes.ts`. */
-var INGEST_KINDS = [
-	"rss",
-	"atom",
-	"http-json"
-];
-/** The agent-performed ingest kind. Instead of a declarative fetch, the host
-*  dispatches a hidden background chat (origin `system`) in `ingest.role`,
-*  seeded with `ingest.template` + a summary of every record, on the
-*  `ingest.schedule` cadence; the worker edits records via the collections io
-*  layer. Kept separate from {@link INGEST_KINDS} (which the declarative
-*  retriever registry keys on) so the schema validator can model `ingest` as a
-*  discriminated union without the feeds engine gaining an "agent" retriever. */
-var AGENT_INGEST_KIND = "agent";
-/** Refresh cadences a Feed's `ingest.schedule` may declare. */
-var FEED_SCHEDULES = [
-	"hourly",
-	"daily",
-	"weekly",
-	"on-demand"
-];
-/** Narrowing guard: true when `every` is the field-driven arm. */
-function isFieldDrivenEvery(every) {
-	return "fromField" in every;
-}
-/** Resolve an `embed` field's target record id: the fixed `id`, or the value
-*  of the sibling `idField` on this record (empty string when neither applies
-*  — the caller renders that as "no record"). Pure + isomorphic so the server
-*  projection (`derive.ts`) and the client preview (`useCollectionRendering`)
-*  resolve embeds identically. */
-function embedTargetId(field, record) {
-	if (field.id) return field.id;
-	if (field.idField && record) return String(record[field.idField] ?? "");
-	return "";
-}
-//#endregion
-//#region src/collection/core/where.ts
-/** True when `record[field]` is absent (`undefined`/`null`) — the only case
-*  where `ne` and every other op disagree on the result. */
-function isMissing(raw) {
-	return raw === void 0 || raw === null;
-}
-/** The effective comparison value for `cond`: its literal `value`, or — for
-*  a `valueFrom` reference — the target field read out of `recordsById`.
-*  `undefined` means UNRESOLVED (no such record, or the field on it is
-*  missing); the caller must treat that as "never matches", not as a
-*  literal `undefined` value to compare against. */
-function resolveValue(cond, record, recordsById) {
-	if (!cond.valueFrom) return cond.value;
-	const { record: refRecord, field } = cond.valueFrom;
-	const raw = (refRecord === void 0 ? record : recordsById[refRecord])?.[field];
-	return isMissing(raw) ? void 0 : String(raw);
-}
-function matchesNumericOp(operator, left, right) {
-	if (operator === "gt") return left > right;
-	if (operator === "gte") return left >= right;
-	if (operator === "lt") return left < right;
-	return left <= right;
-}
-/** `Number("")` / `Number("  ")` are `0`, not `NaN`, so treat a blank string
-*  as non-numeric explicitly — an empty field must fail a numeric compare,
-*  not read as zero. */
-function toNumber(raw) {
-	return raw.trim() === "" ? NaN : Number(raw);
-}
-function matchesNumeric(operator, raw, value) {
-	if (Array.isArray(value)) return false;
-	const left = toNumber(raw);
-	const right = toNumber(value);
-	if (Number.isNaN(left) || Number.isNaN(right)) return false;
-	return matchesNumericOp(operator, left, right);
-}
-/** True when the present string `raw` satisfies `operator` against the
-*  resolved `value` (field known to exist — MISSING is handled by the
-*  caller before this runs, and an UNRESOLVED `valueFrom` never reaches
-*  here either). */
-function matchesPresent(operator, raw, value) {
-	switch (operator) {
-		case "eq": return raw === String(value);
-		case "ne": return raw !== String(value);
-		case "in": return Array.isArray(value) && value.includes(raw);
-		case "contains": return raw.includes(String(value));
-		case "gt":
-		case "gte":
-		case "lt":
-		case "lte": return matchesNumeric(operator, raw, value);
-		default: return false;
-	}
-}
-/** True when `record` satisfies one condition, given `recordsById` to
-*  resolve a `valueFrom` reference. Two independent MISSING cases, checked
-*  in order:
-*  - `record[cond.field]` absent (`undefined`/`null`) → matches only `ne`
-*    (vacuously true — "not equal to X" holds when there's no value at
-*    all); every other op is false. Unchanged from the literal-`value`
-*    behaviour, regardless of whether `valueFrom` would also resolve.
-*  - the resolved comparison value is UNRESOLVED (a `valueFrom` whose
-*    target record/field doesn't exist) → false for EVERY op, including
-*    `ne` — a broken reference must never spuriously match. */
-function matchesCond(cond, record, recordsById) {
-	const raw = record[cond.field];
-	if (isMissing(raw)) return cond.op === "ne";
-	const value = resolveValue(cond, record, recordsById);
-	if (value === void 0) return false;
-	return matchesPresent(cond.op, String(raw), value);
-}
-/** True when `record` satisfies every condition in `where` (AND). An empty
-*  `where` matches everything. `recordsById` — the source collection's
-*  records keyed by primaryKey — resolves any `valueFrom` reference;
-*  omitted (default `{}`) for callers with no cross-record lookups, in
-*  which case every `valueFrom` condition is UNRESOLVED and so never
-*  matches. */
-function matchesWhere(where, record, recordsById = {}) {
-	return where.every((cond) => matchesCond(cond, record, recordsById));
-}
-//#endregion
-//#region src/collection/core/dynamicIcon.ts
-/** The record with the greatest `String(record[field])` (localeCompare) —
-*  ties keep the first-seen record (stable left-to-right `reduce`). */
-function latestByField(pool, field) {
-	return pool.reduce((latest, candidate) => String(candidate[field] ?? "").localeCompare(String(latest[field] ?? "")) > 0 ? candidate : latest);
-}
-/** Reduce `records` to the one record that decides the effective icon, per
-*  `source`'s `where` filter + `from` strategy:
-*  - pool = `source.where`-filtered records, or every record when unset;
-*  - an empty pool resolves to `null` (no source record → fallback);
-*  - `from: "first"` / `"when"` → the first pool record (storage order);
-*  - `from: "latest"` (default), with `orderBy` given → the pool record
-*    whose `String(record[orderBy])` sorts highest;
-*  - `from: "latest"`, with no `orderBy` → the last pool record.
-*  `recordsById` (the source collection's records keyed by primaryKey)
-*  resolves any `valueFrom` reference inside `source.where`; omitted for
-*  callers with no cross-record lookups. */
-function selectDynamicRecord(records, source, orderBy, recordsById = {}) {
-	const { where } = source;
-	const pool = where ? records.filter((record) => matchesWhere(where, record, recordsById)) : records;
-	if (pool.length === 0) return null;
-	if (source.from === "first" || source.from === "when") return pool[0];
-	return orderBy ? latestByField(pool, orderBy) : pool[pool.length - 1];
-}
-/** Map a resolved source record to the effective icon: `spec.fallback`
-*  (or the collection's own static `icon`) when there's no record or no
-*  rule matches; otherwise the `icon` of the first rule whose `where`
-*  matches the record. `recordsById` resolves any `valueFrom` reference
-*  inside a rule's `where`, same as `selectDynamicRecord`. */
-function resolveIcon(record, spec, staticIcon, recordsById = {}) {
-	const fallback = spec.fallback ?? staticIcon;
-	if (!record) return fallback;
-	const matched = spec.rules.find((rule) => matchesWhere(rule.where, record, recordsById));
-	return matched ? matched.icon : fallback;
-}
-var isDateLikeField = (field) => field.type === "date" || field.type === "datetime";
-/** The first field key (declaration order) whose type is `date` or
-*  `datetime` — the default `orderBy` for `from: "latest"` when a
-*  `DynamicIconSource` doesn't name one. `undefined` when the schema has
-*  no date-like field. */
-function firstDateField(schema) {
-	return Object.entries(schema.fields).find(([, field]) => isDateLikeField(field))?.[0];
-}
-//#endregion
-//#region src/collection/core/derivedFormula.ts
-function evaluateDerived(formula, ctx) {
-	let tokens;
-	try {
-		tokens = tokenize(formula);
-	} catch {
-		return null;
-	}
-	const parser = new Parser(tokens);
-	let ast;
-	try {
-		ast = parser.parseExpr();
-		if (!parser.atEnd()) return null;
-	} catch {
-		return null;
-	}
-	const value = evaluate(ast, ctx);
-	return Number.isFinite(value) ? value : null;
-}
-var SINGLE_CHAR_PUNCT = /* @__PURE__ */ new Set([
-	"(",
-	")",
-	"+",
-	"-",
-	"*",
-	"/",
-	"."
-]);
-function consumeWhitespace(cur) {
-	const char = cur.input[cur.index];
-	if (char === " " || char === "	" || char === "\n") {
-		cur.index++;
-		return true;
-	}
-	return false;
-}
-function consumeNumber(cur) {
-	const char = cur.input[cur.index] ?? "";
-	const next = cur.input[cur.index + 1] ?? "";
-	if (!isDigit(char) && !(char === "." && isDigit(next))) return null;
-	let raw = "";
-	while (cur.index < cur.input.length) {
-		const here = cur.input[cur.index] ?? "";
-		if (!isDigit(here) && here !== ".") break;
-		raw += here;
-		cur.index++;
-	}
-	const num = Number(raw);
-	if (!Number.isFinite(num)) throw new Error("bad number");
-	return {
-		kind: "number",
-		value: num
-	};
-}
-function consumeIdent(cur) {
-	if (!isIdentStart(cur.input[cur.index] ?? "")) return null;
-	let raw = "";
-	while (cur.index < cur.input.length && isIdentChar(cur.input[cur.index] ?? "")) {
-		raw += cur.input[cur.index];
-		cur.index++;
-	}
-	return {
-		kind: "ident",
-		value: raw
-	};
-}
-function consumePunct(cur) {
-	const char = cur.input[cur.index] ?? "";
-	if (char === "[" && cur.input[cur.index + 1] === "]") {
-		cur.index += 2;
-		return { kind: "[]" };
-	}
-	if (SINGLE_CHAR_PUNCT.has(char)) {
-		cur.index++;
-		return { kind: char };
-	}
-	return null;
-}
-function tokenize(input) {
-	const tokens = [];
-	const cur = {
-		input,
-		index: 0
-	};
-	while (cur.index < input.length) {
-		if (consumeWhitespace(cur)) continue;
-		const numTok = consumeNumber(cur);
-		if (numTok) {
-			tokens.push(numTok);
-			continue;
-		}
-		const punctTok = consumePunct(cur);
-		if (punctTok) {
-			tokens.push(punctTok);
-			continue;
-		}
-		const identTok = consumeIdent(cur);
-		if (identTok) {
-			tokens.push(identTok);
-			continue;
-		}
-		throw new Error(`unexpected char ${input[cur.index]}`);
-	}
-	return tokens;
-}
-function isDigit(char) {
-	return char >= "0" && char <= "9";
-}
-function isIdentStart(char) {
-	return char >= "a" && char <= "z" || char >= "A" && char <= "Z" || char === "_";
-}
-function isIdentChar(char) {
-	return isIdentStart(char) || isDigit(char);
-}
-var Parser = class {
-	tokens;
-	cursor = 0;
-	constructor(tokens) {
-		this.tokens = tokens;
-	}
-	atEnd() {
-		return this.cursor >= this.tokens.length;
-	}
-	peek() {
-		return this.tokens[this.cursor];
-	}
-	consume() {
-		const tok = this.tokens[this.cursor++];
-		if (!tok) throw new Error("unexpected end of input");
-		return tok;
-	}
-	expect(kind) {
-		const tok = this.consume();
-		if (tok.kind !== kind) throw new Error(`expected ${kind}, got ${tok.kind}`);
-		return tok;
-	}
-	parseExpr() {
-		let left = this.parseTerm();
-		while (this.peek()?.kind === "+" || this.peek()?.kind === "-") {
-			const operator = this.consume().kind;
-			const right = this.parseTerm();
-			left = {
-				kind: "binop",
-				operator,
-				left,
-				right
-			};
-		}
-		return left;
-	}
-	parseTerm() {
-		let left = this.parseFactor();
-		while (this.peek()?.kind === "*" || this.peek()?.kind === "/") {
-			const operator = this.consume().kind;
-			const right = this.parseFactor();
-			left = {
-				kind: "binop",
-				operator,
-				left,
-				right
-			};
-		}
-		return left;
-	}
-	parseFactor() {
-		const tok = this.peek();
-		if (!tok) throw new Error("unexpected end in factor");
-		if (tok.kind === "number") {
-			this.consume();
-			return {
-				kind: "num",
-				value: tok.value
-			};
-		}
-		if (tok.kind === "(") {
-			this.consume();
-			const inner = this.parseExpr();
-			this.expect(")");
-			return inner;
-		}
-		if (tok.kind === "ident") {
-			const name = tok.value ?? "";
-			if (name === "sum" && this.tokens[this.cursor + 1]?.kind === "(") {
-				this.consume();
-				this.expect("(");
-				const arg = this.parseSumArg();
-				this.expect(")");
-				return {
-					kind: "sum",
-					arg
-				};
-			}
-			this.consume();
-			if (this.peek()?.kind === ".") {
-				this.consume();
-				return {
-					kind: "ref",
-					field: name,
-					col: this.expect("ident").value
-				};
-			}
-			return {
-				kind: "ident",
-				name
-			};
-		}
-		throw new Error(`unexpected token ${tok.kind} in factor`);
-	}
-	parseSumArg() {
-		const factors = [];
-		const operators = [];
-		factors.push(this.parseTableCol());
-		while (this.peek()?.kind === "*" || this.peek()?.kind === "/") {
-			const operator = this.consume().kind;
-			operators.push(operator);
-			factors.push(this.parseTableCol());
-		}
-		return {
-			factors,
-			operators
-		};
-	}
-	parseTableCol() {
-		const tableTok = this.expect("ident");
-		this.expect("[]");
-		this.expect(".");
-		const colTok = this.expect("ident");
-		return {
-			table: tableTok.value,
-			col: colTok.value
-		};
-	}
-};
-function evaluate(node, ctx) {
-	if (node.kind === "num") return node.value;
-	if (node.kind === "ident") {
-		const raw = ctx.record[node.name];
-		return toFiniteNumber(raw);
-	}
-	if (node.kind === "ref") {
-		const target = ctx.refs?.[node.field] ?? null;
-		if (!target) return NaN;
-		return toFiniteNumber(target[node.col]);
-	}
-	if (node.kind === "binop") {
-		const left = evaluate(node.left, ctx);
-		const right = evaluate(node.right, ctx);
-		return applyBinop(node.operator, left, right);
-	}
-	if (node.kind === "sum") return evaluateSum(node.arg, ctx);
-	throw new Error(`unknown node`);
-}
-function applyBinop(operator, left, right) {
-	if (!Number.isFinite(left) || !Number.isFinite(right)) return NaN;
-	if (operator === "+") return left + right;
-	if (operator === "-") return left - right;
-	if (operator === "*") return left * right;
-	if (right === 0) return NaN;
-	return left / right;
-}
-function evaluateSum(arg, ctx) {
-	if (arg.factors.length === 0) return 0;
-	const tableName = arg.factors[0].table;
-	for (const factor of arg.factors) if (factor.table !== tableName) return NaN;
-	const rows = ctx.record[tableName];
-	if (!Array.isArray(rows)) return 0;
-	let total = 0;
-	for (const row of rows) {
-		if (!row || typeof row !== "object") continue;
-		let product = toFiniteNumber(row[arg.factors[0].col]);
-		if (!Number.isFinite(product)) return NaN;
-		for (let i = 1; i < arg.factors.length; i++) {
-			const value = toFiniteNumber(row[arg.factors[i].col]);
-			if (!Number.isFinite(value)) return NaN;
-			product = applyBinop(arg.operators[i - 1], product, value);
-		}
-		total += product;
-	}
-	return total;
-}
-function toFiniteNumber(value) {
-	if (typeof value === "number") return Number.isFinite(value) ? value : NaN;
-	if (typeof value === "string" && value.length > 0) {
-		const num = Number(value);
-		return Number.isFinite(num) ? num : NaN;
-	}
-	return NaN;
-}
-//#endregion
-//#region src/collection/core/deriveAll.ts
-/** Map each `ref` field's stored slug to its loaded target record (or
-*  null when dangling / not loaded), keyed by the LOCAL field name —
-*  the shape `evaluateDerived` reads for `<field>.<col>` derefs. */
-function resolveRowRefs(schema, record, refRecords) {
-	const refs = {};
-	for (const [key, field] of Object.entries(schema.fields)) {
-		if (field.type !== "ref" || !field.to) continue;
-		const slug = record[key];
-		refs[key] = typeof slug === "string" ? refRecords[field.to]?.[slug] ?? null : null;
-	}
-	return refs;
-}
-/** Evaluate every `derived` field against `base`, saturating so a
-*  derived field can read another derived field computed in an earlier
-*  pass (`subtotal → tax → total` converges in ≤ field-count passes).
-*  Cycles can't loop forever — passes are bounded by the number of
-*  derived fields and the loop breaks as soon as a pass changes
-*  nothing. Failed formulas stay ABSENT (the UI renders them as
-*  em-dash). Returns a copy; `base` is never mutated.
-*
-*  Derived keys already present in `base` are stripped before
-*  evaluation: computed output is host-truth, never persisted-input
-*  fallback. A record JSON can carry a stale (or forged) derived value
-*  — raw Write/Edit, legacy data — and without the strip, a failing
-*  formula would silently surface that value as if the host computed
-*  it. */
-function deriveAll(schema, base, refRecords) {
-	const derivedKeys = new Set(Object.keys(schema.fields).filter((key) => schema.fields[key]?.type === "derived"));
-	const enriched = Object.fromEntries(Object.entries(base).filter(([key]) => !derivedKeys.has(key)));
-	const refs = resolveRowRefs(schema, base, refRecords);
-	const maxPasses = Object.values(schema.fields).filter((field) => field.type === "derived").length;
-	for (let pass = 0; pass < maxPasses; pass++) {
-		let mutated = false;
-		for (const [key, field] of Object.entries(schema.fields)) {
-			if (field.type !== "derived" || !field.formula) continue;
-			const next = evaluateDerived(field.formula, {
-				record: enriched,
-				refs
-			});
-			if (next !== null && enriched[key] !== next) {
-				enriched[key] = next;
-				mutated = true;
-			}
-		}
-		if (!mutated) break;
-	}
-	return enriched;
-}
-//#endregion
-export { resolveIcon as a, AGENT_INGEST_KIND as c, embedTargetId as d, isFieldDrivenEvery as f, firstDateField as i, FEED_SCHEDULES as l, resolveRowRefs as n, selectDynamicRecord as o, evaluateDerived as r, matchesWhere as s, deriveAll as t, INGEST_KINDS as u };
-
-//# sourceMappingURL=deriveAll-CMFXDQ_G.js.map