@fbltd/async 1.0.17 → 1.0.19

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/>
@@ -67,20 +67,25 @@ setInterval(() => {
 }, 1000)
 ```
 
+#### Stream utils
+##### onceStream
+##### raceStream
+##### next
+
 #### Framework integrations
 ##### React
-Of course, there is a React integration via useStream hook:
+Of course, there is a React integration via stream hooks.
+For example, here is classic react counter implementation via useRaceStream hook.
 
 ```typescript jsx
 type IController = {
-    controller: SomeController,
+    dependecy: Dependency,
 }
 export const Counter: React.FC<ITest> = React.memo(({
-                                                        controller,
+                                                        dependency,
                                                     }) => {
     // num is an instance of DependencyStream
-    const num = controller.num;
-    const {value, dispose} = useStream(num);
+    const {value, dispose} = useRaceStream({dependency});
 
     // resolving promises on component unmounting
     // This is won't cause of rerender
@@ -91,7 +96,7 @@ export const Counter: React.FC<ITest> = React.memo(({
             <button className={"incrementer"}
                 // Now result is array of streams values
                 // It should be object
-                    onClick={() => num.set(value![0] + 1)}>
+                    onClick={() => dependency.value++}>
                 +
             </button>
 
@@ -100,7 +105,7 @@ export const Counter: React.FC<ITest> = React.memo(({
                     // Now result is array of streams values
                     // It should be object                    
                 }
-                {value![0]}
+                {value.dependency}
             </div>
         </div>
     )

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

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

package/dist/bin/dependency-stream/integrations/react/src/index.js

@@ -14,4 +14,9 @@ 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 });
-__exportStar(require("./use-stream.js"), exports);
+exports.isObjectsContentEqual = exports.RaceStreamController = void 0;
+__exportStar(require("./use-race.stream.js"), exports);
+var race_stream_controller_1 = require("./race-stream.controller");
+Object.defineProperty(exports, "RaceStreamController", { enumerable: true, get: function () { return race_stream_controller_1.RaceStreamController; } });
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "isObjectsContentEqual", { enumerable: true, get: function () { return utils_1.isObjectsContentEqual; } });

package/dist/bin/dependency-stream/integrations/react/src/race-stream.controller.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RaceStreamController = void 0;
+const utils_1 = require("./utils");
+const stream_utils_1 = require("../../../stream-utils");
+class RaceStreamController {
+    _value;
+    isFirstWas = false;
+    rerenderTrigger;
+    deps;
+    iterator;
+    constructor(streams) {
+        this.deps = streams;
+        this.init();
+    }
+    get value() {
+        return this._value;
+    }
+    async init() {
+        this.iterator = (0, stream_utils_1.raceStream)(this.deps);
+        this._value = Object.entries(this.deps)
+            .reduce((acc, [key, dep]) => {
+            acc[key] = dep.value;
+            return acc;
+        }, {});
+        for await (let value of this.iterator) {
+            this.rerenderTrigger?.(prev => !prev);
+            if (!this.isFirstWas && !(0, utils_1.isObjectsContentEqual)(this._value, value)) {
+                this._value = value;
+            }
+            this.isFirstWas = true;
+        }
+    }
+    dispose = () => {
+        this.iterator.dispose();
+    };
+}
+exports.RaceStreamController = RaceStreamController;

package/dist/bin/dependency-stream/integrations/react/src/use-race.stream.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useRaceStream = useRaceStream;
+const react_1 = require("react");
+const race_stream_controller_1 = require("./race-stream.controller");
+function useRaceStream(deps) {
+    const [obj] = (0, react_1.useState)(() => ({ controller: new race_stream_controller_1.RaceStreamController(deps) }));
+    const [, setValue] = (0, react_1.useState)(false);
+    obj.controller.rerenderTrigger = setValue;
+    (0, react_1.useEffect)(() => {
+        return () => {
+            obj.controller.dispose();
+            obj.controller = undefined;
+        };
+    }, []);
+    return {
+        value: obj.controller.value,
+        dispose: obj.controller.dispose,
+    };
+}

package/dist/bin/dependency-stream/integrations/react/src/utils.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isObjectsContentEqual = isObjectsContentEqual;
+function isObjectsContentEqual(obj1, obj2) {
+    for (let key in obj1) {
+        if (obj1[key] !== obj2[key])
+            return false;
+    }
+    return true;
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -1,3 +1,4 @@
 export * from "./once.stream.js";
 export * from "./race.stream.js";
 export * from "./next.js";
+export * from "./contracts.js";

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

@@ -0,0 +1,22 @@
+import { symAI } from "../../constants.js";
+import { PromiseConfiguration } from "../../promise-configuration.js";
+/**
+ * @internal
+ */
+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/stream-utils/race.stream.js

@@ -0,0 +1,36 @@
+import { symAI } from "../../constants.js";
+import { PromiseConfiguration } from "../../promise-configuration.js";
+export function raceStream(deps) {
+    let externalDispose = new PromiseConfiguration();
+    const [keys, streams] = Object
+        .entries(deps)
+        .reduce((acc, [key, dep]) => {
+        acc[0].push(key);
+        acc[1].push(dep[symAI]({ externalDispose }));
+        return acc;
+    }, [[], []]);
+    function isDisposed() {
+        return streams.some((s) => s.isDisposed);
+    }
+    return {
+        dispose: () => !isDisposed() && externalDispose.resolve({ done: true, value: void 0 }),
+        get isDisposed() {
+            return isDisposed();
+        },
+        [symAI]() {
+            return {
+                next: async () => {
+                    const res = await Promise.race(streams.map(s => s.next()));
+                    if (res.done) {
+                        return res;
+                    }
+                    const value = keys.reduce((acc, key) => {
+                        acc[key] = deps[key].value;
+                        return acc;
+                    }, {});
+                    return { done: false, value };
+                }
+            };
+        }
+    };
+}

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

@@ -1,4 +1,4 @@
-import { IAllStreamConfig, IThisStreamConfig } from "./contracts.ts";
+import { IAllStreamConfig, IStreamIterator, IThisStreamConfig } from "./contracts.ts";
 import { DependencyStream } from "./dependency.stream.ts";
 export declare class Dependency<T = any> {
     private _value;
@@ -10,17 +10,6 @@ export declare class Dependency<T = any> {
     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;
-        }>;
-    };
+    [Symbol.asyncIterator](this: Dependency<T>, thisStreamConfig?: IThisStreamConfig): IStreamIterator<T>;
     dispose(this: Dependency<T>): void;
 }

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

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

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

@@ -1 +1,3 @@
-export * from './use-stream.ts';
+export * from './use-race.stream.ts';
+export { RaceStreamController } from "./race-stream.controller";
+export { isObjectsContentEqual } from "./utils";

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

@@ -0,0 +1,13 @@
+import { Dispatch, SetStateAction } from "react";
+import { IDepObjectArgument, IDepObjectReturn, raceStream } from "../../../stream-utils";
+export declare class RaceStreamController<T extends IDepObjectArgument> {
+    private _value;
+    private isFirstWas;
+    rerenderTrigger?: Dispatch<SetStateAction<boolean>>;
+    deps: T;
+    iterator: ReturnType<typeof raceStream<T>>;
+    constructor(streams: T);
+    get value(): IDepObjectReturn<T>;
+    init(): Promise<void>;
+    dispose: () => void;
+}

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

@@ -0,0 +1,5 @@
+import { IDepObjectArgument, IDepObjectReturn } from "../../../index";
+export declare function useRaceStream<T extends IDepObjectArgument>(deps: T): {
+    value: IDepObjectReturn<T>;
+    dispose: Function;
+};

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

@@ -0,0 +1 @@
+export declare function isObjectsContentEqual<T extends {}>(obj1: T, obj2: T): boolean;

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

@@ -0,0 +1,7 @@
+import { Dependency } from "../dependency.js";
+export type IDepObjectArgument = {
+    [key: string]: Dependency;
+};
+export type IDepObjectReturn<T extends IDepObjectArgument> = {
+    [Key in keyof T]: T[Key]['value'];
+};

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

@@ -1,3 +1,4 @@
 export * from "./once.stream.ts";
 export * from "./race.stream.ts";
 export * from "./next.ts";
+export * from "./contracts.ts";

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

@@ -0,0 +1,5 @@
+import { Dependency } from "../dependency.ts";
+export declare function next<T>(dep: Dependency<T>): {
+    promise: Promise<T>;
+    dispose: () => void;
+};

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

@@ -0,0 +1,3 @@
+import { IDependencyStream } from "../contracts.js";
+import { IDepObjectArgument, IDepObjectReturn } from "./contracts.js";
+export declare function raceStream<T extends IDepObjectArgument>(deps: T): IDependencyStream<IDepObjectReturn<T>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fbltd/async",
-  "version": "1.0.17",
+  "version": "1.0.19",
   "description": "Miscellaneous async utils",
   "homepage": "https://github.com/GlennMiller1991/async",
   "type": "module",
@@ -25,7 +25,7 @@
     "clearModules": "rm node_modules -rf || true",
     "clearAll": "npm run clearDist && npm run clearModules",
     "build": "cd src/dependency-stream/integrations/react && npm run build && cd ../../../../ && npm run clearAll && npm i && mkdir dist && tsc",
-    "test": "jest --config=./__tests__/jest.config.cjs",
+    "test": "node --expose-gc node_modules/.bin/jest --config=./__tests__/jest.config.cjs",
     "postVersionCommit": "git commit -m='post version commit' || true",
     "postVersionPush": "git push || true",
     "patch": "npm version patch && npm run postVersionCommit && npm run postVersionPush",

package/dist/bin/dependency-stream/integrations/react/src/use-stream.js

@@ -1,39 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useStream = useStream;
-const index_1 = require("../../../index");
-const react_1 = require("react");
-class StreamController {
-    setValue;
-    streams;
-    iterator;
-    constructor(...streams) {
-        this.streams = streams;
-        this.init();
-    }
-    async init() {
-        this.iterator = (0, index_1.raceStream)(...this.streams);
-        for await (let chunk of this.iterator) {
-            console.log(chunk);
-            this.setValue?.(chunk);
-        }
-    }
-    dispose = () => {
-        this.iterator?.dispose();
-    };
-}
-function useStream(...streams) {
-    const [value, setValue] = (0, react_1.useState)(streams.map(s => s.value));
-    const [obj] = (0, react_1.useState)(() => ({ controller: new StreamController(...streams) }));
-    obj.controller.setValue = setValue;
-    (0, react_1.useEffect)(() => {
-        return () => {
-            obj.controller.dispose();
-            obj.controller = undefined;
-        };
-    }, []);
-    return {
-        value,
-        dispose: obj.controller.dispose,
-    };
-}

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

@@ -1,13 +0,0 @@
-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;
-}
-/**
- * @internal
- */
-export const InternalStreamFinishError = StreamFinishError;

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

@@ -1,25 +0,0 @@
-import { symAI } from "../../constants.js";
-import { PromiseConfiguration } from "../../promise-configuration.js";
-export function raceStream(...deps) {
-    let selfDisposePromise = new PromiseConfiguration();
-    let isDisposed = false;
-    const streams = deps.map((dep) => dep[symAI]({
-        externalDispose: selfDisposePromise
-    }));
-    return {
-        dispose: () => selfDisposePromise.resolve({ done: true, value: void 0 }),
-        get isDisposed() {
-            return isDisposed;
-        },
-        [symAI]() {
-            return {
-                next: async () => {
-                    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/integrations/react/src/use-stream.d.ts

@@ -1,5 +0,0 @@
-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,2 +0,0 @@
-import { Dependency } from "../dependency.ts";
-export declare function next<T>(dep: Dependency<T>): Promise<T>;

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

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