@alibarbar/common 1.0.9 → 1.1.0

package/dist/{chunk-O3O67R4I.js → algorithm.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-// src/data/algorithm.ts
+// src/data/algorithm/index.ts
 function binarySearch(array, target, compareFn) {
   let left = 0;
   let right = array.length - 1;
@@ -139,5 +139,3 @@ exports.gcd = gcd;
 exports.lcm = lcm;
 exports.mergeSort = mergeSort;
 exports.quickSort = quickSort;
-//# sourceMappingURL=chunk-O3O67R4I.js.map
-//# sourceMappingURL=chunk-O3O67R4I.js.map

package/dist/algorithm.js

@@ -1,45 +1,131 @@
-'use strict';
+// src/data/algorithm/index.ts
+function binarySearch(array, target, compareFn) {
+  let left = 0;
+  let right = array.length - 1;
+  const compare = compareFn || ((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  while (left <= right) {
+    const mid = Math.floor((left + right) / 2);
+    const comparison = compare(array[mid], target);
+    if (comparison === 0) {
+      return mid;
+    } else if (comparison < 0) {
+      left = mid + 1;
+    } else {
+      right = mid - 1;
+    }
+  }
+  return -1;
+}
+function quickSort(array, compareFn) {
+  if (array.length <= 1) {
+    return [...array];
+  }
+  const compare = compareFn || ((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  const pivot = array[Math.floor(array.length / 2)];
+  const left = [];
+  const right = [];
+  const equal = [];
+  for (const item of array) {
+    const comparison = compare(item, pivot);
+    if (comparison < 0) {
+      left.push(item);
+    } else if (comparison > 0) {
+      right.push(item);
+    } else {
+      equal.push(item);
+    }
+  }
+  return [...quickSort(left, compareFn), ...equal, ...quickSort(right, compareFn)];
+}
+function mergeSort(array, compareFn) {
+  if (array.length <= 1) {
+    return [...array];
+  }
+  const compare = compareFn || ((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  const mid = Math.floor(array.length / 2);
+  const left = mergeSort(array.slice(0, mid), compareFn);
+  const right = mergeSort(array.slice(mid), compareFn);
+  return merge(left, right, compare);
+}
+function merge(left, right, compareFn) {
+  const result = [];
+  let i = 0;
+  let j = 0;
+  while (i < left.length && j < right.length) {
+    if (compareFn(left[i], right[j]) <= 0) {
+      result.push(left[i]);
+      i++;
+    } else {
+      result.push(right[j]);
+      j++;
+    }
+  }
+  return result.concat(left.slice(i)).concat(right.slice(j));
+}
+function bubbleSort(array, compareFn) {
+  const result = [...array];
+  const compare = compareFn || ((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  const n = result.length;
+  for (let i = 0; i < n - 1; i++) {
+    let swapped = false;
+    for (let j = 0; j < n - i - 1; j++) {
+      if (compare(result[j], result[j + 1]) > 0) {
+        [result[j], result[j + 1]] = [result[j + 1], result[j]];
+        swapped = true;
+      }
+    }
+    if (!swapped) {
+      break;
+    }
+  }
+  return result;
+}
+function fibonacci(n) {
+  if (n < 0) {
+    throw new Error("n must be non-negative");
+  }
+  if (n === 0) return 0;
+  if (n === 1) return 1;
+  let a = 0;
+  let b = 1;
+  for (let i = 2; i <= n; i++) {
+    [a, b] = [b, a + b];
+  }
+  return b;
+}
+function fibonacciSequence(n) {
+  if (n <= 0) return [];
+  if (n === 1) return [0];
+  if (n === 2) return [0, 1];
+  const sequence = [0, 1];
+  for (let i = 2; i < n; i++) {
+    sequence.push(sequence[i - 1] + sequence[i - 2]);
+  }
+  return sequence;
+}
+function factorial(n) {
+  if (n < 0) {
+    throw new Error("n must be non-negative");
+  }
+  if (n === 0 || n === 1) {
+    return 1;
+  }
+  let result = 1;
+  for (let i = 2; i <= n; i++) {
+    result *= i;
+  }
+  return result;
+}
+function gcd(a, b) {
+  a = Math.abs(a);
+  b = Math.abs(b);
+  while (b !== 0) {
+    [a, b] = [b, a % b];
+  }
+  return a;
+}
+function lcm(a, b) {
+  return Math.abs(a * b) / gcd(a, b);
+}
 
-var chunkO3O67R4I_js = require('./chunk-O3O67R4I.js');
-require('./chunk-PR4QN5HX.js');
-
-
-
-Object.defineProperty(exports, "binarySearch", {
-  enumerable: true,
-  get: function () { return chunkO3O67R4I_js.binarySearch; }
-});
-Object.defineProperty(exports, "bubbleSort", {
-  enumerable: true,
-  get: function () { return chunkO3O67R4I_js.bubbleSort; }
-});
-Object.defineProperty(exports, "factorial", {
-  enumerable: true,
-  get: function () { return chunkO3O67R4I_js.factorial; }
-});
-Object.defineProperty(exports, "fibonacci", {
-  enumerable: true,
-  get: function () { return chunkO3O67R4I_js.fibonacci; }
-});
-Object.defineProperty(exports, "fibonacciSequence", {
-  enumerable: true,
-  get: function () { return chunkO3O67R4I_js.fibonacciSequence; }
-});
-Object.defineProperty(exports, "gcd", {
-  enumerable: true,
-  get: function () { return chunkO3O67R4I_js.gcd; }
-});
-Object.defineProperty(exports, "lcm", {
-  enumerable: true,
-  get: function () { return chunkO3O67R4I_js.lcm; }
-});
-Object.defineProperty(exports, "mergeSort", {
-  enumerable: true,
-  get: function () { return chunkO3O67R4I_js.mergeSort; }
-});
-Object.defineProperty(exports, "quickSort", {
-  enumerable: true,
-  get: function () { return chunkO3O67R4I_js.quickSort; }
-});
-//# sourceMappingURL=algorithm.js.map
-//# sourceMappingURL=algorithm.js.map
+export { binarySearch, bubbleSort, factorial, fibonacci, fibonacciSequence, gcd, lcm, mergeSort, quickSort };

package/dist/{chunk-LOAZSPGQ.js → array.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-// src/core/array.ts
+// src/core/array/index.ts
 function unique(arr) {
   return Array.from(new Set(arr));
 }
@@ -154,5 +154,3 @@ exports.union = union;
 exports.unique = unique;
 exports.unzip = unzip;
 exports.zip = zip;
-//# sourceMappingURL=chunk-LOAZSPGQ.js.map
-//# sourceMappingURL=chunk-LOAZSPGQ.js.map

package/dist/array.js

@@ -1,85 +1,136 @@
-'use strict';
+// src/core/array/index.ts
+function unique(arr) {
+  return Array.from(new Set(arr));
+}
+function groupBy(arr, keyFn) {
+  const getKey = typeof keyFn === "string" ? (item) => item[keyFn] : keyFn;
+  return arr.reduce(
+    (acc, item) => {
+      const key = getKey(item);
+      if (!acc[key]) {
+        acc[key] = [];
+      }
+      acc[key].push(item);
+      return acc;
+    },
+    {}
+  );
+}
+function chunk(arr, size) {
+  const chunks = [];
+  for (let i = 0; i < arr.length; i += size) {
+    chunks.push(arr.slice(i, i + size));
+  }
+  return chunks;
+}
+function flatten(arr, depth = 1) {
+  return depth > 0 ? arr.reduce(
+    (acc, val) => acc.concat(Array.isArray(val) ? flatten(val, depth - 1) : val),
+    []
+  ) : arr;
+}
+function shuffle(arr) {
+  const result = [...arr];
+  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;
+}
+function sample(arr, count = 1) {
+  if (arr.length === 0) {
+    throw new Error("Cannot sample from empty array");
+  }
+  if (count === 1) {
+    const shuffled2 = shuffle(arr);
+    return shuffled2[0];
+  }
+  if (count >= arr.length) return [...arr];
+  const shuffled = shuffle(arr);
+  return shuffled.slice(0, count);
+}
+function difference(arr1, arr2) {
+  const set2 = new Set(arr2);
+  return arr1.filter((item) => !set2.has(item));
+}
+function intersection(arr1, arr2) {
+  const set2 = new Set(arr2);
+  return arr1.filter((item) => set2.has(item));
+}
+function union(arr1, arr2) {
+  return unique([...arr1, ...arr2]);
+}
+function sortBy(arr, keyFn, order = "asc") {
+  const getKey = typeof keyFn === "string" ? (item) => item[keyFn] : keyFn;
+  const result = [...arr];
+  result.sort((a, b) => {
+    const keyA = getKey(a);
+    const keyB = getKey(b);
+    if (keyA < keyB) return order === "asc" ? -1 : 1;
+    if (keyA > keyB) return order === "asc" ? 1 : -1;
+    return 0;
+  });
+  return result;
+}
+function findIndexBy(arr, predicate) {
+  return arr.findIndex(predicate);
+}
+function partition(arr, predicate) {
+  const truthy = [];
+  const falsy = [];
+  arr.forEach((item) => {
+    if (predicate(item)) {
+      truthy.push(item);
+    } else {
+      falsy.push(item);
+    }
+  });
+  return [truthy, falsy];
+}
+function zip(...arrays) {
+  const maxLength = Math.max(...arrays.map((arr) => arr.length));
+  const result = [];
+  for (let i = 0; i < maxLength; i++) {
+    result.push(
+      arrays.map((arr) => arr[i])
+    );
+  }
+  return result;
+}
+function unzip(array) {
+  if (array.length === 0) return [];
+  const length = array[0].length;
+  const result = Array.from({ length }, () => []);
+  array.forEach((item) => {
+    item.forEach((val, index) => {
+      result[index].push(val);
+    });
+  });
+  return result;
+}
+function compact(arr) {
+  return arr.filter((item) => Boolean(item));
+}
+function take(arr, n) {
+  return arr.slice(0, n);
+}
+function drop(arr, n) {
+  return arr.slice(n);
+}
+function takeWhile(arr, predicate) {
+  const result = [];
+  for (const item of arr) {
+    if (!predicate(item)) break;
+    result.push(item);
+  }
+  return result;
+}
+function dropWhile(arr, predicate) {
+  let index = 0;
+  while (index < arr.length && predicate(arr[index])) {
+    index++;
+  }
+  return arr.slice(index);
+}
 
-var chunkLOAZSPGQ_js = require('./chunk-LOAZSPGQ.js');
-require('./chunk-PR4QN5HX.js');
-
-
-
-Object.defineProperty(exports, "chunk", {
-  enumerable: true,
-  get: function () { return chunkLOAZSPGQ_js.chunk; }
-});
-Object.defineProperty(exports, "compact", {
-  enumerable: true,
-  get: function () { return chunkLOAZSPGQ_js.compact; }
-});
-Object.defineProperty(exports, "difference", {
-  enumerable: true,
-  get: function () { return chunkLOAZSPGQ_js.difference; }
-});
-Object.defineProperty(exports, "drop", {
-  enumerable: true,
-  get: function () { return chunkLOAZSPGQ_js.drop; }
-});
-Object.defineProperty(exports, "dropWhile", {
-  enumerable: true,
-  get: function () { return chunkLOAZSPGQ_js.dropWhile; }
-});
-Object.defineProperty(exports, "findIndexBy", {
-  enumerable: true,
-  get: function () { return chunkLOAZSPGQ_js.findIndexBy; }
-});
-Object.defineProperty(exports, "flatten", {
-  enumerable: true,
-  get: function () { return chunkLOAZSPGQ_js.flatten; }
-});
-Object.defineProperty(exports, "groupBy", {
-  enumerable: true,
-  get: function () { return chunkLOAZSPGQ_js.groupBy; }
-});
-Object.defineProperty(exports, "intersection", {
-  enumerable: true,
-  get: function () { return chunkLOAZSPGQ_js.intersection; }
-});
-Object.defineProperty(exports, "partition", {
-  enumerable: true,
-  get: function () { return chunkLOAZSPGQ_js.partition; }
-});
-Object.defineProperty(exports, "sample", {
-  enumerable: true,
-  get: function () { return chunkLOAZSPGQ_js.sample; }
-});
-Object.defineProperty(exports, "shuffle", {
-  enumerable: true,
-  get: function () { return chunkLOAZSPGQ_js.shuffle; }
-});
-Object.defineProperty(exports, "sortBy", {
-  enumerable: true,
-  get: function () { return chunkLOAZSPGQ_js.sortBy; }
-});
-Object.defineProperty(exports, "take", {
-  enumerable: true,
-  get: function () { return chunkLOAZSPGQ_js.take; }
-});
-Object.defineProperty(exports, "takeWhile", {
-  enumerable: true,
-  get: function () { return chunkLOAZSPGQ_js.takeWhile; }
-});
-Object.defineProperty(exports, "union", {
-  enumerable: true,
-  get: function () { return chunkLOAZSPGQ_js.union; }
-});
-Object.defineProperty(exports, "unique", {
-  enumerable: true,
-  get: function () { return chunkLOAZSPGQ_js.unique; }
-});
-Object.defineProperty(exports, "unzip", {
-  enumerable: true,
-  get: function () { return chunkLOAZSPGQ_js.unzip; }
-});
-Object.defineProperty(exports, "zip", {
-  enumerable: true,
-  get: function () { return chunkLOAZSPGQ_js.zip; }
-});
-//# sourceMappingURL=array.js.map
-//# sourceMappingURL=array.js.map
+export { chunk, compact, difference, drop, dropWhile, findIndexBy, flatten, groupBy, intersection, partition, sample, shuffle, sortBy, take, takeWhile, union, unique, unzip, zip };

package/dist/{chunk-Y364QIQH.js → color.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-// src/format/color.ts
+// src/format/color/index.ts
 function hexToRgb(hex) {
   const cleanHex = hex.replace("#", "");
   if (!/^[0-9A-Fa-f]{6}$/.test(cleanHex)) {
@@ -135,5 +135,3 @@ exports.lighten = lighten;
 exports.mix = mix;
 exports.rgbToHex = rgbToHex;
 exports.rgbToHsl = rgbToHsl;
-//# sourceMappingURL=chunk-Y364QIQH.js.map
-//# sourceMappingURL=chunk-Y364QIQH.js.map

package/dist/color.js

@@ -1,41 +1,128 @@
-'use strict';
+// src/format/color/index.ts
+function hexToRgb(hex) {
+  const cleanHex = hex.replace("#", "");
+  if (!/^[0-9A-Fa-f]{6}$/.test(cleanHex)) {
+    throw new Error("Invalid hex color format");
+  }
+  return {
+    r: parseInt(cleanHex.substring(0, 2), 16),
+    g: parseInt(cleanHex.substring(2, 4), 16),
+    b: parseInt(cleanHex.substring(4, 6), 16)
+  };
+}
+function rgbToHex(rgb) {
+  let r;
+  let g;
+  let b;
+  if (typeof rgb === "string") {
+    const match = rgb.match(/rgb\((\d+),\s*(\d+),\s*(\d+)\)/);
+    if (!match) {
+      throw new Error("Invalid RGB string format");
+    }
+    r = parseInt(match[1], 10);
+    g = parseInt(match[2], 10);
+    b = parseInt(match[3], 10);
+  } else {
+    r = rgb.r;
+    g = rgb.g;
+    b = rgb.b;
+  }
+  r = Math.max(0, Math.min(255, Math.round(r)));
+  g = Math.max(0, Math.min(255, Math.round(g)));
+  b = Math.max(0, Math.min(255, Math.round(b)));
+  return `#${r.toString(16).padStart(2, "0")}${g.toString(16).padStart(2, "0")}${b.toString(16).padStart(2, "0")}`.toUpperCase();
+}
+function rgbToHsl(rgb) {
+  const r = rgb.r / 255;
+  const g = rgb.g / 255;
+  const b = rgb.b / 255;
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  const delta = max - min;
+  let h = 0;
+  let s = 0;
+  const l = (max + min) / 2;
+  if (delta !== 0) {
+    s = l > 0.5 ? delta / (2 - max - min) : delta / (max + min);
+    if (max === r) {
+      h = ((g - b) / delta + (g < b ? 6 : 0)) / 6;
+    } else if (max === g) {
+      h = ((b - r) / delta + 2) / 6;
+    } else {
+      h = ((r - g) / delta + 4) / 6;
+    }
+  }
+  return {
+    h: Math.round(h * 360),
+    s: Math.round(s * 100),
+    l: Math.round(l * 100)
+  };
+}
+function hslToRgb(hsl) {
+  const h = hsl.h / 360;
+  const s = hsl.s / 100;
+  const l = hsl.l / 100;
+  let r;
+  let g;
+  let b;
+  if (s === 0) {
+    r = g = b = l;
+  } else {
+    const hue2rgb = (p2, q2, t) => {
+      if (t < 0) t += 1;
+      if (t > 1) t -= 1;
+      if (t < 1 / 6) return p2 + (q2 - p2) * 6 * t;
+      if (t < 1 / 2) return q2;
+      if (t < 2 / 3) return p2 + (q2 - p2) * (2 / 3 - t) * 6;
+      return p2;
+    };
+    const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+    const p = 2 * l - q;
+    r = hue2rgb(p, q, h + 1 / 3);
+    g = hue2rgb(p, q, h);
+    b = hue2rgb(p, q, h - 1 / 3);
+  }
+  return {
+    r: Math.round(r * 255),
+    g: Math.round(g * 255),
+    b: Math.round(b * 255)
+  };
+}
+function lighten(color, amount) {
+  const rgb = typeof color === "string" ? hexToRgb(color) : color;
+  const hsl = rgbToHsl(rgb);
+  hsl.l = Math.min(100, hsl.l + amount);
+  return rgbToHex(hslToRgb(hsl));
+}
+function darken(color, amount) {
+  const rgb = typeof color === "string" ? hexToRgb(color) : color;
+  const hsl = rgbToHsl(rgb);
+  hsl.l = Math.max(0, hsl.l - amount);
+  return rgbToHex(hslToRgb(hsl));
+}
+function mix(color1, color2, ratio) {
+  const rgb1 = hexToRgb(color1);
+  const rgb2 = hexToRgb(color2);
+  const r = Math.round(rgb1.r * (1 - ratio) + rgb2.r * ratio);
+  const g = Math.round(rgb1.g * (1 - ratio) + rgb2.g * ratio);
+  const b = Math.round(rgb1.b * (1 - ratio) + rgb2.b * ratio);
+  return rgbToHex({ r, g, b });
+}
+function contrast(color1, color2) {
+  const rgb1 = hexToRgb(color1);
+  const rgb2 = hexToRgb(color2);
+  const getLuminance = (rgb) => {
+    const normalize = (value) => {
+      value = value / 255;
+      return value <= 0.03928 ? value / 12.92 : Math.pow((value + 0.055) / 1.055, 2.4);
+    };
+    return 0.2126 * normalize(rgb.r) + 0.7152 * normalize(rgb.g) + 0.0722 * normalize(rgb.b);
+  };
+  const lum1 = getLuminance(rgb1);
+  const lum2 = getLuminance(rgb2);
+  const lighter = Math.max(lum1, lum2);
+  const darker = Math.min(lum1, lum2);
+  return (lighter + 0.05) / (darker + 0.05);
+}
 
-var chunkY364QIQH_js = require('./chunk-Y364QIQH.js');
-require('./chunk-PR4QN5HX.js');
-
-
-
-Object.defineProperty(exports, "contrast", {
-  enumerable: true,
-  get: function () { return chunkY364QIQH_js.contrast; }
-});
-Object.defineProperty(exports, "darken", {
-  enumerable: true,
-  get: function () { return chunkY364QIQH_js.darken; }
-});
-Object.defineProperty(exports, "hexToRgb", {
-  enumerable: true,
-  get: function () { return chunkY364QIQH_js.hexToRgb; }
-});
-Object.defineProperty(exports, "hslToRgb", {
-  enumerable: true,
-  get: function () { return chunkY364QIQH_js.hslToRgb; }
-});
-Object.defineProperty(exports, "lighten", {
-  enumerable: true,
-  get: function () { return chunkY364QIQH_js.lighten; }
-});
-Object.defineProperty(exports, "mix", {
-  enumerable: true,
-  get: function () { return chunkY364QIQH_js.mix; }
-});
-Object.defineProperty(exports, "rgbToHex", {
-  enumerable: true,
-  get: function () { return chunkY364QIQH_js.rgbToHex; }
-});
-Object.defineProperty(exports, "rgbToHsl", {
-  enumerable: true,
-  get: function () { return chunkY364QIQH_js.rgbToHsl; }
-});
-//# sourceMappingURL=color.js.map
-//# sourceMappingURL=color.js.map
+export { contrast, darken, hexToRgb, hslToRgb, lighten, mix, rgbToHex, rgbToHsl };