主题

@formkit/inputs

简介

官方的 FormKit Inputs 插件。此包含有所有原生 HTML 输入类型的源代码。阅读 inputs 文档 以获取使用说明。

辅助工具

$attrs()

通过应用一个将给定属性集合合并到节点中的高阶函数，将属性应用到给定的模式部分。

签名

$attrs(attrs: FormKitSchemaAttributes | (() => FormKitSchemaAttributes), section: FormKitSchemaExtendableSection): FormKitSchemaExtendableSection;

参数

返回

FormKitSchemaExtendableSection

$extend()

使用给定的扩展集合扩展模式节点。

签名

$extend(section: FormKitSchemaExtendableSection, extendWith: Partial<FormKitSchemaNode>): FormKitSchemaExtendableSection;

参数

  • section — 要应用扩展的部分。
  • extendWith — 要应用到部分的部分模式片段。

返回

FormKitSchemaExtendableSection

$for()

将条件应用到给定的模式部分。

签名

$for(varName: string, inName: string, section: FormKitSchemaExtendableSection): (extensions: Record<string, Partial<FormKitSchemaNode>>) => FormKitSchemaNode;

参数

  • varName — 持有当前实例的变量的名称。
  • inName — 我们正在迭代的变量。
  • section — 要重复的部分。

返回

FormKitSchemaExtendableSection

$if()

将条件应用到给定的模式部分。

签名

$if(condition: string, then: FormKitSchemaExtendableSection, otherwise?: FormKitSchemaExtendableSection): FormKitSchemaExtendableSection;

参数

  • condition — 要应用到部分的模式条件。
  • then — 如果条件为真，则应用的部分。
  • otherwise 可选 — (否则) 如果条件为假，则应用的部分。

返回

FormKitSchemaExtendableSection

$root()

创建一个根模式部分。

签名

$root(section: FormKitSchemaExtendableSection): FormKitExtendableSchemaRoot;

参数

  • section — 用于创建根的部分。

返回

FormKitSchemaExtendableSection

特性

checkboxes()

添加复选框选择支持的特性。

签名

checkboxes(node: FormKitNode): void;

参数

defaultIcon()

添加图标属性定义。

签名

defaultIcon(sectionKey: string, defaultIcon: string): (node: FormKitNode) => void;

参数

  • sectionKey — 应加载图标的位置。
  • defaultIcon — 如果在用户的 CSS 中找到匹配项，则应加载的图标。

返回

一个 FormKitPlugin。

files()

添加文件处理支持到输入的特性。

签名

files(node: FormKitNode): void;

参数

initialValue()

确保输入具有 initialValue 属性的特性。

签名

initialValue(node: FormKitNode): void;

参数

localize()

创建一个新特性，生成用于在给定组件上使用的类型为 ui 的本地化消息。

签名

localize(key: string, value?: string): (node: FormKitNode) => void;

参数

  • key — 消息的键。
  • value * 可选 * — 消息的值。

返回

一个 FormKitPlugin。

normalizeBoxes()

标准化盒子类型（复选框，单选框）的特性。

签名

normalizeBoxes(node: FormKitNode): FormKitMiddleware<{
    prop: string | symbol;
    value: any;
}>;

参数

返回

一个 FormKitMiddleware。

options()

将选项属性转换为可用值的特性，供特性或插件使用。

签名

options(node: FormKitNode): void;

参数

radios()

一个功能，用于检查正在检查的值是否为当前值。

签名

radios(node: FormKitNode): void;

参数

函数

createLibraryPlugin()

基于 FormKitLibrary 列表创建插件。

签名

createLibraryPlugin(...libraries: FormKitLibrary[]): FormKitPlugin;

参数

返回

FormKitPlugin

createSection()

创建一个新的可重用部分。

签名

createSection(section: string, el: string | null | (() => FormKitSchemaNode), fragment: true): FormKitSection<FormKitExtendableSchemaRoot>;
createSection(section: string, el: string | null | (() => FormKitSchemaNode)): FormKitSection<FormKitSchemaExtendableSection>;
createSection(section: string, el: string | (() => FormKitSchemaNode), fragment: false): FormKitSection<FormKitSchemaExtendableSection>;

参数

  • section — schema的一个单独部分
  • el — 元素或返回schema节点的函数。
  • fragment

返回

返回 FormKitExtendableSchemaRoot 或 FormKitSchemaExtendableSection。

disables()

一个功能，允许禁用此节点的子节点。

签名

disables(node: FormKitNode): void;

参数

eachSection()

在schema的每个部分上运行回调。如果stopOnCallbackReturn为true并且回调返回一个值，循环将停止并返回该值。

签名

eachSection<T>(schema: FormKitSchemaDefinition, callback: (section: FormKitSchemaComponent | FormKitSchemaDOMNode, schemaParent: FormKitSchemaNode[], schema: FormKitSchemaCondition) => T, stopOnCallbackReturn?: boolean, schemaParent?: FormKitSchemaNode[]): T | void;

参数

  • schema — 一个 FormKitSchemaNode 数组。
  • callback — 在每个部分上运行的回调。
  • stopOnCallbackReturn * 可选 * — 如果为真，如果回调返回一个值，循环将停止。
  • schemaParent * 可选 * — 当前 schema 节点的父节点。

返回

extendSchema()

使用扩展来扩展单个 schema 节点。扩展可以是任何部分节点，包括字符串。

签名

extendSchema(schema: FormKitSchemaNode, extension?: Partial<FormKitSchemaNode>): FormKitSchemaNode;

参数

  • schema — 基础 schema 节点。
  • extension * 可选 * — 要在基础 schema 节点上扩展的值。

返回

FormKitSchemaNode

findSection()

在 schema 中按名称查找部分。

签名

findSection(schema: FormKitSchemaDefinition, target: string): [false, false] | [FormKitSchemaNode[] | false, FormKitSchemaCondition];

参数

返回

schema 和部分的元组，或者如果未找到，则返回 false 和 false 的元组。

form()

一个添加提交处理器和操作部分的功能。

签名

form(node: FormKitNode): void;

参数

ignore()

一个默认应用 ignore="true" 的功能。

签名

ignore(node: FormKitNode): void;

参数

isSchemaObject()

schema 对象的类型保护。

签名

isSchemaObject(schema: Partial<FormKitSchemaNode>): schema is FormKitSchemaDOMNode | FormKitSchemaComponent | FormKitSchemaFormKit;

参数

  • schema — 如果节点是 schema 节点但不是字符串或条件，则返回 true。

返回

boolean

isSlotCondition()

检查当前的 schema 节点是否是插槽条件。

签名

isSlotCondition(node: FormKitSchemaNode): node is {
    if: string;
    then: string;
    else: FormKitSchemaNode | FormKitSchemaNode[];
};

参数

返回

boolean

示例

{
 if: '$slot.name',
 then: '$slot.name',
 else: []
} // 这个 schema node 将返回 true。

normalizeOptions()

一个函数，用于将对象数组、字符串数组或键值对对象标准化为带有值和标签属性的对象数组。

签名

normalizeOptions(options: FormKitOptionsProp): FormKitOptionsList;

参数

返回

一个 FormKitOptionsList 列表。

select()

将选项 prop 转换为可用值。

签名

select(node: FormKitNode): void;

参数

  • node — 一个 formkit 节点。

useSchema()

创建一个包含所有包装基础模式的输入模式。

签名

useSchema(inputSection: FormKitSection): FormKitSchemaExtendableSection;

参数

  • inputSection — 存储在输入部分键位置的内容。

返回

FormKitExtendableSchemaRoot

TypeScript

FormKitBaseEvents

所有 FormKit 输入可用的通用输入事件。

interface FormKitBaseEvents<Props extends FormKitInputs<Props>> {
    (event:'input', value: PropType<Props, 'value'>, node: FormKitNode): any;
    (event:'inputRaw', value: PropType<Props, 'value'>, node: FormKitNode): any;
    (event:'input-raw', value: PropType<Props, 'value'>, node: FormKitNode): any;
    (event:'update: modelValue', value: PropType<Props, 'value'>): any;
    (event:'update: model-value', value: PropType<Props, 'value'>): any;
    (event:'node', node: FormKitNode): any;
}

FormKitBaseProps

应用于所有 FormKit 输入的基础 props。这些不是实际的运行时 props，而是从 context.attrs 对象中提取的。其中许多只是传递给输入元素的 html 属性。

interface FormKitBaseProps {
    accept: string;
    action: string;
    actions:'true' | 'false' | boolean;
    dirtyBehavior:'touched' | 'compare';
    disabled:'true' | 'false' | boolean;
    enctype: string;
    help: string;
    ignore:'true' | 'false' | boolean;
    label: string;
    max: string | number;
    method: string;
    min: string | number;
    multiple:'true' | 'false' | boolean;
    placeholder: string;
    preserve:'true' | 'false' | boolean;
    preserveErrors:'true' | 'false' | boolean;
    step: string | number;
}

FormKitBaseSlots

FormKit中几乎所有的输入都有一套"基础"插槽。这就像是围绕输入本身的"三明治"，比如包装器、帮助文本、错误消息等。其他一些输入的插槽扩展了这个基础接口。

interface FormKitBaseSlots<Props extends FormKitInputs<Props>> {
    help: FormKitSlotData<Props>;
    inner: FormKitSlotData<Props>;
    input: FormKitSlotData<Props>;
    label: FormKitSlotData<Props>;
    message: FormKitSlotData<Props, {
        message: FormKitMessage;
    }>;
    messages: FormKitSlotData<Props>;
    outer: FormKitSlotData<Props>;
    prefix: FormKitSlotData<Props>;
    prefixIcon: FormKitSlotData<Props>;
    suffix: FormKitSlotData<Props>;
    suffixIcon: FormKitSlotData<Props>;
    wrapper: FormKitSlotData<Props>;
}

FormKitBoxSlots

当提供选项时，单选框和复选框输入可用的插槽。

interface FormKitBoxSlots<Props extends FormKitInputs<Props>> {
    box: FormKitSlotData<Props, OptionSlotData<Props>>;
    decorator: FormKitSlotData<Props, OptionSlotData<Props>>;
    decoratorIcon: FormKitSlotData<Props, OptionSlotData<Props>>;
    fieldset: FormKitSlotData<Props>;
    help: FormKitSlotData<Props>;
    icon: FormKitSlotData<Props, OptionSlotData<Props>>;
    inner: FormKitSlotData<Props, OptionSlotData<Props>>;
    input: FormKitSlotData<Props, OptionSlotData<Props>>;
    label: FormKitSlotData<Props, OptionSlotData<Props>>;
    legend: FormKitSlotData<Props>;
    message: FormKitSlotData<Props, {
        message: FormKitMessage;
    }>;
    messages: FormKitSlotData<Props>;
    option: FormKitSlotData<Props, OptionSlotData<Props>>;
    optionHelp: FormKitSlotData<Props, OptionSlotData<Props>>;
    options: FormKitSlotData<Props>;
    prefix: FormKitSlotData<Props, OptionSlotData<Props>>;
    suffix: FormKitSlotData<Props, OptionSlotData<Props>>;
    wrapper: FormKitSlotData<Props, OptionSlotData<Props>>;
}

FormKitConditionalProps

这些是在一个或多个输入中用作条件的属性，因此它们需要在所有输入类型上定义。这些都应该在这里明确地定义为"undefined"，然后只在使用它们的输入中在FormKitInputProps接口中定义为它们的特定类型。

interface FormKitConditionalProps {
    offValue: undefined;
    onValue: undefined;
    options: undefined;
}

FormKitEventsAsProps

在一个完美的世界中，这个接口根本不需要。然而，Vue期望接口被定义为方法重载。不幸的是，由于我们的事件接口使用泛型，UnionToIntersection无法被使用，这意味着如果我们将事件存储为具有属性键的标准接口，我们会丢失事件数据。我们找到的唯一可靠的方法是使用"标准"的方法重载方法（参见FormKitBaseEvents）来让Volar（截至2023年6月）正确识别所有定义的事件。

（基本上我们不能使用这个接口中的事件来自动产生FormKitBaseEvents，否则Volar会丢失事件数据）

这意味着我们无法从接口中获取事件名称，所以我们无法在我们的props中正确使用它们。这对于需要将事件名称作为onEventName props可用的TSX支持等事情很重要。

这个接口被用来手动修补类型系统中的这个缺口。这些类型应该与FormKitBaseEvents以及FormKitInputEvents中定义的事件一一对应。

interface FormKitEventsAsProps {
    'onUpdate: modelValue': (value: unknown, node: FormKitNode) => any;
    onInput: (value: unknown, node: FormKitNode) => any;
    onInputRaw: (value: unknown, node: FormKitNode) => any;
    onNode: (node: FormKitNode) => any;
}

FormKitFile

FormKit的合成"FileList"中的单个文件对象。

interface FormKitFile {
    file?: File;
    name: string;
}

FormKitFileSlots

文件输入可用的插槽，这些插槽扩展了基础插槽。

interface FormKitFileSlots<Props extends FormKitInputs<Props>> extends FormKitBaseSlots<Props> {
    fileItem: FormKitSlotData<Props>;
    fileItemIcon: FormKitSlotData<Props, {
        file: FormKitFile;
    }>;
    fileList: FormKitSlotData<Props>;
    fileName: FormKitSlotData<Props, {
        file: FormKitFile;
    }>;
    fileRemove: FormKitSlotData<Props, {
        file: FormKitFile;
    }>;
    fileRemoveIcon: FormKitSlotData<Props, {
        file: FormKitFile;
    }>;
    noFiles: FormKitSlotData<Props>;
}

FormKitInputEvents

每个FormKit输入发出的独特事件。这个接口的形状是：

interface FormKitInputEvents<Props extends Inputs> {
  typeString: { customEvent: (value: PropType<Props, 'value'>) => any } // <-- All unique events
}

所有输入也将继承来自FormKitBaseInputEvents的所有事件。

interface FormKitInputEvents<Props extends FormKitInputs<Props>> {
    form:{
        (event:'submit-raw', e: Event, node: FormKitNode): any;
        (event:'submit-invalid', node: FormKitNode): any;
        (event:'submit', data: any, node: FormKitNode): any;
    };
}

FormKitInputEventsAsProps

请参阅关于为什么需要此类型的评论。

interface FormKitInputEventsAsProps<Props extends FormKitInputs<Props>> {
    form:{
        onSubmitRaw: (e: Event, node: FormKitNode) => any;
        onSubmitInvalid: (node: FormKitNode) => any;
        onSubmit: (data: any, node: FormKitNode) => any;
    };
}

FormKitInputProps

这是为FormKit组件提供prop定义的基础接口。它用于定义通过使用区分联合类型在FormKit库的每个组件中可用的props。这个接口的结构是：

interface FormKitInputProps {
 typeString: { type: 'string'; value?: string } // <-- 所有独特的props
}

所有输入也将继承FormKitBaseInputProps的所有props。

注意：所有输入都必须提供类型和值prop。

interface FormKitInputProps<Props extends FormKitInputs<Props>> {
    _:{
        type?: Props['type']extendskeyofFormKitInputProps<Props>?never: Props['type'];
        value?: string;
    };
    button:{
        type:'button';
        value?: undefined;
    };
    checkbox:{
        type:'checkbox';
        options?: FormKitOptionsProp;
        onValue?: any;
        offValue?: any;
        value?: Props['options']extendsRecord<inferT, string>?T[]: Props['options']extendsFormKitOptionsItem[]?Array<Props['options'][number]['value']>: Props['options']extendsArray<inferT>?T[]: (Props['onValue']extendsAllReals?Props['onValue']: true) | (Props['offValue']extendsAllReals?Props['offValue']: false);
    };
    color:{
        type:'color';
        value?: string;
    };
    date:{
        type:'date';
        value?: string;
    };
    datetimeLocal:{
        type:'datetimeLocal';
        value?: string;
    };
    email:{
        type:'email';
        value?: string;
    };
    file:{
        type:'file';
        value?: FormKitFile[];
    };
    form:{
        type:'form';
        value?: FormKitGroupValue;
        actions?: boolean | string;
        submitAttrs?: Record<string, any>;
        submitBehavior?:'disabled' | 'live';
        incompleteMessage?: false | string;
    };
    group:{
        type:'group';
        value?: FormKitGroupValue;
    };
    hidden:{
        type:'hidden';
        value?: string;
    };
    list:{
        type:'list';
        value?: unknown[];
        dynamic?: boolean | 'true' | 'false';
        sync?: boolean | 'true' | 'false';
    };
    month:{
        type:'month';
        value?: string;
    };
    number:{
        type:'number';
        value?: string;
    };
    password:{
        type:'password';
        value?: string;
    };
    radio:{
        type:'radio';
        options: FormKitOptionsProp;
        value?: FormKitOptionsValue<Props['options']>;
    };
    range:{
        type:'range';
        value?: string;
    };
    search:{
        type:'search';
        value?: string;
    };
    select:{
        type:'select';
        options?: FormKitOptionsProp;
        value?: FormKitOptionsValue<Props['options']>;
    };
    submit:{
        type:'submit';
        value?: string;
    };
    tel:{
        type:'tel';
        value?: string;
    };
    text:{
        type:'text';
        value?: string;
    };
    textarea:{
        type:'textarea';
        value?: string;
    };
    time:{
        type:'time';
        value?: string;
    };
    url:{
        type:'url';
        value?: string;
    };
    week:{
        type:'week';
        value?: string;
    };
}

FormKitInputSlots

每个FormKit输入提供的插槽。这个接口的形状是：

interface FormKitInputSlots<Props extends Inputs> {
  typeString: { default: (value: PropType<Props, 'value'>) => any } // <-- 所有独特的插槽
}

插槽没有自动继承 - 每个插槽必须为每个输入明确定义。

interface FormKitInputSlots<Props extends FormKitInputs<Props>> {
    button: FormKitButtonSlots<Props>;
    checkbox: Props['options']extendsAllReals?FormKitBoxSlots<Props>: FormKitBaseSlots<Props>;
    color: FormKitTextSlots<Props>;
    date: FormKitTextSlots<Props>;
    datetimeLocal: FormKitTextSlots<Props>;
    email: FormKitTextSlots<Props>;
    file: FormKitFileSlots<Props>;
    form:{
        form: FormKitSlotData<Props>;
        default: FormKitSlotData<Props>;
        message: FormKitSlotData<Props, {
        message: FormKitMessage;
    }>;
        messages: FormKitSlotData<Props>;
        actions: FormKitSlotData<Props>;
        submit: FormKitSlotData<Props>;
    };
    group:{
        default: FormKitSlotData<Props>;
    };
    hidden:{
        input: FormKitSlotData<Props>;
    };
    list:{
        default: FormKitSlotData<Props>;
    };
    month: FormKitTextSlots<Props>;
    number: FormKitTextSlots<Props>;
    password: FormKitTextSlots<Props>;
    radio: Props['options']extendsAllReals?FormKitBoxSlots<Props>: FormKitBaseSlots<Props>;
    range: FormKitTextSlots<Props>;
    search: FormKitTextSlots<Props>;
    select: FormKitSelectSlots<Props>;
    submit: FormKitButtonSlots<Props>;
    tel: FormKitTextSlots<Props>;
    text: FormKitTextSlots<Props>;
    textarea: FormKitTextSlots<Props>;
    time: FormKitTextSlots<Props>;
    url: FormKitTextSlots<Props>;
    week: FormKitTextSlots<Props>;
}

FormKitOptionsItem

选项应始终格式化为带有标签和值属性的对象数组。

interface FormKitOptionsItem<V = unknown> {
    __original?: any;
    [index: string]: any;
    attrs?:{
        disabled?: boolean;
    }&Record<string, any>;
    label: string;
    value: V;
}

FormKitOptionsPropExtensions

允许通过使用其键被忽略，但值被应用到联合类型的接口来定义属性扩展。这允许任何第三方代码通过使用模块增强来扩展选项属性，向联合类型添加新值。

interface FormKitOptionsPropExtensions {
    arrayOfNumbers: number[];
    arrayOfStrings: string[];
    optionsList: FormKitOptionsList;
    valueLabelPojo: Record<string | number, string>;
}

FormKitRuntimeProps

所有内置运行时属性的类型。

警告：在编写这些内容时，它们只特定于Vue的运行时属性要求，不应作为任何类型的外部API使用，因为它们可能会发生变化。

interface FormKitRuntimeProps<Props extends FormKitInputs<Props>> {
    classes: Record<string, string | Record<string, boolean> | FormKitClasses>;
    config: Record<string, any>;
    delay: number;
    errors: string[];
    id: string;
    index: number;
    inputErrors: Record<string, string[]>;
    modelValue: PropType<Props, 'value'>;
    name: string;
    parent: FormKitNode;
    plugins: FormKitPlugin[];
    sectionsSchema: Record<string, Partial<FormKitSchemaNode> | FormKitSchemaCondition>;
    sync: boolean | undefined;
    type: string | FormKitTypeDefinition;
    validation: string | Array<[rule: string, ...args: any]>;
    validationLabel: string | ((node: FormKitNode) => string);
    validationMessages: Record<string, string | ((ctx:{
        node: FormKitNode;
        name: string;
        args: any[];
    }) => string)>;
    validationRules: Record<string, (node: FormKitNode) => boolean | Promise<boolean>>;
}

FormKitSchemaExtendableSection

一个函数，它被调用时带有一个扩展参数，并返回一个有效的模式节点。

interface FormKitSchemaExtendableSection {
    _s?: string;
    (extensions: Record<string, Partial<FormKitSchemaNode>>): FormKitSchemaNode;
}

FormKitSection

一个函数，当被调用时，返回一个可以被带有扩展参数调用的函数。

interface FormKitSection<T = FormKitSchemaExtendableSection> {
    (...children: Array<FormKitSchemaExtendableSection | string>): T;
}

FormKitSelectSlots

可用于选择输入的插槽，这些插槽扩展了基础插槽。

interface FormKitSelectSlots<Props extends FormKitInputs<Props>> extends FormKitBaseSlots<Props> {
    default: FormKitSlotData<Props>;
    option: FormKitSlotData<Props, OptionSlotData<Props>>;
    selectIcon: FormKitSlotData<Props>;
}

FormKitSlotData

传递给每个插槽的上下文对象的形状。

interface FormKitSlotData<Props extends FormKitInputs<Props>, E extends Record<string, any> = {}> {
    (context: FormKitFrameworkContext<PropType<Props, 'value'>>&E): any;
}

FormKitTextSlots

FormKitText输入可用的插槽，这些插槽扩展了基础插槽。

interface FormKitTextSlots<Props extends FormKitInputs<Props>> extends FormKitBaseSlots<Props> {
}

OptionSlotData

具有选项范围的插槽可用的数据。

interface OptionSlotData<Props extends FormKitInputs<Props>> {
    option: FormKitOptionsItem<PropType<Props, 'value'>>;
}

AllReals

试图捕获所有非未定义的值。这用于定义各种条件，其中未定义不是一个具体的类型，但所有其他值需要采取一个逻辑分支。

export type AllReals = number | string | boolean | CallableFunction | Array<any> | null | Record<any, any>;

FormKitButtonSlots

按钮输入可用的插槽，这些插槽扩展了基础插槽。

export type FormKitButtonSlots<Props extends FormKitInputs<Props>> = Omit<FormKitBaseSlots<Props>, 'input' | 'help'> & {
    default: FormKitSlotData<Props>;
};

FormKitEvents

所有FormKit事件应包含在给定的属性集中。

export type FormKitEvents<Props extends FormKitInputs<Props>> = MergedEvents<Props>;

FormKitFileValue

一个合成的基于数组的"FileList"。

export type FormKitFileValue = FormKitFile[];

FormKitInputs

所有FormKit输入应包含在此类型中。

export type FormKitInputs<Props extends FormKitInputs<Props>> = MergedProps<Props>[keyof MergedProps<Props>];

FormKitInputSchema

要么是一个模式节点，要么是一个返回模式节点的函数。

export type FormKitInputSchema = ((children?: FormKitSchemaDefinition) => FormKitSchemaNode) | FormKitSchemaNode;

FormKitOptionsList

选项项的数组。

export type FormKitOptionsList = FormKitOptionsItem[];

FormKitOptionsProp

可以传递给选项prop的选项类型。

export type FormKitOptionsProp = FormKitOptionsPropExtensions[keyof FormKitOptionsPropExtensions];

FormKitOptionsValue

export type FormKitOptionsValue<Options> = Options extends FormKitOptionsProp ? Options extends Record<infer T, string> ? T : Options extends FormKitOptionsItem[] ? Options[number]['value'] : Options extends Array<infer T> ? T : unknown : unknown;

InputType

如果存在，从 props 中选择 "type"，否则默认为 "text"。

export type InputType<Props extends FormKitInputs<Props>> = Props['type'] extends string ? Props['type'] : 'text';

MergedEvents

将所有事件合并为一个类型。然后将其用作结构

export type MergedEvents<Props extends FormKitInputs<Props>> = InputType<Props> extends keyof FormKitInputEvents<Props> ? FormKitBaseEvents<Props> & FormKitInputEvents<Props>[InputType<Props>] : FormKitBaseEvents<Props>;

MergedProps

输入 props、基础 props 和条件 props 的合并。然后将其用作 FormKitInputs 类型的结构。

export type MergedProps<Props extends FormKitInputs<Props>> = {
    [K in keyof FormKitInputProps<Props>]: Omit<Partial<FormKitBaseProps>, keyof FormKitInputProps<Props>[K]> & Omit<Partial<FormKitRuntimeProps<Props>>, keyof FormKitInputProps<Props>[K]> & Omit<Partial<FormKitConditionalProps>, keyof FormKitInputProps<Props>[K]> & Partial<K extends keyof FormKitInputEventsAsProps<Props> ? Omit<FormKitEventsAsProps, keyof FormKitInputEventsAsProps<Props>[K]> & FormKitInputEventsAsProps<Props>[K] : FormKitEventsAsProps> & FormKitInputProps<Props>[K];
};

PropType

从给定的 prop 中提取类型。

export type PropType<Props extends FormKitInputs<Props>, T extends keyof FormKitInputs<Props>> = Extract<FormKitInputs<Props>, {
    type: Props['type'] extends string ? Props['type'] : 'text';
}>[T];

文档

工具

关于

注册获取最新消息

©2024 FormKit, Inc. 版权所有.
主题