@expressive/mvc 0.71.0 → 0.72.0

package/dist/esm/instruction/get.js

@@ -1,90 +1,81 @@
+import { enter } from "../control";
 import { Context } from "../context";
-import { createEffect } from "../control";
-import { fetch, METHOD, Model, PARENT, event, update } from "../model";
+import { PARENT, update } from "../state";
 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);
+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)));
       };
-      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}.`);
+        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 {
-        get: arg1 !== false,
+        value: [],
         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);
+    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, next, !isAsync);
+      update(subject, key, value);
     }
-    return () => {
-      if (!proxy) {
-        source(connect);
-        isAsync = true;
-      }
-      if (STALE.delete(compute))
-        compute();
-      return fetch(subject, key, !proxy);
+    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"]
}

+//# 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"]
}


package/dist/esm/instruction/ref.js

@@ -1,5 +1,5 @@
 import { addListener, enter } from "../control";
-import { update } from "../model";
+import { update } from "../state";
 import { use } from "./use";
 const { defineProperty, defineProperties } = Object;
 function ref(arg, arg2) {
@@ -7,54 +7,57 @@ function ref(arg, arg2) {
     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);
+      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'");
+      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;
+        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);
+          if (typeof out == "function") out(key2);
           flush();
         };
       };
       state[key] = null;
-      value = defineProperties({ get, key, is: subject }, {
-        current: { get, set }
+      value = defineProperty({ get, key, is: subject }, "current", {
+        get,
+        set
       });
     }
     defineProperty(subject, key, { value });
@@ -63,4 +66,4 @@ function ref(arg, arg2) {
 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"]
}

+//# 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"]
}


package/dist/esm/instruction/set.js

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

+//# 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": "AAAA,SAAS,aAAa,OAAO,aAAa;AAC1C,SAAS,QAAQ,OAAO,QAAQ,OAAO,cAAc;AACrD,SAAsB,WAAW;AAEjC,MAAM,QAAQ,oBAAI,QAAoB;AAkFtC,SAAS,IAAa,OAAiB,UAAyB;AAC9D,SAAO,IAAO,CAAC,KAAK,SAAS,UAAU;AACrC,QAAI,OAAO,SAAS;AAClB,YAAM,IAAI;AAAA,QACR,uFAAuF,OAAO,IAAI,GAAG;AAAA,MACvG;AAEF,UAAM,WAAmC,CAAC;AAG1C,QAAI,iBAAiB,SAAS,UAAU,MAAM;AAoB5C,UAASA,WAAT,SAAiB,MAAa;AAC5B,gBAAQ;AAAA,UACN;AAAA,UACA,CAAC,YAAY;AACX,oBAAQ;AAER,gBAAI,EAAE,OAAO,UAAU,MAAM,OAAOC,QAAO,EAAG,CAAAA,SAAQ,CAAC,KAAK;AAE5D,mBAAO,CAAC,cAAc;AACpB,kBAAI,WAAW;AACb,sBAAM,IAAIA,QAAO;AACjB,sBAAM,SAAS,KAAK,IAAI;AAAA,cAC1B;AAAA,YACF;AAAA,UACF;AAAA,UACA;AAAA,QACF;AAAA,MACF,GAESA,WAAT,SAAiB,SAAmB;AAClC,YAAI;AAEJ,YAAI;AACF,iBAAO,OAAO,KAAK,OAAO,OAAO,GAAG;AAAA,QACtC,SAAS,KAAK;AACZ,kBAAQ;AAAA,YACN,iCACE,UAAU,iBAAiB,YAC7B,IAAI,OAAO,IAAI,GAAG;AAAA,UACpB;AAEA,cAAI,QAAS,OAAM;AAEnB,kBAAQ,MAAM,GAAG;AAAA,QACnB;AAEA,eAAO,SAAS,KAAK,MAAM,CAAC,OAAO;AAAA,MACrC;AArCS,oBAAAD,UAmBA,UAAAC;AAtCT,UAAI,OAAO;AACX,UAAI;AAEJ,UAAI,iBAAiB,OAAO;AAC1B,eAAO;AACP,iBAAS;AAAA,MACX,OAAO;AAEL,cAAM,KAAK,OAAO,IAAI,QAAQ,KAAK;AACnC,iBAAU,CAAC,GAAG,MAAM,GAAG,KAAK,GAAG,GAAG,CAAC;AAAA,MACrC;AAGA,YAAM,SAAiB,CAAC,YAAY,QAAQ,IAAI;AAEhD,UAAI;AACJ,UAAI;AACJ,UAAI;AAyCJ,aAAO,MAAM;AACX,YAAI,CAAC,OAAO;AACV,iBAAOD,QAAO;AACd,oBAAU;AAAA,QACZ;AAEA,YAAI,MAAM,OAAOC,QAAO,EAAG,CAAAA,SAAQ;AAEnC,eAAO,OAAO,SAAS,KAAK,CAAC,KAAK;AAAA,MACpC;AAAA,IACF;AAGA,QAAI,OAAO,SAAS,cAAc,iBAAiB,SAAS;AAC1D,UAASC,QAAT,WAAgB;AACd,YAAI,OAAO,SAAS;AAClB,cAAI;AACF,oBAAQ,QAAQ,MAAM,KAAK,SAAS,GAAG,CAAC;AAAA,UAC1C,SAAS,KAAK;AACZ,oBAAQ;AAAA,cACN,gCAAgC,OAAO,IAAI,GAAG;AAAA,YAChD;AACA,kBAAM;AAAA,UACR;AAEF,iBAAS,MAAM,aAAa;AAE5B,cAAMC,OAAM,CAACC,WAAgB,QAAQ,GAAG,IAAIA;AAE5C,YAAI,iBAAiB;AACnB,gBAAM,KAAKD,MAAK,CAAC,UAAU;AACzB,kBAAM,SAAS,GAAG;AAClB,qBAAS,MAAM,MAAM;AACnB,oBAAM;AAAA,YACR;AAAA,UACF,CAAC;AAAA,YACE,CAAAA,KAAI,KAAK;AAEd,YAAI,SAAU,QAAO;AAErB,eAAO,QAAQ,GAAG;AAAA,MACpB;AA3BS,iBAAAD;AA6BT,UAAI,UAAU;AACZ,oBAAY,SAASA,OAAM,IAAI;AAAA,MACjC,OAAO;AACL,iBAAS,MAAMA;AAAA,MACjB;AAAA,IACF,WAAW,UAAU,QAAW;AAC9B,eAAS,QAAQ;AAAA,IACnB;AAEA,QAAI,OAAO,YAAY,YAAY;AACjC,UAAI;AAEJ,eAAS,MAAM,SAAqBE,QAAY,UAAe;AAC7D,cAAM,OAAO,MAAM;AACnB,cAAM,UAAU,SAAS,KAAK,MAAMA,QAAO,QAAQ;AACnD,cAAM,QAAQ,KAAK;AAEnB,YAAI,YAAY,MAAO,QAAO;AAE9B,YAAI,OAAO,SAAS,WAAY,OAAMA,MAAK;AAE3C,gBAAQ,CAAC,SAAY;AACnB,cAAI,OAAO,WAAW,WAAY,SAAQ,IAAI;AAE9C,gBAAM;AAAA,QACR;AAAA,MACF;AAAA,IACF;AACE,eAAS,MAAM,CAACA,WAAU;AACxB,iBAAS,MAAM;AACf,eAAO,SAAS,KAAKA,MAAK;AAAA,MAC5B;AAEF,WAAO;AAAA,EACT,CAAC;AACH;AAEA,SAAS,QAAQ,IAAoB;AAEnC,WAAS,MAAM,KAAc;AAC3B,QAAI,eAAe,QAAS,QAAO,IAAI,KAAK,OAAO;AAAA,QAC9C,OAAM;AAAA,EACb;AAEA,WAAS,UAAe;AACtB,QAAI;AACF,YAAM,SAAS,GAAG;AAElB,aAAO,kBAAkB,UAAU,OAAO,MAAM,KAAK,IAAI;AAAA,IAC3D,SAAS,KAAK;AACZ,aAAO,MAAM,GAAG;AAAA,IAClB;AAAA,EACF;AAEA,SAAO,QAAQ;AACjB;",
  "names": ["connect", "compute", "init", "set", "value"]
}


package/dist/esm/instruction/use.js

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