@dazhicheng/ui 1.5.6 → 1.5.8

package/dist/components/tt-validate/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-validate/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;
+};

package/dist/components/tt-validate/src/useField.d.ts

@@ -0,0 +1,30 @@
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { MaybeRef, MaybeRefOrGetter } from 'vue';
+import { FieldContext, FormContext, GenericValidateFunction, InputType } from './types';
+export type FieldOptions<TValue = unknown> = {
+    initialValue?: MaybeRef<TValue>;
+    validateOnModelUpdate: boolean;
+    validateOnMount?: boolean;
+    bails?: boolean;
+    type?: InputType;
+    checkedValue?: MaybeRefOrGetter<TValue>;
+    uncheckedValue?: MaybeRefOrGetter<TValue>;
+    label?: MaybeRefOrGetter<string | undefined>;
+    controlled?: boolean;
+    keepValueOnUnmount?: MaybeRefOrGetter<boolean | undefined>;
+    syncVModel?: boolean | string;
+    form?: FormContext;
+    validateOnZodRefine?: boolean;
+    rulesBlur?: MaybeRef<RuleExpression<TValue>>;
+    /**
+     * 在判断 dirty 状态时需要排除的字段列表（仅对对象类型有效）
+     * @example
+     * excludeKeys: ['_timestamp']
+     */
+    excludeKeys?: string[];
+};
+export type RuleExpression<TValue> = string | Record<string, unknown> | GenericValidateFunction<TValue> | GenericValidateFunction<TValue>[] | StandardSchemaV1<TValue> | undefined;
+/**
+ * Creates a field composite.
+ */
+export declare function useField<TValue = unknown>(path: MaybeRefOrGetter<string>, rules?: MaybeRef<RuleExpression<TValue>>, opts?: Partial<FieldOptions<TValue>>): FieldContext<TValue>;

package/dist/components/tt-validate/src/useFieldArray.d.ts

@@ -0,0 +1,3 @@
+import { MaybeRefOrGetter } from 'vue';
+import { FieldArrayContext } from './types';
+export declare function useFieldArray<TValue = unknown>(arrayPath: MaybeRefOrGetter<string>): FieldArrayContext<TValue>;

package/dist/components/tt-validate/src/useFieldError.d.ts

@@ -0,0 +1,5 @@
+import { MaybeRefOrGetter } from 'vue';
+/**
+ * Gives access to a single field error
+ */
+export declare function useFieldError(path?: MaybeRefOrGetter<string>): import('vue').ComputedRef<string | undefined>;

package/dist/components/tt-validate/src/useFieldState.d.ts

@@ -0,0 +1,47 @@
+import { MaybeRef, MaybeRefOrGetter, Ref } from 'vue';
+import { FieldMeta, FieldState, FieldValidator, InputType, PathState, PrivateFormContext } from './types';
+export type StateSetterInit<TValue = unknown> = {
+    initialValue: TValue;
+} & FieldState<TValue>;
+export type FieldStateComposable<TValue = unknown> = {
+    id: number;
+    path: MaybeRef<string>;
+    meta: FieldMeta<TValue>;
+    value: Ref<TValue>;
+    flags: PathState['__flags'];
+    initialValue: Ref<TValue>;
+    errors: Ref<string[]>;
+    setState: (state: Partial<StateSetterInit<TValue>>) => void;
+};
+export type StateInit<TInput = unknown, TOutput = TInput> = {
+    modelValue: MaybeRef<TInput>;
+    form?: PrivateFormContext;
+    bails: boolean;
+    label?: MaybeRefOrGetter<string | undefined>;
+    type?: InputType;
+    validate?: FieldValidator<TOutput>;
+    /**
+     * 在判断 dirty 状态时需要排除的字段列表（仅对对象类型有效）
+     * @example
+     * excludeKeys: ['_timestamp']
+     */
+    excludeKeys?: string[];
+};
+export declare function useFieldState<TValue = unknown>(path: MaybeRef<string>, init: Partial<StateInit<TValue>>): FieldStateComposable<TValue>;
+type FieldValueComposable<TValue = unknown> = {
+    value: Ref<TValue>;
+    initialValue: Ref<TValue>;
+    setInitialValue: (value: TValue) => void;
+};
+/**
+ * Creates the field value and resolves the initial value
+ */
+export declare function _useFieldValue<TValue = unknown>(path: MaybeRef<string>, modelValue?: MaybeRef<TValue>, form?: PrivateFormContext): FieldValueComposable<TValue>;
+/**
+ * Creates the error message state for the field state
+ */
+export declare function createFieldErrors(): {
+    errors: Ref<string[], string[]>;
+    setErrors: (messages: string | string[] | null | undefined) => void;
+};
+export {};

package/dist/components/tt-validate/src/useFieldValue.d.ts

@@ -0,0 +1,5 @@
+import { MaybeRefOrGetter } from 'vue';
+/**
+ * Gives access to a field's current value
+ */
+export declare function useFieldValue<TValue = unknown>(path?: MaybeRefOrGetter<string>): import('vue').ComputedRef<TValue>;

package/dist/components/tt-validate/src/useForm.d.ts

@@ -0,0 +1,23 @@
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { MaybeRef } from 'vue';
+import { FlattenAndSetPathsType, FormContext, GenericObject, GenericValidateFunction } from './types';
+type FormSchema<TValues extends Record<string, unknown>> = FlattenAndSetPathsType<TValues, GenericValidateFunction | string | GenericObject> | undefined;
+export type FormOptions<TValues extends GenericObject, TOutput = TValues, TSchema extends StandardSchemaV1<TValues, TOutput> | FormSchema<TValues> = FormSchema<TValues>> = {
+    validationSchema?: MaybeRef<TSchema extends StandardSchemaV1 ? StandardSchemaV1<TValues, TOutput> : any>;
+    initialValues?: Partial<TValues> | undefined | null;
+    initialErrors?: FlattenAndSetPathsType<TValues, string | undefined>;
+    initialTouched?: FlattenAndSetPathsType<TValues, boolean>;
+    validateOnMount?: boolean;
+    keepValuesOnUnmount?: MaybeRef<boolean>;
+    name?: string;
+    /**
+     * 在判断 dirty 状态时需要排除的字段列表
+     * 这些字段的变化不会影响表单的 dirty 状态
+     * @example
+     * excludeKeys: ['_timestamp', '_validationToken']
+     */
+    excludeKeys?: string[];
+};
+export declare function useForm<TValues extends GenericObject = GenericObject, TOutput extends GenericObject = TValues, TSchema extends FormSchema<TValues> | StandardSchemaV1<TValues, TOutput> = FormSchema<TValues>>(opts?: FormOptions<TValues, TOutput, TSchema>): FormContext<TValues, TOutput>;
+export declare function useFormContext<TValues extends GenericObject = GenericObject, TOutput extends GenericObject = TValues>(): FormContext<TValues, TOutput>;
+export {};

package/dist/components/tt-validate/src/useFormErrors.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Gives access to all form errors
+ */
+export declare function useFormErrors<TValues extends Record<string, unknown> = Record<string, unknown>>(): import('vue').ComputedRef<Partial<Record<"" | import('./types').Path<TValues>, string | undefined>>>;

package/dist/components/tt-validate/src/useFormValues.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Gives access to a form's values
+ */
+export declare function useFormValues<TValues extends Record<string, any> = Record<string, any>>(): import('vue').ComputedRef<Partial<TValues>>;

package/dist/components/tt-validate/src/useIsFieldDirty.d.ts

@@ -0,0 +1,5 @@
+import { MaybeRefOrGetter } from 'vue';
+/**
+ * If a field is dirty or not
+ */
+export declare function useIsFieldDirty(path?: MaybeRefOrGetter<string>): import('vue').ComputedRef<boolean>;

package/dist/components/tt-validate/src/useIsFieldTouched.d.ts

@@ -0,0 +1,5 @@
+import { MaybeRefOrGetter } from 'vue';
+/**
+ * If a field is touched or not
+ */
+export declare function useIsFieldTouched(path?: MaybeRefOrGetter<string>): import('vue').ComputedRef<boolean>;

package/dist/components/tt-validate/src/useIsFieldValid.d.ts

@@ -0,0 +1,5 @@
+import { MaybeRefOrGetter } from 'vue';
+/**
+ * If a field is validated and is valid
+ */
+export declare function useIsFieldValid(path?: MaybeRefOrGetter<string>): import('vue').ComputedRef<boolean>;

package/dist/components/tt-validate/src/useIsFormDirty.d.ts

@@ -0,0 +1,4 @@
+/**
+ * If the form is dirty or not
+ */
+export declare function useIsFormDirty(): import('vue').ComputedRef<boolean>;

package/dist/components/tt-validate/src/useIsFormTouched.d.ts

@@ -0,0 +1,4 @@
+/**
+ * If the form is touched or not
+ */
+export declare function useIsFormTouched(): import('vue').ComputedRef<boolean>;

package/dist/components/tt-validate/src/useIsFormValid.d.ts

@@ -0,0 +1,4 @@
+/**
+ * If the form has been validated and is valid
+ */
+export declare function useIsFormValid(): import('vue').ComputedRef<boolean>;

package/dist/components/tt-validate/src/useIsSubmitting.d.ts

@@ -0,0 +1,4 @@
+/**
+ * If the form is submitting or not
+ */
+export declare function useIsSubmitting(): import('vue').ComputedRef<boolean>;

package/dist/components/tt-validate/src/useIsValidating.d.ts

@@ -0,0 +1,4 @@
+/**
+ * If the form is validating or not
+ */
+export declare function useIsValidating(): import('vue').ComputedRef<boolean>;

package/dist/components/tt-validate/src/useResetForm.d.ts

@@ -0,0 +1,2 @@
+import { FormState, ResetFormOpts } from './types';
+export declare function useResetForm<TValues extends Record<string, unknown> = Record<string, unknown>>(): (state?: Partial<FormState<TValues>>, opts?: ResetFormOpts) => void;

package/dist/components/tt-validate/src/useSetFieldError.d.ts

@@ -0,0 +1,5 @@
+import { MaybeRefOrGetter } from 'vue';
+/**
+ * Sets a field's error message
+ */
+export declare function useSetFieldError(path?: MaybeRefOrGetter<string>): (message: string | string[] | undefined) => void;

package/dist/components/tt-validate/src/useSetFieldTouched.d.ts

@@ -0,0 +1,5 @@
+import { MaybeRefOrGetter } from 'vue';
+/**
+ * Sets a field's touched meta state
+ */
+export declare function useSetFieldTouched(path?: MaybeRefOrGetter<string>): (touched: boolean) => void;

package/dist/components/tt-validate/src/useSetFieldValue.d.ts

@@ -0,0 +1,5 @@
+import { MaybeRefOrGetter } from 'vue';
+/**
+ * Sets a field's value
+ */
+export declare function useSetFieldValue<TValue = unknown>(path?: MaybeRefOrGetter<string>): (value: TValue, shouldValidate?: boolean) => void;

package/dist/components/tt-validate/src/useSetFormErrors.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Sets multiple fields errors
+ */
+export declare function useSetFormErrors(): (fields: Record<string, string | string[] | undefined>) => void;

package/dist/components/tt-validate/src/useSetFormTouched.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Sets multiple fields touched or all fields in the form
+ */
+export declare function useSetFormTouched(): (fields: Record<string, boolean> | boolean) => void;

package/dist/components/tt-validate/src/useSetFormValues.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Sets multiple fields values
+ */
+export declare function useSetFormValues<TValues extends Record<string, unknown> = Record<string, unknown>>(): (fields: TValues, shouldValidate?: boolean) => void;

package/dist/components/tt-validate/src/useSubmitCount.d.ts

@@ -0,0 +1,4 @@
+/**
+ * The number of form's submission count
+ */
+export declare function useSubmitCount(): import('vue').ComputedRef<number>;

package/dist/components/tt-validate/src/useSubmitForm.d.ts

@@ -0,0 +1,2 @@
+import { SubmissionHandler } from './types';
+export declare function useSubmitForm<TValues extends Record<string, unknown> = Record<string, unknown>>(cb: SubmissionHandler<TValues>): (e?: Event) => Promise<unknown> | undefined;

package/dist/components/tt-validate/src/useValidateField.d.ts

@@ -0,0 +1,6 @@
+import { MaybeRefOrGetter } from 'vue';
+import { ValidationResult } from './types';
+/**
+ * Validates a single field
+ */
+export declare function useValidateField<TOutput>(path?: MaybeRefOrGetter<string>): () => Promise<ValidationResult<TOutput>>;

package/dist/components/tt-validate/src/useValidateForm.d.ts

@@ -0,0 +1,5 @@
+import { FormValidationResult } from './types';
+/**
+ * Validate multiple fields
+ */
+export declare function useValidateForm<TValues extends Record<string, unknown> = Record<string, unknown>>(): () => Promise<FormValidationResult<TValues>>;

package/dist/components/tt-validate/src/utils/assertions.d.ts

@@ -0,0 +1,54 @@
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { Locator } from '../types';
+export declare const isClient: boolean;
+export declare function isLocator(value: unknown): value is Locator;
+export declare function isStandardSchema(value: unknown): value is StandardSchemaV1;
+export declare function hasCheckedAttr(type: unknown): type is "checkbox" | "radio";
+export declare function isContainerValue(value: unknown): value is Record<string, unknown>;
+/**
+ * True if the value is an empty object or array
+ */
+export declare function isEmptyContainer(value: unknown): boolean;
+/**
+ * Checks if the path opted out of nested fields using `[fieldName]` syntax
+ */
+export declare function isNotNestedPath(path: string): boolean;
+/**
+ * Checks if an element is a native HTML5 multi-select input element
+ */
+export declare function isNativeMultiSelect(el: HTMLElement): el is HTMLSelectElement;
+/**
+ * Checks if an element is a native HTML5 select input element
+ */
+export declare function isNativeSelect(el: HTMLElement): el is HTMLSelectElement;
+/**
+ * Checks if a tag name with attrs object will render a native multi-select element
+ */
+export declare function isNativeMultiSelectNode(tag: string, attrs: Record<string, unknown>): boolean;
+/**
+ * Checks if a node should have a `:value` binding or not
+ *
+ * These nodes should not have a value binding
+ * For files, because they are not reactive
+ * For multi-selects because the value binding will reset the value
+ */
+export declare function shouldHaveValueBinding(tag: string, attrs: Record<string, unknown>): boolean;
+export declare function isFormSubmitEvent(evt: unknown): evt is Event & {
+    target: HTMLFormElement;
+};
+export declare function isEvent(evt: unknown): evt is Event;
+export declare function isPropPresent(obj: Record<string, unknown>, prop: string): boolean;
+export declare function deepEqual<T>(a: T, b: T): boolean;
+export declare const isEqual: typeof deepEqual;
+/**
+ * 比较两个值是否相等，支持排除指定字段
+ * @param a - 第一个值
+ * @param b - 第二个值
+ * @param excludeKeys - 需要排除的字段数组（可选）
+ * @returns 是否相等
+ * @example
+ * isEqualExclude({ a: 1, b: 2 }, { a: 1, b: 3 }, ['b']) // true
+ * isEqualExclude({ a: 1, b: 2 }, { a: 1, b: 3 }) // false
+ */
+export declare function isEqualExclude<T>(a: T, b: T, excludeKeys?: string[]): boolean;
+export declare function isFile(a: unknown): a is File;

package/dist/components/tt-validate/src/utils/common.d.ts

@@ -0,0 +1,48 @@
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { InjectionKey, MaybeRefOrGetter, Ref } from 'vue';
+import { GenericObject, IssueCollection, MaybePromise } from '../types';
+export declare function cleanupNonNestedPath(path: string): string;
+type NestedRecord = GenericObject;
+/**
+ * Gets a nested property value from an object
+ */
+export declare function getFromPath<TValue = unknown>(object: NestedRecord | undefined, path: string): TValue | undefined;
+export declare function getFromPath<TValue = unknown, TFallback = TValue>(object: NestedRecord | undefined, path: string, fallback?: TFallback): TValue | TFallback;
+/**
+ * Sets a nested property value in a path, creates the path properties if it doesn't exist
+ */
+export declare function setInPath(object: NestedRecord, path: string, value: unknown): void;
+/**
+ * Removes a nested property from object
+ */
+export declare function unsetPath(object: NestedRecord, path: string): void;
+/**
+ * A typed version of Object.keys
+ */
+export declare function keysOf<TRecord extends Record<string, unknown>>(record: TRecord): (keyof TRecord)[];
+export declare function injectWithSelf<T>(symbol: InjectionKey<T>, def?: T | undefined): T | undefined;
+export declare function warn(message: string): void;
+export declare function resolveNextCheckboxValue<T>(currentValue: T, checkedValue: T, uncheckedValue: T): T;
+export declare function resolveNextCheckboxValue<T>(currentValue: T[], checkedValue: T, uncheckedValue: T): T[];
+type ThrottledFunction<T extends (...args: any) => any> = (...args: Parameters<T>) => ReturnType<T>;
+/**
+ * Creates a throttled function that only invokes the provided function (`func`) at most once per within a given number of milliseconds
+ * (`limit`)
+ */
+export declare function throttle<T extends (...args: any) => any>(func: T, limit: number): ThrottledFunction<T>;
+export declare function debounceAsync<TFunction extends (...args: any) => Promise<any>, TResult = ReturnType<TFunction>>(inner: TFunction, ms?: number): (...args: Parameters<TFunction>) => Promise<TResult>;
+export declare function applyModelModifiers<TValue = unknown>(value: TValue, modifiers: unknown): TValue;
+export declare function withLatest<TFunction extends (...args: any[]) => Promise<any>, TResult = Awaited<ReturnType<TFunction>>>(fn: TFunction, onDone: (result: TResult, args: Parameters<TFunction>) => TResult): (...args: Parameters<TFunction>) => Promise<any>;
+export declare function computedDeep<TValue = unknown>({ get, set, }: {
+    get: () => TValue;
+    set: (value: TValue) => void;
+}): Ref<TValue>;
+export declare function normalizeErrorItem(message: string | string[] | null | undefined): string[];
+export declare function resolveFieldOrPathState(path?: MaybeRefOrGetter<string>): import('..').PrivateFieldContext<unknown> | import('vue').ComputedRef<import('..').PathState<any, any> | undefined> | undefined;
+export declare function omit<TObj extends GenericObject>(obj: TObj, keys: (keyof GenericObject)[]): TObj;
+export declare function debounceNextTick<TFunction extends (...args: any[]) => MaybePromise<any>, TResult = ReturnType<TFunction>>(inner: TFunction): (...args: Parameters<TFunction>) => Promise<TResult>;
+/**
+ * Aggregates standard schema issues by path.
+ */
+export declare function combineStandardIssues(issues: StandardSchemaV1.Issue[] | readonly StandardSchemaV1.Issue[]): IssueCollection[];
+export {};

package/dist/components/tt-validate/src/utils/events.d.ts

@@ -0,0 +1 @@
+export declare function normalizeEventValue(value: Event | unknown): unknown;

package/dist/components/tt-validate/src/utils/index.d.ts

@@ -0,0 +1,5 @@
+export * from './assertions';
+export * from './common';
+export * from './events';
+export * from './rules';
+export * from './vnode';

package/dist/components/tt-validate/src/utils/rules.d.ts

@@ -0,0 +1,13 @@
+import { Locator } from '../types';
+/**
+ * Normalizes the given rules expression.
+ */
+export declare function normalizeRules(rules: undefined | string | Record<string, unknown | unknown[] | Record<string, unknown>>): Record<string, unknown[] | Record<string, unknown>>;
+/**
+ * Parses a rule string expression.
+ */
+export declare function parseRule(rule: string): {
+    name: string | undefined;
+    params: string[];
+};
+export declare function extractLocators(params: Record<string, unknown> | unknown[]): Locator[];

package/dist/components/tt-validate/src/utils/shared.d.ts

@@ -0,0 +1,19 @@
+export declare function isCallable(fn: unknown): fn is (...args: any[]) => any;
+export declare function isObject(obj: unknown): obj is Record<string, unknown>;
+export declare function isIndex(value: unknown): value is number;
+export declare function isNullOrUndefined(value: unknown): value is undefined | null;
+export declare function toNumber(value: string): number | string;
+export declare function normalizeFormPath(path: string): string;
+export declare function getTag(value: any): string;
+export declare function isObjectLike(value: any): boolean;
+export declare function isPlainObject(value: any): boolean;
+export declare function merge(target: any, source: any): any;
+/**
+ * 将对象扁平化为点/下标路径的键
+ * 例如：
+ *  { a: { b: 1 }, arr: [{ x: 2 }] }
+ *  => { 'a.b': 1, 'arr[0].x': 2 }
+ */
+export declare function flattenToDotPaths(source: any, opts?: {
+    includeEmpty?: boolean;
+}): Record<string, unknown>;

package/dist/components/tt-validate/src/utils/vnode.d.ts

@@ -0,0 +1,22 @@
+import { SetupContext } from 'vue';
+type HTMLElementWithValueBinding = HTMLElement & {
+    _value: unknown;
+};
+export declare function normalizeChildren(tag: string | undefined | null, context: SetupContext<any>, slotProps: () => Record<string, unknown>): import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>[] | {
+    default: () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+        [key: string]: any;
+    }>[] | undefined;
+} | undefined;
+/**
+ * Vue adds a `_value` prop at the moment on the input elements to store the REAL value on them, real values are different than the `value` attribute
+ * as they do not get casted to strings unlike `el.value` which preserves user-code behavior
+ */
+export declare function getBoundValue(el: HTMLElement): unknown;
+/**
+ * Vue adds a `_value` prop at the moment on the input elements to store the REAL value on them, real values are different than the `value` attribute
+ * as they do not get casted to strings unlike `el.value` which preserves user-code behavior
+ */
+export declare function hasValueBinding(el: HTMLElement): el is HTMLElementWithValueBinding;
+export {};

package/dist/components/tt-validate/src/validate.d.ts

@@ -0,0 +1,21 @@
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { FormValidationResult, GenericObject, GenericValidateFunction, RawFormSchema, ValidationResult } from './types';
+type ValidationOptions = {
+    name?: string;
+    label?: string;
+    values?: Record<string, unknown>;
+    bails?: boolean;
+};
+/**
+ * Validates a value against the rules.
+ */
+export declare function validate<TInput, TOutput>(value: TInput, rules: string | Record<string, unknown | unknown[]> | GenericValidateFunction<TInput> | GenericValidateFunction<TInput>[] | StandardSchemaV1<TInput, TOutput>, options?: ValidationOptions): Promise<ValidationResult<TOutput>>;
+export declare function validateStandardSchema<TValues extends GenericObject, TOutput extends GenericObject = TValues>(schema: StandardSchemaV1<TValues, TOutput>, values: TValues): Promise<FormValidationResult<TValues, TOutput>>;
+export declare function validateObjectSchema<TValues extends GenericObject, TOutput extends GenericObject>(schema: RawFormSchema<TValues>, values: TValues | undefined, opts?: Partial<{
+    names: Record<string, {
+        name: string;
+        label: string;
+    }>;
+    bailsMap: Record<string, boolean>;
+}>): Promise<FormValidationResult<TValues, TOutput>>;
+export {};

package/dist/components/tt-validate/zod/index.d.ts

@@ -0,0 +1 @@
+export {};