@zag-js/color-utils 0.0.0-dev-20230414151834

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Chakra UI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,25 @@
+# @zag-js/color-utils
+
+Color utilities for zag.js
+
+## Installation
+
+```sh
+yarn add @zag-js/color-utils
+# or
+npm i @zag-js/color-utils
+```
+
+## Contribution
+
+Yes please! See the [contributing guidelines](https://github.com/chakra-ui/zag/blob/main/CONTRIBUTING.md) for details.
+
+## Licence
+
+This project is licensed under the terms of the [MIT license](https://github.com/chakra-ui/zag/blob/main/LICENSE).
+
+## Credits
+
+This package is largely inspired by the
+[Color utilities](https://github.com/adobe/react-spectrum/tree/main/packages/%40react-stately/color) in the React Aria
+project. You can find the license for this project [here](https://github.com/adobe/react-spectrum/blob/main/LICENSE)

package/dist/chunk-7VB2GGWQ.mjs

@@ -0,0 +1,382 @@
+import {
+  Color
+} from "./chunk-NSR5W5ST.mjs";
+import {
+  clampValue,
+  mod,
+  toFixedNumber
+} from "./chunk-TXOVH6IE.mjs";
+import {
+  __publicField
+} from "./chunk-NHABU752.mjs";
+
+// src/hsl-color.ts
+var HSL_REGEX = /hsl\(([-+]?\d+(?:.\d+)?\s*,\s*[-+]?\d+(?:.\d+)?%\s*,\s*[-+]?\d+(?:.\d+)?%)\)|hsla\(([-+]?\d+(?:.\d+)?\s*,\s*[-+]?\d+(?:.\d+)?%\s*,\s*[-+]?\d+(?:.\d+)?%\s*,\s*[-+]?\d(.\d+)?)\)/;
+var _HSLColor = class extends Color {
+  constructor(hue, saturation, lightness, alpha) {
+    super();
+    this.hue = hue;
+    this.saturation = saturation;
+    this.lightness = lightness;
+    this.alpha = alpha;
+  }
+  static parse(value) {
+    let m;
+    if (m = value.match(HSL_REGEX)) {
+      const [h, s, l, a] = (m[1] ?? m[2]).split(",").map((n) => Number(n.trim().replace("%", "")));
+      return new _HSLColor(mod(h, 360), clampValue(s, 0, 100), clampValue(l, 0, 100), clampValue(a ?? 1, 0, 1));
+    }
+  }
+  toString(format) {
+    switch (format) {
+      case "hex":
+        return this.toRGB().toString("hex");
+      case "hexa":
+        return this.toRGB().toString("hexa");
+      case "hsl":
+        return `hsl(${this.hue}, ${toFixedNumber(this.saturation, 2)}%, ${toFixedNumber(this.lightness, 2)}%)`;
+      case "css":
+      case "hsla":
+        return `hsla(${this.hue}, ${toFixedNumber(this.saturation, 2)}%, ${toFixedNumber(this.lightness, 2)}%, ${this.alpha})`;
+      default:
+        return this.toFormat(format).toString(format);
+    }
+  }
+  toFormat(format) {
+    switch (format) {
+      case "hsl":
+      case "hsla":
+        return this;
+      case "hsb":
+      case "hsba":
+        return this.toHSB();
+      case "rgb":
+      case "rgba":
+        return this.toRGB();
+      default:
+        throw new Error("Unsupported color conversion: hsl -> " + format);
+    }
+  }
+  /**
+   * Converts a HSL color to HSB.
+   * Conversion formula adapted from https://en.wikipedia.org/wiki/HSL_and_HSV#HSL_to_HSV.
+   * @returns An HSBColor object.
+   */
+  toHSB() {
+    let saturation = this.saturation / 100;
+    let lightness = this.lightness / 100;
+    let brightness = lightness + saturation * Math.min(lightness, 1 - lightness);
+    saturation = brightness === 0 ? 0 : 2 * (1 - lightness / brightness);
+    return new HSBColor(
+      toFixedNumber(this.hue, 2),
+      toFixedNumber(saturation * 100, 2),
+      toFixedNumber(brightness * 100, 2),
+      this.alpha
+    );
+  }
+  /**
+   * Converts a HSL color to RGB.
+   * Conversion formula adapted from https://en.wikipedia.org/wiki/HSL_and_HSV#HSL_to_RGB_alternative.
+   * @returns An RGBColor object.
+   */
+  toRGB() {
+    let hue = this.hue;
+    let saturation = this.saturation / 100;
+    let lightness = this.lightness / 100;
+    let a = saturation * Math.min(lightness, 1 - lightness);
+    let fn = (n, k = (n + hue / 30) % 12) => lightness - a * Math.max(Math.min(k - 3, 9 - k, 1), -1);
+    return new RGBColor(Math.round(fn(0) * 255), Math.round(fn(8) * 255), Math.round(fn(4) * 255), this.alpha);
+  }
+  clone() {
+    return new _HSLColor(this.hue, this.saturation, this.lightness, this.alpha);
+  }
+  getChannelRange(channel) {
+    switch (channel) {
+      case "hue":
+        return { minValue: 0, maxValue: 360, step: 1, pageSize: 15 };
+      case "saturation":
+      case "lightness":
+        return { minValue: 0, maxValue: 100, step: 1, pageSize: 10 };
+      case "alpha":
+        return { minValue: 0, maxValue: 1, step: 0.01, pageSize: 0.1 };
+      default:
+        throw new Error("Unknown color channel: " + channel);
+    }
+  }
+  getColorSpace() {
+    return "hsl";
+  }
+  getColorChannels() {
+    return _HSLColor.colorChannels;
+  }
+};
+var HSLColor = _HSLColor;
+__publicField(HSLColor, "colorChannels", ["hue", "saturation", "lightness"]);
+
+// src/hsb-color.ts
+var HSB_REGEX = /hsb\(([-+]?\d+(?:.\d+)?\s*,\s*[-+]?\d+(?:.\d+)?%\s*,\s*[-+]?\d+(?:.\d+)?%)\)|hsba\(([-+]?\d+(?:.\d+)?\s*,\s*[-+]?\d+(?:.\d+)?%\s*,\s*[-+]?\d+(?:.\d+)?%\s*,\s*[-+]?\d(.\d+)?)\)/;
+var _HSBColor = class extends Color {
+  constructor(hue, saturation, brightness, alpha) {
+    super();
+    this.hue = hue;
+    this.saturation = saturation;
+    this.brightness = brightness;
+    this.alpha = alpha;
+  }
+  static parse(value) {
+    let m;
+    if (m = value.match(HSB_REGEX)) {
+      const [h, s, b, a] = (m[1] ?? m[2]).split(",").map((n) => Number(n.trim().replace("%", "")));
+      return new _HSBColor(mod(h, 360), clampValue(s, 0, 100), clampValue(b, 0, 100), clampValue(a ?? 1, 0, 1));
+    }
+  }
+  toString(format) {
+    switch (format) {
+      case "css":
+        return this.toHSL().toString("css");
+      case "hex":
+        return this.toRGB().toString("hex");
+      case "hexa":
+        return this.toRGB().toString("hexa");
+      case "hsb":
+        return `hsb(${this.hue}, ${toFixedNumber(this.saturation, 2)}%, ${toFixedNumber(this.brightness, 2)}%)`;
+      case "hsba":
+        return `hsba(${this.hue}, ${toFixedNumber(this.saturation, 2)}%, ${toFixedNumber(this.brightness, 2)}%, ${this.alpha})`;
+      default:
+        return this.toFormat(format).toString(format);
+    }
+  }
+  toFormat(format) {
+    switch (format) {
+      case "hsb":
+      case "hsba":
+        return this;
+      case "hsl":
+      case "hsla":
+        return this.toHSL();
+      case "rgb":
+      case "rgba":
+        return this.toRGB();
+      default:
+        throw new Error("Unsupported color conversion: hsb -> " + format);
+    }
+  }
+  /**
+   * Converts a HSB color to HSL.
+   * Conversion formula adapted from https://en.wikipedia.org/wiki/HSL_and_HSV#HSV_to_HSL.
+   * @returns An HSLColor object.
+   */
+  toHSL() {
+    let saturation = this.saturation / 100;
+    let brightness = this.brightness / 100;
+    let lightness = brightness * (1 - saturation / 2);
+    saturation = lightness === 0 || lightness === 1 ? 0 : (brightness - lightness) / Math.min(lightness, 1 - lightness);
+    return new HSLColor(
+      toFixedNumber(this.hue, 2),
+      toFixedNumber(saturation * 100, 2),
+      toFixedNumber(lightness * 100, 2),
+      this.alpha
+    );
+  }
+  /**
+   * Converts a HSV color value to RGB.
+   * Conversion formula adapted from https://en.wikipedia.org/wiki/HSL_and_HSV#HSV_to_RGB_alternative.
+   * @returns An RGBColor object.
+   */
+  toRGB() {
+    let hue = this.hue;
+    let saturation = this.saturation / 100;
+    let brightness = this.brightness / 100;
+    let fn = (n, k = (n + hue / 60) % 6) => brightness - saturation * brightness * Math.max(Math.min(k, 4 - k, 1), 0);
+    return new RGBColor(Math.round(fn(5) * 255), Math.round(fn(3) * 255), Math.round(fn(1) * 255), this.alpha);
+  }
+  clone() {
+    return new _HSBColor(this.hue, this.saturation, this.brightness, this.alpha);
+  }
+  getChannelRange(channel) {
+    switch (channel) {
+      case "hue":
+        return { minValue: 0, maxValue: 360, step: 1, pageSize: 15 };
+      case "saturation":
+      case "brightness":
+        return { minValue: 0, maxValue: 100, step: 1, pageSize: 10 };
+      case "alpha":
+        return { minValue: 0, maxValue: 1, step: 0.01, pageSize: 0.1 };
+      default:
+        throw new Error("Unknown color channel: " + channel);
+    }
+  }
+  getColorSpace() {
+    return "hsb";
+  }
+  getColorChannels() {
+    return _HSBColor.colorChannels;
+  }
+};
+var HSBColor = _HSBColor;
+__publicField(HSBColor, "colorChannels", ["hue", "saturation", "brightness"]);
+
+// src/rgb-color.ts
+var _RGBColor = class extends Color {
+  constructor(red, green, blue, alpha) {
+    super();
+    this.red = red;
+    this.green = green;
+    this.blue = blue;
+    this.alpha = alpha;
+  }
+  static parse(value) {
+    let colors = [];
+    if (/^#[\da-f]+$/i.test(value) && [4, 5, 7, 9].includes(value.length)) {
+      const values = (value.length < 6 ? value.replace(/[^#]/gi, "$&$&") : value).slice(1).split("");
+      while (values.length > 0) {
+        colors.push(parseInt(values.splice(0, 2).join(""), 16));
+      }
+      colors[3] = colors[3] !== void 0 ? colors[3] / 255 : void 0;
+    }
+    const match = value.match(/^rgba?\((.*)\)$/);
+    if (match?.[1]) {
+      colors = match[1].split(",").map((value2) => Number(value2.trim())).map((num, i) => clampValue(num, 0, i < 3 ? 255 : 1));
+    }
+    return colors.length < 3 ? void 0 : new _RGBColor(colors[0], colors[1], colors[2], colors[3] ?? 1);
+  }
+  toString(format) {
+    switch (format) {
+      case "hex":
+        return "#" + (this.red.toString(16).padStart(2, "0") + this.green.toString(16).padStart(2, "0") + this.blue.toString(16).padStart(2, "0")).toUpperCase();
+      case "hexa":
+        return "#" + (this.red.toString(16).padStart(2, "0") + this.green.toString(16).padStart(2, "0") + this.blue.toString(16).padStart(2, "0") + Math.round(this.alpha * 255).toString(16).padStart(2, "0")).toUpperCase();
+      case "rgb":
+        return `rgb(${this.red}, ${this.green}, ${this.blue})`;
+      case "css":
+      case "rgba":
+        return `rgba(${this.red}, ${this.green}, ${this.blue}, ${this.alpha})`;
+      default:
+        return this.toFormat(format).toString(format);
+    }
+  }
+  toFormat(format) {
+    switch (format) {
+      case "hex":
+      case "hexa":
+      case "rgb":
+      case "rgba":
+        return this;
+      case "hsb":
+      case "hsba":
+        return this.toHSB();
+      case "hsl":
+      case "hsla":
+        return this.toHSL();
+      default:
+        throw new Error("Unsupported color conversion: rgb -> " + format);
+    }
+  }
+  toHexInt() {
+    return this.red << 16 | this.green << 8 | this.blue;
+  }
+  /**
+   * Converts an RGB color value to HSB.
+   * Conversion formula adapted from https://en.wikipedia.org/wiki/HSL_and_HSV#From_RGB.
+   * @returns An HSBColor object.
+   */
+  toHSB() {
+    const red = this.red / 255;
+    const green = this.green / 255;
+    const blue = this.blue / 255;
+    const min = Math.min(red, green, blue);
+    const brightness = Math.max(red, green, blue);
+    const chroma = brightness - min;
+    const saturation = brightness === 0 ? 0 : chroma / brightness;
+    let hue = 0;
+    if (chroma !== 0) {
+      switch (brightness) {
+        case red:
+          hue = (green - blue) / chroma + (green < blue ? 6 : 0);
+          break;
+        case green:
+          hue = (blue - red) / chroma + 2;
+          break;
+        case blue:
+          hue = (red - green) / chroma + 4;
+          break;
+      }
+      hue /= 6;
+    }
+    return new HSBColor(
+      toFixedNumber(hue * 360, 2),
+      toFixedNumber(saturation * 100, 2),
+      toFixedNumber(brightness * 100, 2),
+      this.alpha
+    );
+  }
+  /**
+   * Converts an RGB color value to HSL.
+   * Conversion formula adapted from https://en.wikipedia.org/wiki/HSL_and_HSV#From_RGB.
+   * @returns An HSLColor object.
+   */
+  toHSL() {
+    const red = this.red / 255;
+    const green = this.green / 255;
+    const blue = this.blue / 255;
+    const min = Math.min(red, green, blue);
+    const max = Math.max(red, green, blue);
+    const lightness = (max + min) / 2;
+    const chroma = max - min;
+    let hue = -1;
+    let saturation = -1;
+    if (chroma === 0) {
+      hue = saturation = 0;
+    } else {
+      saturation = chroma / (lightness < 0.5 ? max + min : 2 - max - min);
+      switch (max) {
+        case red:
+          hue = (green - blue) / chroma + (green < blue ? 6 : 0);
+          break;
+        case green:
+          hue = (blue - red) / chroma + 2;
+          break;
+        case blue:
+          hue = (red - green) / chroma + 4;
+          break;
+      }
+      hue /= 6;
+    }
+    return new HSLColor(
+      toFixedNumber(hue * 360, 2),
+      toFixedNumber(saturation * 100, 2),
+      toFixedNumber(lightness * 100, 2),
+      this.alpha
+    );
+  }
+  clone() {
+    return new _RGBColor(this.red, this.green, this.blue, this.alpha);
+  }
+  getChannelRange(channel) {
+    switch (channel) {
+      case "red":
+      case "green":
+      case "blue":
+        return { minValue: 0, maxValue: 255, step: 1, pageSize: 17 };
+      case "alpha":
+        return { minValue: 0, maxValue: 1, step: 0.01, pageSize: 0.1 };
+      default:
+        throw new Error("Unknown color channel: " + channel);
+    }
+  }
+  getColorSpace() {
+    return "rgb";
+  }
+  getColorChannels() {
+    return _RGBColor.colorChannels;
+  }
+};
+var RGBColor = _RGBColor;
+__publicField(RGBColor, "colorChannels", ["red", "green", "blue"]);
+
+export {
+  RGBColor,
+  HSL_REGEX,
+  HSLColor,
+  HSBColor
+};

package/dist/chunk-NHABU752.mjs

@@ -0,0 +1,10 @@
+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);
+  return value;
+};
+
+export {
+  __publicField
+};

package/dist/chunk-NSR5W5ST.mjs

@@ -0,0 +1,34 @@
+// src/color.ts
+var Color = class {
+  toHexInt() {
+    return this.toFormat("rgb").toHexInt();
+  }
+  getChannelValue(channel) {
+    if (channel in this) {
+      return this[channel];
+    }
+    throw new Error("Unsupported color channel: " + channel);
+  }
+  withChannelValue(channel, value) {
+    if (channel in this) {
+      let clone = this.clone();
+      clone[channel] = value;
+      return clone;
+    }
+    throw new Error("Unsupported color channel: " + channel);
+  }
+  getColorSpaceAxes(xyChannels) {
+    let { xChannel, yChannel } = xyChannels;
+    let xCh = xChannel || this.getColorChannels().find((c) => c !== yChannel);
+    let yCh = yChannel || this.getColorChannels().find((c) => c !== xCh);
+    let zCh = this.getColorChannels().find((c) => c !== xCh && c !== yCh);
+    return { xChannel: xCh, yChannel: yCh, zChannel: zCh };
+  }
+  isEqual(color) {
+    return this.toHexInt() === color.toHexInt();
+  }
+};
+
+export {
+  Color
+};

package/dist/chunk-TXOVH6IE.mjs

@@ -0,0 +1,16 @@
+// src/utils.ts
+function mod(n, m) {
+  return (n % m + m) % m;
+}
+function toFixedNumber(num, digits) {
+  return Math.round(Math.pow(10, digits) * num) / Math.pow(10, digits);
+}
+function clampValue(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+
+export {
+  mod,
+  toFixedNumber,
+  clampValue
+};

package/dist/chunk-WWI4IDFU.mjs

@@ -0,0 +1,26 @@
+import {
+  HSBColor,
+  HSLColor,
+  RGBColor
+} from "./chunk-7VB2GGWQ.mjs";
+
+// src/parse-color.ts
+function parseColor(value) {
+  let result = RGBColor.parse(value) || HSBColor.parse(value) || HSLColor.parse(value);
+  if (!result) {
+    throw new Error("Invalid color value: " + value);
+  }
+  return result;
+}
+function normalizeColor(v) {
+  if (typeof v === "string") {
+    return parseColor(v);
+  } else {
+    return v;
+  }
+}
+
+export {
+  parseColor,
+  normalizeColor
+};

package/dist/color.d.ts

@@ -0,0 +1,20 @@
+import { ColorType, ColorFormat, ColorChannel, ColorChannelRange, ColorAxes } from './types.js';
+
+declare abstract class Color implements ColorType {
+    abstract toFormat(format: ColorFormat): ColorType;
+    abstract toString(format: ColorFormat | "css"): string;
+    abstract clone(): ColorType;
+    abstract getChannelRange(channel: ColorChannel): ColorChannelRange;
+    abstract getColorSpace(): ColorFormat;
+    abstract getColorChannels(): [ColorChannel, ColorChannel, ColorChannel];
+    toHexInt(): number;
+    getChannelValue(channel: ColorChannel): number;
+    withChannelValue(channel: ColorChannel, value: number): ColorType;
+    getColorSpaceAxes(xyChannels: {
+        xChannel?: ColorChannel;
+        yChannel?: ColorChannel;
+    }): ColorAxes;
+    isEqual(color: ColorType): boolean;
+}
+
+export { Color };

package/dist/color.js

@@ -0,0 +1,58 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/color.ts
+var color_exports = {};
+__export(color_exports, {
+  Color: () => Color
+});
+module.exports = __toCommonJS(color_exports);
+var Color = class {
+  toHexInt() {
+    return this.toFormat("rgb").toHexInt();
+  }
+  getChannelValue(channel) {
+    if (channel in this) {
+      return this[channel];
+    }
+    throw new Error("Unsupported color channel: " + channel);
+  }
+  withChannelValue(channel, value) {
+    if (channel in this) {
+      let clone = this.clone();
+      clone[channel] = value;
+      return clone;
+    }
+    throw new Error("Unsupported color channel: " + channel);
+  }
+  getColorSpaceAxes(xyChannels) {
+    let { xChannel, yChannel } = xyChannels;
+    let xCh = xChannel || this.getColorChannels().find((c) => c !== yChannel);
+    let yCh = yChannel || this.getColorChannels().find((c) => c !== xCh);
+    let zCh = this.getColorChannels().find((c) => c !== xCh && c !== yCh);
+    return { xChannel: xCh, yChannel: yCh, zChannel: zCh };
+  }
+  isEqual(color) {
+    return this.toHexInt() === color.toHexInt();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Color
+});

package/dist/color.mjs

@@ -0,0 +1,7 @@
+import {
+  Color
+} from "./chunk-NSR5W5ST.mjs";
+import "./chunk-NHABU752.mjs";
+export {
+  Color
+};

package/dist/hsb-color.d.ts

@@ -0,0 +1,32 @@
+import { Color } from './color.js';
+import { ColorFormat, ColorType, ColorChannel, ColorChannelRange } from './types.js';
+
+declare class HSBColor extends Color {
+    private hue;
+    private saturation;
+    private brightness;
+    private alpha;
+    constructor(hue: number, saturation: number, brightness: number, alpha: number);
+    static parse(value: string): HSBColor | void;
+    toString(format: ColorFormat | "css"): string;
+    toFormat(format: ColorFormat): ColorType;
+    /**
+     * Converts a HSB color to HSL.
+     * Conversion formula adapted from https://en.wikipedia.org/wiki/HSL_and_HSV#HSV_to_HSL.
+     * @returns An HSLColor object.
+     */
+    private toHSL;
+    /**
+     * Converts a HSV color value to RGB.
+     * Conversion formula adapted from https://en.wikipedia.org/wiki/HSL_and_HSV#HSV_to_RGB_alternative.
+     * @returns An RGBColor object.
+     */
+    private toRGB;
+    clone(): ColorType;
+    getChannelRange(channel: ColorChannel): ColorChannelRange;
+    getColorSpace(): ColorFormat;
+    private static colorChannels;
+    getColorChannels(): [ColorChannel, ColorChannel, ColorChannel];
+}
+
+export { HSBColor };