react-hook-form 7.25.0 → 8.0.0-alpha.0

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

@@ -1,316 +0,0 @@
-import { IsAny, IsNever } from '../utils';
-/**
- * Type alias to `string` which describes a lodash-like path through an object.
- * E.g. `'foo.bar.0.baz'`
- */
-export declare type PathString = string;
-/**
- * Type which can be traversed through with a {@link PathString}.
- * I.e. objects, arrays, and tuples
- */
-export declare type Traversable = object;
-/**
- * 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
- * ```
- */
-export declare type IsTuple<T extends ReadonlyArray<any>> = number extends T['length'] ? false : true;
-/**
- * Type which can be used to index an array or tuple type.
- */
-export declare type ArrayKey = number;
-/**
- * Type which can be used to index an object.
- */
-export declare type Key = string;
-/**
- * Type to assert that a type is a {@link Key}.
- * @typeParam T - type which may be a {@link Key}
- */
-export declare type AsKey<T> = Extract<T, Key>;
-/**
- * Type to convert a type to a {@link Key}.
- * @typeParam T - type which may be converted to a {@link Key}
- */
-export declare type ToKey<T> = T extends ArrayKey ? `${T}` : AsKey<T>;
-/**
- * Type which describes a path through an object
- * as a list of individual {@link Key}s.
- */
-export declare type PathTuple = Key[];
-/**
- * Type to assert that a type is a {@link PathTuple}.
- * @typeParam T - type which may be a {@link PathTuple}
- */
-export declare type AsPathTuple<T> = Extract<T, PathTuple>;
-/**
- * Type to intersect a union type.
- * See https://fettblog.eu/typescript-union-to-intersection/
- * @typeParam U - union
- * @example
- * ```
- * UnionToIntersection<{ foo: string } | { bar: number }>
- *   = { foo: string; bar: number }
- * ```
- */
-export declare type UnionToIntersection<U> = (U extends any ? (_: U) => any : never) extends (_: infer I) => any ? I : never;
-/**
- * Type which appends a {@link Key} to the {@link PathTuple} only if it is not
- * blank, i.e. not the empty string.
- * @typeParam PT - path
- * @typeParam K  - key
- * @example
- * ```
- * AppendNonBlankKey<['foo'], 'bar'> = ['foo', 'bar']
- * AppendNonBlankKey<['foo'], ''> = ['foo']
- * ```
- */
-declare type AppendNonBlankKey<PT extends PathTuple, K extends Key> = K extends '' ? PT : [...PT, K];
-/**
- * Type to implement {@link SplitPathString} tail recursively.
- * @typeParam PS - remaining {@link PathString} which should be split into its
- *                 individual {@link Key}s
- * @typeParam PT - accumulator of the {@link Key}s which have been split from
- *                 the original {@link PathString} already
- */
-declare type SplitPathStringImpl<PS extends PathString, PT extends PathTuple> = PS extends `${infer K}.${infer R}` ? SplitPathStringImpl<R, AppendNonBlankKey<PT, K>> : AppendNonBlankKey<PT, PS>;
-/**
- * Type to split a {@link PathString} into a {@link PathTuple}.
- * The individual {@link Key}s may be empty strings.
- * @typeParam PS  - {@link PathString} which should be split into its
- *                  individual {@link Key}s
- * @example
- * ```
- * SplitPathString<'foo'> = ['foo']
- * SplitPathString<'foo.bar.0.baz'> = ['foo', 'bar', '0', 'baz']
- * SplitPathString<'.'> = []
- * ```
- */
-export declare type SplitPathString<PS extends PathString> = SplitPathStringImpl<PS, [
-]>;
-/**
- * Type to implement {@link JoinPathTuple} tail-recursively.
- * @typeParam PT - remaining {@link Key}s which needs to be joined
- * @typeParam PS - accumulator of the already joined {@link Key}s
- */
-declare type JoinPathTupleImpl<PT extends PathTuple, PS extends PathString> = PT extends [infer K, ...infer R] ? JoinPathTupleImpl<AsPathTuple<R>, `${PS}.${AsKey<K>}`> : PS;
-/**
- * Type to join a {@link PathTuple} to a {@link PathString}.
- * @typeParam PT - {@link PathTuple} which should be joined.
- * @example
- * ```
- * JoinPathTuple<['foo']> = 'foo'
- * JoinPathTuple<['foo', 'bar', '0', 'baz']> = 'foo.bar.0.baz'
- * JoinPathTuple<[]> = never
- * ```
- */
-export declare type JoinPathTuple<PT extends PathTuple> = PT extends [
-    infer K,
-    ...infer R
-] ? JoinPathTupleImpl<AsPathTuple<R>, AsKey<K>> : never;
-/**
- * Type which converts all keys of an object to {@link Key}s.
- * @typeParam T - object type
- * @example
- * ```
- * MapKeys<{0: string}> = {'0': string}
- * ```
- */
-declare type MapKeys<T> = {
-    [K in keyof T as ToKey<K>]: T[K];
-};
-/**
- * Type to access a type by a key.
- *  - Returns undefined if it can't be indexed by that key.
- *  - Returns null if the type is null.
- *  - Returns undefined if the type is not traversable.
- * @typeParam T - type which is indexed by the key
- * @typeParam K - key into the type
- * ```
- * TryAccess<{foo: string}, 'foo'> = string
- * TryAccess<{foo: string}, 'bar'> = undefined
- * TryAccess<null, 'foo'> = null
- * TryAccess<string, 'foo'> = undefined
- * ```
- */
-declare type TryAccess<T, K> = K extends keyof T ? T[K] : T extends null ? null : undefined;
-/**
- * Type to access an array type by a key.
- * Returns undefined if the key is non-numeric.
- * @typeParam T - type which is indexed by the key
- * @typeParam K - key into the type
- * ```
- * TryAccessArray<string[], '0'> = string
- * TryAccessArray<string[], 'foo'> = undefined
- * ```
- */
-declare type TryAccessArray<T extends ReadonlyArray<any>, K extends Key> = K extends `${ArrayKey}` ? T[number] : TryAccess<T, K>;
-/**
- * Type to evaluate the type which the given key points to.
- * @typeParam T - type which is indexed by the key
- * @typeParam K - key into the type
- * @example
- * ```
- * EvaluateKey<{foo: string}, 'foo'> = string
- * EvaluateKey<[number, string], '1'> = string
- * EvaluateKey<string[], '1'> = string
- * ```
- */
-export declare type EvaluateKey<T, K extends Key> = T extends ReadonlyArray<any> ? IsTuple<T> extends true ? TryAccess<T, K> : TryAccessArray<T, K> : TryAccess<MapKeys<T>, K>;
-/**
- * Type to evaluate the type which the given path points to.
- * @typeParam T  - deeply nested type which is indexed by the path
- * @typeParam PT - path into the deeply nested type
- * @example
- * ```
- * EvaluatePath<{foo: {bar: string}}, ['foo', 'bar']> = string
- * EvaluatePath<[number, string], ['1']> = string
- * EvaluatePath<number, []> = number
- * EvaluatePath<number, ['foo']> = undefined
- * ```
- */
-export declare type EvaluatePath<T, PT extends PathTuple> = PT extends [
-    infer K,
-    ...infer R
-] ? EvaluatePath<EvaluateKey<T, AsKey<K>>, AsPathTuple<R>> : T;
-/**
- * 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'
- * ```
- */
-export declare type TupleKeys<T extends ReadonlyArray<any>> = Exclude<keyof T, keyof any[]>;
-/**
- * Type which extracts all numeric keys from an object.
- * @typeParam T - type
- * @example
- * ```
- * NumericObjectKeys<{0: string, '1': string, foo: string}> = '0' | '1'
- * ```
- */
-declare type NumericObjectKeys<T extends Traversable> = ToKey<Extract<keyof T, ArrayKey | `${ArrayKey}`>>;
-/**
- * Type which extracts all numeric keys from an object, tuple, or array.
- * If a union is passed, it evaluates to the overlapping numeric keys.
- * @typeParam T - type
- * @example
- * ```
- * NumericKeys<{0: string, '1': string, foo: string}> = '0' | '1'
- * NumericKeys<number[]> = `${number}`
- * NumericKeys<[string, number]> = '0' | '1'
- * NumericKeys<{0: string, '1': string} | [number] | number[]> = '0'
- * ```
- */
-export declare type NumericKeys<T extends Traversable> = UnionToIntersection<T extends ReadonlyArray<any> ? IsTuple<T> extends true ? [TupleKeys<T>] : [ToKey<ArrayKey>] : [NumericObjectKeys<T>]>[never];
-/**
- * Type which extracts all keys from an object.
- * If a union is passed, it evaluates to the overlapping keys.
- * @typeParam T - object type
- * @example
- * ```
- * ObjectKeys<{foo: string, bar: string}, string> = 'foo' | 'bar'
- * ObjectKeys<{foo: string, bar: number}, string> = 'foo'
- * ```
- */
-export declare type ObjectKeys<T extends Traversable> = Exclude<ToKey<keyof T>, `${string}.${string}` | ''>;
-/**
- * Type to check whether a type's property matches the constraint type
- * and return its key. Converts the key to a {@link Key}.
- * @typeParam T - type whose property should be checked
- * @typeParam K - key of the property
- * @typeParam U - constraint type
- * @example
- * ```
- * CheckKeyConstraint<{foo: string}, 'foo', string> = 'foo'
- * CheckKeyConstraint<{foo: string}, 'foo', number> = never
- * CheckKeyConstraint<string[], number, string> = `${number}`
- * ```
- */
-export declare type CheckKeyConstraint<T, K extends Key, U> = K extends any ? EvaluateKey<T, K> extends U ? K : never : never;
-/**
- * Type which evaluates to true when the type is an array or tuple or is a union
- * which contains an array or tuple.
- * @typeParam T - type
- * @example
- * ```
- * ContainsIndexable<{foo: string}> = false
- * ContainsIndexable<{foo: string} | number[]> = true
- * ```
- */
-export declare type ContainsIndexable<T> = IsNever<Extract<T, ReadonlyArray<any>>> extends true ? false : true;
-/**
- * Type to implement {@link Keys} for non-nullable values.
- * @typeParam T - non-nullable type whose property should be checked
- */
-declare type KeysImpl<T> = [T] extends [Traversable] ? ContainsIndexable<T> extends true ? NumericKeys<T> : ObjectKeys<T> : never;
-/**
- * Type to find all properties of a type that match the constraint type
- * and return their keys.
- * If a union is passed, it evaluates to the overlapping keys.
- * @typeParam T - type whose property should be checked
- * @typeParam U - constraint type
- * @example
- * ```
- * Keys<{foo: string, bar: string}, string> = 'foo' | 'bar'
- * Keys<{foo?: string, bar?: string}> = 'foo' | 'bar'
- * Keys<{foo: string, bar: number}, string> = 'foo'
- * Keys<[string, number], string> = '0'
- * Keys<string[], string> = `${number}`
- * Keys<{0: string, '1': string} | [number] | number[]> = '0'
- * ```
- */
-export declare type Keys<T, U = unknown> = IsAny<T> extends true ? Key : IsNever<T> extends true ? Key : IsNever<NonNullable<T>> extends true ? never : CheckKeyConstraint<T, KeysImpl<NonNullable<T>>, U>;
-/**
- * Type to check whether a {@link Key} is present in a type.
- * If a union of {@link Key}s is passed, all {@link Key}s have to be present
- * in the type.
- * @typeParam T - type which is introspected
- * @typeParam K - key
- * @example
- * ```
- * HasKey<{foo: string}, 'foo'> = true
- * HasKey<{foo: string}, 'bar'> = false
- * HasKey<{foo: string}, 'foo' | 'bar'> = false
- * ```
- */
-export declare type HasKey<T, K extends Key> = IsNever<Exclude<K, Keys<T>>>;
-/**
- * Type to implement {@link ValidPathPrefix} tail recursively.
- * @typeParam T   - type which the path should be checked against
- * @typeParam PT  - path which should exist within the given type
- * @typeParam VPT - accumulates the prefix of {@link Key}s which have been
- *                  confirmed to exist already
- */
-declare type ValidPathPrefixImpl<T, PT extends PathTuple, VPT extends PathTuple> = PT extends [infer K, ...infer R] ? HasKey<T, AsKey<K>> extends true ? ValidPathPrefixImpl<EvaluateKey<T, AsKey<K>>, AsPathTuple<R>, AsPathTuple<[...VPT, K]>> : VPT : VPT;
-/**
- * Type to find the longest path prefix which is still valid,
- * i.e. exists within the given type.
- * @typeParam T  - type which the path should be checked against
- * @typeParam PT - path which should exist within the given type
- * @example
- * ```
- * ValidPathPrefix<{foo: {bar: string}}, ['foo', 'bar']> = ['foo', 'bar']
- * ValidPathPrefix<{foo: {bar: string}}, ['foo', 'ba']> = ['foo']
- * ```
- */
-export declare type ValidPathPrefix<T, PT extends PathTuple> = ValidPathPrefixImpl<T, PT, [
-]>;
-/**
- * Type to check whether a path through a type exists.
- * @typeParam T  - type which the path should be checked against
- * @typeParam PT - path which should exist within the given type
- * @example
- * ```
- * HasPath<{foo: {bar: string}}, ['foo', 'bar']> = true
- * HasPath<{foo: {bar: string}}, ['foo', 'ba']> = false
- * ```
- */
-export declare type HasPath<T, PT extends PathTuple> = ValidPathPrefix<T, PT> extends PT ? true : false;
-export {};
-//# sourceMappingURL=common.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../src/types/path/common.ts"],"names":[],"mappings":"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"}

package/dist/types/path/eager.d.ts

@@ -1,82 +0,0 @@
-import { FieldValues } from '../fields';
-import { Primitive } from '../utils';
-import { ArrayKey, IsTuple, TupleKeys } from './common';
-/**
- * Helper type for recursively constructing paths through a type.
- * See {@link Path}
- */
-declare type PathImpl<K extends string | number, V> = V extends Primitive ? `${K}` : `${K}` | `${K}.${Path<V>}`;
-/**
- * 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 declare type Path<T> = T extends ReadonlyArray<infer V> ? IsTuple<T> extends true ? {
-    [K in TupleKeys<T>]-?: PathImpl<K & string, T[K]>;
-}[TupleKeys<T>] : PathImpl<ArrayKey, V> : {
-    [K in keyof T]-?: PathImpl<K & string, T[K]>;
-}[keyof T];
-/**
- * See {@link Path}
- */
-export declare type FieldPath<TFieldValues extends FieldValues> = Path<TFieldValues>;
-/**
- * Helper type for recursively constructing paths through a type.
- * See {@link ArrayPath}
- */
-declare type ArrayPathImpl<K extends string | number, V> = V extends Primitive ? never : V extends ReadonlyArray<infer U> ? U extends Primitive ? never : `${K}` | `${K}.${ArrayPath<V>}` : `${K}.${ArrayPath<V>}`;
-/**
- * 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'
- * ```
- */
-export declare type ArrayPath<T> = T extends ReadonlyArray<infer V> ? IsTuple<T> extends true ? {
-    [K in TupleKeys<T>]-?: ArrayPathImpl<K & string, T[K]>;
-}[TupleKeys<T>] : ArrayPathImpl<ArrayKey, V> : {
-    [K in keyof T]-?: ArrayPathImpl<K & string, T[K]>;
-}[keyof T];
-/**
- * See {@link ArrayPath}
- */
-export declare type FieldArrayPath<TFieldValues extends FieldValues> = ArrayPath<TFieldValues>;
-/**
- * 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 declare 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;
-/**
- * See {@link PathValue}
- */
-export declare type FieldPathValue<TFieldValues extends FieldValues, TFieldPath extends FieldPath<TFieldValues>> = PathValue<TFieldValues, TFieldPath>;
-/**
- * See {@link PathValue}
- */
-export declare type FieldArrayPathValue<TFieldValues extends FieldValues, TFieldArrayPath extends FieldArrayPath<TFieldValues>> = PathValue<TFieldValues, TFieldArrayPath>;
-/**
- * Type to evaluate the type which the given paths point to.
- * @typeParam TFieldValues - field values which are indexed by the paths
- * @typeParam TPath        - paths into the deeply nested field values
- * @example
- * ```
- * FieldPathValues<{foo: {bar: string}}, ['foo', 'foo.bar']>
- *   = [{bar: string}, string]
- * ```
- */
-export declare type FieldPathValues<TFieldValues extends FieldValues, TPath extends FieldPath<TFieldValues>[] | readonly FieldPath<TFieldValues>[]> = {} & {
-    [K in keyof TPath]: FieldPathValue<TFieldValues, TPath[K] & FieldPath<TFieldValues>>;
-};
-export {};
-//# sourceMappingURL=eager.d.ts.map

package/dist/types/path/eager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"eager.d.ts","sourceRoot":"","sources":["../../../src/types/path/eager.ts"],"names":[],"mappings":"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"}

package/dist/utils/omitKeys.d.ts

@@ -1,3 +0,0 @@
-declare const _default: <T extends Partial<Record<"id", string>>[]>(fields: T, keyName: string) => Omit<Partial<Record<"id", string>>, string>[];
-export default _default;
-//# sourceMappingURL=omitKeys.d.ts.map

package/dist/utils/omitKeys.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"omitKeys.d.ts","sourceRoot":"","sources":["../../src/utils/omitKeys.ts"],"names":[],"mappings":"wFAMW,MAAM;AAFjB,wBAGsD"}