socket-function 1.1.49 → 1.2.1

package/src/dist/Zip.ts.cache

@@ -0,0 +1,156 @@
+"use strict"; var console = (function shimConsole() {             let baseConsole = globalThis.console;             if (typeof window !== "undefined")                 return baseConsole;             let name = __filename.replaceAll("\\", "/").split("/").pop();             let dirName = __dirname.replaceAll("\\", "/").split("/").pop();             let context = {                 __FILE__: __filename,                 __DIR__: __dirname,                 __NAME__: name,                 __DIRNAME__: dirName             };             let newConsole = {                 ...baseConsole             };             for (let shim of ["log", "info", "warn", "error"]) {                 newConsole[shim] = (...args) => {                     args.push(context);                     baseConsole[shim](...args);                 };             }             newConsole.__context = context;             return newConsole;         })(); "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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule && mod.default) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+exports.Zip = void 0;
+const misc_1 = require("./misc");
+const measure_1 = require("./profiling/measure");
+const zlib_1 = __importDefault(require("zlib"));
+const pako = __importStar(require("pako"));
+const compileFlags_1 = require("../require/compileFlags");
+(0, compileFlags_1.setFlag)(require, "pako", "allowclient", true);
+const SYNC_THRESHOLD_BYTES = 100000000;
+const ZIP_SYNC_THRESHOLD_BYTES = 10000000;
+// IMPORTANT! If this is slow, add a LZ4 version, which uses lz4-wasm-nodejs. This should be about 10X faster in both dcompression and decompression, only using 50% more space (which isn't great, but... if it is lagging the main thread it might be worth it).
+class Zip {
+    static async gzip(buffer, level) {
+        if (buffer.length < ZIP_SYNC_THRESHOLD_BYTES) {
+            return this.gzipSync(buffer, level);
+        }
+        if ((0, misc_1.isNode)()) {
+            return new Promise((resolve, reject) => {
+                zlib_1.default.gzip(buffer, { level }, (err, result) => {
+                    if (err)
+                        reject(err);
+                    else
+                        resolve(result);
+                });
+            });
+        }
+        else {
+            // @ts-ignore
+            return await doStream(new CompressionStream("gzip"), buffer);
+        }
+    }
+    static gzipSync(buffer, level) {
+        if ((0, misc_1.isNode)() && buffer.length < ZIP_SYNC_THRESHOLD_BYTES) {
+            return Buffer.from(zlib_1.default.gzipSync(buffer, { level }));
+        }
+        return Buffer.from(pako.gzip(buffer));
+    }
+    static gunzip(buffer) {
+        return this.gunzipUntracked(buffer);
+    }
+    static async gunzipAsyncBase(buffer) {
+        return this.gunzipUntracked(buffer);
+    }
+    static gunzipSync(buffer) {
+        return this.gunzipUntrackedSync(buffer);
+    }
+    static async gunzipBatch(buffers) {
+        let time = Date.now();
+        buffers = await Promise.all(buffers.map(x => {
+            return this.gunzipUntracked(x);
+        }));
+        time = Date.now() - time;
+        // let totalSize = buffers.reduce((acc, buffer) => acc + buffer.length, 0);
+        //console.log(`Gunzip ${formatNumber(totalSize)}B at ${formatNumber(totalSize / time * 1000)}B/s`);
+        return buffers;
+    }
+    static gunzipUntracked(buffer) {
+        // Switch to the synchronous version if the buffer is small. This is a lot faster in Node.js and clientside.
+        //  - On tests of random small amounts of data, this seems to be up to 7X faster (on node). However, on non-random data, on the actual data we're using, it seems to be almost 50 times faster. So... definitely worth it...
+        if (buffer.length < SYNC_THRESHOLD_BYTES) {
+            let time = Date.now();
+            let result = Zip.gunzipUntrackedSync(buffer);
+            let duration = Date.now() - time;
+            if (duration > 50) {
+                // Wait, so we don't lock up the main thread. And if we already wait it 50ms, then waiting for one frame is marginal, even client-side. 
+                return ((async () => {
+                    await new Promise(resolve => setTimeout(resolve, 0));
+                    return result;
+                }))();
+            }
+            return result;
+        }
+        if ((0, misc_1.isNode)()) {
+            return doStream(new DecompressionStream("gzip"), buffer);
+        }
+        else {
+            return Zip.gunzipUntrackedSync(buffer);
+        }
+    }
+    static gunzipUntrackedSync(buffer) {
+        if ((0, misc_1.isNode)() && buffer.length < ZIP_SYNC_THRESHOLD_BYTES) {
+            return Buffer.from(zlib_1.default.gunzipSync(buffer));
+        }
+        return Buffer.from(pako.ungzip(buffer));
+    }
+}
+exports.Zip = Zip;
+__decorate([
+    measure_1.measureFnc
+], Zip, "gzip", null);
+__decorate([
+    measure_1.measureFnc
+], Zip, "gzipSync", null);
+__decorate([
+    measure_1.measureFnc
+], Zip, "gunzip", null);
+__decorate([
+    measure_1.measureFnc
+], Zip, "gunzipAsyncBase", null);
+__decorate([
+    measure_1.measureFnc
+], Zip, "gunzipSync", null);
+__decorate([
+    measure_1.measureFnc
+], Zip, "gunzipBatch", null);
+async function doStream(stream, buffer) {
+    let reader = stream.readable.getReader();
+    let writer = stream.writable.getWriter();
+    let writePromise = writer.write(buffer);
+    let closePromise = writer.close();
+    let outputBuffers = [];
+    while (true) {
+        let { value, done } = await reader.read();
+        if (done) {
+            await writePromise;
+            await closePromise;
+            return Buffer.concat(outputBuffers);
+        }
+        outputBuffers.push(Buffer.from(value));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Zip.js","sourceRoot":"","sources":["Zip.ts"],"names":[],"mappings":"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","sourcesContent":["import { isNode } from \"./misc\";\nimport { measureFnc } from \"./profiling/measure\";\nimport zlib from \"zlib\";\nimport * as pako from \"pako\";\n\nimport { setFlag } from \"../require/compileFlags\";\nimport { MaybePromise } from \"./types\";\nsetFlag(require, \"pako\", \"allowclient\", true);\n\nconst SYNC_THRESHOLD_BYTES = 100_000_000;\nconst ZIP_SYNC_THRESHOLD_BYTES = 10_000_000;\n\n// IMPORTANT! If this is slow, add a LZ4 version, which uses lz4-wasm-nodejs. This should be about 10X faster in both dcompression and decompression, only using 50% more space (which isn't great, but... if it is lagging the main thread it might be worth it).\nexport class Zip {\n    @measureFnc\n    public static async gzip(buffer: Buffer, level?: number): Promise<Buffer> {\n        if (buffer.length < ZIP_SYNC_THRESHOLD_BYTES) {\n            return this.gzipSync(buffer, level);\n        }\n        if (isNode()) {\n            return new Promise((resolve, reject) => {\n                zlib.gzip(buffer, { level }, (err: any, result: Buffer) => {\n                    if (err) reject(err);\n                    else resolve(result);\n                });\n            });\n        } else {\n            // @ts-ignore\n            return await doStream(new CompressionStream(\"gzip\"), buffer);\n        }\n    }\n    @measureFnc\n    public static gzipSync(buffer: Buffer, level?: number): Buffer {\n        if (isNode() && buffer.length < ZIP_SYNC_THRESHOLD_BYTES) {\n            return Buffer.from(zlib.gzipSync(buffer, { level }));\n        }\n        return Buffer.from(pako.gzip(buffer));\n    }\n\n    @measureFnc\n    public static gunzip(buffer: Buffer): MaybePromise<Buffer> {\n        return this.gunzipUntracked(buffer);\n    }\n    @measureFnc\n    public static async gunzipAsyncBase(buffer: Buffer): Promise<Buffer> {\n        return this.gunzipUntracked(buffer);\n    }\n\n    @measureFnc\n    public static gunzipSync(buffer: Buffer): Buffer {\n        return this.gunzipUntrackedSync(buffer);\n    }\n\n    @measureFnc\n    public static async gunzipBatch(buffers: Buffer[]): Promise<Buffer[]> {\n        let time = Date.now();\n        buffers = await Promise.all(buffers.map(x => {\n            return this.gunzipUntracked(x);\n        }));\n        time = Date.now() - time;\n        // let totalSize = buffers.reduce((acc, buffer) => acc + buffer.length, 0);\n        //console.log(`Gunzip ${formatNumber(totalSize)}B at ${formatNumber(totalSize / time * 1000)}B/s`);\n        return buffers;\n    }\n\n\n\n    public static gunzipUntracked(buffer: Buffer): MaybePromise<Buffer> {\n        // Switch to the synchronous version if the buffer is small. This is a lot faster in Node.js and clientside.\n        //  - On tests of random small amounts of data, this seems to be up to 7X faster (on node). However, on non-random data, on the actual data we're using, it seems to be almost 50 times faster. So... definitely worth it...\n        if (buffer.length < SYNC_THRESHOLD_BYTES) {\n            let time = Date.now();\n            let result = Zip.gunzipUntrackedSync(buffer);\n            let duration = Date.now() - time;\n            if (duration > 50) {\n                // Wait, so we don't lock up the main thread. And if we already wait it 50ms, then waiting for one frame is marginal, even client-side. \n                return ((async () => {\n                    await new Promise(resolve => setTimeout(resolve, 0));\n                    return result;\n                }))();\n            }\n            return result;\n        }\n        if (isNode()) {\n            return doStream(new DecompressionStream(\"gzip\"), buffer);\n        } else {\n            return Zip.gunzipUntrackedSync(buffer);\n        }\n    }\n\n    private static gunzipUntrackedSync(buffer: Buffer): Buffer {\n        if (isNode() && buffer.length < ZIP_SYNC_THRESHOLD_BYTES) {\n            return Buffer.from(zlib.gunzipSync(buffer));\n        }\n        return Buffer.from(pako.ungzip(buffer));\n    }\n}\n\nasync function doStream(stream: GenericTransformStream, buffer: Buffer): Promise<Buffer> {\n    let reader = stream.readable.getReader();\n    let writer = stream.writable.getWriter();\n    let writePromise = writer.write(buffer);\n    let closePromise = writer.close();\n\n    let outputBuffers: Buffer[] = [];\n    while (true) {\n        let { value, done } = await reader.read();\n        if (done) {\n            await writePromise;\n            await closePromise;\n            return Buffer.concat(outputBuffers);\n        }\n        outputBuffers.push(Buffer.from(value));\n    }\n\n}"]}
+ /* _JS_SOURCE_HASH = "09b1b496be1d6f5cbcff6c1d73b1d1389ec6bd46eedf3b8fb71cbea47aa26dde"; */

package/src/dist/batching.ts.cache

@@ -0,0 +1,377 @@
+"use strict"; var console = (function shimConsole() {             let baseConsole = globalThis.console;             if (typeof window !== "undefined")                 return baseConsole;             let name = __filename.replaceAll("\\", "/").split("/").pop();             let dirName = __dirname.replaceAll("\\", "/").split("/").pop();             let context = {                 __FILE__: __filename,                 __DIR__: __dirname,                 __NAME__: name,                 __DIRNAME__: dirName             };             let newConsole = {                 ...baseConsole             };             for (let shim of ["log", "info", "warn", "error"]) {                 newConsole[shim] = (...args) => {                     args.push(context);                     baseConsole[shim](...args);                 };             }             newConsole.__context = context;             return newConsole;         })(); "use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.safeLoop = exports.unblockLoop = exports.throttledLoop = exports.retryFunctional = exports.shutdownPolling = exports.runInfinitePollCallAtStart = exports.runInfinitePoll = exports.runInParallel = exports.runInSerial = exports.batchFunction = exports.batchFunctionNone = exports.delay = void 0;
+const format_1 = require("./formatting/format");
+const logColors_1 = require("./formatting/logColors");
+const misc_1 = require("./misc");
+const measure_1 = require("./profiling/measure");
+function delay(delayTime, 
+// Delays < 10ms become "immediate"
+immediateShortDelays) {
+    if (delayTime === "afterio") {
+        return new Promise(resolve => setImmediate(resolve));
+    }
+    else if (delayTime === "afterpromises") {
+        // NOTE: We use a promise here as it might be a bit easier to debug than queueMicrotask.
+        //  It is equivalent though...
+        return Promise.resolve();
+    }
+    else if (delayTime === "immediate") {
+        if ((0, misc_1.isNode)()) {
+            return new Promise(resolve => setImmediate(resolve));
+        }
+        else {
+            return delay("afterpromises");
+        }
+    }
+    else if (delayTime === "paintLoop") {
+        if ((0, misc_1.isNode)()) {
+            return delay("immediate");
+        }
+        return (async () => {
+            await new Promise(resolve => requestAnimationFrame(resolve));
+        })();
+    }
+    else if (delayTime === "afterPaint") {
+        if ((0, misc_1.isNode)()) {
+            return delay("immediate");
+        }
+        else {
+            return (async () => {
+                await new Promise(resolve => requestAnimationFrame(resolve));
+                // Before first paint
+                await new Promise(resolve => requestAnimationFrame(resolve));
+                // After first paint
+            })();
+        }
+    }
+    else {
+        if (delayTime < 10 && immediateShortDelays) {
+            // NOTE: setTimeout can't wait this short of a time, so just setImmediate. This should be hard to distinguish
+            //  anyways, as setImmediate (at least in nodejs), should happen after io, so... it should just work
+            //  (the only difference is there will be less unnecessary delay).
+            // NOTE: THIS DOES break certain cases where io is depending on true delay, and by only waiting a microtick
+            //  we don't give it a chance. But... we should just handle those cases explicitly, via an explicit "afterio".
+            return delay("immediate");
+        }
+        // NOTE: We check Date.now() and wait longer if setTimeout didn't wait long enough.
+        return (async () => {
+            let targetTime = Date.now() + delayTime;
+            while (true) {
+                let timeToWait = targetTime - Date.now();
+                await new Promise(resolve => setTimeout(resolve, timeToWait));
+                if (Date.now() >= targetTime) {
+                    break;
+                }
+            }
+        })();
+    }
+}
+exports.delay = delay;
+// NOTE: This is an easy way to turn off batching, without having to strip the extra batch handling code
+function batchFunctionNone(config, fnc) {
+    return async (arg) => fnc([arg]);
+}
+exports.batchFunctionNone = batchFunctionNone;
+function batchFunction(config, fnc) {
+    if (!config.noMeasure) {
+        fnc = (0, measure_1.measureWrap)(fnc, config.name);
+    }
+    let prevPromise;
+    let batching;
+    let curDelay = config.delay;
+    let delayRamp = 0;
+    if (config.throttleWindow && typeof curDelay === "number") {
+        delayRamp = curDelay / (config.throttleWindow / curDelay);
+    }
+    let delayTime = 0;
+    if (typeof curDelay === "number") {
+        delayTime = curDelay;
+    }
+    let countSinceBreak = 0;
+    let lastCall = 0;
+    return arg => {
+        let now = Date.now();
+        if (delayRamp) {
+            // The time since the last call (started) is how much budget we will have received to
+            //  run values. If it is === delayTime, then we subtract 1, as we are right on track.
+            //  If it is > delayTime, then we are running below the rate, so it is fine.
+            //  If it is < delayTime, we are running too fast, and have to slow down.
+            let savedCount = (now - lastCall) / delayTime;
+            if (savedCount >= 1) {
+                countSinceBreak -= savedCount;
+            }
+            if (countSinceBreak < 0) {
+                countSinceBreak = 0;
+            }
+            countSinceBreak++;
+            // Set the max fairly high, as we basically ignore small delay times, so we need a high max to allow
+            //  our delay to even apply!
+            curDelay = Math.min(delayTime * 20, delayRamp * countSinceBreak);
+        }
+        lastCall = now;
+        if (batching) {
+            batching.args.push(arg);
+            return batching.promise;
+        }
+        let curPrevPromise = prevPromise;
+        let args = [arg];
+        let promise = Promise.resolve().then(async () => {
+            // Ignore the error. New callers don't care about errors in previous calls,
+            //  as they are unrelated to the current call, and just break valid calls
+            //  due to invalid calls.
+            try {
+                await curPrevPromise;
+            }
+            catch (_a) { }
+            await delay(curDelay, "immediateShortDelays");
+            // Reset batching, as we once we start the function we can't accept args. `prevPromise` will block
+            //  the next batch from starting before we finish.
+            batching = undefined;
+            return await fnc(args);
+        });
+        batching = { args, promise, };
+        prevPromise = batching.promise;
+        return promise;
+    };
+}
+exports.batchFunction = batchFunction;
+function runInSerial(fnc) {
+    let updateQueue = [];
+    return (async function runInSerial(...args) {
+        var _a;
+        let promise = {
+            promise: null,
+            resolve: () => { },
+        };
+        promise.promise = new Promise(resolve => {
+            promise.resolve = resolve;
+        });
+        const queueWasEmpty = updateQueue.length === 0;
+        if (queueWasEmpty) {
+            promise.resolve();
+        }
+        updateQueue.push(promise);
+        await promise.promise;
+        try {
+            return await fnc(...args);
+        }
+        finally {
+            // Pop ourself off
+            updateQueue.shift();
+            // Resolve the next promise
+            (_a = updateQueue[0]) === null || _a === void 0 ? void 0 : _a.resolve();
+        }
+    });
+}
+exports.runInSerial = runInSerial;
+function runInParallel(config, fnc) {
+    let queued = [];
+    let runningCount = 0;
+    function runIfNeeded() {
+        if (runningCount >= config.parallelCount) {
+            return;
+        }
+        const queuedObj = queued.shift();
+        if (!queuedObj)
+            return;
+        queuedObj.result.resolve((async () => {
+            runningCount++;
+            try {
+                if (config.callTimeout) {
+                    return await (0, misc_1.timeoutToError)(config.callTimeout, fnc(...queuedObj.parameters), () => new Error(`Parallel call timed out for fnc ${fnc.name}`));
+                }
+                else {
+                    return await fnc(...queuedObj.parameters);
+                }
+            }
+            finally {
+                runningCount--;
+                runIfNeeded();
+            }
+        })());
+    }
+    function parallelCall(...args) {
+        queued.push({
+            parameters: args,
+            result: new misc_1.PromiseObj(),
+        });
+        let queuedObj = queued[queued.length - 1];
+        runIfNeeded();
+        return queuedObj.result.promise;
+    }
+    return parallelCall;
+}
+exports.runInParallel = runInParallel;
+let pollingRunning = true;
+let pendingPolls = new Set();
+function runInfinitePoll(delayTime, fnc, stopObj) {
+    void (async () => {
+        while (!(stopObj === null || stopObj === void 0 ? void 0 : stopObj.stop) && pollingRunning) {
+            await delay(delayTime);
+            if (!pollingRunning)
+                break;
+            await runPollFnc(fnc);
+        }
+    })();
+}
+exports.runInfinitePoll = runInfinitePoll;
+async function runInfinitePollCallAtStart(delayTime, fnc, stopObj) {
+    try {
+        return await fnc();
+    }
+    finally {
+        void (async () => {
+            while (!(stopObj === null || stopObj === void 0 ? void 0 : stopObj.stop) && pollingRunning) {
+                await delay(delayTime);
+                if (!pollingRunning)
+                    break;
+                await runPollFnc(fnc);
+            }
+        })();
+    }
+}
+exports.runInfinitePollCallAtStart = runInfinitePollCallAtStart;
+async function runPollFnc(fnc) {
+    let promise = (async () => {
+        try {
+            return await fnc();
+        }
+        catch (e) {
+            console.error(`Error in infinite poll ${fnc.name || fnc.toString().slice(0, 100)} (continuing poll loop)\n${e.stack}`);
+        }
+    })();
+    pendingPolls.add(promise);
+    await promise;
+    pendingPolls.delete(promise);
+}
+/** Disables polling, called on shutdown. Blocks until all pending poll loops finish */
+async function shutdownPolling() {
+    pollingRunning = false;
+    await Promise.all(Array.from(pendingPolls));
+}
+exports.shutdownPolling = shutdownPolling;
+const DEFAULT_RETRY_DELAY = 5000;
+const DEFAULT_MAX_RETRIES = 3;
+function retryFunctional(fnc, config) {
+    let { maxRetries = DEFAULT_MAX_RETRIES, shouldRetry, minDelay = DEFAULT_RETRY_DELAY, maxDelay = DEFAULT_RETRY_DELAY, timeout, warningInterval, } = config || {};
+    let expFactor = Math.max(1, Math.log(maxDelay / minDelay) / Math.log(Math.max(maxRetries, 2)));
+    let name = fnc.name || fnc.toString().slice(0, 100);
+    async function runFnc(args, retries) {
+        try {
+            let promise = fnc(...args);
+            if (timeout !== undefined) {
+                promise = (0, misc_1.timeoutToError)(timeout, promise, () => new Error(`timed out after ${(0, format_1.formatTime)(timeout)}`));
+            }
+            if (warningInterval !== undefined) {
+                promise = (0, misc_1.watchSlowPromise)(name, promise, { interval: warningInterval });
+            }
+            return await promise;
+        }
+        catch (e) {
+            if (shouldRetry && !shouldRetry(String(e.stack))) {
+                throw e;
+            }
+            if (retries < 0)
+                throw e;
+            retries--;
+            console.warn(`Retrying ${name} (${retries}/${maxRetries} left), due to error ${String(e.stack)}`);
+            let curCount = maxRetries - retries;
+            await delay(minDelay * expFactor ** curCount);
+            return runFnc(args, retries);
+        }
+    }
+    return async function (...args) {
+        return await runFnc(args, maxRetries);
+    };
+}
+exports.retryFunctional = retryFunctional;
+/** @deprecated Use safeLoop instead */
+exports.throttledLoop = unblockLoop;
+/** @deprecated Use safeLoop instead */
+async function unblockLoop(config, fnc) {
+    var _a, _b;
+    let data = Array.isArray(config) ? config : config.data;
+    let maxBlockingTime = 300;
+    let backOffTime = 50;
+    if (!Array.isArray(config)) {
+        maxBlockingTime = (_a = config.maxBlockingTime) !== null && _a !== void 0 ? _a : 300;
+        backOffTime = (_b = config.backOffTime) !== null && _b !== void 0 ? _b : 50;
+    }
+    let lastYieldTime = Date.now();
+    let results = [];
+    for (let item of data) {
+        let result = fnc(item);
+        // If the function returns a promise, await it
+        if (result && typeof result === "object" && "then" in result) {
+            result = await result;
+        }
+        results.push(result);
+        // Check if we've been blocking for too long
+        if (Date.now() - lastYieldTime > maxBlockingTime) {
+            await delay(backOffTime);
+            lastYieldTime = Date.now();
+        }
+    }
+    return results;
+}
+exports.unblockLoop = unblockLoop;
+async function safeLoop(config, fnc) {
+    var _a;
+    let { data, maxActiveFraction, doNotWarnOnSlow, name } = config;
+    let maxBlockingTime = (_a = config.maxBlockingTime) !== null && _a !== void 0 ? _a : 1000;
+    let label = name || fnc.name || fnc.toString().slice(0, 100).replaceAll("\n", "\\n");
+    let startTime = Date.now();
+    let index = 0;
+    let indexStartTime = Date.now();
+    let done = false;
+    if (!doNotWarnOnSlow) {
+        void (async () => {
+            while (!done) {
+                await delay(5000);
+                if (done)
+                    break;
+                let message = `${(0, logColors_1.red)("SLOW LOOP")} | ${index} / ${data.length} | ${(0, format_1.formatTime)(Date.now() - startTime)} | ${label}`;
+                let timeOnCurrent = Date.now() - indexStartTime;
+                if (timeOnCurrent > 5000) {
+                    message += `| SLOW INDEX (${index}) ${(0, format_1.formatTime)(timeOnCurrent)}+`;
+                }
+                console.log(message);
+            }
+        })();
+    }
+    let results = [];
+    let activeTimeSinceYield = 0;
+    try {
+        for (index = 0; index < data.length; index++) {
+            indexStartTime = Date.now();
+            let result = fnc(data[index]);
+            let isPromise = false;
+            if (result && typeof result === "object" && "then" in result) {
+                isPromise = true;
+                result = await result;
+            }
+            results.push(result);
+            activeTimeSinceYield += Date.now() - indexStartTime;
+            let backOffTime;
+            if (!isPromise && activeTimeSinceYield > maxBlockingTime) {
+                backOffTime = 0;
+            }
+            if (maxActiveFraction !== undefined && maxActiveFraction > 0 && maxActiveFraction < 1) {
+                let target = activeTimeSinceYield / maxActiveFraction - activeTimeSinceYield;
+                backOffTime = Math.max(backOffTime !== null && backOffTime !== void 0 ? backOffTime : 0, target);
+            }
+            if (backOffTime !== undefined) {
+                await delay(backOffTime);
+                activeTimeSinceYield = 0;
+            }
+        }
+    }
+    finally {
+        done = true;
+    }
+    return results;
+}
+exports.safeLoop = safeLoop;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"batching.js","sourceRoot":"","sources":["batching.ts"],"names":[],"mappings":"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","sourcesContent":["import { formatTime } from \"./formatting/format\";\nimport { red } from \"./formatting/logColors\";\nimport { PromiseObj, isNode, timeoutToError, watchSlowPromise } from \"./misc\";\nimport { measureWrap } from \"./profiling/measure\";\nimport { AnyFunction, Args, MaybePromise } from \"./types\";\n\n/*\n    \"numbers\" use setTimeout\n    \"afterpromises\" uses a microtask, see https://developer.mozilla.org/en-US/docs/Web/API/HTML_DOM_API/Microtask_guide\n    \"afterio\" uses setImmediate, which will be after all pending and all created promises\n        (in the browser it is likely setImmediate will be shimmed with setTimeout)\n    \"immediate\" uses setImmediate, but if not available uses \"afterpromises\"\n        - The ensures a prompt return, without resorting to setTimeout in the browser (which will cause\n            the callback to be delayed a frame).\n*/\nexport type DelayType = (\n    number | \"afterio\" | \"immediate\" | \"afterpromises\"\n    // Waits for paint, usable in a loop. The first wait doesn't wait until the next\n    //  wait, but the second wait will.\n    | \"paintLoop\"\n    // Waits until after paint, by waiting twice.\n    | \"afterPaint\"\n)\nexport function delay(\n    delayTime: DelayType,\n    // Delays < 10ms become \"immediate\"\n    immediateShortDelays?: \"immediateShortDelays\"\n): Promise<void> {\n    if (delayTime === \"afterio\") {\n        return new Promise<void>(resolve => setImmediate(resolve));\n    } else if (delayTime === \"afterpromises\") {\n        // NOTE: We use a promise here as it might be a bit easier to debug than queueMicrotask.\n        //  It is equivalent though...\n        return Promise.resolve();\n    } else if (delayTime === \"immediate\") {\n        if (isNode()) {\n            return new Promise<void>(resolve => setImmediate(resolve));\n        } else {\n            return delay(\"afterpromises\");\n        }\n    } else if (delayTime === \"paintLoop\") {\n        if (isNode()) {\n            return delay(\"immediate\");\n        }\n        return (async () => {\n            await new Promise(resolve => requestAnimationFrame(resolve));\n        })();\n    } else if (delayTime === \"afterPaint\") {\n        if (isNode()) {\n            return delay(\"immediate\");\n        } else {\n            return (async () => {\n                await new Promise(resolve => requestAnimationFrame(resolve));\n                // Before first paint\n                await new Promise(resolve => requestAnimationFrame(resolve));\n                // After first paint\n            })();\n        }\n    } else {\n\n        if (delayTime < 10 && immediateShortDelays) {\n            // NOTE: setTimeout can't wait this short of a time, so just setImmediate. This should be hard to distinguish\n            //  anyways, as setImmediate (at least in nodejs), should happen after io, so... it should just work\n            //  (the only difference is there will be less unnecessary delay).\n            // NOTE: THIS DOES break certain cases where io is depending on true delay, and by only waiting a microtick\n            //  we don't give it a chance. But... we should just handle those cases explicitly, via an explicit \"afterio\".\n            return delay(\"immediate\");\n        }\n        // NOTE: We check Date.now() and wait longer if setTimeout didn't wait long enough.\n        return (async () => {\n            let targetTime = Date.now() + delayTime;\n            while (true) {\n                let timeToWait = targetTime - Date.now();\n                await new Promise<void>(resolve => setTimeout(resolve, timeToWait));\n                if (Date.now() >= targetTime) {\n                    break;\n                }\n            }\n        })();\n    }\n}\n\n// NOTE: This is an easy way to turn off batching, without having to strip the extra batch handling code\nexport function batchFunctionNone<Arg, Result = void>(\n    config: unknown,\n    fnc: (arg: Arg[]) => (Promise<Result> | Result)\n): (arg: Arg) => Promise<Result> {\n    return async arg => fnc([arg]);\n}\n\nexport function batchFunction<Arg, Result = void>(\n    config: {\n        delay: DelayType;\n        /** Instead of immediately waiting delay, starts by waiting 0ms, and every call increments the delay factor\n         *      by 1. Delay is `factor * (delay / throttleWindow)`. For every delay interval we have no calls, we decrease by\n         *      no_calls/delay.\n         *      - This essentially turns delay into a `calls per second` type indicator (ex, 10ms is 100 callers\n         *          per second, 500ms is 2 calls, etc), which is accurate over delay * throttleWindow time.\n         */\n        throttleWindow?: number;\n        name?: string;\n        noMeasure?: boolean;\n    },\n    fnc: (arg: Arg[]) => (Promise<Result> | Result)\n): (arg: Arg) => Promise<Result> {\n    if (!config.noMeasure) {\n        fnc = measureWrap(fnc, config.name);\n    }\n\n    let prevPromise: Promise<Result> | undefined;\n    let batching: {\n        args: Arg[];\n        promise: Promise<Result>;\n    } | undefined;\n    let curDelay = config.delay;\n    let delayRamp = 0;\n    if (config.throttleWindow && typeof curDelay === \"number\") {\n        delayRamp = curDelay / (config.throttleWindow / curDelay);\n    }\n    let delayTime = 0;\n    if (typeof curDelay === \"number\") {\n        delayTime = curDelay;\n    }\n    let countSinceBreak = 0;\n    let lastCall = 0;\n\n    return arg => {\n        let now = Date.now();\n        if (delayRamp) {\n            // The time since the last call (started) is how much budget we will have received to\n            //  run values. If it is === delayTime, then we subtract 1, as we are right on track.\n            //  If it is > delayTime, then we are running below the rate, so it is fine.\n            //  If it is < delayTime, we are running too fast, and have to slow down.\n            let savedCount = (now - lastCall) / delayTime;\n            if (savedCount >= 1) {\n                countSinceBreak -= savedCount;\n            }\n            if (countSinceBreak < 0) {\n                countSinceBreak = 0;\n            }\n\n            countSinceBreak++;\n            // Set the max fairly high, as we basically ignore small delay times, so we need a high max to allow\n            //  our delay to even apply!\n            curDelay = Math.min(delayTime * 20, delayRamp * countSinceBreak);\n        }\n        lastCall = now;\n\n        if (batching) {\n            batching.args.push(arg);\n            return batching.promise;\n        }\n\n        let curPrevPromise = prevPromise;\n        let args: Arg[] = [arg];\n        let promise = Promise.resolve().then(async () => {\n            // Ignore the error. New callers don't care about errors in previous calls,\n            //  as they are unrelated to the current call, and just break valid calls\n            //  due to invalid calls.\n            try {\n                await curPrevPromise;\n            } catch { }\n            await delay(curDelay, \"immediateShortDelays\");\n            // Reset batching, as we once we start the function we can't accept args. `prevPromise` will block\n            //  the next batch from starting before we finish.\n            batching = undefined;\n            return await fnc(args);\n        });\n        batching = { args, promise, };\n        prevPromise = batching.promise;\n\n        return promise;\n    };\n}\n\nexport function runInSerial<T extends (...args: any[]) => Promise<any>>(fnc: T): T {\n    let updateQueue: { promise: Promise<void>; resolve: () => void; }[] = [];\n\n    return (async function runInSerial(...args: any[]) {\n        let promise = {\n            promise: null as any as Promise<void>,\n            resolve: () => { },\n        };\n        promise.promise = new Promise<void>(resolve => {\n            promise.resolve = resolve;\n        });\n        const queueWasEmpty = updateQueue.length === 0;\n        if (queueWasEmpty) {\n            promise.resolve();\n        }\n        updateQueue.push(promise);\n        await promise.promise;\n\n        try {\n            return await fnc(...args);\n        } finally {\n            // Pop ourself off\n            updateQueue.shift();\n            // Resolve the next promise\n            updateQueue[0]?.resolve();\n        }\n    }) as T;\n}\n\n\nexport function runInParallel<T extends (...args: any[]) => Promise<any>>(\n    config: {\n        parallelCount: number;\n        callTimeout?: number;\n    },\n    fnc: T\n): T {\n    let queued: {\n        parameters: Args<T>;\n        result: PromiseObj<ReturnType<T>>;\n    }[] = [];\n    let runningCount = 0;\n\n    function runIfNeeded() {\n        if (runningCount >= config.parallelCount) {\n            return;\n        }\n        const queuedObj = queued.shift();\n        if (!queuedObj) return;\n\n        queuedObj.result.resolve((async () => {\n            runningCount++;\n            try {\n                if (config.callTimeout) {\n                    return await timeoutToError(config.callTimeout, fnc(...queuedObj.parameters), () => new Error(`Parallel call timed out for fnc ${fnc.name}`));\n                } else {\n                    return await fnc(...queuedObj.parameters);\n                }\n            } finally {\n                runningCount--;\n                runIfNeeded();\n            }\n        })());\n    }\n\n    function parallelCall(...args: Args<T>) {\n        queued.push({\n            parameters: args,\n            result: new PromiseObj<ReturnType<T>>(),\n        });\n        let queuedObj = queued[queued.length - 1];\n        runIfNeeded();\n        return queuedObj.result.promise;\n    }\n    return parallelCall as T;\n}\n\nlet pollingRunning = true;\nlet pendingPolls = new Set<Promise<unknown>>();\n\nexport function runInfinitePoll(\n    delayTime: number,\n    fnc: () => Promise<void> | void,\n    stopObj?: { stop: boolean; }\n) {\n    void (async () => {\n        while (!stopObj?.stop && pollingRunning) {\n            await delay(delayTime);\n            if (!pollingRunning) break;\n            await runPollFnc(fnc);\n        }\n    })();\n}\n\nexport async function runInfinitePollCallAtStart(\n    delayTime: number,\n    fnc: () => Promise<void> | void,\n    stopObj?: { stop: boolean; }\n) {\n    try {\n        return await fnc();\n    } finally {\n        void (async () => {\n            while (!stopObj?.stop && pollingRunning) {\n                await delay(delayTime);\n                if (!pollingRunning) break;\n                await runPollFnc(fnc);\n            }\n        })();\n    }\n}\n\nasync function runPollFnc(fnc: () => Promise<void> | void) {\n    let promise = (async () => {\n        try {\n            return await fnc();\n        } catch (e: any) {\n            console.error(`Error in infinite poll ${fnc.name || fnc.toString().slice(0, 100)} (continuing poll loop)\\n${e.stack}`);\n        }\n    })();\n    pendingPolls.add(promise);\n    await promise;\n    pendingPolls.delete(promise);\n}\n\n/** Disables polling, called on shutdown. Blocks until all pending poll loops finish */\nexport async function shutdownPolling() {\n    pollingRunning = false;\n    await Promise.all(Array.from(pendingPolls));\n}\n\n\nconst DEFAULT_RETRY_DELAY = 5000;\nconst DEFAULT_MAX_RETRIES = 3;\nexport function retryFunctional<T extends AnyFunction>(fnc: T, config?: {\n    maxRetries?: number;\n    shouldRetry?: (message: string) => boolean;\n    minDelay?: number;\n    maxDelay?: number;\n    timeout?: number;\n    warningInterval?: number;\n}): T {\n    let {\n        maxRetries = DEFAULT_MAX_RETRIES, shouldRetry, minDelay = DEFAULT_RETRY_DELAY, maxDelay = DEFAULT_RETRY_DELAY,\n        timeout,\n        warningInterval,\n    } = config || {};\n    let expFactor = Math.max(1, Math.log(maxDelay / minDelay) / Math.log(Math.max(maxRetries, 2)));\n    let name = fnc.name || fnc.toString().slice(0, 100);\n    async function runFnc(args: any[], retries: number): Promise<ReturnType<T>> {\n        try {\n            let promise = (fnc as any)(...args);\n            if (timeout !== undefined) {\n                promise = timeoutToError(timeout, promise, () => new Error(`timed out after ${formatTime(timeout)}`));\n            }\n            if (warningInterval !== undefined) {\n                promise = watchSlowPromise(name, promise, { interval: warningInterval });\n            }\n            return await promise;\n        } catch (e: any) {\n            if (shouldRetry && !shouldRetry(String(e.stack))) {\n                throw e;\n            }\n            if (retries < 0) throw e;\n            retries--;\n            console.warn(`Retrying ${name} (${retries}/${maxRetries} left), due to error ${String(e.stack)}`);\n            let curCount = maxRetries - retries;\n            await delay(minDelay * expFactor ** curCount);\n            return runFnc(args, retries);\n        }\n    }\n    return async function (...args: any[]) {\n        return await runFnc(args, maxRetries);\n    } as any;\n}\n\n/** @deprecated Use safeLoop instead */\nexport const throttledLoop = unblockLoop;\n/** @deprecated Use safeLoop instead */\nexport async function unblockLoop<T, R>(config: {\n    data: T[];\n    maxBlockingTime?: number;\n    backOffTime?: number;\n} | T[], fnc: (item: T) => MaybePromise<R>): Promise<R[]> {\n\n    let data = Array.isArray(config) ? config : config.data;\n    let maxBlockingTime = 300;\n    let backOffTime = 50;\n    if (!Array.isArray(config)) {\n        maxBlockingTime = config.maxBlockingTime ?? 300;\n        backOffTime = config.backOffTime ?? 50;\n    }\n\n    let lastYieldTime = Date.now();\n    let results: R[] = [];\n\n    for (let item of data) {\n        let result = fnc(item);\n\n        // If the function returns a promise, await it\n        if (result && typeof result === \"object\" && \"then\" in result) {\n            result = await result;\n        }\n        results.push(result);\n\n        // Check if we've been blocking for too long\n        if (Date.now() - lastYieldTime > maxBlockingTime) {\n            await delay(backOffTime);\n            lastYieldTime = Date.now();\n        }\n    }\n    return results;\n}\n\nexport async function safeLoop<T, R>(config: {\n    data: T[];\n    name?: string;\n    /** If set, yields after blocking for this many ms. ONLY applies if your function does not return promises. Default = 1000ms */\n    maxBlockingTime?: number;\n    /** Fraction of time spent active vs yielded. e.g. 0.5 => after running X ms, wait X ms before continuing. */\n    maxActiveFraction?: number;\n    doNotWarnOnSlow?: boolean;\n}, fnc: (item: T) => MaybePromise<R>): Promise<R[]> {\n    let { data, maxActiveFraction, doNotWarnOnSlow, name } = config;\n    let maxBlockingTime = config.maxBlockingTime ?? 1000;\n\n    let label = name || fnc.name || fnc.toString().slice(0, 100).replaceAll(\"\\n\", \"\\\\n\");\n    let startTime = Date.now();\n    let index = 0;\n    let indexStartTime = Date.now();\n    let done = false;\n\n    if (!doNotWarnOnSlow) {\n        void (async () => {\n            while (!done) {\n                await delay(5000);\n                if (done) break;\n                let message = `${red(\"SLOW LOOP\")} | ${index} / ${data.length} | ${formatTime(Date.now() - startTime)} | ${label}`;\n                let timeOnCurrent = Date.now() - indexStartTime;\n                if (timeOnCurrent > 5000) {\n                    message += `| SLOW INDEX (${index}) ${formatTime(timeOnCurrent)}+`;\n                }\n                console.log(message);\n            }\n        })();\n    }\n\n    let results: R[] = [];\n    let activeTimeSinceYield = 0;\n    try {\n        for (index = 0; index < data.length; index++) {\n            indexStartTime = Date.now();\n            let result = fnc(data[index]);\n            let isPromise = false;\n            if (result && typeof result === \"object\" && \"then\" in result) {\n                isPromise = true;\n                result = await result;\n            }\n            results.push(result);\n\n            activeTimeSinceYield += Date.now() - indexStartTime;\n\n            let backOffTime: number | undefined;\n\n            if (!isPromise && activeTimeSinceYield > maxBlockingTime) {\n                backOffTime = 0;\n            }\n\n            if (maxActiveFraction !== undefined && maxActiveFraction > 0 && maxActiveFraction < 1) {\n                let target = activeTimeSinceYield / maxActiveFraction - activeTimeSinceYield;\n                backOffTime = Math.max(backOffTime ?? 0, target);\n            }\n\n            if (backOffTime !== undefined) {\n                await delay(backOffTime);\n                activeTimeSinceYield = 0;\n            }\n        }\n    } finally {\n        done = true;\n    }\n    return results;\n}"]}
+ /* _JS_SOURCE_HASH = "9799d140cb038e8cb87b2d854c3850d4cf273d8a43b662ace82c78f9a0753e86"; */