@a2simcode/ui 0.0.2 → 0.0.4

package/dist/components/form/src/useForm/interface.d.ts

@@ -0,0 +1,170 @@
+export type FormLabelAlign = 'left' | 'right';
+export type InternalNamePath = (string | number)[];
+export type NamePath = string | number | InternalNamePath;
+export type StoreValue = any;
+export interface Store {
+    [name: string]: StoreValue;
+}
+export interface Meta {
+    touched: boolean;
+    validating: boolean;
+    errors: string[];
+    name: InternalNamePath;
+}
+export interface InternalFieldData extends Meta {
+    value: StoreValue;
+}
+/**
+ * Used by `setFields` config
+ */
+export interface FieldData extends Partial<Omit<InternalFieldData, 'name'>> {
+    name: NamePath;
+}
+export type RuleType = 'string' | 'number' | 'boolean' | 'method' | 'regexp' | 'integer' | 'float' | 'object' | 'enum' | 'date' | 'url' | 'hex' | 'email';
+type Validator = (rule: RuleObject, value: StoreValue) => Promise<void> | void;
+export interface ValidatorRule {
+    warningOnly?: boolean;
+    message?: string;
+    /** custom validate function (Note: callback must be called) */
+    validator: Validator;
+}
+interface BaseRule {
+    warningOnly?: boolean;
+    /** validate the value from a list of possible values */
+    enum?: StoreValue[];
+    /** validate the exact length of a field */
+    len?: number;
+    /** validate the max length of a field */
+    max?: number;
+    /** validation error message */
+    message?: string;
+    /** validate the min length of a field */
+    min?: number;
+    /** validate from a regular expression */
+    pattern?: RegExp;
+    /** indicates whether field is required */
+    required?: boolean;
+    /** transform a value before validation */
+    transform?: (value: StoreValue) => StoreValue;
+    /** built-in validation type, available options: https://github.com/yiminghe/async-validator#type */
+    type?: RuleType;
+    /** treat required fields that only contain whitespace as errors */
+    whitespace?: boolean;
+    /** Customize rule level `validateTrigger`. Must be subset of Field `validateTrigger` */
+    validateTrigger?: string | string[];
+    /** Check trigger timing */
+    trigger?: 'blur' | 'change' | Array<'change' | 'blur'>;
+}
+type AggregationRule = BaseRule & Partial<ValidatorRule>;
+interface ArrayRule extends Omit<AggregationRule, 'type'> {
+    type: 'array';
+    defaultField?: RuleObject;
+}
+export type RuleObject = AggregationRule | ArrayRule;
+export type Rule = RuleObject;
+export interface ValidateErrorEntity<Values = any> {
+    values: Values;
+    errorFields: {
+        name: InternalNamePath;
+        errors: string[];
+    }[];
+    outOfDate: boolean;
+}
+export interface FieldError {
+    name: InternalNamePath | string;
+    errors: string[];
+}
+export interface RuleError {
+    errors: string[];
+    rule: RuleObject;
+}
+export interface ValidateOptions {
+    triggerName?: string;
+    validateMessages?: ValidateMessages;
+}
+export type InternalValidateFields = (nameList?: NamePath[], options?: ValidateOptions) => Promise<Store>;
+export type ValidateFields = (nameList?: NamePath[]) => Promise<Store>;
+interface ValueUpdateInfo {
+    type: 'valueUpdate';
+    source: 'internal' | 'external';
+}
+interface ValidateFinishInfo {
+    type: 'validateFinish';
+}
+interface ResetInfo {
+    type: 'reset';
+}
+interface SetFieldInfo {
+    type: 'setField';
+    data: FieldData;
+}
+interface DependenciesUpdateInfo {
+    type: 'dependenciesUpdate';
+    /**
+     * Contains all the related `InternalNamePath[]`.
+     * a <- b <- c : change `a`
+     * relatedFields=[a, b, c]
+     */
+    relatedFields: InternalNamePath[];
+}
+export type NotifyInfo = ValueUpdateInfo | ValidateFinishInfo | ResetInfo | SetFieldInfo | DependenciesUpdateInfo;
+export type ValuedNotifyInfo = NotifyInfo & {
+    store: Store;
+};
+export interface Callbacks<Values = any> {
+    onValuesChange?: (changedValues: any, values: Values) => void;
+    onFieldsChange?: (changedFields: FieldData[], allFields: FieldData[]) => void;
+    onFinish?: (values: Values) => void;
+    onFinishFailed?: (errorInfo: ValidateErrorEntity<Values>) => void;
+    onValidate?: (name: string | number | string[] | number[], status: boolean, errors: string[] | null) => void;
+}
+export type EventArgs = any[];
+type ValidateMessage = string | (() => string);
+export interface ValidateMessages {
+    default?: ValidateMessage;
+    required?: ValidateMessage;
+    enum?: ValidateMessage;
+    whitespace?: ValidateMessage;
+    date?: {
+        format?: ValidateMessage;
+        parse?: ValidateMessage;
+        invalid?: ValidateMessage;
+    };
+    types?: {
+        string?: ValidateMessage;
+        method?: ValidateMessage;
+        array?: ValidateMessage;
+        object?: ValidateMessage;
+        number?: ValidateMessage;
+        date?: ValidateMessage;
+        boolean?: ValidateMessage;
+        integer?: ValidateMessage;
+        float?: ValidateMessage;
+        regexp?: ValidateMessage;
+        email?: ValidateMessage;
+        url?: ValidateMessage;
+        hex?: ValidateMessage;
+    };
+    string?: {
+        len?: ValidateMessage;
+        min?: ValidateMessage;
+        max?: ValidateMessage;
+        range?: ValidateMessage;
+    };
+    number?: {
+        len?: ValidateMessage;
+        min?: ValidateMessage;
+        max?: ValidateMessage;
+        range?: ValidateMessage;
+    };
+    array?: {
+        len?: ValidateMessage;
+        min?: ValidateMessage;
+        max?: ValidateMessage;
+        range?: ValidateMessage;
+    };
+    pattern?: {
+        mismatch?: ValidateMessage;
+    };
+}
+export {};

package/dist/components/form/src/useForm/validateUtil.d.ts

@@ -0,0 +1,5 @@
+import { RuleObject } from './interface';
+export declare function validateRules(name: string, value: any, rules: RuleObject[]): Promise<{
+    name: string;
+    errors: any;
+} | undefined>;

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

@@ -0,0 +1,112 @@
+export declare const JFormItem: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+        id: {
+            type: StringConstructor;
+            default: string;
+        };
+        type: {
+            type: StringConstructor;
+            default: string;
+        };
+        getCompType: {
+            type: FunctionConstructor;
+            default: undefined;
+        };
+        config: {
+            type: import('vue').PropType<Record<string, any>>;
+            default: () => void;
+        };
+        getCompConfig: {
+            type: FunctionConstructor;
+            default: undefined;
+        };
+        children: {
+            type: import('vue').PropType<import('../comp/src/comp.vue').SchemaRuntimeConfig[]>;
+            default: () => never[];
+        };
+    }>> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+        type: string;
+        id: string;
+        children: import('../comp/src/comp.vue').SchemaRuntimeConfig[];
+        getCompType: Function;
+        config: Record<string, any>;
+        getCompConfig: Function;
+    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('vue').ExtractPropTypes<{
+        id: {
+            type: StringConstructor;
+            default: string;
+        };
+        type: {
+            type: StringConstructor;
+            default: string;
+        };
+        getCompType: {
+            type: FunctionConstructor;
+            default: undefined;
+        };
+        config: {
+            type: import('vue').PropType<Record<string, any>>;
+            default: () => void;
+        };
+        getCompConfig: {
+            type: FunctionConstructor;
+            default: undefined;
+        };
+        children: {
+            type: import('vue').PropType<import('../comp/src/comp.vue').SchemaRuntimeConfig[]>;
+            default: () => never[];
+        };
+    }>> & Readonly<{}>, {}, {}, {}, {}, {
+        type: string;
+        id: string;
+        children: import('../comp/src/comp.vue').SchemaRuntimeConfig[];
+        getCompType: Function;
+        config: Record<string, any>;
+        getCompConfig: Function;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+    id: {
+        type: StringConstructor;
+        default: string;
+    };
+    type: {
+        type: StringConstructor;
+        default: string;
+    };
+    getCompType: {
+        type: FunctionConstructor;
+        default: undefined;
+    };
+    config: {
+        type: import('vue').PropType<Record<string, any>>;
+        default: () => void;
+    };
+    getCompConfig: {
+        type: FunctionConstructor;
+        default: undefined;
+    };
+    children: {
+        type: import('vue').PropType<import('../comp/src/comp.vue').SchemaRuntimeConfig[]>;
+        default: () => never[];
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+    type: string;
+    id: string;
+    children: import('../comp/src/comp.vue').SchemaRuntimeConfig[];
+    getCompType: Function;
+    config: Record<string, any>;
+    getCompConfig: Function;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & {
+    install: (app: import('vue').App) => void;
+};
+export default JFormItem;

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

@@ -0,0 +1,97 @@
+import { PropType } from 'vue';
+import { SchemaRuntimeConfig } from '../../comp/src/comp.vue';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    /**
+     * @zh 组件 id
+     */
+    id: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * @zh 组件类型
+     */
+    type: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * @zh 获取组件类型
+     */
+    getCompType: {
+        type: FunctionConstructor;
+        default: undefined;
+    };
+    /**
+     * @zh 组件配置
+     */
+    config: {
+        type: PropType<Record<string, any>>;
+        default: () => void;
+    };
+    /**
+     * @zh 获取组件配置
+     */
+    getCompConfig: {
+        type: FunctionConstructor;
+        default: undefined;
+    };
+    /**
+     * @zh 子集
+     */
+    children: {
+        type: PropType<SchemaRuntimeConfig[]>;
+        default: () => never[];
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    /**
+     * @zh 组件 id
+     */
+    id: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * @zh 组件类型
+     */
+    type: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * @zh 获取组件类型
+     */
+    getCompType: {
+        type: FunctionConstructor;
+        default: undefined;
+    };
+    /**
+     * @zh 组件配置
+     */
+    config: {
+        type: PropType<Record<string, any>>;
+        default: () => void;
+    };
+    /**
+     * @zh 获取组件配置
+     */
+    getCompConfig: {
+        type: FunctionConstructor;
+        default: undefined;
+    };
+    /**
+     * @zh 子集
+     */
+    children: {
+        type: PropType<SchemaRuntimeConfig[]>;
+        default: () => never[];
+    };
+}>> & Readonly<{}>, {
+    type: string;
+    id: string;
+    children: SchemaRuntimeConfig[];
+    getCompType: Function;
+    config: Record<string, any>;
+    getCompConfig: Function;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

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

@@ -0,0 +1,31 @@
+export declare const JIcon: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./src/icon.vue').IconProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+        size: number;
+        color: string;
+        rotate: number;
+        isDiv: boolean;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('./src/icon.vue').IconProps> & Readonly<{}>, {}, {}, {}, {}, {
+        size: number;
+        color: string;
+        rotate: number;
+        isDiv: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('./src/icon.vue').IconProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+    size: number;
+    color: string;
+    rotate: number;
+    isDiv: boolean;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & {
+    install: (app: import('vue').App) => void;
+};
+export default JIcon;

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

@@ -0,0 +1,33 @@
+export interface IconProps {
+    /**
+     * @zh 图标名称或图标数据
+     */
+    icon: string;
+    /**
+     * @zh 图标尺寸
+     */
+    size?: number;
+    /**
+     * @zh 图标颜色
+     */
+    color?: string;
+    /**
+     * @zh 旋转角度
+     */
+    rotate?: number;
+    /**
+     * @zh 翻转
+     * /
+    flip?: 'horizontal' | 'vertical' | 'both'
+    /**
+     * @zh 是否需要div包裹
+     */
+    isDiv?: boolean;
+}
+declare const _default: import('vue').DefineComponent<IconProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<IconProps> & Readonly<{}>, {
+    size: number;
+    color: string;
+    rotate: number;
+    isDiv: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/index.d.ts

@@ -0,0 +1,35 @@
+import { App } from 'vue';
+import { default as JButton } from './button';
+import { default as JButtons } from './buttons';
+import { default as JInput } from './input';
+import { default as JIcon } from './icon';
+import { default as JRadio } from './radio';
+import { default as JSelect } from './select';
+import { default as JCascaderSelect } from './cascader-select';
+import { default as JCheckbox } from './checkbox';
+import { default as JNumber } from './number';
+import { default as JAutoComplete } from './autocomplete';
+import { default as JLayout } from './layout';
+import { default as JTable } from './table';
+import { default as JDialog } from './dialog';
+import { default as JDialogFull } from './dialog-full';
+import { default as JDrawer } from './drawer';
+import { default as JLayer } from './layer';
+import { default as JDynamicLayer } from './dynamic-layer';
+import { default as JInputTag } from './input-tag';
+import { default as JRate } from './rate';
+import { default as JSlider } from './slider';
+import { default as JUpload } from './upload';
+import { default as JEcharts } from './echarts';
+import { default as JBarcode } from './barcode';
+import { default as JCodeMirror } from './code-mirror';
+import { default as JComp } from './comp';
+import { default as JForm } from './form';
+import { default as JFormItem } from './form-item';
+import { default as JPage } from './page';
+export { JButton, JButtons, JInput, JIcon, JRadio, JSelect, JCascaderSelect, JCheckbox, JNumber, JAutoComplete, JLayout, JTable, JDialog, JDialogFull, JDrawer, JLayer, JDynamicLayer, JInputTag, JRate, JSlider, JUpload, JEcharts, JBarcode, JCodeMirror, JComp, JForm, JFormItem, JPage };
+export * from '../core';
+declare const _default: {
+    install: (app: App) => void;
+};
+export default _default;

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

@@ -0,0 +1,111 @@
+declare const JInput: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./src/input.vue').InputProps> & Readonly<{
+        onClear?: (() => any) | undefined;
+        onInput?: ((value: string | number) => any) | undefined;
+        onFocus?: ((evt: FocusEvent) => any) | undefined;
+        onBlur?: ((evt: FocusEvent) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: string | number) => any) | undefined;
+        onChange?: ((value: string | number) => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        clear: () => any;
+        input: (value: string | number) => any;
+        focus: (evt: FocusEvent) => any;
+        blur: (evt: FocusEvent) => any;
+        "update:modelValue": (value: string | number) => any;
+        change: (value: string | number) => any;
+    }, import('vue').PublicProps, {
+        size: "large" | "default" | "small";
+        type: string;
+        disabled: boolean;
+        readonly: boolean;
+        modelValue: string | number;
+        showWordLimit: boolean;
+        wordLimitPosition: "inside" | "outside";
+        placeholder: string;
+        clearable: boolean;
+        showPassword: boolean;
+        rows: number;
+        autosize: boolean | {
+            minRows?: number;
+            maxRows?: number;
+        };
+        autocomplete: string;
+        autofocus: boolean;
+        validateEvent: boolean;
+        inputStyle: string | Record<string, string | number>;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('./src/input.vue').InputProps> & Readonly<{
+        onClear?: (() => any) | undefined;
+        onInput?: ((value: string | number) => any) | undefined;
+        onFocus?: ((evt: FocusEvent) => any) | undefined;
+        onBlur?: ((evt: FocusEvent) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: string | number) => any) | undefined;
+        onChange?: ((value: string | number) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        size: "large" | "default" | "small";
+        type: string;
+        disabled: boolean;
+        readonly: boolean;
+        modelValue: string | number;
+        showWordLimit: boolean;
+        wordLimitPosition: "inside" | "outside";
+        placeholder: string;
+        clearable: boolean;
+        showPassword: boolean;
+        rows: number;
+        autosize: boolean | {
+            minRows?: number;
+            maxRows?: number;
+        };
+        autocomplete: string;
+        autofocus: boolean;
+        validateEvent: boolean;
+        inputStyle: string | Record<string, string | number>;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('./src/input.vue').InputProps> & Readonly<{
+    onClear?: (() => any) | undefined;
+    onInput?: ((value: string | number) => any) | undefined;
+    onFocus?: ((evt: FocusEvent) => any) | undefined;
+    onBlur?: ((evt: FocusEvent) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string | number) => any) | undefined;
+    onChange?: ((value: string | number) => any) | undefined;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    clear: () => any;
+    input: (value: string | number) => any;
+    focus: (evt: FocusEvent) => any;
+    blur: (evt: FocusEvent) => any;
+    "update:modelValue": (value: string | number) => any;
+    change: (value: string | number) => any;
+}, string, {
+    size: "large" | "default" | "small";
+    type: string;
+    disabled: boolean;
+    readonly: boolean;
+    modelValue: string | number;
+    showWordLimit: boolean;
+    wordLimitPosition: "inside" | "outside";
+    placeholder: string;
+    clearable: boolean;
+    showPassword: boolean;
+    rows: number;
+    autosize: boolean | {
+        minRows?: number;
+        maxRows?: number;
+    };
+    autocomplete: string;
+    autofocus: boolean;
+    validateEvent: boolean;
+    inputStyle: string | Record<string, string | number>;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & {
+    install: (app: import('vue').App) => void;
+};
+export default JInput;