@fbltd/async 1.0.24 → 1.0.26

package/README.md

@@ -36,7 +36,6 @@ There is no any management of passed data for resolving.
 Returned promise is usual ES promise so it is impossible to fulfill promise twice.
 
 ### DependencyStream
-#### core
 Implementation of reactive model leveraging native JavaScript async features like
 Promises, (async) iterators and generators.
 The version is 0.0.x so keep it in mind
@@ -71,7 +70,34 @@ 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. Since the reaction
+provides dependency instance, of course, there is a function result caching:
+```typescript
+let isDep1Ready = new Dependency(false);
+let isDep2Ready = new Dependency(false);
+let counter = new Dependency(0);
+
+// function that uses dependency instances
+let watchFn = () => {
+    // Take a look at IF condition -
+    // value can be changed only if dep1 and dep2 is ready
+    if (isDep1Ready.value && isDep2Ready.value) {
+        return counter.value;
+    }
+    return undefined;
+}
+
+async function subscribe() {
+    for await (const value of reaction(watchFn)) {
+        reactionFn();
+    }
+    exitFn();
+}
+```
 
 #### Framework integrations
 ##### React

package/dist/bin/dependency/dep.factory.js

@@ -0,0 +1,10 @@
+import { Dependency } from "./dependency.js";
+import { reaction } from "./stream-utils/index.js";
+export class DepFactory {
+    static ofValue(value, config) {
+        return new Dependency(value, config);
+    }
+    static ofReaction(fn, config) {
+        return reaction(fn, config);
+    }
+}

package/dist/bin/dependency/dependency.js

@@ -1,7 +1,7 @@
 import { PromiseConfiguration } from "../promise-configuration.js";
-import { DependencyStream } from "./dependency.stream.js";
 import { baseComparer } from "./utils.js";
 import { collectDep } from "./global.js";
+import { symAI } from "../constants.js";
 export class Dependency {
     _value;
     reactionPromise;
@@ -16,6 +16,8 @@ export class Dependency {
         };
     }
     _set(v) {
+        if (this.done)
+            return;
         if (this.config.withCustomEquality(this._value, v)) {
             return;
         }
@@ -32,38 +34,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];
+    [symAI](thisStreamConfig = {}) {
+        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 +79,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 {
@@ -103,9 +111,11 @@ export class Dependency {
             }
         };
     }
+    get disposePromise() {
+        return this.abortPromise.promise;
+    }
     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/index.js

@@ -1,4 +1,5 @@
 export * from "./dependency.js";
 export * from "./dependency.stream.js";
+export * from "./dep.factory.js";
 export * from "./stream-utils/index.js";
 export * from "./integrations/index.js";

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,24 +1,44 @@
 import { runFnWithDepCollection } from "../global.js";
-/**
- * @deprecated
- */
-export function reaction(fn) {
-    const ref = { done: false };
-    return {
-        [Symbol.asyncIterator]: () => {
-            let { result, deps } = runFnWithDepCollection(fn);
-            return {
-                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 };
-                }
-            };
+import { Dependency } from "../dependency.js";
+import { symAI } from "../../constants.js";
+export function reaction(fn, config) {
+    let { result, deps } = runFnWithDepCollection(fn);
+    const dep = new Dependency(result, config);
+    async function subscribe() {
+        const stream = { [symAI]: () => {
+                let depsArray;
+                let beforeValues;
+                let obj = {
+                    next: async () => {
+                        depsArray = Array.from(deps);
+                        beforeValues = depsArray.map(dep => dep.value);
+                        const promises = depsArray.map(dep => dep.next());
+                        promises.push(dep.disposePromise);
+                        await Promise.race(depsArray.map(dep => dep.next()));
+                        if (dep.done)
+                            return { done: true };
+                        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;
+            } };
+        for await (let value of stream) {
+            dep.value = value;
         }
-    };
+    }
+    subscribe().then(() => dep.dispose());
+    return dep;
 }

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/dep.factory.d.ts

@@ -0,0 +1,6 @@
+import { Dependency } from "./dependency.ts";
+import { IAllStreamConfig } from "./contracts.ts";
+export declare abstract class DepFactory {
+    static ofValue<T>(value: T, config?: Partial<IAllStreamConfig<T>>): Dependency<T>;
+    static ofReaction<T>(fn: () => T, config?: Partial<IAllStreamConfig<T>>): Dependency<T>;
+}

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

@@ -1,5 +1,5 @@
 import { IAllStreamConfig, IStreamIterator, IThisStreamConfig } from "./contracts.ts";
-import { DependencyStream } from "./dependency.stream.ts";
+import { symAI } from "../constants.ts";
 export declare class Dependency<T = any> {
     private _value;
     private reactionPromise;
@@ -9,17 +9,24 @@ export declare class Dependency<T = any> {
     private _set;
     set value(v: T);
     get value(): T;
-    getStream(this: Dependency<T>): DependencyStream<T>;
-    [Symbol.asyncIterator](this: Dependency<T>, thisStreamConfig?: IThisStreamConfig): IStreamIterator<T>;
+    get done(): boolean;
+    [symAI](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;
     } | {
         done: boolean;
         readonly value: T;
     }>;
+    get disposePromise(): Promise<void>;
     dispose(this: Dependency<T>): void;
 }

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

@@ -1,4 +1,5 @@
 export * from './dependency.ts';
 export * from './dependency.stream.ts';
+export * from './dep.factory.ts';
 export * from './stream-utils/index.ts';
 export * from './integrations/index.ts';

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

@@ -1,14 +1,3 @@
-/**
- * @deprecated
- */
-export declare function reaction<T>(fn: () => T): {
-    [Symbol.asyncIterator]: () => {
-        next: () => Promise<{
-            done: true;
-            value?: never;
-        } | {
-            done: boolean;
-            value: T;
-        }>;
-    };
-};
+import { Dependency } from "../dependency.ts";
+import { IAllStreamConfig } from "../contracts.js";
+export declare function reaction<T>(fn: () => T, config?: Partial<IAllStreamConfig<T>>): Dependency<T>;

package/package.json

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