@expressive/mvc 0.86.0 → 0.88.0

package/dist/state.js

@@ -1,6 +1,6 @@
-import { Caught } from "./caught.js";
+import { REPORT } from "./dispatch.js";
 import { capture, event, listener, observer, queued, touch, watch } from "./observable.js";
-import { Context, join } from "./context.js";
+import { Context, host, join } from "./context.js";
 
 //#region src/state.ts
 const define = Object.defineProperty;
@@ -11,7 +11,6 @@ const STORE = /* @__PURE__ */ new WeakMap();
 /** States under construction - added on `new`, removed when activated or released.
 *  Also carries work to run at the deadline, which `def` uses to bound its registry. */
 const PENDING = /* @__PURE__ */ new Set();
-/** External lifecycle listeners for any given State class. */
 const SETUP = /* @__PURE__ */ new WeakMap();
 /** Parent-child relationships. */
 const PARENT = /* @__PURE__ */ new WeakMap();
@@ -21,6 +20,10 @@ const UNBIND = /* @__PURE__ */ new WeakMap();
 const METHODS = /* @__PURE__ */ new WeakMap();
 /** List of reactive getters defined by a given type. */
 const GETTERS = /* @__PURE__ */ new WeakMap();
+/** Replacement for a getter captured by live computed properties, for hot patching. */
+const LATEST = /* @__PURE__ */ new WeakMap();
+/** Event every observer treats as watched, forcing a refresh after a hot patch. */
+const REFRESH = Symbol.for("@expressive/mvc.refresh");
 /** Stale flags for compute closures awaiting refresh on next access. */
 const STALE = /* @__PURE__ */ new WeakSet();
 /** Whether the deadline which drains `PENDING` is already queued for this tick. */
@@ -31,6 +34,8 @@ let ANNOUNCED = false;
 /** Adopters for managed properties which have held a child State. */
 const ADOPT = /* @__PURE__ */ new WeakMap();
 const CHILDREN = /* @__PURE__ */ new WeakMap();
+const OWNS = /* @__PURE__ */ new WeakMap();
+const OWNED = /* @__PURE__ */ new WeakMap();
 var State = class State {
 	/**
 	* Whether an instance activated with no enclosing context registers itself
@@ -51,7 +56,8 @@ var State = class State {
 	get(arg1, arg2, arg3) {
 		const self = this.is;
 		if (arg1 === void 0) return values(self);
-		if (State.is(arg1)) return Context.get(self).get(arg1, arg2, arg3, self);
+		if (arg1 === State) return typeof arg2 == "function" ? owned(self, arg2) : observed(this, arg1, owner(self, arg2));
+		if (State.is(arg1)) return observed(this, arg1, Context.get(self).get(arg1, arg2, arg3, self));
 		if (typeof arg1 == "function") return watch(self, unbind(arg1));
 		if (typeof arg2 == "function") return callback(self, arg2, arg1);
 		if (arg1 === null) return observer(self) === null;
@@ -60,7 +66,7 @@ var State = class State {
 	set(arg1, arg2) {
 		const self = this.is;
 		if (typeof arg1 == "function") return listener(self, (key) => {
-			if (typeof key == "string" || typeof key == "number" || typeof key == "symbol") return arg1.call(self, key, self);
+			if (typeof key == "string" || typeof key == "number" || typeof key == "symbol" && key !== REFRESH) return arg1.call(self, key, self);
 		});
 		if (typeof arg2 == "function") return callback(self, arg2, arg1);
 		if (arg1 && typeof arg1 == "object") assign(self, arg1, arg2 === true);
@@ -96,18 +102,8 @@ var State = class State {
 	static is(maybe) {
 		return maybe === this || typeof maybe == "function" && maybe.prototype instanceof this;
 	}
-	/**
-	* Register a lifecycle handler for this State and its subclasses.
-	*
-	* A bare function is per-instance setup run in the `prepare` phase (sugar for
-	* `{ before }`); if it returns a function, that runs when the instance is
-	* destroyed. Pass a {@link State.On} object to hook by cadence - `type`
-	* (per-class, at bootstrap), `before` (per-instance, before `new()`), and
-	* `after` (per-instance, at the `new()` slot).
-	*
-	* @returns Function to remove the handler.
-	*/
 	static on(handler) {
+		if (typeof handler == "function") handler = { setup: handler };
 		let setup = SETUP.get(this);
 		if (!setup) SETUP.set(this, setup = /* @__PURE__ */ new Set());
 		setup.add(handler);
@@ -120,6 +116,9 @@ define(State.prototype, "toString", { value() {
 define(State, "toString", { value() {
 	return this.name;
 } });
+function observed(from, key, value) {
+	return value instanceof State ? touch(from, key, value) : value;
+}
 /** Register a user OnEvent callback, preserving `this` and `source`. */
 function callback(self, cb, select) {
 	return listener(self, (key) => cb.call(self, key, self), select);
@@ -141,7 +140,9 @@ function init(state, ...args) {
 	function observe() {
 		for (const key in state) {
 			const desc = Object.getOwnPropertyDescriptor(state, key) || {};
-			if ("value" in desc && desc.configurable) apply(state, key, desc, true);
+			if (!("value" in desc) || !desc.configurable) continue;
+			if (key[0] == "_") unmanaged(state, key, desc.value);
+			else apply(state, key, desc, true);
 		}
 	}
 	function register() {
@@ -150,13 +151,20 @@ function init(state, ...args) {
 		const g = type.global;
 		if (!(typeof g == "function" ? g(state) : g)) return;
 		if (!Object.prototype.hasOwnProperty.call(type, "global")) throw new Error(`${state} would register as a global by inheritance alone - re-declare \`static global\` on ${type.name} (\`true\` to keep it, \`false\` to opt out).`);
+		for (let T = type; T !== State; T = Object.getPrototypeOf(T)) {
+			const found = Context.root.get(T, false);
+			if (found && (T === type || found.constructor === T)) throw new Error(`Cannot register ${state} as a global - ${found} already exists in root. Destroy the existing instance first, or provide additional ones via explicit context.`);
+		}
 		return Context.root.add(state);
 	}
 	listener(state, (key) => {
 		const rest = trailing(state);
 		PENDING.delete(state);
 		if (key === null) return null;
-		parent(state, null);
+		if (!PARENT.has(state)) parent(state, host(state) || null);
+		const above = PARENT.get(state);
+		const owns = above && (OWNS.get(above) || OWNS.set(above, /* @__PURE__ */ new Set()).get(above));
+		if (owns) listener(state, () => void owns.delete(state), null);
 		const queue = [
 			...before,
 			observe,
@@ -169,12 +177,16 @@ function init(state, ...args) {
 			for (let i = 0; i < queue.length; i++) {
 				const arg = queue[i];
 				const out = typeof arg == "function" ? arg.call(state, state) : arg;
-				if (out instanceof Promise) out.catch((err) => report(new Caught.Init(state, err)));
+				if (out instanceof Promise) out.catch((err) => report("setup", state, err));
 				else if (Array.isArray(out)) queue.splice(i + 1, 0, ...out);
 				else if (typeof out == "function") listener(state, out, null);
 				else if (typeof out == "object") assign(state, out, true);
 			}
 		});
+		if (owns) {
+			owns.add(state);
+			OWNED.get(above)?.forEach((cb) => cb(state));
+		}
 		let end = rest.length;
 		while (end-- > 0 && PENDING.has(rest[end]));
 		for (let i = 0; i < end; i++) PENDING.delete(rest[i]);
@@ -185,12 +197,22 @@ function init(state, ...args) {
 		queueMicrotask(() => {
 			QUEUED = false;
 			for (const item of PENDING) if (typeof item == "function") item();
-			else report(new Caught.Inactive(item));
+			else report("unused", item, /* @__PURE__ */ new Error(`${item} was constructed but never activated.`));
 			PENDING.clear();
 		});
 	}
 	PENDING.add(state);
 }
+function unmanaged(state, key, value) {
+	define(state, key, {
+		configurable: true,
+		enumerable: false,
+		get: () => value,
+		set: (next) => {
+			value = next;
+		}
+	});
+}
 /**
 * Apply instructions and inherited event listeners. Ensure class metadata is ready.
 *
@@ -210,10 +232,9 @@ function bootstrap(T) {
 		T = Object.getPrototypeOf(T);
 	}
 	for (const type of chain) {
-		for (const handler of SETUP.get(type) || []) if (typeof handler == "function") before.add(handler);
-		else {
-			if (handler.before) before.add(handler.before);
-			if (handler.after) after.add(handler.after);
+		for (const handler of SETUP.get(type) || []) {
+			if (handler.setup) before.add(handler.setup);
+			if (handler.ready) after.add(handler.ready);
 			if (handler.type) onType.add(handler.type);
 		}
 		if (type === State) continue;
@@ -225,34 +246,7 @@ function bootstrap(T) {
 		for (const setupType of onType) setupType(type);
 		METHODS.set(type, keys = new Map(keys));
 		GETTERS.set(type, getters = new Map(getters));
-		for (const [key, desc] of Object.entries(Object.getOwnPropertyDescriptors(type.prototype))) {
-			if (key == "constructor" || !desc.configurable) continue;
-			if (typeof desc.get == "function") {
-				if (desc.configurable && typeof desc.set != "function") getters.set(key, desc.get);
-				continue;
-			}
-			const { value } = desc;
-			if (typeof value !== "function") continue;
-			function bind(original) {
-				const { is } = this;
-				if (is.hasOwnProperty(key) && !original) return value;
-				const fn = original || value;
-				const bound = fn.bind(is);
-				UNBIND.set(bound, fn);
-				define(is, key, {
-					value: bound,
-					writable: true,
-					configurable: true
-				});
-				return bound;
-			}
-			UNBIND.set(bind, value);
-			keys.set(key, bind);
-			define(type.prototype, key, {
-				get: bind,
-				set: bind
-			});
-		}
+		classify(type, keys, getters);
 	}
 	if (getters.size) before.add((self) => getters.forEach(compute, self));
 	return {
@@ -260,6 +254,57 @@ function bootstrap(T) {
 		after
 	};
 }
+/** Bind own configurable methods of a type and collect its reactive getters. */
+function classify(type, keys, getters) {
+	for (const [key, desc] of Object.entries(Object.getOwnPropertyDescriptors(type.prototype))) {
+		if (key == "constructor" || !desc.configurable) continue;
+		const { get, set } = desc;
+		if (key[0] == "_" && (get || set)) {
+			define(type.prototype, key, {
+				...desc,
+				get: get && function() {
+					return get.call(this.is || this);
+				},
+				set: set && function(value) {
+					set.call(this.is || this, value);
+				}
+			});
+			continue;
+		}
+		if (typeof get == "function") {
+			if (typeof set != "function") getters.set(key, get);
+			continue;
+		}
+		const { value } = desc;
+		if (typeof value !== "function") continue;
+		function bind(original) {
+			const { is } = this;
+			if (is.hasOwnProperty(key) && !original) return value;
+			const fn = original || value;
+			const bound = fn.bind(is);
+			UNBIND.set(bound, fn);
+			define(is, key, {
+				value: bound,
+				writable: true,
+				configurable: true
+			});
+			for (const handler of stages(is.constructor, "method")) handler.call(is, key, bound, is);
+			return bound;
+		}
+		UNBIND.set(bind, value);
+		keys.set(key, bind);
+		define(type.prototype, key, {
+			get: bind,
+			set: bind
+		});
+	}
+}
+/** Handlers of one stage along the class chain - ancestor first, in registration order, each once. */
+function stages(T, key) {
+	const found = T === State ? /* @__PURE__ */ new Set() : stages(Object.getPrototypeOf(T), key);
+	for (const handler of SETUP.get(T) || []) if (handler[key]) found.add(handler[key]);
+	return found;
+}
 /**
 * Install a reactive computed property on a state instance, derived from a prototype
 * getter or an arity-bearing `set` factory.
@@ -288,13 +333,13 @@ function compute(getter, key) {
 	const run = (initial) => {
 		let next;
 		try {
-			next = getter.call(proxy, proxy);
+			next = latest(getter).call(proxy, proxy);
 		} catch (err) {
 			if (initial) {
 				console.warn(`An exception was thrown while initializing ${this}.${key}.`);
 				throw err;
 			}
-			if (!(err instanceof Promise)) report(new Caught.Getter(this, key, err));
+			if (!(err instanceof Promise)) report("getter", this, err, key);
 		}
 		update(this, key, next, !isAsync);
 	};
@@ -416,6 +461,26 @@ function children(state, callback) {
 	set.add(callback);
 	return () => set.delete(callback);
 }
+function owner(state, required) {
+	const found = PARENT.get(state);
+	if (found || required === false) return found || void 0;
+	throw new Error(`${state} has no owner.`);
+}
+/**
+* Report States owned by this one - those active now, then each one as it
+* activates. A function returned by `callback` runs when that State is destroyed.
+*/
+function owned(state, callback) {
+	function each(child) {
+		const done = callback(child);
+		if (typeof done == "function") listener(child, () => void done(), null);
+	}
+	OWNS.get(state)?.forEach(each);
+	let set = OWNED.get(state);
+	if (!set) OWNED.set(state, set = /* @__PURE__ */ new Set());
+	set.add(each);
+	return () => void set.delete(each);
+}
 /** Currently accumulating export. Stores real values of placeholder properties such as ref() or child states. */
 let EXPORT;
 function values(state) {
@@ -470,7 +535,7 @@ function assign(state, data, silent) {
 		else if (key in state && key !== "is") {
 			const set = (Object.getOwnPropertyDescriptor(state, key) || {}).set;
 			if (set) set.call(state, data[key], silent);
-			else state[key] = data[key];
+			else Reflect.set(state, key, data[key]);
 		}
 	}
 }
@@ -479,15 +544,16 @@ function assign(state, data, silent) {
 *
 * This is used internally to update properties, but can also be used to update properties which are not managed by state, or to update values without triggering setters.
 *
-* A destroyed state reports the write - thrown to the writer unless a `catch` handler takes it - and returns `false`; `silent` skips both, and dispatch.
+* A destroyed state stores the write without dispatch, reports it unless `silent`, and returns `false`.
 */
 function update(state, key, value, silent, own) {
+	const store = STORE.get(state);
+	if (value instanceof State) value = value.is;
 	if (observer(state) === null) {
-		if (!silent) report(new Caught.Destroyed(state, String(key)), true);
+		if (!silent) report("dead", state, /* @__PURE__ */ new Error(`Tried to update ${state}.${String(key)} but state is destroyed.`), String(key));
+		store[key] = value;
 		return false;
 	}
-	const store = STORE.get(state);
-	if (value instanceof State) value = value.is;
 	if (key in store && value === store[key]) return false;
 	store[key] = value;
 	if (!silent) event(state, key);
@@ -495,40 +561,23 @@ function update(state, key, value, silent, own) {
 	return true;
 }
 /**
-* Pass a caught error along `catch` handlers - most-derived class first, last registered
-* first - until one returns nothing. Passed off the end, a warning logs and anything
-* else is thrown - to the caller when `sync`, else uncaught. So is a handler's throw,
-* and one wrapping an error a handler already threw escapes that error unreported.
+* Pass an error along `catch` handlers - most-derived class first, last registered
+* first, one on several classes once at the outermost - until one returns nothing. Passed off
+* the end, a destroyed write outputs nothing, `unused` warns, anything else escapes uncaught;
+* so does a handler's throw.
 */
-function report(caught, sync) {
-	const handlers = /* @__PURE__ */ new Set();
-	let error = caught;
-	if (caught.cause instanceof Caught) return escape(caught.cause);
-	for (let T = caught.state.constructor;; T = Object.getPrototypeOf(T)) {
-		for (const handler of [...SETUP.get(T) || []].reverse()) if (typeof handler == "object" && handler.catch) handlers.add(handler.catch);
-		if (T === State) break;
-	}
+function report(kind, owner, error, key) {
+	const state = owner instanceof State ? owner : owner && PARENT.get(owner);
+	if (!state) return REPORT.error(error);
 	try {
-		for (const handler of handlers) if (!(error = handler.call(caught.state, error))) return;
+		for (const handler of [...stages(state.constructor, "catch")].reverse()) if ((error = handler.call(state, error, kind, key)) === void 0) return;
+		if (kind == "unused") console.warn(error);
+		else if (kind != "dead") REPORT.error(error);
 	} catch (err) {
-		if (sync) throw err;
-		return escape(err);
+		REPORT.error(err);
 	}
-	if (error.warning) console.warn(error);
-	else if (sync) throw error;
-	else escape(error);
-}
-function escape(err) {
-	queueMicrotask(() => {
-		throw err;
-	});
-}
-/** Error thrown by a handler replaying in dispatch, attributed to the State which queued it. */
-function fault(err, owner) {
-	const state = owner instanceof State ? owner : owner && PARENT.get(owner);
-	if (state) report(new Caught.Effect(state, err));
-	else escape(err);
 }
+REPORT.as = report;
 /**
 * Hand a value stored by an owning writer to that property's adopter,
 * creating one the first time a State is stored there. A property which has
@@ -548,6 +597,11 @@ function adopt(state, key, value) {
 	}
 	claim(value);
 }
+/** Resolve a getter to its latest hot-patched replacement. */
+function latest(getter) {
+	for (let next; next = LATEST.get(getter);) getter = next;
+	return getter;
+}
 /** Random alphanumberic of length 6; always starts with a letter. */
 function uid() {
 	return (.278 + Math.random() * .722).toString(36).substring(2, 8).toUpperCase();
@@ -563,5 +617,5 @@ function parent(child, value) {
 }
 
 //#endregion
-export { PENDING, STORE, State, access, apply, children, compute, event, fault, parent, uid, unbind, update };
+export { GETTERS, LATEST, METHODS, PENDING, SETUP, STORE, State, UNBIND, access, adopt, apply, children, classify, compute, event, owned, parent, trailing, uid, unbind, update };
 //# sourceMappingURL=state.js.map