ep-craft 0.1.34 → 0.1.36

package/dist/components/collapse/collapse.d.ts

@@ -0,0 +1,47 @@
+import type { ExtractPublicPropTypes } from 'vue';
+import type { Arrayable, Awaitable } from '@element-plus/utils';
+export type CollapseActiveName = string | number;
+export type CollapseModelValue = Arrayable<CollapseActiveName>;
+export type CollapseIconPositionType = 'left' | 'right';
+export declare const emitChangeFn: (value: CollapseModelValue) => value is string | number | CollapseActiveName[];
+export interface CollapseProps {
+    /**
+     * @description whether to activate accordion mode
+     */
+    accordion?: boolean;
+    /**
+     * @description currently active panel, the type is `string` in accordion mode, otherwise it is `array`
+     */
+    modelValue?: CollapseModelValue;
+    /**
+     * @description set expand icon position
+     */
+    expandIconPosition?: CollapseIconPositionType;
+    /**
+     * @description before-collapse hook before the collapse state changes. If `false` is returned or a `Promise` is returned and then is rejected, will stop collapsing
+     */
+    beforeCollapse?: (name: CollapseActiveName) => Awaitable<boolean>;
+}
+/**
+ * @deprecated Removed after 3.0.0, Use `CollapseProps` instead.
+ */
+export declare const collapseProps: {
+    readonly accordion: BooleanConstructor;
+    readonly modelValue: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => string | number | CollapseActiveName[]) | (() => CollapseModelValue) | (((new (...args: any[]) => string | number | CollapseActiveName[]) | (() => CollapseModelValue)) | null)[], unknown, unknown, () => [], boolean>;
+    readonly expandIconPosition: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => "left" | "right") | (() => CollapseIconPositionType) | (((new (...args: any[]) => "left" | "right") | (() => CollapseIconPositionType)) | null)[], unknown, unknown, "right", boolean>;
+    readonly beforeCollapse: {
+        readonly type: import("vue").PropType<(name: CollapseActiveName) => Awaitable<boolean>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+};
+/**
+ * @deprecated Removed after 3.0.0, Use `CollapseProps` instead.
+ */
+export type CollapsePropsPublic = ExtractPublicPropTypes<typeof collapseProps>;
+export declare const collapseEmits: {
+    "update:modelValue": (value: CollapseModelValue) => value is string | number | CollapseActiveName[];
+    change: (value: CollapseModelValue) => value is string | number | CollapseActiveName[];
+};
+export type CollapseEmits = typeof collapseEmits;

package/dist/components/collapse/collapse.js

@@ -0,0 +1,46 @@
+import { isNumber as i } from "../../utils/types.js";
+import "lodash-unified";
+import "@vueuse/core";
+import { isString as e, isArray as m } from "@vue/shared";
+import { mutable as p } from "../../utils/typescript.js";
+import { CHANGE_EVENT as n, UPDATE_MODEL_EVENT as a } from "../../constants/event.js";
+import "@element-plus/icons-vue";
+import { buildProps as s, definePropType as r } from "../../utils/vue/props/runtime.js";
+import "vue";
+const t = (o) => i(o) || e(o) || m(o);
+s({
+  /**
+   * @description whether to activate accordion mode
+   */
+  accordion: Boolean,
+  /**
+   * @description currently active panel, the type is `string` in accordion mode, otherwise it is `array`
+   */
+  modelValue: {
+    type: r([Array, String, Number]),
+    default: () => p([])
+  },
+  /**
+   * @description set expand icon position
+   */
+  expandIconPosition: {
+    type: r([String]),
+    default: "right"
+  },
+  /**
+   * @description before-collapse hook before the collapse state changes. If `false` is returned or a `Promise` is returned and then is rejected, will stop collapsing
+   */
+  beforeCollapse: {
+    type: r(
+      Function
+    )
+  }
+});
+const N = {
+  [a]: t,
+  [n]: t
+};
+export {
+  N as collapseEmits,
+  t as emitChangeFn
+};

package/dist/components/collapse/constants.d.ts

@@ -0,0 +1,7 @@
+import type { InjectionKey, Ref } from 'vue';
+import type { CollapseActiveName } from './collapse';
+export interface CollapseContext {
+    activeNames: Ref<CollapseActiveName[]>;
+    handleItemClick: (name: CollapseActiveName) => void;
+}
+export declare const collapseContextKey: InjectionKey<CollapseContext>;

package/dist/components/collapse/constants.js

@@ -0,0 +1,4 @@
+const e = Symbol("collapseContextKey");
+export {
+  e as collapseContextKey
+};

package/dist/components/collapse/index.d.ts

@@ -1,4 +1,23 @@
 import type { Plugin } from 'vue';
-import { ElCollapse } from 'element-plus';
-export declare const EpCollapse: typeof ElCollapse & Plugin;
+import _EpCollapse from './EpCollapse.vue';
+import _EpCollapseItem from '../collapse-item/EpCollapseItem.vue';
+/**
+ * collapse 自持 barrel（vendor-batch-4 产出）。
+ *
+ * `.CollapseItem` 是对外公开面的一部分（迁移前包装态经 `Object.assign`
+ * 继承自上游），此处挂载**未安装本体**，与上游形态一致。
+ * 上下文键 `collapseContextKey` 由本入口导出，子项从 ./constants 读取同一 Symbol。
+ * 不导出 `ElCollapse` / `ElCollapseItem` 别名。
+ */
+export declare const EpCollapse: typeof _EpCollapse & Plugin & {
+    CollapseItem: typeof _EpCollapseItem;
+};
 export default EpCollapse;
+export { collapseContextKey } from './constants';
+export { collapseEmits, collapseProps, emitChangeFn, } from './collapse';
+export { collapseItemProps } from '../collapse-item';
+export type { CollapseContext } from './constants';
+export type { CollapseActiveName, CollapseEmits, CollapseIconPositionType, CollapseModelValue, CollapseProps, CollapsePropsPublic, } from './collapse';
+export type { CollapseInstance } from './instance';
+export type { CollapseItemProps, CollapseItemPropsPublic, } from '../collapse-item';
+export type { CollapseItemInstance } from '../collapse-item/instance';

package/dist/components/collapse/index.js

@@ -1,6 +1,14 @@
-import { ElCollapse as l } from "element-plus";
 import { withInstall as o } from "../../utils/with-install.js";
-const p = Object.assign({}, l, { name: "EpCollapse" }), a = o(p, "ep-collapse");
+import m from "./EpCollapse.vue.js";
+import t from "../collapse-item/EpCollapseItem.vue.js";
+import { collapseEmits as n, emitChangeFn as c } from "./collapse.js";
+import "../collapse-item/index.js";
+const l = Object.assign(
+  o(m, "ep-collapse"),
+  { CollapseItem: t }
+);
 export {
-  a as EpCollapse
+  l as EpCollapse,
+  n as collapseEmits,
+  c as emitChangeFn
 };

package/dist/components/collapse/instance.d.ts

@@ -0,0 +1,2 @@
+import type EpCollapse from './EpCollapse.vue';
+export type CollapseInstance = InstanceType<typeof EpCollapse> & unknown;

package/dist/components/collapse/use-collapse-item.d.ts

@@ -0,0 +1,21 @@
+import type { CollapseItemProps } from '../collapse-item/collapse-item';
+export declare const useCollapseItem: (props: CollapseItemProps) => {
+    focusing: import("vue").Ref<boolean, boolean>;
+    id: import("vue").ComputedRef<number>;
+    isActive: import("vue").ComputedRef<boolean | undefined>;
+    handleFocus: () => void;
+    handleHeaderClick: (e: MouseEvent) => void;
+    handleEnterClick: (e: KeyboardEvent) => void;
+};
+export declare const useCollapseItemDOM: (props: CollapseItemProps, { focusing, isActive, id }: Partial<ReturnType<typeof useCollapseItem>>) => {
+    itemTitleKls: import("vue").ComputedRef<string[]>;
+    arrowKls: import("vue").ComputedRef<string[]>;
+    headKls: import("vue").ComputedRef<(string | {
+        focusing: boolean | undefined;
+    })[]>;
+    rootKls: import("vue").ComputedRef<string[]>;
+    itemWrapperKls: import("vue").ComputedRef<string>;
+    itemContentKls: import("vue").ComputedRef<string>;
+    scopedContentId: import("vue").ComputedRef<string>;
+    scopedHeadId: import("vue").ComputedRef<string>;
+};

package/dist/components/collapse/use-collapse-item.js

@@ -0,0 +1,66 @@
+import { inject as v, ref as C, computed as n, unref as o } from "vue";
+import { useNamespace as h } from "../../hooks/use-namespace/index.js";
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import "@element-plus/icons-vue";
+import { useIdInjection as I } from "../../hooks/use-id/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 "../../hooks/use-empty-values/index.js";
+import { collapseContextKey as k } from "./constants.js";
+const W = (c) => {
+  const t = v(k), { namespace: a } = h("collapse"), i = C(!1), e = C(!1), m = I(), d = n(() => m.current++), l = n(() => c.name ?? `${a.value}-id-${m.prefix}-${o(d)}`), u = n(
+    () => t == null ? void 0 : t.activeNames.value.includes(o(l))
+  );
+  return {
+    focusing: i,
+    id: d,
+    isActive: u,
+    handleFocus: () => {
+      setTimeout(() => {
+        e.value ? e.value = !1 : i.value = !0;
+      }, 50);
+    },
+    handleHeaderClick: (r) => {
+      if (c.disabled) return;
+      const s = r.target;
+      s != null && s.closest("input, textarea, select") || (t == null || t.handleItemClick(o(l)), i.value = !1, e.value = !0);
+    },
+    handleEnterClick: (r) => {
+      const s = r.target;
+      s != null && s.closest("input, textarea, select") || (r.preventDefault(), t == null || t.handleItemClick(o(l)));
+    }
+  };
+}, q = (c, { focusing: t, isActive: a, id: i }) => {
+  const e = h("collapse"), m = n(() => [
+    e.b("item"),
+    e.is("active", o(a)),
+    e.is("disabled", c.disabled)
+  ]), d = n(() => [
+    e.be("item", "header"),
+    e.is("active", o(a)),
+    { focusing: o(t) && !c.disabled }
+  ]), l = n(() => [
+    e.be("item", "arrow"),
+    e.is("active", o(a))
+  ]), u = n(() => [e.be("item", "title")]), p = n(() => e.be("item", "wrap")), f = n(() => e.be("item", "content")), b = n(() => e.b(`content-${o(i)}`)), r = n(() => e.b(`head-${o(i)}`));
+  return {
+    itemTitleKls: u,
+    arrowKls: l,
+    headKls: d,
+    rootKls: m,
+    itemWrapperKls: p,
+    itemContentKls: f,
+    scopedContentId: b,
+    scopedHeadId: r
+  };
+};
+export {
+  W as useCollapseItem,
+  q as useCollapseItemDOM
+};

package/dist/components/collapse/use-collapse.d.ts

@@ -0,0 +1,9 @@
+import type { SetupContext } from 'vue';
+import type { CollapseActiveName, CollapseEmits, CollapseProps } from './collapse';
+export declare const useCollapse: (props: CollapseProps, emit: SetupContext<CollapseEmits>["emit"]) => {
+    activeNames: import("vue").Ref<(string | number)[], (string | number)[]>;
+    setActiveNames: (_activeNames: CollapseActiveName[]) => void;
+};
+export declare const useCollapseDOM: (props: CollapseProps) => {
+    rootKls: import("vue").ComputedRef<string[]>;
+};

package/dist/components/collapse/use-collapse.js

@@ -0,0 +1,72 @@
+import { ref as f, watch as d, provide as v, computed as C } from "vue";
+import { isBoolean as h } from "../../utils/types.js";
+import { castArray as n } from "lodash-unified";
+import "@vueuse/core";
+import { throwError as E, debugWarn as b } from "../../utils/error.js";
+import { isPromise as m } from "@vue/shared";
+import { UPDATE_MODEL_EVENT as N, CHANGE_EVENT as P } from "../../constants/event.js";
+import "@element-plus/icons-vue";
+import { useNamespace as O } from "../../hooks/use-namespace/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 "../../hooks/use-empty-values/index.js";
+import { collapseContextKey as x } from "./constants.js";
+const u = "ElCollapse", U = (t, i) => {
+  const r = f(n(t.modelValue)), l = (o) => {
+    r.value = o;
+    const e = t.accordion ? r.value[0] : r.value;
+    i(N, e), i(P, e);
+  }, c = (o) => {
+    if (t.accordion)
+      l([r.value[0] === o ? "" : o]);
+    else {
+      const e = [...r.value], s = e.indexOf(o);
+      s > -1 ? e.splice(s, 1) : e.push(o), l(e);
+    }
+  }, p = async (o) => {
+    const { beforeCollapse: e } = t;
+    if (!e) {
+      c(o);
+      return;
+    }
+    const s = e(o);
+    [
+      m(s),
+      h(s)
+    ].includes(!0) || E(
+      u,
+      "beforeCollapse must return type `Promise<boolean>` or `boolean`"
+    ), m(s) ? s.then((a) => {
+      a !== !1 && c(o);
+    }).catch((a) => {
+      b(u, `some error occurred: ${a}`);
+    }) : s && c(o);
+  };
+  return d(
+    () => t.modelValue,
+    () => r.value = n(t.modelValue),
+    { deep: !0 }
+  ), v(x, {
+    activeNames: r,
+    handleItemClick: p
+  }), {
+    activeNames: r,
+    setActiveNames: l
+  };
+}, W = (t) => {
+  const i = O("collapse");
+  return {
+    rootKls: C(() => [
+      i.b(),
+      i.b(`icon-position-${t.expandIconPosition}`)
+    ])
+  };
+};
+export {
+  U as useCollapse,
+  W as useCollapseDOM
+};

package/dist/components/collapse-item/EpCollapseItem.vue.d.ts

@@ -0,0 +1,27 @@
+import type { CollapseItemProps } from './collapse-item';
+declare var __VLS_1: {
+    isActive: boolean | undefined;
+}, __VLS_3: {
+    isActive: boolean | undefined;
+}, __VLS_17: {};
+type __VLS_Slots = {} & {
+    title?: (props: typeof __VLS_1) => any;
+} & {
+    icon?: (props: typeof __VLS_3) => any;
+} & {
+    default?: (props: typeof __VLS_17) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<CollapseItemProps, {
+    /** @description current collapse-item whether active */
+    isActive: import("vue").ComputedRef<boolean | undefined>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<CollapseItemProps> & Readonly<{}>, {
+    icon: import("../../utils").IconPropType;
+    title: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/collapse-item/EpCollapseItem.vue.js

@@ -0,0 +1,102 @@
+import { defineComponent as g, openBlock as C, createElementBlock as A, normalizeClass as o, unref as e, createElementVNode as s, withKeys as D, withModifiers as $, renderSlot as r, createTextVNode as N, toDisplayString as S, createVNode as v, withCtx as w, createBlock as T, resolveDynamicComponent as V, withDirectives as F, vShow as H, markRaw as M } from "vue";
+import { EpCollapseTransition as R } from "../collapse-transition/index.js";
+import { EpIcon as z } from "../icon/index.js";
+import { ArrowRight as O } from "@element-plus/icons-vue";
+import { useCollapseItem as W, useCollapseItemDOM as j } from "../collapse/use-collapse-item.js";
+const q = ["id", "aria-expanded", "aria-controls", "aria-describedby", "tabindex", "aria-disabled"], G = ["id", "aria-hidden", "aria-labelledby"], X = /* @__PURE__ */ g({
+  name: "EpCollapseItem",
+  __name: "EpCollapseItem",
+  props: {
+    title: { default: "" },
+    name: {},
+    icon: { default: M(O) },
+    disabled: { type: Boolean }
+  },
+  setup(l, { expose: y }) {
+    const c = l, {
+      focusing: m,
+      id: K,
+      isActive: t,
+      handleFocus: p,
+      handleHeaderClick: u,
+      handleEnterClick: f
+    } = W(c), {
+      arrowKls: h,
+      headKls: k,
+      rootKls: E,
+      itemTitleKls: I,
+      itemWrapperKls: x,
+      itemContentKls: B,
+      scopedContentId: d,
+      scopedHeadId: b
+    } = j(c, { focusing: m, isActive: t, id: K });
+    return y({
+      /** @description current collapse-item whether active */
+      isActive: t
+    }), (n, i) => (C(), A("div", {
+      class: o(e(E))
+    }, [
+      s("div", {
+        id: e(b),
+        class: o(e(k)),
+        "aria-expanded": e(t),
+        "aria-controls": e(d),
+        "aria-describedby": e(d),
+        tabindex: l.disabled ? void 0 : 0,
+        "aria-disabled": l.disabled,
+        role: "button",
+        onClick: i[0] || (i[0] = //@ts-ignore
+        (...a) => e(u) && e(u)(...a)),
+        onKeydown: i[1] || (i[1] = D($(
+          //@ts-ignore
+          (...a) => e(f) && e(f)(...a),
+          ["stop"]
+        ), ["space", "enter"])),
+        onFocus: i[2] || (i[2] = //@ts-ignore
+        (...a) => e(p) && e(p)(...a)),
+        onBlur: i[3] || (i[3] = (a) => m.value = !1)
+      }, [
+        s("span", {
+          class: o(e(I))
+        }, [
+          r(n.$slots, "title", { isActive: e(t) }, () => [
+            N(S(l.title), 1)
+          ])
+        ], 2),
+        r(n.$slots, "icon", { isActive: e(t) }, () => [
+          v(e(z), {
+            class: o(e(h))
+          }, {
+            default: w(() => [
+              (C(), T(V(l.icon)))
+            ]),
+            _: 1
+          }, 8, ["class"])
+        ])
+      ], 42, q),
+      v(e(R), null, {
+        default: w(() => [
+          F(s("div", {
+            id: e(d),
+            role: "region",
+            class: o(e(x)),
+            "aria-hidden": !e(t),
+            "aria-labelledby": e(b)
+          }, [
+            s("div", {
+              class: o(e(B))
+            }, [
+              r(n.$slots, "default")
+            ], 2)
+          ], 10, G), [
+            [H, e(t)]
+          ])
+        ]),
+        _: 3
+      })
+    ], 2));
+  }
+});
+export {
+  X as default
+};

package/dist/components/collapse-item/EpCollapseItem2.vue.js

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

package/dist/components/collapse-item/collapse-item.d.ts

@@ -0,0 +1,34 @@
+import type { ExtractPublicPropTypes } from 'vue';
+import type { IconPropType } from '@element-plus/utils';
+import type { CollapseActiveName } from '../collapse/collapse';
+export interface CollapseItemProps {
+    /**
+     * @description title of the panel
+     */
+    title?: string;
+    /**
+     * @description unique identification of the panel
+     */
+    name?: CollapseActiveName;
+    /**
+     * @description icon of the collapse item
+     */
+    icon?: IconPropType;
+    /**
+     * @description disable the collapse item
+     */
+    disabled?: boolean;
+}
+/**
+ * @deprecated Removed after 3.0.0, Use `CollapseItemProps` instead.
+ */
+export declare const collapseItemProps: {
+    readonly title: import("@element-plus/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly name: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => string | number) | (() => CollapseActiveName) | (((new (...args: any[]) => string | number) | (() => CollapseActiveName)) | null)[], unknown, unknown, undefined, boolean>;
+    readonly icon: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown, import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, boolean>;
+    readonly disabled: BooleanConstructor;
+};
+/**
+ * @deprecated Removed after 3.0.0, Use `CollapseItemProps` instead.
+ */
+export type CollapseItemPropsPublic = ExtractPublicPropTypes<typeof collapseItemProps>;

package/dist/components/collapse-item/collapse-item.js

@@ -0,0 +1,34 @@
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import { iconPropType as o } from "../../utils/vue/icon.js";
+import "vue";
+import { buildProps as r, definePropType as t } from "../../utils/vue/props/runtime.js";
+import { ArrowRight as i } from "@element-plus/icons-vue";
+r({
+  /**
+   * @description title of the panel
+   */
+  title: {
+    type: String,
+    default: ""
+  },
+  /**
+   * @description unique identification of the panel
+   */
+  name: {
+    type: t([String, Number]),
+    default: void 0
+  },
+  /**
+   * @description icon of the collapse item
+   */
+  icon: {
+    type: o,
+    default: i
+  },
+  /**
+   * @description disable the collapse item
+   */
+  disabled: Boolean
+});

package/dist/components/collapse-item/index.d.ts

@@ -1,4 +1,13 @@
 import type { Plugin } from 'vue';
-import { ElCollapseItem } from 'element-plus';
-export declare const EpCollapseItem: typeof ElCollapseItem & Plugin;
+import _EpCollapseItem from './EpCollapseItem.vue';
+/**
+ * collapse-item 自持 barrel（vendor-batch-4 产出）。
+ *
+ * 子项通过 `../collapse/constants` 的本地 `collapseContextKey` 注入父上下文；
+ * 父入口以本文件所在目录的本体挂载 `.CollapseItem`。不导出 `ElCollapseItem` 别名。
+ */
+export declare const EpCollapseItem: typeof _EpCollapseItem & Plugin;
 export default EpCollapseItem;
+export { collapseItemProps } from './collapse-item';
+export type { CollapseItemProps, CollapseItemPropsPublic, } from './collapse-item';
+export type { CollapseItemInstance } from './instance';

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

@@ -1,6 +1,10 @@
-import { ElCollapseItem as e } from "element-plus";
-import { withInstall as l } from "../../utils/with-install.js";
-const t = Object.assign({}, e, { name: "EpCollapseItem" }), m = l(t, "ep-collapse-item");
+import { withInstall as o } from "../../utils/with-install.js";
+import t from "./EpCollapseItem.vue.js";
+import "./collapse-item.js";
+const i = o(
+  t,
+  "ep-collapse-item"
+);
 export {
-  m as EpCollapseItem
+  i as EpCollapseItem
 };

package/dist/components/collapse-item/instance.d.ts

@@ -0,0 +1,2 @@
+import type EpCollapseItem from './EpCollapseItem.vue';
+export type CollapseItemInstance = InstanceType<typeof EpCollapseItem> & unknown;

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;