@expressive/mvc 0.73.0 → 0.78.0

package/dist/field/def.js

@@ -0,0 +1,29 @@
+import { listener } from "../observable.js";
+import { STORE, State, apply, uid } from "../state.js";
+
+//#region src/field/def.ts
+const APPLY = /* @__PURE__ */ new Map();
+function def(arg1) {
+	const token = Symbol("field-" + uid());
+	APPLY.set(token, arg1);
+	return token;
+}
+State.on((self) => {
+	const store = STORE.get(self);
+	for (const key in self) {
+		const property = Object.getOwnPropertyDescriptor(self, key);
+		const instruction = APPLY.get(property.value);
+		if (!instruction) continue;
+		APPLY.delete(property.value);
+		delete self[key];
+		const output = instruction.call(self, key, self, store);
+		if (!output) continue;
+		const desc = typeof output == "function" ? { destroy: output } : output;
+		if (desc.destroy) listener(self, desc.destroy, null);
+		apply(self, key, desc, true);
+	}
+});
+
+//#endregion
+export { def };
+//# sourceMappingURL=def.js.map

package/dist/field/def.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"def.js","names":[],"sources":["../../src/field/def.ts"],"sourcesContent":["import { listener } from '../observable';\nimport { State, STORE, uid, apply } from '../state';\n\ndeclare namespace def {\n  /**\n   * Property initializer, will run upon instance creation.\n   * Optional returned callback will run when once upon first access.\n   */\n  type Factory<T = any, M extends State = any> = (\n    this: M,\n    key: Extract<State.Field<M>, string>,\n    thisArg: M,\n    state: State.Values<M>\n  ) => def.Config<T> | (() => void) | void;\n\n  interface Config<T = any> extends State.Apply<T> {\n    destroy?: () => void;\n  }\n}\n\nconst APPLY = new Map<symbol, def.Factory>();\n\nfunction def<T>(arg1: def.Factory<T>) {\n  const token = Symbol('field-' + uid());\n  APPLY.set(token, arg1);\n  return token as T extends void ? unknown : T;\n}\n\nState.on((self) => {\n  const store = STORE.get(self)!;\n\n  for (const key in self) {\n    const property = Object.getOwnPropertyDescriptor(self, key)!;\n    const instruction = APPLY.get(property.value);\n\n    if (!instruction) continue;\n\n    APPLY.delete(property.value);\n    delete (self as any)[key];\n\n    const output = instruction.call(self, key, self, store);\n\n    if (!output) continue;\n\n    const desc = typeof output == 'function' ? { destroy: output } : output;\n\n    if (desc.destroy) listener(self, desc.destroy, null);\n\n    apply(self, key, desc, true);\n  }\n});\n\nexport { def };\n"],"mappings":";;;;AAoBA,MAAM,wBAAQ,IAAI,KAA0B;AAE5C,SAAS,IAAO,MAAsB;CACpC,MAAM,QAAQ,OAAO,WAAW,KAAK,CAAC;AACtC,OAAM,IAAI,OAAO,KAAK;AACtB,QAAO;;AAGT,MAAM,IAAI,SAAS;CACjB,MAAM,QAAQ,MAAM,IAAI,KAAK;AAE7B,MAAK,MAAM,OAAO,MAAM;EACtB,MAAM,WAAW,OAAO,yBAAyB,MAAM,IAAI;EAC3D,MAAM,cAAc,MAAM,IAAI,SAAS,MAAM;AAE7C,MAAI,CAAC,YAAa;AAElB,QAAM,OAAO,SAAS,MAAM;AAC5B,SAAQ,KAAa;EAErB,MAAM,SAAS,YAAY,KAAK,MAAM,KAAK,MAAM,MAAM;AAEvD,MAAI,CAAC,OAAQ;EAEb,MAAM,OAAO,OAAO,UAAU,aAAa,EAAE,SAAS,QAAQ,GAAG;AAEjE,MAAI,KAAK,QAAS,UAAS,MAAM,KAAK,SAAS,KAAK;AAEpD,QAAM,MAAM,KAAK,MAAM,KAAK;;EAE9B"}

package/dist/field/get.d.ts

@@ -0,0 +1,57 @@
+import { State } from "../state.js";
+
+//#region src/field/get.d.ts
+declare namespace get {
+  type Callback<T = any> = (state: T, subject: State) => void | boolean | (() => void);
+}
+/**
+ * Fetches upstream State from context with optional lifecycle callback.
+ * Callback runs on mount and can return cleanup function for unmount.
+ *
+ * @param Type - Type of State to fetch.
+ * @param callback - Optional lifecycle callback, receives (state, subject). Can return cleanup function.
+ */
+declare function get<T extends State>(Type: State.Extends<T>, callback?: get.Callback<T>): T;
+/**
+ * Fetches and assigns the controller which spawned this host.
+ * When parent assigns an instance via `use()` directive, it
+ * will be made available to child upon this request.
+ *
+ * @param Type - Type of controller compatible with this class.
+ * @param required - If false, property may be undefined. Otherwise will throw.
+ */
+declare function get<T extends State>(Type: State.Extends<T>, required: false): T | undefined;
+/**
+ * Collects downstream States, accumulating all instances of specified type
+ * for which this is an ancestor. Returns an array that updates as States
+ * are added or removed. Callback runs on each registration and can return
+ * cleanup or false to prevent registration.
+ *
+ * @param Type - Type of State to collect.
+ * @param downstream - Must be true to enable downstream mode.
+ * @param callback - Optional lifecycle callback, receives (state, subject). May return false to prevent registration.
+ */
+declare function get<T extends State>(Type: State.Extends<T>, downstream: true, callback?: get.Callback<T>): T[];
+/**
+ * Fetches a single downstream State of specified type.
+ * Updates when a matching child appears or is removed.
+ * Throws if not found.
+ *
+ * @param Type - Type of State to fetch.
+ * @param downstream - Must be true to enable downstream mode.
+ * @param required - Throw if no match found.
+ */
+declare function get<T extends State>(Type: State.Extends<T>, downstream: true, single: true): T;
+/**
+ * Fetches a single downstream State of specified type.
+ * Updates when a matching child appears or is removed.
+ * Returns undefined if not found.
+ *
+ * @param Type - Type of State to fetch.
+ * @param downstream - Must be true to enable downstream mode.
+ * @param required - If false, returns undefined if no match found.
+ */
+declare function get<T extends State>(Type: State.Extends<T>, downstream: true, required: false): T | undefined;
+//#endregion
+export { get };
+//# sourceMappingURL=get.d.ts.map

package/dist/field/get.js

@@ -0,0 +1,90 @@
+import { capture } from "../observable.js";
+import { parent, update } from "../state.js";
+import { Context } from "../context.js";
+import { def } from "./def.js";
+
+//#region src/field/get.ts
+function get(Type, arg1, arg2) {
+	return arg1 === true ? below(Type, arg2) : above(Type, arg1);
+}
+function above(Type, argument) {
+	return def((key, subject) => {
+		const hasParent = parent(subject);
+		const callback = typeof argument === "function" ? argument : void 0;
+		function assign(value) {
+			if (callback) {
+				const result = callback(value, subject);
+				if (typeof result === "function") subject.set(null, result);
+			}
+			update(subject, key, value);
+		}
+		if (hasParent && hasParent instanceof Type) {
+			assign(hasParent);
+			return {};
+		}
+		const ctx = Context.get(subject);
+		let found = false;
+		ctx.get(Type, (state) => {
+			found = true;
+			assign(state);
+		}, false, subject);
+		if (!found && argument !== false) throw new Error(`Required ${Type} not found in context for ${subject}.`);
+		return {
+			get: argument !== false,
+			enumerable: false
+		};
+	});
+}
+function below(Type, arg) {
+	return def((key, subject) => {
+		const context = Context.get(subject);
+		if (typeof arg == "boolean") {
+			context.get(Type, (state) => {
+				update(subject, key, state);
+				return state.set(null, () => {
+					update(subject, key, void 0);
+				});
+			}, true);
+			return {
+				get: arg,
+				value: void 0,
+				enumerable: false
+			};
+		}
+		const applied = /* @__PURE__ */ new Set();
+		context.get(Type, (state) => {
+			let remove;
+			let release;
+			if (applied.has(state)) return;
+			if (arg) {
+				let rejected = false;
+				capture((fn) => {
+					const done = arg(state, subject);
+					if (done === false) rejected = true;
+					else if (typeof done == "function") remove = done;
+					release = fn;
+				});
+				if (rejected) return;
+			}
+			applied.add(state);
+			update(subject, key, [...applied]);
+			function done() {
+				if (release) release();
+				ignore();
+				applied.delete(state);
+				update(subject, key, [...applied]);
+				if (typeof remove == "function") remove();
+			}
+			const ignore = state.set(null, done);
+			return done;
+		}, true);
+		return {
+			value: [],
+			enumerable: false
+		};
+	});
+}
+
+//#endregion
+export { get };
+//# sourceMappingURL=get.js.map

package/dist/field/get.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get.js","names":[],"sources":["../../src/field/get.ts"],"sourcesContent":["import { capture } from '../observable';\nimport { Context } from '../context';\nimport { State, parent, update } from '../state';\nimport { def } from './def';\n\ndeclare namespace get {\n  type Callback<T = any> = (\n    state: T,\n    subject: State\n  ) => void | boolean | (() => void);\n}\n\n/**\n * Fetches upstream State from context with optional lifecycle callback.\n * Callback runs on mount and can return cleanup function for unmount.\n *\n * @param Type - Type of State to fetch.\n * @param callback - Optional lifecycle callback, receives (state, subject). Can return cleanup function.\n */\nfunction get<T extends State>(\n  Type: State.Extends<T>,\n  callback?: get.Callback<T>\n): T;\n\n/**\n * Fetches and assigns the controller which spawned this host.\n * When parent assigns an instance via `use()` directive, it\n * will be made available to child upon this request.\n *\n * @param Type - Type of controller compatible with this class.\n * @param required - If false, property may be undefined. Otherwise will throw.\n */\nfunction get<T extends State>(\n  Type: State.Extends<T>,\n  required: false\n): T | undefined;\n\n/**\n * Collects downstream States, accumulating all instances of specified type\n * for which this is an ancestor. Returns an array that updates as States\n * are added or removed. Callback runs on each registration and can return\n * cleanup or false to prevent registration.\n *\n * @param Type - Type of State to collect.\n * @param downstream - Must be true to enable downstream mode.\n * @param callback - Optional lifecycle callback, receives (state, subject). May return false to prevent registration.\n */\nfunction get<T extends State>(\n  Type: State.Extends<T>,\n  downstream: true,\n  callback?: get.Callback<T>\n): T[];\n\n/**\n * Fetches a single downstream State of specified type.\n * Updates when a matching child appears or is removed.\n * Throws if not found.\n *\n * @param Type - Type of State to fetch.\n * @param downstream - Must be true to enable downstream mode.\n * @param required - Throw if no match found.\n */\nfunction get<T extends State>(\n  Type: State.Extends<T>,\n  downstream: true,\n  single: true\n): T;\n\n/**\n * Fetches a single downstream State of specified type.\n * Updates when a matching child appears or is removed.\n * Returns undefined if not found.\n *\n * @param Type - Type of State to fetch.\n * @param downstream - Must be true to enable downstream mode.\n * @param required - If false, returns undefined if no match found.\n */\nfunction get<T extends State>(\n  Type: State.Extends<T>,\n  downstream: true,\n  required: false\n): T | undefined;\n\nfunction get<T extends State>(\n  Type: State.Extends<T>,\n  arg1?: get.Callback<T> | boolean,\n  arg2?: get.Callback<T> | boolean\n) {\n  return arg1 === true ? below(Type, arg2) : above(Type, arg1);\n}\n\nfunction above<T extends State>(\n  Type: State.Extends<T>,\n  argument: get.Callback<T> | boolean | undefined\n) {\n  return def<T>((key, subject) => {\n    const hasParent = parent(subject);\n    const callback =\n      typeof argument === 'function'\n        ? (argument as get.Callback<T>)\n        : undefined;\n\n    function assign(value: T) {\n      if (callback) {\n        const result = callback(value, subject);\n        if (typeof result === 'function') subject.set(null, result);\n      }\n      update(subject, key, value);\n    }\n\n    if (hasParent && hasParent instanceof Type) {\n      assign(hasParent as T);\n      return {};\n    }\n\n    const ctx = Context.get(subject);\n    let found = false;\n\n    ctx.get(Type, (state) => {\n      found = true;\n      assign(state);\n    }, false, subject);\n\n    if (!found && argument !== false)\n      throw new Error(`Required ${Type} not found in context for ${subject}.`);\n\n    return {\n      get: argument !== false,\n      enumerable: false\n    };\n  });\n}\n\nfunction below<T extends State>(\n  Type: State.Extends<T>,\n  arg: get.Callback<T> | boolean | undefined\n) {\n  return def<T[]>((key, subject) => {\n    const context = Context.get(subject);\n\n    if (typeof arg == 'boolean') {\n      context.get(\n        Type,\n        (state) => {\n          update(subject, key, state);\n          return state.set(null, () => {\n            update(subject, key, undefined);\n          });\n        },\n        true\n      );\n\n      return {\n        get: arg,\n        value: undefined,\n        enumerable: false\n      };\n    }\n\n    const applied = new Set<State>();\n\n    context.get(\n      Type,\n      (state) => {\n        let remove: (() => void) | undefined;\n        let release: (() => void) | undefined;\n\n        if (applied.has(state)) return;\n\n        if (arg) {\n          let rejected = false;\n\n          capture((fn) => {\n            const done = arg(state, subject);\n\n            if (done === false) rejected = true;\n            else if (typeof done == 'function') remove = done;\n\n            release = fn;\n          });\n\n          if (rejected) return;\n        }\n\n        applied.add(state);\n        update(subject, key, [...applied]);\n\n        function done() {\n          if (release) release();\n          ignore();\n\n          applied.delete(state);\n          update(subject, key, [...applied]);\n\n          if (typeof remove == 'function') remove();\n        }\n\n        const ignore = state.set(null, done);\n\n        return done;\n      },\n      true\n    );\n\n    return {\n      value: [],\n      enumerable: false\n    };\n  });\n}\n\nexport { get };\n"],"mappings":";;;;;;AAmFA,SAAS,IACP,MACA,MACA,MACA;AACA,QAAO,SAAS,OAAO,MAAM,MAAM,KAAK,GAAG,MAAM,MAAM,KAAK;;AAG9D,SAAS,MACP,MACA,UACA;AACA,QAAO,KAAQ,KAAK,YAAY;EAC9B,MAAM,YAAY,OAAO,QAAQ;EACjC,MAAM,WACJ,OAAO,aAAa,aACf,WACD;EAEN,SAAS,OAAO,OAAU;AACxB,OAAI,UAAU;IACZ,MAAM,SAAS,SAAS,OAAO,QAAQ;AACvC,QAAI,OAAO,WAAW,WAAY,SAAQ,IAAI,MAAM,OAAO;;AAE7D,UAAO,SAAS,KAAK,MAAM;;AAG7B,MAAI,aAAa,qBAAqB,MAAM;AAC1C,UAAO,UAAe;AACtB,UAAO,EAAE;;EAGX,MAAM,MAAM,QAAQ,IAAI,QAAQ;EAChC,IAAI,QAAQ;AAEZ,MAAI,IAAI,OAAO,UAAU;AACvB,WAAQ;AACR,UAAO,MAAM;KACZ,OAAO,QAAQ;AAElB,MAAI,CAAC,SAAS,aAAa,MACzB,OAAM,IAAI,MAAM,YAAY,KAAK,4BAA4B,QAAQ,GAAG;AAE1E,SAAO;GACL,KAAK,aAAa;GAClB,YAAY;GACb;GACD;;AAGJ,SAAS,MACP,MACA,KACA;AACA,QAAO,KAAU,KAAK,YAAY;EAChC,MAAM,UAAU,QAAQ,IAAI,QAAQ;AAEpC,MAAI,OAAO,OAAO,WAAW;AAC3B,WAAQ,IACN,OACC,UAAU;AACT,WAAO,SAAS,KAAK,MAAM;AAC3B,WAAO,MAAM,IAAI,YAAY;AAC3B,YAAO,SAAS,KAAK,OAAU;MAC/B;MAEJ,KACD;AAED,UAAO;IACL,KAAK;IACL,OAAO;IACP,YAAY;IACb;;EAGH,MAAM,0BAAU,IAAI,KAAY;AAEhC,UAAQ,IACN,OACC,UAAU;GACT,IAAI;GACJ,IAAI;AAEJ,OAAI,QAAQ,IAAI,MAAM,CAAE;AAExB,OAAI,KAAK;IACP,IAAI,WAAW;AAEf,aAAS,OAAO;KACd,MAAM,OAAO,IAAI,OAAO,QAAQ;AAEhC,SAAI,SAAS,MAAO,YAAW;cACtB,OAAO,QAAQ,WAAY,UAAS;AAE7C,eAAU;MACV;AAEF,QAAI,SAAU;;AAGhB,WAAQ,IAAI,MAAM;AAClB,UAAO,SAAS,KAAK,CAAC,GAAG,QAAQ,CAAC;GAElC,SAAS,OAAO;AACd,QAAI,QAAS,UAAS;AACtB,YAAQ;AAER,YAAQ,OAAO,MAAM;AACrB,WAAO,SAAS,KAAK,CAAC,GAAG,QAAQ,CAAC;AAElC,QAAI,OAAO,UAAU,WAAY,SAAQ;;GAG3C,MAAM,SAAS,MAAM,IAAI,MAAM,KAAK;AAEpC,UAAO;KAET,KACD;AAED,SAAO;GACL,OAAO,EAAE;GACT,YAAY;GACb;GACD"}

package/dist/field/hot.d.ts

@@ -0,0 +1,16 @@
+//#region src/field/hot.d.ts
+/**
+ * Wrap an array or object as a reactive Proxy.
+ *
+ * Reads register subscriptions in active watch contexts; writes fire keyed events.
+ * Single-level only - nested objects are not wrapped recursively. Use a child State
+ * (or a separate `hot()` call) for nested reactivity.
+ *
+ * Storage is shared with the input value: external mutation of the original
+ * collection bypasses dispatch. Pass a fresh value when this matters.
+ */
+declare function hot<T>(value: T[]): T[];
+declare function hot<T extends object>(value: T): T;
+//#endregion
+export { hot };
+//# sourceMappingURL=hot.d.ts.map

package/dist/field/hot.js

@@ -0,0 +1,98 @@
+import { event, touch } from "../observable.js";
+
+//#region src/field/hot.ts
+function hot(value) {
+	if (typeof value !== "object" || !value) throw new Error("hot() requires an array or object");
+	return Array.isArray(value) ? array(value) : object(value);
+}
+const MAX_INDEX = 2 ** 32 - 2;
+const DELETES = new Set([
+	"pop",
+	"shift",
+	"splice"
+]);
+function array(value) {
+	function index(key) {
+		const value = typeof key == "symbol" ? -1 : +key;
+		return String(value) === key && value >= 0 && value <= MAX_INDEX ? value : -1;
+	}
+	function deny() {
+		throw new Error("hot() arrays must be dense. Use undefined/null placeholders or splice().");
+	}
+	for (let i = 0; i < value.length; i++) if (!(i in value)) deny();
+	const get = () => Object.freeze(value.slice());
+	let internal = false;
+	const proxy = new Proxy(value, {
+		has,
+		get(target, key, receiver) {
+			if (key === "get") return get;
+			const result = Reflect.get(target, key, receiver);
+			if (typeof key === "symbol") return result;
+			if (typeof result === "function") return DELETES.has(key) ? (...args) => {
+				internal = true;
+				try {
+					return result.apply(receiver, args);
+				} finally {
+					internal = false;
+				}
+			} : result;
+			return touch(receiver, key, result);
+		},
+		set(target, key, value) {
+			const oldLength = target.length;
+			if (key === "length" && value > oldLength) deny();
+			const grows = index(key) >= target.length;
+			if (grows && index(key) > target.length) deny();
+			const ok = assign(proxy, target, key, value);
+			if (ok && grows && typeof key !== "symbol") event(proxy, "length");
+			if (ok && key === "length") for (let i = target.length; i < oldLength; i++) event(proxy, String(i));
+			return ok;
+		},
+		deleteProperty(target, key) {
+			if (!(key in target)) return true;
+			if (index(key) >= 0 && !internal) deny();
+			return remove(proxy, target, key);
+		}
+	});
+	event(proxy);
+	return proxy;
+}
+function object(value) {
+	const get = () => Object.freeze({ ...value });
+	const proxy = new Proxy(value, {
+		has,
+		get(target, key, receiver) {
+			if (key === "get" && !(key in target)) return get;
+			const result = Reflect.get(target, key, receiver);
+			if (typeof key === "symbol" || typeof result === "function") return result;
+			return touch(receiver, key, result);
+		},
+		set(target, key, value) {
+			return assign(proxy, target, key, value);
+		},
+		deleteProperty(target, key) {
+			return remove(proxy, target, key);
+		}
+	});
+	event(proxy);
+	return proxy;
+}
+function has(target, key) {
+	return key === "get" || key in target;
+}
+function assign(proxy, target, key, value) {
+	const old = target[key];
+	const ok = Reflect.set(target, key, value);
+	if (ok && typeof key !== "symbol" && old !== value) event(proxy, key);
+	return ok;
+}
+function remove(proxy, target, key) {
+	if (!(key in target)) return true;
+	const ok = Reflect.deleteProperty(target, key);
+	if (ok && typeof key !== "symbol") event(proxy, key);
+	return ok;
+}
+
+//#endregion
+export { hot };
+//# sourceMappingURL=hot.js.map

package/dist/field/hot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hot.js","names":[],"sources":["../../src/field/hot.ts"],"sourcesContent":["import { event, touch } from '../observable';\n\n/**\n * Wrap an array or object as a reactive Proxy.\n *\n * Reads register subscriptions in active watch contexts; writes fire keyed events.\n * Single-level only - nested objects are not wrapped recursively. Use a child State\n * (or a separate `hot()` call) for nested reactivity.\n *\n * Storage is shared with the input value: external mutation of the original\n * collection bypasses dispatch. Pass a fresh value when this matters.\n */\nfunction hot<T>(value: T[]): T[];\nfunction hot<T extends object>(value: T): T;\nfunction hot(value: any) {\n  if (typeof value !== 'object' || !value)\n    throw new Error('hot() requires an array or object');\n\n  return Array.isArray(value) ? array(value) : object(value);\n}\n\nconst MAX_INDEX = 2 ** 32 - 2;\nconst DELETES = new Set(['pop', 'shift', 'splice']);\n\nfunction array<T>(value: T[]) {\n  function index(key: string | symbol) {\n    const value = typeof key == 'symbol' ? -1 : +key;\n    return String(value) === key && value >= 0 && value <= MAX_INDEX ? value : -1;\n  }\n\n  function deny() {\n    throw new Error(\n      'hot() arrays must be dense. Use undefined/null placeholders or splice().'\n    );\n  }\n\n  for (let i = 0; i < value.length; i++)\n    if (!(i in value)) deny();\n\n  const get = () => Object.freeze(value.slice());\n  let internal = false;\n\n  const proxy: any = new Proxy(value, {\n    has,\n    get(target: T[], key, receiver) {\n      if (key === 'get') return get;\n\n      const result = Reflect.get(target, key, receiver);\n\n      if (typeof key === 'symbol') return result;\n      if (typeof result === 'function')\n        return DELETES.has(key) ? (...args: unknown[]) => {\n          internal = true;\n\n          try {\n            return result.apply(receiver, args);\n          } finally {\n            internal = false;\n          }\n        } : result;\n\n      return touch(receiver, key, result);\n    },\n    set(target: T[], key, value) {\n      const oldLength = target.length;\n      if (key === 'length' && value > oldLength) deny();\n\n      const grows = index(key) >= target.length;\n      if (grows && index(key) > target.length) deny();\n\n      const ok = assign(proxy, target, key, value);\n      if (ok && grows && typeof key !== 'symbol') event(proxy, 'length');\n      if (ok && key === 'length')\n        for (let i = target.length; i < oldLength; i++) event(proxy, String(i));\n\n      return ok;\n    },\n    deleteProperty(target, key) {\n      if (!(key in target)) return true;\n      if (index(key) >= 0 && !internal) deny();\n\n      return remove(proxy, target, key);\n    }\n  });\n\n  event(proxy);\n  return proxy;\n}\n\nfunction object<T extends object>(value: T) {\n  const get = () => Object.freeze({ ...value });\n\n  const proxy: any = new Proxy(value, {\n    has,\n    get(target, key, receiver) {\n      if (key === 'get' && !(key in target)) return get;\n\n      const result = Reflect.get(target, key, receiver);\n\n      if (typeof key === 'symbol' || typeof result === 'function')\n        return result;\n\n      return touch(receiver, key, result);\n    },\n    set(target, key, value) {\n      return assign(proxy, target, key, value);\n    },\n    deleteProperty(target, key) {\n      return remove(proxy, target, key);\n    }\n  });\n\n  event(proxy);\n  return proxy;\n}\n\nfunction has(target: object, key: string | symbol) {\n  return key === 'get' || key in target;\n}\n\nfunction assign(proxy: object, target: object, key: string | symbol, value: any) {\n  const old = (target as any)[key];\n  const ok = Reflect.set(target, key, value);\n\n  if (ok && typeof key !== 'symbol' && old !== value) event(proxy, key);\n\n  return ok;\n}\n\nfunction remove(proxy: object, target: object, key: string | symbol) {\n  if (!(key in target)) return true;\n\n  const ok = Reflect.deleteProperty(target, key);\n  if (ok && typeof key !== 'symbol') event(proxy, key);\n\n  return ok;\n}\n\nexport { hot };\n"],"mappings":"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"}

package/dist/field/ref.d.ts

@@ -0,0 +1,78 @@
+import { State } from "../state.js";
+
+//#region src/field/ref.d.ts
+declare namespace ref {
+  type Map<T extends State, R> = (this: T, key: State.Field<T> & string, state: T) => R;
+  type Callback<T> = (argument: T) => ((next: T | null) => void) | Promise<void> | void | boolean;
+  /** Callable ref that also exposes ref-object properties. */
+  interface Object<T = any> {
+    /** Set the current value of this reference. */
+    (value: T | null): void;
+    /** Current value held by this reference. */
+    current: T;
+    /** State instance this reference belongs to. */
+    is: State;
+    /** Key of property on state this reference belongs to. */
+    key: string;
+    /**
+     * Subscribe to changes of this reference.
+     *
+     * @param callback - Callback to invoke with the current value when it changes.
+     * @returns Unsubscribe function to stop listening to changes.
+     */
+    get(callback: (value: T) => void): () => void;
+    /** Retrieve current value. */
+    get(): T | null;
+  }
+  /** Object with references to all managed values of `T`. */
+  type Proxy<T extends State> = { [P in State.Field<T>]-?: Object<T[P]> } & {
+    get(): T;
+  };
+  type CustomProxy<T extends State, R> = { [P in State.Field<T>]-?: R } & {
+    get(): T;
+  };
+}
+/**
+ * Creates an object with references to all managed values.
+ * Each property is a function to set value in state when invoked.
+ *
+ * *Properties are simultaneously a ref-function and ref-object, use as needed.*
+ *
+ * Non-enumerable; excluded from snapshots and `ref(this)`.
+ *
+ * @param state - Source state from which to reference values.
+ */
+declare function ref<T extends State>(state: T): ref.Proxy<T>;
+/**
+ * Creates an object with values based on managed values.
+ * Each property will invoke map function on first access supply
+ * the its return value going forward.
+ *
+ * Non-enumerable; excluded from snapshots and `ref(this)`.
+ *
+ * @param state - Source state from which to reference values.
+ * @param map - Function producing the placeholder value for any given property.
+ */
+declare function ref<T extends State, R>(state: T, map: ref.Map<T, R>): ref.CustomProxy<T, R>;
+/**
+ * Creates a ref-compatible property.
+ * Callable to set the value, with ref-object properties for reading and subscribing.
+ *
+ * Non-enumerable; excluded from snapshots and `ref(this)`.
+ *
+ * @param callback - Optional callback to synchronously fire when reference is first set or does update.
+ */
+declare function ref<T>(callback?: ref.Callback<T>): ref.Object<T>;
+/**
+ * Creates a ref-compatible property.
+ * Callable to set the value, with ref-object properties for reading and subscribing.
+ *
+ * Non-enumerable; excluded from snapshots and `ref(this)`.
+ *
+ * @param callback - Optional callback to synchronously fire when reference is first set or does update.
+ * @param ignoreNull - Default `true`. If `false`, will still callback with `null`.
+ */
+declare function ref<T>(callback: ref.Callback<T | null>, ignoreNull: boolean): ref.Object<T>;
+//#endregion
+export { ref };
+//# sourceMappingURL=ref.d.ts.map

package/dist/field/ref.js

@@ -0,0 +1,85 @@
+import { capture, listener } from "../observable.js";
+import { State, update } from "../state.js";
+import { def } from "./def.js";
+
+//#region src/field/ref.ts
+const { defineProperty, defineProperties } = Object;
+function ref(arg, arg2) {
+	if (arg instanceof State) return proxy(arg, arg2);
+	if (typeof arg == "object") throw new Error("ref instruction requires a State instance, got a plain object");
+	return property(arg, arg2);
+}
+function defaultMap(key) {
+	const source = this;
+	const set = (x) => source[key] = x;
+	const get = (cb) => cb ? listener(this, () => cb(source[key]), key) : source[key];
+	defineProperties(set, {
+		current: {
+			get,
+			set
+		},
+		get: { value: get },
+		is: { value: this },
+		key: { value: key }
+	});
+	return set;
+}
+function proxy(target, map = defaultMap) {
+	return def((_key, _subject) => {
+		const value = {};
+		const source = target;
+		listener(target, () => {
+			for (const key in source) defineProperty(value, key, {
+				configurable: true,
+				get() {
+					const out = map.call(target, key, target);
+					defineProperty(value, key, { value: out });
+					return out;
+				}
+			});
+			return null;
+		});
+		return {
+			get: () => value,
+			enumerable: false
+		};
+	});
+}
+function property(callback, ignoreNull) {
+	return def((key, subject, state) => {
+		let unset;
+		function get(cb) {
+			return cb ? listener(subject, () => cb(state[key]), key) : state[key];
+		}
+		function set(value) {
+			if (!update(subject, key, value) || !callback) return;
+			if (unset) unset = void unset(value);
+			if (value === null && ignoreNull !== false) return;
+			capture((release) => {
+				const out = callback.call(subject, value);
+				unset = (next) => {
+					if (typeof out == "function") out(next);
+					release();
+				};
+			});
+		}
+		state[key] = null;
+		defineProperties(set, {
+			current: {
+				get,
+				set
+			},
+			get: { value: get },
+			is: { value: subject },
+			key: { value: key }
+		});
+		return {
+			get: () => set,
+			enumerable: false
+		};
+	});
+}
+
+//#endregion
+export { ref };
+//# sourceMappingURL=ref.js.map

package/dist/field/ref.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ref.js","names":[],"sources":["../../src/field/ref.ts"],"sourcesContent":["import { listener, capture } from '../observable';\nimport { State, update } from '../state';\nimport { def } from './def';\n\nconst { defineProperty, defineProperties } = Object;\n\ndeclare namespace ref {\n  type Map<T extends State, R> = (\n    this: T,\n    key: State.Field<T> & string,\n    state: T\n  ) => R;\n\n  type Callback<T> = (\n    argument: T\n  ) => ((next: T | null) => void) | Promise<void> | void | boolean;\n\n  /** Callable ref that also exposes ref-object properties. */\n  interface Object<T = any> {\n    /** Set the current value of this reference. */\n    (value: T | null): void;\n\n    /** Current value held by this reference. */\n    current: T;\n\n    /** State instance this reference belongs to. */\n    is: State;\n\n    /** Key of property on state this reference belongs to. */\n    key: string;\n\n    /**\n     * Subscribe to changes of this reference.\n     *\n     * @param callback - Callback to invoke with the current value when it changes.\n     * @returns Unsubscribe function to stop listening to changes.\n     */\n    get(callback: (value: T) => void): () => void;\n\n    /** Retrieve current value. */\n    get(): T | null;\n  }\n\n  /** Object with references to all managed values of `T`. */\n  type Proxy<T extends State> = { [P in State.Field<T>]-?: Object<T[P]> } & {\n    get(): T;\n  };\n\n  type CustomProxy<T extends State, R> = { [P in State.Field<T>]-?: R } & {\n    get(): T;\n  };\n}\n\n/**\n * Creates an object with references to all managed values.\n * Each property is a function to set value in state when invoked.\n *\n * *Properties are simultaneously a ref-function and ref-object, use as needed.*\n *\n * Non-enumerable; excluded from snapshots and `ref(this)`.\n *\n * @param state - Source state from which to reference values.\n */\nfunction ref<T extends State>(state: T): ref.Proxy<T>;\n\n/**\n * Creates an object with values based on managed values.\n * Each property will invoke map function on first access supply\n * the its return value going forward.\n *\n * Non-enumerable; excluded from snapshots and `ref(this)`.\n *\n * @param state - Source state from which to reference values.\n * @param map - Function producing the placeholder value for any given property.\n */\nfunction ref<T extends State, R>(\n  state: T,\n  map: ref.Map<T, R>\n): ref.CustomProxy<T, R>;\n\n/**\n * Creates a ref-compatible property.\n * Callable to set the value, with ref-object properties for reading and subscribing.\n *\n * Non-enumerable; excluded from snapshots and `ref(this)`.\n *\n * @param callback - Optional callback to synchronously fire when reference is first set or does update.\n */\nfunction ref<T>(callback?: ref.Callback<T>): ref.Object<T>;\n\n/**\n * Creates a ref-compatible property.\n * Callable to set the value, with ref-object properties for reading and subscribing.\n *\n * Non-enumerable; excluded from snapshots and `ref(this)`.\n *\n * @param callback - Optional callback to synchronously fire when reference is first set or does update.\n * @param ignoreNull - Default `true`. If `false`, will still callback with `null`.\n */\nfunction ref<T>(\n  callback: ref.Callback<T | null>,\n  ignoreNull: boolean\n): ref.Object<T>;\n\nfunction ref<T extends State>(\n  arg?: ref.Callback<T> | T,\n  arg2?: ref.Map<T, any> | boolean\n) {\n  if (arg instanceof State)\n    return proxy(arg, arg2 as ref.Map<T, any> | undefined);\n\n  if (typeof arg == 'object')\n    throw new Error(\n      'ref instruction requires a State instance, got a plain object'\n    );\n\n  return property(arg, arg2 as boolean | undefined);\n}\n\nfunction defaultMap(this: State, key: string) {\n  const source = this as any as Record<string, any>;\n  const set = (x: any) => (source[key] = x);\n  const get = (cb?: (value: any) => void) =>\n    cb ? listener(this, () => cb(source[key]), key) : source[key];\n\n  defineProperties(set, {\n    current: { get, set },\n    get: { value: get },\n    is: { value: this },\n    key: { value: key }\n  });\n\n  return set;\n}\n\nfunction proxy(target: State, map: ref.Map<any, any> = defaultMap) {\n  return def((_key, _subject) => {\n    const value = {} as Record<string, any>;\n    const source = target as any as Record<string, any>;\n\n    listener(target, () => {\n      for (const key in source)\n        defineProperty(value, key, {\n          configurable: true,\n          get() {\n            const out = map.call(target, key, target);\n            defineProperty(value, key, { value: out });\n            return out;\n          }\n        });\n\n      return null;\n    });\n\n    return {\n      get: () => value,\n      enumerable: false\n    };\n  });\n}\n\nfunction property<T>(callback?: ref.Callback<T>, ignoreNull?: boolean) {\n  return def((key, subject, state) => {\n    let unset: ((next: T) => void) | undefined;\n\n    function get(cb?: (value: T) => void) {\n      return cb ? listener(subject, () => cb(state[key]), key) : state[key];\n    }\n\n    function set(value?: any) {\n      if (!update(subject, key, value) || !callback) return;\n      if (unset) unset = void unset(value);\n      if (value === null && ignoreNull !== false) return;\n\n      capture((release) => {\n        const out = callback.call(subject, value);\n\n        unset = (next) => {\n          if (typeof out == 'function') out(next);\n          release();\n        };\n      });\n    }\n\n    state[key] = null;\n\n    defineProperties(set, {\n      current: { get, set },\n      get: { value: get },\n      is: { value: subject },\n      key: { value: key }\n    });\n\n    return {\n      get: () => set,\n      enumerable: false\n    };\n  });\n}\n\nexport { ref };\n"],"mappings":";;;;;AAIA,MAAM,EAAE,gBAAgB,qBAAqB;AAoG7C,SAAS,IACP,KACA,MACA;AACA,KAAI,eAAe,MACjB,QAAO,MAAM,KAAK,KAAoC;AAExD,KAAI,OAAO,OAAO,SAChB,OAAM,IAAI,MACR,gEACD;AAEH,QAAO,SAAS,KAAK,KAA4B;;AAGnD,SAAS,WAAwB,KAAa;CAC5C,MAAM,SAAS;CACf,MAAM,OAAO,MAAY,OAAO,OAAO;CACvC,MAAM,OAAO,OACX,KAAK,SAAS,YAAY,GAAG,OAAO,KAAK,EAAE,IAAI,GAAG,OAAO;AAE3D,kBAAiB,KAAK;EACpB,SAAS;GAAE;GAAK;GAAK;EACrB,KAAK,EAAE,OAAO,KAAK;EACnB,IAAI,EAAE,OAAO,MAAM;EACnB,KAAK,EAAE,OAAO,KAAK;EACpB,CAAC;AAEF,QAAO;;AAGT,SAAS,MAAM,QAAe,MAAyB,YAAY;AACjE,QAAO,KAAK,MAAM,aAAa;EAC7B,MAAM,QAAQ,EAAE;EAChB,MAAM,SAAS;AAEf,WAAS,cAAc;AACrB,QAAK,MAAM,OAAO,OAChB,gBAAe,OAAO,KAAK;IACzB,cAAc;IACd,MAAM;KACJ,MAAM,MAAM,IAAI,KAAK,QAAQ,KAAK,OAAO;AACzC,oBAAe,OAAO,KAAK,EAAE,OAAO,KAAK,CAAC;AAC1C,YAAO;;IAEV,CAAC;AAEJ,UAAO;IACP;AAEF,SAAO;GACL,WAAW;GACX,YAAY;GACb;GACD;;AAGJ,SAAS,SAAY,UAA4B,YAAsB;AACrE,QAAO,KAAK,KAAK,SAAS,UAAU;EAClC,IAAI;EAEJ,SAAS,IAAI,IAAyB;AACpC,UAAO,KAAK,SAAS,eAAe,GAAG,MAAM,KAAK,EAAE,IAAI,GAAG,MAAM;;EAGnE,SAAS,IAAI,OAAa;AACxB,OAAI,CAAC,OAAO,SAAS,KAAK,MAAM,IAAI,CAAC,SAAU;AAC/C,OAAI,MAAO,SAAQ,KAAK,MAAM,MAAM;AACpC,OAAI,UAAU,QAAQ,eAAe,MAAO;AAE5C,YAAS,YAAY;IACnB,MAAM,MAAM,SAAS,KAAK,SAAS,MAAM;AAEzC,aAAS,SAAS;AAChB,SAAI,OAAO,OAAO,WAAY,KAAI,KAAK;AACvC,cAAS;;KAEX;;AAGJ,QAAM,OAAO;AAEb,mBAAiB,KAAK;GACpB,SAAS;IAAE;IAAK;IAAK;GACrB,KAAK,EAAE,OAAO,KAAK;GACnB,IAAI,EAAE,OAAO,SAAS;GACtB,KAAK,EAAE,OAAO,KAAK;GACpB,CAAC;AAEF,SAAO;GACL,WAAW;GACX,YAAY;GACb;GACD"}

package/dist/field/set.d.ts

@@ -0,0 +1,59 @@
+//#region src/field/set.d.ts
+declare namespace set {
+  type Callback<T, S = any> = (this: S, next: T, previous: T) => ((next: T) => void) | Promise<any> | void | boolean;
+  type Factory<T, S = any> = (this: S, property: string) => Promise<T> | T;
+}
+/**
+ * Set a property as a placeholder, initially `undefined` but required.
+ *
+ * Property cannot be accessed until it is defined. If accessed while undefined, a hybrid
+ * `Promise`/`Error` (aka: [Suspense](https://reactjs.org/docs/concurrent-mode-suspense.html)) will be thrown.
+ *
+ * Non-enumerable; writable only if `onUpdate` callback is provided.
+ *
+ * @param value - Starting value (undefined for suspense placeholder).
+ * @param onUpdate - Callback run when property is set.
+ */
+declare function set<T>(value?: undefined, onUpdate?: set.Callback<T>): T;
+/**
+ * Set property with an async factory function.
+ * If required is not defined, factory runs lazily on first access.
+ * If async, or returns a promise, suspense is thrown upon access until resolved.
+ *
+ * Non-enumerable and read-only.
+ *
+ * @param factory - Zero-arg async callback to produce property value.
+ * @param required - Pass `true` to run factory immediately and require value.
+ */
+declare function set<T>(factory: () => T | Promise<T>, required?: true): T;
+/**
+ * Set property with a lazy factory, no suspense.
+ *
+ * Non-enumerable and read-only.
+ *
+ * @param factory - Zero-arg callback to produce property value.
+ * @param required - Pass `false` to allow undefined while pending.
+ */
+declare function set<T>(factory: () => T | Promise<T>, required: boolean): T | undefined;
+/**
+ * Set property with a factory and update callback.
+ *
+ * Non-enumerable but writable via the callback.
+ *
+ * @param factory - Callback to produce initial value.
+ * @param onUpdate - Callback run when property is updated.
+ */
+declare function set<T>(factory: () => T | Promise<T>, onUpdate: set.Callback<T>): T;
+/**
+ * Set a property with a non-function, non-Promise value.
+ *
+ * Non-enumerable but writable. Unlike plain assignment (`= value`), this
+ * property is excluded from snapshots and `ref(this)`.
+ *
+ * @param value - Starting value for property.
+ * @param onUpdate - Optional callback run when property is set.
+ */
+declare function set<T>(value: T extends Promise<any> ? never : T, onUpdate?: set.Callback<T>): T;
+//#endregion
+export { set };
+//# sourceMappingURL=set.d.ts.map

package/dist/field/set.js

@@ -0,0 +1,84 @@
+import { capture, event, listener } from "../observable.js";
+import { access, update } from "../state.js";
+import { def } from "./def.js";
+
+//#region src/field/set.ts
+function set(value, argument) {
+	return def((key, subject) => {
+		if (value instanceof Promise) throw new TypeError(`Direct promises are not supported in set(${subject}.${key}). Use set(() => promise) instead.`);
+		const config = {
+			enumerable: false,
+			set: false
+		};
+		let computed = false;
+		if (typeof value == "function") {
+			const factory = value.bind(subject, key);
+			computed = true;
+			function init() {
+				let output;
+				try {
+					output = attempt(factory);
+				} catch (err) {
+					console.warn(`Generating initial value for ${subject}.${key} failed.`);
+					throw err;
+				}
+				config.get = argument !== false;
+				function assign(next, silent) {
+					if (typeof argument == "function") subject[key] = next;
+					else update(subject, key, next, silent);
+				}
+				if (output instanceof Promise) output.then(assign, (error) => {
+					event(subject, key);
+					config.get = () => {
+						throw error;
+					};
+				});
+				else assign(output, true);
+				if (argument) return null;
+				if (output instanceof Promise && argument !== false) return access(subject, key, true);
+				return subject[key];
+			}
+			if (argument) listener(subject, () => {
+				init();
+				return null;
+			});
+			else config.get = init;
+		} else if (value !== void 0) config.value = value;
+		if (typeof argument == "function") {
+			let unset;
+			config.set = function(value, previous) {
+				capture((release) => {
+					const returns = argument.call(this, value, previous);
+					if (unset) unset(value);
+					unset = (next) => {
+						if (typeof returns == "function") returns(next);
+						release();
+					};
+				});
+			};
+		} else if (!computed) config.set = () => {
+			config.get = void 0;
+			config.set = void 0;
+		};
+		return config;
+	});
+}
+function attempt(fn) {
+	function retry(err) {
+		if (err instanceof Promise) return err.then(compute);
+		else throw err;
+	}
+	function compute() {
+		try {
+			const output = fn();
+			return output instanceof Promise ? output.catch(retry) : output;
+		} catch (err) {
+			return retry(err);
+		}
+	}
+	return compute();
+}
+
+//#endregion
+export { set };
+//# sourceMappingURL=set.js.map