键入以点分隔的路径键入

Question

我想强烈键入特定类型的点分隔路径。 假设我们有一个递归结构，其中每个叶子都是一个特定的类型，在这种情况下由一组语言翻译：

type Language = "pl" | "en";

type Translation = { [ lang in Language ]: string };
type Translations = { [key: string]: Translation | Translations | undefined };

这方面的一个例子可能是：

const translations = {
  hello: {
    pl: "Dzieńdobry",
    en: "Hello",
  },
  bool: {
    yes: {
      pl: "Tak",
      en: "Yes",
    },
    no: {
      pl: "Nie",
      en: "No",
    },
  },
};

我想要一个路径类型： "hello" 、 "bool.yes"和"bool.no" ，但不是"bool"或"missing"或"bool.foo" or “hello.pl”`。 这是我到目前为止所拥有的：

对于单层翻译文件：

type KeyToTranslation<T extends Translations, K extends string = string> = K extends keyof T 
  ? T[K] extends Translation
    ? K
    : never
  : never;

function printTranslationByKey<T extends Translations, K extends string>(
  t: T,
  k: KeyToTranslation<T, K>
) {
    console.log(t[k]);
}
printTranslationByKey(translations, "hello"); // Valid, Correct!
printTranslationByKey(translations, "hello.pl"); // Error, Correct!
printTranslationByKey(translations, "missing"); // Error, Correct!
printTranslationByKey(translations, "bool.yes"); // Error, Incorrect.

所以我们需要一些模板字符串和infer 。 不幸的是，我似乎无法让这个工作。 似乎忘记了我已经断言T[TKey] extends Translations ：

type DeepKeyToTranslation<T extends Translations, K extends string = string> =  K extends keyof T
    ? T[K] extends Translation
        ? K
        : never
    :
      // This is where we extend this further to cover the dot separated case:
      
      K extends `${infer TKey}.${infer Rest}`
        ? TKey extends keyof T
            ? T[TKey] extends undefined
                ? never
                : T[TKey] extends Translations
                    ? Rest extends DeepKeyToTranslation<T[TKey], Rest>
                        ? K
                        : never
                    : never
            : never
        : never;

function printTranslationByDeepKey<T extends Translations, K extends string>(
  t: T,
  k: DeepKeyToTranslation<T, K>
) {
    console.log(t[k]);
}
printTranslationByDeepKey(translations, "hello"); // Good!
printTranslationByDeepKey(translations, "hello.pl"); // Error
printTranslationByDeepKey(translations, "missing"); // Error

它失败了，因为：

Type 'T[TKey]' does not satisfy the constraint 'Translations'.
  Type 'T[string]' is not assignable to type 'Translations'.
    Type 'Translation | Translations | undefined' is not assignable to type 'Translations'.
      Type 'undefined' is not assignable to type 'Translations'.()

我发现了其他几个类似的问题：

• 打字稿：嵌套对象的深度键
• 获取嵌套对象值的通用函数

第二个甚至是我当前实现的基础，但两者都没有提供类似的功能，您可以根据路径中的值的类型停止递归。

Answer 1

考虑这个解决方案：

type Language = "pl" | "en";


const translations = {
  hello: {
    pl: "Dzieńdobry",
    en: "Hello",
  },
  bool: {
    yes: {
      pl: "Tak",
      en: "Yes",
    },
    no: {
      pl: "Nie",
      en: "No",
    },
  },
} as const;

type Translations = typeof translations;

type KeysUnion<T, Cache extends string = ''> =
  T extends PropertyKey ? Cache : keyof T extends Language ? Cache : {
    [P in keyof T]:
    P extends string
    ? Cache extends ''
    ? KeysUnion<T[P], `${P}`>
    : Cache | KeysUnion<T[P], `${Cache}.${P}`>
    : never
  }[keyof T]

type Result = KeysUnion<Translations>

function printTranslationByDeepKey<T extends Translations, K extends KeysUnion<Translations>>(
  t: T,
  k: K
) {}
printTranslationByDeepKey(translations, "hello"); // Good!
printTranslationByDeepKey(translations, "hello.pl"); // Error
printTranslationByDeepKey(translations, "missing"); // Error

操场

KeysUnion - 递归遍历Translations类型。 如果Cache extends "" - 这意味着它是第一次迭代，我们需要使用适当的参数递归调用KeysUnion ，但不使用Cache memoization，因为在结果中包含空字符串是没有意义的。 如果Cache不是空字符串，则将Cache应用于结果（将其与结果联合）并使用新后缀调用KeysUnion<T[P], ${Cache}.${P} > 。

T extends PropertyKey - 如果T不再是对象 - 返回Cache keyof T extends Language - 如果T是具有pl/en键的对象 - 不需要将它们应用于结果 - 返回Cache 。

您可以在此处找到此实用程序类型的另一种解释和注释

您可以在我的博客中找到更多解释

相关答案列表：[ 第一、 第二、 第三、 第四]

Answer 2

我不完全确定| undefined 需要您的Translations类型的| undefined部分（这里可能是错误的），我怀疑这是造成大部分麻烦的原因。

我稍微修改了您的示例，并达到了似乎可行的程度，请查看它，看看它是否涵盖了您的用例！

type Language = "pl" | "en";

type Translation = { [lang in Language]: string };
type Translations = { [key: string]: Translation | Translations };

type DeepKeyToTranslation<T extends Translations, K extends string = string> = K extends keyof T
    ? T[K] extends Translation
        ? K
        : never
    : K extends `${infer TKey}.${infer Rest}`
        ? T[TKey] extends Translations
            ? DeepKeyToTranslation<T[TKey], Rest> extends never
                ? never
                : K
            : never
        : never

declare function printTranslationByDeepKey<T extends Translations, K extends string>(
    t: T,
    k: DeepKeyToTranslation<T, K>
): K

const translations = {
    hello: {
        pl: "Dzieńdobry",
        en: "Hello",
    },
    bool: {
        yes: {
            pl: "Tak",
            en: "Yes",
        },
        no: {
            pl: "Nie",
            en: "No",
        },
    },
    nested: {
        deep: {
            ok: {
                pl: "Dzieńdobry",
                en: "Hello",
            }
        }
    }
};


printTranslationByDeepKey(translations, "hello") // ok
printTranslationByDeepKey(translations, "bool.yes") // ok
printTranslationByDeepKey(translations, "hello.pl") // err
printTranslationByDeepKey(translations, "missing") // err
printTranslationByDeepKey(translations, "nested.deep.ok") // ok

游乐场链接