@expressive/mvc 0.71.0 → 0.73.0

package/dist/esm/instruction/get.js

@@ -1,90 +1,77 @@
-import { Context } from "../context";
-import { createEffect } from "../control";
-import { fetch, METHOD, Model, PARENT, event, update } from "../model";
-import { use } from "./use";
-const STALE = /* @__PURE__ */ new WeakSet();
-function get(arg0, arg1) {
-  return use((key, subject, state) => {
-    if (typeof arg0 == "symbol")
-      throw new Error(`Attempted to use an instruction result (probably use or get) as computed source for ${subject}.${key}. This is not allowed.`);
-    if (Model.is(arg0)) {
-      let assign2 = function(value) {
-        if (typeof arg1 == "function")
-          value.get((x) => arg1(x, key));
-        update(subject, key, value);
-      };
-      var assign = assign2;
-      const hasParent = PARENT.get(subject);
-      if (!hasParent && arg1 === true)
-        throw new Error(`${subject} may only exist as a child of type ${arg0}.`);
-      else if (hasParent) {
-        if (hasParent instanceof arg0) {
-          assign2(hasParent);
-          return {};
-        } else if (arg1 === true)
-          throw new Error(`New ${subject} created as child of ${hasParent}, but must be instanceof ${arg0}.`);
-      }
-      Context.get(subject, (context) => {
-        const model = context.get(arg0);
-        if (model)
-          assign2(model);
-        else if (arg1 !== false)
-          throw new Error(`Required ${arg0} not found in context for ${subject}.`);
-      });
-      return {
-        get: arg1 !== false,
-        enumerable: false
-      };
-    }
-    let from = subject;
-    if (arg0 instanceof Model) {
-      from = arg0;
-    } else {
-      const fn = METHOD.get(arg0) || arg0;
-      arg1 = (p, k) => fn.call(p, k, p);
-    }
-    const source = (resolve) => resolve(from);
-    const getter = arg1;
-    let reset;
-    let isAsync;
-    let proxy;
-    function connect(model) {
-      reset = createEffect(model, (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 fetch(subject, key, !proxy);
-    };
-  });
+import { scope } from "../observable.js";
+import { PARENT, update } from "../state.js";
+import { Context } from "../context.js";
+import { use } from "./use.js";
+
+//#region src/instruction/get.ts
+function get(Type, arg1, arg2) {
+	const isDownstream = arg1 === true;
+	const isOptional = arg1 === false;
+	return use((key, subject) => {
+		if (isDownstream) {
+			const callback = typeof arg2 === "function" ? arg2 : void 0;
+			const applied = /* @__PURE__ */ new Set();
+			const reset = () => {
+				update(subject, key, Object.freeze(Array.from(applied)));
+			};
+			Context.get(subject, (context) => {
+				context.get(Type, (state) => {
+					let remove;
+					let flush;
+					if (applied.has(state)) return;
+					if (callback) {
+						const exit = scope();
+						try {
+							const done = callback(state, subject);
+							if (done === false) return false;
+							if (typeof done == "function") remove = done;
+						} finally {
+							flush = exit();
+						}
+					}
+					applied.add(state);
+					reset();
+					const done = () => {
+						if (flush) flush();
+						ignore();
+						applied.delete(state);
+						reset();
+						if (typeof remove == "function") remove();
+						remove = void 0;
+					};
+					const ignore = state.set(done, null);
+					return done;
+				});
+			});
+			return {
+				value: [],
+				enumerable: false
+			};
+		}
+		const hasParent = PARENT.get(subject);
+		function assign(value) {
+			if (typeof arg1 === "function") {
+				const result = arg1(value, subject);
+				if (typeof result === "function") subject.set(result, null);
+			}
+			update(subject, key, value);
+		}
+		if (hasParent && hasParent instanceof Type) {
+			assign(hasParent);
+			return {};
+		}
+		Context.get(subject, (context) => {
+			const self = context.get(Type);
+			if (self) assign(self);
+			else if (!isOptional) throw new Error(`Required ${Type} not found in context for ${subject}.`);
+		});
+		return {
+			get: !isOptional,
+			enumerable: false
+		};
+	});
 }
-export {
-  get
-};
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/instruction/get.ts"],
  "sourcesContent": ["import { Context } from '../context';\nimport { createEffect } from '../control';\nimport { fetch, METHOD, Model, PARENT, event, update } from '../model';\nimport { use } from './use';\n\ntype Type<T extends Model> = Model.Type<T> & typeof Model;\n\nconst STALE = new WeakSet<() => void>();\n\ndeclare namespace get {\n  type Compute<T, S = any> = (on: S, key: string) => T;\n\n  type Factory<T, S = any> = (this: S, key: string, thisArg: S) => T;\n\n  type Source<T extends Model = Model> = (resolve: (x: T) => void) => void;\n\n  type Effect<T> = (model: T, key: string) => (() => void) | void;\n}\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 expectParent - If true, will throw if Model is created without a parent.\n */\nfunction get <T extends Model> (Type: Model.Type<T>, expectParent?: true): 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 suspense.\n */\nfunction get <T extends Model> (Type: Model.Type<T>, required?: false): T | undefined;\n\n/**\n * Implement a computed value from a foreign model. Output will be generated by provided function,\n * where the foreign model will be passed to that function.\n * \n * @param source - Type of Model to fetch for computation.\n * @param compute - Compute function. Will update automatically as input values change.\n */\nfunction get <T extends Model> (Type: Model.Type<T>, effect: get.Effect<T>): T;\n\n/**\n * Implement a computed value; output will be generated by provided function.\n *\n * @param source - Source model 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 get <R, T extends Model> (source: T, compute: get.Compute<R, T>): R;\n\n/**\n * Implement a computed value; output is returned by function from provided factory.\n * \n * Factory is bound to owner of property.\n *\n * @param compute - Factory function to generate a getter to subscribe dependancies.\n */\nfunction get <R, T> (compute: get.Factory<R, T>): R;\n \nfunction get<R, T extends Model>(\n  arg0: T | get.Factory<R, T> | Type<T>,\n  arg1?: Function | boolean){\n\n  return use((key, subject, state) => {\n    if(typeof arg0 == \"symbol\")\n      throw new Error(`Attempted to use an instruction result (probably use or get) as computed source for ${subject}.${key}. This is not allowed.`)\n\n    if(Model.is(arg0)){\n      const hasParent = PARENT.get(subject) as T;\n\n      // TODO: notify on discovered context \n      function assign(value: T) {\n        if (typeof arg1 == \"function\")\n          value.get(x => (arg1 as Function)(x, key));\n\n        update(subject, key, value);\n      }\n\n      if(!hasParent && arg1 === true)\n        throw new Error(`${subject} may only exist as a child of type ${arg0}.`);\n      else if(hasParent)\n        if(hasParent instanceof arg0){\n          assign(hasParent);\n          return {}\n        }\n        else if(arg1 === true)\n          throw new Error(`New ${subject} created as child of ${hasParent}, but must be instanceof ${arg0}.`);\n \n      Context.get(subject, (context) => {\n        const model = context.get(arg0);\n\n        if(model)\n          assign(model);\n        else if(arg1 !== false)\n          throw new Error(`Required ${arg0} not found in context for ${subject}.`)\n      });\n\n      return {\n        get: arg1 !== false,\n        enumerable: false\n      };\n    }\n    \n    let from = subject;\n    \n    if(arg0 instanceof Model){\n      from = arg0;\n    }\n    else {\n      const fn = METHOD.get(arg0) || arg0;\n      arg1 = ((p, k) => fn.call(p, k, p)) as get.Effect<T>;\n    }\n\n    const source: get.Source<T> = resolve => resolve(from);\n    const getter = arg1 as get.Compute<R, T>;\n\n    let reset: (() => void) | undefined;\n    let isAsync: boolean;\n    let proxy: any;\n\n    function connect(model: Model){\n      reset = createEffect(model, current => {\n        proxy = current;\n\n        if(!(key in state) || STALE.delete(compute))\n          compute(!reset);\n\n        return (didUpdate) => {\n          if(didUpdate){\n            STALE.add(compute);\n            event(subject, key, true);\n          }\n        };\n      }, false)\n    }\n\n    function compute(initial?: boolean){\n      let next: R | undefined;\n\n      try {\n        next = getter.call(proxy, proxy, key);\n      }\n      catch(err){\n        console.warn(`An exception was thrown while ${initial ? \"initializing\" : \"refreshing\"} ${subject}.${key}.`)\n\n        if(initial)\n          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))\n        compute();\n\n      return fetch(subject, key, !proxy) as T;\n    }\n  })\n}\n\nexport { get };"],
  "mappings": "AAAA,SAAS,eAAe;AACxB,SAAS,oBAAoB;AAC7B,SAAS,OAAO,QAAQ,OAAO,QAAQ,OAAO,cAAc;AAC5D,SAAS,WAAW;AAIpB,MAAM,QAAQ,oBAAI,QAAoB;AA0DtC,SAAS,IACP,MACA,MAA0B;AAE1B,SAAO,IAAI,CAAC,KAAK,SAAS,UAAU;AAClC,QAAG,OAAO,QAAQ;AAChB,YAAM,IAAI,MAAM,uFAAuF,OAAO,IAAI,GAAG,wBAAwB;AAE/I,QAAG,MAAM,GAAG,IAAI,GAAE;AAIhB,UAASA,UAAT,SAAgB,OAAU;AACxB,YAAI,OAAO,QAAQ;AACjB,gBAAM,IAAI,OAAM,KAAkB,GAAG,GAAG,CAAC;AAE3C,eAAO,SAAS,KAAK,KAAK;AAAA,MAC5B;AALS,mBAAAA;AAHT,YAAM,YAAY,OAAO,IAAI,OAAO;AAUpC,UAAG,CAAC,aAAa,SAAS;AACxB,cAAM,IAAI,MAAM,GAAG,OAAO,sCAAsC,IAAI,GAAG;AAAA,eACjE;AACN,YAAG,qBAAqB,MAAK;AAC3B,UAAAA,QAAO,SAAS;AAChB,iBAAO,CAAC;AAAA,QACV,WACQ,SAAS;AACf,gBAAM,IAAI,MAAM,OAAO,OAAO,wBAAwB,SAAS,4BAA4B,IAAI,GAAG;AAAA;AAEtG,cAAQ,IAAI,SAAS,CAAC,YAAY;AAChC,cAAM,QAAQ,QAAQ,IAAI,IAAI;AAE9B,YAAG;AACD,UAAAA,QAAO,KAAK;AAAA,iBACN,SAAS;AACf,gBAAM,IAAI,MAAM,YAAY,IAAI,6BAA6B,OAAO,GAAG;AAAA,MAC3E,CAAC;AAED,aAAO;AAAA,QACL,KAAK,SAAS;AAAA,QACd,YAAY;AAAA,MACd;AAAA,IACF;AAEA,QAAI,OAAO;AAEX,QAAG,gBAAgB,OAAM;AACvB,aAAO;AAAA,IACT,OACK;AACH,YAAM,KAAK,OAAO,IAAI,IAAI,KAAK;AAC/B,aAAQ,CAAC,GAAG,MAAM,GAAG,KAAK,GAAG,GAAG,CAAC;AAAA,IACnC;AAEA,UAAM,SAAwB,aAAW,QAAQ,IAAI;AACrD,UAAM,SAAS;AAEf,QAAI;AACJ,QAAI;AACJ,QAAI;AAEJ,aAAS,QAAQ,OAAa;AAC5B,cAAQ,aAAa,OAAO,aAAW;AACrC,gBAAQ;AAER,YAAG,EAAE,OAAO,UAAU,MAAM,OAAO,OAAO;AACxC,kBAAQ,CAAC,KAAK;AAEhB,eAAO,CAAC,cAAc;AACpB,cAAG,WAAU;AACX,kBAAM,IAAI,OAAO;AACjB,kBAAM,SAAS,KAAK,IAAI;AAAA,UAC1B;AAAA,QACF;AAAA,MACF,GAAG,KAAK;AAAA,IACV;AAEA,aAAS,QAAQ,SAAkB;AACjC,UAAI;AAEJ,UAAI;AACF,eAAO,OAAO,KAAK,OAAO,OAAO,GAAG;AAAA,MACtC,SACM,KAAI;AACR,gBAAQ,KAAK,iCAAiC,UAAU,iBAAiB,YAAY,IAAI,OAAO,IAAI,GAAG,GAAG;AAE1G,YAAG;AACD,gBAAM;AAER,gBAAQ,MAAM,GAAG;AAAA,MACnB;AAEA,aAAO,SAAS,KAAK,MAAM,CAAC,OAAO;AAAA,IACrC;AAEA,WAAO,MAAM;AACX,UAAG,CAAC,OAAM;AACR,eAAO,OAAO;AACd,kBAAU;AAAA,MACZ;AAEA,UAAG,MAAM,OAAO,OAAO;AACrB,gBAAQ;AAEV,aAAO,MAAM,SAAS,KAAK,CAAC,KAAK;AAAA,IACnC;AAAA,EACF,CAAC;AACH;",
  "names": ["assign"]
}

+
+//#endregion
+export { get };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,71 @@
+import { State } from "../state.js";
+
+//#region src/instruction/ref.d.ts
+declare namespace ref {
+  type Callback<T> = (argument: T) => ((next: T | null) => void) | Promise<void> | void | boolean;
+  interface Object<T = any> {
+    /** 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`. */
+  /** 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.*
+ *
+ * @param target - Source state from which to reference values.
+ */
+declare function ref<T extends State>(target: T): ref.Proxy<T>;
+/**
+ * Creates an object with values based on managed values.
+ * Each property will invoke mapper function on first access supply
+ * the its return value going forward.
+ *
+ * @param target - Source state from which to reference values.
+ * @param mapper - Function producing the placeholder value for any given property.
+ */
+declare function ref<O extends State, R>(target: O, mapper: (key: State.Field<O>) => R): ref.CustomProxy<O, R>;
+/**
+ * Creates a ref-compatible property.
+ * Will persist value, and updates to this are made part of controller event-stream.
+ *
+ * *Output is simultaneously a ref-function and ref-object, use as needed.*
+ *
+ * @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.
+ * Will persist value, and updates to this are made part of controller event-stream.
+ *
+ * *Output is simultaneously a ref-function and ref-object, use as needed.*
+ *
+ * @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=data:application/json;charset=utf-8;base64,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

package/dist/esm/instruction/ref.js

@@ -1,66 +1,68 @@
-import { addListener, enter } from "../control";
-import { update } from "../model";
-import { use } from "./use";
+import { addListener, scope } from "../observable.js";
+import { update } from "../state.js";
+import { use } from "./use.js";
+
+//#region src/instruction/ref.ts
 const { defineProperty, defineProperties } = Object;
 function ref(arg, arg2) {
-  return use((key, subject, state) => {
-    let value = {};
-    const method = (key2, from) => (callback) => callback ? addListener(subject, () => callback(from[key2]), key2) : from[key2];
-    if (arg === subject)
-      addListener(subject, () => {
-        for (const key2 in subject)
-          if (typeof arg2 == "function")
-            defineProperty(value, key2, {
-              configurable: true,
-              get() {
-                const out = arg2(key2);
-                defineProperty(value, key2, { value: out });
-                return out;
-              }
-            });
-          else {
-            const get = method(key2, subject);
-            const set = (x) => subject[key2] = x;
-            defineProperties(set, {
-              current: { get, set },
-              get: { value: get },
-              is: { value: subject },
-              key: { value: key2 }
-            });
-            defineProperty(value, key2, { value: set });
-          }
-        return null;
-      }, true);
-    else if (typeof arg == "object")
-      throw new Error("ref instruction does not support object which is not 'this'");
-    else {
-      let unset;
-      const get = method(key, state);
-      const set = (value2) => {
-        if (!update(subject, key, value2) || !arg)
-          return;
-        if (unset)
-          unset = void unset(value2);
-        if (value2 === null && arg2 !== false)
-          return;
-        const exit = enter();
-        const out = arg.call(subject, value2);
-        const flush = exit();
-        unset = (key2) => {
-          if (typeof out == "function")
-            out(key2);
-          flush();
-        };
-      };
-      state[key] = null;
-      value = defineProperties({ get, key, is: subject }, {
-        current: { get, set }
-      });
-    }
-    defineProperty(subject, key, { value });
-  });
+	return use((key, subject, state) => {
+		let value = {};
+		const method = (key, from) => (callback) => callback ? addListener(subject, () => callback(from[key]), key) : from[key];
+		if (arg === subject) addListener(subject, () => {
+			for (const key in subject) if (typeof arg2 == "function") defineProperty(value, key, {
+				configurable: true,
+				get() {
+					const out = arg2(key);
+					defineProperty(value, key, { value: out });
+					return out;
+				}
+			});
+			else {
+				const get = method(key, subject);
+				const set = (x) => subject[key] = x;
+				defineProperties(set, {
+					current: {
+						get,
+						set
+					},
+					get: { value: get },
+					is: { value: subject },
+					key: { value: key }
+				});
+				defineProperty(value, key, { value: set });
+			}
+			return null;
+		}, true);
+		else if (typeof arg == "object") throw new Error("ref instruction does not support object which is not 'this'");
+		else {
+			let unset;
+			const get = method(key, state);
+			const set = (value) => {
+				if (!update(subject, key, value) || !arg) return;
+				if (unset) unset = void unset(value);
+				if (value === null && arg2 !== false) return;
+				const exit = scope();
+				const out = arg.call(subject, value);
+				const flush = exit();
+				unset = (key) => {
+					if (typeof out == "function") out(key);
+					flush();
+				};
+			};
+			state[key] = null;
+			value = defineProperty({
+				get,
+				key,
+				is: subject
+			}, "current", {
+				get,
+				set
+			});
+		}
+		defineProperty(subject, key, { value });
+	});
 }
-export {
-  ref
-};
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/instruction/ref.ts"],
  "sourcesContent": ["import { addListener, enter } from '../control';\nimport { Model, update } from '../model';\nimport { use } from './use';\n\nconst { defineProperty, defineProperties } = Object;\n\ndeclare namespace ref {\n  type Callback<T> = (argument: T) =>\n    ((next: T | null) => void) | Promise<void> | void | boolean;\n\n  interface Object<T = any> {\n    /** Current value held by this reference. */\n    current: T;\n\n    /** Model instance this reference belongs to. */\n    is: Model;\n\n    /** Key of property on model 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\n  /** Object with references to all managed values of `T`. */\n  type Proxy<T extends Model> =\n    & { [P in Model.Field<T>]-?: Object<T[P]> }\n    & { get(): T };\n\n  type CustomProxy<T extends Model, R> =\n    & { [P in Model.Field<T>]-?: R }\n    & { get(): T };\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 * @param target - Source model from which to reference values.\n */\nfunction ref <T extends Model> (target: T): ref.Proxy<T>;\n\n/**\n * Creates an object with values based on managed values.\n * Each property will invoke mapper function on first access supply\n * the its return value going forward.\n *\n * @param target - Source model from which to reference values.\n * @param mapper - Function producing the placeholder value for any given property.\n */\nfunction ref <O extends Model, R>\n  (target: O, mapper: (key: Model.Field<O>) => R): ref.CustomProxy<O, R>;\n\n/**\n * Creates a ref-compatible property.\n * Will persist value, and updates to this are made part of controller event-stream.\n *\n * *Output is simultaneously a ref-function and ref-object, use as needed.*\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 * Will persist value, and updates to this are made part of controller event-stream.\n *\n * *Output is simultaneously a ref-function and ref-object, use as needed.*\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> (callback: ref.Callback<T | null>, ignoreNull: boolean): ref.Object<T>;\n\nfunction ref<T>(\n  arg?: ref.Callback<T> | Model,\n  arg2?: ((key: string) => any) | boolean){\n\n  return use<T>((key, subject, state) => {\n    let value = {};\n    const method = (key: string, from: Record<string, T>) =>\n      (callback?: (value: T) => void) => callback\n        ? addListener(subject, () => callback(from[key]), key)\n        : from[key];\n\n    if(arg === subject)\n      addListener(subject, () => {\n        for(const key in subject)\n          if(typeof arg2 == \"function\")\n            defineProperty(value, key, {\n              configurable: true,\n              get(){\n                const out = arg2(key);\n                defineProperty(value, key, { value: out });\n                return out;\n              }\n            })\n          else {\n            const get = method(key, subject);\n            const set = (x: any) => subject[key] = x;\n\n            defineProperties(set, {\n              current: { get, set },\n              get: { value: get },\n              is: { value: subject },\n              key: { value: key },\n            });\n\n            defineProperty(value, key, { value: set });\n          }\n\n        return null;\n      }, true);\n\n    else if(typeof arg == \"object\")\n      throw new Error(\"ref instruction does not support object which is not 'this'\");\n\n    else {\n      let unset: ((next: T) => void) | undefined;\n      const get = method(key, state);\n      const set = (value?: any) => {\n        if(!update(subject, key, value) || !arg)\n          return;\n\n        if(unset)\n          unset = void unset(value);\n    \n        if(value === null && arg2 !== false)\n          return;\n\n        const exit = enter();\n        const out = arg.call(subject, value);\n        const flush = exit();\n\n        unset = key => {\n          if(typeof out == \"function\")\n            out(key);\n\n          flush();\n        }\n      };\n  \n      state[key] = null;\n      value = defineProperties({ get, key, is: subject }, {\n        current: { get, set }\n      }) as ref.Object<T>;\n    }\n\n    defineProperty(subject, key, { value });\n  })\n}\n\nexport { ref }"],
  "mappings": "AAAA,SAAS,aAAa,aAAa;AACnC,SAAgB,cAAc;AAC9B,SAAS,WAAW;AAEpB,MAAM,EAAE,gBAAgB,iBAAiB,IAAI;AAkF7C,SAAS,IACP,KACA,MAAwC;AAExC,SAAO,IAAO,CAAC,KAAK,SAAS,UAAU;AACrC,QAAI,QAAQ,CAAC;AACb,UAAM,SAAS,CAACA,MAAa,SAC3B,CAAC,aAAkC,WAC/B,YAAY,SAAS,MAAM,SAAS,KAAKA,IAAG,CAAC,GAAGA,IAAG,IACnD,KAAKA,IAAG;AAEd,QAAG,QAAQ;AACT,kBAAY,SAAS,MAAM;AACzB,mBAAUA,QAAO;AACf,cAAG,OAAO,QAAQ;AAChB,2BAAe,OAAOA,MAAK;AAAA,cACzB,cAAc;AAAA,cACd,MAAK;AACH,sBAAM,MAAM,KAAKA,IAAG;AACpB,+BAAe,OAAOA,MAAK,EAAE,OAAO,IAAI,CAAC;AACzC,uBAAO;AAAA,cACT;AAAA,YACF,CAAC;AAAA,eACE;AACH,kBAAM,MAAM,OAAOA,MAAK,OAAO;AAC/B,kBAAM,MAAM,CAAC,MAAW,QAAQA,IAAG,IAAI;AAEvC,6BAAiB,KAAK;AAAA,cACpB,SAAS,EAAE,KAAK,IAAI;AAAA,cACpB,KAAK,EAAE,OAAO,IAAI;AAAA,cAClB,IAAI,EAAE,OAAO,QAAQ;AAAA,cACrB,KAAK,EAAE,OAAOA,KAAI;AAAA,YACpB,CAAC;AAED,2BAAe,OAAOA,MAAK,EAAE,OAAO,IAAI,CAAC;AAAA,UAC3C;AAEF,eAAO;AAAA,MACT,GAAG,IAAI;AAAA,aAED,OAAO,OAAO;AACpB,YAAM,IAAI,MAAM,6DAA6D;AAAA,SAE1E;AACH,UAAI;AACJ,YAAM,MAAM,OAAO,KAAK,KAAK;AAC7B,YAAM,MAAM,CAACC,WAAgB;AAC3B,YAAG,CAAC,OAAO,SAAS,KAAKA,MAAK,KAAK,CAAC;AAClC;AAEF,YAAG;AACD,kBAAQ,KAAK,MAAMA,MAAK;AAE1B,YAAGA,WAAU,QAAQ,SAAS;AAC5B;AAEF,cAAM,OAAO,MAAM;AACnB,cAAM,MAAM,IAAI,KAAK,SAASA,MAAK;AACnC,cAAM,QAAQ,KAAK;AAEnB,gBAAQ,CAAAD,SAAO;AACb,cAAG,OAAO,OAAO;AACf,gBAAIA,IAAG;AAET,gBAAM;AAAA,QACR;AAAA,MACF;AAEA,YAAM,GAAG,IAAI;AACb,cAAQ,iBAAiB,EAAE,KAAK,KAAK,IAAI,QAAQ,GAAG;AAAA,QAClD,SAAS,EAAE,KAAK,IAAI;AAAA,MACtB,CAAC;AAAA,IACH;AAEA,mBAAe,SAAS,KAAK,EAAE,MAAM,CAAC;AAAA,EACxC,CAAC;AACH;",
  "names": ["key", "value"]
}

+
+//#endregion
+export { ref };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"ref.js","names":[],"sources":["../../../src/instruction/ref.ts"],"sourcesContent":["import { addListener, scope } from '../observable';\nimport { State, update } from '../state';\nimport { use } from './use';\n\nconst { defineProperty, defineProperties } = Object;\n\ndeclare namespace ref {\n  type Callback<T> = (\n    argument: T\n  ) => ((next: T | null) => void) | Promise<void> | void | boolean;\n\n  interface Object<T = any> {\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\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 * @param target - Source state from which to reference values.\n */\nfunction ref<T extends State>(target: T): ref.Proxy<T>;\n\n/**\n * Creates an object with values based on managed values.\n * Each property will invoke mapper function on first access supply\n * the its return value going forward.\n *\n * @param target - Source state from which to reference values.\n * @param mapper - Function producing the placeholder value for any given property.\n */\nfunction ref<O extends State, R>(\n  target: O,\n  mapper: (key: State.Field<O>) => R\n): ref.CustomProxy<O, R>;\n\n/**\n * Creates a ref-compatible property.\n * Will persist value, and updates to this are made part of controller event-stream.\n *\n * *Output is simultaneously a ref-function and ref-object, use as needed.*\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 * Will persist value, and updates to this are made part of controller event-stream.\n *\n * *Output is simultaneously a ref-function and ref-object, use as needed.*\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>(\n  arg?: ref.Callback<T> | State,\n  arg2?: ((key: string) => any) | boolean\n) {\n  return use<T>((key, subject, state) => {\n    let value = {};\n    const method =\n      (key: string, from: Record<string, T>) =>\n      (callback?: (value: T) => void) =>\n        callback\n          ? addListener(subject, () => callback(from[key]), key)\n          : from[key];\n\n    if (arg === subject)\n      addListener(\n        subject,\n        () => {\n          for (const key in subject)\n            if (typeof arg2 == 'function')\n              defineProperty(value, key, {\n                configurable: true,\n                get() {\n                  const out = arg2(key);\n                  defineProperty(value, key, { value: out });\n                  return out;\n                }\n              });\n            else {\n              const get = method(key, subject);\n              const set = (x: any) => (subject[key] = x);\n\n              defineProperties(set, {\n                current: { get, set },\n                get: { value: get },\n                is: { value: subject },\n                key: { value: key }\n              });\n\n              defineProperty(value, key, { value: set });\n            }\n\n          return null;\n        },\n        true\n      );\n    else if (typeof arg == 'object')\n      throw new Error(\n        \"ref instruction does not support object which is not 'this'\"\n      );\n    else {\n      let unset: ((next: T) => void) | undefined;\n      const get = method(key, state);\n      const set = (value?: any) => {\n        if (!update(subject, key, value) || !arg) return;\n\n        if (unset) unset = void unset(value);\n\n        if (value === null && arg2 !== false) return;\n\n        const exit = scope();\n        const out = arg.call(subject, value);\n        const flush = exit();\n\n        unset = (key) => {\n          if (typeof out == 'function') out(key);\n\n          flush();\n        };\n      };\n\n      state[key] = null;\n      value = defineProperty({ get, key, is: subject }, 'current', {\n        get,\n        set\n      });\n    }\n\n    defineProperty(subject, key, { value });\n  });\n}\n\nexport { ref };\n"],"mappings":";;;;;AAIA,MAAM,EAAE,gBAAgB,qBAAqB;AAwF7C,SAAS,IACP,KACA,MACA;AACA,QAAO,KAAQ,KAAK,SAAS,UAAU;EACrC,IAAI,QAAQ,EAAE;EACd,MAAM,UACH,KAAa,UACb,aACC,WACI,YAAY,eAAe,SAAS,KAAK,KAAK,EAAE,IAAI,GACpD,KAAK;AAEb,MAAI,QAAQ,QACV,aACE,eACM;AACJ,QAAK,MAAM,OAAO,QAChB,KAAI,OAAO,QAAQ,WACjB,gBAAe,OAAO,KAAK;IACzB,cAAc;IACd,MAAM;KACJ,MAAM,MAAM,KAAK,IAAI;AACrB,oBAAe,OAAO,KAAK,EAAE,OAAO,KAAK,CAAC;AAC1C,YAAO;;IAEV,CAAC;QACC;IACH,MAAM,MAAM,OAAO,KAAK,QAAQ;IAChC,MAAM,OAAO,MAAY,QAAQ,OAAO;AAExC,qBAAiB,KAAK;KACpB,SAAS;MAAE;MAAK;MAAK;KACrB,KAAK,EAAE,OAAO,KAAK;KACnB,IAAI,EAAE,OAAO,SAAS;KACtB,KAAK,EAAE,OAAO,KAAK;KACpB,CAAC;AAEF,mBAAe,OAAO,KAAK,EAAE,OAAO,KAAK,CAAC;;AAG9C,UAAO;KAET,KACD;WACM,OAAO,OAAO,SACrB,OAAM,IAAI,MACR,8DACD;OACE;GACH,IAAI;GACJ,MAAM,MAAM,OAAO,KAAK,MAAM;GAC9B,MAAM,OAAO,UAAgB;AAC3B,QAAI,CAAC,OAAO,SAAS,KAAK,MAAM,IAAI,CAAC,IAAK;AAE1C,QAAI,MAAO,SAAQ,KAAK,MAAM,MAAM;AAEpC,QAAI,UAAU,QAAQ,SAAS,MAAO;IAEtC,MAAM,OAAO,OAAO;IACpB,MAAM,MAAM,IAAI,KAAK,SAAS,MAAM;IACpC,MAAM,QAAQ,MAAM;AAEpB,aAAS,QAAQ;AACf,SAAI,OAAO,OAAO,WAAY,KAAI,IAAI;AAEtC,YAAO;;;AAIX,SAAM,OAAO;AACb,WAAQ,eAAe;IAAE;IAAK;IAAK,IAAI;IAAS,EAAE,WAAW;IAC3D;IACA;IACD,CAAC;;AAGJ,iBAAe,SAAS,KAAK,EAAE,OAAO,CAAC;GACvC"}

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

@@ -0,0 +1,69 @@
+import { State } from "../state.js";
+
+//#region src/instruction/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 Compute<T, S = any> = (on: S, key: string) => T;
+  type Factory<T, S = any> = (this: S, key: string) => Promise<T> | T;
+}
+/**
+ * Set property as `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.
+ */
+declare function set<T = any>(): T;
+/**
+ * Set property with a factory function.
+ *
+ * **Note** Factory is lazy! It will only run if/when property is accessed.
+ * Value will be undefined until factory resolves, which will also dispatch an update for the property.
+ */
+declare function set<T>(factory: set.Factory<T>, required: false): T | undefined;
+/**
+ * Set property with a factory function.
+ *
+ * If async, property cannot be accessed until resolves, yeilding a result.
+ * If accessed while still processing, React Suspense will be thrown.
+ *
+ * @param factory - Callback run to derrive property value.
+ * @param required - If true run factory immediately on creation, otherwise on access.
+ */
+declare function set<T>(factory: set.Factory<T>, required?: boolean): T;
+/**
+ * Set property with a factory function.
+ *
+ * If async, property cannot be accessed until resolves, yeilding a result.
+ * If accessed while still processing, React Suspense will be thrown.
+ *
+ * @param factory - Callback run to derrive property value.
+ * @param onUpdate - Callback run when property is finished computing or is set.
+ */
+declare function set<T>(factory: set.Factory<T>, onUpdate?: set.Callback<T>): T;
+/**
+ * Set a property with empty placeholder and/or update callback.
+ *
+ * @param value - Starting value for property. If undefined, suspense will be thrown on access, until value is set and accepted by callback.
+ * @param onUpdate - Callback run when property is set. If returns false, update is not accepted and property will keep previous value.
+ */
+declare function set<T>(value: T | undefined, onUpdate?: set.Callback<T>): T;
+/**
+ * Implement a reactive computed value using a method reference.
+ *
+ * The method will automatically re-run when any accessed properties change.
+ * Use `true` to indicate reactive mode with implicit `this` as the source.
+ *
+ * @param reactiveToThis - Pass `true` to enable reactive mode with implicit this
+ * @param method - Method reference or compute function to use
+ */
+declare function set<R, T = any>(reactiveToThis: true, method: set.Compute<R, T> | Function): R;
+/**
+ * Implement a computed value; output will be generated by provided function.
+ *
+ * @param reactiveTo - Source state from which computed value will be a subscriber.
+ * @param compute - Compute function. Bound to a subscriber-proxy of source, returns output value. Will update automatically as input values change.
+ */
+declare function set<R, T extends State>(reactiveTo: T, compute: set.Compute<R, T>): R;
+//#endregion
+export { set };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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