解决TypeScript动态导入缓存与多语言数据类型安全挑战的实践指南

// common.ts
interface CommonTranslations {
    greeting: string;
    welcome: string;
}

const nlCommon: CommonTranslations = {
    greeting: "Hallo",
    welcome: "Welkom op onze website!"
};

export default nlCommon;

{
    "greeting": "Hallo",
    "welcome": "Welkom op onze website!"
}

// types/translations.d.ts
export interface CommonTranslations {
    greeting: string;
    welcome: string;
    // ... 其他通用的翻译字段
}

export interface FrenchTranslations {
    // ... 法语特有的翻译字段
}

// ... 为其他语言或模块定义更多接口

import * as fs from 'fs';
import * as path from 'path';
import { CommonTranslations } from './types/translations'; // 假设类型定义在 types/translations.d.ts

/**
 * 动态加载指定语言和模块的翻译数据
 * @param lang 语言代码 (e.g., 'nl', 'fr')
 * @param moduleName 翻译模块名称 (e.g., 'common')
 * @returns 对应的翻译对象
 */
function loadTranslations<T>(lang: string, moduleName: string): T {
    const filePath = path.join(__dirname, 'translations', lang, `${moduleName}.json`);

    try {
        const fileContent = fs.readFileSync(filePath, 'utf8');
        const translations: T = JSON.parse(fileContent);
        return translations;
    } catch (error) {
        console.error(`Error loading translations for ${lang}/${moduleName}:`, error);
        throw new Error(`Failed to load translations: ${lang}/${moduleName}`);
    }
}

// 示例用法：
try {
    const nlCommonTranslations = loadTranslations<CommonTranslations>('nl', 'common');
    console.log('荷兰语通用翻译:', nlCommonTranslations.greeting); // 输出: Hallo

    const frCommonTranslations = loadTranslations<CommonTranslations>('fr', 'common');
    console.log('法语通用翻译:', frCommonTranslations.greeting); // 假设fr/common.json中 greeting 为 "Bonjour"
} catch (e) {
    console.error(e);
}

import * as fs from 'fs';
import * as path from 'path';

/**
 * 根据JSON文件生成对应的TypeScript翻译文件
 * @param sourceDir JSON文件所在的根目录 (e.g., './translations')
 * @param outputDir 生成的TS文件输出目录 (e.g., './generated-translations')
 * @param typeImportPath 类型定义的导入路径 (e.g., '../../types/translations')
 */
function generateTranslationTsFiles(sourceDir: string, outputDir: string, typeImportPath: string) {
    const languages = fs.readdirSync(sourceDir, { withFileTypes: true })
                        .filter(dirent => dirent.isDirectory())
                        .map(dirent => dirent.name);

    for (const lang of languages) {
        const langSourcePath = path.join(sourceDir, lang);
        const langOutputPath = path.join(outputDir, lang);
        fs.mkdirSync(langOutputPath, { recursive: true });

        const jsonFiles = fs.readdirSync(langSourcePath)
                            .filter(file => file.endsWith('.json'));

        for (const jsonFile of jsonFiles) {
            const moduleName = path.basename(jsonFile, '.json');
            const jsonFilePath = path.join(langSourcePath, jsonFile);
            const tsOutputFilePath = path.join(langOutputPath, `${moduleName}.ts`);

            const jsonContent = fs.readFileSync(jsonFilePath, 'utf8');
            const data = JSON.parse(jsonContent);

            // 假设每个模块都有一个对应的类型接口，例如 CommonTranslations
            // 这里可以根据实际情况进行更复杂的类型映射或生成
            const interfaceName = `${moduleName.charAt(0).toUpperCase() + moduleName.slice(1)}Translations`;

            const tsContent = `
import { ${interfaceName} } from '${typeImportPath}';

const ${moduleName}Translations: ${interfaceName} = ${JSON.stringify(data, null, 4)};

export default ${moduleName}Translations;
`;
            fs.writeFileSync(tsOutputFilePath, tsContent);
            console.log(`Generated ${tsOutputFilePath}`);
        }
    }
}

// 示例运行
const sourceTranslationsPath = path.join(__dirname, '../translations');
const generatedTranslationsPath = path.join(__dirname, '../generated-translations');
const typeDefinitionPath = '../../types/translations'; // 相对于生成的TS文件的路径

generateTranslationTsFiles(sourceTranslationsPath, generatedTranslationsPath, typeDefinitionPath);