@expressive/mvc 0.72.0 → 0.73.0

package/dist/esm/instruction/get.js

@@ -1,81 +1,77 @@
-import { enter } from "../control";
-import { Context } from "../context";
-import { PARENT, update } from "../state";
-import { use } from "./use";
+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 = enter();
-            try {
-              const done2 = callback(state, subject);
-              if (done2 === false) return false;
-              if (typeof done2 == "function") remove = done2;
-            } 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 callback = arg1;
-        const result = callback(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
-    };
-  });
+	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 { enter } from '../control';\nimport { Context } from '../context';\nimport { State, PARENT, update } from '../state';\nimport { use } from './use';\n\ntype Type<T extends State> = State.Extends<T> & typeof State;\n\ndeclare namespace get {\n  type Callback<T = any> = (\n    state: T,\n    subject: State\n  ) => void | boolean | (() => void);\n}\n\n/**\n * Fetches upstream State from context with optional lifecycle callback.\n * Callback runs on mount and can return cleanup function for unmount.\n *\n * @param Type - Type of State to fetch.\n * @param callback - Optional lifecycle callback, receives (state, subject). Can return cleanup function.\n */\nfunction get<T extends State>(\n  Type: State.Extends<T>,\n  callback?: get.Callback<T>\n): T;\n\n/**\n * Fetches and assigns the controller which spawned this host.\n * When parent assigns an instance via `use()` directive, it\n * will be made available to child upon this request.\n *\n * @param Type - Type of controller compatible with this class.\n * @param required - If false, property may be undefined. Otherwise will throw suspense.\n */\nfunction get<T extends State>(\n  Type: State.Extends<T>,\n  required: false\n): T | undefined;\n\n/**\n * Collects downstream States, this will accumulate all instances of specified type for which this is an ancestor.\n * Returns a frozen array that updates as States are added or removed.\n * Callback runs on each State registration and can return cleanup or false to prevent registration.\n *\n * @param Type - Type of State to collect.\n * @param downstream - Must be true to enable downstream mode.\n * @param callback - Optional lifecycle callback, receives (state, subject). May return false to prevent registration.\n */\nfunction get<T extends State>(\n  Type: State.Extends<T>,\n  downstream: true,\n  callback?: get.Callback<T>\n): readonly T[];\n\nfunction get<R, T extends State>(\n  Type: Type<T>,\n  arg1?: Function | boolean,\n  arg2?: Function\n) {\n  const isDownstream = arg1 === true;\n  const isOptional = arg1 === false;\n\n  return use<T[] | T>((key, subject) => {\n    // Downstream collection mode\n    if (isDownstream) {\n      const callback =\n        typeof arg2 === 'function' ? (arg2 as get.Callback<T>) : undefined;\n\n      const applied = new Set<State>();\n      const reset = () => {\n        update(subject, key, Object.freeze(Array.from(applied)));\n      };\n\n      Context.get(subject, (context) => {\n        context.get(Type, (state) => {\n          let remove: (() => void) | undefined;\n          let flush: (() => void) | undefined;\n\n          if (applied.has(state)) return;\n\n          if (callback) {\n            const exit = enter();\n\n            try {\n              const done = callback(state, subject);\n\n              if (done === false) return false;\n              if (typeof done == 'function') remove = done;\n            } finally {\n              flush = exit();\n            }\n          }\n\n          applied.add(state);\n          reset();\n\n          const done = () => {\n            if (flush) flush();\n            ignore();\n\n            applied.delete(state);\n            reset();\n\n            if (typeof remove == 'function') remove();\n\n            remove = undefined;\n          };\n\n          const ignore = state.set(done, null);\n\n          return done;\n        });\n      });\n\n      return {\n        value: [],\n        enumerable: false\n      };\n    }\n\n    // Upstream mode\n    const hasParent = PARENT.get(subject) as T;\n\n    function assign(value: T) {\n      // If callback provided, run it as lifecycle hook\n      if (typeof arg1 === 'function') {\n        const callback = arg1 as get.Callback<T>;\n        const result = callback(value, subject);\n\n        // Register cleanup if returned\n        if (typeof result === 'function') {\n          subject.set(result, null);\n        }\n      }\n\n      update(subject, key, value);\n    }\n\n    // Check parent\n    if (hasParent && hasParent instanceof Type) {\n      assign(hasParent);\n      return {};\n    }\n\n    // Check context\n    Context.get(subject, (context) => {\n      const self = context.get(Type);\n\n      if (self) assign(self);\n      else if (!isOptional)\n        throw new Error(\n          `Required ${Type} not found in context for ${subject}.`\n        );\n    });\n\n    return {\n      get: !isOptional,\n      enumerable: false\n    };\n  });\n}\n\nexport { get };\n"],
  "mappings": "AAAA,SAAS,aAAa;AACtB,SAAS,eAAe;AACxB,SAAgB,QAAQ,cAAc;AACtC,SAAS,WAAW;AAmDpB,SAAS,IACP,MACA,MACA,MACA;AACA,QAAM,eAAe,SAAS;AAC9B,QAAM,aAAa,SAAS;AAE5B,SAAO,IAAa,CAAC,KAAK,YAAY;AAEpC,QAAI,cAAc;AAChB,YAAM,WACJ,OAAO,SAAS,aAAc,OAA2B;AAE3D,YAAM,UAAU,oBAAI,IAAW;AAC/B,YAAM,QAAQ,MAAM;AAClB,eAAO,SAAS,KAAK,OAAO,OAAO,MAAM,KAAK,OAAO,CAAC,CAAC;AAAA,MACzD;AAEA,cAAQ,IAAI,SAAS,CAAC,YAAY;AAChC,gBAAQ,IAAI,MAAM,CAAC,UAAU;AAC3B,cAAI;AACJ,cAAI;AAEJ,cAAI,QAAQ,IAAI,KAAK,EAAG;AAExB,cAAI,UAAU;AACZ,kBAAM,OAAO,MAAM;AAEnB,gBAAI;AACF,oBAAMA,QAAO,SAAS,OAAO,OAAO;AAEpC,kBAAIA,UAAS,MAAO,QAAO;AAC3B,kBAAI,OAAOA,SAAQ,WAAY,UAASA;AAAA,YAC1C,UAAE;AACA,sBAAQ,KAAK;AAAA,YACf;AAAA,UACF;AAEA,kBAAQ,IAAI,KAAK;AACjB,gBAAM;AAEN,gBAAM,OAAO,MAAM;AACjB,gBAAI,MAAO,OAAM;AACjB,mBAAO;AAEP,oBAAQ,OAAO,KAAK;AACpB,kBAAM;AAEN,gBAAI,OAAO,UAAU,WAAY,QAAO;AAExC,qBAAS;AAAA,UACX;AAEA,gBAAM,SAAS,MAAM,IAAI,MAAM,IAAI;AAEnC,iBAAO;AAAA,QACT,CAAC;AAAA,MACH,CAAC;AAED,aAAO;AAAA,QACL,OAAO,CAAC;AAAA,QACR,YAAY;AAAA,MACd;AAAA,IACF;AAGA,UAAM,YAAY,OAAO,IAAI,OAAO;AAEpC,aAAS,OAAO,OAAU;AAExB,UAAI,OAAO,SAAS,YAAY;AAC9B,cAAM,WAAW;AACjB,cAAM,SAAS,SAAS,OAAO,OAAO;AAGtC,YAAI,OAAO,WAAW,YAAY;AAChC,kBAAQ,IAAI,QAAQ,IAAI;AAAA,QAC1B;AAAA,MACF;AAEA,aAAO,SAAS,KAAK,KAAK;AAAA,IAC5B;AAGA,QAAI,aAAa,qBAAqB,MAAM;AAC1C,aAAO,SAAS;AAChB,aAAO,CAAC;AAAA,IACV;AAGA,YAAQ,IAAI,SAAS,CAAC,YAAY;AAChC,YAAM,OAAO,QAAQ,IAAI,IAAI;AAE7B,UAAI,KAAM,QAAO,IAAI;AAAA,eACZ,CAAC;AACR,cAAM,IAAI;AAAA,UACR,YAAY,IAAI,6BAA6B,OAAO;AAAA,QACtD;AAAA,IACJ,CAAC;AAED,WAAO;AAAA,MACL,KAAK,CAAC;AAAA,MACN,YAAY;AAAA,IACd;AAAA,EACF,CAAC;AACH;",
  "names": ["done"]
}

+
+//#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,69 +1,68 @@
-import { addListener, enter } from "../control";
-import { update } from "../state";
-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 = defineProperty({ 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 { 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 = enter();\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": "AAAA,SAAS,aAAa,aAAa;AACnC,SAAgB,cAAc;AAC9B,SAAS,WAAW;AAEpB,MAAM,EAAE,gBAAgB,iBAAiB,IAAI;AAwF7C,SAAS,IACP,KACA,MACA;AACA,SAAO,IAAO,CAAC,KAAK,SAAS,UAAU;AACrC,QAAI,QAAQ,CAAC;AACb,UAAM,SACJ,CAACA,MAAa,SACd,CAAC,aACC,WACI,YAAY,SAAS,MAAM,SAAS,KAAKA,IAAG,CAAC,GAAGA,IAAG,IACnD,KAAKA,IAAG;AAEhB,QAAI,QAAQ;AACV;AAAA,QACE;AAAA,QACA,MAAM;AACJ,qBAAWA,QAAO;AAChB,gBAAI,OAAO,QAAQ;AACjB,6BAAe,OAAOA,MAAK;AAAA,gBACzB,cAAc;AAAA,gBACd,MAAM;AACJ,wBAAM,MAAM,KAAKA,IAAG;AACpB,iCAAe,OAAOA,MAAK,EAAE,OAAO,IAAI,CAAC;AACzC,yBAAO;AAAA,gBACT;AAAA,cACF,CAAC;AAAA,iBACE;AACH,oBAAM,MAAM,OAAOA,MAAK,OAAO;AAC/B,oBAAM,MAAM,CAAC,MAAY,QAAQA,IAAG,IAAI;AAExC,+BAAiB,KAAK;AAAA,gBACpB,SAAS,EAAE,KAAK,IAAI;AAAA,gBACpB,KAAK,EAAE,OAAO,IAAI;AAAA,gBAClB,IAAI,EAAE,OAAO,QAAQ;AAAA,gBACrB,KAAK,EAAE,OAAOA,KAAI;AAAA,cACpB,CAAC;AAED,6BAAe,OAAOA,MAAK,EAAE,OAAO,IAAI,CAAC;AAAA,YAC3C;AAEF,iBAAO;AAAA,QACT;AAAA,QACA;AAAA,MACF;AAAA,aACO,OAAO,OAAO;AACrB,YAAM,IAAI;AAAA,QACR;AAAA,MACF;AAAA,SACG;AACH,UAAI;AACJ,YAAM,MAAM,OAAO,KAAK,KAAK;AAC7B,YAAM,MAAM,CAACC,WAAgB;AAC3B,YAAI,CAAC,OAAO,SAAS,KAAKA,MAAK,KAAK,CAAC,IAAK;AAE1C,YAAI,MAAO,SAAQ,KAAK,MAAMA,MAAK;AAEnC,YAAIA,WAAU,QAAQ,SAAS,MAAO;AAEtC,cAAM,OAAO,MAAM;AACnB,cAAM,MAAM,IAAI,KAAK,SAASA,MAAK;AACnC,cAAM,QAAQ,KAAK;AAEnB,gBAAQ,CAACD,SAAQ;AACf,cAAI,OAAO,OAAO,WAAY,KAAIA,IAAG;AAErC,gBAAM;AAAA,QACR;AAAA,MACF;AAEA,YAAM,GAAG,IAAI;AACb,cAAQ,eAAe,EAAE,KAAK,KAAK,IAAI,QAAQ,GAAG,WAAW;AAAA,QAC3D;AAAA,QACA;AAAA,MACF,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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