@expressive/mvc 0.60.3 → 0.62.0

package/dist/index.js

@@ -255,19 +255,9 @@ var Model = class {
         if (key2 === arg1)
           return arg2.call(self, key2, self);
       });
-    if (arg1 && typeof arg1 == "object") {
-      const methods = METHODS.get(self.constructor);
-      for (const key2 in arg1) {
-        const bind = methods.get(key2);
-        if (bind)
-          bind.call(self, arg1[key2]);
-        else if (key2 in self)
-          if (arg2 === true || !Object.getOwnPropertyDescriptor(self, key2)?.set)
-            update(self, key2, arg1[key2], arg2 === true);
-          else
-            self[key2] = arg1[key2];
-      }
-    } else
+    if (arg1 && typeof arg1 == "object")
+      assign(self, arg1, arg2 === true);
+    else
       event(self, arg1);
     return pending(self);
   }
@@ -320,6 +310,19 @@ define(Model, "toString", {
     return this.name;
   }
 });
+function assign(subject, data, silent) {
+  const methods = METHODS.get(subject.constructor);
+  for (const key2 in data) {
+    const bind = methods.get(key2);
+    if (bind)
+      bind.call(subject, data[key2]);
+    else if (key2 in subject && key2 !== "is") {
+      const desc = Object.getOwnPropertyDescriptor(subject, key2);
+      const set2 = desc && desc.set;
+      set2.call(subject, data[key2], silent === true);
+    }
+  }
+}
 function prepare(model) {
   let T = model.constructor;
   if (T === Model)
@@ -358,7 +361,6 @@ function prepare(model) {
   }
 }
 function init(model, args) {
-  const methods = METHODS.get(model.constructor);
   const state = {};
   STATE.set(model, state);
   args = args.flat().filter((arg) => {
@@ -369,21 +371,6 @@ function init(model, args) {
   addListener(model, () => {
     if (!PARENT.has(model))
       PARENT.set(model, null);
-    args.forEach((arg) => {
-      const use2 = typeof arg == "function" ? arg.call(model, model) : arg;
-      if (use2 instanceof Promise)
-        use2.catch((err) => {
-          console.error(`Async error in constructor for ${model}:`);
-          console.error(err);
-        });
-      else if (typeof use2 == "function")
-        addListener(model, use2, null);
-      else if (typeof use2 == "object") {
-        for (const key2 in use2)
-          if (key2 in model || methods.has(key2))
-            model[key2] = use2[key2];
-      }
-    });
     for (const key2 in model) {
       const desc = Object.getOwnPropertyDescriptor(model, key2);
       if ("value" in desc) {
@@ -393,13 +380,25 @@ function init(model, args) {
           get() {
             return watch(this, key2, state[key2]);
           },
-          set(value) {
-            update(model, key2, value);
+          set(value, silent) {
+            update(model, key2, value, silent);
             mayAdopt(model, value);
           }
         });
       }
     }
+    args.forEach((arg) => {
+      const use2 = typeof arg == "function" ? arg.call(model, model) : arg;
+      if (use2 instanceof Promise)
+        use2.catch((err) => {
+          console.error(`Async error in constructor for ${model}:`);
+          console.error(err);
+        });
+      else if (typeof use2 == "function")
+        addListener(model, use2, null);
+      else if (typeof use2 == "object")
+        assign(model, use2, true);
+    });
     addListener(model, () => {
       for (const [_, value] of model)
         if (value instanceof Model && PARENT.get(value) === model)
@@ -409,10 +408,10 @@ function init(model, args) {
     return null;
   });
 }
-function mayAdopt(parent, child) {
-  if (child instanceof Model && !PARENT.has(child)) {
-    PARENT.set(child, parent);
-    event(child);
+function mayAdopt(parent, child2) {
+  if (child2 instanceof Model && !PARENT.has(child2)) {
+    PARENT.set(child2, parent);
+    event(child2);
   }
 }
 function fetch(subject, property, required) {
@@ -471,7 +470,7 @@ function update(subject, key2, value, arg) {
     if (typeof out == "function")
       value = out();
   }
-  if (value === previous)
+  if (value === previous && value !== void 0)
     return;
   state[key2] = value;
   if (arg !== true)
@@ -550,7 +549,7 @@ var Context = class _Context {
     this.layer.clear();
   }
   include(inputs, forEach) {
-    const init2 = /* @__PURE__ */ new Map();
+    const init3 = /* @__PURE__ */ new Map();
     if (typeof inputs == "function" || inputs instanceof Model)
       inputs = { [forEach ? 0 : this.layer.size]: inputs };
     Object.entries(inputs).forEach(([K, V]) => {
@@ -559,7 +558,7 @@ var Context = class _Context {
         if (!exists) {
           const instance = this.add(V);
           this.layer.set(K, V);
-          init2.set(instance, true);
+          init3.set(instance, true);
         } else if (exists !== V) {
           this.pop();
           this.id = uid();
@@ -571,14 +570,14 @@ var Context = class _Context {
         `Context may only include instance or class \`extends Model\` but got ${K == "0" || K == V ? V : `${V} (as '${K}')`}.`
       );
     });
-    for (const [model, explicit] of init2) {
+    for (const [model, explicit] of init3) {
       model.set();
       if (explicit && forEach)
         forEach(model);
       for (const [_key, value] of model)
         if (PARENT.get(value) === model) {
           this.add(value, true);
-          init2.set(value, false);
+          init3.set(value, false);
         }
     }
   }
@@ -628,46 +627,49 @@ var Context = class _Context {
 };
 
 // src/instruction/use.ts
-var INSTRUCT = /* @__PURE__ */ new Map();
+var INSTRUCTION = /* @__PURE__ */ new Map();
 function use(arg1, arg2) {
   const token = Symbol("instruction");
-  if (Model.is(arg1)) {
-    const Type = arg1;
-    arg1 = (key2, subject) => {
-      function set2(next) {
-        if (next ? !(next instanceof Type) : arg2 !== false)
-          throw new Error(`${subject}.${key2} expected Model of type ${Type} but got ${next && next.constructor}.`);
-        update(subject, key2, next);
-        if (next && typeof arg2 == "function")
-          arg2(next);
-        return false;
-      }
-      const value = new Type();
-      set2(value);
-      PARENT.set(value, subject);
-      return { set: set2 };
-    };
-  }
-  INSTRUCT.set(token, arg1);
+  if (Model.is(arg1))
+    arg1 = child(arg1, arg2);
+  INSTRUCTION.set(token, arg1);
   return token;
 }
-Model.on((_, model) => {
-  const state = STATE.get(model);
-  for (const key2 in model) {
-    const { value } = Object.getOwnPropertyDescriptor(model, key2);
-    const instruction = INSTRUCT.get(value);
+function child(type, arg2) {
+  return (key2, subject) => {
+    function set2(next) {
+      if (next ? !(next instanceof type) : arg2 !== false)
+        throw new Error(`${subject}.${key2} expected Model of type ${type} but got ${next && next.constructor}.`);
+      update(subject, key2, next);
+      if (next && typeof arg2 == "function")
+        arg2(next);
+      return false;
+    }
+    const value = new type();
+    set2(value);
+    PARENT.set(value, subject);
+    value.set();
+    return { set: set2 };
+  };
+}
+function init2() {
+  const state = STATE.get(this);
+  for (const key2 in this) {
+    const { value } = Object.getOwnPropertyDescriptor(this, key2);
+    const instruction = INSTRUCTION.get(value);
     if (!instruction) {
-      mayAdopt(model, value);
+      mayAdopt(this, value);
       continue;
     }
-    INSTRUCT.delete(value);
-    delete model[key2];
-    const output = instruction.call(model, key2, model, state);
+    INSTRUCTION.delete(value);
+    delete this[key2];
+    const output = instruction.call(this, key2, this, state);
     if (!output)
       continue;
     const desc = typeof output == "object" ? output : { get: output };
     if ("value" in desc)
       state[key2] = desc.value;
+    const model = this;
     Object.defineProperty(model, key2, {
       enumerable: desc.enumerable !== false,
       get() {
@@ -685,7 +687,8 @@ Model.on((_, model) => {
     });
   }
   return null;
-});
+}
+Model.on(init2);
 
 // src/instruction/get.ts
 var STALE = /* @__PURE__ */ new WeakSet();
@@ -694,27 +697,29 @@ function get(arg0, arg1) {
     if (typeof arg0 == "symbol")
       throw new Error(`Attempted to use an instruction result (probably use or get) as computed source for ${subject}.${key2}. This is not allowed.`);
     if (Model.is(arg0)) {
-      let assign2 = function(value) {
+      let assign3 = function(value) {
         if (typeof arg1 == "function")
           value.get((x) => arg1(x, key2));
         update(subject, key2, value);
       };
-      var assign = assign2;
+      var assign2 = assign3;
       const hasParent = PARENT.get(subject);
-      if (!hasParent) {
-        if (arg1 === true)
-          throw new Error(`${subject} may only exist as a child of type ${arg0}.`);
-        Context.get(subject, (context2) => {
-          const model = context2.get(arg0);
-          if (model)
-            assign2(model);
-          else if (arg1 !== false)
-            throw new Error(`Required ${arg0} not found in context for ${subject}.`);
-        });
-      } else if (!arg0 || hasParent instanceof arg0)
-        assign2(hasParent);
-      else
-        throw new Error(`New ${subject} created as child of ${hasParent}, but must be instanceof ${arg0}.`);
+      if (!hasParent && arg1 === true)
+        throw new Error(`${subject} may only exist as a child of type ${arg0}.`);
+      else if (hasParent) {
+        if (hasParent instanceof arg0) {
+          assign3(hasParent);
+          return {};
+        } else if (arg1 === true)
+          throw new Error(`New ${subject} created as child of ${hasParent}, but must be instanceof ${arg0}.`);
+      }
+      Context.get(subject, (context2) => {
+        const model = context2.get(arg0);
+        if (model)
+          assign3(model);
+        else if (arg1 !== false)
+          throw new Error(`Required ${arg0} not found in context for ${subject}.`);
+      });
       return {
         get: arg1 !== false
       };
@@ -790,8 +795,13 @@ function ref(arg, arg2) {
             const set2 = (value2) => {
               update(subject, key3, value2);
             };
-            defineProperty(set2, "current", { get: get2, set: set2 });
-            defineProperty(set2, "get", { value: get2 });
+            defineProperties(set2, {
+              current: { get: get2, set: set2 },
+              get: { value: get2 },
+              on: {
+                value: (callback) => addListener(subject, () => callback(state[key3]), key3)
+              }
+            });
             defineProperty(value, key3, { value: set2 });
           }
       });
@@ -819,7 +829,10 @@ function ref(arg, arg2) {
       state[key2] = null;
       value = defineProperties(set2, {
         current: { get: get2, set: set2 },
-        get: { value: get2 }
+        get: { value: get2 },
+        on: {
+          value: (callback) => addListener(subject, () => callback(state[key2]), key2)
+        }
       });
     }
     defineProperty(subject, key2, { value });
@@ -831,7 +844,7 @@ function set(value, argument) {
   return use((key2, subject) => {
     const property = {};
     if (typeof value == "function" || value instanceof Promise) {
-      let init3 = function() {
+      let init4 = function() {
         if (typeof value == "function")
           try {
             value = attempt(value.bind(subject, key2));
@@ -855,11 +868,11 @@ function set(value, argument) {
         if (0 in arguments)
           return subject[key2];
       };
-      var init2 = init3;
+      var init3 = init4;
       if (argument)
-        init3();
+        init4();
       else
-        property.get = init3;
+        property.get = init4;
     } else if (value !== void 0)
       property.value = value;
     if (typeof argument == "function") {