@vrojs/element-plus 0.0.1 → 0.0.3

package/dist/vro-el-tags/vro-el-tags.vue.d.ts

@@ -0,0 +1,217 @@
+import { nextTick } from 'vue';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    modelValue: {
+        type: import('vue').PropType<string[]>;
+        default: () => never[];
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    modelValue: {
+        type: import('vue').PropType<string[]>;
+        default: () => never[];
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+    disabled: boolean;
+    modelValue: string[];
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    inputRef: ({
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly id?: string | undefined;
+            readonly size?: import('element-plus').ComponentSize | undefined;
+            readonly disabled?: boolean | undefined;
+            readonly modelValue?: string | number | null | undefined | undefined;
+            readonly modelModifiers?: import('element-plus').InputModelModifiers | undefined;
+            readonly maxlength?: string | number | undefined;
+            readonly minlength?: string | number | undefined;
+            readonly type?: import('element-plus').InputType | undefined;
+            readonly resize?: "none" | "both" | "horizontal" | "vertical" | undefined;
+            readonly autosize?: import('element-plus').InputAutoSize | undefined;
+            readonly autocomplete?: string | undefined;
+            readonly formatter?: ((value: string) => string) | undefined;
+            readonly parser?: ((value: string) => string) | undefined;
+            readonly placeholder?: string | undefined;
+            readonly form?: string | undefined;
+            readonly readonly?: boolean | undefined;
+            readonly clearable?: boolean | undefined;
+            readonly clearIcon?: import('element-plus/es/utils/vue/icon.mjs').IconPropType | undefined;
+            readonly showPassword?: boolean | undefined;
+            readonly showWordLimit?: boolean | undefined;
+            readonly wordLimitPosition?: "inside" | "outside" | undefined;
+            readonly suffixIcon?: import('element-plus/es/utils/vue/icon.mjs').IconPropType | undefined;
+            readonly prefixIcon?: import('element-plus/es/utils/vue/icon.mjs').IconPropType | undefined;
+            readonly containerRole?: string | undefined;
+            readonly tabindex?: string | number | undefined;
+            readonly validateEvent?: boolean | undefined;
+            readonly inputStyle?: import('vue').StyleValue;
+            readonly autofocus?: boolean | undefined;
+            readonly rows?: number | undefined;
+            readonly ariaLabel?: string | undefined;
+            readonly inputmode?: "search" | "text" | "email" | "tel" | "url" | "decimal" | "none" | "numeric" | undefined;
+            readonly name?: string | undefined;
+            readonly countGraphemes?: ((value: string) => number) | undefined;
+            readonly "onUpdate:modelValue"?: ((value: string) => any) | undefined | undefined;
+            readonly onInput?: ((value: string) => any) | undefined | undefined;
+            readonly onChange?: ((value: string, evt?: Event | undefined) => any) | undefined | undefined;
+            readonly onFocus?: ((evt: FocusEvent) => any) | undefined | undefined;
+            readonly onBlur?: ((evt: FocusEvent) => any) | undefined | undefined;
+            readonly onClear?: ((evt: MouseEvent | undefined) => any) | undefined | undefined;
+            readonly onMouseleave?: ((evt: MouseEvent) => any) | undefined | undefined;
+            readonly onMouseenter?: ((evt: MouseEvent) => any) | undefined | undefined;
+            readonly onKeydown?: ((evt: Event | KeyboardEvent) => any) | undefined | undefined;
+            readonly onCompositionstart?: ((evt: CompositionEvent) => any) | undefined | undefined;
+            readonly onCompositionupdate?: ((evt: CompositionEvent) => any) | undefined | undefined;
+            readonly onCompositionend?: ((evt: CompositionEvent) => any) | undefined | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any> | undefined;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: ((event: "input", value: string) => void) & ((event: "clear", evt: MouseEvent | undefined) => void) & ((event: "blur", evt: FocusEvent) => void) & ((event: "change", value: string, evt?: Event | undefined) => void) & ((event: "compositionend", evt: CompositionEvent) => void) & ((event: "compositionstart", evt: CompositionEvent) => void) & ((event: "compositionupdate", evt: CompositionEvent) => void) & ((event: "focus", evt: FocusEvent) => void) & ((event: "keydown", evt: Event | KeyboardEvent) => void) & ((event: "mouseenter", evt: MouseEvent) => void) & ((event: "mouseleave", evt: MouseEvent) => void) & ((event: "update:modelValue", value: string) => void);
+        $el: any;
+        $options: import('vue').ComponentOptionsBase<Readonly<import('element-plus').InputProps> & Readonly<{
+            "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+            onInput?: ((value: string) => any) | undefined;
+            onChange?: ((value: string, evt?: Event | undefined) => any) | undefined;
+            onFocus?: ((evt: FocusEvent) => any) | undefined;
+            onBlur?: ((evt: FocusEvent) => any) | undefined;
+            onClear?: ((evt: MouseEvent | undefined) => any) | undefined;
+            onMouseleave?: ((evt: MouseEvent) => any) | undefined;
+            onMouseenter?: ((evt: MouseEvent) => any) | undefined;
+            onKeydown?: ((evt: Event | KeyboardEvent) => any) | undefined;
+            onCompositionstart?: ((evt: CompositionEvent) => any) | undefined;
+            onCompositionupdate?: ((evt: CompositionEvent) => any) | undefined;
+            onCompositionend?: ((evt: CompositionEvent) => any) | undefined;
+        }>, {
+            input: import('vue').ShallowRef<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+            textarea: import('vue').ShallowRef<HTMLTextAreaElement | undefined, HTMLTextAreaElement | undefined>;
+            ref: import('vue').ComputedRef<HTMLInputElement | HTMLTextAreaElement | undefined>;
+            textareaStyle: import('vue').ComputedRef<import('vue').StyleValue>;
+            autosize: import('vue').Ref<import('element-plus').InputAutoSize | undefined, import('element-plus').InputAutoSize | undefined>;
+            isComposing: import('vue').Ref<boolean, boolean>;
+            passwordVisible: import('vue').Ref<boolean, boolean>;
+            focus: () => void | undefined;
+            blur: () => void | undefined;
+            select: () => void;
+            clear: (evt?: MouseEvent) => void;
+            resizeTextarea: () => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            "update:modelValue": (value: string) => void;
+            input: (value: string) => void;
+            change: (value: string, evt?: Event | undefined) => void;
+            focus: (evt: FocusEvent) => void;
+            blur: (evt: FocusEvent) => void;
+            clear: (evt: MouseEvent | undefined) => void;
+            mouseleave: (evt: MouseEvent) => void;
+            mouseenter: (evt: MouseEvent) => void;
+            keydown: (evt: Event | KeyboardEvent) => void;
+            compositionstart: (evt: CompositionEvent) => void;
+            compositionupdate: (evt: CompositionEvent) => void;
+            compositionend: (evt: CompositionEvent) => void;
+        }, string, {
+            disabled: boolean;
+            modelValue: string | number | null;
+            modelModifiers: import('element-plus').InputModelModifiers;
+            type: import('element-plus').InputType;
+            autocomplete: string;
+            clearIcon: import('element-plus/es/utils/vue/icon.mjs').IconPropType;
+            wordLimitPosition: "inside" | "outside";
+            tabindex: string | number;
+            validateEvent: boolean;
+            inputStyle: string | false | import('vue').CSSProperties | import('vue').StyleValue[] | null;
+            rows: number;
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+    } & Readonly<{
+        disabled: boolean;
+        modelValue: string | number | null;
+        modelModifiers: import('element-plus').InputModelModifiers;
+        type: import('element-plus').InputType;
+        autocomplete: string;
+        clearIcon: import('element-plus/es/utils/vue/icon.mjs').IconPropType;
+        wordLimitPosition: "inside" | "outside";
+        tabindex: string | number;
+        validateEvent: boolean;
+        inputStyle: string | false | import('vue').CSSProperties | import('vue').StyleValue[] | null;
+        rows: number;
+    }> & Omit<Readonly<import('element-plus').InputProps> & Readonly<{
+        "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+        onInput?: ((value: string) => any) | undefined;
+        onChange?: ((value: string, evt?: Event | undefined) => any) | undefined;
+        onFocus?: ((evt: FocusEvent) => any) | undefined;
+        onBlur?: ((evt: FocusEvent) => any) | undefined;
+        onClear?: ((evt: MouseEvent | undefined) => any) | undefined;
+        onMouseleave?: ((evt: MouseEvent) => any) | undefined;
+        onMouseenter?: ((evt: MouseEvent) => any) | undefined;
+        onKeydown?: ((evt: Event | KeyboardEvent) => any) | undefined;
+        onCompositionstart?: ((evt: CompositionEvent) => any) | undefined;
+        onCompositionupdate?: ((evt: CompositionEvent) => any) | undefined;
+        onCompositionend?: ((evt: CompositionEvent) => any) | undefined;
+    }>, "input" | "select" | "textarea" | "clear" | "type" | "blur" | "focus" | "disabled" | "modelValue" | "ref" | "validateEvent" | "tabindex" | "autocomplete" | "clearIcon" | "inputStyle" | "modelModifiers" | "autosize" | "wordLimitPosition" | "rows" | "textareaStyle" | "isComposing" | "passwordVisible" | "resizeTextarea"> & import('vue').ShallowUnwrapRef<{
+        input: import('vue').ShallowRef<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+        textarea: import('vue').ShallowRef<HTMLTextAreaElement | undefined, HTMLTextAreaElement | undefined>;
+        ref: import('vue').ComputedRef<HTMLInputElement | HTMLTextAreaElement | undefined>;
+        textareaStyle: import('vue').ComputedRef<import('vue').StyleValue>;
+        autosize: import('vue').Ref<import('element-plus').InputAutoSize | undefined, import('element-plus').InputAutoSize | undefined>;
+        isComposing: import('vue').Ref<boolean, boolean>;
+        passwordVisible: import('vue').Ref<boolean, boolean>;
+        focus: () => void | undefined;
+        blur: () => void | undefined;
+        select: () => void;
+        clear: (evt?: MouseEvent) => void;
+        resizeTextarea: () => void;
+    }> & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: {
+            prepend?: (props: {}) => any;
+        } & {
+            prefix?: (props: {}) => any;
+        } & {
+            suffix?: (props: {}) => any;
+        } & {
+            'password-icon'?: (props: {
+                visible: boolean;
+            }) => any;
+        } & {
+            append?: (props: {}) => any;
+        };
+    }) | null;
+}, HTMLDivElement>;
+export default _default;

package/dist/vro-el-tags/vro-el-tags.vue.js

@@ -0,0 +1,62 @@
+import { defineComponent as h, ref as r, createElementBlock as f, openBlock as o, createBlock as i, createCommentVNode as E, Fragment as T, renderList as B, unref as a, withCtx as v, createTextVNode as V, toDisplayString as g, withKeys as w, nextTick as I } from "vue";
+import { Plus as $ } from "@element-plus/icons-vue";
+import { ElTag as x, ElInput as K, ElButton as L } from "element-plus";
+import { useLocale as N } from "../locale/useLocale.js";
+import { vroElTagsProps as P } from "./types.js";
+const R = { class: "vro-el-tags" }, q = /* @__PURE__ */ h({
+  name: "VroElTags",
+  __name: "vro-el-tags",
+  props: P,
+  emits: ["update:modelValue"],
+  setup(k, { emit: C }) {
+    const m = C, c = k, { t: b } = N(), n = r(""), u = r(!1), d = r(), y = (e) => {
+      const t = c.modelValue.filter((l, s) => s !== e);
+      m("update:modelValue", t);
+    }, _ = () => {
+      u.value = !0, I(() => {
+        d.value?.input?.focus();
+      });
+    }, p = () => {
+      const e = [...c.modelValue], t = n.value.trim();
+      t && e.push(t), m("update:modelValue", e), u.value = !1, n.value = "";
+    };
+    return (e, t) => (o(), f("div", R, [
+      (o(!0), f(T, null, B(e.modelValue, (l, s) => (o(), i(a(x), {
+        key: `${l}-${s}`,
+        class: "vro-el-tag",
+        size: "large",
+        closable: !e.disabled,
+        "disable-transitions": !1,
+        onClose: (z) => y(s)
+      }, {
+        default: v(() => [
+          V(g(l), 1)
+        ]),
+        _: 2
+      }, 1032, ["closable", "onClose"]))), 128)),
+      u.value ? (o(), i(a(K), {
+        key: 0,
+        ref_key: "inputRef",
+        ref: d,
+        modelValue: n.value,
+        "onUpdate:modelValue": t[0] || (t[0] = (l) => n.value = l),
+        class: "vro-el-tag-input",
+        onKeyup: w(p, ["enter"]),
+        onBlur: p
+      }, null, 8, ["modelValue"])) : e.disabled ? E("", !0) : (o(), i(a(L), {
+        key: 1,
+        class: "vro-el-tag-btn",
+        icon: a($),
+        onClick: _
+      }, {
+        default: v(() => [
+          V(g(a(b)("tags.addText")), 1)
+        ]),
+        _: 1
+      }, 8, ["icon"]))
+    ]));
+  }
+});
+export {
+  q as default
+};

package/dist/vro-el-tags/vro-el-tags.vue2.js

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

package/dist/vro-el-tree/index.d.ts

@@ -0,0 +1,86 @@
+export * from './types';
+export declare const VroElTree: import('@vrojs/base').WithInstall<{
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+        modelValue: {
+            type: import('vue').PropType<import('./types').VroElTreeKey[]>;
+            default: () => never[];
+        };
+        options: {
+            type: import('vue').PropType<import('./types').VroElTreeOption[]>;
+            default: () => never[];
+        };
+        rootId: {
+            type: (NumberConstructor | StringConstructor)[];
+            default: string;
+        };
+    }>> & Readonly<{
+        "onUpdate:modelValue"?: ((value: import('./types').VroElTreeKey[]) => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        "update:modelValue": (value: import('./types').VroElTreeKey[]) => any;
+    }, import('vue').PublicProps, {
+        modelValue: import('./types').VroElTreeKey[];
+        options: import('./types').VroElTreeOption[];
+        rootId: string | number;
+    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('vue').ExtractPropTypes<{
+        modelValue: {
+            type: import('vue').PropType<import('./types').VroElTreeKey[]>;
+            default: () => never[];
+        };
+        options: {
+            type: import('vue').PropType<import('./types').VroElTreeOption[]>;
+            default: () => never[];
+        };
+        rootId: {
+            type: (NumberConstructor | StringConstructor)[];
+            default: string;
+        };
+    }>> & Readonly<{
+        "onUpdate:modelValue"?: ((value: import('./types').VroElTreeKey[]) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        modelValue: import('./types').VroElTreeKey[];
+        options: import('./types').VroElTreeOption[];
+        rootId: string | number;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+    modelValue: {
+        type: import('vue').PropType<import('./types').VroElTreeKey[]>;
+        default: () => never[];
+    };
+    options: {
+        type: import('vue').PropType<import('./types').VroElTreeOption[]>;
+        default: () => never[];
+    };
+    rootId: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: string;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((value: import('./types').VroElTreeKey[]) => any) | undefined;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:modelValue": (value: import('./types').VroElTreeKey[]) => any;
+}, string, {
+    modelValue: import('./types').VroElTreeKey[];
+    options: import('./types').VroElTreeOption[];
+    rootId: string | number;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: {
+        default?(_: any): any;
+    };
+})>;
+export default VroElTree;
+export type VroElTreeInstance = InstanceType<typeof VroElTree>;
+declare module 'vue' {
+    interface GlobalComponents {
+        VroElTree: typeof VroElTree;
+    }
+}

package/dist/vro-el-tree/index.js

@@ -0,0 +1,9 @@
+import { withInstall as r } from "@vrojs/base";
+import o from "./vro-el-tree.vue.js";
+import { vroElTreeProps as p } from "./types.js";
+const m = r(o);
+export {
+  m as VroElTree,
+  m as default,
+  p as vroElTreeProps
+};

package/dist/vro-el-tree/style/css.js

@@ -0,0 +1,4 @@
+import '../../style/base.css';
+import './index.css';
+/* empty css                    */
+/* empty css           */

package/dist/vro-el-tree/style/deps.js

@@ -0,0 +1 @@
+import "element-plus/es/components/tree/style/css";

package/dist/vro-el-tree/style/index.css

@@ -0,0 +1 @@
+.vro-el-tree{-webkit-user-select:none;user-select:none}

package/dist/vro-el-tree/style/index.js

@@ -0,0 +1,5 @@
+import '../../style/base.css';
+import './index.css';
+import "element-plus/es/components/tree/style/css";
+/* empty css                    */
+/* empty css           */

package/dist/vro-el-tree/types.d.ts

@@ -0,0 +1,32 @@
+import { ExtractPropTypes, PropType } from 'vue';
+export type VroElTreeKey = string | number;
+export interface VroElTreeOption {
+    id: VroElTreeKey;
+    parentId?: VroElTreeKey;
+    children?: VroElTreeOption[];
+    [key: string]: any;
+}
+export declare const vroElTreeProps: {
+    /**
+     * 选中的节点 id 列表，包含半选和全选节点。
+     */
+    modelValue: {
+        type: PropType<VroElTreeKey[]>;
+        default: () => never[];
+    };
+    /**
+     * 树节点数据，节点需要包含 id，可通过 parentId 表示父级关系。
+     */
+    options: {
+        type: PropType<VroElTreeOption[]>;
+        default: () => never[];
+    };
+    /**
+     * 根节点 id，用于判断顶层节点的选中链路。
+     */
+    rootId: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: string;
+    };
+};
+export type VroElTreeProps = ExtractPropTypes<typeof vroElTreeProps>;

package/dist/vro-el-tree/types.js

@@ -0,0 +1,26 @@
+const e = {
+  /**
+   * 选中的节点 id 列表，包含半选和全选节点。
+   */
+  modelValue: {
+    type: Array,
+    default: () => []
+  },
+  /**
+   * 树节点数据，节点需要包含 id，可通过 parentId 表示父级关系。
+   */
+  options: {
+    type: Array,
+    default: () => []
+  },
+  /**
+   * 根节点 id，用于判断顶层节点的选中链路。
+   */
+  rootId: {
+    type: [String, Number],
+    default: "-1"
+  }
+};
+export {
+  e as vroElTreeProps
+};

package/dist/vro-el-tree/vro-el-tree.vue.d.ts

@@ -0,0 +1,52 @@
+import { VroElTreeKey, VroElTreeOption } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: any): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    modelValue: {
+        type: import('vue').PropType<VroElTreeKey[]>;
+        default: () => never[];
+    };
+    options: {
+        type: import('vue').PropType<VroElTreeOption[]>;
+        default: () => never[];
+    };
+    rootId: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: string;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:modelValue": (value: VroElTreeKey[]) => any;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    modelValue: {
+        type: import('vue').PropType<VroElTreeKey[]>;
+        default: () => never[];
+    };
+    options: {
+        type: import('vue').PropType<VroElTreeOption[]>;
+        default: () => never[];
+    };
+    rootId: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: string;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((value: VroElTreeKey[]) => any) | undefined;
+}>, {
+    modelValue: VroElTreeKey[];
+    options: VroElTreeOption[];
+    rootId: string | number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/vro-el-tree/vro-el-tree.vue.js

@@ -0,0 +1,56 @@
+import { defineComponent as I, computed as y, createBlock as v, openBlock as C, unref as V, mergeProps as E, createSlots as K, withCtx as P, renderSlot as _, normalizeProps as T, guardReactiveProps as $ } from "vue";
+import { isUndefined as a } from "@daysnap/utils";
+import { ElTree as g } from "element-plus";
+import { vroElTreeProps as B } from "./types.js";
+const N = /* @__PURE__ */ I({
+  name: "VroElTree",
+  __name: "vro-el-tree",
+  props: B,
+  emits: ["update:modelValue"],
+  setup(u, { emit: p }) {
+    const f = p, h = u, i = y(() => {
+      const { modelValue: r, options: t, rootId: o } = h, { childIds: e, mapping: d } = l(t), k = r.reduce(
+        (s, n) => (s[n] = !0, s),
+        {}
+      ), c = (s) => {
+        if (s === o)
+          return !0;
+        if (!k[s])
+          return !1;
+        const n = d[s];
+        return !a(n) && c(n);
+      };
+      return e.filter(c);
+    }), m = (r, t) => {
+      const { checkedKeys: o, halfCheckedKeys: e } = t;
+      f("update:modelValue", [...e, ...o]);
+    };
+    function l(r, t = {}) {
+      const o = [];
+      return r.forEach((e) => {
+        if (a(e.parentId) || (t[e.id] = e.parentId), e.children && e.children.length > 0) {
+          const d = l(e.children ?? [], t);
+          o.push(...d.childIds);
+        } else
+          o.push(e.id);
+      }), { childIds: o, mapping: t };
+    }
+    return (r, t) => (C(), v(V(g), E(r.$attrs, {
+      class: "vro-el-tree",
+      data: r.options,
+      "default-checked-keys": i.value,
+      onCheck: m
+    }), K({ _: 2 }, [
+      r.$slots.default ? {
+        name: "default",
+        fn: P((o) => [
+          _(r.$slots, "default", T($(o)))
+        ]),
+        key: "0"
+      } : void 0
+    ]), 1040, ["data", "default-checked-keys"]));
+  }
+});
+export {
+  N as default
+};

package/dist/vro-el-tree/vro-el-tree.vue2.js

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

package/dist/vro-el-with-config/index.d.ts

@@ -0,0 +1,32 @@
+export * from './types';
+export declare const VroElWithConfig: import('@vrojs/base').WithInstall<import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    elConfigProps: {
+        type: import('vue').PropType<Partial<import('element-plus').ConfigProviderProps>>;
+        default: () => {};
+    };
+    vroConfigProps: {
+        type: import('vue').PropType<Partial<import('..').VroElConfigProviderProps>>;
+        default: () => {};
+    };
+    is: import('vue').PropType<string | import('vue').Component>;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    elConfigProps: {
+        type: import('vue').PropType<Partial<import('element-plus').ConfigProviderProps>>;
+        default: () => {};
+    };
+    vroConfigProps: {
+        type: import('vue').PropType<Partial<import('..').VroElConfigProviderProps>>;
+        default: () => {};
+    };
+    is: import('vue').PropType<string | import('vue').Component>;
+}>> & Readonly<{}>, {
+    elConfigProps: Partial<import('element-plus').ConfigProviderProps>;
+    vroConfigProps: Partial<import('..').VroElConfigProviderProps>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>>;
+export default VroElWithConfig;
+export type VroElWithConfigInstance = InstanceType<typeof VroElWithConfig>;
+declare module 'vue' {
+    interface GlobalComponents {
+        VroElWithConfig: typeof VroElWithConfig;
+    }
+}

package/dist/vro-el-with-config/index.js

@@ -0,0 +1,9 @@
+import { withInstall as o } from "@vrojs/base";
+import r from "./vro-el-with-config.vue.js";
+import { vroElWithConfigProps as n } from "./types.js";
+const f = o(r);
+export {
+  f as VroElWithConfig,
+  f as default,
+  n as vroElWithConfigProps
+};

package/dist/vro-el-with-config/style/css.js

@@ -0,0 +1,4 @@
+import '../../style/base.css';
+/* empty css                    */
+/* empty css                                            */
+/* empty css           */

package/dist/vro-el-with-config/style/deps.js

@@ -0,0 +1 @@
+import "element-plus/es/components/config-provider/style/css";

package/dist/vro-el-with-config/style/index.js

@@ -0,0 +1,5 @@
+import '../../style/base.css';
+import "element-plus/es/components/config-provider/style/css";
+/* empty css                    */
+/* empty css                                            */
+/* empty css           */