@expressive/mvc 0.8.0 → 0.8.1

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

@@ -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,47 @@ 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)));
-}
 class Control {
     constructor(subject) {
         this.subject = subject;
@@ -320,7 +319,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 {
@@ -371,12 +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")
@@ -929,7 +933,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 +953,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 +1038,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 +1231,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 () => {
@@ -1324,10 +1322,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 +1347,8 @@ Object.defineProperties(Model.prototype, {
     },
     [UPDATE]: {
         get() {
-            return getUpdate(this);
+            const source = Subscriber.get(this) || Control.get(this);
+            return source && source.latest;
         }
     }
 });