@expressive/mvc 0.13.1 → 0.14.0

package/lib/index.d.ts

@@ -417,6 +417,11 @@ 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 = {
+        (): void;
+        <T = void>(passthru?: 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 +462,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;
@@ -483,15 +488,16 @@ declare function useNew<T extends Model>(source: Model.Type<T> | (() => T), appl
 
 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> = {

package/lib/index.esm.js

@@ -1354,10 +1354,16 @@ 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 (make)
+                reassign(make());
+            else
+                refresh();
+            if (passthru)
+                return passthru.finally(refresh);
+        }
+        function reassign(next) {
             value = next;
             if (retry) {
                 retry();
@@ -1365,13 +1371,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 +1387,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 +1409,8 @@ function useCompute(source, compute, suspend) {
         });
         return sub;
     }, deps);
+    if (!local)
+        return null;
     React.useLayoutEffect(() => local.release, deps);
     return local.proxy;
 }

package/lib/index.js

@@ -1362,10 +1362,16 @@ 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 (make)
+                reassign(make());
+            else
+                refresh();
+            if (passthru)
+                return passthru.finally(refresh);
+        }
+        function reassign(next) {
             value = next;
             if (retry) {
                 retry();
@@ -1373,13 +1379,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 +1395,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 +1417,8 @@ function useCompute(source, compute, suspend) {
         });
         return sub;
     }, deps);
+    if (!local)
+        return null;
     React__default["default"].useLayoutEffect(() => local.release, deps);
     return local.proxy;
 }

package/package.json

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