Type Alias PathValue<T, P>

PathValue: T extends any
    ? P extends `${infer Key}.${infer Rest}`
        ? Key extends keyof T
            ? PathValue<T[Key], Rest>
            : T extends Map<infer K, infer V>
                ? K extends string
                | number
                    ? Key extends `${K}` ? PathValue<V, Rest> : never
                    : PathValue<V, Rest>
                : T extends Set<infer V>
                    ? Key extends `${number}` ? PathValue<V, Rest> : never
                    : T extends any[]
                        ? Key extends `${number}`
                            ? T extends (infer U)[] ? PathValue<U, Rest> : never
                            : never
                        : never
        : P extends keyof T
            ? T[P]
            : T extends Map<infer K, infer V>
                ? K extends string | number ? P extends `${K}` ? V : never : V
                : T extends Set<infer V>
                    ? P extends `${number}` ? V : never
                    : T extends any[]
                        ? P extends `${number}` ? T extends (infer U)[] ? U : never : never
                        : never
    : never

Extracts the value type at a specific string path.

Enables type-safe deep property access with compile-time validation of both path validity and return type correctness. Supports:

Regular object property access
Array/tuple index access
Map key access
Set index access

Type Parameters

T
P extends string

Example

interface User {
  profile: { name: string; age: number; };
  tags: Set<string>;
  metadata: Map<string, { value: string }>;
}
type UserName = PathValue<User, 'profile.name'>; // string
type Tag = PathValue<User, 'tags.0'>; // string
type MetaValue = PathValue<User, 'metadata.someKey.value'>; // string

// A key typed as a union with primitive members (e.g. `Config | false`)
// resolves against the object member instead of collapsing to `never` —
// the `T extends any` wrapper below is a bare type-param conditional,
// which forces the union to distribute (mirrors `PathNames`) before the
// `keyof T` checks run, so those checks see each member individually.

Type Alias PathValue<T, P>

Type Parameters

Example

Settings