react-hook-form 7.26.1 → 8.0.0-alpha.1

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

@@ -0,0 +1,76 @@
+import { FieldValues } from '../fields';
+import * as Branded from './branded';
+import * as Lazy from './lazy';
+import { PathString } from './pathString';
+/**
+ * Type which offers autocompletion of paths through a form.
+ * @typeParam TFieldValues - the field values for which this path is valid
+ * @typeParam TPathString - the string representation of the path
+ * @typeParam TValue - the value which may be read from the path
+ * @typeParam TValueSet - the value which can be written to the path
+ * @example
+ * ```
+ * declare function getNumber<T extends FieldValues, P extends PathString>(
+ *   obj: T,
+ *   path: TypedFieldPath<T, P, number>,
+ * ): number
+ * ```
+ */
+export declare type TypedFieldPath<TFieldValues, TPathString extends PathString, TValue, TValueSet = TValue> = Branded.TypedFieldPath<TFieldValues, TValue, TValueSet> | Lazy.TypedFieldPath<TFieldValues, TPathString, TValue, TValueSet>;
+/**
+ * Type which offers autocompletion of paths through a form.
+ * @typeParam TFieldValues - the field values for which this path is valid
+ * @typeParam TPathString - the string representation of the path
+ * @example
+ * ```
+ * declare function get<T extends FieldValues, P extends PathString>(
+ *   obj: T,
+ *   path: FieldPath<T, P>,
+ * ): FieldPathValue<T, P>
+ * ```
+ */
+export declare type FieldPath<TFieldValues, TPathString extends PathString> = Branded.FieldPath<TFieldValues> | Lazy.FieldPath<TFieldValues, TPathString>;
+/**
+ * Type which offers autocompletion of paths through a form which point to an array.
+ * @typeParam TFieldValues - the field values for which this path is valid
+ * @typeParam TPathString - the string representation of the path
+ * @typeParam TArrayValues - the value which may be read from array at the path
+ * @typeParam TArrayValuesSet - the value which can be written to the array at the path
+ * @example
+ * ```
+ * declare function popNumber<T extends FieldValues, P extends PathString>(
+ *   obj: T,
+ *   path: TypedFieldArrayPath<T, P, number>,
+ * ): number
+ * ```
+ */
+export declare type TypedFieldArrayPath<TFieldValues, TPathString extends PathString, TArrayValues extends FieldValues, TArrayValuesSet extends FieldValues = TArrayValues> = Branded.TypedFieldArrayPath<TFieldValues, TArrayValues, TArrayValuesSet> | Lazy.TypedFieldArrayPath<TFieldValues, TPathString, TArrayValues, TArrayValuesSet>;
+/**
+ * Type which offers autocompletion of paths through a form which point to an array.
+ * @typeParam TFieldValues - the field values for which this path is valid
+ * @typeParam TPathString - the string representation of the path
+ * @example
+ * ```
+ * declare function pop<T extends FieldValues, P extends PathString>(
+ *   obj: T,
+ *   path: FieldArrayPath<T, P>,
+ * ): FieldPathValue<T, P>[never]
+ * ```
+ */
+export declare type FieldArrayPath<TFieldValues, TPathString extends PathString> = Branded.FieldArrayPath<TFieldValues> | Lazy.FieldArrayPath<TFieldValues, TPathString>;
+/**
+ * Type which offers autocompletion for a tuple of paths through a form.
+ * @typeParam TFieldValues - the field values for which this path is valid
+ * @typeParam TPathStrings - the string representations of the paths
+ * @example
+ * ```
+ * declare function get<
+ *   T extends FieldValues,
+ *   P extends ReadonlyArray<PathString>,
+ * >(obj: T, paths: FieldPaths<T, P>): FieldPathValues<T, P>
+ * ```
+ */
+export declare type FieldPaths<TFieldValues, TPathStrings extends ReadonlyArray<PathString>> = {
+    [Idx in keyof TPathStrings]: FieldPath<TFieldValues, Extract<TPathStrings[Idx], PathString>>;
+};
+//# sourceMappingURL=auto.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"auto.d.ts","sourceRoot":"","sources":["../../../src/types/path/auto.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAExC,OAAO,KAAK,OAAO,MAAM,WAAW,CAAC;AACrC,OAAO,KAAK,IAAI,MAAM,QAAQ,CAAC;AAC/B,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C;;;;;;;;;;;;;GAaG;AACH,oBAAY,cAAc,CACxB,YAAY,EACZ,WAAW,SAAS,UAAU,EAC9B,MAAM,EACN,SAAS,GAAG,MAAM,IAEhB,OAAO,CAAC,cAAc,CAAC,YAAY,EAAE,MAAM,EAAE,SAAS,CAAC,GACvD,IAAI,CAAC,cAAc,CAAC,YAAY,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC;AAEtE;;;;;;;;;;;GAWG;AACH,oBAAY,SAAS,CAAC,YAAY,EAAE,WAAW,SAAS,UAAU,IAC9D,OAAO,CAAC,SAAS,CAAC,YAAY,CAAC,GAC/B,IAAI,CAAC,SAAS,CAAC,YAAY,EAAE,WAAW,CAAC,CAAC;AAE9C;;;;;;;;;;;;;GAaG;AACH,oBAAY,mBAAmB,CAC7B,YAAY,EACZ,WAAW,SAAS,UAAU,EAC9B,YAAY,SAAS,WAAW,EAChC,eAAe,SAAS,WAAW,GAAG,YAAY,IAEhD,OAAO,CAAC,mBAAmB,CAAC,YAAY,EAAE,YAAY,EAAE,eAAe,CAAC,GACxE,IAAI,CAAC,mBAAmB,CACtB,YAAY,EACZ,WAAW,EACX,YAAY,EACZ,eAAe,CAChB,CAAC;AAEN;;;;;;;;;;;GAWG;AACH,oBAAY,cAAc,CAAC,YAAY,EAAE,WAAW,SAAS,UAAU,IACnE,OAAO,CAAC,cAAc,CAAC,YAAY,CAAC,GACpC,IAAI,CAAC,cAAc,CAAC,YAAY,EAAE,WAAW,CAAC,CAAC;AAEnD;;;;;;;;;;;GAWG;AACH,oBAAY,UAAU,CACpB,YAAY,EACZ,YAAY,SAAS,aAAa,CAAC,UAAU,CAAC,IAC5C;KACD,GAAG,IAAI,MAAM,YAAY,GAAG,SAAS,CACpC,YAAY,EACZ,OAAO,CAAC,YAAY,CAAC,GAAG,CAAC,EAAE,UAAU,CAAC,CACvC;CACF,CAAC"}

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

@@ -0,0 +1,61 @@
+import { FieldValues } from '../fields';
+import { AccessPattern } from './internal/utils';
+declare const FORM_VALUES: unique symbol;
+declare const ACCESS_PATTERN: unique symbol;
+/**
+ * Type which describes a path through a form.
+ * @typeParam TFieldValues - the field values for which this path is valid
+ * @typeParam TValue - the value which may be read from the path
+ * @typeParam TValueSet - the value which can be written to the path
+ * @example
+ * ```
+ * declare function getNumber<T extends FieldValues>(
+ *   obj: T,
+ *   path: TypedFieldPath<T, number>,
+ * ): number
+ * ```
+ */
+export declare type TypedFieldPath<TFieldValues, TValue, TValueSet = TValue> = string & {
+    [FORM_VALUES]: TFieldValues;
+    [ACCESS_PATTERN]: AccessPattern<TValue, TValueSet>;
+};
+/**
+ * Type which describes a path through a form.
+ * @typeParam TFieldValues - the field values for which this path is valid
+ * @example
+ * ```
+ * declare function get<T extends FieldValues, P extends FieldPath<T>>(
+ *   obj: T,
+ *   path: P,
+ * ): FieldPathValue<T, P>
+ * ```
+ */
+export declare type FieldPath<TFieldValues> = TypedFieldPath<TFieldValues, unknown, never>;
+/**
+ * Type which describes a path through a form and points to an array.
+ * @typeParam TFieldValues - the field values for which this path is valid
+ * @typeParam TArrayValues - the value which may be read from array at the path
+ * @typeParam TArrayValuesSet - the value which can be written to the array at the path
+ * @example
+ * ```
+ * declare function popNumber<T extends FieldValues>(
+ *   obj: T,
+ *   path: TypedFieldArrayPath<T, number>,
+ * ): number
+ * ```
+ */
+export declare type TypedFieldArrayPath<TFieldValues, TArrayValues extends FieldValues, TArrayValuesSet extends FieldValues = TArrayValues> = TypedFieldPath<TFieldValues, ReadonlyArray<TArrayValues> | null | undefined, TArrayValuesSet[]>;
+/**
+ * Type which describes a path through a form and points to an array.
+ * @typeParam TFieldValues - the field values for which this path is valid
+ * @example
+ * ```
+ * declare function pop<T extends FieldValues, P extends FieldArrayPath<T>>(
+ *   obj: T,
+ *   path: P,
+ * ): FieldPathValue<T, P>[never]
+ * ```
+ */
+export declare type FieldArrayPath<TFieldValues> = TypedFieldArrayPath<TFieldValues, FieldValues, never>;
+export {};
+//# sourceMappingURL=branded.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"branded.d.ts","sourceRoot":"","sources":["../../../src/types/path/branded.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAExC,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjD,OAAO,CAAC,MAAM,WAAW,EAAE,OAAO,MAAM,CAAC;AACzC,OAAO,CAAC,MAAM,cAAc,EAAE,OAAO,MAAM,CAAC;AAE5C;;;;;;;;;;;;GAYG;AACH,oBAAY,cAAc,CACxB,YAAY,EACZ,MAAM,EACN,SAAS,GAAG,MAAM,IAChB,MAAM,GAAG;IACX,CAAC,WAAW,CAAC,EAAE,YAAY,CAAC;IAC5B,CAAC,cAAc,CAAC,EAAE,aAAa,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;CACpD,CAAC;AAEF;;;;;;;;;;GAUG;AACH,oBAAY,SAAS,CAAC,YAAY,IAAI,cAAc,CAClD,YAAY,EACZ,OAAO,EACP,KAAK,CACN,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,oBAAY,mBAAmB,CAC7B,YAAY,EACZ,YAAY,SAAS,WAAW,EAChC,eAAe,SAAS,WAAW,GAAG,YAAY,IAChD,cAAc,CAChB,YAAY,EACZ,aAAa,CAAC,YAAY,CAAC,GAAG,IAAI,GAAG,SAAS,EAC9C,eAAe,EAAE,CAClB,CAAC;AAEF;;;;;;;;;;GAUG;AACH,oBAAY,cAAc,CAAC,YAAY,IAAI,mBAAmB,CAC5D,YAAY,EACZ,WAAW,EACX,KAAK,CACN,CAAC"}

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

@@ -1,4 +1,8 @@
-/** Re-export public API */
-export { PathString } from './common';
-export { ArrayPath, FieldArrayPath, FieldArrayPathValue, FieldPath, FieldPathValue, FieldPathValues, Path, PathValue, } from './eager';
+import type * as Auto from './auto';
+import type * as Branded from './branded';
+import type * as Lazy from './lazy';
+export type { Auto, Branded, Lazy };
+export * from './branded';
+export * from './pathString';
+export * from './value';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/types/path/index.ts"],"names":[],"mappings":"AAAA,2BAA2B;AAE3B,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AACtC,OAAO,EACL,SAAS,EACT,cAAc,EACd,mBAAmB,EACnB,SAAS,EACT,cAAc,EACd,eAAe,EACf,IAAI,EACJ,SAAS,GACV,MAAM,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/types/path/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,IAAI,MAAM,QAAQ,CAAC;AACpC,OAAO,KAAK,KAAK,OAAO,MAAM,WAAW,CAAC;AAC1C,OAAO,KAAK,KAAK,IAAI,MAAM,QAAQ,CAAC;AAEpC,YAAY,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;AACpC,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,SAAS,CAAC"}

package/dist/types/path/internal/autoCompletePath.d.ts

@@ -0,0 +1,173 @@
+import { IsAny, IsNever } from '../../utils';
+import { PathString } from '../pathString';
+import { HasPath, ValidPathPrefix } from './hasPath';
+import { Keys } from './keys';
+import { PathGetValue } from './pathGetValue';
+import { PathSetValue } from './pathSetValue';
+import { JoinPathTuple, PathTuple, SplitPathString } from './pathTuple';
+import { AccessPattern, Key, Traversable, UnionToIntersection } from './utils';
+/**
+ * Type, which given a path, returns the parent path as a string
+ * @typeParam PT - path represented as a tuple
+ * @example
+ * ```
+ * SuggestParentPath<['foo', 'bar', 'baz']> = 'foo.bar'
+ * SuggestParentPath<['foo', 'bar']> = 'foo'
+ * SuggestParentPath<['foo']> = never
+ * ```
+ * @internal
+ */
+export declare type SuggestParentPath<PT extends PathTuple> = JoinPathTuple<PT extends [...infer R, Key] ? R : []>;
+/**
+ * Type to implement {@link SuggestChildPaths}.
+ * @typeParam PT  - the current path as a {@link PathTuple}
+ * @typeParam TPT - the type at that path
+ * @typeParam C   - constraint
+ * @internal
+ */
+declare type SuggestChildPathsImpl<PT extends PathTuple, TPT, C extends AccessPattern> = JoinPathTuple<[
+    ...PT,
+    Keys<TPT, C> | Keys<TPT, AccessPattern<Traversable | undefined | null>>
+]>;
+/**
+ * Type, which given a type and a path into the type, returns all paths as
+ * strings which can be used to index the type at that path.
+ * Filters out paths whose value doesn't match the constraint type or
+ * aren't traversable.
+ * @typeParam T  - type which is indexed by the path
+ * @typeParam PT - the current path into the type as a tuple
+ * @typeParam C  - constraint
+ * @example
+ * ```
+ * SuggestChildPaths<{foo: string, bar: string}, [], AccessPattern<string>>
+ *   = 'foo' | 'bar'
+ * SuggestChildPaths<{foo: string, bar: number}, [], AccessPattern<string>>
+ *   = 'foo'
+ * SuggestChildPaths<{foo: {bar: string}}, ['foo']> = 'foo.bar'
+ * SuggestChildPaths<{foo: {bar: string[]}}, ['foo']> = 'foo.bar'
+ * ```
+ * @internal
+ */
+export declare type SuggestChildPaths<T, PT extends PathTuple, C extends AccessPattern = AccessPattern> = PT extends any ? SuggestChildPathsImpl<PT, PathGetValue<T, PT>, C> : never;
+/**
+ * Type to implement {@link SuggestPaths} without having to compute the valid
+ * path prefix more than once.
+ * @typeParam T   - type which is indexed by the path
+ * @typeParam PT  - the current path into the type as a tuple
+ * @typeParam C   - constraint
+ * @typeParam VPT - the valid path prefix for the given path
+ * @internal
+ */
+declare type SuggestPathsImpl<T, PT extends PathTuple, C extends AccessPattern, VPT extends PathTuple> = SuggestChildPaths<T, VPT, C> | (PT extends VPT ? SuggestParentPath<VPT> : JoinPathTuple<VPT>);
+/**
+ * Type which given a type and a path tuple into it returns
+ *  - its parent/predecessor path string.
+ *  - all its child/successor paths that point to a type which is either
+ *    traversable or matches the constraint type.
+ * In case the path does not exist it returns all of the above, but for the last
+ * valid path prefix.
+ * @typeParam T  - type which is indexed by the path
+ * @typeParam PT - the current path into the type as a tuple
+ * @typeParam C  - constraint
+ * @example
+ * ```
+ * SuggestPaths<{foo: {bar: string}}, ['foo'], string> = 'foo.bar'
+ * SuggestPaths<{foo: {bar: string}}, ['foo', 'ba'], AccessPattern<string>>
+ *   = 'foo' | 'foo.bar'
+ * SuggestPaths<{foo: {bar: string}}, ['foo', 'bar'], AccessPattern<string>>
+ *   = 'foo'
+ * SuggestPaths<{foo: {bar: {baz: string}}}, ['foo', 'bar'], AccessPattern<string>>
+ *   = 'foo' | 'foo.bar.baz'
+ * ```
+ * @internal
+ */
+export declare type SuggestPaths<T, PT extends PathTuple, C extends AccessPattern = AccessPattern> = SuggestPathsImpl<T, PT, C, ValidPathPrefix<T, PT>>;
+/**
+ * Type to test whether the path is a union of paths.
+ * @typeParam PS - path
+ * @example
+ * ```
+ * IsPathUnion<'foo'> = false
+ * IsPathUnion<'foo' | 'foo'> = false
+ * IsPathUnion<'foo' | 'foo.bar'> = true
+ * ```
+ * @internal
+ */
+declare type IsPathUnion<PS extends PathString> = IsNever<UnionToIntersection<PS>>;
+/**
+ * Type to check the current path against the constraint type.
+ * Returns the path if it is valid and matches the constraint type.
+ * @typeParam T  - type which is indexed by the path
+ * @typeParam PS - the current path into the type as a string,
+ *                 mustn't be a union
+ * @typeParam PT - the current path into the type as a tuple,
+ *                 must be equal to SplitPathString<PS>
+ * @typeParam C  - constraint
+ * @example
+ * ```
+ * AutoCompletePathCheckConstraint<{foo: {bar: string}}, 'foo', ['foo'], AccessPattern<string>>
+ *   = never
+ * AutoCompletePathCheckConstraint<{foo: {bar: string}}, 'foo.ba', ['foo', 'ba'], AccessPattern<string>>
+ *   = never
+ * AutoCompletePathCheckConstraint<{foo: {bar: string}}, 'foo.bar', ['foo', 'bar'], AccessPattern<string>>
+ *   = 'foo.bar'
+ * ```
+ * @internal
+ */
+declare type AutoCompletePathCheckConstraint<T, PS extends PathString, PT extends PathTuple, C extends AccessPattern> = HasPath<T, PT> extends true ? AccessPattern<PathGetValue<T, PT>, PathSetValue<T, PT>> extends C ? PS extends JoinPathTuple<PT> ? PS : JoinPathTuple<PT> : never : never;
+/**
+ * Type to implement {@link AutoCompletePath} without having to compute the
+ * path tuple more than once.
+ * @typeParam T  - type which is indexed by the path
+ * @typeParam PS - the current path into the type as a string,
+ *                 mustn't be a union
+ * @typeParam PT - the current path into the type as a tuple,
+ *                 must be equal to SplitPathString<PS>
+ * @typeParam C  - constraint
+ * @example
+ * ```
+ * AutoCompletePathImpl<{foo: {bar: string}}, 'foo', ['foo'], AccessPattern<string>>
+ *   = 'foo.bar'
+ * AutoCompletePathImpl<{foo: {bar: string}}, 'foo.ba', ['foo', 'ba'], AccessPattern<string>>
+ *   = 'foo' | 'foo.bar'
+ * AutoCompletePathImpl<{foo: {bar: string}}, 'foo.bar', ['foo', 'bar'], AccessPattern<string>>
+ *   = 'foo' | 'foo.bar'
+ * AutoCompletePathImpl<{foo: {bar: {baz: string}}}, 'foo.bar', ['foo', 'bar'], AccessPattern<string>>
+ *   = 'foo' | 'foo.bar.baz'
+ * ```
+ * @internal
+ */
+declare type AutoCompletePathImpl<T, PS extends PathString, PT extends PathTuple, C extends AccessPattern> = SuggestPaths<T, PT, C> | AutoCompletePathCheckConstraint<T, PS, PT, C>;
+/**
+ * Type which given a type and a path string into it returns
+ *  - its parent/predecessor path string.
+ *  - the path string itself, if it exists within the type and matches
+ *    the constraint type.
+ *  - all its child/successor paths that point to a type which is either
+ *    traversable or matches the constraint type.
+ * Also,
+ *  - in case the path does not exist it returns all of the above for the last
+ *    valid path.
+ *  - in case the path is a union of paths it doesn't suggest any
+ *    parent/predecessor and child/successor paths.
+ *    Otherwise, the returned type may become to large, or it may accept paths
+ *    which don't match the constraint type.
+ * @typeParam T  - type which is indexed by the path
+ * @typeParam PS - the current path into the type as a string
+ * @typeParam C  - constraint
+ * @example
+ * ```
+ * AutoCompletePath<{foo: {bar: string}}, 'foo', AccessPattern<string>>
+ *   = 'foo.bar'
+ * AutoCompletePath<{foo: {bar: string}}, 'foo.ba', AccessPattern<string>>
+ *   = 'foo' | 'foo.bar'
+ * AutoCompletePath<{foo: {bar: string}}, 'foo.bar', AccessPattern<string>>
+ *   = 'foo' | 'foo.bar'
+ * AutoCompletePath<{foo: {bar: {baz: string}}}, 'foo.bar', AccessPattern<string>>
+ *   = 'foo' | 'foo.bar.baz'
+ * ```
+ * @internal
+ */
+export declare type AutoCompletePath<T, PS extends PathString, C extends AccessPattern = AccessPattern> = IsAny<PS> extends true ? any : IsPathUnion<PS> extends false ? AutoCompletePathImpl<T, PS, SplitPathString<PS>, C> : PS extends any ? AutoCompletePathCheckConstraint<T, PS, SplitPathString<PS>, C> : never;
+export {};
+//# sourceMappingURL=autoCompletePath.d.ts.map

package/dist/types/path/internal/autoCompletePath.d.ts.map

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

package/dist/types/path/internal/hasPath.d.ts

@@ -0,0 +1,56 @@
+import { IsNever } from '../../utils';
+import { Keys } from './keys';
+import { KeyGetValue } from './pathGetValue';
+import { AsPathTuple, PathTuple } from './pathTuple';
+import { AsKey, Key } from './utils';
+/**
+ * Type to check whether a key is present in a type.
+ * If a union of keys is passed, all keys 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
+ * ```
+ * @internal
+ */
+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 keys which have been
+ *                  confirmed to exist already
+ * @internal
+ */
+declare type ValidPathPrefixImpl<T, PT extends PathTuple, VPT extends PathTuple> = PT extends [infer K, ...infer R] ? HasKey<T, AsKey<K>> extends true ? ValidPathPrefixImpl<KeyGetValue<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']
+ * ```
+ * @internal
+ */
+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
+ * ```
+ * @internal
+ */
+export declare type HasPath<T, PT extends PathTuple> = ValidPathPrefix<T, PT> extends PT ? true : false;
+export {};
+//# sourceMappingURL=hasPath.d.ts.map

package/dist/types/path/internal/hasPath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hasPath.d.ts","sourceRoot":"","sources":["../../../../src/types/path/internal/hasPath.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAEtC,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,SAAS,CAAC;AAErC;;;;;;;;;;;;GAYG;AACH,oBAAY,MAAM,CAAC,CAAC,EAAE,CAAC,SAAS,GAAG,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAEpE;;;;;;;GAOG;AACH,aAAK,mBAAmB,CACtB,CAAC,EACD,EAAE,SAAS,SAAS,EACpB,GAAG,SAAS,SAAS,IACnB,EAAE,SAAS,CAAC,MAAM,CAAC,EAAE,GAAG,MAAM,CAAC,CAAC,GAChC,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,IAAI,GAC9B,mBAAmB,CACjB,WAAW,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,EACxB,WAAW,CAAC,CAAC,CAAC,EACd,WAAW,CAAC,CAAC,GAAG,GAAG,EAAE,CAAC,CAAC,CAAC,CACzB,GACD,GAAG,GACL,GAAG,CAAC;AAER;;;;;;;;;;;GAWG;AACH,oBAAY,eAAe,CAAC,CAAC,EAAE,EAAE,SAAS,SAAS,IAAI,mBAAmB,CACxE,CAAC,EACD,EAAE,EACF;CAAE,CACH,CAAC;AAEF;;;;;;;;;;GAUG;AACH,oBAAY,OAAO,CAAC,CAAC,EAAE,EAAE,SAAS,SAAS,IAAI,eAAe,CAAC,CAAC,EAAE,EAAE,CAAC,SAAS,EAAE,GAC5E,IAAI,GACJ,KAAK,CAAC"}

package/dist/types/path/internal/keys.d.ts

@@ -0,0 +1,103 @@
+import { IsAny, IsNever } from '../../utils';
+import { KeyGetValue } from './pathGetValue';
+import { KeySetValue } from './pathSetValue';
+import { AccessPattern, ArrayKey, IsTuple, Key, ToKey, Traversable, UnionToIntersection } from './utils';
+/**
+ * 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'
+ * ```
+ * @internal
+ */
+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'
+ * ```
+ * @internal
+ */
+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'
+ * ```
+ * @internal
+ */
+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'
+ * ```
+ * @internal
+ */
+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 string.
+ * @typeParam T - type whose property should be checked
+ * @typeParam K - key of the property
+ * @typeParam C - constraint
+ * @example
+ * ```
+ * CheckKeyConstraint<{foo: string}, 'foo', AccessPattern<string>> = 'foo'
+ * CheckKeyConstraint<{foo: string}, 'foo', AccessPattern<number>> = never
+ * CheckKeyConstraint<string[], number, AccessPattern<string>> = `${number}`
+ * ```
+ * @internal
+ */
+export declare type CheckKeyConstraint<T, K extends Key, C extends AccessPattern> = K extends any ? AccessPattern<KeyGetValue<T, K>, KeySetValue<T, K>> extends C ? 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
+ * ```
+ * @internal
+ */
+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
+ * @internal
+ */
+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 C - constraint
+ * @example
+ * ```
+ * Keys<{foo: string, bar: string}, AccessPattern<string>> = 'foo' | 'bar'
+ * Keys<{foo?: string, bar?: string}> = 'foo' | 'bar'
+ * Keys<{foo: string, bar: number}, AccessPattern<string>> = 'foo'
+ * Keys<[string, number], string> = '0'
+ * Keys<string[], AccessPattern<string>> = `${number}`
+ * Keys<{0: string, '1': string} | [number] | number[]> = '0'
+ * ```
+ * @internal
+ */
+export declare type Keys<T, C extends AccessPattern = AccessPattern> = IsAny<T> extends true ? Key : IsNever<T> extends true ? Key : IsNever<NonNullable<T>> extends true ? never : CheckKeyConstraint<T, KeysImpl<NonNullable<T>>, C>;
+export {};
+//# sourceMappingURL=keys.d.ts.map

package/dist/types/path/internal/keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keys.d.ts","sourceRoot":"","sources":["../../../../src/types/path/internal/keys.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE7C,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EACL,aAAa,EACb,QAAQ,EACR,OAAO,EACP,GAAG,EACH,KAAK,EACL,WAAW,EACX,mBAAmB,EACpB,MAAM,SAAS,CAAC;AAEjB;;;;;;;;GAQG;AACH,oBAAY,SAAS,CAAC,CAAC,SAAS,aAAa,CAAC,GAAG,CAAC,IAAI,OAAO,CAC3D,MAAM,CAAC,EACP,MAAM,GAAG,EAAE,CACZ,CAAC;AAEF;;;;;;;;GAQG;AACH,aAAK,iBAAiB,CAAC,CAAC,SAAS,WAAW,IAAI,KAAK,CACnD,OAAO,CAAC,MAAM,CAAC,EAAE,QAAQ,GAAG,GAAG,QAAQ,EAAE,CAAC,CAC3C,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,oBAAY,WAAW,CAAC,CAAC,SAAS,WAAW,IAAI,mBAAmB,CAClE,CAAC,SAAS,aAAa,CAAC,GAAG,CAAC,GACxB,OAAO,CAAC,CAAC,CAAC,SAAS,IAAI,GACrB,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,GACd,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,GACnB,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAC3B,CAAC,KAAK,CAAC,CAAC;AAET;;;;;;;;;;GAUG;AACH,oBAAY,UAAU,CAAC,CAAC,SAAS,WAAW,IAAI,OAAO,CACrD,KAAK,CAAC,MAAM,CAAC,CAAC,EACd,GAAG,MAAM,IAAI,MAAM,EAAE,GAAG,EAAE,CAC3B,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,oBAAY,kBAAkB,CAC5B,CAAC,EACD,CAAC,SAAS,GAAG,EACb,CAAC,SAAS,aAAa,IACrB,CAAC,SAAS,GAAG,GACb,aAAa,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,GAC3D,CAAC,GACD,KAAK,GACP,KAAK,CAAC;AAEV;;;;;;;;;;GAUG;AACH,oBAAY,iBAAiB,CAAC,CAAC,IAAI,OAAO,CACxC,OAAO,CAAC,CAAC,EAAE,aAAa,CAAC,GAAG,CAAC,CAAC,CAC/B,SAAS,IAAI,GACV,KAAK,GACL,IAAI,CAAC;AAET;;;;GAIG;AACH,aAAK,QAAQ,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,WAAW,CAAC,GACxC,iBAAiB,CAAC,CAAC,CAAC,SAAS,IAAI,GAC/B,WAAW,CAAC,CAAC,CAAC,GACd,UAAU,CAAC,CAAC,CAAC,GACf,KAAK,CAAC;AAEV;;;;;;;;;;;;;;;;GAgBG;AACH,oBAAY,IAAI,CACd,CAAC,EACD,CAAC,SAAS,aAAa,GAAG,aAAa,IACrC,KAAK,CAAC,CAAC,CAAC,SAAS,IAAI,GACrB,GAAG,GACH,OAAO,CAAC,CAAC,CAAC,SAAS,IAAI,GACvB,GAAG,GACH,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,SAAS,IAAI,GACpC,KAAK,GACL,kBAAkB,CAAC,CAAC,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC"}

package/dist/types/path/internal/pathGetValue.d.ts

@@ -0,0 +1,76 @@
+import { IsAny, IsNever } from '../../utils';
+import { AsPathTuple, PathTuple } from './pathTuple';
+import { ArrayKey, AsKey, IsTuple, Key, MapKeys } from './utils';
+/**
+ * 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
+ * ```
+ * TryGet<{foo: string}, 'foo'> = string
+ * TryGet<{foo: string}, 'bar'> = undefined
+ * TryGet<null, 'foo'> = null
+ * TryGet<string, 'foo'> = undefined
+ * ```
+ * @internal
+ */
+declare type TryGet<T, K> = K extends keyof T ? T[K] : T extends null | undefined ? T : unknown;
+/**
+ * Type to access an array type by a key.
+ * @typeParam T - type which is indexed by the key
+ * @typeParam K - key into the type
+ * ```
+ * TryGetArray<string[], '0'> = string
+ * TryGetArray<string[], 'foo'> = undefined
+ * ```
+ * @internal
+ */
+declare type TryGetArray<T extends ReadonlyArray<any>, K extends Key> = K extends `${ArrayKey}` ? T[number] : TryGet<T, K>;
+/**
+ * Type to evaluate the type which the given key points to.
+ *  - If either T or K is union, it will evaluate to the union of the types at
+ *    the given key(s).
+ *  - If T can be null or undefined, the resulting type will also include null
+ *    or undefined.
+ *  - If a key doesn't exist, or may be optional, the resulting type will
+ *    include undefined.
+ * @typeParam T - type which is indexed by the key
+ * @typeParam K - key into the type
+ * @example
+ * ```
+ * KeyGetValue<{foo: string}, 'foo'> = string
+ * KeyGetValue<{foo: string, bar: number}, 'foo' | 'bar'> = string | number
+ * KeyGetValue<{foo: string} | {foo: number}, 'foo'> = string | number
+ * KeyGetValue<null | {foo: string}, 'foo'> = null | string
+ * KeyGetValue<{bar: string}, 'foo'> = undefined
+ * KeyGetValue<{foo?: string}, 'foo'> = undefined | string
+ * ```
+ * @internal
+ */
+export declare type KeyGetValue<T, K extends Key> = IsNever<K> extends true ? unknown : T extends ReadonlyArray<any> ? IsTuple<T> extends true ? TryGet<T, K> : TryGetArray<T, K> : TryGet<MapKeys<T>, K>;
+/**
+ * Type to evaluate the type which the given path points to.
+ *  - If either T or PT is union, it will evaluate to the union of the types at
+ *    the given path(s).
+ *  - If T can be null or undefined, the resulting type will also include null
+ *    or undefined.
+ *  - If a path doesn't exist, or may be optional, the resulting type will
+ *    include undefined.
+ * @typeParam T  - deeply nested type which is indexed by the path
+ * @typeParam PT - path into the deeply nested type
+ * @example
+ * ```
+ * PathGetValue<{foo: {bar: string}}, ['foo', 'bar']> = string
+ * PathGetValue<{foo: string, bar: number}, ['foo'] | ['bar']> = string | number
+ * PathGetValue<{foo: string} | {foo: number}, ['foo']> = string | number
+ * PathGetValue<null | {foo: string}, ['foo']> = null | string
+ * PathGetValue<{bar: string}, ['foo']> = undefined
+ * PathGetValue<{foo?: string}, ['foo']> = undefined | string
+ * ```
+ * @internal
+ */
+export declare type PathGetValue<T, PT extends PathTuple> = IsAny<PT> extends true ? any : IsNever<PT> extends true ? unknown : PT extends [infer K, ...infer R] ? PathGetValue<KeyGetValue<T, AsKey<K>>, AsPathTuple<R>> : T;
+export {};
+//# sourceMappingURL=pathGetValue.d.ts.map

package/dist/types/path/internal/pathGetValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pathGetValue.d.ts","sourceRoot":"","sources":["../../../../src/types/path/internal/pathGetValue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE7C,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAEjE;;;;;;;;;;;;;;GAcG;AACH,aAAK,MAAM,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,SAAS,MAAM,CAAC,GACjC,CAAC,CAAC,CAAC,CAAC,GACJ,CAAC,SAAS,IAAI,GAAG,SAAS,GAC1B,CAAC,GACD,OAAO,CAAC;AAEZ;;;;;;;;;GASG;AACH,aAAK,WAAW,CACd,CAAC,SAAS,aAAa,CAAC,GAAG,CAAC,EAC5B,CAAC,SAAS,GAAG,IACX,CAAC,SAAS,GAAG,QAAQ,EAAE,GAAG,CAAC,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAEvD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,oBAAY,WAAW,CAAC,CAAC,EAAE,CAAC,SAAS,GAAG,IAAI,OAAO,CAAC,CAAC,CAAC,SAAS,IAAI,GAC/D,OAAO,GACP,CAAC,SAAS,aAAa,CAAC,GAAG,CAAC,GAC5B,OAAO,CAAC,CAAC,CAAC,SAAS,IAAI,GACrB,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,GACZ,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,GACnB,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAE1B;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,oBAAY,YAAY,CAAC,CAAC,EAAE,EAAE,SAAS,SAAS,IAAI,KAAK,CAAC,EAAE,CAAC,SAAS,IAAI,GACtE,GAAG,GACH,OAAO,CAAC,EAAE,CAAC,SAAS,IAAI,GACxB,OAAO,GACP,EAAE,SAAS,CAAC,MAAM,CAAC,EAAE,GAAG,MAAM,CAAC,CAAC,GAChC,YAAY,CAAC,WAAW,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC,GACtD,CAAC,CAAC"}