@xndrjs/i18n 0.6.1 → 0.7.0

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

@@ -27,7 +27,6 @@ describe("formatDictionaryFile", () => {
 
     expect(output).toContain("export const defaultDictionary: InitialSchema");
     expect(output).toContain("defaultNs");
-    expect(output).not.toContain("defaultDictionaryFor");
   });
 
   it("emits an empty module when all namespaces are lazy in split mode (multi)", () => {
@@ -100,8 +99,6 @@ describe("formatDictionaryFile", () => {
       "export function defaultDictionaryFor(locale: AppLocale): InitialSchema"
     );
     expect(output).toContain("return {\n    default: defaultByLocale[locale],\n  };");
-    expect(output).not.toContain("export const defaultDictionary");
-    expect(output).not.toContain("billingEn");
   });
 
   it("emits defaultDictionaryFor with per-locale imports in split mode (single)", () => {
@@ -136,7 +133,6 @@ describe("formatDictionaryFile", () => {
     );
     expect(output).toContain("export function defaultDictionaryFor(locale: AppLocale): AppSchema");
     expect(output).toContain("return translationsByLocale[locale];");
-    expect(output).not.toContain("export const defaultDictionary");
   });
 
   it("emits defaultDictionaryFor with per-area imports in custom mode (multi)", () => {
@@ -178,8 +174,6 @@ describe("formatDictionaryFile", () => {
       "export function defaultDictionaryFor(area: AppDeliveryArea): InitialSchema"
     );
     expect(output).toContain("return {\n    default: defaultByArea[area],\n  };");
-    expect(output).not.toContain("export const defaultDictionary");
-    expect(output).not.toContain("billingEu");
   });
 
   it("emits defaultDictionaryFor with per-area imports in custom mode (single)", () => {
@@ -217,6 +211,5 @@ describe("formatDictionaryFile", () => {
       "export function defaultDictionaryFor(area: AppDeliveryArea): AppSchema"
     );
     expect(output).toContain("return translationsByArea[area];");
-    expect(output).not.toContain("export const defaultDictionary");
   });
 });

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

@@ -79,58 +79,71 @@ export function formatDictionarySchemaFile(
   importExtension: ImportExtension
 ): string {
   const typesImport = toRelativeModuleImport(typesModule, importExtension);
-  const namespaceImport = isSingle
-    ? ""
-    : `  validateExternalNamespace as validateExternalNamespaceCore,\n`;
-  const namespaceValidator = isSingle
-    ? ""
-    : `export function validateExternalNamespace<NS extends keyof ${schemaTypeName}>(\n` +
-      `  namespace: NS,\n` +
-      `  input: unknown,\n` +
-      `) {\n` +
-      `  return validateExternalNamespaceCore<${schemaTypeName}[NS]>(\n` +
-      `    namespace as string,\n` +
-      `    input,\n` +
-      `    DICTIONARY_SPEC,\n` +
-      `  );\n` +
-      `}\n\n`;
+  const partialImport = isSingle
+    ? `  validateExternalDictionaryPartial as validateExternalDictionaryPartialCore,\n` +
+      `  validateExternalKey as validateExternalKeyCore,\n`
+    : `  validateExternalDictionaryPartial as validateExternalDictionaryPartialCore,\n` +
+      `  validateExternalNamespacePartial as validateExternalNamespacePartialCore,\n` +
+      `  validateExternalKey as validateExternalKeyCore,\n`;
+
+  const singleKeyValidator =
+    `export function validateExternalKey<K extends keyof ${schemaTypeName}>(\n` +
+    `  key: K,\n` +
+    `  input: unknown,\n` +
+    `): ValidationResult<Pick<${schemaTypeName}, K>> {\n` +
+    `  return validateExternalKeyCore<Pick<${schemaTypeName}, K>>(\n` +
+    `    key as string,\n` +
+    `    input,\n` +
+    `    DICTIONARY_SPEC,\n` +
+    `  );\n` +
+    `}\n\n`;
+
+  const multiValidators =
+    `export function validateExternalNamespacePartial<NS extends keyof ${schemaTypeName}>(\n` +
+    `  namespace: NS,\n` +
+    `  input: unknown,\n` +
+    `): ValidationResult<Partial<${schemaTypeName}[NS]>> {\n` +
+    `  return validateExternalNamespacePartialCore<Partial<${schemaTypeName}[NS]>>(\n` +
+    `    namespace as string,\n` +
+    `    input,\n` +
+    `    DICTIONARY_SPEC,\n` +
+    `  );\n` +
+    `}\n\n` +
+    `export function validateExternalKey<\n` +
+    `  NS extends keyof ${schemaTypeName},\n` +
+    `  K extends keyof ${schemaTypeName}[NS],\n` +
+    `>(\n` +
+    `  namespace: NS,\n` +
+    `  key: K,\n` +
+    `  input: unknown,\n` +
+    `): ValidationResult<Pick<${schemaTypeName}[NS], K>> {\n` +
+    `  return validateExternalKeyCore<Pick<${schemaTypeName}[NS], K>>(\n` +
+    `    namespace as string,\n` +
+    `    key as string,\n` +
+    `    input,\n` +
+    `    DICTIONARY_SPEC,\n` +
+    `  );\n` +
+    `}\n\n`;
+
+  const keyValidator = isSingle ? singleKeyValidator : multiValidators;
 
   return (
     `${GENERATED_FILE_BANNER}` +
     `import {\n` +
-    `  normalizeDictionary,\n` +
-    `  validateNormalizedDictionary,\n` +
-    namespaceImport +
-    `  toDictionary,\n` +
+    partialImport +
     `  type DictionarySpec,\n` +
-    `  type NormalizedDictionary,\n` +
     `  type ValidationResult,\n` +
     `} from '@xndrjs/i18n/validation';\n` +
     `import type { ${schemaTypeName} } from '${typesImport}';\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` +
+    `export function validateExternalDictionaryPartial(\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` +
+    `): ValidationResult<Partial<${schemaTypeName}>> {\n` +
+    `  return validateExternalDictionaryPartialCore<Partial<${schemaTypeName}>>(\n` +
+    `    input,\n` +
+    `    DICTIONARY_SPEC,\n` +
+    `  );\n` +
     `}\n\n` +
-    namespaceValidator
+    keyValidator
   );
 }

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

@@ -0,0 +1,88 @@
+import { describe, expect, it } from "vitest";
+import { formatInstanceFile, type InstanceFileOptions } from "./instance-file.js";
+
+function baseOptions(overrides: Partial<InstanceFileOptions> = {}): InstanceFileOptions {
+  return {
+    isSingle: false,
+    hasLazy: false,
+    typesOutputPath: "src/i18n/i18n-types.generated.ts",
+    paramsTypeName: "AppParams",
+    schemaTypeName: "AppSchema",
+    localeTypeName: "AppLocale",
+    localeFallbackConstName: "LOCALE_FALLBACK",
+    factoryName: "createI18n",
+    hasLocaleFallback: true,
+    hasLocaleType: true,
+    namespaceNames: ["default", "billing"],
+    importExtension: "none",
+    delivery: "canonical",
+    ...overrides,
+  };
+}
+
+function packageImportBlock(output: string): string {
+  const match = output.match(/import \{([\s\S]*?)\} from '@xndrjs\/i18n'/);
+  return match?.[1] ?? "";
+}
+
+describe("formatInstanceFile package imports", () => {
+  it("emits only single-scope symbols for single eager projects", () => {
+    const imports = packageImportBlock(formatInstanceFile(baseOptions({ isSingle: true })));
+
+    expect(imports).toContain("IcuTranslationProviderSingle");
+    expect(imports).toContain("projectNamespaceLocalesCore");
+    expect(imports).toContain("type I18nScopeSingle");
+    expect(imports).toContain("type OnMissingTranslation");
+    expect(imports).not.toContain("createI18nBuilder");
+    expect(imports).not.toContain("createI18nMultiBuilder");
+    expect(imports).not.toContain("I18nBuilderMultiInitial");
+    expect(imports).not.toContain("I18nBuilderMultiOptions");
+    expect(imports).not.toContain("I18nBuilderMultiPartitioned");
+    expect(imports).not.toContain("I18nScopeMulti");
+    expect(imports).not.toContain("projectDictionaryLocalesCore");
+  });
+
+  it("emits multi eager scope symbols without builder imports", () => {
+    const imports = packageImportBlock(formatInstanceFile(baseOptions()));
+
+    expect(imports).toContain("IcuTranslationProviderMulti");
+    expect(imports).toContain("projectDictionaryLocalesCore");
+    expect(imports).toContain("type I18nScopeMulti");
+    expect(imports).not.toContain("createI18nMultiBuilder");
+    expect(imports).not.toContain("I18nBuilderMultiInitial");
+    expect(imports).not.toContain("I18nScopeSingle");
+  });
+
+  it("emits lazy multi builder symbols instead of I18nScopeMulti", () => {
+    const imports = packageImportBlock(
+      formatInstanceFile(
+        baseOptions({
+          hasLazy: true,
+          namespaceLoadersOutputPath: "src/i18n/namespace-loaders.generated.ts",
+        })
+      )
+    );
+
+    expect(imports).toContain("createI18nMultiBuilder");
+    expect(imports).toContain("type I18nBuilderMultiInitial");
+    expect(imports).toContain("type I18nBuilderMultiOptions");
+    expect(imports).not.toContain("type I18nScopeMulti");
+    expect(imports).not.toContain("createI18nBuilder");
+    expect(imports).not.toContain("I18nBuilderMultiPartitioned");
+  });
+
+  it("includes delivery-area projection helpers when delivery is custom", () => {
+    const imports = packageImportBlock(
+      formatInstanceFile(
+        baseOptions({
+          delivery: "custom",
+          deliveryAreaTypeName: "AppDeliveryArea",
+          deliveryArtifactsTypeName: "AppDeliveryArtifacts",
+        })
+      )
+    );
+
+    expect(imports).toContain("projectNamespaceForDeliveryAreaCore");
+    expect(imports).toContain("projectDictionaryForDeliveryAreaCore");
+  });
+});

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

@@ -10,6 +10,7 @@ export interface InstanceFileOptions {
   isSingle: boolean;
   hasLazy: boolean;
   typesOutputPath: string;
+  namespaceLoadersOutputPath?: string;
   paramsTypeName: string;
   schemaTypeName: string;
   localeTypeName: string;
@@ -20,6 +21,8 @@ export interface InstanceFileOptions {
   namespaceNames: string[];
   importExtension: ImportExtension;
   delivery: DeliveryMode;
+  deliveryAreaTypeName?: string;
+  deliveryArtifactsTypeName?: string;
 }
 
 export function formatInstanceFile(options: InstanceFileOptions): string {
@@ -27,6 +30,7 @@ export function formatInstanceFile(options: InstanceFileOptions): string {
     isSingle,
     hasLazy,
     typesOutputPath,
+    namespaceLoadersOutputPath,
     paramsTypeName,
     schemaTypeName,
     localeTypeName,
@@ -37,16 +41,28 @@ export function formatInstanceFile(options: InstanceFileOptions): string {
     namespaceNames,
     importExtension,
     delivery,
+    deliveryAreaTypeName,
+    deliveryArtifactsTypeName,
   } = options;
 
   const emitDeliveryAreaHelpers = delivery === "custom";
   const providerClass = isSingle ? "IcuTranslationProviderSingle" : "IcuTranslationProviderMulti";
   const typesModule = toModuleBasename(typesOutputPath);
   const typesImport = toRelativeModuleImport(typesModule, importExtension);
+  const loadersModule = namespaceLoadersOutputPath
+    ? toModuleBasename(namespaceLoadersOutputPath)
+    : null;
+  const loadersImport =
+    loadersModule && namespaceLoadersOutputPath
+      ? toRelativeModuleImport(loadersModule, importExtension)
+      : null;
   const dictionaryParamType = hasLazy ? "InitialSchema" : schemaTypeName;
-  const schemaTypesImport = hasLazy
-    ? `import type { ${paramsTypeName}, ${schemaTypeName}, InitialSchema } from '${typesImport}';\n`
-    : `import type { ${paramsTypeName}, ${schemaTypeName} } from '${typesImport}';\n`;
+  const schemaTypesImport =
+    hasLazy && delivery === "custom" && deliveryAreaTypeName && deliveryArtifactsTypeName
+      ? `import type { ${paramsTypeName}, ${schemaTypeName}, InitialSchema, ${deliveryAreaTypeName}, ${deliveryArtifactsTypeName} } from '${typesImport}';\n`
+      : hasLazy
+        ? `import type { ${paramsTypeName}, ${schemaTypeName}, InitialSchema } from '${typesImport}';\n`
+        : `import type { ${paramsTypeName}, ${schemaTypeName} } from '${typesImport}';\n`;
   const providerTypeArgs = hasLocaleFallback
     ? `${schemaTypeName}, ${paramsTypeName}, ${localeTypeName}, typeof ${localeFallbackConstName}`
     : `${schemaTypeName}, ${paramsTypeName}`;
@@ -60,7 +76,12 @@ export function formatInstanceFile(options: InstanceFileOptions): string {
     : "";
   const localesParamType = hasLocaleType ? `readonly ${localeTypeName}[]` : "readonly string[]";
   const fallbackArg = hasLocaleFallback ? `, ${localeFallbackConstName}` : "";
-  const coreImports = formatCoreImports(isSingle, emitDeliveryAreaHelpers);
+  const packageImports = formatPackageImports(
+    providerClass,
+    isSingle,
+    hasLazy,
+    emitDeliveryAreaHelpers
+  );
   const projectionBlock = isSingle
     ? formatSingleProjectionBlock(
         schemaTypeName,
@@ -76,36 +97,162 @@ export function formatInstanceFile(options: InstanceFileOptions): string {
         emitDeliveryAreaHelpers
       );
 
+  const createFactoryBlock = formatCreateI18nFactory({
+    isSingle,
+    hasLazy,
+    hasLocaleFallback,
+    providerClass,
+    providerTypeArgs,
+    providerOptions,
+    factoryName,
+    dictionaryParamType,
+    schemaTypeName,
+    paramsTypeName,
+    localeTypeName,
+    namespaceNames,
+    loadersImport,
+    delivery,
+    ...(deliveryAreaTypeName !== undefined ? { deliveryAreaTypeName } : {}),
+    ...(deliveryArtifactsTypeName !== undefined ? { deliveryArtifactsTypeName } : {}),
+  });
+
   return (
     `${GENERATED_FILE_BANNER}` +
-    `import { ${providerClass}, ${coreImports}, type OnMissingTranslation } from '@xndrjs/i18n';\n` +
+    `import {\n` +
+    `  ${packageImports},\n` +
+    `} from '@xndrjs/i18n';\n` +
     schemaTypesImport +
     typesImportLine +
+    (hasLazy && loadersImport ? `import { namespaceLoaders } from '${loadersImport}';\n` : "") +
     `\n` +
+    createFactoryBlock +
+    projectionBlock
+  );
+}
+
+function formatCreateI18nFactory(options: {
+  isSingle: boolean;
+  hasLazy: boolean;
+  hasLocaleFallback: boolean;
+  providerClass: string;
+  providerTypeArgs: string;
+  providerOptions: string;
+  factoryName: string;
+  dictionaryParamType: string;
+  schemaTypeName: string;
+  paramsTypeName: string;
+  localeTypeName: string;
+  namespaceNames: string[];
+  loadersImport: string | null;
+  delivery: DeliveryMode;
+  deliveryAreaTypeName?: string;
+  deliveryArtifactsTypeName?: string;
+}): string {
+  const {
+    isSingle,
+    hasLazy,
+    providerClass,
+    providerTypeArgs,
+    providerOptions,
+    factoryName,
+    dictionaryParamType,
+    schemaTypeName,
+    paramsTypeName,
+    localeTypeName,
+    namespaceNames,
+    loadersImport,
+    delivery,
+    deliveryAreaTypeName,
+    deliveryArtifactsTypeName,
+  } = options;
+
+  if (isSingle) {
+    return (
+      `export function ${factoryName}(\n` +
+      `  dictionary: ${dictionaryParamType},\n` +
+      `  options?: { onMissing?: OnMissingTranslation },\n` +
+      `): I18nScopeSingle<${schemaTypeName}, ${paramsTypeName}, ${localeTypeName}> {\n` +
+      `  return new ${providerClass}<${providerTypeArgs}>(dictionary${providerOptions}).toScope();\n` +
+      `}\n`
+    );
+  }
+
+  if (!hasLazy) {
+    const namespacesLiteral = `[${namespaceNames
+      .slice()
+      .sort()
+      .map((ns) => JSON.stringify(ns))
+      .join(", ")}] as const`;
+    return (
+      `export function ${factoryName}(\n` +
+      `  dictionary: ${dictionaryParamType},\n` +
+      `  options?: { onMissing?: OnMissingTranslation },\n` +
+      `): I18nScopeMulti<${schemaTypeName}, ${paramsTypeName}, ${localeTypeName}> {\n` +
+      `  const engine = new ${providerClass}<${providerTypeArgs}>(dictionary${providerOptions});\n` +
+      `  return engine.toScope({ namespaces: ${namespacesLiteral} });\n` +
+      `}\n`
+    );
+  }
+
+  if (!loadersImport) {
+    throw new Error("[Codegen Error] namespaceLoadersOutputPath is required when hasLazy is true.");
+  }
+
+  const builderReturnType =
+    delivery === "custom" && deliveryAreaTypeName && deliveryArtifactsTypeName
+      ? `I18nBuilderMultiInitial<${schemaTypeName}, ${paramsTypeName}, ${localeTypeName}, ${localeTypeName}, ${deliveryAreaTypeName}, ${deliveryArtifactsTypeName}>`
+      : `I18nBuilderMultiInitial<${schemaTypeName}, ${paramsTypeName}, ${localeTypeName}>`;
+
+  const multiBuilderTypeArgs =
+    delivery === "custom" && deliveryAreaTypeName && deliveryArtifactsTypeName
+      ? `<${schemaTypeName}, ${paramsTypeName}, ${localeTypeName}, ${deliveryAreaTypeName}, ${deliveryArtifactsTypeName}>`
+      : `<${schemaTypeName}, ${paramsTypeName}, ${localeTypeName}>`;
+
+  return (
     `export function ${factoryName}(\n` +
     `  dictionary: ${dictionaryParamType},\n` +
     `  options?: { onMissing?: OnMissingTranslation },\n` +
-    `) {\n` +
-    `  return new ${providerClass}<${providerTypeArgs}>(dictionary${providerOptions});\n` +
-    `}\n` +
-    projectionBlock
+    `): ${builderReturnType} {\n` +
+    `  const engine = new ${providerClass}<${providerTypeArgs}>(dictionary${providerOptions});\n` +
+    `  return createI18nMultiBuilder${multiBuilderTypeArgs}(engine, {\n` +
+    `    namespaceLoaders,\n` +
+    `  } as I18nBuilderMultiOptions<${schemaTypeName}, ${localeTypeName}>);\n` +
+    `}\n`
   );
 }
 
-function formatCoreImports(isSingle: boolean, emitDeliveryAreaHelpers: boolean): string {
+function formatPackageImports(
+  providerClass: string,
+  isSingle: boolean,
+  hasLazy: boolean,
+  emitDeliveryAreaHelpers: boolean
+): string {
+  const imports = [providerClass];
+
   if (isSingle) {
-    const imports = ["projectNamespaceLocalesCore"];
+    imports.push("projectNamespaceLocalesCore");
     if (emitDeliveryAreaHelpers) {
       imports.push("projectNamespaceForDeliveryAreaCore");
     }
-    return imports.join(", ");
+    imports.push("type I18nScopeSingle");
+  } else {
+    imports.push("projectNamespaceLocalesCore", "projectDictionaryLocalesCore");
+    if (emitDeliveryAreaHelpers) {
+      imports.push("projectNamespaceForDeliveryAreaCore", "projectDictionaryForDeliveryAreaCore");
+    }
+    if (hasLazy) {
+      imports.push(
+        "createI18nMultiBuilder",
+        "type I18nBuilderMultiInitial",
+        "type I18nBuilderMultiOptions"
+      );
+    } else {
+      imports.push("type I18nScopeMulti");
+    }
   }
 
-  const imports = ["projectNamespaceLocalesCore", "projectDictionaryLocalesCore"];
-  if (emitDeliveryAreaHelpers) {
-    imports.push("projectNamespaceForDeliveryAreaCore", "projectDictionaryForDeliveryAreaCore");
-  }
-  return imports.join(", ");
+  imports.push("type OnMissingTranslation");
+  return imports.join(",\n  ");
 }
 
 function formatSingleProjectionBlock(

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

@@ -31,8 +31,6 @@ describe("formatNamespaceLoadersFile", () => {
     expect(output).toContain(
       "billing: () => import('./translations/billing.json').then((m) => m.default),"
     );
-    expect(output).not.toContain("AppLocale");
-    expect(output).not.toContain("ensureNamespacesLoadedForLocale");
   });
 
   it("emits ns(locale) loaders in split mode", () => {
@@ -97,18 +95,13 @@ describe("formatNamespaceLoadersFile", () => {
       "return import('./generated/translations/billing.en.json').then((m) => m.default);"
     );
     expect(output).toContain("user: (locale) => {");
-    expect(output).not.toContain("billing: {");
-    expect(output).not.toContain("import('./translations/billing.json')");
-    expect(output).toContain("export async function ensureNamespacesLoadedForLocale(");
-    expect(output).toContain("i18n.mergeNamespace(namespace,");
-    expect(output).toContain("i18n: I18nMultiInstance,");
     expect(output).toContain(
-      'namespaces: readonly LazyNamespace[] = ["billing", "default", "user"] as const,'
+      'export const defaultLazyNamespaces = ["billing", "default", "user"] as const;'
     );
     expect(output.match(/from '\.\/i18n-types\.generated'/g)?.length).toBe(1);
   });
 
-  it("emits mergeAll helper for single mode in split delivery", () => {
+  it("emits locale-scoped loaders for single mode in split delivery", () => {
     const output = formatNamespaceLoadersFile({
       loadersOutputPath,
       lazyEntries: [
@@ -138,11 +131,7 @@ describe("formatNamespaceLoadersFile", () => {
     });
 
     expect(output).toContain("[K in LazyNamespace]: (locale: AppLocale) => Promise<AppSchema>;");
-    expect(output).toContain("import type { TranslationProviderSingle } from '@xndrjs/i18n';");
-    expect(output).toContain("type I18nSingleInstance = TranslationProviderSingle<");
-    expect(output).toContain("export async function ensureNamespacesLoadedForLocale(");
-    expect(output).toContain("i18n.mergeAll(await namespaceLoaders[namespace](locale));");
-    expect(output).not.toContain("mergeNamespace");
+    expect(output).toContain('export const defaultLazyNamespaces = ["default"] as const;');
   });
 
   it("throws when a split path is missing", () => {
@@ -226,11 +215,8 @@ describe("formatNamespaceLoadersFile", () => {
     expect(output).toContain(
       "return import('./generated/translations/billing.eu.json').then((m) => m.default);"
     );
-    expect(output).not.toContain("import('./translations/billing.json')");
-    expect(output).toContain("export async function ensureNamespacesLoadedForArea(");
-    expect(output).toContain("i18n.mergeNamespace(namespace,");
     expect(output).toContain(
-      'namespaces: readonly LazyNamespace[] = ["billing", "default"] as const,'
+      'export const defaultLazyNamespaces = ["billing", "default"] as const;'
     );
   });
 

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

@@ -30,49 +30,6 @@ interface PartitionedNamespaceLoadersParams {
   partitionKeys: readonly string[];
   paramName: string;
   paramTypeName: string;
-  loadNamespacesFunctionName: string;
-}
-
-function formatI18nMultiInstanceType(options: NamespaceLoadersFileOptions): string {
-  const { schemaTypeName, paramsTypeName, localeTypeName } = options;
-
-  return `TranslationProviderMulti<${schemaTypeName}, ${paramsTypeName}, ${localeTypeName}>`;
-}
-
-function formatI18nSingleInstanceType(options: NamespaceLoadersFileOptions): string {
-  const { schemaTypeName, paramsTypeName, localeTypeName } = options;
-
-  return `TranslationProviderSingle<${schemaTypeName}, ${paramsTypeName}, ${localeTypeName}>`;
-}
-
-function formatLoadNamespacesHelper(
-  options: NamespaceLoadersFileOptions,
-  { paramName, paramTypeName, loadNamespacesFunctionName }: PartitionedNamespaceLoadersParams
-): string {
-  const { lazyEntries, isSingle } = options;
-  const defaultNamespaces = formatDefaultNamespacesLiteral(lazyEntries);
-  const i18nInstanceType = isSingle
-    ? formatI18nSingleInstanceType(options)
-    : formatI18nMultiInstanceType(options);
-  const mergeCall = isSingle
-    ? `i18n.mergeAll(await namespaceLoaders[namespace](${paramName}))`
-    : `i18n.mergeNamespace(namespace, await namespaceLoaders[namespace](${paramName}))`;
-  const i18nTypeAlias = isSingle ? "I18nSingleInstance" : "I18nMultiInstance";
-
-  return (
-    `\ntype ${i18nTypeAlias} = ${i18nInstanceType};\n\n` +
-    `export async function ${loadNamespacesFunctionName}(\n` +
-    `  i18n: ${i18nTypeAlias},\n` +
-    `  ${paramName}: ${paramTypeName},\n` +
-    `  namespaces: readonly LazyNamespace[] = [${defaultNamespaces}] as const,\n` +
-    `): Promise<void> {\n` +
-    `  await Promise.all(\n` +
-    `    namespaces.map(async (namespace) => {\n` +
-    `      ${mergeCall};\n` +
-    `    }),\n` +
-    `  );\n` +
-    `}\n`
-  );
 }
 
 function formatDefaultNamespacesLiteral(lazyEntries: NamespaceEntry[]): string {
@@ -91,17 +48,11 @@ function formatPartitionedTypesImport(
     options;
 
   if (isSingle) {
-    return (
-      `import type { TranslationProviderSingle } from '@xndrjs/i18n';\n` +
-      `import type { ${schemaTypeName}, LazyNamespace, ${paramTypeName}, ${localeTypeName} } from '${toRelativeModuleImport(typesModule, importExtension)}';\n\n`
-    );
+    return `import type { ${schemaTypeName}, LazyNamespace, ${paramTypeName}, ${localeTypeName} } from '${toRelativeModuleImport(typesModule, importExtension)}';\n\n`;
   }
 
   const paramTypeImport = paramTypeName === localeTypeName ? "" : `, ${paramTypeName}`;
-  return (
-    `import type { TranslationProviderMulti } from '@xndrjs/i18n';\n` +
-    `import type { ${localeTypeName}, ${paramsTypeName}, ${schemaTypeName}, LazyNamespace${paramTypeImport} } from '${toRelativeModuleImport(typesModule, importExtension)}';\n\n`
-  );
+  return `import type { ${localeTypeName}, ${paramsTypeName}, ${schemaTypeName}, LazyNamespace${paramTypeImport} } from '${toRelativeModuleImport(typesModule, importExtension)}';\n\n`;
 }
 
 function formatSwitchDefaultCase(namespace: string, paramName: string): string {
@@ -169,7 +120,8 @@ function formatPartitionedNamespaceLoadersFile(
     `export const namespaceLoaders: {\n` +
     `  [K in LazyNamespace]: (${paramName}: ${paramTypeName}) => Promise<${loaderValueType}>;\n` +
     `} = {\n${loaderEntries}\n};\n` +
-    formatLoadNamespacesHelper(options, params)
+    `\n` +
+    `export const defaultLazyNamespaces = [${formatDefaultNamespacesLiteral(lazyEntries)}] as const;\n`
   );
 }
 
@@ -204,7 +156,6 @@ export function formatNamespaceLoadersFile(options: NamespaceLoadersFileOptions)
       partitionKeys: options.requestLocales ?? [],
       paramName: "locale",
       paramTypeName: options.localeTypeName,
-      loadNamespacesFunctionName: "ensureNamespacesLoadedForLocale",
     });
   }
   if (delivery === "custom") {
@@ -215,7 +166,6 @@ export function formatNamespaceLoadersFile(options: NamespaceLoadersFileOptions)
       partitionKeys: options.deliveryAreaNames ?? [],
       paramName: "area",
       paramTypeName: options.deliveryAreaTypeName,
-      loadNamespacesFunctionName: "ensureNamespacesLoadedForArea",
     });
   }
   return formatCanonicalNamespaceLoadersFile(options);

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

@@ -37,7 +37,6 @@ describe("formatTypesFile", () => {
 
     expect(output).toContain("login_button: Partial<Record<AppLocale, string>>;");
     expect(output).toContain("invoice_summary: Partial<Record<AppLocale, string>>;");
-    expect(output).not.toContain("typeof import");
   });
 
   it("emits explicit Partial schema types for single-file mode", () => {
@@ -65,7 +64,6 @@ describe("formatTypesFile", () => {
     expect(output).toContain(
       "export type AppSchema = {\n  welcome: Partial<Record<AppLocale, string>>;\n};"
     );
-    expect(output).not.toContain("typeof import");
   });
 
   it("emits delivery area type for custom delivery", () => {