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

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"}

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

@@ -0,0 +1,96 @@
+import { IsAny } from '../../utils';
+import { AsPathTuple, PathTuple } from './pathTuple';
+import { ArrayKey, AsKey, IsTuple, Key, MapKeys, UnionToIntersection } from './utils';
+/**
+ * Type to access a type by a key. Returns never
+ *  - if it can't be indexed by that key.
+ *  - if the type is not traversable.
+ * @typeParam T - type which is indexed by the key
+ * @typeParam K - key into the type
+ * ```
+ * TrySet<{foo: string}, 'foo'> = string
+ * TrySet<{foo: string}, 'bar'> = never
+ * TrySet<null, 'foo'> = never
+ * TrySet<string, 'foo'> = never
+ * ```
+ * @internal
+ */
+declare type TrySet<T, K> = K extends keyof T ? T[K] : never;
+/**
+ * Type to access an array type by a key.
+ * @typeParam T - type which is indexed by the key
+ * @typeParam K - key into the type
+ * ```
+ * TrySetArray<string[], '0'> = string
+ * TrySetArray<string[], 'foo'> = never
+ * ```
+ * @internal
+ */
+declare type TrySetArray<T extends ReadonlyArray<any>, K extends Key> = K extends `${ArrayKey}` ? T[number] : TrySet<T, K>;
+/**
+ * Type to implement {@link KeySetValue}. Wraps everything into a tuple.
+ * @typeParam T - non-nullable type which is indexed by the key
+ * @typeParam K - key into the type, mustn't be a union of keys
+ * @internal
+ */
+declare type KeySetValueImpl<T, K extends Key> = T extends ReadonlyArray<any> ? IsTuple<T> extends true ? [TrySet<T, K>] : [TrySetArray<T, K>] : [TrySet<MapKeys<T>, K>];
+/**
+ * Type to evaluate the type which is required for setting the property which
+ * the given key points to.
+ *  - If either T or K is union, it will evaluate to the intersection of the
+ *    types at the given key(s).
+ *  - If T can be null or undefined, the resulting type won't include null or
+ *    undefined.
+ *  - If a key doesn't exist,the resulting type will be never.
+ *  - If a key 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
+ * ```
+ * KeySetValue<{foo: string}, 'foo'> = string
+ * KeySetValue<{foo: string, bar: number}, 'foo' | 'bar'> = string & number
+ * KeySetValue<{foo: string} | {foo: number}, 'foo'> = string & number
+ * KeySetValue<null | {foo: string}, 'foo'> = string
+ * KeySetValue<{bar: string}, 'foo'> = never
+ * KeySetValue<{foo?: string}, 'foo'> = undefined | string
+ * ```
+ * @internal
+ */
+export declare type KeySetValue<T, K extends Key> = UnionToIntersection<K extends any ? KeySetValueImpl<NonNullable<T>, K> : never>[never];
+/**
+ * Type to implement {@link PathSetValue} tail-recursively.
+ * Wraps everything into a tuple.
+ * @typeParam T  - deeply nested type which is indexed by the path
+ * @typeParam PT - path into the deeply nested type
+ * @internal
+ */
+declare type PathSetValueImpl<T, PT extends PathTuple> = PT extends [
+    infer K,
+    ...infer R
+] ? PathSetValueImpl<KeySetValue<T, AsKey<K>>, AsPathTuple<R>> : [T];
+/**
+ * Type to evaluate the type which is required for setting the property which
+ * the given path points to.
+ *  - If either T or PT is union, it will evaluate to the intersection of the
+ *    types at the given paths(s).
+ *  - If T can be null or undefined, the resulting type won't include null or
+ *    undefined.
+ *  - If a path doesn't exist, the resulting type will be never.
+ *  - Only if last kay is 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
+ * ```
+ * PathSetValue<{foo: {bar: string}}, ['foo', 'bar']> = string
+ * PathSetValue<{foo: string, bar: number}, ['foo'] | ['bar']> = string & number
+ * PathSetValue<{foo: string} | {foo: number}, ['foo']> = string & number
+ * PathSetValue<null | {foo: string}, ['foo']> = string
+ * PathSetValue<{bar: string}, ['foo']> = never
+ * PathSetValue<{foo?: string}, ['foo']> = undefined | string
+ * PathSetValue<{foo?: {bar: string}}, ['foo', 'bar']> = string
+ * ```
+ * @internal
+ */
+export declare type PathSetValue<T, PT extends PathTuple> = IsAny<PT> extends true ? any : UnionToIntersection<PathSetValueImpl<T, PT>>[never];
+export {};
+//# sourceMappingURL=pathSetValue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pathSetValue.d.ts","sourceRoot":"","sources":["../../../../src/types/path/internal/pathSetValue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEpC,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,EACL,QAAQ,EACR,KAAK,EACL,OAAO,EACP,GAAG,EACH,OAAO,EACP,mBAAmB,EACpB,MAAM,SAAS,CAAC;AAEjB;;;;;;;;;;;;;GAaG;AACH,aAAK,MAAM,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,SAAS,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC;AAErD;;;;;;;;;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;;;;;GAKG;AACH,aAAK,eAAe,CAAC,CAAC,EAAE,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,aAAa,CAAC,GAAG,CAAC,GACjE,OAAO,CAAC,CAAC,CAAC,SAAS,IAAI,GACrB,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GACd,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GACrB,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,oBAAY,WAAW,CAAC,CAAC,EAAE,CAAC,SAAS,GAAG,IAAI,mBAAmB,CAC7D,CAAC,SAAS,GAAG,GAAG,eAAe,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,KAAK,CAC3D,CAAC,KAAK,CAAC,CAAC;AAET;;;;;;GAMG;AACH,aAAK,gBAAgB,CAAC,CAAC,EAAE,EAAE,SAAS,SAAS,IAAI,EAAE,SAAS;IAC1D,MAAM,CAAC;IACP,GAAG,MAAM,CAAC;CACX,GACG,gBAAgB,CAAC,WAAW,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC,GAC1D,CAAC,CAAC,CAAC,CAAC;AAER;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,oBAAY,YAAY,CAAC,CAAC,EAAE,EAAE,SAAS,SAAS,IAAI,KAAK,CAAC,EAAE,CAAC,SAAS,IAAI,GACtE,GAAG,GACH,mBAAmB,CAAC,gBAAgB,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC"}

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

@@ -0,0 +1,73 @@
+import { IsAny } from '../../utils';
+import { PathString } from '../pathString';
+import { AsKey, Key } from './utils';
+/**
+ * Type which describes a path through an object as a list of individual keys.
+ * @internal
+ */
+export declare type PathTuple = Key[];
+/**
+ * Type to assert that a type is a path tuple.
+ * @typeParam T - type which may be a path tuple
+ * @internal
+ */
+export declare type AsPathTuple<T> = Extract<T, PathTuple>;
+/**
+ * Type which appends a key to the path tuple 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']
+ * ```
+ * @internal
+ */
+declare type AppendNonBlankKey<PT extends PathTuple, K extends Key> = K extends '' ? PT : [...PT, K];
+/**
+ * Type to implement {@link SplitPathString} tail recursively.
+ * @typeParam PS - remaining path string which should be split into its
+ *                 individual keys
+ * @typeParam PT - accumulator of the keys which have been split from
+ *                 the original path string already
+ * @internal
+ */
+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 path string into a path tuple.
+ * The individual keys may be empty strings.
+ * @typeParam PS  - path string which should be split into its individual keys
+ * @example
+ * ```
+ * SplitPathString<'foo'> = ['foo']
+ * SplitPathString<'foo.bar.0.baz'> = ['foo', 'bar', '0', 'baz']
+ * SplitPathString<'.'> = []
+ * ```
+ * @internal
+ */
+export declare type SplitPathString<PS extends PathString> = IsAny<PS> extends true ? any : SplitPathStringImpl<PS, []>;
+/**
+ * Type to implement {@link JoinPathTuple} tail-recursively.
+ * @typeParam PT - remaining keys which needs to be joined
+ * @typeParam PS - accumulator of the already joined keys
+ * @internal
+ */
+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 path tuple to a path string.
+ * @typeParam PT - path tuple which should be joined.
+ * @example
+ * ```
+ * JoinPathTuple<['foo']> = 'foo'
+ * JoinPathTuple<['foo', 'bar', '0', 'baz']> = 'foo.bar.0.baz'
+ * JoinPathTuple<[]> = never
+ * ```
+ * @internal
+ */
+export declare type JoinPathTuple<PT extends PathTuple> = PT extends [
+    infer K,
+    ...infer R
+] ? JoinPathTupleImpl<AsPathTuple<R>, AsKey<K>> : never;
+export {};
+//# sourceMappingURL=pathTuple.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pathTuple.d.ts","sourceRoot":"","sources":["../../../../src/types/path/internal/pathTuple.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,SAAS,CAAC;AAErC;;;GAGG;AACH,oBAAY,SAAS,GAAG,GAAG,EAAE,CAAC;AAE9B;;;;GAIG;AACH,oBAAY,WAAW,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;AAEnD;;;;;;;;;;;GAWG;AACH,aAAK,iBAAiB,CAAC,EAAE,SAAS,SAAS,EAAE,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,EAAE,GACtE,EAAE,GACF,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC;AAEf;;;;;;;GAOG;AACH,aAAK,mBAAmB,CACtB,EAAE,SAAS,UAAU,EACrB,EAAE,SAAS,SAAS,IAClB,EAAE,SAAS,GAAG,MAAM,CAAC,IAAI,MAAM,CAAC,EAAE,GAClC,mBAAmB,CAAC,CAAC,EAAE,iBAAiB,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAChD,iBAAiB,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;AAE9B;;;;;;;;;;;GAWG;AACH,oBAAY,eAAe,CAAC,EAAE,SAAS,UAAU,IAAI,KAAK,CAAC,EAAE,CAAC,SAAS,IAAI,GACvE,GAAG,GACH,mBAAmB,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;AAEhC;;;;;GAKG;AACH,aAAK,iBAAiB,CACpB,EAAE,SAAS,SAAS,EACpB,EAAE,SAAS,UAAU,IACnB,EAAE,SAAS,CAAC,MAAM,CAAC,EAAE,GAAG,MAAM,CAAC,CAAC,GAChC,iBAAiB,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,GACtD,EAAE,CAAC;AAEP;;;;;;;;;;GAUG;AACH,oBAAY,aAAa,CAAC,EAAE,SAAS,SAAS,IAAI,EAAE,SAAS;IAC3D,MAAM,CAAC;IACP,GAAG,MAAM,CAAC;CACX,GACG,iBAAiB,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,GAC3C,KAAK,CAAC"}