@qsxy/element-plus-react 1.0.0-next.1

package/dist/ColorPicker/SvPanel.js

@@ -0,0 +1,95 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/ColorPicker/SvPanel.tsx
+var SvPanel_exports = {};
+__export(SvPanel_exports, {
+  default: () => SvPanel_default
+});
+module.exports = __toCommonJS(SvPanel_exports);
+var import_ahooks = require("ahooks");
+var import_react = __toESM(require("react"));
+var import_hooks = require("../hooks");
+var import_draggable = __toESM(require("./draggable"));
+var import_util = require("./util");
+var SvPanel = (0, import_react.forwardRef)((props, ref) => {
+  const { color, onChange } = props;
+  const { b, e } = (0, import_hooks.useClassNames)("color-svpanel");
+  const [cursorTop, setCursorTop] = (0, import_react.useState)(0);
+  const [cursorLeft, setCursorLeft] = (0, import_react.useState)(0);
+  const [background, setBackground] = (0, import_react.useState)("hsl(0, 100%, 50%)");
+  const el = (0, import_react.useRef)();
+  const update = (0, import_react.useCallback)(() => {
+    if (color) {
+      const saturation = color.get("saturation");
+      const value = color.get("value");
+      const { clientWidth: width, clientHeight: height } = el.current;
+      setCursorLeft(saturation * width / 100);
+      setCursorTop((100 - value) * height / 100);
+      setBackground(`hsl(${color.get("hue")}, 100%, 50%)`);
+    }
+  }, [color]);
+  const handleDrag = (0, import_react.useCallback)(
+    (event) => {
+      var _a;
+      const rect = (_a = el.current) == null ? void 0 : _a.getBoundingClientRect();
+      const { clientX, clientY } = (0, import_util.getClientXY)(event);
+      let left = clientX - rect.left;
+      let top = clientY - rect.top;
+      left = Math.max(0, left);
+      left = Math.min(left, rect.width);
+      top = Math.max(0, top);
+      top = Math.min(top, rect.height);
+      setCursorLeft(left);
+      setCursorTop(top);
+      color.set({
+        saturation: left / rect.width * 100,
+        value: 100 - top / rect.height * 100
+      });
+      onChange(color);
+    },
+    [color, onChange]
+  );
+  (0, import_react.useImperativeHandle)(ref, () => ({
+    update
+  }));
+  (0, import_ahooks.useMount)(() => {
+    (0, import_draggable.default)(el.current, {
+      drag: (event) => {
+        handleDrag(event);
+      },
+      end: (event) => {
+        handleDrag(event);
+      }
+    });
+  });
+  return /* @__PURE__ */ import_react.default.createElement("div", { className: b(), style: { backgroundColor: background }, ref: el }, /* @__PURE__ */ import_react.default.createElement("div", { className: e`white` }), /* @__PURE__ */ import_react.default.createElement("div", { className: e`black` }), /* @__PURE__ */ import_react.default.createElement("div", { className: e`cursor`, style: { top: cursorTop, left: cursorLeft } }, /* @__PURE__ */ import_react.default.createElement("div", null)));
+});
+SvPanel.defaultProps = {};
+SvPanel.displayName = "SvPanel";
+var SvPanel_default = SvPanel;

package/dist/ColorPicker/color.d.ts

@@ -0,0 +1,28 @@
+export interface Options {
+    enableAlpha: boolean;
+    format: string;
+    value?: string;
+}
+export default class Color {
+    private _hue;
+    private _saturation;
+    private _value;
+    private _alpha;
+    enableAlpha: boolean;
+    format: string;
+    value: string;
+    selected?: boolean;
+    constructor(options?: Options);
+    set(prop: {
+        [key: string]: any;
+    } | any, value?: number): void;
+    get(prop: string): any;
+    toRgb(): {
+        r: number;
+        g: number;
+        b: number;
+    };
+    fromString(value: any): void;
+    compare(color: any): boolean;
+    doOnChange(): void;
+}

package/dist/ColorPicker/color.js

@@ -0,0 +1,293 @@
+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/ColorPicker/color.ts
+var color_exports = {};
+__export(color_exports, {
+  default: () => Color
+});
+module.exports = __toCommonJS(color_exports);
+var hsv2hsl = function(hue, sat, val) {
+  return [hue, sat * val / ((hue = (2 - sat) * val) < 1 ? hue : 2 - hue) || 0, hue / 2];
+};
+var isOnePointZero = function(n) {
+  return typeof n === "string" && n.includes(".") && Number.parseFloat(n) === 1;
+};
+var isPercentage = function(n) {
+  return typeof n === "string" && n.includes("%");
+};
+var bound01 = function(value, max) {
+  if (isOnePointZero(value)) {
+    value = "100%";
+  }
+  const processPercent = isPercentage(value);
+  value = Math.min(max, Math.max(0, Number.parseFloat(`${value}`)));
+  if (processPercent) {
+    value = Number.parseInt(`${value * max}`, 10) / 100;
+  }
+  if (Math.abs(value - max) < 1e-6) {
+    return 1;
+  }
+  return value % max / Number.parseFloat(max);
+};
+var INT_HEX_MAP = { 10: "A", 11: "B", 12: "C", 13: "D", 14: "E", 15: "F" };
+var hexOne = function(value) {
+  value = Math.min(Math.round(value), 255);
+  const high = Math.floor(value / 16);
+  const low = value % 16;
+  return `${INT_HEX_MAP[high] || high}${INT_HEX_MAP[low] || low}`;
+};
+var toHex = function({ r, g, b }) {
+  if (Number.isNaN(+r) || Number.isNaN(+g) || Number.isNaN(+b)) {
+    return "";
+  }
+  return `#${hexOne(r)}${hexOne(g)}${hexOne(b)}`;
+};
+var HEX_INT_MAP = { A: 10, B: 11, C: 12, D: 13, E: 14, F: 15 };
+var parseHexChannel = function(hex) {
+  if (hex.length === 2) {
+    return (HEX_INT_MAP[hex[0].toUpperCase()] || +hex[0]) * 16 + (HEX_INT_MAP[hex[1].toUpperCase()] || +hex[1]);
+  }
+  return HEX_INT_MAP[hex[1].toUpperCase()] || +hex[1];
+};
+var hsl2hsv = function(hue, sat, light) {
+  sat = sat / 100;
+  light = light / 100;
+  let smin = sat;
+  const lmin = Math.max(light, 0.01);
+  light *= 2;
+  sat *= light <= 1 ? light : 2 - light;
+  smin *= lmin <= 1 ? lmin : 2 - lmin;
+  const v = (light + sat) / 2;
+  const sv = light === 0 ? 2 * smin / (lmin + smin) : 2 * sat / (light + sat);
+  return {
+    h: hue,
+    s: sv * 100,
+    v: v * 100
+  };
+};
+var rgb2hsv = function(r, g, b) {
+  r = bound01(r, 255);
+  g = bound01(g, 255);
+  b = bound01(b, 255);
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  let h;
+  const v = max;
+  const d = max - min;
+  const s = max === 0 ? 0 : d / max;
+  if (max === min) {
+    h = 0;
+  } else {
+    switch (max) {
+      case r: {
+        h = (g - b) / d + (g < b ? 6 : 0);
+        break;
+      }
+      case g: {
+        h = (b - r) / d + 2;
+        break;
+      }
+      case b: {
+        h = (r - g) / d + 4;
+        break;
+      }
+    }
+    h /= 6;
+  }
+  return { h: h * 360, s: s * 100, v: v * 100 };
+};
+var hsv2rgb = function(h, s, v) {
+  h = bound01(h, 360) * 6;
+  s = bound01(s, 100);
+  v = bound01(v, 100);
+  const i = Math.floor(h);
+  const f = h - i;
+  const p = v * (1 - s);
+  const q = v * (1 - f * s);
+  const t = v * (1 - (1 - f) * s);
+  const mod = i % 6;
+  const r = [v, q, p, p, t, v][mod];
+  const g = [t, v, v, q, p, p][mod];
+  const b = [p, p, t, v, v, q][mod];
+  return {
+    r: Math.round(r * 255),
+    g: Math.round(g * 255),
+    b: Math.round(b * 255)
+  };
+};
+var Color = class {
+  constructor(options) {
+    this._hue = 0;
+    this._saturation = 100;
+    this._value = 100;
+    this._alpha = 100;
+    this.enableAlpha = false;
+    this.format = "hex";
+    this.value = "";
+    options = options || {};
+    for (const option in options) {
+      if (Object.prototype.hasOwnProperty.call(options, option)) {
+        this[option] = options[option];
+      }
+    }
+    if (options.value) {
+      this.fromString(options.value);
+    } else {
+      this.doOnChange();
+    }
+  }
+  set(prop, value) {
+    if (arguments.length === 1 && typeof prop === "object") {
+      for (const p in prop) {
+        if (Object.prototype.hasOwnProperty.call(prop, p)) {
+          this.set(p, prop[p]);
+        }
+      }
+      return;
+    }
+    this[`_${prop}`] = value;
+    this.doOnChange();
+  }
+  get(prop) {
+    if (prop === "alpha") {
+      return Math.floor(this[`_${prop}`]);
+    }
+    return this[`_${prop}`];
+  }
+  toRgb() {
+    return hsv2rgb(this._hue, this._saturation, this._value);
+  }
+  fromString(value) {
+    if (!value) {
+      this._hue = 0;
+      this._saturation = 100;
+      this._value = 100;
+      this.doOnChange();
+      return;
+    }
+    const fromHSV = (h, s, v) => {
+      this._hue = Math.max(0, Math.min(360, h));
+      this._saturation = Math.max(0, Math.min(100, s));
+      this._value = Math.max(0, Math.min(100, v));
+      this.doOnChange();
+    };
+    if (value.includes("hsl")) {
+      const parts = value.replace(/hsla|hsl|\(|\)/gm, "").split(/\s|,/g).filter((val) => val !== "").map((val, index) => index > 2 ? Number.parseFloat(val) : Number.parseInt(val, 10));
+      if (parts.length === 4) {
+        this._alpha = Number.parseFloat(parts[3]) * 100;
+      } else if (parts.length === 3) {
+        this._alpha = 100;
+      }
+      if (parts.length >= 3) {
+        const { h, s, v } = hsl2hsv(parts[0], parts[1], parts[2]);
+        fromHSV(h, s, v);
+      }
+    } else if (value.includes("hsv")) {
+      const parts = value.replace(/hsva|hsv|\(|\)/gm, "").split(/\s|,/g).filter((val) => val !== "").map((val, index) => index > 2 ? Number.parseFloat(val) : Number.parseInt(val, 10));
+      if (parts.length === 4) {
+        this._alpha = Number.parseFloat(parts[3]) * 100;
+      } else if (parts.length === 3) {
+        this._alpha = 100;
+      }
+      if (parts.length >= 3) {
+        fromHSV(parts[0], parts[1], parts[2]);
+      }
+    } else if (value.includes("rgb")) {
+      const parts = value.replace(/rgba|rgb|\(|\)/gm, "").split(/\s|,/g).filter((val) => val !== "").map((val, index) => index > 2 ? Number.parseFloat(val) : Number.parseInt(val, 10));
+      if (parts.length === 4) {
+        this._alpha = Number.parseFloat(parts[3]) * 100;
+      } else if (parts.length === 3) {
+        this._alpha = 100;
+      }
+      if (parts.length >= 3) {
+        const { h, s, v } = rgb2hsv(parts[0], parts[1], parts[2]);
+        fromHSV(h, s, v);
+      }
+    } else if (value.includes("#")) {
+      const hex = value.replace("#", "").trim();
+      if (!/^[0-9a-fA-F]{3}$|^[0-9a-fA-F]{6}$|^[0-9a-fA-F]{8}$/.test(hex)) {
+        return;
+      }
+      let r, g, b;
+      if (hex.length === 3) {
+        r = parseHexChannel(hex[0] + hex[0]);
+        g = parseHexChannel(hex[1] + hex[1]);
+        b = parseHexChannel(hex[2] + hex[2]);
+      } else if (hex.length === 6 || hex.length === 8) {
+        r = parseHexChannel(hex.slice(0, 2));
+        g = parseHexChannel(hex.slice(2, 4));
+        b = parseHexChannel(hex.slice(4, 6));
+      }
+      if (hex.length === 8) {
+        this._alpha = parseHexChannel(hex.slice(6)) / 255 * 100;
+      } else if (hex.length === 3 || hex.length === 6) {
+        this._alpha = 100;
+      }
+      const { h, s, v } = rgb2hsv(r, g, b);
+      fromHSV(h, s, v);
+    }
+  }
+  compare(color) {
+    return Math.abs(color._hue - this._hue) < 2 && Math.abs(color._saturation - this._saturation) < 1 && Math.abs(color._value - this._value) < 1 && Math.abs(color._alpha - this._alpha) < 1;
+  }
+  doOnChange() {
+    const { _hue, _saturation, _value, _alpha, format } = this;
+    if (this.enableAlpha) {
+      switch (format) {
+        case "hsl": {
+          const hsl = hsv2hsl(_hue, _saturation / 100, _value / 100);
+          this.value = `hsla(${_hue}, ${Math.round(hsl[1] * 100)}%, ${Math.round(hsl[2] * 100)}%, ${this.get("alpha") / 100})`;
+          break;
+        }
+        case "hsv": {
+          this.value = `hsva(${_hue}, ${Math.round(_saturation)}%, ${Math.round(_value)}%, ${this.get("alpha") / 100})`;
+          break;
+        }
+        case "hex": {
+          this.value = `${toHex(hsv2rgb(_hue, _saturation, _value))}${hexOne(_alpha * 255 / 100)}`;
+          break;
+        }
+        default: {
+          const { r, g, b } = hsv2rgb(_hue, _saturation, _value);
+          this.value = `rgba(${r}, ${g}, ${b}, ${this.get("alpha") / 100})`;
+        }
+      }
+    } else {
+      switch (format) {
+        case "hsl": {
+          const hsl = hsv2hsl(_hue, _saturation / 100, _value / 100);
+          this.value = `hsl(${_hue}, ${Math.round(hsl[1] * 100)}%, ${Math.round(hsl[2] * 100)}%)`;
+          break;
+        }
+        case "hsv": {
+          this.value = `hsv(${_hue}, ${Math.round(_saturation)}%, ${Math.round(_value)}%)`;
+          break;
+        }
+        case "rgb": {
+          const { r, g, b } = hsv2rgb(_hue, _saturation, _value);
+          this.value = `rgb(${r}, ${g}, ${b})`;
+          break;
+        }
+        default: {
+          this.value = toHex(hsv2rgb(_hue, _saturation, _value));
+        }
+      }
+    }
+  }
+};

package/dist/ColorPicker/draggable.d.ts

@@ -0,0 +1,6 @@
+export declare interface IOptions {
+    drag?: (event: Event) => void;
+    start?: (event: Event) => void;
+    end?: (event: Event) => void;
+}
+export default function (element: HTMLElement, options: IOptions): void;

package/dist/ColorPicker/draggable.js

@@ -0,0 +1,60 @@
+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/ColorPicker/draggable.ts
+var draggable_exports = {};
+__export(draggable_exports, {
+  default: () => draggable_default
+});
+module.exports = __toCommonJS(draggable_exports);
+var import_dom_lib = require("dom-lib");
+var isDragging = false;
+function draggable_default(element, options) {
+  const moveFn = function(event) {
+    var _a;
+    (_a = options.drag) == null ? void 0 : _a.call(options, event);
+  };
+  const upFn = function(event) {
+    var _a;
+    (0, import_dom_lib.off)(document, "mousemove", moveFn);
+    (0, import_dom_lib.off)(document, "mouseup", upFn);
+    (0, import_dom_lib.off)(document, "touchmove", moveFn);
+    (0, import_dom_lib.off)(document, "touchend", upFn);
+    document.onselectstart = null;
+    document.ondragstart = null;
+    isDragging = false;
+    (_a = options.end) == null ? void 0 : _a.call(options, event);
+  };
+  const downFn = function(event) {
+    var _a;
+    if (isDragging) {
+      return;
+    }
+    event.preventDefault();
+    document.onselectstart = () => false;
+    document.ondragstart = () => false;
+    (0, import_dom_lib.on)(document, "mousemove", moveFn);
+    (0, import_dom_lib.on)(document, "mouseup", upFn);
+    (0, import_dom_lib.on)(document, "touchmove", moveFn);
+    (0, import_dom_lib.on)(document, "touchend", upFn);
+    isDragging = true;
+    (_a = options.start) == null ? void 0 : _a.call(options, event);
+  };
+  (0, import_dom_lib.on)(element, "mousedown", downFn);
+  (0, import_dom_lib.on)(element, "touchstart", downFn);
+}

package/dist/ColorPicker/index.d.ts

@@ -0,0 +1,2 @@
+export { default as ColorPicker } from './ColorPicker';
+export type { ColorPickerProps } from './typings';

package/dist/ColorPicker/index.js

@@ -0,0 +1,39 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/ColorPicker/index.ts
+var ColorPicker_exports = {};
+__export(ColorPicker_exports, {
+  ColorPicker: () => import_ColorPicker.default
+});
+module.exports = __toCommonJS(ColorPicker_exports);
+var import_ColorPicker = __toESM(require("./ColorPicker"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ColorPicker
+});

package/dist/ColorPicker/typings.d.ts

@@ -0,0 +1,13 @@
+import { PopperOptions } from '../Popper';
+import { AnimationEventProps, BaseProps, NativeProps, TypeAttributes } from '../types/common';
+export interface ColorPickerProps extends BaseProps, NativeProps, AnimationEventProps, PopperOptions {
+    value?: string;
+    defaultValue?: string;
+    disabled?: boolean;
+    size?: TypeAttributes.Size;
+    showAlpha?: boolean;
+    colorFormat?: 'hsl' | 'hsv' | 'hex' | 'rgb';
+    predefine?: string[];
+    onChange?: (value?: string) => void;
+    activeChange?: (value?: string) => void;
+}

package/dist/ColorPicker/typings.js

@@ -0,0 +1,17 @@
+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/ColorPicker/typings.ts
+var typings_exports = {};
+module.exports = __toCommonJS(typings_exports);

package/dist/ColorPicker/util.d.ts

@@ -0,0 +1,6 @@
+export declare const getClientXY: (event: MouseEvent | TouchEvent) => {
+    clientX: number;
+    clientY: number;
+};
+export declare const displayedRgb: (color: any, showAlpha: any) => string;
+export declare function parseColors(colors: any, color: any): any;

package/dist/ColorPicker/util.js

@@ -0,0 +1,78 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/ColorPicker/util.ts
+var util_exports = {};
+__export(util_exports, {
+  displayedRgb: () => displayedRgb,
+  getClientXY: () => getClientXY,
+  parseColors: () => parseColors
+});
+module.exports = __toCommonJS(util_exports);
+var import_color = __toESM(require("./color"));
+var getClientXY = (event) => {
+  let clientX;
+  let clientY;
+  if (event.type === "touchend") {
+    clientY = event.changedTouches[0].clientY;
+    clientX = event.changedTouches[0].clientX;
+  } else if (event.type.startsWith("touch")) {
+    clientY = event.touches[0].clientY;
+    clientX = event.touches[0].clientX;
+  } else {
+    clientY = event.clientY;
+    clientX = event.clientX;
+  }
+  return {
+    clientX,
+    clientY
+  };
+};
+var displayedRgb = (color, showAlpha) => {
+  if (!(color instanceof import_color.default)) {
+    throw new TypeError("color should be instance of _color Class");
+  }
+  const { r, g, b } = color.toRgb();
+  return showAlpha ? `rgba(${r}, ${g}, ${b}, ${color.get("alpha") / 100})` : `rgb(${r}, ${g}, ${b})`;
+};
+function parseColors(colors, color) {
+  return colors.map((value) => {
+    const c = new import_color.default();
+    c.enableAlpha = true;
+    c.format = "rgba";
+    c.fromString(value);
+    c.selected = c.value === color.value;
+    return c;
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  displayedRgb,
+  getClientXY,
+  parseColors
+});

package/dist/ConfigProvider/ConfigProvider.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="react" />
+export interface ConfigProviderProps {
+    button?: {
+        autoInsertSpace?: boolean;
+    };
+    inputNumber?: {
+        controlsPositionRight?: boolean;
+        max?: number;
+        min?: number;
+    };
+    popper?: {
+        appendTo?: HTMLElement;
+    };
+}
+declare const ConfigProvider: import("react").Context<ConfigProviderProps>;
+export default ConfigProvider;