better-supabase 0.14.0 → 0.15.0

package/dist/rrule-xDm2znty.js

@@ -1,290 +0,0 @@
-import { t as temporal } from "./temporal-required-B8qQHYbI.js";
-//#region src/blocks/reminders/rrule.ts
-/**
-* Expands an RFC 5545 recurrence rule on `Temporal.ZonedDateTime`, so a local
-* time stays on the same clock time across a daylight-saving change. Covered
-* parts: FREQ, INTERVAL, COUNT, UNTIL, BYDAY (with ordinals), BYMONTHDAY,
-* BYMONTH, BYSETPOS and WKST.
-*/
-const DAYS = {
-	MO: 1,
-	TU: 2,
-	WE: 3,
-	TH: 4,
-	FR: 5,
-	SA: 6,
-	SU: 7
-};
-const DAY_NAME = [
-	"",
-	"MO",
-	"TU",
-	"WE",
-	"TH",
-	"FR",
-	"SA",
-	"SU"
-];
-function part(text) {
-	const body = text.replace(/^RRULE:/i, "").trim();
-	const fields = new Map(body.split(";").map((item) => {
-		const eq = item.indexOf("=");
-		return [item.slice(0, eq).toUpperCase(), item.slice(eq + 1)];
-	}));
-	const frequency = frequencyOf(fields.get("FREQ"));
-	const interval = Number(fields.get("INTERVAL") ?? "1");
-	if (!Number.isInteger(interval) || interval < 1) throw new TypeError("INTERVAL must be a positive integer");
-	const countText = fields.get("COUNT");
-	const count = countText === void 0 ? void 0 : Number(countText);
-	if (count !== void 0 && (!Number.isInteger(count) || count < 1)) throw new TypeError("COUNT must be a positive integer");
-	const untilText = fields.get("UNTIL");
-	const byDay = (fields.get("BYDAY") ?? "").split(",").filter(Boolean).map(dayRule);
-	return {
-		frequency,
-		interval,
-		count,
-		until: untilText === void 0 ? void 0 : until(untilText),
-		byDay,
-		byMonthDay: numbers(fields.get("BYMONTHDAY")),
-		byMonth: numbers(fields.get("BYMONTH")),
-		bySetPos: numbers(fields.get("BYSETPOS")),
-		weekStart: DAYS[fields.get("WKST") ?? "MO"] ?? 1
-	};
-}
-function dayRule(text) {
-	const match = /^([+-]?\d+)?(MO|TU|WE|TH|FR|SA|SU)$/.exec(text.toUpperCase());
-	if (!match) throw new TypeError(`BYDAY value ${text} is not a weekday`);
-	const day = DAYS[match[2] ?? ""];
-	if (day === void 0) throw new TypeError(`BYDAY value ${text} is not a weekday`);
-	return {
-		ordinal: match[1] === void 0 ? void 0 : Number(match[1]),
-		day
-	};
-}
-function numbers(text) {
-	if (text === void 0 || text === "") return [];
-	return text.split(",").map((item) => {
-		const value = Number(item);
-		if (!Number.isInteger(value) || value === 0) throw new TypeError(`recurrence part ${item} is not a non-zero integer`);
-		return value;
-	});
-}
-function until(text) {
-	const match = /^(\d{4})(\d{2})(\d{2})T(\d{2})(\d{2})(\d{2})Z$/.exec(text);
-	if (!match) throw new TypeError("UNTIL must be a UTC date-time");
-	const [, year, month, day, hour, minute, second] = match;
-	return temporal().Instant.from(`${year}-${month}-${day}T${hour}:${minute}:${second}Z`);
-}
-const COLUMN_FREQUENCY = {
-	daily: "DAILY",
-	weekly: "WEEKLY",
-	monthly: "MONTHLY",
-	yearly: "YEARLY"
-};
-function frequencyOf(value) {
-	if (value === "DAILY" || value === "WEEKLY" || value === "MONTHLY" || value === "YEARLY") return value;
-	throw new TypeError("an RRULE needs FREQ of DAILY, WEEKLY, MONTHLY or YEARLY");
-}
-function fromColumns(columns) {
-	const frequency = COLUMN_FREQUENCY[columns.frequency];
-	const byDay = columns.monthWeekday === void 0 ? (columns.weekDays ?? []).map((day) => ({
-		ordinal: void 0,
-		day
-	})) : [{
-		ordinal: columns.monthOrdinal,
-		day: columns.monthWeekday
-	}];
-	return {
-		frequency,
-		interval: columns.interval ?? 1,
-		count: columns.count,
-		until: columns.until,
-		byDay,
-		byMonthDay: columns.monthDay === void 0 ? [] : [columns.monthDay],
-		byMonth: [],
-		bySetPos: [],
-		weekStart: 1
-	};
-}
-function at(date, start) {
-	return date.toZonedDateTime({
-		timeZone: start.timeZoneId,
-		plainTime: start.toPlainTime()
-	});
-}
-function monthDay(year, month, which) {
-	const dates = temporal().PlainDate;
-	const length = dates.from({
-		year,
-		month,
-		day: 1
-	}).daysInMonth;
-	const day = which > 0 ? which : length + which + 1;
-	if (day < 1 || day > length) return;
-	return dates.from({
-		year,
-		month,
-		day
-	});
-}
-function nthWeekday(year, month, ordinal, weekday) {
-	const dates = temporal().PlainDate;
-	const first = dates.from({
-		year,
-		month,
-		day: 1
-	});
-	const length = first.daysInMonth;
-	if (ordinal > 0) {
-		const day = 1 + (weekday - first.dayOfWeek + 7) % 7 + (ordinal - 1) * 7;
-		if (day > length) return;
-		return dates.from({
-			year,
-			month,
-			day
-		});
-	}
-	const day = length - (dates.from({
-		year,
-		month,
-		day: length
-	}).dayOfWeek - weekday + 7) % 7 + (ordinal + 1) * 7;
-	if (day < 1) return;
-	return dates.from({
-		year,
-		month,
-		day
-	});
-}
-function weekOf(date, weekStart) {
-	const delta = (date.dayOfWeek - weekStart + 7) % 7;
-	return date.subtract({ days: delta });
-}
-function periodDates(start, rule, index) {
-	const anchor = start.toPlainDate();
-	if (rule.frequency === "DAILY") {
-		const date = anchor.add({ days: index * rule.interval });
-		if (rule.byDay.length > 0 && !rule.byDay.some((item) => item.day === date.dayOfWeek)) return [];
-		return [date];
-	}
-	if (rule.frequency === "WEEKLY") {
-		const week = weekOf(anchor, rule.weekStart).add({ weeks: index * rule.interval });
-		return (rule.byDay.length === 0 ? [{
-			ordinal: void 0,
-			day: anchor.dayOfWeek
-		}] : rule.byDay).map((item) => week.add({ days: (item.day - rule.weekStart + 7) % 7 }));
-	}
-	const moved = rule.frequency === "MONTHLY" ? anchor.add({ months: index * rule.interval }) : anchor.add({ years: index * rule.interval });
-	const months = rule.byMonth.length === 0 ? [moved.month] : rule.byMonth;
-	const dates = [];
-	for (const month of months) {
-		const year = rule.frequency === "YEARLY" ? moved.year : moved.year;
-		if (rule.byDay.some((item) => item.ordinal !== void 0)) {
-			for (const item of rule.byDay) {
-				if (item.ordinal === void 0) continue;
-				const date = nthWeekday(year, month, item.ordinal, item.day);
-				if (date) dates.push(date);
-			}
-			continue;
-		}
-		if (rule.byDay.length > 0) {
-			const datesOf = temporal().PlainDate;
-			const length = datesOf.from({
-				year,
-				month,
-				day: 1
-			}).daysInMonth;
-			for (let day = 1; day <= length; day += 1) {
-				const date = datesOf.from({
-					year,
-					month,
-					day
-				});
-				if (rule.byDay.some((item) => item.day === date.dayOfWeek)) dates.push(date);
-			}
-		} else if (rule.byMonthDay.length > 0) for (const which of rule.byMonthDay) {
-			const date = monthDay(year, month, which);
-			if (date) dates.push(date);
-		}
-		else {
-			const date = monthDay(year, month, moved.day);
-			if (date) dates.push(date);
-		}
-	}
-	return dates;
-}
-function applySetPos(dates, positions) {
-	const sorted = dates.toSorted((a, b) => temporal().PlainDate.compare(a, b));
-	const picked = /* @__PURE__ */ new Set();
-	for (const position of positions) {
-		const date = sorted[position > 0 ? position - 1 : sorted.length + position];
-		if (date) picked.add(date.toString());
-	}
-	return sorted.filter((date) => picked.has(date.toString()));
-}
-/** The occurrences of a rule, in order, starting at `dtstart` when it matches. */
-function expandRule(input) {
-	if (input.rrule === void 0 && input.columns === void 0) throw new TypeError("expandRule needs an rrule or columns");
-	const rule = input.columns === void 0 ? part(input.rrule ?? "") : fromColumns(input.columns);
-	const start = input.dtstart;
-	const span = input.window;
-	const cap = span === void 0 ? Math.min(rule.count ?? input.limit ?? 366, input.limit ?? 366) : input.limit ?? 1e3;
-	const first = span === void 0 || rule.count !== void 0 ? 0 : skipTo(start, rule, span.from);
-	const found = [];
-	let generated = 0;
-	for (let index = first; found.length < cap && index < first + 4e3; index += 1) {
-		let dates = periodDates(start, rule, index);
-		if (rule.bySetPos.length > 0) dates = applySetPos(dates, rule.bySetPos);
-		const time = temporal();
-		const ordered = dates.toSorted((a, b) => time.PlainDate.compare(a, b));
-		for (const date of ordered) {
-			const when = at(date, start);
-			if (time.ZonedDateTime.compare(when, start) < 0) continue;
-			const instant = when.toInstant();
-			if (rule.until !== void 0 && time.Instant.compare(instant, rule.until) > 0) return found;
-			generated += 1;
-			if (rule.count !== void 0 && generated > rule.count) return found;
-			if (span !== void 0) {
-				if (time.Instant.compare(instant, span.until) >= 0) return found;
-				if (time.Instant.compare(instant, span.from) < 0) continue;
-			}
-			found.push(when);
-			if (found.length >= cap) return found;
-		}
-	}
-	return found;
-}
-/** The first period index that can reach `from`, for a rule without COUNT. */
-function skipTo(start, rule, from) {
-	const anchor = start.toPlainDate();
-	const target = from.toZonedDateTimeISO(start.timeZoneId).toPlainDate();
-	if (temporal().PlainDate.compare(target, anchor) <= 0) return 0;
-	let periods;
-	switch (rule.frequency) {
-		case "DAILY":
-			periods = target.since(anchor, { largestUnit: "days" }).days;
-			break;
-		case "WEEKLY":
-			periods = Math.floor(target.since(weekOf(anchor, rule.weekStart), { largestUnit: "days" }).days / 7);
-			break;
-		case "MONTHLY":
-			periods = (target.year - anchor.year) * 12 + target.month - anchor.month;
-			break;
-		case "YEARLY":
-			periods = target.year - anchor.year;
-			break;
-		default: {
-			const never = rule.frequency;
-			throw new TypeError(`unknown frequency ${String(never)}`);
-		}
-	}
-	return Math.max(0, Math.floor(periods / rule.interval) - 1);
-}
-/** A weekday name for a column-format rule, 1 (Monday) through 7 (Sunday). */
-function weekdayName(day) {
-	const name = DAY_NAME[day];
-	if (name === void 0 || name === "") throw new TypeError("weekday must be 1 (Monday) through 7 (Sunday)");
-	return name;
-}
-//#endregion
-export { weekdayName as n, expandRule as t };

package/dist/rules-DcW5mj1r.js

@@ -1,287 +0,0 @@
-import { n as dbError } from "./errors-03ysrOt4.js";
-import { a as ok, r as err, t as AsyncResult } from "./result-B3m7xtRY.js";
-import { n as isRecord } from "./guards-6F2bCtQR.js";
-import { t as FILTER_OPERATORS } from "./filter-query-D4ZSwbcJ.js";
-import { C as optionalText, D as recordOf, I as textOf, R as toInstant, f as errorText, k as recordsOf, m as instantArg, n as applyTemporal, o as blockCall } from "./block-helpers-CiKtrb6g.js";
-import { r as withBlockHooks } from "./block-hooks-BymdcD0V.js";
-import { t as evaluateFilterQuery } from "./filter-evaluate-CRDXv0Dl.js";
-import { i as ruleFilterFieldInfo } from "./fields-DK30XCgc.js";
-//#region src/blocks/rules/rules.ts
-const FIELD_TYPES = Object.keys(FILTER_OPERATORS);
-function isFieldType(value) {
-	return typeof value === "string" && FIELD_TYPES.includes(value);
-}
-function isFilterNode(value) {
-	if (!isRecord(value) || typeof value["id"] !== "string") return false;
-	if (value["type"] === "rule") return Array.isArray(value["path"]);
-	const rules = value["rules"];
-	return value["type"] === "group" && (value["combinator"] === "and" || value["combinator"] === "or") && Array.isArray(rules) && rules.every(isFilterNode);
-}
-/** A stored filter tree, checked to be a group. */
-function conditionsOf(value) {
-	if (!isFilterNode(value) || value.type !== "group") throw new TypeError(`filter conditions are ${JSON.stringify(value)}`);
-	return value;
-}
-function actionsOf(value) {
-	if (!Array.isArray(value)) return [];
-	return value.filter(isRecord).map((action) => ({
-		kind: textOf(action["kind"]),
-		...isRecord(action["config"]) ? { config: action["config"] } : {}
-	}));
-}
-function resultsOf(value) {
-	if (!isRecord(value)) return {};
-	return Object.fromEntries(Object.entries(value).map(([key, truth]) => [key, typeof truth === "boolean" ? truth : null]));
-}
-/** A rule row from the module's functions. */
-function ruleOf(value) {
-	const row = recordOf(value, "rule");
-	return {
-		id: textOf(row["id"]),
-		organizationId: textOf(row["organizationId"]),
-		subjectType: textOf(row["subjectType"]),
-		trigger: textOf(row["trigger"]),
-		name: textOf(row["name"]),
-		description: optionalText(row["description"]),
-		conditions: conditionsOf(row["conditions"]),
-		actions: actionsOf(row["actions"]),
-		enabled: row["enabled"] === true,
-		stopProcessing: row["stopProcessing"] === true,
-		rank: textOf(row["rank"]),
-		version: Number(row["version"]),
-		createdBy: optionalText(row["createdBy"]),
-		updatedBy: optionalText(row["updatedBy"]),
-		createdAt: toInstant(textOf(row["createdAt"])),
-		updatedAt: toInstant(textOf(row["updatedAt"]))
-	};
-}
-function fieldOf(value) {
-	const type = value["type"];
-	if (!isFieldType(type)) throw new TypeError(`rule field type ${JSON.stringify(type)}`);
-	const options = value["options"];
-	const operators = value["operators"];
-	return {
-		subjectType: textOf(value["subjectType"]),
-		id: textOf(value["id"]),
-		label: textOf(value["label"]),
-		description: optionalText(value["description"]),
-		type,
-		column: textOf(value["column"]),
-		columnType: textOf(value["columnType"]),
-		nullable: value["nullable"] !== false,
-		options: Array.isArray(options) ? options.filter(isRecord).map((option) => ({
-			value: textOf(option["value"]),
-			label: textOf(option["label"] ?? option["value"])
-		})) : void 0,
-		operators: Array.isArray(operators) ? operators.map(textOf) : void 0
-	};
-}
-function versionOf(value) {
-	return {
-		ruleId: textOf(value["ruleId"]),
-		version: Number(value["version"]),
-		name: textOf(value["name"]),
-		conditions: conditionsOf(value["conditions"]),
-		actions: actionsOf(value["actions"]),
-		savedBy: optionalText(value["savedBy"]),
-		savedAt: toInstant(textOf(value["savedAt"]))
-	};
-}
-function evaluationOf(value) {
-	const row = recordOf(value, "rule evaluation");
-	return {
-		id: textOf(row["id"]),
-		organizationId: textOf(row["organizationId"]),
-		ruleId: textOf(row["ruleId"]),
-		version: Number(row["version"]),
-		subjectType: textOf(row["subjectType"]),
-		subjectId: optionalText(row["subjectId"]),
-		trigger: textOf(row["trigger"]),
-		matched: row["matched"] === true,
-		results: resultsOf(row["results"]),
-		mode: row["mode"] === "test" ? "test" : "live",
-		evaluatedBy: optionalText(row["evaluatedBy"]),
-		evaluatedAt: toInstant(textOf(row["evaluatedAt"]))
-	};
-}
-function matchesOf(value) {
-	return recordsOf(value, "matching_rules").map((entry) => ({
-		rule: ruleOf(entry["rule"]),
-		results: resultsOf(entry["results"])
-	}));
-}
-/** Catalog fields in the shape `evaluateFilterQuery` reads. */
-function ruleRecordFields(fields) {
-	return ruleFilterFieldInfo(fields);
-}
-/**
-* Tests a rule's conditions on one record in memory, the same way the
-* database's `rule_evaluate` does. `fields` is the subject type's catalog.
-*/
-function evaluateRule(rule, subject, fields, clock) {
-	return evaluateFilterQuery(rule.conditions, subject, ruleRecordFields(fields), clock);
-}
-function inputArg(input) {
-	const out = {};
-	for (const [key, value] of Object.entries(input)) if (value !== void 0) out[key] = value;
-	return out;
-}
-/** Tenant rules as the caller: the catalog, the rules, their history and tests. */
-function createRules(options) {
-	applyTemporal(options);
-	const call = blockCall(options.transport, options.schema, options.mappers);
-	const fields = (subjectType) => call("rule_fields_list", { subject_type: subjectType ?? null }, (value) => recordsOf(value, "rule_fields_list").map(fieldOf));
-	return withBlockHooks({
-		fields,
-		list: (organizationId, filter = {}) => call("rules_list", {
-			tenant: organizationId,
-			subject_type: filter.subjectType ?? null,
-			trigger: filter.trigger ?? null,
-			enabled: filter.enabled ?? null
-		}, (value) => recordsOf(value, "rules_list").map(ruleOf)),
-		get: (id) => call("rule_get", { id }, (value) => isRecord(value) ? ruleOf(value) : void 0),
-		save: (organizationId, input) => call("save_rule", {
-			tenant: organizationId,
-			rule: inputArg(input)
-		}, ruleOf),
-		setEnabled: (id, enabled) => call("set_rule_enabled", {
-			id,
-			enabled
-		}, ruleOf),
-		move: (id, rank) => call("rank_rule", {
-			id,
-			rank
-		}, ruleOf),
-		remove: (id) => call("remove_rule", { id }, (value) => value === true),
-		versions: (id) => call("rule_versions_list", { id }, (value) => recordsOf(value, "rule_versions_list").map(versionOf)),
-		evaluations: (id, page = {}) => call("rule_evaluations_list", {
-			rule: id,
-			before: instantArg(page.before) ?? null,
-			page_size: page.pageSize ?? 50
-		}, (value) => recordsOf(value, "rule_evaluations_list").map(evaluationOf)),
-		matching: (organizationId, input) => call("matching_rules", {
-			tenant: organizationId,
-			subject_type: input.subjectType,
-			trigger: input.trigger,
-			subject: input.subject,
-			time_zone: input.timeZone ?? "UTC"
-		}, matchesOf),
-		test: (rule, subject, test = {}) => {
-			return (test.fields === void 0 ? fields(rule.subjectType) : AsyncResult.ok(test.fields)).andThen(async (found) => {
-				let evaluation;
-				try {
-					evaluation = evaluateRule(rule, subject, found, test.clock);
-				} catch (cause) {
-					return err(dbError("invalid_request", errorText(cause)));
-				}
-				const logged = await call("record_rule_evaluation", {
-					rule: rule.id,
-					subject_id: test.subjectId ?? null,
-					matched: evaluation.matched,
-					results: evaluation.results,
-					mode: "test"
-				}, evaluationOf);
-				return logged.ok ? ok(evaluation) : logged;
-			});
-		}
-	}, options.hooks, {
-		block: "rules",
-		...options.logger ? { logger: options.logger } : {}
-	});
-}
-/** The field sync and live evaluation, with a service-role client. */
-function createRulesAdmin(options) {
-	applyTemporal(options);
-	const call = blockCall(options.transport, options.schema, options.mappers);
-	return {
-		syncFields: (catalog) => call("sync_rule_fields", {
-			subject_type: catalog.subjectType,
-			fields: catalog.fields.map((field) => ({
-				id: field.id,
-				label: field.label,
-				...field.description === void 0 ? {} : { description: field.description },
-				type: field.type,
-				column: field.column,
-				columnType: field.columnType,
-				nullable: field.nullable,
-				...field.options === void 0 ? {} : { options: field.options },
-				...field.operators === void 0 ? {} : { operators: field.operators }
-			}))
-		}, Number),
-		run: (organizationId, input) => call("run_rules", {
-			tenant: organizationId,
-			subject_type: input.subjectType,
-			trigger: input.trigger,
-			subject_id: input.subjectId ?? null,
-			subject: input.subject,
-			time_zone: input.timeZone ?? "UTC"
-		}, matchesOf)
-	};
-}
-/** Runs matched rules' actions with the app's handlers. */
-function createRuleDispatcher(options) {
-	const runOne = async (call) => {
-		const { action, rule } = call;
-		const handler = options.handlers[action.kind];
-		if (handler === void 0) return {
-			ruleId: rule.id,
-			kind: action.kind,
-			ok: false,
-			error: dbError("invalid_request", `No handler for the rule action "${action.kind}"`, { hint: "RULE_ACTION_UNKNOWN" })
-		};
-		let result;
-		try {
-			result = await handler(call);
-		} catch (cause) {
-			result = err(dbError("unexpected", errorText(cause)));
-		}
-		return result.ok ? {
-			ruleId: rule.id,
-			kind: action.kind,
-			ok: true,
-			value: result.data
-		} : {
-			ruleId: rule.id,
-			kind: action.kind,
-			ok: false,
-			error: result.error
-		};
-	};
-	return { dispatch: (matches, context) => AsyncResult.from(async () => {
-		const outcomes = [];
-		for (const match of matches) for (const action of match.rule.actions) outcomes.push(await runOne({
-			action,
-			rule: match.rule,
-			results: match.results,
-			context
-		}));
-		return ok(outcomes);
-	}) };
-}
-/**
-* An outbox consumer handler that tests the rules whose trigger is the event's
-* type and runs the actions of the ones that match, for
-* `outbox.consume("rules", createRuleSink(...))`. It throws when the evaluation
-* fails, so the outbox retries the event; a failed action goes to `onOutcomes`
-* instead, since a retry would run the others again.
-*/
-function createRuleSink(options) {
-	return async (events) => {
-		for (const event of events) {
-			const target = await options.load(event);
-			if (target === void 0) continue;
-			const matches = await options.rules.run(target.organizationId, {
-				subjectType: target.subjectType,
-				trigger: event.type,
-				subject: target.subject,
-				...target.subjectId === void 0 ? {} : { subjectId: target.subjectId },
-				...target.timeZone === void 0 ? {} : { timeZone: target.timeZone }
-			}).orThrow();
-			if (matches.length === 0) continue;
-			const outcomes = await options.dispatcher.dispatch(matches, target.context).orThrow();
-			options.onOutcomes?.(event, outcomes);
-		}
-	};
-}
-//#endregion
-export { createRulesAdmin as a, ruleRecordFields as c, createRules as i, createRuleDispatcher as n, evaluateRule as o, createRuleSink as r, ruleOf as s, conditionsOf as t };

package/dist/run-state-CPo-1X2B.d.ts

@@ -1,12 +0,0 @@
-//#region src/core/run-state.d.ts
-/**
- * Where a run is, in the words every block that records runs shares: ai-chat
- * runs, ai-tasks runs and workflow runs. Each block uses the subset it needs.
- */
-type RunState = "queued" | "running" | "waiting" | "cancel_requested" | "completed" | "failed" | "cancelled";
-/** The states a run ends in. */
-type FinalRunState = Extract<RunState, "completed" | "failed" | "cancelled">;
-/** The states a run ends in, in the order blocks list them. */
-declare const FINAL_RUN_STATES: readonly FinalRunState[];
-//#endregion
-export { FinalRunState as n, RunState as r, FINAL_RUN_STATES as t };

package/dist/sales-lines-9HsX89aO.d.ts

@@ -1,28 +0,0 @@
-import { n as Money } from "./money-BNRdJQzA.js";
-import { t as RecordRef } from "./sales-shared-DAAGwQwN.js";
-//#region src/blocks/sales-lines.d.ts
-/** A line of a quote or invoice, in the document's currency. */
-interface LineInput {
-  readonly description: string;
-  readonly quantity?: number;
-  readonly unitAmount: Money;
-  readonly discountBps?: number;
-  readonly taxRateBps?: number;
-  readonly taxCode?: string;
-  readonly product?: RecordRef;
-}
-interface Line extends LineInput {
-  readonly quantity: number;
-  readonly discountBps: number;
-  readonly taxRateBps: number;
-}
-/** A document's totals, in its currency. */
-interface Totals {
-  readonly listTotal: Money;
-  readonly discountTotal: Money;
-  readonly subtotal: Money;
-  readonly taxTotal: Money;
-  readonly total: Money;
-}
-//#endregion
-export { LineInput as n, Totals as r, Line as t };

package/dist/sales-lines-BhrIx2oK.js

@@ -1,41 +0,0 @@
-import { C as optionalText, D as recordOf, I as textOf } from "./block-helpers-CiKtrb6g.js";
-import { i as moneyOf, t as amountText } from "./money-codec-jMP0PQLZ.js";
-import { i as refOf, n as compact } from "./sales-shared-C_u68eq2.js";
-//#region src/blocks/sales-lines.ts
-/** A line a document function returned, in the document's `currency`. */
-function lineOf(value, currency) {
-	const row = recordOf(value, "line");
-	const product = recordOf(row["product"] ?? {}, "line product");
-	return compact({
-		description: textOf(row["description"]),
-		quantity: Number(row["quantity"] ?? 1),
-		unitAmount: moneyOf(row["unitAmount"], currency, "line unitAmount"),
-		discountBps: Number(row["discountBps"] ?? 0),
-		taxRateBps: Number(row["taxRateBps"] ?? 0),
-		taxCode: optionalText(row["taxCode"]),
-		product: refOf(product["type"], product["id"])
-	});
-}
-/**
-* A document's totals: a row (snake keys) or a `set_*_lines` result (camel
-* keys, with its currency).
-*/
-function totalsOf(row, camel) {
-	const currency = row["currency"];
-	const at = (snake, camelKey) => moneyOf(camel ? row[camelKey] : row[snake], currency, camelKey);
-	return {
-		listTotal: at("list_total", "listTotal"),
-		discountTotal: at("discount_total", "discountTotal"),
-		subtotal: at("subtotal", "subtotal"),
-		taxTotal: at("tax_total", "taxTotal"),
-		total: at("total", "total")
-	};
-}
-/** A line as the database reads it: the unit amount as text, with its currency. */
-const lineArg = (line) => ({
-	...line,
-	unitAmount: amountText(line.unitAmount),
-	currency: line.unitAmount.currency
-});
-//#endregion
-export { lineOf as n, totalsOf as r, lineArg as t };

package/dist/sales-shared-C_u68eq2.js

@@ -1,22 +0,0 @@
-import { t as temporal } from "./temporal-required-B8qQHYbI.js";
-import { C as optionalText } from "./block-helpers-CiKtrb6g.js";
-//#region src/blocks/sales-shared.ts
-/** Drops `undefined` properties, which `exactOptionalPropertyTypes` refuses. */
-function compact(value) {
-	return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== void 0));
-}
-const plainDate = (value) => typeof value === "string" ? temporal().PlainDate.from(value.slice(0, 10)) : void 0;
-function refOf(type, id) {
-	const t = optionalText(type);
-	const i = optionalText(id);
-	return t === void 0 || i === void 0 ? void 0 : {
-		type: t,
-		id: i
-	};
-}
-/** Write attributes as the database reads them: dates as ISO text. */
-function attrsArg(input) {
-	return Object.fromEntries(Object.entries(input).map(([key, value]) => [key, value instanceof temporal().PlainDate || value instanceof temporal().Instant ? value.toString() : value]));
-}
-//#endregion
-export { refOf as i, compact as n, plainDate as r, attrsArg as t };

package/dist/sales-shared-DAAGwQwN.d.ts

@@ -1,8 +0,0 @@
-//#region src/blocks/sales-shared.d.ts
-/** A record a sales document points at: a company, a contact, its origin. */
-interface RecordRef {
-  readonly type: string;
-  readonly id: string;
-}
-//#endregion
-export { RecordRef as t };