@fbltd/async 1.0.24 → 1.0.25

package/README.md

@@ -71,7 +71,35 @@ setInterval(() => {
 ##### onceStream
 ##### 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

package/dist/bin/dependency/dependency.js

@@ -1,5 +1,4 @@
 import { PromiseConfiguration } from "../promise-configuration.js";
-import { DependencyStream } from "./dependency.stream.js";
 import { baseComparer } from "./utils.js";
 import { collectDep } from "./global.js";
 export class Dependency {
@@ -16,6 +15,8 @@ export class Dependency {
         };
     }
     _set(v) {
+        if (this.done)
+            return;
         if (this.config.withCustomEquality(this._value, v)) {
             return;
         }
@@ -32,38 +33,36 @@ export class Dependency {
         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 () => {
-                this.reactionPromise = this.reactionPromise ?? new PromiseConfiguration();
                 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) {
@@ -79,21 +78,29 @@ export class Dependency {
             }
         };
     }
+    /**
+     * One race of value change and dependency dispose
+     * for all subscribers
+     */
     _race;
-    async next(ref = {}) {
-        const abortPromise = this.abortPromise;
+    getOrCreateRace() {
         if (!this._race) {
             this.reactionPromise = this.reactionPromise ?? new PromiseConfiguration();
             this._race = Promise.race([
-                abortPromise.promise,
+                this.abortPromise.promise,
                 this.reactionPromise.promise,
             ]);
         }
-        let race = this._race;
+        return this._race;
+    }
+    /**
+     * Another subscribe for current race
+     */
+    async next() {
+        let race = this.getOrCreateRace();
         await race;
         this._race = undefined;
-        if (abortPromise.isFulfilled) {
-            ref.done = true;
+        if (this.done) {
             return { done: true };
         }
         return {
@@ -105,7 +112,6 @@ export class Dependency {
     }
     dispose() {
         this.abortPromise.resolve();
-        this.abortPromise = new PromiseConfiguration();
         this.reactionPromise = undefined;
     }
 }

package/dist/bin/dependency/global.js

@@ -20,5 +20,7 @@ export function runFnWithDepCollection(fn) {
 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

@@ -3,22 +3,33 @@ import { runFnWithDepCollection } from "../global.js";
  * @deprecated
  */
 export function reaction(fn) {
-    const ref = { done: false };
     return {
         [Symbol.asyncIterator]: () => {
             let { result, deps } = runFnWithDepCollection(fn);
-            return {
+            let depsArray;
+            let beforeValues;
+            let obj = {
                 next: async () => {
-                    await Promise
-                        .race(Array
-                        .from(deps)
-                        .map(dep => dep.next(ref)));
-                    if (ref.done)
-                        return ref;
-                    ({ result, deps } = runFnWithDepCollection(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,12 +8,18 @@ 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;
-    next(ref?: {
-        done?: boolean;
-    }): Promise<{
+    private getOrCreateRace;
+    /**
+     * Another subscribe for current race
+     */
+    next(): Promise<{
         done: true;
         value?: never;
     } | {

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

@@ -7,7 +7,7 @@ export declare function reaction<T>(fn: () => T): {
             done: true;
             value?: never;
         } | {
-            done: boolean;
+            done: false;
             value: T;
         }>;
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fbltd/async",
-  "version": "1.0.24",
+  "version": "1.0.25",
   "description": "Miscellaneous async utils",
   "homepage": "https://github.com/GlennMiller1991/async",
   "type": "module",