@fbltd/async 1.0.23 → 1.0.25

package/README.md

@@ -72,6 +72,35 @@ setInterval(() => {
 ##### raceStream
 ##### next
 
+##### reaction
+The most powerful util among all stream utils.
+Function is watching only for actual dependencies and does not react
+for dependencies that do not affect result value:
+```typescript
+let isDep1Ready = new Dependency(false);
+let isDep2Ready = new Dependency(false);
+let counter = new Dependency(0);
+
+// function that implicityly uses dependency instances
+let cachedFunction = () => {
+    if (isDep1Ready.value && isDep2Ready.value) {
+        return counter.value;
+    }
+    return undefined;
+}
+
+async function subscribe() {
+    for await (const value of reaction(cachedFunction)) {
+        reactionFn();
+    }
+    exitFn();
+}
+```
+The reaction is declared deprecated because a return value caching does not
+use optimal strategy. Moreover, ideally, reaction should give back a 
+dependency instance or something like it, that can provide an ability
+to be an observable for another reaction.
+
 #### Framework integrations
 ##### React
 Of course, there is a React integration via stream hooks.

package/dist/bin/dependency/dependency.js

@@ -1,7 +1,6 @@
 import { PromiseConfiguration } from "../promise-configuration.js";
-import { DependencyStream } from "./dependency.stream.js";
 import { baseComparer } from "./utils.js";
-import { setDep } from "./global.js";
+import { collectDep } from "./global.js";
 export class Dependency {
     _value;
     reactionPromise;
@@ -16,6 +15,8 @@ export class Dependency {
         };
     }
     _set(v) {
+        if (this.done)
+            return;
         if (this.config.withCustomEquality(this._value, v)) {
             return;
         }
@@ -29,44 +30,39 @@ export class Dependency {
         this._set(v);
     }
     get value() {
-        setDep(this);
+        collectDep(this);
         return this._value;
     }
-    getStream() {
-        return new DependencyStream(this);
+    get done() {
+        return this.abortPromise.isFulfilled;
     }
     [Symbol.asyncIterator](thisStreamConfig = {}) {
-        const totalDispose = this.abortPromise;
-        const externalPromises = [totalDispose.promise];
+        const externalPromises = [];
         let firstPromise;
         const withReactionOnSubscribe = this.config.withReactionOnSubscribe || thisStreamConfig.withReactionOnSubscribe;
         if (withReactionOnSubscribe) {
             firstPromise = new PromiseConfiguration();
-            firstPromise.resolve(this.value);
+            firstPromise.resolve();
             externalPromises.push(firstPromise.promise);
         }
         if (thisStreamConfig.externalDispose) {
             externalPromises.push(thisStreamConfig.externalDispose.promise);
         }
-        let isDisposed = false;
         const owner = this;
+        let done = false;
         return {
             owner,
             dispose: owner.dispose.bind(owner),
             get isDisposed() {
-                return isDisposed;
+                return done || owner.done;
             },
             next: async () => {
-                if (!this.reactionPromise) {
-                    this.reactionPromise = new PromiseConfiguration();
-                    this._set(this._value);
-                }
                 await Promise.race([
                     ...externalPromises,
-                    this.reactionPromise.promise,
+                    owner.next(),
                 ]);
-                if (totalDispose.isFulfilled || thisStreamConfig.externalDispose?.isFulfilled) {
-                    isDisposed = true;
+                if (this.done || thisStreamConfig.externalDispose?.isFulfilled) {
+                    done = true;
                     return { done: true };
                 }
                 if (firstPromise) {
@@ -82,9 +78,40 @@ export class Dependency {
             }
         };
     }
+    /**
+     * One race of value change and dependency dispose
+     * for all subscribers
+     */
+    _race;
+    getOrCreateRace() {
+        if (!this._race) {
+            this.reactionPromise = this.reactionPromise ?? new PromiseConfiguration();
+            this._race = Promise.race([
+                this.abortPromise.promise,
+                this.reactionPromise.promise,
+            ]);
+        }
+        return this._race;
+    }
+    /**
+     * Another subscribe for current race
+     */
+    async next() {
+        let race = this.getOrCreateRace();
+        await race;
+        this._race = undefined;
+        if (this.done) {
+            return { done: true };
+        }
+        return {
+            done: false,
+            get value() {
+                return this.value;
+            }
+        };
+    }
     dispose() {
         this.abortPromise.resolve();
-        this.abortPromise = new PromiseConfiguration();
         this.reactionPromise = undefined;
     }
 }

package/dist/bin/dependency/global.js

@@ -3,7 +3,7 @@ const global = {
     dependencies: null
 };
 const notImplemented = new Error('Watching while watching is not implemented');
-export function watchDeps(fn) {
+export function runFnWithDepCollection(fn) {
     if (global.watchFlag) {
         throw notImplemented;
     }
@@ -17,8 +17,10 @@ export function watchDeps(fn) {
         result, deps
     };
 }
-export function setDep(dep) {
+export function collectDep(dep) {
     if (!global.watchFlag)
         return;
+    if (dep.done)
+        return;
     global.dependencies.add(dep);
 }

package/dist/bin/dependency/stream-utils/get.stream.js

@@ -0,0 +1,4 @@
+import { DependencyStream } from "../dependency.stream.js";
+export function getStream(dep) {
+    return new DependencyStream(dep);
+}

package/dist/bin/dependency/stream-utils/once.stream.js

@@ -1,6 +1,7 @@
 import { symAI } from "../../constants.js";
+import { getStream } from "./get.stream.js";
 export function onceStream(dep) {
-    const stream = dep.getStream();
+    const stream = getStream(dep);
     const iterator = stream[symAI]();
     return {
         get isDisposed() {

package/dist/bin/dependency/stream-utils/reaction.js

@@ -1,21 +1,35 @@
-import { watchDeps } from "../global.js";
-import { symAI } from "../../constants.js";
+import { runFnWithDepCollection } from "../global.js";
 /**
  * @deprecated
  */
 export function reaction(fn) {
     return {
         [Symbol.asyncIterator]: () => {
-            let { result, deps } = watchDeps(fn);
-            return {
+            let { result, deps } = runFnWithDepCollection(fn);
+            let depsArray;
+            let beforeValues;
+            let obj = {
                 next: async () => {
-                    const dependencies = Array.from(deps);
-                    const streams = dependencies.map(dep => dep[symAI]());
-                    await Promise.race(streams.map(s => s.next()));
-                    ({ result, deps } = watchDeps(fn));
-                    return { done: false, value: result };
+                    depsArray = Array.from(deps);
+                    beforeValues = depsArray.map(dep => dep.value);
+                    await Promise.race(depsArray.map(dep => dep.next()));
+                    let shouldRun = depsArray.some((dep, i) => dep.value !== beforeValues[i]);
+                    if (shouldRun) {
+                        ({ result, deps } = runFnWithDepCollection(fn));
+                        return { done: false, value: result };
+                    }
+                    else {
+                        for (let dep of deps) {
+                            if (dep.done)
+                                deps.delete(dep);
+                        }
+                        if (!deps.size)
+                            return { done: true };
+                        return obj.next();
+                    }
                 }
             };
+            return obj;
         }
     };
 }

package/dist/types/dependency/contracts.d.ts

@@ -16,9 +16,22 @@ export interface IIsEquals<T> {
 }
 export type IAllStreamConfig<T> = {
     withCustomEquality: IIsEquals<T>;
+    /**
+     * Reaction happens anyway right after current task
+     * wherever dependency was disposed
+     */
     withReactionOnSubscribe: boolean;
 };
 export type IThisStreamConfig = Partial<{
+    /**
+     * Reaction happens right after current task
+     * wherever dependency itself was disposed, but
+     * stream dispose has priority over first reaction
+     */
     withReactionOnSubscribe: boolean;
+    /**
+     * Dispose happens anyway right after current task,
+     * wherever value of dependency was changed
+     */
     externalDispose: PromiseConfiguration<any>;
 }>;

package/dist/types/dependency/dependency.d.ts

@@ -1,5 +1,4 @@
 import { IAllStreamConfig, IStreamIterator, IThisStreamConfig } from "./contracts.ts";
-import { DependencyStream } from "./dependency.stream.ts";
 export declare class Dependency<T = any> {
     private _value;
     private reactionPromise;
@@ -9,7 +8,23 @@ export declare class Dependency<T = any> {
     private _set;
     set value(v: T);
     get value(): T;
-    getStream(this: Dependency<T>): DependencyStream<T>;
+    get done(): boolean;
     [Symbol.asyncIterator](this: Dependency<T>, thisStreamConfig?: IThisStreamConfig): IStreamIterator<T>;
+    /**
+     * One race of value change and dependency dispose
+     * for all subscribers
+     */
+    private _race;
+    private getOrCreateRace;
+    /**
+     * Another subscribe for current race
+     */
+    next(): Promise<{
+        done: true;
+        value?: never;
+    } | {
+        done: boolean;
+        readonly value: T;
+    }>;
     dispose(this: Dependency<T>): void;
 }

package/dist/types/dependency/global.d.ts

@@ -3,9 +3,9 @@ declare const global: {
     watchFlag: boolean;
     dependencies: Set<Dependency>;
 };
-export declare function watchDeps<T>(fn: () => T): {
+export declare function runFnWithDepCollection<T>(fn: () => T): {
     result: T;
     deps: typeof global.dependencies;
 };
-export declare function setDep(dep: Dependency): void;
+export declare function collectDep(dep: Dependency): void;
 export {};

package/dist/types/dependency/stream-utils/get.stream.d.ts

@@ -0,0 +1,3 @@
+import { DependencyStream } from "../dependency.stream.ts";
+import { Dependency } from "../dependency.ts";
+export declare function getStream<T>(dep: Dependency<T>): DependencyStream<T>;

package/dist/types/dependency/stream-utils/reaction.d.ts

@@ -4,7 +4,10 @@
 export declare function reaction<T>(fn: () => T): {
     [Symbol.asyncIterator]: () => {
         next: () => Promise<{
-            done: boolean;
+            done: true;
+            value?: never;
+        } | {
+            done: false;
             value: T;
         }>;
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fbltd/async",
-  "version": "1.0.23",
+  "version": "1.0.25",
   "description": "Miscellaneous async utils",
   "homepage": "https://github.com/GlennMiller1991/async",
   "type": "module",
@@ -21,8 +21,8 @@
     "tsconfig.json"
   ],
   "scripts": {
-    "clearDist": "rm dist -r || true",
-    "clearModules": "rm node_modules -r || true",
+    "clearDist": "rm -r dist || true",
+    "clearModules": "rm -r node_modules || true",
     "clearAll": "npm run clearDist && npm run clearModules",
     "build": "npm run clearAll && npm i && mkdir dist && tsc",
     "test": "node --expose-gc node_modules/.bin/jest --config=./__tests__/jest.config.cjs",