@dazhicheng/ui 1.5.33 → 1.5.35

package/dist/components/tt-form/src/shared/zod-defaults.d.ts

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+/**
+ * A type which represents all the simple Zod types
+ * that do not require special handling.
+ */
+export type SimpleSupportedZodTypes = z.ZodBoolean | z.ZodNumber | z.ZodString | z.ZodArray<any>;
+/**
+ * A type which represents all the supported Zod types
+ * that do not require special handling.
+ *
+ * Other special types like ZodUnion, ZodIntersection, etc.
+ * require special handling and are not included in this type.
+ *
+ * TODO: Add support for missing Zod types.
+ */
+export type BaseSupportedZodTypes = SimpleSupportedZodTypes | z.ZodRecord<any, any> | z.ZodObject<any, any> | z.ZodTuple<[any, ...any[]]>;
+/**
+ * A type which represents all the supported Zod types
+ * that require special handling because they are composed
+ * of multiple Zod types.
+ *
+ * TODO: Add support for missing Zod types.
+ */
+export type AdvancedSupportedZodTypes = z.ZodDefault<any> | z.ZodOptional<any> | z.ZodUnion<any> | z.ZodIntersection<any, any>;
+/**
+ * A type which represents all the supported Zod types.
+ */
+export type SupportedZodTypes = BaseSupportedZodTypes | AdvancedSupportedZodTypes;
+/**
+ * Returns the default values as an object for the provided schema.
+ *
+ * For example, given the following schema:
+ * ```typescript
+ * const schema = z.object({
+ *   name: z.string(),
+ *   age: z.number(),
+ *   isStudent: z.boolean().default(true),
+ * });
+ * ```
+ *
+ * The default object would be:
+ * ```json
+ * {
+ *   name: "",
+ *   age: 0,
+ *   isStudent: true
+ * }
+ * ```
+ * Note the default value for `isStudent` is `true` because it is specified in
+ * the schema.
+ *
+ * @param schema
+ */
+export declare function getDefaultsForSchema<T extends z.ZodObject<any> | z.ZodUnion<any> | z.ZodIntersection<any, any>>(schema: T): Record<string, never> | z.infer<T>;

package/dist/components/tt-form/src/types/common.d.ts

@@ -0,0 +1,11 @@
+import { MaybeRef, Ref } from 'vue';
+import { Path, PathValue } from './paths';
+export type GenericObject = Record<string, any>;
+export type MaybeArray<T> = T | T[];
+export type MaybePromise<T> = T | Promise<T>;
+export type FlattenAndSetPathsType<TRecord, TType> = {
+    [K in Path<TRecord>]: TType;
+};
+export type MapValuesPathsToRefs<TValues extends GenericObject, TPaths extends readonly [...MaybeRef<Path<TValues>>[]]> = {
+    readonly [K in keyof TPaths]: TPaths[K] extends MaybeRef<infer TKey> ? TKey extends Path<TValues> ? Ref<PathValue<TValues, TKey>> : Ref<unknown> : Ref<unknown>;
+};

package/dist/components/tt-form/src/types/forms.d.ts

@@ -0,0 +1,280 @@
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { PartialDeep } from 'type-fest';
+import { ComputedRef, MaybeRef, MaybeRefOrGetter, Ref } from 'vue';
+import { FlattenAndSetPathsType, GenericObject, MapValuesPathsToRefs, MaybeArray, MaybePromise } from './common';
+import { Path, PathValue } from './paths';
+import { FieldValidationMetaInfo } from './shared';
+export type ValidationResult<TValue = unknown> = {
+    errors: string[];
+    valid: boolean;
+    value?: TValue;
+};
+export type FlattenAndMapPathsValidationResult<TInput extends GenericObject, TOutput extends GenericObject> = {
+    [K in Path<TInput>]: ValidationResult<TOutput[K]>;
+};
+export type Locator = {
+    __locatorRef: string;
+} & ((values: GenericObject) => unknown);
+export interface FieldMeta<TValue> {
+    touched: boolean;
+    dirty: boolean;
+    valid: boolean;
+    validated: boolean;
+    pending: boolean;
+    initialValue?: TValue;
+}
+export interface FormMeta<TValues extends GenericObject> {
+    touched: boolean;
+    dirty: boolean;
+    valid: boolean;
+    pending: boolean;
+    initialValues?: Partial<TValues>;
+}
+export interface FieldState<TValue = unknown> {
+    value: TValue;
+    touched: boolean;
+    errors: string[];
+}
+export type InputType = "checkbox" | "radio" | "default";
+/**
+ * validated-only: only mutate the previously validated fields
+ * silent: do not mutate any field
+ * force: validate all fields and mutate their state
+ */
+export type SchemaValidationMode = "validated-only" | "silent" | "force" | "no-validated";
+export type ValidationOptions = {
+    mode: SchemaValidationMode;
+    warn: boolean;
+};
+export type FieldValidator<TOutput> = (opts?: Partial<ValidationOptions>) => Promise<ValidationResult<TOutput>>;
+export type PathStateConfig<TOutput> = {
+    bails: boolean;
+    label: MaybeRefOrGetter<string | undefined>;
+    type: InputType;
+    validate: FieldValidator<TOutput>;
+    schema?: MaybeRefOrGetter<StandardSchemaV1 | undefined>;
+    /**
+     * 在判断 dirty 状态时需要排除的字段列表（仅对对象类型有效）
+     * @example
+     * excludeKeys: ['_timestamp']
+     */
+    excludeKeys?: string[];
+};
+export type IssueCollection<TPath = string> = {
+    path: TPath;
+    messages: string[];
+};
+export type PathState<TInput = unknown, TOutput = TInput> = {
+    id: number | number[];
+    path: string;
+    touched: boolean;
+    dirty: boolean;
+    valid: boolean;
+    validated: boolean;
+    pending: boolean;
+    initialValue: TInput | undefined;
+    value: TInput | undefined;
+    errors: string[];
+    bails: boolean;
+    label: string | undefined;
+    type: InputType;
+    multiple: boolean;
+    fieldsCount: number;
+    __flags: {
+        pendingUnmount: Record<string, boolean>;
+        pendingReset: boolean;
+    };
+    validate?: FieldValidator<TOutput>;
+};
+export type FieldEntry<TValue = unknown> = {
+    value: TValue;
+    key: string | number;
+    isFirst: boolean;
+    isLast: boolean;
+};
+export type FieldArrayContext<TValue = unknown> = {
+    fields: Ref<FieldEntry<TValue>[]>;
+    remove: (idx: number) => void;
+    replace: (newArray: TValue[]) => void;
+    update: (idx: number, value: TValue) => void;
+    push: (value: TValue) => void;
+    swap: (indexA: number, indexB: number) => void;
+    insert: (idx: number, value: TValue) => void;
+    prepend: (value: TValue) => void;
+    move: (oldIdx: number, newIdx: number) => void;
+};
+export type PrivateFieldArrayContext<TValue = unknown> = {
+    reset: () => void;
+    path: MaybeRefOrGetter<string>;
+} & FieldArrayContext<TValue>;
+export type PrivateFieldContext<TInput = unknown, TOutput = TInput> = {
+    id: number;
+    name: MaybeRef<string>;
+    value: Ref<TInput>;
+    meta: FieldMeta<TInput>;
+    errors: Ref<string[]>;
+    errorMessage: Ref<string | undefined>;
+    label?: MaybeRefOrGetter<string | undefined>;
+    type?: string;
+    bails?: boolean;
+    keepValueOnUnmount?: MaybeRefOrGetter<boolean | undefined>;
+    checkedValue?: MaybeRefOrGetter<TInput>;
+    uncheckedValue?: MaybeRefOrGetter<TInput>;
+    checked?: Ref<boolean>;
+    resetField: (state?: Partial<FieldState<TInput>>) => void;
+    handleReset: () => void;
+    validate: FieldValidator<TOutput>;
+    handleChange: (e: Event | unknown, shouldValidate?: boolean) => void;
+    handleBlur: (e?: Event, shouldValidate?: boolean) => void;
+    handleFocus: (e?: Event) => void;
+    setState: (state: Partial<FieldState<TInput>>) => void;
+    setTouched: (isTouched: boolean) => void;
+    setErrors: (message: string | string[]) => void;
+    setValue: (value: TInput, shouldValidate?: boolean) => void;
+};
+export type FieldContext<TValue = unknown> = Omit<PrivateFieldContext<TValue>, "id" | "instances">;
+export type GenericValidateFunction<TValue = unknown> = (value: TValue, ctx: FieldValidationMetaInfo) => MaybePromise<boolean | MaybeArray<string>>;
+export interface FormState<TValues> {
+    values: PartialDeep<TValues>;
+    errors: Partial<Record<Path<TValues>, string | undefined>>;
+    touched: Partial<Record<Path<TValues>, boolean>>;
+    submitCount: number;
+}
+export type FormErrors<TValues extends GenericObject> = Partial<Record<Path<TValues> | "", string | undefined>>;
+export type FormErrorBag<TValues extends GenericObject> = Partial<Record<Path<TValues> | "", string[]>>;
+export interface ResetFormOpts {
+    force?: boolean;
+}
+export interface FormActions<TValues extends GenericObject, _TOutput = TValues> {
+    setFieldValue: <T extends Path<TValues>>(field: T, value: PathValue<TValues, T>, shouldValidate?: boolean) => void;
+    setFieldError: (field: Path<TValues>, message: string | string[] | undefined) => void;
+    setErrors: (fields: Partial<FlattenAndSetPathsType<TValues, string | string[] | undefined>>) => void;
+    setValues: (fields: Partial<TValues>, shouldValidate?: boolean) => void;
+    setFieldTouched: (field: Path<TValues>, isTouched: boolean) => void;
+    setTouched: (fields: Partial<Record<Path<TValues>, boolean>> | boolean) => void;
+    resetForm: (state?: Partial<FormState<TValues>>, opts?: Partial<ResetFormOpts>) => void;
+    resetField: (field: Path<TValues>, state?: Partial<FieldState>) => void;
+}
+export interface FormValidationResult<TInput extends GenericObject, TOutput extends GenericObject = TInput> {
+    valid: boolean;
+    results: Partial<FlattenAndMapPathsValidationResult<TInput, TOutput>>;
+    errors: Partial<Record<Path<TInput>, string>>;
+    values?: Partial<TOutput>;
+    source: "schema" | "fields" | "none";
+}
+export interface SubmissionContext<TInput extends GenericObject = GenericObject> extends FormActions<TInput> {
+    evt?: Event;
+    controlledValues: Partial<TInput>;
+}
+export type SubmissionHandler<TInput extends GenericObject = GenericObject, TOutput = TInput, TReturn = unknown> = (values: TOutput, ctx: SubmissionContext<TInput>) => TReturn;
+export interface InvalidSubmissionContext<TInput extends GenericObject = GenericObject, TOutput extends GenericObject = TInput> {
+    values: TInput;
+    evt?: Event;
+    errors: Partial<Record<Path<TInput>, string>>;
+    results: FormValidationResult<TInput, TOutput>["results"];
+}
+export type InvalidSubmissionHandler<TInput extends GenericObject = GenericObject, TOutput extends GenericObject = TInput> = (ctx: InvalidSubmissionContext<TInput, TOutput>) => void;
+export type RawFormSchema<TValues> = Record<Path<TValues>, string | GenericValidateFunction | GenericObject>;
+export type FieldPathLookup<TValues extends GenericObject = GenericObject> = Partial<Record<Path<TValues>, PrivateFieldContext | PrivateFieldContext[]>>;
+type HandleSubmitFactory<TValues extends GenericObject, TOutput extends GenericObject = TValues> = <TReturn = unknown>(cb: SubmissionHandler<TValues, TOutput, TReturn>, onSubmitValidationErrorCb?: InvalidSubmissionHandler<TValues, TOutput>) => (e?: Event) => Promise<TReturn | undefined>;
+export type PublicPathState<TValue = unknown> = Omit<PathState<TValue>, "bails" | "label" | "multiple" | "fieldsCount" | "validate" | "id" | "type" | "__flags">;
+export interface BaseFieldProps {
+    onBlur: () => void;
+    onChange: () => void;
+    onInput: () => void;
+}
+export interface InputBindsConfig<TValue = unknown, TExtraProps extends GenericObject = GenericObject> {
+    props: (state: PublicPathState<TValue>) => TExtraProps;
+    validateOnBlur: boolean;
+    label: MaybeRefOrGetter<string>;
+    validateOnChange: boolean;
+    validateOnInput: boolean;
+    validateOnModelUpdate: boolean;
+}
+export type LazyInputBindsConfig<TValue = unknown, TExtraProps extends GenericObject = GenericObject> = (state: PublicPathState<TValue>) => Partial<{
+    props: TExtraProps;
+    validateOnBlur: boolean;
+    validateOnChange: boolean;
+    validateOnInput: boolean;
+    validateOnModelUpdate: boolean;
+}>;
+export interface ComponentBindsConfig<TValue = unknown, TExtraProps extends GenericObject = GenericObject, TModel extends string = "modelValue"> {
+    mapProps: (state: PublicPathState<TValue>) => TExtraProps;
+    validateOnBlur: boolean;
+    validateOnModelUpdate: boolean;
+    model: TModel;
+}
+export type LazyComponentBindsConfig<TValue = unknown, TExtraProps extends GenericObject = GenericObject, TModel extends string = "modelValue"> = (state: PublicPathState<TValue>) => Partial<{
+    props: TExtraProps;
+    validateOnBlur: boolean;
+    validateOnModelUpdate: boolean;
+    model: TModel;
+}>;
+export interface ComponentModellessBinds {
+    onBlur: () => void;
+}
+export type ComponentModelBinds<TValue = any, TModel extends string = "modelValue"> = ComponentModellessBinds & {
+    [TKey in `onUpdate:${TModel}`]: (value: TValue) => void;
+};
+export type BaseComponentBinds<TValue = any, TModel extends string = "modelValue"> = ComponentModelBinds<TValue, TModel> & {
+    [k in TModel]: TValue;
+};
+export interface BaseInputBinds<TValue = unknown> {
+    value: TValue | undefined;
+    onBlur: (e: Event) => void;
+    onChange: (e: Event) => void;
+    onInput: (e: Event) => void;
+}
+export interface PrivateFormContext<TValues extends GenericObject = GenericObject, TOutput extends GenericObject = TValues> extends FormActions<TValues> {
+    name: string;
+    formId: number;
+    values: TValues;
+    initialValues: Ref<Partial<TValues>>;
+    controlledValues: Ref<TValues>;
+    fieldArrays: PrivateFieldArrayContext[];
+    submitCount: Ref<number>;
+    schema?: MaybeRef<RawFormSchema<TValues> | StandardSchemaV1<TValues, TOutput> | undefined>;
+    errorBag: Ref<FormErrorBag<TValues>>;
+    errors: ComputedRef<FormErrors<TValues>>;
+    meta: ComputedRef<FormMeta<TValues>>;
+    isSubmitting: Ref<boolean>;
+    isValidating: Ref<boolean>;
+    keepValuesOnUnmount: MaybeRef<boolean>;
+    validateSchema?: (mode: SchemaValidationMode) => Promise<FormValidationResult<TValues, TOutput>>;
+    validate: (opts?: Partial<ValidationOptions>) => Promise<FormValidationResult<TValues, TOutput>>;
+    validateField: <TPath extends Path<TValues>>(field: TPath, opts?: Partial<ValidationOptions>) => Promise<ValidationResult<TOutput[TPath]>>;
+    stageInitialValue: (path: string, value: unknown, updateOriginal?: boolean) => void;
+    unsetInitialValue: (path: string) => void;
+    handleSubmit: HandleSubmitFactory<TValues, TOutput> & {
+        withControlled: HandleSubmitFactory<TValues, TOutput>;
+    };
+    setFieldInitialValue: (path: string, value: unknown, updateOriginal?: boolean) => void;
+    createPathState: <TPath extends Path<TValues>>(path: MaybeRef<TPath>, config?: Partial<PathStateConfig<TOutput[TPath]>>) => PathState<PathValue<TValues, TPath>>;
+    getPathState: <TPath extends Path<TValues>>(path: TPath) => PathState<PathValue<TValues, TPath>> | undefined;
+    getAllPathStates: () => PathState[];
+    removePathState: <TPath extends Path<TValues>>(path: TPath, id: number) => void;
+    unsetPathValue: <TPath extends Path<TValues>>(path: TPath) => void;
+    destroyPath: (path: string) => void;
+    isFieldTouched: <TPath extends Path<TValues>>(path: TPath) => boolean;
+    isFieldDirty: <TPath extends Path<TValues>>(path: TPath) => boolean;
+    isFieldValid: <TPath extends Path<TValues>>(path: TPath) => boolean;
+    defineField: <TPath extends Path<TValues>, TValue = PathValue<TValues, TPath>, TExtras extends GenericObject = GenericObject>(path: MaybeRefOrGetter<TPath>, config?: Partial<InputBindsConfig<TValue, TExtras>> | LazyInputBindsConfig<TValue, TExtras>) => [Ref<TValue>, Ref<BaseFieldProps & TExtras>];
+    /**
+     * @deprecated use defineField instead
+     */
+    useFieldModel: (<TPath extends Path<TValues>>(path: TPath) => Ref<PathValue<TValues, TPath>>) & (<TPaths extends readonly [...MaybeRef<Path<TValues>>[]]>(paths: TPaths) => MapValuesPathsToRefs<TValues, TPaths>);
+    /**
+     * @deprecated use defineField instead
+     */
+    defineComponentBinds: <TPath extends Path<TValues>, TValue = PathValue<TValues, TPath>, TModel extends string = "modelValue", TExtras extends GenericObject = GenericObject>(path: MaybeRefOrGetter<TPath>, config?: Partial<ComponentBindsConfig<TValue, TExtras, TModel>> | LazyComponentBindsConfig<TValue, TExtras, TModel>) => Ref<BaseComponentBinds<TValue, TModel> & TExtras>;
+    /**
+     * @deprecated use defineField instead
+     */
+    defineInputBinds: <TPath extends Path<TValues>, TValue = PathValue<TValues, TPath>, TExtras extends GenericObject = GenericObject>(path: MaybeRefOrGetter<TPath>, config?: Partial<InputBindsConfig<TValue, TExtras>> | LazyInputBindsConfig<TValue, TExtras>) => Ref<BaseInputBinds<TValue> & TExtras>;
+}
+export interface FormContext<TValues extends GenericObject = GenericObject, TOutput extends GenericObject = TValues> extends Omit<PrivateFormContext<TValues, TOutput>, "formId" | "schema" | "initialValues" | "getPathState" | "getAllPathStates" | "removePathState" | "unsetPathValue" | "validateSchema" | "stageInitialValue" | "setFieldInitialValue" | "unsetInitialValue" | "fieldArrays" | "markForUnmount" | "keepValuesOnUnmount" | "values"> {
+    values: TValues;
+    handleReset: () => void;
+    submitForm: (e?: unknown) => Promise<void>;
+}
+export {};

package/dist/components/tt-form/src/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './common';
+export * from './forms';
+export * from './paths';

package/dist/components/tt-form/src/types/paths.d.ts

@@ -0,0 +1,142 @@
+type BrowserNativeObject = Date | FileList | File;
+type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+/**
+ * Checks whether the type is any
+ * See {@link https://stackoverflow.com/a/49928360/3406963}
+ * @typeParam T - type which may be any
+ * ```
+ * IsAny<any> = true
+ * IsAny<string> = false
+ * ```
+ */
+export type IsAny<T> = 0 extends 1 & T ? true : false;
+/**
+ * Checks whether T1 can be exactly (mutually) assigned to T2
+ * @typeParam T1 - type to check
+ * @typeParam T2 - type to check against
+ * ```
+ * IsEqual<string, string> = true
+ * IsEqual<'foo', 'foo'> = true
+ * IsEqual<string, number> = false
+ * IsEqual<string, number> = false
+ * IsEqual<string, 'foo'> = false
+ * IsEqual<'foo', string> = false
+ * IsEqual<'foo' | 'bar', 'foo'> = boolean // 'foo' is assignable, but 'bar' is not (true | false) -> boolean
+ * ```
+ */
+export type IsEqual<T1, T2> = T1 extends T2 ? (<G>() => G extends T1 ? 1 : 2) extends <G>() => G extends T2 ? 1 : 2 ? true : false : false;
+/**
+ * Type to query whether an array type T is a tuple type.
+ * @typeParam T - type which may be an array or tuple
+ * @example
+ * ```
+ * IsTuple<[number]> = true
+ * IsTuple<number[]> = false
+ * ```
+ */
+type IsTuple<T extends ReadonlyArray<any>> = number extends T["length"] ? false : true;
+/**
+ * Type which can be used to index an array or tuple type.
+ */
+type ArrayKey = number;
+/**
+ * Helper function to break apart T1 and check if any are equal to T2
+ *
+ * See {@link IsEqual}
+ */
+type AnyIsEqual<T1, T2> = T1 extends T2 ? (IsEqual<T1, T2> extends true ? true : never) : never;
+/**
+ * Type which given a tuple type returns its own keys, i.e. only its indices.
+ * @typeParam T - tuple type
+ * @example
+ * ```
+ * TupleKeys<[number, string]> = '0' | '1'
+ * ```
+ */
+type TupleKeys<T extends ReadonlyArray<any>> = Exclude<keyof T, keyof any[]>;
+/**
+ * Helper type to construct tuple key paths and recurse into its elements.
+ *
+ * See {@link Path}
+ */
+type PathInternalTuple<TValue extends ReadonlyArray<any>, TraversedTypes> = {
+    [Key in TupleKeys<TValue> & string]: `[${Key}]` | `[${Key}]${PathInternal<TValue[Key], TraversedTypes, false>}`;
+}[TupleKeys<TValue> & string];
+/**
+ * Helper type to construct array key paths and recurse into its elements.
+ *
+ * See {@link Path}
+ */
+type PathInternalArray<TValue extends ReadonlyArray<any>, TraversedTypes> = `[${ArrayKey}]` | `[${ArrayKey}]${PathInternal<TValue[ArrayKey], TraversedTypes, false>}`;
+/**
+ * Helper type to construct object key paths and recurse into its nested values.
+ *
+ * See {@link Path}
+ */
+type PathInternalObject<TValue, TraversedTypes, First extends boolean> = {
+    [Key in keyof TValue & string]: First extends true ? `${Key}` | `${Key}${PathInternal<TValue[Key], TraversedTypes, false>}` : `.${Key}` | `.${Key}${PathInternal<TValue[Key], TraversedTypes, false>}`;
+}[keyof TValue & string];
+/**
+ * Helper type to construct nested any object key paths.
+ *
+ * See {@link Path}
+ */
+type PathInternalAny = `.${string}` | `[${string}]` | `[${string}].${string}`;
+/**
+ * Helper type for recursively constructing paths through a type.
+ *
+ * This obscures internal type params TraversedTypes and First from ed contract.
+ *
+ * See {@link Path}
+ */
+type PathInternal<TValue, TraversedTypes, First extends boolean> = TValue extends Primitive | BrowserNativeObject ? IsAny<TValue> extends true ? PathInternalAny : never : TValue extends ReadonlyArray<any> ? true extends AnyIsEqual<TraversedTypes, TValue> ? never : IsTuple<TValue> extends true ? PathInternalTuple<TValue, TraversedTypes | TValue> : PathInternalArray<TValue, TraversedTypes | TValue> : TValue extends Record<string, any> ? PathInternalObject<TValue, TraversedTypes | TValue, First> : "";
+/**
+ * Helper type for recursively constructing paths through a type.
+ * This actually constructs the strings and recurses into nested
+ * object types.
+ *
+ * See {@link ArrayPath}
+ */
+type ArrayPathImpl<K extends string | number, V, TraversedTypes> = V extends Primitive | BrowserNativeObject ? IsAny<V> extends true ? string : never : V extends ReadonlyArray<infer U> ? U extends Primitive | BrowserNativeObject ? IsAny<V> extends true ? string : never : true extends AnyIsEqual<TraversedTypes, V> ? never : `${K}` | `${K}.${ArrayPathInternal<V, TraversedTypes | V>}` : true extends AnyIsEqual<TraversedTypes, V> ? never : `${K}.${ArrayPathInternal<V, TraversedTypes | V>}`;
+/**
+ * Helper type for recursively constructing paths through a type.
+ * This obscures the internal type param TraversedTypes from ed contract.
+ *
+ * See {@link ArrayPath}
+ */
+type ArrayPathInternal<T, TraversedTypes = T> = T extends ReadonlyArray<infer V> ? IsTuple<T> extends true ? {
+    [K in TupleKeys<T>]-?: ArrayPathImpl<K & string, T[K], TraversedTypes>;
+}[TupleKeys<T>] : ArrayPathImpl<ArrayKey, V, TraversedTypes> : {
+    [K in keyof T]-?: ArrayPathImpl<K & string, T[K], TraversedTypes>;
+}[keyof T];
+/**
+ * Type which eagerly collects all paths through a type which point to an array
+ * type.
+ * @typeParam T - type which should be introspected.
+ * @example
+ * ```
+ * Path<{foo: {bar: string[], baz: number[]}}> = 'foo.bar' | 'foo.baz'
+ * ```
+ */
+type ArrayPath<T> = T extends any ? ArrayPathInternal<T> : never;
+/**
+ * Type to evaluate the type which the given path points to.
+ * @typeParam T - deeply nested type which is indexed by the path
+ * @typeParam P - path into the deeply nested type
+ * @example
+ * ```
+ * PathValue<{foo: {bar: string}}, 'foo.bar'> = string
+ * PathValue<[number, string], '1'> = string
+ * ```
+ */
+export type PathValue<T, P extends Path<T> | ArrayPath<T>> = T extends any ? P extends `${infer K}.${infer R}` ? K extends keyof T ? R extends Path<T[K]> ? PathValue<T[K], R> : never : K extends `${ArrayKey}` ? T extends ReadonlyArray<infer V> ? PathValue<V, R & Path<V>> : never : never : P extends keyof T ? T[P] : P extends `${ArrayKey}` ? T extends ReadonlyArray<infer V> ? V : never : never : never;
+/**
+ * Type which eagerly collects all paths through a type
+ * @typeParam T - type which should be introspected
+ * @example
+ * ```
+ * Path<{foo: {bar: string}}> = 'foo' | 'foo.bar'
+ * ```
+ */
+export type Path<T> = T extends any ? PathInternal<T, T, true> & string : never;
+export {};

package/dist/components/tt-form/src/types/shared.d.ts

@@ -0,0 +1,19 @@
+export type FieldValidationMetaInfo = {
+    field: string;
+    name: string;
+    label?: string;
+    value: unknown;
+    form: Record<string, unknown>;
+    rule?: {
+        name: string;
+        params?: Record<string, unknown> | unknown[];
+    };
+};
+export type ValidationRuleFunction<TValue = unknown, TParams = unknown[] | Record<string, unknown>> = (value: TValue, params: TParams, ctx: FieldValidationMetaInfo) => boolean | string | Promise<boolean | string>;
+export type SimpleValidationRuleFunction<TValue = unknown, TParams = unknown[] | Record<string, unknown>> = (value: TValue, params: TParams) => boolean | string | Promise<boolean | string>;
+export type ValidationMessageGenerator = (ctx: FieldValidationMetaInfo) => string;
+export type Optional<T> = T extends Record<string, any> ? Partial<T> : T | undefined;
+export type InterpolateOptions = {
+    prefix: string;
+    suffix: string;
+};