@expressive/mvc 0.63.6 → 0.64.2

package/dist/index.js

@@ -23,10 +23,11 @@ __export(index_exports, {
   Context: () => Context,
   METHOD: () => METHOD,
   Model: () => Model,
+  Observable: () => Observable,
   addListener: () => addListener,
   createEffect: () => createEffect,
-  createProxy: () => createProxy,
   default: () => Model,
+  event: () => event,
   get: () => get,
   has: () => has,
   ref: () => ref,
@@ -36,20 +37,21 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/control.ts
+var Observable = Symbol("observe");
 var onReady = () => null;
 var LISTENERS = /* @__PURE__ */ new WeakMap();
 var PENDING = /* @__PURE__ */ new WeakMap();
 var PENDING_KEYS = /* @__PURE__ */ new WeakMap();
 var DISPATCH = /* @__PURE__ */ new Set();
-var OBSERVER = /* @__PURE__ */ new WeakMap();
 function addListener(subject, callback, select) {
   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 (!listeners.has(onReady) && !filter)
+  if (select !== void 0 && !(select instanceof Set))
+    select = /* @__PURE__ */ new Set([select]);
+  if (!listeners.has(onReady) && !select)
     callback.call(subject, true, subject);
-  listeners.set(callback, filter);
+  listeners.set(callback, select);
   return () => listeners.delete(callback);
 }
 function emit(model, key2) {
@@ -57,13 +59,13 @@ function emit(model, key2) {
   const notReady = listeners.has(onReady);
   if (key2 === true && !notReady)
     return;
-  let pending2 = PENDING.get(model);
-  if (pending2) {
-    pending2.add(key2);
+  let pending = PENDING.get(model);
+  if (pending) {
+    pending.add(key2);
     return;
   }
-  PENDING.set(model, pending2 = new Set(notReady ? [true, key2] : [key2]));
-  for (const key3 of pending2)
+  PENDING.set(model, pending = new Set(notReady ? [true, key2] : [key2]));
+  for (const key3 of pending)
     for (const [callback, filter] of listeners)
       if (!filter || filter.has(key3)) {
         const after = callback.call(model, key3, model);
@@ -81,32 +83,19 @@ function event(subject, key2, silent) {
     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());
+  let pending = PENDING_KEYS.get(subject);
+  if (!pending) {
+    PENDING_KEYS.set(subject, pending = /* @__PURE__ */ new Set());
     if (!silent)
       enqueue(() => {
         emit(subject, false);
         PENDING_KEYS.delete(subject);
       });
   }
-  pending2.add(key2);
+  pending.add(key2);
   if (!silent)
     emit(subject, key2);
 }
-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(() => {
@@ -121,54 +110,31 @@ function enqueue(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, argument) {
-  const listeners = LISTENERS.get(target);
   let unset;
   let reset;
   function invoke() {
     let stale;
-    const subscriber = createProxy(target, access);
-    LISTENERS.set(subscriber, listeners);
     function onUpdate() {
-      if (stale)
-        return null;
+      if (stale || reset === null)
+        return;
       stale = true;
       if (reset && unset) {
         unset(true);
         unset = void 0;
       }
-      return reset;
-    }
-    function access(from, key2, value) {
-      if (value === void 0 && argument)
-        throw new Error(`${from}.${key2} is required in this context.`);
-      const listeners2 = LISTENERS.get(from);
-      let listener = listeners2.get(onUpdate);
-      if (!listener)
-        listeners2.set(onUpdate, listener = /* @__PURE__ */ new Set());
-      listener.add(key2);
-      const nested = LISTENERS.get(value);
-      if (nested)
-        LISTENERS.set(value = createProxy(value, access), nested);
-      return value;
+      enqueue(invoke);
+      return { then: enqueue };
     }
+    const subscriber = target[Observable](onUpdate, argument === true);
     try {
-      const ctx = context(argument === false);
-      const ret = callback.call(subscriber, subscriber);
-      const flush = ctx();
-      reset = ret === null ? null : invoke;
+      const exit = enter(argument === false);
+      const output = callback.call(subscriber, subscriber);
+      const flush = exit();
+      reset = output === null ? null : invoke;
       unset = (key2) => {
-        if (typeof ret == "function")
-          ret(key2);
+        if (typeof output == "function")
+          output(key2);
         flush();
       };
     } catch (err) {
@@ -198,17 +164,15 @@ function createEffect(target, callback, argument) {
   return cleanup;
 }
 var EffectContext;
-function context(ignore) {
+function enter(ignore) {
   if (ignore)
     return () => () => {
     };
-  const current = EffectContext;
-  const ctx = EffectContext = /* @__PURE__ */ new Set();
+  const last = EffectContext;
+  const context = EffectContext = /* @__PURE__ */ new Set();
   return () => {
-    EffectContext = current;
-    return () => {
-      ctx.forEach((fn) => fn());
-    };
+    EffectContext = last;
+    return () => context.forEach((fn) => fn());
   };
 }
 
@@ -226,14 +190,28 @@ var Model = class {
     define(this, "is", { value: this });
     init(this, args);
   }
+  [Observable](callback, required) {
+    const watch2 = /* @__PURE__ */ new Set();
+    const proxy = Object.create(this);
+    addListener(this, () => void callback(), watch2);
+    OBSERVER.set(proxy, (key2, value) => {
+      if (value === void 0 && required)
+        throw new Error(`${this}.${key2} is required in this context.`);
+      watch2.add(key2);
+      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);
         };
@@ -241,23 +219,33 @@ var Model = class {
     }
     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, (key2) => {
-        if (typeof key2 == "string")
+        if (arg2 === key2 || arg2 === void 0 && typeof key2 == "string")
           return arg1.call(self, key2, self);
       });
-    if (typeof arg2 == "function")
-      return addListener(self, (key2) => {
-        if (key2 === arg1)
-          return arg2.call(self, key2, 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, (key2) => {
+            if (key2 !== true) {
+              remove();
+              return res2.bind(null, Array.from(pending));
+            }
+          });
+        }).then(res)
+      };
   }
   /**
    * Iterate over managed properties in this instance of Model.
@@ -317,7 +305,7 @@ function assign(subject, data, silent) {
     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);
+      set2.call(subject, data[key2], silent);
     }
   }
 }
@@ -375,26 +363,10 @@ function init(model, args) {
       PARENT.set(model, null);
     for (const key2 in model) {
       const desc = Object.getOwnPropertyDescriptor(model, key2);
-      if ("value" in desc) {
-        let set3 = function(value, silent) {
-          update(model, key2, value, silent);
-          if (value instanceof Model && !PARENT.has(value)) {
-            PARENT.set(value, model);
-            event(value);
-          }
-        };
-        var set2 = set3;
-        set3(desc.value, true);
-        define(model, key2, {
-          configurable: false,
-          set: set3,
-          get() {
-            return watch(this, key2, state[key2]);
-          }
-        });
-      }
+      if ("value" in desc)
+        manage(model, key2, desc.value, true);
     }
-    args.forEach((arg) => {
+    for (const arg of args) {
       const use2 = typeof arg == "function" ? arg.call(model, model) : arg;
       if (use2 instanceof Promise)
         use2.catch((err) => {
@@ -405,7 +377,7 @@ function init(model, args) {
         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)
@@ -415,6 +387,26 @@ function init(model, args) {
     return null;
   });
 }
+function manage(target, key2, value, silent) {
+  const state = STATE.get(target);
+  function get2() {
+    return watch(this, key2, state[key2]);
+  }
+  function set2(value2, silent2) {
+    update(target, key2, value2, silent2);
+    if (value2 instanceof Model && !PARENT.has(value2)) {
+      PARENT.set(value2, target);
+      event(value2);
+    }
+  }
+  define(target, key2, { set: set2, get: get2 });
+  set2(value, silent);
+}
+var OBSERVER = /* @__PURE__ */ new WeakMap();
+function watch(from, key2, value) {
+  const access = OBSERVER.get(from);
+  return access ? access(key2, value) : value;
+}
 function fetch(subject, property, required) {
   const state = STATE.get(subject);
   if (property in state || required === false) {
@@ -630,13 +622,13 @@ var Context = class _Context {
 // src/instruction/use.ts
 var INSTRUCTION = /* @__PURE__ */ new Map();
 function use(arg1, arg2) {
-  const token = Symbol("instruction-" + uid());
   if (Model.is(arg1))
-    arg1 = child(arg1, arg2);
+    arg1 = childInstruction(arg1, arg2);
+  const token = Symbol("instruction-" + uid());
   INSTRUCTION.set(token, arg1);
   return token;
 }
-function child(type, arg2) {
+function childInstruction(type, arg2) {
   return (key2, subject) => {
     function set2(next) {
       if (next ? !(next instanceof type) : arg2 !== false)
@@ -712,8 +704,8 @@ function get(arg0, arg1) {
         } 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);
+      Context.get(subject, (context) => {
+        const model = context.get(arg0);
         if (model)
           assign3(model);
         else if (arg1 !== false)
@@ -815,9 +807,9 @@ function ref(arg, arg2) {
           unset = void unset(value2);
         if (value2 === null && arg2 !== false)
           return;
-        const ctx = context();
+        const exit = enter();
         const out = arg.call(subject, value2);
-        const flush = ctx();
+        const flush = exit();
         unset = (key3) => {
           if (typeof out == "function")
             out(key3);
@@ -872,16 +864,16 @@ function set(value, argument) {
     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;
+        const exit = enter();
+        const returns = argument.call(this, value2, previous);
+        const flush = exit();
+        if (returns === false)
+          return false;
         if (typeof unset == "function")
           unset(value2);
         unset = (next) => {
-          if (typeof out == "function")
-            out(next);
+          if (typeof returns == "function")
+            returns(next);
           flush();
         };
       };
@@ -922,27 +914,31 @@ function has(arg1, arg2) {
     if (Model.is(arg1))
       Context.get(subject, (ctx) => {
         ctx.has(arg1, (model) => {
-          const ctx2 = context();
           let remove;
           let disconnect;
+          let flush;
           if (applied.has(model))
             return;
-          const notify = APPLY.get(model);
-          if (notify) {
-            const after = notify(subject);
-            if (after === false)
-              return;
-            if (typeof after == "function")
-              disconnect = after;
-          }
-          if (typeof arg2 == "function") {
-            const done2 = arg2(model, subject);
-            if (done2 === false)
-              return false;
-            if (typeof done2 == "function")
-              remove = done2;
+          const exit = enter();
+          try {
+            const notify = APPLY.get(model);
+            if (notify) {
+              const after = notify(subject);
+              if (after === false)
+                return;
+              if (typeof after == "function")
+                disconnect = after;
+            }
+            if (typeof arg2 == "function") {
+              const done2 = arg2(model, subject);
+              if (done2 === false)
+                return false;
+              if (typeof done2 == "function")
+                remove = done2;
+            }
+          } finally {
+            flush = exit();
           }
-          const flush = ctx2();
           applied.add(model);
           reset();
           const done = () => {
@@ -956,7 +952,7 @@ function has(arg1, arg2) {
               remove();
             remove = void 0;
           };
-          const ignore = model.set(null, done);
+          const ignore = model.set(done, null);
           return done;
         });
       });
@@ -988,9 +984,10 @@ function has(arg1, arg2) {
   Context,
   METHOD,
   Model,
+  Observable,
   addListener,
   createEffect,
-  createProxy,
+  event,
   get,
   has,
   ref,