core-ts-utils/dist/index.js

Commonly used utilities in JS and TS

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var index_exports = {};
__export(index_exports, {
  camelCase: () => camelCase_default,
  capitalize: () => capitalize_default,
  chunk: () => chunk_default,
  compose: () => compose_default,
  cookies: () => cookies_default,
  curry: () => curry_default,
  debounce: () => debounce_default,
  deepClone: () => deepClone_default,
  flatten: () => flatten_default,
  groupBy: () => groupBy_default,
  isEmail: () => isEmail_default,
  isEmpty: () => isEmpty_default,
  isNumeric: () => isNumeric_default,
  isURL: () => isURL_default,
  kebabCase: () => kebabCase_default,
  memoize: () => memoize_default,
  merge: () => merge_default,
  omit: () => omit_default,
  once: () => once_default,
  parallel: () => parallel_default,
  partial: () => partial_default,
  pick: () => pick_default,
  pipe: () => pipe_default,
  promisify: () => promisisfy_default,
  queryParams: () => queryParams_default,
  randomId: () => randomId_default,
  retry: () => retry_default,
  sleep: () => sleep_default,
  snakeCase: () => snakeCase_default,
  storage: () => storage_default,
  template: () => template_default,
  throttle: () => throttle_default,
  truncate: () => truncate_default,
  uniqueBy: () => uniqueBy_default
});
module.exports = __toCommonJS(index_exports);

// src/debounce.ts
function debounce(func, delay = 300) {
  let timer;
  return function(...args) {
    clearTimeout(timer);
    timer = setTimeout(() => func.apply(this, args), delay);
  };
}
var debounce_default = debounce;

// src/throttle.ts
function throttle(func, limit) {
  let lastExecuted = 0;
  let timeout = null;
  return function(...args) {
    const context = this;
    const now = Date.now();
    if (now - lastExecuted >= limit) {
      func.apply(context, args);
      lastExecuted = now;
    } else if (!timeout) {
      timeout = setTimeout(() => {
        func.apply(context, args);
        lastExecuted = Date.now();
        timeout = null;
      }, limit - (now - lastExecuted));
    }
  };
}
var throttle_default = throttle;

// src/curry.ts
function curry(fn) {
  return function curried(...args) {
    if (args.length >= fn.length) {
      return fn.apply(this, args);
    }
    return (...nextArgs) => curried.apply(this, [...args, ...nextArgs]);
  };
}
var curry_default = curry;

// src/memoize.ts
function memoize(fn) {
  const cache = /* @__PURE__ */ new Map();
  return function(...args) {
    const key = JSON.stringify(args);
    if (cache.has(key)) {
      return cache.get(key);
    }
    const result = fn.apply(this, args);
    cache.set(key, result);
    return result;
  };
}
var memoize_default = memoize;

// src/once.ts
function once(fn) {
  let called = false;
  let result;
  return function(...args) {
    if (!called) {
      called = true;
      result = fn.apply(this, args);
    }
    return result;
  };
}
var once_default = once;

// src/deepClone.ts
function deepClone(obj) {
  return JSON.parse(JSON.stringify(obj));
}
var deepClone_default = deepClone;

// src/randomId.ts
function randomId(length = 16) {
  const id1 = Date.now().toString();
  const id2 = Math.random().toString(36).substr(2);
  const shuffled = (id1 + id2).split("").sort(() => Math.random() - 0.5).join("");
  return shuffled.slice(0, length);
}
var randomId_default = randomId;

// src/sleep.ts
function sleep(ms = 1e3) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}
var sleep_default = sleep;

// src/flatten.ts
function flatten(arr) {
  return arr.reduce((acc, val) => Array.isArray(val) ? acc.concat(flatten(val)) : acc.concat(val), []);
}
var flatten_default = flatten;

// src/capitalize.ts
function capitalize(str) {
  return str.charAt(0).toUpperCase() + str.slice(1);
}
var capitalize_default = capitalize;

// src/isEmpty.ts
function isEmpty(obj) {
  return obj === "" || obj === null || obj === void 0 || typeof obj === "object" && !Array.isArray(obj) && Object.keys(obj).length === 0 || Array.isArray(obj) && obj.length === 0;
}
var isEmpty_default = isEmpty;

// src/chunk.ts
function chunk(array, size = 1) {
  if (!Array.isArray(array)) {
    throw new TypeError("Expected an array as the first argument");
  }
  if (size <= 0) {
    throw new Error("Chunk size must be greater than 0");
  }
  const result = [];
  for (let i = 0; i < array.length; i += size) {
    result.push(array.slice(i, i + size));
  }
  return result;
}
var chunk_default = chunk;

// src/groupBy.ts
function groupBy(array, iteratee) {
  if (!Array.isArray(array)) {
    throw new TypeError("Expected an array as the first argument");
  }
  const result = {};
  const callback = typeof iteratee === "function" ? iteratee : (item) => item[iteratee];
  for (const item of array) {
    const key = callback(item).toString();
    if (!result[key]) {
      result[key] = [];
    }
    result[key].push(item);
  }
  return result;
}
var groupBy_default = groupBy;

// src/omit.ts
function omit(object, paths) {
  if (typeof object !== "object" || object === null) {
    throw new TypeError("Expected an object as the first argument");
  }
  const result = { ...object };
  const keysToOmit = Array.isArray(paths) ? paths : [paths];
  for (const key of keysToOmit) {
    delete result[key];
  }
  return result;
}
var omit_default = omit;

// src/pick.ts
function pick(object, paths) {
  if (typeof object !== "object" || object === null) {
    throw new TypeError("Expected an object as the first argument");
  }
  const result = {};
  const keysToPick = Array.isArray(paths) ? paths : [paths];
  for (const key of keysToPick) {
    if (Object.prototype.hasOwnProperty.call(object, key)) {
      result[key] = object[key];
    }
  }
  return result;
}
var pick_default = pick;

// src/merge.ts
function merge(...objects) {
  return objects.reduce((result, current) => {
    if (!current) return result;
    Object.keys(current).forEach((key) => {
      const resultValue = result[key];
      const currentValue = current[key];
      if (Array.isArray(resultValue) && Array.isArray(currentValue)) {
        result[key] = [...resultValue, ...currentValue];
      } else if (resultValue && currentValue && typeof resultValue === "object" && typeof currentValue === "object" && !Array.isArray(resultValue) && !Array.isArray(currentValue)) {
        result[key] = merge(resultValue, currentValue);
      } else {
        result[key] = currentValue;
      }
    });
    return result;
  }, {});
}
var merge_default = merge;

// src/uniqueBy.ts
function uniqueBy(array, iteratee) {
  if (!Array.isArray(array)) {
    throw new TypeError("Expected an array as the first argument");
  }
  const seen = /* @__PURE__ */ new Set();
  const callback = typeof iteratee === "function" ? iteratee : (item) => item[iteratee];
  return array.filter((item) => {
    const key = callback(item);
    if (seen.has(key)) {
      return false;
    }
    seen.add(key);
    return true;
  });
}
var uniqueBy_default = uniqueBy;

// src/camelCase.ts
function camelCase(str) {
  if (typeof str !== "string") {
    throw new TypeError("Expected a string as argument");
  }
  return str.replace(/[\s_-]+(.)?/g, (_, char) => char ? char.toUpperCase() : "").replace(/^([A-Z])/, (match) => match.toLowerCase());
}
var camelCase_default = camelCase;

// src/kebabCase.ts
function kebabCase(str) {
  if (typeof str !== "string") {
    throw new TypeError("Expected a string as argument");
  }
  return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
}
var kebabCase_default = kebabCase;

// src/snakeCase.ts
function snakeCase(str) {
  if (typeof str !== "string") {
    throw new TypeError("Expected a string as argument");
  }
  return str.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[\s-]+/g, "_").toLowerCase();
}
var snakeCase_default = snakeCase;

// src/truncate.ts
function truncate(str, maxLength, suffix = "...") {
  if (typeof str !== "string") {
    throw new TypeError("Expected a string as first argument");
  }
  if (str.length <= maxLength) {
    return str;
  }
  const truncatedLength = maxLength - suffix.length;
  return truncatedLength <= 0 ? suffix : str.slice(0, truncatedLength) + suffix;
}
var truncate_default = truncate;

// src/template.ts
function template(template2, data) {
  if (typeof template2 !== "string") {
    throw new TypeError("Expected a string as first argument");
  }
  return template2.replace(/{([^{}]*)}/g, (match, key) => {
    const value = key.split(".").reduce((obj, prop) => {
      return obj && obj[prop] !== void 0 ? obj[prop] : void 0;
    }, data);
    return value !== void 0 ? String(value) : match;
  });
}
var template_default = template;

// src/compose.ts
function compose(...fns) {
  if (fns.length === 0) {
    return (x) => x;
  }
  if (fns.length === 1) {
    return fns[0];
  }
  return fns.reduce((a, b) => (arg) => a(b(arg)));
}
var compose_default = compose;

// src/pipe.ts
function pipe(...fns) {
  if (fns.length === 0) {
    return (x) => x;
  }
  if (fns.length === 1) {
    return fns[0];
  }
  return (x) => fns.reduce((acc, fn) => fn(acc), x);
}
var pipe_default = pipe;

// src/partial.ts
function partial(fn, ...args) {
  return (...remainingArgs) => fn(...args, ...remainingArgs);
}
var partial_default = partial;

// src/isEmail.ts
function isEmail(value) {
  if (typeof value !== "string") {
    return false;
  }
  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  return emailRegex.test(value);
}
var isEmail_default = isEmail;

// src/isURL.ts
function isURL(value) {
  if (typeof value !== "string") {
    return false;
  }
  try {
    const url = new URL(value);
    return url.protocol === "http:" || url.protocol === "https:";
  } catch {
    return false;
  }
}
var isURL_default = isURL;

// src/isNumeric.ts
function isNumeric(value) {
  if (typeof value === "number") {
    return !isNaN(value) && isFinite(value);
  }
  if (typeof value !== "string") {
    return false;
  }
  return !isNaN(Number(value)) && isFinite(Number(value));
}
var isNumeric_default = isNumeric;

// src/cookies.ts
var cookies = {
  /**
   * Get cookie value by name
   * @param name - Cookie name
   * @returns Cookie value or null if not found
   */
  get(name) {
    if (typeof document === "undefined") {
      throw new Error("cookies.get() requires a browser environment");
    }
    const matches = document.cookie.match(new RegExp(`(?:^|; )${name.replace(/([.$?*|{}()[\]\\/+^])/g, "\\$1")}=([^;]*)`));
    return matches ? decodeURIComponent(matches[1]) : null;
  },
  /**
   * Set a cookie
   * @param name - Cookie name
   * @param value - Cookie value
   * @param options - Cookie options
   */
  set(name, value, options = {}) {
    if (typeof document === "undefined") {
      throw new Error("cookies.set() requires a browser environment");
    }
    const optionsWithDefaults = {
      path: "/",
      ...options
    };
    if (optionsWithDefaults.expires instanceof Date) {
      optionsWithDefaults.expires = optionsWithDefaults.expires.toUTCString();
    } else if (typeof optionsWithDefaults.expires === "number") {
      const days = optionsWithDefaults.expires;
      const t = optionsWithDefaults.expires = /* @__PURE__ */ new Date();
      t.setTime(t.getTime() + days * 864e5);
      optionsWithDefaults.expires = t.toUTCString();
    }
    let updatedCookie = `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
    for (const [key, val] of Object.entries(optionsWithDefaults)) {
      if (val === true) {
        updatedCookie += `; ${key}`;
      } else if (val !== false) {
        updatedCookie += `; ${key}=${val}`;
      }
    }
    document.cookie = updatedCookie;
  },
  /**
   * Delete a cookie
   * @param name - Cookie name
   * @param options - Cookie options
   */
  delete(name, options = {}) {
    this.set(name, "", {
      ...options,
      expires: -1
    });
  }
};
var cookies_default = cookies;

// src/storage.ts
var storage = {
  /**
   * Set a value in localStorage with optional expiration
   * @param key - Storage key
   * @param value - Value to store
   * @param expiresInMs - Milliseconds until expiration (optional)
   */
  set(key, value, expiresInMs) {
    if (typeof localStorage === "undefined") {
      throw new Error("storage.set() requires a browser environment");
    }
    const item = {
      value,
      expires: expiresInMs ? Date.now() + expiresInMs : null
    };
    localStorage.setItem(key, JSON.stringify(item));
  },
  /**
   * Get a value from localStorage
   * @param key - Storage key
   * @param defaultValue - Default value if not found or expired
   * @returns Stored value or defaultValue
   */
  get(key, defaultValue = null) {
    if (typeof localStorage === "undefined") {
      throw new Error("storage.get() requires a browser environment");
    }
    const itemStr = localStorage.getItem(key);
    if (!itemStr) {
      return defaultValue;
    }
    try {
      const item = JSON.parse(itemStr);
      if (item.expires && Date.now() > item.expires) {
        localStorage.removeItem(key);
        return defaultValue;
      }
      return item.value;
    } catch (e) {
      return defaultValue;
    }
  },
  /**
   * Remove a value from localStorage
   * @param key - Storage key
   */
  remove(key) {
    if (typeof localStorage === "undefined") {
      throw new Error("storage.remove() requires a browser environment");
    }
    localStorage.removeItem(key);
  },
  /**
   * Clear all values in localStorage
   */
  clear() {
    if (typeof localStorage === "undefined") {
      throw new Error("storage.clear() requires a browser environment");
    }
    localStorage.clear();
  }
};
var storage_default = storage;

// src/queryParams.ts
var queryParams = {
  /**
   * Get all query parameters as an object
   * @param url - URL to parse (defaults to current URL)
   * @returns Object with all query parameters
   */
  getAll(url) {
    const searchParams = new URLSearchParams(url ? new URL(url).search : typeof window !== "undefined" ? window.location.search : "");
    const params = {};
    searchParams.forEach((value, key) => {
      params[key] = value;
    });
    return params;
  },
  /**
   * Get a specific query parameter
   * @param name - Parameter name
   * @param url - URL to parse (defaults to current URL)
   * @returns Parameter value or null if not found
   */
  get(name, url) {
    const searchParams = new URLSearchParams(url ? new URL(url).search : typeof window !== "undefined" ? window.location.search : "");
    return searchParams.get(name);
  },
  /**
   * Set query parameters and return the new URL
   * @param params - Parameters to set
   * @param url - Base URL (defaults to current URL)
   * @returns New URL with updated parameters
   */
  set(params, url) {
    const baseUrl = url || (typeof window !== "undefined" ? window.location.href : "");
    const urlObj = new URL(baseUrl);
    Object.entries(params).forEach(([key, value]) => {
      urlObj.searchParams.set(key, value);
    });
    return urlObj.toString();
  },
  /**
   * Remove query parameters and return the new URL
   * @param paramNames - Parameter names to remove
   * @param url - Base URL (defaults to current URL)
   * @returns New URL with parameters removed
   */
  remove(paramNames, url) {
    const baseUrl = url || (typeof window !== "undefined" ? window.location.href : "");
    const urlObj = new URL(baseUrl);
    const paramsToRemove = Array.isArray(paramNames) ? paramNames : [paramNames];
    paramsToRemove.forEach((name) => {
      urlObj.searchParams.delete(name);
    });
    return urlObj.toString();
  }
};
var queryParams_default = queryParams;

// src/retry.ts
async function retry(fn, options = {}) {
  const { maxAttempts = 5, initialDelay = 100, maxDelay = 1e4, factor = 2, onRetry = () => {
  } } = options;
  let attempt = 0;
  let delay = initialDelay;
  while (true) {
    try {
      return await fn();
    } catch (error) {
      attempt++;
      if (attempt >= maxAttempts) {
        throw error;
      }
      if (error instanceof Error) {
        onRetry(error, attempt);
      }
      delay = Math.min(delay * factor, maxDelay);
      await new Promise((resolve) => setTimeout(resolve, delay));
    }
  }
}
var retry_default = retry;

// src/promisisfy.ts
function promisify(fn) {
  return (...args) => {
    return new Promise((resolve, reject) => {
      fn(...args, (error, result) => {
        if (error) {
          reject(error);
        } else {
          resolve(result);
        }
      });
    });
  };
}
var promisisfy_default = promisify;

// src/parallel.ts
async function parallel(tasks, concurrency = Infinity) {
  if (!Array.isArray(tasks)) {
    throw new TypeError("Expected tasks to be an array of functions");
  }
  if (tasks.length === 0) {
    return [];
  }
  const results = new Array(tasks.length);
  const runningTasks = /* @__PURE__ */ new Set();
  let nextIndex = 0;
  return new Promise((resolve, reject) => {
    const startNext = () => {
      if (nextIndex >= tasks.length) {
        if (runningTasks.size === 0) {
          resolve(results);
        }
        return;
      }
      const index = nextIndex++;
      const task = tasks[index]();
      const runningTask = task.then((result) => {
        results[index] = result;
        runningTasks.delete(runningTask);
        startNext();
      }).catch((error) => {
        reject(error);
      });
      runningTasks.add(runningTask);
      if (runningTasks.size < concurrency) {
        startNext();
      }
    };
    for (let i = 0; i < Math.min(concurrency, tasks.length); i++) {
      startNext();
    }
  });
}
var parallel_default = parallel;
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  camelCase,
  capitalize,
  chunk,
  compose,
  cookies,
  curry,
  debounce,
  deepClone,
  flatten,
  groupBy,
  isEmail,
  isEmpty,
  isNumeric,
  isURL,
  kebabCase,
  memoize,
  merge,
  omit,
  once,
  parallel,
  partial,
  pick,
  pipe,
  promisify,
  queryParams,
  randomId,
  retry,
  sleep,
  snakeCase,
  storage,
  template,
  throttle,
  truncate,
  uniqueBy
});