@lee-zg/melange 1.0.0

package/dist/chunk-352XNR3C.js

@@ -0,0 +1,716 @@
+import { __name } from './chunk-7QVYU63E.js';
+
+// src/utils/object.ts
+function deepClone(value) {
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  if (value instanceof Date) {
+    return new Date(value.getTime());
+  }
+  if (value instanceof RegExp) {
+    return new RegExp(value.source, value.flags);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => deepClone(item));
+  }
+  if (value instanceof Map) {
+    const result2 = /* @__PURE__ */ new Map();
+    value.forEach((v, k) => {
+      result2.set(deepClone(k), deepClone(v));
+    });
+    return result2;
+  }
+  if (value instanceof Set) {
+    const result2 = /* @__PURE__ */ new Set();
+    value.forEach((v) => {
+      result2.add(deepClone(v));
+    });
+    return result2;
+  }
+  const result = {};
+  for (const key of Object.keys(value)) {
+    result[key] = deepClone(value[key]);
+  }
+  return result;
+}
+__name(deepClone, "deepClone");
+function deepMerge(...objects) {
+  const result = {};
+  for (const obj of objects) {
+    if (!obj) continue;
+    for (const key of Object.keys(obj)) {
+      const targetValue = result[key];
+      const sourceValue = obj[key];
+      if (isPlainObject(targetValue) && isPlainObject(sourceValue)) {
+        result[key] = deepMerge(
+          targetValue,
+          sourceValue
+        );
+      } else {
+        result[key] = deepClone(sourceValue);
+      }
+    }
+  }
+  return result;
+}
+__name(deepMerge, "deepMerge");
+function pick(obj, keys) {
+  const result = {};
+  for (const key of keys) {
+    if (key in obj) {
+      result[key] = obj[key];
+    }
+  }
+  return result;
+}
+__name(pick, "pick");
+function omit(obj, keys) {
+  const keysSet = new Set(keys);
+  const result = {};
+  for (const key of Object.keys(obj)) {
+    if (!keysSet.has(key)) {
+      result[key] = obj[key];
+    }
+  }
+  return result;
+}
+__name(omit, "omit");
+function get(obj, path, defaultValue) {
+  const keys = typeof path === "string" ? path.split(".") : path;
+  let result = obj;
+  for (const key of keys) {
+    if (result == null || typeof result !== "object") {
+      return defaultValue;
+    }
+    result = result[key];
+  }
+  return result === void 0 ? defaultValue : result;
+}
+__name(get, "get");
+function set(obj, path, value) {
+  const keys = typeof path === "string" ? path.split(".") : path;
+  let current = obj;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    if (key === void 0) continue;
+    if (current[key] == null || typeof current[key] !== "object") {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  const lastKey = keys[keys.length - 1];
+  if (lastKey !== void 0) {
+    current[lastKey] = value;
+  }
+  return obj;
+}
+__name(set, "set");
+function has(obj, path) {
+  const keys = typeof path === "string" ? path.split(".") : path;
+  let current = obj;
+  for (const key of keys) {
+    if (current == null || typeof current !== "object") {
+      return false;
+    }
+    if (!(key in current)) {
+      return false;
+    }
+    current = current[key];
+  }
+  return true;
+}
+__name(has, "has");
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+__name(isPlainObject, "isPlainObject");
+function fromEntries(entries) {
+  const result = {};
+  for (const [key, value] of entries) {
+    result[key] = value;
+  }
+  return result;
+}
+__name(fromEntries, "fromEntries");
+function mapValues(obj, fn) {
+  const result = {};
+  for (const key of Object.keys(obj)) {
+    const value = obj[key];
+    if (value !== void 0) {
+      result[key] = fn(value, key);
+    }
+  }
+  return result;
+}
+__name(mapValues, "mapValues");
+function filterObject(obj, predicate) {
+  const result = {};
+  for (const key of Object.keys(obj)) {
+    const value = obj[key];
+    if (value !== void 0 && predicate(value, key)) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+__name(filterObject, "filterObject");
+
+// src/utils/array.ts
+function chunk(array, size) {
+  if (size <= 0) {
+    throw new Error("Chunk size must be positive");
+  }
+  const result = [];
+  for (let i = 0; i < array.length; i += size) {
+    result.push(array.slice(i, i + size));
+  }
+  return result;
+}
+__name(chunk, "chunk");
+function flatten(array) {
+  const result = [];
+  for (const item of array) {
+    if (Array.isArray(item)) {
+      result.push(...item);
+    } else {
+      result.push(item);
+    }
+  }
+  return result;
+}
+__name(flatten, "flatten");
+function flattenDeep(array) {
+  const result = [];
+  function flattenHelper(arr) {
+    for (const item of arr) {
+      if (Array.isArray(item)) {
+        flattenHelper(item);
+      } else {
+        result.push(item);
+      }
+    }
+  }
+  __name(flattenHelper, "flattenHelper");
+  flattenHelper(array);
+  return result;
+}
+__name(flattenDeep, "flattenDeep");
+function unique(array, keyFn) {
+  if (!keyFn) {
+    return [...new Set(array)];
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const item of array) {
+    const key = keyFn(item);
+    if (!seen.has(key)) {
+      seen.add(key);
+      result.push(item);
+    }
+  }
+  return result;
+}
+__name(unique, "unique");
+function groupBy(array, keyFn) {
+  const result = {};
+  for (const item of array) {
+    const key = keyFn(item);
+    if (!result[key]) {
+      result[key] = [];
+    }
+    result[key].push(item);
+  }
+  return result;
+}
+__name(groupBy, "groupBy");
+function sortBy(array, keyFn, order = "asc") {
+  const multiplier = order === "asc" ? 1 : -1;
+  return [...array].sort((a, b) => {
+    const keyA = keyFn(a);
+    const keyB = keyFn(b);
+    if (keyA < keyB) return -1 * multiplier;
+    if (keyA > keyB) return 1 * multiplier;
+    return 0;
+  });
+}
+__name(sortBy, "sortBy");
+function partition(array, predicate) {
+  const pass = [];
+  const fail = [];
+  for (const item of array) {
+    if (predicate(item)) {
+      pass.push(item);
+    } else {
+      fail.push(item);
+    }
+  }
+  return [pass, fail];
+}
+__name(partition, "partition");
+function zip(arr1, arr2) {
+  const length = Math.min(arr1.length, arr2.length);
+  const result = [];
+  for (let i = 0; i < length; i++) {
+    const first2 = arr1[i];
+    const second = arr2[i];
+    if (first2 !== void 0 && second !== void 0) {
+      result.push([first2, second]);
+    }
+  }
+  return result;
+}
+__name(zip, "zip");
+function first(array) {
+  return array[0];
+}
+__name(first, "first");
+function last(array) {
+  return array[array.length - 1];
+}
+__name(last, "last");
+function sample(array) {
+  if (array.length === 0) return void 0;
+  return array[Math.floor(Math.random() * array.length)];
+}
+__name(sample, "sample");
+function 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;
+}
+__name(shuffle, "shuffle");
+function range(startOrEnd, end, step = 1) {
+  let start = 0;
+  let finalEnd = startOrEnd;
+  if (end !== void 0) {
+    start = startOrEnd;
+    finalEnd = end;
+  }
+  if (step === 0) {
+    throw new Error("Step cannot be zero");
+  }
+  const result = [];
+  if (step > 0) {
+    for (let i = start; i < finalEnd; i += step) {
+      result.push(i);
+    }
+  } else {
+    for (let i = start; i > finalEnd; i += step) {
+      result.push(i);
+    }
+  }
+  return result;
+}
+__name(range, "range");
+function intersection(arr1, arr2) {
+  const set2 = new Set(arr2);
+  return arr1.filter((item) => set2.has(item));
+}
+__name(intersection, "intersection");
+function difference(arr1, arr2) {
+  const set2 = new Set(arr2);
+  return arr1.filter((item) => !set2.has(item));
+}
+__name(difference, "difference");
+
+// src/utils/string.ts
+function capitalize(str) {
+  if (str.length === 0) return str;
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+__name(capitalize, "capitalize");
+function camelCase(str) {
+  return str.replace(
+    /[\s_-]+(.)?/g,
+    (_, char) => char ? char.toUpperCase() : ""
+  ).replace(/^[A-Z]/, (char) => char.toLowerCase());
+}
+__name(camelCase, "camelCase");
+function pascalCase(str) {
+  return capitalize(camelCase(str));
+}
+__name(pascalCase, "pascalCase");
+function snakeCase(str) {
+  return str.replace(/[\s-]+/g, "_").replace(/([a-z])([A-Z])/g, "$1_$2").replace(/([A-Z])([A-Z][a-z])/g, "$1_$2").toLowerCase();
+}
+__name(snakeCase, "snakeCase");
+function kebabCase(str) {
+  return str.replace(/[\s_]+/g, "-").replace(/([a-z])([A-Z])/g, "$1-$2").replace(/([A-Z])([A-Z][a-z])/g, "$1-$2").toLowerCase();
+}
+__name(kebabCase, "kebabCase");
+function constantCase(str) {
+  return snakeCase(str).toUpperCase();
+}
+__name(constantCase, "constantCase");
+function truncate(str, maxLength, suffix = "...") {
+  if (str.length <= maxLength) return str;
+  return str.slice(0, maxLength - suffix.length) + suffix;
+}
+__name(truncate, "truncate");
+function padStart(str, length, padChar = " ") {
+  if (str.length >= length) return str;
+  const padding = padChar.repeat(Math.ceil((length - str.length) / padChar.length));
+  return (padding + str).slice(-length);
+}
+__name(padStart, "padStart");
+function padEnd(str, length, padChar = " ") {
+  if (str.length >= length) return str;
+  const padding = padChar.repeat(Math.ceil((length - str.length) / padChar.length));
+  return (str + padding).slice(0, length);
+}
+__name(padEnd, "padEnd");
+function collapseWhitespace(str) {
+  return str.replace(/\s+/g, " ").trim();
+}
+__name(collapseWhitespace, "collapseWhitespace");
+function escapeHtml(str) {
+  const htmlEntities = {
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#39;"
+  };
+  return str.replace(/[&<>"']/g, (char) => htmlEntities[char] ?? char);
+}
+__name(escapeHtml, "escapeHtml");
+function unescapeHtml(str) {
+  const htmlEntities = {
+    "&amp;": "&",
+    "&lt;": "<",
+    "&gt;": ">",
+    "&quot;": '"',
+    "&#39;": "'",
+    "&apos;": "'"
+  };
+  return str.replace(
+    /&(?:amp|lt|gt|quot|#39|apos);/g,
+    (entity) => htmlEntities[entity] ?? entity
+  );
+}
+__name(unescapeHtml, "unescapeHtml");
+function randomString(length, chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789") {
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    result += chars.charAt(Math.floor(Math.random() * chars.length));
+  }
+  return result;
+}
+__name(randomString, "randomString");
+function words(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[\s_-]+/g, " ").trim().split(" ").filter((word) => word.length > 0);
+}
+__name(words, "words");
+function titleCase(str) {
+  return words(str).map((word) => capitalize(word.toLowerCase())).join(" ");
+}
+__name(titleCase, "titleCase");
+function reverse(str) {
+  return [...str].reverse().join("");
+}
+__name(reverse, "reverse");
+function countOccurrences(str, substr) {
+  if (substr.length === 0) return 0;
+  let count = 0;
+  let pos = 0;
+  while ((pos = str.indexOf(substr, pos)) !== -1) {
+    count++;
+    pos += substr.length;
+  }
+  return count;
+}
+__name(countOccurrences, "countOccurrences");
+
+// src/utils/timing.ts
+function debounce(fn, wait, options) {
+  const { leading = false, trailing = true } = options ?? {};
+  let timeoutId = null;
+  let lastArgs = null;
+  let lastThis = null;
+  let result;
+  function invokeFunc() {
+    if (lastArgs !== null) {
+      result = fn.apply(lastThis, lastArgs);
+      lastArgs = null;
+      lastThis = null;
+    }
+  }
+  __name(invokeFunc, "invokeFunc");
+  function debounced(...args) {
+    lastArgs = args;
+    lastThis = this;
+    if (leading && timeoutId === null) {
+      invokeFunc();
+    }
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      if (trailing) {
+        invokeFunc();
+      }
+      timeoutId = null;
+    }, wait);
+    return result;
+  }
+  __name(debounced, "debounced");
+  debounced.cancel = () => {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+    lastArgs = null;
+    lastThis = null;
+  };
+  debounced.flush = () => {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+      if (trailing) {
+        invokeFunc();
+      }
+    }
+  };
+  return debounced;
+}
+__name(debounce, "debounce");
+function throttle(fn, limit) {
+  let lastCall = 0;
+  let timeoutId = null;
+  let lastArgs = null;
+  let lastThis = null;
+  function throttled(...args) {
+    const now = Date.now();
+    const remaining = limit - (now - lastCall);
+    lastArgs = args;
+    lastThis = this;
+    if (remaining <= 0) {
+      if (timeoutId !== null) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+      lastCall = now;
+      return fn.apply(this, args);
+    }
+    if (timeoutId === null) {
+      timeoutId = setTimeout(() => {
+        lastCall = Date.now();
+        timeoutId = null;
+        if (lastArgs !== null) {
+          fn.apply(lastThis, lastArgs);
+          lastArgs = null;
+          lastThis = null;
+        }
+      }, remaining);
+    }
+    return void 0;
+  }
+  __name(throttled, "throttled");
+  throttled.cancel = () => {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+    lastArgs = null;
+    lastThis = null;
+  };
+  return throttled;
+}
+__name(throttle, "throttle");
+function delay(ms, value) {
+  return new Promise((resolve) => setTimeout(() => resolve(value), ms));
+}
+__name(delay, "delay");
+async function retry(fn, options) {
+  const {
+    maxRetries = 3,
+    delay: retryDelay = 1e3,
+    backoff = "none",
+    onRetry
+  } = options ?? {};
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt < maxRetries) {
+        onRetry?.(error, attempt + 1);
+        let waitTime = retryDelay;
+        if (backoff === "linear") {
+          waitTime = retryDelay * (attempt + 1);
+        } else if (backoff === "exponential") {
+          waitTime = retryDelay * Math.pow(2, attempt);
+        }
+        await delay(waitTime);
+      }
+    }
+  }
+  throw lastError;
+}
+__name(retry, "retry");
+function timeout(promise, ms, errorMessage) {
+  let timeoutId;
+  const timeoutPromise = new Promise((_, reject) => {
+    timeoutId = setTimeout(() => {
+      reject(new Error(errorMessage ?? `Operation timed out after ${ms}ms`));
+    }, ms);
+  });
+  return Promise.race([promise, timeoutPromise]).finally(() => {
+    clearTimeout(timeoutId);
+  });
+}
+__name(timeout, "timeout");
+function createDeferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+__name(createDeferred, "createDeferred");
+async function parallel(tasks, options) {
+  const { concurrency = Infinity } = options ?? {};
+  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();
+      }
+    }
+  }
+  __name(runNext, "runNext");
+  const workers = Array.from(
+    { length: Math.min(concurrency, tasks.length) },
+    () => runNext()
+  );
+  await Promise.all(workers);
+  return results;
+}
+__name(parallel, "parallel");
+async function sequence(tasks) {
+  const results = [];
+  for (const task of tasks) {
+    results.push(await task());
+  }
+  return results;
+}
+__name(sequence, "sequence");
+
+// src/utils/guards.ts
+function isString(value) {
+  return typeof value === "string";
+}
+__name(isString, "isString");
+function isNumber(value) {
+  return typeof value === "number" && !Number.isNaN(value);
+}
+__name(isNumber, "isNumber");
+function isBoolean(value) {
+  return typeof value === "boolean";
+}
+__name(isBoolean, "isBoolean");
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isObject, "isObject");
+function isArray(value) {
+  return Array.isArray(value);
+}
+__name(isArray, "isArray");
+function isFunction(value) {
+  return typeof value === "function";
+}
+__name(isFunction, "isFunction");
+function isNil(value) {
+  return value === null || value === void 0;
+}
+__name(isNil, "isNil");
+function isNotNil(value) {
+  return value !== null && value !== void 0;
+}
+__name(isNotNil, "isNotNil");
+function isEmpty(value) {
+  if (isNil(value)) return true;
+  if (typeof value === "string") return value.length === 0;
+  if (Array.isArray(value)) return value.length === 0;
+  if (value instanceof Map || value instanceof Set) return value.size === 0;
+  if (typeof value === "object" && value !== null) return Object.keys(value).length === 0;
+  return false;
+}
+__name(isEmpty, "isEmpty");
+function isNotEmpty(value) {
+  return !isEmpty(value);
+}
+__name(isNotEmpty, "isNotEmpty");
+function isDate(value) {
+  return value instanceof Date && !Number.isNaN(value.getTime());
+}
+__name(isDate, "isDate");
+function isPromise(value) {
+  return value instanceof Promise || value !== null && typeof value === "object" && typeof value.then === "function";
+}
+__name(isPromise, "isPromise");
+function isSymbol(value) {
+  return typeof value === "symbol";
+}
+__name(isSymbol, "isSymbol");
+function isBigInt(value) {
+  return typeof value === "bigint";
+}
+__name(isBigInt, "isBigInt");
+function isEmail(value) {
+  if (!isString(value)) return false;
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return emailRegex.test(value);
+}
+__name(isEmail, "isEmail");
+function isUUID(value) {
+  if (!isString(value)) return false;
+  const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+  return uuidRegex.test(value);
+}
+__name(isUUID, "isUUID");
+function isURL(value) {
+  if (!isString(value)) return false;
+  try {
+    new URL(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(isURL, "isURL");
+function isInteger(value) {
+  return isNumber(value) && Number.isInteger(value);
+}
+__name(isInteger, "isInteger");
+function isPositive(value) {
+  return isNumber(value) && value > 0;
+}
+__name(isPositive, "isPositive");
+function isNegative(value) {
+  return isNumber(value) && value < 0;
+}
+__name(isNegative, "isNegative");
+function isInRange(value, min, max) {
+  return isNumber(value) && value >= min && value <= max;
+}
+__name(isInRange, "isInRange");
+
+export { camelCase, capitalize, chunk, collapseWhitespace, constantCase, countOccurrences, createDeferred, debounce, deepClone, deepMerge, delay, difference, escapeHtml, filterObject, first, flatten, flattenDeep, fromEntries, get, groupBy, has, intersection, isArray, isBigInt, isBoolean, isDate, isEmail, isEmpty, isFunction, isInRange, isInteger, isNegative, isNil, isNotEmpty, isNotNil, isNumber, isObject, isPlainObject, isPositive, isPromise, isString, isSymbol, isURL, isUUID, kebabCase, last, mapValues, omit, padEnd, padStart, parallel, partition, pascalCase, pick, randomString, range, retry, reverse, sample, sequence, set, shuffle, snakeCase, sortBy, throttle, timeout, titleCase, truncate, unescapeHtml, unique, words, zip };
+//# sourceMappingURL=chunk-352XNR3C.js.map
+//# sourceMappingURL=chunk-352XNR3C.js.map