@xndrjs/i18n 0.2.0-alpha.0

package/src/codegen/emit/dictionary-schema-file.ts

@@ -0,0 +1,129 @@
+import type { VariableSpec } from "../../icu/extract-variables.js";
+import { GENERATED_FILE_BANNER } from "../paths.js";
+import type { NamespaceEntry } from "../types.js";
+
+function formatVariableSpecObject(spec: VariableSpec): string {
+  const entries = Object.entries(spec);
+  if (entries.length === 0) {
+    return "{}";
+  }
+
+  const lines = entries.map(
+    ([name, type]) => `      ${JSON.stringify(name)}: ${JSON.stringify(type)},`
+  );
+  return `{\n${lines.join("\n")}\n    }`;
+}
+
+export function formatDictionarySpecBlock(
+  isSingle: boolean,
+  entries: NamespaceEntry[],
+  argsSpecByNamespace: Record<string, Record<string, VariableSpec>>
+): string {
+  if (isSingle) {
+    const onlyNamespace = entries[0]!.namespace;
+    const argsByKey = argsSpecByNamespace[onlyNamespace] ?? {};
+    const requiredKeys = Object.keys(argsByKey)
+      .map((key) => JSON.stringify(key))
+      .join(", ");
+    const argsLines = Object.entries(argsByKey)
+      .map(([key, spec]) => `    ${JSON.stringify(key)}: ${formatVariableSpecObject(spec)},`)
+      .join("\n");
+
+    return (
+      `export const DICTIONARY_SPEC = {\n` +
+      `  mode: 'single' as const,\n` +
+      `  requiredKeys: [${requiredKeys}] as const,\n` +
+      `  argsByKey: {\n${argsLines}\n  },\n` +
+      `} satisfies DictionarySpec;\n`
+    );
+  }
+
+  const requiredKeysLines = entries
+    .map((entry) => {
+      const keys = Object.keys(argsSpecByNamespace[entry.namespace] ?? {})
+        .map((key) => JSON.stringify(key))
+        .join(", ");
+      return `    ${JSON.stringify(entry.namespace)}: [${keys}] as const,`;
+    })
+    .join("\n");
+
+  const argsByKeyLines = entries
+    .map((entry) => {
+      const argsByKey = argsSpecByNamespace[entry.namespace] ?? {};
+      const keyLines = Object.entries(argsByKey)
+        .map(([key, spec]) => `      ${JSON.stringify(key)}: ${formatVariableSpecObject(spec)},`)
+        .join("\n");
+      return `    ${JSON.stringify(entry.namespace)}: {\n${keyLines}\n    },`;
+    })
+    .join("\n");
+
+  return (
+    `export const DICTIONARY_SPEC = {\n` +
+    `  mode: 'multi' as const,\n` +
+    `  requiredKeys: {\n${requiredKeysLines}\n  },\n` +
+    `  argsByKey: {\n${argsByKeyLines}\n  },\n` +
+    `} satisfies DictionarySpec;\n`
+  );
+}
+
+export function formatDictionarySchemaFile(
+  schemaTypeName: string,
+  typesModule: string,
+  isSingle: boolean,
+  dictionarySpecBlock: string
+): string {
+  const namespaceImport = isSingle
+    ? ""
+    : `  validateExternalNamespace as validateExternalNamespaceImpl,\n`;
+  const namespaceValidator = isSingle
+    ? ""
+    : `export function validateExternalNamespace<NS extends keyof ${schemaTypeName}>(\n` +
+      `  namespace: NS,\n` +
+      `  input: unknown,\n` +
+      `) {\n` +
+      `  return validateExternalNamespaceImpl<${schemaTypeName}[NS]>(\n` +
+      `    namespace as string,\n` +
+      `    input,\n` +
+      `    DICTIONARY_SPEC,\n` +
+      `  );\n` +
+      `}\n\n`;
+
+  return (
+    `${GENERATED_FILE_BANNER}` +
+    `import {\n` +
+    `  normalizeDictionary,\n` +
+    `  validateNormalizedDictionary,\n` +
+    namespaceImport +
+    `  toDictionary,\n` +
+    `  type DictionarySpec,\n` +
+    `  type NormalizedDictionary,\n` +
+    `  type ValidationResult,\n` +
+    `} from '@xndrjs/i18n/validation';\n` +
+    `import type { ${schemaTypeName} } from './${typesModule}.js';\n\n` +
+    `${dictionarySpecBlock}\n` +
+    `export function normalizeExternalDictionary(\n` +
+    `  input: unknown,\n` +
+    `): ValidationResult<NormalizedDictionary> {\n` +
+    `  return normalizeDictionary(input, DICTIONARY_SPEC);\n` +
+    `}\n\n` +
+    `export function validateNormalizedExternalDictionary(\n` +
+    `  normalized: NormalizedDictionary,\n` +
+    `): ValidationResult<NormalizedDictionary> {\n` +
+    `  return validateNormalizedDictionary(normalized, DICTIONARY_SPEC);\n` +
+    `}\n\n` +
+    `export function validateExternalDictionary(\n` +
+    `  input: unknown,\n` +
+    `): ValidationResult<${schemaTypeName}> {\n` +
+    `  const step1 = normalizeExternalDictionary(input);\n` +
+    `  if (!step1.ok) {\n` +
+    `    return step1;\n` +
+    `  }\n\n` +
+    `  const step2 = validateNormalizedExternalDictionary(step1.data);\n` +
+    `  if (!step2.ok) {\n` +
+    `    return step2;\n` +
+    `  }\n\n` +
+    `  return { ok: true, data: toDictionary(step2.data) as ${schemaTypeName} };\n` +
+    `}\n\n` +
+    namespaceValidator
+  );
+}

package/src/codegen/emit/instance-file.ts

@@ -0,0 +1,60 @@
+import { GENERATED_FILE_BANNER, toModuleBasename } from "../paths.js";
+
+export interface InstanceFileOptions {
+  isSingle: boolean;
+  hasLazy: boolean;
+  typesOutputPath: string;
+  dictionaryOutputPath: string;
+  paramsTypeName: string;
+  schemaTypeName: string;
+  localeTypeName: string;
+  localeFallbackConstName: string;
+  factoryName: string;
+  hasLocaleFallback: boolean;
+}
+
+export function formatInstanceFile(options: InstanceFileOptions): string {
+  const {
+    isSingle,
+    hasLazy,
+    typesOutputPath,
+    dictionaryOutputPath,
+    paramsTypeName,
+    schemaTypeName,
+    localeTypeName,
+    localeFallbackConstName,
+    factoryName,
+    hasLocaleFallback,
+  } = options;
+
+  const providerClass = isSingle ? "IcuTranslationProviderSingle" : "IcuTranslationProviderMulti";
+  const typesModule = toModuleBasename(typesOutputPath);
+  const dictionaryModule = toModuleBasename(dictionaryOutputPath);
+  const initialDictionaryType = hasLazy ? "InitialSchema" : schemaTypeName;
+  const initialDictionaryImport = hasLazy
+    ? `import type { ${paramsTypeName}, ${schemaTypeName}, InitialSchema } from './${typesModule}.js';\n`
+    : `import type { ${paramsTypeName}, ${schemaTypeName} } from './${typesModule}.js';\n`;
+  const providerTypeArgs = hasLocaleFallback
+    ? `${schemaTypeName}, ${paramsTypeName}, ${localeTypeName}, typeof ${localeFallbackConstName}`
+    : `${schemaTypeName}, ${paramsTypeName}`;
+  const providerOptions = hasLocaleFallback
+    ? `, {\n    localeFallback: ${localeFallbackConstName},\n  }`
+    : "";
+  const fallbackImport = hasLocaleFallback
+    ? `import { ${localeFallbackConstName}, type ${localeTypeName} } from './${typesModule}.js';\n`
+    : "";
+
+  return (
+    `${GENERATED_FILE_BANNER}` +
+    `import { ${providerClass} } from '@xndrjs/i18n';\n` +
+    `import { dictionary } from './${dictionaryModule}.js';\n` +
+    initialDictionaryImport +
+    fallbackImport +
+    `\n` +
+    `export function ${factoryName}(\n` +
+    `  initialDictionary: ${initialDictionaryType} = dictionary,\n` +
+    `) {\n` +
+    `  return new ${providerClass}<${providerTypeArgs}>(initialDictionary${providerOptions});\n` +
+    `}\n`
+  );
+}

package/src/codegen/emit/namespace-loaders-file.ts

@@ -0,0 +1,44 @@
+import { GENERATED_FILE_BANNER, toImportPath } from "../paths.js";
+import type { NamespaceEntry } from "../types.js";
+
+export function formatNamespaceLoadersFile(
+  loadersOutputPath: string,
+  lazyEntries: (NamespaceEntry & { absolutePath: string })[],
+  schemaTypeName: string,
+  typesModule: string,
+  dictionarySchemaModule: string,
+  instanceModule: string,
+  factoryName: string
+): string {
+  const loaderEntries = lazyEntries
+    .map((entry) => {
+      const importPath = toImportPath(loadersOutputPath, entry.absolutePath);
+      return `  ${entry.namespace}: () => import('${importPath}.json').then((m) => m.default),`;
+    })
+    .join("\n");
+
+  return (
+    `${GENERATED_FILE_BANNER}` +
+    `import { ensureNamespacesLoadedImpl } from '@xndrjs/i18n';\n` +
+    `import { validateExternalNamespace } from './${dictionarySchemaModule}.js';\n` +
+    `import type { ${schemaTypeName}, LazyNamespace } from './${typesModule}.js';\n` +
+    `import type { ${factoryName} } from './${instanceModule}.js';\n\n` +
+    `export const namespaceLoaders: Record<\n` +
+    `  LazyNamespace,\n` +
+    `  () => Promise<${schemaTypeName}[LazyNamespace]>\n` +
+    `> = {\n${loaderEntries}\n};\n\n` +
+    `export async function ensureNamespacesLoaded(\n` +
+    `  i18n: ReturnType<typeof ${factoryName}>,\n` +
+    `  namespaces: LazyNamespace[],\n` +
+    `): Promise<void> {\n` +
+    `  return ensureNamespacesLoadedImpl<${schemaTypeName}, LazyNamespace>(\n` +
+    `    {\n` +
+    `      provider: i18n,\n` +
+    `      resolveLoader: (namespace) => namespaceLoaders[namespace],\n` +
+    `      validate: (namespace, raw) => validateExternalNamespace(namespace, raw),\n` +
+    `    },\n` +
+    `    namespaces,\n` +
+    `  );\n` +
+    `}\n`
+  );
+}

package/src/codegen/emit/types-file.ts

@@ -0,0 +1,118 @@
+import path from "node:path";
+import { formatLocaleFallbackBlock } from "../locale-fallback.js";
+import { GENERATED_FILE_BANNER, toImportPath } from "../paths.js";
+import type { NamespaceEntry } from "../types.js";
+
+export function formatLazyTypesBlock(
+  loadOnInitSet: Set<string>,
+  lazyEntries: NamespaceEntry[],
+  schemaTypeName: string
+): string {
+  const loadOnInitUnion = [...loadOnInitSet]
+    .sort()
+    .map((namespace) => `'${namespace}'`)
+    .join(" | ");
+  const lazyUnion = lazyEntries.map((entry) => `'${entry.namespace}'`).join(" | ");
+
+  return (
+    `export type LoadOnInitNamespace = ${loadOnInitUnion};\n` +
+    `export type LazyNamespace = ${lazyUnion};\n` +
+    `export type InitialSchema = Pick<${schemaTypeName}, LoadOnInitNamespace>;\n\n`
+  );
+}
+
+export interface TypesFileOptions {
+  isSingle: boolean;
+  entries: NamespaceEntry[];
+  projectRoot: string;
+  typesOutputPath: string;
+  paramsTypeName: string;
+  schemaTypeName: string;
+  localeTypeName: string;
+  localeFallbackConstName: string;
+  localeFallbackTypeName: string;
+  localeFallback?: Record<string, string | null> | undefined;
+  paramsByNamespace: Record<string, Record<string, string>>;
+  requestLocaleUnion: string;
+  hasLazy: boolean;
+  loadOnInitSet: Set<string>;
+  lazyEntries: NamespaceEntry[];
+}
+
+export function formatTypesFile(options: TypesFileOptions): string {
+  const {
+    isSingle,
+    entries,
+    projectRoot,
+    typesOutputPath,
+    paramsTypeName,
+    schemaTypeName,
+    localeTypeName,
+    localeFallbackConstName,
+    localeFallbackTypeName,
+    localeFallback,
+    paramsByNamespace,
+    requestLocaleUnion,
+    hasLazy,
+    loadOnInitSet,
+    lazyEntries,
+  } = options;
+
+  const localeBlock = requestLocaleUnion
+    ? `${localeFallback ? formatLocaleFallbackBlock(localeFallback, localeFallbackConstName, localeFallbackTypeName) : ""}` +
+      `export type ${localeTypeName} = ${requestLocaleUnion};\n\n`
+    : "";
+
+  let paramsBlock: string;
+  let schemaBlock: string;
+
+  if (isSingle) {
+    const onlyNamespace = entries[0]!.namespace;
+    const keyTypes = paramsByNamespace[onlyNamespace] ?? {};
+    const paramsLines = Object.entries(keyTypes)
+      .map(([key, type]) => `  ${key}: ${type};`)
+      .join("\n");
+
+    paramsBlock = `export type ${paramsTypeName} = {\n${paramsLines}\n};`;
+
+    const importPath = toImportPath(
+      typesOutputPath,
+      path.resolve(projectRoot, entries[0]!.filePath)
+    );
+    schemaBlock = `export type ${schemaTypeName} = typeof import('${importPath}.json');`;
+  } else {
+    const namespaceBlocks = entries
+      .map((entry) => {
+        const keyTypes = paramsByNamespace[entry.namespace] ?? {};
+        const lines = Object.entries(keyTypes)
+          .map(([key, type]) => `    ${key}: ${type};`)
+          .join("\n");
+        return `  ${entry.namespace}: {\n${lines}\n  };`;
+      })
+      .join("\n");
+
+    paramsBlock = `export type ${paramsTypeName} = {\n${namespaceBlocks}\n};`;
+
+    const schemaLines = entries
+      .map((entry) => {
+        const importPath = toImportPath(typesOutputPath, path.resolve(projectRoot, entry.filePath));
+        return `  ${entry.namespace}: typeof import('${importPath}.json');`;
+      })
+      .join("\n");
+
+    schemaBlock = `export type ${schemaTypeName} = {\n${schemaLines}\n};`;
+  }
+
+  const lazyTypesBlock = hasLazy
+    ? formatLazyTypesBlock(loadOnInitSet, lazyEntries, schemaTypeName)
+    : "";
+
+  return (
+    `${GENERATED_FILE_BANNER}` +
+    `export const I18N_MODE = '${isSingle ? "single" : "multi"}' as const;\n\n` +
+    `${localeBlock}` +
+    `${paramsBlock}\n\n` +
+    `${schemaBlock}\n` +
+    `${lazyTypesBlock}`
+  );
+}