x-next 0.0.0-alpha.5 → 0.0.0-alpha.50

package/dist/components/drawer/src/props.d.ts

@@ -0,0 +1,75 @@
+import { ExtractPropTypes } from 'vue';
+import { Placement } from './types';
+export declare const drawerProps: {
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    modelValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    placement: {
+        type: import('vue').PropType<Placement>;
+        default: string;
+    };
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+    mask: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showFooter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    maskToClose: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    escToClose: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    destroyOnClosed: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    width: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    height: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    okText: {
+        type: StringConstructor;
+        default: string;
+    };
+    cancelText: {
+        type: StringConstructor;
+        default: string;
+    };
+    onBeforeOk: {
+        type: import('vue').PropType<() => boolean | Promise<boolean>>;
+    };
+    onBeforeCancel: {
+        type: import('vue').PropType<() => boolean | Promise<boolean>>;
+    };
+    renderTo: {
+        type: import('vue').PropType<string | HTMLElement>;
+        default: string;
+    };
+    popupClass: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    showClose: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+};
+export type DrawerProps = ExtractPropTypes<typeof drawerProps>;

package/dist/components/drawer/src/types.d.ts

@@ -0,0 +1 @@
+export type Placement = 'top' | 'right' | 'bottom' | 'left';

package/dist/components/form/constants.d.ts

@@ -0,0 +1,4 @@
+import { InjectionKey } from 'vue';
+import { FormContext, FormItemContext } from './types';
+export declare const formContextKey: InjectionKey<FormContext>;
+export declare const formItemContextKey: InjectionKey<FormItemContext>;

package/dist/components/form/form-item.d.ts

@@ -0,0 +1,31 @@
+import { ExtractPropTypes } from 'vue';
+import { Arrayable, FormItemRule } from './types';
+export declare const formItemValidateStates: readonly ["", "error", "validating", "success"];
+export type FormItemValidateState = (typeof formItemValidateStates)[number];
+export type FormItemProp = Arrayable<string>;
+export declare const formItemProps: {
+    label: StringConstructor;
+    labelWidth: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: string;
+    };
+    prop: {
+        type: import('vue').PropType<FormItemProp>;
+    };
+    required: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    rules: {
+        type: import('vue').PropType<Arrayable<FormItemRule>>;
+    };
+    validateStatus: {
+        type: StringConstructor;
+        values: readonly ["", "error", "validating", "success"];
+    };
+    showMessage: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+};
+export type FormItemProps = ExtractPropTypes<typeof formItemProps>;

package/dist/components/form/form.d.ts

@@ -0,0 +1,39 @@
+import { ExtractPropTypes, PropType } from 'vue';
+import { FormItemProp } from './form-item';
+export declare const formProps: {
+    model: {
+        type: ObjectConstructor;
+    };
+    rules: {
+        type: PropType<Partial<Record<string, import('./types').Arrayable<import('./types').FormItemRule>>>>;
+    };
+    labelPosition: {
+        type: PropType<"left" | "right" | "top">;
+        default: string;
+    };
+    requireAsteriskPosition: {
+        type: StringConstructor;
+        default: string;
+    };
+    labelWidth: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: string;
+    };
+    showMessage: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    validateOnRuleChange: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    inline: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+};
+export type FormProps = ExtractPropTypes<typeof formProps>;
+export declare const formEmits: {
+    validate: (prop: FormItemProp, isValid: boolean, message: string) => boolean;
+};
+export type FormEmits = typeof formEmits;

package/dist/components/form/hooks.d.ts

@@ -0,0 +1,4 @@
+export declare const useFormItem: () => {
+    form: import('./types').FormContext | undefined;
+    formItem: import('./types').FormItemContext | undefined;
+};

package/dist/components/form/types.d.ts

@@ -0,0 +1,31 @@
+import { SetupContext } from 'vue';
+import { RuleItem, ValidateError, ValidateFieldsError } from 'async-validator';
+import { FormProps, FormEmits } from './form';
+import { FormItemProp, FormItemProps, FormItemValidateState } from './form-item';
+export type Arrayable<T> = T | T[];
+export interface FormItemRule extends Omit<RuleItem, 'validator'> {
+    trigger?: Arrayable<string>;
+    validator?: RuleItem['validator'] | string;
+}
+export type FormRules = Partial<Record<string, Arrayable<FormItemRule>>>;
+export type FormValidationResult = Promise<any>;
+export type FormValidateCallback = (isValid: boolean, invalidFields?: any) => void;
+export type FormContext = FormProps & {
+    emit: SetupContext<FormEmits>['emit'];
+    addField: (field: FormItemContext) => void;
+    removeField: (field: FormItemContext) => void;
+    resetFields: (props?: Arrayable<FormItemProp>) => void;
+    clearValidate: (props?: Arrayable<FormItemProp>) => void;
+    validateField: (props?: Arrayable<FormItemProp>, callback?: FormValidateCallback) => FormValidationResult;
+};
+export interface FormItemContext extends FormItemProps {
+    $el: HTMLDivElement | undefined;
+    validateState: FormItemValidateState;
+    validate: (trigger: string, callback?: FormValidateCallback) => FormValidationResult;
+    resetField(): void;
+    clearValidate(): void;
+}
+export interface FormValidateFailure {
+    errors: ValidateError[] | null;
+    fields: ValidateFieldsError;
+}