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

package/dist/rgb-color.js

@@ -0,0 +1,440 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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 = (mod2) => __copyProps(__defProp({}, "__esModule", { value: true }), mod2);
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+
+// src/rgb-color.ts
+var rgb_color_exports = {};
+__export(rgb_color_exports, {
+  RGBColor: () => RGBColor
+});
+module.exports = __toCommonJS(rgb_color_exports);
+
+// 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();
+  }
+};
+
+// 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);
+}
+
+// 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"]);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RGBColor
+});

package/dist/rgb-color.mjs

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

package/dist/types.d.ts

@@ -0,0 +1,64 @@
+type ColorFormat = "hex" | "hexa" | "rgb" | "rgba" | "hsl" | "hsla" | "hsb" | "hsba";
+type ColorChannel = "hue" | "saturation" | "brightness" | "lightness" | "red" | "green" | "blue" | "alpha";
+type ColorAxes = {
+    xChannel: ColorChannel;
+    yChannel: ColorChannel;
+    zChannel: ColorChannel;
+};
+interface ColorChannelRange {
+    /** The minimum value of the color channel. */
+    minValue: number;
+    /** The maximum value of the color channel. */
+    maxValue: number;
+    /** The step value of the color channel, used when incrementing and decrementing. */
+    step: number;
+    /** The page step value of the color channel, used when incrementing and decrementing. */
+    pageSize: number;
+}
+interface ColorType {
+    /** Converts the color to the given color format, and returns a new Color object. */
+    toFormat(format: ColorFormat): ColorType;
+    /** Converts the color to a string in the given format. */
+    toString(format: ColorFormat | "css"): string;
+    /** Converts the color to hex, and returns an integer representation. */
+    toHexInt(): number;
+    /**
+     * Returns the numeric value for a given channel.
+     * Throws an error if the channel is unsupported in the current color format.
+     */
+    getChannelValue(channel: ColorChannel): number;
+    /**
+     * Sets the numeric value for a given channel, and returns a new Color object.
+     * Throws an error if the channel is unsupported in the current color format.
+     */
+    withChannelValue(channel: ColorChannel, value: number): ColorType;
+    /**
+     * Returns the minimum, maximum, and step values for a given channel.
+     */
+    getChannelRange(channel: ColorChannel): ColorChannelRange;
+    /**
+     * Returns the color space, 'rgb', 'hsb' or 'hsl', for the current color.
+     */
+    getColorSpace(): ColorFormat;
+    /**
+     * Returns the color space axes, xChannel, yChannel, zChannel.
+     */
+    getColorSpaceAxes(xyChannels: {
+        xChannel?: ColorChannel;
+        yChannel?: ColorChannel;
+    }): ColorAxes;
+    /**
+     * Returns an array of the color channels within the current color space space.
+     */
+    getColorChannels(): [ColorChannel, ColorChannel, ColorChannel];
+    /**
+     * Returns a new Color object with the same values as the current color.
+     */
+    clone(): ColorType;
+    /**
+     * Whether the color is equal to another color.
+     */
+    isEqual(color: ColorType): boolean;
+}
+
+export { ColorAxes, ColorChannel, ColorChannelRange, ColorFormat, ColorType };

package/dist/types.js

@@ -0,0 +1,18 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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/types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/utils.d.ts

@@ -0,0 +1,5 @@
+declare function mod(n: number, m: number): number;
+declare function toFixedNumber(num: number, digits: number): number;
+declare function clampValue(value: number, min: number, max: number): number;
+
+export { clampValue, mod, toFixedNumber };

package/dist/utils.js

@@ -0,0 +1,42 @@
+"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 = (mod2) => __copyProps(__defProp({}, "__esModule", { value: true }), mod2);
+
+// src/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  clampValue: () => clampValue,
+  mod: () => mod,
+  toFixedNumber: () => toFixedNumber
+});
+module.exports = __toCommonJS(utils_exports);
+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);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clampValue,
+  mod,
+  toFixedNumber
+});

package/dist/utils.mjs

@@ -0,0 +1,11 @@
+import {
+  clampValue,
+  mod,
+  toFixedNumber
+} from "./chunk-TXOVH6IE.mjs";
+import "./chunk-NHABU752.mjs";
+export {
+  clampValue,
+  mod,
+  toFixedNumber
+};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@zag-js/color-utils",
+  "version": "0.0.0-dev-20230414151834",
+  "description": "Color utilities for zag.js",
+  "keywords": [
+    "js",
+    "utils",
+    "color-utils"
+  ],
+  "author": "Segun Adebayo <sage@adebayosegun.com>",
+  "homepage": "https://github.com/chakra-ui/zag#readme",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "repository": "https://github.com/chakra-ui/zag/tree/main/packages/utilities/color-utils",
+  "sideEffects": false,
+  "files": [
+    "dist/**/*"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "bugs": {
+    "url": "https://github.com/chakra-ui/zag/issues"
+  },
+  "clean-package": "../../../clean-package.config.json",
+  "devDependencies": {
+    "clean-package": "2.2.0"
+  },
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build-fast": "tsup src",
+    "start": "pnpm build --watch",
+    "build": "tsup src --dts",
+    "test": "jest --config ../../../jest.config.js --rootDir . --passWithNoTests",
+    "lint": "eslint src --ext .ts,.tsx",
+    "test-ci": "pnpm test --ci --runInBand",
+    "test-watch": "pnpm test --watch -u",
+    "typecheck": "tsc --noEmit"
+  }
+}