@expressive/mvc 0.8.0 → 0.8.2

package/lib/index.js

@@ -25,7 +25,7 @@ function issues(register) {
     return Library;
 }
 
-const Oops$c = issues({
+const Oops$d = issues({
     BadCallback: () => `Callback for effect-callback may only return a function.`
 });
 const { assign, create, defineProperty, entries, getPrototypeOf, getOwnPropertyNames, getOwnPropertyDescriptor, getOwnPropertySymbols, values } = Object;
@@ -38,7 +38,7 @@ function createEffect(callback) {
         if (unSet instanceof Promise)
             unSet = undefined;
         if (unSet && typeof unSet !== "function")
-            throw Oops$c.BadCallback();
+            throw Oops$d.BadCallback();
     };
 }
 function createValueEffect(callback) {
@@ -54,15 +54,15 @@ function createValueEffect(callback) {
         if (typeof out == "function")
             unSet = out;
         else
-            throw Oops$c.BadCallback();
+            throw Oops$d.BadCallback();
     };
 }
 
-const Oops$b = issues({
+const Oops$c = issues({
     NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`,
 });
 function suspend(source, key) {
-    const error = Oops$b.NotReady(source.subject, key);
+    const error = Oops$c.NotReady(source.subject, key);
     const promise = new Promise(resolve => {
         const release = source.addListener(forKey => {
             if (forKey == key)
@@ -102,7 +102,7 @@ function mayRetry(fn) {
     return compute();
 }
 
-const Oops$a = issues({
+const Oops$b = issues({
     Failed: (parent, property, initial) => `An exception was thrown while ${initial ? "initializing" : "refreshing"} [${parent}.${property}].`
 });
 const INFO = new WeakMap();
@@ -119,7 +119,7 @@ function computeMode(self, source, setter, key, required) {
             return setter.call(sub.proxy, sub.proxy);
         }
         catch (err) {
-            Oops$a.Failed(subject, key, initial).warn();
+            Oops$b.Failed(subject, key, initial).warn();
             throw err;
         }
     };
@@ -195,20 +195,21 @@ class Subscriber {
         this.onUpdate = onUpdate;
         this.active = false;
         this.dependant = new Set();
-        const proxy = create(parent.subject);
-        const using = new Map();
-        REGISTER$1.set(proxy, this);
-        defineProperty(this, "proxy", {
-            configurable: true,
-            get() {
-                hasUpdate(proxy);
-                return proxy;
-            }
-        });
-        const release = parent.addListener(key => {
+        this.watch = new Map();
+        this.commit = () => {
+            const release = this.parent.addListener(this.event);
+            this.active = true;
+            this.dependant.forEach(x => x.commit());
+            return this.release = () => {
+                this.dependant.forEach(x => x.release());
+                release();
+            };
+        };
+        this.event = (key) => {
             if (!this.active)
                 return;
-            const handler = using.get(key);
+            const { parent, watch } = this;
+            const handler = watch.get(key);
             let notify;
             if (typeof handler == "function") {
                 const callback = handler();
@@ -219,49 +220,48 @@ class Subscriber {
                 notify = this.onUpdate(key, parent);
             if (!notify)
                 return;
-            parent.waiting.add(() => addUpdate(proxy, using));
+            parent.waiting.add(() => {
+                this.latest = parent.latest.filter(k => watch.has(k));
+            });
             parent.waiting.add(notify);
-        });
-        this.add = (key, value) => {
-            if (value !== undefined)
-                using.set(key, value);
-            else if (!using.has(key))
-                using.set(key, true);
-        };
-        this.commit = () => {
-            this.active = true;
-            this.dependant.forEach(x => x.commit());
-            return this.release;
-        };
-        this.release = () => {
-            this.dependant.forEach(x => x.release());
-            release();
         };
+        const proxy = create(parent.subject);
+        const reset = () => this.latest = undefined;
+        REGISTER$1.set(proxy, this);
+        defineProperty(this, "proxy", {
+            configurable: true,
+            get() {
+                setTimeout(reset, 0);
+                return proxy;
+            }
+        });
     }
     static get(from) {
         return REGISTER$1.get(from);
     }
+    get using() {
+        return Array.from(this.watch.keys());
+    }
+    assign(apply, keys) {
+        const { waiting, subject } = this.parent;
+        this.active = false;
+        if (typeof keys !== "object")
+            keys = getOwnPropertyNames(subject);
+        for (const key of keys)
+            if (key in apply)
+                subject[key] = apply[key];
+        waiting.add(() => this.active = true);
+    }
+    add(key, value) {
+        if (value !== undefined)
+            this.watch.set(key, value);
+        else if (!this.watch.has(key))
+            this.watch.set(key, true);
+    }
 }
 
 const REGISTER = new WeakMap();
-const UPDATE$1 = new WeakMap();
-function getUpdate(subject) {
-    return UPDATE$1.get(subject);
-}
-function setUpdate(subject, keys) {
-    UPDATE$1.set(subject, Array.from(keys));
-    setTimeout(() => UPDATE$1.delete(subject), 0);
-}
-/** Ensure a local update is dropped after use. */
-function hasUpdate(proxy) {
-    if (UPDATE$1.has(proxy))
-        setTimeout(() => UPDATE$1.delete(proxy), 0);
-}
-/** Set local update for a subscribed context. */
-function addUpdate(proxy, using) {
-    const parent = UPDATE$1.get(getPrototypeOf(proxy));
-    UPDATE$1.set(proxy, parent.filter(k => using.has(k)));
-}
+const PENDING = new Map();
 class Control {
     constructor(subject) {
         this.subject = subject;
@@ -328,7 +328,8 @@ class Control {
         else if (!frame.size)
             setTimeout(() => {
                 flush(this);
-                setUpdate(this.subject, frame);
+                this.latest = Array.from(frame);
+                setTimeout(() => this.latest = undefined, 0);
                 frame.clear();
                 for (const notify of waiting)
                     try {
@@ -378,13 +379,16 @@ class Control {
     }
 }
 
-const PENDING = new Map();
-function add(fn, label) {
-    const name = label || fn.name || "pending";
+/**
+ * Run instruction as controller sets itself up.
+ * This will specialize the behavior of a given property.
+ */
+function add(instruction, label) {
+    const name = label || instruction.name || "pending";
     const placeholder = Symbol(`${name} instruction`);
     function setup(key) {
         const { subject, state } = this;
-        let output = fn.call(this, key, this);
+        let output = instruction.call(this, key, this);
         if (typeof output == "function")
             output = { get: output };
         if (typeof output != "object")
@@ -485,7 +489,7 @@ function __awaiter(thisArg, _arguments, P, generator) {
     });
 }
 
-const Oops$9 = issues({
+const Oops$a = issues({
     DuplicatePending: (key) => `Invoked action ${key} but one is already active.`
 });
 function act(task) {
@@ -493,7 +497,7 @@ function act(task) {
         let pending = false;
         const invoke = (...args) => __awaiter(this, void 0, void 0, function* () {
             if (pending)
-                return Promise.reject(Oops$9.DuplicatePending(key));
+                return Promise.reject(Oops$a.DuplicatePending(key));
             pending = true;
             this.update(key);
             try {
@@ -515,6 +519,9 @@ function act(task) {
     });
 }
 
+const Oops$9 = issues({
+    NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`
+});
 function factoryMode(self, output, key, required) {
     const { subject, state } = self;
     let pending;
@@ -536,7 +543,7 @@ function factoryMode(self, output, key, required) {
     const suspend = () => {
         if (required === false)
             return undefined;
-        const issue = Oops$8.NotReady(subject, key);
+        const issue = Oops$9.NotReady(subject, key);
         assign(pending, {
             message: issue.message,
             stack: issue.stack
@@ -554,12 +561,8 @@ function factoryMode(self, output, key, required) {
 }
 
 const Oops$8 = issues({
-    // BadSource: (model, property, got) =>
-    //   `Bad from-instruction provided to ${model}.${property}. Expects an arrow-function or a Model as source. Got ${got}.`,
     PeerNotAllowed: (model, property) => `Attempted to use an instruction result (probably use or tap) as computed source for ${model}.${property}. This is not possible.`,
     ComputeFailed: (model, key) => `Generating initial value for ${model}.${key} failed.`,
-    NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`,
-    FactoryFailed: (model, key) => `Generating initial value for ${model}.${key} failed.`,
     Failed: (parent, property, initial) => `An exception was thrown while ${initial ? "initializing" : "refreshing"} [${parent}.${property}].`
 });
 function get(arg0, arg1, arg2) {
@@ -937,7 +940,7 @@ class Model {
                         }
                         else if (keys.includes(key)) {
                             removeListener();
-                            return () => resolve(single ? control.state.get(key) : getUpdate(this));
+                            return () => resolve(single ? control.state.get(key) : control.latest);
                         }
                     });
                 });
@@ -957,7 +960,7 @@ class Model {
                 catch (e) { }
             const callback = single
                 ? () => { argument.call(this, control.state.get(select), select); }
-                : () => { argument.call(this, getUpdate(this)); };
+                : () => { argument.call(this, control.latest); };
             const onEvent = once
                 ? () => {
                     removeListener();
@@ -1042,7 +1045,7 @@ class Model {
                     throw Oops$5.NoChaining();
                 if (frame.size || arg1 !== false)
                     waiting.add(() => {
-                        callback(getUpdate(this));
+                        callback(control.latest);
                     });
                 else
                     callback(false);
@@ -1235,14 +1238,8 @@ function useModel(source, arg, arg2) {
         return instance;
     }
     const local = use(refresh => (Control.for(instance).subscribe(() => refresh)));
-    if (typeof arg == "object") {
-        local.active = false;
-        if (typeof arg2 !== "object")
-            arg2 = getOwnPropertyNames(instance);
-        for (const key of arg2)
-            if (key in arg)
-                instance[key] = arg[key];
-    }
+    if (typeof arg == "object")
+        local.assign(arg, arg2);
     React__default["default"].useLayoutEffect(() => {
         local.commit();
         return () => {
@@ -1299,10 +1296,10 @@ function useTap(source, arg1, arg2) {
     const instance = React.useMemo(() => {
         if (typeof source == "object")
             return () => source;
-        if (MVC.isTypeof(source))
-            return () => source.get(true);
         if (Model.isTypeof(source))
-            return () => useContext(source);
+            return "get" in source
+                ? () => source.get(true)
+                : () => useContext(source);
         return source;
     }, [])();
     if (typeof arg1 == "function")
@@ -1332,10 +1329,10 @@ class MVC extends Model {
     }
 }
 
-const LOCAL = Symbol("LOCAL");
-const STATE = Symbol("STATE");
-const UPDATE = Symbol("UPDATE");
-const CONTROL = Symbol("CONTROL");
+const LOCAL = "$debug local";
+const STATE = "$debug state";
+const UPDATE = "$debug update";
+const CONTROL = "$debug controller";
 Object.defineProperties(Model.prototype, {
     [CONTROL]: {
         get() {
@@ -1357,7 +1354,8 @@ Object.defineProperties(Model.prototype, {
     },
     [UPDATE]: {
         get() {
-            return getUpdate(this);
+            const source = Subscriber.get(this) || Control.get(this);
+            return source && source.latest;
         }
     }
 });