rx-compo 1.0.53 → 1.0.55

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

@@ -0,0 +1,8 @@
+import type { ExtractPropTypes, PropType } from 'vue';
+import { ButtonInstance } from 'element-plus';
+declare type butonType = Omit<ButtonInstance['$props'], 'type'>;
+export declare const RxButtonProps: {
+    type: PropType<"primary" | "danger">;
+};
+export declare type RxButtonPropsType = ExtractPropTypes<typeof RxButtonProps & butonType>;
+export {};

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

@@ -0,0 +1,6 @@
+declare const _default: import("vue").DefineComponent<{
+    type: import("vue").PropType<"primary" | "danger">;
+}, {}, 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">;
+}>>, {}>;
+export default _default;

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

@@ -0,0 +1,4 @@
+declare const QiDate: any;
+export { QiDate };
+export default QiDate;
+export type { DateInstance, DateComponent, DatePublicProps as DateProps } from './src/date';

package/es/components/date/index.js

@@ -0,0 +1 @@
+import{withInstall as o}from"rx-compo/es/utils/with-install";import{defineComponent as e,openBlock as t,createElementBlock as r,toDisplayString as n}from"vue";import{IxPropTypes as s}from"rx-compo/es/utils";import i from"moment";var l=e({name:"QiDate",props:{mode:s.oneOf(["primary","default","dashed","text","link"]),danger:s.bool,ghost:s.bool,disabled:s.bool,loading:s.bool,size:s.oneOf(["lg","xl","md","sm","xs"]),shape:s.oneOf(["circle","round"]),block:s.bool,icon:s.string,type:s.oneOf(["button","submit","reset"]).def("button")},setup:o=>({now:i().format("LLLL")})});const m={class:"w-[100px] h-[100px] bg-red-500"};l.render=function(o,e,s,i,l,a){return t(),r("div",m,n(o.now),1)},l.__file="packages/components/date/src/date.vue";const a=o(l);export{a as QiDate,a as default};

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

@@ -0,0 +1,24 @@
+import type { ExtractInnerPropTypes, ExtractPublicPropTypes } from 'rx-compo/es/utils';
+import type { AnchorHTMLAttributes, ButtonHTMLAttributes, DefineComponent } from 'vue';
+export declare type DateMode = 'primary' | 'default' | 'dashed' | 'text' | 'link';
+export declare type DateShape = 'circle' | 'round';
+export declare type DateSize = 'lg' | 'xl' | 'md' | 'sm' | 'xs';
+export declare type DateType = 'button' | 'submit' | 'reset';
+export declare const dateProps: {
+    mode: import("vue-types").VueTypeDef<DateMode>;
+    danger: import("vue-types").VueTypeValidableDef<boolean>;
+    ghost: import("vue-types").VueTypeValidableDef<boolean>;
+    disabled: import("vue-types").VueTypeValidableDef<boolean>;
+    loading: import("vue-types").VueTypeValidableDef<boolean>;
+    size: import("vue-types").VueTypeDef<DateSize>;
+    shape: import("vue-types").VueTypeDef<DateShape>;
+    block: import("vue-types").VueTypeValidableDef<boolean>;
+    icon: import("vue-types").VueTypeValidableDef<string>;
+    type: import("vue-types").VueTypeDef<DateType> & {
+        default: DateType;
+    };
+};
+export declare type DateProps = ExtractInnerPropTypes<typeof dateProps>;
+export declare type DatePublicProps = ExtractPublicPropTypes<typeof dateProps>;
+export declare type DateComponent = DefineComponent<Omit<ButtonHTMLAttributes | AnchorHTMLAttributes, keyof DatePublicProps> & DatePublicProps>;
+export declare type DateInstance = InstanceType<DefineComponent<DateProps>>;

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

@@ -0,0 +1,32 @@
+declare const _default: import("vue").DefineComponent<{
+    mode: import("vue-types").VueTypeDef<import("./date").DateMode>;
+    danger: import("vue-types").VueTypeValidableDef<boolean>;
+    ghost: import("vue-types").VueTypeValidableDef<boolean>;
+    disabled: import("vue-types").VueTypeValidableDef<boolean>;
+    loading: import("vue-types").VueTypeValidableDef<boolean>;
+    size: import("vue-types").VueTypeDef<import("./date").DateSize>;
+    shape: import("vue-types").VueTypeDef<import("./date").DateShape>;
+    block: import("vue-types").VueTypeValidableDef<boolean>;
+    icon: import("vue-types").VueTypeValidableDef<string>;
+    type: import("vue-types").VueTypeDef<import("./date").DateType> & {
+        default: import("./date").DateType;
+    };
+}, {
+    now: string;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    mode: import("vue-types").VueTypeDef<import("./date").DateMode>;
+    danger: import("vue-types").VueTypeValidableDef<boolean>;
+    ghost: import("vue-types").VueTypeValidableDef<boolean>;
+    disabled: import("vue-types").VueTypeValidableDef<boolean>;
+    loading: import("vue-types").VueTypeValidableDef<boolean>;
+    size: import("vue-types").VueTypeDef<import("./date").DateSize>;
+    shape: import("vue-types").VueTypeDef<import("./date").DateShape>;
+    block: import("vue-types").VueTypeValidableDef<boolean>;
+    icon: import("vue-types").VueTypeValidableDef<string>;
+    type: import("vue-types").VueTypeDef<import("./date").DateType> & {
+        default: import("./date").DateType;
+    };
+}>>, {
+    type: import("./date").DateType;
+}>;
+export default _default;

package/es/components/icon/index.css

@@ -0,0 +1 @@
+.qi-icon{border:1px solid #000;border-radius:15px;margin:5px;padding:5px}

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

@@ -0,0 +1,4 @@
+declare const QiIcon: any;
+export { QiIcon };
+export default QiIcon;
+export type { IconInstance, IconComponent, IconPublicProps as IconProps } from './src/icon';

package/es/components/icon/index.js

@@ -0,0 +1 @@
+import{withInstall as o}from"rx-compo/es/utils/with-install";import{defineComponent as e,computed as s,openBlock as t,createElementBlock as i,normalizeStyle as l,renderSlot as n}from"vue";import{IxPropTypes as r}from"rx-compo/es/utils";var c=e({name:"QiIcon",props:{color:r.string,mode:r.oneOf(["primary","default","dashed","text","link"]),danger:r.bool,ghost:r.bool,disabled:r.bool,loading:r.bool,size:r.oneOf(["lg","xl","md","sm","xs"]),shape:r.oneOf(["circle","round"]),block:r.bool,icon:r.string,type:r.oneOf(["button","submit","reset"]).def("button")},setup:o=>({style:s((()=>o.size||o.color?Object.assign(Object.assign({},o.size?{"font-size":o.size+"px"}:{}),o.color?{color:o.color}:{}):{}))})});c.render=function(o,e,s,r,c,a){return t(),i("i",{class:"qi-icon",style:l(o.style)},[n(o.$slots,"default")],4)},c.__file="packages/components/icon/src/icon.vue";const a=o(c);export{a as QiIcon,a as default};

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

@@ -0,0 +1,25 @@
+import type { ExtractInnerPropTypes, ExtractPublicPropTypes } from 'rx-compo/es/utils';
+import type { AnchorHTMLAttributes, ButtonHTMLAttributes, DefineComponent } from 'vue';
+export declare type IconMode = 'primary' | 'default' | 'dashed' | 'text' | 'link';
+export declare type IconShape = 'circle' | 'round';
+export declare type IconSize = 'lg' | 'xl' | 'md' | 'sm' | 'xs';
+export declare type IconType = 'button' | 'submit' | 'reset';
+export declare const iconProps: {
+    color: import("vue-types").VueTypeValidableDef<string>;
+    mode: import("vue-types").VueTypeDef<IconMode>;
+    danger: import("vue-types").VueTypeValidableDef<boolean>;
+    ghost: import("vue-types").VueTypeValidableDef<boolean>;
+    disabled: import("vue-types").VueTypeValidableDef<boolean>;
+    loading: import("vue-types").VueTypeValidableDef<boolean>;
+    size: import("vue-types").VueTypeDef<IconSize>;
+    shape: import("vue-types").VueTypeDef<IconShape>;
+    block: import("vue-types").VueTypeValidableDef<boolean>;
+    icon: import("vue-types").VueTypeValidableDef<string>;
+    type: import("vue-types").VueTypeDef<IconType> & {
+        default: IconType;
+    };
+};
+export declare type IconProps = ExtractInnerPropTypes<typeof iconProps>;
+export declare type IconPublicProps = ExtractPublicPropTypes<typeof iconProps>;
+export declare type IconComponent = DefineComponent<Omit<ButtonHTMLAttributes | AnchorHTMLAttributes, keyof IconPublicProps> & IconPublicProps>;
+export declare type IconInstance = InstanceType<DefineComponent<IconProps>>;

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

@@ -0,0 +1,37 @@
+declare const _default: import("vue").DefineComponent<{
+    color: import("vue-types").VueTypeValidableDef<string>;
+    mode: import("vue-types").VueTypeDef<import("./icon").IconMode>;
+    danger: import("vue-types").VueTypeValidableDef<boolean>;
+    ghost: import("vue-types").VueTypeValidableDef<boolean>;
+    disabled: import("vue-types").VueTypeValidableDef<boolean>;
+    loading: import("vue-types").VueTypeValidableDef<boolean>;
+    size: import("vue-types").VueTypeDef<import("./icon").IconSize>;
+    shape: import("vue-types").VueTypeDef<import("./icon").IconShape>;
+    block: import("vue-types").VueTypeValidableDef<boolean>;
+    icon: import("vue-types").VueTypeValidableDef<string>;
+    type: import("vue-types").VueTypeDef<import("./icon").IconType> & {
+        default: import("./icon").IconType;
+    };
+}, {
+    style: import("vue").ComputedRef<{
+        color?: string;
+        'font-size'?: string;
+    }>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    color: import("vue-types").VueTypeValidableDef<string>;
+    mode: import("vue-types").VueTypeDef<import("./icon").IconMode>;
+    danger: import("vue-types").VueTypeValidableDef<boolean>;
+    ghost: import("vue-types").VueTypeValidableDef<boolean>;
+    disabled: import("vue-types").VueTypeValidableDef<boolean>;
+    loading: import("vue-types").VueTypeValidableDef<boolean>;
+    size: import("vue-types").VueTypeDef<import("./icon").IconSize>;
+    shape: import("vue-types").VueTypeDef<import("./icon").IconShape>;
+    block: import("vue-types").VueTypeValidableDef<boolean>;
+    icon: import("vue-types").VueTypeValidableDef<string>;
+    type: import("vue-types").VueTypeDef<import("./icon").IconType> & {
+        default: import("./icon").IconType;
+    };
+}>>, {
+    type: import("./icon").IconType;
+}>;
+export default _default;

package/es/components/index.d.ts

@@ -1,2 +1,9 @@
-export * from './RxButton';
+import type { App } from 'vue';
+import 'element-plus/dist/index.css';
+declare const _default: {
+    install: (app: App<any>) => void;
+};
+export default _default;
+export * from './icon';
+export * from './date';
 export * from './RxButton';

package/es/components/index.js

@@ -1 +1 @@
-export * from './RxButton';
+import o from"element-plus";import"element-plus/dist/index.css";import*as e from"@element-plus/icons-vue";import t from"./icon";export*from"./icon";import r from"./date";export*from"./date";export*from"./RxButton";const m=[t,r];var n={install:function(t){m.forEach((o=>{t.component(o.name,o)})),t.use(o),Object.entries(e).forEach((([o,e])=>{t.component(o,e)}))}};export{n as default};

package/es/index.d.ts

@@ -1,7 +1,6 @@
-import type { App } from 'vue';
-import 'virtual:windi.css';
+import type { App } from "vue";
 declare const _default: {
     install: (app: App<any>) => void;
 };
 export default _default;
-export * from './components';
+export * from "rx-compo/es/components";

package/es/index.js

@@ -1,14 +1 @@
-import * as components from 'rx-compo/es/components';
-export * from 'rx-compo/es/components';
-import 'virtual:windi.css';
-
-const install = (app) => {
-    Object.entries(components).forEach(([name, component]) => {
-        app.component(name, component);
-    });
-};
-var index = {
-    install
-};
-
-export { index as default };
+import*as o from"rx-compo/es/components";export*from"rx-compo/es/components";import e from"element-plus";import*as t from"@element-plus/icons-vue";var r={install:r=>{Object.entries(o).forEach((([o,e])=>{r.component(o,e)})),r.use(e),Object.entries(t).forEach((([o,e])=>{r.component(o,e)}))}};export{r as default};

package/es/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './src/props';

package/es/utils/index.js

@@ -0,0 +1 @@
+export * from './src/props';

package/es/utils/src/props.d.ts

@@ -0,0 +1,74 @@
+import type { IfAny } from '@vue/shared';
+import type { Prop, VNode } from 'vue';
+import type { VueTypeDef, VueTypeValidableDef } from 'vue-types';
+import type { InferType, VueProp, Prop as VueTypeProp } from 'vue-types/dist/types';
+import { arrayOf, custom, instanceOf, objectOf, shape } from 'vue-types';
+export declare type MaybeArray<T> = T | T[];
+declare type PublicRequiredKeys<T> = {
+    [K in keyof T]: T[K] extends {
+        required: true;
+    } ? K : never;
+}[keyof T];
+declare type PublicOptionalKeys<T> = Exclude<keyof T, PublicRequiredKeys<T>>;
+declare type InnerRequiredKeys<T> = {
+    [K in keyof T]: T[K] extends {
+        required: true;
+    } | {
+        default: any;
+    } ? T[K] extends {
+        default: undefined;
+    } ? never : K : never;
+}[keyof T];
+declare type InnerOptionalKeys<T> = Exclude<keyof T, InnerRequiredKeys<T>>;
+declare type InferPropType<T> = [T] extends [null] ? any : [T] extends [{
+    type: null | true;
+}] ? any : [T] extends [ObjectConstructor | {
+    type: ObjectConstructor;
+}] ? Record<string, any> : [T] extends [BooleanConstructor | {
+    type: BooleanConstructor;
+}] ? boolean : [T] extends [DateConstructor | {
+    type: DateConstructor;
+}] ? Date : [T] extends [(infer U)[] | {
+    type: (infer U)[];
+}] ? U extends DateConstructor ? Date | InferPropType<U> : InferPropType<U> : [T] extends [Prop<infer V, infer D>] ? unknown extends V ? IfAny<V, V, D> : V : T;
+export declare type ExtractPublicPropTypes<O> = {
+    [K in keyof Pick<O, PublicRequiredKeys<O>>]: InferPropType<O[K]>;
+} & {
+    [K in keyof Pick<O, PublicOptionalKeys<O>>]?: InferPropType<O[K]>;
+};
+export declare type ExtractInnerPropTypes<O> = {
+    [K in keyof Pick<O, InnerRequiredKeys<O>>]: InferPropType<O[K]>;
+} & {
+    [K in keyof Pick<O, InnerOptionalKeys<O>>]?: InferPropType<O[K]>;
+};
+export declare class IxPropTypes {
+    static get any(): VueTypeValidableDef<any>;
+    static get bool(): VueTypeValidableDef<boolean>;
+    static get string(): VueTypeValidableDef<string>;
+    static get number(): VueTypeValidableDef<number>;
+    static get integer(): VueTypeValidableDef<number>;
+    static get symbol(): VueTypeDef<symbol>;
+    static custom: typeof custom;
+    static instanceOf: typeof instanceOf;
+    static arrayOf: typeof arrayOf;
+    static objectOf: typeof objectOf;
+    static shape: typeof shape;
+    static object<T>(): VueTypeValidableDef<T>;
+    static func<T extends (...args: any[]) => any>(): VueTypeValidableDef<T>;
+    static array<T>(): VueTypeValidableDef<T[]>;
+    static oneOfType<T>(arr: Array<VueProp<T> | VueTypeProp<T>>): VueTypeDef<T>;
+    static oneOfType<U extends VueProp<any> | VueTypeProp<any>, V = InferType<U>>(arr: U[]): VueTypeDef<V>;
+    static oneOf<T>(arr: T[]): VueTypeDef<T>;
+    static oneOf<T extends readonly any[]>(arr: T): VueTypeDef<T[number]>;
+    static get vNode(): VueTypeValidableDef<VNode>;
+    static maxLength(max: number): VueTypeValidableDef<string>;
+    static minLength(min: number): VueTypeValidableDef<string>;
+    static max(max: number): VueTypeValidableDef<number>;
+    static min(min: number): VueTypeValidableDef<number>;
+    static range(min: number, max: number): VueTypeValidableDef<number>;
+    static emit<T extends (...args: any[]) => any>(): VueTypeDef<T | T[]>;
+}
+export declare function callEmit<T extends (...args: any[]) => any>(funcs: T[] | T | undefined, ...args: Parameters<T>): ReturnType<T> | void;
+export declare type VKey = string | number | symbol;
+export declare const vKeyPropDef: VueTypeDef<string | number | symbol>;
+export {};

package/es/utils/src/props.js

@@ -0,0 +1,115 @@
+import { isVNode } from 'vue';
+import { array, arrayOf, custom, func, instanceOf, object, objectOf, oneOf, oneOfType, shape, toType, toValidableType, } from 'vue-types';
+export class IxPropTypes {
+    static get any() {
+        return toValidableType('any', { default: undefined });
+    }
+    static get bool() {
+        return toValidableType('boolean', {
+            type: Boolean,
+            default: undefined,
+        });
+    }
+    static get string() {
+        return toValidableType('string', {
+            type: String,
+            default: undefined,
+        });
+    }
+    static get number() {
+        return toValidableType('number', {
+            type: Number,
+            default: undefined,
+        });
+    }
+    static get integer() {
+        return toValidableType('integer', {
+            type: Number,
+            validator(value) {
+                return Number.isInteger(value);
+            },
+            default: undefined,
+        });
+    }
+    static get symbol() {
+        return toType('symbol', {
+            validator(value) {
+                return typeof value === 'symbol';
+            },
+            default: undefined,
+        });
+    }
+    static object() {
+        return object();
+    }
+    static func() {
+        return func();
+    }
+    static array() {
+        return array();
+    }
+    static oneOfType(arr) {
+        const type = oneOfType(arr);
+        type.default = undefined;
+        return type;
+    }
+    static oneOf(arr) {
+        return oneOf(arr);
+    }
+    static get vNode() {
+        return toValidableType('vNode', {
+            type: Object,
+            validator: (value) => isVNode(value),
+        });
+    }
+    static maxLength(max) {
+        return toValidableType('maxLength', {
+            type: String,
+            validator: (value) => value.length <= max,
+        });
+    }
+    static minLength(min) {
+        return toValidableType('minLength', {
+            type: String,
+            validator: (value) => value.length >= min,
+        });
+    }
+    static max(max) {
+        return toValidableType('max', {
+            type: Number,
+            validator: (value) => value <= max,
+        });
+    }
+    static min(min) {
+        return toValidableType('min', {
+            type: Number,
+            validator: (value) => value >= min,
+        });
+    }
+    static range(min, max) {
+        return toValidableType('range', {
+            type: Number,
+            validator: (value) => value >= min && value <= max,
+        });
+    }
+    static emit() {
+        return oneOfType([func(), array()]);
+    }
+}
+IxPropTypes.custom = custom;
+IxPropTypes.instanceOf = instanceOf;
+IxPropTypes.arrayOf = arrayOf;
+IxPropTypes.objectOf = objectOf;
+IxPropTypes.shape = shape;
+export function callEmit(funcs, ...args) {
+    if (!funcs) {
+        return;
+    }
+    if (Array.isArray(funcs)) {
+        funcs.forEach(fn => fn(...args));
+    }
+    else {
+        return funcs(...args);
+    }
+}
+export const vKeyPropDef = IxPropTypes.oneOfType([String, Number, Symbol]);

package/es/utils/with-install.d.ts

@@ -1,3 +1,3 @@
-import type { Plugin } from 'vue';
+import type { Plugin } from "vue";
 export declare type SFCWithInstall<T> = T & Plugin;
-export declare const withInstall: <T>(comp: any) => SFCWithInstall<T>;
+export declare const withInstall: <T>(comp: any) => any;

package/es/utils/with-install.js

@@ -1,5 +1,4 @@
 export const withInstall = (comp) => {
-    ;
     comp.install = function (app) {
         app.component(comp.name, comp);
     };