export declare function update<Obj, const Path, T>(
  obj: Obj,
  path: Path,
  updater: (value: Get<Obj, Path>) => T,
): SetDeep<Obj, Path, T>;

type SetDeep<Obj, Path, T> = RecursiveSet<Obj, ParsePath<Path>, T>;

type Get<Obj, Path> = RecursiveGet<Obj, ParsePath<Path>>;

type ParsePath<
  Path,
  Output extends string[] = [],
  CurrentChunk extends string = "",
> = Path extends number
  ? [`${Path}`]
  : Path extends `${infer First}${infer Rest}`
    ? First extends "." | "[" | "]"
      ? ParsePath<
          Rest,
          [...Output, ...(CurrentChunk extends "" ? [] : [CurrentChunk])],
          ""
        >
      : ParsePath<Rest, Output, `${CurrentChunk}${First}`>
    : [...Output, ...(CurrentChunk extends "" ? [] : [CurrentChunk])];

type RecursiveGet<Obj, PathList> = Obj extends any
  ? PathList extends [infer First, ...infer Rest]
    ? First extends keyof Obj
      ? RecursiveGet<Obj[First], Rest>
      : [First, Obj] extends [`${number}` | "number", any[]]
        ? RecursiveGet<Extract<Obj, any[]>[number], Rest>
        : undefined
    : Obj
  : never;

type RecursiveSet<Obj, PathList, T> = Obj extends any
  ? PathList extends [infer First, ...infer Rest]
    ? First extends keyof Obj
      ? {
          [K in keyof Obj]: Equal<First, K> extends true
            ? RecursiveSet<Obj[K], Rest, T>
            : Obj[K];
        }
      : [First, Obj] extends [`${number}`, any[]]
        ? RecursiveSet<Extract<Obj, any[]>[number], Rest, T>[]
        : undefined
    : T
  : never;

type SnakeToCamel<Str> = Str extends `${infer First}_${infer Rest}`
  ? //    Split on underscores 👆
    `${First}${SnakeToCamel<Capitalize<Rest>>}`
  : //      Capitalize each word 👆
    Str;

type CamelizeDeep<T> =
  | {
      [K in keyof T as SnakeToCamel<K>]: CamelizeDeep<T[K]>;
    }
  | never;

export declare function deepCamelize<T>(obj: T): CamelizeDeep<T>;

import { deepCamelize } from "~/helpers/deep-camelize";

// Transforms all keys from snake_case to camelCase:

const apiPayload = {
  chapter_title: "Loops with Mapped Types",
  author: { full_name: "Gabriel Vergnaud" },
};

const camelized = deepCamelize(apiPayload);
//    camelized: { chapterTitle: string; author: { fullName: string } }

import { update } from "~/helpers/update";

const player = { position: { x: "1", y: 0 } };
//               `x` is a string 👆

const newPlayer = update(player, "position.x", (x) => parseInt(x));
/*    newPlayer: { position: { x: number, y: number } }
                 Now it's a number! 👆                     */

const pkg = { name: "such-wow", releases: [{ version: 1 }] };

const newPkg = update(pkg, "releases[0].version", (v) => `${v}.0.0`);
//    newPkg: { name: string, releases: { version: string }[] }