@expressive/mvc 0.13.1 → 0.15.0

package/lib/index.d.ts

@@ -61,7 +61,10 @@ declare namespace Model {
     export { Subscriber };
     /** Including but not limited to T. */
     type Extends<T> = T | (string & Record<never, never>);
-    export type Type<T extends Model = Model> = typeof Model & (new () => T);
+    /** Any typeof Model, using class constructor as the reference. */
+    export type Type<T extends Model = Model> = (new (...args: any[]) => T);
+    /** A typeof Model, specifically one which may be created without arguments. */
+    export type Constructor<T extends Model = Model> = (new () => T) & typeof Model;
     export type Effect<T> = (this: T, argument: T) => Callback | Promise<any> | void;
     /** Exotic value, actual value is contained. */
     export type Ref<T = any> = {
@@ -105,7 +108,7 @@ declare namespace Model {
     export type Get<T, K extends Key<T> = Key<T>> = {
         [P in K]: Value<T[P]>;
     };
-    export type Export<T, E extends Model = Model> = {
+    export type Export<T> = {
         [P in Key<T>]: Value<T[P]>;
     };
 }
@@ -386,7 +389,7 @@ declare function use<T extends Model>(from: () => T, required: boolean): T;
 /**
  * Create a new child instance of model.
  */
-declare function use<T extends Model>(Type: Model.Type<T>, callback?: (i: T) => void): T;
+declare function use<T extends Model>(Type: Model.Constructor<T>, callback?: (i: T) => void): T;
 /**
  * Create a managed child from factory function.
  */
@@ -417,6 +420,22 @@ declare function has<T extends Model>(Type: Model.Type<T>, required?: true): T;
 
 declare namespace MVC {
     type EffectCallback<T = MVC> = (found: T) => Callback | void;
+    type ForceUpdate = {
+        /** Force an update in current component. */
+        (): void;
+        /**
+         * Force an update and again after promise either resolves or rejects.
+         * Will return a duplicate of given Promise, which resolves after refresh.
+         */
+        <T = void>(passthru?: Promise<T>): Promise<T>;
+        /**
+         * Force a update while calling async function.
+         * A refresh will occur both before and after given function.
+         * Any actions performed before first `await` will occur before refresh!
+         */
+        <T = void>(invoke?: () => Promise<T>): Promise<T>;
+    };
+    type TapCallback<T extends Model, R> = (this: T, model: T, update: MVC.ForceUpdate) => R;
 }
 declare class MVC extends Model {
     end(force?: boolean): boolean | void;
@@ -457,11 +476,11 @@ declare class MVC extends Model {
     static tap<T extends MVC>(this: Model.Type<T>): T;
     static tap<T extends MVC, K extends Model.Key<T>>(this: Model.Type<T>, key: K, expect: true): Exclude<T[K], undefined>;
     static tap<T extends MVC, K extends Model.Key<T>>(this: Model.Type<T>, key: K, expect?: boolean): NoVoid<T[K]>;
-    static tap<T extends MVC, R>(this: Model.Type<T>, connect: (this: T, model: T) => () => R): NoVoid<R>;
-    static tap<T extends MVC, R>(this: Model.Type<T>, connect: (this: T, model: T) => (() => R) | null): NoVoid<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): NoVoid<R> | null;
-    static tap<T extends MVC, R>(this: Model.Type<T>, compute: (this: T, model: T) => R, expect?: boolean): NoVoid<R>;
+    static tap<T extends MVC, R>(this: Model.Type<T>, connect: MVC.TapCallback<T, () => R>): NoVoid<R>;
+    static tap<T extends MVC, R>(this: Model.Type<T>, connect: MVC.TapCallback<T, (() => R) | null>): NoVoid<R> | null;
+    static tap<T extends MVC, R>(this: Model.Type<T>, compute: MVC.TapCallback<T, Promise<R> | R>, expect: true): Exclude<R, undefined>;
+    static tap<T extends MVC, R>(this: Model.Type<T>, compute: MVC.TapCallback<T, Promise<R>>, expect?: boolean): NoVoid<R> | null;
+    static tap<T extends MVC, R>(this: Model.Type<T>, compute: MVC.TapCallback<T, R>, expect?: boolean): NoVoid<R>;
     static use<I extends MVC>(this: Model.Type<I>, watch: Model.Key<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;
@@ -477,21 +496,22 @@ declare class MVC extends Model {
 declare function useContext<T extends Model>(Type: Model.Type<T>, required: false): T | undefined;
 declare function useContext<T extends Model>(Type: Model.Type<T>, required?: boolean): T;
 
-declare function useNew<T extends Model>(source: Model.Type<T> | (() => T), callback?: (instance: T) => void): T;
-declare function useNew<T extends Model>(source: Model.Type<T> | (() => T), watch: Model.Key<T>[], callback?: (instance: T) => void): T;
-declare function useNew<T extends Model>(source: Model.Type<T> | (() => T), apply: Model.Compat<T>, keys?: Model.Event<T>[]): T;
+declare function useNew<T extends Model>(source: Model.Constructor<T> | (() => T), callback?: (instance: T) => void): T;
+declare function useNew<T extends Model>(source: Model.Constructor<T> | (() => T), watch: Model.Key<T>[], callback?: (instance: T) => void): T;
+declare function useNew<T extends Model>(source: Model.Constructor<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>);
+    type Callback<T extends Model, R> = (this: T, model: T, update: MVC.ForceUpdate) => R;
 }
 declare function useTap<T extends Model>(source: useTap.Source<T>): T;
 declare function useTap<T extends Model, K extends Model.Key<T>>(source: useTap.Source<T>, path: K, expect: true): Exclude<T[K], undefined>;
 declare function useTap<T extends Model, K extends Model.Key<T>>(source: useTap.Source<T>, path: K, expect?: boolean): NoVoid<T[K]>;
-declare function useTap<T extends Model, R>(source: useTap.Source<T>, connect: (this: T, model: T) => () => R): NoVoid<R>;
-declare function useTap<T extends Model, R>(source: useTap.Source<T>, connect: (this: T, model: T) => (() => R) | null): NoVoid<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): NoVoid<R> | null;
-declare function useTap<T extends Model, R>(source: useTap.Source<T>, compute: (this: T, model: T) => R, expect?: boolean): NoVoid<R>;
+declare function useTap<T extends Model, R>(source: useTap.Source<T>, connect: useTap.Callback<T, () => R>): NoVoid<R>;
+declare function useTap<T extends Model, R>(source: useTap.Source<T>, connect: useTap.Callback<T, (() => R) | null>): NoVoid<R> | null;
+declare function useTap<T extends Model, R>(source: useTap.Source<T>, compute: useTap.Callback<T, Promise<R> | R>, expect: true): Exclude<R, undefined>;
+declare function useTap<T extends Model, R>(source: useTap.Source<T>, compute: useTap.Callback<T, Promise<R>>, expect?: boolean): NoVoid<R> | null;
+declare function useTap<T extends Model, R>(source: useTap.Source<T>, compute: useTap.Callback<T, R>, expect?: boolean): NoVoid<R>;
 
 declare namespace Consumer {
     type HasProps<E extends Class> = {
@@ -531,7 +551,7 @@ declare namespace Consumer {
 declare function Consumer<T extends Class>(props: Consumer.Props<T>): any;
 
 declare namespace Provider {
-    type Item = Model | Model.Type;
+    type Item = Model | Model.Constructor;
     type Multiple<T extends Item = Item> = T[] | {
         [key: string]: T;
     };
@@ -540,13 +560,13 @@ declare namespace Provider {
         for: E;
         fallback?: React.ReactNode;
         children?: React.ReactNode | ((instance: I) => React.ReactNode);
-        and?: Model.Compat<I>;
+        use?: Model.Compat<I>;
     };
     type MultipleProps<T extends Item> = {
         for: Multiple<T>;
         fallback?: React.ReactNode;
         children?: React.ReactNode;
-        and?: Model.Compat<Instance<T>>;
+        use?: Model.Compat<Instance<T>>;
     };
     type Props<T extends Item> = MultipleProps<T> | NormalProps<T>;
 }

package/lib/index.esm.js

@@ -1354,10 +1354,18 @@ function useCompute(source, compute, suspend) {
     const local = use(refresh => {
         const sub = control(source).subscribe(() => update);
         const spy = sub.proxy;
-        let value = compute.call(spy, spy);
-        let update;
-        let retry;
-        const set = (next) => {
+        let make = () => compute.call(spy, spy, forceUpdate);
+        function forceUpdate(passthru) {
+            if (typeof passthru == "function")
+                passthru = passthru();
+            if (make)
+                reassign(make());
+            else
+                refresh();
+            if (passthru)
+                return passthru.finally(refresh);
+        }
+        function reassign(next) {
             value = next;
             if (retry) {
                 retry();
@@ -1365,13 +1373,14 @@ function useCompute(source, compute, suspend) {
             }
             else
                 refresh();
-        };
+        }
+        let retry;
+        let update;
+        let value = make();
         if (value === null) {
             sub.watch.clear();
-            return {
-                proxy: null,
-                release: () => { }
-            };
+            make = undefined;
+            return;
         }
         if (typeof value == "function") {
             const get = value;
@@ -1380,15 +1389,15 @@ function useCompute(source, compute, suspend) {
             value = get();
         }
         if (value instanceof Promise) {
-            value.then(set);
+            value.then(reassign);
             value = undefined;
         }
         else {
             sub.commit();
             update = () => {
-                const next = compute.call(spy, spy);
+                const next = make();
                 if (value != next)
-                    set(next);
+                    reassign(next);
             };
         }
         defineProperty(sub, "proxy", {
@@ -1402,6 +1411,8 @@ function useCompute(source, compute, suspend) {
         });
         return sub;
     }, deps);
+    if (!local)
+        return null;
     React.useLayoutEffect(() => local.release, deps);
     return local.proxy;
 }
@@ -1517,7 +1528,7 @@ const Oops = issues({
     NoType: () => "Provider 'for' prop must be Model, typeof Model or a collection of them."
 });
 function Provider(props) {
-    const context = useNewContext(props.for, props.and);
+    const context = useNewContext(props.for, props.use);
     return (React.createElement(LookupContext.Provider, { value: context }, props.fallback === false
         ? props.children
         : (React.createElement(Suspense, { fallback: props.fallback || null }, props.children))));

package/lib/index.js

@@ -1362,10 +1362,18 @@ function useCompute(source, compute, suspend) {
     const local = use(refresh => {
         const sub = control(source).subscribe(() => update);
         const spy = sub.proxy;
-        let value = compute.call(spy, spy);
-        let update;
-        let retry;
-        const set = (next) => {
+        let make = () => compute.call(spy, spy, forceUpdate);
+        function forceUpdate(passthru) {
+            if (typeof passthru == "function")
+                passthru = passthru();
+            if (make)
+                reassign(make());
+            else
+                refresh();
+            if (passthru)
+                return passthru.finally(refresh);
+        }
+        function reassign(next) {
             value = next;
             if (retry) {
                 retry();
@@ -1373,13 +1381,14 @@ function useCompute(source, compute, suspend) {
             }
             else
                 refresh();
-        };
+        }
+        let retry;
+        let update;
+        let value = make();
         if (value === null) {
             sub.watch.clear();
-            return {
-                proxy: null,
-                release: () => { }
-            };
+            make = undefined;
+            return;
         }
         if (typeof value == "function") {
             const get = value;
@@ -1388,15 +1397,15 @@ function useCompute(source, compute, suspend) {
             value = get();
         }
         if (value instanceof Promise) {
-            value.then(set);
+            value.then(reassign);
             value = undefined;
         }
         else {
             sub.commit();
             update = () => {
-                const next = compute.call(spy, spy);
+                const next = make();
                 if (value != next)
-                    set(next);
+                    reassign(next);
             };
         }
         defineProperty(sub, "proxy", {
@@ -1410,6 +1419,8 @@ function useCompute(source, compute, suspend) {
         });
         return sub;
     }, deps);
+    if (!local)
+        return null;
     React__default["default"].useLayoutEffect(() => local.release, deps);
     return local.proxy;
 }
@@ -1525,7 +1536,7 @@ const Oops = issues({
     NoType: () => "Provider 'for' prop must be Model, typeof Model or a collection of them."
 });
 function Provider(props) {
-    const context = useNewContext(props.for, props.and);
+    const context = useNewContext(props.for, props.use);
     return (React__default["default"].createElement(LookupContext.Provider, { value: context }, props.fallback === false
         ? props.children
         : (React__default["default"].createElement(React.Suspense, { fallback: props.fallback || null }, props.children))));

package/package.json

@@ -49,5 +49,5 @@
     "tslib": "^2.3.0",
     "typescript": "4.6.3"
   },
-  "version": "0.13.1"
+  "version": "0.15.0"
 }