@expressive/mvc 0.9.3 → 0.9.4

package/lib/index.d.ts

@@ -29,6 +29,32 @@ declare class Subscriber<T extends {} = any> {
     private event;
 }
 
+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: "$debug controller";
+    readonly LOCAL: "$debug local";
+    readonly STATE: "$debug state";
+    readonly UPDATE: "$debug update";
+};
+declare type Debug<T extends {}> = T & {
+    /** Controller for this instance. */
+    [CONTROL]?: Control<T>;
+    /** Current subscriber (if present) while used in a live context (e.g. hook or effect). */
+    [LOCAL]?: Subscriber<T>;
+    /** Current state of this instance. */
+    [STATE]?: Model.Values<T>;
+    /**
+     * Last update causing a refresh to subscribers.
+     *
+     * If accessed directly, will contain all keys from last push.
+     * If within a subscribed function, will contain only keys which explicitly caused a refresh.
+     */
+    [UPDATE]?: readonly Model.Event<T>[];
+};
+
 declare namespace Model {
     export { Control };
     export { Subscriber };
@@ -52,7 +78,7 @@ declare namespace Model {
      *
      * TODO: Should exclude methods
      **/
-    export type Field<T, U extends Model = Model> = Exclude<keyof T & string, keyof U>;
+    export type Field<T, U extends Model = Model> = Exclude<keyof T, keyof U | keyof Debug<{}>> & string;
     /**
      * Including but not limited to `keyof T` which are not methods or defined by base Model.
      **/
@@ -415,12 +441,13 @@ declare class MVC extends Model {
      * **React Hook** - Fetch and subscribe to instance of this controller within ambient component.
      */
     static tap<T extends MVC>(this: Model.Type<T>): T;
-    static tap<I extends MVC, K extends Model.Field<I>>(this: Model.Type<I>, key: K, expect: true): Exclude<I[K], undefined>;
-    static tap<I extends MVC, K extends Model.Field<I>>(this: Model.Type<I>, key: K, expect?: boolean): I[K];
-    static tap<T, I extends MVC>(this: Model.Type<I>, from: (this: I, state: I) => Promise<T>, expect: true): Exclude<T, undefined>;
-    static tap<T, I extends MVC>(this: Model.Type<I>, from: (this: I, state: I) => Promise<T>, expect?: boolean): T;
-    static tap<T, I extends MVC>(this: Model.Type<I>, from: (this: I, state: I) => T, expect: true): Exclude<T, undefined>;
-    static tap<T, I extends MVC>(this: Model.Type<I>, from: (this: I, state: I) => T, expect?: boolean): T;
+    static tap<T extends MVC, K extends Model.Field<T>>(this: Model.Type<T>, key: K, expect: true): Exclude<T[K], undefined>;
+    static tap<T extends MVC, K extends Model.Field<T>>(this: Model.Type<T>, key: K, expect?: boolean): T[K];
+    static tap<T extends MVC, R>(this: Model.Type<T>, connect: (this: T, model: T) => () => R): R;
+    static tap<T extends MVC, R>(this: Model.Type<T>, connect: (this: T, model: T) => (() => R) | null): R | null;
+    static tap<T extends MVC, R>(this: Model.Type<T>, compute: (this: T, model: T) => Promise<R> | R, expect: true): Exclude<R, undefined>;
+    static tap<T extends MVC, R>(this: Model.Type<T>, compute: (this: T, model: T) => Promise<R>, expect?: boolean): R | undefined;
+    static tap<T extends MVC, R>(this: Model.Type<T>, compute: (this: T, model: T) => R, expect?: boolean): R;
     static use<I extends MVC>(this: Model.Type<I>, watch: Model.Field<I>[], callback?: (instance: I) => void): I;
     static use<I extends MVC>(this: Model.Type<I>, callback?: (instance: I) => void): I;
     static use<I extends MVC>(this: Model.Type<I>, apply: Model.Compat<I>, keys?: Model.Event<I>[]): I;
@@ -433,32 +460,6 @@ 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 = "$debug local";
-declare const STATE = "$debug state";
-declare const UPDATE = "$debug update";
-declare const CONTROL = "$debug controller";
-declare const Debug: {
-    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. */
-    [CONTROL]?: Control<T>;
-    /** Current subscriber (if present) while used in a live context (e.g. hook or effect). */
-    [LOCAL]?: Subscriber<T>;
-    /** Current state of this instance. */
-    [STATE]?: Model.Values<T>;
-    /**
-     * Last update causing a refresh to subscribers.
-     *
-     * If accessed directly, will contain all keys from last push.
-     * If within a subscribed function, will contain only keys which explicitly caused a refresh.
-     */
-    [UPDATE]?: readonly Model.Event<T>[];
-};
-
 declare namespace Consumer {
     type HasProps<E extends Class> = {
         /** @deprecated - use for instead */
@@ -538,7 +539,7 @@ declare class Global extends MVC {
      * Returns a thenable; resolves after successful update.
      * If instance does not already exist, one will be created.
      */
-    static set<T extends typeof Global>(this: T, values: Model.Compat<InstanceOf<T>, Global>): PromiseLike<Exclude<keyof InstanceOf<T> & string, keyof Global>[]>;
+    static set<T extends typeof Global>(this: T, values: Model.Compat<InstanceOf<T>, Global>): PromiseLike<Model.Field<InstanceOf<T>, Global>[]>;
     /**
      * **React Hook** - Fetch most instance of this controller from context, if it exists.
      *
@@ -597,7 +598,10 @@ declare namespace useTap {
 declare function useTap<T extends Model>(source: useTap.Source<T>): T;
 declare function useTap<T extends Model, K extends Model.Field<T>>(source: useTap.Source<T>, path: K, expect: true): Exclude<T[K], undefined>;
 declare function useTap<T extends Model, K extends Model.Field<T>>(source: useTap.Source<T>, path: K, expect?: boolean): T[K];
-declare function useTap<T extends Model, R>(source: useTap.Source<T>, compute: (this: T, from: T) => R, expect: true): Exclude<R, undefined>;
-declare function useTap<T extends Model, R>(source: useTap.Source<T>, compute: (this: T, from: T) => R, expect?: boolean): R;
+declare function useTap<T extends Model, R>(source: useTap.Source<T>, connect: (this: T, model: T) => () => R): R;
+declare function useTap<T extends Model, R>(source: useTap.Source<T>, connect: (this: T, model: T) => (() => R) | null): R | null;
+declare function useTap<T extends Model, R>(source: useTap.Source<T>, compute: (this: T, model: T) => Promise<R> | R, expect: true): Exclude<R, undefined>;
+declare function useTap<T extends Model, R>(source: useTap.Source<T>, compute: (this: T, model: T) => Promise<R>, expect?: boolean): R | undefined;
+declare function useTap<T extends Model, R>(source: useTap.Source<T>, compute: (this: T, model: T) => R, expect?: boolean): R;
 
 export { Consumer, Debug, Global, MVC, MVC as Model, Provider, add, MVC as default, get, has, ref, run, set, tap, use, useContext, useModel, useTap, useValue };

package/lib/index.esm.js

@@ -19,11 +19,11 @@ function issues(register) {
 
 const { assign, create, defineProperties, defineProperty, entries, getPrototypeOf, getOwnPropertyNames, getOwnPropertyDescriptor, getOwnPropertySymbols, values } = Object;
 
-const Oops$d = issues({
+const Oops$e = issues({
     NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`,
 });
 function suspend(source, key) {
-    const error = Oops$d.NotReady(source.subject, key);
+    const error = Oops$e.NotReady(source.subject, key);
     const promise = new Promise(resolve => {
         const release = source.addListener(forKey => {
             if (forKey == key)
@@ -63,7 +63,7 @@ function mayRetry(fn) {
     return compute();
 }
 
-const Oops$c = issues({
+const Oops$d = issues({
     Failed: (parent, property, initial) => `An exception was thrown while ${initial ? "initializing" : "refreshing"} [${parent}.${property}].`
 });
 const INFO = new WeakMap();
@@ -83,7 +83,7 @@ function computeMode(self, source, setter, key, required) {
             return setter.call(sub.proxy, sub.proxy);
         }
         catch (err) {
-            Oops$c.Failed(subject, key, initial).warn();
+            Oops$d.Failed(subject, key, initial).warn();
             throw err;
         }
     };
@@ -458,7 +458,7 @@ function __awaiter(thisArg, _arguments, P, generator) {
     });
 }
 
-const Oops$b = issues({
+const Oops$c = issues({
     DuplicatePending: (key) => `Invoked action ${key} but one is already active.`
 });
 function run(task) {
@@ -466,7 +466,7 @@ function run(task) {
         let pending = false;
         const invoke = (...args) => __awaiter(this, void 0, void 0, function* () {
             if (pending)
-                return Promise.reject(Oops$b.DuplicatePending(key));
+                return Promise.reject(Oops$c.DuplicatePending(key));
             pending = true;
             this.update(key);
             try {
@@ -488,7 +488,7 @@ function run(task) {
     });
 }
 
-const Oops$a = issues({
+const Oops$b = issues({
     NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`
 });
 function factoryMode(self, output, key, required) {
@@ -512,7 +512,7 @@ function factoryMode(self, output, key, required) {
     const suspend = () => {
         if (required === false)
             return undefined;
-        const issue = Oops$a.NotReady(subject, key);
+        const issue = Oops$b.NotReady(subject, key);
         assign(pending, {
             message: issue.message,
             stack: issue.stack
@@ -529,7 +529,7 @@ function factoryMode(self, output, key, required) {
     };
 }
 
-const Oops$9 = issues({
+const Oops$a = issues({
     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.`,
     Failed: (parent, property, initial) => `An exception was thrown while ${initial ? "initializing" : "refreshing"} [${parent}.${property}].`
@@ -542,7 +542,7 @@ function get(arg0, arg1, arg2) {
         let getter;
         // Easy mistake, using a peer, will always be unresolved.
         if (typeof arg0 == "symbol")
-            throw Oops$9.PeerNotAllowed(subject, key);
+            throw Oops$a.PeerNotAllowed(subject, key);
         // if(typeof arg0 == "function" && /^[A-Z]/.test(arg0.name))
         //   throw Oops.BadSource(subject, key, arg0);
         this.state.set(key, undefined);
@@ -576,7 +576,7 @@ function get(arg0, arg1, arg2) {
                 init();
             }
             catch (err) {
-                Oops$9.ComputeFailed(subject, key).warn();
+                Oops$a.ComputeFailed(subject, key).warn();
                 throw err;
             }
         return () => {
@@ -587,7 +587,7 @@ function get(arg0, arg1, arg2) {
     });
 }
 
-const Oops$8 = issues({
+const Oops$9 = issues({
     BadCallback: () => `Callback for effect-callback may only return a function.`
 });
 function createEffect(model, callback, keys) {
@@ -601,7 +601,7 @@ function createEffect(model, callback, keys) {
             if (unSet instanceof Promise)
                 unSet = undefined;
             if (unSet && typeof unSet !== "function")
-                throw Oops$8.BadCallback();
+                throw Oops$9.BadCallback();
         }
         function invoke() {
             if (busy)
@@ -644,7 +644,7 @@ function createValueEffect(callback) {
         if (typeof out == "function")
             unSet = out;
         else
-            throw Oops$8.BadCallback();
+            throw Oops$9.BadCallback();
     };
 }
 
@@ -842,7 +842,7 @@ function createProxy(emit, watch) {
 }
 
 const Parent = new WeakMap();
-const Oops$7 = issues({
+const Oops$8 = issues({
     BadArgument: (type) => `Instruction \`use\` cannot accept argument type of ${type}.`,
     NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`
 });
@@ -859,7 +859,7 @@ function use$1(input, argument) {
                 input = new input();
         }
         else if (input && typeof input !== "object")
-            throw Oops$7.BadArgument(typeof input);
+            throw Oops$8.BadArgument(typeof input);
         if (input instanceof Map || input instanceof Set)
             return keyed(this, key, input);
         const onUpdate = (next) => {
@@ -876,7 +876,7 @@ function use$1(input, argument) {
         const suspend = () => {
             if (required === false)
                 return;
-            const issue = Oops$7.NotReady(subject, key);
+            const issue = Oops$8.NotReady(subject, key);
             assign(pending, {
                 message: issue.message,
                 stack: issue.stack
@@ -921,7 +921,7 @@ function use$1(input, argument) {
     });
 }
 
-const Oops$6 = issues({
+const Oops$7 = issues({
     Required: (expects, child) => `New ${child} created standalone but requires parent of type ${expects}. Did you remember to create via use(${child})?`,
     Unexpected: (expects, child, got) => `New ${child} created as child of ${got}, but must be instanceof ${expects}.`,
 });
@@ -932,19 +932,100 @@ function has(Type, required) {
         const expected = Type.name;
         if (!value) {
             if (required !== false)
-                throw Oops$6.Required(expected, child);
+                throw Oops$7.Required(expected, child);
         }
         else if (!(value instanceof Type))
-            throw Oops$6.Unexpected(expected, child, value);
+            throw Oops$7.Unexpected(expected, child, value);
         return { value };
     });
 }
 
-const Oops$5 = issues({
+const Oops$6 = issues({
     Timeout: (keys, timeout) => `No update seen for [${keys}] within ${timeout}.`,
     KeysExpected: (key) => `Key "${key}" was expected in current update.`,
     StrictUpdate: () => `Expected update but none in progress.`,
-    StrictNoUpdate: () => `Update is not expected but one is in progress!`,
+    StrictNoUpdate: () => `Update is not expected but one is in progress!`
+});
+function addEventListener(source, arg1, arg2, arg3) {
+    const single = typeof arg1 == "string";
+    const keys = typeof arg1 == "string" ? [arg1] :
+        typeof arg1 == "object" ? arg1 :
+            undefined;
+    if (typeof arg2 == "function" && keys)
+        return Control.for(source, control => {
+            for (const key of keys)
+                try {
+                    void source[key];
+                }
+                catch (e) { }
+            const invoke = single
+                ? () => arg2.call(source, control.state.get(arg1), arg1)
+                : (frame) => arg2.call(source, frame);
+            const removeListener = control.addListener(key => {
+                if (!key && !keys.length)
+                    invoke([]);
+                if (keys.includes(key)) {
+                    if (arg3)
+                        removeListener();
+                    return invoke;
+                }
+            });
+            return removeListener;
+        });
+    return new Promise((resolve, reject) => {
+        const timeout = (message) => {
+            const k = keys ? keys.join(", ") : "any";
+            removeListener();
+            reject(Oops$6.Timeout(k, message));
+        };
+        const removeListener = Control.for(source, control => {
+            const pending = control.frame;
+            if (keys === null) {
+                if (pending.size)
+                    reject(Oops$6.StrictNoUpdate());
+                else
+                    resolve(null);
+                return;
+            }
+            if (keys) {
+                if (keys.length) {
+                    if (arg2 === 0 && single && !pending.has(keys[0])) {
+                        reject(Oops$6.KeysExpected(keys[0]));
+                        return;
+                    }
+                    else
+                        for (const key of keys)
+                            try {
+                                void source[key];
+                            }
+                            catch (e) { }
+                }
+            }
+            else if (!pending.size && arg1 === true || arg2 === 0) {
+                reject(Oops$6.StrictUpdate());
+                return;
+            }
+            else
+                control.waiting.add(resolve);
+            return control.addListener(key => {
+                if (!key) {
+                    if (keys && !keys.length)
+                        resolve([]);
+                    else
+                        timeout(`lifetime of ${source}`);
+                }
+                else if (!keys || keys.includes(key)) {
+                    removeListener();
+                    return keys => resolve(single ? control.state.get(key) : keys);
+                }
+            });
+        });
+        if (arg2 && typeof arg2 == "number")
+            setTimeout(() => timeout(`${arg2}ms`), arg2);
+    });
+}
+
+const Oops$5 = issues({
     NoChaining: () => `Then called with undefined; update promise will never catch nor supports chaining.`
 });
 class Model {
@@ -955,82 +1036,7 @@ class Model {
     on(arg1, arg2, arg3) {
         if (typeof arg1 == "function")
             return createEffect(this.is, arg1, arg2);
-        const single = typeof arg1 == "string";
-        const keys = typeof arg1 == "string" ? [arg1] :
-            typeof arg1 == "object" ? arg1 :
-                undefined;
-        if (typeof arg2 == "function" && keys)
-            return Control.for(this, control => {
-                for (const key of keys)
-                    try {
-                        void this[key];
-                    }
-                    catch (e) { }
-                const invoke = single
-                    ? () => arg2.call(this, control.state.get(arg1), arg1)
-                    : (frame) => arg2.call(this, frame);
-                const removeListener = control.addListener(key => {
-                    if (!key && !keys.length)
-                        invoke([]);
-                    if (keys.includes(key)) {
-                        if (arg3)
-                            removeListener();
-                        return invoke;
-                    }
-                });
-                return removeListener;
-            });
-        return new Promise((resolve, reject) => {
-            const timeout = (message) => {
-                const k = keys ? keys.join(", ") : "any";
-                removeListener();
-                reject(Oops$5.Timeout(k, message));
-            };
-            const removeListener = Control.for(this, control => {
-                const pending = control.frame;
-                if (keys === null) {
-                    if (pending.size)
-                        reject(Oops$5.StrictNoUpdate());
-                    else
-                        resolve(null);
-                    return;
-                }
-                if (keys) {
-                    if (keys.length) {
-                        if (arg2 === 0 && single && !pending.has(keys[0])) {
-                            reject(Oops$5.KeysExpected(keys[0]));
-                            return;
-                        }
-                        else
-                            for (const key of keys)
-                                try {
-                                    void this[key];
-                                }
-                                catch (e) { }
-                    }
-                }
-                else if (!pending.size && arg1 === true || arg2 === 0) {
-                    reject(Oops$5.StrictUpdate());
-                    return;
-                }
-                else
-                    control.waiting.add(resolve);
-                return control.addListener(key => {
-                    if (!key) {
-                        if (keys && !keys.length)
-                            resolve([]);
-                        else
-                            timeout(`lifetime of ${this}`);
-                    }
-                    else if (!keys || keys.includes(key)) {
-                        removeListener();
-                        return keys => resolve(single ? control.state.get(key) : keys);
-                    }
-                });
-            });
-            if (arg2 && typeof arg2 == "number")
-                setTimeout(() => timeout(`${arg2}ms`), arg2);
-        });
+        return addEventListener(this.is, arg1, arg2, arg3);
     }
     export(subset) {
         const { state } = Control.for(this);
@@ -1283,6 +1289,19 @@ function useValue(source, compute, suspend) {
             else
                 refresh();
         };
+        if (value === null) {
+            sub.watch.clear();
+            return {
+                proxy: null,
+                release: () => { }
+            };
+        }
+        if (typeof value == "function") {
+            const get = value;
+            sub.watch.clear();
+            compute = () => get();
+            value = get();
+        }
         if (value instanceof Promise) {
             value.then(set);
             value = undefined;