i18n-llm-translate/validation.js

Automatically translates namespace-based JSON translation files across multiple languages from any source language

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.validateTranslateOptions = validateTranslateOptions;
exports.extractVariablesFromString = extractVariablesFromString;
exports.createVariableConsistencySchema = createVariableConsistencySchema;
exports.createObjectVariableConsistencySchema = createObjectVariableConsistencySchema;
exports.generateLanguagesTranslateReturnZodSchema = generateLanguagesTranslateReturnZodSchema;
exports.generateTranslationsZodSchema = generateTranslationsZodSchema;
const zod_1 = require("zod");
const TranslateOptionsSchema = zod_1.z.object({
    languagesDirectoryPath: zod_1.z.string().min(1, "languagesDirectoryPath is required and cannot be empty"),
    baseLanguageCode: zod_1.z.string().min(1, "baseLanguageCode is required and cannot be empty"),
    targetLanguageCodes: zod_1.z.array(zod_1.z.string().min(1)).min(1, "At least one target language code is required"),
    namesMapping: zod_1.z.object({
        languages: zod_1.z.union([
            zod_1.z.function(),
            zod_1.z.object({
                base: zod_1.z.string().optional(),
                targets: zod_1.z.string().optional()
            })
        ]).optional(),
        jsonCache: zod_1.z.string().optional()
    }).optional(),
    applicationContextEntries: zod_1.z.array(zod_1.z.string()),
    cleanup: zod_1.z.boolean().optional(),
    debug: zod_1.z.boolean().optional(),
    verbose: zod_1.z.boolean().optional(),
    logger: zod_1.z.any().optional(),
    verboseEngineErrors: zod_1.z.boolean().optional()
});
function validateTranslateOptions(options) {
    try {
        TranslateOptionsSchema.parse(options);
    }
    catch (error) {
        if (error instanceof zod_1.z.ZodError) {
            const errorMessages = error.errors.map(err => `${err.path.join('.')}: ${err.message}`).join('; ');
            throw new Error(`Configuration validation failed: ${errorMessages}`);
        }
        throw error;
    }
}
/**
 * Extracts all variable names from a string that match the pattern {{ variableName }}
 * @param str The string to extract variables from
 * @returns Array of variable names found in the string
 */
function extractVariablesFromString(str) {
    const variableRegex = /\{\{\s*(\w+)\s*\}\}/g;
    const variables = [];
    let match;
    while ((match = variableRegex.exec(str)) !== null) {
        variables.push(match[1]);
    }
    return variables;
}
/**
 * Creates a zod schema that validates a string contains the same variables as the original
 * @param originalString The original string to compare against
 * @returns A zod schema that validates variable consistency
 */
function createVariableConsistencySchema(originalString) {
    const originalVariables = extractVariablesFromString(originalString);
    return zod_1.z.string().superRefine((translatedString, ctx) => {
        const translatedVariables = extractVariablesFromString(translatedString);
        // Check if all original variables are present in the translated string
        const allOriginalPresent = originalVariables.every(variable => translatedVariables.includes(variable));
        // Check if all translated variables were present in the original
        const allTranslatedPresent = translatedVariables.every(variable => originalVariables.includes(variable));
        if (!allOriginalPresent || !allTranslatedPresent) {
            ctx.addIssue({
                code: zod_1.z.ZodIssueCode.custom,
                message: `Variable mismatch. Original variables: [${originalVariables.join(', ')}], Translated variables: [${translatedVariables.join(', ')}]`
            });
        }
    });
}
/**
 * Creates a zod schema for an object that validates all string values maintain variable consistency
 * @param originalObject The original object to compare against
 * @returns A zod schema that validates variable consistency for all string values
 */
function createObjectVariableConsistencySchema(originalObject) {
    const schema = {};
    for (const [key, value] of Object.entries(originalObject)) {
        if (typeof value === "string") {
            schema[key] = createVariableConsistencySchema(value);
        }
        else if (typeof value === "object" && value !== null) {
            schema[key] = createObjectVariableConsistencySchema(value);
        }
        else {
            schema[key] = zod_1.z.any();
        }
    }
    return zod_1.z.object(schema);
}
function generateLanguagesTranslateReturnZodSchema(targetLanguages, differencesSchema) {
    const object = {};
    for (let targetLanguage of targetLanguages) {
        object[targetLanguage] = differencesSchema;
    }
    return zod_1.z.object(object);
}
function generateTranslationsZodSchema(obj) {
    const object = {};
    for (let [key, value] of Object.entries(obj)) {
        if (typeof value === "string") {
            object[key] = createVariableConsistencySchema(value);
        }
        else if (typeof value === "object" && value !== null) {
            object[key] = generateTranslationsZodSchema(value);
        }
        else {
            throw new Error(`Invalid type for key '${key}': Expected string or object.`);
        }
    }
    return zod_1.z.object(object);
}