rx-compo 1.0.55 → 1.0.56

package/es/components/RxButton/index.d.ts

@@ -1,4 +1,4 @@
 declare const RxButton: any;
 export { RxButton };
 export default RxButton;
-export type { RxButtonPropsType } from './src/RxButton';
+export type { RxButtonPropsType, RxButtonComponent } from './src/RxButton';

package/es/components/RxButton/index.js

@@ -1 +1 @@
-import{withInstall as t}from"rx-compo/es/utils/with-install";import{defineComponent as o,resolveComponent as e,openBlock as n,createBlock as r,mergeProps as s,withCtx as u,renderSlot as p}from"vue";import{ElButton as l}from"element-plus";var a=o({name:"RxButton",components:{ElButton:l},props:{type:String},setup:()=>({})});a.render=function(t,o,l,a,m,c){const i=e("el-button");return n(),r(i,s({...t.$attrs,...t.$props},{class:"rx-button"}),{default:u((()=>[p(t.$slots,"default")])),_:3},16)},a.__file="packages/components/RxButton/src/RxButton.vue";const m=t(a);export{m as RxButton,m as default};
+import{withInstall as t}from"rx-compo/es/utils/with-install";import{defineComponent as o,resolveComponent as e,openBlock as r,createBlock as n,mergeProps as s,withCtx as u,renderSlot as p}from"vue";import{IxPropTypes as l}from"rx-compo/es/utils";import{ElButton as m}from"element-plus";var c=o({name:"RxButton",components:{ElButton:m},props:{type:String,fuck:l.oneOf(["circle","round"])},setup:()=>({})});c.render=function(t,o,l,m,c,i){const a=e("el-button");return r(),n(a,s({...t.$attrs,...t.$props},{class:"rx-button"}),{default:u((()=>[p(t.$slots,"default")])),_:3},16)},c.__file="packages/components/RxButton/src/RxButton.vue";const i=t(c);export{i as RxButton,i as default};

package/es/components/RxButton/src/RxButton.d.ts

@@ -1,8 +1,11 @@
-import type { ExtractPropTypes, PropType } from 'vue';
+import type { DefineComponent, ExtractPropTypes, PropType } from 'vue';
 import { ButtonInstance } from 'element-plus';
-declare type butonType = Omit<ButtonInstance['$props'], 'type'>;
+export declare type butonType = Partial<Omit<ButtonInstance['$props'], 'type'>>;
+export declare type DateShape = 'circle' | 'round';
 export declare const RxButtonProps: {
     type: PropType<"primary" | "danger">;
+    fuck: import("vue-types").VueTypeDef<DateShape>;
 };
 export declare type RxButtonPropsType = ExtractPropTypes<typeof RxButtonProps & butonType>;
-export {};
+export declare type RxButtonComponent = DefineComponent<typeof RxButtonProps>;
+export declare type RxButtonInstance = InstanceType<DefineComponent<typeof RxButtonProps>>;

package/es/components/RxButton/src/RxButton.vue.d.ts

@@ -1,6 +1,8 @@
 declare const _default: import("vue").DefineComponent<{
     type: import("vue").PropType<"primary" | "danger">;
+    fuck: import("vue-types").VueTypeDef<import("./RxButton").DateShape>;
 }, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
     type: import("vue").PropType<"primary" | "danger">;
+    fuck: import("vue-types").VueTypeDef<import("./RxButton").DateShape>;
 }>>, {}>;
 export default _default;

package/es/components/RxCheckbox/index.d.ts

@@ -0,0 +1,4 @@
+declare const RxCheckbox: any;
+export { RxCheckbox };
+export default RxCheckbox;
+export type { RxCheckboxPropsType, RxCheckboxComponent } from './src/RxCheckbox';

package/es/components/RxCheckbox/index.js

@@ -0,0 +1 @@
+import{withInstall as e}from"rx-compo/es/utils/with-install";import{defineComponent as o,resolveComponent as s,openBlock as l,createBlock as t,mergeProps as a,createSlots as r,withCtx as u,renderSlot as m}from"vue";import{IxPropTypes as c}from"rx-compo/es/utils";import{ElCheckbox as p}from"element-plus";import{useVModel as n}from"@vueuse/core";var f=o({name:"RxCheckbox",components:{ElCheckbox:p},props:{value:c.bool.def(!1)},setup:(e,{emit:o})=>({valuePass:n(e,"value",o)})});f.render=function(e,o,c,p,n,f){const i=s("el-checkbox");return l(),t(i,a({...e.$attrs,...e.$props},{modelValue:e.valuePass,"onUpdate:modelValue":o[0]||(o[0]=o=>e.valuePass=o),class:"rx-checkbox"}),r({_:2},[e.$slots.default?{name:"default",fn:u((()=>[m(e.$slots,"default")]))}:void 0]),1040,["modelValue"])},f.__file="packages/components/RxCheckbox/src/RxCheckbox.vue";const i=e(f);export{i as RxCheckbox,i as default};

package/es/components/RxCheckbox/src/RxCheckbox.d.ts

@@ -0,0 +1,9 @@
+import type { ExtractPropTypes, DefineComponent } from 'vue';
+export declare const RxCheckboxProps: {
+    value: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    };
+};
+export declare type RxCheckboxPropsType = ExtractPropTypes<typeof RxCheckboxProps>;
+export declare type RxCheckboxComponent = DefineComponent<typeof RxCheckboxProps>;
+export declare type RxCheckboxInstance = InstanceType<DefineComponent<typeof RxCheckboxProps>>;

package/es/components/RxCheckbox/src/RxCheckbox.vue.d.ts

@@ -0,0 +1,14 @@
+declare const _default: import("vue").DefineComponent<{
+    value: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    };
+}, {
+    valuePass: import("vue").Ref<boolean> | import("vue").WritableComputedRef<boolean>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    value: import("vue-types").VueTypeValidableDef<boolean> & {
+        default: boolean;
+    };
+}>>, {
+    value: boolean;
+}>;
+export default _default;

package/es/components/RxDatePicker/index.d.ts

@@ -0,0 +1,4 @@
+declare const RxDatePicker: any;
+export { RxDatePicker };
+export default RxDatePicker;
+export type { RxDatePickerPropsType, RxDatePickerComponent } from './src/RxDatePicker';

package/es/components/RxDatePicker/index.js

@@ -0,0 +1 @@
+import{withInstall as e}from"rx-compo/es/utils/with-install";import{defineComponent as o,resolveComponent as l,openBlock as r,createBlock as t,withCtx as a,createVNode as m,mergeProps as i}from"vue";import{IxPropTypes as c}from"rx-compo/es/utils";import{useVModel as n}from"@vueuse/core";import{ElDatePicker as u,ElConfigProvider as s}from"element-plus";import p from"element-plus/dist/locale/zh-cn.mjs";var d=o({name:"RxDatePicker",components:{ElDatePicker:u,ElConfigProvider:s},props:{modelValue:c.string.def("")},setup:(e,{emit:o})=>({valueLocal:n(e,"modelValue",o),zhCn:p})});d.render=function(e,o,c,n,u,s){const p=l("el-date-picker"),d=l("el-config-provider");return r(),t(d,{locale:e.zhCn},{default:a((()=>[m(p,i({modelValue:e.valueLocal,"onUpdate:modelValue":o[0]||(o[0]=o=>e.valueLocal=o)},{...e.$attrs}),null,16,["modelValue"])])),_:1},8,["locale"])},d.__file="packages/components/RxDatePicker/src/RxDatePicker.vue";const f=e(d);export{f as RxDatePicker,f as default};

package/es/components/RxDatePicker/src/RxDatePicker.d.ts

@@ -0,0 +1,9 @@
+import type { ExtractPropTypes, DefineComponent } from 'vue';
+export declare const RxDatePickerProps: {
+    modelValue: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    };
+};
+export declare type RxDatePickerPropsType = ExtractPropTypes<typeof RxDatePickerProps>;
+export declare type RxDatePickerComponent = DefineComponent<typeof RxDatePickerProps>;
+export declare type RxDatePickerInstance = InstanceType<DefineComponent<typeof RxDatePickerProps>>;

package/es/components/RxInput/index.d.ts

@@ -0,0 +1,4 @@
+declare const RxInput: any;
+export { RxInput };
+export default RxInput;
+export type { RxInputPropsType, RxInputComponent } from './src/RxInput';

package/es/components/RxInput/index.js

@@ -0,0 +1 @@
+import{withInstall as t}from"rx-compo/es/utils/with-install";import{defineComponent as e,nextTick as l,resolveComponent as o,openBlock as a,createElementBlock as u,Fragment as n,createCommentVNode as r,createBlock as s,mergeProps as p,withCtx as i,renderSlot as d}from"vue";import{IxPropTypes as m}from"rx-compo/es/utils";import{useVModel as f}from"@vueuse/core";import{ElInput as c}from"element-plus";var v=e({name:"RxInput",components:{ElInput:c},props:{value:m.string.def(""),inputType:{type:String,default:"default"},totalOption:{type:Object,default:void 0}},setup(t,{emit:e}){const o=f(t,"value",e),{formmatterTotalInputValue:a,formatterTotalBlurForAddDecimal:u,checkPropsIsVaildWhenTotal:n}=function(t,e){return{formmatterTotalInputValue:function(e){const l=null==e?void 0:e.replace(/[^\d.]+|\.(?=.*\.|\s)/g,"");t.value=l},formatterTotalBlurForAddDecimal:function(){var l;t.value=function(t,e){const l=parseFloat(t);return isNaN(l)?t:l.toFixed(e)}(t.value,(null===(l=null==e?void 0:e.totalOption)||void 0===l?void 0:l.digit)||0)},checkPropsIsVaildWhenTotal:function(){var t;return void 0===(null==e?void 0:e.totalOption)||void 0===(null===(t=null==e?void 0:e.totalOption)||void 0===t?void 0:t.digit)&&void 0}}}(o,t);return l((()=>{if("total"===t.inputType)n()})),{valuePass:o,formmatterTotalInputValue:a,formatterTotalBlurForAddDecimal:u}}});v.render=function(t,e,l,m,f,c){const v=o("el-input");return a(),u(n,null,[r(" 默认input "),"default"==t.inputType?(a(),s(v,p({key:0,modelValue:t.valuePass,"onUpdate:modelValue":e[0]||(e[0]=e=>t.valuePass=e),class:"rx-input input-default"},t.$attrs,{clearable:""}),{default:i((()=>[d(t.$slots,"prefix"),d(t.$slots,"suffix"),d(t.$slots,"prepend"),d(t.$slots,"append")])),_:3},16,["modelValue"])):r("v-if",!0),r(" 数量input "),"total"==t.inputType?(a(),s(v,p({key:1,modelValue:t.valuePass,"onUpdate:modelValue":e[1]||(e[1]=e=>t.valuePass=e),class:"rx-input input-total",clearable:""},t.$attrs,{onInput:t.formmatterTotalInputValue,onBlur:t.formatterTotalBlurForAddDecimal}),{default:i((()=>[d(t.$slots,"prefix"),d(t.$slots,"suffix"),d(t.$slots,"prepend"),d(t.$slots,"append")])),_:3},16,["modelValue","onInput","onBlur"])):r("v-if",!0),r(" 金额input "),"money"==t.inputType?(a(),s(v,p({key:2,modelValue:t.valuePass,"onUpdate:modelValue":e[2]||(e[2]=e=>t.valuePass=e),class:"rx-input input-money",clearable:""},t.$attrs),{default:i((()=>[d(t.$slots,"prefix"),d(t.$slots,"suffix"),d(t.$slots,"prepend"),d(t.$slots,"append")])),_:3},16,["modelValue"])):r("v-if",!0)],64)},v.__file="packages/components/RxInput/src/RxInput.vue";const x=t(v);export{x as RxInput,x as default};

package/es/components/RxInput/src/RxInput.d.ts

@@ -0,0 +1,21 @@
+import type { ExtractPropTypes, PropType, DefineComponent } from 'vue';
+export declare type inputType = 'total' | 'money' | 'default';
+export declare type totalOption = {
+    digit: number;
+};
+export declare const RxInputProps: {
+    value: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    };
+    inputType: {
+        type: StringConstructor;
+        default: string;
+    };
+    totalOption: {
+        type: PropType<totalOption>;
+        default: any;
+    };
+};
+export declare type RxInputPropsType = ExtractPropTypes<typeof RxInputProps>;
+export declare type RxInputComponent = DefineComponent<typeof RxInputProps>;
+export declare type RxInputInstance = InstanceType<DefineComponent<typeof RxInputProps>>;

package/es/components/RxInput/src/RxInput.vue.d.ts

@@ -0,0 +1,34 @@
+declare const _default: import("vue").DefineComponent<{
+    value: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    };
+    inputType: {
+        type: StringConstructor;
+        default: string;
+    };
+    totalOption: {
+        type: import("vue").PropType<import("./RxInput").totalOption>;
+        default: any;
+    };
+}, {
+    valuePass: import("vue").Ref<string> | import("vue").WritableComputedRef<string>;
+    formmatterTotalInputValue: (str: string) => void;
+    formatterTotalBlurForAddDecimal: () => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    value: import("vue-types").VueTypeValidableDef<string> & {
+        default: string;
+    };
+    inputType: {
+        type: StringConstructor;
+        default: string;
+    };
+    totalOption: {
+        type: import("vue").PropType<import("./RxInput").totalOption>;
+        default: any;
+    };
+}>>, {
+    value: string;
+    inputType: string;
+    totalOption: import("./RxInput").totalOption;
+}>;
+export default _default;

package/es/components/RxInput/src/hooks/useTotalInput.d.ts

@@ -0,0 +1,6 @@
+import { Ref, WritableComputedRef } from 'vue';
+export declare function useTotalInput(valuePass: Ref<string | undefined> | WritableComputedRef<string | undefined>, props: any): {
+    formmatterTotalInputValue: (str: string) => void;
+    formatterTotalBlurForAddDecimal: () => void;
+    checkPropsIsVaildWhenTotal: () => boolean;
+};

package/es/components/RxOption/index.d.ts

@@ -0,0 +1,5 @@
+import { RxOptionPropsType } from './src/RxOption';
+declare const RxOption: any;
+export { RxOption };
+export type { RxOptionPropsType };
+export default RxOption;

package/es/components/RxOption/index.js

@@ -0,0 +1 @@
+import{withInstall as t}from"rx-compo/es/utils/with-install";import{defineComponent as o,resolveComponent as e,openBlock as n,createBlock as p,mergeProps as s,withCtx as r,renderSlot as i}from"vue";import{ElOption as l}from"element-plus";var a=o({name:"RxOption",components:{ElOption:l},props:{},setup:()=>({})});a.render=function(t,o,l,a,m,u){const c=e("el-option");return n(),p(c,s(t.$attrs,{class:"rx-option"}),{default:r((()=>[i(t.$slots,"default")])),_:3},16)},a.__file="packages/components/RxOption/src/RxOption.vue";const m=t(a);export{m as RxOption,m as default};

package/es/components/RxOption/src/RxOption.d.ts

@@ -0,0 +1,3 @@
+import type { ExtractPropTypes } from 'vue';
+export declare const RxOptionProps: any;
+export declare type RxOptionPropsType = ExtractPropTypes<typeof RxOptionProps>;

package/es/components/RxOption/src/RxOption.vue.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import("vue").DefineComponent<any, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<any>, {} | {
+    [x: string]: any;
+}>;
+export default _default;

package/es/components/RxScrollbar/index.d.ts

@@ -0,0 +1,3 @@
+declare const RxScrollbar: any;
+export { RxScrollbar };
+export default RxScrollbar;

package/es/components/RxScrollbar/index.js

@@ -0,0 +1 @@
+import{withInstall as r}from"rx-compo/es/utils/with-install";import{defineComponent as o,resolveComponent as l,openBlock as t,createBlock as e,normalizeProps as s,guardReactiveProps as a,withCtx as c,renderSlot as n}from"vue";import{ElScrollbar as p}from"element-plus";var m=o({name:"RxScrollbar",components:{ElScrollbar:p},props:{},setup:()=>({})});m.render=function(r,o,p,m,u,f){const i=l("el-scrollbar");return t(),e(i,s(a(r.$attrs)),{default:c((()=>[n(r.$slots,"default")])),_:3},16)},m.__file="packages/components/RxScrollbar/src/RxScrollbar.vue";const u=r(m);export{u as RxScrollbar,u as default};

package/es/components/RxScrollbar/src/RxScrollbar.d.ts

@@ -0,0 +1,3 @@
+import type { ExtractPropTypes } from 'vue';
+export declare const RxScrollbarProps: {};
+export declare type RxScrollbarPropsType = ExtractPropTypes<typeof RxScrollbarProps>;

package/es/components/RxScrollbar/src/RxScrollbar.vue.d.ts

@@ -0,0 +1,8 @@
+declare const _default: import("vue").DefineComponent<Readonly<import("vue").ComponentPropsOptions<{
+    [x: string]: unknown;
+}>>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, readonly string[] | Readonly<import("vue").ExtractPropTypes<Readonly<import("vue").ComponentObjectPropsOptions<{
+    [x: string]: unknown;
+}>>>>, {
+    [x: number]: string;
+} | {}>;
+export default _default;

package/es/components/RxSelect/index.d.ts

@@ -0,0 +1,6 @@
+import { RxSelectPropsType } from './src/RxSelect';
+import { RxSelectExpose } from './src/types';
+declare const RxSelect: any;
+export { RxSelect };
+export type { RxSelectPropsType, RxSelectExpose };
+export default RxSelect;

package/es/components/RxSelect/index.js

@@ -0,0 +1 @@
+import{withInstall as e}from"rx-compo/es/utils/with-install";import{ref as t,computed as o,unref as l,defineComponent as n,onMounted as r,resolveComponent as c,openBlock as s,createBlock as p,mergeProps as u,withCtx as i,renderSlot as a,createElementBlock as x,Fragment as f,renderList as S}from"vue";import{useVModel as m}from"@vueuse/core";import{ElSelect as d}from"element-plus";import{RxOption as g}from"rx-compo/es/components/RxOption";var R=n({name:"RxSelect",components:{ElSelect:d,RxOption:g},props:{modelValue:{type:[Array,String,Number,Boolean,Object],default:""},options:{type:Array,default:[]}},setup(e,{attrs:n,emit:c,expose:s}){const p=t(),u=m(e,"modelValue",c),{rxSelectDropDownClass:i,updateRxSelectDropDown:a,getRxSelectDropDownConfig:x}=function(e,o){const l=t("rx-select-drop-option");return{rxSelectDropDownClass:l,updateRxSelectDropDown:function(){const{popperClass:e}=o;l.value=e?`rx-select-drop-option ${e}`:"rx-select-drop-option"},getRxSelectDropDownConfig:function(){return l.value}}}(0,n),{rxSelectConfig:f,updateRxSelectPlusConfig:S,getRxSelectPlusConfig:d}=function(e,n){const r=t();return{rxSelectConfig:r,updateRxSelectPlusConfig:function(){r.value={popperClass:o((()=>l(n)))}},getRxSelectPlusConfig:function(){return Object.assign(Object.assign({},e),r.value)}}}(n,i);return r((()=>{!function(e,t){e(),t()}(a,S)})),s({rxSelectRef:p,updateRxSelectPlusConfig:S,updateRxSelectDropDown:a,getRxSelectPlusConfig:d,getRxSelectDropDownConfig:x}),{rxSelectRef:p,rxSelectConfig:f,rxSelectModelValue:u}}});R.render=function(e,t,o,l,n,r){const m=c("rx-option"),d=c("el-select");return s(),p(d,u({modelValue:e.rxSelectModelValue,"onUpdate:modelValue":t[0]||(t[0]=t=>e.rxSelectModelValue=t),class:"rx-select",ref:"rxSelectRef"},{...e.$attrs,...e.rxSelectConfig}),{default:i((()=>[e.$slots.default?a(e.$slots,"default",{key:0}):(s(!0),x(f,{key:1},S(e.options,((e,t)=>(s(),p(m,u({key:t},e),null,16)))),128))])),prefix:i((()=>[a(e.$slots,"prefix")])),empty:i((()=>[a(e.$slots,"empty")])),_:3},16,["modelValue"])},R.__file="packages/components/RxSelect/src/RxSelect.vue";const C=e(R);export{C as RxSelect,C as default};

package/es/components/RxSelect/src/RxSelect.d.ts

@@ -0,0 +1,14 @@
+import type { ExtractPropTypes, PropType } from 'vue';
+import type { RxOptionPropsType } from 'rx-compo/es/components';
+export type { RxSelectExpose } from './types';
+export declare const RxSelectProps: {
+    modelValue: {
+        type: (BooleanConstructor | StringConstructor | ObjectConstructor | NumberConstructor | ArrayConstructor)[];
+        default: string;
+    };
+    options: {
+        type: PropType<RxOptionPropsType[]>;
+        default: any[];
+    };
+};
+export declare type RxSelectPropsType = ExtractPropTypes<typeof RxSelectProps>;

package/es/components/RxSelect/src/RxSelect.vue.d.ts

@@ -0,0 +1,27 @@
+declare const _default: import("vue").DefineComponent<{
+    modelValue: {
+        type: (BooleanConstructor | StringConstructor | ObjectConstructor | NumberConstructor | ArrayConstructor)[];
+        default: string;
+    };
+    options: {
+        type: import("vue").PropType<import("rx-compo/es/components/RxOption").RxOptionPropsType[]>;
+        default: any[];
+    };
+}, {
+    rxSelectRef: import("vue").Ref<any>;
+    rxSelectConfig: import("vue").Ref<any>;
+    rxSelectModelValue: import("vue").Ref<string | number | boolean | unknown[] | Record<string, any>> | import("vue").WritableComputedRef<string | number | boolean | unknown[] | Record<string, any>>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: (BooleanConstructor | StringConstructor | ObjectConstructor | NumberConstructor | ArrayConstructor)[];
+        default: string;
+    };
+    options: {
+        type: import("vue").PropType<import("rx-compo/es/components/RxOption").RxOptionPropsType[]>;
+        default: any[];
+    };
+}>>, {
+    modelValue: string | number | boolean | unknown[] | Record<string, any>;
+    options: import("rx-compo/es/components/RxOption").RxOptionPropsType[];
+}>;
+export default _default;

package/es/components/RxSelect/src/hooks/useController.d.ts

@@ -0,0 +1 @@
+export declare function useController(updateRxSelectDropDown: Function, updateRxSelectPlusConfig: Function): {};

package/es/components/RxSelect/src/hooks/useOptionClass.d.ts

@@ -0,0 +1,6 @@
+import { RxSelectPropsType } from '../RxSelect';
+export declare function useOptionClass(props: RxSelectPropsType, attrs: any): {
+    rxSelectDropDownClass: import("vue").Ref<string>;
+    updateRxSelectDropDown: () => void;
+    getRxSelectDropDownConfig: () => string;
+};

package/es/components/RxSelect/src/hooks/useRxSelect.d.ts

@@ -0,0 +1,6 @@
+import { Ref } from 'vue';
+export declare function useRxSelect(attrs: any, rxSelectDropDownClass: Ref<string>): {
+    rxSelectConfig: Ref<any>;
+    updateRxSelectPlusConfig: () => void;
+    getRxSelectPlusConfig: () => any;
+};

package/es/components/RxSelectPlus/index.d.ts

@@ -0,0 +1,6 @@
+import { RxSelectPlusExpose } from './src/types';
+declare const RxSelectPlus: any;
+export { RxSelectPlus };
+export type { RxSelectPlusExpose };
+export default RxSelectPlus;
+export type { RxSelectPlusPropsType, RxSelectPlusComponent } from './src/RxSelectPlus';

package/es/components/RxSelectPlus/index.js

@@ -0,0 +1 @@
+import{withInstall as e}from"rx-compo/es/utils/with-install";import{computed as o,ref as t,watch as l,nextTick as n,defineComponent as s,onMounted as r,resolveComponent as i,openBlock as u,createElementBlock as c,mergeProps as a,createBlock as p,normalizeProps as x,withCtx as f,createVNode as m,createSlots as d,renderList as T,renderSlot as g,guardReactiveProps as S,createCommentVNode as v,normalizeStyle as R,createTextVNode as h,toDisplayString as C}from"vue";import{useVModel as y}from"@vueuse/core";import{RxScrollbar as P}from"rx-compo/es/components/RxScrollbar";import{RxTooltip as M}from"rx-compo/es/components/RxTooltip";import{RxSelect as V}from"rx-compo/es/components/RxSelect";import{useTextOverflow as w}from"rx-compo/es/utils/useTextOverflow";import{find as O}from"lodash";var b=s({name:"RxSelectPlus",components:{RxSelect:V,RxScrollbar:P,RxTooltip:M},props:{modelValue:{type:[Array,String,Number,Boolean,Object],default:""},toolTip:{type:Boolean,default:!0},toolTipConfig:{type:Object,default:{placement:"top"}},options:{type:Array,default:[]}},setup(e,{attrs:s,slots:i,emit:u,expose:c}){const a=t(),p=t(),x=y(e,"modelValue",u),{isOverflowed:f,componentsSwitch:m,handleMouseenter:d}=function(e){const{isOverflowed:t,checkOverflowCustom:l}=w("RxSelectPlus"),n=o((()=>e.toolTip&&t.value));return{isOverflowed:t,componentsSwitch:n,handleMouseenter:function(e){l(e.target)}}}(e),{rxToolTipConfig:T,updateRxToolTipConfig:g,getRxToolTipConfig:S}=function(e,o,l){const n=t();return{rxToolTipConfig:n,updateRxToolTipConfig:function(){var o;const{toolTipConfig:s,options:r,modelValue:i}=e,{width:u}=l.value.getBoundingClientRect(),c={width:`${u}px`,maxHeight:(null==s?void 0:s.maxHeight)?s.maxHeight:"80px"},a=t();if(null==s?void 0:s.content){const{content:e}=s;a.value=e}else a.value=null===(o=O(r,(e=>e.value===i)))||void 0===o?void 0:o.label;n.value=Object.assign(Object.assign({},s),{style:c,content:a.value})},getRxToolTipConfig:function(){return n.value}}}(e,0,a),v=Object.keys(i);return r((()=>{!function(e,o){l((()=>e.value),(()=>{n((()=>{o()}))}),{deep:!0,immediate:!0})}(x,g)})),c({rxSelectPlusRef:a,rxSelectRef:p,updateRxToolTipConfig:g,getRxToolTipConfig:S}),{rxSelectPlusRef:a,rxSelectRef:p,rxToolTipConfig:T,isOverflowed:f,rxSelectModelPlusValue:x,componentsSwitch:m,selectPlusSlots:v,handleMouseenter:d}}});b.render=function(e,o,t,l,n,s){const r=i("rx-select"),y=i("rx-scrollbar"),P=i("rx-tooltip");return u(),c("div",a({ref:"rxSelectPlusRef"},e.$attrs),[e.componentsSwitch?(u(),p(P,x(a({key:0},e.rxToolTipConfig)),{default:f((()=>[m(r,a({modelValue:e.rxSelectModelPlusValue,"onUpdate:modelValue":o[0]||(o[0]=o=>e.rxSelectModelPlusValue=o),class:"rx-select",ref:"rxSelectRef"},e.$attrs,{options:e.options,onMouseenter:e.handleMouseenter}),d({_:2},[T(e.selectPlusSlots,(o=>({name:o,fn:f((t=>[g(e.$slots,`${o}`,x(S(t)))]))})))]),1040,["modelValue","options","onMouseenter"])])),content:f((()=>[v(" 自定义tooltip "),e.$slots.rxToolTipSlot?g(e.$slots,"rxToolTipSlot",{key:0}):(u(),c("div",{key:1,style:R(e.rxToolTipConfig.style)},[v(" 默认模板 "),m(y,{"max-height":e.rxToolTipConfig.style.maxHeight},{default:f((()=>[h(C(e.rxToolTipConfig?.content),1)])),_:1},8,["max-height"])],4))])),_:3},16)):(u(),p(r,a({key:1,modelValue:e.rxSelectModelPlusValue,"onUpdate:modelValue":o[1]||(o[1]=o=>e.rxSelectModelPlusValue=o)},e.$attrs,{ref:"rxSelectRef",class:"rx-select",options:e.options,onMouseenter:e.handleMouseenter}),d({_:2},[T(e.selectPlusSlots,(o=>({name:o,fn:f((t=>[g(e.$slots,`${o}`,x(S(t)))]))})))]),1040,["modelValue","options","onMouseenter"]))],16)},b.__file="packages/components/RxSelectPlus/src/RxSelectPlus.vue";const $=e(b);export{$ as RxSelectPlus,$ as default};

package/es/components/RxSelectPlus/src/RxSelectPlus.d.ts

@@ -0,0 +1,252 @@
+import type { ExtractPropTypes, PropType, DefineComponent } from 'vue';
+import type { RxOptionPropsType } from 'rx-compo/es/components';
+import { ScrollbarMaxHeight } from './types';
+export type { RxSelectPlusExpose } from './types';
+export declare type SelectType = ExtractPropTypes<Array<any> & String>;
+export declare const RxSelectPlusProps: {
+    modelValue: {
+        type: (BooleanConstructor | StringConstructor | ObjectConstructor | NumberConstructor | ArrayConstructor)[];
+        default: string;
+    };
+    toolTip: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    toolTipConfig: {
+        type: PropType<{} & {
+            readonly disabled?: boolean;
+            readonly onClick?: Function;
+            readonly style?: import("vue").StyleValue;
+            readonly id?: string;
+            readonly popperClass?: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | any[] | {
+                [x: string]: boolean;
+            })[])[])[])[])[])[])[])[])[])[]) & {}) | (() => string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | any[] | {
+                [x: string]: boolean;
+            })[])[])[])[])[])[])[])[])[])[]) | ((new (...args: any[]) => (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | any[] | {
+                [x: string]: boolean;
+            })[])[])[])[])[])[])[])[])[])[]) & {}) | (() => string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | any[] | {
+                [x: string]: boolean;
+            })[])[])[])[])[])[])[])[])[])[]))[], unknown, unknown>;
+            readonly popperOptions?: unknown;
+            readonly placement?: import("element-plus/es/utils").EpPropMergeType<StringConstructor, import("element-plus").Placement, unknown>;
+            readonly strategy?: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "fixed" | "absolute", unknown>;
+            readonly zIndex?: number;
+            readonly onFocus?: Function;
+            readonly onBlur?: Function;
+            readonly onMouseleave?: Function;
+            readonly onMouseenter?: Function;
+            readonly onKeydown?: Function;
+            readonly visible?: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => boolean & {}) | (() => boolean) | ((new (...args: any[]) => boolean & {}) | (() => boolean))[], unknown, unknown>;
+            readonly effect?: string;
+            readonly teleported?: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly persistent?: boolean;
+            openDelay?: number;
+            visibleArrow?: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly hideAfter?: number;
+            showArrow?: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly appendTo?: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement) | ((new (...args: any[]) => (string | HTMLElement) & {}) | (() => string | HTMLElement))[], unknown, unknown>;
+            readonly content?: string;
+            readonly rawContent?: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly ariaLabel?: string;
+            readonly transition?: string;
+            readonly className?: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | any[] | {
+                [x: string]: boolean;
+            })[])[])[])[])[])[])[])[])[])[]) & {}) | (() => string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | any[] | {
+                [x: string]: boolean;
+            })[])[])[])[])[])[])[])[])[])[]) | ((new (...args: any[]) => (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | any[] | {
+                [x: string]: boolean;
+            })[])[])[])[])[])[])[])[])[])[]) & {}) | (() => string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | any[] | {
+                [x: string]: boolean;
+            })[])[])[])[])[])[])[])[])[])[]))[], unknown, unknown>;
+            readonly enterable?: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly pure?: boolean;
+            readonly focusOnShow?: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly trapping?: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly popperStyle?: import("vue").StyleValue;
+            readonly referenceEl?: HTMLElement;
+            readonly triggerTargetEl?: HTMLElement;
+            readonly stopPopperMouseEvent?: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly virtualTriggering?: boolean;
+            readonly boundariesPadding?: number;
+            readonly fallbackPlacements?: import("element-plus").Placement;
+            readonly gpuAcceleration?: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly offset?: number;
+            readonly showAfter?: number;
+            readonly trigger?: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => ("focus" | "hover" | "click" | "contextmenu" | ("focus" | "hover" | "click" | "contextmenu")[]) & {}) | (() => "focus" | "hover" | "click" | "contextmenu" | ("focus" | "hover" | "click" | "contextmenu")[]) | ((new (...args: any[]) => ("focus" | "hover" | "click" | "contextmenu" | ("focus" | "hover" | "click" | "contextmenu")[]) & {}) | (() => "focus" | "hover" | "click" | "contextmenu" | ("focus" | "hover" | "click" | "contextmenu")[]))[], unknown, unknown>;
+            readonly triggerKeys?: string;
+            readonly virtualRef?: import("element-plus").Measurable;
+            readonly onContextmenu?: Function;
+            readonly open?: boolean;
+        } & ScrollbarMaxHeight>;
+        default: {
+            placement: string;
+        };
+    };
+    options: {
+        type: PropType<RxOptionPropsType[]>;
+        default: any[];
+    };
+};
+export declare type RxSelectPlusPropsType = ExtractPropTypes<typeof RxSelectPlusProps>;
+export declare type RxSelectPlusComponent = DefineComponent<typeof RxSelectPlusProps>;
+export declare type RxSelectPlusInstance = InstanceType<DefineComponent<typeof RxSelectPlusProps>>;