@fbltd/async 1.0.10 → 1.0.12

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -36,20 +36,22 @@ class DependencyStream {
     }
     [Symbol.asyncIterator](thisStreamConfig = {}) {
         const totalDispose = this.abortPromise;
-        const selfDispose = (0, get_promise_1.getPromise)();
-        const externalPromises = [totalDispose.promise, selfDispose.promise];
+        const externalPromises = [totalDispose.promise];
         let firstPromise;
-        if (this.config.withReactionOnSubscribe || thisStreamConfig.withReactionOnSubscribe) {
+        const withReactionOnSubscribe = this.config.withReactionOnSubscribe || thisStreamConfig.withReactionOnSubscribe;
+        if (withReactionOnSubscribe) {
             firstPromise = (0, get_promise_1.getPromise)();
             firstPromise.resolve(this.value);
             externalPromises.push(firstPromise.promise);
         }
-        ;
+        if (thisStreamConfig.externalDispose) {
+            externalPromises.push(thisStreamConfig.externalDispose.promise);
+        }
         let isDisposed = false;
         const owner = this;
         return {
             owner,
-            dispose: () => selfDispose.resolve(),
+            dispose: owner.dispose.bind(owner),
             get isDisposed() {
                 return isDisposed;
             },
@@ -62,7 +64,7 @@ class DependencyStream {
                     ...externalPromises,
                     this.reactionPromise.promise,
                 ]);
-                if (totalDispose.isFulfilled || selfDispose.isFulfilled) {
+                if (totalDispose.isFulfilled || thisStreamConfig.externalDispose?.isFulfilled) {
                     isDisposed = true;
                     return { done: true };
                 }

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

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./dependency-stream"), exports);
 __exportStar(require("./utils"), exports);
 __exportStar(require("./integrations"), exports);
+__exportStar(require("./contracts"), exports);

package/dist/bin/dependency-stream/utils/index.js

@@ -1,7 +1,19 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.raceStream = exports.once = void 0;
-var once_1 = require("./once");
-Object.defineProperty(exports, "once", { enumerable: true, get: function () { return once_1.once; } });
-var race_stream_1 = require("./race.stream");
-Object.defineProperty(exports, "raceStream", { enumerable: true, get: function () { return race_stream_1.raceStream; } });
+__exportStar(require("./once.stream"), exports);
+__exportStar(require("./race.stream"), exports);
+__exportStar(require("./next"), exports);

package/dist/bin/dependency-stream/utils/next.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.next = next;
+const constants_1 = require("../../constants");
+async function next(dep) {
+    return (await dep[constants_1.symAI]().next()).value;
+}

package/dist/bin/dependency-stream/utils/once.stream.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onceStream = onceStream;
+const get_promise_1 = require("../../get-promise");
+const constants_1 = require("../../constants");
+function onceStream(dep) {
+    const externalDispose = (0, get_promise_1.getPromise)();
+    const iterator = dep[constants_1.symAI]({ externalDispose });
+    function isDisposed() {
+        return externalDispose.isFulfilled || iterator.isDisposed;
+    }
+    return {
+        get isDisposed() {
+            return isDisposed();
+        },
+        dispose: externalDispose.resolve,
+        [constants_1.symAI]() {
+            return {
+                next: async () => {
+                    const result = await iterator.next();
+                    if (!isDisposed())
+                        externalDispose.resolve();
+                    return result;
+                }
+            };
+        },
+    };
+}

package/dist/bin/dependency-stream/utils/race.stream.js

@@ -4,22 +4,22 @@ exports.raceStream = raceStream;
 const constants_1 = require("../../constants");
 const get_promise_1 = require("../../get-promise");
 function raceStream(...deps) {
-    const streams = deps.map((dep) => dep[constants_1.symAI]());
     let selfDisposePromise = (0, get_promise_1.getPromise)();
     let isDisposed = false;
+    const streams = deps.map((dep) => dep[constants_1.symAI]({
+        externalDispose: selfDisposePromise
+    }));
     return {
-        dispose: selfDisposePromise.resolve,
+        dispose: () => selfDisposePromise.resolve({ done: true, value: void 0 }),
         get isDisposed() {
             return isDisposed;
         },
         [constants_1.symAI]() {
             return {
                 next: async () => {
-                    await Promise.race([selfDisposePromise.promise, streams.map(s => s.next())]);
-                    if (selfDisposePromise.isFulfilled || streams.some(s => s.isDisposed)) {
-                        isDisposed = true;
-                        return { done: true };
-                    }
+                    const res = await Promise.race([selfDisposePromise.promise, ...streams.map(s => s.next())]);
+                    if (res.done)
+                        return res;
                     return { done: false, value: streams.map(s => s.owner.value) };
                 }
             };

package/dist/types/dependency-stream/contracts.d.ts

@@ -0,0 +1,18 @@
+export interface IIteratorOwner<TValue = any> {
+    value: TValue;
+    dispose(): void;
+}
+export type IStreamReturn = void;
+export type IStreamIteratorReturn = IteratorReturnResult<IStreamReturn>;
+export type IStreamIteratorYield<T> = IteratorYieldResult<T>;
+export interface IStreamIterator<TValue = any> {
+    owner: IIteratorOwner<TValue>;
+    dispose(): void;
+    readonly isDisposed: boolean;
+    next(): Promise<IteratorResult<TValue, IStreamReturn>>;
+}
+export interface IStreamOwner<TValue = any> {
+    dispose(): void;
+    readonly isDisposed: boolean;
+    [Symbol.asyncIterator](): AsyncIterator<TValue, IStreamReturn>;
+}

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

@@ -1,3 +1,5 @@
+import { IPromiseConfiguration } from "../get-promise";
+import { IIteratorOwner, IStreamIterator } from "./contracts";
 interface IIsEquals<T> {
     (prev: T, cur: T): boolean;
 }
@@ -7,8 +9,9 @@ type IAllStreamConfig<T> = {
 };
 type IThisStreamConfig = Partial<{
     withReactionOnSubscribe: boolean;
+    externalDispose: IPromiseConfiguration<any>;
 }>;
-export declare class DependencyStream<T = any> {
+export declare class DependencyStream<T = any> implements IIteratorOwner<T> {
     private _value;
     private reactionPromise;
     private abortPromise;
@@ -17,18 +20,7 @@ export declare class DependencyStream<T = any> {
     private _set;
     set value(v: T);
     get value(): T;
-    [Symbol.asyncIterator](this: DependencyStream<T>, thisStreamConfig?: IThisStreamConfig): {
-        owner: DependencyStream<T>;
-        dispose: () => void;
-        readonly isDisposed: boolean;
-        next: () => Promise<{
-            done: boolean;
-            readonly value?: undefined;
-        } | {
-            done: boolean;
-            readonly value: T;
-        }>;
-    };
+    [Symbol.asyncIterator](this: DependencyStream<T>, thisStreamConfig?: IThisStreamConfig): IStreamIterator<T>;
     dispose(this: DependencyStream<T>): void;
 }
 export {};

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

@@ -1,3 +1,4 @@
 export * from './dependency-stream';
 export * from './utils';
 export * from './integrations';
+export * from './contracts';

package/dist/types/dependency-stream/utils/index.d.ts

@@ -1,2 +1,3 @@
-export { once } from "./once";
-export { raceStream } from "./race.stream";
+export * from "./once.stream";
+export * from "./race.stream";
+export * from "./next";

package/dist/types/dependency-stream/utils/next.d.ts

@@ -0,0 +1,2 @@
+import { DependencyStream } from "../dependency-stream";
+export declare function next<T>(dep: DependencyStream<T>): Promise<void | T>;

package/dist/types/dependency-stream/utils/once.stream.d.ts

@@ -0,0 +1,3 @@
+import { DependencyStream } from "../dependency-stream";
+import { IStreamOwner } from "../contracts";
+export declare function onceStream<T>(dep: DependencyStream<T>): IStreamOwner<T>;

package/dist/types/dependency-stream/utils/race.stream.d.ts

@@ -1,13 +1,10 @@
 import { DependencyStream } from "../dependency-stream";
 import { symAI } from "../../constants";
-export declare function raceStream(...deps: DependencyStream[]): {
-    dispose: (value: void) => void;
+export declare function raceStream<TArray extends DependencyStream[]>(...deps: NoInfer<TArray>): {
+    dispose: () => void;
     readonly isDisposed: boolean;
     [Symbol.asyncIterator](): {
-        next: () => Promise<{
-            done: boolean;
-            readonly value?: undefined;
-        } | {
+        next: () => Promise<IteratorReturnResult<void> | {
             done: boolean;
             value: any[];
         }>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fbltd/async",
-  "version": "1.0.10",
+  "version": "1.0.12",
   "description": "Miscellaneous async utils",
   "homepage": "https://github.com/GlennMiller1991/async",
   "keywords": [

package/dist/bin/dependency-stream/utils/once.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.once = once;
-function once(dep) {
-    let isIterationWas = false;
-    const iterator = dep[Symbol.asyncIterator]();
-    return {
-        [Symbol.asyncIterator]() {
-            return {
-                next: async () => {
-                    if (isIterationWas)
-                        return { done: true };
-                    return iterator.next();
-                }
-            };
-        },
-        dispose: iterator.dispose,
-    };
-}

package/dist/types/dependency-stream/utils/once.d.ts

@@ -1,12 +0,0 @@
-import { DependencyStream } from "../dependency-stream";
-export declare function once(dep: DependencyStream): {
-    [Symbol.asyncIterator](): {
-        next: () => Promise<{
-            done: boolean;
-            readonly value: any;
-        } | {
-            done: boolean;
-        }>;
-    };
-    dispose: () => void;
-};