@fangzhongya/fang-ui 0.0.12 → 0.0.14

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

@@ -1,13 +1,133 @@
-declare const Selects: import('../../utils/vues').WithInstall<import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+declare const Selects: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+        placeholder: {
+            type: StringConstructor;
+        };
+        options: {
+            type: {
+                (arrayLength: number): ObjAny[];
+                (...items: ObjAny[]): ObjAny[];
+                new (arrayLength: number): ObjAny[];
+                new (...items: ObjAny[]): ObjAny[];
+                isArray(arg: any): arg is any[];
+                readonly prototype: any[];
+                from<T>(arrayLike: ArrayLike<T>): T[];
+                from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                of<T>(...items: T[]): T[];
+                fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                readonly [Symbol.species]: ArrayConstructor;
+            };
+            default(): never[];
+        };
+        clearAbsent: {
+            type: BooleanConstructor;
+        };
+        label: {
+            type: (FunctionConstructor | StringConstructor)[];
+            default: string;
+        };
+        prop: {
+            type: (FunctionConstructor | StringConstructor)[];
+            default: string;
+        };
+        modelValue: {
+            type: null;
+        };
+        multiple: {
+            type: (BooleanConstructor | StringConstructor)[];
+        };
+        load: {
+            type: BooleanConstructor[];
+        };
+        optobj: {
+            type: BooleanConstructor[];
+        };
+    }>> & Readonly<{}>, {
+        el: import('vue').Ref<any, any>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+        label: string | Function;
+        options: ObjAny[];
+        prop: string | Function;
+        clearAbsent: boolean;
+    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        refEl: HTMLDivElement;
+    }, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('vue').ExtractPropTypes<{
+        placeholder: {
+            type: StringConstructor;
+        };
+        options: {
+            type: {
+                (arrayLength: number): ObjAny[];
+                (...items: ObjAny[]): ObjAny[];
+                new (arrayLength: number): ObjAny[];
+                new (...items: ObjAny[]): ObjAny[];
+                isArray(arg: any): arg is any[];
+                readonly prototype: any[];
+                from<T>(arrayLike: ArrayLike<T>): T[];
+                from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                of<T>(...items: T[]): T[];
+                fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                readonly [Symbol.species]: ArrayConstructor;
+            };
+            default(): never[];
+        };
+        clearAbsent: {
+            type: BooleanConstructor;
+        };
+        label: {
+            type: (FunctionConstructor | StringConstructor)[];
+            default: string;
+        };
+        prop: {
+            type: (FunctionConstructor | StringConstructor)[];
+            default: string;
+        };
+        modelValue: {
+            type: null;
+        };
+        multiple: {
+            type: (BooleanConstructor | StringConstructor)[];
+        };
+        load: {
+            type: BooleanConstructor[];
+        };
+        optobj: {
+            type: BooleanConstructor[];
+        };
+    }>> & Readonly<{}>, {
+        el: import('vue').Ref<any, any>;
+    }, {}, {}, {}, {
+        label: string | Function;
+        options: ObjAny[];
+        prop: string | Function;
+        clearAbsent: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
     placeholder: {
         type: StringConstructor;
     };
-    list: {
+    options: {
         type: {
-            (arrayLength: number): import('../../types/object').ObjAny[];
-            (...items: import('../../types/object').ObjAny[]): import('../../types/object').ObjAny[];
-            new (arrayLength: number): import('../../types/object').ObjAny[];
-            new (...items: import('../../types/object').ObjAny[]): import('../../types/object').ObjAny[];
+            (arrayLength: number): ObjAny[];
+            (...items: ObjAny[]): ObjAny[];
+            new (arrayLength: number): ObjAny[];
+            new (...items: ObjAny[]): ObjAny[];
             isArray(arg: any): arg is any[];
             readonly prototype: any[];
             from<T>(arrayLike: ArrayLike<T>): T[];
@@ -21,12 +141,15 @@ declare const Selects: import('../../utils/vues').WithInstall<import('vue').Defi
         };
         default(): never[];
     };
+    clearAbsent: {
+        type: BooleanConstructor;
+    };
     label: {
-        type: (StringConstructor | FunctionConstructor)[];
+        type: (FunctionConstructor | StringConstructor)[];
         default: string;
     };
     prop: {
-        type: (StringConstructor | FunctionConstructor)[];
+        type: (FunctionConstructor | StringConstructor)[];
         default: string;
     };
     modelValue: {
@@ -35,46 +158,18 @@ declare const Selects: import('../../utils/vues').WithInstall<import('vue').Defi
     multiple: {
         type: (BooleanConstructor | StringConstructor)[];
     };
-}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
-    placeholder: {
-        type: StringConstructor;
-    };
-    list: {
-        type: {
-            (arrayLength: number): import('../../types/object').ObjAny[];
-            (...items: import('../../types/object').ObjAny[]): import('../../types/object').ObjAny[];
-            new (arrayLength: number): import('../../types/object').ObjAny[];
-            new (...items: import('../../types/object').ObjAny[]): import('../../types/object').ObjAny[];
-            isArray(arg: any): arg is any[];
-            readonly prototype: any[];
-            from<T>(arrayLike: ArrayLike<T>): T[];
-            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
-            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
-            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
-            of<T>(...items: T[]): T[];
-            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
-            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
-            readonly [Symbol.species]: ArrayConstructor;
-        };
-        default(): never[];
-    };
-    label: {
-        type: (StringConstructor | FunctionConstructor)[];
-        default: string;
-    };
-    prop: {
-        type: (StringConstructor | FunctionConstructor)[];
-        default: string;
+    load: {
+        type: BooleanConstructor[];
     };
-    modelValue: {
-        type: null;
-    };
-    multiple: {
-        type: (BooleanConstructor | StringConstructor)[];
+    optobj: {
+        type: BooleanConstructor[];
     };
 }>> & Readonly<{}>, {
+    el: import('vue').Ref<any, any>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
     label: string | Function;
-    list: import('../../types/object').ObjAny[];
+    options: ObjAny[];
     prop: string | Function;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>> & Record<string, any>;
+    clearAbsent: boolean;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & import('vue').Plugin;
 export { Selects, Selects as default };

package/dist/components/selects/index.js

@@ -1,3 +1,4 @@
+/* empty css                 */
 import { withInstall } from "../../utils/vues/withInstall.js";
 import _sfc_main from "./src/index.js";
 const Selects = withInstall(_sfc_main, "Selects");

package/dist/components/selects/index.scss

@@ -0,0 +1,12 @@
+@use '../css/common.scss' as *;
+
+$selects: 'selects';
+@include b($selects) {
+	&-select {
+		height: 100%;
+		min-width: 100px;
+		& > div {
+			height: 100%;
+		}
+	}
+}

package/dist/components/selects/src/data.cjs

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const buildProps = require("../../../utils/vues/buildProps.cjs");
-const list = require("../../common/data/list.cjs");
-const dataProps = buildProps.buildProps({
+const list = require("../../common/list.cjs");
+const dataProps = {
   ...list.props,
   /**
    * @props { String } placeholder= ( )
@@ -11,7 +10,7 @@ const dataProps = buildProps.buildProps({
   placeholder: {
     type: String
   }
-});
+};
 const dataHandle = list.comHandle;
 const dataEmits = [...list.emits];
 exports.dataEmits = dataEmits;

package/dist/components/selects/src/data.d.ts

@@ -1,5 +1,5 @@
-import { ExtractPublicPropTypes } from 'vue';
-import { comHandle } from '../../common/data/list';
+import { ExtractPropTypes } from 'vue';
+import { comHandle } from '../../common/list';
 export declare const dataProps: {
     /**
      * @props { String } placeholder= ( )
@@ -8,12 +8,12 @@ export declare const dataProps: {
     placeholder: {
         type: StringConstructor;
     };
-    list: {
+    options: {
         type: {
-            (arrayLength: number): import('../../../types/object').ObjAny[];
-            (...items: import('../../../types/object').ObjAny[]): import('../../../types/object').ObjAny[];
-            new (arrayLength: number): import('../../../types/object').ObjAny[];
-            new (...items: import('../../../types/object').ObjAny[]): import('../../../types/object').ObjAny[];
+            (arrayLength: number): ObjAny[];
+            (...items: ObjAny[]): ObjAny[];
+            new (arrayLength: number): ObjAny[];
+            new (...items: ObjAny[]): ObjAny[];
             isArray(arg: any): arg is any[];
             readonly prototype: any[];
             from<T>(arrayLike: ArrayLike<T>): T[];
@@ -27,12 +27,15 @@ export declare const dataProps: {
         };
         default(): never[];
     };
+    clearAbsent: {
+        type: BooleanConstructor;
+    };
     label: {
-        type: (StringConstructor | FunctionConstructor)[];
+        type: (FunctionConstructor | StringConstructor)[];
         default: string;
     };
     prop: {
-        type: (StringConstructor | FunctionConstructor)[];
+        type: (FunctionConstructor | StringConstructor)[];
         default: string;
     };
     modelValue: {
@@ -41,8 +44,14 @@ export declare const dataProps: {
     multiple: {
         type: (BooleanConstructor | StringConstructor)[];
     };
+    load: {
+        type: BooleanConstructor[];
+    };
+    optobj: {
+        type: BooleanConstructor[];
+    };
 };
-export type DataProps = ExtractPublicPropTypes<typeof dataProps>;
+export type DataProps = ExtractPropTypes<typeof dataProps>;
 export declare const dataHandle: typeof comHandle;
 export declare const dataEmits: string[];
 export type DataEmits = typeof dataEmits;

package/dist/components/selects/src/data.js

@@ -1,6 +1,5 @@
-import { buildProps } from "../../../utils/vues/buildProps.js";
-import { emits, comHandle, props } from "../../common/data/list.js";
-const dataProps = buildProps({
+import { emits, props, comHandle } from "../../common/list.js";
+const dataProps = {
   ...props,
   /**
    * @props { String } placeholder= ( )
@@ -9,7 +8,7 @@ const dataProps = buildProps({
   placeholder: {
     type: String
   }
-});
+};
 const dataHandle = comHandle;
 const dataEmits = [...emits];
 export {

package/dist/components/selects/src/index.cjs

@@ -1,23 +1,25 @@
 "use strict";
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const vue = require("vue");
+const require$$0 = require("vue");
+const index$2 = require("../../../directives/expose/index.cjs");
 const elementPlus = require("element-plus");
-const common = require("../../../utils/vues/common.cjs");
-const index = require("../../../hooks/cssname/index.cjs");
-const index$1 = require("../../../hooks/locale/index.cjs");
+const index = require("../../../hooks/inherit/index.cjs");
+const use = require("../../common/use.cjs");
+const index$1 = require("../../../hooks/cssname/index.cjs");
 const data = require("./data.cjs");
-const index$2 = require("../../../directives/expose/index.cjs");
-const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+const _sfc_main = /* @__PURE__ */ require$$0.defineComponent({
+  ...{ inheritAttrs: false },
   __name: "index",
   props: data.dataProps,
   emits: data.dataEmits,
-  setup(__props, { emit: __emit }) {
-    const cs = index.useCssName("selects");
-    const { getLocale } = index$1.useLocale();
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const refEl = require$$0.ref();
+    const attrs = index.useInherit(require$$0.useAttrs());
+    const cs = index$1.useCssName("selects");
     const props = __props;
-    const placeholder = vue.computed(() => {
+    const placeholder = require$$0.computed(() => {
       if (typeof props.placeholder == "undefined") {
-        return getLocale("form.select");
+        return "请选择";
       } else {
         return props.placeholder;
       }
@@ -26,31 +28,38 @@ const _sfc_main = /* @__PURE__ */ vue.defineComponent({
     const listFuObj = data.dataHandle(props, emit);
     const value = listFuObj.value;
     const multiple = listFuObj.multiple;
+    __expose({
+      el: refEl
+    });
     return (_ctx, _cache) => {
-      return vue.openBlock(), vue.createElementBlock("div", {
-        class: vue.normalizeClass(vue.unref(cs).z())
-      }, [
-        vue.withDirectives((vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElSelect), vue.mergeProps({
-          modelValue: vue.unref(value),
-          "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => vue.isRef(value) ? value.value = $event : null)
-        }, _ctx.$attrs, {
-          multiple: vue.unref(multiple),
+      return require$$0.openBlock(), require$$0.createElementBlock("div", require$$0.mergeProps({
+        ref_key: "refEl",
+        ref: refEl
+      }, require$$0.unref(attrs).root, {
+        class: require$$0.unref(cs).z()
+      }), [
+        require$$0.withDirectives((require$$0.openBlock(), require$$0.createBlock(require$$0.unref(elementPlus.ElSelect), require$$0.mergeProps({
+          class: require$$0.unref(cs).z("select"),
+          modelValue: require$$0.unref(value),
+          "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => require$$0.isRef(value) ? value.value = $event : null)
+        }, require$$0.unref(attrs).assem, {
+          multiple: require$$0.unref(multiple),
           placeholder: placeholder.value
         }), {
-          default: vue.withCtx(() => [
-            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(props.list, (item) => {
-              return vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElOption), {
-                label: vue.unref(common.setVueValue)(item, props.label),
-                value: vue.unref(common.setVueValue)(item, props.prop),
+          default: require$$0.withCtx(() => [
+            (require$$0.openBlock(true), require$$0.createElementBlock(require$$0.Fragment, null, require$$0.renderList(props.options, (item) => {
+              return require$$0.openBlock(), require$$0.createBlock(require$$0.unref(elementPlus.ElOption), {
+                label: require$$0.unref(use.useVueValue)(item, props.label),
+                value: require$$0.unref(use.useVueValue)(item, props.prop),
                 disabled: item == null ? void 0 : item.disabled
               }, null, 8, ["label", "value", "disabled"]);
             }), 256))
           ]),
           _: 1
-        }, 16, ["modelValue", "multiple", "placeholder"])), [
-          [vue.unref(index$2.default)]
+        }, 16, ["class", "modelValue", "multiple", "placeholder"])), [
+          [require$$0.unref(index$2.default), {}]
         ])
-      ], 2);
+      ], 16);
     };
   }
 });

package/dist/components/selects/src/index.d.ts

@@ -2,12 +2,12 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
     placeholder: {
         type: StringConstructor;
     };
-    list: {
+    options: {
         type: {
-            (arrayLength: number): import('../../../types/object').ObjAny[];
-            (...items: import('../../../types/object').ObjAny[]): import('../../../types/object').ObjAny[];
-            new (arrayLength: number): import('../../../types/object').ObjAny[];
-            new (...items: import('../../../types/object').ObjAny[]): import('../../../types/object').ObjAny[];
+            (arrayLength: number): ObjAny[];
+            (...items: ObjAny[]): ObjAny[];
+            new (arrayLength: number): ObjAny[];
+            new (...items: ObjAny[]): ObjAny[];
             isArray(arg: any): arg is any[];
             readonly prototype: any[];
             from<T>(arrayLike: ArrayLike<T>): T[];
@@ -21,12 +21,15 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
         };
         default(): never[];
     };
+    clearAbsent: {
+        type: BooleanConstructor;
+    };
     label: {
-        type: (StringConstructor | FunctionConstructor)[];
+        type: (FunctionConstructor | StringConstructor)[];
         default: string;
     };
     prop: {
-        type: (StringConstructor | FunctionConstructor)[];
+        type: (FunctionConstructor | StringConstructor)[];
         default: string;
     };
     modelValue: {
@@ -35,16 +38,24 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
     multiple: {
         type: (BooleanConstructor | StringConstructor)[];
     };
-}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    load: {
+        type: BooleanConstructor[];
+    };
+    optobj: {
+        type: BooleanConstructor[];
+    };
+}>, {
+    el: import('vue').Ref<any, any>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
     placeholder: {
         type: StringConstructor;
     };
-    list: {
+    options: {
         type: {
-            (arrayLength: number): import('../../../types/object').ObjAny[];
-            (...items: import('../../../types/object').ObjAny[]): import('../../../types/object').ObjAny[];
-            new (arrayLength: number): import('../../../types/object').ObjAny[];
-            new (...items: import('../../../types/object').ObjAny[]): import('../../../types/object').ObjAny[];
+            (arrayLength: number): ObjAny[];
+            (...items: ObjAny[]): ObjAny[];
+            new (arrayLength: number): ObjAny[];
+            new (...items: ObjAny[]): ObjAny[];
             isArray(arg: any): arg is any[];
             readonly prototype: any[];
             from<T>(arrayLike: ArrayLike<T>): T[];
@@ -58,12 +69,15 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
         };
         default(): never[];
     };
+    clearAbsent: {
+        type: BooleanConstructor;
+    };
     label: {
-        type: (StringConstructor | FunctionConstructor)[];
+        type: (FunctionConstructor | StringConstructor)[];
         default: string;
     };
     prop: {
-        type: (StringConstructor | FunctionConstructor)[];
+        type: (FunctionConstructor | StringConstructor)[];
         default: string;
     };
     modelValue: {
@@ -72,9 +86,18 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
     multiple: {
         type: (BooleanConstructor | StringConstructor)[];
     };
+    load: {
+        type: BooleanConstructor[];
+    };
+    optobj: {
+        type: BooleanConstructor[];
+    };
 }>> & Readonly<{}>, {
     label: string | Function;
-    list: import('../../../types/object').ObjAny[];
+    options: ObjAny[];
     prop: string | Function;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+    clearAbsent: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    refEl: HTMLDivElement;
+}, any>;
 export default _default;

package/dist/components/selects/src/index.js

@@ -1,21 +1,23 @@
-import { defineComponent, computed, createElementBlock, openBlock, normalizeClass, unref, withDirectives, createBlock, mergeProps, isRef, withCtx, Fragment, renderList } from "vue";
+import { defineComponent, ref, useAttrs, computed, createElementBlock, openBlock, mergeProps, unref, withDirectives, createBlock, isRef, withCtx, Fragment, renderList } from "vue";
+import vExpose from "../../../directives/expose/index.js";
 import { ElSelect, ElOption } from "element-plus";
-import { setVueValue } from "../../../utils/vues/common.js";
+import { useInherit } from "../../../hooks/inherit/index.js";
+import { useVueValue } from "../../common/use.js";
 import { useCssName } from "../../../hooks/cssname/index.js";
-import { useLocale } from "../../../hooks/locale/index.js";
 import { dataEmits, dataProps, dataHandle } from "./data.js";
-import vExpose from "../../../directives/expose/index.js";
 const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{ inheritAttrs: false },
   __name: "index",
   props: dataProps,
   emits: dataEmits,
-  setup(__props, { emit: __emit }) {
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const refEl = ref();
+    const attrs = useInherit(useAttrs());
     const cs = useCssName("selects");
-    const { getLocale } = useLocale();
     const props = __props;
     const placeholder = computed(() => {
       if (typeof props.placeholder == "undefined") {
-        return getLocale("form.select");
+        return "请选择";
       } else {
         return props.placeholder;
       }
@@ -24,31 +26,38 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     const listFuObj = dataHandle(props, emit);
     const value = listFuObj.value;
     const multiple = listFuObj.multiple;
+    __expose({
+      el: refEl
+    });
     return (_ctx, _cache) => {
-      return openBlock(), createElementBlock("div", {
-        class: normalizeClass(unref(cs).z())
-      }, [
+      return openBlock(), createElementBlock("div", mergeProps({
+        ref_key: "refEl",
+        ref: refEl
+      }, unref(attrs).root, {
+        class: unref(cs).z()
+      }), [
         withDirectives((openBlock(), createBlock(unref(ElSelect), mergeProps({
+          class: unref(cs).z("select"),
           modelValue: unref(value),
           "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => isRef(value) ? value.value = $event : null)
-        }, _ctx.$attrs, {
+        }, unref(attrs).assem, {
           multiple: unref(multiple),
           placeholder: placeholder.value
         }), {
           default: withCtx(() => [
-            (openBlock(true), createElementBlock(Fragment, null, renderList(props.list, (item) => {
+            (openBlock(true), createElementBlock(Fragment, null, renderList(props.options, (item) => {
               return openBlock(), createBlock(unref(ElOption), {
-                label: unref(setVueValue)(item, props.label),
-                value: unref(setVueValue)(item, props.prop),
+                label: unref(useVueValue)(item, props.label),
+                value: unref(useVueValue)(item, props.prop),
                 disabled: item == null ? void 0 : item.disabled
               }, null, 8, ["label", "value", "disabled"]);
             }), 256))
           ]),
           _: 1
-        }, 16, ["modelValue", "multiple", "placeholder"])), [
-          [unref(vExpose)]
+        }, 16, ["class", "modelValue", "multiple", "placeholder"])), [
+          [unref(vExpose), {}]
         ])
-      ], 2);
+      ], 16);
     };
   }
 });

package/dist/components/slider/index.cjs

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const withInstall = require("../../utils/vues/withInstall.cjs");
+const index_vue_vue_type_script_setup_true_lang = require("./src/index.cjs");
+const Slider = withInstall.withInstall(index_vue_vue_type_script_setup_true_lang.default, "Slider");
+exports.Slider = Slider;
+exports.default = Slider;