"use strict";
Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
const vue = require("vue");
const comp = require("../../ui/src/comp.js");
const XEUtils = require("xe-utils");
require("../../ui/index.js");
const dom = require("../../ui/src/dom.js");
const utils = require("../../ui/src/utils.js");
const util = require("./util.js");
const button = require("../../button/src/button.js");
const input = require("../../input/src/input.js");
const numberInput = require("../../number-input/src/number-input.js");
const config = require("../../../../@vxe-ui/core/es/src/config.js");
const useFns = require("../../../../@vxe-ui/core/es/src/useFns.js");
const event = require("../../../../@vxe-ui/core/es/src/event.js");
const index_esm = require("../../../../@vxe-ui/core/es/index.esm.js");
const i18n = require("../../../../@vxe-ui/core/es/src/i18n.js");
const icon = require("../../../../@vxe-ui/core/es/src/icon.js");
const VxeColorPickerComponent = comp.defineVxeComponent({
  name: "VxeColorPicker",
  props: {
    modelValue: String,
    placeholder: String,
    clearable: {
      type: Boolean,
      default: () => config.getConfig().colorPicker.clearable
    },
    type: {
      type: String,
      default: () => config.getConfig().colorPicker.type
    },
    size: {
      type: String,
      default: () => config.getConfig().colorPicker.size || config.getConfig().size
    },
    className: [String, Function],
    popupClassName: [String, Function],
    colors: {
      type: Array,
      default: () => XEUtils.clone(config.getConfig().colorPicker.colors, true) || []
    },
    showAlpha: {
      type: Boolean,
      default: () => config.getConfig().colorPicker.showAlpha
    },
    showEyeDropper: {
      type: Boolean,
      default: () => config.getConfig().colorPicker.showEyeDropper
    },
    showColorExtractor: {
      type: Boolean,
      default: () => config.getConfig().colorPicker.showColorExtractor
    },
    showQuick: {
      type: Boolean,
      default: () => config.getConfig().colorPicker.showQuick
    },
    readonly: {
      type: Boolean,
      default: null
    },
    disabled: {
      type: Boolean,
      default: null
    },
    clickToCopy: {
      type: Boolean,
      default: () => config.getConfig().colorPicker.clickToCopy
    },
    placement: String,
    transfer: {
      type: Boolean,
      default: null
    }
  },
  emits: [
    "update:modelValue",
    "change",
    "clear",
    "click"
  ],
  setup(props, context) {
    const { emit } = context;
    const $xeModal = vue.inject("$xeModal", null);
    const $xeDrawer = vue.inject("$xeDrawer", null);
    const $xeTable = vue.inject("$xeTable", null);
    const $xeForm = vue.inject("$xeForm", null);
    const formItemInfo = vue.inject("xeFormItemInfo", null);
    const WinEyeDropper = typeof window !== "undefined" ? window.EyeDropper : null;
    const xID = XEUtils.uniqueId();
    const { computeSize } = useFns.useSize(props);
    const refElem = vue.ref();
    const refInputTarget = vue.ref();
    const refOptionPanel = vue.ref();
    const refHueSliderElem = vue.ref();
    const refHueSliderBtnElem = vue.ref();
    const refAlphaSliderElem = vue.ref();
    const refAlphaSliderBtnElem = vue.ref();
    const refColorPanelElem = vue.ref();
    const refColorActiveElem = vue.ref();
    const reactData = vue.reactive({
      initialized: false,
      selectTyle: "hex",
      selectColor: `${props.modelValue || ""}`,
      showTypePopup: false,
      panelColor: "",
      hexValue: "",
      rValue: 0,
      gValue: 0,
      bValue: 0,
      aValue: 0,
      panelIndex: 0,
      panelStyle: {},
      panelPlacement: null,
      visiblePanel: false,
      isAniVisible: false,
      isActivated: false
    });
    const typeList = [
      { label: "HEX", value: "hex" },
      { label: "RGB", value: "rgb" }
    ];
    const internalData = {
      // hpTimeout: undefined
    };
    const computeFormReadonly = vue.computed(() => {
      const { readonly } = props;
      if (readonly === null) {
        if ($xeForm) {
          return $xeForm.props.readonly;
        }
        return false;
      }
      return readonly;
    });
    const computeIsDisabled = vue.computed(() => {
      const { disabled } = props;
      if (disabled === null) {
        if ($xeForm) {
          return $xeForm.props.disabled;
        }
        return false;
      }
      return disabled;
    });
    const computeBtnTransfer = vue.computed(() => {
      const { transfer } = props;
      if (transfer === null) {
        const globalTransfer = config.getConfig().colorPicker.transfer;
        if (XEUtils.isBoolean(globalTransfer)) {
          return globalTransfer;
        }
        if ($xeTable || $xeModal || $xeDrawer || $xeForm) {
          return true;
        }
      }
      return transfer;
    });
    const computeColorList = vue.computed(() => {
      const { colors } = props;
      if (colors) {
        return colors.map((item) => {
          if (XEUtils.isString(item)) {
            return {
              label: item,
              value: item
            };
          }
          return {
            label: XEUtils.eqNull(item.label) ? item.value : item.label,
            value: item.value
          };
        });
      }
      return [];
    });
    const computeIsRgb = vue.computed(() => {
      const { selectTyle } = reactData;
      return selectTyle === "rgb";
    });
    const computeSelectTypeItem = vue.computed(() => {
      const { selectTyle } = reactData;
      return typeList.find((item) => item.value === selectTyle);
    });
    const refMaps = {
      refElem
    };
    const computeMaps = {};
    const $xeColorPicker = {
      xID,
      props,
      context,
      reactData,
      getRefMaps: () => refMaps,
      getComputeMaps: () => computeMaps
    };
    const emitModel = (value) => {
      emit("update:modelValue", value);
    };
    const updateMode = () => {
      const { modelValue } = props;
      reactData.selectColor = XEUtils.toValueString(modelValue);
      updateModelColor();
    };
    const updateType = () => {
      const { type } = props;
      let selectTyle = "hex";
      if (type === "rgb" || type === "rgba") {
        selectTyle = "rgb";
      }
      reactData.selectTyle = selectTyle;
      updateMode();
    };
    const updateModelColor = () => {
      const { selectColor, isAniVisible } = reactData;
      const isRgb = computeIsRgb.value;
      const hueSliderEl = refHueSliderElem.value;
      const alphaSliderEl = refAlphaSliderElem.value;
      const colorRest = util.parseColor(selectColor);
      reactData.hexValue = colorRest.hex;
      reactData.rValue = colorRest.r;
      reactData.gValue = colorRest.g;
      reactData.bValue = colorRest.b;
      reactData.aValue = colorRest.a;
      if (colorRest.value) {
        if (isRgb) {
          if (colorRest.type === "hex") {
            const rgbRest = util.hexToRgb(colorRest.hex);
            if (rgbRest) {
              reactData.rValue = rgbRest.r;
              reactData.gValue = rgbRest.g;
              reactData.bValue = rgbRest.b;
              reactData.aValue = rgbRest.a;
            }
          }
        } else {
          if (colorRest.type !== "hex") {
            reactData.hexValue = util.rgbToHex(colorRest);
          }
        }
      }
      if (isAniVisible) {
        const hsvRest = colorRest.type === "hex" ? util.hexToHsv(colorRest.hex) : util.rgbToHsv(colorRest);
        const colorPanelEl = refColorPanelElem.value;
        if (hsvRest) {
          if (colorPanelEl) {
            const offsetTop = colorPanelEl.clientHeight * (1 - hsvRest.v);
            const offsetLeft = colorPanelEl.clientWidth * hsvRest.s;
            handlePanelColor(offsetLeft, offsetTop);
          }
          if (hueSliderEl) {
            handleHueColor(XEUtils.ceil((1 - hsvRest.h / 360) * hueSliderEl.clientWidth));
          }
        }
        if (alphaSliderEl) {
          handleAlphaColor(alphaSliderEl.clientWidth * colorRest.a);
        }
      }
    };
    const updateZindex = () => {
      if (reactData.panelIndex < utils.getLastZIndex()) {
        reactData.panelIndex = utils.nextZIndex();
      }
    };
    const updatePlacement = () => {
      const { placement } = props;
      const { panelIndex } = reactData;
      const targetElem = refElem.value;
      const panelElem = refOptionPanel.value;
      const btnTransfer = computeBtnTransfer.value;
      const handleStyle = () => {
        const ppObj = dom.updatePanelPlacement(targetElem, panelElem, {
          placement,
          teleportTo: btnTransfer
        });
        const panelStyle = Object.assign(ppObj.style, {
          zIndex: panelIndex
        });
        reactData.panelStyle = panelStyle;
        reactData.panelPlacement = ppObj.placement;
      };
      handleStyle();
      return vue.nextTick().then(handleStyle);
    };
    const showOptionPanel = () => {
      const { hpTimeout } = internalData;
      const isDisabled = computeIsDisabled.value;
      if (!isDisabled) {
        if (hpTimeout) {
          clearTimeout(hpTimeout);
          internalData.hpTimeout = void 0;
        }
        if (!reactData.initialized) {
          reactData.initialized = true;
        }
        reactData.isActivated = true;
        reactData.isAniVisible = true;
        setTimeout(() => {
          updateModelColor();
          reactData.visiblePanel = true;
        }, 10);
        updateZindex();
        updatePlacement();
      }
    };
    const hideOptionPanel = () => {
      reactData.visiblePanel = false;
      internalData.hpTimeout = setTimeout(() => {
        reactData.isAniVisible = false;
      }, 350);
    };
    const changeEvent = (evnt, value) => {
      reactData.selectColor = value;
      if (value !== props.modelValue) {
        emitModel(value);
        dispatchEvent("change", { value }, evnt);
        if ($xeForm && formItemInfo) {
          $xeForm.triggerItemEvent(evnt, formItemInfo.itemConfig.field, value);
        }
      }
    };
    const clearValueEvent = (evnt, selectValue) => {
      changeEvent(evnt, selectValue);
      dispatchEvent("clear", { value: selectValue }, evnt);
    };
    const focusEvent = () => {
      const isDisabled = computeIsDisabled.value;
      if (!isDisabled) {
        if (!reactData.visiblePanel) {
          showOptionPanel();
        }
      }
    };
    const blurEvent = () => {
      reactData.isActivated = false;
    };
    const clearEvent = (evnt) => {
      clearValueEvent(evnt, null);
      hideOptionPanel();
    };
    const confirmEvent = (evnt) => {
      const { selectColor } = reactData;
      changeEvent(evnt, selectColor);
      hideOptionPanel();
    };
    const togglePanelEvent = (evnt) => {
      evnt.preventDefault();
      if (reactData.visiblePanel) {
        hideOptionPanel();
      } else {
        showOptionPanel();
      }
    };
    const clickEvent = (evnt) => {
      togglePanelEvent(evnt);
      dispatchEvent("click", {}, evnt);
    };
    const handlePanelClickEvent = () => {
      reactData.showTypePopup = false;
    };
    const toggleTypeVisibleEvent = (evnt) => {
      evnt.stopPropagation();
      reactData.showTypePopup = !reactData.showTypePopup;
    };
    const handleChangeType = (type) => {
      const { selectTyle } = reactData;
      if (type !== selectTyle) {
        reactData.selectTyle = type;
        updateModelColor();
      }
      reactData.showTypePopup = false;
    };
    const handleHueColor = (offsetLeft) => {
      const hueSliderEl = refHueSliderElem.value;
      const hueSliderBtnEl = refHueSliderBtnElem.value;
      if (hueSliderEl && hueSliderBtnEl) {
        if (offsetLeft < 0) {
          offsetLeft = 0;
        }
        const barWidth = XEUtils.toInteger(hueSliderEl.clientWidth);
        const itemNum = 255;
        const countNum = itemNum * 6;
        const offsetX = XEUtils.ceil(countNum / barWidth * offsetLeft);
        const offsetNum = offsetX % itemNum;
        let rNum = 0;
        let gNum = 0;
        let bNum = 0;
        switch (Math.ceil(offsetX / itemNum)) {
          case 1:
            rNum = itemNum;
            bNum = offsetNum;
            break;
          case 2:
            rNum = itemNum - offsetNum;
            bNum = itemNum;
            break;
          case 3:
            gNum = offsetNum;
            bNum = itemNum;
            break;
          case 4:
            gNum = itemNum;
            bNum = itemNum - offsetNum;
            break;
          case 5:
            rNum = offsetNum;
            gNum = itemNum;
            break;
          case 6:
            rNum = itemNum;
            gNum = itemNum - offsetNum;
            break;
        }
        reactData.panelColor = util.toRgb(rNum, gNum, bNum);
        hueSliderBtnEl.style.left = dom.toCssUnit(offsetLeft);
      }
    };
    const handleHueBarEvent = (evnt) => {
      const hueSliderEl = refHueSliderElem.value;
      const hueSliderBtnEl = refHueSliderBtnElem.value;
      if (hueSliderEl && hueSliderBtnEl) {
        const hueSliderRect = hueSliderEl.getBoundingClientRect();
        const barWidth = XEUtils.toInteger(hueSliderEl.clientWidth);
        const offsetLeft = XEUtils.ceil(Math.min(barWidth - 1, Math.max(1, evnt.clientX - hueSliderRect.x)));
        handleHueColor(offsetLeft);
      }
    };
    const handleHueSliderMousedownEvent = (evnt) => {
      evnt.preventDefault();
      document.onmousemove = (evnt2) => {
        evnt2.preventDefault();
        handleHueBarEvent(evnt2);
      };
      document.onmouseup = (evnt2) => {
        document.onmousemove = null;
        document.onmouseup = null;
        handleHueBarEvent(evnt2);
      };
    };
    const handleAlphaColor = (offsetLeft) => {
      const { selectColor } = reactData;
      const alphaSliderEl = refAlphaSliderElem.value;
      const alphaSliderBtnEl = refAlphaSliderBtnElem.value;
      if (alphaSliderEl && alphaSliderBtnEl) {
        const alphaSliderRect = alphaSliderEl.getBoundingClientRect();
        const barWidth = alphaSliderRect.width;
        if (offsetLeft < 0) {
          offsetLeft = 0;
        }
        if (offsetLeft > barWidth) {
          offsetLeft = barWidth;
        }
        const alpha = XEUtils.ceil(100 / barWidth * offsetLeft / 100, 2);
        reactData.aValue = alpha;
        alphaSliderBtnEl.style.left = dom.toCssUnit(offsetLeft);
        reactData.selectColor = util.updateColorAlpha(selectColor, alpha);
      }
    };
    const handleAlphaBarEvent = (evnt) => {
      const alphaSliderEl = refAlphaSliderElem.value;
      const alphaSliderBtnEl = refAlphaSliderBtnElem.value;
      if (alphaSliderEl && alphaSliderBtnEl) {
        const alphaSliderRect = alphaSliderEl.getBoundingClientRect();
        const barWidth = alphaSliderRect.width;
        const offsetLeft = Math.min(barWidth, Math.max(0, evnt.clientX - alphaSliderRect.x));
        handleAlphaColor(offsetLeft);
        updateModelColor();
      }
    };
    const handleAlphaSliderMousedownEvent = (evnt) => {
      evnt.preventDefault();
      document.onmousemove = (evnt2) => {
        evnt2.preventDefault();
        handleAlphaBarEvent(evnt2);
      };
      document.onmouseup = (evnt2) => {
        document.onmousemove = null;
        document.onmouseup = null;
        handleAlphaBarEvent(evnt2);
      };
    };
    const handleInputRgbEvent = () => {
      const { rValue, gValue, bValue, aValue } = reactData;
      reactData.selectColor = util.toRgb(rValue, gValue, bValue, aValue);
      updateModelColor();
    };
    const handleInputAlphaEvent = () => {
      const { aValue } = reactData;
      const alphaSliderEl = refAlphaSliderElem.value;
      const alphaSliderBtnEl = refAlphaSliderBtnElem.value;
      if (alphaSliderEl && alphaSliderBtnEl) {
        const alphaSliderRect = alphaSliderEl.getBoundingClientRect();
        const barWidth = alphaSliderRect.width;
        const offsetLeft = barWidth * aValue;
        handleAlphaColor(offsetLeft);
      }
    };
    const handleQuickEvent = (evnt, item) => {
      const value = item.value;
      reactData.selectColor = value;
      updateModelColor();
    };
    const handlePanelColor = (offsetLeft, offsetTop) => {
      const colorActiveEl = refColorActiveElem.value;
      if (colorActiveEl) {
        colorActiveEl.style.top = dom.toCssUnit(offsetTop);
        colorActiveEl.style.left = dom.toCssUnit(offsetLeft);
      }
    };
    const handleEyeDropperEvent = () => {
      if (WinEyeDropper) {
        try {
          const eyeDropper = new WinEyeDropper();
          eyeDropper.open().then((rest) => {
            if (rest && rest.sRGBHex) {
              reactData.selectColor = rest.sRGBHex;
              updateModelColor();
            }
          }).catch(() => {
          });
        } catch (e) {
        }
      }
    };
    const handleSelectColorByXY = (clientX, clientY) => {
      const { showAlpha } = props;
      const { panelColor, aValue } = reactData;
      const colorPanelEl = refColorPanelElem.value;
      const colorActiveEl = refColorActiveElem.value;
      if (colorPanelEl && colorActiveEl) {
        const { clientWidth, clientHeight } = colorPanelEl;
        const colorPanelRect = colorPanelEl.getBoundingClientRect();
        const offsetTop = Math.min(clientHeight, Math.max(0, clientY - colorPanelRect.y));
        const offsetLeft = Math.min(clientWidth, Math.max(0, clientX - colorPanelRect.x));
        const colorRest = util.parseColor(panelColor);
        if (colorRest) {
          const hsvRest = colorRest.type === "hex" ? util.hexToHsv(colorRest.hex) : util.rgbToHsv(colorRest);
          if (hsvRest) {
            const ragRest = util.hsvToRgb(hsvRest.h, offsetLeft / clientWidth, 1 - offsetTop / clientHeight);
            reactData.selectColor = util.toRgb(ragRest.r, ragRest.g, ragRest.b, showAlpha ? aValue : null);
            updateModelColor();
          }
        }
        handlePanelColor(offsetLeft, offsetTop);
      }
    };
    const handleSelectColorMousedownEvent = (evnt) => {
      evnt.stopPropagation();
      evnt.preventDefault();
      handleSelectColorByXY(evnt.clientX, evnt.clientY);
      document.onmousemove = (evnt2) => {
        handleSelectColorByXY(evnt2.clientX, evnt2.clientY);
      };
      document.onmouseup = () => {
        document.onmousemove = null;
        document.onmouseup = null;
      };
    };
    const handleCopyColorEvent = () => {
      const { selectColor } = reactData;
      if (selectColor) {
        if (index_esm.VxeUI.clipboard.copy(selectColor)) {
          if (index_esm.VxeUI.modal) {
            index_esm.VxeUI.modal.message({
              content: i18n.getI18n("vxe.colorPicker.copySuccess", [selectColor]),
              status: "success"
            });
          }
        }
      }
    };
    const handleGlobalMousewheelEvent = (evnt) => {
      const { visiblePanel } = reactData;
      const isDisabled = computeIsDisabled.value;
      if (!isDisabled) {
        if (visiblePanel) {
          const panelElem = refOptionPanel.value;
          if (dom.getEventTargetNode(evnt, panelElem).flag) {
            updatePlacement();
          } else {
            hideOptionPanel();
          }
        }
      }
    };
    const handleGlobalMousedownEvent = (evnt) => {
      const { visiblePanel } = reactData;
      const isDisabled = computeIsDisabled.value;
      if (!isDisabled) {
        const el = refElem.value;
        const panelElem = refOptionPanel.value;
        reactData.isActivated = dom.getEventTargetNode(evnt, el).flag || dom.getEventTargetNode(evnt, panelElem).flag;
        if (visiblePanel && !reactData.isActivated) {
          hideOptionPanel();
        }
      }
    };
    const handleGlobalBlurEvent = () => {
      const { visiblePanel, isActivated } = reactData;
      if (visiblePanel) {
        hideOptionPanel();
      }
      if (isActivated) {
        reactData.isActivated = false;
      }
      if (visiblePanel || isActivated) {
        const targetElem = refInputTarget.value;
        if (targetElem) {
          targetElem.blur();
        }
      }
    };
    const handleGlobalResizeEvent = () => {
      const { visiblePanel } = reactData;
      if (visiblePanel) {
        updatePlacement();
      }
    };
    const dispatchEvent = (type, params, evnt) => {
      emit(type, event.createEvent(evnt, { $colorPicker: $xeColorPicker }, params));
    };
    const colorPickerMethods = {
      dispatchEvent
    };
    const colorPickerPrivateMethods = {};
    Object.assign($xeColorPicker, colorPickerMethods, colorPickerPrivateMethods);
    const renderColorWrapper = () => {
      const { showColorExtractor } = props;
      const { panelColor } = reactData;
      if (showColorExtractor) {
        return vue.h("div", {
          ref: refColorPanelElem,
          class: "vxe-color-picker--color-wrapper",
          onMousedown: handleSelectColorMousedownEvent
        }, [
          vue.h("div", {
            class: "vxe-color-picker--color-bg",
            style: {
              backgroundColor: panelColor
            }
          }),
          vue.h("div", {
            class: "vxe-color-picker--white-bg"
          }),
          vue.h("div", {
            class: "vxe-color-picker--black-bg"
          }),
          vue.h("div", {
            ref: refColorActiveElem,
            class: "vxe-color-picker--color-active"
          })
        ]);
      }
      return index_esm.renderEmptyElement();
    };
    const renderColorBar = () => {
      const { showAlpha, clickToCopy, showEyeDropper } = props;
      const { selectTyle, showTypePopup, hexValue, rValue, gValue, bValue, aValue, selectColor, panelColor } = reactData;
      const isRgb = computeIsRgb.value;
      const selectTypeItem = computeSelectTypeItem.value;
      return vue.h("div", {
        class: "vxe-color-picker--bar-wrapper"
      }, [
        vue.h("div", {
          class: "vxe-color-picker--slider-wrapper"
        }, [
          showEyeDropper && WinEyeDropper ? vue.h("div", {
            class: "vxe-color-picker--color-dropper"
          }, [
            vue.h("span", {
              class: "vxe-color-picker--color-dropper-btn",
              onClick: handleEyeDropperEvent
            }, [
              vue.h("i", {
                class: icon.getIcon().COLOR_PICKER_EYE_DROPPER
              })
            ])
          ]) : index_esm.renderEmptyElement(),
          vue.h("div", {
            class: "vxe-color-picker--slider-preview"
          }, [
            vue.h("div", {
              class: "vxe-color-picker--preview-btn"
            }, [
              vue.h("div", {
                class: "vxe-color-picker--preview-color",
                style: {
                  backgroundColor: selectColor
                }
              }, clickToCopy ? [
                vue.h("span", {
                  class: "vxe-color-picker--preview-copy-btn",
                  onClick: handleCopyColorEvent
                }, [
                  vue.h("i", {
                    class: icon.getIcon().COLOR_PICKER_COLOR_COPY
                  })
                ])
              ] : [])
            ])
          ]),
          vue.h("div", {
            class: "vxe-color-picker--slider-handle"
          }, [
            vue.h("div", {
              ref: refHueSliderElem,
              class: "vxe-color-picker--bar-hue-slider",
              onClick: handleHueBarEvent
            }, [
              vue.h("div", {
                ref: refHueSliderBtnElem,
                class: "vxe-color-picker--bar-hue-btn",
                onMousedown: handleHueSliderMousedownEvent
              })
            ]),
            showAlpha ? vue.h("div", {
              ref: refAlphaSliderElem,
              class: "vxe-color-picker--bar-alpha-slider",
              onClick: handleAlphaBarEvent
            }, [
              vue.h("div", {
                class: "vxe-color-picker--bar-alpha-bg",
                style: {
                  background: `linear-gradient(to right, rgba(0, 0, 0, 0), ${panelColor})`
                }
              }),
              vue.h("div", {
                ref: refAlphaSliderBtnElem,
                class: "vxe-color-picker--bar-alpha-btn",
                onMousedown: handleAlphaSliderMousedownEvent
              })
            ]) : index_esm.renderEmptyElement()
          ])
        ]),
        vue.h("div", {
          class: "vxe-color-picker--custom-wrapper"
        }, [
          vue.h("div", {
            class: "vxe-color-picker--type-switch"
          }, [
            vue.h("div", {
              class: "vxe-color-picker--type-label",
              onClick: toggleTypeVisibleEvent
            }, [
              vue.h("span", `${selectTypeItem ? selectTypeItem.label : selectTyle}`),
              vue.h("span", {
                class: "vxe-color-picker--type-icon"
              }, [
                vue.h("i", {
                  class: showTypePopup ? icon.getIcon().COLOR_PICKER_TPTY_OPEN : icon.getIcon().COLOR_PICKER_TPTY_CLOSE
                })
              ])
            ]),
            vue.h("div", {
              class: ["vxe-color-picker--type-popup", {
                "is--visible": showTypePopup
              }]
            }, typeList.map((item) => {
              return vue.h("div", {
                class: "vxe-color-picker--type-item",
                onClick(evnt) {
                  evnt.stopPropagation();
                  handleChangeType(item.value);
                }
              }, item.label);
            }))
          ]),
          vue.h("div", {
            class: `vxe-color-picker--${selectTyle}-wrapper`
          }, isRgb ? [
            vue.h("div", {
              class: "vxe-color-picker--input-wrapper"
            }, [
              vue.h(numberInput.default, {
                type: "integer",
                size: "mini",
                align: "center",
                min: 0,
                max: 255,
                maxLength: 3,
                placeholder: "",
                modelValue: rValue,
                controlConfig: {
                  showButton: false
                },
                "onUpdate:modelValue"(val) {
                  reactData.rValue = val;
                },
                onChange: handleInputRgbEvent
              }),
              vue.h(numberInput.default, {
                type: "integer",
                size: "mini",
                align: "center",
                min: 0,
                max: 255,
                maxLength: 3,
                placeholder: "",
                modelValue: gValue,
                controlConfig: {
                  showButton: false
                },
                "onUpdate:modelValue"(val) {
                  reactData.gValue = val;
                },
                onChange: handleInputRgbEvent
              }),
              vue.h(numberInput.default, {
                type: "integer",
                size: "mini",
                align: "center",
                min: 0,
                max: 255,
                maxLength: 3,
                placeholder: "",
                modelValue: bValue,
                controlConfig: {
                  showButton: false
                },
                "onUpdate:modelValue"(val) {
                  reactData.bValue = val;
                },
                onChange: handleInputRgbEvent
              }),
              vue.h(numberInput.default, {
                type: "number",
                size: "mini",
                align: "center",
                min: 0,
                max: 1,
                step: 0.01,
                maxLength: 4,
                placeholder: "",
                modelValue: aValue,
                controlConfig: {
                  showButton: false
                },
                "onUpdate:modelValue"(val) {
                  reactData.aValue = val;
                },
                onChange: handleInputAlphaEvent
              })
            ]),
            vue.h("div", {
              class: "vxe-color-picker--input-title"
            }, [
              vue.h("span", "R"),
              vue.h("span", "G"),
              vue.h("span", "B"),
              vue.h("span", "A")
            ])
          ] : [
            vue.h("div", {
              class: "vxe-color-picker--input-wrapper"
            }, [
              vue.h(input.default, {
                type: "text",
                size: "mini",
                align: "center",
                maxLength: 9,
                placeholder: "",
                modelValue: hexValue,
                "onUpdate:modelValue"(val) {
                  reactData.hexValue = val;
                },
                onChange() {
                  const colorRest = util.parseColor(reactData.hexValue);
                  if (colorRest) {
                    if (colorRest.value) {
                      reactData.selectColor = colorRest.value;
                      updateModelColor();
                    }
                  }
                }
              })
            ]),
            vue.h("div", {
              class: "vxe-color-picker--input-title"
            }, i18n.getI18n("vxe.colorPicker.hex"))
          ])
        ])
      ]);
    };
    const renderQuickWrapper = () => {
      const { showQuick } = props;
      const colorList = computeColorList.value;
      if (showQuick && colorList.length) {
        return vue.h("div", {
          class: "vxe-color-picker--quick-wrapper"
        }, colorList.map((item, i) => {
          return vue.h("div", {
            key: i,
            class: "vxe-color-picker--quick-item",
            title: item.label || "",
            style: {
              backgroundColor: item.value
            },
            onClick(evnt) {
              handleQuickEvent(evnt, item);
            }
          });
        }));
      }
      return index_esm.renderEmptyElement();
    };
    const renderVN = () => {
      const { className, popupClassName, clearable, modelValue } = props;
      const { initialized, isActivated, isAniVisible, visiblePanel } = reactData;
      const vSize = computeSize.value;
      const isDisabled = computeIsDisabled.value;
      const btnTransfer = computeBtnTransfer.value;
      const formReadonly = computeFormReadonly.value;
      if (formReadonly) {
        return vue.h("div", {
          ref: refElem,
          class: ["vxe-color-picker--readonly", className]
        }, [
          vue.h("div", {
            class: "vxe-color-picker--readonly-color",
            style: {
              backgroundColor: modelValue
            }
          })
        ]);
      }
      return vue.h("div", {
        ref: refElem,
        class: ["vxe-color-picker", className ? XEUtils.isFunction(className) ? className({ $colorPicker: $xeColorPicker }) : className : "", {
          [`size--${vSize}`]: vSize,
          "is--selected": !!modelValue,
          "is--visible": visiblePanel,
          "is--disabled": isDisabled,
          "is--active": isActivated
        }]
      }, [
        vue.h("input", {
          ref: refInputTarget,
          class: "vxe-color-picker--input",
          onFocus: focusEvent,
          onBlur: blurEvent
        }),
        vue.h("div", {
          class: "vxe-color-picker--inner",
          onClick: clickEvent
        }, [
          vue.h("div", {
            class: "vxe-color-picker--inner-color",
            style: {
              backgroundColor: modelValue
            }
          })
        ]),
        vue.h(vue.Teleport, {
          to: "body",
          disabled: btnTransfer ? !initialized : true
        }, [
          vue.h("div", {
            ref: refOptionPanel,
            class: ["vxe-table--ignore-clear vxe-color-picker--panel", popupClassName ? XEUtils.isFunction(popupClassName) ? popupClassName({ $colorPicker: $xeColorPicker }) : popupClassName : "", {
              [`size--${vSize}`]: vSize,
              "is--transfer": btnTransfer,
              "ani--leave": isAniVisible,
              "ani--enter": visiblePanel
            }],
            placement: reactData.panelPlacement,
            style: reactData.panelStyle
          }, [
            initialized && (visiblePanel || isAniVisible) ? vue.h("div", {
              class: "vxe-color-picker--panel-wrapper",
              onClick: handlePanelClickEvent
            }, [
              renderColorWrapper(),
              renderColorBar(),
              renderQuickWrapper(),
              vue.h("div", {
                class: "vxe-color-picker--footer-wrapper"
              }, [
                clearable ? vue.h(button.default, {
                  content: i18n.getI18n("vxe.colorPicker.clear"),
                  size: "mini",
                  onClick: clearEvent
                }) : index_esm.renderEmptyElement(),
                vue.h(button.default, {
                  content: i18n.getI18n("vxe.colorPicker.confirm"),
                  size: "mini",
                  status: "primary",
                  onClick: confirmEvent
                })
              ])
            ]) : index_esm.renderEmptyElement()
          ])
        ])
      ]);
    };
    vue.watch(() => props.modelValue, () => {
      updateMode();
    });
    vue.watch(() => props.type, () => {
      updateType();
    });
    vue.onMounted(() => {
      event.globalEvents.on($xeColorPicker, "mousewheel", handleGlobalMousewheelEvent);
      event.globalEvents.on($xeColorPicker, "mousedown", handleGlobalMousedownEvent);
      event.globalEvents.on($xeColorPicker, "blur", handleGlobalBlurEvent);
      event.globalEvents.on($xeColorPicker, "resize", handleGlobalResizeEvent);
    });
    vue.onUnmounted(() => {
      event.globalEvents.off($xeColorPicker, "mousewheel");
      event.globalEvents.off($xeColorPicker, "mousedown");
      event.globalEvents.off($xeColorPicker, "blur");
      event.globalEvents.off($xeColorPicker, "resize");
    });
    updateType();
    vue.provide("$xeColorPicker", $xeColorPicker);
    $xeColorPicker.renderVN = renderVN;
    return $xeColorPicker;
  },
  render() {
    return this.renderVN();
  }
});
exports.default = VxeColorPickerComponent;
