@expressive/mvc 0.2.4 → 0.3.0

package/lib/index.d.ts

@@ -23,7 +23,6 @@ declare function array<T = any>(): T[];
 type Callback = () => void;
 type Class = new (...args: any[]) => any;
 type InstanceOf<T> = T extends { prototype: infer U } ? U : never;
-type RequestCallback<T extends string = string> = (keys: readonly T[]) => void;
 
 declare type Listener = {
     commit(): void;
@@ -136,7 +135,7 @@ declare class Model {
     constructor();
     get [STATE](): this;
     get [WHY](): readonly string[] | undefined;
-    on<P = Model.Event<this>>(event: (key: P) => RequestCallback | void): Callback;
+    on<P = Model.Event<this>>(event: (key: P) => Callback | void): Callback;
     on<P = Model.Event<this>>(keys: [], listener: Model.OnUpdate<this, P>, squash?: boolean, once?: boolean): Callback;
     on<P = Model.Event<this>>(keys: [], listener: (keys: P[]) => void, squash: true, once?: boolean): Callback;
     on(keys: [], listener: unknown, squash: boolean, once?: boolean): Callback;
@@ -186,16 +185,16 @@ declare class Model {
 }
 
 declare namespace Controller {
-    type OnEvent<T = any> = (key: Model.Event<T>, source: Controller) => RequestCallback | void;
     type OnValue<T = any, S = Model.Values<T>> = (this: T, value: any, state: S) => boolean | void;
+    type OnEvent<T = any> = (key: Model.Event<T>, source: Controller) => Callback | void;
 }
 declare class Controller<T extends Stateful = any> {
     subject: T;
     proxy: Model.Entries<T>;
     state: Model.Values<T, Exclude<keyof T & string, keyof Model>>;
     frame: Set<string>;
-    waiting: Set<RequestCallback<string>>;
     onDestroy: Set<Callback>;
+    private waiting;
     protected followers: Set<Model.Controller.OnEvent<any>>;
     constructor(subject: T);
     start(): void;
@@ -203,13 +202,13 @@ declare class Controller<T extends Stateful = any> {
     manage(key: Model.Field<T>, value: any): void;
     ref(key: Model.Field<T>, handler?: Controller.OnValue<T>): (value: any) => void;
     addListener(listener: Controller.OnEvent<T>): () => void;
-    emit(keys: readonly Model.Event<T>[]): void;
     update(key: Model.Event<T>, value?: any): void;
+    flush(): void;
     requestUpdate(): PromiseLike<readonly Model.Event<T>[] | false>;
     requestUpdate(strict: true): Promise<readonly Model.Event<T>[]>;
     requestUpdate(strict: false): Promise<false>;
     requestUpdate(strict: boolean): Promise<readonly Model.Event<T>[] | false>;
-    requestUpdate(callback: (keys: readonly Model.Event<T>[]) => void): void;
+    requestUpdate(callback: Callback): void;
 }
 
 /**
@@ -301,30 +300,10 @@ declare function ref<T extends Model>(target: T): ref.Proxy<T>;
 declare function ref<T = HTMLElement>(callback?: ref.Callback<T>): ref.Object<T>;
 declare function ref<T, S>(callback?: ref.Callback<T, S>): ref.Object<T>;
 
-declare namespace set {
+declare namespace set$1 {
     type Factory<T, S = unknown> = (this: S, key: string, subject: S) => T;
     type Callback<T, S = any> = (this: S, argument: T) => ((next: T) => void) | Promise<any> | void | boolean;
 }
-/**
- * Set property with a placeholder.
- *
- * Property cannot be accessed until it is defined. If accessed while undefined, a hybrid
- * `Promise`/`Error` (ala: [Suspense](https://reactjs.org/docs/concurrent-mode-suspense.html)) will be thrown.
- */
-declare function set<T = any>(): T;
-/**
- * Set property with starting value `undefined`.
- *
- * If required and accessed while still empty, React Suspense will be thrown.
- * Property will reject any assignment of undefined.
- *
- * @param value - Starting value of host property (undefined).
- * @param required - Property will suspend callee if undefined at time of access.
- */
-declare function set<T>(value: undefined, required: false): T | undefined;
-declare function set<T>(value: undefined, required?: boolean): T;
-declare function set<T>(value: undefined, onUpdate: set.Callback<T>): T | undefined;
-declare function set<T, S>(value: undefined, onUpdate: set.Callback<T, S>): T | undefined;
 /**
  * Set property with an async function.
  *
@@ -340,12 +319,12 @@ declare function set<T, S>(value: undefined, onUpdate: set.Callback<T, S>): T |
  * @param factory - Callback run to derrive property value.
  * @param required - (default: true) Run factory immediately on creation, otherwise on access.
  */
-declare function set<T>(factory: set.Factory<Promise<T>>, required: false): T | undefined;
-declare function set<T, S>(factory: set.Factory<Promise<T>, S>, required: false): T | undefined;
-declare function set<T>(factory: set.Factory<Promise<T>>, required?: boolean): T;
-declare function set<T, S>(factory: set.Factory<Promise<T>, S>, required?: boolean): T;
-declare function set<T>(value: set.Factory<Promise<T>>, onUpdate: set.Callback<T>): T;
-declare function set<T, S>(value: set.Factory<Promise<T>, S>, onUpdate: set.Callback<T, S>): T;
+declare function put<T>(factory: set$1.Factory<Promise<T>>, required: false): T | undefined;
+declare function put<T, S>(factory: set$1.Factory<Promise<T>, S>, required: false): T | undefined;
+declare function put<T>(factory: set$1.Factory<Promise<T>>, required?: boolean): T;
+declare function put<T, S>(factory: set$1.Factory<Promise<T>, S>, required?: boolean): T;
+declare function put<T>(value: set$1.Factory<Promise<T>>, onUpdate: set$1.Callback<T>): T;
+declare function put<T, S>(value: set$1.Factory<Promise<T>, S>, onUpdate: set$1.Callback<T, S>): T;
 /**
  * Set property with a factory function.
  *
@@ -358,24 +337,41 @@ declare function set<T, S>(value: set.Factory<Promise<T>, S>, onUpdate: set.Call
  * @param factory - Callback run to derrive property value.
  * @param required - (default: true) Run factory immediately on creation, otherwise on access.
  */
-declare function set<T>(factory: set.Factory<T>, required: false): T | undefined;
-declare function set<T, S>(factory: set.Factory<T, S>, required: false): T | undefined;
-declare function set<T>(factory: set.Factory<T>, required?: boolean): T;
-declare function set<T, S>(factory: set.Factory<T, S>, required?: boolean): T;
-declare function set<T>(value: set.Factory<T>, onUpdate: set.Callback<T>): T;
-declare function set<T, S>(value: set.Factory<T, S>, onUpdate: set.Callback<T, S>): T;
+declare function put<T>(factory: set$1.Factory<T>, required: false): T | undefined;
+declare function put<T, S>(factory: set$1.Factory<T, S>, required: false): T | undefined;
+declare function put<T>(factory: set$1.Factory<T>, required?: boolean): T;
+declare function put<T, S>(factory: set$1.Factory<T, S>, required?: boolean): T;
+declare function put<T>(value: set$1.Factory<T>, onUpdate: set$1.Callback<T>): T;
+declare function put<T, S>(value: set$1.Factory<T, S>, onUpdate: set$1.Callback<T, S>): T;
 /**
  * Assign a property with result of a promise.
  */
-declare function set<T>(factory: Promise<T>, required: false): T | undefined;
-declare function set<T>(factory: Promise<T>, required?: boolean): T;
-declare function set<T>(value: Promise<T>, onUpdate: set.Callback<T>): T;
+declare function put<T>(factory: Promise<T>, required: false): T | undefined;
+declare function put<T>(factory: Promise<T>, required?: boolean): T;
+declare function put<T>(value: Promise<T>, onUpdate: set$1.Callback<T>): T;
 /**
  * Assign a property.
  */
-declare function set<T>(factory: T, required: false): T | undefined;
-declare function set<T>(factory: T, required?: boolean): T;
+declare function put<T>(factory: T, required: false): T | undefined;
+declare function put<T>(factory: T, required?: boolean): T;
+declare function put<T>(value: T, onUpdate: set$1.Callback<T>): T;
+
+declare namespace set {
+    type Callback<T, S = any> = (this: S, argument: T) => ((next: T) => void) | Promise<any> | void | boolean;
+}
+/**
+ * Set property with a placeholder.
+ *
+ * Property cannot be accessed until it is defined. If accessed while undefined, a hybrid
+ * `Promise`/`Error` (ala: [Suspense](https://reactjs.org/docs/concurrent-mode-suspense.html)) will be thrown.
+ */
+declare function set<T = any>(): T;
+declare function set<T>(onUpdate: set.Callback<T>): T;
+declare function set<T, S>(onUpdate: set.Callback<T, S>): T;
+declare function set<T>(value: undefined, onUpdate: set.Callback<T>): T;
+declare function set<T, S>(value: undefined, onUpdate: set.Callback<T, S>): T;
 declare function set<T>(value: T, onUpdate: set.Callback<T>): T;
+declare function set<T, S>(value: T, onUpdate: set.Callback<T, S>): T;
 
 /**
  * Create a placeholder for specified Model type.
@@ -574,13 +570,13 @@ declare class Global extends MVC {
      *
      * @param required - If false, may return undefined.
      */
-    static get<T extends Class>(this: T, required?: true): InstanceOf<T>;
+    static get<T extends Class>(this: T, required: false): InstanceOf<T> | undefined;
     /**
      * **React Hook** - Fetch most instance of this controller from context.
      *
      * @param required - Unless false, will throw where instance cannot be found.
      */
-    static get<T extends Class>(this: T, required: boolean): InstanceOf<T> | undefined;
+    static get<T extends Class>(this: T, required?: boolean): InstanceOf<T>;
     /**
      * **React Hook** - Fetch specific value from instance of this controller in context.
      */
@@ -643,4 +639,4 @@ declare function useTap<T extends Stateful, K extends Model.Field<T>>(source: T
 declare function useTap<T extends Stateful, R>(source: T | (() => T) | useTap.Tappable, compute: (this: T, from: T) => R, expect: true): Exclude<R, undefined>;
 declare function useTap<T extends Stateful, R>(source: T | (() => T) | useTap.Tappable, compute: (this: T, from: T) => R, expect?: boolean): R;
 
-export { CONTROL, Consumer, Global, LOCAL, MVC as Model, Provider, STATE, Stateful, WHY, act, apply, array, MVC as default, from, parent, ref, set, tap, use, useFrom, useLocal, useModel, useTap };
+export { CONTROL, Consumer, Global, LOCAL, MVC as Model, Provider, STATE, Stateful, WHY, act, apply, array, MVC as default, from, parent, put, ref, set, tap, use, useFrom, useLocal, useModel, useTap };

package/lib/index.esm.js

@@ -140,6 +140,9 @@ function applyUpdate(subject, keys) {
             UPDATE.delete(subject);
         }, 0);
     };
+}
+function getUpdate(subject) {
+    return UPDATE.get(subject);
 }
 
 const CONTROL = Symbol("CONTROL");
@@ -171,21 +174,30 @@ class Model {
         return control(this, control => {
             if (typeof select == "function")
                 return control.addListener(select);
-            const keys = typeof select == "string" ? [select] :
+            const selection = typeof select == "string" ? [select] :
                 !select.length ? getOwnPropertyNames(control.state) :
                     select;
-            ensure(control, keys);
+            ensure(control, selection);
             const callback = squash
-                ? handler.bind(this)
-                : frame => frame
-                    .filter(k => keys.includes(k))
-                    .forEach(k => handler.call(this, control.state[k], k));
-            const trigger = once
-                ? frame => { remove(); callback(frame); }
+                ? () => {
+                    handler.call(this, getUpdate(this));
+                }
+                : () => {
+                    getUpdate(this)
+                        .filter(k => selection.includes(k))
+                        .forEach(k => {
+                        handler.call(this, control.state[k], k);
+                    });
+                };
+            const onEvent = once
+                ? () => {
+                    remove();
+                    callback();
+                }
                 : callback;
             const remove = control.addListener(key => {
-                if (keys.includes(key))
-                    return trigger;
+                if (selection.includes(key))
+                    return onEvent;
             });
             return remove;
         });
@@ -201,7 +213,7 @@ class Model {
         const effect = createEffect(callback);
         return control(this, control => {
             let busy = false;
-            let inject = this.get;
+            let inject = this.is;
             const invoke = () => {
                 if (busy)
                     return;
@@ -306,6 +318,7 @@ class Subscriber {
         this.watch = {};
         const parent = target instanceof Controller
             ? target : control(target);
+        const subject = parent.subject;
         const proxy = create(parent.proxy);
         let reset;
         define(proxy, LOCAL, this);
@@ -324,8 +337,10 @@ class Subscriber {
             if (typeof handler == "function")
                 handler();
             const notify = this.onUpdate(key, parent);
-            const getWhy = (keys) => {
-                reset = applyUpdate(proxy, keys.filter(k => k in this.watch));
+            const getWhy = () => {
+                const update = getUpdate(subject);
+                const applicable = update.filter(k => k in this.watch);
+                reset = applyUpdate(proxy, applicable);
             };
             if (notify) {
                 parent.requestUpdate(getWhy);
@@ -410,9 +425,9 @@ function from(source, arg1, arg2) {
             }
         }
         function defer(_key, from) {
-            let pending = KEYS.get(from);
+            let pending = KEYS.get(from.frame);
             if (!pending)
-                KEYS.set(from, pending = []);
+                KEYS.set(from.frame, pending = []);
             if (info.parent !== from)
                 update();
             else {
@@ -466,19 +481,17 @@ function ensure(on, keys) {
             getter(true);
     }
 }
-function flush(on) {
-    const handled = on.frame;
-    const pending = KEYS.get(on);
+function flush(frame) {
+    const pending = KEYS.get(frame);
     if (!pending)
         return;
     while (pending.length) {
-        const why = [...handled];
         const compute = pending.shift();
         const { key } = INFO.get(compute);
-        if (!handled.has(key))
-            compute(why);
+        if (!frame.has(key))
+            compute();
     }
-    KEYS.delete(on);
+    KEYS.delete(frame);
 }
 
 const Oops$9 = issues({
@@ -492,41 +505,41 @@ class Controller {
         this.subject = subject;
         this.state = {};
         this.frame = new Set();
-        this.waiting = new Set();
         this.onDestroy = new Set();
+        this.waiting = new Set();
         this.followers = new Set();
         this.proxy = Object.create(subject);
     }
     start() {
         READY.add(this);
         for (const key in this.subject) {
-            const { value: entry } = getOwnPropertyDescriptor(this.subject, key);
-            if (typeof entry == "function")
+            const { value } = getOwnPropertyDescriptor(this.subject, key);
+            if (typeof value == "function")
                 continue;
-            if (typeof entry == "symbol") {
-                const instruction = PENDING.get(entry);
+            if (typeof value == "symbol") {
+                const instruction = PENDING.get(value);
                 if (instruction)
                     instruction.call(this, key, this);
                 continue;
             }
-            this.manage(key, entry);
+            this.manage(key, value);
         }
-        this.emit([]);
+        this.flush();
     }
     stop() {
         this.followers.clear();
         this.onDestroy.forEach(x => x());
     }
     manage(key, value) {
-        const { proxy, state, subject } = this;
-        state[key] = value;
+        const { state } = this;
         const set = this.ref(key);
-        defineProperty(subject, key, {
+        state[key] = value;
+        defineProperty(this.subject, key, {
             enumerable: false,
             get: () => state[key],
             set
         });
-        defineProperty(proxy, key, {
+        defineProperty(this.proxy, key, {
             enumerable: false,
             get() {
                 const local = this[LOCAL];
@@ -558,53 +571,56 @@ class Controller {
             this.followers.delete(listener);
         };
     }
-    emit(keys) {
-        const waiting = [...this.waiting];
-        this.waiting.clear();
-        applyUpdate(this.subject, keys)();
-        for (const callback of waiting)
-            try {
-                callback(keys);
-            }
-            catch (err) {
-                console.error(err);
-            }
-    }
     update(key, value) {
+        const { frame } = this;
         if (1 in arguments)
             this.state[key] = value;
-        if (this.frame.has(key))
-            return;
-        if (!this.frame.size)
+        if (!frame.size)
             setTimeout(() => {
-                flush(this);
-                const keys = Object.freeze([...this.frame]);
-                this.frame.clear();
-                this.emit(keys);
+                flush(frame);
+                this.flush();
             }, 0);
-        this.frame.add(key);
+        else if (frame.has(key))
+            return;
+        frame.add(key);
         for (const callback of this.followers) {
             const event = callback(key, this);
             if (typeof event == "function")
                 this.waiting.add(event);
         }
     }
+    flush() {
+        const waiting = Array.from(this.waiting);
+        const keys = Array.from(this.frame);
+        this.frame.clear();
+        this.waiting.clear();
+        applyUpdate(this.subject, keys)();
+        for (const callback of waiting)
+            try {
+                callback();
+            }
+            catch (err) {
+                console.error(err);
+            }
+    }
     requestUpdate(arg) {
+        const { frame, subject, waiting } = this;
         if (typeof arg == "function") {
-            this.waiting.add(arg);
+            waiting.add(arg);
             return;
         }
-        if (arg === true && this.frame.size < 1)
+        if (!frame.size && arg === true)
             return Promise.reject(Oops$9.StrictUpdate());
         return {
             then: (callback) => {
-                if (callback)
-                    if (this.frame.size || arg !== false)
-                        this.waiting.add(callback);
-                    else
-                        callback(false);
-                else
+                if (!callback)
                     throw Oops$9.NoChaining();
+                if (frame.size || arg !== false)
+                    waiting.add(() => {
+                        callback(getUpdate(subject));
+                    });
+                else
+                    callback(false);
             }
         };
     }
@@ -827,65 +843,60 @@ const Oops$7 = issues({
     NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`,
     Failed: (model, key) => `Generating initial value for ${model}.${key} failed.`
 });
-function set(factory, argument) {
+function put(factory, argument) {
     return apply(function set(key) {
         const { subject, state } = this;
         const required = argument === true || argument === undefined;
         let set;
         let get;
-        let suspense;
-        if (factory === undefined)
-            suspense = true;
-        else {
-            let pending;
-            let error;
-            const init = () => {
-                const output = typeof factory == "function" ?
-                    mayRetry(() => factory.call(subject, key, subject)) :
-                    factory;
-                if (output instanceof Promise) {
-                    pending = output
-                        .catch(err => error = err)
-                        .then(val => state[key] = val)
-                        .finally(() => {
-                        pending = undefined;
-                        this.update(key);
-                    });
-                    return;
-                }
-                return state[key] = output;
-            };
-            const suspend = () => {
-                if (required === false)
-                    return undefined;
-                const issue = Oops$7.NotReady(subject, key);
-                Object.assign(pending, {
-                    message: issue.message,
-                    stack: issue.stack
+        let pending;
+        let error;
+        const init = () => {
+            const output = typeof factory == "function" ?
+                mayRetry(() => factory.call(subject, key, subject)) :
+                factory;
+            if (output instanceof Promise) {
+                pending = output
+                    .catch(err => error = err)
+                    .then(val => state[key] = val)
+                    .finally(() => {
+                    pending = undefined;
+                    this.update(key);
                 });
-                throw pending;
-            };
-            if (required)
-                try {
-                    init();
-                }
-                catch (err) {
-                    Oops$7.Failed(subject, key).warn();
-                    throw err;
-                }
-            get = () => {
-                if (pending)
-                    return suspend();
-                if (error)
-                    throw error;
-                if (key in state)
-                    return state[key];
-                let output = init();
-                return pending
-                    ? suspend()
-                    : output;
-            };
-        }
+                return;
+            }
+            return state[key] = output;
+        };
+        const suspend = () => {
+            if (required === false)
+                return undefined;
+            const issue = Oops$7.NotReady(subject, key);
+            Object.assign(pending, {
+                message: issue.message,
+                stack: issue.stack
+            });
+            throw pending;
+        };
+        if (required)
+            try {
+                init();
+            }
+            catch (err) {
+                Oops$7.Failed(subject, key).warn();
+                throw err;
+            }
+        get = () => {
+            if (pending)
+                return suspend();
+            if (error)
+                throw error;
+            if (key in state)
+                return state[key];
+            let output = init();
+            return pending
+                ? suspend()
+                : output;
+        };
         if (typeof argument == "function")
             set = createValueEffect(argument);
         else
@@ -895,8 +906,24 @@ function set(factory, argument) {
             };
         return {
             set,
-            get,
-            suspense
+            get
+        };
+    });
+}
+
+function set(value, argument) {
+    if (!(1 in arguments)) {
+        argument = value;
+        value = undefined;
+    }
+    return apply(function set(key) {
+        if (value !== undefined)
+            this.state[key] = value;
+        return {
+            suspense: true,
+            set: typeof argument == "function"
+                ? createValueEffect(argument)
+                : undefined
         };
     });
 }
@@ -1388,5 +1415,5 @@ class Global extends MVC {
     }
 }
 
-export { CONTROL, Consumer, Global, LOCAL, MVC as Model, Provider, STATE, WHY, act, apply, array, MVC as default, from, parent, ref, set, tap, use$1 as use, useFrom, useLocal, useModel, useTap };
+export { CONTROL, Consumer, Global, LOCAL, MVC as Model, Provider, STATE, WHY, act, apply, array, MVC as default, from, parent, put, ref, set, tap, use$1 as use, useFrom, useLocal, useModel, useTap };
 //# sourceMappingURL=index.esm.js.map