Typsichere Extraktion von tief verschachtelten Eigenschaftspfaden

type Primitive = string | number | boolean | bigint | symbol | null | undefined;
 
type PropertyPath<T> = T extends Primitive
  ? never
  : {
      [K in keyof T & (string | number)]: T[K] extends Primitive
        ? `${K}`
        : `${K}` | `${K}.${PropertyPath<T[K]>}`;
    }[keyof T & (string | number)];
 
type PathValue<T, P extends string> = P extends `${infer Head}.${infer Tail}`
  ? Head extends keyof T
    ? PathValue<T[Head], Tail>
    : never
  : P extends keyof T
  ? T[P]
  : never;
 
function getDeepValue<T, P extends PropertyPath<T>>(obj: T, path: P): PathValue<T, P> {
  const keys = (path as string).split('.');
  let current: any = obj;
  for (const key of keys) {
    current = current?.[key];
  }
  return current;
}