typescript - 如何创建带自动推断的嵌套泛型类型

假设我想创建一个“feature-config”，它具有以下类型：

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
            }
         }
      }
   }
}

到目前为止一切正常并且已检查过类型。现在我想创建一个“build”函数，该函数接受一个Config并返回一个“feature-tree”，我可以检查某个功能是否被激活。我创建这个函数的目标是实现以下语法/功能:

/// 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)

我在普通的 JavaScript 中实现函数逻辑没有问题，但我在给 createFeatureChecker 添加类型时遇到了困难，希望能以一种类型安全的方式使用 featureChecker。

有什么办法可以解决我的问题吗？

答案＃1

你需要使用 as const 声明 config 或将其作为对象字面量传递。

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

一个类型化的 createFeatureFunction 看起来像这样：

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
}

一些测试看看它是否工作：

const featureChecker = createFeatureChecker(config);

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

操场