@oscarpalmer/atoms 0.56.0 → 0.57.0

package/dist/css/flex.css

@@ -2,10 +2,11 @@
   flex: 1;
 }
 
-:where(.flow, .flow-large, .flow-small,
+:where(.flow, .flow-large, .flow-small, .flow-text,
 .stack,
 .stack-large,
-.stack-small) {
+.stack-small,
+.stack-text) {
   display: flex;
 }
 

package/dist/js/array/chunk.mjs

@@ -0,0 +1,18 @@
+// src/js/array/chunk.ts
+function chunk(array, size) {
+  const { length } = array;
+  const chunkSize = typeof size === "number" && size > 0 ? size : 32000;
+  if (length <= chunkSize) {
+    return [array];
+  }
+  const chunks = [];
+  let remaining = Number(length);
+  while (remaining > 0) {
+    chunks.push(array.splice(0, chunkSize));
+    remaining -= chunkSize;
+  }
+  return chunks;
+}
+export {
+  chunk
+};

package/dist/js/array/exists.mjs

@@ -0,0 +1,8 @@
+// src/js/array/exists.ts
+import {findValue} from "../internal/array-find";
+function exists(array, value, key) {
+  return findValue("index", array, value, key) > -1;
+}
+export {
+  exists
+};

package/dist/js/array/filter.mjs

@@ -0,0 +1,8 @@
+// src/js/array/filter.ts
+import {findValues} from "../internal/array-find";
+function filter(array, value, key) {
+  return findValues("all", array, value, key);
+}
+export {
+  filter
+};

package/dist/js/array/find.mjs

@@ -0,0 +1,8 @@
+// src/js/array/find.ts
+import {findValue} from "../internal/array-find";
+function find(array, value, key) {
+  return findValue("value", array, value, key);
+}
+export {
+  find
+};

package/dist/js/array/group-by.mjs

@@ -0,0 +1,33 @@
+// src/js/array/group-by.ts
+import {getCallbacks} from "../internal/array-callbacks";
+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;
+}
+export {
+  groupValues,
+  groupBy
+};

package/dist/js/array/index-of.mjs

@@ -0,0 +1,8 @@
+// src/js/array/index-of.ts
+import {findValue} from "../internal/array-find";
+function indexOf(array, value, key) {
+  return findValue("index", array, value, key);
+}
+export {
+  indexOf
+};

package/dist/js/{array.js → array/index.js}

@@ -1,9 +1,4 @@
-// src/js/is.ts
-function isKey(value) {
-  return typeof value === "number" || typeof value === "string";
-}
-
-// src/js/array.ts
+// src/js/array/chunk.ts
 function chunk(array, size) {
   const { length } = array;
   const chunkSize = typeof size === "number" && size > 0 ? size : 32000;
@@ -18,24 +13,51 @@ function chunk(array, size) {
   }
   return chunks;
 }
-var comparison = function(first, second) {
-  if (typeof first === "number" && typeof second === "number") {
-    return first - second;
+
+// 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).reverse();
+  const { length } = chunked;
+  let returned;
+  for (let index = 0;index < length; index += 1) {
+    const result = array.splice(start, index === 0 ? deleteCount : 0, ...chunked[index]);
+    if (returned == null) {
+      returned = result;
+    }
   }
-  const firstAsNumber = Number(first);
-  const secondAsNumber = Number(second);
-  return Number.isNaN(firstAsNumber) || Number.isNaN(secondAsNumber) ? String(first).localeCompare(String(second)) : firstAsNumber - secondAsNumber;
-};
-function exists(array, value, key) {
-  return findValue("index", array, value, key) > -1;
+  return type === "splice" ? returned : array.length;
 }
-function filter(array, value, key) {
-  return findValues("all", array, value, key);
+
+// src/js/array/index.ts
+function compact(array2) {
+  return array2.filter((value) => value != null);
 }
-function find(array, value, key) {
-  return findValue("value", array, value, key);
+function push(array2, values) {
+  return insertValues("push", array2, values, array2.length, 0);
 }
-var findValue = function(type, array, value, key) {
+
+// 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);
@@ -52,8 +74,8 @@ var findValue = function(type, array, value, key) {
     }
   }
   return type === "index" ? -1 : undefined;
-};
-var findValues = function(type, array, value, key) {
+}
+function findValues(type, array, value, key) {
   const callbacks = getCallbacks(value, key);
   const { length } = array;
   if (type === "unique" && callbacks?.key == null && length >= 100) {
@@ -79,26 +101,25 @@ var findValues = function(type, array, value, key) {
     }
   }
   return result;
-};
-var getCallbacks = function(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/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);
 }
-var groupValues = function(array, key, arrays, indicable) {
+function groupValues(array, key, arrays, indicable) {
   const callbacks = getCallbacks(undefined, key);
   const hasCallback = typeof callbacks?.key === "function";
   if (!hasCallback && !indicable) {
@@ -121,34 +142,31 @@ var groupValues = function(array, key, arrays, indicable) {
     }
   }
   return record;
-};
+}
+// src/js/array/index-of.ts
 function indexOf(array, value, key) {
   return findValue("index", array, value, key);
 }
-function insert(array, index, values) {
-  insertValues("splice", array, values, index, 0);
+// src/js/is.ts
+function isKey(value) {
+  return typeof value === "number" || typeof value === "string";
 }
-var insertValues = function(type, array, values, start, deleteCount) {
-  const chunked = chunk(values).reverse();
-  const { length } = chunked;
-  let returned;
-  for (let index = 0;index < length; index += 1) {
-    const result = array.splice(start, index === 0 ? deleteCount : 0, ...chunked[index]);
-    if (returned == null) {
-      returned = result;
-    }
+
+// src/js/array/sort.ts
+var comparison = function(first, second) {
+  if (typeof first === "number" && typeof second === "number") {
+    return first - second;
   }
-  return type === "splice" ? returned : array.length;
+  const firstAsNumber = Number(first);
+  const secondAsNumber = Number(second);
+  return Number.isNaN(firstAsNumber) || Number.isNaN(secondAsNumber) ? String(first).localeCompare(String(second)) : firstAsNumber - secondAsNumber;
 };
-function push(array, values) {
-  return insertValues("push", array, values, array.length, 0);
-}
-function sort(array, first, second) {
-  if (array.length < 2) {
-    return array;
+function sort(array2, first, second) {
+  if (array2.length < 2) {
+    return array2;
   }
   if (first == null || typeof first === "boolean") {
-    return first === true ? array.sort((first2, second2) => second2 - first2) : array.sort();
+    return first === true ? array2.sort((first2, second2) => second2 - first2) : array2.sort();
   }
   const direction = second === true ? "desc" : "asc";
   const keys = (Array.isArray(first) ? first : [first]).map((key) => {
@@ -168,12 +186,12 @@ function sort(array, first, second) {
   }).filter((key) => typeof key.callback === "function");
   const { length } = keys;
   if (length === 0) {
-    return direction === "asc" ? array.sort() : array.sort((first2, second2) => second2 - first2);
+    return direction === "asc" ? array2.sort() : array2.sort((first2, second2) => second2 - first2);
   }
   if (length === 1) {
-    return array.sort((first2, second2) => comparison(keys[0].callback(first2), keys[0].callback(second2)) * (keys[0].direction === "asc" ? 1 : -1));
+    return array2.sort((first2, second2) => comparison(keys[0].callback(first2), keys[0].callback(second2)) * (keys[0].direction === "asc" ? 1 : -1));
   }
-  const sorted = array.sort((first2, second2) => {
+  const sorted = array2.sort((first2, second2) => {
     for (let index = 0;index < length; index += 1) {
       const { callback, direction: direction2 } = keys[index];
       const descending = direction2 === "desc";
@@ -186,19 +204,21 @@ function sort(array, first, second) {
   });
   return sorted;
 }
-function splice(array, start, amountOrValues, values) {
+// src/js/array/splice.ts
+function splice(array2, 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);
+  return insertValues("splice", array2, amoutOrValuesIsArray ? amountOrValues : values ?? [], start, amoutOrValuesIsArray ? array2.length : typeof amountOrValues === "number" && amountOrValues > 0 ? amountOrValues : 0);
 }
-function toMap(array, first, second) {
+// src/js/array/to-map.ts
+function toMap(array2, 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;
+  const { length } = array2;
   for (let index = 0;index < length; index += 1) {
-    const value = array[index];
-    const key = hasCallback ? callbacks?.key?.(value, index, array) ?? index : index;
+    const value = array2[index];
+    const key = hasCallback ? callbacks?.key?.(value, index, array2) ?? index : index;
     if (asArrays) {
       const existing = map.get(key);
       if (Array.isArray(existing)) {
@@ -212,11 +232,13 @@ function toMap(array, first, second) {
   }
   return map;
 }
-function toRecord(array, first, second) {
-  return groupValues(array, first, first === true || second === true, true);
+// src/js/array/to-record.ts
+function toRecord(array2, first, second) {
+  return groupValues(array2, first, first === true || second === true, true);
 }
-function unique(array, key) {
-  return findValues("unique", array, undefined, key);
+// src/js/array/unique.ts
+function unique(array2, key) {
+  return findValues("unique", array2, undefined, key);
 }
 export {
   unique,
@@ -231,5 +253,6 @@ export {
   find,
   filter,
   exists,
+  compact,
   chunk
 };

package/dist/js/array/index.mjs

@@ -0,0 +1,30 @@
+// src/js/array/index.ts
+import {insertValues} from "./insert";
+function compact(array) {
+  return array.filter((value) => value != null);
+}
+function push(array, values) {
+  return insertValues("push", array, values, array.length, 0);
+}
+
+export * from "./chunk";
+export * from "./exists";
+export * from "./filter";
+export * from "./find";
+import {groupBy} from "./group-by";
+
+export * from "./index-of";
+import {insert as insert2} from "./insert";
+import {sort} from "./sort";
+
+export * from "./splice";
+export * from "./to-map";
+export * from "./to-record";
+export * from "./unique";
+export {
+  sort,
+  push,
+  insert2 as insert,
+  groupBy,
+  compact
+};

package/dist/js/array/insert.mjs

@@ -0,0 +1,21 @@
+// src/js/array/insert.ts
+import {chunk as chunk2} from "./chunk";
+function insert(array, index, values) {
+  insertValues("splice", array, values, index, 0);
+}
+function insertValues(type, array, values, start, deleteCount) {
+  const chunked = chunk2(values).reverse();
+  const { length } = chunked;
+  let returned;
+  for (let index = 0;index < length; index += 1) {
+    const result = array.splice(start, index === 0 ? deleteCount : 0, ...chunked[index]);
+    if (returned == null) {
+      returned = result;
+    }
+  }
+  return type === "splice" ? returned : array.length;
+}
+export {
+  insertValues,
+  insert
+};

package/dist/js/array/sort.mjs

@@ -0,0 +1,56 @@
+// src/js/array/sort.ts
+import {isKey} from "../is";
+var comparison = function(first, second) {
+  if (typeof first === "number" && typeof second === "number") {
+    return first - second;
+  }
+  const firstAsNumber = Number(first);
+  const secondAsNumber = Number(second);
+  return Number.isNaN(firstAsNumber) || Number.isNaN(secondAsNumber) ? String(first).localeCompare(String(second)) : firstAsNumber - secondAsNumber;
+};
+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) => comparison(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 = comparison(callback(descending ? second2 : first2), callback(descending ? first2 : second2));
+      if (compared !== 0) {
+        return compared;
+      }
+    }
+    return 0;
+  });
+  return sorted;
+}
+export {
+  sort
+};

package/dist/js/array/splice.mjs

@@ -0,0 +1,9 @@
+// src/js/array/splice.ts
+import {insertValues} from "./insert";
+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);
+}
+export {
+  splice
+};

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

@@ -0,0 +1,27 @@
+// src/js/array/to-map.ts
+import {getCallbacks} from "../internal/array-callbacks";
+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;
+}
+export {
+  toMap
+};

package/dist/js/array/to-record.mjs

@@ -0,0 +1,8 @@
+// src/js/array/to-record.ts
+import {groupValues} from "./group-by";
+function toRecord(array, first, second) {
+  return groupValues(array, first, first === true || second === true, true);
+}
+export {
+  toRecord
+};

package/dist/js/array/unique.mjs

@@ -0,0 +1,8 @@
+// src/js/array/unique.ts
+import {findValues} from "../internal/array-find";
+function unique(array, key) {
+  return findValues("unique", array, undefined, key);
+}
+export {
+  unique
+};

package/dist/js/colour/hex.mjs

@@ -0,0 +1,51 @@
+// src/js/colour/hex.ts
+import {createRgb} from "./rgb";
+function createHex(original) {
+  let value = original.slice();
+  const instance = Object.create({
+    toHsl() {
+      return hexToRgb(value).toHsl();
+    },
+    toRgb() {
+      return hexToRgb(value);
+    },
+    toString() {
+      return `#${value}`;
+    }
+  });
+  Object.defineProperty(instance, "value", {
+    get() {
+      return `#${value}`;
+    },
+    set(hex) {
+      if (anyPattern.test(hex)) {
+        value = getNormalisedHex(hex);
+      }
+    }
+  });
+  return instance;
+}
+function getHexColour(value) {
+  return createHex(anyPattern.test(value) ? getNormalisedHex(value) : "000000");
+}
+var getNormalisedHex = function(value) {
+  const normalised = value.replace(/^#/, "");
+  return normalised.length === 3 ? normalised.split("").map((character) => character.repeat(2)).join("") : normalised;
+};
+function hexToRgb(value) {
+  const hex = anyPattern.test(value) ? getNormalisedHex(value) : "";
+  const pairs = groupedPattern.exec(hex) ?? [];
+  const rgb2 = [];
+  const { length } = pairs;
+  for (let index = 1;index < length; index += 1) {
+    rgb2.push(Number.parseInt(pairs[index], 16));
+  }
+  return createRgb({ blue: rgb2[2] ?? 0, green: rgb2[1] ?? 0, red: rgb2[0] ?? 0 });
+}
+var anyPattern = /^#*([a-f0-9]{3}){1,2}$/i;
+var groupedPattern = /^#*([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})$/i;
+export {
+  hexToRgb,
+  getHexColour,
+  createHex
+};

package/dist/js/colour/hsl.mjs

@@ -0,0 +1,47 @@
+// src/js/colour/hsl.ts
+import {createProperty} from "../internal/colour-property";
+import {clamp} from "../number";
+import {createRgb} from "./rgb";
+function createHsl(original) {
+  const value = { ...original };
+  const instance = Object.create({
+    toHex() {
+      return hslToRgb(value).toHex();
+    },
+    toRgb() {
+      return hslToRgb(value);
+    },
+    toString() {
+      return `hsl(${value.hue}, ${value.saturation}%, ${value.lightness}%)`;
+    }
+  });
+  Object.defineProperties(instance, {
+    hue: createProperty(value, "hue", 0, 360),
+    lightness: createProperty(value, "lightness", 0, 100),
+    saturation: createProperty(value, "saturation", 0, 100),
+    value: { value }
+  });
+  return instance;
+}
+function hslToRgb(value) {
+  let hue = value.hue % 360;
+  if (hue < 0) {
+    hue += 360;
+  }
+  const saturation = value.saturation / 100;
+  const lightness = value.lightness / 100;
+  function get(value2) {
+    const part = (value2 + hue / 30) % 12;
+    const mod = saturation * Math.min(lightness, 1 - lightness);
+    return lightness - mod * Math.max(-1, Math.min(part - 3, 9 - part, 1));
+  }
+  return createRgb({
+    blue: clamp(Math.round(get(4) * 255), 0, 255),
+    green: clamp(Math.round(get(8) * 255), 0, 255),
+    red: clamp(Math.round(get(0) * 255), 0, 255)
+  });
+}
+export {
+  hslToRgb,
+  createHsl
+};