@expressive/mvc 0.63.6 → 0.64.0

package/dist/esm/model.js

@@ -1,4 +1,4 @@
-import { addListener, createEffect, event, pending, PENDING_KEYS, watch } from "./control";
+import { addListener, createEffect, event, Observable, PENDING_KEYS } from "./control";
 const define = Object.defineProperty;
 const ID = /* @__PURE__ */ new WeakMap();
 const STATE = /* @__PURE__ */ new WeakMap();
@@ -12,14 +12,28 @@ class Model {
     define(this, "is", { value: this });
     init(this, args);
   }
+  [Observable](callback, required) {
+    const watch2 = /* @__PURE__ */ new Set();
+    const proxy = Object.create(this);
+    addListener(this, callback, watch2);
+    OBSERVER.set(proxy, (key, value) => {
+      if (value === void 0 && required)
+        throw new Error(`${this}.${key} is required in this context.`);
+      watch2.add(key);
+      if (value instanceof Object && Observable in value)
+        return value[Observable](callback, required);
+      return value;
+    });
+    return proxy;
+  }
   get(arg1, arg2) {
     const self = this.is;
     if (typeof arg1 == "function") {
-      let pending2 = /* @__PURE__ */ new Set();
+      let pending = /* @__PURE__ */ new Set();
       return createEffect(self, (proxy) => {
-        const cb = arg1.call(proxy, proxy, pending2);
+        const cb = arg1.call(proxy, proxy, pending);
         return cb === null ? null : (update2) => {
-          pending2 = PENDING_KEYS.get(self);
+          pending = PENDING_KEYS.get(self);
           if (typeof cb == "function")
             cb(update2);
         };
@@ -27,23 +41,33 @@ class Model {
     }
     return arg1 === void 0 ? snapshot(self) : typeof arg2 == "function" ? addListener(self, arg2, arg1) : arg1 === null ? Object.isFrozen(STATE.get(self)) : fetch(self, arg1, arg2);
   }
-  set(arg1, arg2) {
+  set(arg1, arg2, arg3) {
     const self = this.is;
     if (typeof arg1 == "function")
       return addListener(self, (key) => {
-        if (typeof key == "string")
+        if (arg2 === key || arg2 === void 0 && typeof key == "string")
           return arg1.call(self, key, self);
       });
-    if (typeof arg2 == "function")
-      return addListener(self, (key) => {
-        if (key === arg1)
-          return arg2.call(self, key, self);
-      });
     if (arg1 && typeof arg1 == "object")
       assign(self, arg1, arg2 === true);
-    else
+    else if (!arg2)
       event(self, arg1);
-    return pending(self);
+    else if (arg3)
+      manage(self, arg1, arg2);
+    else
+      update(self, arg1, arg2);
+    const pending = PENDING_KEYS.get(this);
+    if (pending)
+      return {
+        then: (res) => new Promise((res2) => {
+          const remove = addListener(this, (key) => {
+            if (key !== true) {
+              remove();
+              return res2.bind(null, Array.from(pending));
+            }
+          });
+        }).then(res)
+      };
   }
   /**
    * Iterate over managed properties in this instance of Model.
@@ -103,7 +127,7 @@ function assign(subject, data, silent) {
     else if (key in subject && key !== "is") {
       const desc = Object.getOwnPropertyDescriptor(subject, key);
       const set = desc && desc.set;
-      set.call(subject, data[key], silent === true);
+      set.call(subject, data[key], silent);
     }
   }
 }
@@ -161,26 +185,10 @@ function init(model, args) {
       PARENT.set(model, null);
     for (const key in model) {
       const desc = Object.getOwnPropertyDescriptor(model, key);
-      if ("value" in desc) {
-        let set2 = function(value, silent) {
-          update(model, key, value, silent);
-          if (value instanceof Model && !PARENT.has(value)) {
-            PARENT.set(value, model);
-            event(value);
-          }
-        };
-        var set = set2;
-        set2(desc.value, true);
-        define(model, key, {
-          configurable: false,
-          set: set2,
-          get() {
-            return watch(this, key, state[key]);
-          }
-        });
-      }
+      if ("value" in desc)
+        manage(model, key, desc.value, true);
     }
-    args.forEach((arg) => {
+    for (const arg of args) {
       const use = typeof arg == "function" ? arg.call(model, model) : arg;
       if (use instanceof Promise)
         use.catch((err) => {
@@ -191,7 +199,7 @@ function init(model, args) {
         addListener(model, use, null);
       else if (typeof use == "object")
         assign(model, use, true);
-    });
+    }
     addListener(model, () => {
       for (const [_, value] of model)
         if (value instanceof Model && PARENT.get(value) === model)
@@ -201,6 +209,26 @@ function init(model, args) {
     return null;
   });
 }
+function manage(target, key, value, silent) {
+  const state = STATE.get(target);
+  function get() {
+    return watch(this, key, state[key]);
+  }
+  function set(value2, silent2) {
+    update(target, key, value2, silent2);
+    if (value2 instanceof Model && !PARENT.has(value2)) {
+      PARENT.set(value2, target);
+      event(value2);
+    }
+  }
+  define(target, key, { set, get });
+  set(value, silent);
+}
+const OBSERVER = /* @__PURE__ */ new WeakMap();
+function watch(from, key, value) {
+  const access = OBSERVER.get(from);
+  return access ? access(key, value) : value;
+}
 function fetch(subject, property, required) {
   const state = STATE.get(subject);
   if (property in state || required === false) {
@@ -275,6 +303,7 @@ export {
   event,
   fetch,
   uid,
-  update
+  update,
+  watch
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/model.ts"],
  "sourcesContent": ["import { addListener, createEffect, event, OnUpdate, pending, PENDING_KEYS, watch } from './control';\n\nconst define = Object.defineProperty;\n\n/** Register for all active models via string identifiers (usually unique). */\nconst ID = new WeakMap<Model, string>();\n\n/** Internal state assigned to models. */\nconst STATE = new WeakMap<Model, Record<string | number | symbol, unknown>>();\n\n/** External listeners for any given Model. */\nconst NOTIFY = new WeakMap<Model.Type, Set<OnUpdate>>();\n\n/** Parent-child relationships. */\nconst PARENT = new WeakMap<Model, Model | null>();\n\n/** List of methods defined by a given type. */\nconst METHODS = new WeakMap<Model.Type, Map<string, (value: any) => void>>();\n\n/** Reference bound instance methods to real ones. */\nconst METHOD = new WeakMap<any, any>();\n\ndeclare namespace Model {\n  /** Any type of Model, using own class constructor as its identifier. */\n  type Type<T extends Model = Model> =\n    (abstract new (...args: any[]) => T) & typeof Model;\n\n  /** A Model constructor, but which is not abstract. */\n  type Init<T extends Model = Model> =\n    (new (...args: Model.Args<T>) => T) & Omit<typeof Model, never>;\n\n  /**\n   * Model constructor callback - is called when Model finishes intializing.\n   * Returned function will run when model is destroyed.\n   */\n  type Callback<T extends Model = Model> =\n    (this: T, thisArg: T) => Promise<void> | (() => void) | Assign<T> | void;\n\n  /** Model constructor argument */\n  type Argument<T extends Model = Model> = Assign<T> | Callback<T> | string | void;\n\n  /** Model constructor arguments */\n  type Args<T extends Model = any> = (Argument<T> | Args<T>)[];\n\n  /** Subset of `keyof T` which are not methods or defined by base Model U. **/\n  type Field<T> = Exclude<keyof T, keyof Model>;\n\n  /** Any valid key for model, including but not limited to Field<T>. */\n  type Event<T> = Field<T> | (string & {}) | number | symbol;\n\n  /** Object overlay to override values and methods on a model. */\n  type Assign<T> = {\n    [K in Field<T>]?:\n      T[K] extends (...args: infer A) => infer R \n        ? (this: T, ...args: A) => R\n        : T[K];\n  } & Record<string, unknown>;\n\n  /** Export/Import compatible value for a given property in a Model. */\n  type Export<R> = R extends { get(): infer T } ? T : R;\n\n  /** Value for a property managed by a model. */\n  type Value<T extends Model, K extends Event<T>> =\n    K extends keyof T ? Export<T[K]> : unknown;\n\n  type OnEvent<T extends Model> =\n    (this: T, key: unknown, source: T) => (() => void) | void | null;\n\n  type OnUpdate<T extends Model, K extends Event<T>> =\n    (this: T, key: K, thisArg: K) => void;\n\n  /**\n   * Values from current state of given model.\n   * Differs from `Values` as values here will drill\n   * into \"real\" values held by exotics like ref.Object.\n   */\n  type State<T> = { [P in Field<T>]: Export<T[P]> };\n\n  /** Object comperable to data found in T. */\n  type Values<T> = { [P in Field<T>]?: Export<T[P]> };\n\n  /** Exotic value, where actual value is contained within. */\n  type Ref<T = any> = {\n    (next: T): void;\n    current: T | null;\n  }\n\n  /**\n   * A callback function which is subscribed to parent and updates when accessed properties change.\n   * \n   * @param current - Current state of this model. This is a proxy which detects properties which\n   * where accessed, and thus depended upon to stay current.\n   * \n   * @param update - Set of properties which have changed, and events fired, since last update.\n   * \n   * @returns A callback function which will be called when this effect is stale.\n   */\n  type Effect<T> = (this: T, current: T, update: Set<Event<T>>) =>\n    EffectCallback | Promise<void> | null | void;\n\n  /**\n   * A callback function returned by effect. Will be called when effect is stale.\n   * \n   * @param update - `true` if update is pending, `false` effect has been cancelled, `null` if model is destroyed.\n   */\n  type EffectCallback = ((update: boolean | null) => void);\n\n  /**\n   * Property initializer, will run upon instance creation.\n   * Optional returned callback will run when once upon first access.\n   */\n  type Instruction<T = any, M extends Model = any> =\n    // TODO: Should this allow for numbers/symbol properties?\n    (this: M, key: Extract<Field<M>, string>, thisArg: M, state: State<M>) =>\n      Descriptor<T> | ((source: M) => T) | void;\n\n  type Getter<T> = (source: Model) => T;\n  type Setter<T> = (value: T, previous: T) => boolean | void | (() => T);\n\n  type Descriptor<T = any> = {\n    get?: Getter<T> | boolean;\n    set?: Setter<T> | boolean;\n    enumerable?: boolean;\n    value?: T;\n  }\n}\n\ninterface Model {\n  /**\n   * Loopback to instance of this model. This is useful when in a subscribed context,\n   * to keep write access to `this` after a destructure. You can use it to read variables silently as well.\n   **/\n  is: this;\n}\n\nabstract class Model {\n  constructor(...args: Model.Args){\n    prepare(this);\n    define(this, \"is\", { value: this });\n    init(this, args);\n  }\n\n  /**\n   * Pull current values from state. Flattens all models and exotic values recursively.\n   * \n   * @returns Object with all values from this model.\n   **/\n  get(): Model.State<this>;\n\n  /**\n   * Run a function which will run automatically when accessed values change.\n   * \n   * @param effect Function to run, and again whenever accessed values change.\n   *               If effect returns a function, it will be called when a change occurs (syncronously),\n   *               effect is cancelled, or parent model is destroyed.\n   * @returns Function to cancel listener.\n   */\n  get(effect: Model.Effect<this>): () => void;\n\n  /**\n   * Get value of a property.\n   * \n   * @param key - Property to get value of.\n   * @param required - If true, will throw an error if property is not available.\n   * @returns Value of property.\n   */\n  get<T extends Model.Event<this>>(key: T, required?: boolean): Model.Value<this, T>;\n\n  /**\n   * Run a function when a property is updated.\n   * \n   * @param key - Property to watch for updates.\n   * @param callback - Function to call when property is updated.\n   * @returns Function to cancel listener.\n   */\n  get<T extends Model.Event<this>>(key: T, callback: Model.OnUpdate<this, T>): () => void;\n\n  /**\n   * Check if model is expired.\n   * \n   * @param status - `null` to check if model is expired.\n   * @returns `true` if model is expired, `false` otherwise.\n   */\n  get(status: null): boolean;\n\n  /**\n   * Callback when model is to be destroyed.\n   * \n   * @param callback - Function to call when model is destroyed.\n   * @returns Function to cancel listener.\n   */\n  get(status: null, callback: () => void): () => void;\n\n  get(arg1?: Model.Effect<this> | string | null, arg2?: boolean | Model.OnUpdate<this, any>){\n    const self = this.is;\n\n    if(typeof arg1 == \"function\"){\n      let pending = new Set<Model.Event<this>>();\n\n      return createEffect(self, (proxy) => {\n        const cb = arg1.call(proxy, proxy, pending);\n\n        return cb === null ? null : ((update) => {\n          pending = PENDING_KEYS.get(self)!;\n          if(typeof cb == \"function\")\n            cb(update);\n        })\n      });\n    }\n\n    return (\n      arg1 === undefined ? snapshot(self) :\n      typeof arg2 == \"function\" ? addListener(self, arg2, arg1) :\n      arg1 === null ? Object.isFrozen(STATE.get(self)) :\n      fetch(self, arg1, arg2)\n    )\n  }\n\n  /**\n   * Get update in progress.\n   *\n   * @returns Promise which resolves object with updated values, `undefined` if there no update is pending.\n   **/\n  set(): PromiseLike<Model.Event<this>[]> | undefined;\n\n  /**\n   * Update mulitple properties at once. Merges argument with current state.\n   * Properties which are not managed by this model will be ignored.\n   * \n   * @param assign - Object with properties to update.\n   * @param silent - If an update does occur, listeners will not be refreshed automatically.\n   * @returns Promise resolving an array of keys updated, `undefined` (immediately) if a noop.\n   */\n  set(assign?: Model.Assign<this>, silent?: boolean): PromiseLike<Model.Event<this>[]> | undefined;\n\n  /**\n   * Push an update. This will not change the value of associated property.\n   * \n   * Useful where a property value internally has changed, but the object is the same.\n   * For example: An array has pushed a new value, or a nested property is updated.\n   * \n   * You can also use this to dispatch arbitrary events.\n   * Symbols are recommended as non-property events, however you can use any string.\n   * If doing so, be sure to avoid collisions with property names! An easy way to do this is\n   * to prefix an event with \"!\" and/or use dash-case. e.g. `set(\"!event\")` or `set(\"my-event\")`.\n   * \n   * @param key - Property or event to dispatch.\n   * @returns Promise resolves an array of keys updated.\n   */\n  set(key: Model.Event<this>): PromiseLike<Model.Event<this>[]>;\n\n  /**\n   * Call a function when update occurs.\n   * \n   * Given function is called for every assignment (which changes value) or explicit `set`.\n   * \n   * To run logic on final value only, callback may return a function. Using the same\n   * function for one or more events will ensure it is called only when events are settled.\n   * \n   * @param callback - Function to call when update occurs.\n   * @returns Function to remove listener. Will return `true` if removed, `false` if inactive already.\n   * \n  */\n  set(callback: Model.OnEvent<this>): () => boolean;\n\n  /**\n   * Call a function when a property is updated.\n   * Unlike `get`, this calsl synchronously and will fire as many times as the property is updated.\n   * \n   * @param key - Property to watch for updates.\n   * @param callback - Function to call when property is updated.\n   */\n  set(key: Model.Event<this> | null, callback: Model.OnEvent<this>): () => boolean;\n\n  /**\n   * Declare an end to updates. This event is final and will freeze state.\n   * This event can be watched for as well, to run cleanup logic and internally will remove all listeners.\n   * \n   * @param status - `null` to end updates.\n   */\n  set(status: null): void;\n\n  set(\n    arg1?: Model.OnEvent<this> | Model.Assign<this> | Model.Event<this> | null,\n    arg2?: boolean | Model.OnEvent<this>){\n\n    const self = this.is;\n\n    if(typeof arg1 == \"function\")\n      return addListener(self, key => {\n        if(typeof key == \"string\")\n          return arg1.call(self, key, self);\n      })\n      \n    if(typeof arg2 == \"function\")\n      return addListener(self, key => {\n        if(key === arg1)\n          return arg2.call(self, key, self);\n      });\n\n    if(arg1 && typeof arg1 == \"object\")\n      assign(self, arg1, arg2 === true);\n    else\n      event(self, arg1);\n\n    return pending(self);\n  }\n\n  /**\n   * Iterate over managed properties in this instance of Model.\n   * Yeilds the key and current value for each property.\n   */\n  [Symbol.iterator](): Iterator<[string, unknown]> {\n    return Object.entries(STATE.get(this.is)!)[Symbol.iterator]();\n  }\n\n  /**\n   * Create and activate a new instance of this model.\n   * \n   * **Important** - Unlike `new this(...)` - this method also activates state.\n   * \n   * @param args - arguments sent to constructor\n   */\n  static new<T extends Model>(this: Model.Init<T>, ...args: Model.Args<T>){\n    const instance = new this(...args);\n    event(instance);\n    return instance;\n  }\n\n  /**\n   * Static equivalent of `x instanceof this`.\n   * Determines if provided class is a subtype of this one.\n   * If so, language server will make available all static\n   * methods and properties of this class.\n   */\n  static is<T extends Model.Type>(this: T, maybe: unknown): maybe is T {\n    return maybe === this || typeof maybe == \"function\" && maybe.prototype instanceof this;\n  }\n\n  /**\n   * Register a callback to run when any instance of this Model is updated. \n   */\n  static on<T extends Model>(this: Model.Type<T>, listener: Model.OnEvent<T>){\n    let notify = NOTIFY.get(this);\n\n    if(!notify)\n      NOTIFY.set(this, notify = new Set);\n\n    notify.add(listener);\n\n    return () => notify.delete(listener);\n  }\n}\n\ndefine(Model.prototype, \"toString\", {\n  value(){\n    return ID.get(this.is);\n  }\n});\n\ndefine(Model, \"toString\", {\n  value(){\n    return this.name;\n  }\n});\n\nfunction assign(subject: Model, data: Model.Assign<Model>, silent?: boolean){\n  const methods = METHODS.get(subject.constructor as Model.Type)!;\n    \n  for(const key in data){\n    const bind = methods.get(key);\n\n    if(bind)\n      bind.call(subject, data[key]);\n    else if(key in subject && key !== \"is\"){\n      const desc = Object.getOwnPropertyDescriptor(subject, key)!;\n      const set = desc && desc.set as (value: any, silent?: boolean) => void;\n\n      set.call(subject, data[key], silent === true);\n    }\n  }\n}\n\n/** Apply instructions and inherited event listeners. Ensure class metadata is ready. */\nfunction prepare(model: Model){\n  let T = model.constructor as Model.Type;\n\n  if(T === Model)\n    throw new Error(\"Cannot create base Model.\");\n\n  const chain = [] as Model.Type[];\n  let keys = new Map<string, (value: any) => void>();\n\n  ID.set(model, `${T}-${uid()}`);\n\n  while(T.name){\n    for(const cb of NOTIFY.get(T) || [])\n      addListener(model, cb);\n\n    if(T === Model) break;\n    else chain.unshift(T);\n\n    T = Object.getPrototypeOf(T)\n  }\n\n  for(const type of chain){\n    if(METHODS.has(type)){\n      keys = METHODS.get(type)!;\n      continue;\n    }\n\n    METHODS.set(type, keys = new Map(keys));\n\n    for(const [key, { value }] of Object.entries(\n      Object.getOwnPropertyDescriptors(type.prototype)\n    )){\n      if(!value || key == \"constructor\")\n        continue;\n      \n      function bind(this: Model, original?: Function){\n        const { is } = this;\n\n        if(is.hasOwnProperty(key) && !original)\n          return value as Function;\n\n        const fn = original || value;\n        const bound = fn.bind(is);\n        \n        METHOD.set(bound, fn);\n        define(is, key, { value: bound, writable: true });\n        \n        return bound;\n      }\n\n      keys.set(key, bind);\n      define(type.prototype, key, { get: bind, set: bind });\n    }\n  }\n}\n\n/**\n * Apply model arguemnts, run callbacks and observe properties.\n * Accumulate and handle cleanup events.\n **/\nfunction init(model: Model, args: Model.Args){\n  const state = {} as Record<string | number | symbol, unknown>;\n\n  STATE.set(model, state);\n\n  args = args.flat().filter(arg => {\n    if(typeof arg != \"string\")\n      return true;\n\n    ID.set(model, arg);\n  });\n\n  addListener(model, () => {\n    if(!PARENT.has(model))\n      PARENT.set(model, null);\n\n    for(const key in model){\n      const desc = Object.getOwnPropertyDescriptor(model, key)!;\n\n      if(\"value\" in desc){\n        function set(value: unknown, silent?: boolean){\n          update(model, key, value, silent);\n          if(value instanceof Model && !PARENT.has(value)){\n            PARENT.set(value, model);\n            event(value);\n          }\n        }\n\n        set(desc.value, true);\n        define(model, key, {\n          configurable: false,\n          set,\n          get(){\n            return watch(this, key, state[key]);\n          }\n        });\n      }\n    }\n    \n    args.forEach((arg) => {\n      const use = typeof arg == \"function\"\n        ? arg.call(model, model)\n        : arg as Model.Assign<Model>;\n\n      if(use instanceof Promise)\n        use.catch(err => {\n          console.error(`Async error in constructor for ${model}:`);\n          console.error(err);\n        });\n      else if(typeof use == \"function\")\n        addListener(model, use, null)\n      else if(typeof use == \"object\")\n        assign(model, use, true);\n    });\n\n    addListener(model, () => {\n      for(const [_, value] of model)\n        if(value instanceof Model && PARENT.get(value) === model)\n          value.set(null);\n  \n      Object.freeze(state);\n    }, null);\n  \n    return null;\n  });\n}\n\nfunction fetch(subject: Model, property: string, required?: boolean){\n  const state = STATE.get(subject)!;\n  \n  if(property in state || required === false){\n    const value = state[property];\n\n    if(value !== undefined || !required)\n      return value;\n  }\n\n  const error = new Error(`${subject}.${property} is not yet available.`);\n  const promise = new Promise<any>((resolve, reject) => {\n    addListener(subject, key => {\n      if(key === property){\n        resolve(state[key]);\n        return null;\n      }\n\n      if(key === null)\n        reject(new Error(`${subject} is destroyed.`));\n    });\n  });\n\n  throw Object.assign(promise, {\n    toString: () => String(error),\n    name: \"Suspense\",\n    message: error.message,\n    stack: error.stack\n  });\n}\n\n/** Currently accumulating export. Stores real values of placeholder properties such as ref() or child models. */\nlet EXPORT: Map<any, any> | undefined;\n\nfunction snapshot<T extends Model>(model: T): Model.State<T> {\n  const values = {} as any;\n  let isNotRecursive;\n\n  if(!EXPORT){\n    isNotRecursive = true;\n    EXPORT = new Map([[model, values]]);\n  }\n\n  for(let [key, value] of model){\n    if(EXPORT.has(value))\n      value = EXPORT.get(value);\n    else if(value && typeof value == \"object\" && \"get\" in value && typeof value.get === \"function\")\n      EXPORT.set(value, value = value.get());\n\n    values[key] = value;\n  }\n\n  if(isNotRecursive)\n    EXPORT = undefined;\n\n  return Object.freeze(values);\n}\n\nfunction update<T>(\n  subject: Model,\n  key: string | number | symbol,\n  value: T,\n  arg?: boolean | Model.Setter<T>){\n\n  const state = STATE.get(subject)!;\n\n  if(Object.isFrozen(state))\n    throw new Error(`Tried to update ${String(key)} but ${subject} is destroyed.`);\n\n  const previous = state[key] as T;\n\n  if(typeof arg == \"function\"){\n    const out = arg.call(subject, value, previous);\n\n    if(out === false)\n      return false;\n\n    if(typeof out == \"function\")\n      value = out();\n  }\n\n  if(value === previous && value !== undefined)\n    return;\n\n  state[key] = value;\n\n  if(arg !== true)\n    event(subject, key);\n\n  return true;\n}\n\n/** Random alphanumberic of length 6; always starts with a letter. */\nfunction uid(){\n  return (0.278 + Math.random() * 0.722).toString(36).substring(2, 8).toUpperCase();\n}\n\nexport {\n  event,\n  fetch,\n  METHOD,\n  Model,\n  PARENT,\n  STATE,\n  uid,\n  update,\n}"],
  "mappings": "AAAA,SAAS,aAAa,cAAc,OAAiB,SAAS,cAAc,aAAa;AAEzF,MAAM,SAAS,OAAO;AAGtB,MAAM,KAAK,oBAAI,QAAuB;AAGtC,MAAM,QAAQ,oBAAI,QAA0D;AAG5E,MAAM,SAAS,oBAAI,QAAmC;AAGtD,MAAM,SAAS,oBAAI,QAA6B;AAGhD,MAAM,UAAU,oBAAI,QAAuD;AAG3E,MAAM,SAAS,oBAAI,QAAkB;AAmHrC,MAAe,MAAM;AAAA,EACnB,eAAe,MAAiB;AAC9B,YAAQ,IAAI;AACZ,WAAO,MAAM,MAAM,EAAE,OAAO,KAAK,CAAC;AAClC,SAAK,MAAM,IAAI;AAAA,EACjB;AAAA,EAqDA,IAAI,MAA2C,MAA2C;AACxF,UAAM,OAAO,KAAK;AAElB,QAAG,OAAO,QAAQ,YAAW;AAC3B,UAAIA,WAAU,oBAAI,IAAuB;AAEzC,aAAO,aAAa,MAAM,CAAC,UAAU;AACnC,cAAM,KAAK,KAAK,KAAK,OAAO,OAAOA,QAAO;AAE1C,eAAO,OAAO,OAAO,OAAQ,CAACC,YAAW;AACvC,UAAAD,WAAU,aAAa,IAAI,IAAI;AAC/B,cAAG,OAAO,MAAM;AACd,eAAGC,OAAM;AAAA,QACb;AAAA,MACF,CAAC;AAAA,IACH;AAEA,WACE,SAAS,SAAY,SAAS,IAAI,IAClC,OAAO,QAAQ,aAAa,YAAY,MAAM,MAAM,IAAI,IACxD,SAAS,OAAO,OAAO,SAAS,MAAM,IAAI,IAAI,CAAC,IAC/C,MAAM,MAAM,MAAM,IAAI;AAAA,EAE1B;AAAA,EAkEA,IACE,MACA,MAAqC;AAErC,UAAM,OAAO,KAAK;AAElB,QAAG,OAAO,QAAQ;AAChB,aAAO,YAAY,MAAM,SAAO;AAC9B,YAAG,OAAO,OAAO;AACf,iBAAO,KAAK,KAAK,MAAM,KAAK,IAAI;AAAA,MACpC,CAAC;AAEH,QAAG,OAAO,QAAQ;AAChB,aAAO,YAAY,MAAM,SAAO;AAC9B,YAAG,QAAQ;AACT,iBAAO,KAAK,KAAK,MAAM,KAAK,IAAI;AAAA,MACpC,CAAC;AAEH,QAAG,QAAQ,OAAO,QAAQ;AACxB,aAAO,MAAM,MAAM,SAAS,IAAI;AAAA;AAEhC,YAAM,MAAM,IAAI;AAElB,WAAO,QAAQ,IAAI;AAAA,EACrB;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,CAAC,OAAO,QAAQ,IAAiC;AAC/C,WAAO,OAAO,QAAQ,MAAM,IAAI,KAAK,EAAE,CAAE,EAAE,OAAO,QAAQ,EAAE;AAAA,EAC9D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,OAAO,OAA6C,MAAoB;AACtE,UAAM,WAAW,IAAI,KAAK,GAAG,IAAI;AACjC,UAAM,QAAQ;AACd,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAO,GAAkC,OAA4B;AACnE,WAAO,UAAU,QAAQ,OAAO,SAAS,cAAc,MAAM,qBAAqB;AAAA,EACpF;AAAA;AAAA;AAAA;AAAA,EAKA,OAAO,GAAyC,UAA2B;AACzE,QAAI,SAAS,OAAO,IAAI,IAAI;AAE5B,QAAG,CAAC;AACF,aAAO,IAAI,MAAM,SAAS,oBAAI,KAAG;AAEnC,WAAO,IAAI,QAAQ;AAEnB,WAAO,MAAM,OAAO,OAAO,QAAQ;AAAA,EACrC;AACF;AAEA,OAAO,MAAM,WAAW,YAAY;AAAA,EAClC,QAAO;AACL,WAAO,GAAG,IAAI,KAAK,EAAE;AAAA,EACvB;AACF,CAAC;AAED,OAAO,OAAO,YAAY;AAAA,EACxB,QAAO;AACL,WAAO,KAAK;AAAA,EACd;AACF,CAAC;AAED,SAAS,OAAO,SAAgB,MAA2B,QAAiB;AAC1E,QAAM,UAAU,QAAQ,IAAI,QAAQ,WAAyB;AAE7D,aAAU,OAAO,MAAK;AACpB,UAAM,OAAO,QAAQ,IAAI,GAAG;AAE5B,QAAG;AACD,WAAK,KAAK,SAAS,KAAK,GAAG,CAAC;AAAA,aACtB,OAAO,WAAW,QAAQ,MAAK;AACrC,YAAM,OAAO,OAAO,yBAAyB,SAAS,GAAG;AACzD,YAAM,MAAM,QAAQ,KAAK;AAEzB,UAAI,KAAK,SAAS,KAAK,GAAG,GAAG,WAAW,IAAI;AAAA,IAC9C;AAAA,EACF;AACF;AAGA,SAAS,QAAQ,OAAa;AAC5B,MAAI,IAAI,MAAM;AAEd,MAAG,MAAM;AACP,UAAM,IAAI,MAAM,2BAA2B;AAE7C,QAAM,QAAQ,CAAC;AACf,MAAI,OAAO,oBAAI,IAAkC;AAEjD,KAAG,IAAI,OAAO,GAAG,CAAC,IAAI,IAAI,CAAC,EAAE;AAE7B,SAAM,EAAE,MAAK;AACX,eAAU,MAAM,OAAO,IAAI,CAAC,KAAK,CAAC;AAChC,kBAAY,OAAO,EAAE;AAEvB,QAAG,MAAM,MAAO;AAAA,QACX,OAAM,QAAQ,CAAC;AAEpB,QAAI,OAAO,eAAe,CAAC;AAAA,EAC7B;AAEA,aAAU,QAAQ,OAAM;AACtB,QAAG,QAAQ,IAAI,IAAI,GAAE;AACnB,aAAO,QAAQ,IAAI,IAAI;AACvB;AAAA,IACF;AAEA,YAAQ,IAAI,MAAM,OAAO,IAAI,IAAI,IAAI,CAAC;AAEtC,eAAU,CAAC,KAAK,EAAE,MAAM,CAAC,KAAK,OAAO;AAAA,MACnC,OAAO,0BAA0B,KAAK,SAAS;AAAA,IACjD,GAAE;AAIA,UAASC,QAAT,SAA2B,UAAoB;AAC7C,cAAM,EAAE,GAAG,IAAI;AAEf,YAAG,GAAG,eAAe,GAAG,KAAK,CAAC;AAC5B,iBAAO;AAET,cAAM,KAAK,YAAY;AACvB,cAAM,QAAQ,GAAG,KAAK,EAAE;AAExB,eAAO,IAAI,OAAO,EAAE;AACpB,eAAO,IAAI,KAAK,EAAE,OAAO,OAAO,UAAU,KAAK,CAAC;AAEhD,eAAO;AAAA,MACT;AAbS,iBAAAA;AAHT,UAAG,CAAC,SAAS,OAAO;AAClB;AAiBF,WAAK,IAAI,KAAKA,KAAI;AAClB,aAAO,KAAK,WAAW,KAAK,EAAE,KAAKA,OAAM,KAAKA,MAAK,CAAC;AAAA,IACtD;AAAA,EACF;AACF;AAMA,SAAS,KAAK,OAAc,MAAiB;AAC3C,QAAM,QAAQ,CAAC;AAEf,QAAM,IAAI,OAAO,KAAK;AAEtB,SAAO,KAAK,KAAK,EAAE,OAAO,SAAO;AAC/B,QAAG,OAAO,OAAO;AACf,aAAO;AAET,OAAG,IAAI,OAAO,GAAG;AAAA,EACnB,CAAC;AAED,cAAY,OAAO,MAAM;AACvB,QAAG,CAAC,OAAO,IAAI,KAAK;AAClB,aAAO,IAAI,OAAO,IAAI;AAExB,eAAU,OAAO,OAAM;AACrB,YAAM,OAAO,OAAO,yBAAyB,OAAO,GAAG;AAEvD,UAAG,WAAW,MAAK;AACjB,YAASC,OAAT,SAAa,OAAgB,QAAiB;AAC5C,iBAAO,OAAO,KAAK,OAAO,MAAM;AAChC,cAAG,iBAAiB,SAAS,CAAC,OAAO,IAAI,KAAK,GAAE;AAC9C,mBAAO,IAAI,OAAO,KAAK;AACvB,kBAAM,KAAK;AAAA,UACb;AAAA,QACF;AANS,kBAAAA;AAQT,QAAAA,KAAI,KAAK,OAAO,IAAI;AACpB,eAAO,OAAO,KAAK;AAAA,UACjB,cAAc;AAAA,UACd,KAAAA;AAAA,UACA,MAAK;AACH,mBAAO,MAAM,MAAM,KAAK,MAAM,GAAG,CAAC;AAAA,UACpC;AAAA,QACF,CAAC;AAAA,MACH;AAAA,IACF;AAEA,SAAK,QAAQ,CAAC,QAAQ;AACpB,YAAM,MAAM,OAAO,OAAO,aACtB,IAAI,KAAK,OAAO,KAAK,IACrB;AAEJ,UAAG,eAAe;AAChB,YAAI,MAAM,SAAO;AACf,kBAAQ,MAAM,kCAAkC,KAAK,GAAG;AACxD,kBAAQ,MAAM,GAAG;AAAA,QACnB,CAAC;AAAA,eACK,OAAO,OAAO;AACpB,oBAAY,OAAO,KAAK,IAAI;AAAA,eACtB,OAAO,OAAO;AACpB,eAAO,OAAO,KAAK,IAAI;AAAA,IAC3B,CAAC;AAED,gBAAY,OAAO,MAAM;AACvB,iBAAU,CAAC,GAAG,KAAK,KAAK;AACtB,YAAG,iBAAiB,SAAS,OAAO,IAAI,KAAK,MAAM;AACjD,gBAAM,IAAI,IAAI;AAElB,aAAO,OAAO,KAAK;AAAA,IACrB,GAAG,IAAI;AAEP,WAAO;AAAA,EACT,CAAC;AACH;AAEA,SAAS,MAAM,SAAgB,UAAkB,UAAmB;AAClE,QAAM,QAAQ,MAAM,IAAI,OAAO;AAE/B,MAAG,YAAY,SAAS,aAAa,OAAM;AACzC,UAAM,QAAQ,MAAM,QAAQ;AAE5B,QAAG,UAAU,UAAa,CAAC;AACzB,aAAO;AAAA,EACX;AAEA,QAAM,QAAQ,IAAI,MAAM,GAAG,OAAO,IAAI,QAAQ,wBAAwB;AACtE,QAAM,UAAU,IAAI,QAAa,CAAC,SAAS,WAAW;AACpD,gBAAY,SAAS,SAAO;AAC1B,UAAG,QAAQ,UAAS;AAClB,gBAAQ,MAAM,GAAG,CAAC;AAClB,eAAO;AAAA,MACT;AAEA,UAAG,QAAQ;AACT,eAAO,IAAI,MAAM,GAAG,OAAO,gBAAgB,CAAC;AAAA,IAChD,CAAC;AAAA,EACH,CAAC;AAED,QAAM,OAAO,OAAO,SAAS;AAAA,IAC3B,UAAU,MAAM,OAAO,KAAK;AAAA,IAC5B,MAAM;AAAA,IACN,SAAS,MAAM;AAAA,IACf,OAAO,MAAM;AAAA,EACf,CAAC;AACH;AAGA,IAAI;AAEJ,SAAS,SAA0B,OAA0B;AAC3D,QAAM,SAAS,CAAC;AAChB,MAAI;AAEJ,MAAG,CAAC,QAAO;AACT,qBAAiB;AACjB,aAAS,oBAAI,IAAI,CAAC,CAAC,OAAO,MAAM,CAAC,CAAC;AAAA,EACpC;AAEA,WAAQ,CAAC,KAAK,KAAK,KAAK,OAAM;AAC5B,QAAG,OAAO,IAAI,KAAK;AACjB,cAAQ,OAAO,IAAI,KAAK;AAAA,aAClB,SAAS,OAAO,SAAS,YAAY,SAAS,SAAS,OAAO,MAAM,QAAQ;AAClF,aAAO,IAAI,OAAO,QAAQ,MAAM,IAAI,CAAC;AAEvC,WAAO,GAAG,IAAI;AAAA,EAChB;AAEA,MAAG;AACD,aAAS;AAEX,SAAO,OAAO,OAAO,MAAM;AAC7B;AAEA,SAAS,OACP,SACA,KACA,OACA,KAAgC;AAEhC,QAAM,QAAQ,MAAM,IAAI,OAAO;AAE/B,MAAG,OAAO,SAAS,KAAK;AACtB,UAAM,IAAI,MAAM,mBAAmB,OAAO,GAAG,CAAC,QAAQ,OAAO,gBAAgB;AAE/E,QAAM,WAAW,MAAM,GAAG;AAE1B,MAAG,OAAO,OAAO,YAAW;AAC1B,UAAM,MAAM,IAAI,KAAK,SAAS,OAAO,QAAQ;AAE7C,QAAG,QAAQ;AACT,aAAO;AAET,QAAG,OAAO,OAAO;AACf,cAAQ,IAAI;AAAA,EAChB;AAEA,MAAG,UAAU,YAAY,UAAU;AACjC;AAEF,QAAM,GAAG,IAAI;AAEb,MAAG,QAAQ;AACT,UAAM,SAAS,GAAG;AAEpB,SAAO;AACT;AAGA,SAAS,MAAK;AACZ,UAAQ,QAAQ,KAAK,OAAO,IAAI,OAAO,SAAS,EAAE,EAAE,UAAU,GAAG,CAAC,EAAE,YAAY;AAClF;",
  "names": ["pending", "update", "bind", "set"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/model.ts"],
  "sourcesContent": ["import { addListener, createEffect, event, Observable, OnUpdate, PENDING_KEYS } from './control';\n\nconst define = Object.defineProperty;\n\n/** Register for all active models via string identifiers (usually unique). */\nconst ID = new WeakMap<Model, string>();\n\n/** Internal state assigned to models. */\nconst STATE = new WeakMap<Model, Record<string | number | symbol, unknown>>();\n\n/** External listeners for any given Model. */\nconst NOTIFY = new WeakMap<Model.Type, Set<OnUpdate>>();\n\n/** Parent-child relationships. */\nconst PARENT = new WeakMap<Model, Model | null>();\n\n/** List of methods defined by a given type. */\nconst METHODS = new WeakMap<Model.Type, Map<string, (value: any) => void>>();\n\n/** Reference bound instance methods to real ones. */\nconst METHOD = new WeakMap<any, any>();\n\ndeclare namespace Model {\n  /** Any type of Model, using own class constructor as its identifier. */\n  type Type<T extends Model = Model> =\n    (abstract new (...args: any[]) => T) & typeof Model;\n\n  /** A Model constructor, but which is not abstract. */\n  type Init<T extends Model = Model> =\n    (new (...args: Model.Args<T>) => T) & Omit<typeof Model, never>;\n\n  /**\n   * Model constructor callback - is called when Model finishes intializing.\n   * Returned function will run when model is destroyed.\n   */\n  type Callback<T extends Model = Model> =\n    (this: T, thisArg: T) => Promise<void> | (() => void) | Assign<T> | void;\n\n  /** Model constructor argument */\n  type Argument<T extends Model = Model> = Assign<T> | Callback<T> | string | void;\n\n  /** Model constructor arguments */\n  type Args<T extends Model = any> = (Argument<T> | Args<T>)[];\n\n  /** Subset of `keyof T` which are not methods or defined by base Model U. **/\n  type Field<T> = Exclude<keyof T, keyof Model>;\n\n  /** Any valid key for model, including but not limited to Field<T>. */\n  type Event<T> = Field<T> | (string & {}) | number | symbol;\n\n  /** Object overlay to override values and methods on a model. */\n  type Assign<T> = {\n    [K in Field<T>]?:\n      T[K] extends (...args: infer A) => infer R \n        ? (this: T, ...args: A) => R\n        : T[K];\n  } & Record<string, unknown>;\n\n  /** Export/Import compatible value for a given property in a Model. */\n  type Export<R> = R extends { get(): infer T } ? T : R;\n\n  /** Value for a property managed by a model. */\n  type Value<T extends Model, K extends Event<T>> =\n    K extends keyof T ? Export<T[K]> : unknown;\n\n  type OnEvent<T extends Model> =\n    (this: T, key: unknown, source: T) => (() => void) | void | null;\n\n  type OnUpdate<T extends Model, K extends Event<T>> =\n    (this: T, key: K, thisArg: K) => void;\n\n  /**\n   * Values from current state of given model.\n   * Differs from `Values` as values here will drill\n   * into \"real\" values held by exotics like ref.Object.\n   */\n  type State<T> = { [P in Field<T>]: Export<T[P]> };\n\n  /** Object comperable to data found in T. */\n  type Values<T> = { [P in Field<T>]?: Export<T[P]> };\n\n  /** Exotic value, where actual value is contained within. */\n  type Ref<T = any> = {\n    (next: T): void;\n    current: T | null;\n  }\n\n  /**\n   * A callback function which is subscribed to parent and updates when accessed properties change.\n   * \n   * @param current - Current state of this model. This is a proxy which detects properties which\n   * where accessed, and thus depended upon to stay current.\n   * \n   * @param update - Set of properties which have changed, and events fired, since last update.\n   * \n   * @returns A callback function which will be called when this effect is stale.\n   */\n  type Effect<T> = (this: T, current: T, update: Set<Event<T>>) =>\n    EffectCallback | Promise<void> | null | void;\n\n  /**\n   * A callback function returned by effect. Will be called when effect is stale.\n   * \n   * @param update - `true` if update is pending, `false` effect has been cancelled, `null` if model is destroyed.\n   */\n  type EffectCallback = ((update: boolean | null) => void);\n\n  /**\n   * Property initializer, will run upon instance creation.\n   * Optional returned callback will run when once upon first access.\n   */\n  type Instruction<T = any, M extends Model = any> =\n    // TODO: Should this allow for numbers/symbol properties?\n    (this: M, key: Extract<Field<M>, string>, thisArg: M, state: State<M>) =>\n      Descriptor<T> | ((source: M) => T) | void;\n\n  type Getter<T> = (source: Model) => T;\n  type Setter<T> = (value: T, previous: T) => boolean | void | (() => T);\n\n  type Descriptor<T = any> = {\n    get?: Getter<T> | boolean;\n    set?: Setter<T> | boolean;\n    enumerable?: boolean;\n    value?: T;\n  }\n}\n\ninterface Model {\n  /**\n   * Loopback to instance of this model. This is useful when in a subscribed context,\n   * to keep write access to `this` after a destructure. You can use it to read variables silently as well.\n   **/\n  is: this;\n}\n\nabstract class Model implements Observable {\n  constructor(...args: Model.Args){\n    prepare(this);\n    define(this, \"is\", { value: this });\n    init(this, args);\n  }\n\n  [Observable](callback: OnUpdate, required?: boolean){\n    const watch = new Set<Model.Event<this>>();\n    const proxy = Object.create(this);\n    \n    addListener(this, callback, watch);\n    OBSERVER.set(proxy, (key, value) => {\n      if(value === undefined && required)\n        throw new Error(`${this}.${key} is required in this context.`);\n\n      watch.add(key);\n\n      if(value instanceof Object && Observable in value)\n        return value[Observable](callback, required);\n\n      return value;\n    });\n\n    return proxy as this;\n  }\n\n  /**\n   * Pull current values from state. Flattens all models and exotic values recursively.\n   * \n   * @returns Object with all values from this model.\n   **/\n  get(): Model.State<this>;\n\n  /**\n   * Run a function which will run automatically when accessed values change.\n   * \n   * @param effect Function to run, and again whenever accessed values change.\n   *               If effect returns a function, it will be called when a change occurs (syncronously),\n   *               effect is cancelled, or parent model is destroyed.\n   * @returns Function to cancel listener.\n   */\n  get(effect: Model.Effect<this>): () => void;\n\n  /**\n   * Get value of a property.\n   * \n   * @param key - Property to get value of.\n   * @param required - If true, will throw an error if property is not available.\n   * @returns Value of property.\n   */\n  get<T extends Model.Event<this>>(key: T, required?: boolean): Model.Value<this, T>;\n\n  /**\n   * Run a function when a property is updated.\n   * \n   * @param key - Property to watch for updates.\n   * @param callback - Function to call when property is updated.\n   * @returns Function to cancel listener.\n   */\n  get<T extends Model.Event<this>>(key: T, callback: Model.OnUpdate<this, T>): () => void;\n\n  /**\n   * Check if model is expired.\n   * \n   * @param status - `null` to check if model is expired.\n   * @returns `true` if model is expired, `false` otherwise.\n   */\n  get(status: null): boolean;\n\n  /**\n   * Callback when model is to be destroyed.\n   * \n   * @param callback - Function to call when model is destroyed.\n   * @returns Function to cancel listener.\n   */\n  get(status: null, callback: () => void): () => void;\n\n  get(arg1?: Model.Effect<this> | string | null, arg2?: boolean | Model.OnUpdate<this, any>){\n    const self = this.is;\n\n    if(typeof arg1 == \"function\"){\n      let pending = new Set<Model.Event<this>>();\n\n      return createEffect(self, (proxy) => {\n        const cb = arg1.call(proxy, proxy, pending);\n\n        return cb === null ? null : ((update) => {\n          pending = PENDING_KEYS.get(self)!;\n          if(typeof cb == \"function\")\n            cb(update);\n        })\n      });\n    }\n\n    return (\n      arg1 === undefined ? snapshot(self) :\n      typeof arg2 == \"function\" ? addListener(self, arg2, arg1) :\n      arg1 === null ? Object.isFrozen(STATE.get(self)) :\n      fetch(self, arg1, arg2)\n    )\n  }\n\n  /**\n   * Get update in progress.\n   *\n   * @returns Promise which resolves object with updated values, `undefined` if there no update is pending.\n   **/\n  set(): PromiseLike<Model.Event<this>[]> | undefined;\n\n  /**\n   * Update mulitple properties at once. Merges argument with current state.\n   * Properties which are not managed by this model will be ignored.\n   * \n   * @param assign - Object with properties to update.\n   * @param silent - If an update does occur, listeners will not be refreshed automatically.\n   * @returns Promise resolving an array of keys updated, `undefined` (immediately) if a noop.\n   */\n  set(assign?: Model.Assign<this>, silent?: boolean): PromiseLike<Model.Event<this>[]> | undefined;\n\n  /**\n   * Push an update. This will not change the value of associated property.\n   * \n   * Useful where a property value internally has changed, but the object is the same.\n   * For example: An array has pushed a new value, or a nested property is updated.\n   * \n   * You can also use this to dispatch arbitrary events.\n   * Symbols are recommended as non-property events, however you can use any string.\n   * If doing so, be sure to avoid collisions with property names! An easy way to do this is\n   * to prefix an event with \"!\" and/or use dash-case. e.g. `set(\"!event\")` or `set(\"my-event\")`.\n   * \n   * @param key - Property or event to dispatch.\n   * @returns Promise resolves an array of keys updated.\n   */\n  set(key: Model.Event<this>): PromiseLike<Model.Event<this>[]>;\n\n  /**\n   * Set a value for a property. This will update the value and notify listeners.\n   * \n   * **Use with caution!** Key nor value are checked for validity.\n   * \n   * This is meant for assigning values programmatically,\n   * where simple assignment is not practicable.\n   * \n   * For example: `(this as any)[myProperty] = value;`\n   * \n   * @param key - Property to set value for.\n   * @param value - Value to set for property.\n   * @param init - If true, model will begin to manage the property if it is not already.\n   * @returns Promise resolves an array of keys updated.\n   */\n  set(key: Model.Event<this>, value: unknown, init?: boolean): PromiseLike<Model.Event<this>[]>;\n\n  /**\n   * Call a function when update occurs.\n   * \n   * Given function is called for every assignment (which changes value) or explicit `set`.\n   * \n   * To run logic on final value only, callback may return a function. Using the same\n   * function for one or more events will ensure it is called only when events are settled.\n   * \n   * @param callback - Function to call when update occurs.\n   * @returns Function to remove listener. Will return `true` if removed, `false` if inactive already.\n   * \n  */\n  set(callback: Model.OnEvent<this>): () => boolean;\n\n  /**\n   * Call a function when a property is updated.\n   * Unlike `get`, this calsl synchronously and will fire as many times as the property is updated.\n   * \n   * @param callback - Function to call when property is updated.\n   * @param event - Property to watch for updates.\n   */\n  set(callback: Model.OnEvent<this>, event: Model.Event<this> | null): () => boolean;\n\n  /**\n   * Declare an end to updates. This event is final and will freeze state.\n   * This event can be watched for as well, to run cleanup logic and internally will remove all listeners.\n   * \n   * @param status - `null` to end updates.\n   */\n  set(status: null): void;\n\n  set(\n    arg1?: Model.OnEvent<this> | Model.Assign<this> | Model.Event<this> | null,\n    arg2?: unknown,\n    arg3?: boolean){\n\n    const self = this.is;\n\n    if(typeof arg1 == \"function\")\n      return addListener(self, key => {\n        if(arg2 === key || arg2 === undefined && typeof key == \"string\")\n          return arg1.call(self, key, self);\n      })\n      \n    if(arg1 && typeof arg1 == \"object\")\n      assign(self, arg1, arg2 === true);\n    else if(!arg2)\n      event(self, arg1);\n    else if(arg3)\n      manage(self, arg1 as string | number, arg2);\n    else\n      update(self, arg1 as string | number, arg2)\n\n    const pending = PENDING_KEYS.get(this);\n\n    if(pending)\n      return <PromiseLike<Model.Event<this>[]>> {\n        then: (res) => new Promise<any>(res => {\n          const remove = addListener(this, key => {\n            if(key !== true){\n              remove();\n              return res.bind(null, Array.from(pending));\n            }\n          });\n        }).then(res)\n      }\n  }\n\n  /**\n   * Iterate over managed properties in this instance of Model.\n   * Yeilds the key and current value for each property.\n   */\n  [Symbol.iterator](): Iterator<[string, unknown]> {\n    return Object.entries(STATE.get(this.is)!)[Symbol.iterator]();\n  }\n\n  /**\n   * Create and activate a new instance of this model.\n   * \n   * **Important** - Unlike `new this(...)` - this method also activates state.\n   * \n   * @param args - arguments sent to constructor\n   */\n  static new<T extends Model>(this: Model.Init<T>, ...args: Model.Args<T>){\n    const instance = new this(...args);\n    event(instance);\n    return instance;\n  }\n\n  /**\n   * Static equivalent of `x instanceof this`.\n   * Determines if provided class is a subtype of this one.\n   * If so, language server will make available all static\n   * methods and properties of this class.\n   */\n  static is<T extends Model.Type>(this: T, maybe: unknown): maybe is T {\n    return maybe === this || typeof maybe == \"function\" && maybe.prototype instanceof this;\n  }\n\n  /**\n   * Register a callback to run when any instance of this Model is updated. \n   */\n  static on<T extends Model>(this: Model.Type<T>, listener: Model.OnEvent<T>){\n    let notify = NOTIFY.get(this);\n\n    if(!notify)\n      NOTIFY.set(this, notify = new Set);\n\n    notify.add(listener);\n\n    return () => notify.delete(listener);\n  }\n}\n\ndefine(Model.prototype, \"toString\", {\n  value(){\n    return ID.get(this.is);\n  }\n});\n\ndefine(Model, \"toString\", {\n  value(){\n    return this.name;\n  }\n});\n\nfunction assign(subject: Model, data: Model.Assign<Model>, silent?: boolean){\n  const methods = METHODS.get(subject.constructor as Model.Type)!;\n    \n  for(const key in data){\n    const bind = methods.get(key);\n\n    if(bind)\n      bind.call(subject, data[key]);\n    else if(key in subject && key !== \"is\"){\n      const desc = Object.getOwnPropertyDescriptor(subject, key)!;\n      const set = desc && desc.set as (value: any, silent?: boolean) => void;\n\n      set.call(subject, data[key], silent);\n    }\n  }\n}\n\n/** Apply instructions and inherited event listeners. Ensure class metadata is ready. */\nfunction prepare(model: Model){\n  let T = model.constructor as Model.Type;\n\n  if(T === Model)\n    throw new Error(\"Cannot create base Model.\");\n\n  const chain = [] as Model.Type[];\n  let keys = new Map<string, (value: any) => void>();\n\n  ID.set(model, `${T}-${uid()}`);\n\n  while(T.name){\n    for(const cb of NOTIFY.get(T) || [])\n      addListener(model, cb);\n\n    if(T === Model) break;\n    else chain.unshift(T);\n\n    T = Object.getPrototypeOf(T)\n  }\n\n  for(const type of chain){\n    if(METHODS.has(type)){\n      keys = METHODS.get(type)!;\n      continue;\n    }\n\n    METHODS.set(type, keys = new Map(keys));\n\n    for(const [key, { value }] of Object.entries(\n      Object.getOwnPropertyDescriptors(type.prototype)\n    )){\n      if(!value || key == \"constructor\")\n        continue;\n      \n      function bind(this: Model, original?: Function){\n        const { is } = this;\n\n        if(is.hasOwnProperty(key) && !original)\n          return value as Function;\n\n        const fn = original || value;\n        const bound = fn.bind(is);\n        \n        METHOD.set(bound, fn);\n        define(is, key, { value: bound, writable: true });\n        \n        return bound;\n      }\n\n      keys.set(key, bind);\n      define(type.prototype, key, { get: bind, set: bind });\n    }\n  }\n}\n\n/**\n * Apply model arguemnts, run callbacks and observe properties.\n * Accumulate and handle cleanup events.\n **/\nfunction init(model: Model, args: Model.Args){\n  const state = {} as Record<string | number | symbol, unknown>;\n\n  STATE.set(model, state);\n\n  args = args.flat().filter(arg => {\n    if(typeof arg != \"string\")\n      return true;\n\n    ID.set(model, arg);\n  });\n\n  addListener(model, () => {\n    if(!PARENT.has(model))\n      PARENT.set(model, null);\n\n    for(const key in model){\n      const desc = Object.getOwnPropertyDescriptor(model, key)!;\n\n      if(\"value\" in desc)\n        manage(model, key, desc.value, true);\n    }\n\n    for(const arg of args){\n      const use = typeof arg == \"function\"\n        ? arg.call(model, model)\n        : arg as Model.Assign<Model>;\n\n      if(use instanceof Promise)\n        use.catch(err => {\n          console.error(`Async error in constructor for ${model}:`);\n          console.error(err);\n        });\n      else if(typeof use == \"function\")\n        addListener(model, use, null)\n      else if(typeof use == \"object\")\n        assign(model, use, true);\n    }\n\n    addListener(model, () => {\n      for(const [_, value] of model)\n        if(value instanceof Model && PARENT.get(value) === model)\n          value.set(null);\n  \n      Object.freeze(state);\n    }, null);\n  \n    return null;\n  });\n}\n\nfunction manage(target: Model, key: string | number, value: any, silent?: boolean){\n  const state = STATE.get(target)!;\n  \n  function get(this: Model){\n    return watch(this, key, state[key]);\n  }\n\n  function set(value: unknown, silent?: boolean){\n    update(target, key, value, silent);\n    if(value instanceof Model && !PARENT.has(value)){\n      PARENT.set(value, target);\n      event(value);\n    }\n  }\n\n  define(target, key, { set, get });\n  set(value, silent);\n}\n\ntype Proxy<T = any> = (key: string | number, value: T) => T;\n\nconst OBSERVER = new WeakMap<Model, Proxy>();\n\nfunction watch(from: Model, key: string | number, value?: any){\n  const access = OBSERVER.get(from);\n  return access ? access(key, value) : value;\n}\n\nfunction fetch(subject: Model, property: string, required?: boolean){\n  const state = STATE.get(subject)!;\n  \n  if(property in state || required === false){\n    const value = state[property];\n\n    if(value !== undefined || !required)\n      return value;\n  }\n\n  const error = new Error(`${subject}.${property} is not yet available.`);\n  const promise = new Promise<any>((resolve, reject) => {\n    addListener(subject, key => {\n      if(key === property){\n        resolve(state[key]);\n        return null;\n      }\n\n      if(key === null)\n        reject(new Error(`${subject} is destroyed.`));\n    });\n  });\n\n  throw Object.assign(promise, {\n    toString: () => String(error),\n    name: \"Suspense\",\n    message: error.message,\n    stack: error.stack\n  });\n}\n\n/** Currently accumulating export. Stores real values of placeholder properties such as ref() or child models. */\nlet EXPORT: Map<any, any> | undefined;\n\nfunction snapshot<T extends Model>(model: T): Model.State<T> {\n  const values = {} as any;\n  let isNotRecursive;\n\n  if(!EXPORT){\n    isNotRecursive = true;\n    EXPORT = new Map([[model, values]]);\n  }\n\n  for(let [key, value] of model){\n    if(EXPORT.has(value))\n      value = EXPORT.get(value);\n    else if(value && typeof value == \"object\" && \"get\" in value && typeof value.get === \"function\")\n      EXPORT.set(value, value = value.get());\n\n    values[key] = value;\n  }\n\n  if(isNotRecursive)\n    EXPORT = undefined;\n\n  return Object.freeze(values);\n}\n\nfunction update<T>(\n  subject: Model,\n  key: string | number | symbol,\n  value: T,\n  arg?: boolean | Model.Setter<T>){\n\n  const state = STATE.get(subject)!;\n\n  if(Object.isFrozen(state))\n    throw new Error(`Tried to update ${String(key)} but ${subject} is destroyed.`);\n\n  const previous = state[key] as T;\n\n  if(typeof arg == \"function\"){\n    const out = arg.call(subject, value, previous);\n\n    if(out === false)\n      return false;\n\n    if(typeof out == \"function\")\n      value = out();\n  }\n\n  if(value === previous && value !== undefined)\n    return;\n\n  state[key] = value;\n\n  if(arg !== true)\n    event(subject, key);\n\n  return true;\n}\n\n/** Random alphanumberic of length 6; always starts with a letter. */\nfunction uid(){\n  return (0.278 + Math.random() * 0.722).toString(36).substring(2, 8).toUpperCase();\n}\n\nexport {\n  event,\n  fetch,\n  METHOD,\n  Model,\n  PARENT,\n  STATE,\n  uid,\n  update,\n  watch\n}"],
  "mappings": "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",
  "names": ["watch", "update", "res", "bind", "value", "silent"]
}


package/dist/index.d.ts

@@ -8,12 +8,15 @@
  *   - `null` - terminal event; instance is expired.
  * @param source - Instance of Model for which update has occured.
  */
-type OnUpdate<T extends Model = any> = (this: T, key: unknown, source: T) => (() => void) | null | void;
-type OnAccess<T extends Model = any, R = unknown> = (from: T, key: string | number, value: R) => unknown;
-type Effect<T extends Model> = (this: T, proxy: T) => ((update: boolean | null) => void) | Promise<void> | null | void;
+type OnUpdate<T extends Observable = any> = (this: T, key: unknown, source: T) => (() => void) | null | void;
+type Effect<T extends Observable> = (this: T, proxy: T) => ((update: boolean | null) => void) | Promise<void> | null | void;
 type Event = number | string | null | boolean | symbol;
-declare function addListener<T extends Model>(subject: T, callback: OnUpdate<T>, select?: Event): () => boolean;
-declare function createProxy<T extends Model>(from: T, observer: OnAccess<T>): T;
+interface Observable {
+    [Observable](callback: OnUpdate, required?: boolean): this;
+}
+declare const Observable: unique symbol;
+declare function addListener<T extends Observable>(subject: T, callback: OnUpdate<T>, select?: Event | Set<Event>): () => boolean;
+declare function event(subject: Observable, key?: string | number | symbol | null, silent?: boolean): void;
 /**
  * Create a side-effect which will update whenever values accessed change.
  * Callback is called immediately and whenever values are stale.
@@ -22,8 +25,8 @@ declare function createProxy<T extends Model>(from: T, observer: OnAccess<T>): T
  * @param callback - Function to invoke when values change.
  * @param requireValues - If `true` will throw if accessing a value which is `undefined`.
  */
-declare function createEffect<T extends Model>(target: T, callback: Effect<Required<T>>, requireValues: true): () => void;
-declare function createEffect<T extends Model>(target: T, callback: Effect<T>, recursive?: boolean): () => void;
+declare function createEffect<T extends Observable>(target: T, callback: Effect<Required<T>>, requireValues: true): () => void;
+declare function createEffect<T extends Observable>(target: T, callback: Effect<T>, recursive?: boolean): () => void;
 
 /** Reference bound instance methods to real ones. */
 declare const METHOD: WeakMap<any, any>;
@@ -112,8 +115,9 @@ interface Model {
      **/
     is: this;
 }
-declare abstract class Model {
+declare abstract class Model implements Observable {
     constructor(...args: Model.Args);
+    [Observable](callback: OnUpdate, required?: boolean): this;
     /**
      * Pull current values from state. Flattens all models and exotic values recursively.
      *
@@ -189,6 +193,22 @@ declare abstract class Model {
      * @returns Promise resolves an array of keys updated.
      */
     set(key: Model.Event<this>): PromiseLike<Model.Event<this>[]>;
+    /**
+     * Set a value for a property. This will update the value and notify listeners.
+     *
+     * **Use with caution!** Key nor value are checked for validity.
+     *
+     * This is meant for assigning values programmatically,
+     * where simple assignment is not practicable.
+     *
+     * For example: `(this as any)[myProperty] = value;`
+     *
+     * @param key - Property to set value for.
+     * @param value - Value to set for property.
+     * @param init - If true, model will begin to manage the property if it is not already.
+     * @returns Promise resolves an array of keys updated.
+     */
+    set(key: Model.Event<this>, value: unknown, init?: boolean): PromiseLike<Model.Event<this>[]>;
     /**
      * Call a function when update occurs.
      *
@@ -206,10 +226,10 @@ declare abstract class Model {
      * Call a function when a property is updated.
      * Unlike `get`, this calsl synchronously and will fire as many times as the property is updated.
      *
-     * @param key - Property to watch for updates.
      * @param callback - Function to call when property is updated.
+     * @param event - Property to watch for updates.
      */
-    set(key: Model.Event<this> | null, callback: Model.OnEvent<this>): () => boolean;
+    set(callback: Model.OnEvent<this>, event: Model.Event<this> | null): () => boolean;
     /**
      * Declare an end to updates. This event is final and will freeze state.
      * This event can be watched for as well, to run cleanup logic and internally will remove all listeners.
@@ -442,4 +462,4 @@ declare class Context {
     protected add<T extends Model>(input: T | Model.Init<T>, implicit?: boolean): T;
 }
 
-export { Context, METHOD, Model, addListener, createEffect, createProxy, Model as default, get, has, ref, set, use };
+export { Context, METHOD, Model, Observable, addListener, createEffect, Model as default, event, get, has, ref, set, use };