@threadlabs/looma 0.30.1 → 0.30.3

package/vue/chunks/props.js

@@ -1,3 +1,4 @@
+import { computed, shallowRef, watch } from "vue";
 //#region .build/vue/props.ts
 var CSS_NAMED_COLOR_SET = /* @__PURE__ */ new Set([
 	"accentcolor",
@@ -429,8 +430,9 @@ function parse(value, node, path) {
 			const issues = [];
 			const fields = new Map(node.fields.map((field) => [field.name, field]));
 			for (const field of node.fields) {
-				if (!(field.name in input)) {
+				if (!(field.name in input) || field.optional && input[field.name] == null) {
 					if (!field.optional) issues.push(pathAt(path, field.name) + ": Required field is absent.");
+					else if (field.name in input) output[field.name] = null;
 					continue;
 				}
 				const result = parse(input[field.name], field.type, pathAt(path, field.name));
@@ -512,13 +514,10 @@ function boundProblem(value, type, bounds) {
 	}
 }
 function checkedProp(value, type, _required, name, accepted, inputAccepted, htmlBoolean = true) {
-	if (value === void 0 || value === null) {
-		if (inputAccepted !== void 0) inputAccepted[name] = true;
-		if (accepted !== void 0) accepted[name] = null;
-		return null;
-	}
-	if (htmlBoolean && value === "" && type.kind === "terminal" && type.name === "boolean") value = true;
-	const result = parse(value, type, "$");
+	const result = value === void 0 ? {
+		ok: true,
+		value: null
+	} : checkPropInput(value, type, htmlBoolean);
 	if (inputAccepted !== void 0) inputAccepted[name] = result.ok;
 	if (result.ok) {
 		if (accepted !== void 0) accepted[name] = result.value;
@@ -526,6 +525,14 @@ function checkedProp(value, type, _required, name, accepted, inputAccepted, html
 	}
 	return accepted?.[name] ?? null;
 }
+function checkPropInput(value, type, htmlBoolean = true, optional = true) {
+	if (optional && value === null) return {
+		ok: true,
+		value: null
+	};
+	if (htmlBoolean && value === "" && type.kind === "terminal" && type.name === "boolean") value = true;
+	return parse(value, type, "$");
+}
 function propValidity(binding) {
 	const errors = [];
 	for (const [name, prop] of Object.entries(binding.contract.props)) {
@@ -752,8 +759,7 @@ var vPropValidity = {
 function acceptsControllerWrite(value, type, keys) {
 	if (type === void 0) return true;
 	if (keys.length === 0) {
-		if (value === void 0) return true;
-		if (value === null) return parse(value, type, "$").ok;
+		if (value === void 0 || value === null) return true;
 		if (type.kind === "list") return Array.isArray(value);
 		if (type.kind === "object" || type.kind === "record") return typeof value === "object" && !Array.isArray(value);
 		if (type.kind === "union") return type.members.some((member) => acceptsControllerWrite(value, member, keys));
@@ -766,5 +772,423 @@ function acceptsControllerWrite(value, type, keys) {
 	if (type.kind === "object" && !type.open && !type.fields.some((field) => field.name === key)) return value === void 0;
 	return acceptsControllerWrite(value, type.kind === "object" ? type.fields.find((field) => field.name === key)?.type : type.kind === "list" ? /^\d+$/.test(key) ? type.item : void 0 : type.kind === "record" ? type.value : void 0, keys.slice(1));
 }
+var READY_INPUT = {
+	ready: true,
+	pending: false,
+	error: null,
+	stale: false
+};
+var UNRESOLVED_INPUT = {
+	ready: false,
+	pending: false,
+	error: null,
+	stale: false
+};
+/** Public error identity is its name/message, not the producer's object allocation. */
+function sameInputStatus(left, right) {
+	return left === right || left !== void 0 && right !== void 0 && left.ready === right.ready && left.pending === right.pending && left.stale === right.stale && left.error?.name === right.error?.name && left.error?.message === right.error?.message;
+}
+var inputObservation;
+/** Only synchronous reads made by this evaluation contribute prerequisites. */
+function observingInputs() {
+	return inputObservation !== void 0;
+}
+function observeInputStatus(status) {
+	if (inputObservation === void 0) return;
+	inputObservation.ready &&= status.ready;
+	inputObservation.pending ||= status.pending;
+	inputObservation.error ??= status.error;
+	inputObservation.stale ||= status.stale;
+}
+/** Compiler adapters wrap declaration reads; ordinary application values keep their types. */
+function inputRead(value, status) {
+	observeInputStatus(status);
+	return value;
+}
+/** Native expression evaluation and framework computeds share status composition, not reactivity. */
+function evaluateInput(compute, previous, invalid = Symbol.for("html-next.invalid-result")) {
+	const parent = inputObservation;
+	const observed = {
+		ready: true,
+		pending: false,
+		error: null,
+		stale: false
+	};
+	inputObservation = observed;
+	let value;
+	try {
+		value = compute();
+	} finally {
+		inputObservation = parent;
+	}
+	if (value === void 0 || value === invalid && previous?.ready !== true) observed.ready = false;
+	if (!observed.ready) observed.stale = false;
+	const status = sameInputStatus(previous, observed) ? previous : observed.ready && !observed.pending && observed.error === null && !observed.stale ? READY_INPUT : !observed.ready && !observed.pending && observed.error === null ? UNRESOLVED_INPUT : observed;
+	return {
+		value,
+		status
+	};
+}
+/** The adapter supplies its own memo/computed primitive; acceptance runs only for available data. */
+function inputComputed(compute, make, accept, initialStatus) {
+	let previous;
+	const cell = make(() => {
+		const result = evaluateInput(compute, previous?.status ?? initialStatus);
+		const value = result.status.ready ? accept === void 0 ? result.value : accept(result.value) : null;
+		if (previous !== void 0 && Object.is(previous.value, value) && previous.status === result.status) return previous;
+		return previous = {
+			value,
+			status: result.status
+		};
+	});
+	return {
+		get: () => cell.get().value,
+		get value() {
+			return cell.get().value;
+		},
+		status: () => cell.get().status
+	};
+}
+/** Project only the status a template may observe, retaining no mutable producer-owned object. */
+function publicInputStatus(status) {
+	if (typeof status.ready !== "boolean" || typeof status.pending !== "boolean" || typeof status.stale !== "boolean" || !status.ready && status.stale) throw new TypeError("Input status requires boolean ready, pending and stale; stale requires an accepted value.");
+	const error = status.error;
+	if (error !== null && (typeof error.name !== "string" || typeof error.message !== "string")) throw new TypeError("An input failure requires public string name and message fields.");
+	return {
+		ready: status.ready,
+		pending: status.pending,
+		stale: status.stale,
+		error: error === null ? null : {
+			name: error.name,
+			message: error.message
+		}
+	};
+}
+function requireInputStatus(status, handlesError) {
+	if (!status.ready && status.error !== null && !handlesError) throw Object.assign(new Error(status.error.message), { name: status.error.name });
+	return status;
+}
+/**
+* One source capability per prop. The adapter owns accepted storage and type checks; this port
+* owns neither a second value store nor a second reactive engine. It also enforces caller precedence
+* before the adapter sees any source proposal, including proposals that arrive after disposal.
+*/
+function createInputPort(adapter) {
+	const names = [...adapter.names];
+	const readNames = [.../* @__PURE__ */ new Set([...names, ...adapter.readNames ?? []])];
+	const owners = /* @__PURE__ */ new Map();
+	const declared = (name) => {
+		if (!names.includes(name)) throw new TypeError(`Input \`${name}\` is not a declared prop.`);
+	};
+	const readable = (name) => {
+		if (!readNames.includes(name)) throw new TypeError(`Binding \`${name}\` is not declared in this component.`);
+	};
+	return {
+		get names() {
+			return [...names];
+		},
+		get readNames() {
+			return [...readNames];
+		},
+		read(name) {
+			readable(name);
+			const value = adapter.read(name);
+			if (observingInputs()) observeInputStatus(adapter.status(name));
+			return value;
+		},
+		status(name) {
+			readable(name);
+			return publicInputStatus(adapter.status(name));
+		},
+		supplied(name) {
+			declared(name);
+			return adapter.supplied(name);
+		},
+		revision(name) {
+			declared(name);
+			return adapter.revision?.(name);
+		},
+		capture(read) {
+			const result = evaluateInput(() => {
+				try {
+					return {
+						ok: true,
+						value: read()
+					};
+				} catch (error) {
+					return {
+						ok: false,
+						error
+					};
+				}
+			});
+			return {
+				...result.value,
+				status: publicInputStatus(result.status)
+			};
+		},
+		watch: (run) => adapter.watch(run),
+		source(name) {
+			declared(name);
+			if (owners.has(name)) throw new TypeError(`Input \`${name}\` already has a source.`);
+			const token = {};
+			owners.set(name, token);
+			return {
+				current: () => ({
+					value: adapter.read(name),
+					status: publicInputStatus(adapter.status(name))
+				}),
+				publish(snapshot) {
+					if (owners.get(name) !== token) return false;
+					return adapter.untracked(() => !adapter.supplied(name) && adapter.publish(name, {
+						value: snapshot.value,
+						status: publicInputStatus(snapshot.status)
+					}));
+				},
+				dispose() {
+					if (owners.get(name) === token) owners.delete(name);
+				}
+			};
+		}
+	};
+}
+/** Renderer-neutral input bookkeeping. Accepted values remain in the renderer's existing store. */
+var BINDING_INPUTS_PROP = "\0htmlNextInputStatus";
+var PropInputs = class PropInputs {
+	#options;
+	#records = Object.create(null);
+	#port;
+	#reactions;
+	#portOwner;
+	#baseRevisions;
+	constructor(options) {
+		this.#options = options;
+	}
+	/** Imperative code reads the connected instance, even during a speculative render. */
+	get committed() {
+		return this.#portOwner ?? this;
+	}
+	/** Concurrent renderers may examine a candidate without changing the connected instance. */
+	fork(options) {
+		const candidate = new PropInputs({
+			...options,
+			defaults: this.#options.defaults,
+			values: { ...this.#options.values }
+		});
+		for (const [name, record] of Object.entries(this.#records)) candidate.#records[name] = { ...record };
+		candidate.#portOwner = this;
+		candidate.#baseRevisions = new Map(Object.entries(this.#records).map(([name, record]) => [name, record.revision]));
+		return candidate;
+	}
+	commit(candidate) {
+		const values = this.#options.values;
+		for (const [name, next] of Object.entries(candidate.#records)) {
+			const current = this.#record(name);
+			const base = candidate.#baseRevisions?.get(name) ?? 0;
+			if (current.revision !== base && current.source && !next.provided) this.#records[name] = {
+				...current,
+				caller: next.caller,
+				refused: next.refused,
+				accepted: next.accepted,
+				input: next.refused || next.caller !== current.caller ? next.input : current.input
+			};
+			else {
+				values[name] = candidate.#options.values[name];
+				this.#records[name] = {
+					...next,
+					revision: next.revision === base ? current.revision : Math.max(next.revision, current.revision + 1)
+				};
+			}
+		}
+		this.#options = {
+			...candidate.#options,
+			values
+		};
+	}
+	#record(name) {
+		return this.#records[name] ??= {
+			caller: void 0,
+			input: null,
+			provided: false,
+			source: false,
+			refused: false,
+			accepted: true,
+			status: void 0,
+			revision: 0
+		};
+	}
+	#fallback(name) {
+		return Object.hasOwn(this.#options.defaults, name) ? this.#options.defaults[name] : null;
+	}
+	#status(record, status) {
+		const old = record.status;
+		if (sameInputStatus(old, status)) return;
+		record.status = publicInputStatus(status);
+	}
+	value(name, input, bindings, flags) {
+		const record = this.#record(name);
+		const released = record.caller !== void 0 && input === void 0;
+		record.caller = input;
+		const upstream = bindings !== void 0 && Object.hasOwn(bindings, name) ? bindings[name]() : void 0;
+		if (upstream !== void 0) {
+			if (!upstream.status.ready) {
+				record.revision += 1;
+				this.#options.values[name] = this.#fallback(name);
+				record.input = upstream.value ?? null;
+				record.provided = true;
+				record.source = false;
+				record.refused = false;
+				record.accepted = true;
+				this.#status(record, upstream.status);
+			} else {
+				const result = this.#options.check(name, upstream.value === null ? this.#fallback(name) : upstream.value, false, this.#options.values);
+				record.accepted = result.ok;
+				if (result.ok) {
+					record.revision += 1;
+					this.#options.values[name] = result.value;
+					record.input = upstream.value;
+					record.provided = true;
+					record.source = false;
+					record.refused = false;
+					this.#status(record, upstream.status);
+				}
+			}
+		} else if (input === void 0 && record.source && !released) record.accepted = true;
+		else {
+			const candidate = input === void 0 || input === null ? this.#fallback(name) : input;
+			const result = input === void 0 && !Object.hasOwn(this.#options.defaults, name) ? {
+				ok: true,
+				value: null
+			} : this.#options.check(name, candidate, false, this.#options.values);
+			record.input = input === void 0 ? null : input;
+			record.accepted = result.ok;
+			record.refused = !result.ok && input !== void 0;
+			if (result.ok) {
+				record.revision += 1;
+				this.#options.values[name] = result.value;
+				record.provided = input !== void 0;
+				record.source = false;
+				record.status = void 0;
+			}
+		}
+		if (flags !== void 0) flags[name] = record.accepted;
+		return this.#options.values[name];
+	}
+	read(name) {
+		return this.#options.values[name];
+	}
+	inputValue(name) {
+		return this.#record(name).input;
+	}
+	supplied(name) {
+		return this.#record(name).provided;
+	}
+	revision(name) {
+		return this.#record(name).revision;
+	}
+	status(name) {
+		const record = this.#record(name);
+		return record.status ?? (record.provided || Object.hasOwn(this.#options.defaults, name) ? READY_INPUT : UNRESOLVED_INPUT);
+	}
+	publish(name, snapshot) {
+		const record = this.#record(name);
+		if (record.provided) return false;
+		let value = this.#fallback(name);
+		if (snapshot.status.ready) {
+			const result = this.#options.check(name, snapshot.value === null ? this.#fallback(name) : snapshot.value, true, this.#options.values);
+			if (!result.ok) return false;
+			value = result.value;
+		}
+		this.#options.values[name] = value;
+		record.revision += 1;
+		if (!record.refused) record.input = snapshot.value ?? null;
+		record.source = true;
+		this.#status(record, !snapshot.status.ready && Object.hasOwn(this.#options.defaults, name) ? {
+			...snapshot.status,
+			ready: true,
+			stale: false
+		} : snapshot.status);
+		this.#options.invalidate();
+		if (this.#reactions?.notify !== void 0) {
+			this.#reactions.notify(name, "value");
+			this.#reactions.notify(name, "status");
+		}
+		return true;
+	}
+	port(reactions) {
+		if (this.#portOwner !== void 0) return this.#portOwner.port(reactions);
+		this.#reactions ??= reactions;
+		return this.#port ??= createInputPort({
+			names: this.#options.names,
+			readNames: [...this.#options.names, ...Object.keys(reactions.declarations ?? {})],
+			read: (name) => {
+				if (!this.#options.names.includes(name)) return reactions.declarations[name].read();
+				reactions.track(name, "value");
+				return this.read(name);
+			},
+			status: (name) => {
+				if (!this.#options.names.includes(name)) return reactions.declarations[name].status();
+				reactions.track(name, "status");
+				return this.status(name);
+			},
+			supplied: (name) => {
+				reactions.track(name, "supplied");
+				return this.supplied(name);
+			},
+			revision: (name) => this.revision(name),
+			publish: (name, snapshot) => this.publish(name, snapshot),
+			watch: (run) => reactions.watch(run),
+			untracked: (run) => reactions.untracked(run)
+		});
+	}
+};
+function vuePropInputs(values, defaults, check, prepare) {
+	const version = shallowRef(0);
+	const inputs = new PropInputs({
+		names: Object.keys(values),
+		values,
+		defaults,
+		check,
+		invalidate: () => {
+			version.value += 1;
+		}
+	});
+	const reads = /* @__PURE__ */ new Map();
+	return {
+		inputs,
+		version,
+		track(name, kind) {
+			const key = kind + ":" + name;
+			let read = reads.get(key);
+			if (read === void 0) {
+				read = computed(() => {
+					prepare();
+					version.value;
+					return kind === "value" ? inputs.read(name) : kind === "status" ? inputs.status(name) : inputs.supplied(name);
+				});
+				reads.set(key, read);
+			}
+			read.value;
+		},
+		untracked(run) {
+			let value;
+			let error;
+			let failed = false;
+			watch(() => true, () => {
+				try {
+					value = run();
+				} catch (caught) {
+					error = caught;
+					failed = true;
+				}
+			}, {
+				immediate: true,
+				flush: "sync"
+			})();
+			if (failed) throw error;
+			return value;
+		}
+	};
+}
 //#endregion
-export { vPropValidity as a, selectedPropNode as i, checkedProp as n, propValidityState as r, acceptsControllerWrite as t };
+export { checkedProp as a, inputRead as c, selectedPropNode as d, vPropValidity as f, checkPropInput as i, propValidityState as l, READY_INPUT as n, evaluateInput as o, vuePropInputs as p, acceptsControllerWrite as r, inputComputed as s, BINDING_INPUTS_PROP as t, requireInputStatus as u };