@xndrjs/i18n 0.7.0 → 0.8.0

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

@@ -8,27 +8,19 @@ import { GENERATED_FILE_BANNER } from "../paths.js";
 import type { NamespaceEntry } from "../types.js";
 
 /**
- * Emits the generated `i18n-types.generated.ts` module: schema, params, locale/area
- * unions, fallback constants, and lazy-load type aliases.
+ * Emits lazy-load type aliases. Every namespace is lazy; `InitialSchema` is empty
+ * (cold start / hydrate via `resources` only).
  */
-export function formatLazyTypesBlock(
-  loadOnInitSet: Set<string>,
-  lazyEntries: NamespaceEntry[],
-  schemaTypeName: string
-): string {
-  const loadOnInitUnion =
-    loadOnInitSet.size > 0
-      ? [...loadOnInitSet]
-          .sort()
-          .map((namespace) => `'${namespace}'`)
-          .join(" | ")
+export function formatLazyTypesBlock(lazyEntries: NamespaceEntry[]): string {
+  const lazyUnion =
+    lazyEntries.length > 0
+      ? lazyEntries.map((entry) => `'${entry.namespace}'`).join(" | ")
       : "never";
-  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`
+    `/** Empty cold-start schema — namespaces arrive via \`namespaceLoaders\`. */\n` +
+    `export type InitialSchema = Record<string, never>;\n\n`
   );
 }
 
@@ -40,7 +32,6 @@ export function formatLocaleTemplateType(localeTypeName: string, hasLocaleUnion:
 }
 
 export interface TypesFileOptions {
-  isSingle: boolean;
   entries: NamespaceEntry[];
   projectRoot: string;
   typesOutputPath: string;
@@ -51,19 +42,18 @@ export interface TypesFileOptions {
   localeFallbackTypeName: string;
   localeFallback?: Record<string, string | null> | undefined;
   paramsByNamespace: Record<string, Record<string, string>>;
-  requestLocaleUnion: string;
+  /** Sorted request locales — emits `ProjectLocales` const + `ProjectLocale` type. */
+  requestLocales: readonly string[];
   deliveryAreaTypeName?: string;
-  deliveryAreaUnion?: string;
+  /** Sorted delivery area names — emits `ProjectDeliveryAreas` const + type. */
+  deliveryAreaNames?: readonly string[];
   deliveryArtifacts?: DeliveryArtifactsMap;
   localeDeliveryAreaConstName?: string;
-  hasLazy: boolean;
-  loadOnInitSet: Set<string>;
   lazyEntries: NamespaceEntry[];
 }
 
 export function formatTypesFile(options: TypesFileOptions): string {
   const {
-    isSingle,
     entries,
     paramsTypeName,
     schemaTypeName,
@@ -72,27 +62,32 @@ export function formatTypesFile(options: TypesFileOptions): string {
     localeFallbackTypeName,
     localeFallback,
     paramsByNamespace,
-    requestLocaleUnion,
+    requestLocales,
     deliveryAreaTypeName,
-    deliveryAreaUnion,
+    deliveryAreaNames,
     deliveryArtifacts,
     localeDeliveryAreaConstName = "LOCALE_DELIVERY_AREA",
-    hasLazy,
-    loadOnInitSet,
     lazyEntries,
   } = options;
 
-  const hasLocaleUnion = Boolean(requestLocaleUnion);
+  const hasLocaleUnion = requestLocales.length > 0;
   const localeTemplateType = formatLocaleTemplateType(localeTypeName, hasLocaleUnion);
+  const localesConstName = `${localeTypeName}s`;
 
-  const localeBlock = requestLocaleUnion
+  const localeBlock = hasLocaleUnion
     ? `${localeFallback ? formatLocaleFallbackBlock(localeFallback, localeFallbackConstName, localeFallbackTypeName) : ""}` +
-      `export type ${localeTypeName} = ${requestLocaleUnion};\n\n`
+      `export const ${localesConstName} = [${requestLocales.map((locale) => JSON.stringify(locale)).join(", ")}] as const;\n` +
+      `export type ${localeTypeName} = (typeof ${localesConstName})[number];\n\n`
     : "";
 
+  const deliveryAreasConstName = deliveryAreaTypeName ? `${deliveryAreaTypeName}s` : undefined;
   const deliveryAreaBlock =
-    deliveryAreaTypeName && deliveryAreaUnion
-      ? `export type ${deliveryAreaTypeName} = ${deliveryAreaUnion};\n\n` +
+    deliveryAreaTypeName &&
+    deliveryAreasConstName &&
+    deliveryAreaNames &&
+    deliveryAreaNames.length > 0
+      ? `export const ${deliveryAreasConstName} = [${deliveryAreaNames.map((area) => JSON.stringify(area)).join(", ")}] as const;\n` +
+        `export type ${deliveryAreaTypeName} = (typeof ${deliveryAreasConstName})[number];\n\n` +
         (deliveryArtifacts
           ? formatDeliveryArtifactsBlock(
               deliveryArtifacts,
@@ -109,56 +104,35 @@ export function formatTypesFile(options: TypesFileOptions): string {
           : "")
       : "";
 
-  let paramsBlock: string;
-  let schemaBlock: string;
+  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");
 
-  if (isSingle) {
-    const onlyNamespace = entries[0]!.namespace;
-    const keyTypes = paramsByNamespace[onlyNamespace] ?? {};
-    const paramsLines = Object.entries(keyTypes)
-      .map(([key, type]) => `  ${key}: ${type};`)
-      .join("\n");
+  const paramsBlock = `export type ${paramsTypeName} = {\n${namespaceBlocks}\n};`;
 
-    paramsBlock = `export type ${paramsTypeName} = {\n${paramsLines}\n};`;
+  const schemaLines = entries
+    .map((entry) => {
+      const keyTypes = paramsByNamespace[entry.namespace] ?? {};
+      const lines = Object.keys(keyTypes)
+        .map((key) => `    ${key}: ${localeTemplateType};`)
+        .join("\n");
+      return `  ${entry.namespace}: {\n${lines}\n  };`;
+    })
+    .join("\n");
 
-    const schemaLines = Object.keys(keyTypes)
-      .map((key) => `  ${key}: ${localeTemplateType};`)
-      .join("\n");
+  const schemaBlock = `export type ${schemaTypeName} = {\n${schemaLines}\n};`;
 
-    schemaBlock = `export type ${schemaTypeName} = {\n${schemaLines}\n};`;
-  } 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 keyTypes = paramsByNamespace[entry.namespace] ?? {};
-        const lines = Object.keys(keyTypes)
-          .map((key) => `    ${key}: ${localeTemplateType};`)
-          .join("\n");
-        return `  ${entry.namespace}: {\n${lines}\n  };`;
-      })
-      .join("\n");
-
-    schemaBlock = `export type ${schemaTypeName} = {\n${schemaLines}\n};`;
-  }
-
-  const lazyTypesBlock = hasLazy
-    ? formatLazyTypesBlock(loadOnInitSet, lazyEntries, schemaTypeName)
-    : "";
+  const lazyTypesBlock = formatLazyTypesBlock(lazyEntries);
 
   return (
     `${GENERATED_FILE_BANNER}` +
-    `export const I18N_MODE = '${isSingle ? "single" : "multi"}' as const;\n\n` +
+    `export const I18N_MODE = 'multi' as const;\n\n` +
     `${localeBlock}` +
     `${deliveryAreaBlock}` +
     `${paramsBlock}\n\n` +