ep-craft 0.1.34 → 0.1.36

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/col/EpCol.vue.d.ts

@@ -0,0 +1,24 @@
+import type { ColProps } from './col';
+declare var __VLS_6: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_6) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<ColProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ColProps> & Readonly<{}>, {
+    push: number;
+    offset: number;
+    span: number;
+    tag: string;
+    pull: number;
+    xs: import("./col").ColSize;
+    sm: import("./col").ColSize;
+    md: import("./col").ColSize;
+    lg: import("./col").ColSize;
+    xl: import("./col").ColSize;
+}, {}, {}, {}, 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/col/EpCol.vue.js

@@ -0,0 +1,61 @@
+import { defineComponent as c, inject as d, computed as r, openBlock as h, createBlock as $, resolveDynamicComponent as g, normalizeStyle as b, normalizeClass as x, withCtx as v, renderSlot as y } from "vue";
+import { isNumber as f } from "../../utils/types.js";
+import "lodash-unified";
+import "@vueuse/core";
+import { isObject as C } from "@vue/shared";
+import "@element-plus/icons-vue";
+import { useNamespace as E } 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 { rowContextKey as _ } from "../row/constants.js";
+const I = /* @__PURE__ */ c({
+  name: "EpCol",
+  __name: "EpCol",
+  props: {
+    tag: { default: "div" },
+    span: { default: 24 },
+    offset: { default: 0 },
+    pull: { default: 0 },
+    push: { default: 0 },
+    xs: { default: () => ({}) },
+    sm: { default: () => ({}) },
+    md: { default: () => ({}) },
+    lg: { default: () => ({}) },
+    xl: { default: () => ({}) }
+  },
+  setup(n) {
+    const s = n, { gutter: a } = d(_, { gutter: r(() => 0) }), o = E("col"), m = r(() => {
+      const e = {};
+      return a.value && (e.paddingLeft = e.paddingRight = `${a.value / 2}px`), e;
+    }), i = r(() => {
+      const e = [];
+      return ["span", "offset", "pull", "push"].forEach((t) => {
+        const l = s[t];
+        f(l) && (t === "span" ? e.push(o.b(`${s[t]}`)) : l > 0 && e.push(o.b(`${t}-${s[t]}`)));
+      }), ["xs", "sm", "md", "lg", "xl"].forEach((t) => {
+        f(s[t]) ? e.push(o.b(`${t}-${s[t]}`)) : C(s[t]) && Object.entries(s[t]).forEach(([l, u]) => {
+          e.push(
+            l !== "span" ? o.b(`${t}-${l}-${u}`) : o.b(`${t}-${u}`)
+          );
+        });
+      }), a.value && e.push(o.is("guttered")), [o.b(), e];
+    });
+    return (e, p) => (h(), $(g(n.tag), {
+      class: x(i.value),
+      style: b(m.value)
+    }, {
+      default: v(() => [
+        y(e.$slots, "default")
+      ]),
+      _: 3
+    }, 8, ["class", "style"]));
+  }
+});
+export {
+  I as default
+};

package/dist/components/col/EpCol2.vue.js

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

package/dist/components/col/col.d.ts

@@ -0,0 +1,71 @@
+import type { ExtractPublicPropTypes } from 'vue';
+import type EpCol from './EpCol.vue';
+export type ColSizeObject = {
+    span?: number;
+    offset?: number;
+    pull?: number;
+    push?: number;
+};
+export type ColSize = number | ColSizeObject;
+export interface ColProps {
+    /**
+     * @description custom element tag
+     */
+    tag?: string;
+    /**
+     * @description number of column the grid spans
+     */
+    span?: number;
+    /**
+     * @description number of spacing on the left side of the grid
+     */
+    offset?: number;
+    /**
+     * @description number of columns that grid moves to the left
+     */
+    pull?: number;
+    /**
+     * @description number of columns that grid moves to the right
+     */
+    push?: number;
+    /**
+     * @description `<768px` Responsive columns or column props object
+     */
+    xs?: ColSize;
+    /**
+     * @description `≥768px` Responsive columns or column props object
+     */
+    sm?: ColSize;
+    /**
+     * @description `≥992px` Responsive columns or column props object
+     */
+    md?: ColSize;
+    /**
+     * @description `≥1200px` Responsive columns or column props object
+     */
+    lg?: ColSize;
+    /**
+     * @description `≥1920px` Responsive columns or column props object
+     */
+    xl?: ColSize;
+}
+/**
+ * @deprecated Removed after 3.0.0, Use `ColProps` instead.
+ */
+export declare const colProps: {
+    readonly tag: import("@element-plus/utils").EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
+    readonly span: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 24, boolean>;
+    readonly offset: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly pull: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly push: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly xs: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => number | ColSizeObject) | (() => ColSize) | (((new (...args: any[]) => number | ColSizeObject) | (() => ColSize)) | null)[], unknown, unknown, () => import("@element-plus/utils").Mutable<{}>, boolean>;
+    readonly sm: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => number | ColSizeObject) | (() => ColSize) | (((new (...args: any[]) => number | ColSizeObject) | (() => ColSize)) | null)[], unknown, unknown, () => import("@element-plus/utils").Mutable<{}>, boolean>;
+    readonly md: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => number | ColSizeObject) | (() => ColSize) | (((new (...args: any[]) => number | ColSizeObject) | (() => ColSize)) | null)[], unknown, unknown, () => import("@element-plus/utils").Mutable<{}>, boolean>;
+    readonly lg: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => number | ColSizeObject) | (() => ColSize) | (((new (...args: any[]) => number | ColSizeObject) | (() => ColSize)) | null)[], unknown, unknown, () => import("@element-plus/utils").Mutable<{}>, boolean>;
+    readonly xl: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => number | ColSizeObject) | (() => ColSize) | (((new (...args: any[]) => number | ColSizeObject) | (() => ColSize)) | null)[], unknown, unknown, () => import("@element-plus/utils").Mutable<{}>, boolean>;
+};
+/**
+ * @deprecated Removed after 3.0.0, Use `ColProps` instead.
+ */
+export type ColPropsPublic = ExtractPublicPropTypes<typeof colProps>;
+export type ColInstance = InstanceType<typeof EpCol> & unknown;

package/dist/components/col/col.js

@@ -0,0 +1,79 @@
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import { mutable as e } from "../../utils/typescript.js";
+import "@element-plus/icons-vue";
+import { buildProps as p, definePropType as t } from "../../utils/vue/props/runtime.js";
+import "vue";
+p({
+  /**
+   * @description custom element tag
+   */
+  tag: {
+    type: String,
+    default: "div"
+  },
+  /**
+   * @description number of column the grid spans
+   */
+  span: {
+    type: Number,
+    default: 24
+  },
+  /**
+   * @description number of spacing on the left side of the grid
+   */
+  offset: {
+    type: Number,
+    default: 0
+  },
+  /**
+   * @description number of columns that grid moves to the left
+   */
+  pull: {
+    type: Number,
+    default: 0
+  },
+  /**
+   * @description number of columns that grid moves to the right
+   */
+  push: {
+    type: Number,
+    default: 0
+  },
+  /**
+   * @description `<768px` Responsive columns or column props object
+   */
+  xs: {
+    type: t([Number, Object]),
+    default: () => e({})
+  },
+  /**
+   * @description `≥768px` Responsive columns or column props object
+   */
+  sm: {
+    type: t([Number, Object]),
+    default: () => e({})
+  },
+  /**
+   * @description `≥992px` Responsive columns or column props object
+   */
+  md: {
+    type: t([Number, Object]),
+    default: () => e({})
+  },
+  /**
+   * @description `≥1200px` Responsive columns or column props object
+   */
+  lg: {
+    type: t([Number, Object]),
+    default: () => e({})
+  },
+  /**
+   * @description `≥1920px` Responsive columns or column props object
+   */
+  xl: {
+    type: t([Number, Object]),
+    default: () => e({})
+  }
+});

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

@@ -1,4 +1,12 @@
 import type { Plugin } from 'vue';
-import { ElCol } from 'element-plus';
-export declare const EpCol: typeof ElCol & Plugin;
+import _EpCol from './EpCol.vue';
+/**
+ * col 自持 barrel（vendor-batch-4 产出）。
+ *
+ * 列通过 `../row/constants` 的本地 `rowContextKey` 读取父级 gutter；
+ * 这是本批唯一允许的跨族 constants 依赖。不导出 `ElCol` 别名。
+ */
+export declare const EpCol: typeof _EpCol & Plugin;
 export default EpCol;
+export { colProps } from './col';
+export type { ColInstance, ColProps, ColPropsPublic, ColSize, ColSizeObject, } from './col';

package/dist/components/col/index.js

@@ -1,6 +1,7 @@
-import { ElCol as o } from "element-plus";
-import { withInstall as l } from "../../utils/with-install.js";
-const t = Object.assign({}, o, { name: "EpCol" }), n = l(t, "ep-col");
+import { withInstall as o } from "../../utils/with-install.js";
+import t from "./EpCol.vue.js";
+import "./col.js";
+const i = o(t, "ep-col");
 export {
-  n as EpCol
+  i as EpCol
 };

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

@@ -0,0 +1,27 @@
+import type { CollapseProps } from './collapse';
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<CollapseProps, {
+    /** @description active names */
+    activeNames: import("vue").Ref<(string | number)[], (string | number)[]>;
+    /** @description set active names */
+    setActiveNames: (_activeNames: import("./collapse").CollapseActiveName[]) => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: import("./collapse").CollapseModelValue) => void;
+    change: (value: import("./collapse").CollapseModelValue) => void;
+}, string, import("vue").PublicProps, Readonly<CollapseProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: import("./collapse").CollapseModelValue) => any) | undefined;
+    onChange?: ((value: import("./collapse").CollapseModelValue) => any) | undefined;
+}>, {
+    modelValue: import("./collapse").CollapseModelValue;
+    expandIconPosition: import("./collapse").CollapseIconPositionType;
+}, {}, {}, {}, 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/EpCollapse.vue.js

@@ -0,0 +1,30 @@
+import { defineComponent as m, openBlock as c, createElementBlock as i, normalizeClass as f, unref as u, renderSlot as d } from "vue";
+import { collapseEmits as C } from "./collapse.js";
+import { useCollapse as _, useCollapseDOM as E } from "./use-collapse.js";
+const k = /* @__PURE__ */ m({
+  name: "EpCollapse",
+  __name: "EpCollapse",
+  props: {
+    accordion: { type: Boolean },
+    modelValue: { default: () => [] },
+    expandIconPosition: { default: "right" },
+    beforeCollapse: {}
+  },
+  emits: C,
+  setup(o, { expose: s, emit: t }) {
+    const e = o, l = t, { activeNames: a, setActiveNames: n } = _(e, l), { rootKls: p } = E(e);
+    return s({
+      /** @description active names */
+      activeNames: a,
+      /** @description set active names */
+      setActiveNames: n
+    }), (r, v) => (c(), i("div", {
+      class: f(u(p))
+    }, [
+      d(r.$slots, "default")
+    ], 2));
+  }
+});
+export {
+  k as default
+};

package/dist/components/collapse/EpCollapse2.vue.js

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