@expressive/mvc 0.46.0 → 0.47.0

package/dist/index.d.ts

@@ -201,8 +201,6 @@ declare class Model {
     static at<T extends Model>(this: Model.Type<T>, from: Model, cb: (got: T | undefined) => void): void;
 }
 
-declare function add<T = any>(instruction: Model.Instruction): T;
-
 declare namespace get {
     type Function<T, S = any> = (on: S, key: string) => T;
     type Factory<T, S = any> = (this: S, key: string, thisArg: S) => T;
@@ -346,19 +344,9 @@ declare function set<T>(factory: set.Factory<T> | Promise<T>, required?: boolean
  */
 declare function set<T>(value: T | undefined, onUpdate: set.Callback<T>): T;
 
-/** Create a placeholder for specified Model type. */
-declare function use<T extends Model>(): T | undefined;
-/** Create a new child instance of model. */
+declare function use<T = any>(instruction: Model.Instruction): T;
+declare function use<T extends Model>(Type: Model.Type<T>, required: false): T | undefined;
 declare function use<T extends Model>(Type: Model.Type<T>, ready?: (i: T) => void): T;
-/**
- * Use existing model as a child of model assigned to.
- *
- * Note: If `peer` is not already initialized before parent is
- * (created with `new` as opposed to create method), that model will
- * attach this via `parent()` instruction. It will not, however, if
- * already active.
- **/
-declare function use<T extends Model>(model: T, ready?: (i: T) => void): T;
 
 declare namespace has {
     type Callback<T = any> = (model: T) => void | boolean | (() => void);
@@ -404,4 +392,4 @@ declare global {
     }
 }
 
-export { Context, Model, add, Model as default, get, has, ref, set, use };
+export { Context, Model, Model as default, get, has, ref, set, use };

package/dist/index.js

@@ -22,7 +22,6 @@ var src_exports = {};
 __export(src_exports, {
   Context: () => Context,
   Model: () => Model,
-  add: () => add,
   default: () => Model,
   get: () => get,
   has: () => has,
@@ -197,7 +196,7 @@ var Model = class _Model {
       for (const key in this) {
         const desc = Object.getOwnPropertyDescriptor(this, key);
         if ("value" in desc) {
-          state[key] = desc.value;
+          update(this, key, desc.value, true);
           define(this, key, {
             configurable: false,
             set: (x) => update(this, key, x),
@@ -207,6 +206,8 @@ var Model = class _Model {
           });
         }
       }
+      if (!PARENT.has(this))
+        PARENT.set(this, null);
       addListener(this, () => {
         if (!done)
           throw new Error(`Tried to destroy ${this} but not fully initialized.`);
@@ -368,6 +369,10 @@ function update(subject, key, value, silent) {
   const previous = state[key];
   if (value === previous)
     return true;
+  if (value instanceof Model && !PARENT.has(value)) {
+    PARENT.set(value, subject);
+    event(value, true);
+  }
   state[key] = value;
   if (silent !== true)
     push(subject, key);
@@ -424,26 +429,42 @@ function uid() {
   return (Math.random() * 0.722 + 0.278).toString(36).substring(2, 8).toUpperCase();
 }
 
-// src/instruction/add.ts
+// src/instruction/use.ts
 var INSTRUCT = /* @__PURE__ */ new Map();
-function add(instruction) {
+function use(model, argument) {
   const token = Symbol("instruction");
-  INSTRUCT.set(token, instruction);
+  if (Model.is(model)) {
+    const type = model;
+    const value = new model();
+    model = (key, subject) => {
+      function set2(next) {
+        if (next ? !(next instanceof type) : argument !== false)
+          throw new Error(`${subject}.${key} expected Model of type ${type} but got ${next && next.constructor}.`);
+        update(subject, key, next);
+        if (next && typeof argument == "function")
+          argument(next);
+        return false;
+      }
+      set2(value);
+      return { set: set2, value };
+    };
+  }
+  INSTRUCT.set(token, model);
   return token;
 }
 Model.on((_, subject) => {
   const state = STATE.get(subject);
-  Object.entries(
-    Object.getOwnPropertyDescriptors(subject)
-  ).forEach(([key, { value }]) => {
+  const props = Object.getOwnPropertyDescriptors(subject);
+  for (const key in props) {
+    const { value } = props[key];
     const instruction = INSTRUCT.get(value);
     if (!instruction)
-      return;
+      continue;
     INSTRUCT.delete(value);
     delete subject[key];
     const output = instruction.call(subject, key, subject, state);
     if (!output)
-      return;
+      continue;
     const desc = typeof output == "object" ? output : { get: output };
     const { enumerable = true } = desc;
     if ("value" in desc)
@@ -472,20 +493,21 @@ Model.on((_, subject) => {
         );
       }
     });
-  });
+  }
   return null;
 });
 
 // src/instruction/get.ts
+var STALE = /* @__PURE__ */ new WeakSet();
 function get(arg0, arg1) {
-  return add((key, subject) => {
+  return use((key, subject) => {
     let from = subject;
     if (typeof arg0 == "symbol")
       throw new Error(`Attempted to use an instruction result (probably use or get) as computed source for ${from}.${key}. This is not allowed.`);
     let source = (resolve) => resolve(from);
-    if (arg0 instanceof Model)
+    if (arg0 instanceof Model) {
       from = arg0;
-    else if (Model.is(arg0)) {
+    } else if (arg0.prototype instanceof Model) {
       const hasParent = PARENT.get(from);
       if (!hasParent) {
         if (arg1 === true)
@@ -502,63 +524,61 @@ function get(arg0, arg1) {
         from = hasParent;
       else
         throw new Error(`New ${from} created as child of ${hasParent}, but must be instanceof ${arg0}.`);
-    } else if (typeof arg0 == "function") {
+    } else {
       const fn = METHOD.get(arg0) || arg0;
       arg1 = (p, k) => fn.call(p, k, p);
     }
-    if (typeof arg1 == "function")
-      return compute(subject, key, source, arg1);
-    source((got) => subject.set(key, got));
-    return { get: arg1 };
-  });
-}
-var STALE = /* @__PURE__ */ new WeakSet();
-function compute(subject, key, source, setter) {
-  let reset;
-  let isAsync;
-  let proxy;
-  function connect(model) {
-    reset = effect(model, (current) => {
-      proxy = current;
-      if (!reset)
-        compute2(true);
-      else if (STALE.delete(compute2))
-        compute2();
-      return (didUpdate) => {
-        if (didUpdate) {
-          STALE.add(compute2);
-          push(subject, key, true);
+    if (typeof arg1 == "function") {
+      let connect2 = function(model) {
+        reset = effect(model, (current) => {
+          proxy = current;
+          if (!reset)
+            compute2(true);
+          else if (STALE.delete(compute2))
+            compute2();
+          return (didUpdate) => {
+            if (didUpdate) {
+              STALE.add(compute2);
+              push(subject, key, true);
+            }
+          };
+        });
+      }, compute2 = function(initial) {
+        let next;
+        try {
+          next = getter.call(proxy, proxy, key);
+        } catch (err) {
+          console.warn(`An exception was thrown while ${initial ? "initializing" : "refreshing"} ${subject}.${key}.`);
+          if (initial)
+            throw err;
+          console.error(err);
         }
+        update(subject, key, next, !isAsync);
       };
-    });
-  }
-  function compute2(initial) {
-    let next;
-    try {
-      next = setter.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(compute2))
-      compute2();
-    return fetch(subject, key, !proxy);
-  };
+      var connect = connect2, compute = compute2;
+      const getter = arg1;
+      let reset;
+      let isAsync;
+      let proxy;
+      return () => {
+        if (!proxy) {
+          source(connect2);
+          isAsync = true;
+        }
+        if (STALE.delete(compute2))
+          compute2();
+        return fetch(subject, key, !proxy);
+      };
+    } else
+      source((got) => subject.set(key, got));
+    return { get: arg1 };
+  });
 }
 
 // src/instruction/ref.ts
 var define2 = Object.defineProperty;
 function ref(arg, arg2) {
-  return add((key, subject, state) => {
+  return use((key, subject, state) => {
     let value = {};
     if (arg === subject)
       subject.get(() => {
@@ -608,7 +628,7 @@ function ref(arg, arg2) {
 
 // src/instruction/set.ts
 function set(value, argument) {
-  return add((key, subject) => {
+  return use((key, subject) => {
     const output = {};
     if (typeof value == "function" || value instanceof Promise) {
       let init2 = function() {
@@ -664,11 +684,11 @@ function set(value, argument) {
 function attempt(fn) {
   function retry(err) {
     if (err instanceof Promise)
-      return err.then(compute2);
+      return err.then(compute);
     else
       throw err;
   }
-  function compute2() {
+  function compute() {
     try {
       const output = fn();
       return output instanceof Promise ? output.catch(retry) : output;
@@ -676,27 +696,7 @@ function attempt(fn) {
       return retry(err);
     }
   }
-  return compute2();
-}
-
-// src/instruction/use.ts
-function use(value, argument) {
-  return add((property, subject) => {
-    if (typeof value === "function")
-      value = new value();
-    function set2(next) {
-      if (value instanceof Model && !(next instanceof value.constructor))
-        throw new Error(`${subject}.${property} expected Model of type ${value.constructor} but got ${next}.`);
-      if (next instanceof Model) {
-        PARENT.set(next, subject);
-        event(next, true);
-      }
-      if (typeof argument == "function")
-        argument(next);
-    }
-    set2(value);
-    return { set: set2, value };
-  });
+  return compute();
 }
 
 // src/context.ts
@@ -829,7 +829,7 @@ function reject(argument) {
 
 // src/instruction/has.ts
 function has(type, argument) {
-  return add((key, subject, state) => {
+  return use((key, subject, state) => {
     if (typeof argument == "boolean") {
       Context.request(type, subject, (model) => {
         subject.set(key, model);
@@ -871,7 +871,6 @@ function has(type, argument) {
 0 && (module.exports = {
   Context,
   Model,
-  add,
   get,
   has,
   ref,

package/dist/index.mjs

@@ -163,7 +163,7 @@ var Model = class _Model {
       for (const key in this) {
         const desc = Object.getOwnPropertyDescriptor(this, key);
         if ("value" in desc) {
-          state[key] = desc.value;
+          update(this, key, desc.value, true);
           define(this, key, {
             configurable: false,
             set: (x) => update(this, key, x),
@@ -173,6 +173,8 @@ var Model = class _Model {
           });
         }
       }
+      if (!PARENT.has(this))
+        PARENT.set(this, null);
       addListener(this, () => {
         if (!done)
           throw new Error(`Tried to destroy ${this} but not fully initialized.`);
@@ -334,6 +336,10 @@ function update(subject, key, value, silent) {
   const previous = state[key];
   if (value === previous)
     return true;
+  if (value instanceof Model && !PARENT.has(value)) {
+    PARENT.set(value, subject);
+    event(value, true);
+  }
   state[key] = value;
   if (silent !== true)
     push(subject, key);
@@ -390,26 +396,42 @@ function uid() {
   return (Math.random() * 0.722 + 0.278).toString(36).substring(2, 8).toUpperCase();
 }
 
-// src/instruction/add.ts
+// src/instruction/use.ts
 var INSTRUCT = /* @__PURE__ */ new Map();
-function add(instruction) {
+function use(model, argument) {
   const token = Symbol("instruction");
-  INSTRUCT.set(token, instruction);
+  if (Model.is(model)) {
+    const type = model;
+    const value = new model();
+    model = (key, subject) => {
+      function set2(next) {
+        if (next ? !(next instanceof type) : argument !== false)
+          throw new Error(`${subject}.${key} expected Model of type ${type} but got ${next && next.constructor}.`);
+        update(subject, key, next);
+        if (next && typeof argument == "function")
+          argument(next);
+        return false;
+      }
+      set2(value);
+      return { set: set2, value };
+    };
+  }
+  INSTRUCT.set(token, model);
   return token;
 }
 Model.on((_, subject) => {
   const state = STATE.get(subject);
-  Object.entries(
-    Object.getOwnPropertyDescriptors(subject)
-  ).forEach(([key, { value }]) => {
+  const props = Object.getOwnPropertyDescriptors(subject);
+  for (const key in props) {
+    const { value } = props[key];
     const instruction = INSTRUCT.get(value);
     if (!instruction)
-      return;
+      continue;
     INSTRUCT.delete(value);
     delete subject[key];
     const output = instruction.call(subject, key, subject, state);
     if (!output)
-      return;
+      continue;
     const desc = typeof output == "object" ? output : { get: output };
     const { enumerable = true } = desc;
     if ("value" in desc)
@@ -438,20 +460,21 @@ Model.on((_, subject) => {
         );
       }
     });
-  });
+  }
   return null;
 });
 
 // src/instruction/get.ts
+var STALE = /* @__PURE__ */ new WeakSet();
 function get(arg0, arg1) {
-  return add((key, subject) => {
+  return use((key, subject) => {
     let from = subject;
     if (typeof arg0 == "symbol")
       throw new Error(`Attempted to use an instruction result (probably use or get) as computed source for ${from}.${key}. This is not allowed.`);
     let source = (resolve) => resolve(from);
-    if (arg0 instanceof Model)
+    if (arg0 instanceof Model) {
       from = arg0;
-    else if (Model.is(arg0)) {
+    } else if (arg0.prototype instanceof Model) {
       const hasParent = PARENT.get(from);
       if (!hasParent) {
         if (arg1 === true)
@@ -468,63 +491,61 @@ function get(arg0, arg1) {
         from = hasParent;
       else
         throw new Error(`New ${from} created as child of ${hasParent}, but must be instanceof ${arg0}.`);
-    } else if (typeof arg0 == "function") {
+    } else {
       const fn = METHOD.get(arg0) || arg0;
       arg1 = (p, k) => fn.call(p, k, p);
     }
-    if (typeof arg1 == "function")
-      return compute(subject, key, source, arg1);
-    source((got) => subject.set(key, got));
-    return { get: arg1 };
-  });
-}
-var STALE = /* @__PURE__ */ new WeakSet();
-function compute(subject, key, source, setter) {
-  let reset;
-  let isAsync;
-  let proxy;
-  function connect(model) {
-    reset = effect(model, (current) => {
-      proxy = current;
-      if (!reset)
-        compute2(true);
-      else if (STALE.delete(compute2))
-        compute2();
-      return (didUpdate) => {
-        if (didUpdate) {
-          STALE.add(compute2);
-          push(subject, key, true);
+    if (typeof arg1 == "function") {
+      let connect2 = function(model) {
+        reset = effect(model, (current) => {
+          proxy = current;
+          if (!reset)
+            compute2(true);
+          else if (STALE.delete(compute2))
+            compute2();
+          return (didUpdate) => {
+            if (didUpdate) {
+              STALE.add(compute2);
+              push(subject, key, true);
+            }
+          };
+        });
+      }, compute2 = function(initial) {
+        let next;
+        try {
+          next = getter.call(proxy, proxy, key);
+        } catch (err) {
+          console.warn(`An exception was thrown while ${initial ? "initializing" : "refreshing"} ${subject}.${key}.`);
+          if (initial)
+            throw err;
+          console.error(err);
         }
+        update(subject, key, next, !isAsync);
       };
-    });
-  }
-  function compute2(initial) {
-    let next;
-    try {
-      next = setter.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(compute2))
-      compute2();
-    return fetch(subject, key, !proxy);
-  };
+      var connect = connect2, compute = compute2;
+      const getter = arg1;
+      let reset;
+      let isAsync;
+      let proxy;
+      return () => {
+        if (!proxy) {
+          source(connect2);
+          isAsync = true;
+        }
+        if (STALE.delete(compute2))
+          compute2();
+        return fetch(subject, key, !proxy);
+      };
+    } else
+      source((got) => subject.set(key, got));
+    return { get: arg1 };
+  });
 }
 
 // src/instruction/ref.ts
 var define2 = Object.defineProperty;
 function ref(arg, arg2) {
-  return add((key, subject, state) => {
+  return use((key, subject, state) => {
     let value = {};
     if (arg === subject)
       subject.get(() => {
@@ -574,7 +595,7 @@ function ref(arg, arg2) {
 
 // src/instruction/set.ts
 function set(value, argument) {
-  return add((key, subject) => {
+  return use((key, subject) => {
     const output = {};
     if (typeof value == "function" || value instanceof Promise) {
       let init2 = function() {
@@ -630,11 +651,11 @@ function set(value, argument) {
 function attempt(fn) {
   function retry(err) {
     if (err instanceof Promise)
-      return err.then(compute2);
+      return err.then(compute);
     else
       throw err;
   }
-  function compute2() {
+  function compute() {
     try {
       const output = fn();
       return output instanceof Promise ? output.catch(retry) : output;
@@ -642,27 +663,7 @@ function attempt(fn) {
       return retry(err);
     }
   }
-  return compute2();
-}
-
-// src/instruction/use.ts
-function use(value, argument) {
-  return add((property, subject) => {
-    if (typeof value === "function")
-      value = new value();
-    function set2(next) {
-      if (value instanceof Model && !(next instanceof value.constructor))
-        throw new Error(`${subject}.${property} expected Model of type ${value.constructor} but got ${next}.`);
-      if (next instanceof Model) {
-        PARENT.set(next, subject);
-        event(next, true);
-      }
-      if (typeof argument == "function")
-        argument(next);
-    }
-    set2(value);
-    return { set: set2, value };
-  });
+  return compute();
 }
 
 // src/context.ts
@@ -795,7 +796,7 @@ function reject(argument) {
 
 // src/instruction/has.ts
 function has(type, argument) {
-  return add((key, subject, state) => {
+  return use((key, subject, state) => {
     if (typeof argument == "boolean") {
       Context.request(type, subject, (model) => {
         subject.set(key, model);
@@ -836,7 +837,6 @@ function has(type, argument) {
 export {
   Context,
   Model,
-  add,
   Model as default,
   get,
   has,

package/package.json

@@ -28,6 +28,6 @@
     "prebuild": "rm -rf dist",
     "preversion": "npm run test && npm run build"
   },
-  "version": "0.46.0",
-  "gitHead": "22ffbbadad0ab45f73c71e178183941e78ed2a56"
+  "version": "0.47.0",
+  "gitHead": "7c0ddd5ea9b7e08bd5aa21aa8e1ab65ceef17fcf"
 }