@expressive/mvc 0.52.2-alpha.74 → 0.53.0

package/dist/index.js

@@ -35,58 +35,78 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/control.ts
-var DISPATCH = /* @__PURE__ */ new Set();
-var OBSERVER = /* @__PURE__ */ new WeakMap();
+var onReady = () => null;
 var LISTENERS = /* @__PURE__ */ new WeakMap();
 var PENDING = /* @__PURE__ */ new WeakMap();
-var onReady = () => null;
+var PENDING_KEYS = /* @__PURE__ */ new WeakMap();
+var DISPATCH = /* @__PURE__ */ new Set();
+var OBSERVER = /* @__PURE__ */ new WeakMap();
 function addListener(subject, callback, select) {
-  let subs = LISTENERS.get(subject);
-  if (!subs)
-    LISTENERS.set(subject, subs = /* @__PURE__ */ new Map([[onReady, void 0]]));
+  let listeners = LISTENERS.get(subject);
+  if (!listeners)
+    LISTENERS.set(subject, listeners = /* @__PURE__ */ new Map([[onReady, void 0]]));
   const filter = select === void 0 ? void 0 : /* @__PURE__ */ new Set([select]);
-  if (!subs.has(onReady) && !filter)
-    callback(true, subject);
-  subs.set(callback, filter);
-  return () => subs.delete(callback);
+  if (!listeners.has(onReady) && !filter)
+    callback.call(subject, true, subject);
+  listeners.set(callback, filter);
+  return () => listeners.delete(callback);
 }
-function createProxy(from, observer) {
-  const proxy = Object.create(from);
-  OBSERVER.set(proxy, observer);
-  return proxy;
-}
-function watch(from, key2, value) {
-  const access = OBSERVER.get(from);
-  return access ? access(from, key2, value) : value;
-}
-function emit(source, key2) {
-  const subs = LISTENERS.get(source);
-  const ready = !subs.has(onReady);
-  if (key2 === true && ready)
+function emit(model, key2) {
+  const listeners = LISTENERS.get(model);
+  const notReady = listeners.has(onReady);
+  if (key2 === true && !notReady)
     return;
-  let pending = PENDING.get(source);
-  if (pending) {
-    pending.add(key2);
+  let pending2 = PENDING.get(model);
+  if (pending2) {
+    pending2.add(key2);
     return;
   }
-  PENDING.set(source, pending = new Set(
-    key2 !== true && ready ? [key2] : [true, key2]
-  ));
-  pending.forEach((key3) => {
-    pending.delete(key3);
-    subs.forEach((select, callback) => {
-      let after;
-      if (!select || select.has(key3)) {
-        if (after = callback.call(source, key3, source))
-          queue(after);
+  PENDING.set(model, pending2 = new Set(notReady ? [true, key2] : [key2]));
+  for (const key3 of pending2)
+    for (const [callback, filter] of listeners)
+      if (!filter || filter.has(key3)) {
+        const after = callback.call(model, key3, model);
+        if (after)
+          enqueue(after);
+        else if (after === null)
+          listeners.delete(callback);
       }
-      if (after === null || key3 === null)
-        subs.delete(callback);
-    });
-  });
-  PENDING.delete(source);
+  if (key2 === null)
+    listeners.clear();
+  PENDING.delete(model);
+}
+function event(subject, key2, silent) {
+  if (key2 === null)
+    return emit(subject, key2);
+  if (!key2)
+    return emit(subject, true);
+  let pending2 = PENDING_KEYS.get(subject);
+  if (!pending2) {
+    PENDING_KEYS.set(subject, pending2 = /* @__PURE__ */ new Set());
+    if (!silent)
+      enqueue(() => {
+        emit(subject, false);
+        PENDING_KEYS.delete(subject);
+      });
+  }
+  pending2.add(key2);
+  if (!silent)
+    emit(subject, key2);
 }
-function queue(eventHandler) {
+function pending(subject) {
+  if (PENDING_KEYS.has(subject))
+    return {
+      then: (res) => new Promise((res2) => {
+        const remove = addListener(subject, (key2) => {
+          if (key2 !== true) {
+            remove();
+            return res2.bind(null, Array.from(PENDING_KEYS.get(subject)));
+          }
+        });
+      }).then(res)
+    };
+}
+function enqueue(eventHandler) {
   if (!DISPATCH.size)
     setTimeout(() => {
       DISPATCH.forEach((event2) => {
@@ -100,6 +120,15 @@ function queue(eventHandler) {
     }, 0);
   DISPATCH.add(eventHandler);
 }
+function createProxy(from, observer) {
+  const proxy = Object.create(from);
+  OBSERVER.set(proxy, observer);
+  return proxy;
+}
+function watch(from, key2, value) {
+  const access = OBSERVER.get(from);
+  return access ? access(from, key2, value) : value;
+}
 function createEffect(target, callback, requireValues) {
   const listeners = LISTENERS.get(target);
   let unset;
@@ -166,7 +195,6 @@ var define = Object.defineProperty;
 var ID = /* @__PURE__ */ new WeakMap();
 var STATE = /* @__PURE__ */ new WeakMap();
 var NOTIFY = /* @__PURE__ */ new WeakMap();
-var PENDING2 = /* @__PURE__ */ new WeakMap();
 var PARENT = /* @__PURE__ */ new WeakMap();
 var METHODS = /* @__PURE__ */ new WeakMap();
 var METHOD = /* @__PURE__ */ new WeakMap();
@@ -178,65 +206,44 @@ var Model = class {
   }
   get(arg1, arg2) {
     const self = this.is;
-    if (arg1 === void 0)
-      return snapshot(self);
     if (typeof arg1 == "function") {
-      let pending = /* @__PURE__ */ new Set();
-      return createEffect(self, (state) => {
-        const cb = arg1.call(state, state, pending);
+      let pending2 = /* @__PURE__ */ new Set();
+      return createEffect(self, (proxy) => {
+        const cb = arg1.call(proxy, proxy, pending2);
         return cb === null ? cb : (update2) => {
-          pending = PENDING2.get(self);
+          pending2 = PENDING_KEYS.get(self);
           if (typeof cb == "function")
             cb(update2);
         };
       });
     }
-    if (typeof arg2 == "function") {
-      if (arg1 === null)
-        return addListener(self, arg2.bind(this, this), null);
-      const state = STATE.get(self);
-      if (arg1 in state)
-        arg2.call(this, state[arg1], arg1, this);
-      return addListener(self, () => {
-        arg2.call(this, arg1 in state ? state[arg1] : arg1, arg1, this);
-      }, arg1);
-    }
+    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, arg3) {
+  set(arg1, arg2) {
     const self = this.is;
     if (typeof arg1 == "function")
       return addListener(self, (key2) => {
         if (typeof key2 == "string")
           return arg1.call(self, key2, self);
       });
-    if (arg1 === null) {
-      emit(this, null);
-      return;
-    }
-    if (typeof arg1 == "object")
-      assign(self, arg1);
-    else if (arg1 == void 0)
-      emit(this, true);
-    else if (1 in arguments)
-      update(self, arg1, arg2, arg3);
-    else
+    if (arg1 && typeof arg1 == "object") {
+      const methods = METHODS.get(self.constructor);
+      for (const key2 in arg1)
+        if (methods.has(key2))
+          self[key2] = arg1[key2];
+        else if (key2 in self)
+          update(self, key2, arg1[key2], arg2 === true);
+    } else
       event(self, arg1);
-    if (PENDING2.has(self))
-      return {
-        then: (res) => new Promise((res2) => {
-          const remove = addListener(self, (key2) => {
-            if (key2 !== true) {
-              remove();
-              return res2.bind(null, Array.from(PENDING2.get(self)));
-            }
-          });
-        }).then(res)
-      };
+    return pending(self);
   }
   /**
    * Iterate over managed properties in this instance of Model.
-   * Yeilds the key and underlying value for each property.
+   * Yeilds the key and current value for each property.
    */
   [Symbol.iterator]() {
     return Object.entries(STATE.get(this.is))[Symbol.iterator]();
@@ -250,7 +257,7 @@ var Model = class {
    */
   static new(...args) {
     const instance = new this(...args);
-    emit(instance, true);
+    event(instance);
     return instance;
   }
   /**
@@ -308,25 +315,23 @@ function prepare(model) {
     for (const [key2, { value }] of Object.entries(
       Object.getOwnPropertyDescriptors(type.prototype)
     )) {
-      let get3 = function() {
-        return this.hasOwnProperty(key2) ? value : set3.call(this, value);
-      }, set3 = function(method) {
-        const value2 = method.bind(this.is);
+      let bind2 = function(method = value) {
+        const value2 = method.bind(model);
         METHOD.set(value2, method);
-        define(this.is, key2, { value: value2, writable: true });
+        define(model, key2, { value: value2, writable: true });
         return value2;
       };
-      var get2 = get3, set2 = set3;
+      var bind = bind2;
       if (!value || key2 == "constructor")
         continue;
       keys2.add(key2);
-      define(type.prototype, key2, { get: get3, set: set3 });
+      define(type.prototype, key2, { get: bind2, set: bind2 });
     }
   }
 }
 function init(model, args) {
+  const methods = METHODS.get(model.constructor);
   const state = {};
-  const clean = /* @__PURE__ */ new Set();
   STATE.set(model, state);
   args = args.flat().filter((arg) => {
     if (typeof arg != "string")
@@ -343,10 +348,13 @@ function init(model, args) {
           console.error(`Async error in constructor for ${model}:`);
           console.error(err);
         });
-      else if (typeof use2 == "object")
-        assign(model, use2);
       else if (typeof use2 == "function")
-        clean.add(use2);
+        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);
@@ -354,22 +362,30 @@ function init(model, args) {
         update(model, key2, desc.value, true);
         define(model, key2, {
           configurable: false,
-          set: (x) => update(model, key2, x),
           get() {
             return watch(this, key2, state[key2]);
+          },
+          set(value) {
+            update(model, key2, 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;
   });
-  addListener(model, () => {
-    clean.forEach((x) => x());
-    for (const [_, value] of model)
-      if (value instanceof Model && PARENT.get(value) === model)
-        value.set(null);
-    Object.freeze(state);
-  }, 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);
@@ -428,37 +444,14 @@ function update(subject, key2, value, arg) {
       value = out();
   }
   if (value === previous)
-    return true;
-  if (value instanceof Model && !PARENT.has(value)) {
-    PARENT.set(value, subject);
-    emit(value, true);
-  }
+    return;
   state[key2] = value;
   if (arg !== true)
     event(subject, key2);
-}
-function event(subject, key2, silent) {
-  let pending = PENDING2.get(subject);
-  if (!pending) {
-    PENDING2.set(subject, pending = /* @__PURE__ */ new Set());
-    if (!silent)
-      queue(() => {
-        emit(subject, false);
-        PENDING2.delete(subject);
-      });
-  }
-  pending.add(key2);
-  if (!silent)
-    emit(subject, key2);
-}
-function assign(to, values) {
-  const methods = METHODS.get(to.constructor);
-  for (const key2 in values)
-    if (key2 in to || methods.has(key2))
-      to[key2] = values[key2];
+  return true;
 }
 function uid() {
-  return (Math.random() * 0.722 + 0.278).toString(36).substring(2, 8).toUpperCase();
+  return (0.278 + Math.random() * 0.722).toString(36).substring(2, 8).toUpperCase();
 }
 
 // src/context.ts
@@ -551,11 +544,11 @@ var Context = class _Context {
       }
     }
     for (const [model, explicit] of init2) {
-      emit(model, true);
+      model.set();
       if (typeof forEach == "function")
         forEach(model, explicit);
       else if (forEach && explicit)
-        assign(model, forEach);
+        model.set(forEach);
       for (const [_key, value] of model)
         if (PARENT.get(value) === model) {
           this.add(value, true);
@@ -572,8 +565,8 @@ var Context = class _Context {
       I = new input();
       this.cleanup.add(() => I.set(null));
     } else {
+      T = input.constructor;
       I = input;
-      T = I.constructor;
     }
     keys(T, true).forEach((K) => {
       const result = this[K];
@@ -630,8 +623,7 @@ Model.on((_, model) => {
     const { value } = Object.getOwnPropertyDescriptor(model, key2);
     const instruction = INSTRUCT.get(value);
     if (!instruction) {
-      if (value instanceof Model && key2 !== "is")
-        update(model, key2, value);
+      mayAdopt(model, value);
       continue;
     }
     INSTRUCT.delete(value);
@@ -665,76 +657,80 @@ Model.on((_, model) => {
 var STALE = /* @__PURE__ */ new WeakSet();
 function get(arg0, arg1) {
   return use((key2, subject, state) => {
-    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}.${key2}. This is not allowed.`);
-    let source = (resolve) => resolve(from);
-    if (arg0 instanceof Model) {
-      from = arg0;
-    } else if (Model.is(arg0)) {
-      const hasParent = PARENT.get(from);
+      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) {
+        if (typeof arg1 == "function")
+          value.get((x) => arg1(x, key2));
+        update(subject, key2, value);
+      };
+      var assign = assign2;
+      const hasParent = PARENT.get(subject);
       if (!hasParent) {
         if (arg1 === true)
-          throw new Error(`${from} may only exist as a child of type ${arg0}.`);
-        source = (resolve) => {
-          Context.get(from, (context) => {
-            const got = context.get(arg0);
-            if (got)
-              resolve(got);
-            else if (arg1 !== false)
-              throw new Error(`Required ${arg0} not found in context for ${from}.`);
-          });
-        };
+          throw new Error(`${subject} may only exist as a child of type ${arg0}.`);
+        Context.get(subject, (context) => {
+          const model = context.get(arg0);
+          if (model)
+            assign2(model);
+          else if (arg1 !== false)
+            throw new Error(`Required ${arg0} not found in context for ${subject}.`);
+        });
       } else if (!arg0 || hasParent instanceof arg0)
-        from = hasParent;
+        assign2(hasParent);
       else
-        throw new Error(`New ${from} created as child of ${hasParent}, but must be instanceof ${arg0}.`);
+        throw new Error(`New ${subject} created as child of ${hasParent}, but must be instanceof ${arg0}.`);
+      return {
+        get: arg1 !== false
+      };
+    }
+    let from = subject;
+    if (arg0 instanceof Model) {
+      from = arg0;
     } else {
       const fn = METHOD.get(arg0) || arg0;
       arg1 = (p, k) => fn.call(p, k, p);
     }
-    if (typeof arg1 == "function") {
-      let connect2 = function(model) {
-        reset = createEffect(model, (current) => {
-          proxy = current;
-          if (!(key2 in state) || STALE.delete(compute2))
-            compute2(!reset);
-          return (didUpdate) => {
-            if (didUpdate) {
-              STALE.add(compute2);
-              event(subject, key2, true);
-            }
-          };
-        });
-      }, compute2 = function(initial) {
-        let next;
-        try {
-          next = getter.call(proxy, proxy, key2);
-        } catch (err) {
-          console.warn(`An exception was thrown while ${initial ? "initializing" : "refreshing"} ${subject}.${key2}.`);
-          if (initial)
-            throw err;
-          console.error(err);
-        }
-        update(subject, key2, next, !isAsync);
-      };
-      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, key2, !proxy);
-      };
-    } else
-      source((got) => subject.set(key2, got));
-    return { get: arg1 };
+    const source = (resolve) => resolve(from);
+    const getter = arg1;
+    let reset;
+    let isAsync;
+    let proxy;
+    function connect(model) {
+      reset = createEffect(model, (current) => {
+        proxy = current;
+        if (!(key2 in state) || STALE.delete(compute))
+          compute(!reset);
+        return (didUpdate) => {
+          if (didUpdate) {
+            STALE.add(compute);
+            event(subject, key2, true);
+          }
+        };
+      });
+    }
+    function compute(initial) {
+      let next;
+      try {
+        next = getter.call(proxy, proxy, key2);
+      } catch (err) {
+        console.warn(`An exception was thrown while ${initial ? "initializing" : "refreshing"} ${subject}.${key2}.`);
+        if (initial)
+          throw err;
+        console.error(err);
+      }
+      update(subject, key2, next, !isAsync);
+    }
+    return () => {
+      if (!proxy) {
+        source(connect);
+        isAsync = true;
+      }
+      if (STALE.delete(compute))
+        compute();
+      return fetch(subject, key2, !proxy);
+    };
   });
 }
 
@@ -756,7 +752,9 @@ function ref(arg, arg2) {
             });
           else {
             const get2 = () => state[key3];
-            const set2 = (value2) => subject.set(key3, value2);
+            const set2 = (value2) => {
+              update(subject, key3, value2);
+            };
             define(set2, "current", { get: get2, set: set2 });
             define(set2, "get", { value: get2 });
             define(value, key3, { value: set2 });
@@ -768,7 +766,7 @@ function ref(arg, arg2) {
       let unSet;
       const get2 = () => state[key2];
       const set2 = (value2) => {
-        if (!subject.set(key2, value2) || !arg)
+        if (!update(subject, key2, value2) || !arg)
           return;
         if (unSet)
           unSet = void unSet(value2);
@@ -804,16 +802,16 @@ function set(value, argument) {
         output.get = argument === true;
         if (value instanceof Promise) {
           value.then((value2) => {
-            subject.set(key2, value2);
+            update(subject, key2, value2);
             return value2;
           }).catch((err) => {
-            subject.set(key2);
+            event(subject, key2);
             output.get = () => {
               throw err;
             };
           });
         } else
-          subject.set(key2, value);
+          update(subject, key2, value);
         if (0 in arguments)
           return subject[key2];
       };
@@ -838,7 +836,7 @@ function set(value, argument) {
     } else
       output.set = (value2) => {
         output.get = void 0;
-        subject.set(key2, value2);
+        update(subject, key2, value2);
       };
     return output;
   });
@@ -866,17 +864,17 @@ var APPLY = /* @__PURE__ */ new WeakMap();
 function has(arg1, arg2) {
   return use((key2, subject) => {
     const applied = /* @__PURE__ */ new Set();
-    const update2 = () => {
-      subject.set(key2, Object.freeze(Array.from(applied)));
+    const apply = () => {
+      update(subject, key2, Object.freeze(Array.from(applied)));
     };
     if (Model.is(arg1))
       Context.get(subject, (context) => {
-        context.has(arg1, (got) => {
+        context.has(arg1, (model) => {
           let remove;
           let disconnect;
-          if (applied.has(got))
+          if (applied.has(model))
             return;
-          const callback = APPLY.get(got);
+          const callback = APPLY.get(model);
           if (callback) {
             const after = callback(subject);
             if (after === false)
@@ -885,7 +883,7 @@ function has(arg1, arg2) {
               disconnect = after;
           }
           if (typeof arg2 == "function") {
-            const done2 = arg2(got, subject);
+            const done2 = arg2(model, subject);
             if (done2 === false)
               return false;
             remove = () => {
@@ -893,18 +891,18 @@ function has(arg1, arg2) {
                 done2();
             };
           }
-          applied.add(got);
-          update2();
+          applied.add(model);
+          apply();
           const done = () => {
-            reset();
-            applied.delete(got);
-            update2();
+            ignore();
+            applied.delete(model);
+            apply();
             if (disconnect)
               disconnect();
             if (typeof remove == "function")
               remove();
           };
-          const reset = got.get(null, done);
+          const ignore = model.get(null, done);
           return done;
         });
       });
@@ -919,10 +917,10 @@ function has(arg1, arg2) {
             return false;
         }
         applied.add(recipient);
-        update2();
+        apply();
         return () => {
           applied.delete(recipient);
-          update2();
+          apply();
           if (typeof remove == "function")
             remove();
         };