@fbltd/async 1.0.39 → 1.0.40

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

@@ -1,5 +1,6 @@
 import { Dependency } from "./dependency.js";
 import { reaction } from "./vanilla/index.js";
+import { getStream } from "./vanilla/get.stream.js";
 export class DepFactory {
     static ofValue(value, config) {
         return new Dependency(value, config);
@@ -7,4 +8,7 @@ export class DepFactory {
     static ofReaction(fn, config) {
         return reaction(fn, config);
     }
+    static ofDependency(dep) {
+        return getStream(dep);
+    }
 }

package/dist/bin/dependency/dependency.js

@@ -45,29 +45,28 @@ export class Dependency {
         let firstPromise;
         const withReactionOnSubscribe = this.config.withReactionOnSubscribe || thisStreamConfig.withReactionOnSubscribe;
         if (withReactionOnSubscribe) {
-            firstPromise = new PromiseConfiguration();
-            firstPromise.resolve();
-            externalPromises.push(firstPromise.promise);
+            firstPromise = Promise.resolve();
+            externalPromises.push(firstPromise);
         }
         const owner = this;
         return {
             owner,
-            dispose: () => { },
+            dispose: owner.dispose.bind(owner),
             get isDisposed() {
-                return false;
+                return owner.done;
             },
             next: async () => {
                 await Promise.race([
                     owner.next(),
                     ...externalPromises,
                 ]);
-                if (this.done) {
-                    return { done: true };
-                }
                 if (firstPromise) {
                     firstPromise = undefined;
                     externalPromises.pop();
                 }
+                if (this.done) {
+                    return { done: true };
+                }
                 return {
                     done: false,
                     get value() {
@@ -112,6 +111,9 @@ export class Dependency {
             }
         };
     }
+    get disposePromise() {
+        return this.abortPromise?.promise ?? Promise.resolve();
+    }
     dispose() {
         this.abortPromise?.resolve();
         this.abortPromise = this.reactionPromise = undefined;

package/dist/bin/dependency/dependency.stream.js

@@ -2,37 +2,50 @@ import { PromiseConfiguration } from "../promise-configuration.js";
 import { symAI } from "../constants.js";
 export class DependencyStream {
     owner;
-    selfDispose = new PromiseConfiguration();
+    abortPromise = new PromiseConfiguration();
     iterator;
     get isDisposed() {
         return this.iterator.isDisposed;
     }
+    get done() {
+        return this.owner.done || !this.abortPromise?.isPending;
+    }
     constructor(owner) {
         this.owner = owner;
-        this.selfDispose = new PromiseConfiguration();
+        this.abortPromise = new PromiseConfiguration();
         this.iterator = owner[symAI]();
     }
     [symAI]() {
         const done = { done: true };
         return {
             next: async () => {
-                if (this.selfDispose.isFulfilled)
+                if (this.done) {
+                    this.abort();
                     return done;
+                }
                 const nextRes = this.iterator.next();
                 await Promise.race([
-                    this.selfDispose.promise,
+                    this.abortPromise.promise,
                     nextRes,
                 ]);
-                if (this.selfDispose.isFulfilled)
+                if (this.done) {
+                    this.abort();
                     return done;
-                this.selfDispose = new PromiseConfiguration();
+                }
+                this.abortPromise = new PromiseConfiguration();
                 return nextRes;
             }
         };
     }
+    abort() {
+        if (this.abortPromise?.isPending) {
+            this.abortPromise.resolve();
+            this.abortPromise = undefined;
+        }
+    }
     dispose() {
-        if (this.isDisposed)
+        if (this.done)
             return;
-        this.selfDispose.resolve();
+        this.abort();
     }
 }

package/dist/bin/dependency/vanilla/reaction/reaction.js

@@ -13,8 +13,8 @@ export function reaction(fn, config) {
                         depsArray = Array.from(deps);
                         beforeValues = depsArray.map(dep => dep.value_unsafe);
                         const promises = depsArray.map(dep => dep.next());
-                        // promises.push(dep.disposePromise as Promise<any>);
-                        await Promise.race(depsArray.map(dep => dep.next()));
+                        promises.push(dep.disposePromise);
+                        await Promise.race(promises);
                         if (dep.done)
                             return { done: true };
                         let shouldRun = depsArray.some((dep, i) => dep.value_unsafe !== beforeValues[i]);

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

@@ -3,4 +3,5 @@ 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>;
+    static ofDependency<T>(dep: Dependency<T>): import("./dependency.stream.ts").DependencyStream<T>;
 }

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

@@ -28,5 +28,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/dependency.stream.d.ts

@@ -3,12 +3,14 @@ import { symAI } from "../constants.ts";
 import { Dependency } from "./dependency.ts";
 export declare class DependencyStream<T = any> implements IDependencyStream {
     readonly owner: Dependency;
-    private selfDispose;
+    private abortPromise;
     private readonly iterator;
     get isDisposed(): boolean;
+    get done(): boolean;
     constructor(owner: Dependency);
     [symAI](): {
         next: () => Promise<IteratorResult<T, void>>;
     };
+    protected abort(): void;
     dispose(): void;
 }

package/package.json

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