@xndrjs/i18n 0.8.0 → 0.8.2-alpha.0

package/dist/cli/audit.js

@@ -0,0 +1,739 @@
+#!/usr/bin/env node
+import { z } from 'zod';
+import path4 from 'path';
+import fs2 from 'fs';
+import { parse } from 'yaml';
+import { fileURLToPath } from 'url';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/codegen/constants.ts
+var IDENTIFIER_NAME_PATTERN, IDENTIFIER_NAME_REQUIREMENT;
+var init_constants = __esm({
+  "src/codegen/constants.ts"() {
+    IDENTIFIER_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+    IDENTIFIER_NAME_REQUIREMENT = "allowed: letters, digits, underscore; must not start with a digit";
+  }
+});
+
+// src/codegen/delivery-artifacts.ts
+function getDeliveryArtifactsStructureIssues(deliveryArtifacts) {
+  const issues = [];
+  for (const [area, locales] of Object.entries(deliveryArtifacts)) {
+    if (!DELIVERY_AREA_NAME_PATTERN.test(area)) {
+      issues.push({
+        path: ["deliveryArtifacts", area],
+        message: `Invalid delivery area name "${area}": must match ${DELIVERY_AREA_NAME_PATTERN.source}`
+      });
+    }
+    if (locales.length === 0) {
+      issues.push({
+        path: ["deliveryArtifacts", area],
+        message: `Delivery area "${area}" must include at least one locale.`
+      });
+    }
+  }
+  const localeToArea = /* @__PURE__ */ new Map();
+  for (const [area, locales] of Object.entries(deliveryArtifacts)) {
+    for (const locale of locales) {
+      const previousArea = localeToArea.get(locale);
+      if (previousArea) {
+        issues.push({
+          path: ["deliveryArtifacts", area],
+          message: `Locale "${locale}" appears in both "${previousArea}" and "${area}".`
+        });
+      } else {
+        localeToArea.set(locale, area);
+      }
+    }
+  }
+  return issues;
+}
+var DELIVERY_AREA_NAME_PATTERN;
+var init_delivery_artifacts = __esm({
+  "src/codegen/delivery-artifacts.ts"() {
+    DELIVERY_AREA_NAME_PATTERN = /^[a-zA-Z][a-zA-Z0-9_-]*$/;
+  }
+});
+
+// src/codegen-config/type-names.ts
+function typeNamesForProject(project) {
+  return {
+    paramsTypeName: `${project}Params`,
+    schemaTypeName: `${project}Schema`,
+    localeTypeName: `${project}Locale`
+  };
+}
+var init_type_names = __esm({
+  "src/codegen-config/type-names.ts"() {
+  }
+});
+function resolveCodegenPaths(config) {
+  const typeNames = typeNamesForProject(config.projectName);
+  const codegenPath = config.codegenPath;
+  return {
+    codegenPath,
+    typesOutput: path4.join(codegenPath, GENERATED_BASENAMES.types),
+    instanceOutput: path4.join(codegenPath, GENERATED_BASENAMES.instance),
+    namespaceLoadersOutput: path4.join(codegenPath, GENERATED_BASENAMES.namespaceLoaders),
+    dictionarySchemaOutput: path4.join(codegenPath, GENERATED_BASENAMES.dictionarySchema),
+    artifactsPath: config.artifactsPath ?? codegenPath,
+    paramsTypeName: typeNames.paramsTypeName,
+    schemaTypeName: typeNames.schemaTypeName,
+    localeTypeName: typeNames.localeTypeName,
+    localeFallbackConstName: DEFAULT_LOCALE_FALLBACK_CONST_NAME,
+    factoryName: DEFAULT_FACTORY_NAME,
+    deliveryAreaTypeName: `${config.projectName}DeliveryArea`
+  };
+}
+function resolveArtifactsPath(config) {
+  return config.artifactsPath ?? config.codegenPath;
+}
+function formatCodegenConfigIssues(error) {
+  const issueLines = error.issues.map((issue) => {
+    const path7 = issue.path.length > 0 ? issue.path.join(".") : "(root)";
+    return `  - ${path7}: ${issue.message}`;
+  });
+  return [
+    "[Codegen Error] Invalid i18n.codegen.json:",
+    ...issueLines,
+    "",
+    `Allowed keys: ${codegenConfigKeys.join(", ")}`
+  ].join("\n");
+}
+var localeFallbackSchema, deliveryArtifactsSchema, DELIVERY_MODES, LOADER_STRATEGIES, PROJECT_NAME_PATTERN, codegenConfigShape, codegenConfigKeys, codegenConfigSchema, GENERATED_BASENAMES, DEFAULT_FACTORY_NAME, DEFAULT_LOCALE_FALLBACK_CONST_NAME;
+var init_codegen_config_schema = __esm({
+  "src/codegen/codegen-config-schema.ts"() {
+    init_constants();
+    init_delivery_artifacts();
+    init_type_names();
+    localeFallbackSchema = z.record(z.string(), z.union([z.string(), z.null()]));
+    deliveryArtifactsSchema = z.record(z.string(), z.array(z.string().min(1)));
+    DELIVERY_MODES = ["split-by-locale", "custom"];
+    LOADER_STRATEGIES = ["import", "fetch"];
+    PROJECT_NAME_PATTERN = /^[A-Z][a-zA-Z0-9]*$/;
+    codegenConfigShape = {
+      /** PascalCase project id — generates `{project}Params`, `{project}Schema`, `{project}Locale`. */
+      projectName: z.string().min(1).regex(PROJECT_NAME_PATTERN, 'projectName must be PascalCase (e.g. "MyApp")'),
+      namespaces: z.record(z.string(), z.string().min(1)),
+      /**
+       * Directory for generated TypeScript modules:
+       * `i18n-types.generated.ts`, `instance.generated.ts`,
+       * `namespace-loaders.generated.ts`, `dictionary-schema.generated.ts`.
+       */
+      codegenPath: z.string().min(1),
+      localeFallback: localeFallbackSchema.optional(),
+      delivery: z.enum(DELIVERY_MODES).optional().default("split-by-locale"),
+      deliveryArtifacts: deliveryArtifactsSchema.optional(),
+      /** Directory for delivery JSON (`translations/`). Defaults to {@link codegenPath}. */
+      artifactsPath: z.string().min(1).optional(),
+      /**
+       * How generated `namespaceLoaders` resolve artifacts.
+       * - `import` (default): dynamic `import()` — JSON is bundled; content updates need a rebuild.
+       * - `fetch`: runtime `fetchImpl({ locale, namespace, area? })` via required `createI18n({ fetchImpl })`.
+       *   Codegen does not know URLs — mapping id → transport is an application concern.
+       */
+      loaderStrategy: z.enum(LOADER_STRATEGIES).optional().default("import")
+    };
+    codegenConfigKeys = Object.keys(
+      codegenConfigShape
+    );
+    codegenConfigSchema = z.object(codegenConfigShape).strict().superRefine((config, ctx) => {
+      for (const namespace of Object.keys(config.namespaces)) {
+        if (!IDENTIFIER_NAME_PATTERN.test(namespace)) {
+          ctx.addIssue({
+            code: "custom",
+            path: ["namespaces", namespace],
+            message: `Invalid namespace name "${namespace}" (${IDENTIFIER_NAME_REQUIREMENT}).`
+          });
+        }
+      }
+      if (config.delivery === "custom") {
+        if (!config.deliveryArtifacts) {
+          ctx.addIssue({
+            code: "custom",
+            path: ["deliveryArtifacts"],
+            message: 'deliveryArtifacts is required when delivery is "custom".'
+          });
+        } else {
+          for (const issue of getDeliveryArtifactsStructureIssues(config.deliveryArtifacts)) {
+            ctx.addIssue({
+              code: "custom",
+              path: issue.path,
+              message: issue.message
+            });
+          }
+        }
+      } else if (config.deliveryArtifacts !== void 0) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["deliveryArtifacts"],
+          message: 'deliveryArtifacts is only allowed when delivery is "custom".'
+        });
+      }
+    });
+    GENERATED_BASENAMES = {
+      types: "i18n-types.generated.ts",
+      instance: "instance.generated.ts",
+      namespaceLoaders: "namespace-loaders.generated.ts",
+      dictionarySchema: "dictionary-schema.generated.ts"
+    };
+    DEFAULT_FACTORY_NAME = "createI18n";
+    DEFAULT_LOCALE_FALLBACK_CONST_NAME = "LOCALE_FALLBACK";
+  }
+});
+
+// src/codegen/config.ts
+var config_exports = {};
+__export(config_exports, {
+  DEFAULT_FACTORY_NAME: () => DEFAULT_FACTORY_NAME,
+  DEFAULT_LOCALE_FALLBACK_CONST_NAME: () => DEFAULT_LOCALE_FALLBACK_CONST_NAME,
+  GENERATED_BASENAMES: () => GENERATED_BASENAMES,
+  loadConfig: () => loadConfig,
+  resolveArtifactsPath: () => resolveArtifactsPath,
+  resolveCodegenPaths: () => resolveCodegenPaths,
+  resolveNamespaces: () => resolveNamespaces
+});
+function loadConfig(configPath) {
+  let raw;
+  try {
+    raw = JSON.parse(fs2.readFileSync(configPath, "utf8"));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`[Codegen Error] Failed to parse config JSON (${configPath}): ${message}`);
+  }
+  const result = codegenConfigSchema.safeParse(raw);
+  if (!result.success) {
+    throw new Error(formatCodegenConfigIssues(result.error));
+  }
+  return result.data;
+}
+function resolveNamespaces(config) {
+  return Object.entries(config.namespaces).map(([namespace, filePath]) => ({
+    namespace,
+    filePath
+  }));
+}
+var init_config = __esm({
+  "src/codegen/config.ts"() {
+    init_codegen_config_schema();
+    init_codegen_config_schema();
+  }
+});
+
+// src/resolve-locale.ts
+function resolveLocaleTemplate(localeByKey, requestedLocale, fallbackMap) {
+  const chain = [requestedLocale];
+  let currentLocale = requestedLocale;
+  while (true) {
+    const template = localeByKey?.[currentLocale];
+    if (template !== void 0) {
+      return { template, resolvedLocale: currentLocale, fallbackChain: chain };
+    }
+    if (!fallbackMap) {
+      return void 0;
+    }
+    const fallback = fallbackMap[currentLocale];
+    if (fallback === void 0 || fallback === null) {
+      return void 0;
+    }
+    if (chain.includes(fallback)) {
+      throw new Error(
+        `[i18n] Circular locale fallback detected: ${[...chain, fallback].join(" \u2192 ")}`
+      );
+    }
+    chain.push(fallback);
+    currentLocale = fallback;
+  }
+}
+var init_resolve_locale = __esm({
+  "src/resolve-locale.ts"() {
+  }
+});
+
+// src/project-locales.ts
+function classifyAreaLocales(areaLocales, localeFallback) {
+  const areaSet = new Set(areaLocales);
+  const full = [];
+  const preserve = [];
+  for (const locale of areaLocales) {
+    const fallback = localeFallback?.[locale];
+    if (fallback !== null && fallback !== void 0 && areaSet.has(fallback)) {
+      preserve.push(locale);
+    } else {
+      full.push(locale);
+    }
+  }
+  return { full, preserve };
+}
+function projectKeyDictionary(dictionary, locales, localeFallback) {
+  const targetLocales = [...new Set(locales)];
+  const result = {};
+  for (const [key, localesByKey] of Object.entries(dictionary)) {
+    const projected = {};
+    for (const locale of targetLocales) {
+      const resolved = resolveLocaleTemplate(localesByKey, locale, localeFallback);
+      if (resolved !== void 0) {
+        projected[locale] = resolved.template;
+      }
+    }
+    if (Object.keys(projected).length > 0) {
+      result[key] = projected;
+    }
+  }
+  return result;
+}
+function projectNamespaceLocalesCore(dictionary, locales, localeFallback) {
+  return projectKeyDictionary(dictionary, locales, localeFallback);
+}
+function projectNamespaceForDeliveryAreaCore(dictionary, areaLocales, localeFallback) {
+  const { full, preserve } = classifyAreaLocales(areaLocales, localeFallback);
+  const fullProjection = full.length > 0 ? projectKeyDictionary(dictionary, full, localeFallback) : void 0;
+  const result = {};
+  for (const [key, localesByKey] of Object.entries(dictionary)) {
+    const projected = {};
+    if (fullProjection !== void 0) {
+      const fullEntry = fullProjection[key];
+      if (fullEntry !== void 0) {
+        Object.assign(projected, fullEntry);
+      }
+    }
+    for (const locale of preserve) {
+      const template = localesByKey[locale];
+      if (template !== void 0) {
+        projected[locale] = template;
+      }
+    }
+    if (Object.keys(projected).length > 0) {
+      result[key] = projected;
+    }
+  }
+  return result;
+}
+var init_project_locales = __esm({
+  "src/project-locales.ts"() {
+    init_resolve_locale();
+  }
+});
+function relativePosixPath(from, to) {
+  return path4.relative(from, to).replace(/\\/g, "/");
+}
+var init_paths = __esm({
+  "src/codegen/paths.ts"() {
+  }
+});
+function writeFileIfChanged(absolutePath, content) {
+  if (fs2.existsSync(absolutePath)) {
+    const currentContent = fs2.readFileSync(absolutePath, "utf8");
+    if (currentContent === content) {
+      return false;
+    }
+  }
+  fs2.mkdirSync(path4.dirname(absolutePath), { recursive: true });
+  fs2.writeFileSync(absolutePath, content);
+  return true;
+}
+var init_write_file_if_changed = __esm({
+  "src/codegen/write-file-if-changed.ts"() {
+  }
+});
+
+// src/codegen/read-dictionary.ts
+var read_dictionary_exports = {};
+__export(read_dictionary_exports, {
+  SUPPORTED_DICTIONARY_EXTENSIONS: () => SUPPORTED_DICTIONARY_EXTENSIONS,
+  getDictionaryFormat: () => getDictionaryFormat,
+  prepareDictionaryEntries: () => prepareDictionaryEntries,
+  readDictionaryFile: () => readDictionaryFile,
+  resolveAreaJsonPath: () => resolveAreaJsonPath,
+  resolveCompiledJsonPath: () => resolveCompiledJsonPath,
+  resolveSplitJsonPath: () => resolveSplitJsonPath,
+  splitDictionaryByDeliveryArea: () => splitDictionaryByDeliveryArea,
+  splitDictionaryByLocale: () => splitDictionaryByLocale
+});
+function getDictionaryFormat(filePath) {
+  const extension = path4.extname(filePath).toLowerCase();
+  if (extension === ".json") {
+    return "json";
+  }
+  if (extension === ".yaml" || extension === ".yml") {
+    return "yaml";
+  }
+  return null;
+}
+function resolveCompiledJsonPath(sourcePath, generatedDirRelative) {
+  const baseName = `${path4.basename(sourcePath, path4.extname(sourcePath))}.json`;
+  return path4.join(generatedDirRelative, "translations", baseName).replace(/\\/g, "/");
+}
+function resolveSplitJsonPath(sourcePath, locale, generatedDirRelative) {
+  const baseName = path4.basename(sourcePath, path4.extname(sourcePath));
+  return path4.join(generatedDirRelative, "translations", `${baseName}.${locale}.json`).replace(/\\/g, "/");
+}
+function resolveAreaJsonPath(sourcePath, area, generatedDirRelative) {
+  const baseName = path4.basename(sourcePath, path4.extname(sourcePath));
+  return path4.join(generatedDirRelative, "translations", `${baseName}.${area}.json`).replace(/\\/g, "/");
+}
+function splitDictionaryByLocale(dictionary, locales, localeFallback) {
+  const byLocale = {};
+  for (const locale of locales) {
+    byLocale[locale] = projectNamespaceLocalesCore(dictionary, [locale], localeFallback);
+  }
+  return byLocale;
+}
+function splitDictionaryByDeliveryArea(dictionary, deliveryArtifacts, localeFallback) {
+  const byArea = {};
+  for (const [area, areaLocales] of Object.entries(deliveryArtifacts)) {
+    byArea[area] = projectNamespaceForDeliveryAreaCore(dictionary, areaLocales, localeFallback);
+  }
+  return byArea;
+}
+function assertDictionaryShape(value, context) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`[Codegen Error] ${context} must be a plain object.`);
+  }
+  for (const [key, localesByKey] of Object.entries(value)) {
+    if (!IDENTIFIER_NAME_PATTERN.test(key)) {
+      throw new Error(
+        `[Codegen Error] ${context}: invalid key "${key}" (${IDENTIFIER_NAME_REQUIREMENT}).`
+      );
+    }
+    if (localesByKey === null || typeof localesByKey !== "object" || Array.isArray(localesByKey)) {
+      throw new Error(`[Codegen Error] ${context}: key "${key}" must map locales to strings.`);
+    }
+    for (const [locale, template] of Object.entries(localesByKey)) {
+      if (typeof template !== "string") {
+        throw new Error(
+          `[Codegen Error] ${context}: key "${key}", locale "${locale}" must be a string.`
+        );
+      }
+    }
+  }
+}
+function readDictionaryFile(absolutePath) {
+  const format = getDictionaryFormat(absolutePath);
+  if (!format) {
+    throw new Error(
+      `[Codegen Error] Unsupported dictionary format "${path4.extname(absolutePath)}" for ${absolutePath}. Use .json, .yaml, or .yml.`
+    );
+  }
+  const source = fs2.readFileSync(absolutePath, "utf8");
+  let parsed;
+  try {
+    parsed = format === "json" ? JSON.parse(source) : parse(source);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`[Codegen Error] Failed to parse dictionary ${absolutePath}: ${message}`);
+  }
+  assertDictionaryShape(parsed, `Dictionary file ${absolutePath}`);
+  return parsed;
+}
+function writeCompiledJson(absoluteJsonPath, dictionary) {
+  return writeFileIfChanged(absoluteJsonPath, `${JSON.stringify(dictionary, null, 2)}
+`);
+}
+function prepareDictionaryEntries(projectRoot, entries, generatedDirRelative, options) {
+  const delivery = options.delivery;
+  const { dictionariesByNamespace, localeFallback, requestLocales, deliveryArtifacts } = options;
+  const resolvedEntries = [];
+  const splitPathsByNamespace = {};
+  const compiledFiles = [];
+  if (delivery === "split-by-locale" && (!requestLocales || requestLocales.length === 0)) {
+    throw new Error(
+      "[Codegen Error] split-by-locale delivery requires at least one request locale."
+    );
+  }
+  if (delivery === "custom" && (!deliveryArtifacts || Object.keys(deliveryArtifacts).length === 0)) {
+    throw new Error("[Codegen Error] custom delivery requires deliveryArtifacts.");
+  }
+  for (const entry of entries) {
+    const sourceAbsolutePath = path4.resolve(projectRoot, entry.filePath);
+    const format = getDictionaryFormat(entry.filePath);
+    if (!format) {
+      throw new Error(
+        `[Codegen Error] Namespace "${entry.namespace}" uses unsupported dictionary extension in "${entry.filePath}". Use .json, .yaml, or .yml.`
+      );
+    }
+    const dictionary = dictionariesByNamespace[entry.namespace];
+    if (!dictionary) {
+      throw new Error(
+        `[Codegen Error] Missing parsed dictionary for namespace "${entry.namespace}".`
+      );
+    }
+    if (delivery === "split-by-locale") {
+      const splitPaths2 = {};
+      const dictionariesByLocale = splitDictionaryByLocale(
+        dictionary,
+        requestLocales,
+        localeFallback
+      );
+      for (const locale of requestLocales) {
+        const splitRelativePath = resolveSplitJsonPath(
+          entry.filePath,
+          locale,
+          generatedDirRelative
+        );
+        const splitAbsolutePath = path4.resolve(projectRoot, splitRelativePath);
+        const wroteFile = writeCompiledJson(splitAbsolutePath, dictionariesByLocale[locale]);
+        if (wroteFile) {
+          compiledFiles.push(
+            `${relativePosixPath(projectRoot, sourceAbsolutePath)} \u2192 ${splitRelativePath}`
+          );
+        }
+        splitPaths2[locale] = splitRelativePath;
+      }
+      splitPathsByNamespace[entry.namespace] = splitPaths2;
+      resolvedEntries.push(entry);
+      continue;
+    }
+    const splitPaths = {};
+    const dictionariesByArea = splitDictionaryByDeliveryArea(
+      dictionary,
+      deliveryArtifacts,
+      localeFallback
+    );
+    for (const area of Object.keys(deliveryArtifacts).sort()) {
+      const areaRelativePath = resolveAreaJsonPath(entry.filePath, area, generatedDirRelative);
+      const areaAbsolutePath = path4.resolve(projectRoot, areaRelativePath);
+      const wroteFile = writeCompiledJson(areaAbsolutePath, dictionariesByArea[area]);
+      if (wroteFile) {
+        compiledFiles.push(
+          `${relativePosixPath(projectRoot, sourceAbsolutePath)} \u2192 ${areaRelativePath}`
+        );
+      }
+      splitPaths[area] = areaRelativePath;
+    }
+    splitPathsByNamespace[entry.namespace] = splitPaths;
+    resolvedEntries.push(entry);
+  }
+  return { resolvedEntries, splitPathsByNamespace, compiledFiles };
+}
+var SUPPORTED_DICTIONARY_EXTENSIONS;
+var init_read_dictionary = __esm({
+  "src/codegen/read-dictionary.ts"() {
+    init_constants();
+    init_project_locales();
+    init_paths();
+    init_write_file_if_changed();
+    SUPPORTED_DICTIONARY_EXTENSIONS = [".json", ".yaml", ".yml"];
+  }
+});
+
+// src/audit/run-audit.ts
+init_config();
+
+// src/codegen/locale-fallback.ts
+init_resolve_locale();
+function collectRequestLocales(dictionaryLocales, fallback) {
+  const all = new Set(dictionaryLocales);
+  if (!fallback) {
+    return all;
+  }
+  for (const [locale, target] of Object.entries(fallback)) {
+    all.add(locale);
+    if (target !== null) {
+      all.add(target);
+    }
+  }
+  return all;
+}
+
+// src/codegen/locale-policy.ts
+function buildRequiredLocales(dictionaryLocales, configFallback) {
+  return [...collectRequestLocales(dictionaryLocales, configFallback)].sort();
+}
+function enrichLocaleFallback(dictionaryLocales, configFallback) {
+  const enriched = { ...configFallback };
+  for (const locale of buildRequiredLocales(dictionaryLocales, configFallback)) {
+    if (!(locale in enriched)) {
+      enriched[locale] = null;
+    }
+  }
+  const sortedEntries = Object.entries(enriched).sort(
+    ([left], [right]) => left.localeCompare(right)
+  );
+  return Object.fromEntries(sortedEntries);
+}
+
+// src/audit/audit-dictionaries.ts
+init_resolve_locale();
+function isDirectlyMissing(localesByKey, locale, treatEmptyAsMissing) {
+  const template = localesByKey[locale];
+  if (template === void 0) {
+    return true;
+  }
+  return treatEmptyAsMissing && template === "";
+}
+function isEffectivelyMissing(localesByKey, locale, localeFallback, treatEmptyAsMissing) {
+  const resolved = resolveLocaleTemplate(localesByKey, locale, localeFallback);
+  if (resolved === void 0) {
+    return true;
+  }
+  return treatEmptyAsMissing && resolved.template === "";
+}
+function collectDictionaryLocales(namespaces) {
+  const locales = /* @__PURE__ */ new Set();
+  for (const dictionary of Object.values(namespaces)) {
+    for (const localesByKey of Object.values(dictionary)) {
+      for (const locale of Object.keys(localesByKey)) {
+        locales.add(locale);
+      }
+    }
+  }
+  return locales;
+}
+function auditDictionaries(options) {
+  const { namespaces, config, treatEmptyAsMissing = true } = options;
+  const dictionaryLocales = collectDictionaryLocales(namespaces);
+  const requiredLocales = buildRequiredLocales(dictionaryLocales, config.localeFallback);
+  const localeFallbackForAudit = config.localeFallback ? enrichLocaleFallback(dictionaryLocales, config.localeFallback) : void 0;
+  const summary = {};
+  const missingDirectByLocale = {};
+  const missingEffectiveByLocale = {};
+  for (const [namespace, dictionary] of Object.entries(namespaces)) {
+    summary[namespace] = {};
+    missingDirectByLocale[namespace] = {};
+    missingEffectiveByLocale[namespace] = {};
+    for (const locale of requiredLocales) {
+      summary[namespace][locale] = { missingDirect: 0, missingEffective: 0 };
+      missingDirectByLocale[namespace][locale] = [];
+      missingEffectiveByLocale[namespace][locale] = [];
+    }
+    for (const [key, localesByKey] of Object.entries(dictionary)) {
+      for (const locale of requiredLocales) {
+        if (isDirectlyMissing(localesByKey, locale, treatEmptyAsMissing)) {
+          summary[namespace][locale].missingDirect += 1;
+          missingDirectByLocale[namespace][locale].push(key);
+        }
+        if (isEffectivelyMissing(localesByKey, locale, localeFallbackForAudit, treatEmptyAsMissing)) {
+          summary[namespace][locale].missingEffective += 1;
+          missingEffectiveByLocale[namespace][locale].push(key);
+        }
+      }
+    }
+    for (const locale of requiredLocales) {
+      missingDirectByLocale[namespace][locale].sort();
+      missingEffectiveByLocale[namespace][locale].sort();
+    }
+  }
+  return {
+    requiredLocales,
+    ...localeFallbackForAudit !== void 0 ? { localeFallback: localeFallbackForAudit } : {},
+    summary,
+    missingDirectByLocale,
+    missingEffectiveByLocale
+  };
+}
+function reportHasGaps(report, criterion) {
+  for (const namespace of Object.keys(report.missingDirectByLocale)) {
+    for (const locale of report.requiredLocales) {
+      const direct = report.missingDirectByLocale[namespace]?.[locale] ?? [];
+      const effective = report.missingEffectiveByLocale[namespace]?.[locale] ?? [];
+      if (criterion === "direct" && direct.length > 0) {
+        return true;
+      }
+      if (criterion === "effective" && effective.length > 0) {
+        return true;
+      }
+      if (criterion === "any" && (direct.length > 0 || effective.length > 0)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+async function runAuditFromConfig(options) {
+  const { resolveNamespaces: resolveNamespaces2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+  const { readDictionaryFile: readDictionaryFile2 } = await Promise.resolve().then(() => (init_read_dictionary(), read_dictionary_exports));
+  const config = options.config;
+  const entries = resolveNamespaces2(config);
+  const namespaces = {};
+  for (const entry of entries) {
+    const absolutePath = path4.resolve(options.projectRoot, entry.filePath);
+    namespaces[entry.namespace] = readDictionaryFile2(absolutePath);
+  }
+  const report = auditDictionaries({
+    namespaces,
+    config,
+    ...options.treatEmptyAsMissing !== void 0 ? { treatEmptyAsMissing: options.treatEmptyAsMissing } : {}
+  });
+  const exitCode = options.failOn && reportHasGaps(report, options.failOn) ? 1 : 0;
+  return { report, exitCode };
+}
+
+// src/audit/run-audit.ts
+var FAIL_ON_VALUES = /* @__PURE__ */ new Set(["effective", "direct", "any"]);
+function parseAuditArgs(argv) {
+  const configArgIndex = argv.indexOf("--config");
+  const outArgIndex = argv.indexOf("--out");
+  const failOnArgIndex = argv.indexOf("--fail-on");
+  const configPath = path4.resolve(
+    process.cwd(),
+    configArgIndex >= 0 ? argv[configArgIndex + 1] : "i18n/i18n.codegen.json"
+  );
+  const outPath = outArgIndex >= 0 ? path4.resolve(process.cwd(), argv[outArgIndex + 1]) : void 0;
+  let failOn;
+  if (failOnArgIndex >= 0) {
+    const value = argv[failOnArgIndex + 1];
+    if (!value || !FAIL_ON_VALUES.has(value)) {
+      throw new Error(`[Audit Error] --fail-on must be one of: effective, direct, any`);
+    }
+    failOn = value;
+  }
+  const treatEmptyAsMissing = !argv.includes("--allow-empty");
+  return {
+    configPath,
+    treatEmptyAsMissing,
+    ...outPath !== void 0 ? { outPath } : {},
+    ...failOn !== void 0 ? { failOn } : {}
+  };
+}
+async function runAuditCli(argv = process.argv.slice(2)) {
+  let options;
+  let config;
+  try {
+    options = parseAuditArgs(argv);
+    if (!fs2.existsSync(options.configPath)) {
+      console.error(`[Audit Error] Config file not found: ${options.configPath}`);
+      return 2;
+    }
+    config = loadConfig(options.configPath);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    return 2;
+  }
+  const projectRoot = path4.dirname(options.configPath);
+  const { report, exitCode } = await runAuditFromConfig({
+    projectRoot,
+    config,
+    treatEmptyAsMissing: options.treatEmptyAsMissing,
+    ...options.failOn !== void 0 ? { failOn: options.failOn } : {}
+  });
+  const json = `${JSON.stringify(report, null, 2)}
+`;
+  if (options.outPath) {
+    fs2.mkdirSync(path4.dirname(options.outPath), { recursive: true });
+    fs2.writeFileSync(options.outPath, json);
+  } else {
+    process.stdout.write(json);
+  }
+  return exitCode;
+}
+async function main() {
+  const exitCode = await runAuditCli();
+  process.exit(exitCode);
+}
+if (process.argv[1] && fileURLToPath(import.meta.url) === path4.resolve(process.argv[1])) {
+  void main();
+}
+
+export { parseAuditArgs, runAuditCli };
+//# sourceMappingURL=audit.js.map
+//# sourceMappingURL=audit.js.map