@autonomys/asynchronous 1.4.0 → 1.4.1

package/LICENSE

@@ -0,0 +1,18 @@
+MIT License
+
+Copyright (c) 2024 Autonomys Network (autonomys.xyz)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+1. **Attribution**: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+2. **No Warranty**: THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+
+3. **Limitation of Liability**: IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---

package/dist/asyncGenerators/index.d.ts

@@ -0,0 +1,13 @@
+import { Readable } from 'stream';
+export type AwaitIterable<T> = AsyncIterable<T> | Iterable<T>;
+export declare const asyncIterableMap: <T, R>(iterable: AwaitIterable<T>, fn: (value: T) => Promise<R>) => Promise<R[]>;
+export declare const asyncIterableForEach: <T>(iterable: AwaitIterable<T>, fn: (value: T[]) => Promise<void>, concurrency: number) => Promise<void>;
+export declare const asyncIterableToPromiseOfArray: <T>(iterable: AwaitIterable<T>) => Promise<T[]>;
+export declare const bufferToAsyncIterable: (buffer: Buffer) => AsyncIterable<Buffer>;
+export declare const asyncIterableToBuffer: (iterable: AwaitIterable<Buffer>) => Promise<Buffer>;
+export declare const asyncByChunk: (iterable: AwaitIterable<Buffer>, chunkSize: number, ignoreLastChunk?: boolean) => AsyncIterable<Buffer>;
+export declare function forkAsyncIterable(asyncIterable: AwaitIterable<Uint8Array>): Promise<[Readable, Readable]>;
+export declare const asyncFromStream: (stream: ReadableStream<Uint8Array>) => AsyncIterable<Buffer>;
+export declare const bufferToIterable: (buffer: Buffer) => AsyncIterable<Buffer>;
+export declare const fileToIterable: (file: File | Blob, chunkSize?: number) => AsyncIterable<Buffer>;
+//# sourceMappingURL=index.d.ts.map

package/dist/asyncGenerators/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/asyncGenerators/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,QAAQ,EAAE,MAAM,QAAQ,CAAA;AAE9C,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,aAAa,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAA;AAE7D,eAAO,MAAM,gBAAgB,GAAU,CAAC,EAAE,CAAC,EACzC,UAAU,aAAa,CAAC,CAAC,CAAC,EAC1B,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,KAC3B,OAAO,CAAC,CAAC,EAAE,CAMb,CAAA;AAED,eAAO,MAAM,oBAAoB,GAAU,CAAC,EAC1C,UAAU,aAAa,CAAC,CAAC,CAAC,EAC1B,IAAI,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,EACjC,aAAa,MAAM,KAClB,OAAO,CAAC,IAAI,CAad,CAAA;AAED,eAAO,MAAM,6BAA6B,GAAU,CAAC,EACnD,UAAU,aAAa,CAAC,CAAC,CAAC,KACzB,OAAO,CAAC,CAAC,EAAE,CAMb,CAAA;AAED,eAAO,MAAM,qBAAqB,GAAI,QAAQ,MAAM,KAAG,aAAa,CAAC,MAAM,CAI1E,CAAA;AAED,eAAO,MAAM,qBAAqB,GAAU,UAAU,aAAa,CAAC,MAAM,CAAC,KAAG,OAAO,CAAC,MAAM,CAM3F,CAAA;AAED,eAAO,MAAM,YAAY,GACvB,UAAU,aAAa,CAAC,MAAM,CAAC,EAC/B,WAAW,MAAM,EACjB,kBAAiB,OAAe,KAC/B,aAAa,CAAC,MAAM,CAatB,CAAA;AAED,wBAAsB,iBAAiB,CACrC,aAAa,EAAE,aAAa,CAAC,UAAU,CAAC,GACvC,OAAO,CAAC,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAY/B;AAED,eAAO,MAAM,eAAe,GAC1B,QAAQ,cAAc,CAAC,UAAU,CAAC,KACjC,aAAa,CAAC,MAAM,CAOtB,CAAA;AAED,eAAO,MAAM,gBAAgB,GAAoB,QAAQ,MAAM,KAAG,aAAa,CAAC,MAAM,CAErF,CAAA;AAED,eAAO,MAAM,cAAc,GACzB,MAAM,IAAI,GAAG,IAAI,EACjB,YAAW,MAAoB,KAC9B,aAAa,CAAC,MAAM,CAItB,CAAA"}

package/dist/asyncGenerators/index.js

@@ -0,0 +1,217 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fileToIterable = exports.bufferToIterable = exports.asyncFromStream = exports.asyncByChunk = exports.asyncIterableToBuffer = exports.bufferToAsyncIterable = exports.asyncIterableToPromiseOfArray = exports.asyncIterableForEach = exports.asyncIterableMap = void 0;
+exports.forkAsyncIterable = forkAsyncIterable;
+const stream_1 = require("stream");
+const asyncIterableMap = (iterable, fn) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, iterable_1, iterable_1_1;
+    var _b, e_1, _c, _d;
+    const result = [];
+    try {
+        for (_a = true, iterable_1 = __asyncValues(iterable); iterable_1_1 = yield iterable_1.next(), _b = iterable_1_1.done, !_b; _a = true) {
+            _d = iterable_1_1.value;
+            _a = false;
+            const value = _d;
+            result.push(yield fn(value));
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (!_a && !_b && (_c = iterable_1.return)) yield _c.call(iterable_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return result;
+});
+exports.asyncIterableMap = asyncIterableMap;
+const asyncIterableForEach = (iterable, fn, concurrency) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, iterable_2, iterable_2_1;
+    var _b, e_2, _c, _d;
+    let batch = [];
+    try {
+        for (_a = true, iterable_2 = __asyncValues(iterable); iterable_2_1 = yield iterable_2.next(), _b = iterable_2_1.done, !_b; _a = true) {
+            _d = iterable_2_1.value;
+            _a = false;
+            const value = _d;
+            batch.push(value);
+            if (batch.length === concurrency) {
+                yield fn(batch);
+                batch = [];
+            }
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (!_a && !_b && (_c = iterable_2.return)) yield _c.call(iterable_2);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    if (batch.length > 0) {
+        yield fn(batch);
+    }
+});
+exports.asyncIterableForEach = asyncIterableForEach;
+const asyncIterableToPromiseOfArray = (iterable) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, iterable_3, iterable_3_1;
+    var _b, e_3, _c, _d;
+    const result = [];
+    try {
+        for (_a = true, iterable_3 = __asyncValues(iterable); iterable_3_1 = yield iterable_3.next(), _b = iterable_3_1.done, !_b; _a = true) {
+            _d = iterable_3_1.value;
+            _a = false;
+            const value = _d;
+            result.push(value);
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (!_a && !_b && (_c = iterable_3.return)) yield _c.call(iterable_3);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    return result;
+});
+exports.asyncIterableToPromiseOfArray = asyncIterableToPromiseOfArray;
+const bufferToAsyncIterable = (buffer) => {
+    return (function () {
+        return __asyncGenerator(this, arguments, function* () {
+            yield yield __await(buffer);
+        });
+    })();
+};
+exports.bufferToAsyncIterable = bufferToAsyncIterable;
+const asyncIterableToBuffer = (iterable) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, iterable_4, iterable_4_1;
+    var _b, e_4, _c, _d;
+    let buffer = Buffer.alloc(0);
+    try {
+        for (_a = true, iterable_4 = __asyncValues(iterable); iterable_4_1 = yield iterable_4.next(), _b = iterable_4_1.done, !_b; _a = true) {
+            _d = iterable_4_1.value;
+            _a = false;
+            const chunk = _d;
+            buffer = Buffer.concat([buffer, chunk]);
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (!_a && !_b && (_c = iterable_4.return)) yield _c.call(iterable_4);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+    return buffer;
+});
+exports.asyncIterableToBuffer = asyncIterableToBuffer;
+const asyncByChunk = function (iterable_5, chunkSize_1) {
+    return __asyncGenerator(this, arguments, function* (iterable, chunkSize, ignoreLastChunk = false) {
+        var _a, e_5, _b, _c;
+        let accumulated = Buffer.alloc(0);
+        try {
+            for (var _d = true, iterable_6 = __asyncValues(iterable), iterable_6_1; iterable_6_1 = yield __await(iterable_6.next()), _a = iterable_6_1.done, !_a; _d = true) {
+                _c = iterable_6_1.value;
+                _d = false;
+                const chunk = _c;
+                accumulated = Buffer.concat([accumulated, chunk]);
+                while (accumulated.length >= chunkSize) {
+                    yield yield __await(accumulated.subarray(0, chunkSize));
+                    accumulated = accumulated.subarray(chunkSize);
+                }
+            }
+        }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = iterable_6.return)) yield __await(_b.call(iterable_6));
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
+        if (accumulated.length > 0 && !ignoreLastChunk) {
+            yield yield __await(accumulated);
+        }
+    });
+};
+exports.asyncByChunk = asyncByChunk;
+function forkAsyncIterable(asyncIterable) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, asyncIterable_1, asyncIterable_1_1;
+        var _b, e_6, _c, _d;
+        const passThrough1 = new stream_1.PassThrough();
+        const passThrough2 = new stream_1.PassThrough();
+        try {
+            for (_a = true, asyncIterable_1 = __asyncValues(asyncIterable); asyncIterable_1_1 = yield asyncIterable_1.next(), _b = asyncIterable_1_1.done, !_b; _a = true) {
+                _d = asyncIterable_1_1.value;
+                _a = false;
+                const chunk = _d;
+                passThrough1.write(chunk);
+                passThrough2.write(chunk);
+            }
+        }
+        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+        finally {
+            try {
+                if (!_a && !_b && (_c = asyncIterable_1.return)) yield _c.call(asyncIterable_1);
+            }
+            finally { if (e_6) throw e_6.error; }
+        }
+        passThrough1.end();
+        passThrough2.end();
+        return [passThrough1, passThrough2];
+    });
+}
+const asyncFromStream = function (stream) {
+    return __asyncGenerator(this, arguments, function* () {
+        const reader = stream.getReader();
+        let result = yield __await(reader.read());
+        while (!result.done) {
+            yield yield __await(Buffer.from(result.value));
+            result = yield __await(reader.read());
+        }
+    });
+};
+exports.asyncFromStream = asyncFromStream;
+const bufferToIterable = function (buffer) {
+    return __asyncGenerator(this, arguments, function* () {
+        yield yield __await(buffer);
+    });
+};
+exports.bufferToIterable = bufferToIterable;
+const fileToIterable = function (file_1) {
+    return __asyncGenerator(this, arguments, function* (file, chunkSize = 1024 * 1024) {
+        for (let i = 0; i < file.size; i += chunkSize) {
+            yield yield __await(Buffer.from(yield __await(file.slice(i, i + chunkSize).arrayBuffer())));
+        }
+    });
+};
+exports.fileToIterable = fileToIterable;

package/dist/concurrency/index.d.ts

@@ -0,0 +1,2 @@
+export * from './weightedRequestsConcurrencyController.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/concurrency/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/concurrency/index.ts"],"names":[],"mappings":"AAAA,cAAc,4CAA4C,CAAA"}

package/dist/concurrency/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("./weightedRequestsConcurrencyController.js"), exports);

package/dist/concurrency/weightedRequestsConcurrencyController.d.ts

@@ -0,0 +1,5 @@
+export type Job<T> = () => Promise<T>;
+type ConcurrencyController = <T>(job: Job<T>, concurrency: number) => Promise<T>;
+export declare const weightedRequestConcurrencyController: (maxConcurrency: number, ensureOrder?: boolean) => ConcurrencyController;
+export {};
+//# sourceMappingURL=weightedRequestsConcurrencyController.d.ts.map

package/dist/concurrency/weightedRequestsConcurrencyController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"weightedRequestsConcurrencyController.d.ts","sourceRoot":"","sources":["../../src/concurrency/weightedRequestsConcurrencyController.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,GAAG,CAAC,CAAC,IAAI,MAAM,OAAO,CAAC,CAAC,CAAC,CAAA;AAErC,KAAK,qBAAqB,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,CAAA;AAOhF,eAAO,MAAM,oCAAoC,GAC/C,gBAAgB,MAAM,EACtB,cAAa,OAAe,KAC3B,qBAqDF,CAAA"}

package/dist/concurrency/weightedRequestsConcurrencyController.js

@@ -0,0 +1,58 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.weightedRequestConcurrencyController = void 0;
+const weightedRequestConcurrencyController = (maxConcurrency, ensureOrder = false) => {
+    if (maxConcurrency <= 0) {
+        throw new Error('Max concurrency must be greater than 0');
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const queue = [];
+    let active = 0;
+    const enqueue = (task, concurrency) => {
+        return new Promise((resolve, reject) => {
+            queue.push({
+                job: () => task().then(resolve).catch(reject),
+                concurrency,
+            });
+        });
+    };
+    const findExecutableTask = () => {
+        const index = queue.findIndex((e) => active + e.concurrency <= maxConcurrency);
+        const notMatched = index === -1;
+        const notFirst = ensureOrder && index !== 0;
+        if (notMatched || notFirst) {
+            return null;
+        }
+        return queue.splice(index, 1).at(0);
+    };
+    const manageJobFinalization = (concurrency) => __awaiter(void 0, void 0, void 0, function* () {
+        active -= concurrency;
+        const executableTask = findExecutableTask();
+        if (executableTask) {
+            setImmediate(() => internalRunJob(executableTask.job, executableTask.concurrency));
+        }
+    });
+    const internalRunJob = (job, concurrency) => __awaiter(void 0, void 0, void 0, function* () {
+        active += concurrency;
+        return job().finally(() => manageJobFinalization(concurrency));
+    });
+    const runJob = (job, concurrency) => __awaiter(void 0, void 0, void 0, function* () {
+        const exceededMaxConcurrency = active + concurrency > maxConcurrency;
+        const shouldRespectOrder = ensureOrder && queue.length > 0;
+        if (exceededMaxConcurrency || shouldRespectOrder) {
+            return enqueue(job, concurrency);
+        }
+        return internalRunJob(job, concurrency);
+    });
+    return runJob;
+};
+exports.weightedRequestConcurrencyController = weightedRequestConcurrencyController;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './asyncGenerators';
+export * from './concurrency';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAA;AACjC,cAAc,eAAe,CAAA"}

package/dist/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("./asyncGenerators"), exports);
+__exportStar(require("./concurrency"), exports);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@autonomys/asynchronous",
   "packageManager": "yarn@4.7.0",
-  "version": "1.4.0",
+  "version": "1.4.1",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -29,5 +29,5 @@
     "ts-jest": "^29.1.4",
     "typescript": "^5.4.5"
   },
-  "gitHead": "53cf74430ba08ed3b8f38ccc2fcee7b373a7934c"
+  "gitHead": "115cb6ba785c73fa7c536381d5b04d8b3fcd68b9"
 }