@fbltd/async 1.0.38 → 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

@@ -1,7 +1,7 @@
 import { PromiseConfiguration } from "../promise-configuration.js";
 import { baseComparer } from "./utils.js";
-import { observationState } from "./observe.state.js";
 import { symAI } from "../constants.js";
+import { observationState } from "./observe.state.js";
 export class Dependency {
     _value;
     reactionPromise;
@@ -38,38 +38,35 @@ export class Dependency {
         return this._value;
     }
     get done() {
-        return this.abortPromise.isFulfilled;
+        return !this.abortPromise || this.abortPromise.isFulfilled;
     }
     [symAI](thisStreamConfig = {}) {
         const externalPromises = [];
         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;
-        let done = false;
         return {
             owner,
             dispose: owner.dispose.bind(owner),
             get isDisposed() {
-                return done || owner.done;
+                return owner.done;
             },
             next: async () => {
                 await Promise.race([
-                    ...externalPromises,
                     owner.next(),
+                    ...externalPromises,
                 ]);
-                if (this.done) {
-                    done = true;
-                    return { done: true };
-                }
                 if (firstPromise) {
                     firstPromise = undefined;
                     externalPromises.pop();
                 }
+                if (this.done) {
+                    return { done: true };
+                }
                 return {
                     done: false,
                     get value() {
@@ -98,23 +95,27 @@ export class Dependency {
      * Another subscribe for current race
      */
     async next() {
+        const done = { done: true };
+        const owner = this;
+        if (this.done)
+            return done;
         await this.getOrCreateRace();
         this._race = undefined;
-        if (this.done) {
-            return { done: true };
-        }
+        if (this.done)
+            return done;
+        this.abortPromise = new PromiseConfiguration();
         return {
             done: false,
             get value() {
-                return this.value;
+                return owner.value;
             }
         };
     }
     get disposePromise() {
-        return this.abortPromise.promise;
+        return this.abortPromise?.promise ?? Promise.resolve();
     }
     dispose() {
-        this.abortPromise.resolve();
-        this.reactionPromise = undefined;
+        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

@@ -14,7 +14,7 @@ export function reaction(fn, config) {
                         beforeValues = depsArray.map(dep => dep.value_unsafe);
                         const promises = depsArray.map(dep => dep.next());
                         promises.push(dep.disposePromise);
-                        await Promise.race(depsArray.map(dep => dep.next()));
+                        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

@@ -23,7 +23,7 @@ export declare class Dependency<T = any> {
      */
     next(): Promise<{
         done: true;
-        value?: never;
+        value: void;
     } | {
         done: boolean;
         readonly value: T;

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.38",
+  "version": "1.0.40",
   "description": "Miscellaneous async utils",
   "homepage": "https://github.com/GlennMiller1991/async",
   "type": "module",