@gabrielbourget/i18n-foundation 0.1.0

package/dist/pseudolocalization/index.d.ts

@@ -0,0 +1,89 @@
+import type { PostProcessorModule } from "i18next";
+export declare const PSEUDOLOCALIZATION_CHARACTER_SET__ACCENTED = "accented";
+export declare const PSEUDOLOCALIZATION_CHARACTER_SET__HIEROGLYPHICS = "hieroglyphics";
+export declare const PSEUDOLOCALIZATION_CHARACTER_SET__WINGDINGS = "wingdings";
+export declare const PSEUDOLOCALIZATION_CHARACTER_SETS: readonly ["accented", "hieroglyphics", "wingdings"];
+export declare const DEFAULT_PSEUDOLOCALIZATION_CHARACTER_SET = "accented";
+export declare const DEFAULT_PSEUDOLOCALIZATION_POST_PROCESSOR_NAME = "i18nFoundationPseudolocalization";
+export type TPseudolocalizationCharacterSet = (typeof PSEUDOLOCALIZATION_CHARACTER_SETS)[number];
+export type TPseudolocalizationReplacementMap = Readonly<Record<string, string>>;
+export type TPseudoLocalizeOptions = {
+    characterSet?: TPseudolocalizationCharacterSet | undefined;
+    replacementMap?: TPseudolocalizationReplacementMap | undefined;
+    replaceDots?: boolean | undefined;
+    wrap?: boolean | undefined;
+};
+export type TPseudolocalizationPostProcessorOptions = TPseudoLocalizeOptions & {
+    name?: string | undefined;
+};
+export declare const PSEUDOLOCALIZATION_REPLACEMENT_MAPS: {
+    readonly accented: {
+        a: string;
+        b: string;
+        c: string;
+        d: string;
+        e: string;
+        f: string;
+        g: string;
+        h: string;
+        i: string;
+        j: string;
+        k: string;
+        l: string;
+        m: string;
+        n: string;
+        o: string;
+        p: string;
+        q: string;
+        r: string;
+        s: string;
+        t: string;
+        u: string;
+        v: string;
+        w: string;
+        x: string;
+        y: string;
+        z: string;
+        A: string;
+        B: string;
+        C: string;
+        D: string;
+        E: string;
+        F: string;
+        G: string;
+        H: string;
+        I: string;
+        J: string;
+        K: string;
+        L: string;
+        M: string;
+        N: string;
+        O: string;
+        P: string;
+        Q: string;
+        R: string;
+        S: string;
+        T: string;
+        U: string;
+        V: string;
+        W: string;
+        X: string;
+        Y: string;
+        Z: string;
+    };
+    readonly hieroglyphics: Readonly<Record<string, string>>;
+    readonly wingdings: Readonly<Record<string, string>>;
+};
+export declare const getPseudolocalizationReplacementMap: (characterSet?: TPseudolocalizationCharacterSet) => TPseudolocalizationReplacementMap;
+export declare const buildPseudolocalizationCharacterPattern: (characterSet?: TPseudolocalizationCharacterSet) => RegExp;
+export declare const pseudoLocalize: (input: string, options?: TPseudoLocalizeOptions) => string;
+export declare const createPseudolocalizationPostProcessor: (options?: TPseudolocalizationPostProcessorOptions) => PostProcessorModule;
+export declare const getPseudolocalizationPostProcessConfig: (name?: string) => string;
+declare global {
+    var __PSEUDOLOCALIZATION_ACTIVE__: boolean | undefined;
+    var __PSEUDOLOCALIZATION_CHARACTER_SET__: TPseudolocalizationCharacterSet | undefined;
+    var __PSEUDOLOCALIZE__: ((input: string, options?: TPseudoLocalizeOptions) => string) | undefined;
+    var t: ((...args: unknown[]) => unknown) | undefined;
+}
+export declare const initializePseudolocalization: (options?: TPseudoLocalizeOptions) => void;
+//# sourceMappingURL=index.d.ts.map

package/dist/pseudolocalization/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/pseudolocalization/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAA;AAElD,eAAO,MAAM,0CAA0C,aAAa,CAAA;AACpE,eAAO,MAAM,+CAA+C,kBAAkB,CAAA;AAC9E,eAAO,MAAM,2CAA2C,cAAc,CAAA;AAEtE,eAAO,MAAM,iCAAiC,qDAIpC,CAAA;AAEV,eAAO,MAAM,wCAAwC,aAA6C,CAAA;AAClG,eAAO,MAAM,8CAA8C,qCAAqC,CAAA;AAEhG,MAAM,MAAM,+BAA+B,GAAG,CAAC,OAAO,iCAAiC,CAAC,CAAC,MAAM,CAAC,CAAA;AAChG,MAAM,MAAM,iCAAiC,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;AAEhF,MAAM,MAAM,sBAAsB,GAAG;IACnC,YAAY,CAAC,EAAE,+BAA+B,GAAG,SAAS,CAAA;IAC1D,cAAc,CAAC,EAAE,iCAAiC,GAAG,SAAS,CAAA;IAC9D,WAAW,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IACjC,IAAI,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;CAC3B,CAAA;AAED,MAAM,MAAM,uCAAuC,GAAG,sBAAsB,GAAG;IAC7E,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAC1B,CAAA;AAkID,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAI+C,CAAA;AAE/F,eAAO,MAAM,mCAAmC,GAC9C,eAAc,+BAA0E,KACvF,iCAAsF,CAAA;AAEzF,eAAO,MAAM,uCAAuC,GAClD,eAAc,+BAA0E,KACvF,MAMF,CAAA;AAED,eAAO,MAAM,cAAc,GAAI,OAAO,MAAM,EAAE,UAAS,sBAA2B,KAAG,MASpF,CAAA;AAED,eAAO,MAAM,qCAAqC,GAChD,UAAS,uCAA4C,KACpD,mBAMD,CAAA;AAEF,eAAO,MAAM,sCAAsC,GAAI,aAAqD,KAAG,MACzG,CAAA;AAIN,OAAO,CAAC,MAAM,CAAC;IACb,IAAI,6BAA6B,EAAE,OAAO,GAAG,SAAS,CAAA;IACtD,IAAI,oCAAoC,EAAE,+BAA+B,GAAG,SAAS,CAAA;IACrF,IAAI,kBAAkB,EAAE,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,sBAAsB,KAAK,MAAM,CAAC,GAAG,SAAS,CAAA;IACjG,IAAI,CAAC,EAAE,CAAC,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,GAAG,SAAS,CAAA;CACrD;AAED,eAAO,MAAM,4BAA4B,GAAI,UAAS,sBAA2B,KAAG,IAyBnF,CAAA"}

package/dist/pseudolocalization/index.js

@@ -0,0 +1,182 @@
+export const PSEUDOLOCALIZATION_CHARACTER_SET__ACCENTED = "accented";
+export const PSEUDOLOCALIZATION_CHARACTER_SET__HIEROGLYPHICS = "hieroglyphics";
+export const PSEUDOLOCALIZATION_CHARACTER_SET__WINGDINGS = "wingdings";
+export const PSEUDOLOCALIZATION_CHARACTER_SETS = [
+    PSEUDOLOCALIZATION_CHARACTER_SET__ACCENTED,
+    PSEUDOLOCALIZATION_CHARACTER_SET__HIEROGLYPHICS,
+    PSEUDOLOCALIZATION_CHARACTER_SET__WINGDINGS,
+];
+export const DEFAULT_PSEUDOLOCALIZATION_CHARACTER_SET = PSEUDOLOCALIZATION_CHARACTER_SET__ACCENTED;
+export const DEFAULT_PSEUDOLOCALIZATION_POST_PROCESSOR_NAME = "i18nFoundationPseudolocalization";
+const accentedMap = {
+    a: "ā",
+    b: "ƀ",
+    c: "ĉ",
+    d: "đ",
+    e: "ē",
+    f: "ƒ",
+    g: "ĝ",
+    h: "ĥ",
+    i: "ī",
+    j: "ĵ",
+    k: "ķ",
+    l: "ĺ",
+    m: "ḿ",
+    n: "ń",
+    o: "ō",
+    p: "ṕ",
+    q: "ʠ",
+    r: "ŕ",
+    s: "ś",
+    t: "ť",
+    u: "ū",
+    v: "ṽ",
+    w: "ŵ",
+    x: "ẋ",
+    y: "ȳ",
+    z: "ž",
+    A: "Ā",
+    B: "Ƀ",
+    C: "Ċ",
+    D: "Ď",
+    E: "Ē",
+    F: "Ƒ",
+    G: "Ĝ",
+    H: "Ĥ",
+    I: "Ī",
+    J: "Ĵ",
+    K: "Ķ",
+    L: "Ļ",
+    M: "Ḿ",
+    N: "Ń",
+    O: "Ō",
+    P: "Ṕ",
+    Q: "Ɋ",
+    R: "Ŕ",
+    S: "Ś",
+    T: "Ť",
+    U: "Ū",
+    V: "Ṽ",
+    W: "Ŵ",
+    X: "Ẋ",
+    Y: "Ȳ",
+    Z: "Ž",
+};
+const hieroglyphicsLowercase = [
+    "𓄿",
+    "𓃀",
+    "𓍿",
+    "𓂧",
+    "𓇋",
+    "𓆑",
+    "𓎼",
+    "𓉔",
+    "𓇋",
+    "𓆓",
+    "𓎡",
+    "𓃭",
+    "𓅓",
+    "𓈖",
+    "𓍯",
+    "𓊪",
+    "𓏘",
+    "𓂋",
+    "𓋴",
+    "𓏏",
+    "𓅱",
+    "𓆑",
+    "𓅱",
+    "𓐍",
+    "𓇌",
+    "𓊃",
+];
+const wingdingsLowercase = [
+    "✈",
+    "☞",
+    "☾",
+    "◆",
+    "☰",
+    "✿",
+    "●",
+    "♥",
+    "♧",
+    "♪",
+    "☼",
+    "◈",
+    "✉",
+    "✦",
+    "○",
+    "□",
+    "❖",
+    "☛",
+    "✶",
+    "✝",
+    "☂",
+    "✓",
+    "⌘",
+    "✕",
+    "☯",
+    "✹",
+];
+const buildAlphabetMap = (lowercase) => {
+    const map = {};
+    for (let index = 0; index < 26; index += 1) {
+        const lowercaseLetter = String.fromCharCode("a".charCodeAt(0) + index);
+        const uppercaseLetter = lowercaseLetter.toUpperCase();
+        const replacement = lowercase[index] ?? lowercaseLetter;
+        map[lowercaseLetter] = replacement;
+        map[uppercaseLetter] = replacement;
+    }
+    return map;
+};
+export const PSEUDOLOCALIZATION_REPLACEMENT_MAPS = {
+    [PSEUDOLOCALIZATION_CHARACTER_SET__ACCENTED]: accentedMap,
+    [PSEUDOLOCALIZATION_CHARACTER_SET__HIEROGLYPHICS]: buildAlphabetMap(hieroglyphicsLowercase),
+    [PSEUDOLOCALIZATION_CHARACTER_SET__WINGDINGS]: buildAlphabetMap(wingdingsLowercase),
+};
+export const getPseudolocalizationReplacementMap = (characterSet = DEFAULT_PSEUDOLOCALIZATION_CHARACTER_SET) => PSEUDOLOCALIZATION_REPLACEMENT_MAPS[characterSet];
+export const buildPseudolocalizationCharacterPattern = (characterSet = DEFAULT_PSEUDOLOCALIZATION_CHARACTER_SET) => {
+    const characters = [
+        ...new Set(Object.values(getPseudolocalizationReplacementMap(characterSet)).flatMap((value) => [...value])),
+    ];
+    return new RegExp(`[${characters.map((character) => character.replace(/[\\\]^]/gu, "\\$&")).join("")}]`, "u");
+};
+export const pseudoLocalize = (input, options = {}) => {
+    const replacementMap = options.replacementMap ?? getPseudolocalizationReplacementMap(options.characterSet);
+    const replaceDots = options.replaceDots ?? true;
+    const wrap = options.wrap ?? true;
+    const transformed = input
+        .replace(/[A-Za-z]/gu, (character) => replacementMap[character] ?? character)
+        .replace(/\./gu, replaceDots ? "•" : ".");
+    return wrap ? `[${transformed}]` : transformed;
+};
+export const createPseudolocalizationPostProcessor = (options = {}) => ({
+    name: options.name ?? DEFAULT_PSEUDOLOCALIZATION_POST_PROCESSOR_NAME,
+    type: "postProcessor",
+    process(value) {
+        return pseudoLocalize(value, options);
+    },
+});
+export const getPseudolocalizationPostProcessConfig = (name = DEFAULT_PSEUDOLOCALIZATION_POST_PROCESSOR_NAME) => name;
+let installed = false;
+export const initializePseudolocalization = (options = {}) => {
+    if (installed)
+        return;
+    installed = true;
+    const characterSet = options.characterSet ?? DEFAULT_PSEUDOLOCALIZATION_CHARACTER_SET;
+    globalThis.__PSEUDOLOCALIZATION_ACTIVE__ = true;
+    globalThis.__PSEUDOLOCALIZATION_CHARACTER_SET__ = characterSet;
+    globalThis.__PSEUDOLOCALIZE__ = pseudoLocalize;
+    const maybeT = globalThis.t;
+    if (typeof maybeT === "function") {
+        const safeT = maybeT;
+        const wrappedT = (...args) => {
+            const result = safeT(...args);
+            return typeof result === "string" ? pseudoLocalize(result, options) : String(result);
+        };
+        globalThis.t = wrappedT;
+    }
+    if (typeof console !== "undefined" && typeof console.info === "function") {
+        console.info(`%c[i18n] Pseudolocalization active (${characterSet})`, "color:#00aaff;font-weight:bold;");
+    }
+};

package/dist/verifier/domainContracts.d.ts

@@ -0,0 +1,43 @@
+export type TStringArrayExportContract = {
+    label: string;
+    sourceFile: string;
+    sourceExport: string;
+};
+export type TDomainTranslationContract = TStringArrayExportContract & {
+    namespace: string;
+    keyPrefix: string;
+    excludedCodes?: readonly string[] | undefined;
+    requiredKeySuffixes?: readonly string[] | undefined;
+};
+export type TDomainSeedSourceContract = TStringArrayExportContract & {
+    seedFile: string;
+    sourceModule: string;
+};
+export type TParsedStringArrayExport = {
+    errors: readonly string[];
+    values: readonly string[];
+};
+export type TVerifyDomainTranslationContractsArgs = {
+    contracts: readonly TDomainTranslationContract[];
+    locales: readonly string[];
+    repoRoot: string;
+    sheetsByLocale: ReadonlyMap<string, ReadonlyMap<string, unknown>>;
+};
+export type TVerifyDomainSeedSourceContractsArgs = {
+    contracts: readonly TDomainSeedSourceContract[];
+    repoRoot: string;
+};
+export type TVerifyDomainTranslationContractsResult = {
+    checkedCodeCount: number;
+    checkedContractCount: number;
+    errors: readonly string[];
+};
+export type TVerifyDomainSeedSourceContractsResult = {
+    checkedContractCount: number;
+    checkedSourceCodeCount: number;
+    errors: readonly string[];
+};
+export declare const parseStringArrayExport: (repoRoot: string, contract: TStringArrayExportContract, sourceArrayCache?: Map<string, TParsedStringArrayExport>) => Promise<TParsedStringArrayExport>;
+export declare const verifyDomainTranslationContracts: ({ contracts, locales, repoRoot, sheetsByLocale, }: TVerifyDomainTranslationContractsArgs) => Promise<TVerifyDomainTranslationContractsResult>;
+export declare const verifyDomainSeedSourceContracts: ({ contracts, repoRoot, }: TVerifyDomainSeedSourceContractsArgs) => Promise<TVerifyDomainSeedSourceContractsResult>;
+//# sourceMappingURL=domainContracts.d.ts.map

package/dist/verifier/domainContracts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domainContracts.d.ts","sourceRoot":"","sources":["../../src/verifier/domainContracts.ts"],"names":[],"mappings":"AASA,MAAM,MAAM,0BAA0B,GAAG;IACvC,KAAK,EAAE,MAAM,CAAA;IACb,UAAU,EAAE,MAAM,CAAA;IAClB,YAAY,EAAE,MAAM,CAAA;CACrB,CAAA;AAED,MAAM,MAAM,0BAA0B,GAAG,0BAA0B,GAAG;IACpE,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,CAAA;IAC7C,mBAAmB,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,CAAA;CACpD,CAAA;AAED,MAAM,MAAM,yBAAyB,GAAG,0BAA0B,GAAG;IACnE,QAAQ,EAAE,MAAM,CAAA;IAChB,YAAY,EAAE,MAAM,CAAA;CACrB,CAAA;AAED,MAAM,MAAM,wBAAwB,GAAG;IACrC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAA;IACzB,MAAM,EAAE,SAAS,MAAM,EAAE,CAAA;CAC1B,CAAA;AAED,MAAM,MAAM,qCAAqC,GAAG;IAClD,SAAS,EAAE,SAAS,0BAA0B,EAAE,CAAA;IAChD,OAAO,EAAE,SAAS,MAAM,EAAE,CAAA;IAC1B,QAAQ,EAAE,MAAM,CAAA;IAChB,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;CAClE,CAAA;AAED,MAAM,MAAM,oCAAoC,GAAG;IACjD,SAAS,EAAE,SAAS,yBAAyB,EAAE,CAAA;IAC/C,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,MAAM,MAAM,uCAAuC,GAAG;IACpD,gBAAgB,EAAE,MAAM,CAAA;IACxB,oBAAoB,EAAE,MAAM,CAAA;IAC5B,MAAM,EAAE,SAAS,MAAM,EAAE,CAAA;CAC1B,CAAA;AAED,MAAM,MAAM,sCAAsC,GAAG;IACnD,oBAAoB,EAAE,MAAM,CAAA;IAC5B,sBAAsB,EAAE,MAAM,CAAA;IAC9B,MAAM,EAAE,SAAS,MAAM,EAAE,CAAA;CAC1B,CAAA;AAuGD,eAAO,MAAM,sBAAsB,GACjC,UAAU,MAAM,EAChB,UAAU,0BAA0B,EACpC,mBAAkB,GAAG,CAAC,MAAM,EAAE,wBAAwB,CAAa,KAClE,OAAO,CAAC,wBAAwB,CAkFlC,CAAA;AAwHD,eAAO,MAAM,gCAAgC,GAAU,mDAKpD,qCAAqC,KAAG,OAAO,CAAC,uCAAuC,CAyFzF,CAAA;AAED,eAAO,MAAM,+BAA+B,GAAU,0BAGnD,oCAAoC,KAAG,OAAO,CAAC,sCAAsC,CAiDvF,CAAA"}

package/dist/verifier/domainContracts.js

@@ -0,0 +1,324 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import * as ts from "typescript";
+import { isPlainObject } from "./keyShape.js";
+const DOMAIN_CODE_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const isStringLiteralLike = (node) => ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node);
+const unwrapExpression = (expression) => {
+    let currentExpression = expression;
+    while (ts.isAsExpression(currentExpression) ||
+        ts.isTypeAssertionExpression(currentExpression) ||
+        ts.isParenthesizedExpression(currentExpression)) {
+        currentExpression = currentExpression.expression;
+    }
+    return currentExpression;
+};
+const collectTopLevelConstDeclarations = (sourceFile) => {
+    const declarations = new Map();
+    for (const statement of sourceFile.statements) {
+        if (!ts.isVariableStatement(statement))
+            continue;
+        const isConst = Boolean(statement.declarationList.flags & ts.NodeFlags.Const);
+        const isExported = statement.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+        for (const declaration of statement.declarationList.declarations) {
+            if (!ts.isIdentifier(declaration.name))
+                continue;
+            declarations.set(declaration.name.text, {
+                initializer: declaration.initializer,
+                isConst,
+                isExported,
+            });
+        }
+    }
+    return declarations;
+};
+const resolveStringExpression = (expression, declarations, context, resolutionStack = []) => {
+    if (!expression) {
+        return {
+            errors: [`${context} has no initializer`],
+            value: null,
+        };
+    }
+    const unwrappedExpression = unwrapExpression(expression);
+    if (isStringLiteralLike(unwrappedExpression)) {
+        return {
+            errors: [],
+            value: unwrappedExpression.text,
+        };
+    }
+    if (ts.isIdentifier(unwrappedExpression)) {
+        const identifier = unwrappedExpression.text;
+        if (resolutionStack.includes(identifier)) {
+            return {
+                errors: [`${context} has circular constant reference: ${[...resolutionStack, identifier].join(" -> ")}`],
+                value: null,
+            };
+        }
+        const declaration = declarations.get(identifier);
+        if (!declaration) {
+            return {
+                errors: [`${context} references unknown constant ${identifier}`],
+                value: null,
+            };
+        }
+        return resolveStringExpression(declaration.initializer, declarations, context, [...resolutionStack, identifier]);
+    }
+    return {
+        errors: [`${context} uses unsupported array element syntax: ${unwrappedExpression.getText()}`],
+        value: null,
+    };
+};
+export const parseStringArrayExport = async (repoRoot, contract, sourceArrayCache = new Map()) => {
+    const cacheKey = `${contract.sourceFile}#${contract.sourceExport}`;
+    const cachedSourceArray = sourceArrayCache.get(cacheKey);
+    if (cachedSourceArray)
+        return cachedSourceArray;
+    const sourcePath = path.join(repoRoot, contract.sourceFile);
+    const sourceText = await fs.readFile(sourcePath, "utf8");
+    const sourceFile = ts.createSourceFile(sourcePath, sourceText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const declarations = collectTopLevelConstDeclarations(sourceFile);
+    const declaration = declarations.get(contract.sourceExport);
+    const context = `${contract.sourceFile} ${contract.sourceExport}`;
+    const errors = [];
+    if (!declaration) {
+        const result = {
+            errors: [`${context} was not found`],
+            values: [],
+        };
+        sourceArrayCache.set(cacheKey, result);
+        return result;
+    }
+    if (!declaration.isConst) {
+        errors.push(`${context} must be declared with const`);
+    }
+    if (!declaration.isExported) {
+        errors.push(`${context} must be exported`);
+    }
+    if (!declaration.initializer) {
+        const result = {
+            errors: [...errors, `${context} has no initializer`],
+            values: [],
+        };
+        sourceArrayCache.set(cacheKey, result);
+        return result;
+    }
+    const arrayExpression = unwrapExpression(declaration.initializer);
+    if (!ts.isArrayLiteralExpression(arrayExpression)) {
+        const result = {
+            errors: [...errors, `${context} must be an array literal`],
+            values: [],
+        };
+        sourceArrayCache.set(cacheKey, result);
+        return result;
+    }
+    const values = [];
+    for (const element of arrayExpression.elements) {
+        if (ts.isSpreadElement(element)) {
+            errors.push(`${context} uses unsupported spread syntax in its domain code array`);
+            continue;
+        }
+        const resolvedElement = resolveStringExpression(element, declarations, context);
+        errors.push(...resolvedElement.errors);
+        if (resolvedElement.value != null) {
+            values.push(resolvedElement.value);
+        }
+    }
+    const result = {
+        errors,
+        values,
+    };
+    sourceArrayCache.set(cacheKey, result);
+    return result;
+};
+const getLeafKeyPaths = (value, pathSegments = []) => {
+    if (!isPlainObject(value))
+        return [pathSegments.join(".")];
+    return Object.entries(value).flatMap(([key, child]) => {
+        if (pathSegments.length === 0 && key === "_meta")
+            return [];
+        return getLeafKeyPaths(child, [...pathSegments, key]);
+    });
+};
+const getExpectedTranslationKey = (contract, code, requiredKeySuffix) => requiredKeySuffix ? `${contract.keyPrefix}.${code}.${requiredKeySuffix}` : `${contract.keyPrefix}.${code}`;
+const collectRuntimeNamedImportLocalNames = (sourceFile, sourceModule, importedName) => {
+    const localNames = [];
+    let hasTypeOnlyMatch = false;
+    for (const statement of sourceFile.statements) {
+        if (!ts.isImportDeclaration(statement))
+            continue;
+        if (!ts.isStringLiteral(statement.moduleSpecifier))
+            continue;
+        if (statement.moduleSpecifier.text !== sourceModule)
+            continue;
+        const importClause = statement.importClause;
+        const namedBindings = importClause?.namedBindings;
+        if (!namedBindings || !ts.isNamedImports(namedBindings))
+            continue;
+        for (const element of namedBindings.elements) {
+            const exportedName = element.propertyName?.text ?? element.name.text;
+            if (exportedName !== importedName)
+                continue;
+            if (importClause.isTypeOnly || element.isTypeOnly) {
+                hasTypeOnlyMatch = true;
+                continue;
+            }
+            localNames.push(element.name.text);
+        }
+    }
+    return {
+        hasTypeOnlyMatch,
+        localNames,
+    };
+};
+const sourceUsesArrayMapCall = (sourceFile, arrayIdentifier) => {
+    let hasMapCall = false;
+    const visit = (node) => {
+        if (hasMapCall)
+            return;
+        if (ts.isCallExpression(node)) {
+            const expression = unwrapExpression(node.expression);
+            if (ts.isPropertyAccessExpression(expression) && expression.name.text === "map") {
+                const mapTarget = unwrapExpression(expression.expression);
+                if (ts.isIdentifier(mapTarget) && mapTarget.text === arrayIdentifier) {
+                    hasMapCall = true;
+                    return;
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return hasMapCall;
+};
+const getContractKeyDetails = (contract, keyPath) => {
+    const prefix = `${contract.keyPrefix}.`;
+    if (!keyPath.startsWith(prefix))
+        return null;
+    const remainder = keyPath.slice(prefix.length);
+    const requiredKeySuffixes = contract.requiredKeySuffixes ?? [""];
+    for (const suffix of requiredKeySuffixes) {
+        if (!suffix && !remainder.includes(".")) {
+            return {
+                code: remainder,
+                expectedShape: true,
+            };
+        }
+        if (suffix && remainder.endsWith(`.${suffix}`)) {
+            return {
+                code: remainder.slice(0, -(suffix.length + 1)),
+                expectedShape: true,
+            };
+        }
+    }
+    return {
+        code: remainder,
+        expectedShape: false,
+    };
+};
+export const verifyDomainTranslationContracts = async ({ contracts, locales, repoRoot, sheetsByLocale, }) => {
+    const errors = [];
+    const sourceArrayCache = new Map();
+    let checkedCodeCount = 0;
+    for (const contract of contracts) {
+        const sourceArray = await parseStringArrayExport(repoRoot, contract, sourceArrayCache);
+        const allSourceCodes = sourceArray.values;
+        const excludedCodeSet = new Set(contract.excludedCodes ?? []);
+        const sourceCodes = allSourceCodes.filter((code) => !excludedCodeSet.has(code));
+        const allSourceCodeSet = new Set(allSourceCodes);
+        const sourceCodeSet = new Set(sourceCodes);
+        const requiredKeySuffixes = contract.requiredKeySuffixes ?? [""];
+        const sourceContext = `${contract.label} (${contract.sourceFile} ${contract.sourceExport})`;
+        errors.push(...sourceArray.errors.map((error) => `${contract.label}: ${error}`));
+        if (allSourceCodes.length === 0)
+            continue;
+        for (const code of allSourceCodes) {
+            if (!DOMAIN_CODE_PATTERN.test(code)) {
+                errors.push(`${sourceContext} contains a non-kebab-case domain code: ${code}`);
+            }
+        }
+        const duplicateCodes = allSourceCodes.filter((code, index) => allSourceCodes.indexOf(code) !== index);
+        for (const code of [...new Set(duplicateCodes)]) {
+            errors.push(`${sourceContext} contains duplicate domain code: ${code}`);
+        }
+        for (const code of excludedCodeSet) {
+            if (!allSourceCodeSet.has(code)) {
+                errors.push(`${sourceContext} excludes unknown domain code: ${code}`);
+            }
+        }
+        if (sourceCodes.length === 0)
+            continue;
+        checkedCodeCount += sourceCodes.length;
+        for (const locale of locales) {
+            const sheet = sheetsByLocale.get(locale)?.get(contract.namespace);
+            const sheetContext = `${locale}/${contract.namespace}.json`;
+            if (!sheet) {
+                errors.push(`${contract.label}: ${sheetContext} was not found`);
+                continue;
+            }
+            const leafKeyPaths = getLeafKeyPaths(sheet);
+            const leafKeyPathSet = new Set(leafKeyPaths);
+            const contractKeyDetails = leafKeyPaths
+                .map((keyPath) => ({
+                details: getContractKeyDetails(contract, keyPath),
+                keyPath,
+            }))
+                .filter((entry) => Boolean(entry.details));
+            for (const code of sourceCodes) {
+                for (const requiredKeySuffix of requiredKeySuffixes) {
+                    const expectedKey = getExpectedTranslationKey(contract, code, requiredKeySuffix);
+                    if (!leafKeyPathSet.has(expectedKey)) {
+                        errors.push(`${contract.label}: ${sheetContext} is missing ${expectedKey}`);
+                    }
+                }
+            }
+            for (const { keyPath, details } of contractKeyDetails) {
+                if (!details.expectedShape) {
+                    errors.push(`${contract.label}: ${sheetContext} has unexpected key shape ${keyPath}`);
+                    continue;
+                }
+                if (!sourceCodeSet.has(details.code)) {
+                    errors.push(`${contract.label}: ${sheetContext} has stale or unknown code key ${keyPath}`);
+                }
+            }
+        }
+    }
+    return {
+        checkedCodeCount,
+        checkedContractCount: contracts.length,
+        errors,
+    };
+};
+export const verifyDomainSeedSourceContracts = async ({ contracts, repoRoot, }) => {
+    const errors = [];
+    const sourceArrayCache = new Map();
+    let checkedSourceCodeCount = 0;
+    for (const contract of contracts) {
+        const sourceArray = await parseStringArrayExport(repoRoot, contract, sourceArrayCache);
+        const seedPath = path.join(repoRoot, contract.seedFile);
+        const seedText = await fs.readFile(seedPath, "utf8");
+        const seedSourceFile = ts.createSourceFile(seedPath, seedText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+        const sourceContext = `${contract.label} (${contract.sourceFile} ${contract.sourceExport})`;
+        const seedContext = `${contract.label}: ${contract.seedFile}`;
+        errors.push(...sourceArray.errors.map((error) => `${contract.label}: ${error}`));
+        if (sourceArray.values.length > 0) {
+            checkedSourceCodeCount += sourceArray.values.length;
+        }
+        const { hasTypeOnlyMatch, localNames } = collectRuntimeNamedImportLocalNames(seedSourceFile, contract.sourceModule, contract.sourceExport);
+        if (localNames.length === 0) {
+            errors.push(`${seedContext} must import ${contract.sourceExport} from ${contract.sourceModule}`);
+            if (hasTypeOnlyMatch) {
+                errors.push(`${seedContext} imports ${contract.sourceExport} as type-only, but seed rows need the runtime array`);
+            }
+            continue;
+        }
+        const mapsOverSourceArray = localNames.some((localName) => sourceUsesArrayMapCall(seedSourceFile, localName));
+        if (!mapsOverSourceArray) {
+            errors.push(`${seedContext} must map over ${contract.sourceExport} when building seed rows from ${sourceContext}`);
+        }
+    }
+    return {
+        checkedContractCount: contracts.length,
+        checkedSourceCodeCount,
+        errors,
+    };
+};

package/dist/verifier/fileSystem.d.ts

@@ -0,0 +1,9 @@
+export type TReadJSONFileResult = {
+    json: unknown;
+    raw: string;
+};
+export declare const listDirNames: (directoryPath: string) => Promise<string[]>;
+export declare const listFilesRecursive: (directoryPath: string) => Promise<string[]>;
+export declare const listJSONFiles: (directoryPath: string) => Promise<string[]>;
+export declare const readJSONFileOrThrow: (filePath: string, errorPrefix?: string) => Promise<TReadJSONFileResult>;
+//# sourceMappingURL=fileSystem.d.ts.map

package/dist/verifier/fileSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fileSystem.d.ts","sourceRoot":"","sources":["../../src/verifier/fileSystem.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,mBAAmB,GAAG;IAChC,IAAI,EAAE,OAAO,CAAA;IACb,GAAG,EAAE,MAAM,CAAA;CACZ,CAAA;AAED,eAAO,MAAM,YAAY,GAAU,eAAe,MAAM,KAAG,OAAO,CAAC,MAAM,EAAE,CAO1E,CAAA;AAED,eAAO,MAAM,kBAAkB,GAAU,eAAe,MAAM,KAAG,OAAO,CAAC,MAAM,EAAE,CAkBhF,CAAA;AAED,eAAO,MAAM,aAAa,GAAU,eAAe,MAAM,KAAG,OAAO,CAAC,MAAM,EAAE,CAO3E,CAAA;AAED,eAAO,MAAM,mBAAmB,GAC9B,UAAU,MAAM,EAChB,oBAA6B,KAC5B,OAAO,CAAC,mBAAmB,CAW7B,CAAA"}