O plugin oficial FormKit Inputs. Este pacote contém o código fonte para todos os tipos de entrada HTML nativos. Leia a documentação de inputs para instruções de uso.
Aplica atributos a uma determinada seção de esquema aplicando uma função de ordem superior que mescla um determinado conjunto de atributos no nó.
$attrs(attrs: FormKitSchemaAttributes | (() => FormKitSchemaAttributes), section: FormKitSchemaExtendableSection): FormKitSchemaExtendableSection;
attrs — Atributos para aplicar a uma FormKitSchemaExtendableSection.section — Uma seção para aplicar atributos.FormKitSchemaExtendableSection
Estende um nó de esquema com um determinado conjunto de extensões.
$extend(section: FormKitSchemaExtendableSection, extendWith: Partial<FormKitSchemaNode>): FormKitSchemaExtendableSection;
section — Uma seção para aplicar uma extensão.extendWith — Um trecho de esquema parcial para aplicar à seção.FormKitSchemaExtendableSection
Aplica uma condição a uma determinada seção de esquema.
$for(varName: string, inName: string, section: FormKitSchemaExtendableSection): (extensions: Record<string, Partial<FormKitSchemaNode>>) => FormKitSchemaNode;
varName — O nome da variável que contém a instância atual.inName — A variável que estamos iterando.section — Uma seção para repetir.FormKitSchemaExtendableSection
Aplica uma condição a uma determinada seção de esquema.
$if(condition: string, then: FormKitSchemaExtendableSection, otherwise?: FormKitSchemaExtendableSection): FormKitSchemaExtendableSection;
condition — Uma condição de esquema para aplicar a uma seção.then — A seção que se aplica se a condição for verdadeira.otherwise opcional — (else) A seção que se aplica se a condição for falsa.FormKitSchemaExtendableSection
Cria uma seção de esquema raiz.
$root(section: FormKitSchemaExtendableSection): FormKitExtendableSchemaRoot;
section — Uma seção para transformar em raiz.FormKitSchemaExtendableSection
Um recurso que adiciona suporte à seleção de caixas de seleção.
checkboxes(node: FormKitNode): void;
node — Um FormKitNode.Adiciona definição de props de ícone.
defaultIcon(sectionKey: string, defaultIcon: string): (node: FormKitNode) => void;
sectionKey — o local onde o ícone deve ser carregado.defaultIcon — o ícone que deve ser carregado se uma correspondência for encontrada no CSS do usuário.Um FormKitPlugin.
Um recurso para adicionar suporte ao manuseio de arquivos em uma entrada.
files(node: FormKitNode): void;
node — Um FormKitNode.Um recurso que garante que a entrada tenha uma prop initialValue.
initialValue(node: FormKitNode): void;
node — Um FormKitNode.Cria um novo recurso que gera uma mensagem de localização do tipo ui para uso em um determinado componente.
localize(key: string, value?: string): (node: FormKitNode) => void;
key — A chave da mensagem.value * opcional * — O valor da mensagem.Um FormKitPlugin.
Um recurso que normaliza os tipos de caixas (caixas de seleção, rádios).
normalizeBoxes(node: FormKitNode): FormKitMiddleware<{
prop: string | symbol;
value: any;
}>;
node — Um FormKitNode.Um recurso que converte a prop de opções em valores utilizáveis, para ser usado por um recurso ou um plugin.
options(node: FormKitNode): void;
node — Um FormKitNode.Um recurso para verificar se o valor sendo verificado é o valor atual.
radios(node: FormKitNode): void;
node — Um FormKitNode.Um recurso que permite a conversão para números.
casts(node: FormKitNode): void;
node — Um FormKitNode.Cria um plugin baseado em uma lista de FormKitLibrary.
createLibraryPlugin(...libraries: FormKitLibrary[]): FormKitPlugin;
libraries — Uma ou várias FormKitLibrary.Cria uma nova seção reutilizável.
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 — Uma única seção de esquemael — O elemento ou uma função que retorna um nó de esquema.fragmentRetorna um FormKitExtendableSchemaRoot ou um FormKitSchemaExtendableSection.
Um recurso que permite desativar os filhos deste nó.
disables(node: FormKitNode): void;
node — Um FormKitNode.Executa um callback em cada seção de um esquema. Se stopOnCallbackReturn for verdadeiro e o callback retornar um valor, o loop irá parar e retornar esse valor.
eachSection<T>(schema: FormKitSchemaDefinition, callback: (section: FormKitSchemaComponent | FormKitSchemaDOMNode, schemaParent: FormKitSchemaNode[], schema: FormKitSchemaCondition) => T, stopOnCallbackReturn?: boolean, schemaParent?: FormKitSchemaNode[]): T | void;
schema — Um array FormKitSchemaNode.callback — Um callback para executar em cada seção.stopOnCallbackReturn * opcional * — Se verdadeiro, o loop irá parar se o callback retornar um valor.schemaParent * opcional * — O pai do nó de esquema atual.Estende um único nó de esquema com uma extensão. A extensão pode ser qualquer nó parcial, incluindo strings.
extendSchema(schema: FormKitSchemaNode, extension?: Partial<FormKitSchemaNode>): FormKitSchemaNode;
schema — O nó de esquema base.extension * opcional * — Os valores para estender no nó de esquema base.Encontra uma seção por nome em um esquema.
findSection(schema: FormKitSchemaDefinition, target: string): [false, false] | [FormKitSchemaNode[] | false, FormKitSchemaCondition];
schema — Um array FormKitSchemaDefinition.target — O nome da seção a ser encontrada.uma tupla do esquema e da seção ou uma tupla de false e false se não for encontrada.
Um recurso para adicionar um manipulador de envio e seção de ações.
form(node: FormKitNode): void;
node — Um FormKitNode.Um recurso que aplica ignore="true" por padrão.
ignore(node: FormKitNode): void;
node — Um FormKitNode.Um auxiliar para determinar se uma opção é um grupo ou uma opção.
isGroupOption(option: FormKitOptionsItem | FormKitOptionsGroupItem | FormKitOptionsGroupItemProp): option is FormKitOptionsGroupItem;
option — Uma opçãoGuarda de tipo para objetos de esquema.
isSchemaObject(schema: Partial<FormKitSchemaNode>): schema is FormKitSchemaDOMNode | FormKitSchemaComponent | FormKitSchemaFormKit;
schema — retorna true se o nó for um nó de esquema, mas não uma string ou condicional.boolean
Verifica se o nó de esquema atual é uma condição de slot.
isSlotCondition(node: FormKitSchemaNode): node is {
if: string;
then: string;
else: FormKitSchemaNode | FormKitSchemaNode[];
};
node — Um FormKitSchemaNode.boolean
{
if: '$slot.name',
then: '$slot.name',
else: []
} // este nó de esquema retornaria verdadeiro.
Uma função para normalizar um array de objetos, array de strings, ou objeto de chaves-valores para usar um array de objetos com propriedades de valor e rótulo.
normalizeOptions<T extends FormKitOptionsPropWithGroups>(options: T): T extends FormKitOptionsProp ? FormKitOptionsList : FormKitOptionsListWithGroups;
options — Uma FormKitOptionsProp não normalizada.Uma lista de FormKitOptionsList.
Renomeia automaticamente quaisquer entradas de rádio.
renamesRadios(node: FormKitNode): void;
node — Um nó formkit.Converte a propriedade de opções em valores utilizáveis.
select(node: FormKitNode): void;
node — Um nó formkit.Cria um esquema de entrada com todo o esquema base envolvente.
useSchema(inputSection: FormKitSection): FormKitSchemaExtendableSection;
inputSection — Conteúdo para armazenar na localização da chave da seção de entrada.Eventos de entrada gerais disponíveis para todas as entradas 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;
}
Propriedades base que devem ser aplicadas a todos os inputs do FormKit. Estas não são propriedades de tempo de execução reais e são retiradas do objeto context.attrs. Muitas destas são apenas atributos html que são passados para o elemento de input.
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;
}
Quase todos os inputs no FormKit têm um conjunto "base" de slots. Este é o "sanduíche" em torno do próprio input, como os wrappers, texto de ajuda, mensagens de erro, etc. Vários outros slots de input estendem esta interface base.
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>;
}
Os slots disponíveis para os inputs de rádio e checkbox quando as opções são fornecidas.
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>>;
}
Estas são props que são usadas como condicionais em uma ou mais entradas, e como tal, precisam ser definidas em todos os tipos de entrada. Todas devem ser definidas explicitamente como "undefined" aqui, e então definidas como seu tipo específico na interface FormKitInputProps apenas nas entradas que as utilizam.
interface FormKitConditionalProps {
number: undefined;
offValue: undefined;
onValue: undefined;
options: undefined;
}
Em um mundo perfeito, essa interface não seria necessária. No entanto, o Vue espera que as interfaces sejam definidas como sobrecargas de método. Infelizmente, como nossa interface de eventos usa genéricos, UnionToIntersection não pode ser usado, o que significa que perdemos dados de evento se armazenarmos os eventos como uma interface padrão com chaves de propriedade. A única maneira que encontramos para fazer com que o Volar (a partir de junho de 2023) reconheça corretamente todos os eventos definidos é usar a abordagem de sobrecarga de método "padrão" (veja FormKitBaseEvents).
(Basicamente, não podemos usar os eventos nesta interface para produzir automaticamente o FormKitBaseEvents sem que o Volar perca dados do evento)
Isso significa que não temos como obter os nomes dos eventos da interface, então não podemos usá-los corretamente em nossas props. Isso importa para coisas como suporte TSX, onde os nomes dos eventos precisam estar disponíveis como props onEventName.
Esta interface é usada para preencher manualmente essa lacuna no sistema de tipos. Esses tipos devem corresponder 1-1 com os eventos definidos em FormKitBaseEvents, bem como 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;
}
Um único objeto de arquivo na "FileList" sintética do FormKit.
interface FormKitFile {
file?: File;
name: string;
}
Os slots disponíveis para a entrada de arquivo, estes estendem os slots base.
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>;
}
Eventos únicos emitidos por cada entrada do FormKit. A estrutura desta interface é:
interface FormKitInputEvents<Props extends Inputs> {
typeString: { customEvent: (value: PropType<Props, 'value'>) => any } // <-- Todos os eventos únicos
}
Todas as entradas também herdarão todos os eventos de 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;
};
}
Veja o comentário no tomo sobre por que esse tipo é necessário.
interface FormKitInputEventsAsProps<Props extends FormKitInputs<Props>> {
form:{
onSubmitRaw: (e: Event, node: FormKitNode) => any;
onSubmitInvalid: (node: FormKitNode) => any;
onSubmit: (data: any, node: FormKitNode) => any;
};
}
Esta é a interface base para fornecer definições de propriedades para o componente FormKit. É usada para definir as propriedades que estão disponíveis para cada componente na biblioteca FormKit usando um tipo de união discriminada. A estrutura desta interface é:
interface FormKitInputProps {
typeString: { type: 'string'; value?: string } // <-- Todas as propriedades únicas
}
Todas as entradas também herdarão todas as propriedades de FormKitBaseInputProps.
Nota: É importante que todas as entradas forneçam um tipo e uma propriedade de valor.
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?: Props['number']extendsAllReals?number: string;
number?:'integer' | 'float' | 'true' | true;
};
list:{
type:'list';
value?: unknown[];
dynamic?: boolean | 'true' | 'false';
sync?: boolean | 'true' | 'false';
};
meta:{
type:'meta';
value?: any;
};
month:{
type:'month';
value?: string;
};
number:{
type:'number';
value?: Props['number']extendsAllReals?number: string;
number?:'integer' | 'float' | 'true' | true;
};
password:{
type:'password';
value?: string;
};
radio:{
type:'radio';
options: FormKitOptionsProp;
value?: FormKitOptionsValue<Props['options']>;
};
range:{
type:'range';
value?: Props['number']extendsAllReals?number: string;
number?:'integer' | 'float' | 'true' | true;
};
search:{
type:'search';
value?: Props['number']extendsAllReals?number | string: string;
number?:'integer' | 'float' | 'true' | true;
};
select:{
type:'select';
options?: FormKitOptionsPropWithGroups;
value?: FormKitOptionsValue<Props['options']>;
};
submit:{
type:'submit';
value?: string;
};
tel:{
type:'tel';
value?: Props['number']extendsAllReals?number | string: string;
number?:'integer' | 'float' | 'true' | true;
};
text:{
type:'text';
value?: Props['number']extendsAllReals?number | string: string;
number?:'integer' | 'float' | 'true' | true;
};
textarea:{
type:'textarea';
value?: string;
};
time:{
type:'time';
value?: string;
};
url:{
type:'url';
value?: string;
};
week:{
type:'week';
value?: string;
};
}
Slots fornecidos por cada entrada FormKit. A estrutura desta interface é:
interface FormKitInputSlots<Props extends Inputs> {
typeString: { default: (value: PropType<Props, 'value'>) => any } // <-- Todos os slots únicos
}
Não há herança automática de slots - cada slot deve ser explicitamente definido para cada entrada.
interface FormKitInputSlots<Props extends FormKitInputs<Props>> {
'datetime-local': FormKitTextSlots<Props>;
button: FormKitButtonSlots<Props>;
checkbox: Props['options']extendsAllReals?FormKitBoxSlots<Props>: FormKitBaseSlots<Props>;
color: FormKitTextSlots<Props>;
date: 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>;
};
meta:{
wrapper: 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>;
}
Grupos de opções devem sempre ser formatados como um array de objetos com grupo e opções aninhadas
interface FormKitOptionsGroupItem {
attrs?: Record<string, any>;
group: string;
options: FormKitOptionsList;
}
Grupos de opções devem sempre ser formatados como um array de objetos com grupo e opções aninhadas
interface FormKitOptionsGroupItemProp {
attrs?: Record<string, any>;
group: string;
options: FormKitOptionsProp;
}
As opções devem sempre ser formatadas como um array de objetos com propriedades de rótulo e valor.
interface FormKitOptionsItem<V = unknown> {
__original?: any;
[index: string]: any;
attrs?:{
disabled?: boolean;
}&Record<string, any>;
label: string;
value: V;
}
Permite que extensões de propriedades sejam definidas usando uma interface cujas chaves são ignoradas, mas os valores são aplicados a um tipo de união. Isso permite que qualquer código de terceiros estenda a propriedade de opções usando a ampliação do módulo para adicionar novos valores ao tipo de união.
interface FormKitOptionsPropExtensions {
arrayOfNumbers: number[];
arrayOfStrings: string[];
optionsList: FormKitOptionsList;
valueLabelPojo: Record<string | number, string>;
}
Tipagens para todas as propriedades de tempo de execução integradas.
Aviso: No momento da escrita, estas são apenas específicas para os requisitos de propriedade de tempo de execução do Vue e não devem ser usadas como qualquer tipo de API externa, pois estão sujeitas a alterações.
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>>;
}
Uma função que é chamada com um argumento de extensões e retorna um nó de esquema válido.
interface FormKitSchemaExtendableSection {
_s?: string;
(extensions: Record<string, Partial<FormKitSchemaNode>>): FormKitSchemaNode;
}
Uma função que, quando chamada, retorna uma função que por sua vez pode ser chamada com um parâmetro de extensão.
interface FormKitSection<T = FormKitSchemaExtendableSection> {
(...children: Array<FormKitSchemaExtendableSection | string | FormKitSchemaCondition>): T;
}
Os slots disponíveis para a entrada de seleção, estes estendem os slots base.
interface FormKitSelectSlots<Props extends FormKitInputs<Props>> extends FormKitBaseSlots<Props> {
default: FormKitSlotData<Props>;
option: FormKitSlotData<Props, OptionSlotData<Props>>;
selectIcon: FormKitSlotData<Props>;
}
A forma do objeto de contexto que é passado para cada slot.
interface FormKitSlotData<Props extends FormKitInputs<Props>, E extends Record<string, any> = {}> {
(context: FormKitFrameworkContext<PropType<Props, 'value'>>&E): any;
}
Os slots disponíveis para a entrada de texto FormKitText, estes estendem os slots base.
interface FormKitTextSlots<Props extends FormKitInputs<Props>> extends FormKitBaseSlots<Props> {
}
Os dados disponíveis para slots que têm uma opção no escopo.
interface OptionSlotData<Props extends FormKitInputs<Props>> {
option: FormKitOptionsItem<PropType<Props, 'value'>>;
}
Uma tentativa de capturar todos os valores não indefinidos. Isso é usado para definir várias condicionais onde indefinido não é um tipo concreto, mas todos os outros valores precisam seguir um ramo lógico.
export type AllReals = number | string | boolean | CallableFunction | Array<any> | null | Record<any, any>;
Os slots disponíveis para a entrada de botão, estes estendem os slots base.
export type FormKitButtonSlots<Props extends FormKitInputs<Props>> = Omit<FormKitBaseSlots<Props>, 'inner'> & {
default: FormKitSlotData<Props>;
};
Todos os eventos FormKit devem ser incluídos para um determinado conjunto de props.
export type FormKitEvents<Props extends FormKitInputs<Props>> = MergedEvents<Props>;
Uma "FileList" sintética baseada em array.
export type FormKitFileValue = FormKitFile[];
Todas as entradas FormKit devem ser incluídas para este tipo.
export type FormKitInputs<Props extends FormKitInputs<Props>> = MergedProps<Props>[keyof MergedProps<Props>];
Ou um nó de esquema, ou uma função que retorna um nó de esquema.
export type FormKitInputSchema = ((children?: FormKitSchemaDefinition) => FormKitSchemaNode) | FormKitSchemaNode;
Um array de itens de opção.
export type FormKitOptionsList = FormKitOptionsItem[];
Um array de itens de opção com um grupo.
export type FormKitOptionsListWithGroups = Array<FormKitOptionsItem | FormKitOptionsGroupItem>;
Um array de itens de opção com suporte a grupo — onde a opção dos grupos pode ser qualquer tipo válido de FormKitOptionsProp.
export type FormKitOptionsListWithGroupsProp = Array<FormKitOptionsItem | FormKitOptionsGroupItemProp>;
Os tipos de opções que podem ser passados para a propriedade de opções.
export type FormKitOptionsProp = FormKitOptionsPropExtensions[keyof FormKitOptionsPropExtensions];
Os tipos de opções que podem ser passados para a propriedade de opções.
export type FormKitOptionsPropWithGroups = FormKitOptionsProp | FormKitOptionsListWithGroupsProp;
A forma correta de dados a serem passados para a propriedade de opções.
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;
Seleciona o "tipo" das props se existir, caso contrário, o padrão é "texto".
export type InputType<Props extends FormKitInputs<Props>> = Props['type'] extends string ? Props['type'] : 'text';
Mescla todos os eventos em um único tipo. Isso é então usado como a estrutura para
export type MergedEvents<Props extends FormKitInputs<Props>> = InputType<Props> extends keyof FormKitInputEvents<Props> ? FormKitBaseEvents<Props> & FormKitInputEvents<Props>[InputType<Props>] : FormKitBaseEvents<Props>;
Uma fusão de props de entrada, props base e props condicionais. Isso é então usado como a estrutura para o tipo 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];
};
Extrai o tipo de uma propriedade fornecida.
export type PropType<Props extends FormKitInputs<Props>, T extends keyof FormKitInputs<Props>> = Extract<FormKitInputs<Props>, {
type: Props['type'] extends string ? Props['type'] : 'text';
}>[T];