@expressive/mvc 0.53.6 → 0.54.0

package/dist/esm/instruction/set.mjs

@@ -0,0 +1,83 @@
+import { context } from "../control";
+import { event, update } from "../model";
+import { use } from "./use";
+function set(value, argument) {
+  return use((key, subject) => {
+    const property = {};
+    if (typeof value == "function" || value instanceof Promise) {
+      let init2 = function() {
+        if (typeof value == "function")
+          try {
+            value = attempt(value.bind(subject, key));
+          } catch (err) {
+            console.warn(`Generating initial value for ${subject}.${key} failed.`);
+            throw err;
+          }
+        property.get = argument === true;
+        if (value instanceof Promise) {
+          value.then((value2) => {
+            update(subject, key, value2);
+            return value2;
+          }).catch((err) => {
+            event(subject, key);
+            property.get = () => {
+              throw err;
+            };
+          });
+        } else
+          update(subject, key, value);
+        if (0 in arguments)
+          return subject[key];
+      };
+      var init = init2;
+      if (argument)
+        init2();
+      else
+        property.get = init2;
+    } else if (value !== void 0)
+      property.value = value;
+    if (typeof argument == "function") {
+      let unset;
+      property.set = function(value2, previous) {
+        const ctx = context();
+        const out = argument.call(this, value2, previous);
+        const flush = ctx();
+        if (out === false)
+          return out;
+        if (typeof unset == "function")
+          unset(value2);
+        unset = (next) => {
+          if (typeof out == "function")
+            out(next);
+          flush();
+        };
+      };
+    } else
+      property.set = (value2) => {
+        property.get = void 0;
+        update(subject, key, value2);
+      };
+    return property;
+  });
+}
+function attempt(fn) {
+  function retry(err) {
+    if (err instanceof Promise)
+      return err.then(compute);
+    else
+      throw err;
+  }
+  function compute() {
+    try {
+      const output = fn();
+      return output instanceof Promise ? output.catch(retry) : output;
+    } catch (err) {
+      return retry(err);
+    }
+  }
+  return compute();
+}
+export {
+  set
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/instruction/use.mjs

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

package/dist/esm/model.mjs

@@ -0,0 +1,274 @@
+import { addListener, createEffect, event, pending, PENDING_KEYS, watch } from "./control";
+const define = Object.defineProperty;
+const ID = /* @__PURE__ */ new WeakMap();
+const STATE = /* @__PURE__ */ new WeakMap();
+const NOTIFY = /* @__PURE__ */ new WeakMap();
+const PARENT = /* @__PURE__ */ new WeakMap();
+const METHODS = /* @__PURE__ */ new WeakMap();
+const METHOD = /* @__PURE__ */ new WeakMap();
+class Model {
+  constructor(...args) {
+    prepare(this);
+    define(this, "is", { value: this });
+    init(this, args);
+  }
+  get(arg1, arg2) {
+    const self = this.is;
+    if (typeof arg1 == "function") {
+      let pending2 = /* @__PURE__ */ new Set();
+      return createEffect(self, (proxy) => {
+        const cb = arg1.call(proxy, proxy, pending2);
+        return cb === null ? null : (update2) => {
+          pending2 = PENDING_KEYS.get(self);
+          if (typeof cb == "function")
+            cb(update2);
+        };
+      });
+    }
+    if (arg1 === void 0)
+      return snapshot(self);
+    if (typeof arg2 == "function")
+      return addListener(self, arg2, arg1);
+    return arg1 === null ? Object.isFrozen(STATE.get(self)) : fetch(self, arg1, arg2);
+  }
+  set(arg1, arg2) {
+    const self = this.is;
+    if (typeof arg1 == "function")
+      return addListener(self, (key) => {
+        if (typeof key == "string")
+          return arg1.call(self, key, self);
+      });
+    if (arg1 && typeof arg1 == "object") {
+      const methods = METHODS.get(self.constructor);
+      for (const key in arg1)
+        if (methods.has(key))
+          self[key] = arg1[key];
+        else if (key in self)
+          update(self, key, arg1[key], arg2 === true);
+    } else
+      event(self, arg1);
+    return pending(self);
+  }
+  /**
+   * Iterate over managed properties in this instance of Model.
+   * Yeilds the key and current value for each property.
+   */
+  [Symbol.iterator]() {
+    return Object.entries(STATE.get(this.is))[Symbol.iterator]();
+  }
+  /**
+   * Create and activate a new instance of this model.
+   * 
+   * **Important** - Unlike `new this(...)` - this method also activates state.
+   * 
+   * @param args - arguments sent to constructor
+   */
+  static new(...args) {
+    const instance = new this(...args);
+    event(instance);
+    return instance;
+  }
+  /**
+   * Static equivalent of `x instanceof this`.
+   * Determines if provided class is a subtype of this one.
+   * If so, language server will make available all static
+   * methods and properties of this class.
+   */
+  static is(maybe) {
+    return maybe === this || typeof maybe == "function" && maybe.prototype instanceof this;
+  }
+  /**
+   * Register a callback to run when any instance of this Model is updated. 
+   */
+  static on(listener) {
+    let notify = NOTIFY.get(this);
+    if (!notify)
+      NOTIFY.set(this, notify = /* @__PURE__ */ new Set());
+    notify.add(listener);
+    return () => notify.delete(listener);
+  }
+}
+define(Model.prototype, "toString", {
+  value() {
+    return ID.get(this.is);
+  }
+});
+define(Model, "toString", {
+  value() {
+    return this.name;
+  }
+});
+function prepare(model) {
+  let T = model.constructor;
+  if (T === Model)
+    throw new Error("Cannot create base Model.");
+  const chain = [];
+  let keys = /* @__PURE__ */ new Set();
+  ID.set(model, `${T}-${uid()}`);
+  while (T.name) {
+    for (const cb of NOTIFY.get(T) || [])
+      addListener(model, cb);
+    if (T === Model) break;
+    else chain.unshift(T);
+    T = Object.getPrototypeOf(T);
+  }
+  for (const type of chain) {
+    if (METHODS.has(type)) {
+      keys = METHODS.get(type);
+      continue;
+    }
+    METHODS.set(type, keys = new Set(keys));
+    for (const [key, { value }] of Object.entries(
+      Object.getOwnPropertyDescriptors(type.prototype)
+    )) {
+      let bind2 = function(method = value) {
+        const value2 = method.bind(this.is);
+        METHOD.set(value2, method);
+        define(this.is, key, { value: value2, writable: true });
+        return value2;
+      };
+      var bind = bind2;
+      if (!value || key == "constructor")
+        continue;
+      keys.add(key);
+      define(type.prototype, key, { get: bind2, set: bind2 });
+    }
+  }
+}
+function init(model, args) {
+  const methods = METHODS.get(model.constructor);
+  const state = {};
+  STATE.set(model, state);
+  args = args.flat().filter((arg) => {
+    if (typeof arg != "string")
+      return true;
+    ID.set(model, arg);
+  });
+  addListener(model, () => {
+    if (!PARENT.has(model))
+      PARENT.set(model, null);
+    args.forEach((arg) => {
+      const use = typeof arg == "function" ? arg.call(model, model) : arg;
+      if (use instanceof Promise)
+        use.catch((err) => {
+          console.error(`Async error in constructor for ${model}:`);
+          console.error(err);
+        });
+      else if (typeof use == "function")
+        addListener(model, use, null);
+      else if (typeof use == "object") {
+        for (const key in use)
+          if (key in model || methods.has(key))
+            model[key] = use[key];
+      }
+    });
+    for (const key in model) {
+      const desc = Object.getOwnPropertyDescriptor(model, key);
+      if ("value" in desc) {
+        update(model, key, desc.value, true);
+        define(model, key, {
+          configurable: false,
+          get() {
+            return watch(this, key, state[key]);
+          },
+          set(value) {
+            update(model, key, value);
+            mayAdopt(model, value);
+          }
+        });
+      }
+    }
+    addListener(model, () => {
+      for (const [_, value] of model)
+        if (value instanceof Model && PARENT.get(value) === model)
+          value.set(null);
+      Object.freeze(state);
+    }, null);
+    return null;
+  });
+}
+function mayAdopt(parent, child) {
+  if (child instanceof Model && !PARENT.has(child)) {
+    PARENT.set(child, parent);
+    event(child);
+  }
+}
+function fetch(subject, property, required) {
+  const state = STATE.get(subject);
+  if (property in state || required === false) {
+    const value = state[property];
+    if (value !== void 0 || !required)
+      return value;
+  }
+  const error = new Error(`${subject}.${property} is not yet available.`);
+  const promise = new Promise((resolve, reject) => {
+    addListener(subject, (key) => {
+      if (key === property) {
+        resolve(state[key]);
+        return null;
+      }
+      if (key === null)
+        reject(new Error(`${subject} is destroyed.`));
+    });
+  });
+  throw Object.assign(promise, {
+    toString: () => String(error),
+    name: "Suspense",
+    message: error.message,
+    stack: error.stack
+  });
+}
+let EXPORT;
+function snapshot(model) {
+  const values = {};
+  let isNotRecursive;
+  if (!EXPORT) {
+    isNotRecursive = true;
+    EXPORT = /* @__PURE__ */ new Map([[model, values]]);
+  }
+  for (let [key, value] of model) {
+    if (EXPORT.has(value))
+      value = EXPORT.get(value);
+    else if (value && typeof value == "object" && "get" in value && typeof value.get === "function")
+      EXPORT.set(value, value = value.get());
+    values[key] = value;
+  }
+  if (isNotRecursive)
+    EXPORT = void 0;
+  return Object.freeze(values);
+}
+function update(subject, key, value, arg) {
+  const state = STATE.get(subject);
+  if (Object.isFrozen(state))
+    throw new Error(`Tried to update ${String(key)} but ${subject} is destroyed.`);
+  const previous = state[key];
+  if (typeof arg == "function") {
+    const out = arg.call(subject, value, previous);
+    if (out === false)
+      return false;
+    if (typeof out == "function")
+      value = out();
+  }
+  if (value === previous)
+    return;
+  state[key] = value;
+  if (arg !== true)
+    event(subject, key);
+  return true;
+}
+function uid() {
+  return (0.278 + Math.random() * 0.722).toString(36).substring(2, 8).toUpperCase();
+}
+export {
+  METHOD,
+  Model,
+  PARENT,
+  STATE,
+  define,
+  event,
+  fetch,
+  mayAdopt,
+  uid,
+  update
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/model.ts"],
  "sourcesContent": ["import { addListener, createEffect, event, OnUpdate, pending, PENDING_KEYS, watch } from './control';\n\nexport const 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, Set<string>>();\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 Exclude<keyof T, keyof Model>]?:\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    if(arg1 === undefined)\n      return snapshot(self);\n\n    if(typeof arg2 == \"function\")\n      return addListener(self, arg2, arg1)\n\n    return arg1 === null\n      ? Object.isFrozen(STATE.get(self))\n      : fetch(self, arg1, arg2);\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   * 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\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(arg1 && typeof arg1 == \"object\"){\n      const methods = METHODS.get(self.constructor as Model.Type)!;\n    \n      for(const key in arg1)\n        if(methods.has(key))\n          self[key as keyof this] = arg1[key] as any;\n        else if(key in self)\n          update(self, key, arg1[key], arg2 === true);\n    }\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\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 Set<string>();\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 Set(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, method = value){\n        const value = method.bind(this.is);\n        \n        METHOD.set(value, method);\n        define(this.is, key, { value, writable: true });\n        \n        return value;\n      }\n\n      keys.add(key);\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 methods = METHODS.get(model.constructor as Model.Type)!;\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    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        for(const key in use)\n          if(key in model || methods.has(key))\n            model[key as keyof Model] = use[key] as any;\n    });\n\n    for(const key in model){\n      const desc = Object.getOwnPropertyDescriptor(model, key)!;\n\n      if(\"value\" in desc){\n        update(model, key, desc.value, true);\n        define(model, key, {\n          configurable: false,\n          get(){\n            return watch(this, key, state[key]);\n          },\n          set(value){\n            update(model, key, value);\n            mayAdopt(model, value);\n          }\n        });\n      }\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 mayAdopt(parent: Model, child: unknown){\n  if(child instanceof Model && !PARENT.has(child)){\n    PARENT.set(child, parent);\n    event(child);\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)\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  mayAdopt,\n  METHOD,\n  Model,\n  PARENT,\n  STATE,\n  uid,\n  update,\n}"],
  "mappings": "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",
  "names": ["pending", "update", "bind", "value"]
}


package/dist/index.js

@@ -974,3 +974,4 @@ function has(arg1, arg2) {
   set,
   use
 });
+//# sourceMappingURL=index.js.map