@oscarpalmer/atoms 0.74.1 → 0.76.0

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

@@ -0,0 +1,27 @@
+import { getCallbacks } from "../internal/array/callbacks.js";
+function toMap(array, first, second, third) {
+  var _a, _b;
+  const asArrays = first === true || second === true || third === true;
+  const 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;
+}
+export {
+  toMap
+};

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const array_groupBy = require("./group-by.cjs");
+function toRecord(array, first, second, third) {
+  return array_groupBy.groupValues(
+    array,
+    first,
+    second,
+    first === true || second === true || third === true
+  );
+}
+exports.toRecord = toRecord;

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

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

package/dist/js/array/unique.cjs

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const internal_array_find = require("../internal/array/find.cjs");
+function unique(array, key) {
+  return internal_array_find.findValues("unique", array, void 0, key, void 0);
+}
+exports.unique = unique;

package/dist/js/array/unique.js

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

package/dist/js/colour/base.cjs

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const colour_is = require("./is.cjs");
+class Colour {
+  /**
+   * Get the current value of the colour
+   */
+  get value() {
+    return { ...this.state.value };
+  }
+  constructor(type, value, defaults, properties) {
+    this.$colour = type;
+    this.state = {
+      value: colour_is.isColourValue(value, properties) ? { ...value } : { ...defaults }
+    };
+  }
+}
+exports.Colour = Colour;

package/dist/js/colour/{base.mjs → base.js}

@@ -1,7 +1,8 @@
-// src/js/colour/base.ts
-import { isColourValue } from "./is";
-
+import { isColourValue } from "./is.js";
 class Colour {
+  /**
+   * Get the current value of the colour
+   */
   get value() {
     return { ...this.state.value };
   }

package/dist/js/colour/functions.cjs

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const colour_hex = require("./hex.cjs");
+const colour_hsl = require("./hsl.cjs");
+const colour_rgb = require("./rgb.cjs");
+const number = require("../number.cjs");
+const anyPattern = /^#*([a-f0-9]{3}){1,2}$/i;
+const groupedPattern = /^#*([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})$/i;
+function getNormalisedHex(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 rgb = [];
+  const { length } = pairs;
+  for (let index = 1; index < length; index += 1) {
+    rgb.push(Number.parseInt(pairs[index], 16));
+  }
+  return new colour_rgb.RGBColour({
+    blue: rgb[2] ?? 0,
+    green: rgb[1] ?? 0,
+    red: rgb[0] ?? 0
+  });
+}
+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 new colour_rgb.RGBColour({
+    blue: number.clamp(Math.round(get(4) * 255), 0, 255),
+    green: number.clamp(Math.round(get(8) * 255), 0, 255),
+    red: number.clamp(Math.round(get(0) * 255), 0, 255)
+  });
+}
+function rgbToHex(value) {
+  return new colour_hex.HexColour(
+    `${[value.red, value.green, value.blue].map((colour) => {
+      const hex = colour.toString(16);
+      return hex.length === 1 ? `0${hex}` : hex;
+    }).join("")}`
+  );
+}
+function rgbToHsl(rgb) {
+  const blue = rgb.blue / 255;
+  const green = rgb.green / 255;
+  const red = rgb.red / 255;
+  const max = Math.max(blue, green, red);
+  const min = Math.min(blue, green, red);
+  const delta = max - min;
+  const lightness = (min + max) / 2;
+  let hue = 0;
+  let saturation = 0;
+  if (delta !== 0) {
+    saturation = lightness === 0 || lightness === 1 ? 0 : (max - lightness) / Math.min(lightness, 1 - lightness);
+    switch (max) {
+      case blue:
+        hue = (red - green) / delta + 4;
+        break;
+      case green:
+        hue = (blue - red) / delta + 2;
+        break;
+      case red:
+        hue = (green - blue) / delta + (green < blue ? 6 : 0);
+        break;
+    }
+    hue *= 60;
+  }
+  if (saturation < 0) {
+    hue += 180;
+    saturation = Math.abs(saturation);
+  }
+  if (hue >= 360) {
+    hue -= 360;
+  }
+  return new colour_hsl.HSLColour({
+    hue: +hue.toFixed(2),
+    lightness: +(lightness * 100).toFixed(2),
+    saturation: +(saturation * 100).toFixed(2)
+  });
+}
+exports.anyPattern = anyPattern;
+exports.getNormalisedHex = getNormalisedHex;
+exports.hexToRgb = hexToRgb;
+exports.hslToRgb = hslToRgb;
+exports.rgbToHex = rgbToHex;
+exports.rgbToHsl = rgbToHsl;

package/dist/js/colour/{functions.mjs → functions.js}

@@ -1,8 +1,9 @@
-// src/js/colour/functions.ts
-import { clamp } from "../number";
-import { HexColour } from "./hex";
-import { HSLColour } from "./hsl";
-import { RGBColour } from "./rgb";
+import { HexColour } from "./hex.js";
+import { HSLColour } from "./hsl.js";
+import { RGBColour } from "./rgb.js";
+import { clamp } from "../number.js";
+const anyPattern = /^#*([a-f0-9]{3}){1,2}$/i;
+const groupedPattern = /^#*([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})$/i;
 function getNormalisedHex(value) {
   const normalised = value.replace(/^#/, "");
   return normalised.length === 3 ? normalised.split("").map((character) => character.repeat(2)).join("") : normalised;
@@ -12,7 +13,7 @@ function hexToRgb(value) {
   const pairs = groupedPattern.exec(hex) ?? [];
   const rgb = [];
   const { length } = pairs;
-  for (let index = 1;index < length; index += 1) {
+  for (let index = 1; index < length; index += 1) {
     rgb.push(Number.parseInt(pairs[index], 16));
   }
   return new RGBColour({
@@ -40,10 +41,12 @@ function hslToRgb(value) {
   });
 }
 function rgbToHex(value) {
-  return new HexColour(`${[value.red, value.green, value.blue].map((colour) => {
-    const hex = colour.toString(16);
-    return hex.length === 1 ? `0${hex}` : hex;
-  }).join("")}`);
+  return new HexColour(
+    `${[value.red, value.green, value.blue].map((colour) => {
+      const hex = colour.toString(16);
+      return hex.length === 1 ? `0${hex}` : hex;
+    }).join("")}`
+  );
 }
 function rgbToHsl(rgb) {
   const blue = rgb.blue / 255;
@@ -67,8 +70,6 @@ function rgbToHsl(rgb) {
       case red:
         hue = (green - blue) / delta + (green < blue ? 6 : 0);
         break;
-      default:
-        break;
     }
     hue *= 60;
   }
@@ -85,13 +86,11 @@ function rgbToHsl(rgb) {
     saturation: +(saturation * 100).toFixed(2)
   });
 }
-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 {
-  rgbToHsl,
-  rgbToHex,
-  hslToRgb,
-  hexToRgb,
+  anyPattern,
   getNormalisedHex,
-  anyPattern
+  hexToRgb,
+  hslToRgb,
+  rgbToHex,
+  rgbToHsl
 };

package/dist/js/colour/hex.cjs

@@ -0,0 +1,56 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const colour_functions = require("./functions.cjs");
+class HexColour {
+  constructor(value) {
+    __publicField(this, "state");
+    this.$colour = "hex";
+    this.state = {
+      value: typeof value === "string" && colour_functions.anyPattern.test(value) ? colour_functions.getNormalisedHex(value) : "000000"
+    };
+  }
+  /**
+   * Get the value of the colour
+   */
+  get value() {
+    return `#${this.state.value}`;
+  }
+  /**
+   * Set the value of the colour
+   */
+  set value(value) {
+    this.state.value = colour_functions.anyPattern.test(value) ? colour_functions.getNormalisedHex(value) : "000000";
+  }
+  /**
+   * Convert the colour to an RGB-colour
+   */
+  toHsl() {
+    return HexColour.toRgb(this.value).toHsl();
+  }
+  /**
+   * Convert the colour to an HSL-colour
+   */
+  toRgb() {
+    return HexColour.toRgb(this.value);
+  }
+  /**
+   * Get the colour as a string _(prefixed with #)_
+   */
+  toString() {
+    return this.value;
+  }
+  /**
+   * Convert a hex-colour to an RGB-colour
+   */
+  static toRgb(value) {
+    return colour_functions.hexToRgb(value);
+  }
+}
+function getHexColour(value) {
+  return new HexColour(value);
+}
+exports.HexColour = HexColour;
+exports.getHexColour = getHexColour;

package/dist/js/colour/{hex.mjs → hex.js}

@@ -1,37 +1,56 @@
-// src/js/colour/hex.ts
-import { anyPattern, getNormalisedHex, hexToRgb } from "./functions";
-function getHexColour(value) {
-  return new HexColour(value);
-}
-
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { anyPattern, getNormalisedHex, hexToRgb } from "./functions.js";
 class HexColour {
-  state;
-  get value() {
-    return `#${this.state.value}`;
-  }
-  set value(value) {
-    this.state.value = anyPattern.test(value) ? getNormalisedHex(value) : "000000";
-  }
   constructor(value) {
+    __publicField(this, "state");
     this.$colour = "hex";
     this.state = {
       value: typeof value === "string" && anyPattern.test(value) ? getNormalisedHex(value) : "000000"
     };
   }
+  /**
+   * Get the value of the colour
+   */
+  get value() {
+    return `#${this.state.value}`;
+  }
+  /**
+   * Set the value of the colour
+   */
+  set value(value) {
+    this.state.value = anyPattern.test(value) ? getNormalisedHex(value) : "000000";
+  }
+  /**
+   * Convert the colour to an RGB-colour
+   */
   toHsl() {
     return HexColour.toRgb(this.value).toHsl();
   }
+  /**
+   * Convert the colour to an HSL-colour
+   */
   toRgb() {
     return HexColour.toRgb(this.value);
   }
+  /**
+   * Get the colour as a string _(prefixed with #)_
+   */
   toString() {
     return this.value;
   }
+  /**
+   * Convert a hex-colour to an RGB-colour
+   */
   static toRgb(value) {
     return hexToRgb(value);
   }
 }
+function getHexColour(value) {
+  return new HexColour(value);
+}
 export {
-  getHexColour,
-  HexColour
+  HexColour,
+  getHexColour
 };

package/dist/js/colour/hsl.cjs

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const colour_base = require("./base.cjs");
+const colour_functions = require("./functions.cjs");
+const number = require("../number.cjs");
+class HSLColour extends colour_base.Colour {
+  /**
+   * Get the current hue
+   */
+  get hue() {
+    return +this.state.value.hue;
+  }
+  /**
+   * Set the current hue
+   */
+  set hue(value) {
+    this.state.value.hue = number.clamp(value, 0, 360);
+  }
+  /**
+   * Get the current lightness
+   */
+  get lightness() {
+    return +this.state.value.lightness;
+  }
+  /**
+   * Set the current lightness
+   */
+  set lightness(value) {
+    this.state.value.lightness = number.clamp(value, 0, 100);
+  }
+  /**
+   * Get the current saturation
+   */
+  get saturation() {
+    return +this.state.value.saturation;
+  }
+  /**
+   * Set the current saturation
+   */
+  set saturation(value) {
+    this.state.value.saturation = number.clamp(value, 0, 100);
+  }
+  constructor(value) {
+    super("hsl", value, defaults, properties);
+  }
+  /**
+   * @inheritdoc
+   */
+  toHex() {
+    return HSLColour.toRgb(this.state.value).toHex();
+  }
+  /**
+   * Convert the colour to an RGB-colour
+   */
+  toRgb() {
+    return HSLColour.toRgb(this.state.value);
+  }
+  /**
+   * @inheritdoc
+   */
+  toString() {
+    return `hsl(${this.state.value.hue}, ${this.state.value.saturation}%, ${this.state.value.lightness}%)`;
+  }
+  /**
+   * Convert an HSL-colour to an RGB-colour
+   */
+  static toRgb(value) {
+    return colour_functions.hslToRgb(value);
+  }
+}
+const defaults = {
+  hue: 0,
+  lightness: 0,
+  saturation: 0
+};
+const properties = [
+  "hue",
+  "lightness",
+  "saturation"
+];
+function getHSLColour(value) {
+  return new HSLColour(value);
+}
+exports.HSLColour = HSLColour;
+exports.getHSLColour = getHSLColour;

package/dist/js/colour/{hsl.mjs → hsl.js}

@@ -1,57 +1,85 @@
-// src/js/colour/hsl.ts
-import { clamp } from "../number";
-import { Colour } from "./base";
-import { hslToRgb } from "./functions";
-function getHSLColour(value) {
-  return new HSLColour(value);
-}
-
+import { Colour } from "./base.js";
+import { hslToRgb } from "./functions.js";
+import { clamp } from "../number.js";
 class HSLColour extends Colour {
+  /**
+   * Get the current hue
+   */
   get hue() {
     return +this.state.value.hue;
   }
+  /**
+   * Set the current hue
+   */
   set hue(value) {
     this.state.value.hue = clamp(value, 0, 360);
   }
+  /**
+   * Get the current lightness
+   */
   get lightness() {
     return +this.state.value.lightness;
   }
+  /**
+   * Set the current lightness
+   */
   set lightness(value) {
     this.state.value.lightness = clamp(value, 0, 100);
   }
+  /**
+   * Get the current saturation
+   */
   get saturation() {
     return +this.state.value.saturation;
   }
+  /**
+   * Set the current saturation
+   */
   set saturation(value) {
     this.state.value.saturation = clamp(value, 0, 100);
   }
   constructor(value) {
     super("hsl", value, defaults, properties);
   }
+  /**
+   * @inheritdoc
+   */
   toHex() {
     return HSLColour.toRgb(this.state.value).toHex();
   }
+  /**
+   * Convert the colour to an RGB-colour
+   */
   toRgb() {
     return HSLColour.toRgb(this.state.value);
   }
+  /**
+   * @inheritdoc
+   */
   toString() {
     return `hsl(${this.state.value.hue}, ${this.state.value.saturation}%, ${this.state.value.lightness}%)`;
   }
+  /**
+   * Convert an HSL-colour to an RGB-colour
+   */
   static toRgb(value) {
     return hslToRgb(value);
   }
 }
-var defaults = {
+const defaults = {
   hue: 0,
   lightness: 0,
   saturation: 0
 };
-var properties = [
+const properties = [
   "hue",
   "lightness",
   "saturation"
 ];
+function getHSLColour(value) {
+  return new HSLColour(value);
+}
 export {
-  getHSLColour,
-  HSLColour
+  HSLColour,
+  getHSLColour
 };

package/dist/js/colour/index.cjs

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const colour_hex = require("./hex.cjs");
+const colour_hsl = require("./hsl.cjs");
+const colour_is = require("./is.cjs");
+const colour_rgb = require("./rgb.cjs");
+function getForegroundColour(value) {
+  const values = [value.blue / 255, value.green / 255, value.red / 255];
+  for (let colour of values) {
+    if (colour <= 0.03928) {
+      colour /= 12.92;
+    } else {
+      colour = ((colour + 0.055) / 1.055) ** 2.4;
+    }
+  }
+  const luminance = 0.2126 * values[2] + 0.7152 * values[1] + 0.0722 * values[0];
+  return luminance > 0.625 ? "black" : "white";
+}
+exports.HexColour = colour_hex.HexColour;
+exports.getHexColour = colour_hex.getHexColour;
+exports.HSLColour = colour_hsl.HSLColour;
+exports.getHSLColour = colour_hsl.getHSLColour;
+exports.isColour = colour_is.isColour;
+exports.isHSLColour = colour_is.isHSLColour;
+exports.isHexColour = colour_is.isHexColour;
+exports.isRGBColour = colour_is.isRGBColour;
+exports.RGBColour = colour_rgb.RGBColour;
+exports.getRGBColour = colour_rgb.getRGBColour;
+exports.getForegroundColour = getForegroundColour;