@germondai/ts-utils 0.0.4 → 0.1.0

package/dist/module.d.ts

@@ -1 +1,2 @@
 export * from './runtime';
+export * from './types';

package/dist/module.js

@@ -1,11 +1,99 @@
-// src/runtime/collection.ts
-var hasDuplicates = (array, keyExtractor) => new Set(array.map((value, index) => keyExtractor?.(value, index, array) || value)).size < array.length;
+// src/runtime/array.ts
+var hasDuplicates = (array, keyExtractor) => new Set(array.map((value, index) => keyExtractor?.(value, index, array) ?? value)).size < array.length;
 var uniqueArray = (array, keyExtractor) => [
   ...new Map(array.map((value, index, array2) => [
-    keyExtractor?.(value, index, array2) || value,
+    keyExtractor?.(value, index, array2) ?? value,
     value
   ])).values()
 ];
+var chunk = (array, size) => {
+  if (size <= 0)
+    return [];
+  const result = [];
+  for (let i = 0;i < array.length; i += size) {
+    result.push(array.slice(i, i + size));
+  }
+  return result;
+};
+var shuffle = (array) => {
+  const result = [...array];
+  for (let i = result.length - 1;i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [result[i], result[j]] = [result[j], result[i]];
+  }
+  return result;
+};
+var groupBy = (array, key) => {
+  const getKey = typeof key === "function" ? key : (item) => String(item[key]);
+  const result = {};
+  for (const item of array) {
+    const k = getKey(item);
+    if (!result[k])
+      result[k] = [];
+    result[k].push(item);
+  }
+  return result;
+};
+var intersection = (...arrays) => {
+  if (arrays.length === 0)
+    return [];
+  return arrays.reduce((acc, arr) => acc.filter((item) => arr.includes(item)));
+};
+var difference = (a, b) => a.filter((item) => !b.includes(item));
+var range = (start, end, step = 1) => {
+  if (step <= 0)
+    return [];
+  const result = [];
+  for (let i = start;i < end; i += step) {
+    result.push(i);
+  }
+  return result;
+};
+var sortBy = (array, key, order = "asc") => {
+  const getVal = typeof key === "function" ? key : (item) => item[key];
+  return [...array].sort((a, b) => {
+    const va = getVal(a);
+    const vb = getVal(b);
+    const cmp = va < vb ? -1 : va > vb ? 1 : 0;
+    return order === "desc" ? -cmp : cmp;
+  });
+};
+var compact = (array) => array.filter(Boolean);
+var last = (array) => array[array.length - 1];
+var sample = (array) => array.length === 0 ? undefined : array[Math.floor(Math.random() * array.length)];
+// src/runtime/color.ts
+var hexToRgb = (hex) => {
+  const cleaned = hex.replace(/^#/, "");
+  let fullHex;
+  if (cleaned.length === 3) {
+    fullHex = cleaned.split("").map((c) => c + c).join("");
+  } else if (cleaned.length === 6) {
+    fullHex = cleaned;
+  } else {
+    return null;
+  }
+  const num = parseInt(fullHex, 16);
+  if (isNaN(num))
+    return null;
+  return {
+    r: num >> 16 & 255,
+    g: num >> 8 & 255,
+    b: num & 255
+  };
+};
+var rgbToHex = (r, g, b) => "#" + [r, g, b].map((v) => Math.max(0, Math.min(255, Math.round(v)))).map((v) => v.toString(16).padStart(2, "0")).join("");
+var lighten = (hex, amount) => {
+  const rgb = hexToRgb(hex);
+  if (!rgb)
+    return hex;
+  return rgbToHex(rgb.r + (255 - rgb.r) * amount, rgb.g + (255 - rgb.g) * amount, rgb.b + (255 - rgb.b) * amount);
+};
+var darken = (hex, amount) => {
+  const rgb = hexToRgb(hex);
+  if (!rgb)
+    return hex;
+  return rgbToHex(rgb.r * (1 - amount), rgb.g * (1 - amount), rgb.b * (1 - amount));
+};
 // src/runtime/constants.ts
 var SUPPORTED_DISPLAYABLE_MEDIA_TYPES = {
   images: [
@@ -25,13 +113,14 @@ var SUPPORTED_DISPLAYABLE_MEDIA_TYPES = {
   ]
 };
 // src/runtime/convertor.ts
+var splitWords = (input) => input.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").toLowerCase().split(/[\s_\-]+/).filter(Boolean);
 var toCamelCase = (input) => {
-  const words = input.toLowerCase().split(/[\s_-]+/).filter(Boolean);
+  const words = splitWords(input);
   return words.map((word, index) => index === 0 ? word : word.charAt(0).toUpperCase() + word.slice(1)).join("");
 };
-var toPascalCase = (input) => input.toLowerCase().split(/[\s_-]+/).filter(Boolean).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
-var toSnakeCase = (input) => input.toLowerCase().split(/[\s-]+/).filter(Boolean).join("_");
-var toKebabCase = (input) => input.toLowerCase().split(/[\s_]+/).filter(Boolean).join("-");
+var toPascalCase = (input) => splitWords(input).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+var toSnakeCase = (input) => splitWords(input).join("_");
+var toKebabCase = (input) => splitWords(input).join("-");
 var toTitleCase = (input) => input.toLowerCase().split(/\s+/).filter(Boolean).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
 var toSentenceCase = (input) => {
   const lower = input.toLowerCase();
@@ -67,8 +156,64 @@ var unescapeHTML = (str) => {
   };
   return str.replace(/&[a-zA-Z0-9#]+;/g, (entity) => unescapeMap[entity] || entity);
 };
+// src/runtime/crypto.ts
+var generateId = (length = 16) => {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  let result = "";
+  for (let i = 0;i < length; i++) {
+    result += chars.charAt(Math.floor(Math.random() * chars.length));
+  }
+  return result;
+};
+var hash = (str) => {
+  let h = 5381;
+  for (let i = 0;i < str.length; i++) {
+    h = (h << 5) + h + str.charCodeAt(i) >>> 0;
+  }
+  return h;
+};
 // src/runtime/data.ts
-var clone = (data) => JSON.parse(JSON.stringify(data));
+var clone = (data) => {
+  if (data === null || typeof data !== "object")
+    return data;
+  try {
+    return structuredClone(data);
+  } catch {
+    return JSON.parse(JSON.stringify(data));
+  }
+};
+var isEqual = (a, b, seen = new WeakSet) => {
+  if (a === b)
+    return true;
+  if (a == null || b == null)
+    return false;
+  if (typeof a !== typeof b)
+    return false;
+  if (typeof a === "object") {
+    if (seen.has(a) || seen.has(b))
+      return a === b;
+    seen.add(a);
+    seen.add(b);
+    if (Array.isArray(a) && Array.isArray(b)) {
+      if (a.length !== b.length)
+        return false;
+      for (let i = 0;i < a.length; i++)
+        if (!isEqual(a[i], b[i], seen))
+          return false;
+      return true;
+    } else {
+      const keysA = Object.keys(a);
+      const keysB = Object.keys(b);
+      if (keysA.length !== keysB.length)
+        return false;
+      for (const key of keysA)
+        if (!keysB.includes(key) || !isEqual(a[key], b[key], seen))
+          return false;
+      return true;
+    }
+  }
+  return false;
+};
 // src/runtime/errors.ts
 var catchError = async (promise, errorsToCatch) => {
   try {
@@ -80,6 +225,61 @@ var catchError = async (promise, errorsToCatch) => {
     throw error;
   }
 };
+// src/runtime/function.ts
+var debounce = (fn, ms) => {
+  let timer;
+  const debounced = (...args) => {
+    if (timer !== undefined)
+      clearTimeout(timer);
+    timer = setTimeout(() => fn(...args), ms);
+  };
+  debounced.cancel = () => {
+    if (timer !== undefined)
+      clearTimeout(timer);
+    timer = undefined;
+  };
+  return debounced;
+};
+var throttle = (fn, ms) => {
+  let timer;
+  let lastRun = 0;
+  const throttled = (...args) => {
+    const now = Date.now();
+    const remaining = ms - (now - lastRun);
+    if (remaining <= 0) {
+      if (timer !== undefined) {
+        clearTimeout(timer);
+        timer = undefined;
+      }
+      lastRun = now;
+      fn(...args);
+    } else if (timer === undefined) {
+      timer = setTimeout(() => {
+        lastRun = Date.now();
+        timer = undefined;
+        fn(...args);
+      }, remaining);
+    }
+  };
+  throttled.cancel = () => {
+    if (timer !== undefined)
+      clearTimeout(timer);
+    timer = undefined;
+  };
+  return throttled;
+};
+var once = (fn) => {
+  let called = false;
+  let result;
+  return (...args) => {
+    if (!called) {
+      called = true;
+      result = fn(...args);
+    }
+    return result;
+  };
+};
+var noop = () => {};
 // src/runtime/math.ts
 var rand = (n, m = 0) => Math.floor(Math.random() * (m - n + 1)) + n;
 var percentage = (value, maxValue, decimalPlaces = 2) => {
@@ -90,10 +290,175 @@ var percentage = (value, maxValue, decimalPlaces = 2) => {
 };
 var clamp = (num, min, max) => Math.min(Math.max(num, min), max);
 var formatNumber = (num) => num.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+var sum = (numbers) => numbers.reduce((acc, n) => acc + n, 0);
+var average = (numbers) => numbers.length === 0 ? 0 : sum(numbers) / numbers.length;
+var median = (numbers) => {
+  if (numbers.length === 0)
+    return 0;
+  const sorted = [...numbers].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 !== 0 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+};
+var min = (numbers) => numbers.length === 0 ? Infinity : Math.min(...numbers);
+var max = (numbers) => numbers.length === 0 ? -Infinity : Math.max(...numbers);
+var round = (value, decimals = 0) => {
+  const factor = Math.pow(10, decimals);
+  return Math.round(value * factor) / factor;
+};
 // src/runtime/media.ts
 var isSupportedDisplayableMedia = (mime, type = { image: true, video: true }) => type.image && SUPPORTED_DISPLAYABLE_MEDIA_TYPES.images.includes(mime) || type.video && SUPPORTED_DISPLAYABLE_MEDIA_TYPES.videos.includes(mime);
+// src/runtime/normalize.ts
+var normalize = (value) => {
+  let normalized;
+  switch (typeof value) {
+    case "string":
+      normalized = value === "" ? null : value;
+      break;
+    case "number":
+      normalized = isNaN(value) ? null : value;
+      break;
+    case "boolean":
+      normalized = value;
+      break;
+    case "object":
+      if (value === null || value === undefined)
+        normalized = value ?? null;
+      else if (value instanceof Date)
+        normalized = isNaN(value.getTime()) ? null : value;
+      else if (Array.isArray(value))
+        normalized = value.length === 0 ? null : value;
+      else if (value instanceof Set)
+        normalized = value.size === 0 ? null : value;
+      else if (value instanceof Map)
+        normalized = value.size === 0 ? null : value;
+      else
+        normalized = Object.keys(value).length === 0 ? null : value;
+      break;
+    default:
+      normalized = value ?? null;
+  }
+  return normalized;
+};
+// src/runtime/object.ts
+var pick = (obj, keys) => {
+  const result = {};
+  for (const key of keys) {
+    if (key in obj)
+      result[key] = obj[key];
+  }
+  return result;
+};
+var omit = (obj, keys) => {
+  const result = { ...obj };
+  for (const key of keys)
+    delete result[key];
+  return result;
+};
+var merge = (...objects) => {
+  const isPlainObject = (val) => val !== null && typeof val === "object" && val.constructor === Object;
+  const result = {};
+  for (const obj of objects) {
+    for (const key of Object.keys(obj)) {
+      const val = obj[key];
+      if (isPlainObject(val) && isPlainObject(result[key])) {
+        result[key] = merge(result[key], val);
+      } else {
+        result[key] = val;
+      }
+    }
+  }
+  return result;
+};
+var flattenObject = (obj, prefix = "") => {
+  const result = {};
+  for (const key of Object.keys(obj)) {
+    const fullKey = prefix ? `${prefix}.${key}` : key;
+    const val = obj[key];
+    if (val !== null && typeof val === "object" && val.constructor === Object) {
+      Object.assign(result, flattenObject(val, fullKey));
+    } else {
+      result[fullKey] = val;
+    }
+  }
+  return result;
+};
+var unflattenObject = (obj) => {
+  const result = {};
+  for (const key of Object.keys(obj)) {
+    const parts = key.split(".");
+    let current = result;
+    for (let i = 0;i < parts.length - 1; i++) {
+      if (!(parts[i] in current))
+        current[parts[i]] = {};
+      current = current[parts[i]];
+    }
+    current[parts[parts.length - 1]] = obj[key];
+  }
+  return result;
+};
+var isPlainObj = (val) => val !== null && typeof val === "object" && val.constructor === Object;
+var deepEqual = (a, b) => {
+  if (a === b)
+    return true;
+  if (a == null || b == null)
+    return false;
+  if (typeof a !== typeof b)
+    return false;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length)
+      return false;
+    return a.every((v, i) => deepEqual(v, b[i]));
+  }
+  if (isPlainObj(a) && isPlainObj(b)) {
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length)
+      return false;
+    return keysA.every((k) => keysB.includes(k) && deepEqual(a[k], b[k]));
+  }
+  return false;
+};
+var diff = (a, b) => {
+  const result = {};
+  const allKeys = new Set([...Object.keys(a), ...Object.keys(b)]);
+  for (const key of allKeys) {
+    const valA = a[key];
+    const valB = b[key];
+    if (deepEqual(valA, valB))
+      continue;
+    if (isPlainObj(valA) && isPlainObj(valB)) {
+      const nested = diff(valA, valB);
+      if (Object.keys(nested).length > 0) {
+        result[key] = nested;
+      }
+    } else {
+      result[key] = valB;
+    }
+  }
+  return result;
+};
 // src/runtime/promise.ts
 var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var retry = async (fn, options) => {
+  const { retries = 3, delay = 1000, backoff = false } = options ?? {};
+  let lastError;
+  for (let attempt = 0;attempt <= retries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt < retries) {
+        const waitTime = backoff ? delay * Math.pow(2, attempt) : delay;
+        await sleep(waitTime);
+      }
+    }
+  }
+  throw lastError;
+};
+var timeout = (promise, ms, message) => Promise.race([
+  promise,
+  new Promise((_, reject) => setTimeout(() => reject(new Error(message ?? `Timed out after ${ms}ms`)), ms))
+]);
 // src/runtime/regex.ts
 var isEmail = (value) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value);
 var isUrl = (value) => /^(https?|ftp):\/\/[^\s/$.?#].[^\s]*$/.test(value);
@@ -144,6 +509,48 @@ var toBytes = (size) => {
       return;
   }
 };
+// src/runtime/string.ts
+var reverse = (str) => [...str].reverse().join("");
+var countOccurrences = (str, search) => {
+  if (search === "")
+    return 0;
+  let count = 0;
+  let pos = 0;
+  while ((pos = str.indexOf(search, pos)) !== -1) {
+    count++;
+    pos += search.length;
+  }
+  return count;
+};
+var pad = (str, length, char = " ", direction = "left") => {
+  if (str.length >= length)
+    return str;
+  const padChar = char[0] || " ";
+  switch (direction) {
+    case "right":
+      return str.padEnd(length, padChar);
+    case "both": {
+      const total = length - str.length;
+      const left = Math.floor(total / 2);
+      const right = total - left;
+      return padChar.repeat(left) + str + padChar.repeat(right);
+    }
+    default:
+      return str.padStart(length, padChar);
+  }
+};
+var mask = (str, visibleCount = 4, maskChar = "*") => {
+  if (str.length <= visibleCount)
+    return str;
+  const masked = maskChar[0].repeat(str.length - visibleCount);
+  return masked + str.slice(-visibleCount);
+};
+var initials = (name) => name.split(/\s+/).filter(Boolean).map((word) => word[0]).join("").toUpperCase();
+var wordCount = (str) => {
+  const words = str.trim().split(/\s+/).filter(Boolean);
+  return str.trim() === "" ? 0 : words.length;
+};
+var isBlank = (str) => str.trim() === "";
 // src/runtime/time.ts
 var formatTime = (seconds) => {
   const hours = Math.floor(seconds / 3600);
@@ -159,15 +566,15 @@ var formatTime = (seconds) => {
 };
 var formatDuration = (ms) => {
   const sec = Math.floor(ms / 1000);
-  const min = Math.floor(sec / 60);
-  const hrs = Math.floor(min / 60);
+  const min2 = Math.floor(sec / 60);
+  const hrs = Math.floor(min2 / 60);
   const days = Math.floor(hrs / 24);
   if (days > 0)
     return `${days}d ${hrs % 24}h`;
   if (hrs > 0)
-    return `${hrs}h ${min % 60}m`;
-  if (min > 0)
-    return `${min}m ${sec % 60}s`;
+    return `${hrs}h ${min2 % 60}m`;
+  if (min2 > 0)
+    return `${min2}m ${sec % 60}s`;
   return `${sec}s`;
 };
 var toSeconds = (time) => {
@@ -223,6 +630,13 @@ var isJSON = (value) => {
     return false;
   }
 };
+var isFunction = (value) => typeof value === "function";
+var isDate = (value) => value instanceof Date && !isNaN(value.getTime());
+var isNumber = (value) => typeof value === "number" && !isNaN(value);
+var isString = (value) => typeof value === "string";
+var isBoolean = (value) => typeof value === "boolean";
+var isNil = (value) => value === null || value === undefined;
+var isRegExp = (value) => value instanceof RegExp;
 // src/runtime/url.ts
 var getQueryParams = (urlString) => {
   const url = new URL(urlString);
@@ -257,8 +671,10 @@ var buildUrl = (baseUrl, path, queryParams) => {
   return url.toString();
 };
 export {
+  wordCount,
   updateQueryParam,
   uniqueArray,
+  unflattenObject,
   unescapeHTML,
   truncate,
   toggleCase,
@@ -271,20 +687,49 @@ export {
   toConstantCase,
   toCamelCase,
   toBytes,
+  timeout,
+  throttle,
+  sum,
   stripTags,
+  splitWords,
+  sortBy,
   slugify,
   sleep,
+  shuffle,
+  sample,
+  round,
+  rgbToHex,
+  reverse,
+  retry,
   removeQueryParam,
+  range,
   rand,
+  pick,
   percentage,
+  pad,
+  once,
+  omit,
+  normalize,
+  noop,
+  min,
+  merge,
+  median,
+  max,
+  mask,
+  lighten,
+  last,
   isUrl,
   isUUID,
   isSupportedDisplayableMedia,
+  isString,
   isSlug,
+  isRegExp,
   isPrimitive,
   isPostalCode,
   isPhoneNumber,
   isObject,
+  isNumber,
+  isNil,
   isMacAddress,
   isJSON,
   isISODate,
@@ -292,23 +737,43 @@ export {
   isIPv4,
   isHexColor,
   isHex,
+  isFunction,
+  isEqual,
   isEmpty,
   isEmail,
   isDomain,
+  isDate,
   isCreditCard,
+  isBoolean,
+  isBlank,
   isBase64,
   isArray,
+  intersection,
+  initials,
+  hexToRgb,
+  hash,
   hasDuplicates,
+  groupBy,
   getQueryParams,
+  generateId,
   formatTime,
   formatNumber,
   formatDuration,
   formatBytes,
+  flattenObject,
   escapeHTML,
+  difference,
+  diff,
+  debounce,
+  darken,
+  countOccurrences,
+  compact,
   clone,
   clamp,
+  chunk,
   catchError,
   capitalize,
   buildUrl,
+  average,
   SUPPORTED_DISPLAYABLE_MEDIA_TYPES
 };