@oscarpalmer/atoms 0.95.0 → 0.97.0

package/dist/array/group-by.cjs

@@ -21,7 +21,7 @@ function groupValues(array, key, value, arrays) {
   const { length } = array;
   for (let index = 0; index < length; index += 1) {
     const item = array[index];
-    const keyed = callbacks?.key?.(item, index, array) ?? index;
+    const keyed = callbacks?.keyed?.(item, index, array) ?? index;
     const valued = callbacks?.value?.(item, index, array) ?? item;
     if (arrays) {
       const existing = record[keyed];

package/dist/array/group-by.js

@@ -17,7 +17,7 @@ function groupValues(array, key, value, arrays) {
   const { length } = array;
   for (let index = 0; index < length; index += 1) {
     const item = array[index];
-    const keyed = callbacks?.key?.(item, index, array) ?? index;
+    const keyed = callbacks?.keyed?.(item, index, array) ?? index;
     const valued = callbacks?.value?.(item, index, array) ?? item;
     if (arrays) {
       const existing = record[keyed];

package/dist/array/sort.cjs

@@ -13,34 +13,34 @@ function sort(array, first, second) {
     return array;
   }
   const direction = first === true || second === true ? "desc" : "asc";
-  const unknownKeys = Array.isArray(first) ? first : [first];
-  let { length } = unknownKeys;
-  const keys = [];
+  const unknownSorters = Array.isArray(first) ? first : [first];
+  let { length } = unknownSorters;
+  const sorters = [];
   for (let index = 0; index < length; index += 1) {
-    const key = unknownKeys[index];
-    const keyWithCallback = {
+    const unknownSorter = unknownSorters[index];
+    const sorter = {
       direction,
       callback: void 0
     };
-    if (is.isKey(key)) {
-      keyWithCallback.callback = (value) => value[key];
-    } else if (typeof key === "function") {
-      keyWithCallback.callback = key;
-    } else if (typeof key?.value === "function" || is.isKey(key?.value)) {
-      keyWithCallback.direction = key?.direction ?? direction;
-      keyWithCallback.callback = typeof key.value === "function" ? key.value : (value) => value[key.value];
+    if (is.isKey(unknownSorter)) {
+      sorter.callback = (value) => value[unknownSorter];
+    } else if (typeof unknownSorter === "function") {
+      sorter.callback = unknownSorter;
+    } else if (typeof unknownSorter?.value === "function" || is.isKey(unknownSorter?.value)) {
+      sorter.direction = unknownSorter?.direction ?? direction;
+      sorter.callback = typeof unknownSorter.value === "function" ? unknownSorter.value : (value) => value[unknownSorter.value];
     }
-    if (typeof keyWithCallback.callback === "function") {
-      const existing = keys.findIndex(
-        (existing2) => existing2.callback.toString() === keyWithCallback.callback.toString()
+    if (typeof sorter.callback === "function") {
+      const existing = sorters.findIndex(
+        (existing2) => existing2.callback.toString() === sorter.callback.toString()
       );
       if (existing > -1) {
-        keys.splice(existing, 1);
+        sorters.splice(existing, 1);
       }
-      keys.push(keyWithCallback);
+      sorters.push(sorter);
     }
   }
-  length = keys.length;
+  length = sorters.length;
   if (length === 0) {
     return array.sort(
       (first2, second2) => value_compare.compare(first2, second2) * (direction === "asc" ? 1 : -1)
@@ -48,12 +48,12 @@ function sort(array, first, second) {
   }
   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)
+      (first2, second2) => value_compare.compare(sorters[0].callback(first2), sorters[0].callback(second2)) * (sorters[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 { callback, direction: direction2 } = sorters[index];
       const compared = value_compare.compare(callback(first2), callback(second2)) * (direction2 === "asc" ? 1 : -1);
       if (compared !== 0) {
         return compared;

package/dist/array/sort.js

@@ -9,34 +9,34 @@ function sort(array, first, second) {
     return array;
   }
   const direction = first === true || second === true ? "desc" : "asc";
-  const unknownKeys = Array.isArray(first) ? first : [first];
-  let { length } = unknownKeys;
-  const keys = [];
+  const unknownSorters = Array.isArray(first) ? first : [first];
+  let { length } = unknownSorters;
+  const sorters = [];
   for (let index = 0; index < length; index += 1) {
-    const key = unknownKeys[index];
-    const keyWithCallback = {
+    const unknownSorter = unknownSorters[index];
+    const sorter = {
       direction,
       callback: void 0
     };
-    if (isKey(key)) {
-      keyWithCallback.callback = (value) => value[key];
-    } else if (typeof key === "function") {
-      keyWithCallback.callback = key;
-    } else if (typeof key?.value === "function" || isKey(key?.value)) {
-      keyWithCallback.direction = key?.direction ?? direction;
-      keyWithCallback.callback = typeof key.value === "function" ? key.value : (value) => value[key.value];
+    if (isKey(unknownSorter)) {
+      sorter.callback = (value) => value[unknownSorter];
+    } else if (typeof unknownSorter === "function") {
+      sorter.callback = unknownSorter;
+    } else if (typeof unknownSorter?.value === "function" || isKey(unknownSorter?.value)) {
+      sorter.direction = unknownSorter?.direction ?? direction;
+      sorter.callback = typeof unknownSorter.value === "function" ? unknownSorter.value : (value) => value[unknownSorter.value];
     }
-    if (typeof keyWithCallback.callback === "function") {
-      const existing = keys.findIndex(
-        (existing2) => existing2.callback.toString() === keyWithCallback.callback.toString()
+    if (typeof sorter.callback === "function") {
+      const existing = sorters.findIndex(
+        (existing2) => existing2.callback.toString() === sorter.callback.toString()
       );
       if (existing > -1) {
-        keys.splice(existing, 1);
+        sorters.splice(existing, 1);
       }
-      keys.push(keyWithCallback);
+      sorters.push(sorter);
     }
   }
-  length = keys.length;
+  length = sorters.length;
   if (length === 0) {
     return array.sort(
       (first2, second2) => compare(first2, second2) * (direction === "asc" ? 1 : -1)
@@ -44,12 +44,12 @@ function sort(array, first, second) {
   }
   if (length === 1) {
     return array.sort(
-      (first2, second2) => compare(keys[0].callback(first2), keys[0].callback(second2)) * (keys[0].direction === "asc" ? 1 : -1)
+      (first2, second2) => compare(sorters[0].callback(first2), sorters[0].callback(second2)) * (sorters[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 { callback, direction: direction2 } = sorters[index];
       const compared = compare(callback(first2), callback(second2)) * (direction2 === "asc" ? 1 : -1);
       if (compared !== 0) {
         return compared;

package/dist/array/to-map.cjs

@@ -14,7 +14,7 @@ function toMap(array, keyOrArrays, valueOrArrays, arrays) {
   const { length } = array;
   for (let index = 0; index < length; index += 1) {
     const item = array[index];
-    const key = callbacks?.key?.(item, index, array) ?? index;
+    const key = callbacks?.keyed?.(item, index, array) ?? index;
     const value = callbacks?.value?.(item, index, array) ?? item;
     if (asArrays) {
       const existing = map.get(key);

package/dist/array/to-map.js

@@ -10,7 +10,7 @@ function toMap(array, keyOrArrays, valueOrArrays, arrays) {
   const { length } = array;
   for (let index = 0; index < length; index += 1) {
     const item = array[index];
-    const key = callbacks?.key?.(item, index, array) ?? index;
+    const key = callbacks?.keyed?.(item, index, array) ?? index;
     const value = callbacks?.value?.(item, index, array) ?? item;
     if (asArrays) {
       const existing = map.get(key);

package/dist/color/constants.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const anyPattern = /^#?([a-f0-9]{3}){1,2}$/i;
+const defaultHex = "000000";
+const defaultHsl = {
+  hue: 0,
+  lightness: 0,
+  saturation: 0
+};
+const defaultRgb = {
+  blue: 0,
+  green: 0,
+  red: 0
+};
+const groupedPattern = /^#?([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})$/i;
+const hslKeys = /* @__PURE__ */ new Set([
+  "hue",
+  "lightness",
+  "saturation"
+]);
+const prefixPattern = /^#/;
+const rgbKeys = /* @__PURE__ */ new Set(["blue", "green", "red"]);
+
+exports.anyPattern = anyPattern;
+exports.defaultHex = defaultHex;
+exports.defaultHsl = defaultHsl;
+exports.defaultRgb = defaultRgb;
+exports.groupedPattern = groupedPattern;
+exports.hslKeys = hslKeys;
+exports.prefixPattern = prefixPattern;
+exports.rgbKeys = rgbKeys;

package/dist/color/constants.js

@@ -0,0 +1,22 @@
+const anyPattern = /^#?([a-f0-9]{3}){1,2}$/i;
+const defaultHex = "000000";
+const defaultHsl = {
+  hue: 0,
+  lightness: 0,
+  saturation: 0
+};
+const defaultRgb = {
+  blue: 0,
+  green: 0,
+  red: 0
+};
+const groupedPattern = /^#?([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})$/i;
+const hslKeys = /* @__PURE__ */ new Set([
+  "hue",
+  "lightness",
+  "saturation"
+]);
+const prefixPattern = /^#/;
+const rgbKeys = /* @__PURE__ */ new Set(["blue", "green", "red"]);
+
+export { anyPattern, defaultHex, defaultHsl, defaultRgb, groupedPattern, hslKeys, prefixPattern, rgbKeys };

package/dist/color/get.cjs

@@ -0,0 +1,57 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const number = require('../number.cjs');
+const color_constants = require('./constants.cjs');
+const color_is = require('./is.cjs');
+const color_value = require('./value.cjs');
+
+function getNormalisedHex(value) {
+  if (!color_is.isHexColor(value)) {
+    return String(color_constants.defaultHex);
+  }
+  const normalized = value.replace(color_constants.prefixPattern, "");
+  return normalized.length === 3 ? normalized.split("").map((character) => character.repeat(2)).join("") : normalized;
+}
+function getState(value) {
+  if (typeof value === "string") {
+    const hex = getNormalisedHex(value);
+    const rgb = color_value.hexToRgb(hex);
+    return {
+      hex,
+      rgb,
+      hsl: color_value.rgbToHsl(rgb)
+    };
+  }
+  const state = {};
+  if (typeof value === "object" && value !== null) {
+    if (color_is.isHSLColor(value)) {
+      state.hsl = {
+        hue: number.clamp(value.hue, 0, 360),
+        lightness: number.clamp(value.lightness, 0, 100),
+        saturation: number.clamp(value.saturation, 0, 100)
+      };
+      state.rgb = color_value.hslToRgb(state.hsl);
+      state.hex = color_value.rgbToHex(state.rgb);
+      return state;
+    }
+    if (color_is.isRGBColor(value)) {
+      state.rgb = {
+        blue: number.clamp(value.blue, 0, 255),
+        green: number.clamp(value.green, 0, 255),
+        red: number.clamp(value.red, 0, 255)
+      };
+      state.hex = color_value.rgbToHex(state.rgb);
+      state.hsl = color_value.rgbToHsl(state.rgb);
+      return state;
+    }
+  }
+  state.hex = String(color_constants.defaultHex);
+  state.hsl = { ...color_constants.defaultHsl };
+  state.rgb = { ...color_constants.defaultRgb };
+  return state;
+}
+
+exports.getNormalisedHex = getNormalisedHex;
+exports.getState = getState;

package/dist/color/get.js

@@ -0,0 +1,52 @@
+import { clamp } from '../number.js';
+import { defaultHex, prefixPattern, defaultHsl, defaultRgb } from './constants.js';
+import { isHexColor, isHSLColor, isRGBColor } from './is.js';
+import { hexToRgb, rgbToHsl, hslToRgb, rgbToHex } from './value.js';
+
+function getNormalisedHex(value) {
+  if (!isHexColor(value)) {
+    return String(defaultHex);
+  }
+  const normalized = value.replace(prefixPattern, "");
+  return normalized.length === 3 ? normalized.split("").map((character) => character.repeat(2)).join("") : normalized;
+}
+function getState(value) {
+  if (typeof value === "string") {
+    const hex = getNormalisedHex(value);
+    const rgb = hexToRgb(hex);
+    return {
+      hex,
+      rgb,
+      hsl: rgbToHsl(rgb)
+    };
+  }
+  const state = {};
+  if (typeof value === "object" && value !== null) {
+    if (isHSLColor(value)) {
+      state.hsl = {
+        hue: clamp(value.hue, 0, 360),
+        lightness: clamp(value.lightness, 0, 100),
+        saturation: clamp(value.saturation, 0, 100)
+      };
+      state.rgb = hslToRgb(state.hsl);
+      state.hex = rgbToHex(state.rgb);
+      return state;
+    }
+    if (isRGBColor(value)) {
+      state.rgb = {
+        blue: clamp(value.blue, 0, 255),
+        green: clamp(value.green, 0, 255),
+        red: clamp(value.red, 0, 255)
+      };
+      state.hex = rgbToHex(state.rgb);
+      state.hsl = rgbToHsl(state.rgb);
+      return state;
+    }
+  }
+  state.hex = String(defaultHex);
+  state.hsl = { ...defaultHsl };
+  state.rgb = { ...defaultRgb };
+  return state;
+}
+
+export { getNormalisedHex, getState };

package/dist/color/index.cjs

@@ -0,0 +1,97 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const color_get = require('./get.cjs');
+const color_is = require('./is.cjs');
+const color_value = require('./value.cjs');
+
+class Color {
+  $color = true;
+  state;
+  /**
+   * Get the color as a hex-color
+   */
+  get hex() {
+    return this.state.hex;
+  }
+  /**
+   * Set colors from a hex-color
+   */
+  set hex(value) {
+    if (color_is.isHexColor(value) && value !== this.state.hex) {
+      const hex = color_get.getNormalisedHex(value);
+      const rgb = color_value.hexToRgb(hex);
+      this.state.hex = hex;
+      this.state.hsl = color_value.rgbToHsl(rgb);
+      this.state.rgb = rgb;
+    }
+  }
+  /**
+   * Get the color as an HSL-color
+   */
+  get hsl() {
+    return this.state.hsl;
+  }
+  set hsl(value) {
+    if (color_is.isHSLColor(value)) {
+      const rgb = color_value.hslToRgb(value);
+      this.state.hex = color_value.rgbToHex(rgb);
+      this.state.hsl = value;
+      this.state.rgb = rgb;
+    }
+  }
+  /**
+   * Get the color as an RGB-color
+   */
+  get rgb() {
+    return this.state.rgb;
+  }
+  set rgb(value) {
+    if (color_is.isRGBColor(value)) {
+      this.state.hex = color_value.rgbToHex(value);
+      this.state.hsl = color_value.rgbToHsl(value);
+      this.state.rgb = value;
+    }
+  }
+  constructor(value) {
+    this.state = color_get.getState(value);
+  }
+}
+function getColor(value) {
+  return color_is.isColor(value) ? value : new Color(value);
+}
+function getForegroundColor(value) {
+  const original = getColor(value);
+  const { blue, green, red } = original.rgb;
+  const values = [blue / 255, green / 255, red / 255];
+  for (let color of values) {
+    if (color <= 0.03928) {
+      color /= 12.92;
+    } else {
+      color = ((color + 0.055) / 1.055) ** 2.4;
+    }
+  }
+  const luminance = 0.2126 * values[2] + 0.7152 * values[1] + 0.0722 * values[0];
+  return getColor(luminance > 0.625 ? "000000" : "ffffff");
+}
+function getHexColor(value) {
+  return getColor(value).hex;
+}
+function getHSLColor(value) {
+  return getColor(value).hsl;
+}
+function getRGBColor(value) {
+  return getColor(value).rgb;
+}
+
+exports.isColor = color_is.isColor;
+exports.isHSLColor = color_is.isHSLColor;
+exports.isHexColor = color_is.isHexColor;
+exports.isRGBColor = color_is.isRGBColor;
+exports.Color = Color;
+exports.getColor = getColor;
+exports.getForegroundColor = getForegroundColor;
+exports.getHSLColor = getHSLColor;
+exports.getHexColor = getHexColor;
+exports.getRGBColor = getRGBColor;

package/dist/color/index.js

@@ -0,0 +1,84 @@
+import { getNormalisedHex, getState } from './get.js';
+import { isHexColor, isHSLColor, isRGBColor, isColor } from './is.js';
+import { hexToRgb, rgbToHsl, hslToRgb, rgbToHex } from './value.js';
+
+class Color {
+  $color = true;
+  state;
+  /**
+   * Get the color as a hex-color
+   */
+  get hex() {
+    return this.state.hex;
+  }
+  /**
+   * Set colors from a hex-color
+   */
+  set hex(value) {
+    if (isHexColor(value) && value !== this.state.hex) {
+      const hex = getNormalisedHex(value);
+      const rgb = hexToRgb(hex);
+      this.state.hex = hex;
+      this.state.hsl = rgbToHsl(rgb);
+      this.state.rgb = rgb;
+    }
+  }
+  /**
+   * Get the color as an HSL-color
+   */
+  get hsl() {
+    return this.state.hsl;
+  }
+  set hsl(value) {
+    if (isHSLColor(value)) {
+      const rgb = hslToRgb(value);
+      this.state.hex = rgbToHex(rgb);
+      this.state.hsl = value;
+      this.state.rgb = rgb;
+    }
+  }
+  /**
+   * Get the color as an RGB-color
+   */
+  get rgb() {
+    return this.state.rgb;
+  }
+  set rgb(value) {
+    if (isRGBColor(value)) {
+      this.state.hex = rgbToHex(value);
+      this.state.hsl = rgbToHsl(value);
+      this.state.rgb = value;
+    }
+  }
+  constructor(value) {
+    this.state = getState(value);
+  }
+}
+function getColor(value) {
+  return isColor(value) ? value : new Color(value);
+}
+function getForegroundColor(value) {
+  const original = getColor(value);
+  const { blue, green, red } = original.rgb;
+  const values = [blue / 255, green / 255, red / 255];
+  for (let color of values) {
+    if (color <= 0.03928) {
+      color /= 12.92;
+    } else {
+      color = ((color + 0.055) / 1.055) ** 2.4;
+    }
+  }
+  const luminance = 0.2126 * values[2] + 0.7152 * values[1] + 0.0722 * values[0];
+  return getColor(luminance > 0.625 ? "000000" : "ffffff");
+}
+function getHexColor(value) {
+  return getColor(value).hex;
+}
+function getHSLColor(value) {
+  return getColor(value).hsl;
+}
+function getRGBColor(value) {
+  return getColor(value).rgb;
+}
+
+export { Color, getColor, getForegroundColor, getHSLColor, getHexColor, getRGBColor, isColor, isHSLColor, isHexColor, isRGBColor };

package/dist/color/is.cjs

@@ -0,0 +1,58 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const number = require('../number.cjs');
+const color_constants = require('./constants.cjs');
+
+function isColor(value) {
+  return typeof value === "object" && value !== null && "$color" in value && value.$color === true;
+}
+function isDegree(value) {
+  return typeof value === "number" && number.between(value, 0, 360);
+}
+function isHexColor(value) {
+  return typeof value === "string" && color_constants.anyPattern.test(value);
+}
+function isHexy(value) {
+  return typeof value === "number" && number.between(value, 0, 255);
+}
+function isHSLColor(value) {
+  return isObject(value, color_constants.hslKeys);
+}
+function isRGBColor(value) {
+  return isObject(value, color_constants.rgbKeys);
+}
+function isObject(obj, properties) {
+  if (typeof obj !== "object" || obj === null) {
+    return false;
+  }
+  const keys = Object.keys(obj);
+  const { length } = keys;
+  if (length !== properties.size) {
+    return false;
+  }
+  for (let index = 0; index < length; index += 1) {
+    const key = keys[index];
+    if (!properties.has(key) || !validators[key](obj[key])) {
+      return false;
+    }
+  }
+  return true;
+}
+function isPercentage(value) {
+  return typeof value === "number" && number.between(value, 0, 100);
+}
+const validators = {
+  blue: isHexy,
+  green: isHexy,
+  hue: isDegree,
+  lightness: isPercentage,
+  saturation: isPercentage,
+  red: isHexy
+};
+
+exports.isColor = isColor;
+exports.isHSLColor = isHSLColor;
+exports.isHexColor = isHexColor;
+exports.isRGBColor = isRGBColor;

package/dist/color/is.js

@@ -0,0 +1,51 @@
+import { between } from '../number.js';
+import { anyPattern, hslKeys, rgbKeys } from './constants.js';
+
+function isColor(value) {
+  return typeof value === "object" && value !== null && "$color" in value && value.$color === true;
+}
+function isDegree(value) {
+  return typeof value === "number" && between(value, 0, 360);
+}
+function isHexColor(value) {
+  return typeof value === "string" && anyPattern.test(value);
+}
+function isHexy(value) {
+  return typeof value === "number" && between(value, 0, 255);
+}
+function isHSLColor(value) {
+  return isObject(value, hslKeys);
+}
+function isRGBColor(value) {
+  return isObject(value, rgbKeys);
+}
+function isObject(obj, properties) {
+  if (typeof obj !== "object" || obj === null) {
+    return false;
+  }
+  const keys = Object.keys(obj);
+  const { length } = keys;
+  if (length !== properties.size) {
+    return false;
+  }
+  for (let index = 0; index < length; index += 1) {
+    const key = keys[index];
+    if (!properties.has(key) || !validators[key](obj[key])) {
+      return false;
+    }
+  }
+  return true;
+}
+function isPercentage(value) {
+  return typeof value === "number" && between(value, 0, 100);
+}
+const validators = {
+  blue: isHexy,
+  green: isHexy,
+  hue: isDegree,
+  lightness: isPercentage,
+  saturation: isPercentage,
+  red: isHexy
+};
+
+export { isColor, isHSLColor, isHexColor, isRGBColor };

package/dist/color/models.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/color/models.js

@@ -0,0 +1 @@
+