@formkit/core

add: (node: FormKitNode, index?: number) => FormKitNode

address: FormKitAddress

addProps: (props: string[]) => FormKitNode

at: (address: FormKitAddress | string) => FormKitNode | undefined

children: Array<FormKitNode>

clearErrors: (clearChildren?: boolean, sourceKey?: string) => FormKitNode

config: FormKitConfig

define: (definition: FormKitTypeDefinition) => void

destroy: () => void

each: (callback: FormKitChildCallback) => void

emit: (event: string, payload?: any, bubble?: boolean, meta: Record<string, unknown>) => FormKitNode

extend: (property: string, trap: FormKitTrap) => FormKitNode

find: (
 selector: string,
 searcher?: keyof FormKitNode | FormKitSearchFunction
) => FormKitNode | undefined

hook: FormKitHooks

index: number

input: (value: unknown, async?: boolean) => Promise<unknown>

isCreated: boolean

isSettled: boolean

ledger: FormKitLedger

name: string

off: (receipt: string) => FormKitNode

on: (eventName: string, listener: FormKitEventListener) => string

parent: FormKitNode | null

props: Partial<FormKitProps>

remove: (node: FormKitNode) => FormKitNode

reset: () => FormKitNode

root: FormKitNode

setErrors: (localErrors: ErrorMessages, childErrors?: ErrorMessages) => void

settled: Promise<unknown>

store: FormKitStore

submit: () => void

t: (key: string | FormKitTextFragment) => string

type: FormKitNodeType

use: (
 plugin: FormKitPlugin | FormKitPlugin[] | Set<FormKitPlugin>,
 run?: boolean,
 library?: boolean
) => FormKitNode

readonly value: unknown

walk: (callback: FormKitChildCallback, stopOnFalse?: boolean, recurseOnFalse?: boolean) => void

bfs(tree: FormKitNode, searchValue: string | number, searchGoal?: keyof FormKitNode | FormKitSearchFunction): FormKitNode | undefined;

clearErrors(id: string, clearChildren?: boolean): void;

compile(expr: string): FormKitCompilerOutput;

let name = {
  value: 'jon'
}
const condition = compile("$name == 'bob'").provide((token) => {
 return () => name.value // 必须返回一个函数！
})

condition() // false

createClasses(propertyKey: string, node: FormKitNode, sectionClassList?: FormKitClasses | string | Record<string, boolean>): Record<string, boolean>;

createConfig(options?: Partial<FormKitConfig>): FormKitRootConfig;

createMessage(conf: Partial<FormKitMessage>, node?: FormKitNode): FormKitMessageProps;

createNode<V = unknown>(options?: FormKitOptions): FormKitNode<V>;

import { createNode } from '@formkit/core'

const input = createNode({
  type: 'input', // 如果未指定，默认为 'input'
  value: 'hello node world',
})

console.log(input.value)
// 'hello node world'

createValue(options: FormKitOptions): unknown;

deregister(node: FormKitNode): void;

error(code: number, data?: any): never;

generateClassList(node: FormKitNode, property: string, ...args: Record<string, boolean>[]): string | null;

getNode(id: string): FormKitNode | undefined;

isComponent(node: string | Record<PropertyKey, any>): node is FormKitSchemaComponent;

isConditional(node: FormKitSchemaNode): node is FormKitSchemaCondition;
isConditional(node: FormKitSchemaAttributesCondition | FormKitSchemaAttributes): node is FormKitSchemaAttributesCondition;

isDOM(node: string | Record<PropertyKey, any>): node is FormKitSchemaDOMNode;

isList(arg: FormKitContextShape): arg is FormKitListContext;

isNode(node: any): node is FormKitNode;

import { isNode, createNode } from '@formkit/core'

const input = createNode({
  type: 'input', // 如果未指定，默认为 'input'
  value: 'hello node world',
})

const obj = {};

isNode(obj)
// false

isNode(input)
// true

isPlaceholder(node: FormKitNode | FormKitPlaceholderNode): node is FormKitPlaceholderNode;

isSugar(node: FormKitSchemaNode): node is FormKitSchemaFormKit;

names(children: FormKitNode[]): {
    [index: string]: FormKitNode;
};

register(node: FormKitNode): void;

reset(id: string | FormKitNode, resetTo?: unknown): FormKitNode | undefined;

resetCount(): void;

resetRegistry(): void;

setErrors(id: string, localErrors: ErrorMessages, childErrors?: ErrorMessages): void;

submitForm(id: string): void;

sugar<T extends FormKitSchemaNode>(node: T): Exclude<FormKitSchemaNode, string | FormKitSchemaFormKit>;

warn(code: number, data?: any): void;

watchRegistry(id: string, callback: FormKitEventListener): void;

interface FormKitChildCallback {
    (child: FormKitNode): any;
}

interface FormKitChildValue {
    from?: number | symbol;
    name: string | number | symbol;
    value: any;
}

interface FormKitClasses {
    (node: FormKitNode, sectionKey: string): string | Record<string, boolean>;
}

interface FormKitCompilerOutput {
    (tokens?: Record<string, any>): boolean | number | string;
    provide: FormKitCompilerProvider;
}

interface FormKitConfig {
    [index: string]: any;
    classes?: Record<string, FormKitClasses | string | Record<string, boolean>>;
    delimiter: string;
    rootClasses: ((sectionKey: string, node: FormKitNode) => Record<string, boolean>) | false;
    rootConfig?: FormKitRootConfig;
}

interface FormKitContext {
    _d: number;
    _e: FormKitEventEmitter;
    _resolve: ((value: unknown) => void) | false;
    _tmo: number | false;
    _value: unknown;
    children: Array<FormKitNode | FormKitPlaceholderNode>;
    config: FormKitConfig;
    context?: FormKitFrameworkContext;
    hook: FormKitHooks;
    isCreated: boolean;
    isSettled: boolean;
    ledger: FormKitLedger;
    name: string | symbol;
    parent: FormKitNode | null;
    plugins: Set<FormKitPlugin>;
    props: Partial<FormKitProps>;
    settled: Promise<unknown>;
    store: FormKitStore;
    sync: boolean;
    traps: FormKitTraps;
    type: FormKitNodeType;
    uid: symbol;
    value: unknown;
}

interface FormKitContextShape {
    _value: unknown;
    type: FormKitNodeType;
    value: unknown;
}

interface FormKitCounter {
    condition: FormKitCounterCondition;
    count: number;
    name: string;
    node: FormKitNode;
    promise: Promise<void>;
    resolve: () => void;
}

interface FormKitCounterCondition {
    (message: FormKitMessage): boolean;
}

interface FormKitDispatcher<T> {
    (dispatchable: FormKitMiddleware<T>): number;
    dispatch: (payload: T) => T;
    remove: (dispatchable: FormKitMiddleware<T>) => void;
    unshift: (dispatchable: FormKitMiddleware<T>) => number;
}

interface FormKitEvent {
    bubble: boolean;
    meta?: Record<string, unknown>;
    name: string;
    origin: FormKitNode;
    payload: any;
}

interface FormKitEventEmitter {
    (node: FormKitNode, event: FormKitEvent): void;
    flush: () => void;
    off: (receipt: string) => void;
    on: (eventName: string, listener: FormKitEventListener) => string;
    pause: (node?: FormKitNode) => void;
    play: (node?: FormKitNode) => void;
}

interface FormKitEventListener {
    (event: FormKitEvent): void;
    receipt?: string;
}

interface FormKitExtendableSchemaRoot {
    (extensions: Record<string, Partial<FormKitSchemaNode> | FormKitSchemaCondition>): FormKitSchemaDefinition;
    memoKey?: string;
}

interface FormKitFrameworkContext<T = any> {
    __root?: Document | ShadowRoot;
    _value: T;
    [index: string]: unknown;
    attrs: Record<string, any>;
    classes: Record<string, string>;
    defaultMessagePlacement: boolean;
    fns: Record<string, (...args: any[]) => any>;
    handlers:{
        blur: () => void;
        touch: () => void;
        DOMInput: (e: Event) => void;
    }&Record<string, (...args: any[]) => void>;
    help?: string;
    id: string;
    items: symbol[];
    label?: string;
    messages: Record<string, FormKitMessage>;
    node: FormKitNode;
    options?: Array<Record<string, any>&{
        label: string;
        value: any;
    }>;
    slots: Record<string, CallableFunction>;
    state: FormKitFrameworkContextState;
    type: string;
    value: T;
}

interface FormKitFrameworkContextState {
    [index: string]: boolean;
    blurred: boolean;
    complete: boolean;
    dirty: boolean;
    errors: boolean;
    rules: boolean;
    settled: boolean;
    submitted: boolean;
    valid: boolean;
    validationVisible: boolean;
}

interface FormKitGroupValue {
    __init?: boolean;
    [index: string]: unknown;
}

interface FormKitHandlerPayload {
    code: number;
    data: any;
    message?: string;
}

interface FormKitHooks {
    classes: FormKitDispatcher<{
        property: string;
        classes: Record<string, boolean>;
    }>;
    commit: FormKitDispatcher<any>;
    error: FormKitDispatcher<string>;
    init: FormKitDispatcher<FormKitNode>;
    input: FormKitDispatcher<any>;
    message: FormKitDispatcher<FormKitMessage>;
    prop: FormKitDispatcher<{
        prop: string | symbol;
        value: any;
    }>;
    schema: FormKitDispatcher<FormKitSchemaNode[] | FormKitSchemaCondition>;
    setErrors: FormKitDispatcher<{
        localErrors: ErrorMessages;
        childErrors?: ErrorMessages;
    }>;
    submit: FormKitDispatcher<Record<string, any>>;
    text: FormKitDispatcher<FormKitTextFragment>;
}

interface FormKitInputMessages {
    [address: string]: FormKitMessage[];
}

interface FormKitLedger {
    count: (name: string, condition?: FormKitCounterCondition, increment?: number) => Promise<void>;
    init: (node: FormKitNode) => void;
    merge: (child: FormKitNode) => void;
    settled: (name: string) => Promise<void>;
    unmerge: (child: FormKitNode) => void;
    value: (name: string) => number;
}

interface FormKitLibrary {
    [index: string]: FormKitTypeDefinition;
}

interface FormKitListContext {
    _value: FormKitListContextValue;
    type:'list';
    value: FormKitListContextValue;
}

interface FormKitMessageMeta {
    [index: string]: any;
    i18nArgs?: any[];
    messageKey?: string;
}

interface FormKitMessageProps {
    blocking: boolean;
    key: string;
    meta: FormKitMessageMeta;
    type: string;
    value?: string | number | boolean;
    visible: boolean;
}

interface FormKitMessageStore {
    [index: string]: FormKitMessage;
}

interface FormKitNodeExtensions {
}

interface FormKitPlaceholderNode<V = unknown> {
    __FKP: true;
    _value: V;
    input: (value: unknown, async?: boolean) => Promise<unknown>;
    isSettled: boolean;
    name: string;
    type: FormKitNodeType;
    uid: symbol;
    use: (...args: any[]) => void;
    value: V;
}

interface FormKitPlugin {
    (node: FormKitNode): false | any | void;
    library?: (node: FormKitNode) => void;
}

interface FormKitSchemaAttributesCondition {
    else?: FormKitAttributeValue;
    if: string;
    then: FormKitAttributeValue;
}

interface FormKitSchemaComposable {
    (extendWith?: Partial<FormKitSchemaNode>, children?: string | FormKitSchemaNode[] | FormKitSchemaCondition, ...args: any[]): FormKitSchemaNode;
}

interface FormKitSchemaContext {
    __FK_SCP: Map<symbol, Record<string, any>>;
    [index: string]: any;
}

interface FormKitSchemaProps {
    bind?: string;
    children?: string | FormKitSchemaNode[] | FormKitSchemaCondition;
    for?: FormKitListStatement;
    if?: string;
    key?: string;
    meta?: FormKitSchemaMeta;
}

interface FormKitStoreTraps {
    apply: (messages: Array<FormKitMessage> | FormKitInputMessages, clear?: MessageClearer) => void;
    filter: (callback: (message: FormKitMessage) => boolean, type?: string) => FormKitStore;
    reduce:<T>(reducer: (accumulator: T, message: FormKitMessage) => T, accumulator: T) => T;
    release: () => void;
    remove: (key: string) => FormKitStore;
    set: (message: FormKitMessageProps) => FormKitStore;
    touch: () => void;
}

interface FormKitTrap {
    get: TrapGetter;
    set: TrapSetter;
}

interface KeyedValue {
    [index: number]: any;
    [index: string]: any;
}

export type ChildMessageBuffer = Map<string, Array<[FormKitMessage[], MessageClearer | undefined]>>;

export type ErrorMessages = string | string[] | Record<string, string | string[]>;

export type FormKitAddress = Array<string | number>;

export type FormKitAttributeValue = string | number | boolean | undefined | FormKitSchemaAttributes | FormKitSchemaAttributesCondition;

export type FormKitCompilerProvider = (callback: (requirements: string[]) => Record<string, () => any>) => FormKitCompilerOutput;

export type FormKitListContextValue<T = any> = Array<T>;

export type FormKitListStatement = [value: any, key: number | string, list: FormKitListValue] | [value: any, list: FormKitListValue];

export type FormKitListValue = string | Record<string, any> | Array<string | number | Record<string, any>> | number;

export type FormKitMessage = Readonly<FormKitMessageProps>;

export type FormKitMiddleware<T = unknown> = (payload: T, next: (payload?: T) => T) => T;

export type FormKitNodeType = 'input' | 'list' | 'group';

export type FormKitOptions = Partial<Omit<FormKitContext, 'children' | 'plugins' | 'config' | 'hook'> & {
    config: Partial<FormKitConfig>;
    props: Partial<FormKitProps>;
    children: FormKitNode[] | Set<FormKitNode>;
    index?: number;
    sync: boolean;
    plugins: FormKitPlugin[];
    alias: string;
    schemaAlias: string;
}>;

export type FormKitProps = {
    __root?: Document | ShadowRoot;
    delay: number;
    id: string;
    validationLabelStrategy?: (node?: FormKitNode) => string;
    validationRules?: Record<string, (node: FormKitNode) => boolean | Promise<boolean>>;
    validationMessages?: Record<string, ((ctx: {
        name: string;
        args: any[];
        node: FormKitNode;
    }) => string) | string>;
    definition?: FormKitTypeDefinition;
    context?: FormKitFrameworkContext;
    [index: string]: any;
} & FormKitConfig;

export type FormKitRootConfig = Partial<FormKitConfig> & {
    _add: (node: FormKitNode) => void;
    _rm: (node: FormKitNode) => void;
};

export type FormKitSchemaAttributes = {
    [index: string]: FormKitAttributeValue;
} | null | FormKitSchemaAttributesCondition;

export type FormKitSchemaComponent = {
    $cmp: string;
    props?: Record<string, any>;
} & FormKitSchemaProps;

export type FormKitSchemaCondition = {
    if: string;
    then: FormKitSchemaNode | FormKitSchemaNode[];
    else?: FormKitSchemaNode | FormKitSchemaNode[];
};

export type FormKitSchemaDefinition = FormKitSchemaNode | FormKitSchemaNode[] | FormKitSchemaCondition;

export type FormKitSchemaDOMNode = {
    $el: string | null;
    attrs?: FormKitSchemaAttributes;
} & FormKitSchemaProps;

export type FormKitSchemaFormKit = {
    $formkit: string;
} & Record<string, any> & FormKitSchemaProps;

export type FormKitSchemaMeta = {
    [key: string]: string | number | boolean | undefined | null | CallableFunction | FormKitSchemaMeta;
};

export type FormKitSchemaNode = FormKitSchemaDOMNode | FormKitSchemaComponent | FormKitSchemaTextNode | FormKitSchemaCondition | FormKitSchemaFormKit;

export type FormKitSchemaTextNode = string;

export type FormKitSearchFunction = (node: FormKitNode, searchTerm?: string | number) => boolean;

export type FormKitStore = FormKitMessageStore & {
    _n: FormKitNode;
    _b: Array<[messages: FormKitMessage[], clear?: MessageClearer]>;
    _m: ChildMessageBuffer;
    _r?: string;
    buffer: boolean;
} & FormKitStoreTraps;

export type FormKitTextFragment = Partial<FormKitMessageProps> & {
    key: string;
    value: string;
    type: string;
};

export type FormKitTraps = Map<string | symbol, FormKitTrap>;

export type FormKitTypeDefinition = {
    type: FormKitNodeType;
    family?: string;
    forceTypeProp?: string;
    props?: string[];
    schema?: FormKitExtendableSchemaRoot | FormKitSchemaNode[] | FormKitSchemaCondition;
    component?: unknown;
    library?: Record<string, unknown>;
    features?: Array<(node: FormKitNode) => void>;
    schemaMemoKey?: string;
};

export type MessageClearer = string | ((message: FormKitMessage) => boolean);

export type TrapGetter = ((node: FormKitNode, context: FormKitContext, ...args: any[]) => unknown) | false;

export type TrapSetter = ((node: FormKitNode, context: FormKitContext, property: string | number | symbol, value: any) => boolean | never) | false;