typescript - Ako vytvoriť vnorený generický typ s automatickým inferovaním

Povedzme, že chcem vytvoriť „feature-config“, ktorý má nasledujúci typ:

type FeatureConfig = {
   isActivated: boolean;
   childs?: {
      [key: string]: FeatureConfig;
   }
}

const config : FeatureConfig = {
   isActivated: true,
   childs: {
      bar: {
         isActivated: true,
         childs: {
            foo: {
              isActivated: true
            }
         }
      },
      foo: {
         isActivated: false,
         childs: {
            bar: {
              isActivated: true
            }
         }
      }
   }
}

Všetko je zatiaľ v poriadku a overené typmi. Teraz chcem vytvoriť funkciu „build“, ktorá vezme Config a vráti „feature-tree“, ktorý môžem skontrolovať, či je určitá funkcia aktivovaná. Môj cieľ s touto funkciou je mať nasledujúcu syntax/funkcionalitu:

/// How should the types of this function look like??
const createFeatureChecker = (config: FeatureConfig) => {
   //...implementation
}

const featureChecker = createFeatureChecker(config);

featureChecker.bar.foo.isActivated // true
featureChecker.foo.isActivated // false
featureChecker.foo.bar.isActivated // false (since featureChecker.foo.isActivated is false)

Nemám žiadne problémy s implementáciou logiky funkcie v obyčajnom Javascript-e, ale mám problémy so správnym typovaním createFeatureChecker tak, aby som mohol používať featureChecker bezpečne z hľadiska typov.

Má niekto nejaké nápady, ako vyriešiť môj problém?

Odpoveď č. 1

Budete musieť použiť as const pri deklarovaní config alebo ho odovzdať ako objektový literál.

const config = {
   isActivated: true,
   childs: {
      bar: {
         isActivated: true,
         childs: {
            foo: {
              isActivated: true
            }
         }
      },
      foo: {
         isActivated: false,
         childs: {
            bar: {
              isActivated: true
            }
         }
      }
   }
} as const

Typovaná createFeatureFunction by vyzerala takto:

type Expand<T> = T extends infer O ? { [K in keyof O]: O[K] } : never

type CreateFeatureChecker<T extends FeatureConfig, Activated extends boolean = true> = {
    isActivated: Activated extends true ? T["isActivated"] : false
} & {
    -readonly [K in keyof (T["childs"])]: 
      (T["isActivated"] extends false ? false : Activated extends false ? false : true) extends infer A extends boolean
        ? T["childs"][K] extends { isActivated: infer B extends boolean } 
            ? T["childs"][K] extends { childs: infer C extends {
                [key: string]: FeatureConfig;
              }} 
                ? Expand<CreateFeatureChecker<{ isActivated: B, childs: C }, A>>
                : Expand<CreateFeatureChecker<{ isActivated: B }, A>>
            : never
        : never
}

const createFeatureChecker = <T extends FeatureConfig>(config: T): Expand<CreateFeatureChecker<T>> => {
   return {} as any
}

Niekoľko testov, aby sa zistilo, či to funguje:

const featureChecker = createFeatureChecker(config);

const a = featureChecker.bar.foo.isActivated // true
const b = featureChecker.foo.isActivated // false
const c = featureChecker.foo.bar.isActivated // false

Detské ihrisko