Better typing for aligned arrays and objects

[DIEGOHORVATTI]

src/types/path/eager.ts

I don't know if you use this as much as I do but I needed to make sure that my fields follow the typing of the interfaces that represent my routes because as it's an integration it can change a lot so I realized that the typing that HookForm provides wasn't enough so I created my own and to make sure I created typing tests trying to make it more human to understand.

My exemple of typing

export declare global {
  /**
   * @description Returns the nested keys of an object, including array support and avoiding circular references.
   */
  type NestedKeys<T = string, SeenTypes = never> = NonNullable<T extends object ? NestedKeyPath<T, SeenTypes> : never>;
}

type DotNotationKey<K extends string, U, SeenTypes> = `${K}` | `${K}.${number}` | (U extends SeenTypes ? never : `${K}.${number}.${NestedKeys<U, SeenTypes | U>}`);

type KeyPathType<K extends string, T, SeenTypes> = `${K}` | (T extends SeenTypes ? never : `${K}.${NestedKeys<T, SeenTypes | T>}`);

type IndexedKeyPath<Index extends number, U, SeenTypes> = `${Index}` | (U extends SeenTypes ? never : `${Index}.${NestedKeys<U, SeenTypes | U>}`);

type KeyPathIndexMapper<U, SeenTypes> = {
  [Index in number]: U extends object ? IndexedKeyPath<Index, U, SeenTypes> : `${Index}`;
}[number];

type KeyPathResolver<T, SeenTypes> = {
  [K in keyof T]: K extends string ? (T[K] extends (infer U)[] ? DotNotationKey<K, U, SeenTypes> : T[K] extends object ? KeyPathType<K, T[K], SeenTypes> : `${K}`) : never;
}[keyof T];

type NestedKeyPath<T, SeenTypes> = T extends (infer U)[] ? `${number}` | `${number}.${NestedKeys<U, SeenTypes>}` : KeyPathResolver<T, SeenTypes>;

---

But what the hell does it do??? I can have a binding when I work with complex arrays, especially when we're working with useFieldArray.