@expressive/mvc 0.72.0 → 0.73.0

package/dist/esm/instruction/set.js

@@ -1,136 +1,118 @@
-import { addListener, enter, watch } from "../control";
-import { access, event, METHOD, State, update } from "../state";
-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, 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 connect2 = function(self) {
-        reset = watch(
-          self,
-          (current) => {
-            proxy = current;
-            if (!(key in state) || STALE.delete(compute2)) compute2(!reset);
-            return (didUpdate) => {
-              if (didUpdate) {
-                STALE.add(compute2);
-                event(subject, key, true);
-              }
-            };
-          },
-          false
-        );
-      }, compute2 = function(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);
-      };
-      var connect = connect2, compute = compute2;
-      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;
-      return () => {
-        if (!proxy) {
-          source(connect2);
-          isAsync = true;
-        }
-        if (STALE.delete(compute2)) compute2();
-        return access(subject, key, !proxy);
-      };
-    }
-    if (typeof value == "function" || value instanceof Promise) {
-      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 (value instanceof Promise)
-          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();
 }
-export {
-  set
-};
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/instruction/set.ts"],
  "sourcesContent": ["import { addListener, enter, watch } from '../control';\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 = enter();\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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",
  "names": ["connect", "compute", "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":";;;;;AAIA,MAAM,wBAAQ,IAAI,SAAqB;AAkFvC,SAAS,IAAa,OAAiB,UAAyB;AAC9D,QAAO,KAAQ,KAAK,SAAS,UAAU;AACrC,MAAI,OAAO,SAAS,SAClB,OAAM,IAAI,MACR,uFAAuF,QAAQ,GAAG,IAAI,wBACvG;EAEH,MAAM,WAAmC,EAAE;AAG3C,MAAI,iBAAiB,SAAS,UAAU,MAAM;GAC5C,IAAI,OAAO;GACX,IAAI;AAEJ,OAAI,iBAAiB,OAAO;AAC1B,WAAO;AACP,aAAS;UACJ;IAEL,MAAM,KAAK,OAAO,IAAI,SAAS,IAAI;AACnC,eAAW,GAAG,MAAM,GAAG,KAAK,GAAG,GAAG,EAAE;;GAItC,MAAM,UAAkB,YAAY,QAAQ,KAAK;GAEjD,IAAI;GACJ,IAAI;GACJ,IAAI;GAEJ,SAAS,QAAQ,MAAa;AAC5B,YAAQ,MACN,OACC,YAAY;AACX,aAAQ;AAER,SAAI,EAAE,OAAO,UAAU,MAAM,OAAO,QAAQ,CAAE,SAAQ,CAAC,MAAM;AAE7D,aAAQ,cAAc;AACpB,UAAI,WAAW;AACb,aAAM,IAAI,QAAQ;AAClB,aAAM,SAAS,KAAK,KAAK;;;OAI/B,MACD;;GAGH,SAAS,QAAQ,SAAmB;IAClC,IAAI;AAEJ,QAAI;AACF,YAAO,OAAO,KAAK,OAAO,OAAO,IAAI;aAC9B,KAAK;AACZ,aAAQ,KACN,iCACE,UAAU,iBAAiB,aAC5B,GAAG,QAAQ,GAAG,IAAI,GACpB;AAED,SAAI,QAAS,OAAM;AAEnB,aAAQ,MAAM,IAAI;;AAGpB,WAAO,SAAS,KAAK,MAAM,CAAC,QAAQ;;AAGtC,gBAAa;AACX,QAAI,CAAC,OAAO;AACV,YAAO,QAAQ;AACf,eAAU;;AAGZ,QAAI,MAAM,OAAO,QAAQ,CAAE,UAAS;AAEpC,WAAO,OAAO,SAAS,KAAK,CAAC,MAAM;;;AAKvC,MAAI,OAAO,SAAS,cAAc,iBAAiB,SAAS;GAC1D,SAAS,OAAO;AACd,QAAI,OAAO,SAAS,WAClB,KAAI;AACF,aAAQ,QAAQ,MAAM,KAAK,SAAS,IAAI,CAAC;aAClC,KAAK;AACZ,aAAQ,KACN,gCAAgC,QAAQ,GAAG,IAAI,UAChD;AACD,WAAM;;AAGV,aAAS,MAAM,aAAa;IAE5B,MAAM,OAAO,UAAgB,QAAQ,OAAO;AAE5C,QAAI,iBAAiB,QACnB,OAAM,KAAK,MAAM,UAAU;AACzB,WAAM,SAAS,IAAI;AACnB,cAAS,YAAY;AACnB,YAAM;;MAER;QACC,KAAI,MAAM;AAEf,QAAI,SAAU,QAAO;AAErB,WAAO,QAAQ;;AAGjB,OAAI,SACF,aAAY,SAAS,MAAM,KAAK;OAEhC,UAAS,MAAM;aAER,UAAU,OACnB,UAAS,QAAQ;AAGnB,MAAI,OAAO,YAAY,YAAY;GACjC,IAAI;AAEJ,YAAS,MAAM,SAAqB,OAAY,UAAe;IAC7D,MAAM,OAAO,OAAO;IACpB,MAAM,UAAU,SAAS,KAAK,MAAM,OAAO,SAAS;IACpD,MAAM,QAAQ,MAAM;AAEpB,QAAI,YAAY,MAAO,QAAO;AAE9B,QAAI,OAAO,SAAS,WAAY,OAAM,MAAM;AAE5C,aAAS,SAAY;AACnB,SAAI,OAAO,WAAW,WAAY,SAAQ,KAAK;AAE/C,YAAO;;;QAIX,UAAS,OAAO,UAAU;AACxB,YAAS,MAAM;AACf,UAAO,SAAS,KAAK,MAAM;;AAG/B,SAAO;GACP;;AAGJ,SAAS,QAAQ,IAAoB;CAEnC,SAAS,MAAM,KAAc;AAC3B,MAAI,eAAe,QAAS,QAAO,IAAI,KAAK,QAAQ;MAC/C,OAAM;;CAGb,SAAS,UAAe;AACtB,MAAI;GACF,MAAM,SAAS,IAAI;AAEnB,UAAO,kBAAkB,UAAU,OAAO,MAAM,MAAM,GAAG;WAClD,KAAK;AACZ,UAAO,MAAM,IAAI;;;AAIrB,QAAO,SAAS"}

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,63 +1,56 @@
-import { access, follow, State, PARENT, STATE, uid, update } from "../state";
+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 (State.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 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 };
-  };
+	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 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;
+	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;
 }
 State.on(init);
-export {
-  use
-};
-//# sourceMappingURL=data:application/json;base64,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
+
+//#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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