@fbltd/async 1.0.1

package/README.md

@@ -0,0 +1,73 @@
+### R&D async tools ###
+
+First of all, attention paid to creation of reactive model
+leveraging native JavaScript async features like Promises, (async) iterators
+and generators.
+
+The version is 0.0.0 so keep it in mind
+
+```typescript
+const counter = new DependencyStream<number>(0);
+
+async function onCounterChange() {
+    for await (let value of counter.stream()) {
+        // do whatever you want
+    }
+
+    // here we going in case of disposing counter (counter.dispose)
+    // or stream itself (counter.stream().dispose)
+}
+
+onCounterChange();
+
+let i = 0;
+setInterval(() => {
+    for (let k = 0; k < 10; k++) {
+        // The counter detects changes when the first new value 
+        // differs from the previous one. 
+        // Subsequent value updates are collected and processed together
+        // during the next microtask execution phase of the event loop.
+        counter.set(i++);
+    }
+}, 1000)
+```
+
+Of course, there is a React integration via useStream hook:
+
+```typescript jsx
+type IController = {
+    controller: SomeController,
+}
+export const Counter: React.FC<ITest> = React.memo(({
+                                                        controller,
+                                                    }) => {
+    // num is an instance of DependencyStream
+    const num = controller.num;
+    const {value, dispose} = useStream(num);
+
+    // resolving promises on component unmounting
+    // This is won't cause of rerender
+    useEffect(() => dispose, [])
+
+    return (
+        <div className={"container"}>
+            <button className={"incrementer"}
+                // Now result is array of streams values
+                // It should be object
+                    onClick={() => num.set(value![0] + 1)}>
+                +
+            </button>
+
+            <div className={cn("display")}>
+                {
+                    // Now result is array of streams values
+                    // It should be object                    
+                }
+                {value![0]}
+            </div>
+        </div>
+    )
+})
+```
+
+Now this package is CommonJS module but should be ESM.

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

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DependencyStream = void 0;
+const utils_1 = require("../utils");
+class DependencyStream {
+    _value;
+    promise;
+    abortPromise = (0, utils_1.getPromise)();
+    constructor(_value) {
+        this._value = _value;
+    }
+    _set(v) {
+        if (v === this._value)
+            return;
+        this._value = v;
+        this.promise && this.promise.resolve(v);
+    }
+    set = (v) => {
+        this._set(v);
+    };
+    get() {
+        return this._value;
+    }
+    [Symbol.asyncIterator]() {
+        const totalDispose = this.abortPromise;
+        const selfDispose = (0, utils_1.getPromise)();
+        return {
+            owner: this,
+            dispose: () => selfDispose.resolve(undefined),
+            next: async () => {
+                if (!this.promise) {
+                    this.promise = (0, utils_1.getPromise)();
+                    this._set(this._value);
+                }
+                await Promise.race([
+                    totalDispose.promise,
+                    selfDispose.promise,
+                    this.promise.promise,
+                ]);
+                this.promise = undefined;
+                if (totalDispose.isFulfilled || selfDispose.isFulfilled) {
+                    return { done: true };
+                }
+                const value = this.get();
+                return {
+                    done: false,
+                    get value() {
+                        return value;
+                    }
+                };
+            }
+        };
+    }
+    dispose() {
+        this.abortPromise.resolve(undefined);
+        this.abortPromise = (0, utils_1.getPromise)();
+    }
+}
+exports.DependencyStream = DependencyStream;

package/dist/bin/core/index.js

@@ -0,0 +1,18 @@
+"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 });
+__exportStar(require("./dependency-stream"), exports);
+__exportStar(require("./utils"), exports);

package/dist/bin/core/utils.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stream = stream;
+exports.once = once;
+exports.anyStream = anyStream;
+function stream(dep) {
+    return dep[Symbol.asyncIterator]();
+}
+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,
+    };
+}
+function anyStream(...deps) {
+    const streams = deps.map((dep) => stream(dep));
+    let disposed = false;
+    return {
+        dispose: () => {
+            streams.map(s => s.dispose());
+            disposed = true;
+        },
+        [Symbol.asyncIterator]() {
+            return {
+                next: async () => {
+                    await Promise.race(streams.map(s => s.next()));
+                    if (disposed) {
+                        return { done: true };
+                    }
+                    return { done: false, value: streams.map(s => s.owner.get()) };
+                }
+            };
+        }
+    };
+}

package/dist/bin/index.js

@@ -0,0 +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 });
+__exportStar(require("./core"), exports);
+__exportStar(require("./react"), exports);
+__exportStar(require("./utils"), exports);

package/dist/bin/react/index.js

@@ -0,0 +1,17 @@
+"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 });
+__exportStar(require("./src"), exports);

package/dist/bin/react/src/index.js

@@ -0,0 +1,17 @@
+"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 });
+__exportStar(require("./use-stream"), exports);

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useStream = useStream;
+const core_1 = require("../../core");
+const react_1 = require("react");
+class StreamController {
+    setValue;
+    streams;
+    iterator;
+    constructor(...streams) {
+        this.streams = streams;
+        this.init();
+    }
+    async init() {
+        this.iterator = (0, core_1.anyStream)(...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.get()));
+    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/utils/get-promise.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPromise = getPromise;
+function getPromise() {
+    let resolve;
+    let reject;
+    let isPending = true;
+    let isFulfilled = false;
+    const promise = new Promise((res, rej) => {
+        resolve = (value) => {
+            res(value);
+            isPending = false;
+            isFulfilled = true;
+        };
+        reject = (error) => {
+            rej(error);
+            isPending = false;
+            isFulfilled = true;
+        };
+    });
+    return {
+        resolve,
+        reject,
+        get isPending() {
+            return isPending;
+        },
+        get isFulfilled() {
+            return isFulfilled;
+        },
+        promise
+    };
+}

package/dist/bin/utils/index.js

@@ -0,0 +1,17 @@
+"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 });
+__exportStar(require("./get-promise"), exports);

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

@@ -0,0 +1,21 @@
+export declare class DependencyStream<T = any> {
+    private _value;
+    private promise;
+    private abortPromise;
+    constructor(_value: T);
+    private _set;
+    set: (v: T) => void;
+    get(): T;
+    [Symbol.asyncIterator](this: DependencyStream<T>): {
+        owner: DependencyStream<T>;
+        dispose: () => void;
+        next: () => Promise<{
+            done: boolean;
+            readonly value?: undefined;
+        } | {
+            done: boolean;
+            readonly value: T;
+        }>;
+    };
+    dispose(this: DependencyStream<T>): void;
+}

package/dist/types/core/index.d.ts

@@ -0,0 +1,2 @@
+export * from './dependency-stream';
+export * from './utils';

package/dist/types/core/utils.d.ts

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

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './core';
+export * from './react';
+export * from './utils';

package/dist/types/react/index.d.ts

@@ -0,0 +1 @@
+export * from './src';

package/dist/types/react/src/index.d.ts

@@ -0,0 +1 @@
+export * from './use-stream';

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

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

package/dist/types/utils/get-promise.d.ts

@@ -0,0 +1,7 @@
+export declare function getPromise<TReturn>(): {
+    resolve: (value: TReturn) => void;
+    reject: (value: Error) => void;
+    readonly isPending: boolean;
+    readonly isFulfilled: boolean;
+    promise: Promise<TReturn>;
+};

package/dist/types/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './get-promise';

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@fbltd/async",
+  "version": "1.0.1",
+  "description": "R&D async tools",
+  "exports": {
+    "require": "./dist/bin/index.js",
+    "import": "./dist/bin/index.js",
+    "types": "./dist/types/index.d.ts"
+  },
+  "files": [
+    "dist",
+    "package.json",
+    "tsconfig.base.json",
+    "tsconfig.json"
+  ],
+  "scripts": {
+    "clearDist": "rm dist -rf || true",
+    "clearModules": "rm node_modules -rf || true",
+    "clearAll": "npm run clearDist && npm run clearModules",
+    "build": "cd src/react && npm run build && cd ../../ && npm run clearAll && npm i && mkdir dist && tsc",
+    "test": "jest --config=./__tests__/jest.config.js",
+    "patch": "npm version patch && git commit -a -m version patch && git push",
+    "deploy": "npm run build && npm run test && npm run patch && npm run publish"
+  },
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "jest": "^30.0.4",
+    "ts-jest": "^29.4.0",
+    "typescript": "^5.x.x"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/tsconfig.base.json

@@ -0,0 +1,36 @@
+// @formatter:off
+{
+  "compilerOptions": {
+
+    // syntax
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "noImplicitThis": true,
+    "noImplicitReturns": true,
+    "noImplicitOverride": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "strictBindCallApply": true,
+    "strictBuiltinIteratorReturn": true,
+    "strictFunctionTypes": true,
+    "strictPropertyInitialization": true,
+    "allowJs": false,
+
+    // emit
+    "target": "ESNext",
+    "noEmitOnError": true,
+    "removeComments": false,
+    "outDir": "dist/bin",
+    "declaration": true,
+    "declarationDir": "dist/types",
+    "declarationMap": false,    // Typically, source files are not emits, so there is no reason to emit source maps
+    "sourceMap": false          // Typically, source files are not emits, so there is no reason to emit source maps
+  },
+
+  "exclude": [
+    "./node_modules/",
+    "./dist/",
+    "./__tests__",
+  ]
+}
+// @formatter:on

package/tsconfig.json

@@ -0,0 +1,9 @@
+// @formatter:off
+{
+  "extends": "./tsconfig.base.json",
+  "compilerOptions": {
+    "module": "CommonJS",
+    "moduleResolution": "node",
+  },
+}
+// @formatter:on