@expressive/mvc 0.71.0 → 0.73.0

package/dist/esm/instruction/set.js

@@ -1,85 +1,118 @@
-import { addListener, enter } from "../control";
-import { event, update } from "../model";
-import { use } from "./use";
+import { addListener, event, scope, watch } from "../observable.js";
+import { METHOD, State, access, update } from "../state.js";
+import { use } from "./use.js";
+
+//#region src/instruction/set.ts
+const STALE = /* @__PURE__ */ new WeakSet();
 function set(value, argument) {
-  return use((key, subject) => {
-    const property = {};
-    if (typeof value == "function" || isThenable(value)) {
-      let init2 = function() {
-        if (typeof value == "function")
-          try {
-            value = attempt(value.bind(subject, key));
-          } catch (err) {
-            console.warn(`Generating initial value for ${subject}.${key} failed.`);
-            throw err;
-          }
-        property.get = argument !== false;
-        const set2 = (value2) => subject[key] = value2;
-        if (isThenable(value))
-          value.then(set2, (error) => {
-            event(subject, key);
-            property.get = () => {
-              throw error;
-            };
-          });
-        else
-          set2(value);
-        if (argument)
-          return null;
-        return subject[key];
-      };
-      var init = init2;
-      if (argument)
-        addListener(subject, init2, true);
-      else
-        property.get = init2;
-    } else if (value !== void 0)
-      property.value = value;
-    if (typeof argument == "function") {
-      let unset;
-      property.set = function(value2, previous) {
-        const exit = enter();
-        const returns = argument.call(this, value2, previous);
-        const flush = exit();
-        if (returns === false)
-          return false;
-        if (typeof unset == "function")
-          unset(value2);
-        unset = (next) => {
-          if (typeof returns == "function")
-            returns(next);
-          flush();
-        };
-      };
-    } else
-      property.set = (value2) => {
-        property.get = void 0;
-        update(subject, key, value2);
-      };
-    return property;
-  });
+	return use((key, subject, state) => {
+		if (typeof value == "symbol") throw new Error(`Attempted to use an instruction result (probably use or get) as computed source for ${subject}.${key}. This is not allowed.`);
+		const property = {};
+		if (value instanceof State || value === true) {
+			let from = subject;
+			let getter;
+			if (value instanceof State) {
+				from = value;
+				getter = argument;
+			} else {
+				const fn = METHOD.get(argument) || argument;
+				getter = ((p, k) => fn.call(p, k, p));
+			}
+			const source = (resolve) => resolve(from);
+			let reset;
+			let isAsync;
+			let proxy;
+			function connect(self) {
+				reset = watch(self, (current) => {
+					proxy = current;
+					if (!(key in state) || STALE.delete(compute)) compute(!reset);
+					return (didUpdate) => {
+						if (didUpdate) {
+							STALE.add(compute);
+							event(subject, key, true);
+						}
+					};
+				}, false);
+			}
+			function compute(initial) {
+				let next;
+				try {
+					next = getter.call(proxy, proxy, key);
+				} catch (err) {
+					console.warn(`An exception was thrown while ${initial ? "initializing" : "refreshing"} ${subject}.${key}.`);
+					if (initial) throw err;
+					console.error(err);
+				}
+				update(subject, key, next, !isAsync);
+			}
+			return () => {
+				if (!proxy) {
+					source(connect);
+					isAsync = true;
+				}
+				if (STALE.delete(compute)) compute();
+				return access(subject, key, !proxy);
+			};
+		}
+		if (typeof value == "function" || value instanceof Promise) {
+			function init() {
+				if (typeof value == "function") try {
+					value = attempt(value.bind(subject, key));
+				} catch (err) {
+					console.warn(`Generating initial value for ${subject}.${key} failed.`);
+					throw err;
+				}
+				property.get = argument !== false;
+				const set = (value) => subject[key] = value;
+				if (value instanceof Promise) value.then(set, (error) => {
+					event(subject, key);
+					property.get = () => {
+						throw error;
+					};
+				});
+				else set(value);
+				if (argument) return null;
+				return subject[key];
+			}
+			if (argument) addListener(subject, init, true);
+			else property.get = init;
+		} else if (value !== void 0) property.value = value;
+		if (typeof argument == "function") {
+			let unset;
+			property.set = function(value, previous) {
+				const exit = scope();
+				const returns = argument.call(this, value, previous);
+				const flush = exit();
+				if (returns === false) return false;
+				if (typeof unset == "function") unset(value);
+				unset = (next) => {
+					if (typeof returns == "function") returns(next);
+					flush();
+				};
+			};
+		} else property.set = (value) => {
+			property.get = void 0;
+			update(subject, key, value);
+		};
+		return property;
+	});
 }
 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();
+	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();
 }
-function isThenable(value) {
-  return value && typeof value == "object" && typeof value.then == "function";
-}
-export {
-  set
-};
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/instruction/set.ts"],
  "sourcesContent": ["import { addListener, enter } from '../control';\nimport { Model, event, update } from '../model';\nimport { use } from './use';\n\ndeclare namespace set {\n  type Callback<T, S = any> = (this: S, next: T, previous: T) =>\n    ((next: T) => void) | Promise<any> | void | boolean;\n\n  type Factory<T, S = any> = (this: S, key: string) => Thenable<T> | T;\n\n  type Thenable<T> = {\n    then: (onFulfilled?: (value: T) => any, onRejected?: (reason: any) => any) => any;\n  };\n}\n\n/**\n * Set property as `undefined` but required.\n * \n * Property cannot be accessed until it is defined. If accessed while undefined, a hybrid\n * `Promise`/`Error` (aka: [Suspense](https://reactjs.org/docs/concurrent-mode-suspense.html)) will be thrown.\n */\nfunction set <T = any>(): T;\n\n/**\n * Set property with a factory function.\n * \n * **Note** Factory is lazy! It will only run if/when property is accessed.\n * Value will be undefined until factory resolves, which will also dispatch an update for the property.\n */\nfunction set <T> (factory: set.Factory<T> | set.Thenable<T>, required: false): T | undefined;\n\n/**\n * Set property with a factory function.\n *\n * If async, property cannot be accessed until resolves, yeilding a result.\n * If accessed while still processing, React Suspense will be thrown.\n *\n * @param factory - Callback run to derrive property value.\n * @param required - If true run factory immediately on creation, otherwise on access.\n */\nfunction set <T> (factory: set.Factory<T> | set.Thenable<T>, required?: boolean): T;\n\n/**\n * Set property with a factory function.\n *\n * If async, property cannot be accessed until resolves, yeilding a result.\n * If accessed while still processing, React Suspense will be thrown.\n *\n * @param factory - Callback run to derrive property value.\n * @param onUpdate - Callback run when property is finished computing or is set. \n */\nfunction set <T> (factory: set.Factory<T> | set.Thenable<T>, onUpdate?: set.Callback<T>): T;\n\n/**\n * Set a property with empty placeholder and/or update callback.\n * \n * @param value - Starting value for property. If undefined, suspense will be thrown on access, until value is set and accepted by callback.\n * @param onUpdate - Callback run when property is set. If returns false, update is not accepted and property will keep previous value.\n */\nfunction set <T> (value: T | undefined, onUpdate?: set.Callback<T>): T;\n\nfunction set <T> (\n  value?: set.Factory<T> | set.Thenable<T> | T,\n  argument?: set.Callback<any> | boolean){\n\n  return use<T>((key, subject) => {\n    const property: Model.Descriptor = {};\n\n    if(typeof value == \"function\" || isThenable(value)){\n      function init(){\n        if(typeof value == \"function\")\n          try {\n            value = attempt(value.bind(subject, key));\n          }\n          catch(err){\n            console.warn(`Generating initial value for ${subject}.${key} failed.`);\n            throw err;\n          }\n\n        property.get = argument !== false;\n\n        const set = (value: any) => subject[key] = value;\n\n        if(isThenable(value))\n          value.then(set, error => {\n            event(subject, key);\n            property.get = () => { throw error };\n          })\n        else\n          set(value);\n\n        if(argument)\n          return null;\n        \n        return subject[key];\n      }\n\n      if(argument)\n        addListener(subject, init, true);\n      else\n        property.get = init;\n    }\n    else if(value !== undefined)\n      property.value = value;\n\n    if(typeof argument == \"function\"){\n      let unset: ((next: T) => void) | undefined;\n\n      property.set = function(this: any, value: any, previous: any){\n        const exit = enter();\n        const returns = argument.call(this, value, previous);\n        const flush = exit();\n\n        if(returns === false)\n          return false;\n\n        if(typeof unset == \"function\")\n          unset(value);\n\n        unset = (next: T) => {\n          if(typeof returns == \"function\")\n            returns(next);\n\n          flush();\n        }\n      }\n    }\n    else\n      property.set = value => {\n        property.get = undefined;\n        update(subject, key, value);\n      }\n\n    return property;\n  })\n}\n\nfunction attempt(fn: () => any): any {\n  function retry(err: unknown){\n    if(err instanceof Promise)\n      return err.then(compute);\n    else\n      throw err;\n  }\n\n  function compute(): any {\n    try {\n      const output = fn();\n\n      return output instanceof Promise\n        ? output.catch(retry)\n        : output;\n    }\n    catch(err){\n      return retry(err);\n    }\n  }\n\n  return compute();\n}\n\nfunction isThenable(value: any): value is set.Thenable<any> {\n  return value && typeof value == \"object\" && typeof value.then == \"function\";\n}\n\nexport { set }"],
  "mappings": "AAAA,SAAS,aAAa,aAAa;AACnC,SAAgB,OAAO,cAAc;AACrC,SAAS,WAAW;AA2DpB,SAAS,IACP,OACA,UAAuC;AAEvC,SAAO,IAAO,CAAC,KAAK,YAAY;AAC9B,UAAM,WAA6B,CAAC;AAEpC,QAAG,OAAO,SAAS,cAAc,WAAW,KAAK,GAAE;AACjD,UAASA,QAAT,WAAe;AACb,YAAG,OAAO,SAAS;AACjB,cAAI;AACF,oBAAQ,QAAQ,MAAM,KAAK,SAAS,GAAG,CAAC;AAAA,UAC1C,SACM,KAAI;AACR,oBAAQ,KAAK,gCAAgC,OAAO,IAAI,GAAG,UAAU;AACrE,kBAAM;AAAA,UACR;AAEF,iBAAS,MAAM,aAAa;AAE5B,cAAMC,OAAM,CAACC,WAAe,QAAQ,GAAG,IAAIA;AAE3C,YAAG,WAAW,KAAK;AACjB,gBAAM,KAAKD,MAAK,WAAS;AACvB,kBAAM,SAAS,GAAG;AAClB,qBAAS,MAAM,MAAM;AAAE,oBAAM;AAAA,YAAM;AAAA,UACrC,CAAC;AAAA;AAED,UAAAA,KAAI,KAAK;AAEX,YAAG;AACD,iBAAO;AAET,eAAO,QAAQ,GAAG;AAAA,MACpB;AA1BS,iBAAAD;AA4BT,UAAG;AACD,oBAAY,SAASA,OAAM,IAAI;AAAA;AAE/B,iBAAS,MAAMA;AAAA,IACnB,WACQ,UAAU;AAChB,eAAS,QAAQ;AAEnB,QAAG,OAAO,YAAY,YAAW;AAC/B,UAAI;AAEJ,eAAS,MAAM,SAAoBE,QAAY,UAAc;AAC3D,cAAM,OAAO,MAAM;AACnB,cAAM,UAAU,SAAS,KAAK,MAAMA,QAAO,QAAQ;AACnD,cAAM,QAAQ,KAAK;AAEnB,YAAG,YAAY;AACb,iBAAO;AAET,YAAG,OAAO,SAAS;AACjB,gBAAMA,MAAK;AAEb,gBAAQ,CAAC,SAAY;AACnB,cAAG,OAAO,WAAW;AACnB,oBAAQ,IAAI;AAEd,gBAAM;AAAA,QACR;AAAA,MACF;AAAA,IACF;AAEE,eAAS,MAAM,CAAAA,WAAS;AACtB,iBAAS,MAAM;AACf,eAAO,SAAS,KAAKA,MAAK;AAAA,MAC5B;AAEF,WAAO;AAAA,EACT,CAAC;AACH;AAEA,SAAS,QAAQ,IAAoB;AACnC,WAAS,MAAM,KAAa;AAC1B,QAAG,eAAe;AAChB,aAAO,IAAI,KAAK,OAAO;AAAA;AAEvB,YAAM;AAAA,EACV;AAEA,WAAS,UAAe;AACtB,QAAI;AACF,YAAM,SAAS,GAAG;AAElB,aAAO,kBAAkB,UACrB,OAAO,MAAM,KAAK,IAClB;AAAA,IACN,SACM,KAAI;AACR,aAAO,MAAM,GAAG;AAAA,IAClB;AAAA,EACF;AAEA,SAAO,QAAQ;AACjB;AAEA,SAAS,WAAW,OAAwC;AAC1D,SAAO,SAAS,OAAO,SAAS,YAAY,OAAO,MAAM,QAAQ;AACnE;",
  "names": ["init", "set", "value"]
}

+
+//#endregion
+export { set };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"set.js","names":[],"sources":["../../../src/instruction/set.ts"],"sourcesContent":["import { addListener, scope, watch } from '../observable';\nimport { access, event, METHOD, State, update } from '../state';\nimport { Instruction, use } from './use';\n\nconst STALE = new WeakSet<() => void>();\n\ndeclare namespace set {\n  type Callback<T, S = any> = (\n    this: S,\n    next: T,\n    previous: T\n  ) => ((next: T) => void) | Promise<any> | void | boolean;\n\n  type Compute<T, S = any> = (on: S, key: string) => T;\n\n  type Factory<T, S = any> = (this: S, key: string) => Promise<T> | T;\n}\n\n/**\n * Set property as `undefined` but required.\n *\n * Property cannot be accessed until it is defined. If accessed while undefined, a hybrid\n * `Promise`/`Error` (aka: [Suspense](https://reactjs.org/docs/concurrent-mode-suspense.html)) will be thrown.\n */\nfunction set<T = any>(): T;\n\n/**\n * Set property with a factory function.\n *\n * **Note** Factory is lazy! It will only run if/when property is accessed.\n * Value will be undefined until factory resolves, which will also dispatch an update for the property.\n */\nfunction set<T>(factory: set.Factory<T>, required: false): T | undefined;\n\n/**\n * Set property with a factory function.\n *\n * If async, property cannot be accessed until resolves, yeilding a result.\n * If accessed while still processing, React Suspense will be thrown.\n *\n * @param factory - Callback run to derrive property value.\n * @param required - If true run factory immediately on creation, otherwise on access.\n */\nfunction set<T>(factory: set.Factory<T>, required?: boolean): T;\n\n/**\n * Set property with a factory function.\n *\n * If async, property cannot be accessed until resolves, yeilding a result.\n * If accessed while still processing, React Suspense will be thrown.\n *\n * @param factory - Callback run to derrive property value.\n * @param onUpdate - Callback run when property is finished computing or is set.\n */\nfunction set<T>(factory: set.Factory<T>, onUpdate?: set.Callback<T>): T;\n\n/**\n * Set a property with empty placeholder and/or update callback.\n *\n * @param value - Starting value for property. If undefined, suspense will be thrown on access, until value is set and accepted by callback.\n * @param onUpdate - Callback run when property is set. If returns false, update is not accepted and property will keep previous value.\n */\nfunction set<T>(value: T | undefined, onUpdate?: set.Callback<T>): T;\n\n/**\n * Implement a reactive computed value using a method reference.\n *\n * The method will automatically re-run when any accessed properties change.\n * Use `true` to indicate reactive mode with implicit `this` as the source.\n *\n * @param reactiveToThis - Pass `true` to enable reactive mode with implicit this\n * @param method - Method reference or compute function to use\n */\nfunction set<R, T = any>(\n  reactiveToThis: true,\n  method: set.Compute<R, T> | Function\n): R;\n\n/**\n * Implement a computed value; output will be generated by provided function.\n *\n * @param reactiveTo - Source state from which computed value will be a subscriber.\n * @param compute - Compute function. Bound to a subscriber-proxy of source, returns output value. Will update automatically as input values change.\n */\nfunction set<R, T extends State>(reactiveTo: T, compute: set.Compute<R, T>): R;\n\nfunction set<T = any>(value?: unknown, argument?: unknown): any {\n  return use<T>((key, subject, state) => {\n    if (typeof value == 'symbol')\n      throw new Error(\n        `Attempted to use an instruction result (probably use or get) as computed source for ${subject}.${key}. This is not allowed.`\n      );\n\n    const property: Instruction.Descriptor = {};\n\n    // Handle reactive compute modes\n    if (value instanceof State || value === true) {\n      let from = subject;\n      let getter: set.Compute<T, any>;\n\n      if (value instanceof State) {\n        from = value;\n        getter = argument as set.Compute<T, any>;\n      } else {\n        // value === true, implicit this with method reference\n        const fn = METHOD.get(argument) || argument;\n        getter = ((p, k) => fn.call(p, k, p)) as set.Compute<T, any>;\n      }\n\n      type Source<T extends State = State> = (resolve: (x: T) => void) => void;\n      const source: Source = (resolve) => resolve(from);\n\n      let reset: (() => void) | undefined;\n      let isAsync: boolean;\n      let proxy: any;\n\n      function connect(self: State) {\n        reset = watch(\n          self,\n          (current) => {\n            proxy = current;\n\n            if (!(key in state) || STALE.delete(compute)) compute(!reset);\n\n            return (didUpdate) => {\n              if (didUpdate) {\n                STALE.add(compute);\n                event(subject, key, true);\n              }\n            };\n          },\n          false\n        );\n      }\n\n      function compute(initial?: boolean) {\n        let next: T | undefined;\n\n        try {\n          next = getter.call(proxy, proxy, key);\n        } catch (err) {\n          console.warn(\n            `An exception was thrown while ${\n              initial ? 'initializing' : 'refreshing'\n            } ${subject}.${key}.`\n          );\n\n          if (initial) throw err;\n\n          console.error(err);\n        }\n\n        update(subject, key, next, !isAsync);\n      }\n\n      return () => {\n        if (!proxy) {\n          source(connect);\n          isAsync = true;\n        }\n\n        if (STALE.delete(compute)) compute();\n\n        return access(subject, key, !proxy) as T;\n      };\n    }\n\n    // Handle factory/value modes (existing logic)\n    if (typeof value == 'function' || value instanceof Promise) {\n      function init() {\n        if (typeof value == 'function')\n          try {\n            value = attempt(value.bind(subject, key));\n          } catch (err) {\n            console.warn(\n              `Generating initial value for ${subject}.${key} failed.`\n            );\n            throw err;\n          }\n\n        property.get = argument !== false;\n\n        const set = (value: any) => (subject[key] = value);\n\n        if (value instanceof Promise)\n          value.then(set, (error) => {\n            event(subject, key);\n            property.get = () => {\n              throw error;\n            };\n          });\n        else set(value);\n\n        if (argument) return null;\n\n        return subject[key];\n      }\n\n      if (argument) {\n        addListener(subject, init, true);\n      } else {\n        property.get = init;\n      }\n    } else if (value !== undefined) {\n      property.value = value;\n    }\n\n    if (typeof argument == 'function') {\n      let unset: ((next: T) => void) | undefined;\n\n      property.set = function (this: any, value: any, previous: any) {\n        const exit = scope();\n        const returns = argument.call(this, value, previous);\n        const flush = exit();\n\n        if (returns === false) return false;\n\n        if (typeof unset == 'function') unset(value);\n\n        unset = (next: T) => {\n          if (typeof returns == 'function') returns(next);\n\n          flush();\n        };\n      };\n    } else\n      property.set = (value) => {\n        property.get = undefined;\n        update(subject, key, value);\n      };\n\n    return property;\n  });\n}\n\nfunction attempt(fn: () => any): any {\n  // Ignore TS80006: Function must be synchronous.\n  function retry(err: unknown) {\n    if (err instanceof Promise) return err.then(compute);\n    else throw err;\n  }\n\n  function compute(): any {\n    try {\n      const output = fn();\n\n      return output instanceof Promise ? output.catch(retry) : output;\n    } catch (err) {\n      return retry(err);\n    }\n  }\n\n  return compute();\n}\n\nexport { set };\n"],"mappings":"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"}

package/dist/esm/instruction/use.d.ts

@@ -0,0 +1,23 @@
+import { State } from "../state.js";
+
+//#region src/instruction/use.d.ts
+/**
+ * Property initializer, will run upon instance creation.
+ * Optional returned callback will run when once upon first access.
+ */
+type Instruction<T = any, M extends State = any> = (this: M, key: Extract<State.Field<M>, string>, thisArg: M, state: State.Values<M>) => Instruction.Descriptor<T> | ((source: M) => T) | void;
+declare namespace Instruction {
+  type Getter<T> = (source: State) => T;
+  type Descriptor<T = any> = {
+    get?: Getter<T> | boolean;
+    set?: State.Setter<T> | boolean;
+    enumerable?: boolean;
+    value?: T;
+  };
+}
+declare function use<T>(instruction: Instruction<T>): T extends void ? unknown : T;
+declare function use<T extends State>(Type: State.Type<T>, required: false): T | undefined;
+declare function use<T extends State>(Type: State.Type<T>, ready?: (i: T) => void): T;
+//#endregion
+export { Instruction, use };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/instruction/use.js

@@ -1,65 +1,56 @@
-import { fetch, Model, PARENT, STATE, uid, update, watch } from "../model";
+import { PARENT, STATE, State, access, follow, uid, update } from "../state.js";
+
+//#region src/instruction/use.ts
 const INSTRUCTION = /* @__PURE__ */ new Map();
 function use(arg1, arg2) {
-  if (Model.is(arg1))
-    arg1 = childInstruction(arg1, arg2);
-  const token = Symbol("instruction-" + uid());
-  INSTRUCTION.set(token, arg1);
-  return token;
+	if (State.is(arg1)) arg1 = childInstruction(arg1, arg2);
+	const token = Symbol("instruction-" + uid());
+	INSTRUCTION.set(token, arg1);
+	return token;
 }
 function childInstruction(type, arg2) {
-  return (key, subject) => {
-    function set(next) {
-      if (next ? !(next instanceof type) : arg2 !== false)
-        throw new Error(`${subject}.${key} expected Model of type ${type} but got ${next && next.constructor}.`);
-      update(subject, key, next);
-      if (next && typeof arg2 == "function")
-        arg2(next);
-      return false;
-    }
-    const value = new type();
-    set(value);
-    PARENT.set(value, subject);
-    value.set();
-    return { set };
-  };
+	return (key, subject) => {
+		function set(next) {
+			if (next ? !(next instanceof type) : arg2 !== false) throw new Error(`${subject}.${key} expected State of type ${type} but got ${next && next.constructor}.`);
+			update(subject, key, next);
+			if (next && typeof arg2 == "function") arg2(next);
+			return false;
+		}
+		const value = new type();
+		set(value);
+		PARENT.set(value, subject);
+		value.set();
+		return { set };
+	};
 }
 function init() {
-  const state = STATE.get(this);
-  for (const key in this) {
-    const { value } = Object.getOwnPropertyDescriptor(this, key);
-    const instruction = INSTRUCTION.get(value);
-    if (!instruction)
-      continue;
-    INSTRUCTION.delete(value);
-    delete this[key];
-    const output = instruction.call(this, key, this, state);
-    if (!output)
-      continue;
-    const desc = typeof output == "object" ? output : { get: output };
-    if ("value" in desc)
-      state[key] = desc.value;
-    const model = this;
-    Object.defineProperty(model, key, {
-      enumerable: desc.enumerable !== false,
-      get() {
-        return watch(
-          this,
-          key,
-          typeof desc.get == "function" ? desc.get(this) : fetch(model, key, desc.get)
-        );
-      },
-      set(next) {
-        if (desc.set === false)
-          throw new Error(`${model}.${key} is read-only.`);
-        update(model, key, next, desc.set);
-      }
-    });
-  }
-  return null;
+	const state = STATE.get(this);
+	for (const key in this) {
+		const { value } = Object.getOwnPropertyDescriptor(this, key);
+		const instruction = INSTRUCTION.get(value);
+		if (!instruction) continue;
+		INSTRUCTION.delete(value);
+		delete this[key];
+		const output = instruction.call(this, key, this, state);
+		if (!output) continue;
+		const desc = typeof output == "object" ? output : { get: output };
+		if ("value" in desc) state[key] = desc.value;
+		const self = this;
+		Object.defineProperty(self, key, {
+			enumerable: desc.enumerable !== false,
+			get() {
+				return follow(this, key, typeof desc.get == "function" ? desc.get(this) : access(self, key, desc.get));
+			},
+			set(next) {
+				if (desc.set === false) throw new Error(`${self}.${key} is read-only.`);
+				update(self, key, next, desc.set);
+			}
+		});
+	}
+	return null;
 }
-Model.on(init);
-export {
-  use
-};
-//# sourceMappingURL=data:application/json;base64,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
+State.on(init);
+
+//#endregion
+export { use };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/observable.d.ts

@@ -0,0 +1,42 @@
+//#region src/observable.d.ts
+/**
+ * Update callback function.
+ *
+ * @param key -
+ *   - `string` - property which has updated.
+ *   - `false` - a normal update has completed.
+ *   - `true` - initial event; instance is ready.
+ *   - `null` - terminal event; instance is expired.
+ * @param source - Instance of State for which update has occured.
+ */
+type Notify<T extends Observable = any> = (this: T, key: Event, source: T) => (() => void) | null | void;
+type Effect<T extends Observable> = (proxy: T) => ((update: boolean | null) => void) | Promise<void> | null | void;
+type Event = number | string | null | boolean | symbol;
+type PromiseLite<T = void> = {
+  then: (callback: () => T) => T;
+};
+declare namespace Observable {
+  type Callback = () => void | PromiseLite;
+}
+interface Observable {
+  [Observable](callback: Observable.Callback, required?: boolean): this | void;
+}
+declare const Observable: unique symbol;
+/** Update register. */
+declare const PENDING_KEYS: WeakMap<Observable, Set<string | number | symbol>>;
+declare function addListener<T extends Observable>(subject: T, callback: Notify<T>, select?: Event | Set<Event>): () => boolean;
+declare function event(subject: Observable, key?: string | number | symbol | null, silent?: boolean): void;
+/**
+ * Create a side-effect which will update whenever values accessed change.
+ * Callback is called immediately and whenever values are stale.
+ *
+ * @param target - Instance of State to observe.
+ * @param callback - Function to invoke when values change.
+ * @param requireValues - If `true` will throw if accessing a value which is `undefined`.
+ */
+declare function watch<T extends Observable>(target: T, callback: Effect<Required<T>>, requireValues: true): () => void;
+declare function watch<T extends Observable>(target: T, callback: Effect<T>, recursive?: boolean): () => void;
+declare function scope(): () => () => void;
+//#endregion
+export { Notify, Observable, PENDING_KEYS, addListener, event, scope, watch };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/observable.js

@@ -0,0 +1,121 @@
+//#region src/observable.ts
+const Observable = Symbol("observe");
+/** Placeholder event determines if state is initialized or not. */
+const onReady = () => null;
+const LISTENERS = /* @__PURE__ */ new WeakMap();
+/** Events pending for a given object. */
+const PENDING = /* @__PURE__ */ new WeakMap();
+/** Update register. */
+const PENDING_KEYS = /* @__PURE__ */ new WeakMap();
+/** Central event dispatch. Bunches all updates to occur at same time. */
+const DISPATCH = /* @__PURE__ */ new Set();
+function addListener(subject, callback, select) {
+	let listeners = LISTENERS.get(subject);
+	if (!listeners) LISTENERS.set(subject, listeners = new Map([[onReady, void 0]]));
+	if (select !== void 0 && !(select instanceof Set)) select = new Set([select]);
+	if (!listeners.has(onReady) && !select) callback.call(subject, true, subject);
+	listeners.set(callback, select);
+	return () => listeners.delete(callback);
+}
+function emit(state, key) {
+	const listeners = LISTENERS.get(state);
+	const notReady = listeners.has(onReady);
+	if (key === true && !notReady) return;
+	let pending = PENDING.get(state);
+	if (pending) {
+		pending.add(key);
+		return;
+	}
+	PENDING.set(state, pending = new Set(notReady ? [true, key] : [key]));
+	for (const key of pending) for (const [callback, filter] of listeners) if (!filter || filter.has(key)) {
+		const after = callback.call(state, key, state);
+		if (after) enqueue(after);
+		else if (after === null) listeners.delete(callback);
+	}
+	if (key === null) listeners.clear();
+	PENDING.delete(state);
+}
+function event(subject, key, silent) {
+	if (key === null) return emit(subject, key);
+	if (!key) return emit(subject, true);
+	let pending = PENDING_KEYS.get(subject);
+	if (!pending) {
+		PENDING_KEYS.set(subject, pending = /* @__PURE__ */ new Set());
+		if (!silent) enqueue(() => {
+			emit(subject, false);
+			PENDING_KEYS.delete(subject);
+		});
+	}
+	pending.add(key);
+	if (!silent) emit(subject, key);
+}
+function enqueue(eventHandler) {
+	if (!DISPATCH.size) setTimeout(() => {
+		DISPATCH.forEach((event) => {
+			try {
+				event();
+			} catch (err) {
+				console.error(err);
+			}
+		});
+		DISPATCH.clear();
+	}, 0);
+	DISPATCH.add(eventHandler);
+}
+function watch(target, callback, argument) {
+	let unset;
+	let reset;
+	function invoke() {
+		let ignore = true;
+		function onUpdate() {
+			if (ignore || reset === null) return;
+			ignore = true;
+			if (reset && unset) {
+				unset(true);
+				unset = void 0;
+			}
+			enqueue(invoke);
+			return { then: enqueue };
+		}
+		try {
+			const exit = argument === false ? void 0 : scope();
+			const output = callback(target[Observable](onUpdate, argument === true));
+			const flush = exit ? exit() : () => {};
+			ignore = false;
+			reset = output === null ? null : invoke;
+			unset = (key) => {
+				if (typeof output == "function") output(key);
+				flush();
+			};
+		} catch (err) {
+			if (err instanceof Promise) {
+				reset = void 0;
+				err.then(invoke);
+			} else throw err;
+		}
+	}
+	function cleanup() {
+		if (unset) unset(false);
+		reset = null;
+	}
+	if (EffectContext && argument !== false) EffectContext.add(cleanup);
+	addListener(target, (key) => {
+		if (key === true) invoke();
+		else if (!reset) return reset;
+		if (key === null && unset) unset(null);
+	});
+	return cleanup;
+}
+let EffectContext;
+function scope() {
+	const last = EffectContext;
+	const context = EffectContext = /* @__PURE__ */ new Set();
+	return () => {
+		EffectContext = last;
+		return () => context.forEach((fn) => fn());
+	};
+}
+
+//#endregion
+export { Observable, PENDING_KEYS, addListener, event, scope, watch };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"observable.js","names":[],"sources":["../../src/observable.ts"],"sourcesContent":["/**\n * Update callback function.\n *\n * @param key -\n *   - `string` - property which has updated.\n *   - `false` - a normal update has completed.\n *   - `true` - initial event; instance is ready.\n *   - `null` - terminal event; instance is expired.\n * @param source - Instance of State for which update has occured.\n */\ntype Notify<T extends Observable = any> = (\n  this: T,\n  key: Event,\n  source: T\n) => (() => void) | null | void;\n\ntype Effect<T extends Observable> = (\n  proxy: T\n) => ((update: boolean | null) => void) | Promise<void> | null | void;\n\ntype Event = number | string | null | boolean | symbol;\n\ntype PromiseLite<T = void> = { then: (callback: () => T) => T };\n\ndeclare namespace Observable {\n  export type Callback = () => void | PromiseLite;\n}\n\ninterface Observable {\n  [Observable](callback: Observable.Callback, required?: boolean): this | void;\n}\n\nconst Observable = Symbol('observe');\n\n/** Placeholder event determines if state is initialized or not. */\nconst onReady = () => null;\n\nconst LISTENERS = new WeakMap<\n  Observable,\n  Map<Notify, Set<Event> | undefined>\n>();\n\n/** Events pending for a given object. */\nconst PENDING = new WeakMap<Observable, Set<Event>>();\n\n/** Update register. */\nconst PENDING_KEYS = new WeakMap<Observable, Set<string | number | symbol>>();\n\n/** Central event dispatch. Bunches all updates to occur at same time. */\nconst DISPATCH = new Set<() => void>();\n\nfunction addListener<T extends Observable>(\n  subject: T,\n  callback: Notify<T>,\n  select?: Event | Set<Event>\n) {\n  let listeners = LISTENERS.get(subject)!;\n\n  if (!listeners)\n    LISTENERS.set(subject, (listeners = new Map([[onReady, undefined]])));\n\n  if (select !== undefined && !(select instanceof Set))\n    select = new Set([select]);\n\n  if (!listeners.has(onReady) && !select) {\n    callback.call(subject, true, subject);\n  }\n\n  listeners.set(callback, select);\n\n  return () => listeners.delete(callback);\n}\n\nfunction emit(state: Observable, key: Event): void {\n  const listeners = LISTENERS.get(state)!;\n  const notReady = listeners.has(onReady);\n\n  if (key === true && !notReady) return;\n\n  let pending = PENDING.get(state);\n\n  if (pending) {\n    pending.add(key);\n    return;\n  }\n\n  PENDING.set(state, (pending = new Set(notReady ? [true, key] : [key])));\n\n  for (const key of pending)\n    for (const [callback, filter] of listeners)\n      if (!filter || filter.has(key)) {\n        const after = callback.call(state, key, state);\n\n        if (after) {\n          enqueue(after);\n        } else if (after === null) {\n          listeners.delete(callback);\n        }\n      }\n\n  if (key === null) listeners.clear();\n\n  PENDING.delete(state);\n}\n\nfunction event(\n  subject: Observable,\n  key?: string | number | symbol | null,\n  silent?: boolean\n) {\n  if (key === null) return emit(subject, key);\n\n  if (!key) return emit(subject, true);\n\n  let pending = PENDING_KEYS.get(subject);\n\n  if (!pending) {\n    PENDING_KEYS.set(subject, (pending = new Set()));\n\n    if (!silent)\n      enqueue(() => {\n        emit(subject, false);\n        PENDING_KEYS.delete(subject);\n      });\n  }\n\n  pending.add(key);\n\n  if (!silent) emit(subject, key);\n}\n\nfunction enqueue(eventHandler: () => void) {\n  if (!DISPATCH.size)\n    setTimeout(() => {\n      DISPATCH.forEach((event) => {\n        try {\n          event();\n        } catch (err) {\n          console.error(err);\n        }\n      });\n      DISPATCH.clear();\n    }, 0);\n\n  DISPATCH.add(eventHandler);\n}\n\n/**\n * Create a side-effect which will update whenever values accessed change.\n * Callback is called immediately and whenever values are stale.\n *\n * @param target - Instance of State to observe.\n * @param callback - Function to invoke when values change.\n * @param requireValues - If `true` will throw if accessing a value which is `undefined`.\n */\nfunction watch<T extends Observable>(\n  target: T,\n  callback: Effect<Required<T>>,\n  requireValues: true\n): () => void;\n\nfunction watch<T extends Observable>(\n  target: T,\n  callback: Effect<T>,\n  recursive?: boolean\n): () => void;\n\nfunction watch<T extends Observable>(\n  target: T,\n  callback: Effect<T>,\n  argument?: boolean\n) {\n  let unset: ((update: boolean | null) => void) | undefined;\n  let reset: (() => void) | null | undefined;\n\n  function invoke() {\n    let ignore: boolean = true;\n\n    function onUpdate(): void | PromiseLite<void> {\n      if (ignore || reset === null) return;\n\n      ignore = true;\n\n      if (reset && unset) {\n        unset(true);\n        unset = undefined;\n      }\n\n      enqueue(invoke);\n      return { then: enqueue };\n    }\n\n    try {\n      const exit = argument === false ? undefined : scope();\n      const output = callback(\n        target[Observable](onUpdate, argument === true) as T\n      );\n      const flush = exit ? exit() : () => {};\n\n      ignore = false;\n      reset = output === null ? null : invoke;\n      unset = (key) => {\n        if (typeof output == 'function') output(key);\n\n        flush();\n      };\n    } catch (err) {\n      if (err instanceof Promise) {\n        reset = undefined;\n        err.then(invoke);\n      } else {\n        throw err;\n      }\n    }\n  }\n\n  function cleanup() {\n    if (unset) unset(false);\n\n    reset = null;\n  }\n\n  if (EffectContext && argument !== false) EffectContext.add(cleanup);\n\n  addListener(target, (key) => {\n    if (key === true) invoke();\n    else if (!reset) return reset;\n\n    if (key === null && unset) unset(null);\n  });\n\n  return cleanup;\n}\n\nlet EffectContext: Set<() => void> | undefined;\n\nexport function scope() {\n  const last = EffectContext;\n  const context = (EffectContext = new Set());\n\n  return () => {\n    EffectContext = last;\n    return () => context.forEach((fn) => fn());\n  };\n}\n\nexport { addListener, watch, event, Notify, PENDING_KEYS, Observable };\n"],"mappings":"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"}