@fbltd/async 1.0.16 → 1.0.18

package/README.md

@@ -1,5 +1,5 @@
 # Async tools
-R&D async tools tree-shakable ES module
+Tree-shakable ES module with async tools.
 
 ## Installation
 You can install this package with your favorite package manager.<br/>

package/dist/bin/delay.js

@@ -1,4 +1,4 @@
-import { PromiseConfiguration } from "./get-promise.js";
+import { PromiseConfiguration } from "./promise-configuration.js";
 export function delay(ms = 0, syncKey) {
     ms = Math.max(ms, 0);
     return delay.methods[typeof syncKey](ms);

package/dist/bin/dependency-stream/{dependency-stream.js → dependency.js}

@@ -1,8 +1,7 @@
-import { PromiseConfiguration } from "../get-promise.js";
-function baseComparer(prev, cur) {
-    return prev === cur;
-}
-export class DependencyStream {
+import { PromiseConfiguration } from "../promise-configuration.js";
+import { DependencyStream } from "./dependency.stream.js";
+import { baseComparer } from "./utils.js";
+export class Dependency {
     _value;
     reactionPromise;
     abortPromise = new PromiseConfiguration();
@@ -31,6 +30,9 @@ export class DependencyStream {
     get value() {
         return this._value;
     }
+    getStream() {
+        return new DependencyStream(this);
+    }
     [Symbol.asyncIterator](thisStreamConfig = {}) {
         const totalDispose = this.abortPromise;
         const externalPromises = [totalDispose.promise];

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

@@ -0,0 +1,27 @@
+import { PromiseConfiguration } from "../promise-configuration.js";
+import { symAI } from "../constants.js";
+export class DependencyStream {
+    owner;
+    selfDispose = new PromiseConfiguration();
+    iterator;
+    get isDisposed() {
+        return this.iterator.isDisposed;
+    }
+    constructor(owner) {
+        this.owner = owner;
+        this.selfDispose = new PromiseConfiguration();
+        this.iterator = owner[symAI]({ externalDispose: this.selfDispose });
+    }
+    [symAI]() {
+        return {
+            next: () => {
+                return this.iterator.next();
+            }
+        };
+    }
+    dispose() {
+        if (this.isDisposed)
+            return;
+        this.selfDispose.resolve();
+    }
+}

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

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

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

@@ -1,13 +1,22 @@
 import { symAI } from "../../constants.js";
-const StreamFinishError = new Error("Stream is done");
-export async function next(dep) {
-    const res = await dep[symAI]().next();
-    if (res.done) {
-        throw StreamFinishError;
-    }
-    return res.value;
-}
+import { PromiseConfiguration } from "../../promise-configuration.js";
 /**
  * @internal
  */
-export const InternalStreamFinishError = StreamFinishError;
+export const StreamFinishError = new Error("Stream is done");
+export function next(dep) {
+    const disposePromise = new PromiseConfiguration();
+    const resultPromise = new PromiseConfiguration();
+    dep[symAI]({ externalDispose: disposePromise })
+        .next()
+        .then((res) => {
+        if (res.done)
+            resultPromise.reject(StreamFinishError);
+        else
+            resultPromise.resolve(res.value);
+    });
+    return {
+        promise: resultPromise.promise,
+        dispose: () => disposePromise.resolve()
+    };
+}

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

@@ -1,22 +1,18 @@
-import { PromiseConfiguration } from "../../get-promise.js";
 import { symAI } from "../../constants.js";
 export function onceStream(dep) {
-    const externalDispose = new PromiseConfiguration();
-    const iterator = dep[symAI]({ externalDispose });
-    function isDisposed() {
-        return externalDispose.isFulfilled || iterator.isDisposed;
-    }
+    const stream = dep.getStream();
+    const iterator = stream[symAI]();
     return {
         get isDisposed() {
-            return isDisposed();
+            return stream.isDisposed;
         },
-        dispose: externalDispose.resolve,
+        dispose: () => stream.dispose(),
         [symAI]() {
             return {
                 next: async () => {
                     const result = await iterator.next();
-                    if (!isDisposed())
-                        externalDispose.resolve();
+                    if (!result.done)
+                        stream.dispose();
                     return result;
                 }
             };

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

@@ -1,5 +1,5 @@
 import { symAI } from "../../constants.js";
-import { PromiseConfiguration } from "../../get-promise.js";
+import { PromiseConfiguration } from "../../promise-configuration.js";
 export function raceStream(...deps) {
     let selfDisposePromise = new PromiseConfiguration();
     let isDisposed = false;

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

@@ -0,0 +1,3 @@
+export function baseComparer(prev, cur) {
+    return prev === cur;
+}

package/dist/bin/index.js

@@ -1,4 +1,4 @@
 export * from "./dependency-stream/index.js";
 export * from "./dependency-stream/integrations/react/index.js";
 export * from "./delay.js";
-export * from "./get-promise.js";
+export * from "./promise-configuration.js";

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

@@ -1,18 +1,24 @@
-export interface IIteratorOwner<TValue = any> {
-    value: TValue;
-    dispose(): void;
-}
-export type IStreamReturn = void;
-export type IStreamIteratorReturn = IteratorReturnResult<IStreamReturn>;
-export type IStreamIteratorYield<T> = IteratorYieldResult<T>;
+import { PromiseConfiguration } from "../promise-configuration.js";
+import { Dependency } from "./dependency.ts";
 export interface IStreamIterator<TValue = any> {
-    owner: IIteratorOwner<TValue>;
+    owner: Dependency;
     dispose(): void;
     readonly isDisposed: boolean;
-    next(): Promise<IteratorResult<TValue, IStreamReturn>>;
+    next(): Promise<IteratorResult<TValue, void>>;
 }
-export interface IStreamOwner<TValue = any> {
+export interface IDependencyStream<TValue = any> {
     dispose(): void;
     readonly isDisposed: boolean;
-    [Symbol.asyncIterator](): AsyncIterator<TValue, IStreamReturn>;
+    [Symbol.asyncIterator](): AsyncIterator<TValue, void>;
+}
+export interface IIsEquals<T> {
+    (prev: T, cur: T): boolean;
 }
+export type IAllStreamConfig<T> = {
+    withCustomEquality: IIsEquals<T>;
+    withReactionOnSubscribe: boolean;
+};
+export type IThisStreamConfig = Partial<{
+    withReactionOnSubscribe: boolean;
+    externalDispose: PromiseConfiguration<any>;
+}>;

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

@@ -0,0 +1,26 @@
+import { IAllStreamConfig, IThisStreamConfig } from "./contracts.ts";
+import { DependencyStream } from "./dependency.stream.ts";
+export declare class Dependency<T = any> {
+    private _value;
+    private reactionPromise;
+    private abortPromise;
+    private config;
+    constructor(_value: T, config?: Partial<IAllStreamConfig<T>>);
+    private _set;
+    set value(v: T);
+    get value(): T;
+    getStream(this: Dependency<T>): DependencyStream<T>;
+    [Symbol.asyncIterator](this: Dependency<T>, thisStreamConfig?: IThisStreamConfig): {
+        owner: Dependency<T>;
+        dispose: () => void;
+        readonly isDisposed: boolean;
+        next: () => Promise<{
+            done: true;
+            value: void;
+        } | {
+            done: boolean;
+            readonly value: T;
+        }>;
+    };
+    dispose(this: Dependency<T>): void;
+}

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

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

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

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

package/dist/types/dependency-stream/integrations/react/src/use-stream.d.ts

@@ -1,5 +1,5 @@
-import { DependencyStream } from "../../../index";
-export declare function useStream(...streams: DependencyStream[]): {
+import { Dependency } from "../../../index";
+export declare function useStream(...streams: Dependency[]): {
     value: Array<any> | undefined;
     dispose: () => void;
 };

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

@@ -1,6 +1,5 @@
-import { DependencyStream } from "../dependency-stream.ts";
-export declare function next<T>(dep: DependencyStream<T>): Promise<T>;
-/**
- * @internal
- */
-export declare const InternalStreamFinishError: Error;
+import { Dependency } from "../dependency.ts";
+export declare function next<T>(dep: Dependency<T>): {
+    promise: Promise<T>;
+    dispose: () => void;
+};

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

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

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

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

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

@@ -0,0 +1 @@
+export declare function baseComparer<T>(prev: T, cur: T): boolean;

package/dist/types/index.d.ts

@@ -1,4 +1,4 @@
 export * from './dependency-stream/index.ts';
 export * from './dependency-stream/integrations/react/index.ts';
 export * from './delay.ts';
-export * from './get-promise.ts';
+export * from './promise-configuration.ts';

package/package.json

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

package/tsconfig.json

@@ -4,6 +4,7 @@
   "compilerOptions": {
     "module": "NodeNext",
     "moduleResolution": "NodeNext",
+    "stripInternal": true,
   },
 }
 // @formatter:on

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

@@ -1,26 +0,0 @@
-import { IIteratorOwner, IStreamIterator } from "./contracts.ts";
-import { PromiseConfiguration } from "../get-promise.ts";
-interface IIsEquals<T> {
-    (prev: T, cur: T): boolean;
-}
-type IAllStreamConfig<T> = {
-    withCustomEquality: IIsEquals<T>;
-    withReactionOnSubscribe: boolean;
-};
-type IThisStreamConfig = Partial<{
-    withReactionOnSubscribe: boolean;
-    externalDispose: PromiseConfiguration<any>;
-}>;
-export declare class DependencyStream<T = any> implements IIteratorOwner<T> {
-    private _value;
-    private reactionPromise;
-    private abortPromise;
-    private config;
-    constructor(_value: T, config?: Partial<IAllStreamConfig<T>>);
-    private _set;
-    set value(v: T);
-    get value(): T;
-    [Symbol.asyncIterator](this: DependencyStream<T>, thisStreamConfig?: IThisStreamConfig): IStreamIterator<T>;
-    dispose(this: DependencyStream<T>): void;
-}
-export {};