ep-craft 0.1.34 → 0.1.35

package/dist/components/cascader-panel/node.js

@@ -0,0 +1,75 @@
+import { isEmpty as m, isUndefined as p } from "../../utils/types.js";
+import "lodash-unified";
+import "@vueuse/core";
+import { isFunction as u, isArray as f } from "@vue/shared";
+import "@element-plus/icons-vue";
+import "vue";
+let b = 0;
+const k = (d) => {
+  const t = [d];
+  let { parent: e } = d;
+  for (; e; )
+    t.unshift(e), e = e.parent;
+  return t;
+};
+class o {
+  constructor(t, e, s, i = !1) {
+    this.data = t, this.config = e, this.parent = s, this.root = i, this.uid = b++, this.checked = !1, this.indeterminate = !1, this.loading = !1;
+    const { value: h, label: a, children: n } = e, c = t[n], r = k(this);
+    this.level = i ? 0 : s ? s.level + 1 : 1, this.value = t[h], this.label = t[a], this.pathNodes = r, this.pathValues = r.map((l) => l.value), this.pathLabels = r.map((l) => l.label), this.childrenData = c, this.children = (c || []).map(
+      (l) => new o(l, e, this)
+    ), this.loaded = !e.lazy || this.isLeaf || !m(c), this.text = "";
+  }
+  get isDisabled() {
+    const { data: t, parent: e, config: s } = this, { disabled: i, checkStrictly: h } = s;
+    return (u(i) ? i(t, this) : !!t[i]) || !h && !!(e != null && e.isDisabled);
+  }
+  get isLeaf() {
+    const { data: t, config: e, childrenData: s, loaded: i } = this, { lazy: h, leaf: a } = e, n = u(a) ? a(t, this) : t[a];
+    return p(n) ? h && !i ? !1 : !(f(s) && s.length) : !!n;
+  }
+  get valueByOption() {
+    return this.config.emitPath ? this.pathValues : this.value;
+  }
+  appendChild(t) {
+    const { childrenData: e, children: s } = this, i = new o(t, this.config, this);
+    return f(e) ? e.push(t) : this.childrenData = [t], s.push(i), i;
+  }
+  calcText(t, e) {
+    const s = t ? this.pathLabels.join(e) : this.label;
+    return this.text = s, s;
+  }
+  broadcast(t) {
+    this.children.forEach((e) => {
+      var s;
+      e && (e.broadcast(t), (s = e.onParentCheck) == null || s.call(e, t));
+    });
+  }
+  emit() {
+    var e;
+    const { parent: t } = this;
+    t && ((e = t.onChildCheck) == null || e.call(t), t.emit());
+  }
+  onParentCheck(t) {
+    this.isDisabled || this.setCheckState(t);
+  }
+  onChildCheck() {
+    const { children: t } = this, e = t.filter((i) => !i.isDisabled), s = e.length ? e.every((i) => i.checked) : !1;
+    this.setCheckState(s);
+  }
+  setCheckState(t) {
+    const e = this.children.length, s = this.children.reduce((i, h) => {
+      const a = h.checked ? 1 : h.indeterminate ? 0.5 : 0;
+      return i + a;
+    }, 0);
+    this.checked = this.loaded && this.children.filter((i) => !i.isDisabled).every((i) => i.loaded && i.checked) && t, this.indeterminate = this.loaded && s !== e && s > 0;
+  }
+  doCheck(t) {
+    if (this.checked === t) return;
+    const { checkStrictly: e, multiple: s } = this.config;
+    e || !s ? this.checked = t : (this.broadcast(t), this.setCheckState(t), this.emit());
+  }
+}
+export {
+  o as default
+};

package/dist/components/cascader-panel/store.d.ts

@@ -0,0 +1,17 @@
+import Node from './node';
+import type { Nullable } from '@element-plus/utils';
+import type { CascaderConfig, CascaderNodePathValue, CascaderNodeValue, CascaderOption } from './types';
+export default class Store {
+    readonly config: CascaderConfig;
+    readonly nodes: Node[];
+    readonly allNodes: Node[];
+    readonly leafNodes: Node[];
+    constructor(data: CascaderOption[], config: CascaderConfig);
+    getNodes(): Node[];
+    getFlattedNodes(leafOnly: boolean): Node[];
+    appendNode(nodeData: CascaderOption, parentNode?: Node): void;
+    appendNodes(nodeDataList: CascaderOption[], parentNode: Node): void;
+    appendAllNodesAndLeafNodes(node: Node): void;
+    getNodeByValue(value: CascaderNodeValue | CascaderNodePathValue, leafOnly?: boolean): Nullable<Node>;
+    getSameNode(node: Node): Nullable<Node>;
+}

package/dist/components/cascader-panel/store.js

@@ -0,0 +1,49 @@
+import { isEqual as l } from "lodash-unified";
+import { isPropAbsent as n } from "../../utils/types.js";
+import "@vueuse/core";
+import "@vue/shared";
+import "@element-plus/icons-vue";
+import "vue";
+import h from "./node.js";
+const o = (d, e) => d.reduce((s, t) => (t.isLeaf ? s.push(t) : (!e && s.push(t), s = s.concat(o(t.children, e))), s), []);
+class m {
+  constructor(e, s) {
+    this.config = s;
+    const t = (e || []).map(
+      (i) => new h(i, this.config)
+    );
+    this.nodes = t, this.allNodes = o(t, !1), this.leafNodes = o(t, !0);
+  }
+  getNodes() {
+    return this.nodes;
+  }
+  getFlattedNodes(e) {
+    return e ? this.leafNodes : this.allNodes;
+  }
+  appendNode(e, s) {
+    const t = s ? s.appendChild(e) : new h(e, this.config);
+    s || this.nodes.push(t), this.appendAllNodesAndLeafNodes(t);
+  }
+  appendNodes(e, s) {
+    e.length > 0 ? e.forEach((t) => this.appendNode(t, s)) : s && s.isLeaf && this.leafNodes.push(s);
+  }
+  appendAllNodesAndLeafNodes(e) {
+    this.allNodes.push(e), e.isLeaf && this.leafNodes.push(e), e.children && e.children.forEach((s) => {
+      this.appendAllNodesAndLeafNodes(s);
+    });
+  }
+  // when checkStrictly, leaf node first
+  getNodeByValue(e, s = !1) {
+    return n(e) ? null : this.getFlattedNodes(s).find(
+      (i) => l(i.value, e) || l(i.pathValues, e)
+    ) || null;
+  }
+  getSameNode(e) {
+    return e && this.getFlattedNodes(!1).find(
+      ({ value: t, level: i }) => l(e.value, t) && e.level === i
+    ) || null;
+  }
+}
+export {
+  m as default
+};

package/dist/components/cascader-panel/types.d.ts

@@ -0,0 +1,64 @@
+import type { InjectionKey, VNode } from 'vue';
+import type { Nullable } from '@element-plus/utils';
+import type { default as CascaderNode } from './node';
+export type { CascaderNode, Nullable };
+export type CascaderNodeValue = string | number | Record<string, any>;
+export type CascaderNodePathValue = CascaderNodeValue[];
+export type CascaderValue = CascaderNodeValue | CascaderNodePathValue | (CascaderNodeValue | CascaderNodePathValue)[];
+export type CascaderConfig = Required<CascaderProps>;
+export type ExpandTrigger = 'click' | 'hover';
+export type isDisabled = (data: CascaderOption, node: CascaderNode) => boolean;
+export type isLeaf = (data: CascaderOption, node: CascaderNode) => boolean;
+export type Resolve = (dataList?: CascaderOption[]) => void;
+export type LazyLoad = (node: CascaderNode, resolve: Resolve, reject: () => void) => void;
+export interface RenderLabelProps {
+    node: CascaderNode;
+    data: CascaderOption;
+}
+export type RenderLabel = (props: RenderLabelProps) => VNode | VNode[];
+export interface CascaderOption extends Record<string, unknown> {
+    label?: string;
+    value?: CascaderNodeValue;
+    children?: CascaderOption[];
+    disabled?: boolean;
+    leaf?: boolean;
+}
+export interface CascaderProps {
+    expandTrigger?: ExpandTrigger;
+    multiple?: boolean;
+    checkStrictly?: boolean;
+    emitPath?: boolean;
+    lazy?: boolean;
+    lazyLoad?: LazyLoad;
+    value?: string;
+    label?: string;
+    children?: string;
+    disabled?: string | isDisabled;
+    leaf?: string | isLeaf;
+    hoverThreshold?: number;
+    checkOnClickNode?: boolean;
+    checkOnClickLeaf?: boolean;
+    showPrefix?: boolean;
+}
+export interface Tag {
+    node?: CascaderNode;
+    key: number;
+    text: string;
+    hitState?: boolean;
+    closable: boolean;
+}
+export interface ElCascaderPanelContext {
+    config: CascaderConfig;
+    expandingNode: CascaderNode | undefined;
+    checkedNodes: CascaderNode[];
+    isHoverMenu: boolean;
+    initialLoaded: boolean;
+    renderLabelFn?: RenderLabel;
+    virtualScroll: boolean;
+    itemSize: number;
+    height: number;
+    lazyLoad: (node?: CascaderNode, cb?: (dataList: CascaderOption[]) => void) => void;
+    expandNode: (node: CascaderNode, silent?: boolean) => void;
+    handleCheckChange: (node: CascaderNode, checked: boolean, emitClose?: boolean) => void;
+}
+export declare const CASCADER_PANEL_INJECTION_KEY: InjectionKey<ElCascaderPanelContext>;

package/dist/components/cascader-panel/types.js

@@ -0,0 +1,4 @@
+const E = Symbol();
+export {
+  E as CASCADER_PANEL_INJECTION_KEY
+};

package/dist/components/cascader-panel/utils.d.ts

@@ -0,0 +1,4 @@
+import type { CascaderNode } from './types';
+export declare const getMenuIndex: (el: HTMLElement) => number;
+export declare const checkNode: (el: HTMLElement) => void;
+export declare const sortByOriginalOrder: (oldNodes: CascaderNode[], newNodes: CascaderNode[]) => CascaderNode[];

package/dist/components/cascader-panel/utils.js

@@ -0,0 +1,26 @@
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import { isLeaf as p } from "../../utils/dom/aria.js";
+import "@element-plus/icons-vue";
+import "vue";
+const x = (e) => {
+  if (!e) return 0;
+  const i = e.id.split("-");
+  return Number(i[i.length - 2]);
+}, g = (e) => {
+  if (!e) return;
+  const i = e.querySelector("input");
+  i ? i.click() : p(e) && e.click();
+}, k = (e, i) => {
+  const t = i.slice(0), o = t.map((r) => r.uid), s = e.reduce((r, c) => {
+    const n = o.indexOf(c.uid);
+    return n > -1 && (r.push(c), t.splice(n, 1), o.splice(n, 1)), r;
+  }, []);
+  return s.push(...t), s;
+};
+export {
+  g as checkNode,
+  x as getMenuIndex,
+  k as sortByOriginalOrder
+};

package/dist/components/checkbox/EpCheckbox.vue.d.ts

@@ -131,8 +131,8 @@ declare const __VLS_component: import("vue").DefineComponent<import("vue").Extra
     id: string;
     modelValue: string | number | boolean;
     validateEvent: boolean;
-    checked: boolean;
     indeterminate: boolean;
+    checked: boolean;
     trueValue: string | number;
     falseValue: string | number;
     trueLabel: string | number;

package/dist/components/checkbox-button/EpCheckboxButton.vue.d.ts

@@ -131,8 +131,8 @@ declare const __VLS_component: import("vue").DefineComponent<import("vue").Extra
     id: string;
     modelValue: string | number | boolean;
     validateEvent: boolean;
-    checked: boolean;
     indeterminate: boolean;
+    checked: boolean;
     trueValue: string | number;
     falseValue: string | number;
     trueLabel: string | number;

package/dist/components/checkbox-group/index.js

@@ -1,12 +1,13 @@
 import { withInstall as o } from "../../utils/with-install.js";
 import r from "./EpCheckboxGroup.vue.js";
-import { checkboxGroupEmits as x, checkboxGroupProps as h } from "./src/checkbox-group.js";
+import { checkboxGroupEmits as s, checkboxGroupProps as x } from "./src/checkbox-group.js";
 const t = o(
   r,
   "ep-checkbox-group"
 );
 export {
   t as EpCheckboxGroup,
-  x as checkboxGroupEmits,
-  h as checkboxGroupProps
+  s as checkboxGroupEmits,
+  x as checkboxGroupProps,
+  t as default
 };

package/dist/components/collapse-transition/index.js

@@ -6,8 +6,9 @@ import "@element-plus/icons-vue";
 import "vue";
 import { withInstall as i } from "../../utils/vue/install.js";
 import t from "./src/collapse-transition.vue.js";
-const c = i(t), f = o(t, "ep-collapse-transition");
+const f = i(t), c = o(t, "ep-collapse-transition");
 export {
-  c as ElCollapseTransition,
-  f as EpCollapseTransition
+  f as ElCollapseTransition,
+  c as EpCollapseTransition,
+  c as default
 };

package/dist/components/color-picker/EpColorPicker.vue.d.ts

@@ -0,0 +1,53 @@
+import Color from '@element-plus/components/color-picker-panel/utils/color';
+import type { ColorPickerProps } from './color-picker';
+declare function show(): void;
+declare function hide(): void;
+declare function focus(): void;
+declare function blur(): void;
+declare const _default: import("vue").DefineComponent<ColorPickerProps, {
+    /**
+     * @description current color object
+     */
+    color: Color;
+    /**
+     * @description manually show ColorPicker
+     */
+    show: typeof show;
+    /**
+     * @description manually hide ColorPicker
+     */
+    hide: typeof hide;
+    /**
+     * @description focus the input element
+     */
+    focus: typeof focus;
+    /**
+     * @description blur the input element
+     */
+    blur: typeof blur;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    clear: () => void;
+    "update:modelValue": (val: string | null) => void;
+    change: (val: string | null) => void;
+    focus: (evt: FocusEvent) => void;
+    blur: (evt: FocusEvent) => void;
+    activeChange: (val: string | null) => void;
+}, string, import("vue").PublicProps, Readonly<ColorPickerProps> & Readonly<{
+    onClear?: (() => any) | undefined;
+    "onUpdate:modelValue"?: ((val: string | null) => any) | undefined;
+    onChange?: ((val: string | null) => any) | undefined;
+    onFocus?: ((evt: FocusEvent) => any) | undefined;
+    onBlur?: ((evt: FocusEvent) => any) | undefined;
+    onActiveChange?: ((val: string | null) => any) | undefined;
+}>, {
+    disabled: boolean;
+    tabindex: string | number;
+    teleported: boolean;
+    modelValue: string | null;
+    valueOnClear: string | number | boolean | Function | null;
+    popperStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+    persistent: boolean;
+    validateEvent: boolean;
+    clearable: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/color-picker/EpColorPicker.vue.js

@@ -0,0 +1,318 @@
+import { defineComponent as ge, ref as g, computed as k, nextTick as O, watch as B, provide as ye, openBlock as D, createBlock as F, unref as o, withCtx as d, createElementVNode as y, mergeProps as U, normalizeClass as f, normalizeStyle as Ee, withDirectives as T, createVNode as E, vShow as Y, withKeys as we, createTextVNode as q, toDisplayString as Q, createCommentVNode as Ve, mergeDefaults as Pe } from "vue";
+import { pick as Oe, debounce as Be } from "lodash-unified";
+import { ElIcon as W } from "../icon/index.js";
+import { reactiveComputed as Se } from "@vueuse/core";
+import Ne from "../../directives/click-outside/index.js";
+import { NOOP as A } from "@vue/shared";
+import { getEventCode as De } from "../../utils/dom/event.js";
+import { ArrowDown as Fe, Close as Te } from "@element-plus/icons-vue";
+import { EVENT_CODE as S } from "../../constants/aria.js";
+import { UPDATE_MODEL_EVENT as X, CHANGE_EVENT as Z } from "../../constants/event.js";
+import "normalize-wheel-es";
+import { ElTooltip as Ae } from "../tooltip/index.js";
+import { EpButton as _ } from "../button/index.js";
+import "../form/index.js";
+import { useNamespace as xe } from "../../hooks/use-namespace/index.js";
+import { useLocale as $e } from "../../hooks/use-locale/index.js";
+import "../../hooks/use-size/index.js";
+import "@popperjs/core";
+import "../../hooks/use-z-index/index.js";
+import "../../hooks/use-delayed-toggle/index.js";
+import "../../hooks/use-aria/index.js";
+import "../../hooks/use-model-toggle/index.js";
+import { useEmptyValues as Le } from "../../hooks/use-empty-values/index.js";
+import { useFocusController as ze } from "../../hooks/use-focus-controller/index.js";
+import { colorPickerEmits as Re, colorPickerPropsDefaults as Ke } from "./color-picker.js";
+import Ie from "../color-picker-panel/EpColorPickerPanel.vue.js";
+import { colorPickerPanelProps as Me, ROOT_COMMON_COLOR_INJECTION_KEY as je } from "../color-picker-panel/color-picker-panel.js";
+import He from "../color-picker-panel/utils/color.js";
+import { useCommonColor as Ge } from "../color-picker-panel/composables/use-common-color.js";
+import { useFormItem as Je, useFormItemInputId as Ue } from "../form/src/hooks/use-form-item.js";
+import { useFormSize as Ye, useFormDisabled as qe } from "../form/src/hooks/use-form-common-props.js";
+const Qe = ["id", "aria-label", "aria-labelledby", "aria-description", "aria-disabled", "tabindex"], So = /* @__PURE__ */ ge({
+  name: "EpColorPicker",
+  __name: "EpColorPicker",
+  props: /* @__PURE__ */ Pe({
+    persistent: { type: Boolean },
+    modelValue: {},
+    id: {},
+    showAlpha: { type: Boolean },
+    colorFormat: {},
+    disabled: { type: Boolean },
+    clearable: { type: Boolean },
+    size: {},
+    popperClass: {},
+    popperStyle: { type: [Boolean, null, String, Object, Array] },
+    tabindex: {},
+    teleported: { type: Boolean },
+    appendTo: {},
+    predefine: {},
+    validateEvent: { type: Boolean },
+    emptyValues: {},
+    valueOnClear: { type: [String, Number, Boolean, Function, null] },
+    ariaLabel: {}
+  }, Ke),
+  emits: Re,
+  setup(i, { expose: ee, emit: oe }) {
+    const l = i, c = oe, { t: w } = $e(), t = xe("color"), { formItem: r } = Je(), le = Ye(), m = qe(), { valueOnClear: V, isEmptyValue: ae } = Le(l, null), x = Ge(l, c), { inputId: te, isLabeledByFormItem: $ } = Ue(l, {
+      formItemContext: r
+    }), L = g(), h = g(), u = g(), v = g(!1), s = g(!1);
+    let N = !0;
+    const { isFocused: z, handleFocus: R, handleBlur: K } = ze(h, {
+      disabled: m,
+      beforeBlur(e) {
+        var a;
+        return (a = L.value) == null ? void 0 : a.isFocusInsideContent(e);
+      },
+      afterBlur() {
+        var e;
+        C(!1), b(), l.validateEvent && ((e = r == null ? void 0 : r.validate) == null || e.call(r, "blur").catch(A));
+      }
+    }), n = Se(
+      () => {
+        var e;
+        return ((e = u.value) == null ? void 0 : e.color) ?? x.color;
+      }
+    ), re = k(
+      () => Oe(l, Object.keys(Me))
+    ), ie = k(() => !l.modelValue && !s.value ? "transparent" : pe(n, l.showAlpha)), ne = k(() => !l.modelValue && !s.value ? "" : n.value), se = k(() => $.value ? void 0 : l.ariaLabel || w("el.colorpicker.defaultLabel")), ce = k(() => $.value ? r == null ? void 0 : r.labelId : void 0), ue = k(() => [
+      t.b("picker"),
+      t.is("disabled", m.value),
+      t.bm("picker", le.value),
+      t.is("focused", z.value)
+    ]);
+    function pe(e, a) {
+      const { r: p, g: G, b: J, a: Ce } = e.toRgb();
+      return a ? `rgba(${p}, ${G}, ${J}, ${Ce})` : `rgb(${p}, ${G}, ${J})`;
+    }
+    function C(e) {
+      v.value = e;
+    }
+    const P = Be(C, 100, { leading: !0 });
+    function I() {
+      m.value || C(!0);
+    }
+    function M() {
+      P(!1), b();
+    }
+    function b() {
+      O(() => {
+        l.modelValue ? n.fromString(l.modelValue) : (n.value = "", O(() => {
+          s.value = !1;
+        }));
+      });
+    }
+    function de() {
+      m.value || (v.value && b(), P(!v.value));
+    }
+    function fe() {
+      const e = ae(n.value) ? V.value : n.value;
+      c(X, e), c(Z, e), l.validateEvent && (r == null || r.validate("change").catch(A)), P(!1), O(() => {
+        const a = new He({
+          enableAlpha: l.showAlpha,
+          format: l.colorFormat || "",
+          value: l.modelValue
+        });
+        n.compare(a) || b();
+      });
+    }
+    function me() {
+      P(!1), c(X, V.value), c(Z, V.value), l.modelValue !== V.value && l.validateEvent && (r == null || r.validate("change").catch(A)), b(), c("clear");
+    }
+    function ve() {
+      var e, a;
+      (a = (e = u == null ? void 0 : u.value) == null ? void 0 : e.inputRef) == null || a.focus();
+    }
+    function be() {
+      v.value && (M(), z.value && H());
+    }
+    function j(e) {
+      e.preventDefault(), e.stopPropagation(), C(!1), b();
+    }
+    function ke(e) {
+      switch (De(e)) {
+        case S.enter:
+        case S.numpadEnter:
+        case S.space:
+          e.preventDefault(), e.stopPropagation(), I();
+          break;
+        case S.esc:
+          j(e);
+          break;
+      }
+    }
+    function H() {
+      h.value.focus();
+    }
+    function he() {
+      h.value.blur();
+    }
+    return B(
+      () => ne.value,
+      (e) => {
+        N && c("activeChange", e), N = !0;
+      }
+    ), B(
+      () => n.value,
+      () => {
+        !l.modelValue && !s.value && (s.value = !0);
+      }
+    ), B(
+      () => l.modelValue,
+      (e) => {
+        e ? e && e !== n.value && (N = !1, n.fromString(e)) : s.value = !1;
+      }
+    ), B(
+      () => v.value,
+      () => {
+        u.value && O(u.value.update);
+      }
+    ), ye(je, x), ee({
+      /**
+       * @description current color object
+       */
+      color: n,
+      /**
+       * @description manually show ColorPicker
+       */
+      show: I,
+      /**
+       * @description manually hide ColorPicker
+       */
+      hide: M,
+      /**
+       * @description focus the input element
+       */
+      focus: H,
+      /**
+       * @description blur the input element
+       */
+      blur: he
+    }), (e, a) => (D(), F(o(Ae), {
+      ref_key: "popper",
+      ref: L,
+      visible: v.value,
+      "show-arrow": !1,
+      "fallback-placements": ["bottom", "top", "right", "left"],
+      offset: 0,
+      "gpu-acceleration": !1,
+      "popper-class": [o(t).be("picker", "panel"), i.popperClass],
+      "popper-style": i.popperStyle,
+      "stop-popper-mouse-event": !1,
+      pure: "",
+      loop: "",
+      role: "dialog",
+      effect: "light",
+      trigger: "click",
+      teleported: i.teleported,
+      transition: `${o(t).namespace.value}-zoom-in-top`,
+      persistent: i.persistent,
+      "append-to": i.appendTo,
+      onShow: ve,
+      onHide: a[2] || (a[2] = (p) => C(!1))
+    }, {
+      content: d(() => [
+        T((D(), F(o(Ie), U({
+          ref_key: "pickerPanelRef",
+          ref: u
+        }, re.value, {
+          border: !1,
+          "validate-event": !1,
+          onKeydown: we(j, ["esc"])
+        }), {
+          footer: d(() => [
+            y("div", null, [
+              i.clearable ? (D(), F(o(_), {
+                key: 0,
+                class: f(o(t).be("footer", "link-btn")),
+                text: "",
+                size: "small",
+                onClick: me
+              }, {
+                default: d(() => [
+                  q(Q(o(w)("el.colorpicker.clear")), 1)
+                ]),
+                _: 1
+              }, 8, ["class"])) : Ve("", !0),
+              E(o(_), {
+                plain: "",
+                size: "small",
+                class: f(o(t).be("footer", "btn")),
+                onClick: fe
+              }, {
+                default: d(() => [
+                  q(Q(o(w)("el.colorpicker.confirm")), 1)
+                ]),
+                _: 1
+              }, 8, ["class"])
+            ])
+          ]),
+          _: 1
+        }, 16)), [
+          [o(Ne), be, h.value]
+        ])
+      ]),
+      default: d(() => [
+        y("div", U({
+          id: o(te),
+          ref_key: "triggerRef",
+          ref: h
+        }, e.$attrs, {
+          class: ue.value,
+          role: "button",
+          "aria-label": se.value,
+          "aria-labelledby": ce.value,
+          "aria-description": o(w)("el.colorpicker.description", { color: i.modelValue || "" }),
+          "aria-disabled": o(m),
+          tabindex: o(m) ? void 0 : i.tabindex,
+          onKeydown: ke,
+          onFocus: a[0] || (a[0] = //@ts-ignore
+          (...p) => o(R) && o(R)(...p)),
+          onBlur: a[1] || (a[1] = //@ts-ignore
+          (...p) => o(K) && o(K)(...p))
+        }), [
+          y("div", {
+            class: f(o(t).be("picker", "trigger")),
+            onClick: de
+          }, [
+            y("span", {
+              class: f([o(t).be("picker", "color"), o(t).is("alpha", i.showAlpha)])
+            }, [
+              y("span", {
+                class: f(o(t).be("picker", "color-inner")),
+                style: Ee({
+                  backgroundColor: ie.value
+                })
+              }, [
+                T(E(o(W), {
+                  class: f([o(t).be("picker", "icon"), o(t).is("icon-arrow-down")])
+                }, {
+                  default: d(() => [
+                    E(o(Fe))
+                  ]),
+                  _: 1
+                }, 8, ["class"]), [
+                  [Y, i.modelValue || s.value]
+                ]),
+                T(E(o(W), {
+                  class: f([o(t).be("picker", "empty"), o(t).is("icon-close")])
+                }, {
+                  default: d(() => [
+                    E(o(Te))
+                  ]),
+                  _: 1
+                }, 8, ["class"]), [
+                  [Y, !i.modelValue && !s.value]
+                ])
+              ], 6)
+            ], 2)
+          ], 2)
+        ], 16, Qe)
+      ]),
+      _: 1
+    }, 8, ["visible", "popper-class", "popper-style", "teleported", "transition", "persistent", "append-to"]));
+  }
+});
+export {
+  So as default
+};

package/dist/components/color-picker/EpColorPicker2.vue.js

@@ -0,0 +1,4 @@
+import f from "./EpColorPicker.vue.js";
+export {
+  f as default
+};