@expressive/mvc 0.8.0 → 0.8.2

package/lib/index.d.ts

@@ -11,14 +11,19 @@ declare type Listener = {
 declare class Subscriber<T extends {} = any> {
     parent: Control<T>;
     onUpdate: Control.OnEvent;
+    static get<T extends {}>(from: T): Model.Subscriber<T> | undefined;
     proxy: T;
-    commit: () => Callback;
     release: Callback;
+    latest?: Model.Event<T>[];
     active: boolean;
     dependant: Set<Listener>;
-    add: (key: any, value?: boolean | Callback) => void;
-    static get<T extends {}>(from: T): Subscriber<T> | undefined;
+    watch: Map<any, boolean | (() => true | void)>;
     constructor(parent: Control<T>, onUpdate: Control.OnEvent);
+    get using(): Model.Values<T>;
+    assign(apply: Model.Compat<T>, keys?: any): void;
+    add(key: any, value?: boolean | Callback): void;
+    commit: () => () => void;
+    private event;
 }
 
 declare namespace Model {
@@ -133,6 +138,7 @@ declare class Control<T extends {} = any> {
     frame: Set<string>;
     waiting: Set<Callback>;
     followers: Set<Model.Control.OnEvent<any>>;
+    latest?: Model.Event<T>[];
     constructor(subject: T);
     subscribe(callback: Control.OnEvent<T>): Model.Subscriber<T>;
     watch(key: keyof T & string): void;
@@ -179,7 +185,7 @@ declare namespace Instruction {
  * Run instruction as controller sets itself up.
  * This will specialize the behavior of a given property.
  */
-declare function add<T = any>(instruction: Instruction<T>, name?: string): T;
+declare function add<T = any>(instruction: Instruction<any>, label?: string): T;
 
 declare type Async<T = any> = (...args: any[]) => Promise<T>;
 /**
@@ -419,15 +425,15 @@ declare class MVC extends Model {
     static meta<T, M extends Class>(this: M, from: (this: M, state: M) => T, expect?: boolean): T;
 }
 
-declare const LOCAL: unique symbol;
-declare const STATE: unique symbol;
-declare const UPDATE: unique symbol;
-declare const CONTROL: unique symbol;
+declare const LOCAL = "$debug local";
+declare const STATE = "$debug state";
+declare const UPDATE = "$debug update";
+declare const CONTROL = "$debug controller";
 declare const Debug: {
-    readonly CONTROL: typeof CONTROL;
-    readonly LOCAL: typeof LOCAL;
-    readonly STATE: typeof STATE;
-    readonly UPDATE: typeof UPDATE;
+    readonly CONTROL: "$debug controller";
+    readonly LOCAL: "$debug local";
+    readonly STATE: "$debug state";
+    readonly UPDATE: "$debug update";
 };
 declare type Debug<T extends {}> = T & {
     /** Controller for this instance. */
@@ -573,12 +579,9 @@ declare function tap<T extends Model>(Type: Model.Type<T>, required?: boolean):
 declare function useFrom<T extends {}, R>(source: (() => T) | T, compute: (this: T, from: T) => R, expect: true): Exclude<R, undefined>;
 declare function useFrom<T extends {}, R>(source: (() => T) | T, compute: (this: T, from: T) => R, expect?: boolean): R;
 
-declare function useModel<T extends Model>(source: Model.Type<T>, watch: Model.Field<T>[], callback?: (instance: T) => void): T;
-declare function useModel<T extends Model>(source: Model.Type<T>, callback?: (instance: T) => void): T;
-declare function useModel<T extends Model>(source: Model.Type<T>, apply: Model.Compat<T>, keys?: Model.Event<T>[]): T;
-declare function useModel<T extends Model>(source: () => T, watch?: Model.Field<T>[], callback?: (instance: T) => void): T;
-declare function useModel<T extends Model>(source: () => T, callback?: (instance: T) => void): T;
-declare function useModel<T extends Model>(source: () => T, apply: Model.Compat<T>, keys?: Model.Event<T>[]): T;
+declare function useModel<T extends Model>(source: Model.Type<T> | (() => T), callback?: (instance: T) => void): T;
+declare function useModel<T extends Model>(source: Model.Type<T> | (() => T), watch: Model.Field<T>[], callback?: (instance: T) => void): T;
+declare function useModel<T extends Model>(source: Model.Type<T> | (() => T), apply: Model.Compat<T>, keys?: Model.Event<T>[]): T;
 
 declare namespace useTap {
     type Source<T extends Model> = T | Model.Type<T> | (() => T | Model.Type<T>);

package/lib/index.esm.js

@@ -17,7 +17,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;
@@ -30,7 +30,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) {
@@ -46,15 +46,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)
@@ -94,7 +94,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();
@@ -111,7 +111,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;
         }
     };
@@ -187,20 +187,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();
@@ -211,49 +212,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;
@@ -320,7 +320,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 {
@@ -370,13 +371,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")
@@ -477,7 +481,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) {
@@ -485,7 +489,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 {
@@ -507,6 +511,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;
@@ -528,7 +535,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
@@ -546,12 +553,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) {
@@ -929,7 +932,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);
                         }
                     });
                 });
@@ -949,7 +952,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();
@@ -1034,7 +1037,7 @@ class Model {
                     throw Oops$5.NoChaining();
                 if (frame.size || arg1 !== false)
                     waiting.add(() => {
-                        callback(getUpdate(this));
+                        callback(control.latest);
                     });
                 else
                     callback(false);
@@ -1227,14 +1230,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.useLayoutEffect(() => {
         local.commit();
         return () => {
@@ -1291,10 +1288,10 @@ function useTap(source, arg1, arg2) {
     const instance = 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")
@@ -1324,10 +1321,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() {
@@ -1349,7 +1346,8 @@ Object.defineProperties(Model.prototype, {
     },
     [UPDATE]: {
         get() {
-            return getUpdate(this);
+            const source = Subscriber.get(this) || Control.get(this);
+            return source && source.latest;
         }
     }
 });