superjs-core 0.1.0

package/dist/async/index.d.ts

@@ -0,0 +1,44 @@
+import { RetryOptions } from '../core/index.js';
+
+/**
+ * Delays execution for the given number of milliseconds.
+ */
+declare function sleep(ms: number): Promise<void>;
+/**
+ * Rejects a promise if it does not resolve within the specified timeout.
+ */
+declare function timeout<T>(promise: Promise<T>, ms: number, errorMessage?: string): Promise<T>;
+/**
+ * Races a promise against a timeout, returning 'timeout' if the timer wins.
+ */
+declare function raceWithTimeout<T>(promise: Promise<T>, ms: number): Promise<T | 'timeout'>;
+/**
+ * Maps over an array with an async function, using Promise.allSettled.
+ * Returns an array of PromiseSettledResult.
+ */
+declare function allSettledMap<T, R>(items: T[], fn: (item: T) => Promise<R>): Promise<PromiseSettledResult<R>[]>;
+/**
+ * Maps over an array with an async function, limiting concurrency.
+ *
+ * @param concurrency - Maximum number of concurrent operations (default Infinity)
+ */
+declare function parallelMap<T, R>(items: T[], fn: (item: T) => Promise<R>, concurrency?: number): Promise<R[]>;
+/**
+ * Retries an async function with exponential backoff.
+ */
+declare function retryAsync<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
+/**
+ * Composes async functions, passing the result of each to the next.
+ */
+declare function pipeline<T>(initial: T, ...fns: Array<(arg: T) => Promise<T>>): Promise<T>;
+/**
+ * Creates a deferred promise with external resolve and reject methods.
+ */
+declare function deferred<T>(): Deferred<T>;
+interface Deferred<T> {
+    promise: Promise<T>;
+    resolve: (value: T) => void;
+    reject: (reason: unknown) => void;
+}
+
+export { type Deferred, allSettledMap, deferred, parallelMap, pipeline, raceWithTimeout, retryAsync, sleep, timeout };

package/dist/async/index.js

@@ -0,0 +1,88 @@
+// src/async/index.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function timeout(promise, ms, errorMessage) {
+  let timer;
+  const timeoutPromise = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error(errorMessage ?? `Promise timed out after ${ms}ms`)), ms);
+  });
+  try {
+    return await Promise.race([promise, timeoutPromise]);
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+  }
+}
+async function raceWithTimeout(promise, ms) {
+  let timer;
+  const timeoutPromise = new Promise((resolve) => {
+    timer = setTimeout(() => resolve("timeout"), ms);
+  });
+  try {
+    return await Promise.race([promise, timeoutPromise]);
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+  }
+}
+async function allSettledMap(items, fn) {
+  return await Promise.allSettled(items.map(fn));
+}
+async function parallelMap(items, fn, concurrency = Number.POSITIVE_INFINITY) {
+  if (concurrency === Number.POSITIVE_INFINITY) {
+    return await Promise.all(items.map(fn));
+  }
+  const results = [];
+  const queue = [...items];
+  const worker = async () => {
+    while (queue.length > 0) {
+      const item = queue.shift();
+      results.push(await fn(item));
+    }
+  };
+  const workerCount = Math.min(concurrency, items.length);
+  const workers = Array.from({ length: workerCount }, () => worker());
+  await Promise.all(workers);
+  return results;
+}
+async function retryAsync(fn, options) {
+  const { attempts = 3, baseDelay = 1e3, maxDelay = 3e4, shouldRetry = () => true } = options ?? {};
+  let lastError;
+  for (let attempt = 0; attempt < attempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (!shouldRetry(error) || attempt >= attempts - 1) break;
+      const delay = Math.min(baseDelay * 2 ** attempt + Math.random() * baseDelay, maxDelay);
+      await sleep(delay);
+    }
+  }
+  throw lastError;
+}
+async function pipeline(initial, ...fns) {
+  let result = initial;
+  for (const fn of fns) {
+    result = await fn(result);
+  }
+  return result;
+}
+function deferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+export {
+  allSettledMap,
+  deferred,
+  parallelMap,
+  pipeline,
+  raceWithTimeout,
+  retryAsync,
+  sleep,
+  timeout
+};
+//# sourceMappingURL=index.js.map

package/dist/async/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/async/index.ts"],"sourcesContent":["import type { RetryOptions } from '../core/index.js'\n\n/**\n * Delays execution for the given number of milliseconds.\n */\nexport function sleep(ms: number): Promise<void> {\n  return new Promise(resolve => setTimeout(resolve, ms))\n}\n\n/**\n * Rejects a promise if it does not resolve within the specified timeout.\n */\nexport async function timeout<T>(promise: Promise<T>, ms: number, errorMessage?: string): Promise<T> {\n  let timer: ReturnType<typeof setTimeout> | undefined\n  const timeoutPromise = new Promise<never>((_, reject) => {\n    timer = setTimeout(() => reject(new Error(errorMessage ?? `Promise timed out after ${ms}ms`)), ms)\n  })\n  try {\n    return await Promise.race([promise, timeoutPromise])\n  } finally {\n    if (timer !== undefined) clearTimeout(timer)\n  }\n}\n\n/**\n * Races a promise against a timeout, returning 'timeout' if the timer wins.\n */\nexport async function raceWithTimeout<T>(promise: Promise<T>, ms: number): Promise<T | 'timeout'> {\n  let timer: ReturnType<typeof setTimeout> | undefined\n  const timeoutPromise = new Promise<'timeout'>(resolve => {\n    timer = setTimeout(() => resolve('timeout'), ms)\n  })\n  try {\n    return await Promise.race([promise, timeoutPromise])\n  } finally {\n    if (timer !== undefined) clearTimeout(timer)\n  }\n}\n\n/**\n * Maps over an array with an async function, using Promise.allSettled.\n * Returns an array of PromiseSettledResult.\n */\nexport async function allSettledMap<T, R>(\n  items: T[],\n  fn: (item: T) => Promise<R>,\n): Promise<PromiseSettledResult<R>[]> {\n  return await Promise.allSettled(items.map(fn))\n}\n\n/**\n * Maps over an array with an async function, limiting concurrency.\n *\n * @param concurrency - Maximum number of concurrent operations (default Infinity)\n */\nexport async function parallelMap<T, R>(\n  items: T[],\n  fn: (item: T) => Promise<R>,\n  concurrency = Number.POSITIVE_INFINITY,\n): Promise<R[]> {\n  if (concurrency === Number.POSITIVE_INFINITY) {\n    return await Promise.all(items.map(fn))\n  }\n\n  const results: R[] = []\n  const queue = [...items]\n\n  const worker = async (): Promise<void> => {\n    while (queue.length > 0) {\n      const item = queue.shift()!\n      results.push(await fn(item))\n    }\n  }\n\n  const workerCount = Math.min(concurrency, items.length)\n  const workers = Array.from({ length: workerCount }, () => worker())\n  await Promise.all(workers)\n  return results\n}\n\n/**\n * Retries an async function with exponential backoff.\n */\nexport async function retryAsync<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T> {\n  const { attempts = 3, baseDelay = 1000, maxDelay = 30000, shouldRetry = () => true } = options ?? {}\n  let lastError: unknown\n  for (let attempt = 0; attempt < attempts; attempt++) {\n    try {\n      return await fn()\n    } catch (error) {\n      lastError = error\n      if (!shouldRetry(error) || attempt >= attempts - 1) break\n      const delay = Math.min(baseDelay * 2 ** attempt + Math.random() * baseDelay, maxDelay)\n      await sleep(delay)\n    }\n  }\n  throw lastError\n}\n\n/**\n * Composes async functions, passing the result of each to the next.\n */\nexport async function pipeline<T>(initial: T, ...fns: Array<(arg: T) => Promise<T>>): Promise<T> {\n  let result = initial\n  for (const fn of fns) {\n    result = await fn(result)\n  }\n  return result\n}\n\n/**\n * Creates a deferred promise with external resolve and reject methods.\n */\nexport function deferred<T>(): Deferred<T> {\n  let resolve!: (value: T) => void\n  let reject!: (reason: unknown) => void\n  const promise = new Promise<T>((res, rej) => {\n    resolve = res\n    reject = rej\n  })\n  return { promise, resolve, reject }\n}\n\nexport interface Deferred<T> {\n  promise: Promise<T>\n  resolve: (value: T) => void\n  reject: (reason: unknown) => void\n}\n"],"mappings":";AAKO,SAAS,MAAM,IAA2B;AAC/C,SAAO,IAAI,QAAQ,aAAW,WAAW,SAAS,EAAE,CAAC;AACvD;AAKA,eAAsB,QAAW,SAAqB,IAAY,cAAmC;AACnG,MAAI;AACJ,QAAM,iBAAiB,IAAI,QAAe,CAAC,GAAG,WAAW;AACvD,YAAQ,WAAW,MAAM,OAAO,IAAI,MAAM,gBAAgB,2BAA2B,EAAE,IAAI,CAAC,GAAG,EAAE;AAAA,EACnG,CAAC;AACD,MAAI;AACF,WAAO,MAAM,QAAQ,KAAK,CAAC,SAAS,cAAc,CAAC;AAAA,EACrD,UAAE;AACA,QAAI,UAAU,OAAW,cAAa,KAAK;AAAA,EAC7C;AACF;AAKA,eAAsB,gBAAmB,SAAqB,IAAoC;AAChG,MAAI;AACJ,QAAM,iBAAiB,IAAI,QAAmB,aAAW;AACvD,YAAQ,WAAW,MAAM,QAAQ,SAAS,GAAG,EAAE;AAAA,EACjD,CAAC;AACD,MAAI;AACF,WAAO,MAAM,QAAQ,KAAK,CAAC,SAAS,cAAc,CAAC;AAAA,EACrD,UAAE;AACA,QAAI,UAAU,OAAW,cAAa,KAAK;AAAA,EAC7C;AACF;AAMA,eAAsB,cACpB,OACA,IACoC;AACpC,SAAO,MAAM,QAAQ,WAAW,MAAM,IAAI,EAAE,CAAC;AAC/C;AAOA,eAAsB,YACpB,OACA,IACA,cAAc,OAAO,mBACP;AACd,MAAI,gBAAgB,OAAO,mBAAmB;AAC5C,WAAO,MAAM,QAAQ,IAAI,MAAM,IAAI,EAAE,CAAC;AAAA,EACxC;AAEA,QAAM,UAAe,CAAC;AACtB,QAAM,QAAQ,CAAC,GAAG,KAAK;AAEvB,QAAM,SAAS,YAA2B;AACxC,WAAO,MAAM,SAAS,GAAG;AACvB,YAAM,OAAO,MAAM,MAAM;AACzB,cAAQ,KAAK,MAAM,GAAG,IAAI,CAAC;AAAA,IAC7B;AAAA,EACF;AAEA,QAAM,cAAc,KAAK,IAAI,aAAa,MAAM,MAAM;AACtD,QAAM,UAAU,MAAM,KAAK,EAAE,QAAQ,YAAY,GAAG,MAAM,OAAO,CAAC;AAClE,QAAM,QAAQ,IAAI,OAAO;AACzB,SAAO;AACT;AAKA,eAAsB,WAAc,IAAsB,SAAoC;AAC5F,QAAM,EAAE,WAAW,GAAG,YAAY,KAAM,WAAW,KAAO,cAAc,MAAM,KAAK,IAAI,WAAW,CAAC;AACnG,MAAI;AACJ,WAAS,UAAU,GAAG,UAAU,UAAU,WAAW;AACnD,QAAI;AACF,aAAO,MAAM,GAAG;AAAA,IAClB,SAAS,OAAO;AACd,kBAAY;AACZ,UAAI,CAAC,YAAY,KAAK,KAAK,WAAW,WAAW,EAAG;AACpD,YAAM,QAAQ,KAAK,IAAI,YAAY,KAAK,UAAU,KAAK,OAAO,IAAI,WAAW,QAAQ;AACrF,YAAM,MAAM,KAAK;AAAA,IACnB;AAAA,EACF;AACA,QAAM;AACR;AAKA,eAAsB,SAAY,YAAe,KAAgD;AAC/F,MAAI,SAAS;AACb,aAAW,MAAM,KAAK;AACpB,aAAS,MAAM,GAAG,MAAM;AAAA,EAC1B;AACA,SAAO;AACT;AAKO,SAAS,WAA2B;AACzC,MAAI;AACJ,MAAI;AACJ,QAAM,UAAU,IAAI,QAAW,CAAC,KAAK,QAAQ;AAC3C,cAAU;AACV,aAAS;AAAA,EACX,CAAC;AACD,SAAO,EAAE,SAAS,SAAS,OAAO;AACpC;","names":[]}

package/dist/collection/index.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Groups an array of items by a key extracted from each item.
+ *
+ * @example groupBy([{ type: 'a' }, { type: 'b' }, { type: 'a' }], x => x.type)
+ *          // => { a: [{ type: 'a' }, { type: 'a' }], b: [{ type: 'b' }] }
+ */
+declare function groupBy<T, K extends string | number | symbol>(items: T[], keyFn: (item: T) => K): Record<K, T[]>;
+/**
+ * Creates an object keyed by the result of keyFn for each item.
+ *
+ * @example keyBy([{ id: 1, name: 'a' }, { id: 2, name: 'b' }], x => x.id)
+ *          // => { 1: { id: 1, name: 'a' }, 2: { id: 2, name: 'b' } }
+ */
+declare function keyBy<T, K extends string | number | symbol>(items: T[], keyFn: (item: T) => K): Record<K, T>;
+/**
+ * Returns a copy of the object with the specified keys omitted.
+ */
+declare function omit<T extends Record<string, unknown>, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;
+/**
+ * Returns a copy of the object with only the specified keys.
+ */
+declare function pick<T extends Record<string, unknown>, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;
+/**
+ * Extracts a property value from each item in an array.
+ */
+declare function pluck<T, K extends keyof T>(items: T[], key: K): T[K][];
+/**
+ * Randomizes array order in-place using the Fisher-Yates algorithm.
+ */
+declare function shuffle<T>(items: T[]): T[];
+/**
+ * Returns a random element from the array, or undefined if empty.
+ */
+declare function sample<T>(items: T[]): T | undefined;
+/**
+ * Returns an array of `size` random elements (without duplicates).
+ */
+declare function sampleSize<T>(items: T[], size: number): T[];
+/**
+ * Splits an array into chunks of the specified size.
+ */
+declare function chunk<T>(items: T[], size: number): T[][];
+declare function sortBy<T>(items: T[], ...criteria: Array<(item: T) => unknown>): T[];
+/**
+ * Returns a sorted copy of the array by a single key and direction.
+ */
+declare function orderBy<T>(items: T[], key: (item: T) => unknown, direction?: SortDirection): T[];
+/**
+ * Returns unique elements based on the result of keyFn.
+ */
+declare function uniqueBy<T>(items: T[], keyFn: (item: T) => unknown): T[];
+/**
+ * Flattens an array of arrays one level.
+ */
+declare function flatten<T>(items: T[][]): T[];
+/**
+ * Returns an array with unique primitive values.
+ */
+declare function uniq<T>(items: T[]): T[];
+/**
+ * Returns the first element, or undefined if empty.
+ */
+declare function first<T>(items: T[]): T | undefined;
+/**
+ * Returns the last element, or undefined if empty.
+ */
+declare function last<T>(items: T[]): T | undefined;
+/**
+ * Checks if a value is empty.
+ * Works for arrays, objects, strings, Map, and Set.
+ */
+declare function isEmpty(value: unknown): boolean;
+type SortDirection = 'asc' | 'desc';
+
+export { type SortDirection, chunk, first, flatten, groupBy, isEmpty, keyBy, last, omit, orderBy, pick, pluck, sample, sampleSize, shuffle, sortBy, uniq, uniqueBy };

package/dist/collection/index.js

@@ -0,0 +1,140 @@
+// src/collection/index.ts
+function groupBy(items, keyFn) {
+  const result = {};
+  for (const item of items) {
+    const key = keyFn(item);
+    if (!result[key]) result[key] = [];
+    result[key].push(item);
+  }
+  return result;
+}
+function keyBy(items, keyFn) {
+  const result = {};
+  for (const item of items) {
+    const key = keyFn(item);
+    result[key] = item;
+  }
+  return result;
+}
+function omit(obj, keys) {
+  const result = { ...obj };
+  for (const key of keys) {
+    delete result[key];
+  }
+  return result;
+}
+function pick(obj, keys) {
+  const result = {};
+  for (const key of keys) {
+    if (key in obj) {
+      result[key] = obj[key];
+    }
+  }
+  return result;
+}
+function pluck(items, key) {
+  return items.map((item) => item[key]);
+}
+function shuffle(items) {
+  const result = [...items];
+  for (let i = result.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    const temp = result[i];
+    result[i] = result[j];
+    result[j] = temp;
+  }
+  return result;
+}
+function sample(items) {
+  return items.length > 0 ? items[Math.floor(Math.random() * items.length)] : void 0;
+}
+function sampleSize(items, size) {
+  if (size <= 0 || items.length === 0) return [];
+  const pool = shuffle(items);
+  return pool.slice(0, Math.min(size, items.length));
+}
+function chunk(items, size) {
+  if (size <= 0 || items.length === 0) return [];
+  const result = [];
+  for (let i = 0; i < items.length; i += size) {
+    result.push(items.slice(i, i + size));
+  }
+  return result;
+}
+function compareValues(a, b) {
+  if (a === b) return 0;
+  if (a == null) return -1;
+  if (b == null) return 1;
+  if (typeof a === "string" && typeof b === "string") return a < b ? -1 : 1;
+  if (typeof a === "number" && typeof b === "number") return a < b ? -1 : 1;
+  return String(a) < String(b) ? -1 : 1;
+}
+function sortBy(items, ...criteria) {
+  return [...items].sort((a, b) => {
+    for (const criterion of criteria) {
+      const cmp = compareValues(criterion(a), criterion(b));
+      if (cmp !== 0) return cmp;
+    }
+    return 0;
+  });
+}
+function orderBy(items, key, direction = "asc") {
+  return [...items].sort((a, b) => {
+    const cmp = compareValues(key(a), key(b));
+    return direction === "asc" ? cmp : -cmp;
+  });
+}
+function uniqueBy(items, keyFn) {
+  const seen = /* @__PURE__ */ new Set();
+  return items.filter((item) => {
+    const key = keyFn(item);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function flatten(items) {
+  const result = [];
+  for (const sub of items) {
+    for (const item of sub) {
+      result.push(item);
+    }
+  }
+  return result;
+}
+function uniq(items) {
+  return [...new Set(items)];
+}
+function first(items) {
+  return items[0];
+}
+function last(items) {
+  return items[items.length - 1];
+}
+function isEmpty(value) {
+  if (Array.isArray(value)) return value.length === 0;
+  if (typeof value === "string") return value.length === 0;
+  if (value instanceof Map || value instanceof Set) return value.size === 0;
+  if (value !== null && typeof value === "object") return Object.keys(value).length === 0;
+  return false;
+}
+export {
+  chunk,
+  first,
+  flatten,
+  groupBy,
+  isEmpty,
+  keyBy,
+  last,
+  omit,
+  orderBy,
+  pick,
+  pluck,
+  sample,
+  sampleSize,
+  shuffle,
+  sortBy,
+  uniq,
+  uniqueBy
+};
+//# sourceMappingURL=index.js.map

package/dist/collection/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/collection/index.ts"],"sourcesContent":["/**\n * Groups an array of items by a key extracted from each item.\n *\n * @example groupBy([{ type: 'a' }, { type: 'b' }, { type: 'a' }], x => x.type)\n *          // => { a: [{ type: 'a' }, { type: 'a' }], b: [{ type: 'b' }] }\n */\nexport function groupBy<T, K extends string | number | symbol>(items: T[], keyFn: (item: T) => K): Record<K, T[]> {\n  const result = {} as Record<K, T[]>\n  for (const item of items) {\n    const key = keyFn(item)\n    if (!result[key]) result[key] = []\n    result[key]!.push(item)\n  }\n  return result\n}\n\n/**\n * Creates an object keyed by the result of keyFn for each item.\n *\n * @example keyBy([{ id: 1, name: 'a' }, { id: 2, name: 'b' }], x => x.id)\n *          // => { 1: { id: 1, name: 'a' }, 2: { id: 2, name: 'b' } }\n */\nexport function keyBy<T, K extends string | number | symbol>(items: T[], keyFn: (item: T) => K): Record<K, T> {\n  const result = {} as Record<K, T>\n  for (const item of items) {\n    const key = keyFn(item)\n    result[key] = item\n  }\n  return result\n}\n\n/**\n * Returns a copy of the object with the specified keys omitted.\n */\nexport function omit<T extends Record<string, unknown>, K extends keyof T>(obj: T, keys: K[]): Omit<T, K> {\n  const result = { ...obj } as T\n  for (const key of keys) {\n    delete result[key]\n  }\n  return result as Omit<T, K>\n}\n\n/**\n * Returns a copy of the object with only the specified keys.\n */\nexport function pick<T extends Record<string, unknown>, K extends keyof T>(obj: T, keys: K[]): Pick<T, K> {\n  const result = {} as Pick<T, K>\n  for (const key of keys) {\n    if (key in obj) {\n      result[key] = obj[key]\n    }\n  }\n  return result\n}\n\n/**\n * Extracts a property value from each item in an array.\n */\nexport function pluck<T, K extends keyof T>(items: T[], key: K): T[K][] {\n  return items.map(item => item[key])\n}\n\n/**\n * Randomizes array order in-place using the Fisher-Yates algorithm.\n */\nexport function shuffle<T>(items: T[]): T[] {\n  const result = [...items]\n  for (let i = result.length - 1; i > 0; i--) {\n    const j = Math.floor(Math.random() * (i + 1))\n    const temp = result[i]!\n    result[i] = result[j]!\n    result[j] = temp\n  }\n  return result\n}\n\n/**\n * Returns a random element from the array, or undefined if empty.\n */\nexport function sample<T>(items: T[]): T | undefined {\n  return items.length > 0 ? items[Math.floor(Math.random() * items.length)] : undefined\n}\n\n/**\n * Returns an array of `size` random elements (without duplicates).\n */\nexport function sampleSize<T>(items: T[], size: number): T[] {\n  if (size <= 0 || items.length === 0) return []\n  const pool = shuffle(items)\n  return pool.slice(0, Math.min(size, items.length))\n}\n\n/**\n * Splits an array into chunks of the specified size.\n */\nexport function chunk<T>(items: T[], size: number): T[][] {\n  if (size <= 0 || items.length === 0) return []\n  const result: T[][] = []\n  for (let i = 0; i < items.length; i += size) {\n    result.push(items.slice(i, i + size))\n  }\n  return result\n}\n\n/**\n * Returns a sorted copy of the array using the provided criteria functions.\n * Earlier criteria take precedence.\n */\nfunction compareValues(a: unknown, b: unknown): number {\n  if (a === b) return 0\n  if (a == null) return -1\n  if (b == null) return 1\n  if (typeof a === 'string' && typeof b === 'string') return a < b ? -1 : 1\n  if (typeof a === 'number' && typeof b === 'number') return a < b ? -1 : 1\n  return String(a) < String(b) ? -1 : 1\n}\n\nexport function sortBy<T>(items: T[], ...criteria: Array<(item: T) => unknown>): T[] {\n  return [...items].sort((a, b) => {\n    for (const criterion of criteria) {\n      const cmp = compareValues(criterion(a), criterion(b))\n      if (cmp !== 0) return cmp\n    }\n    return 0\n  })\n}\n\n/**\n * Returns a sorted copy of the array by a single key and direction.\n */\nexport function orderBy<T>(items: T[], key: (item: T) => unknown, direction: SortDirection = 'asc'): T[] {\n  return [...items].sort((a, b) => {\n    const cmp = compareValues(key(a), key(b))\n    return direction === 'asc' ? cmp : -cmp\n  })\n}\n\n/**\n * Returns unique elements based on the result of keyFn.\n */\nexport function uniqueBy<T>(items: T[], keyFn: (item: T) => unknown): T[] {\n  const seen = new Set<unknown>()\n  return items.filter(item => {\n    const key = keyFn(item)\n    if (seen.has(key)) return false\n    seen.add(key)\n    return true\n  })\n}\n\n/**\n * Flattens an array of arrays one level.\n */\nexport function flatten<T>(items: T[][]): T[] {\n  const result: T[] = []\n  for (const sub of items) {\n    for (const item of sub) {\n      result.push(item)\n    }\n  }\n  return result\n}\n\n/**\n * Returns an array with unique primitive values.\n */\nexport function uniq<T>(items: T[]): T[] {\n  return [...new Set(items)]\n}\n\n/**\n * Returns the first element, or undefined if empty.\n */\nexport function first<T>(items: T[]): T | undefined {\n  return items[0]\n}\n\n/**\n * Returns the last element, or undefined if empty.\n */\nexport function last<T>(items: T[]): T | undefined {\n  return items[items.length - 1]\n}\n\n/**\n * Checks if a value is empty.\n * Works for arrays, objects, strings, Map, and Set.\n */\nexport function isEmpty(value: unknown): boolean {\n  if (Array.isArray(value)) return value.length === 0\n  if (typeof value === 'string') return value.length === 0\n  if (value instanceof Map || value instanceof Set) return value.size === 0\n  if (value !== null && typeof value === 'object') return Object.keys(value as Record<string, unknown>).length === 0\n  return false\n}\n\nexport type SortDirection = 'asc' | 'desc'\n"],"mappings":";AAMO,SAAS,QAA+C,OAAY,OAAuC;AAChH,QAAM,SAAS,CAAC;AAChB,aAAW,QAAQ,OAAO;AACxB,UAAM,MAAM,MAAM,IAAI;AACtB,QAAI,CAAC,OAAO,GAAG,EAAG,QAAO,GAAG,IAAI,CAAC;AACjC,WAAO,GAAG,EAAG,KAAK,IAAI;AAAA,EACxB;AACA,SAAO;AACT;AAQO,SAAS,MAA6C,OAAY,OAAqC;AAC5G,QAAM,SAAS,CAAC;AAChB,aAAW,QAAQ,OAAO;AACxB,UAAM,MAAM,MAAM,IAAI;AACtB,WAAO,GAAG,IAAI;AAAA,EAChB;AACA,SAAO;AACT;AAKO,SAAS,KAA2D,KAAQ,MAAuB;AACxG,QAAM,SAAS,EAAE,GAAG,IAAI;AACxB,aAAW,OAAO,MAAM;AACtB,WAAO,OAAO,GAAG;AAAA,EACnB;AACA,SAAO;AACT;AAKO,SAAS,KAA2D,KAAQ,MAAuB;AACxG,QAAM,SAAS,CAAC;AAChB,aAAW,OAAO,MAAM;AACtB,QAAI,OAAO,KAAK;AACd,aAAO,GAAG,IAAI,IAAI,GAAG;AAAA,IACvB;AAAA,EACF;AACA,SAAO;AACT;AAKO,SAAS,MAA4B,OAAY,KAAgB;AACtE,SAAO,MAAM,IAAI,UAAQ,KAAK,GAAG,CAAC;AACpC;AAKO,SAAS,QAAW,OAAiB;AAC1C,QAAM,SAAS,CAAC,GAAG,KAAK;AACxB,WAAS,IAAI,OAAO,SAAS,GAAG,IAAI,GAAG,KAAK;AAC1C,UAAM,IAAI,KAAK,MAAM,KAAK,OAAO,KAAK,IAAI,EAAE;AAC5C,UAAM,OAAO,OAAO,CAAC;AACrB,WAAO,CAAC,IAAI,OAAO,CAAC;AACpB,WAAO,CAAC,IAAI;AAAA,EACd;AACA,SAAO;AACT;AAKO,SAAS,OAAU,OAA2B;AACnD,SAAO,MAAM,SAAS,IAAI,MAAM,KAAK,MAAM,KAAK,OAAO,IAAI,MAAM,MAAM,CAAC,IAAI;AAC9E;AAKO,SAAS,WAAc,OAAY,MAAmB;AAC3D,MAAI,QAAQ,KAAK,MAAM,WAAW,EAAG,QAAO,CAAC;AAC7C,QAAM,OAAO,QAAQ,KAAK;AAC1B,SAAO,KAAK,MAAM,GAAG,KAAK,IAAI,MAAM,MAAM,MAAM,CAAC;AACnD;AAKO,SAAS,MAAS,OAAY,MAAqB;AACxD,MAAI,QAAQ,KAAK,MAAM,WAAW,EAAG,QAAO,CAAC;AAC7C,QAAM,SAAgB,CAAC;AACvB,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,MAAM;AAC3C,WAAO,KAAK,MAAM,MAAM,GAAG,IAAI,IAAI,CAAC;AAAA,EACtC;AACA,SAAO;AACT;AAMA,SAAS,cAAc,GAAY,GAAoB;AACrD,MAAI,MAAM,EAAG,QAAO;AACpB,MAAI,KAAK,KAAM,QAAO;AACtB,MAAI,KAAK,KAAM,QAAO;AACtB,MAAI,OAAO,MAAM,YAAY,OAAO,MAAM,SAAU,QAAO,IAAI,IAAI,KAAK;AACxE,MAAI,OAAO,MAAM,YAAY,OAAO,MAAM,SAAU,QAAO,IAAI,IAAI,KAAK;AACxE,SAAO,OAAO,CAAC,IAAI,OAAO,CAAC,IAAI,KAAK;AACtC;AAEO,SAAS,OAAU,UAAe,UAA4C;AACnF,SAAO,CAAC,GAAG,KAAK,EAAE,KAAK,CAAC,GAAG,MAAM;AAC/B,eAAW,aAAa,UAAU;AAChC,YAAM,MAAM,cAAc,UAAU,CAAC,GAAG,UAAU,CAAC,CAAC;AACpD,UAAI,QAAQ,EAAG,QAAO;AAAA,IACxB;AACA,WAAO;AAAA,EACT,CAAC;AACH;AAKO,SAAS,QAAW,OAAY,KAA2B,YAA2B,OAAY;AACvG,SAAO,CAAC,GAAG,KAAK,EAAE,KAAK,CAAC,GAAG,MAAM;AAC/B,UAAM,MAAM,cAAc,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;AACxC,WAAO,cAAc,QAAQ,MAAM,CAAC;AAAA,EACtC,CAAC;AACH;AAKO,SAAS,SAAY,OAAY,OAAkC;AACxE,QAAM,OAAO,oBAAI,IAAa;AAC9B,SAAO,MAAM,OAAO,UAAQ;AAC1B,UAAM,MAAM,MAAM,IAAI;AACtB,QAAI,KAAK,IAAI,GAAG,EAAG,QAAO;AAC1B,SAAK,IAAI,GAAG;AACZ,WAAO;AAAA,EACT,CAAC;AACH;AAKO,SAAS,QAAW,OAAmB;AAC5C,QAAM,SAAc,CAAC;AACrB,aAAW,OAAO,OAAO;AACvB,eAAW,QAAQ,KAAK;AACtB,aAAO,KAAK,IAAI;AAAA,IAClB;AAAA,EACF;AACA,SAAO;AACT;AAKO,SAAS,KAAQ,OAAiB;AACvC,SAAO,CAAC,GAAG,IAAI,IAAI,KAAK,CAAC;AAC3B;AAKO,SAAS,MAAS,OAA2B;AAClD,SAAO,MAAM,CAAC;AAChB;AAKO,SAAS,KAAQ,OAA2B;AACjD,SAAO,MAAM,MAAM,SAAS,CAAC;AAC/B;AAMO,SAAS,QAAQ,OAAyB;AAC/C,MAAI,MAAM,QAAQ,KAAK,EAAG,QAAO,MAAM,WAAW;AAClD,MAAI,OAAO,UAAU,SAAU,QAAO,MAAM,WAAW;AACvD,MAAI,iBAAiB,OAAO,iBAAiB,IAAK,QAAO,MAAM,SAAS;AACxE,MAAI,UAAU,QAAQ,OAAO,UAAU,SAAU,QAAO,OAAO,KAAK,KAAgC,EAAE,WAAW;AACjH,SAAO;AACT;","names":[]}

package/dist/core/index.d.ts

@@ -0,0 +1,95 @@
+interface DebounceOptions {
+    leading?: boolean;
+    trailing?: boolean;
+    maxWait?: number;
+}
+interface DebouncedFunction<T extends (...args: unknown[]) => unknown> {
+    (...args: Parameters<T>): void;
+    cancel(): void;
+    flush(): void;
+}
+interface MemoizedFunction<T extends (...args: unknown[]) => unknown> {
+    (...args: Parameters<T>): ReturnType<T>;
+    cache: Map<string, ReturnType<T>>;
+}
+interface RetryOptions {
+    attempts?: number;
+    baseDelay?: number;
+    maxDelay?: number;
+    shouldRetry?: (error: unknown) => boolean;
+}
+/**
+ * Deep clone a value, supporting objects, arrays, Date, RegExp, Map, Set,
+ * and cyclic references.
+ *
+ * @param value - The value to clone.
+ * @returns A deep copy of the input value.
+ */
+declare function deepClone<T>(value: T): T;
+/**
+ * Deep merge multiple objects. Arrays are overwritten, not concatenated.
+ * `null` and `undefined` source objects are skipped.
+ *
+ * @param objects - The objects to merge.
+ * @returns A new object with merged properties.
+ */
+declare function deepMerge<T extends Record<string, unknown>>(...objects: Partial<T>[]): T;
+/**
+ * Creates a debounced function that delays invoking `fn` until after `wait`
+ * milliseconds have elapsed since the last invocation. Supports leading,
+ * trailing, and maxWait options. The returned function also has `.cancel()`
+ * and `.flush()` methods.
+ *
+ * @param fn - The function to debounce.
+ * @param wait - The number of milliseconds to delay.
+ * @param options - Optional configuration.
+ * @returns A debounced function with `.cancel()` and `.flush()`.
+ */
+declare function debounce<T extends (...args: unknown[]) => unknown>(fn: T, wait: number, options?: DebounceOptions): DebouncedFunction<T>;
+/**
+ * Creates a throttled function that only invokes `fn` at most once per
+ * `wait` milliseconds.
+ *
+ * @param fn - The function to throttle.
+ * @param wait - The number of milliseconds to throttle invocations to.
+ * @returns A throttled function.
+ */
+declare function throttle<T extends (...args: unknown[]) => unknown>(fn: T, wait: number): (...args: Parameters<T>) => void;
+/**
+ * Creates a memoized version of `fn`. Uses a `Map` cache keyed by the
+ * first argument by default, or by a custom `resolver` function.
+ *
+ * @param fn - The function to memoize.
+ * @param resolver - Optional function to determine the cache key.
+ * @returns The memoized function with a `.cache` property.
+ */
+declare function memoize<T extends (...args: unknown[]) => unknown>(fn: T, resolver?: (...args: Parameters<T>) => string): MemoizedFunction<T>;
+/**
+ * Retries an async function with exponential backoff and jitter.
+ *
+ * @param fn - The async function to retry.
+ * @param options - Retry configuration.
+ * @returns A promise that resolves with the function result.
+ */
+declare function retry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
+/**
+ * A no-operation function that returns `undefined`.
+ */
+declare function noop(): void;
+/**
+ * Returns the given value unchanged.
+ *
+ * @param value - The value to return.
+ * @returns The same value.
+ */
+declare function identity<T>(value: T): T;
+/**
+ * Creates a function that invokes `fn` only once. Subsequent calls return
+ * the result of the first invocation.
+ *
+ * @param fn - The function to wrap.
+ * @returns A function that runs only once.
+ */
+declare function once<T extends (...args: unknown[]) => unknown>(fn: T): (...args: Parameters<T>) => ReturnType<T>;
+
+export { type DebounceOptions, type DebouncedFunction, type MemoizedFunction, type RetryOptions, debounce, deepClone, deepMerge, identity, memoize, noop, once, retry, throttle };