@luxass/utils 2.2.2 → 2.3.0

package/dist/index.d.ts

@@ -2,6 +2,7 @@ import { isNotNull$1 as isNotNull, isNotNullish$1 as isNotNullish, isNotUndefine
 import { clamp$1 as clamp } from "./number-C2E_sOOy.js";
 import { capitalize$1 as capitalize, dedent$1 as dedent, dedentRaw$1 as dedentRaw, formatStr$1 as formatStr, sanitizeIdentifier$1 as sanitizeIdentifier, toCamelCase$1 as toCamelCase, toKebabCase$1 as toKebabCase, toPascalCase$1 as toPascalCase, toSnakeCase$1 as toSnakeCase } from "./string-CBWIJiC0.js";
 import { ElementOf, InferArguments, MaybeArray, MaybePromise, Nullable, Nullish, Prettify, RemoveIndexSignature } from "./types-QETho94V.js";
+import pRetry from "p-retry";
 
 //#region src/common.d.ts
 declare class InvariantError extends Error {
@@ -20,4 +21,4 @@ declare class InvariantError extends Error {
 declare function invariant(predicate: unknown, message: string, ...positionals: unknown[]): asserts predicate;
 
 //#endregion
-export { ElementOf, InferArguments, InvariantError, MaybeArray, MaybePromise, Nullable, Nullish, Prettify, RemoveIndexSignature, capitalize, clamp, dedent, dedentRaw, formatStr, invariant, isNotNull, isNotNullish, isNotUndefined, isTruthy, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase };
+export { ElementOf, InferArguments, InvariantError, MaybeArray, MaybePromise, Nullable, Nullish, Prettify, RemoveIndexSignature, capitalize, clamp, dedent, dedentRaw, formatStr, invariant, isNotNull, isNotNullish, isNotUndefined, isTruthy, pRetry as promiseRetry, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase };

package/dist/index.js

@@ -2,6 +2,32 @@ import { isNotNull, isNotNullish, isNotUndefined, isTruthy } from "./guards-O1HG
 import { capitalize, dedent, dedentRaw, formatStr, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase } from "./string-pQApOGKP.js";
 import { clamp } from "./number-BS9T5WGO.js";
 
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
 //#region src/common.ts
 var InvariantError = class extends Error {
 	constructor(message, ...positionals) {
@@ -24,4 +50,270 @@ function invariant(predicate, message, ...positionals) {
 }
 
 //#endregion
-export { InvariantError, capitalize, clamp, dedent, dedentRaw, formatStr, invariant, isNotNull, isNotNullish, isNotUndefined, isTruthy, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase };
+//#region node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry_operation.js
+var require_retry_operation = __commonJS({ "node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry_operation.js"(exports, module) {
+	function RetryOperation$1(timeouts, options) {
+		if (typeof options === "boolean") options = { forever: options };
+		this._originalTimeouts = JSON.parse(JSON.stringify(timeouts));
+		this._timeouts = timeouts;
+		this._options = options || {};
+		this._maxRetryTime = options && options.maxRetryTime || Infinity;
+		this._fn = null;
+		this._errors = [];
+		this._attempts = 1;
+		this._operationTimeout = null;
+		this._operationTimeoutCb = null;
+		this._timeout = null;
+		this._operationStart = null;
+		this._timer = null;
+		if (this._options.forever) this._cachedTimeouts = this._timeouts.slice(0);
+	}
+	module.exports = RetryOperation$1;
+	RetryOperation$1.prototype.reset = function() {
+		this._attempts = 1;
+		this._timeouts = this._originalTimeouts.slice(0);
+	};
+	RetryOperation$1.prototype.stop = function() {
+		if (this._timeout) clearTimeout(this._timeout);
+		if (this._timer) clearTimeout(this._timer);
+		this._timeouts = [];
+		this._cachedTimeouts = null;
+	};
+	RetryOperation$1.prototype.retry = function(err) {
+		if (this._timeout) clearTimeout(this._timeout);
+		if (!err) return false;
+		var currentTime = new Date().getTime();
+		if (err && currentTime - this._operationStart >= this._maxRetryTime) {
+			this._errors.push(err);
+			this._errors.unshift(new Error("RetryOperation timeout occurred"));
+			return false;
+		}
+		this._errors.push(err);
+		var timeout = this._timeouts.shift();
+		if (timeout === void 0) if (this._cachedTimeouts) {
+			this._errors.splice(0, this._errors.length - 1);
+			timeout = this._cachedTimeouts.slice(-1);
+		} else return false;
+		var self = this;
+		this._timer = setTimeout(function() {
+			self._attempts++;
+			if (self._operationTimeoutCb) {
+				self._timeout = setTimeout(function() {
+					self._operationTimeoutCb(self._attempts);
+				}, self._operationTimeout);
+				if (self._options.unref) self._timeout.unref();
+			}
+			self._fn(self._attempts);
+		}, timeout);
+		if (this._options.unref) this._timer.unref();
+		return true;
+	};
+	RetryOperation$1.prototype.attempt = function(fn, timeoutOps) {
+		this._fn = fn;
+		if (timeoutOps) {
+			if (timeoutOps.timeout) this._operationTimeout = timeoutOps.timeout;
+			if (timeoutOps.cb) this._operationTimeoutCb = timeoutOps.cb;
+		}
+		var self = this;
+		if (this._operationTimeoutCb) this._timeout = setTimeout(function() {
+			self._operationTimeoutCb();
+		}, self._operationTimeout);
+		this._operationStart = new Date().getTime();
+		this._fn(this._attempts);
+	};
+	RetryOperation$1.prototype.try = function(fn) {
+		console.log("Using RetryOperation.try() is deprecated");
+		this.attempt(fn);
+	};
+	RetryOperation$1.prototype.start = function(fn) {
+		console.log("Using RetryOperation.start() is deprecated");
+		this.attempt(fn);
+	};
+	RetryOperation$1.prototype.start = RetryOperation$1.prototype.try;
+	RetryOperation$1.prototype.errors = function() {
+		return this._errors;
+	};
+	RetryOperation$1.prototype.attempts = function() {
+		return this._attempts;
+	};
+	RetryOperation$1.prototype.mainError = function() {
+		if (this._errors.length === 0) return null;
+		var counts = {};
+		var mainError = null;
+		var mainErrorCount = 0;
+		for (var i = 0; i < this._errors.length; i++) {
+			var error = this._errors[i];
+			var message = error.message;
+			var count = (counts[message] || 0) + 1;
+			counts[message] = count;
+			if (count >= mainErrorCount) {
+				mainError = error;
+				mainErrorCount = count;
+			}
+		}
+		return mainError;
+	};
+} });
+
+//#endregion
+//#region node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry.js
+var require_retry$1 = __commonJS({ "node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry.js"(exports) {
+	var RetryOperation = require_retry_operation();
+	exports.operation = function(options) {
+		var timeouts = exports.timeouts(options);
+		return new RetryOperation(timeouts, {
+			forever: options && (options.forever || options.retries === Infinity),
+			unref: options && options.unref,
+			maxRetryTime: options && options.maxRetryTime
+		});
+	};
+	exports.timeouts = function(options) {
+		if (options instanceof Array) return [].concat(options);
+		var opts = {
+			retries: 10,
+			factor: 2,
+			minTimeout: 1 * 1e3,
+			maxTimeout: Infinity,
+			randomize: false
+		};
+		for (var key in options) opts[key] = options[key];
+		if (opts.minTimeout > opts.maxTimeout) throw new Error("minTimeout is greater than maxTimeout");
+		var timeouts = [];
+		for (var i = 0; i < opts.retries; i++) timeouts.push(this.createTimeout(i, opts));
+		if (options && options.forever && !timeouts.length) timeouts.push(this.createTimeout(i, opts));
+		timeouts.sort(function(a, b) {
+			return a - b;
+		});
+		return timeouts;
+	};
+	exports.createTimeout = function(attempt, opts) {
+		var random = opts.randomize ? Math.random() + 1 : 1;
+		var timeout = Math.round(random * Math.max(opts.minTimeout, 1) * Math.pow(opts.factor, attempt));
+		timeout = Math.min(timeout, opts.maxTimeout);
+		return timeout;
+	};
+	exports.wrap = function(obj, options, methods) {
+		if (options instanceof Array) {
+			methods = options;
+			options = null;
+		}
+		if (!methods) {
+			methods = [];
+			for (var key in obj) if (typeof obj[key] === "function") methods.push(key);
+		}
+		for (var i = 0; i < methods.length; i++) {
+			var method = methods[i];
+			var original = obj[method];
+			obj[method] = function retryWrapper(original$1) {
+				var op = exports.operation(options);
+				var args = Array.prototype.slice.call(arguments, 1);
+				var callback = args.pop();
+				args.push(function(err) {
+					if (op.retry(err)) return;
+					if (err) arguments[0] = op.mainError();
+					callback.apply(this, arguments);
+				});
+				op.attempt(function() {
+					original$1.apply(obj, args);
+				});
+			}.bind(obj, original);
+			obj[method].options = options;
+		}
+	};
+} });
+
+//#endregion
+//#region node_modules/.pnpm/retry@0.13.1/node_modules/retry/index.js
+var require_retry = __commonJS({ "node_modules/.pnpm/retry@0.13.1/node_modules/retry/index.js"(exports, module) {
+	module.exports = require_retry$1();
+} });
+
+//#endregion
+//#region node_modules/.pnpm/is-network-error@1.1.0/node_modules/is-network-error/index.js
+const objectToString = Object.prototype.toString;
+const isError = (value) => objectToString.call(value) === "[object Error]";
+const errorMessages = new Set([
+	"network error",
+	"Failed to fetch",
+	"NetworkError when attempting to fetch resource.",
+	"The Internet connection appears to be offline.",
+	"Load failed",
+	"Network request failed",
+	"fetch failed",
+	"terminated"
+]);
+function isNetworkError(error) {
+	const isValid = error && isError(error) && error.name === "TypeError" && typeof error.message === "string";
+	if (!isValid) return false;
+	if (error.message === "Load failed") return error.stack === void 0;
+	return errorMessages.has(error.message);
+}
+
+//#endregion
+//#region node_modules/.pnpm/p-retry@6.2.1/node_modules/p-retry/index.js
+var import_retry = __toESM(require_retry(), 1);
+var AbortError = class extends Error {
+	constructor(message) {
+		super();
+		if (message instanceof Error) {
+			this.originalError = message;
+			({message} = message);
+		} else {
+			this.originalError = new Error(message);
+			this.originalError.stack = this.stack;
+		}
+		this.name = "AbortError";
+		this.message = message;
+	}
+};
+const decorateErrorWithCounts = (error, attemptNumber, options) => {
+	const retriesLeft = options.retries - (attemptNumber - 1);
+	error.attemptNumber = attemptNumber;
+	error.retriesLeft = retriesLeft;
+	return error;
+};
+async function pRetry(input, options) {
+	return new Promise((resolve, reject) => {
+		options = { ...options };
+		options.onFailedAttempt ??= () => {};
+		options.shouldRetry ??= () => true;
+		options.retries ??= 10;
+		const operation = import_retry.default.operation(options);
+		const abortHandler = () => {
+			operation.stop();
+			reject(options.signal?.reason);
+		};
+		if (options.signal && !options.signal.aborted) options.signal.addEventListener("abort", abortHandler, { once: true });
+		const cleanUp = () => {
+			options.signal?.removeEventListener("abort", abortHandler);
+			operation.stop();
+		};
+		operation.attempt(async (attemptNumber) => {
+			try {
+				const result = await input(attemptNumber);
+				cleanUp();
+				resolve(result);
+			} catch (error) {
+				try {
+					if (!(error instanceof Error)) throw new TypeError(`Non-error was thrown: "${error}". You should only throw errors.`);
+					if (error instanceof AbortError) throw error.originalError;
+					if (error instanceof TypeError && !isNetworkError(error)) throw error;
+					decorateErrorWithCounts(error, attemptNumber, options);
+					if (!await options.shouldRetry(error)) {
+						operation.stop();
+						reject(error);
+					}
+					await options.onFailedAttempt(error);
+					if (!operation.retry(error)) throw operation.mainError();
+				} catch (finalError) {
+					decorateErrorWithCounts(finalError, attemptNumber, options);
+					cleanUp();
+					reject(finalError);
+				}
+			}
+		});
+	});
+}
+
+//#endregion
+export { InvariantError, capitalize, clamp, dedent, dedentRaw, formatStr, invariant, isNotNull, isNotNullish, isNotUndefined, isTruthy, pRetry as promiseRetry, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luxass/utils",
-  "version": "2.2.2",
+  "version": "2.3.0",
   "description": "A collection of utilities for JavaScript/TypeScript",
   "type": "module",
   "author": {
@@ -38,6 +38,9 @@
   "engines": {
     "node": ">=20"
   },
+  "dependencies": {
+    "p-retry": "^6.2.1"
+  },
   "devDependencies": {
     "@luxass/eslint-config": "^4.18.1",
     "@types/node": "^22.15.2",