typetify 0.1.1

package/dist/chunk-GS3PP67B.js

@@ -0,0 +1,200 @@
+'use strict';
+
+var chunkPZ5AY32C_js = require('./chunk-PZ5AY32C.js');
+
+// src/async/index.ts
+var async_exports = {};
+chunkPZ5AY32C_js.__export(async_exports, {
+  awaitTo: () => awaitTo,
+  debounce: () => debounce,
+  defer: () => defer,
+  once: () => once,
+  onceAsync: () => onceAsync,
+  parallel: () => parallel,
+  retry: () => retry,
+  sleep: () => sleep,
+  throttle: () => throttle,
+  withTimeout: () => withTimeout
+});
+
+// src/async/awaitTo.ts
+async function awaitTo(promise) {
+  try {
+    const result = await promise;
+    return [null, result];
+  } catch (error) {
+    return [error, null];
+  }
+}
+
+// src/async/sleep.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/async/withTimeout.ts
+async function withTimeout(promise, ms, message = "Operation timed out") {
+  let timeoutId;
+  const timeoutPromise = new Promise((_, reject) => {
+    timeoutId = setTimeout(() => {
+      reject(new Error(message));
+    }, ms);
+  });
+  try {
+    const result = await Promise.race([promise, timeoutPromise]);
+    return result;
+  } finally {
+    if (timeoutId !== void 0) {
+      clearTimeout(timeoutId);
+    }
+  }
+}
+
+// src/async/retry.ts
+async function retry(fn, options = {}) {
+  const { attempts = 3, delay = 1e3, backoff = 1, onRetry } = options;
+  let lastError;
+  let currentDelay = delay;
+  for (let attempt = 1; attempt <= attempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (attempt < attempts) {
+        onRetry?.(lastError, attempt);
+        await new Promise((resolve) => setTimeout(resolve, currentDelay));
+        currentDelay *= backoff;
+      }
+    }
+  }
+  throw lastError;
+}
+
+// src/async/debounce.ts
+function debounce(fn, delay) {
+  let timeoutId;
+  const debounced = (...args) => {
+    if (timeoutId !== void 0) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      fn(...args);
+      timeoutId = void 0;
+    }, delay);
+  };
+  debounced.cancel = () => {
+    if (timeoutId !== void 0) {
+      clearTimeout(timeoutId);
+      timeoutId = void 0;
+    }
+  };
+  return debounced;
+}
+
+// src/async/throttle.ts
+function throttle(fn, interval) {
+  let lastCall = 0;
+  let timeoutId;
+  const throttled = (...args) => {
+    const now = Date.now();
+    const remaining = interval - (now - lastCall);
+    if (remaining <= 0) {
+      if (timeoutId !== void 0) {
+        clearTimeout(timeoutId);
+        timeoutId = void 0;
+      }
+      lastCall = now;
+      fn(...args);
+    } else if (timeoutId === void 0) {
+      timeoutId = setTimeout(() => {
+        lastCall = Date.now();
+        timeoutId = void 0;
+        fn(...args);
+      }, remaining);
+    }
+  };
+  throttled.cancel = () => {
+    if (timeoutId !== void 0) {
+      clearTimeout(timeoutId);
+      timeoutId = void 0;
+    }
+  };
+  return throttled;
+}
+
+// src/async/once.ts
+function once(fn) {
+  let called = false;
+  let result;
+  return ((...args) => {
+    if (!called) {
+      called = true;
+      result = fn(...args);
+    }
+    return result;
+  });
+}
+
+// src/async/onceAsync.ts
+function onceAsync(fn) {
+  let promise;
+  return () => {
+    if (promise === void 0) {
+      promise = fn();
+    }
+    return promise;
+  };
+}
+
+// src/async/defer.ts
+function defer() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+
+// src/async/parallel.ts
+async function parallel(tasks, options = {}) {
+  const { concurrency = Infinity } = options;
+  if (tasks.length === 0) {
+    return [];
+  }
+  if (concurrency === Infinity || concurrency >= tasks.length) {
+    return Promise.all(tasks.map((task) => task()));
+  }
+  const results = new Array(tasks.length);
+  let currentIndex = 0;
+  async function runNext() {
+    while (currentIndex < tasks.length) {
+      const index = currentIndex++;
+      const task = tasks[index];
+      if (task) {
+        results[index] = await task();
+      }
+    }
+  }
+  const workers = Array.from(
+    { length: Math.min(concurrency, tasks.length) },
+    () => runNext()
+  );
+  await Promise.all(workers);
+  return results;
+}
+
+exports.async_exports = async_exports;
+exports.awaitTo = awaitTo;
+exports.debounce = debounce;
+exports.defer = defer;
+exports.once = once;
+exports.onceAsync = onceAsync;
+exports.parallel = parallel;
+exports.retry = retry;
+exports.sleep = sleep;
+exports.throttle = throttle;
+exports.withTimeout = withTimeout;
+//# sourceMappingURL=chunk-GS3PP67B.js.map
+//# sourceMappingURL=chunk-GS3PP67B.js.map

package/dist/chunk-GS3PP67B.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/async/index.ts","../src/async/awaitTo.ts","../src/async/sleep.ts","../src/async/withTimeout.ts","../src/async/retry.ts","../src/async/debounce.ts","../src/async/throttle.ts","../src/async/once.ts","../src/async/onceAsync.ts","../src/async/defer.ts","../src/async/parallel.ts"],"names":["__export"],"mappings":"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","file":"chunk-GS3PP67B.js","sourcesContent":["export { awaitTo } from './awaitTo'\nexport { sleep } from './sleep'\nexport { withTimeout } from './withTimeout'\nexport { retry } from './retry'\nexport type { RetryOptions } from './retry'\nexport { debounce } from './debounce'\nexport { throttle } from './throttle'\nexport { once } from './once'\nexport { onceAsync } from './onceAsync'\nexport { defer } from './defer'\nexport type { Deferred } from './defer'\nexport { parallel } from './parallel'\n","/**\n * Wraps a promise to return a tuple of [error, result].\n * Eliminates the need for try/catch blocks.\n *\n * @example\n * const [error, user] = await awaitTo(fetchUser(id))\n * if (error) {\n *   console.error('Failed to fetch user:', error)\n *   return\n * }\n * console.log(user.name)\n */\nexport async function awaitTo<T, E = Error>(\n  promise: Promise<T>\n): Promise<[E, null] | [null, T]> {\n  try {\n    const result = await promise\n    return [null, result]\n  } catch (error) {\n    return [error as E, null]\n  }\n}\n","/**\n * Returns a promise that resolves after the specified milliseconds.\n *\n * @example\n * await sleep(1000) // wait 1 second\n * console.log('Done waiting')\n */\nexport function sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms))\n}\n","/**\n * Wraps a promise with a timeout. Rejects if the promise doesn't resolve in time.\n *\n * @example\n * const result = await withTimeout(fetchData(), 5000)\n * // Throws if fetchData takes more than 5 seconds\n */\nexport async function withTimeout<T>(\n  promise: Promise<T>,\n  ms: number,\n  message: string = 'Operation timed out'\n): Promise<T> {\n  let timeoutId: ReturnType<typeof setTimeout> | undefined\n\n  const timeoutPromise = new Promise<never>((_, reject) => {\n    timeoutId = setTimeout(() => {\n      reject(new Error(message))\n    }, ms)\n  })\n\n  try {\n    const result = await Promise.race([promise, timeoutPromise])\n    return result\n  } finally {\n    if (timeoutId !== undefined) {\n      clearTimeout(timeoutId)\n    }\n  }\n}\n","export interface RetryOptions {\n  /** Maximum number of attempts (default: 3) */\n  attempts?: number\n  /** Delay between attempts in ms (default: 1000) */\n  delay?: number\n  /** Multiply delay by this factor after each attempt (default: 1) */\n  backoff?: number\n  /** Called when an attempt fails */\n  onRetry?: (error: Error, attempt: number) => void\n}\n\n/**\n * Retries a function until it succeeds or max attempts is reached.\n *\n * @example\n * const data = await retry(() => fetchData(), {\n *   attempts: 3,\n *   delay: 1000,\n *   backoff: 2,\n * })\n */\nexport async function retry<T>(\n  fn: () => Promise<T>,\n  options: RetryOptions = {}\n): Promise<T> {\n  const { attempts = 3, delay = 1000, backoff = 1, onRetry } = options\n\n  let lastError: Error | undefined\n  let currentDelay = delay\n\n  for (let attempt = 1; attempt <= attempts; attempt++) {\n    try {\n      return await fn()\n    } catch (error) {\n      lastError = error instanceof Error ? error : new Error(String(error))\n\n      if (attempt < attempts) {\n        onRetry?.(lastError, attempt)\n        await new Promise((resolve) => setTimeout(resolve, currentDelay))\n        currentDelay *= backoff\n      }\n    }\n  }\n\n  throw lastError\n}\n","/**\n * Creates a debounced version of a function.\n * The function will only be called after it stops being called for the specified delay.\n *\n * @example\n * const debouncedSearch = debounce((query: string) => {\n *   console.log('Searching:', query)\n * }, 300)\n *\n * debouncedSearch('h')\n * debouncedSearch('he')\n * debouncedSearch('hello') // Only this one executes after 300ms\n */\nexport function debounce<T extends (...args: Parameters<T>) => void>(\n  fn: T,\n  delay: number\n): ((...args: Parameters<T>) => void) & { cancel: () => void } {\n  let timeoutId: ReturnType<typeof setTimeout> | undefined\n\n  const debounced = (...args: Parameters<T>): void => {\n    if (timeoutId !== undefined) {\n      clearTimeout(timeoutId)\n    }\n\n    timeoutId = setTimeout(() => {\n      fn(...args)\n      timeoutId = undefined\n    }, delay)\n  }\n\n  debounced.cancel = (): void => {\n    if (timeoutId !== undefined) {\n      clearTimeout(timeoutId)\n      timeoutId = undefined\n    }\n  }\n\n  return debounced\n}\n","/**\n * Creates a throttled version of a function.\n * The function will only be called at most once per specified interval.\n *\n * @example\n * const throttledScroll = throttle(() => {\n *   console.log('Scroll event')\n * }, 100)\n *\n * window.addEventListener('scroll', throttledScroll)\n */\nexport function throttle<T extends (...args: Parameters<T>) => void>(\n  fn: T,\n  interval: number\n): ((...args: Parameters<T>) => void) & { cancel: () => void } {\n  let lastCall = 0\n  let timeoutId: ReturnType<typeof setTimeout> | undefined\n\n  const throttled = (...args: Parameters<T>): void => {\n    const now = Date.now()\n    const remaining = interval - (now - lastCall)\n\n    if (remaining <= 0) {\n      if (timeoutId !== undefined) {\n        clearTimeout(timeoutId)\n        timeoutId = undefined\n      }\n      lastCall = now\n      fn(...args)\n    } else if (timeoutId === undefined) {\n      timeoutId = setTimeout(() => {\n        lastCall = Date.now()\n        timeoutId = undefined\n        fn(...args)\n      }, remaining)\n    }\n  }\n\n  throttled.cancel = (): void => {\n    if (timeoutId !== undefined) {\n      clearTimeout(timeoutId)\n      timeoutId = undefined\n    }\n  }\n\n  return throttled\n}\n","/**\n * Creates a function that can only be called once.\n * Subsequent calls return the result of the first call.\n *\n * @example\n * const initialize = once(() => {\n *   console.log('Initializing...')\n *   return { ready: true }\n * })\n *\n * initialize() // logs 'Initializing...', returns { ready: true }\n * initialize() // returns { ready: true } without logging\n */\nexport function once<T extends (...args: Parameters<T>) => ReturnType<T>>(\n  fn: T\n): T {\n  let called = false\n  let result: ReturnType<T>\n\n  return ((...args: Parameters<T>): ReturnType<T> => {\n    if (!called) {\n      called = true\n      result = fn(...args)\n    }\n    return result\n  }) as T\n}\n","/**\n * Creates an async function that can only be called once.\n * Subsequent calls return the same promise.\n * Useful for initialization that should only happen once.\n *\n * @example\n * const loadConfig = onceAsync(async () => {\n *   const response = await fetch('/config')\n *   return response.json()\n * })\n *\n * // Both calls return the same promise\n * const config1 = await loadConfig()\n * const config2 = await loadConfig()\n */\nexport function onceAsync<T>(fn: () => Promise<T>): () => Promise<T> {\n  let promise: Promise<T> | undefined\n\n  return (): Promise<T> => {\n    if (promise === undefined) {\n      promise = fn()\n    }\n    return promise\n  }\n}\n","export interface Deferred<T> {\n  promise: Promise<T>\n  resolve: (value: T | PromiseLike<T>) => void\n  reject: (reason?: unknown) => void\n}\n\n/**\n * Creates a deferred promise that can be resolved or rejected externally.\n *\n * @example\n * const deferred = defer<string>()\n *\n * setTimeout(() => {\n *   deferred.resolve('Done!')\n * }, 1000)\n *\n * const result = await deferred.promise\n */\nexport function defer<T>(): Deferred<T> {\n  let resolve!: (value: T | PromiseLike<T>) => void\n  let reject!: (reason?: unknown) => void\n\n  const promise = new Promise<T>((res, rej) => {\n    resolve = res\n    reject = rej\n  })\n\n  return { promise, resolve, reject }\n}\n","/**\n * Runs async functions in parallel with a concurrency limit.\n *\n * @example\n * const urls = ['url1', 'url2', 'url3', 'url4', 'url5']\n * const results = await parallel(\n *   urls.map(url => () => fetch(url)),\n *   { concurrency: 2 }\n * )\n */\nexport async function parallel<T>(\n  tasks: readonly (() => Promise<T>)[],\n  options: { concurrency?: number } = {}\n): Promise<T[]> {\n  const { concurrency = Infinity } = options\n\n  if (tasks.length === 0) {\n    return []\n  }\n\n  if (concurrency === Infinity || concurrency >= tasks.length) {\n    return Promise.all(tasks.map((task) => task()))\n  }\n\n  const results: T[] = new Array(tasks.length)\n  let currentIndex = 0\n\n  async function runNext(): Promise<void> {\n    while (currentIndex < tasks.length) {\n      const index = currentIndex++\n      const task = tasks[index]\n      if (task) {\n        results[index] = await task()\n      }\n    }\n  }\n\n  const workers = Array.from(\n    { length: Math.min(concurrency, tasks.length) },\n    () => runNext()\n  )\n\n  await Promise.all(workers)\n\n  return results\n}\n"]}

package/dist/chunk-J5LGTIGS.mjs

@@ -0,0 +1,9 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export { __export };
+//# sourceMappingURL=chunk-J5LGTIGS.mjs.map
+//# sourceMappingURL=chunk-J5LGTIGS.mjs.map

package/dist/chunk-J5LGTIGS.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"chunk-J5LGTIGS.mjs"}