@zairakai/js-utils 1.0.0

package/dist/chunk-42CHLXT7.js

@@ -0,0 +1,214 @@
+import {
+  EnhancedArray
+} from "./chunk-TY75OOIQ.js";
+
+// src/php-arrays.ts
+var array_chunk = (array, size) => {
+  if (0 >= size) {
+    return [];
+  }
+  const chunks = [];
+  for (let i = 0; i < array.length; i += size) {
+    chunks.push(array.slice(i, i + size));
+  }
+  return chunks;
+};
+var array_filter = (array, callback) => {
+  if (!callback) {
+    return array.filter((item) => Boolean(item));
+  }
+  return array.filter(callback);
+};
+var array_map = (callback, array) => {
+  return array.map(callback);
+};
+var array_reduce = (array, callback, initial) => {
+  return array.reduce((carry, item, index) => callback(carry, item, index), initial);
+};
+var array_merge = (...arrays) => {
+  return arrays.flat();
+};
+var array_unique = (array) => {
+  return [...new Set(array)];
+};
+var array_reverse = (array, _preserveKeys = false) => {
+  return [...array].reverse();
+};
+var array_slice = (array, offset, length) => {
+  const start = 0 > offset ? Math.max(0, array.length + offset) : offset;
+  const end = length !== void 0 ? start + length : void 0;
+  return array.slice(start, end);
+};
+var array_splice = (array, offset, length, ...replacement) => {
+  const result = [...array];
+  const actualLength = length ?? result.length - offset;
+  result.splice(offset, actualLength, ...replacement);
+  return result;
+};
+var array_keys = (array) => {
+  return array.map((_, index) => index);
+};
+var array_search = (needle, haystack) => {
+  const index = haystack.indexOf(needle);
+  return -1 !== index ? index : false;
+};
+var array_key_exists = (key, array) => {
+  return 0 <= key && key < array.length;
+};
+var array_pop = (array) => {
+  const result = [...array];
+  return result.pop();
+};
+var array_push = (array, ...values) => {
+  return [...array, ...values];
+};
+var array_shift = (array) => {
+  const result = [...array];
+  return result.shift();
+};
+var array_unshift = (array, ...values) => {
+  return [...values, ...array];
+};
+var array_sum = (array) => {
+  return array.reduce((sum, num) => sum + num, 0);
+};
+var array_product = (array) => {
+  return array.reduce((product, num) => product * num, 1);
+};
+var array_rand = (array, num = 1) => {
+  if (0 === array.length) {
+    return 1 === num ? void 0 : [];
+  }
+  const shuffled = [...array].sort(() => Math.random() - 0.5);
+  if (1 === num) {
+    return shuffled[0];
+  }
+  return shuffled.slice(0, Math.min(num, array.length));
+};
+var array_flip = (array) => {
+  const result = {};
+  array.forEach((value, index) => {
+    result[String(value)] = index;
+  });
+  return result;
+};
+var array_count_values = (array) => {
+  const result = {};
+  array.forEach((value) => {
+    const key = String(value);
+    result[key] = (result[key] || 0) + 1;
+  });
+  return result;
+};
+var array_intersect = (...arrays) => {
+  if (0 === arrays.length) {
+    return [];
+  }
+  const first = arrays[0];
+  return first.filter((item) => arrays.slice(1).every((arr) => arr.includes(item)));
+};
+var array_diff = (array1, ...arrays) => {
+  const otherItems = new Set(arrays.flat());
+  return array1.filter((item) => !otherItems.has(item));
+};
+var array_column = (array, column) => {
+  return array.map((item) => item && "object" === typeof item ? item[column] : void 0).filter((value) => value !== void 0);
+};
+var sort = (array) => {
+  return [...array].sort();
+};
+var rsort = (array) => {
+  return [...array].sort().reverse();
+};
+var usort = (array, compareFunction) => {
+  return [...array].sort(compareFunction);
+};
+var uasort = (array, compareFunction) => {
+  return [...array].sort(compareFunction);
+};
+var uksort = (array, compareFunction) => {
+  const indices = Array.from({ length: array.length }, (_, i) => i);
+  const sortedIndices = indices.sort(compareFunction);
+  return sortedIndices.map((i) => array[i]);
+};
+var shuffle = (array) => {
+  const result = [...array];
+  for (let i = result.length - 1; 0 < i; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [result[i], result[j]] = [result[j], result[i]];
+  }
+  return result;
+};
+var range = (start, end, step = 1) => {
+  const result = [];
+  if (0 < step) {
+    for (let i = start; i <= end; i += step) {
+      result.push(i);
+    }
+  } else if (0 > step) {
+    for (let i = start; i >= end; i += step) {
+      result.push(i);
+    }
+  }
+  return result;
+};
+var php_array = (items) => {
+  const enhanced = new EnhancedArray(...items);
+  Object.assign(enhanced, {
+    // PHP array functions as methods
+    chunk: (size) => array_chunk(enhanced, size),
+    merge: (...arrays) => new EnhancedArray(...array_merge(enhanced, ...arrays)),
+    unique: () => new EnhancedArray(...array_unique(enhanced)),
+    reverse: (preserveKeys = false) => new EnhancedArray(...array_reverse(enhanced, preserveKeys)),
+    search: (needle) => array_search(needle, enhanced),
+    sum: () => array_sum(enhanced),
+    product: () => array_product(enhanced),
+    rand: (num = 1) => array_rand(enhanced, num),
+    flip: () => array_flip(enhanced),
+    countValues: () => array_count_values(enhanced),
+    intersect: (...arrays) => new EnhancedArray(...array_intersect(enhanced, ...arrays)),
+    diff: (...arrays) => new EnhancedArray(...array_diff(enhanced, ...arrays)),
+    column: (column) => array_column(enhanced, column),
+    // PHP sorting as methods
+    sort: () => new EnhancedArray(...sort(enhanced)),
+    rsort: () => new EnhancedArray(...rsort(enhanced)),
+    shuffle: () => new EnhancedArray(...shuffle(enhanced)),
+    usort: (compareFunction) => new EnhancedArray(...usort(enhanced, compareFunction))
+  });
+  return enhanced;
+};
+
+export {
+  array_chunk,
+  array_filter,
+  array_map,
+  array_reduce,
+  array_merge,
+  array_unique,
+  array_reverse,
+  array_slice,
+  array_splice,
+  array_keys,
+  array_search,
+  array_key_exists,
+  array_pop,
+  array_push,
+  array_shift,
+  array_unshift,
+  array_sum,
+  array_product,
+  array_rand,
+  array_flip,
+  array_count_values,
+  array_intersect,
+  array_diff,
+  array_column,
+  sort,
+  rsort,
+  usort,
+  uasort,
+  uksort,
+  shuffle,
+  range,
+  php_array
+};

package/dist/chunk-7SXRFZBB.js

@@ -0,0 +1,173 @@
+// src/arrays.ts
+var arrayAdd = (array, key, value) => {
+  const result = Array.isArray(array) ? Object.fromEntries(array.map((v, i) => [i, v])) : { ...array };
+  result[key] = value;
+  return result;
+};
+var arrayCollapse = (array) => {
+  if (!Array.isArray(array)) {
+    return [];
+  }
+  return array.reduce((flat, item) => {
+    if (Array.isArray(item)) {
+      return flat.concat(item);
+    }
+    return flat.concat([item]);
+  }, []);
+};
+var arrayDivide = (array) => {
+  if (!Array.isArray(array)) {
+    return [[], []];
+  }
+  const keys = array.map((_, index) => index.toString());
+  const values = [...array];
+  return [keys, values];
+};
+var arrayDot = (array, prepend = "") => {
+  const result = {};
+  for (const [key, value] of Object.entries(array)) {
+    const newKey = prepend ? `${prepend}.${key}` : key;
+    if (value && "object" === typeof value && !Array.isArray(value)) {
+      Object.assign(result, arrayDot(value, newKey));
+    } else {
+      result[newKey] = value;
+    }
+  }
+  return result;
+};
+var arrayExcept = (array, keys) => {
+  if (!Array.isArray(array) || !Array.isArray(keys)) {
+    return array;
+  }
+  return array.filter((_, index) => !keys.includes(index.toString()));
+};
+var arrayFirst = (array, callback, defaultValue) => {
+  if (!Array.isArray(array)) {
+    return defaultValue;
+  }
+  if (!callback) {
+    return 0 < array.length ? array[0] : defaultValue;
+  }
+  for (let i = 0; i < array.length; i++) {
+    if (callback(array[i], i)) {
+      return array[i];
+    }
+  }
+  return defaultValue;
+};
+var arrayFlatten = (array, depth = Infinity) => {
+  if (!Array.isArray(array)) {
+    return [];
+  }
+  const flatten = (arr, currentDepth) => {
+    const result = [];
+    for (const item of arr) {
+      if (Array.isArray(item) && 0 < currentDepth) {
+        result.push(...flatten(item, currentDepth - 1));
+      } else {
+        result.push(item);
+      }
+    }
+    return result;
+  };
+  return flatten(array, depth);
+};
+var arrayGet = (array, key, defaultValue) => {
+  if (!array || "object" !== typeof array) {
+    return defaultValue;
+  }
+  const keys = key.split(".");
+  let current = array;
+  for (const k of keys) {
+    if (null === current || current === void 0 || "object" !== typeof current || !(k in current)) {
+      return defaultValue;
+    }
+    current = current[k];
+  }
+  return current;
+};
+var arrayHas = (array, keys) => {
+  if (!array || "object" !== typeof array) {
+    return false;
+  }
+  const keyArray = Array.isArray(keys) ? keys : [keys];
+  return keyArray.every((key) => {
+    const keyParts = key.split(".");
+    let current = array;
+    for (const part of keyParts) {
+      if (null === current || current === void 0 || "object" !== typeof current || !(part in current)) {
+        return false;
+      }
+      current = current[part];
+    }
+    return true;
+  });
+};
+var arrayOnly = (array, keys) => {
+  if (!Array.isArray(array) || !Array.isArray(keys)) {
+    return [];
+  }
+  return array.filter((_, index) => keys.includes(index.toString()));
+};
+var arrayWhere = (array, callback) => {
+  if (!Array.isArray(array)) {
+    return [];
+  }
+  return array.filter(callback);
+};
+var arrayPluck = (array, key) => {
+  if (!Array.isArray(array)) {
+    return [];
+  }
+  return array.map((item) => item && "object" === typeof item ? item[key] : void 0).filter((value) => value !== void 0);
+};
+var arrayGroupBy = (array, keyOrFn) => {
+  if (!Array.isArray(array)) {
+    return {};
+  }
+  return array.reduce(
+    (groups, item) => {
+      const key = "function" === typeof keyOrFn ? String(keyOrFn(item)) : String(item && "object" === typeof item ? item[keyOrFn] : item);
+      if (!groups[key]) {
+        groups[key] = [];
+      }
+      groups[key].push(item);
+      return groups;
+    },
+    {}
+  );
+};
+var arrayUnique = (array, key) => {
+  if (!Array.isArray(array)) {
+    return [];
+  }
+  if (!key) {
+    return [...new Set(array)];
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return array.filter((item) => {
+    const value = item && "object" === typeof item ? item[key] : item;
+    if (seen.has(value)) {
+      return false;
+    }
+    seen.add(value);
+    return true;
+  });
+};
+
+export {
+  arrayAdd,
+  arrayCollapse,
+  arrayDivide,
+  arrayDot,
+  arrayExcept,
+  arrayFirst,
+  arrayFlatten,
+  arrayGet,
+  arrayHas,
+  arrayOnly,
+  arrayWhere,
+  arrayPluck,
+  arrayGroupBy,
+  arrayUnique
+};

package/dist/chunk-F6RSTW65.js

@@ -0,0 +1,156 @@
+// src/formatters.ts
+var capitalize = (value) => {
+  if (value == null) {
+    return "";
+  }
+  const stringValue = String(value);
+  return stringValue.charAt(0).toUpperCase() + stringValue.slice(1).toLowerCase();
+};
+var slugify = (text) => {
+  if (!text) {
+    return "";
+  }
+  return text.toString().normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().trim().replace(/\s+/g, "-").replace(/[^\w-]+/g, "").replace(/--+/g, "-");
+};
+var strLimit = (value, size) => {
+  if (!value) {
+    return "";
+  }
+  const stringValue = String(value);
+  return stringValue.length <= size ? stringValue : `${stringValue.slice(0, size)}\u2026`;
+};
+var normalizeString = (value) => {
+  if (!value) {
+    return value;
+  }
+  return value.trim().toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+};
+var strContainsAll = (haystack, needles) => {
+  if (!haystack || !Array.isArray(needles)) {
+    return false;
+  }
+  return needles.every((needle) => haystack.includes(needle));
+};
+var strContainsAny = (haystack, needles) => {
+  if (!haystack || !Array.isArray(needles)) {
+    return false;
+  }
+  return needles.some((needle) => haystack.includes(needle));
+};
+var strFinish = (value, cap) => {
+  if (!value) {
+    return cap;
+  }
+  if (!cap) {
+    return value;
+  }
+  return value.endsWith(cap) ? value : value + cap;
+};
+var strStart = (value, prefix) => {
+  if (!value) {
+    return prefix;
+  }
+  if (!prefix) {
+    return value;
+  }
+  return value.startsWith(prefix) ? value : prefix + value;
+};
+var strPadBoth = (str, length, pad = " ") => {
+  if (str.length >= length) {
+    return str;
+  }
+  const totalPad = length - str.length;
+  const leftPad = Math.floor(totalPad / 2);
+  const rightPad = totalPad - leftPad;
+  return pad.repeat(leftPad) + str + pad.repeat(rightPad);
+};
+var strPadLeft = (str, length, pad = " ") => {
+  return str.padStart(length, pad);
+};
+var strPadRight = (str, length, pad = " ") => {
+  return str.padEnd(length, pad);
+};
+var strReverse = (value) => {
+  return value.split("").reverse().join("");
+};
+var strRemove = (search, subject, caseSensitive = true) => {
+  if (!search || !subject) {
+    return subject;
+  }
+  const flags = caseSensitive ? "g" : "gi";
+  return subject.replace(new RegExp(search.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), flags), "");
+};
+var strMask = (str, character, index, length) => {
+  if (!str) {
+    return str;
+  }
+  const start = Math.max(0, index);
+  const end = length !== void 0 ? start + length : str.length;
+  return str.substring(0, start) + character.repeat(end - start) + str.substring(end);
+};
+var strWordCount = (str, characters) => {
+  if (!str) {
+    return 0;
+  }
+  const pattern = characters ? new RegExp(`[${characters}\\s]+`) : /\s+/;
+  return str.trim().split(pattern).filter((word) => 0 < word.length).length;
+};
+var strWords = (value, words = 100, end = "...") => {
+  if (!value) {
+    return "";
+  }
+  const wordArray = value.trim().split(/\s+/);
+  if (wordArray.length <= words) {
+    return value;
+  }
+  return wordArray.slice(0, words).join(" ") + end;
+};
+var camelCase = (value) => {
+  const studly = studlyCase(value);
+  return studly.charAt(0).toLowerCase() + studly.slice(1);
+};
+var snakeCase = (value) => {
+  return value.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[\s-]+/g, "_").toLowerCase();
+};
+var kebabCase = (value) => {
+  return value.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+};
+var studlyCase = (value) => {
+  return value.replace(/[_-]/g, " ").replace(/\s+(.)/g, (_, c) => c.toUpperCase()).replace(/^(.)/, (_, c) => c.toUpperCase()).replace(/\s+/g, "");
+};
+var titleCase = (value) => {
+  return value.replace(/\w\S*/g, (txt) => {
+    return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
+  });
+};
+var numberFormat = (value, decimals = 2, locale = "en-US") => {
+  return new Intl.NumberFormat(locale, {
+    minimumFractionDigits: decimals,
+    maximumFractionDigits: decimals
+  }).format(value);
+};
+
+export {
+  capitalize,
+  slugify,
+  strLimit,
+  normalizeString,
+  strContainsAll,
+  strContainsAny,
+  strFinish,
+  strStart,
+  strPadBoth,
+  strPadLeft,
+  strPadRight,
+  strReverse,
+  strRemove,
+  strMask,
+  strWordCount,
+  strWords,
+  camelCase,
+  snakeCase,
+  kebabCase,
+  studlyCase,
+  titleCase,
+  numberFormat
+};