@threadlabs/looma 0.24.1 → 0.25.0

package/vue/chunks/host.js

@@ -1,5 +1,117 @@
 import { Fragment, computed, getCurrentInstance, onBeforeUnmount, onBeforeUpdate, onMounted, onUpdated, shallowRef, useSlots, watchEffect } from "vue";
 //#region .build/vue/host.ts
+function controllerNamespaces(options, source) {
+	const reported = /* @__PURE__ */ new Set();
+	const nested = /* @__PURE__ */ new WeakMap();
+	const eventType = typeof Event === "undefined" ? void 0 : Object.getOwnPropertyDescriptor(Event.prototype, "type").get;
+	const eventBrands = /* @__PURE__ */ new WeakMap();
+	const nativeEvent = (value) => {
+		if (!("type" in value) || eventType === void 0) return false;
+		const known = eventBrands.get(value);
+		if (known !== void 0) return known;
+		let accepted = false;
+		try {
+			eventType.call(value);
+			accepted = true;
+		} catch {}
+		eventBrands.set(value, accepted);
+		return accepted;
+	};
+	const warn = (path, readonly) => {
+		if (reported.has(path)) return;
+		reported.add(path);
+		console.warn(source + ": HR007: Destination " + path + (readonly ? " is read-only." : " does not satisfy its declared type."));
+	};
+	const write = (name, keys, value, readonly, apply) => {
+		if (readonly || options.acceptsState?.(name, keys, value) === false) warn([name, ...keys].join("."), readonly);
+		else apply();
+		return true;
+	};
+	const wrap = (value, name, keys, readonly) => {
+		if (value === null || typeof value !== "object" || nativeEvent(value)) return value;
+		const path = [name, ...keys].join(".");
+		let paths = nested.get(value);
+		if (paths === void 0) nested.set(value, paths = /* @__PURE__ */ new Map());
+		const known = paths.get(path);
+		if (known !== void 0) return known;
+		const surface = readonly ? Array.isArray(value) ? [] : Object.create(Object.getPrototypeOf(value)) : value;
+		if (readonly && Array.isArray(value)) surface.length = value.length;
+		const proxy = new Proxy(surface, {
+			get: (_target, key) => wrap(Reflect.get(value, key), name, [...keys, String(key)], readonly),
+			set: (_target, key, next) => write(name, [...keys, String(key)], next, readonly, () => {
+				const previous = Reflect.get(value, key);
+				if (Reflect.set(value, key, next) && !Object.is(previous, next)) options.changed?.(name);
+			}),
+			has: (_target, key) => Reflect.has(value, key),
+			ownKeys: () => Reflect.ownKeys(value),
+			getOwnPropertyDescriptor: (_target, key) => {
+				if (readonly && Array.isArray(value) && key === "length") {
+					surface.length = value.length;
+					return Reflect.getOwnPropertyDescriptor(surface, key);
+				}
+				const descriptor = Reflect.getOwnPropertyDescriptor(value, key);
+				return descriptor === void 0 ? void 0 : readonly ? {
+					...descriptor,
+					configurable: true
+				} : descriptor;
+			},
+			deleteProperty: (_target, key) => write(name, [...keys, String(key)], void 0, readonly, () => {
+				if (Reflect.has(value, key) && Reflect.deleteProperty(value, key)) options.changed?.(name);
+			}),
+			defineProperty: (_target, key, descriptor) => {
+				if (readonly || !("value" in descriptor) || options.acceptsState?.(name, [...keys, String(key)], descriptor.value) === false) {
+					warn([
+						name,
+						...keys,
+						String(key)
+					].join("."), readonly);
+					return false;
+				}
+				const changed = Reflect.defineProperty(value, key, descriptor);
+				if (changed) options.changed?.(name);
+				return changed;
+			}
+		});
+		paths.set(path, proxy);
+		return proxy;
+	};
+	return {
+		state: new Proxy({}, {
+			get: (_target, name) => {
+				if (typeof name !== "string") return void 0;
+				if (Object.hasOwn(options.state, name)) return wrap(options.state[name].get(), name, [], false);
+				if (Object.hasOwn(options.computed, name)) return wrap(options.computed[name](), name, [], true);
+			},
+			set: (_target, name, value) => write(String(name), [], value, typeof name !== "string" || !Object.hasOwn(options.state, name), () => options.state[String(name)].set(value)),
+			deleteProperty: (_target, name) => {
+				warn(String(name), true);
+				return true;
+			},
+			defineProperty: (_target, name) => {
+				warn(String(name), true);
+				return false;
+			},
+			has: (_target, name) => typeof name === "string" && (Object.hasOwn(options.state, name) || Object.hasOwn(options.computed, name))
+		}),
+		data: new Proxy({}, {
+			get: (_target, name) => typeof name === "string" && Object.hasOwn(options.data ?? {}, name) ? wrap(options.data[name](), "data." + name, [], true) : void 0,
+			set: (_target, name, value) => write("data." + String(name), [], value, true, () => {}),
+			deleteProperty: (_target, name) => {
+				warn("data." + String(name), true);
+				return true;
+			},
+			defineProperty: (_target, name) => {
+				warn("data." + String(name), true);
+				return false;
+			},
+			has: (_target, name) => typeof name === "string" && Object.hasOwn(options.data ?? {}, name)
+		})
+	};
+}
+function dispatchToTargets(recorded, send) {
+	const targets = (recorded instanceof Set ? [...recorded] : Array.isArray(recorded) ? [...recorded] : [recorded]).map((ref) => ref?.nodeType === 1 ? ref : ref?.$el).filter((element) => element?.nodeType === 1 && element.isConnected).sort((a, b) => a === b ? 0 : a.compareDocumentPosition(b) & 4 ? -1 : 1);
+	for (const target of targets) if (target.isConnected) send(target);
+}
 var connectionHubs = /* @__PURE__ */ new WeakMap();
 /** One native observer per document tracks externally detached controller roots. */
 function observeConnection(element, check) {
@@ -99,7 +211,24 @@ function useComponentHost(controllerLoader, options) {
 		throw controllerDiagnostic("HJ001", error);
 	});
 	const stops = [];
-	const readState = (name) => Object.hasOwn(state, name) ? state[name].value : Object.hasOwn(computedValues, name) ? computedValues[name].value : Object.hasOwn(data, name) ? data[name].value : Object.hasOwn(context, name) ? context[name].value : void 0;
+	const connected = shallowRef(false);
+	const pauses = /* @__PURE__ */ new Map();
+	const subscriptions = /* @__PURE__ */ new Set();
+	const activate = (entry) => {
+		if (entry.type === "connect") entry.cleanup = entry.callback(new Event("connect"));
+		else if (entry.type !== "disconnect") {
+			entry.target = root.value ?? void 0;
+			entry.target?.addEventListener(entry.type, entry.callback);
+		}
+	};
+	const deactivate = (entry, disconnecting) => {
+		entry.target?.removeEventListener(entry.type, entry.callback);
+		entry.target = void 0;
+		const cleanup = entry.cleanup;
+		entry.cleanup = void 0;
+		cleanup?.();
+		if (disconnecting && entry.type === "disconnect") entry.callback(new Event("disconnect"));
+	};
 	const propHandles = Object.create(null);
 	for (const name of propNames) {
 		const validity = () => options.propValidity?.(name);
@@ -123,15 +252,28 @@ function useComponentHost(controllerLoader, options) {
 		get root() {
 			return root.value;
 		},
-		state: new Proxy({}, {
-			get: (_target, name) => typeof name === "string" ? readState(name) : void 0,
-			set: (_target, name, value) => {
-				if (typeof name !== "string" || !Object.hasOwn(state, name)) throw new TypeError(`Only declared state is writable; \`${String(name)}\` is not.`);
-				state[name].value = value;
-				return true;
-			},
-			has: (_target, name) => typeof name === "string" && (Object.hasOwn(state, name) || Object.hasOwn(computedValues, name) || Object.hasOwn(data, name) || Object.hasOwn(context, name))
-		}),
+		...controllerNamespaces({
+			state: Object.fromEntries(Object.entries(state).map(([name, value]) => [name, {
+				get: () => value.value,
+				set: (next) => {
+					value.value = next;
+				}
+			}])),
+			computed: Object.fromEntries([...Object.entries(computedValues), ...Object.entries(context)].map(([name, value]) => [name, () => value.value])),
+			data: Object.fromEntries(Object.entries(data).map(([name, value]) => [name, () => value.value])),
+			acceptsState: options.acceptsState
+		}, options.controllerSource?.definition ?? "<component>"),
+		on(type, callback) {
+			const entry = {
+				type,
+				callback
+			};
+			subscriptions.add(entry);
+			if (connected.value) activate(entry);
+			return () => {
+				if (subscriptions.delete(entry)) deactivate(entry, false);
+			};
+		},
 		props: Object.freeze(propHandles),
 		refs: Object.defineProperties({}, Object.fromEntries(Object.entries(refs).map(([name, ref]) => [name, {
 			enumerable: true,
@@ -162,12 +304,24 @@ function useComponentHost(controllerLoader, options) {
 			return { get: () => value.value };
 		},
 		effect(run) {
-			const stop = watchEffect((onCleanup) => {
-				const cleanup = run();
-				if (typeof cleanup === "function") onCleanup(cleanup);
+			let cleanup;
+			const pause = () => {
+				const previous = cleanup;
+				cleanup = void 0;
+				previous?.();
+			};
+			const stop = watchEffect(() => {
+				pause();
+				if (connected.value) cleanup = run();
 			}, { flush: "post" });
-			stops.push(stop);
-			return stop;
+			const dispose = () => {
+				stop();
+				pause();
+				pauses.delete(dispose);
+			};
+			pauses.set(dispose, pause);
+			stops.push(dispose);
+			return dispose;
 		},
 		dispatch
 	};
@@ -175,13 +329,14 @@ function useComponentHost(controllerLoader, options) {
 	let started;
 	let stopObserving;
 	let connection = 0;
-	let connected = false;
+	let initialized = false;
 	let unmounted = false;
 	const disconnect = () => {
-		if (!connected) return;
-		connected = false;
+		if (!connected.value) return;
+		connected.value = false;
 		connection += 1;
-		for (const stop of stops.splice(0)) stop();
+		for (const pause of pauses.values()) pause();
+		for (const entry of subscriptions) deactivate(entry, true);
 		cleanup?.();
 		cleanup = void 0;
 	};
@@ -191,14 +346,23 @@ function useComponentHost(controllerLoader, options) {
 			disconnect();
 			return;
 		}
-		if (connected) return;
-		connected = true;
+		if (connected.value) {
+			for (const entry of subscriptions) if (entry.type !== "connect" && entry.type !== "disconnect" && entry.target !== root.value) {
+				deactivate(entry, false);
+				activate(entry);
+			}
+			return;
+		}
+		connected.value = true;
+		for (const entry of subscriptions) activate(entry);
+		if (initialized) return;
 		const current = ++connection;
 		started = loadControllerModule().then(async (loaded) => {
-			if (!connected || current !== connection) return loaded;
+			if (!connected.value || current !== connection || initialized) return loaded;
+			initialized = true;
 			const result = await loaded.default(host);
 			if (typeof result === "function") {
-				if (!connected || current !== connection) result();
+				if (!connected.value || current !== connection) result();
 				else cleanup = result;
 			}
 			return loaded;
@@ -221,12 +385,10 @@ function useComponentHost(controllerLoader, options) {
 		unmounted = true;
 		stopObserving?.();
 		disconnect();
+		for (const stop of stops.splice(0)) stop();
+		subscriptions.clear();
 	});
-	/** `ready` settles once the controller has started; a method exposed by the component awaits it. */
-	return {
-		host,
-		ready: () => started
-	};
+	return host;
 }
 var HtmlDiagnosticError = class extends Error {
 	diagnostic;
@@ -243,9 +405,21 @@ var HtmlDiagnosticError = class extends Error {
 function createDispatch(root, emit, options = {}) {
 	const { declared = {}, checks = {}, modeled = [] } = options;
 	const reported = /* @__PURE__ */ new Map();
-	return (name, detail) => {
+	return (name, detail, targets) => {
 		const check = checks[name];
 		if (detail !== void 0 && check !== void 0 && !check(detail)) throw new HtmlDiagnosticError("HR002", `Event \`${name}\` detail does not satisfy its declared type.`);
+		if (targets !== void 0) {
+			let accepted = true;
+			dispatchToTargets(targets, (target) => {
+				if (!target.dispatchEvent(new CustomEvent(name, {
+					bubbles: true,
+					composed: true,
+					...declared[name],
+					detail
+				}))) accepted = false;
+			});
+			return accepted;
+		}
 		if (detail !== null && typeof detail === "object") for (const prop of modeled) {
 			if (!(prop in detail)) continue;
 			const value = detail[prop];

package/vue/chunks/props.js

@@ -171,6 +171,20 @@ var CSS_NAMED_COLOR_SET = /* @__PURE__ */ new Set([
 	"yellowgreen"
 ]);
 var HTML_EMAIL_PATTERN = /^[a-zA-Z0-9.!#$%&'*+/?=^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+var eventType = typeof Event === "undefined" ? void 0 : Object.getOwnPropertyDescriptor(Event.prototype, "type").get;
+var eventBrands = /* @__PURE__ */ new WeakMap();
+function nativeEvent(value) {
+	if (typeof value !== "object" || value === null || !("type" in value) || eventType === void 0) return false;
+	const known = eventBrands.get(value);
+	if (known !== void 0) return known;
+	let accepted = false;
+	try {
+		eventType.call(value);
+		accepted = true;
+	} catch {}
+	eventBrands.set(value, accepted);
+	return accepted;
+}
 function issue(path, message) {
 	return {
 		ok: false,
@@ -334,6 +348,10 @@ function parse(value, node, path) {
 					ok: true,
 					value
 				} : issue(path, "Must be a " + (node.name === "trusted-html" ? "TrustedHTML" : "TrustedScript") + " value.");
+				case "event": return nativeEvent(value) ? {
+					ok: true,
+					value
+				} : issue(path, "Must be a native Event value.");
 				case "function": return typeof value === "function" ? {
 					ok: true,
 					value
@@ -434,13 +452,13 @@ function parse(value, node, path) {
 		}
 	}
 }
-/** Match HTML Next's typed invocation boundary before Vue renders or a controller reads a prop. */
+/** Return the actual selected destination, without a validation fallback. */
+function selectedBindingNode(selector, options) {
+	if (selector === null || selector === void 0) return null;
+	return options.find((candidate) => candidate.value === selector)?.type ?? null;
+}
 function selectedPropNode(selector, options) {
-	if (selector === null || selector === void 0) return {
-		kind: "terminal",
-		name: "null"
-	};
-	return options.find((candidate) => candidate.value === selector)?.type ?? {
+	return selectedBindingNode(selector, options) ?? {
 		kind: "terminal",
 		name: "null"
 	};
@@ -730,5 +748,23 @@ var vPropValidity = {
 		validityStates.delete(el);
 	}
 };
+/** Controller writes use immediate destination checks, including declared nested paths. */
+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 (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));
+		if (type.kind === "constrained") return acceptsControllerWrite(value, type.base, keys);
+		return parse(value, type, "$").ok;
+	}
+	if (type.kind === "union") return type.members.some((member) => acceptsControllerWrite(value, member, keys));
+	if (type.kind === "constrained") return acceptsControllerWrite(value, type.base, keys);
+	const key = keys[0];
+	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));
+}
 //#endregion
-export { vPropValidity as i, propValidityState as n, selectedPropNode as r, checkedProp as t };
+export { vPropValidity as a, selectedPropNode as i, checkedProp as n, propValidityState as r, acceptsControllerWrite as t };