vft 0.0.142 → 0.0.145

package/es/app-components/button/button-custom.d.ts

@@ -0,0 +1,5 @@
+import { TinyColor } from '@ctrl/tinycolor';
+import type { ButtonProps } from './button.vue';
+/** 生成暗色 */
+export declare function darken(color: TinyColor, amount?: number): string;
+export declare function useButtonCustomStyle(props: ButtonProps): import("vue").ComputedRef<Record<string, string>>;

package/es/app-components/button/constants.d.ts

@@ -0,0 +1,3 @@
+import type { InjectionKey } from 'vue';
+import type { ButtonGroupProps } from './types';
+export declare const buttonGroupContextKey: InjectionKey<ButtonGroupProps>;

package/es/app-components/button/index.d.ts

@@ -0,0 +1,5 @@
+import VftButton, { type ButtonProps } from './button.vue';
+import VftButtonGroup from './button-group.vue';
+export { type ButtonProps, VftButtonGroup, VftButton };
+export * from './types';
+export * from './constants';

package/es/app-components/button/types.d.ts

@@ -0,0 +1,9 @@
+import type { ButtonProps } from './button.vue';
+export type ButtonType = 'default' | 'primary' | 'success' | 'warning' | 'info' | 'danger' | 'text' | '';
+export interface ButtonConfigContext {
+    autoInsertSpace?: boolean;
+}
+export interface ButtonGroupProps {
+    size?: ButtonProps['size'];
+    type?: ButtonProps['type'];
+}

package/es/{components → app-components}/button/use-button.d.ts

@@ -1,6 +1,5 @@
-import type { SetupContext } from 'vue';
 import type { ButtonProps } from './button.vue';
-export declare const useButton: (props: ButtonProps, emit: SetupContext['emit']) => {
+export declare const useButton: (props: ButtonProps, emit: any) => {
     _props: import("vue").ComputedRef<{
         ariaDisabled: boolean | undefined;
         disabled: boolean | undefined;
@@ -13,7 +12,7 @@ export declare const useButton: (props: ButtonProps, emit: SetupContext['emit'])
         type?: undefined;
     }>;
     _disabled: import("vue").ComputedRef<boolean>;
-    _size: import("vue").ComputedRef<"" | "default" | "small" | "large">;
+    _size: import("vue").ComputedRef<import("../form").ComponentSize>;
     _type: import("vue").ComputedRef<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
     _ref: import("vue").Ref<HTMLButtonElement | undefined>;
     shouldAddSpace: import("vue").ComputedRef<boolean>;

package/es/app-components/clamp/index.d.ts

@@ -0,0 +1,2 @@
+import VftClamp from './clamp.vue';
+export { VftClamp };

package/es/app-components/col/index.d.ts

@@ -0,0 +1,4 @@
+import VftCol, { type ColProps } from './col.vue';
+export * from './types';
+export { type ColProps };
+export { VftCol };

package/es/app-components/col/types.d.ts

@@ -0,0 +1,11 @@
+export type ColSizeObject = {
+    /** 栅格占据的列数 */
+    span?: number;
+    /** 栅格左侧的间隔格数 */
+    offset?: number;
+    /** 栅格向左移动格数 */
+    pull?: number;
+    /** 栅格向右移动格数 */
+    push?: number;
+};
+export type ColSize = number | ColSizeObject;

package/es/app-components/form/constants.d.ts

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

package/es/app-components/form/form-label-wrap.d.ts

@@ -0,0 +1,11 @@
+declare const _default: import("vue").DefineComponent<{
+    isAutoWidth: BooleanConstructor;
+    updateAll: BooleanConstructor;
+}, () => JSX.Element | null, {}, {}, {}, import("vue/types/v3-component-options").ComponentOptionsMixin, import("vue/types/v3-component-options").ComponentOptionsMixin, {}, string, Readonly<import("vue").ExtractPropTypes<{
+    isAutoWidth: BooleanConstructor;
+    updateAll: BooleanConstructor;
+}>>, {
+    isAutoWidth: boolean;
+    updateAll: boolean;
+}>;
+export default _default;

package/es/app-components/form/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export * from './use-form-common-props';
+export * from './use-form-item';

package/es/{components → app-components}/form/hooks/use-form-common-props.d.ts

@@ -1,6 +1,7 @@
-import type { ComponentSize } from 'vft/es/constants';
+import type { ComponentSize } from '../types';
 import type { MaybeRef } from '@vueuse/core';
-export declare const useFormSize: (fallback?: MaybeRef<ComponentSize | undefined>, ignore?: Partial<Record<'prop' | 'form' | 'formItem' | 'global', boolean>>) => import("vue").ComputedRef<"" | "default" | "small" | "large">;
-export declare const useFormDisabled: (fallback?: MaybeRef<boolean | undefined>) => import("vue").ComputedRef<boolean>;
-export declare const useSize: (fallback?: MaybeRef<ComponentSize | undefined>, ignore?: Partial<Record<'prop' | 'form' | 'formItem' | 'global', boolean>>) => import("vue").ComputedRef<"" | "default" | "small" | "large">;
-export declare const useDisabled: (fallback?: MaybeRef<boolean | undefined>) => import("vue").ComputedRef<boolean>;
+import { type ComputedRef } from 'vue';
+export declare const useFormSize: (fallback?: MaybeRef<ComponentSize | undefined>, ignore?: Partial<Record<'prop' | 'form' | 'formItem' | 'global', boolean>>) => ComputedRef<ComponentSize>;
+export declare const useFormDisabled: (fallback?: MaybeRef<boolean | undefined>) => ComputedRef<boolean>;
+export declare const useSize: (fallback?: MaybeRef<ComponentSize | undefined>, ignore?: Partial<Record<'prop' | 'form' | 'formItem' | 'global', boolean>>) => ComputedRef<ComponentSize>;
+export declare const useDisabled: (fallback?: MaybeRef<boolean | undefined>) => ComputedRef<boolean>;

package/es/app-components/form/hooks/use-form-item.d.ts

@@ -0,0 +1,18 @@
+import type { ComputedRef, Ref } from 'vue';
+import type { FormItemContext } from '../types';
+export declare const useFormItem: () => {
+    form: import("../types").FormContext | undefined;
+    formItem: FormItemContext | undefined;
+};
+export type IUseFormItemInputCommonProps = {
+    id?: string;
+    label?: string | number | boolean | Record<string, any>;
+};
+export declare const useFormItemInputId: (props: Partial<IUseFormItemInputCommonProps>, { formItemContext, disableIdGeneration, disableIdManagement, }: {
+    formItemContext?: FormItemContext | undefined;
+    disableIdGeneration?: Ref<boolean> | ComputedRef<boolean> | undefined;
+    disableIdManagement?: Ref<boolean> | ComputedRef<boolean> | undefined;
+}) => {
+    isLabeledByFormItem: ComputedRef<boolean>;
+    inputId: Ref<string | undefined>;
+};

package/es/app-components/form/index.d.ts

@@ -0,0 +1,5 @@
+import VftForm, { type FormProps } from './form.vue';
+import VftFormItem, { type FormItemProps } from './form-item.vue';
+export { VftForm, type FormProps, VftFormItem, type FormItemProps };
+export * from './hooks';
+export * from './types';

package/es/app-components/form/types.d.ts

@@ -0,0 +1,43 @@
+import type { Arrayable } from '../types';
+import type { RuleItem, ValidateError, ValidateFieldsError } from 'async-validator';
+import type { SetupContext, UnwrapRef } from 'vue';
+import { type FormProps } from './form.vue';
+import { type FormItemProps } from './form-item.vue';
+import type { useFormLabelWidth } from './utils';
+export type FormItemProp = Arrayable<string>;
+export declare const formItemValidateStates: readonly ["", "error", "validating", "success"];
+export type FormItemValidateState = (typeof formItemValidateStates)[number];
+export type FormLabelWidthContext = ReturnType<typeof useFormLabelWidth>;
+export interface FormItemRule extends RuleItem {
+    trigger?: Arrayable<string>;
+}
+export type FormRules = Partial<Record<string, Arrayable<FormItemRule>>>;
+export type FormValidationResult = Promise<boolean>;
+export type FormValidateCallback = (isValid: boolean, invalidFields?: ValidateFieldsError) => void;
+export interface FormValidateFailure {
+    errors: ValidateError[] | null;
+    fields: ValidateFieldsError;
+}
+export type FormContext = FormProps & UnwrapRef<FormLabelWidthContext> & {
+    emit: SetupContext['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 type ComponentSize = '' | 'default' | 'small' | 'large';
+export interface FormItemContext extends FormItemProps {
+    $el: HTMLDivElement | undefined;
+    size: ComponentSize;
+    validateState: FormItemValidateState;
+    isGroup: boolean;
+    labelId: string;
+    inputIds: string[];
+    hasLabel: boolean;
+    addInputId: (id: string) => void;
+    removeInputId: (id: string) => void;
+    validate: (trigger: string, callback?: FormValidateCallback) => FormValidationResult;
+    resetField(): void;
+    clearValidate(): void;
+}

package/es/app-components/form/utils.d.ts

@@ -0,0 +1,9 @@
+import type { Arrayable } from '../types';
+import type { FormItemProps } from './form-item.vue';
+import type { FormItemContext } from './types';
+export declare function useFormLabelWidth(): {
+    autoLabelWidth: import("vue").ComputedRef<string>;
+    registerLabelWidth: (val: number, oldVal: number) => void;
+    deregisterLabelWidth: (val: number) => void;
+};
+export declare const filterFields: (fields: FormItemContext[], props: Arrayable<FormItemProps>) => FormItemContext[];

package/es/app-components/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export * from './use-id';
+export * from './use-namespace';

package/es/app-components/hooks/use-id.d.ts

@@ -0,0 +1,9 @@
+import type { MaybeRef } from '@vueuse/core';
+import type { InjectionKey, Ref } from 'vue';
+export type IdInjectionContext = {
+    prefix: number;
+    current: number;
+};
+export declare const ID_INJECTION_KEY: InjectionKey<IdInjectionContext>;
+export declare const useIdInjection: () => IdInjectionContext;
+export declare const useId: (deterministicId?: MaybeRef<string>) => Ref<string>;

package/es/app-components/hooks/use-namespace.d.ts

@@ -0,0 +1,22 @@
+import type { InjectionKey, Ref } from 'vue';
+export declare const defaultNamespace = "vft";
+export declare const _bem: (namespace: string, block: string, blockSuffix: string, element: string, modifier: string) => string;
+export declare const namespaceContextKey: InjectionKey<Ref<string | undefined>>;
+export declare const useNamespace: (block: string) => {
+    namespace: string;
+    b: (blockSuffix?: string) => string;
+    e: (element?: string) => string;
+    m: (modifier?: string) => string;
+    be: (blockSuffix?: string, element?: string) => string;
+    em: (element?: string, modifier?: string) => string;
+    bm: (blockSuffix?: string, modifier?: string) => string;
+    bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+    is: {
+        (name: string, state: boolean | undefined): string;
+        (name: string): string;
+    };
+    cssVar: (object: Record<string, string | undefined>) => Record<string, string>;
+    cssVarName: (name: string) => string;
+    cssVarBlock: (object: Record<string, string | undefined>) => Record<string, string>;
+    cssVarBlockName: (name: string) => string;
+};

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

@@ -0,0 +1,3 @@
+import VftIcon, { type IconProps } from './icon.vue';
+export { type IconProps };
+export { VftIcon };

package/es/app-components/image/index.d.ts

@@ -0,0 +1,3 @@
+import VftImage from './image.vue';
+export * from './types';
+export { VftImage };

package/es/app-components/image/types.d.ts

@@ -0,0 +1,13 @@
+export type ImgFitType = 'contain' | 'cover' | 'fill' | 'none' | 'scale-down';
+export type ImagePosition = 'center' | 'top' | 'right' | 'bottom' | 'left' | string;
+export interface ImageProps {
+    src?: string;
+    alt?: string;
+    /** objectFit 属性 */
+    fit?: ImgFitType;
+    /** 图片位置，等同于原生的 object-position 属性 */
+    position?: ImagePosition;
+    width?: number | string;
+    height?: number | string;
+    radius?: number | string;
+}

package/es/app-components/index.d.ts

@@ -0,0 +1,11 @@
+export * from './image';
+export * from './overlay';
+export * from './popup';
+export * from './upload';
+export * from './icon';
+export * from './form';
+export * from './input';
+export * from './button';
+export * from './row';
+export * from './col';
+export * from './clamp';

package/es/app-components/input/index.d.ts

@@ -0,0 +1,3 @@
+import VftInput from './input.vue';
+export type { InputProps } from './input.vue';
+export { VftInput };

package/es/app-components/input/utils.d.ts

@@ -0,0 +1,6 @@
+type TextAreaHeight = {
+    height: string;
+    minHeight?: string;
+};
+export declare function calcTextareaHeight(targetElement: HTMLTextAreaElement, minRows?: number, maxRows?: number): TextAreaHeight;
+export {};

package/es/app-components/overlay/index.d.ts

@@ -0,0 +1,2 @@
+import VftOverlay from './overlay.vue';
+export { VftOverlay };

package/es/app-components/popup/index.d.ts

@@ -0,0 +1,3 @@
+import VftPopup from './popup.vue';
+export * from './types';
+export { VftPopup };

package/es/app-components/popup/types.d.ts

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

package/es/app-components/row/constants.d.ts

@@ -0,0 +1,6 @@
+import type { ComputedRef, InjectionKey } from 'vue';
+interface RowContext {
+    gutter: ComputedRef<number>;
+}
+export declare const rowContextKey: InjectionKey<RowContext>;
+export {};

package/es/app-components/row/index.d.ts

@@ -0,0 +1,5 @@
+import VftRow, { type RowProps } from './row.vue';
+export * from './constants';
+export * from './types';
+export { type RowProps };
+export { VftRow };

package/es/app-components/row/types.d.ts

@@ -0,0 +1,2 @@
+export type RowJustify = 'start' | 'center' | 'end' | 'space-around' | 'space-between' | 'space-evenly';
+export type RowAlign = 'top' | 'middle' | 'bottom';

package/es/app-components/super-form/component-map.d.ts

@@ -0,0 +1,14 @@
+import type { Component } from 'vue';
+export declare enum FormCompEnum {
+    INPUT = "input",
+    INPUT_NUMBER = "input-number",
+    INPUT_NUMBER_STEP = "input-number-step",
+    PASSWORD = "password",
+    TEXTAREA = "textarea"
+}
+declare const componentMap: Map<FormCompEnum, Component>;
+export declare function add(compName: FormCompEnum, type: Component): void;
+export declare function del(compName: FormCompEnum): void;
+declare const isInput: (type: FormCompEnum) => boolean;
+declare const isDatePicker: (type: FormCompEnum) => boolean;
+export { componentMap, isDatePicker, isInput };

package/es/app-components/super-form/index.d.ts

@@ -0,0 +1,5 @@
+import VftSuperForm from './super-form.vue';
+export { VftSuperForm };
+export * from './component-map';
+export * from './types';
+export * from './use/use-form';

package/es/app-components/super-form/types.d.ts

@@ -0,0 +1,177 @@
+import type { ButtonProps, ColProps, RowProps } from '..';
+import type { FormItemProps, FormProps } from '../form';
+import type { InternalRuleItem, RuleItem } from 'async-validator';
+import type { VNode } from 'vue';
+import type { StyleValue } from 'vue/types/jsx';
+import { FormCompEnum } from './component-map';
+import type { Arrayable, Recordable } from '../types';
+export type ButtonOptions = Partial<ButtonProps> & {
+    btnText?: string;
+};
+export type InternalNamePath = (string | number)[];
+export type NamePath = string | number | InternalNamePath;
+export type FieldMapToTime = [
+    string,
+    [
+        string,
+        string
+    ],
+    (string | [string, string])?
+][];
+export type Rule = {
+    trigger?: 'blur' | 'change' | ['change', 'blur'];
+};
+type FormItemRule = Omit<RuleItem, 'validator'> & Rule & {
+    validator?: (rule: InternalRuleItem, value: any, callback?: (error?: string | Error) => void) => Promise<any>;
+} & {
+    isNumber?: boolean;
+};
+export interface RenderCallbackParams {
+    schema: FormSchema;
+    values: Recordable;
+    model: Recordable;
+    field: string;
+}
+export interface FormActionType {
+    submit: () => Promise<void>;
+    setFieldsValue: (values: Recordable) => Promise<void>;
+    resetFields: (props?: FormItemProps | FormItemProps[]) => Promise<void>;
+    getFieldsValue: () => Recordable;
+    getFieldValue: (field: string) => string | number | Recordable;
+    clearValidate: (name?: string | string[]) => Promise<void>;
+    updateSchema: (data: Partial<FormSchema> | Partial<FormSchema>[]) => Promise<void>;
+    resetSchema: (data: Partial<FormSchema> | Partial<FormSchema>[]) => Promise<void>;
+    setProps: (formProps: Partial<SuperFormProps>) => Promise<void>;
+    removeSchemaByField: (field: string | string[]) => Promise<void>;
+    setSubmitLoading: (loading?: boolean) => Promise<void>;
+    appendSchemaByField: (schema: FormSchema | FormSchema[], prefixField: string | undefined, first?: boolean | undefined) => Promise<void>;
+    validateField: (nameList?: NamePath[]) => Promise<any>;
+    validate: (nameList?: NamePath[]) => Promise<any>;
+    scrollToField: (name: NamePath, options?: ScrollOptions) => Promise<void>;
+    setFormItemError: (field: string, errMess: string) => Promise<void>;
+}
+export interface SuperFormActionProps {
+    showResetButton?: boolean;
+    showSubmitButton?: boolean;
+    showCommonButton?: boolean;
+    resetButtonOptions?: ButtonOptions;
+    submitButtonOptions?: ButtonOptions;
+    commonButtonOptions?: ButtonOptions;
+    actionRowOptions?: Partial<RowProps>;
+}
+type FormInnerProps = FormProps & SuperFormActionProps;
+export interface SuperFormProps extends FormInnerProps {
+    /** 配置表单的 RowProps */
+    rowProps?: RowProps;
+    /** 配置所有选子项的 ColProps */
+    baseColProps?: Partial<ColProps>;
+    /** 根据 1/2/3...快速分列 */
+    quickColSpan?: number;
+    /** 自动设置占位符 */
+    autoSetPlaceHolder?: boolean;
+    /** 表单配置 */
+    schemas?: FormSchema[];
+    /** 是否聚焦第一个输入框，只在第一个表单项为 input 的时候作用 */
+    autoFocusFirstItem?: boolean;
+    /** 重置时是否提交表单 */
+    submitOnReset?: boolean;
+    /** 额外传递到子组件的参数 values */
+    mergeDynamicData?: Recordable;
+    /** 将表单内时间区域的值映射成 2 个字段 */
+    fieldMapToTime?: FieldMapToTime;
+    /** 在input中输入时按回车自动提交 */
+    autoSubmitOnEnter?: boolean;
+    /** 如果表单项有校验，会自动生成校验信息，该参数控制是否将字段中文名字拼接到自动生成的信息后方 */
+    rulesMessageJoinLabel?: boolean;
+    /** 表单改变时触发提交 */
+    submitOnChange?: boolean;
+    /** 是否显示操作按钮(重置/提交) */
+    showActionButtonGroup?: boolean;
+    /** 自动清除报错信息 */
+    autoCleanErrorMessage?: boolean;
+    /** 提交前置事件 */
+    beforeSubmitFunc?: () => Promise<void>;
+    /** 提交 */
+    submitFunc?: () => Promise<void>;
+    /** 监听数据是否发生改变 */
+    watchDataIsChange?: boolean;
+    /** Form 下组件宽度是否撑满 */
+    compFullWidth?: boolean;
+    /** 操作栏是否为行内 */
+    actionInline?: boolean;
+    /** 自定义 reset 事件 */
+    resetFunc?: () => Promise<void>;
+}
+export interface FormSchema {
+    /** 字段 key */
+    field: string;
+    /** 名称 label title 都可以 */
+    label?: string | VNode;
+    title?: string | VNode;
+    /** 值改变的触发事件 */
+    changeEvent?: string;
+    /** v-model 绑定的 value 值 */
+    valueField?: string;
+    /** 子 label */
+    subLabel?: string;
+    /** 是否显示 label */
+    showLabel?: boolean;
+    /** 标签宽度，如果通过，则 itemProps 配置的 labelCol 和 WrapperCol 将无效 */
+    labelWidth?: string | number;
+    /** 渲染组件 */
+    type: FormCompEnum;
+    /** 组件内置参数 */
+    componentProps?: ((opt: {
+        schema: FormSchema;
+        formActionType: FormActionType;
+        formModel: Recordable;
+    }) => Recordable) | object;
+    /** 是否为必填项 */
+    required?: boolean | ((renderCallbackParams: RenderCallbackParams) => boolean);
+    /** 组件后自定义内容 */
+    suffix?: string | number | ((values: RenderCallbackParams) => string | number) | VNode | JSX.Element | (() => JSX.Element);
+    /** 组件前自定义内容 */
+    prefix?: string | number | ((values: RenderCallbackParams) => string | number) | VNode | JSX.Element | (() => JSX.Element);
+    /** 前置内容父级样式 */
+    prefixParentStyle?: StyleValue;
+    /** 自定义规则 */
+    rules?: FormItemRule[] | FormItemRule;
+    /** 自定义报错规则是否添加自动添加 label */
+    rulesMessageJoinLabel?: boolean;
+    /** 自动生成 placeholder */
+    placeholderJoinLabel?: boolean;
+    /** form-item 参数 */
+    itemProps?: Partial<FormItemProps & {
+        title: string;
+    }>;
+    /** col 参数 */
+    colProps?: Partial<ColProps>;
+    /** 根据 1/2/3...快速分列 */
+    quickColSpan?: number;
+    /** 默认值 */
+    defaultValue?: any;
+    /** 是否自动处理与时间相关组件的默认值 */
+    isHandleDateDefaultValue?: boolean;
+    /** 栅格占据的列数 */
+    span?: number;
+    /** 动态判断当前组件是否显示，js 控制，会删除 dom */
+    ifShow?: boolean | ((renderCallbackParams: RenderCallbackParams) => boolean);
+    /** 动态判断当前组件是否显示，css 控制，不会删除 dom */
+    show?: boolean | ((renderCallbackParams: RenderCallbackParams) => boolean);
+    /** 自定义渲染组件*/
+    render?: (renderCallbackParams: RenderCallbackParams) => VNode | VNode[] | string;
+    /** 自定义渲染组件（需要自行包含 formItem）*/
+    renderColContent?: (renderCallbackParams: RenderCallbackParams) => VNode | VNode[] | string;
+    /** 自定义渲染组内部的 slot */
+    renderComponentContent?: ((renderCallbackParams: RenderCallbackParams) => any) | VNode | VNode[] | string;
+    /** 自定义 slot，渲染组件 */
+    slot?: string;
+    /** 自定义 slot，渲染组件 （需要自行包含 formItem）*/
+    colSlot?: string;
+    /** 动态判断当前组件是否禁用 */
+    dynamicDisabled?: boolean | ((renderCallbackParams: RenderCallbackParams) => boolean);
+    /** 动态判返当前组件你校验规则 */
+    dynamicRule?: (renderCallbackParams: RenderCallbackParams) => Arrayable<FormItemRule>;
+    dynamicRuleAdd?: boolean;
+}
+export {};

package/es/app-components/super-form/use/helper.d.ts

@@ -0,0 +1,17 @@
+import { FormCompEnum } from '../component-map';
+/**
+ * @description 自动创建 placeholder
+ * @example
+ * @returns
+ * @param type 组件类型
+ * @param label
+ */
+export declare function createPlaceholderMessage(type: FormCompEnum, label?: string): string;
+/**
+ * @description 处理 input 输入为数值的 val
+ * @example
+ * @returns
+ * @param type
+ * @param val
+ */
+export declare function handleInputNumberValue(type?: FormCompEnum, val?: any): any;

package/es/app-components/super-form/use/use-auto-focus.d.ts

@@ -0,0 +1,11 @@
+import type { ComputedRef, Ref } from 'vue';
+import type { FormActionType, FormSchema, SuperFormProps } from '../types';
+interface UseAutoFocusContext {
+    getSchema: ComputedRef<FormSchema[]>;
+    getProps: ComputedRef<SuperFormProps>;
+    isInitedDefault: Ref<boolean>;
+    formElRef: Ref<FormActionType>;
+}
+/** 自动聚焦处理 */
+export declare function useAutoFocus({ getSchema, getProps, formElRef, isInitedDefault, }: UseAutoFocusContext): Promise<void>;
+export {};

package/es/app-components/super-form/use/use-form-context.d.ts

@@ -0,0 +1,8 @@
+export interface FormContextProps {
+    resetAction: (props?: Record<string, any>) => Promise<void>;
+    submitAction: () => Promise<void>;
+}
+export declare function createFormContext(context: FormContextProps): {
+    state: any;
+};
+export declare function useFormContext(): any;

package/es/app-components/super-form/use/use-form-events.d.ts

@@ -0,0 +1,30 @@
+import type { ComputedRef, Ref } from 'vue';
+import type { Recordable, Fn } from '../../types';
+import type { FormActionType, FormSchema, SuperFormProps } from '../types';
+interface UseFormActionContext {
+    emit: any;
+    getProps: ComputedRef<SuperFormProps>;
+    getSchema: ComputedRef<FormSchema[]>;
+    formModel: Recordable;
+    defaultValueRef: Ref<Recordable>;
+    formElRef: Ref<FormActionType>;
+    schemaRef: Ref<FormSchema[]>;
+    handleFormValues: Fn;
+    initValues: Ref<Recordable>;
+}
+export declare function useFormEvents({ emit, getProps, formModel, getSchema, defaultValueRef, formElRef, schemaRef, handleFormValues, initValues, }: UseFormActionContext): {
+    handleSubmit: (e?: Event) => Promise<void>;
+    clearValidate: (name?: string | string[]) => Promise<void>;
+    validate: (nameList?: any[] | undefined) => Promise<any>;
+    validateField: (nameList?: any[] | undefined) => Promise<any>;
+    getFieldsValue: () => Recordable;
+    updateSchema: (data: Partial<FormSchema> | Partial<FormSchema>[]) => Promise<void>;
+    resetSchema: (data: Partial<FormSchema> | Partial<FormSchema>[]) => Promise<void>;
+    appendSchemaByField: (schema: FormSchema | FormSchema[], prefixField?: string, first?: boolean) => Promise<void>;
+    removeSchemaByField: (fields: string | string[]) => Promise<void>;
+    resetFields: (props: any) => Promise<void>;
+    setFieldsValue: (values: Recordable) => Promise<void>;
+    scrollToField: (name: any, options?: ScrollOptions | undefined) => Promise<void>;
+    getFieldValue: (field: string) => string | number | Recordable;
+};
+export {};

package/es/app-components/super-form/use/use-form-values.d.ts

@@ -0,0 +1,14 @@
+import type { ComputedRef, Ref } from 'vue';
+import type { Recordable } from '../../types';
+import type { FormSchema, SuperFormProps } from '../types';
+interface UseFormValuesContext {
+    defaultValueRef: Ref<any>;
+    getSchema: ComputedRef<FormSchema[]>;
+    getProps: ComputedRef<SuperFormProps>;
+    formModel: Recordable;
+}
+export declare function useFormValues({ defaultValueRef, getSchema, formModel, getProps, }: UseFormValuesContext): {
+    handleFormValues: (values: Recordable) => Recordable;
+    initDefault: () => void;
+};
+export {};