@fbltd/async 1.0.25 → 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
@@ -75,14 +74,17 @@ setInterval(() => {
 ##### 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:
+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 implicityly uses dependency instances
-let cachedFunction = () => {
+// 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;
     }
@@ -90,16 +92,12 @@ let cachedFunction = () => {
 }
 
 async function subscribe() {
-    for await (const value of reaction(cachedFunction)) {
+    for await (const value of reaction(watchFn)) {
         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/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,6 +1,7 @@
 import { PromiseConfiguration } from "../promise-configuration.js";
 import { baseComparer } from "./utils.js";
 import { collectDep } from "./global.js";
+import { symAI } from "../constants.js";
 export class Dependency {
     _value;
     reactionPromise;
@@ -36,7 +37,7 @@ export class Dependency {
     get done() {
         return this.abortPromise.isFulfilled;
     }
-    [Symbol.asyncIterator](thisStreamConfig = {}) {
+    [symAI](thisStreamConfig = {}) {
         const externalPromises = [];
         let firstPromise;
         const withReactionOnSubscribe = this.config.withReactionOnSubscribe || thisStreamConfig.withReactionOnSubscribe;
@@ -110,6 +111,9 @@ export class Dependency {
             }
         };
     }
+    get disposePromise() {
+        return this.abortPromise.promise;
+    }
     dispose() {
         this.abortPromise.resolve();
         this.reactionPromise = undefined;

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/reaction.js

@@ -1,35 +1,44 @@
 import { runFnWithDepCollection } from "../global.js";
-/**
- * @deprecated
- */
-export function reaction(fn) {
-    return {
-        [Symbol.asyncIterator]: () => {
-            let { result, deps } = runFnWithDepCollection(fn);
-            let depsArray;
-            let beforeValues;
-            let obj = {
-                next: async () => {
-                    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)
+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 };
-                        return obj.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;
+                };
+                return obj;
+            } };
+        for await (let value of stream) {
+            dep.value = value;
         }
-    };
+    }
+    subscribe().then(() => dep.dispose());
+    return dep;
 }

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,4 +1,5 @@
 import { IAllStreamConfig, IStreamIterator, IThisStreamConfig } from "./contracts.ts";
+import { symAI } from "../constants.ts";
 export declare class Dependency<T = any> {
     private _value;
     private reactionPromise;
@@ -9,7 +10,7 @@ export declare class Dependency<T = any> {
     set value(v: T);
     get value(): T;
     get done(): boolean;
-    [Symbol.asyncIterator](this: Dependency<T>, thisStreamConfig?: IThisStreamConfig): IStreamIterator<T>;
+    [symAI](this: Dependency<T>, thisStreamConfig?: IThisStreamConfig): IStreamIterator<T>;
     /**
      * One race of value change and dependency dispose
      * for all subscribers
@@ -26,5 +27,6 @@ export declare class Dependency<T = any> {
         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/reaction.d.ts

@@ -1,14 +1,3 @@
-/**
- * @deprecated
- */
-export declare function reaction<T>(fn: () => T): {
-    [Symbol.asyncIterator]: () => {
-        next: () => Promise<{
-            done: true;
-            value?: never;
-        } | {
-            done: false;
-            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.25",
+  "version": "1.0.26",
   "description": "Miscellaneous async utils",
   "homepage": "https://github.com/GlennMiller1991/async",
   "type": "module",