@expressive/mvc 0.53.5 → 0.54.0

package/dist/esm/context.mjs

@@ -0,0 +1,141 @@
+import { Model, PARENT, define, uid } from "./model";
+const LOOKUP = /* @__PURE__ */ new WeakMap();
+const KEYS = /* @__PURE__ */ new Map();
+function key(T, upstream) {
+  let K = KEYS.get(T);
+  if (!K)
+    KEYS.set(T, K = Symbol(
+      typeof T == "symbol" ? "get " + T.description : String(T)
+    ));
+  return upstream ? key(K) : K;
+}
+function keys(from, upstream) {
+  const keys2 = /* @__PURE__ */ new Set();
+  do {
+    keys2.add(key(from, upstream));
+  } while ((from = Object.getPrototypeOf(from)) !== Model);
+  return keys2;
+}
+class Context {
+  constructor(inputs) {
+    this.layer = /* @__PURE__ */ new Map();
+    this.cleanup = /* @__PURE__ */ new Set();
+    if (inputs)
+      this.include(inputs);
+  }
+  static get(from, callback) {
+    const waiting = LOOKUP.get(from);
+    if (waiting instanceof Context) {
+      if (callback)
+        callback(waiting);
+      return waiting;
+    }
+    if (callback)
+      if (waiting)
+        waiting.push(callback);
+      else
+        LOOKUP.set(from, [callback]);
+  }
+  /** Run callback when a specified type is registered to a **child** context. */
+  has(Type, callback) {
+    define(this, key(Type, true), { value: callback });
+  }
+  /** Find specified type registered to a parent context. Returns undefined if none are found. */
+  get(Type) {
+    const result = this[key(Type)];
+    if (result === null)
+      throw new Error(`Did find ${Type} in context, but multiple were defined.`);
+    return result;
+  }
+  push(inputs) {
+    const next = Object.create(this);
+    next.layer = /* @__PURE__ */ new Map();
+    next.cleanup = /* @__PURE__ */ new Set();
+    if (inputs)
+      next.include(inputs);
+    return next;
+  }
+  pop() {
+    for (const key2 of Object.getOwnPropertySymbols(this))
+      delete this[key2];
+    this.cleanup.forEach((cb) => cb());
+    this.layer.clear();
+  }
+  include(inputs, forEach) {
+    const init = /* @__PURE__ */ new Map();
+    if (typeof inputs == "function" || inputs instanceof Model)
+      inputs = { 0: inputs };
+    Object.entries(inputs).forEach(([K, V]) => {
+      if (Model.is(V) || V instanceof Model)
+        return;
+      if (K && K != V)
+        V = `${V} (as '${K}')`;
+      throw new Error(
+        `Context may only include instance or class \`extends Model\` but got ${V}.`
+      );
+    });
+    for (const key2 in inputs) {
+      const input = inputs[key2];
+      const exists = this.layer.get(key2);
+      if (!exists) {
+        const instance = this.add(input);
+        this.layer.set(key2, input);
+        init.set(instance, true);
+      } else if (exists !== input) {
+        this.pop();
+        this.id = uid();
+        this.include(inputs);
+      }
+    }
+    for (const [model, explicit] of init) {
+      model.set();
+      if (typeof forEach == "function")
+        forEach(model, explicit);
+      else if (forEach && explicit)
+        model.set(forEach);
+      for (const [_key, value] of model)
+        if (PARENT.get(value) === model) {
+          this.add(value, true);
+          init.set(value, false);
+        }
+    }
+  }
+  add(input, implicit) {
+    let T;
+    let I;
+    if (typeof input == "function") {
+      Model.is(input);
+      T = input;
+      I = new input();
+      this.cleanup.add(() => I.set(null));
+    } else {
+      T = input.constructor;
+      I = input;
+    }
+    keys(T, true).forEach((K) => {
+      const result = this[K];
+      if (!result)
+        return;
+      const callback = result(I);
+      if (callback)
+        this.cleanup.add(callback);
+    });
+    keys(T).forEach((K) => {
+      const value = this.hasOwnProperty(K) ? null : I;
+      if (value || this[K] !== I && !implicit)
+        define(this, K, {
+          configurable: true,
+          value
+        });
+    });
+    const waiting = LOOKUP.get(I);
+    if (waiting instanceof Array)
+      waiting.forEach((cb) => cb(this));
+    LOOKUP.set(I, this);
+    return I;
+  }
+}
+export {
+  Context
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/context.ts"],
  "sourcesContent": ["import { Model, PARENT, define, uid } from './model';\n\nconst LOOKUP = new WeakMap<Model, Context | ((got: Context) => void)[]>();\nconst KEYS = new Map<symbol | Model.Type, symbol>();\n\nfunction key(T: Model.Type | symbol, upstream?: boolean): symbol {\n  let K = KEYS.get(T);\n\n  if(!K)\n    KEYS.set(T, K = Symbol(\n      typeof T == \"symbol\" ? \"get \" + T.description : String(T)\n    ));\n  \n  return upstream ? key(K) : K;\n}\n\nfunction keys(from: Model.Type, upstream?: boolean){\n  const keys = new Set<symbol>();\n\n  do {\n    keys.add(key(from, upstream));\n  }\n  while((from = Object.getPrototypeOf(from)) !== Model);\n\n  return keys;\n}\n\ndeclare namespace Context {\n  type Multiple<T extends Model> = {\n    [key: string | number]: Model.Init<T> | T;\n  };\n\n  type Accept<T extends Model = Model> = T | Model.Init<T> | Multiple<T>;\n\n  type ForEach = (added: Model, explicit: boolean) => void;\n\n  type Expect = (model: Model) => (() => void) | void;\n}\n\ninterface Context {\n  [key: symbol]: Model | Context.Expect | null | undefined;\n}\n\nclass Context {\n  static get<T extends Model>(on: Model, callback: ((got: Context) => void)): void;\n  static get<T extends Model>(on: Model): Context | undefined;\n  static get(from: Model, callback?: (got: Context) => void){\n    const waiting = LOOKUP.get(from);\n\n    if(waiting instanceof Context){\n      if(callback)\n        callback(waiting);\n\n      return waiting;\n    }\n\n    if(callback)\n      if(waiting) \n        waiting.push(callback);\n      else \n        LOOKUP.set(from, [callback]);\n  }\n\n  public id!: string;\n\n  protected layer = new Map<string | number, Model | Model.Type>();\n  protected cleanup = new Set<() => void>();\n\n  constructor(inputs?: Context.Accept){\n    if(inputs)\n      this.include(inputs);\n  }\n\n  /** Run callback when a specified type is registered to a **child** context. */\n  public has<T extends Model>(Type: Model.Type<T>, callback: (model: T) => void){\n    define(this, key(Type, true), { value: callback });\n  }\n\n  /** Find specified type registered to a parent context. Returns undefined if none are found. */\n  public get<T extends Model>(Type: Model.Type<T>){\n    const result = this[key(Type)];\n\n    if(result === null)\n      throw new Error(`Did find ${Type} in context, but multiple were defined.`);\n\n    return result as T | undefined;\n  }\n\n  public push(inputs?: Context.Accept){\n    const next = Object.create(this) as this;\n\n    next.layer = new Map();\n    next.cleanup = new Set();\n\n    if(inputs)\n      next.include(inputs);\n\n    return next;\n  }\n\n  public pop(){\n    for(const key of Object.getOwnPropertySymbols(this))\n      delete (this as any)[key];\n\n    this.cleanup.forEach(cb => cb());\n    this.layer.clear();\n  }\n\n  public include<T extends Model>(\n    inputs: Context.Accept<T>,\n    forEach?: Context.ForEach | Model.Assign<T>\n  ){\n    const init = new Map<Model, boolean>();\n\n    if(typeof inputs == \"function\" || inputs instanceof Model)\n      inputs = { 0: inputs };\n\n    Object.entries(inputs).forEach(([K, V]: [string, unknown]) => {\n      if(Model.is(V) || V instanceof Model)\n        return;\n\n      if(K && K != V)\n        V = `${V} (as '${K}')`;\n\n      throw new Error(\n        `Context may only include instance or class \\`extends Model\\` but got ${V}.`\n      );\n    })\n\n    for(const key in inputs){\n      const input = inputs[key];\n      const exists = this.layer.get(key);\n\n      if(!exists){\n        const instance = this.add(input);\n\n        this.layer.set(key, input)\n        init.set(instance, true);\n      }\n      // Context must force-reset because inputs are no longer safe.\n      else if(exists !== input){    \n        this.pop();\n        this.id = uid();\n        this.include(inputs);\n      }\n    } \n\n    for(const [model, explicit] of init){\n      model.set();\n\n      if(typeof forEach == \"function\")\n        forEach(model, explicit);\n      else if(forEach && explicit)\n        model.set(forEach);\n\n      for(const [_key, value] of model)\n        if(PARENT.get(value as Model) === model){\n          this.add(value as Model, true);\n          init.set(value as Model, false);\n        }\n    }\n  }\n\n  protected add<T extends Model>(\n    input: T | Model.Init<T>,\n    implicit?: boolean){\n\n    let T: Model.Type<T>;\n    let I: T;\n\n    if(typeof input == \"function\"){\n      Model.is(input);\n\n      T = input;\n      I = new input() as T;\n      this.cleanup.add(() => I.set(null));\n    }\n    else {\n      T = input.constructor as Model.Type<T>;\n      I = input;\n    }\n\n    keys(T, true).forEach(K => {\n      const result = this[K] as Context.Expect | undefined;\n  \n      if(!result)\n        return;\n  \n      const callback = result(I);\n        \n      if(callback)\n        this.cleanup.add(callback);\n    });\n\n    keys(T).forEach(K => {\n      const value = this.hasOwnProperty(K) ? null : I;\n\n      if(value || this[K] !== I && !implicit)\n        define(this, K, {\n          configurable: true,\n          value\n        });\n    });\n\n    const waiting = LOOKUP.get(I);\n  \n    if(waiting instanceof Array)\n      waiting.forEach(cb => cb(this));\n\n    LOOKUP.set(I, this);\n\n    return I;\n  }\n}\n\nexport { Context }"],
  "mappings": "AAAA,SAAS,OAAO,QAAQ,QAAQ,WAAW;AAE3C,MAAM,SAAS,oBAAI,QAAqD;AACxE,MAAM,OAAO,oBAAI,IAAiC;AAElD,SAAS,IAAI,GAAwB,UAA4B;AAC/D,MAAI,IAAI,KAAK,IAAI,CAAC;AAElB,MAAG,CAAC;AACF,SAAK,IAAI,GAAG,IAAI;AAAA,MACd,OAAO,KAAK,WAAW,SAAS,EAAE,cAAc,OAAO,CAAC;AAAA,IAC1D,CAAC;AAEH,SAAO,WAAW,IAAI,CAAC,IAAI;AAC7B;AAEA,SAAS,KAAK,MAAkB,UAAmB;AACjD,QAAMA,QAAO,oBAAI,IAAY;AAE7B,KAAG;AACD,IAAAA,MAAK,IAAI,IAAI,MAAM,QAAQ,CAAC;AAAA,EAC9B,UACO,OAAO,OAAO,eAAe,IAAI,OAAO;AAE/C,SAAOA;AACT;AAkBA,MAAM,QAAQ;AAAA,EAyBZ,YAAY,QAAwB;AAHpC,SAAU,QAAQ,oBAAI,IAAyC;AAC/D,SAAU,UAAU,oBAAI,IAAgB;AAGtC,QAAG;AACD,WAAK,QAAQ,MAAM;AAAA,EACvB;AAAA,EAzBA,OAAO,IAAI,MAAa,UAAkC;AACxD,UAAM,UAAU,OAAO,IAAI,IAAI;AAE/B,QAAG,mBAAmB,SAAQ;AAC5B,UAAG;AACD,iBAAS,OAAO;AAElB,aAAO;AAAA,IACT;AAEA,QAAG;AACD,UAAG;AACD,gBAAQ,KAAK,QAAQ;AAAA;AAErB,eAAO,IAAI,MAAM,CAAC,QAAQ,CAAC;AAAA,EACjC;AAAA;AAAA,EAaO,IAAqB,MAAqB,UAA6B;AAC5E,WAAO,MAAM,IAAI,MAAM,IAAI,GAAG,EAAE,OAAO,SAAS,CAAC;AAAA,EACnD;AAAA;AAAA,EAGO,IAAqB,MAAoB;AAC9C,UAAM,SAAS,KAAK,IAAI,IAAI,CAAC;AAE7B,QAAG,WAAW;AACZ,YAAM,IAAI,MAAM,YAAY,IAAI,yCAAyC;AAE3E,WAAO;AAAA,EACT;AAAA,EAEO,KAAK,QAAwB;AAClC,UAAM,OAAO,OAAO,OAAO,IAAI;AAE/B,SAAK,QAAQ,oBAAI,IAAI;AACrB,SAAK,UAAU,oBAAI,IAAI;AAEvB,QAAG;AACD,WAAK,QAAQ,MAAM;AAErB,WAAO;AAAA,EACT;AAAA,EAEO,MAAK;AACV,eAAUC,QAAO,OAAO,sBAAsB,IAAI;AAChD,aAAQ,KAAaA,IAAG;AAE1B,SAAK,QAAQ,QAAQ,QAAM,GAAG,CAAC;AAC/B,SAAK,MAAM,MAAM;AAAA,EACnB;AAAA,EAEO,QACL,QACA,SACD;AACC,UAAM,OAAO,oBAAI,IAAoB;AAErC,QAAG,OAAO,UAAU,cAAc,kBAAkB;AAClD,eAAS,EAAE,GAAG,OAAO;AAEvB,WAAO,QAAQ,MAAM,EAAE,QAAQ,CAAC,CAAC,GAAG,CAAC,MAAyB;AAC5D,UAAG,MAAM,GAAG,CAAC,KAAK,aAAa;AAC7B;AAEF,UAAG,KAAK,KAAK;AACX,YAAI,GAAG,CAAC,SAAS,CAAC;AAEpB,YAAM,IAAI;AAAA,QACR,wEAAwE,CAAC;AAAA,MAC3E;AAAA,IACF,CAAC;AAED,eAAUA,QAAO,QAAO;AACtB,YAAM,QAAQ,OAAOA,IAAG;AACxB,YAAM,SAAS,KAAK,MAAM,IAAIA,IAAG;AAEjC,UAAG,CAAC,QAAO;AACT,cAAM,WAAW,KAAK,IAAI,KAAK;AAE/B,aAAK,MAAM,IAAIA,MAAK,KAAK;AACzB,aAAK,IAAI,UAAU,IAAI;AAAA,MACzB,WAEQ,WAAW,OAAM;AACvB,aAAK,IAAI;AACT,aAAK,KAAK,IAAI;AACd,aAAK,QAAQ,MAAM;AAAA,MACrB;AAAA,IACF;AAEA,eAAU,CAAC,OAAO,QAAQ,KAAK,MAAK;AAClC,YAAM,IAAI;AAEV,UAAG,OAAO,WAAW;AACnB,gBAAQ,OAAO,QAAQ;AAAA,eACjB,WAAW;AACjB,cAAM,IAAI,OAAO;AAEnB,iBAAU,CAAC,MAAM,KAAK,KAAK;AACzB,YAAG,OAAO,IAAI,KAAc,MAAM,OAAM;AACtC,eAAK,IAAI,OAAgB,IAAI;AAC7B,eAAK,IAAI,OAAgB,KAAK;AAAA,QAChC;AAAA,IACJ;AAAA,EACF;AAAA,EAEU,IACR,OACA,UAAmB;AAEnB,QAAI;AACJ,QAAI;AAEJ,QAAG,OAAO,SAAS,YAAW;AAC5B,YAAM,GAAG,KAAK;AAEd,UAAI;AACJ,UAAI,IAAI,MAAM;AACd,WAAK,QAAQ,IAAI,MAAM,EAAE,IAAI,IAAI,CAAC;AAAA,IACpC,OACK;AACH,UAAI,MAAM;AACV,UAAI;AAAA,IACN;AAEA,SAAK,GAAG,IAAI,EAAE,QAAQ,OAAK;AACzB,YAAM,SAAS,KAAK,CAAC;AAErB,UAAG,CAAC;AACF;AAEF,YAAM,WAAW,OAAO,CAAC;AAEzB,UAAG;AACD,aAAK,QAAQ,IAAI,QAAQ;AAAA,IAC7B,CAAC;AAED,SAAK,CAAC,EAAE,QAAQ,OAAK;AACnB,YAAM,QAAQ,KAAK,eAAe,CAAC,IAAI,OAAO;AAE9C,UAAG,SAAS,KAAK,CAAC,MAAM,KAAK,CAAC;AAC5B,eAAO,MAAM,GAAG;AAAA,UACd,cAAc;AAAA,UACd;AAAA,QACF,CAAC;AAAA,IACL,CAAC;AAED,UAAM,UAAU,OAAO,IAAI,CAAC;AAE5B,QAAG,mBAAmB;AACpB,cAAQ,QAAQ,QAAM,GAAG,IAAI,CAAC;AAEhC,WAAO,IAAI,GAAG,IAAI;AAElB,WAAO;AAAA,EACT;AACF;",
  "names": ["keys", "key"]
}


package/dist/esm/control.mjs

@@ -0,0 +1,189 @@
+const onReady = () => null;
+const LISTENERS = /* @__PURE__ */ new WeakMap();
+const PENDING = /* @__PURE__ */ new WeakMap();
+const PENDING_KEYS = /* @__PURE__ */ new WeakMap();
+const DISPATCH = /* @__PURE__ */ new Set();
+const OBSERVER = /* @__PURE__ */ new WeakMap();
+function addListener(subject, callback, select) {
+  let listeners = LISTENERS.get(subject);
+  if (!listeners)
+    LISTENERS.set(subject, listeners = /* @__PURE__ */ new Map([[onReady, void 0]]));
+  const filter = select === void 0 ? void 0 : /* @__PURE__ */ new Set([select]);
+  if (!listeners.has(onReady) && !filter)
+    callback.call(subject, true, subject);
+  listeners.set(callback, filter);
+  return () => listeners.delete(callback);
+}
+function emit(model, key) {
+  const listeners = LISTENERS.get(model);
+  const notReady = listeners.has(onReady);
+  if (key === true && !notReady)
+    return;
+  let pending2 = PENDING.get(model);
+  if (pending2) {
+    pending2.add(key);
+    return;
+  }
+  PENDING.set(model, pending2 = new Set(notReady ? [true, key] : [key]));
+  for (const key2 of pending2)
+    for (const [callback, filter] of listeners)
+      if (!filter || filter.has(key2)) {
+        const after = callback.call(model, key2, model);
+        if (after)
+          enqueue(after);
+        else if (after === null)
+          listeners.delete(callback);
+      }
+  if (key === null)
+    listeners.clear();
+  PENDING.delete(model);
+}
+function event(subject, key, silent) {
+  if (key === null)
+    return emit(subject, key);
+  if (!key)
+    return emit(subject, true);
+  let pending2 = PENDING_KEYS.get(subject);
+  if (!pending2) {
+    PENDING_KEYS.set(subject, pending2 = /* @__PURE__ */ new Set());
+    if (!silent)
+      enqueue(() => {
+        emit(subject, false);
+        PENDING_KEYS.delete(subject);
+      });
+  }
+  pending2.add(key);
+  if (!silent)
+    emit(subject, key);
+}
+function pending(subject) {
+  if (PENDING_KEYS.has(subject))
+    return {
+      then: (res) => new Promise((res2) => {
+        const remove = addListener(subject, (key) => {
+          if (key !== true) {
+            remove();
+            return res2.bind(null, Array.from(PENDING_KEYS.get(subject)));
+          }
+        });
+      }).then(res)
+    };
+}
+function enqueue(eventHandler) {
+  if (!DISPATCH.size)
+    setTimeout(() => {
+      DISPATCH.forEach((event2) => {
+        try {
+          event2();
+        } catch (err) {
+          console.error(err);
+        }
+      });
+      DISPATCH.clear();
+    }, 0);
+  DISPATCH.add(eventHandler);
+}
+function createProxy(from, observer) {
+  const proxy = Object.create(from);
+  OBSERVER.set(proxy, observer);
+  return proxy;
+}
+function watch(from, key, value) {
+  const access = OBSERVER.get(from);
+  return access ? access(from, key, value) : value;
+}
+function createEffect(target, callback, argument) {
+  const listeners = LISTENERS.get(target);
+  let unset;
+  let reset;
+  function invoke() {
+    let stale;
+    const subscriber = createProxy(target, access);
+    LISTENERS.set(subscriber, listeners);
+    function onUpdate() {
+      if (stale)
+        return null;
+      stale = true;
+      if (reset && unset) {
+        unset(true);
+        unset = void 0;
+      }
+      return reset;
+    }
+    function access(from, key, value) {
+      if (value === void 0 && argument)
+        throw new Error(`${from}.${key} is required in this context.`);
+      const listeners2 = LISTENERS.get(from);
+      let listener = listeners2.get(onUpdate);
+      if (!listener)
+        listeners2.set(onUpdate, listener = /* @__PURE__ */ new Set());
+      listener.add(key);
+      const nested = LISTENERS.get(value);
+      if (nested)
+        LISTENERS.set(
+          value = createProxy(value, access),
+          nested
+        );
+      return value;
+    }
+    try {
+      const ctx = context(argument === false);
+      const ret = callback.call(subscriber, subscriber);
+      const flush = ctx();
+      reset = ret === null ? null : invoke;
+      unset = (key) => {
+        if (typeof ret == "function")
+          ret(key);
+        flush();
+      };
+    } catch (err) {
+      if (err instanceof Promise) {
+        reset = void 0;
+        err.then(invoke);
+      } else
+        throw err;
+    }
+  }
+  function cleanup() {
+    if (unset)
+      unset(false);
+    reset = null;
+  }
+  ;
+  if (EffectContext && argument !== false)
+    EffectContext.add(cleanup);
+  addListener(target, (key) => {
+    if (key === true)
+      invoke();
+    else if (!reset)
+      return reset;
+    if (key === null && unset)
+      unset(null);
+  });
+  return cleanup;
+}
+let EffectContext;
+function context(ignore) {
+  if (ignore)
+    return () => () => {
+    };
+  const current = EffectContext;
+  const ctx = EffectContext = /* @__PURE__ */ new Set();
+  return () => {
+    EffectContext = current;
+    return () => {
+      ctx.forEach((fn) => fn());
+    };
+  };
+}
+export {
+  PENDING_KEYS,
+  addListener,
+  context,
+  createEffect,
+  createProxy,
+  event,
+  pending,
+  watch
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/control.ts"],
  "sourcesContent": ["import type { Model } from \"./model\";\n\n/**\n * Update callback function.\n * \n * @param key -\n *   - `string` - property which has updated.\n *   - `false` - a normal update has completed.\n *   - `true` - initial event; instance is ready.\n *   - `null` - terminal event; instance is expired.\n * @param source - Instance of Model for which update has occured.\n */\ntype OnUpdate<T extends Model = any> = \n  (this: T, key: unknown, source: T) => (() => void) | null | void;\n\ntype OnAccess<T extends Model = any, R = unknown> =\n  (from: T, key: string | number, value: R) => unknown;\n\ntype Effect<T extends Model> = (this: T, proxy: T) =>\n  ((update: boolean | null) => void) | Promise<void> | null | void;\n\ntype Event = number | string | null | boolean | symbol;\n\n/** Placeholder event determines if model is initialized or not. */\nconst onReady = () => null;\n\nconst LISTENERS = new WeakMap<Model, Map<OnUpdate, Set<Event> | undefined>>();\n\n/** Events pending for a given object. */\nconst PENDING = new WeakMap<Model, Set<Event>>();\n\n/** Update register. */\nconst PENDING_KEYS = new WeakMap<Model, Set<string | number | symbol>>();\n\n/** Central event dispatch. Bunches all updates to occur at same time. */\nconst DISPATCH = new Set<() => void>();\n\nconst OBSERVER = new WeakMap<Model, OnAccess>();\n\nfunction addListener<T extends Model>(subject: T, callback: OnUpdate<T>, select?: Event){\n  let listeners = LISTENERS.get(subject)!;\n\n  if(!listeners)\n    LISTENERS.set(subject, listeners = new Map([[onReady, undefined]]));\n\n  const filter = select === undefined ? undefined : new Set([select]);\n\n  if(!listeners.has(onReady) && !filter)\n    callback.call(subject, true, subject);\n\n  listeners.set(callback, filter);\n\n  return () => listeners.delete(callback);\n}\n\nfunction emit(model: Model, key: Event): void {\n  const listeners = LISTENERS.get(model)!;\n  const notReady = listeners.has(onReady);\n\n  if(key === true && !notReady)\n    return;\n\n  let pending = PENDING.get(model);\n\n  if(pending){\n    pending.add(key);\n    return;\n  }\n\n  PENDING.set(model, pending = new Set(notReady ? [true, key] : [key]));\n\n  for(const key of pending)\n    for(const [callback, filter] of listeners)\n      if(!filter || filter.has(key)){\n        const after = callback.call(model, key, model);\n\n        if(after)\n          enqueue(after);\n\n        else if(after === null)\n          listeners.delete(callback);\n      }\n\n  if(key === null)\n    listeners.clear();\n  \n  PENDING.delete(model);\n}\n\nfunction event(\n  subject: Model,\n  key?: string | number | symbol | null,\n  silent?: boolean){\n\n  if(key === null)\n    return emit(subject, key);\n\n  if(!key)\n    return emit(subject, true);\n\n  let pending = PENDING_KEYS.get(subject);\n\n  if(!pending){\n    PENDING_KEYS.set(subject, pending = new Set());\n\n    if(!silent)\n      enqueue(() => {\n        emit(subject, false);\n        PENDING_KEYS.delete(subject)\n      })\n  }\n\n  pending.add(key);\n\n  if(!silent)\n    emit(subject, key);\n}\n\nfunction pending<T extends Model>(subject: T){\n  if(PENDING_KEYS.has(subject))\n    return <PromiseLike<Model.Event<T>[]>> {\n      then: (res) => new Promise<any>(res => {\n        const remove = addListener(subject, key => {\n          if(key !== true){\n            remove();\n            return res.bind(null, Array.from(PENDING_KEYS.get(subject)!));\n          }\n        });\n      }).then(res)\n    }\n}\n\nfunction enqueue(eventHandler: (() => void)){\n  if(!DISPATCH.size)\n    setTimeout(() => {\n      DISPATCH.forEach(event => {\n        try {\n          event();\n        }\n        catch(err){\n          console.error(err);\n        }\n      });\n      DISPATCH.clear();\n    }, 0);\n\n  DISPATCH.add(eventHandler);\n}\n\nfunction createProxy<T extends Model>(from: T, observer: OnAccess<T>){\n  const proxy = Object.create(from) as T;\n  OBSERVER.set(proxy, observer);\n  return proxy;\n}\n\nfunction watch(from: any, key: string | number, value?: any){\n  const access = OBSERVER.get(from);\n  return access ? access(from, key, value) : value;\n}\n\n/**\n * Create a side-effect which will update whenever values accessed change.\n * Callback is called immediately and whenever values are stale.\n * \n * @param target - Instance of Model to observe.\n * @param callback - Function to invoke when values change.\n * @param requireValues - If `true` will throw if accessing a value which is `undefined`.\n */\nfunction createEffect<T extends Model>(target: T, callback: Effect<Required<T>>, requireValues: true): () => void;\nfunction createEffect<T extends Model>(target: T, callback: Effect<T>, recursive?: boolean): () => void;\nfunction createEffect<T extends Model>(target: T, callback: Effect<T>, argument?: boolean){\n  const listeners = LISTENERS.get(target)!;\n\n  let unset: ((update: boolean | null) => void) | undefined;\n  let reset: (() => void) | null | undefined;\n\n  function invoke(){\n    let stale: boolean | undefined;\n\n    const subscriber = createProxy(target, access);\n\n    LISTENERS.set(subscriber, listeners);\n\n    function onUpdate() {\n      if (stale)\n        return null;\n\n      stale = true;\n\n      if (reset && unset) {\n        unset(true);\n        unset = undefined;\n      }\n\n      return reset;\n    }\n\n    function access(from: Model, key: string | number, value: any) {\n      if(value === undefined && argument)\n        throw new Error(`${from}.${key} is required in this context.`);\n\n      const listeners = LISTENERS.get(from)!;\n      let listener = listeners.get(onUpdate);\n\n      if(!listener)\n        listeners.set(onUpdate, listener = new Set);\n\n      listener.add(key);\n\n      const nested = LISTENERS.get(value);\n\n      if(nested)\n        LISTENERS.set(\n          value = createProxy(value, access),\n          nested\n        );\n\n      return value;\n    }\n\n    try {\n      const ctx = context(argument === false)\n      const ret = callback.call(subscriber, subscriber);\n      const flush = ctx();\n\n      reset = ret === null ? null : invoke;\n      unset = key => {\n        if(typeof ret == \"function\")\n          ret(key);\n\n        flush();\n      }\n    }\n    catch(err){\n      if(err instanceof Promise){\n        reset = undefined;\n        err.then(invoke);\n      }\n      else\n        throw err;\n    }\n  }\n\n  function cleanup(){\n    if(unset)\n      unset(false);\n\n    reset = null;\n  };\n\n  if(EffectContext && argument !== false)\n    EffectContext.add(cleanup);\n\n  addListener(target, key => {\n    if(key === true)\n      invoke();\n\n    else if(!reset)\n      return reset;\n\n    if(key === null && unset)\n      unset(null);\n  });\n  \n  return cleanup;\n}\n\nlet EffectContext: Set<() => void> | undefined;\n\nexport function context(ignore?: boolean){\n  if(ignore)\n    return () => () => {};\n\n  const current = EffectContext;\n  const ctx = EffectContext = new Set;\n\n  return () => {\n    EffectContext = current;\n    \n    return () => {\n      ctx.forEach(fn => fn());\n    }\n  }\n}\n\nexport {\n  addListener,\n  createEffect,\n  createProxy,\n  event,\n  OnUpdate,\n  PENDING_KEYS,\n  pending,\n  watch\n}"],
  "mappings": "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",
  "names": ["pending", "key", "res", "event", "listeners"]
}


package/dist/esm/index.mjs

@@ -0,0 +1,22 @@
+import { get } from "./instruction/get";
+import { ref } from "./instruction/ref";
+import { set } from "./instruction/set";
+import { use } from "./instruction/use";
+import { has } from "./instruction/has";
+import { Model, Model as Model2 } from "./model";
+import { createEffect, createProxy, addListener } from "./control";
+import { Context } from "./context";
+export {
+  Context,
+  Model,
+  addListener,
+  createEffect,
+  createProxy,
+  Model2 as default,
+  get,
+  has,
+  ref,
+  set,
+  use
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vc3JjL2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyJleHBvcnQgeyBnZXQgfSBmcm9tICcuL2luc3RydWN0aW9uL2dldCc7XG5leHBvcnQgeyByZWYgfSBmcm9tICcuL2luc3RydWN0aW9uL3JlZic7XG5leHBvcnQgeyBzZXQgfSBmcm9tICcuL2luc3RydWN0aW9uL3NldCc7XG5leHBvcnQgeyB1c2UgfSBmcm9tICcuL2luc3RydWN0aW9uL3VzZSc7XG5leHBvcnQgeyBoYXMgfSBmcm9tICcuL2luc3RydWN0aW9uL2hhcyc7XG5cbmV4cG9ydCB7IE1vZGVsLCBNb2RlbCBhcyBkZWZhdWx0IH0gZnJvbSAnLi9tb2RlbCc7XG5leHBvcnQgeyBjcmVhdGVFZmZlY3QsIGNyZWF0ZVByb3h5LCBhZGRMaXN0ZW5lciB9IGZyb20gJy4vY29udHJvbCc7XG5leHBvcnQgeyBDb250ZXh0IH0gZnJvbSAnLi9jb250ZXh0JzsiXSwKICAibWFwcGluZ3MiOiAiQUFBQSxTQUFTLFdBQVc7QUFDcEIsU0FBUyxXQUFXO0FBQ3BCLFNBQVMsV0FBVztBQUNwQixTQUFTLFdBQVc7QUFDcEIsU0FBUyxXQUFXO0FBRXBCLFNBQVMsT0FBZ0IsU0FBVEEsY0FBd0I7QUFDeEMsU0FBUyxjQUFjLGFBQWEsbUJBQW1CO0FBQ3ZELFNBQVMsZUFBZTsiLAogICJuYW1lcyI6IFsiTW9kZWwiXQp9Cg==

package/dist/esm/instruction/get.mjs

@@ -0,0 +1,87 @@
+import { Context } from "../context";
+import { createEffect } from "../control";
+import { fetch, METHOD, Model, PARENT, event, update } from "../model";
+import { use } from "./use";
+const STALE = /* @__PURE__ */ new WeakSet();
+function get(arg0, arg1) {
+  return use((key, subject, state) => {
+    if (typeof arg0 == "symbol")
+      throw new Error(`Attempted to use an instruction result (probably use or get) as computed source for ${subject}.${key}. This is not allowed.`);
+    if (Model.is(arg0)) {
+      let assign2 = function(value) {
+        if (typeof arg1 == "function")
+          value.get((x) => arg1(x, key));
+        update(subject, key, value);
+      };
+      var assign = assign2;
+      const hasParent = PARENT.get(subject);
+      if (!hasParent) {
+        if (arg1 === true)
+          throw new Error(`${subject} may only exist as a child of type ${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}.`);
+        });
+      } else if (!arg0 || hasParent instanceof arg0)
+        assign2(hasParent);
+      else
+        throw new Error(`New ${subject} created as child of ${hasParent}, but must be instanceof ${arg0}.`);
+      return {
+        get: arg1 !== false
+      };
+    }
+    let from = subject;
+    if (arg0 instanceof Model) {
+      from = arg0;
+    } else {
+      const fn = METHOD.get(arg0) || arg0;
+      arg1 = (p, k) => fn.call(p, k, p);
+    }
+    const source = (resolve) => resolve(from);
+    const getter = arg1;
+    let reset;
+    let isAsync;
+    let proxy;
+    function connect(model) {
+      reset = createEffect(model, (current) => {
+        proxy = current;
+        if (!(key in state) || STALE.delete(compute))
+          compute(!reset);
+        return (didUpdate) => {
+          if (didUpdate) {
+            STALE.add(compute);
+            event(subject, key, true);
+          }
+        };
+      }, false);
+    }
+    function compute(initial) {
+      let next;
+      try {
+        next = getter.call(proxy, proxy, key);
+      } catch (err) {
+        console.warn(`An exception was thrown while ${initial ? "initializing" : "refreshing"} ${subject}.${key}.`);
+        if (initial)
+          throw err;
+        console.error(err);
+      }
+      update(subject, key, next, !isAsync);
+    }
+    return () => {
+      if (!proxy) {
+        source(connect);
+        isAsync = true;
+      }
+      if (STALE.delete(compute))
+        compute();
+      return fetch(subject, key, !proxy);
+    };
+  });
+}
+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>, asParent?: 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){\n        if(arg1 === true)\n          throw new Error(`${subject} may only exist as a child of type ${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      else if(!arg0 || hasParent instanceof arg0)\n        assign(hasParent);\n      else\n        throw new Error(`New ${subject} created as child of ${hasParent}, but must be instanceof ${arg0}.`);\n\n      return {\n        get: arg1 !== 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,WAAU;AACZ,YAAG,SAAS;AACV,gBAAM,IAAI,MAAM,GAAG,OAAO,sCAAsC,IAAI,GAAG;AAEzE,gBAAQ,IAAI,SAAS,CAAC,YAAY;AAChC,gBAAM,QAAQ,QAAQ,IAAI,IAAI;AAE9B,cAAG;AACD,YAAAA,QAAO,KAAK;AAAA,mBACN,SAAS;AACf,kBAAM,IAAI,MAAM,YAAY,IAAI,6BAA6B,OAAO,GAAG;AAAA,QAC3E,CAAC;AAAA,MACH,WACQ,CAAC,QAAQ,qBAAqB;AACpC,QAAAA,QAAO,SAAS;AAAA;AAEhB,cAAM,IAAI,MAAM,OAAO,OAAO,wBAAwB,SAAS,4BAA4B,IAAI,GAAG;AAEpG,aAAO;AAAA,QACL,KAAK,SAAS;AAAA,MAChB;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"]
}


package/dist/esm/instruction/has.mjs

@@ -0,0 +1,76 @@
+import { Context } from "../context";
+import { Model, update } from "../model";
+import { use } from "./use";
+const APPLY = /* @__PURE__ */ new WeakMap();
+function has(arg1, arg2) {
+  return use((key, subject) => {
+    const applied = /* @__PURE__ */ new Set();
+    const apply = () => {
+      update(subject, key, Object.freeze(Array.from(applied)));
+    };
+    if (Model.is(arg1))
+      Context.get(subject, (context) => {
+        context.has(arg1, (model) => {
+          let remove;
+          let disconnect;
+          if (applied.has(model))
+            return;
+          const callback = APPLY.get(model);
+          if (callback) {
+            const after = callback(subject);
+            if (after === false)
+              return;
+            if (typeof after == "function")
+              disconnect = after;
+          }
+          if (typeof arg2 == "function") {
+            const done2 = arg2(model, subject);
+            if (done2 === false)
+              return false;
+            remove = () => {
+              if (typeof done2 == "function")
+                done2();
+            };
+          }
+          applied.add(model);
+          apply();
+          const done = () => {
+            ignore();
+            applied.delete(model);
+            apply();
+            if (disconnect)
+              disconnect();
+            if (typeof remove == "function")
+              remove();
+          };
+          const ignore = model.get(null, done);
+          return done;
+        });
+      });
+    else {
+      if (APPLY.has(subject))
+        throw new Error(`'has' callback can only be used once per model.`);
+      APPLY.set(subject, (recipient) => {
+        let remove;
+        if (arg1) {
+          remove = arg1(recipient, subject);
+          if (remove === false)
+            return false;
+        }
+        applied.add(recipient);
+        apply();
+        return () => {
+          applied.delete(recipient);
+          apply();
+          if (typeof remove == "function")
+            remove();
+        };
+      });
+    }
+    return { value: [] };
+  });
+}
+export {
+  has
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/instruction/ref.mjs

@@ -0,0 +1,62 @@
+import { context } from "../control";
+import { define, update } from "../model";
+import { use } from "./use";
+function ref(arg, arg2) {
+  return use((key, subject, state) => {
+    let value = {};
+    if (arg === subject)
+      subject.get(() => {
+        for (const key2 in state)
+          if (typeof arg2 == "function")
+            define(value, key2, {
+              configurable: true,
+              get() {
+                const out = arg2(key2);
+                define(value, key2, { value: out });
+                return out;
+              }
+            });
+          else {
+            const get = () => state[key2];
+            const set = (value2) => {
+              update(subject, key2, value2);
+            };
+            define(set, "current", { get, set });
+            define(set, "get", { value: get });
+            define(value, key2, { value: set });
+          }
+      });
+    else if (typeof arg == "object")
+      throw new Error("ref instruction does not support object which is not 'this'");
+    else {
+      let unset;
+      const get = () => state[key];
+      const set = (value2) => {
+        if (!update(subject, key, value2) || !arg)
+          return;
+        if (unset)
+          unset = void unset(value2);
+        if (value2 === null && arg2 !== false)
+          return;
+        const ctx = context();
+        const out = arg.call(subject, value2);
+        const flush = ctx();
+        unset = (key2) => {
+          if (typeof out == "function")
+            out(key2);
+          flush();
+        };
+      };
+      state[key] = null;
+      value = Object.defineProperties(set, {
+        current: { get, set },
+        get: { value: get }
+      });
+    }
+    define(subject, key, { value });
+  });
+}
+export {
+  ref
+};
+//# sourceMappingURL=data:application/json;base64,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