@myparcel-dev/vue-form-builder 1.0.0-beta.53

package/dist/plugin/devtools/createFieldsNodes.d.ts

@@ -0,0 +1,5 @@
+import { UnwrapNestedRefs } from 'vue';
+import { CustomInspectorNode } from '@vue/devtools-api';
+import { FormInstance } from '../../types/form.types';
+
+export declare const createFieldsNodes: (form: UnwrapNestedRefs<FormInstance>) => CustomInspectorNode[];

package/dist/plugin/devtools/createFormNode.d.ts

@@ -0,0 +1,5 @@
+import { UnwrapNestedRefs } from 'vue';
+import { CustomInspectorNode } from '@vue/devtools-api';
+import { FormInstance } from '../../types/form.types';
+
+export declare const createFormNode: (name: string, form: UnwrapNestedRefs<FormInstance>) => CustomInspectorNode;

package/dist/plugin/devtools/getComponentName.d.ts

@@ -0,0 +1,3 @@
+import { FieldInstance } from '../../types/field.types';
+
+export declare const getComponentName: (field: FieldInstance) => string;

package/dist/plugin/devtools/setupDevtools.d.ts

@@ -0,0 +1,3 @@
+import { App } from '@vue/devtools-api';
+
+export declare const setupDevtools: (app: App) => void;

package/dist/plugin/devtools/types.d.ts

@@ -0,0 +1,7 @@
+export declare const PINK_500 = 15485081;
+export declare const BLUE_600 = 2450411;
+export declare const LIME_500 = 8702998;
+export declare const CYAN_400 = 2282478;
+export declare const ORANGE_400 = 16486972;
+export declare const GRAY_100 = 16053493;
+export declare const DARK = 6710886;

package/dist/symbols.d.ts

@@ -0,0 +1,6 @@
+import { InjectionKey } from 'vue';
+import { FormInstance } from './types/form.types';
+import { FieldInstance } from './types/field.types';
+
+export declare const INJECT_FORM: InjectionKey<FormInstance>;
+export declare const INJECT_ELEMENT: InjectionKey<FieldInstance<unknown, any>>;

package/dist/types/common.types.d.ts

@@ -0,0 +1,6 @@
+import { UnwrapNestedRefs } from 'vue';
+
+export type ToRecord<T> = {
+    [K in keyof T]: T[K];
+};
+export type MaybeUnwrapNestedRefs<T> = UnwrapNestedRefs<T> | T;

package/dist/types/component.types.d.ts

@@ -0,0 +1,17 @@
+import { Component } from 'vue';
+import { PromiseOr } from '@myparcel-dev/ts-utils';
+import { FieldInstance } from './field.types';
+
+export interface ComponentLifecycleHooks<I extends FieldInstance = FieldInstance> {
+    onActivated?(instance: I): PromiseOr<void>;
+    onBeforeMount?(instance: I): PromiseOr<void>;
+    onBeforeUnmount?(instance: I): PromiseOr<void>;
+    onBeforeUpdate?(instance: I): PromiseOr<void>;
+    onCreated?(instance: I): PromiseOr<void>;
+    onDeactivated?(instance: I): PromiseOr<void>;
+    onMounted?(instance: I): PromiseOr<void>;
+    onUnmounted?(instance: I): PromiseOr<void>;
+    onUpdated?(instance: I): PromiseOr<void>;
+}
+export type ComponentProps = any;
+export type ComponentOrHtmlElement<Props extends ComponentProps = ComponentProps> = string | Component<Props>;

package/dist/types/deprecated.types.d.ts

@@ -0,0 +1,35 @@
+import { FieldName, FieldSlots, FieldConfiguration, FieldInstance, FieldHooks, CreatedField, ModularCreatedField } from './field.types';
+import { ComponentProps } from './component.types';
+
+/**  @deprecated use FieldName */
+export type ElementName = FieldName;
+/**  @deprecated use FieldSlots */
+export type ElementSlots = FieldSlots;
+/** @deprecated use FieldConfiguration */
+export type BaseElementConfiguration<Props extends ComponentProps = ComponentProps> = FieldConfiguration<unknown, Props>;
+/** @deprecated use FieldConfiguration */
+export type PlainElementConfiguration<Type = unknown, Props extends ComponentProps = ComponentProps> = FieldConfiguration<Type, Props>;
+/** @deprecated use FieldConfiguration */
+export type InteractiveElementConfiguration<Type = unknown, Props extends ComponentProps = ComponentProps> = FieldConfiguration<Type, Props>;
+/** @deprecated use FieldConfiguration * */
+export type AnyElementConfiguration<Type = unknown, Props extends ComponentProps = ComponentProps> = FieldConfiguration<Type, Props>;
+/** @deprecated use FieldConfiguration */
+export type ResolvedElementConfiguration<Type = unknown, Props extends ComponentProps = ComponentProps> = FieldConfiguration<Type, Props>;
+/** @deprecated use FieldHooks */
+export type BaseElementHooks<I extends FieldInstance = FieldInstance> = FieldHooks<unknown, ComponentProps, I>;
+/** @deprecated use FieldConfiguration */
+export type PlainElementHooks<Type = unknown, Props extends ComponentProps = ComponentProps> = FieldHooks<Type, Props>;
+/** @deprecated use FieldConfiguration */
+export type InteractiveElementHooks<Type = unknown, Props extends ComponentProps = ComponentProps, I extends FieldInstance<Type, Props> = FieldInstance<Type, Props>> = FieldHooks<Type, Props, I>;
+/** @deprecated use FieldInstance */
+export type BaseFieldInstance<Props extends ComponentProps = ComponentProps> = FieldInstance<unknown, Props>;
+/**  @deprecated use FieldInstance */
+export type PlainElementInstance<Type = unknown, Props extends ComponentProps = ComponentProps> = FieldInstance<Type, Props>;
+/**  @deprecated use FieldInstance */
+export type InteractiveElementInstance<Type = unknown, Props extends ComponentProps = ComponentProps> = FieldInstance<Type, Props>;
+/** @deprecated use FieldInstance * */
+export type AnyElementInstance<Type = unknown, Props extends ComponentProps = ComponentProps> = FieldInstance<Type, Props>;
+/** @deprecated use CreatedField */
+export type CreatedElement<Type = unknown, Props extends ComponentProps = ComponentProps> = CreatedField<Type, Props>;
+/** @deprecated use ModularCreatedField */
+export type ModularCreatedElement<Type = unknown, Props extends ComponentProps = ComponentProps> = ModularCreatedField<Type, Props>;

package/dist/types/field.types.d.ts

@@ -0,0 +1,199 @@
+import { ComponentSlots } from 'vue-component-type-helpers';
+import { Ref, ComputedRef, Component, Slots } from 'vue';
+import { UnwrapNestedRefs } from '@vue/reactivity';
+import { PromiseOr, ReadonlyOr } from '@myparcel-dev/ts-utils';
+import { HookManagerInstance } from '../hooks/HookManager';
+import { Validator, ValidateFunction } from './validator.types';
+import { AnyAttributes, FunctionOr } from './utils.types';
+import { FormInstance } from './form.types';
+import { ComponentProps, ComponentOrHtmlElement } from './component.types';
+import { ToRecord } from './common.types';
+
+export type FieldName = string;
+export type FieldSlots = Slots;
+export interface CreatedField<Type = unknown, Props extends ComponentProps = ComponentProps> {
+    Component: Component<Props>;
+    field: FieldConfiguration<Type, Props>;
+    ref: Ref<Type>;
+}
+export interface ModularCreatedField<Type = unknown, Props extends ComponentProps = ComponentProps> extends CreatedField<Type, Props> {
+    /**
+     * Only available when `wrapper` is `false`.
+     * @TODO: reflect this in the type
+     */
+    Errors: Component;
+    /**
+     * Only available when `wrapper` is `false`.
+     * @TODO: reflect this in the type
+     */
+    Label: Component;
+}
+export interface FieldConfiguration<Type = unknown, Props extends ComponentProps = ComponentProps> extends FieldHooks<Type, Props> {
+    name: FieldName;
+    /**
+     * Attributes to be passed to the component.
+     */
+    attributes?: AnyAttributes;
+    /**
+     * HTML element or Vue component. Can be any type of component that renders as a Vue fragment, including JSX
+     * templates.
+     */
+    component: ComponentOrHtmlElement<Props>;
+    /**
+     * Name of the field to port errors to.
+     */
+    errorsTarget?: string;
+    /**
+     * Hooks to be registered.
+     */
+    hookNames?: ReadonlyOr<string[]>;
+    /**
+     * Element label.
+     */
+    label?: string;
+    /**
+     * Props to be passed to the component.
+     */
+    props?: Props;
+    /**
+     * Slot content to be passed to the component.
+     */
+    slots?: ComponentSlots<never>;
+    /**
+     * Selector to render the field in.
+     * @deprecated
+     */
+    teleportSelector?: string;
+    /**
+     * Visibility of the element. Defaults to true.
+     */
+    visible?: boolean;
+    /**
+     * Wrap the field in a TableFormGroup. Defaults to true.
+     */
+    wrapper?: boolean | Component;
+    /**
+     * The ref of the field. Will be created if not provided.
+     */
+    ref?: Ref<Type>;
+    validate?: ValidateFunction<Type, Props>;
+    errorMessage?: FunctionOr<string>;
+    precedence?: number;
+    validators?: Validator<Type, Props>[];
+    /**
+     * Whether the field is lazy. Defaults to false.
+     */
+    lazy?: boolean;
+    /**
+     * Whether the element is disabled. Defaults to false.
+     */
+    disabled?: boolean;
+    /**
+     * Whether the element is optional. Defaults to false.
+     */
+    optional?: boolean;
+    /**
+     * Whether the element is read-only. Defaults to false.z
+     */
+    readOnly?: boolean;
+    visibleWhen?(instance: FieldInstance<Type, Props>): PromiseOr<boolean>;
+    disabledWhen?(instance: FieldInstance<Type, Props>): PromiseOr<boolean>;
+    optionalWhen?(instance: FieldInstance<Type, Props>): PromiseOr<boolean>;
+    readOnlyWhen?(instance: FieldInstance<Type, Props>): PromiseOr<boolean>;
+}
+export interface FieldHooks<Type = unknown, Props extends ComponentProps = ComponentProps, I extends FieldInstance<Type, Props> = FieldInstance<Type, Props>> {
+    beforeFocus?(instance: I, event: FocusEvent): PromiseOr<void>;
+    focus?(instance: I, event: FocusEvent): PromiseOr<void>;
+    afterFocus?(instance: I, event: FocusEvent): PromiseOr<void>;
+    beforeClick?(instance: I): PromiseOr<void>;
+    click?(instance: I, event: MouseEvent): PromiseOr<void>;
+    afterClick?(instance: I): PromiseOr<void>;
+    beforeBlur?(instance: I, value: Type): PromiseOr<void>;
+    blur?(instance: I, event: MouseEvent): PromiseOr<void>;
+    afterBlur?(instance: I, value: Type): PromiseOr<void>;
+    beforeSanitize?(instance: I, value: Type): PromiseOr<void>;
+    afterSanitize?(instance: I, value: Type): PromiseOr<void>;
+    beforeUpdate?(instance: I, value: Type, oldValue: Type): PromiseOr<void>;
+    afterUpdate?(instance: I, value: Type, oldValueT: Type): PromiseOr<void>;
+    beforeValidate?(instance: I, value: Type): PromiseOr<void>;
+    afterValidate?(instance: I, value: Type, isValid: boolean): PromiseOr<void>;
+}
+export interface FieldInstance<Type = unknown, Props extends ComponentProps = ComponentProps> extends FieldHooks<Type, Props> {
+    ref: Ref<Type>;
+    readonly name: FieldName;
+    readonly form: FormInstance;
+    readonly component: ComponentOrHtmlElement<Props>;
+    readonly config: FieldConfiguration<Type, Props>;
+    readonly hooks: HookManagerInstance<ToRecord<FieldHooks<Type, Props>>>;
+    readonly lazy: boolean;
+    readonly wrapper: boolean | Component;
+    readonly attributes: UnwrapNestedRefs<AnyAttributes>;
+    readonly props: UnwrapNestedRefs<Props>;
+    /** @deprecated use template slots */
+    readonly slots?: FieldSlots;
+    /** @deprecated */
+    readonly teleportSelector?: string;
+    readonly label?: string;
+    readonly errorsTarget?: string;
+    readonly errors: Ref<FunctionOr<string>[]>;
+    readonly formattedErrors: ComputedRef<string[]>;
+    readonly isVisible: Ref<boolean>;
+    readonly isDirty: Ref<boolean>;
+    readonly isDisabled: Ref<boolean>;
+    readonly isOptional: Ref<boolean>;
+    readonly isReadOnly: Ref<boolean>;
+    readonly isSuspended: Ref<boolean>;
+    readonly isTouched: Ref<boolean>;
+    /**
+     * Determines whether the field is valid.
+     */
+    readonly isValid: Ref<boolean>;
+    /**
+     * Validators used to compute the value of isValid.
+     */
+    readonly validators: Ref<Validator<Type, Props>[]>;
+    /**
+     * Resets the field.
+     */
+    reset(): PromiseOr<void>;
+    /**
+     * Destroys the field.
+     */
+    destroy(): Promise<void>;
+    /**
+     * Validates the field.
+     */
+    validate(): Promise<boolean>;
+    resetValidation(): void;
+    setValue(value: Type): void;
+    setDisabled(disabled: boolean): void;
+    setOptional(optional: boolean): void;
+    setReadOnly(optional: boolean): void;
+    addError(error: string): void;
+    setVisible(value: boolean): void;
+    setInvalid(): void;
+}
+export type ElementProp<Type = unknown, Props = ComponentProps> = UnwrapNestedRefs<FieldInstance<Type, Props>>;
+export interface FieldWrapperProps<Type = unknown, Props = ComponentProps> {
+    element: ElementProp<Type, Props>;
+}
+export interface FieldProps<Type = unknown, Props = ComponentProps> extends FieldWrapperProps<Type, Props> {
+    modelValue: Type;
+}
+export type FieldEmits<Type = unknown> = (event: 'update:modelValue', value: Type) => void;
+export declare const FIELD_INSTANCE_PROPS_KEYS: readonly ["name", "isVisible", "isDirty", "isDisabled", "isOptional", "isReadOnly", "isSuspended", "isTouched", "isValid"];
+/**
+ * The properties of a field instance that are spread into the component.
+ * This can be aded to the component props definition to make the field instance available in the component.
+ */
+export type FieldInstanceProps = {
+    name?: string;
+    isVisible?: boolean;
+    isDirty?: boolean;
+    isDisabled?: boolean;
+    isOptional?: boolean;
+    isReadOnly?: boolean;
+    isSuspended?: boolean;
+    isTouched?: boolean;
+    isValid?: boolean;
+};

package/dist/types/form-builder.types.d.ts

@@ -0,0 +1,27 @@
+import { Ref } from 'vue';
+import { InstanceFormConfiguration, FormInstance, FormValues, FormConfiguration } from './form.types';
+
+export type FormBuilder = {
+    /**
+     * All registered forms.
+     */
+    forms: Ref<Record<string, FormInstance>>;
+    /**
+     * Default settings to apply to newly registered forms.
+     */
+    defaults: Ref<InstanceFormConfiguration>;
+    on(hook: 'beforeRegister', callback: () => void): void;
+    on(hook: 'afterRegister', callback: (form: FormInstance) => void): void;
+    /**
+     * Register a new form. If a form with the same name already exists, it will be overwritten.
+     */
+    register<V extends FormValues = FormValues, N extends string = string>(name: N, config?: FormConfiguration<V>): FormInstance<V>;
+    /**
+     * Retrieve a previously registered form.
+     */
+    getForm<N extends string>(name: N): FormInstance;
+    /**
+     * Set default settings to apply to newly registered forms.
+     */
+    setDefaults(options: Partial<FormConfiguration>): void;
+};

package/dist/types/form.types.d.ts

@@ -0,0 +1,202 @@
+import { Ref, ComputedRef, UnwrapNestedRefs, Component } from 'vue';
+import { ReadonlyOr, PromiseOr } from '@myparcel-dev/ts-utils';
+import { HookManagerInstance, HookUnregisterHandler } from '../hooks/HookManager';
+import { FormHook } from '../data/hooks';
+import { AnyAttributes, FunctionOr } from './utils.types';
+import { FieldConfiguration, FieldInstance } from './field.types';
+import { ComponentOrHtmlElement, ComponentProps } from './component.types';
+import { ToRecord } from './common.types';
+
+export type FormValues = Record<string | symbol, any>;
+/**
+ * The input configuration for a Form.
+ */
+export interface FormConfiguration<Values extends FormValues = FormValues> extends FormHooks<Values> {
+    /**
+     * Global configuration for all fields.
+     */
+    field?: {
+        wrapper?: ComponentOrHtmlElement;
+        /**
+         * Whether to use the element as a prop on custom elements. Defaults to true. If set to false, your component
+         * boilerplate can be more concise and omit the "element" prop without getting it as an extraneous attribute in
+         * your html. You can still access the element via injection using useElement().
+         *
+         * When the value is 'spread', the element will be spread the FieldInstanceProps from the element to the component.
+         *
+         * @see useElement
+         * @see FieldInstanceProps
+         */
+        elementProp?: boolean | 'spread';
+    };
+    /**
+     * Default configuration for all fields.
+     */
+    fieldDefaults?: Partial<Omit<FieldConfiguration, 'ref'>>;
+    /**
+     * Configuration for the form element.
+     */
+    form?: {
+        /**
+         * Attributes to apply to the outer form element.
+         */
+        attributes?: AnyAttributes;
+        /**
+         * Tag to use for the form element. Defaults to 'form'.
+         */
+        tag?: string;
+        /**
+         * Component or html element wrapping all form elements. Defaults to false.
+         */
+        wrapper?: ComponentOrHtmlElement;
+    };
+    /**
+     * Names of hooks to register.
+     */
+    hookNames?: ReadonlyOr<string[]>;
+    /**
+     * Values to initialize the form with.
+     */
+    initialValues?: Partial<Values>;
+    /**
+     * Function executed when any label is rendered.
+     */
+    renderLabel?: (input: string) => string;
+    /**
+     * Messages that are used for built-in validations.
+     */
+    validationMessages?: Record<'required' | string, FunctionOr<string>>;
+}
+export interface FormHooks<Values extends FormValues = FormValues> {
+    beforeSubmit?(form: FormInstance<Values>): PromiseOr<void>;
+    afterSubmit?(form: FormInstance<Values>): PromiseOr<void>;
+    beforeReset?(form: FormInstance<Values>): PromiseOr<void>;
+    afterReset?(form: FormInstance<Values>): PromiseOr<void>;
+    beforeValidate?(form: FormInstance<Values>): PromiseOr<void>;
+    afterValidate?(form: FormInstance<Values>): PromiseOr<void>;
+    beforeAddElement?<T extends keyof Values, Props extends ComponentProps = ComponentProps>(form: FormInstance<Values>, field: FieldInstance<Values[T], Props>): PromiseOr<void>;
+    afterAddElement?<T extends keyof Values, Props extends ComponentProps = ComponentProps>(form: FormInstance<Values>, field: FieldInstance<Values[T], Props>): PromiseOr<void>;
+    elementChange?<T extends keyof Values, Props extends ComponentProps = ComponentProps>(form: FormInstance<Values>, field: FieldInstance<Values[T], Props>, value: Values[T]): PromiseOr<void>;
+}
+export interface BaseFormInstance<Values extends FormValues = FormValues> {
+    /**
+     * Form configuration.
+     */
+    readonly config: Omit<InstanceFormConfiguration<Values>, 'fields'>;
+    /**
+     * The outer HTML element.
+     */
+    element: HTMLElement;
+    /**
+     * All fields in the form.
+     */
+    readonly fields: Ref<FieldInstance[]>;
+    /**
+     * Hooks that are registered for this form.
+     */
+    readonly hooks: HookManagerInstance<ToRecord<FormHooks>>;
+    /**
+     * Exposes whether the form is dirty.
+     */
+    readonly isDirty: ComputedRef<boolean>;
+    /**
+     * Determines whether the form is valid.
+     */
+    readonly isValid: Ref<boolean>;
+    /**
+     * An object containing all named fields in the form as {name: field} pairs.
+     */
+    readonly model: FieldsToModel<Values>;
+    /**
+     * The name of the form.
+     */
+    readonly name: string;
+    /**
+     * Computed values from all non-disabled fields.
+     */
+    readonly values: UnwrapNestedRefs<Values>;
+    /**
+     * Add a new element to the form.
+     *
+     * @internal
+     */
+    addElement<Type = unknown, Props extends ComponentProps = ComponentProps>(element: FieldConfiguration<Type, Props>): Promise<FieldInstance<Type, Props>>;
+    /**
+     * Get a field by name.
+     */
+    getField<F extends FieldInstance | null = FieldInstance | null>(name: string): F;
+    /**
+     * Get the value of a field by name.
+     * @deprecated use computed values
+     */
+    getValue<T = unknown, K extends keyof Values | string = keyof Values>(fieldName: K): K extends keyof Values ? Values[K] : T;
+    /**
+     * Get values from all non-disabled fields.
+     * @deprecated use computed values
+     */
+    getValues<T extends FormValues = Values>(): T;
+    /**
+     * Remove one or more event listeners from the form.
+     */
+    off(event: FormHook, callback?: (form: FormInstance<Values>) => void): void;
+    /**
+     * Add an event listener to the form.
+     */
+    on(event: FormHook, callback: (form: FormInstance<Values>) => void): HookUnregisterHandler;
+    /**
+     * Remove an element from the form by name.
+     *
+     * @internal
+     */
+    removeElement(name: string): void;
+    /**
+     * Reset all fields to their original state.
+     */
+    reset(): PromiseOr<void>;
+    /**
+     * Destroy the form.
+     */
+    destroy(): void;
+    /**
+     * Set the value of a field by name.
+     */
+    setValue<T = unknown, K extends keyof Values | string = keyof Values>(fieldName: K, value: K extends keyof Values ? Values[K] : T): void;
+    /**
+     * Set values for multiple fields at once.
+     */
+    setValues<T extends FormValues = Values>(values: T): void;
+    /**
+     * Submit the form.
+     */
+    submit(): PromiseOr<void>;
+    /**
+     * Validate all fields in the form.
+     */
+    validate(): PromiseOr<boolean>;
+}
+/**
+ * Initialized form configuration always contains the following properties.
+ */
+export interface InstanceFormConfiguration<V extends FormValues = FormValues> extends FormConfiguration<V> {
+    field: {
+        elementProp: boolean | 'spread';
+        wrapper?: ComponentOrHtmlElement;
+    };
+    fieldDefaults: Partial<FieldConfiguration> & {
+        attributes: AnyAttributes;
+        wrapper: boolean;
+    };
+    form: {
+        attributes: AnyAttributes;
+        tag: string;
+        wrapper?: ComponentOrHtmlElement;
+    };
+}
+export type FormInstance<Values extends FormValues = FormValues> = BaseFormInstance<Values>;
+export type FieldsToModel<Values extends FormValues> = {
+    [K in keyof Values]: FieldInstance<ComponentProps, Values[K]>;
+};
+export interface CreatedForm<Values extends FormValues = FormValues> {
+    Component: Component;
+    instance: FormInstance<Values>;
+}

package/dist/types/hooks.types.d.ts

@@ -0,0 +1,11 @@
+import { ReadonlyOr } from '@myparcel-dev/ts-utils';
+
+export type HookCallback = (...args: any[]) => any;
+export type HookManagerConfiguration<HN extends string = string> = {
+    hookNames?: ReadonlyOr<HN[]>;
+} & Record<HN, unknown>;
+export type CustomHookItem<HN extends string = string> = {
+    name: HN;
+    callback: HookCallback;
+};
+export type ResolveHook<HN extends string> = string | `before${Capitalize<HN>}` | `after${Capitalize<HN>}` | HN;

package/dist/types/utils.types.d.ts

@@ -0,0 +1,14 @@
+import { HTMLAttributes } from 'vue';
+
+export interface SelectOption<Type = string> {
+    label: string;
+    value: Type;
+}
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+export type UnionToOverloads<U> = UnionToIntersection<U extends any ? (f: U) => void : never>;
+export type PopUnion<U> = UnionToOverloads<U> extends (a: infer A) => void ? A : never;
+export type IsUnion<T> = [T] extends [UnionToIntersection<T>] ? false : true;
+export type UnionToArray<T, A extends unknown[] = []> = IsUnion<T> extends true ? UnionToArray<Exclude<T, PopUnion<T>>, [PopUnion<T>, ...A]> : [T, ...A];
+export type FunctionOr<T> = (() => T) | T;
+export type AnyAttributes = HTMLAttributes & Record<string, unknown>;
+export type StringKey<T> = Extract<keyof T, string>;

package/dist/types/validator.types.d.ts

@@ -0,0 +1,21 @@
+import { ComputedRef } from 'vue';
+import { PromiseOr } from '@myparcel-dev/ts-utils';
+import { FunctionOr } from './utils.types';
+import { FieldInstance } from './field.types';
+import { ComponentProps } from './component.types';
+
+export type ValidateFunction<Type = unknown, Props extends ComponentProps = ComponentProps> = (field: FieldInstance<Type, Props>, value: Type) => PromiseOr<boolean>;
+export interface WithComputedValidator {
+    isValid: ComputedRef<boolean>;
+}
+export interface WithMultiValidator<Type = unknown, Props extends ComponentProps = ComponentProps> {
+    validators: Validator<Type, Props>[];
+}
+export interface Validator<Type = unknown, Props extends ComponentProps = ComponentProps> {
+    validate: ValidateFunction<Type, Props>;
+    errorMessage?: FunctionOr<string>;
+    precedence?: number;
+}
+export type ValidatorWithPrecedence<Type = unknown, Props extends ComponentProps = ComponentProps> = Validator<Type, Props> & {
+    precedence: number;
+};

package/dist/utils/createField.d.ts

@@ -0,0 +1,3 @@
+import { FieldConfiguration, ModularCreatedField } from '../types/field.types';
+
+export declare const createField: <Type = unknown, Props extends unknown = any>(field: FieldConfiguration<Type, Props>) => ModularCreatedField<Type, Props>;

package/dist/utils/createForm.d.ts

@@ -0,0 +1,3 @@
+import { CreatedForm, FormConfiguration, FormValues } from '../types/form.types';
+
+export declare const createForm: <V extends FormValues = FormValues>(name: string, config?: Omit<FormConfiguration<V>, 'fields'>) => CreatedForm<V>;

package/dist/utils/defineField.d.ts

@@ -0,0 +1,8 @@
+import { FieldConfiguration } from '../types/field.types';
+
+/**
+ * Define a field for use in a form with fields array.
+ *
+ * @example defineField({name: 'name', component: 'input', props: {type: 'text'}})
+ */
+export declare const defineField: <Type = unknown, Props extends unknown = any, FC extends FieldConfiguration<Type, Props> = FieldConfiguration<Type, Props>>(field: FC) => FC;

package/dist/utils/defineForm.d.ts

@@ -0,0 +1,3 @@
+import { FormConfiguration, FormInstance, FormValues } from '../types/form.types';
+
+export declare const defineForm: <V extends FormValues = FormValues>(name: string, config?: FormConfiguration<V>) => FormInstance<V>;

package/dist/utils/generateFieldName.d.ts

@@ -0,0 +1,4 @@
+import { FieldInstance } from '../types/field.types';
+import { MaybeUnwrapNestedRefs } from '../types/common.types';
+
+export declare const generateFieldName: (field?: MaybeUnwrapNestedRefs<FieldInstance> | null, suffix?: string) => string | undefined;

package/dist/utils/getDefaultFormConfiguration.d.ts

@@ -0,0 +1,3 @@
+import { InstanceFormConfiguration } from '../types/form.types';
+
+export declare const getDefaultFormConfiguration: () => InstanceFormConfiguration;

package/dist/utils/markComponentAsRaw.d.ts

@@ -0,0 +1,4 @@
+import { Raw } from 'vue';
+import { ComponentOrHtmlElement } from '../types/component.types';
+
+export declare const markComponentAsRaw: <T extends boolean | ComponentOrHtmlElement | undefined>(value: T) => undefined | Raw<T>;

package/dist/utils/normalizeFieldConfiguration.d.ts

@@ -0,0 +1,12 @@
+import { FormInstance } from '../types/form.types';
+import { FieldConfiguration } from '../types/field.types';
+import { ComponentProps } from '../types/component.types';
+
+type PropsWithDefault = 'visible' | 'wrapper' | 'optional' | 'lazy' | 'disabled' | 'readOnly';
+export type MakeRequired<Type, Keys extends keyof Type> = Omit<Type, Keys> & Required<Pick<Type, Keys>>;
+export type NormalizedFieldConfiguration<Type, Props extends ComponentProps> = MakeRequired<FieldConfiguration<Type, Props>, PropsWithDefault>;
+/**
+ * Normalize an input field configuration with default values, optionally from a form configuration.
+ */
+export declare const normalizeFieldConfiguration: <Type = unknown, Props extends unknown = any>(input: FieldConfiguration<Type, Props>, form?: FormInstance) => NormalizedFieldConfiguration<Type, Props>;
+export {};

package/dist/utils/normalizeFormConfiguration.d.ts

@@ -0,0 +1,3 @@
+import { FormConfiguration, FormValues, InstanceFormConfiguration } from '../types/form.types';
+
+export declare const normalizeFormConfiguration: <V extends FormValues, FC extends Partial<FormConfiguration<V>>>(defaults: InstanceFormConfiguration<V>, config: FC) => InstanceFormConfiguration<V>;

package/dist/utils/toPromise.d.ts

@@ -0,0 +1,3 @@
+import { PromiseOr } from '@myparcel-dev/ts-utils';
+
+export declare const toPromise: <T>(value: PromiseOr<T>) => Promise<T>;