@gabrielbourget/i18n-foundation 0.1.0

package/dist/verifier/fileSystem.js

@@ -0,0 +1,42 @@
+import fs from "node:fs/promises";
+export const listDirNames = async (directoryPath) => {
+    const entries = await fs.readdir(directoryPath, { withFileTypes: true });
+    return entries
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name)
+        .sort();
+};
+export const listFilesRecursive = async (directoryPath) => {
+    const entries = await fs.readdir(directoryPath, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const entryPath = `${directoryPath}/${entry.name}`;
+        if (entry.isDirectory()) {
+            files.push(...(await listFilesRecursive(entryPath)));
+            continue;
+        }
+        if (entry.isFile()) {
+            files.push(entryPath);
+        }
+    }
+    return files.sort();
+};
+export const listJSONFiles = async (directoryPath) => {
+    const entries = await fs.readdir(directoryPath, { withFileTypes: true });
+    return entries
+        .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
+        .map((entry) => entry.name)
+        .sort();
+};
+export const readJSONFileOrThrow = async (filePath, errorPrefix = "[i18n verify]") => {
+    const raw = await fs.readFile(filePath, "utf8");
+    try {
+        return {
+            json: JSON.parse(raw),
+            raw,
+        };
+    }
+    catch (error) {
+        throw new Error(`${errorPrefix} Invalid JSON: ${filePath}\n${String(error)}`);
+    }
+};

package/dist/verifier/icuContracts.d.ts

@@ -0,0 +1,13 @@
+export type TTranslationStringEntry = {
+    keyPath: string;
+    value: string;
+};
+export type TICUContract = {
+    contractSignatures: readonly string[];
+    interpolationTokens: readonly string[];
+};
+export declare const getTranslationStringEntries: (value: unknown, pathSegments?: readonly string[]) => TTranslationStringEntry[];
+export declare const parseICUContract: (message: string, locale: string, context: string, errors: string[]) => TICUContract | null;
+export declare const pushContractDiffs: (errors: string[], context: string, referenceContext: string, label: string, referenceItems: readonly string[], localeItems: readonly string[]) => void;
+export declare const getDeclaredInterpolationTokens: (sheet: unknown, keyPath: string) => string[];
+//# sourceMappingURL=icuContracts.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"icuContracts.d.ts","sourceRoot":"","sources":["../../src/verifier/icuContracts.ts"],"names":[],"mappings":"AAuBA,MAAM,MAAM,uBAAuB,GAAG;IACpC,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,MAAM,MAAM,YAAY,GAAG;IACzB,kBAAkB,EAAE,SAAS,MAAM,EAAE,CAAA;IACrC,mBAAmB,EAAE,SAAS,MAAM,EAAE,CAAA;CACvC,CAAA;AAaD,eAAO,MAAM,2BAA2B,GACtC,OAAO,OAAO,EACd,eAAc,SAAS,MAAM,EAAO,KACnC,uBAAuB,EAUzB,CAAA;AA+DD,eAAO,MAAM,gBAAgB,GAC3B,SAAS,MAAM,EACf,QAAQ,MAAM,EACd,SAAS,MAAM,EACf,QAAQ,MAAM,EAAE,KACf,YAAY,GAAG,IAWjB,CAAA;AAED,eAAO,MAAM,iBAAiB,GAC5B,QAAQ,MAAM,EAAE,EAChB,SAAS,MAAM,EACf,kBAAkB,MAAM,EACxB,OAAO,MAAM,EACb,gBAAgB,SAAS,MAAM,EAAE,EACjC,aAAa,SAAS,MAAM,EAAE,KAC7B,IAaF,CAAA;AAED,eAAO,MAAM,8BAA8B,GAAI,OAAO,OAAO,EAAE,SAAS,MAAM,KAAG,MAAM,EAUtF,CAAA"}

package/dist/verifier/icuContracts.js

@@ -0,0 +1,109 @@
+import { IntlMessageFormat } from "intl-messageformat";
+import { isPlainObject } from "./keyShape.js";
+const MESSAGE_ELEMENT_TYPES = Object.freeze({
+    argument: 1,
+    date: 3,
+    literal: 0,
+    number: 2,
+    plural: 6,
+    pound: 7,
+    select: 5,
+    tag: 8,
+    time: 4,
+});
+const SIMPLE_ARGUMENT_MESSAGE_TYPES = new Map([
+    [MESSAGE_ELEMENT_TYPES.argument, "argument"],
+    [MESSAGE_ELEMENT_TYPES.number, "number"],
+    [MESSAGE_ELEMENT_TYPES.date, "date"],
+    [MESSAGE_ELEMENT_TYPES.time, "time"],
+]);
+const sortUnique = (items) => [...new Set(items)].sort();
+export const getTranslationStringEntries = (value, pathSegments = []) => {
+    if (pathSegments[0] === "_meta")
+        return [];
+    if (typeof value === "string") {
+        return [{ keyPath: pathSegments.join("."), value }];
+    }
+    if (!isPlainObject(value))
+        return [];
+    return Object.entries(value).flatMap(([key, child]) => getTranslationStringEntries(child, [...pathSegments, key]));
+};
+const getSortedOptionKeys = (options) => Object.keys(options ?? {}).sort();
+const collectMessageContract = (elements) => {
+    const interpolationTokens = [];
+    const contractSignatures = [];
+    const visit = (messageElements) => {
+        for (const element of messageElements) {
+            const simpleArgumentKind = SIMPLE_ARGUMENT_MESSAGE_TYPES.get(element.type);
+            if (simpleArgumentKind && element.value) {
+                interpolationTokens.push(element.value);
+                contractSignatures.push(`${simpleArgumentKind}(${element.value})`);
+                continue;
+            }
+            if (element.type === MESSAGE_ELEMENT_TYPES.select && element.value) {
+                const optionKeys = getSortedOptionKeys(element.options);
+                interpolationTokens.push(element.value);
+                contractSignatures.push(`select(${element.value}, options=${optionKeys.join("|")})`);
+                for (const optionKey of optionKeys) {
+                    visit(element.options?.[optionKey]?.value ?? []);
+                }
+                continue;
+            }
+            if (element.type === MESSAGE_ELEMENT_TYPES.plural && element.value) {
+                const optionKeys = getSortedOptionKeys(element.options);
+                const pluralType = element.pluralType ?? "cardinal";
+                const offset = element.offset ?? 0;
+                interpolationTokens.push(element.value);
+                contractSignatures.push(`plural(${element.value}, type=${pluralType}, offset=${offset}, options=${optionKeys.join("|")})`);
+                for (const optionKey of optionKeys) {
+                    visit(element.options?.[optionKey]?.value ?? []);
+                }
+                continue;
+            }
+            if (element.type === MESSAGE_ELEMENT_TYPES.tag && element.value) {
+                contractSignatures.push(`tag(${element.value})`);
+                visit(element.children ?? []);
+            }
+        }
+    };
+    visit(elements);
+    return {
+        contractSignatures: sortUnique(contractSignatures),
+        interpolationTokens: sortUnique(interpolationTokens),
+    };
+};
+export const parseICUContract = (message, locale, context, errors) => {
+    try {
+        const ast = new IntlMessageFormat(message, locale).getAst();
+        return collectMessageContract(ast);
+    }
+    catch (error) {
+        const messageText = error instanceof Error ? error.message : String(error);
+        errors.push(`${context} has invalid ICU syntax: ${messageText}`);
+        return null;
+    }
+};
+export const pushContractDiffs = (errors, context, referenceContext, label, referenceItems, localeItems) => {
+    const referenceItemSet = new Set(referenceItems);
+    const localeItemSet = new Set(localeItems);
+    const missingItems = referenceItems.filter((item) => !localeItemSet.has(item));
+    const extraItems = localeItems.filter((item) => !referenceItemSet.has(item));
+    if (missingItems.length > 0) {
+        errors.push(`${context} is missing ICU ${label} from ${referenceContext}: ${missingItems.join(", ")}`);
+    }
+    if (extraItems.length > 0) {
+        errors.push(`${context} has extra ICU ${label} not present in ${referenceContext}: ${extraItems.join(", ")}`);
+    }
+};
+export const getDeclaredInterpolationTokens = (sheet, keyPath) => {
+    if (!isPlainObject(sheet))
+        return [];
+    if (!isPlainObject(sheet._meta))
+        return [];
+    if (!isPlainObject(sheet._meta.interpolation))
+        return [];
+    const declaredTokens = sheet._meta.interpolation[keyPath];
+    return Array.isArray(declaredTokens) && declaredTokens.every((token) => typeof token === "string")
+        ? sortUnique(declaredTokens)
+        : [];
+};

package/dist/verifier/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./domainContracts.js";
+export * from "./fileSystem.js";
+export * from "./icuContracts.js";
+export * from "./keyShape.js";
+export * from "./sheetOrdering.js";
+export * from "./verifyI18nSource.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/verifier/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAA;AACpC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,mBAAmB,CAAA;AACjC,cAAc,eAAe,CAAA;AAC7B,cAAc,oBAAoB,CAAA;AAClC,cAAc,uBAAuB,CAAA"}

package/dist/verifier/index.js

@@ -0,0 +1,6 @@
+export * from "./domainContracts.js";
+export * from "./fileSystem.js";
+export * from "./icuContracts.js";
+export * from "./keyShape.js";
+export * from "./sheetOrdering.js";
+export * from "./verifyI18nSource.js";

package/dist/verifier/keyShape.d.ts

@@ -0,0 +1,12 @@
+export type TLeafShape = {
+    keyPath: string;
+    kind: string;
+};
+export type TValidateKeyConventionsOptions = {
+    structuredNamespaceKeyConventionExceptions?: ReadonlySet<string> | readonly string[] | undefined;
+};
+export declare const isPlainObject: (value: unknown) => value is Record<string, unknown>;
+export declare const getLeafShapes: (value: unknown, pathSegments?: readonly string[]) => TLeafShape[];
+export declare const normalizeShapeEntries: (entries: readonly TLeafShape[]) => string[];
+export declare const validateKeyConventions: (sheet: unknown, context: string, namespace: string, options?: TValidateKeyConventionsOptions) => string[];
+//# sourceMappingURL=keyShape.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"keyShape.d.ts","sourceRoot":"","sources":["../../src/verifier/keyShape.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,GAAG;IACvB,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED,MAAM,MAAM,8BAA8B,GAAG;IAC3C,0CAA0C,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,SAAS,MAAM,EAAE,GAAG,SAAS,CAAA;CACjG,CAAA;AAID,eAAO,MAAM,aAAa,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CACR,CAAA;AAQtE,eAAO,MAAM,aAAa,GAAI,OAAO,OAAO,EAAE,eAAc,SAAS,MAAM,EAAO,KAAG,UAAU,EAM9F,CAAA;AAED,eAAO,MAAM,qBAAqB,GAAI,SAAS,SAAS,UAAU,EAAE,KAAG,MAAM,EACZ,CAAA;AA6DjE,eAAO,MAAM,sBAAsB,GACjC,OAAO,OAAO,EACd,SAAS,MAAM,EACf,WAAW,MAAM,EACjB,UAAS,8BAAmC,KAC3C,MAAM,EAgBR,CAAA"}

package/dist/verifier/keyShape.js

@@ -0,0 +1,73 @@
+const TRANSLATION_KEY_SEGMENT_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+export const isPlainObject = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+const getValueKind = (value) => {
+    if (Array.isArray(value))
+        return "array";
+    if (isPlainObject(value))
+        return "object";
+    return typeof value;
+};
+export const getLeafShapes = (value, pathSegments = []) => {
+    if (!isPlainObject(value)) {
+        return [{ keyPath: pathSegments.join("."), kind: getValueKind(value) }];
+    }
+    return Object.entries(value).flatMap(([key, child]) => getLeafShapes(child, [...pathSegments, key]));
+};
+export const normalizeShapeEntries = (entries) => entries.map(({ keyPath, kind }) => `${keyPath}:${kind}`).sort();
+const validateTranslationKey = (keyPath, context, errors) => {
+    const segments = keyPath.split(".");
+    const invalidSegments = segments.filter((segment) => !TRANSLATION_KEY_SEGMENT_PATTERN.test(segment));
+    if (invalidSegments.length === 0)
+        return;
+    errors.push(`${context} has non-kebab-case key segment(s): ${invalidSegments.join(", ")} in "${keyPath}"`);
+};
+const validateMeta = (sheet, context) => {
+    const errors = [];
+    if (!isPlainObject(sheet)) {
+        return [`${context} must contain a JSON object`];
+    }
+    const meta = sheet._meta;
+    if (!isPlainObject(meta)) {
+        return [`${context} must define root _meta as an object`];
+    }
+    if (!isPlainObject(meta.interpolation)) {
+        errors.push(`${context} _meta.interpolation must be an object`);
+    }
+    if (typeof meta.lastModified !== "string") {
+        errors.push(`${context} _meta.lastModified must be a string`);
+    }
+    const unexpectedMetaKeys = Object.keys(meta).filter((key) => key !== "interpolation" && key !== "lastModified");
+    for (const key of unexpectedMetaKeys) {
+        errors.push(`${context} _meta has unexpected key "${key}"`);
+    }
+    if (isPlainObject(meta.interpolation)) {
+        for (const [key, placeholders] of Object.entries(meta.interpolation)) {
+            validateTranslationKey(key, `${context} _meta.interpolation`, errors);
+            if (!Array.isArray(placeholders) || placeholders.some((placeholder) => typeof placeholder !== "string")) {
+                errors.push(`${context} _meta.interpolation.${key} must be an array of strings`);
+            }
+        }
+    }
+    return errors;
+};
+const hasStructuredNamespaceException = (namespace, exceptions) => {
+    if (!exceptions)
+        return false;
+    if ("has" in exceptions && typeof exceptions.has === "function")
+        return exceptions.has(namespace);
+    return exceptions.includes(namespace);
+};
+export const validateKeyConventions = (sheet, context, namespace, options = {}) => {
+    const errors = validateMeta(sheet, context);
+    if (!isPlainObject(sheet))
+        return errors;
+    if (hasStructuredNamespaceException(namespace, options.structuredNamespaceKeyConventionExceptions)) {
+        return errors;
+    }
+    for (const key of Object.keys(sheet)) {
+        if (key === "_meta")
+            continue;
+        validateTranslationKey(key, context, errors);
+    }
+    return errors;
+};

package/dist/verifier/sheetOrdering.d.ts

@@ -0,0 +1,2 @@
+export declare const formatI18nSheet: (sheet: unknown) => string;
+//# sourceMappingURL=sheetOrdering.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sheetOrdering.d.ts","sourceRoot":"","sources":["../../src/verifier/sheetOrdering.ts"],"names":[],"mappings":"AAmMA,eAAO,MAAM,eAAe,GAAI,OAAO,OAAO,KAAG,MAA0C,CAAA"}

package/dist/verifier/sheetOrdering.js

@@ -0,0 +1,161 @@
+import { isPlainObject } from "./keyShape.js";
+const CANONICAL_ROOT_KEY_ORDER = [
+    "title",
+    "page",
+    "card",
+    "section",
+    "sheet",
+    "panel",
+    "nav",
+    "navbar",
+    "menu-button",
+    "popover-button",
+    "tabs",
+    "labels",
+    "locale",
+    "theme",
+    "display-mode",
+    "role",
+    "institutions",
+    "digital-destinations",
+    "link-destinations",
+    "ticket-link-destinations",
+    "types",
+    "statuses",
+    "entities",
+    "query-controls",
+    "sort-and-filter-panel",
+    "saved-views",
+    "search",
+    "search-panel",
+    "prompts",
+    "form",
+    "current-sorts",
+    "sort-entry",
+    "current-filters",
+    "filter-entry",
+    "table",
+    "pagination",
+    "page-counter",
+    "page-input",
+    "items-per-page",
+    "primary-controls",
+    "actions",
+    "rules",
+    "import",
+    "messages",
+    "errors",
+    "aria-label",
+];
+const CANONICAL_NESTED_KEY_ORDER = [
+    "interpolation",
+    "lastModified",
+    "display",
+    "grammar",
+    "singular",
+    "plural",
+    "articleForm",
+    "gender",
+    "elision",
+    "countable",
+];
+const ROOT_KEY_RANKS = new Map(CANONICAL_ROOT_KEY_ORDER.map((key, index) => [key, index]));
+const NESTED_KEY_RANKS = new Map(CANONICAL_NESTED_KEY_ORDER.map((key, index) => [key, index]));
+const INDENT = "  ";
+const UNKNOWN_KEY_RANK = 10_000;
+const compareStrings = (left, right) => {
+    if (left === right)
+        return 0;
+    return left < right ? -1 : 1;
+};
+const getRootKey = (key) => key.split(".")[0] ?? key;
+const getRootKeyRank = (key) => ROOT_KEY_RANKS.get(getRootKey(key)) ?? UNKNOWN_KEY_RANK;
+const getNestedKeyRank = (key) => NESTED_KEY_RANKS.get(key) ?? UNKNOWN_KEY_RANK;
+const compareRootKeys = (left, right) => {
+    if (left === "_meta")
+        return -1;
+    if (right === "_meta")
+        return 1;
+    const rankDiff = getRootKeyRank(left) - getRootKeyRank(right);
+    if (rankDiff !== 0)
+        return rankDiff;
+    return compareStrings(left, right);
+};
+const compareNestedKeys = (left, right) => {
+    if (left === "_meta")
+        return -1;
+    if (right === "_meta")
+        return 1;
+    const rankDiff = getNestedKeyRank(left) - getNestedKeyRank(right);
+    if (rankDiff !== 0)
+        return rankDiff;
+    return compareStrings(left, right);
+};
+const isInterpolationObjectPath = (pathSegments) => pathSegments.length === 2 && pathSegments[0] === "_meta" && pathSegments[1] === "interpolation";
+const isInterpolationTokenArrayPath = (pathSegments) => pathSegments.length === 3 && pathSegments[0] === "_meta" && pathSegments[1] === "interpolation";
+const compareKeysForPath = (left, right, pathSegments) => pathSegments.length === 0 || isInterpolationObjectPath(pathSegments)
+    ? compareRootKeys(left, right)
+    : compareNestedKeys(left, right);
+const getTopLevelFormattingGroup = (key) => {
+    if (key === "_meta")
+        return "_meta";
+    return getRootKey(key);
+};
+const formatPrimitive = (value) => JSON.stringify(value);
+const formatArray = (value, pathSegments, depth) => {
+    const normalizedValue = isInterpolationTokenArrayPath(pathSegments) && value.every((item) => typeof item === "string")
+        ? [...value].sort(compareStrings)
+        : value;
+    if (normalizedValue.length === 0)
+        return "[]";
+    if (normalizedValue.every((item) => !isPlainObject(item) && !Array.isArray(item))) {
+        return `[${normalizedValue.map(formatPrimitive).join(", ")}]`;
+    }
+    const childIndent = INDENT.repeat(depth + 1);
+    const closingIndent = INDENT.repeat(depth);
+    const lines = ["["];
+    normalizedValue.forEach((item, index) => {
+        const valueText = formatValue(item, [...pathSegments, String(index)], depth + 1);
+        const valueLines = `${childIndent}${valueText}`.split("\n");
+        if (index < normalizedValue.length - 1) {
+            const lastIndex = valueLines.length - 1;
+            valueLines[lastIndex] = `${valueLines[lastIndex] ?? ""},`;
+        }
+        lines.push(...valueLines);
+    });
+    lines.push(`${closingIndent}]`);
+    return lines.join("\n");
+};
+const formatObject = (value, pathSegments, depth) => {
+    const keys = Object.keys(value).sort((left, right) => compareKeysForPath(left, right, pathSegments));
+    if (keys.length === 0)
+        return "{}";
+    const childIndent = INDENT.repeat(depth + 1);
+    const closingIndent = INDENT.repeat(depth);
+    const lines = ["{"];
+    keys.forEach((key, index) => {
+        const valueText = formatValue(value[key], [...pathSegments, key], depth + 1);
+        const propertyLines = `${childIndent}${JSON.stringify(key)}: ${valueText}`.split("\n");
+        const nextKey = keys[index + 1];
+        if (index < keys.length - 1) {
+            const lastIndex = propertyLines.length - 1;
+            propertyLines[lastIndex] = `${propertyLines[lastIndex] ?? ""},`;
+        }
+        lines.push(...propertyLines);
+        if (pathSegments.length === 0 &&
+            nextKey &&
+            getTopLevelFormattingGroup(key) !== getTopLevelFormattingGroup(nextKey)) {
+            lines.push("");
+        }
+    });
+    lines.push(`${closingIndent}}`);
+    return lines.join("\n");
+};
+const formatValue = (value, pathSegments, depth) => {
+    if (Array.isArray(value))
+        return formatArray(value, pathSegments, depth);
+    if (isPlainObject(value))
+        return formatObject(value, pathSegments, depth);
+    return formatPrimitive(value);
+};
+export const formatI18nSheet = (sheet) => `${formatValue(sheet, [], 0)}\n`;

package/dist/verifier/verifyI18nSource.d.ts

@@ -0,0 +1,25 @@
+import { type TDomainSeedSourceContract, type TDomainTranslationContract } from "./domainContracts.js";
+export type TVerifyI18nSourceArgs<Locale extends string = string, Namespace extends string = string> = {
+    localesRoot: string;
+    availableNamespaces: readonly Namespace[];
+    declaredLocales?: readonly Locale[] | undefined;
+    defaultLocale: Locale;
+    initialLoadNamespaces?: readonly Namespace[] | undefined;
+    repoRoot?: string | undefined;
+    domainTranslationContracts?: readonly TDomainTranslationContract[] | undefined;
+    domainSeedSourceContracts?: readonly TDomainSeedSourceContract[] | undefined;
+    structuredNamespaceKeyConventionExceptions?: readonly Namespace[] | undefined;
+};
+export type TVerifyI18nSourceResult = {
+    sheetCount: number;
+    icuMessageCount: number;
+    localeCount: number;
+    registeredNamespaceCount: number;
+    keyTreeCount: number;
+    domainTranslationContractCount: number;
+    domainTranslationSourceCodeCount: number;
+    domainSeedSourceContractCount: number;
+    domainSeedSourceCodeCount: number;
+};
+export declare const verifyI18nSource: <Locale extends string, Namespace extends string>({ localesRoot, availableNamespaces, declaredLocales, defaultLocale, initialLoadNamespaces, repoRoot, domainTranslationContracts, domainSeedSourceContracts, structuredNamespaceKeyConventionExceptions, }: TVerifyI18nSourceArgs<Locale, Namespace>) => Promise<TVerifyI18nSourceResult>;
+//# sourceMappingURL=verifyI18nSource.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"verifyI18nSource.d.ts","sourceRoot":"","sources":["../../src/verifier/verifyI18nSource.ts"],"names":[],"mappings":"AAWA,OAAO,EAGL,KAAK,yBAAyB,EAC9B,KAAK,0BAA0B,EAChC,MAAM,sBAAsB,CAAA;AAE7B,MAAM,MAAM,qBAAqB,CAAC,MAAM,SAAS,MAAM,GAAG,MAAM,EAAE,SAAS,SAAS,MAAM,GAAG,MAAM,IAAI;IACrG,WAAW,EAAE,MAAM,CAAA;IACnB,mBAAmB,EAAE,SAAS,SAAS,EAAE,CAAA;IACzC,eAAe,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,CAAA;IAC/C,aAAa,EAAE,MAAM,CAAA;IACrB,qBAAqB,CAAC,EAAE,SAAS,SAAS,EAAE,GAAG,SAAS,CAAA;IACxD,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC7B,0BAA0B,CAAC,EAAE,SAAS,0BAA0B,EAAE,GAAG,SAAS,CAAA;IAC9E,yBAAyB,CAAC,EAAE,SAAS,yBAAyB,EAAE,GAAG,SAAS,CAAA;IAC5E,0CAA0C,CAAC,EAAE,SAAS,SAAS,EAAE,GAAG,SAAS,CAAA;CAC9E,CAAA;AAED,MAAM,MAAM,uBAAuB,GAAG;IACpC,UAAU,EAAE,MAAM,CAAA;IAClB,eAAe,EAAE,MAAM,CAAA;IACvB,WAAW,EAAE,MAAM,CAAA;IACnB,wBAAwB,EAAE,MAAM,CAAA;IAChC,YAAY,EAAE,MAAM,CAAA;IACpB,8BAA8B,EAAE,MAAM,CAAA;IACtC,gCAAgC,EAAE,MAAM,CAAA;IACxC,6BAA6B,EAAE,MAAM,CAAA;IACrC,yBAAyB,EAAE,MAAM,CAAA;CAClC,CAAA;AAUD,eAAO,MAAM,gBAAgB,GAAU,MAAM,SAAS,MAAM,EAAE,SAAS,SAAS,MAAM,EAAE,2MAUrF,qBAAqB,CAAC,MAAM,EAAE,SAAS,CAAC,KAAG,OAAO,CAAC,uBAAuB,CAsO5E,CAAA"}

package/dist/verifier/verifyI18nSource.js

@@ -0,0 +1,162 @@
+import path from "node:path";
+import { getDeclaredInterpolationTokens, getTranslationStringEntries, parseICUContract, pushContractDiffs, } from "./icuContracts.js";
+import { getLeafShapes, normalizeShapeEntries, validateKeyConventions } from "./keyShape.js";
+import { listDirNames, listJSONFiles, readJSONFileOrThrow } from "./fileSystem.js";
+import { formatI18nSheet } from "./sheetOrdering.js";
+import { verifyDomainSeedSourceContracts, verifyDomainTranslationContracts, } from "./domainContracts.js";
+const formatList = (items) => items.map((item) => `  - ${item}`).join("\n");
+const assertNoItems = (label, items) => {
+    if (items.length === 0)
+        return;
+    throw new Error(`[i18n verify] ${label}\n${formatList(items)}`);
+};
+export const verifyI18nSource = async ({ localesRoot, availableNamespaces, declaredLocales, defaultLocale, initialLoadNamespaces = [], repoRoot, domainTranslationContracts = [], domainSeedSourceContracts = [], structuredNamespaceKeyConventionExceptions = [], }) => {
+    if (availableNamespaces.length === 0) {
+        throw new Error("[i18n verify] availableNamespaces must contain at least one namespace");
+    }
+    const locales = declaredLocales ? [...declaredLocales] : (await listDirNames(localesRoot));
+    if (locales.length === 0) {
+        throw new Error(`[i18n verify] No locale directories found at ${localesRoot}`);
+    }
+    if (!locales.includes(defaultLocale)) {
+        throw new Error(`[i18n verify] Reference locale "${defaultLocale}" was not found at ${localesRoot}`);
+    }
+    const registeredNamespaceSet = new Set(availableNamespaces);
+    const initialNamespacesOutsideRegistry = initialLoadNamespaces.filter((namespace) => !registeredNamespaceSet.has(namespace));
+    assertNoItems("Initial load namespaces are missing from the available namespace registry:", initialNamespacesOutsideRegistry);
+    const discoveredLocaleDirectories = await listDirNames(localesRoot);
+    assertNoItems("Declared locales are missing locale directories:", locales.filter((locale) => !discoveredLocaleDirectories.includes(locale)));
+    assertNoItems("Locale directories are missing from declared locales:", discoveredLocaleDirectories.filter((locale) => !locales.includes(locale)));
+    let sheetCount = 0;
+    const namespacesByLocale = new Map();
+    const sheetsByLocale = new Map();
+    const sheetOrderingErrors = [];
+    const namespaceUnion = new Set();
+    for (const locale of locales) {
+        const localeDir = path.join(localesRoot, locale);
+        const files = await listJSONFiles(localeDir);
+        const namespaces = files.map((file) => file.replace(/\.json$/, ""));
+        if (files.length === 0) {
+            throw new Error(`[i18n verify] No translation sheets found for locale=${locale}`);
+        }
+        namespacesByLocale.set(locale, namespaces);
+        sheetsByLocale.set(locale, new Map());
+        namespaces.forEach((namespace) => namespaceUnion.add(namespace));
+        for (const file of files) {
+            const namespace = file.replace(/\.json$/, "");
+            const filePath = path.join(localeDir, file);
+            const { json: sheet, raw } = await readJSONFileOrThrow(filePath, "[i18n verify]");
+            const canonicalSheet = formatI18nSheet(sheet);
+            if (raw !== canonicalSheet) {
+                sheetOrderingErrors.push(`${locale}/${file}`);
+            }
+            sheetsByLocale.get(locale)?.set(namespace, sheet);
+            sheetCount += 1;
+        }
+    }
+    const sourceNamespaces = [...namespaceUnion].sort();
+    for (const locale of locales) {
+        const localeNamespaceSet = new Set(namespacesByLocale.get(locale));
+        const missingNamespaces = sourceNamespaces.filter((namespace) => !localeNamespaceSet.has(namespace));
+        assertNoItems(`Locale ${locale} is missing translation sheets present in another locale:`, missingNamespaces);
+    }
+    assertNoItems("Registered namespaces are missing source translation sheets:", availableNamespaces.filter((namespace) => !namespaceUnion.has(namespace)));
+    assertNoItems("Source translation sheets are missing from the namespace registry:", sourceNamespaces.filter((namespace) => !registeredNamespaceSet.has(namespace)));
+    assertNoItems("Translation sheets are not canonically ordered. Run the app facade formatter:", sheetOrderingErrors);
+    const keyShapeErrors = [];
+    for (const namespace of sourceNamespaces) {
+        const referenceSheet = sheetsByLocale.get(defaultLocale)?.get(namespace);
+        const referenceShapes = normalizeShapeEntries(getLeafShapes(referenceSheet));
+        const referenceShapeSet = new Set(referenceShapes);
+        for (const locale of locales) {
+            const sheet = sheetsByLocale.get(locale)?.get(namespace);
+            const context = `${locale}/${namespace}.json`;
+            keyShapeErrors.push(...validateKeyConventions(sheet, context, namespace, {
+                structuredNamespaceKeyConventionExceptions,
+            }));
+            if (locale === defaultLocale)
+                continue;
+            const localeShapes = normalizeShapeEntries(getLeafShapes(sheet));
+            const localeShapeSet = new Set(localeShapes);
+            const missingShapes = referenceShapes.filter((shape) => !localeShapeSet.has(shape));
+            const extraShapes = localeShapes.filter((shape) => !referenceShapeSet.has(shape));
+            for (const shape of missingShapes) {
+                keyShapeErrors.push(`${context} is missing key shape from ${defaultLocale}/${namespace}.json: ${shape}`);
+            }
+            for (const shape of extraShapes) {
+                keyShapeErrors.push(`${context} has extra key shape not present in ${defaultLocale}/${namespace}.json: ${shape}`);
+            }
+        }
+    }
+    assertNoItems("Translation key shape violations:", keyShapeErrors);
+    const domainTranslationContractResult = repoRoot && domainTranslationContracts.length > 0
+        ? await verifyDomainTranslationContracts({
+            contracts: domainTranslationContracts,
+            locales,
+            repoRoot,
+            sheetsByLocale,
+        })
+        : {
+            checkedCodeCount: 0,
+            checkedContractCount: 0,
+            errors: [],
+        };
+    assertNoItems("Domain-to-i18n contract violations:", domainTranslationContractResult.errors);
+    const domainSeedSourceContractResult = repoRoot && domainSeedSourceContracts.length > 0
+        ? await verifyDomainSeedSourceContracts({
+            contracts: domainSeedSourceContracts,
+            repoRoot,
+        })
+        : {
+            checkedContractCount: 0,
+            checkedSourceCodeCount: 0,
+            errors: [],
+        };
+    assertNoItems("Domain seed source contract violations:", domainSeedSourceContractResult.errors);
+    let icuMessageCount = 0;
+    const icuContractErrors = [];
+    for (const namespace of sourceNamespaces) {
+        const referenceSheet = sheetsByLocale.get(defaultLocale)?.get(namespace);
+        const referenceContractsByKeyPath = new Map();
+        for (const { keyPath, value } of getTranslationStringEntries(referenceSheet)) {
+            const referenceContext = `${defaultLocale}/${namespace}.json ${keyPath}`;
+            const referenceContract = parseICUContract(value, defaultLocale, referenceContext, icuContractErrors);
+            if (referenceContract) {
+                referenceContractsByKeyPath.set(keyPath, referenceContract);
+                icuMessageCount += 1;
+            }
+        }
+        for (const locale of locales) {
+            const sheet = sheetsByLocale.get(locale)?.get(namespace);
+            for (const { keyPath, value } of getTranslationStringEntries(sheet)) {
+                const context = `${locale}/${namespace}.json ${keyPath}`;
+                const contract = locale === defaultLocale
+                    ? referenceContractsByKeyPath.get(keyPath)
+                    : parseICUContract(value, locale, context, icuContractErrors);
+                if (!contract)
+                    continue;
+                if (locale !== defaultLocale)
+                    icuMessageCount += 1;
+                pushContractDiffs(icuContractErrors, `${context} _meta.interpolation`, context, "interpolation token(s)", contract.interpolationTokens, getDeclaredInterpolationTokens(sheet, keyPath));
+                if (locale === defaultLocale)
+                    continue;
+                const referenceContract = referenceContractsByKeyPath.get(keyPath);
+                if (!referenceContract)
+                    continue;
+                pushContractDiffs(icuContractErrors, context, `${defaultLocale}/${namespace}.json ${keyPath}`, "contract signature(s)", referenceContract.contractSignatures, contract.contractSignatures);
+            }
+        }
+    }
+    assertNoItems("ICU message contract violations:", icuContractErrors);
+    return {
+        domainSeedSourceCodeCount: domainSeedSourceContractResult.checkedSourceCodeCount,
+        domainSeedSourceContractCount: domainSeedSourceContractResult.checkedContractCount,
+        domainTranslationContractCount: domainTranslationContractResult.checkedContractCount,
+        domainTranslationSourceCodeCount: domainTranslationContractResult.checkedCodeCount,
+        icuMessageCount,
+        keyTreeCount: sourceNamespaces.length,
+        localeCount: locales.length,
+        registeredNamespaceCount: availableNamespaces.length,
+        sheetCount,
+    };
+};