@md-oss/common 0.1.6 → 0.1.7

package/dist/random-BqJDZAPb.d.cts

@@ -0,0 +1,131 @@
+/**
+ * Generate a random integer between min and max (inclusive)
+ * @param min - Minimum value
+ * @param max - Maximum value
+ * @returns Random integer
+ * @example randomInt(1, 10) // Random integer from 1 to 10
+ */
+declare const randomInt: (min: number, max: number) => number;
+/**
+ * Generate a random float between min and max
+ * @param min - Minimum value
+ * @param max - Maximum value
+ * @returns Random float
+ * @example randomFloat(1.0, 10.0) // Random float from 1.0 to 10.0
+ */
+declare const randomFloat: (min: number, max: number) => number;
+/**
+ * Get a random item from an array
+ * @param items - Array to pick from
+ * @returns Random item or undefined if array is empty
+ * @example randomItem([1, 2, 3]) // Could return 1, 2, or 3
+ */
+declare const randomItem: <T>(items: T[]) => T | undefined;
+/**
+ * Get a random key from an object or array
+ * @param items - Object or array to pick from
+ * @returns Random key or undefined
+ * @example randomKey({a: 1, b: 2}) // Could return "a" or "b"
+ */
+declare const randomKey: <T>(items: Record<string, T> | T[]) => string | undefined;
+/**
+ * Get a random value from an object or array
+ * @param items - Object or array to pick from
+ * @returns Random value or undefined
+ * @example randomValue({a: 1, b: 2}) // Could return 1 or 2
+ */
+declare const randomValue: <T>(items: Record<string, T> | T[]) => T | undefined;
+/**
+ * Generate a random boolean value
+ * @returns Random true or false
+ * @example randomBoolean() // Could return true or false with 50% probability each
+ */
+declare const randomBoolean: () => boolean;
+/**
+ * Generate a random string of specified length
+ * @param length - Length of the string to generate
+ * @param characters - Character set to use (string or options object)
+ * @returns Random string
+ * @example randomString(10) // Random 10-char string with uppercase, lowercase, and numbers
+ * @example randomString(5, 'abc') // Random 5-char string using only 'a', 'b', 'c'
+ * @example randomString(8, {useUppercase: true, useLowercase: false, useNumeric: false})
+ */
+declare const randomString: (length: number, characters?: string | RandomStringOptions) => string;
+/**
+ * Generate a random hex string (lowercase)
+ * @param length - Length of the hex string (default: 16)
+ * @returns Random hex string
+ * @example randomHex(8) // "a3f5c9d1"
+ */
+declare const randomHex: (length?: number) => string;
+/**
+ * Generate a UUID v4 (random)
+ * @returns UUID string
+ * @example randomUUID() // "f47ac10b-58cc-4372-a567-0e02b2c3d479"
+ */
+declare const randomUUID: () => string;
+/**
+ * Pick N random items from an array without replacement
+ * @param items - Array to sample from
+ * @param count - Number of items to pick
+ * @returns Array of randomly selected items
+ * @example sample([1, 2, 3, 4, 5], 3) // [2, 5, 1]
+ */
+declare const sample: <T>(items: T[], count: number) => T[];
+/**
+ * Pick a random item with weighted probabilities
+ * @param items - Array of items
+ * @param weights - Array of weights (must be same length as items)
+ * @returns Random item based on weights
+ * @example weightedRandom(['a', 'b', 'c'], [1, 2, 3]) // 'c' is 3x more likely than 'a'
+ */
+declare const weightedRandom: <T>(items: T[], weights: number[]) => T | undefined;
+/**
+ * Get a random enum value
+ * @param enumObj - Enum object
+ * @returns Random enum value
+ * @example enum Color { Red, Green, Blue }; randomEnum(Color) // Color.Green
+ */
+declare const randomEnum: <T extends Record<string, string | number>>(enumObj: T) => T[keyof T];
+/**
+ * Generate a random hex color
+ * @returns Random hex color string (e.g., "#a3f5c9")
+ * @example randomColor() // "#a3f5c9"
+ */
+declare const randomColor: () => string;
+/**
+ * Generate a random date between two dates
+ * @param start - Start date
+ * @param end - End date
+ * @returns Random date between start and end
+ * @example randomDate(new Date(2020, 0, 1), new Date(2021, 0, 1))
+ */
+declare const randomDate: (start: Date, end: Date) => Date;
+type RandomStringOptions = {
+    useNumeric?: boolean;
+    useLowercase?: boolean;
+    useUppercase?: boolean;
+};
+
+type random_RandomStringOptions = RandomStringOptions;
+declare const random_randomBoolean: typeof randomBoolean;
+declare const random_randomColor: typeof randomColor;
+declare const random_randomDate: typeof randomDate;
+declare const random_randomEnum: typeof randomEnum;
+declare const random_randomFloat: typeof randomFloat;
+declare const random_randomHex: typeof randomHex;
+declare const random_randomInt: typeof randomInt;
+declare const random_randomItem: typeof randomItem;
+declare const random_randomKey: typeof randomKey;
+declare const random_randomString: typeof randomString;
+declare const random_randomUUID: typeof randomUUID;
+declare const random_randomValue: typeof randomValue;
+declare const random_sample: typeof sample;
+declare const random_weightedRandom: typeof weightedRandom;
+declare namespace random {
+  export { random_randomBoolean as randomBoolean, random_randomColor as randomColor, random_randomDate as randomDate, random_randomEnum as randomEnum, random_randomFloat as randomFloat, random_randomHex as randomHex, random_randomInt as randomInt, random_randomItem as randomItem, random_randomKey as randomKey, random_randomString as randomString, random_randomUUID as randomUUID, random_randomValue as randomValue, random_sample as sample, random_weightedRandom as weightedRandom };
+  export type { random_RandomStringOptions as RandomStringOptions };
+}
+
+export { randomInt as a, randomFloat as b, randomItem as c, randomKey as d, randomValue as e, randomBoolean as f, randomString as g, randomHex as h, randomUUID as i, randomEnum as j, randomColor as k, randomDate as l, random as r, sample as s, weightedRandom as w };
+export type { RandomStringOptions as R };

package/dist/random-BqJDZAPb.d.mts

@@ -0,0 +1,131 @@
+/**
+ * Generate a random integer between min and max (inclusive)
+ * @param min - Minimum value
+ * @param max - Maximum value
+ * @returns Random integer
+ * @example randomInt(1, 10) // Random integer from 1 to 10
+ */
+declare const randomInt: (min: number, max: number) => number;
+/**
+ * Generate a random float between min and max
+ * @param min - Minimum value
+ * @param max - Maximum value
+ * @returns Random float
+ * @example randomFloat(1.0, 10.0) // Random float from 1.0 to 10.0
+ */
+declare const randomFloat: (min: number, max: number) => number;
+/**
+ * Get a random item from an array
+ * @param items - Array to pick from
+ * @returns Random item or undefined if array is empty
+ * @example randomItem([1, 2, 3]) // Could return 1, 2, or 3
+ */
+declare const randomItem: <T>(items: T[]) => T | undefined;
+/**
+ * Get a random key from an object or array
+ * @param items - Object or array to pick from
+ * @returns Random key or undefined
+ * @example randomKey({a: 1, b: 2}) // Could return "a" or "b"
+ */
+declare const randomKey: <T>(items: Record<string, T> | T[]) => string | undefined;
+/**
+ * Get a random value from an object or array
+ * @param items - Object or array to pick from
+ * @returns Random value or undefined
+ * @example randomValue({a: 1, b: 2}) // Could return 1 or 2
+ */
+declare const randomValue: <T>(items: Record<string, T> | T[]) => T | undefined;
+/**
+ * Generate a random boolean value
+ * @returns Random true or false
+ * @example randomBoolean() // Could return true or false with 50% probability each
+ */
+declare const randomBoolean: () => boolean;
+/**
+ * Generate a random string of specified length
+ * @param length - Length of the string to generate
+ * @param characters - Character set to use (string or options object)
+ * @returns Random string
+ * @example randomString(10) // Random 10-char string with uppercase, lowercase, and numbers
+ * @example randomString(5, 'abc') // Random 5-char string using only 'a', 'b', 'c'
+ * @example randomString(8, {useUppercase: true, useLowercase: false, useNumeric: false})
+ */
+declare const randomString: (length: number, characters?: string | RandomStringOptions) => string;
+/**
+ * Generate a random hex string (lowercase)
+ * @param length - Length of the hex string (default: 16)
+ * @returns Random hex string
+ * @example randomHex(8) // "a3f5c9d1"
+ */
+declare const randomHex: (length?: number) => string;
+/**
+ * Generate a UUID v4 (random)
+ * @returns UUID string
+ * @example randomUUID() // "f47ac10b-58cc-4372-a567-0e02b2c3d479"
+ */
+declare const randomUUID: () => string;
+/**
+ * Pick N random items from an array without replacement
+ * @param items - Array to sample from
+ * @param count - Number of items to pick
+ * @returns Array of randomly selected items
+ * @example sample([1, 2, 3, 4, 5], 3) // [2, 5, 1]
+ */
+declare const sample: <T>(items: T[], count: number) => T[];
+/**
+ * Pick a random item with weighted probabilities
+ * @param items - Array of items
+ * @param weights - Array of weights (must be same length as items)
+ * @returns Random item based on weights
+ * @example weightedRandom(['a', 'b', 'c'], [1, 2, 3]) // 'c' is 3x more likely than 'a'
+ */
+declare const weightedRandom: <T>(items: T[], weights: number[]) => T | undefined;
+/**
+ * Get a random enum value
+ * @param enumObj - Enum object
+ * @returns Random enum value
+ * @example enum Color { Red, Green, Blue }; randomEnum(Color) // Color.Green
+ */
+declare const randomEnum: <T extends Record<string, string | number>>(enumObj: T) => T[keyof T];
+/**
+ * Generate a random hex color
+ * @returns Random hex color string (e.g., "#a3f5c9")
+ * @example randomColor() // "#a3f5c9"
+ */
+declare const randomColor: () => string;
+/**
+ * Generate a random date between two dates
+ * @param start - Start date
+ * @param end - End date
+ * @returns Random date between start and end
+ * @example randomDate(new Date(2020, 0, 1), new Date(2021, 0, 1))
+ */
+declare const randomDate: (start: Date, end: Date) => Date;
+type RandomStringOptions = {
+    useNumeric?: boolean;
+    useLowercase?: boolean;
+    useUppercase?: boolean;
+};
+
+type random_RandomStringOptions = RandomStringOptions;
+declare const random_randomBoolean: typeof randomBoolean;
+declare const random_randomColor: typeof randomColor;
+declare const random_randomDate: typeof randomDate;
+declare const random_randomEnum: typeof randomEnum;
+declare const random_randomFloat: typeof randomFloat;
+declare const random_randomHex: typeof randomHex;
+declare const random_randomInt: typeof randomInt;
+declare const random_randomItem: typeof randomItem;
+declare const random_randomKey: typeof randomKey;
+declare const random_randomString: typeof randomString;
+declare const random_randomUUID: typeof randomUUID;
+declare const random_randomValue: typeof randomValue;
+declare const random_sample: typeof sample;
+declare const random_weightedRandom: typeof weightedRandom;
+declare namespace random {
+  export { random_randomBoolean as randomBoolean, random_randomColor as randomColor, random_randomDate as randomDate, random_randomEnum as randomEnum, random_randomFloat as randomFloat, random_randomHex as randomHex, random_randomInt as randomInt, random_randomItem as randomItem, random_randomKey as randomKey, random_randomString as randomString, random_randomUUID as randomUUID, random_randomValue as randomValue, random_sample as sample, random_weightedRandom as weightedRandom };
+  export type { random_RandomStringOptions as RandomStringOptions };
+}
+
+export { randomInt as a, randomFloat as b, randomItem as c, randomKey as d, randomValue as e, randomBoolean as f, randomString as g, randomHex as h, randomUUID as i, randomEnum as j, randomColor as k, randomDate as l, random as r, sample as s, weightedRandom as w };
+export type { RandomStringOptions as R };

package/dist/random-ihslkInn.mjs

@@ -0,0 +1,2 @@
+var b=Object.defineProperty;var n=(r,e)=>b(r,"name",{value:e,configurable:!0});const d=n((r,e)=>Math.floor(Math.random()*(e-r+1))+r,"randomInt"),h=n((r,e)=>Math.random()*(e-r)+r,"randomFloat"),m=n(r=>r[Math.floor(Math.random()*r.length)],"randomItem"),x=n(r=>m(Object.keys(r)),"randomKey"),u=n(r=>m(Array.isArray(r)?r:Object.values(r)),"randomValue"),g=n(()=>Math.random()<.5,"randomBoolean"),l=n((r,e)=>{const t=typeof e=="string"?e:n((a={})=>{const s=a.useUppercase!==void 0||a.useLowercase!==void 0||a.useNumeric!==void 0;return[a.useUppercase??!s?"ABCDEFGHIJKLMNOPQRSTUVWXYZ":"",a.useLowercase??!s?"abcdefghijklmnopqrstuvwxyz":"",a.useNumeric??!s?"0123456789":""].join("")},"resolveCharactersFromOptions")(e);if(t.length===0&&r>0)throw new Error("Character set cannot be empty");return r<=0?"":Array.from({length:r}).map(()=>t.charAt(d(0,t.length-1))).join("")},"randomString"),c=n((r=16)=>l(r,"0123456789abcdef"),"randomHex"),i=n(()=>"xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g,r=>{const e=Math.random()*16|0;return(r==="x"?e:e&3|8).toString(16)}),"randomUUID"),f=n((r,e)=>{if(e>r.length)throw new Error(`Cannot sample ${e} items from array of length ${r.length}`);if(e<=0)return[];const o=[],t=[...r];for(let a=0;a<e;a++){const s=d(0,t.length-1);o.push(t[s]),t.splice(s,1)}return o},"sample"),p=n((r,e)=>{if(r.length===0)return;if(r.length!==e.length)throw new Error("Items and weights arrays must have the same length");const o=e.reduce((a,s)=>a+s,0);if(o<=0)throw new Error("Total weight must be greater than 0");let t=Math.random()*o;for(let a=0;a<r.length;a++)if(t-=e[a],t<=0)return r[a];return r[r.length-1]},"weightedRandom"),y=n(r=>{const e=Object.keys(r).filter(o=>Number.isNaN(Number(o))).map(o=>r[o]);return m(e)},"randomEnum"),w=n(()=>`#${c(6)}`,"randomColor"),v=n((r,e)=>new Date(r.getTime()+Math.random()*(e.getTime()-r.getTime())),"randomDate");var M=Object.freeze({__proto__:null,randomBoolean:g,randomColor:w,randomDate:v,randomEnum:y,randomFloat:h,randomHex:c,randomInt:d,randomItem:m,randomKey:x,randomString:l,randomUUID:i,randomValue:u,sample:f,weightedRandom:p});export{d as a,h as b,m as c,x as d,u as e,g as f,l as g,c as h,i,y as j,w as k,v as l,M as r,f as s,p as w};
+//# sourceMappingURL=random-ihslkInn.mjs.map

package/dist/random-ihslkInn.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"random-ihslkInn.mjs","sources":["../src/utils/random.ts"],"sourcesContent":["/**\n * Generate a random integer between min and max (inclusive)\n * @param min - Minimum value\n * @param max - Maximum value\n * @returns Random integer\n * @example randomInt(1, 10) // Random integer from 1 to 10\n */\nconst randomInt = (min: number, max: number): number =>\n\tMath.floor(Math.random() * (max - min + 1)) + min;\n\n/**\n * Generate a random float between min and max\n * @param min - Minimum value\n * @param max - Maximum value\n * @returns Random float\n * @example randomFloat(1.0, 10.0) // Random float from 1.0 to 10.0\n */\nconst randomFloat = (min: number, max: number): number =>\n\tMath.random() * (max - min) + min;\n\n/**\n * Get a random item from an array\n * @param items - Array to pick from\n * @returns Random item or undefined if array is empty\n * @example randomItem([1, 2, 3]) // Could return 1, 2, or 3\n */\nconst randomItem = <T>(items: T[]): T | undefined =>\n\titems[Math.floor(Math.random() * items.length)];\n\n/**\n * Get a random key from an object or array\n * @param items - Object or array to pick from\n * @returns Random key or undefined\n * @example randomKey({a: 1, b: 2}) // Could return \"a\" or \"b\"\n */\nconst randomKey = <T>(items: Record<string, T> | T[]): string | undefined =>\n\trandomItem(Object.keys(items));\n\n/**\n * Get a random value from an object or array\n * @param items - Object or array to pick from\n * @returns Random value or undefined\n * @example randomValue({a: 1, b: 2}) // Could return 1 or 2\n */\nconst randomValue = <T>(items: Record<string, T> | T[]): T | undefined =>\n\trandomItem(Array.isArray(items) ? items : Object.values(items));\n\n/**\n * Generate a random boolean value\n * @returns Random true or false\n * @example randomBoolean() // Could return true or false with 50% probability each\n */\nconst randomBoolean = (): boolean => Math.random() < 0.5;\n\n/**\n * Generate a random string of specified length\n * @param length - Length of the string to generate\n * @param characters - Character set to use (string or options object)\n * @returns Random string\n * @example randomString(10) // Random 10-char string with uppercase, lowercase, and numbers\n * @example randomString(5, 'abc') // Random 5-char string using only 'a', 'b', 'c'\n * @example randomString(8, {useUppercase: true, useLowercase: false, useNumeric: false})\n */\nconst randomString = (\n\tlength: number,\n\tcharacters?: string | RandomStringOptions\n): string => {\n\tconst resolveCharactersFromOptions = (options: RandomStringOptions = {}) => {\n\t\t// Default to all character types if none specified\n\t\tconst hasAnyOption =\n\t\t\toptions.useUppercase !== undefined ||\n\t\t\toptions.useLowercase !== undefined ||\n\t\t\toptions.useNumeric !== undefined;\n\n\t\treturn [\n\t\t\t(options.useUppercase ?? !hasAnyOption)\n\t\t\t\t? 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'\n\t\t\t\t: '',\n\t\t\t(options.useLowercase ?? !hasAnyOption)\n\t\t\t\t? 'abcdefghijklmnopqrstuvwxyz'\n\t\t\t\t: '',\n\t\t\t(options.useNumeric ?? !hasAnyOption) ? '0123456789' : '',\n\t\t].join('');\n\t};\n\n\tconst resolvedCharacters =\n\t\ttypeof characters === 'string'\n\t\t\t? characters\n\t\t\t: resolveCharactersFromOptions(characters);\n\n\tif (resolvedCharacters.length === 0 && length > 0) {\n\t\tthrow new Error('Character set cannot be empty');\n\t}\n\n\tif (length <= 0) return '';\n\n\treturn Array.from({ length })\n\t\t.map(() =>\n\t\t\tresolvedCharacters.charAt(randomInt(0, resolvedCharacters.length - 1))\n\t\t)\n\t\t.join('');\n};\n\n/**\n * Generate a random hex string (lowercase)\n * @param length - Length of the hex string (default: 16)\n * @returns Random hex string\n * @example randomHex(8) // \"a3f5c9d1\"\n */\nconst randomHex = (length = 16): string => {\n\treturn randomString(length, '0123456789abcdef');\n};\n\n/**\n * Generate a UUID v4 (random)\n * @returns UUID string\n * @example randomUUID() // \"f47ac10b-58cc-4372-a567-0e02b2c3d479\"\n */\nconst randomUUID = (): string => {\n\treturn 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {\n\t\tconst r = (Math.random() * 16) | 0;\n\t\tconst v = c === 'x' ? r : (r & 0x3) | 0x8;\n\t\treturn v.toString(16);\n\t});\n};\n\n/**\n * Pick N random items from an array without replacement\n * @param items - Array to sample from\n * @param count - Number of items to pick\n * @returns Array of randomly selected items\n * @example sample([1, 2, 3, 4, 5], 3) // [2, 5, 1]\n */\nconst sample = <T>(items: T[], count: number): T[] => {\n\tif (count > items.length) {\n\t\tthrow new Error(\n\t\t\t`Cannot sample ${count} items from array of length ${items.length}`\n\t\t);\n\t}\n\tif (count <= 0) return [];\n\n\tconst result: T[] = [];\n\tconst copy = [...items];\n\n\tfor (let i = 0; i < count; i++) {\n\t\tconst index = randomInt(0, copy.length - 1);\n\t\tresult.push(copy[index]);\n\t\tcopy.splice(index, 1);\n\t}\n\n\treturn result;\n};\n\n/**\n * Pick a random item with weighted probabilities\n * @param items - Array of items\n * @param weights - Array of weights (must be same length as items)\n * @returns Random item based on weights\n * @example weightedRandom(['a', 'b', 'c'], [1, 2, 3]) // 'c' is 3x more likely than 'a'\n */\nconst weightedRandom = <T>(items: T[], weights: number[]): T | undefined => {\n\tif (items.length === 0) return undefined;\n\tif (items.length !== weights.length) {\n\t\tthrow new Error('Items and weights arrays must have the same length');\n\t}\n\n\tconst totalWeight = weights.reduce((sum, weight) => sum + weight, 0);\n\tif (totalWeight <= 0) {\n\t\tthrow new Error('Total weight must be greater than 0');\n\t}\n\n\tlet random = Math.random() * totalWeight;\n\n\tfor (let i = 0; i < items.length; i++) {\n\t\trandom -= weights[i];\n\t\tif (random <= 0) {\n\t\t\treturn items[i];\n\t\t}\n\t}\n\n\t// Fallback (should never reach here)\n\treturn items[items.length - 1];\n};\n\n/**\n * Get a random enum value\n * @param enumObj - Enum object\n * @returns Random enum value\n * @example enum Color { Red, Green, Blue }; randomEnum(Color) // Color.Green\n */\nconst randomEnum = <T extends Record<string, string | number>>(\n\tenumObj: T\n): T[keyof T] => {\n\t// Filter out numeric keys (reverse mappings in numeric enums)\n\tconst enumValues = Object.keys(enumObj)\n\t\t.filter((key) => Number.isNaN(Number(key)))\n\t\t.map((key) => enumObj[key]);\n\n\treturn randomItem(enumValues as T[keyof T][]) as T[keyof T];\n};\n\n/**\n * Generate a random hex color\n * @returns Random hex color string (e.g., \"#a3f5c9\")\n * @example randomColor() // \"#a3f5c9\"\n */\nconst randomColor = (): string => {\n\treturn `#${randomHex(6)}`;\n};\n\n/**\n * Generate a random date between two dates\n * @param start - Start date\n * @param end - End date\n * @returns Random date between start and end\n * @example randomDate(new Date(2020, 0, 1), new Date(2021, 0, 1))\n */\nconst randomDate = (start: Date, end: Date): Date => {\n\treturn new Date(\n\t\tstart.getTime() + Math.random() * (end.getTime() - start.getTime())\n\t);\n};\n\ntype RandomStringOptions = {\n\tuseNumeric?: boolean;\n\tuseLowercase?: boolean;\n\tuseUppercase?: boolean;\n};\n\nexport {\n\trandomInt,\n\trandomFloat,\n\trandomItem,\n\trandomKey,\n\trandomValue,\n\trandomBoolean,\n\trandomString,\n\trandomHex,\n\trandomUUID,\n\tsample,\n\tweightedRandom,\n\trandomEnum,\n\trandomColor,\n\trandomDate,\n\ttype RandomStringOptions,\n};\n"],"names":["randomInt","__name","min","max","randomFloat","randomItem","items","randomKey","randomValue","randomBoolean","randomString","length","characters","resolvedCharacters","options","hasAnyOption","randomHex","randomUUID","c","r","sample","count","result","copy","i","index","weightedRandom","weights","totalWeight","sum","weight","random","randomEnum","enumObj","enumValues","key","randomColor","randomDate","start","end"],"mappings":"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"}

package/dist/runtime-7fkN5_oL.d.cts

@@ -0,0 +1,206 @@
+/**
+ * Sleep for a specified number of milliseconds
+ * @param ms - Milliseconds to sleep
+ * @returns Promise that resolves after the specified time
+ * @example await sleep(1000) // Sleep for 1 second
+ */
+declare const sleep: (ms: number) => Promise<void>;
+/**
+ * Sleep until a condition becomes true
+ * @param condition - Function that returns true when ready to continue
+ * @param interval - How often to check the condition in ms (default: 1000)
+ * @returns Promise that resolves when condition is true
+ * @example await sleepUntil(() => dataLoaded, 500)
+ */
+declare const sleepUntil: (condition: () => boolean | Promise<boolean>, interval?: number) => Promise<void>;
+/**
+ * Sleep until a condition becomes true or timeout is reached
+ * @param condition - Function that returns true when ready to continue
+ * @param timeout - Maximum time to wait in ms
+ * @param interval - How often to check the condition in ms (default: 1000)
+ * @returns Promise that resolves when condition is true or timeout is reached
+ * @example await sleepUntilOrTimeout(() => dataLoaded, 5000, 500)
+ */
+declare const sleepUntilOrTimeout: (condition: () => boolean | Promise<boolean>, timeout: number, interval?: number) => Promise<void>;
+/**
+ * Race a promise against a timeout
+ * @param promise - Promise to await
+ * @param timeout - Timeout in milliseconds
+ * @returns Promise that resolves with the value or rejects on timeout
+ * @example await awaitOrTimeout(fetchData(), 5000)
+ */
+declare const awaitOrTimeout: <T>(promise: Promise<T>, timeout: number) => Promise<T>;
+/**
+ * Safely set a timeout that handles values larger than INT32_MAX
+ * @param timeoutMs - Timeout in milliseconds
+ * @param scheduleOverflowInFuture - Whether to schedule overflow timeouts automatically
+ * @param fn - Function to execute
+ * @param onNewTimeout - Callback when a new timeout is scheduled
+ * @returns Timeout handle
+ * @example safeSetTimeout(2147483648, true, () => console.log('Done'))
+ */
+declare const safeSetTimeout: (timeoutMs: number, scheduleOverflowInFuture: boolean, fn: () => void, onNewTimeout?: (timeout: NodeJS.Timeout, isTimeoutForRunFn: boolean) => void) => NodeJS.Timeout;
+/**
+ * Safely set an interval that handles values larger than INT32_MAX
+ * @param intervalMs - Interval in milliseconds
+ * @param fn - Function to execute
+ * @param onNewTimeout - Callback when a new timeout is scheduled
+ * @returns Timeout handle
+ * @example safeSetInterval(2147483648, () => console.log('Tick'))
+ */
+declare const safeSetInterval: (intervalMs: number, fn: () => void, onNewTimeout?: (timeout: NodeJS.Timeout, isTimeoutForRunFn: boolean) => void) => NodeJS.Timeout;
+/**
+ * Safely set an async interval that handles values larger than INT32_MAX
+ * @param intervalMs - Interval in milliseconds
+ * @param fn - Async function to execute
+ * @param onNewTimeout - Callback when a new timeout is scheduled
+ * @returns Timeout handle
+ * @example safeSetAsyncInterval(2147483648, async () => await doWork())
+ */
+declare const safeSetAsyncInterval: (intervalMs: number, fn: () => Promise<void>, onNewTimeout?: (timeout: NodeJS.Timeout, isTimeoutForRunFn: boolean) => void) => NodeJS.Timeout;
+/**
+ * Result of a batch operation
+ */
+type BatchResult<T> = {
+    /** Successfully processed results */
+    results: T[];
+    /** Errors that occurred during processing */
+    errors: Array<{
+        index: number;
+        error: Error;
+    }>;
+    /** Total number of tasks */
+    total: number;
+    /** Number of successful tasks */
+    successful: number;
+    /** Number of failed tasks */
+    failed: number;
+};
+/**
+ * Options for batch processing
+ */
+interface BatchProcessOptions {
+    /** Maximum number of concurrent executions (default: 5) */
+    concurrency?: number;
+    /** Whether to stop on first error (default: false) */
+    stopOnError?: boolean;
+    /** Timeout per task in milliseconds (default: none) */
+    taskTimeout?: number;
+    /** Delay between batches in milliseconds (default: 0) */
+    batchDelay?: number;
+    /** Callback for progress updates */
+    onProgress?: (completed: number, total: number) => void;
+    /** Callback for each error */
+    onError?: (error: Error, index: number) => void;
+}
+/**
+ * Options for batch processing with retry
+ */
+interface BatchProcessWithRetryOptions extends BatchProcessOptions {
+    /** Maximum number of retry attempts (default: 3) */
+    maxRetries?: number;
+    /** Delay between retries in milliseconds (default: 1000) */
+    retryDelay?: number;
+    /** Backoff multiplier for retry delay (default: 2) */
+    retryBackoff?: number;
+}
+/**
+ * Execute async tasks with controlled concurrency
+ * @param tasks - Array of async functions to execute
+ * @param concurrency - Maximum number of concurrent executions (default: 5)
+ * @returns Array of results in the same order as input tasks
+ * @throws Error if any task fails (use batchProcess for error handling)
+ * @example
+ * const results = await executeWithConcurrency(
+ *   urls.map(url => () => fetch(url)),
+ *   3
+ * );
+ */
+declare function executeWithConcurrency<T>(tasks: (() => Promise<T>)[], concurrency?: number): Promise<T[]>;
+/**
+ * Process tasks in batches with advanced error handling and progress tracking
+ * @param tasks - Array of async functions to execute
+ * @param options - Batch processing options
+ * @returns BatchResult with results and error information
+ * @example
+ * const result = await batchProcess(
+ *   urls.map(url => () => fetchData(url)),
+ *   {
+ *     concurrency: 3,
+ *     stopOnError: false,
+ *     onProgress: (done, total) => console.log(`${done}/${total}`)
+ *   }
+ * );
+ */
+declare function batchProcess<T>(tasks: (() => Promise<T>)[], options?: BatchProcessOptions): Promise<BatchResult<T>>;
+/**
+ * Map over an array with controlled concurrency
+ * @param items - Array of items to process
+ * @param mapper - Async function to transform each item
+ * @param concurrency - Maximum number of concurrent executions (default: 5)
+ * @returns Array of transformed results in the same order
+ * @throws Error if any transformation fails
+ * @example
+ * const users = await batchMap(
+ *   userIds,
+ *   async (id) => await fetchUser(id),
+ *   3
+ * );
+ */
+declare function batchMap<T, R>(items: T[], mapper: (item: T, index: number) => Promise<R>, concurrency?: number): Promise<R[]>;
+/**
+ * Map over an array with controlled concurrency and retry logic
+ * @param items - Array of items to process
+ * @param mapper - Async function to transform each item
+ * @param options - Batch processing options with retry configuration
+ * @returns BatchResult with results and error information
+ * @example
+ * const result = await batchMapWithRetry(
+ *   userIds,
+ *   async (id) => await fetchUser(id),
+ *   {
+ *     concurrency: 3,
+ *     maxRetries: 3,
+ *     retryDelay: 1000,
+ *     stopOnError: false
+ *   }
+ * );
+ */
+declare function batchMapWithRetry<T, R>(items: T[], mapper: (item: T, index: number) => Promise<R>, options?: BatchProcessWithRetryOptions): Promise<BatchResult<R>>;
+/**
+ * Process items in chunks/batches sequentially
+ * @param items - Array of items to process
+ * @param batchSize - Number of items per batch
+ * @param processor - Function to process each batch
+ * @returns Array of batch results
+ * @example
+ * const results = await processBatches(
+ *   allUsers,
+ *   100,
+ *   async (batch) => await bulkInsert(batch)
+ * );
+ */
+declare function processBatches<T, R>(items: T[], batchSize: number, processor: (batch: T[], batchIndex: number) => Promise<R>): Promise<R[]>;
+
+type runtime_BatchProcessOptions = BatchProcessOptions;
+type runtime_BatchProcessWithRetryOptions = BatchProcessWithRetryOptions;
+type runtime_BatchResult<T> = BatchResult<T>;
+declare const runtime_awaitOrTimeout: typeof awaitOrTimeout;
+declare const runtime_batchMap: typeof batchMap;
+declare const runtime_batchMapWithRetry: typeof batchMapWithRetry;
+declare const runtime_batchProcess: typeof batchProcess;
+declare const runtime_executeWithConcurrency: typeof executeWithConcurrency;
+declare const runtime_processBatches: typeof processBatches;
+declare const runtime_safeSetAsyncInterval: typeof safeSetAsyncInterval;
+declare const runtime_safeSetInterval: typeof safeSetInterval;
+declare const runtime_safeSetTimeout: typeof safeSetTimeout;
+declare const runtime_sleep: typeof sleep;
+declare const runtime_sleepUntil: typeof sleepUntil;
+declare const runtime_sleepUntilOrTimeout: typeof sleepUntilOrTimeout;
+declare namespace runtime {
+  export { runtime_awaitOrTimeout as awaitOrTimeout, runtime_batchMap as batchMap, runtime_batchMapWithRetry as batchMapWithRetry, runtime_batchProcess as batchProcess, runtime_executeWithConcurrency as executeWithConcurrency, runtime_processBatches as processBatches, runtime_safeSetAsyncInterval as safeSetAsyncInterval, runtime_safeSetInterval as safeSetInterval, runtime_safeSetTimeout as safeSetTimeout, runtime_sleep as sleep, runtime_sleepUntil as sleepUntil, runtime_sleepUntilOrTimeout as sleepUntilOrTimeout };
+  export type { runtime_BatchProcessOptions as BatchProcessOptions, runtime_BatchProcessWithRetryOptions as BatchProcessWithRetryOptions, runtime_BatchResult as BatchResult };
+}
+
+export { sleepUntil as a, sleepUntilOrTimeout as b, awaitOrTimeout as c, safeSetTimeout as d, safeSetInterval as e, safeSetAsyncInterval as f, executeWithConcurrency as g, batchProcess as h, batchMap as i, batchMapWithRetry as j, processBatches as p, runtime as r, sleep as s };
+export type { BatchResult as B, BatchProcessOptions as k, BatchProcessWithRetryOptions as l };