morningfast-plus 1.0.21 → 1.1.0

package/components/export-setting/src/use-export-setting.d.ts

@@ -0,0 +1,8 @@
+import { MpExportSettingItem, UseMpTableExportSettingOptions } from './types';
+export declare function useMpTableExportSetting<Row = any>(options: UseMpTableExportSettingOptions<Row>): {
+    showExportSetting: import('vue').Ref<boolean, boolean>;
+    exportableColumns: import('vue').ComputedRef<MpExportSettingItem[]>;
+    isExportEnabled: import('vue').ComputedRef<boolean>;
+    openExportSetting: () => void;
+    closeExportSetting: () => void;
+};

package/components/form/index.d.ts

@@ -0,0 +1,14 @@
+import { SFCWithInstall } from '../install';
+import { default as Form } from './src/form.vue';
+/**
+ * @file Form 表单组件
+ * @module /packages/components/form
+ * @description 提供基于 schema 的配置化表单能力
+ */
+export declare const MpForm: SFCWithInstall<typeof Form>;
+export default MpForm;
+export { getMpFieldComponents as getMpFormFieldComponents, registerMpFieldComponent as registerMpFormFieldComponent, registerMpFieldComponents as registerMpFormFieldComponents, resolveMpFieldComponent as resolveMpFormFieldComponent, } from './src/field-renderer';
+export * from './src/form';
+export * from './src/model';
+export type { FormInstance } from './src/instance';
+export type * from './src/types';

package/components/form/src/field-renderer/index.d.ts

@@ -0,0 +1,38 @@
+export declare const MpFieldRenderer: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+        schema: import('.').MpFieldSchema;
+        modelValue: import('.').MpFieldModel;
+    }> & Readonly<{
+        "onUpdate:modelValue"?: ((value: import('.').MpFieldModel) => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        "update:modelValue": (value: import('.').MpFieldModel) => any;
+    }, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{
+        schema: import('.').MpFieldSchema;
+        modelValue: import('.').MpFieldModel;
+    }> & Readonly<{
+        "onUpdate:modelValue"?: ((value: import('.').MpFieldModel) => any) | undefined;
+    }>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<{
+    schema: import('.').MpFieldSchema;
+    modelValue: import('.').MpFieldModel;
+}> & Readonly<{
+    "onUpdate:modelValue"?: ((value: import('.').MpFieldModel) => any) | undefined;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: import('.').MpFieldModel) => any;
+}, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: any;
+});
+export default MpFieldRenderer;
+export { registerMpFieldComponents } from './src/register-fields';
+export * from './src/field-components';
+export type * from './src/types';

package/components/form/src/field-renderer/src/field-components.d.ts

@@ -0,0 +1,7 @@
+import { Component } from 'vue';
+export type MpFieldComponentRegistry = Record<string, Component>;
+export declare function registerMpFieldComponent(name: string, component: Component): void;
+export declare function resolveMpFieldComponent(component: string | Component): Component;
+export declare function getMpFieldComponents(): {
+    [x: string]: Component;
+};

package/components/form/src/field-renderer/src/field-renderer.vue.d.ts

@@ -0,0 +1,19 @@
+import { MpFieldModel, MpFieldSchema } from './types';
+type __VLS_Props = {
+    schema: MpFieldSchema;
+    modelValue: MpFieldModel;
+};
+declare function __VLS_template(): any;
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: MpFieldModel) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: MpFieldModel) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/components/form/src/field-renderer/src/register-fields.d.ts

@@ -0,0 +1 @@
+export declare function registerMpFieldComponents(): void;

package/components/form/src/field-renderer/src/types.d.ts

@@ -0,0 +1,50 @@
+import { Component } from 'vue';
+export type MpFieldValue = unknown;
+export type MpFieldModel = Record<string, MpFieldValue>;
+export type MpFieldComponentType = 'input' | 'input-number' | 'select' | 'select-v2' | 'tree-select' | 'cascader' | 'radio-group' | 'checkbox' | 'checkbox-group' | 'date' | 'time' | 'time-select' | 'textarea' | 'switch' | 'slot' | string | Component;
+export interface MpFieldOption {
+    label: string;
+    value: string | number | boolean;
+    disabled?: boolean;
+    [key: string]: unknown;
+}
+export interface MpFieldEventContext<Schema = MpFieldSchema> {
+    schema: Schema;
+    field: string;
+    value: unknown;
+    model: MpFieldModel;
+    setValue: (field: string, value: unknown) => void;
+    option?: MpFieldOption;
+    options?: MpFieldOption[];
+    event?: unknown;
+    args: unknown[];
+}
+export type MpFieldEventHandler<Schema = MpFieldSchema> = (context: MpFieldEventContext<Schema>) => void;
+export interface MpFieldStateContext<Schema = MpFieldSchema> {
+    schema: Schema;
+    field: string;
+    value: unknown;
+    model: MpFieldModel;
+}
+export type MpFieldStateResolver<Schema = MpFieldSchema> = boolean | ((context: MpFieldStateContext<Schema>) => boolean);
+export interface MpFieldSchema {
+    field: string;
+    label: string;
+    component?: MpFieldComponentType;
+    defaultValue?: MpFieldValue;
+    modelProp?: string;
+    updateEvent?: string;
+    slots?: Record<string, string>;
+    events?: Record<string, MpFieldEventHandler>;
+    onChange?: MpFieldEventHandler;
+    onBlur?: MpFieldEventHandler;
+    onFocus?: MpFieldEventHandler;
+    onClick?: MpFieldEventHandler;
+    visible?: MpFieldStateResolver;
+    disabled?: MpFieldStateResolver;
+    placeholder?: string;
+    componentProps?: Record<string, unknown> & {
+        options?: MpFieldOption[];
+    };
+    slot?: string;
+}

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

@@ -0,0 +1,24 @@
+import { MpFormModel, MpFormSchema } from './types';
+type __VLS_Props = {
+    schema: MpFormSchema;
+    modelValue: MpFormModel;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: any;
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: import('./field-renderer').MpFieldModel) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: import('./field-renderer').MpFieldModel) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/components/form/src/form-renderer.vue.d.ts

@@ -0,0 +1,29 @@
+import { MpFormModel, MpFormSchema } from './types';
+type __VLS_Props = {
+    schemas: MpFormSchema[];
+    modelValue: MpFormModel;
+    gutter: number;
+    defaultSpan: number;
+    xs: number;
+    sm: number;
+    hiddenIndexes?: number[];
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: any;
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: import('./field-renderer').MpFieldModel) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: import('./field-renderer').MpFieldModel) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/components/form/src/form.d.ts

@@ -0,0 +1,56 @@
+import { PropType } from 'vue';
+import { FormRules } from 'element-plus';
+import { MpFormModel, MpFormSchema } from './types';
+export declare const mpFormProps: {
+    readonly modelValue: {
+        readonly type: PropType<MpFormModel>;
+        readonly required: true;
+    };
+    readonly schemas: {
+        readonly type: PropType<MpFormSchema[]>;
+        readonly required: true;
+    };
+    readonly rules: {
+        readonly type: PropType<FormRules>;
+        readonly default: undefined;
+    };
+    readonly labelPosition: {
+        readonly type: StringConstructor;
+        readonly default: "right";
+    };
+    readonly labelWidth: {
+        readonly type: PropType<string | number>;
+        readonly default: "80px";
+    };
+    readonly gutter: {
+        readonly type: NumberConstructor;
+        readonly default: 16;
+    };
+    readonly defaultSpan: {
+        readonly type: NumberConstructor;
+        readonly default: 12;
+    };
+    readonly xs: {
+        readonly type: NumberConstructor;
+        readonly default: 24;
+    };
+    readonly sm: {
+        readonly type: NumberConstructor;
+        readonly default: 24;
+    };
+    readonly hiddenIndexes: {
+        readonly type: PropType<number[]>;
+        readonly default: () => never[];
+    };
+    readonly disabled: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly loading: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+};
+export declare const MpFormEmits: {
+    'update:modelValue': (value: MpFormModel) => boolean;
+};

package/components/form/src/form.vue.d.ts

@@ -0,0 +1,140 @@
+import { FormInstance as ElFormInstance } from 'element-plus';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: any;
+    refs: {
+        formRef: unknown;
+    };
+    rootEl: HTMLElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    readonly modelValue: {
+        readonly type: import('vue').PropType<import('./types').MpFormModel>;
+        readonly required: true;
+    };
+    readonly schemas: {
+        readonly type: import('vue').PropType<import('./types').MpFormSchema[]>;
+        readonly required: true;
+    };
+    readonly rules: {
+        readonly type: import('vue').PropType<import('element-plus').FormRules>;
+        readonly default: undefined;
+    };
+    readonly labelPosition: {
+        readonly type: StringConstructor;
+        readonly default: "right";
+    };
+    readonly labelWidth: {
+        readonly type: import('vue').PropType<string | number>;
+        readonly default: "80px";
+    };
+    readonly gutter: {
+        readonly type: NumberConstructor;
+        readonly default: 16;
+    };
+    readonly defaultSpan: {
+        readonly type: NumberConstructor;
+        readonly default: 12;
+    };
+    readonly xs: {
+        readonly type: NumberConstructor;
+        readonly default: 24;
+    };
+    readonly sm: {
+        readonly type: NumberConstructor;
+        readonly default: 24;
+    };
+    readonly hiddenIndexes: {
+        readonly type: import('vue').PropType<number[]>;
+        readonly default: () => never[];
+    };
+    readonly disabled: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly loading: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+}>, {
+    formRef: ElFormInstance | undefined;
+    validate: ElFormInstance["validate"];
+    validateField: ElFormInstance["validateField"];
+    resetFields: ElFormInstance["resetFields"];
+    clearValidate: ElFormInstance["clearValidate"];
+    scrollToField: ElFormInstance["scrollToField"];
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: import('./field-renderer').MpFieldModel) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    readonly modelValue: {
+        readonly type: import('vue').PropType<import('./types').MpFormModel>;
+        readonly required: true;
+    };
+    readonly schemas: {
+        readonly type: import('vue').PropType<import('./types').MpFormSchema[]>;
+        readonly required: true;
+    };
+    readonly rules: {
+        readonly type: import('vue').PropType<import('element-plus').FormRules>;
+        readonly default: undefined;
+    };
+    readonly labelPosition: {
+        readonly type: StringConstructor;
+        readonly default: "right";
+    };
+    readonly labelWidth: {
+        readonly type: import('vue').PropType<string | number>;
+        readonly default: "80px";
+    };
+    readonly gutter: {
+        readonly type: NumberConstructor;
+        readonly default: 16;
+    };
+    readonly defaultSpan: {
+        readonly type: NumberConstructor;
+        readonly default: 12;
+    };
+    readonly xs: {
+        readonly type: NumberConstructor;
+        readonly default: 24;
+    };
+    readonly sm: {
+        readonly type: NumberConstructor;
+        readonly default: 24;
+    };
+    readonly hiddenIndexes: {
+        readonly type: import('vue').PropType<number[]>;
+        readonly default: () => never[];
+    };
+    readonly disabled: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly loading: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((value: import('./field-renderer').MpFieldModel) => any) | undefined;
+}>, {
+    readonly disabled: boolean;
+    readonly loading: boolean;
+    readonly rules: Partial<Record<string, import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').FormItemRule>>>;
+    readonly labelPosition: string;
+    readonly labelWidth: string | number;
+    readonly gutter: number;
+    readonly defaultSpan: number;
+    readonly xs: number;
+    readonly sm: number;
+    readonly hiddenIndexes: number[];
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    formRef: unknown;
+}, HTMLElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/components/form/src/instance.d.ts

@@ -0,0 +1,9 @@
+import { FormInstance as ElFormInstance } from 'element-plus';
+export interface FormInstance {
+    formRef: ElFormInstance | undefined;
+    validate: ElFormInstance['validate'];
+    validateField: ElFormInstance['validateField'];
+    resetFields: ElFormInstance['resetFields'];
+    clearValidate: ElFormInstance['clearValidate'];
+    scrollToField: ElFormInstance['scrollToField'];
+}

package/components/form/src/model.d.ts

@@ -0,0 +1,2 @@
+import { MpFormModel, MpFormSchema } from './types';
+export declare function createDefaultFormModel(schemas: MpFormSchema[], fallbackValue?: unknown): MpFormModel;

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

@@ -0,0 +1,33 @@
+import { FormItemRule, FormRules } from 'element-plus';
+import { MpFieldComponentType, MpFieldEventContext, MpFieldEventHandler, MpFieldModel, MpFieldOption, MpFieldSchema, MpFieldStateContext, MpFieldStateResolver, MpFieldValue } from './field-renderer';
+export type MpFormFieldValue = MpFieldValue;
+export type MpFormModel = MpFieldModel;
+export type MpFormComponentType = MpFieldComponentType;
+export type MpFormOption = MpFieldOption;
+export type MpFormFieldEventContext = MpFieldEventContext<MpFormSchema>;
+export type MpFormFieldEventHandler = MpFieldEventHandler<MpFormSchema>;
+export type MpFormFieldStateContext = MpFieldStateContext<MpFormSchema>;
+export type MpFormFieldStateResolver = MpFieldStateResolver<MpFormSchema>;
+export interface MpFormProps {
+    modelValue: MpFormModel;
+    schemas: MpFormSchema[];
+    rules?: FormRules;
+    labelPosition?: 'left' | 'right' | 'top';
+    labelWidth?: string | number;
+    gutter?: number;
+    defaultSpan?: number;
+    xs?: number;
+    sm?: number;
+    hiddenIndexes?: number[];
+    disabled?: boolean;
+}
+export interface MpFormSchema extends Omit<MpFieldSchema, 'events' | 'onChange' | 'onBlur' | 'onFocus' | 'onClick'> {
+    events?: Record<string, MpFormFieldEventHandler>;
+    onChange?: MpFormFieldEventHandler;
+    onBlur?: MpFormFieldEventHandler;
+    onFocus?: MpFormFieldEventHandler;
+    onClick?: MpFormFieldEventHandler;
+    span?: number;
+    rules?: FormItemRule | FormItemRule[];
+    formItemProps?: Record<string, unknown>;
+}