@oscarpalmer/atoms 0.74.1 → 0.76.0

package/dist/js/array/index.js

@@ -1,388 +1,41 @@
-// src/js/array/chunk.ts
-function chunk(array, size) {
-  const { length } = array;
-  const chunkSize = typeof size === "number" && size > 0 ? size : 64000;
-  if (length <= chunkSize) {
-    return [array];
-  }
-  const chunks = [];
-  let remaining = Number(length);
-  while (remaining > 0) {
-    chunks.push(array.splice(0, chunkSize));
-    remaining -= chunkSize;
-  }
-  return chunks;
-}
-
-// src/js/array/insert.ts
-function insert(array, index, values) {
-  insertValues("splice", array, values, index, 0);
-}
-function insertValues(type, array, values, start, deleteCount) {
-  const chunked = chunk(values);
-  const lastIndex = chunked.length - 1;
-  let index = Number(chunked.length);
-  let returned;
-  while (--index >= 0) {
-    const result = array.splice(start, index === lastIndex ? deleteCount : 0, ...chunked[index]);
-    if (returned == null) {
-      returned = result;
-    }
-  }
-  return type === "splice" ? returned : array.length;
-}
-
-// src/js/array/index.ts
+import { insertValues } from "./insert.js";
+import { insert } from "./insert.js";
+import { chunk } from "./chunk.js";
+import { compact } from "./compact.js";
+import { count } from "./count.js";
+import { exists } from "./exists.js";
+import { filter } from "./filter.js";
+import { find } from "./find.js";
+import { groupBy } from "./group-by.js";
+import { indexOf } from "./index-of.js";
+import { shuffle } from "./shuffle.js";
+import { sort } from "./sort.js";
+import { splice } from "./splice.js";
+import { toMap } from "./to-map.js";
+import { toRecord } from "./to-record.js";
+import { unique } from "./unique.js";
 function flatten(array) {
   return array.flat(Number.POSITIVE_INFINITY);
 }
-function push(array, values) {
-  return insertValues("push", array, values, array.length, 0);
-}
-
-// src/js/array/compact.ts
-function compact(array, strict) {
-  return strict === true ? array.filter((item) => !!item) : array.filter((item) => item != null);
-}
-// src/js/internal/array-callbacks.ts
-function getCallbacks(bool, key) {
-  if (typeof bool === "function") {
-    return { bool };
-  }
-  if (typeof key === "function") {
-    return { key };
-  }
-  const isString = typeof key === "string";
-  if (!isString && typeof key !== "number" || isString && key.includes(".")) {
-    return;
-  }
-  return {
-    key: (value) => value?.[key]
-  };
-}
-
-// src/js/internal/array-find.ts
-function findValue(type, array, value, key) {
-  const callbacks = getCallbacks(value, key);
-  if (callbacks?.bool == null && callbacks?.key == null) {
-    return type === "index" ? array.indexOf(value) : array.find((item) => item === value);
-  }
-  if (callbacks.bool != null) {
-    const index = array.findIndex(callbacks.bool);
-    return type === "index" ? index : index > -1 ? array[index] : undefined;
-  }
-  const { length } = array;
-  for (let index = 0;index < length; index += 1) {
-    const item = array[index];
-    if (callbacks.key?.(item, index, array) === value) {
-      return type === "index" ? index : item;
-    }
-  }
-  return type === "index" ? -1 : undefined;
-}
-function findValues(type, array, value, key) {
-  const callbacks = getCallbacks(value, key);
-  const { length } = array;
-  if (type === "unique" && callbacks?.key == null && length >= 100) {
-    return Array.from(new Set(array));
-  }
-  if (typeof callbacks?.bool === "function") {
-    return array.filter(callbacks.bool);
-  }
-  if (type === "all" && key == null) {
-    return array.filter((item) => item === value);
-  }
-  const hasCallback = typeof callbacks?.key === "function";
-  const result = [];
-  const values = hasCallback ? [] : result;
-  for (let index = 0;index < length; index += 1) {
-    const item = array[index];
-    const itemKey = hasCallback ? callbacks.key?.(item, index, array) : item;
-    if (type === "all" && itemKey === value || type === "unique" && values.indexOf(itemKey) === -1) {
-      if (values !== result) {
-        values.push(itemKey);
-      }
-      result.push(item);
-    }
-  }
-  return result;
-}
-
-// src/js/array/count.ts
-function count(array, value, key) {
-  return findValues("all", array, value, key).length;
-}
-// src/js/array/exists.ts
-function exists(array, value, key) {
-  return findValue("index", array, value, key) > -1;
-}
-// src/js/array/filter.ts
-function filter(array, value, key) {
-  return findValues("all", array, value, key);
-}
-// src/js/array/find.ts
-function find(array, value, key) {
-  return findValue("value", array, value, key);
-}
-// src/js/array/group-by.ts
-function groupBy(array, key) {
-  return groupValues(array, key, true, false);
-}
-function groupValues(array, key, arrays, indicable) {
-  const callbacks = getCallbacks(undefined, key);
-  const hasCallback = typeof callbacks?.key === "function";
-  if (!hasCallback && !indicable) {
-    return {};
-  }
-  const record = {};
-  const { length } = array;
-  for (let index = 0;index < length; index += 1) {
-    const value = array[index];
-    const key2 = hasCallback ? callbacks?.key?.(value, index, array) ?? index : index;
-    if (arrays) {
-      const existing = record[key2];
-      if (Array.isArray(existing)) {
-        existing.push(value);
-      } else {
-        record[key2] = [value];
-      }
-    } else {
-      record[key2] = value;
-    }
-  }
-  return record;
-}
-// src/js/array/index-of.ts
-function indexOf(array, value, key) {
-  return findValue("index", array, value, key);
-}
-// src/js/random.ts
-function getRandomFloat(min, max) {
-  const minimum = min ?? Number.MIN_SAFE_INTEGER;
-  return Math.random() * ((max ?? Number.MAX_SAFE_INTEGER) - minimum) + minimum;
-}
-function getRandomInteger(min, max) {
-  return Math.floor(getRandomFloat(min, max));
-}
-
-// src/js/array/shuffle.ts
-function shuffle(array) {
-  const shuffled = array.slice();
-  const { length } = shuffled;
-  for (let index = 0;index < length; index += 1) {
-    const random = getRandomInteger(0, length);
-    [shuffled[index], shuffled[random]] = [shuffled[random], shuffled[index]];
-  }
-  return shuffled;
-}
-// src/js/string/index.ts
-function getString(value) {
-  if (typeof value === "string") {
-    return value;
-  }
-  if (typeof value !== "object" || value == null) {
-    return String(value);
-  }
-  const valueOff = value.valueOf?.() ?? value;
-  const asString = valueOff?.toString?.() ?? String(valueOff);
-  return asString.startsWith("[object ") ? JSON.stringify(value) : asString;
-}
-function join(value, delimiter) {
-  return compact(value).map(getString).filter((value2) => value2.trim().length > 0).join(typeof delimiter === "string" ? delimiter : "");
-}
-function words(value) {
-  return value.match(/[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g) ?? [];
-}
-// src/js/math.ts
-function max(values) {
-  return values.length > 0 ? Math.max(...values) : Number.NaN;
-}
-
-// src/js/number.ts
-function getNumber(value) {
-  if (typeof value === "number") {
-    return value;
-  }
-  if (typeof value === "symbol") {
-    return Number.NaN;
-  }
-  let parsed = value?.valueOf?.() ?? value;
-  if (typeof parsed === "object") {
-    parsed = parsed?.toString() ?? parsed;
-  }
-  if (typeof parsed !== "string") {
-    return parsed == null ? Number.NaN : typeof parsed === "number" ? parsed : +parsed;
-  }
-  if (/^\s*0+\s*$/.test(parsed)) {
-    return 0;
-  }
-  const trimmed = parsed.trim();
-  if (trimmed.length === 0) {
-    return Number.NaN;
-  }
-  const isBinary = /^0b[01]+$/i.test(trimmed);
-  if (isBinary || /^0o[0-7]+$/i.test(trimmed)) {
-    return Number.parseInt(trimmed.slice(2), isBinary ? 2 : 8);
-  }
-  return +(/^0x[0-9a-f]+$/i.test(trimmed) ? trimmed : trimmed.replace(/_/g, ""));
-}
-
-// src/js/value/compare.ts
-function compare(first, second) {
-  const firstParts = getParts(first);
-  const secondParts = getParts(second);
-  const length = max([firstParts.length, secondParts.length]);
-  const lastIndex = length - 1;
-  for (let index = 0;index < length; index += 1) {
-    const firstPart = firstParts[index];
-    const secondPart = secondParts[index];
-    if (firstPart === secondPart) {
-      if (index === lastIndex) {
-        return 0;
-      }
-      continue;
-    }
-    if (firstPart == null || typeof firstPart === "string" && firstPart.length === 0) {
-      return -1;
-    }
-    if (secondPart == null || typeof secondPart === "string" && secondPart.length === 0) {
-      return 1;
-    }
-    const firstNumber = getNumber(firstPart);
-    const secondNumber = getNumber(secondPart);
-    const firstIsNaN = Number.isNaN(firstNumber);
-    const secondIsNaN = Number.isNaN(secondNumber);
-    if (firstIsNaN || secondIsNaN) {
-      if (firstIsNaN && secondIsNaN) {
-        return getString(firstPart).localeCompare(getString(secondPart));
-      }
-      if (firstIsNaN) {
-        return 1;
-      }
-      if (secondIsNaN) {
-        return -1;
-      }
-    }
-    if (firstNumber === secondNumber) {
-      if (index === lastIndex) {
-        return 0;
-      }
-      continue;
-    }
-    return firstNumber - secondNumber;
-  }
-  return join(firstParts).localeCompare(join(secondParts));
-}
-function getParts(value) {
-  if (value == null) {
-    return [""];
-  }
-  if (Array.isArray(value)) {
-    return value;
-  }
-  return typeof value === "object" ? [value] : words(getString(value));
-}
-// src/js/is.ts
-function isKey(value) {
-  return typeof value === "number" || typeof value === "string";
-}
-
-// src/js/array/sort.ts
-function sort(array, first, second) {
-  if (array.length < 2) {
-    return array;
-  }
-  if (first == null || typeof first === "boolean") {
-    return first === true ? array.sort((first2, second2) => second2 - first2) : array.sort();
-  }
-  const direction = second === true ? "desc" : "asc";
-  const keys = (Array.isArray(first) ? first : [first]).map((key) => {
-    const returned = {
-      direction,
-      callback: undefined
-    };
-    if (isKey(key)) {
-      returned.callback = (value) => value[key];
-    } else if (typeof key === "function") {
-      returned.callback = key;
-    } else if (typeof key?.value === "function" || isKey(key?.value)) {
-      returned.direction = key?.direction ?? direction;
-      returned.callback = typeof key.value === "function" ? key.value : (value) => value[key.value];
-    }
-    return returned;
-  }).filter((key) => typeof key.callback === "function");
-  const { length } = keys;
-  if (length === 0) {
-    return direction === "asc" ? array.sort() : array.sort((first2, second2) => second2 - first2);
-  }
-  if (length === 1) {
-    return array.sort((first2, second2) => compare(keys[0].callback(first2), keys[0].callback(second2)) * (keys[0].direction === "asc" ? 1 : -1));
-  }
-  const sorted = array.sort((first2, second2) => {
-    for (let index = 0;index < length; index += 1) {
-      const { callback, direction: direction2 } = keys[index];
-      const descending = direction2 === "desc";
-      const compared = compare(callback(descending ? second2 : first2), callback(descending ? first2 : second2));
-      if (compared !== 0) {
-        return compared;
-      }
-    }
-    return 0;
-  });
-  return sorted;
-}
-// src/js/array/splice.ts
-function splice(array, start, amountOrValues, values) {
-  const amoutOrValuesIsArray = Array.isArray(amountOrValues);
-  return insertValues("splice", array, amoutOrValuesIsArray ? amountOrValues : values ?? [], start, amoutOrValuesIsArray ? array.length : typeof amountOrValues === "number" && amountOrValues > 0 ? amountOrValues : 0);
-}
-// src/js/array/to-map.ts
-function toMap(array, first, second) {
-  const asArrays = first === true || second === true;
-  const callbacks = getCallbacks(undefined, first);
-  const hasCallback = typeof callbacks?.key === "function";
-  const map = new Map;
-  const { length } = array;
-  for (let index = 0;index < length; index += 1) {
-    const value = array[index];
-    const key = hasCallback ? callbacks?.key?.(value, index, array) ?? index : index;
-    if (asArrays) {
-      const existing = map.get(key);
-      if (Array.isArray(existing)) {
-        existing.push(value);
-      } else {
-        map.set(key, [value]);
-      }
-    } else {
-      map.set(key, value);
-    }
-  }
-  return map;
-}
-// src/js/array/to-record.ts
-function toRecord(array, first, second) {
-  return groupValues(array, first, first === true || second === true, true);
-}
-// src/js/array/unique.ts
-function unique(array, key) {
-  return findValues("unique", array, undefined, key);
+function push(array, pushed) {
+  return insertValues("push", array, pushed, array.length, 0);
 }
 export {
-  unique,
-  toRecord,
-  toMap,
-  splice,
-  sort,
-  shuffle,
-  push,
-  insert,
-  indexOf,
-  groupBy,
-  flatten,
-  find,
-  filter,
-  exists,
-  count,
+  chunk,
   compact,
-  chunk
+  count,
+  exists,
+  filter,
+  find,
+  flatten,
+  groupBy,
+  indexOf,
+  insert,
+  push,
+  shuffle,
+  sort,
+  splice,
+  toMap,
+  toRecord,
+  unique
 };

package/dist/js/array/insert.cjs

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const array_chunk = require("./chunk.cjs");
+function insert(array, first, second) {
+  insertValues(
+    "splice",
+    array,
+    Array.isArray(first) ? first : second ?? [],
+    typeof first === "number" ? first : array.length,
+    0
+  );
+}
+function insertValues(type, array, items, start, deleteCount) {
+  const chunked = array_chunk.chunk(items);
+  const lastIndex = chunked.length - 1;
+  let index = Number(chunked.length);
+  let returned;
+  while (--index >= 0) {
+    const result = array.splice(
+      start,
+      index === lastIndex ? deleteCount : 0,
+      ...chunked[index]
+    );
+    if (returned == null) {
+      returned = result;
+    }
+  }
+  return type === "splice" ? returned : array.length;
+}
+exports.insert = insert;
+exports.insertValues = insertValues;

package/dist/js/array/insert.js

@@ -0,0 +1,31 @@
+import { chunk } from "./chunk.js";
+function insert(array, first, second) {
+  insertValues(
+    "splice",
+    array,
+    Array.isArray(first) ? first : second ?? [],
+    typeof first === "number" ? first : array.length,
+    0
+  );
+}
+function insertValues(type, array, items, start, deleteCount) {
+  const chunked = chunk(items);
+  const lastIndex = chunked.length - 1;
+  let index = Number(chunked.length);
+  let returned;
+  while (--index >= 0) {
+    const result = array.splice(
+      start,
+      index === lastIndex ? deleteCount : 0,
+      ...chunked[index]
+    );
+    if (returned == null) {
+      returned = result;
+    }
+  }
+  return type === "splice" ? returned : array.length;
+}
+export {
+  insert,
+  insertValues
+};

package/dist/js/array/models.cjs

@@ -0,0 +1 @@
+"use strict";

package/dist/js/array/models.js

@@ -0,0 +1 @@
+

package/dist/js/array/shuffle.cjs

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const random = require("../random.cjs");
+function shuffle(array) {
+  const shuffled = array.slice();
+  const { length } = shuffled;
+  for (let index = 0; index < length; index += 1) {
+    const random$1 = random.getRandomInteger(0, length);
+    [shuffled[index], shuffled[random$1]] = [shuffled[random$1], shuffled[index]];
+  }
+  return shuffled;
+}
+exports.shuffle = shuffle;

package/dist/js/array/{shuffle.mjs → shuffle.js}

@@ -1,9 +1,8 @@
-// src/js/array/shuffle.ts
-import { getRandomInteger } from "../random";
+import { getRandomInteger } from "../random.js";
 function shuffle(array) {
   const shuffled = array.slice();
   const { length } = shuffled;
-  for (let index = 0;index < length; index += 1) {
+  for (let index = 0; index < length; index += 1) {
     const random = getRandomInteger(0, length);
     [shuffled[index], shuffled[random]] = [shuffled[random], shuffled[index]];
   }

package/dist/js/array/sort.cjs

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const is = require("../is.cjs");
+const value_compare = require("../value/compare.cjs");
+function sort(array, first, second) {
+  if (array.length < 2) {
+    return array;
+  }
+  if (first == null || typeof first === "boolean") {
+    return first === true ? array.sort((first2, second2) => second2 - first2) : array.sort();
+  }
+  const direction = second === true ? "desc" : "asc";
+  const keys = (Array.isArray(first) ? first : [first]).map((key) => {
+    const returned = {
+      direction,
+      callback: void 0
+    };
+    if (is.isKey(key)) {
+      returned.callback = (value) => value[key];
+    } else if (typeof key === "function") {
+      returned.callback = key;
+    } else if (typeof (key == null ? void 0 : key.value) === "function" || is.isKey(key == null ? void 0 : key.value)) {
+      returned.direction = (key == null ? void 0 : key.direction) ?? direction;
+      returned.callback = typeof key.value === "function" ? key.value : (value) => value[key.value];
+    }
+    return returned;
+  }).filter((key) => typeof key.callback === "function");
+  const { length } = keys;
+  if (length === 0) {
+    return direction === "asc" ? array.sort() : array.sort((first2, second2) => second2 - first2);
+  }
+  if (length === 1) {
+    return array.sort(
+      (first2, second2) => value_compare.compare(keys[0].callback(first2), keys[0].callback(second2)) * (keys[0].direction === "asc" ? 1 : -1)
+    );
+  }
+  const sorted = array.sort((first2, second2) => {
+    for (let index = 0; index < length; index += 1) {
+      const { callback, direction: direction2 } = keys[index];
+      const descending = direction2 === "desc";
+      const compared = value_compare.compare(
+        callback(descending ? second2 : first2),
+        callback(descending ? first2 : second2)
+      );
+      if (compared !== 0) {
+        return compared;
+      }
+    }
+    return 0;
+  });
+  return sorted;
+}
+exports.sort = sort;

package/dist/js/array/{sort.mjs → sort.js}

@@ -1,6 +1,5 @@
-// src/js/array/sort.ts
-import { isKey } from "../is";
-import { compare } from "../value/compare";
+import { isKey } from "../is.js";
+import { compare } from "../value/compare.js";
 function sort(array, first, second) {
   if (array.length < 2) {
     return array;
@@ -12,14 +11,14 @@ function sort(array, first, second) {
   const keys = (Array.isArray(first) ? first : [first]).map((key) => {
     const returned = {
       direction,
-      callback: undefined
+      callback: void 0
     };
     if (isKey(key)) {
       returned.callback = (value) => value[key];
     } else if (typeof key === "function") {
       returned.callback = key;
-    } else if (typeof key?.value === "function" || isKey(key?.value)) {
-      returned.direction = key?.direction ?? direction;
+    } else if (typeof (key == null ? void 0 : key.value) === "function" || isKey(key == null ? void 0 : key.value)) {
+      returned.direction = (key == null ? void 0 : key.direction) ?? direction;
       returned.callback = typeof key.value === "function" ? key.value : (value) => value[key.value];
     }
     return returned;
@@ -29,13 +28,18 @@ function sort(array, first, second) {
     return direction === "asc" ? array.sort() : array.sort((first2, second2) => second2 - first2);
   }
   if (length === 1) {
-    return array.sort((first2, second2) => compare(keys[0].callback(first2), keys[0].callback(second2)) * (keys[0].direction === "asc" ? 1 : -1));
+    return array.sort(
+      (first2, second2) => compare(keys[0].callback(first2), keys[0].callback(second2)) * (keys[0].direction === "asc" ? 1 : -1)
+    );
   }
   const sorted = array.sort((first2, second2) => {
-    for (let index = 0;index < length; index += 1) {
+    for (let index = 0; index < length; index += 1) {
       const { callback, direction: direction2 } = keys[index];
       const descending = direction2 === "desc";
-      const compared = compare(callback(descending ? second2 : first2), callback(descending ? first2 : second2));
+      const compared = compare(
+        callback(descending ? second2 : first2),
+        callback(descending ? first2 : second2)
+      );
       if (compared !== 0) {
         return compared;
       }

package/dist/js/array/splice.cjs

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const array_insert = require("./insert.cjs");
+function splice(array, start, first, second) {
+  const isArray = Array.isArray(first);
+  return array_insert.insertValues(
+    "splice",
+    array,
+    isArray ? first : second ?? [],
+    start,
+    isArray ? array.length : typeof first === "number" && first > 0 ? first : 0
+  );
+}
+exports.splice = splice;

package/dist/js/array/splice.js

@@ -0,0 +1,14 @@
+import { insertValues } from "./insert.js";
+function splice(array, start, first, second) {
+  const isArray = Array.isArray(first);
+  return insertValues(
+    "splice",
+    array,
+    isArray ? first : second ?? [],
+    start,
+    isArray ? array.length : typeof first === "number" && first > 0 ? first : 0
+  );
+}
+export {
+  splice
+};

package/dist/js/array/to-map.cjs

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const internal_array_callbacks = require("../internal/array/callbacks.cjs");
+function toMap(array, first, second, third) {
+  var _a, _b;
+  const asArrays = first === true || second === true || third === true;
+  const callbacks = internal_array_callbacks.getCallbacks(void 0, first, second);
+  const map = /* @__PURE__ */ new Map();
+  const { length } = array;
+  for (let index = 0; index < length; index += 1) {
+    const item = array[index];
+    const key = ((_a = callbacks == null ? void 0 : callbacks.key) == null ? void 0 : _a.call(callbacks, item, index, array)) ?? index;
+    const value = ((_b = callbacks == null ? void 0 : callbacks.value) == null ? void 0 : _b.call(callbacks, item, index, array)) ?? item;
+    if (asArrays) {
+      const existing = map.get(key);
+      if (existing == null) {
+        map.set(key, [value]);
+      } else {
+        existing.push(value);
+      }
+    } else {
+      map.set(key, value);
+    }
+  }
+  return map;
+}
+exports.toMap = toMap;