@zachhandley/ez-i18n 0.1.9 → 0.2.0

package/dist/index.js

@@ -152,8 +152,29 @@ function toRelativeImport(absolutePath, projectRoot) {
 }
 function toGlobPattern(baseDir, projectRoot) {
   const relativePath = path.relative(projectRoot, baseDir).replace(/\\/g, "/");
+  if (relativePath.startsWith("public/") || relativePath === "public") {
+    return null;
+  }
   return `/${relativePath}/**/*.json`;
 }
+function isInPublicDir(filePath, projectRoot) {
+  const relativePath = path.relative(projectRoot, filePath).replace(/\\/g, "/");
+  return relativePath.startsWith("public/") || relativePath === "public";
+}
+function toPublicUrl(filePath, projectRoot) {
+  const relativePath = path.relative(projectRoot, filePath).replace(/\\/g, "/");
+  if (relativePath.startsWith("public/")) {
+    return "/" + relativePath.slice("public/".length);
+  }
+  return "/" + relativePath;
+}
+function getLocaleBaseDirForNamespace(localeBaseDir, projectRoot) {
+  const relativePath = path.relative(projectRoot, localeBaseDir).replace(/\\/g, "/");
+  if (relativePath.startsWith("public/")) {
+    return relativePath.slice("public/".length);
+  }
+  return relativePath;
+}
 function getNamespaceFromPath(filePath, localeDir) {
   const relative2 = path.relative(localeDir, filePath);
   const withoutExt = relative2.replace(/\.json$/i, "");
@@ -261,12 +282,14 @@ function vitePlugin(config) {
         };
         for (const locale of finalLocales) {
           const files = translations[locale] || [];
+          const filesInPublic = files.length > 0 && isInPublicDir(files[0], projectRoot);
           const info = {
             locale,
             files,
-            localeBaseDir: localeBaseDirs[locale]
+            localeBaseDir: localeBaseDirs[locale],
+            isPublic: filesInPublic
           };
-          if (isDev && config.translations) {
+          if (isDev && config.translations && !filesInPublic) {
             const localeConfig = typeof config.translations === "string" ? path2.join(config.translations, locale) + "/" : config.translations[locale];
             if (localeConfig && typeof localeConfig === "string") {
               const pathType = detectPathType(localeConfig);
@@ -419,19 +442,43 @@ function generateDevTranslationsModule(translationInfo, projectRoot, pathBasedNa
   for (const [locale, info] of translationInfo) {
     if (info.files.length === 0) {
       loaderEntries.push(`  ${JSON.stringify(locale)}: async () => ({})`);
+    } else if (info.isPublic) {
+      if (pathBasedNamespacing && info.localeBaseDir) {
+        const localeBaseDirForNs = getLocaleBaseDirForNamespace(info.localeBaseDir, projectRoot);
+        const fileEntries = info.files.map((f) => {
+          const url = toPublicUrl(f, projectRoot);
+          const namespace = getNamespaceFromPath(f, info.localeBaseDir);
+          return `{ url: ${JSON.stringify(url)}, namespace: ${JSON.stringify(namespace)} }`;
+        });
+        loaderEntries.push(`  ${JSON.stringify(locale)}: async () => {
+    const fileInfos = [${fileEntries.join(", ")}];
+    const responses = await Promise.all(fileInfos.map(f => fetch(f.url).then(r => r.json())));
+    const wrapped = responses.map((content, i) => __wrapWithNamespace(fileInfos[i].namespace, content));
+    return __deepMerge({}, ...wrapped);
+  }`);
+      } else {
+        const urls = info.files.map((f) => toPublicUrl(f, projectRoot));
+        loaderEntries.push(`  ${JSON.stringify(locale)}: async () => {
+    const urls = ${JSON.stringify(urls)};
+    const responses = await Promise.all(urls.map(url => fetch(url).then(r => r.json())));
+    if (responses.length === 1) return responses[0];
+    return __deepMerge({}, ...responses);
+  }`);
+      }
     } else if (info.globPattern && pathBasedNamespacing && info.localeBaseDir) {
       const varName = `__${locale}Modules`;
-      const localeBaseDir = info.localeBaseDir.replace(/\\/g, "/");
+      const localeBaseDirForNs = getLocaleBaseDirForNamespace(info.localeBaseDir, projectRoot);
       imports.push(
         `const ${varName} = import.meta.glob(${JSON.stringify(info.globPattern)}, { eager: true, import: 'default' });`
       );
       loaderEntries.push(`  ${JSON.stringify(locale)}: async () => {
     const entries = Object.entries(${varName});
     if (entries.length === 0) return {};
-    const localeBaseDir = ${JSON.stringify(localeBaseDir)};
+    const localeBaseDir = ${JSON.stringify(localeBaseDirForNs)};
     const wrapped = entries.map(([filePath, content]) => {
-      // Extract relative path from locale base dir
-      const relativePath = filePath.replace(localeBaseDir + '/', '').replace(/\\.json$/i, '');
+      // Extract relative path from locale base dir - filePath starts with /
+      const normalizedPath = filePath.startsWith('/') ? filePath.slice(1) : filePath;
+      const relativePath = normalizedPath.replace(localeBaseDir + '/', '').replace(/\\.json$/i, '');
       const namespace = relativePath.replace(/[\\/]/g, '.').replace(/\\.index$/, '');
       return __wrapWithNamespace(namespace, content);
     });
@@ -518,6 +565,33 @@ function generateBuildTranslationsModule(translationInfo, projectRoot, pathBased
   for (const [locale, info] of translationInfo) {
     if (info.files.length === 0) {
       loaderEntries.push(`  ${JSON.stringify(locale)}: async () => ({})`);
+    } else if (info.isPublic) {
+      needsDeepMerge = info.files.length > 1;
+      if (pathBasedNamespacing && info.localeBaseDir) {
+        needsNamespaceWrapper = true;
+        const fileEntries = info.files.map((f) => {
+          const url = toPublicUrl(f, projectRoot);
+          const namespace = getNamespaceFromPath(f, info.localeBaseDir);
+          return `{ url: ${JSON.stringify(url)}, namespace: ${JSON.stringify(namespace)} }`;
+        });
+        loaderEntries.push(`  ${JSON.stringify(locale)}: async () => {
+    const fileInfos = [${fileEntries.join(", ")}];
+    const responses = await Promise.all(fileInfos.map(f => fetch(f.url).then(r => r.json())));
+    const wrapped = responses.map((content, i) => __wrapWithNamespace(fileInfos[i].namespace, content));
+    return __deepMerge({}, ...wrapped);
+  }`);
+      } else {
+        const urls = info.files.map((f) => toPublicUrl(f, projectRoot));
+        if (urls.length === 1) {
+          loaderEntries.push(`  ${JSON.stringify(locale)}: () => fetch(${JSON.stringify(urls[0])}).then(r => r.json())`);
+        } else {
+          loaderEntries.push(`  ${JSON.stringify(locale)}: async () => {
+    const urls = ${JSON.stringify(urls)};
+    const responses = await Promise.all(urls.map(url => fetch(url).then(r => r.json())));
+    return __deepMerge({}, ...responses);
+  }`);
+        }
+      }
     } else if (info.files.length === 1) {
       const relativePath = toRelativeImport(info.files[0], projectRoot);
       if (pathBasedNamespacing && info.localeBaseDir) {

package/dist/utils/index.d.ts

@@ -54,8 +54,9 @@ declare function toRelativeImport(absolutePath: string, projectRoot: string): st
 /**
  * Generate a glob pattern for import.meta.glob from a base directory.
  * In virtual modules, globs must start with '/' (project root relative).
+ * Returns null if the path is in public/ (can't use import.meta.glob for public files).
  */
-declare function toGlobPattern(baseDir: string, projectRoot: string): string;
+declare function toGlobPattern(baseDir: string, projectRoot: string): string | null;
 /**
  * Get namespace from file path relative to locale base directory.
  *

package/dist/utils/index.js

@@ -173,6 +173,9 @@ function toRelativeImport(absolutePath, projectRoot) {
 }
 function toGlobPattern(baseDir, projectRoot) {
   const relativePath = path.relative(projectRoot, baseDir).replace(/\\/g, "/");
+  if (relativePath.startsWith("public/") || relativePath === "public") {
+    return null;
+  }
   return `/${relativePath}/**/*.json`;
 }
 function getNamespaceFromPath(filePath, localeDir) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zachhandley/ez-i18n",
-  "version": "0.1.9",
+  "version": "0.2.0",
   "publishConfig": {
     "access": "public"
   },

package/src/utils/translations.ts

@@ -304,13 +304,52 @@ export function toRelativeImport(absolutePath: string, projectRoot: string): str
 /**
  * Generate a glob pattern for import.meta.glob from a base directory.
  * In virtual modules, globs must start with '/' (project root relative).
+ * Returns null if the path is in public/ (can't use import.meta.glob for public files).
  */
-export function toGlobPattern(baseDir: string, projectRoot: string): string {
+export function toGlobPattern(baseDir: string, projectRoot: string): string | null {
   const relativePath = path.relative(projectRoot, baseDir).replace(/\\/g, '/');
+  // Can't use import.meta.glob for public directory files
+  if (relativePath.startsWith('public/') || relativePath === 'public') {
+    return null;
+  }
   // Virtual modules require globs to start with '/' (project root relative)
   return `/${relativePath}/**/*.json`;
 }
 
+/**
+ * Check if an absolute path is inside the public directory
+ */
+export function isInPublicDir(filePath: string, projectRoot: string): boolean {
+  const relativePath = path.relative(projectRoot, filePath).replace(/\\/g, '/');
+  return relativePath.startsWith('public/') || relativePath === 'public';
+}
+
+/**
+ * Convert a public directory path to its served URL.
+ * public/i18n/en/common.json → /i18n/en/common.json
+ */
+export function toPublicUrl(filePath: string, projectRoot: string): string {
+  const relativePath = path.relative(projectRoot, filePath).replace(/\\/g, '/');
+  // Remove 'public/' prefix - files in public/ are served at root
+  if (relativePath.startsWith('public/')) {
+    return '/' + relativePath.slice('public/'.length);
+  }
+  return '/' + relativePath;
+}
+
+/**
+ * Get the locale base directory for namespace calculation.
+ * For public paths, strips the 'public/' prefix.
+ */
+export function getLocaleBaseDirForNamespace(localeBaseDir: string, projectRoot: string): string {
+  const relativePath = path.relative(projectRoot, localeBaseDir).replace(/\\/g, '/');
+  // For namespace calculation, we want the path without 'public/' prefix
+  if (relativePath.startsWith('public/')) {
+    return relativePath.slice('public/'.length);
+  }
+  return relativePath;
+}
+
 /**
  * Get namespace from file path relative to locale base directory.
  *

package/src/vite-plugin.ts

@@ -10,6 +10,9 @@ import {
   detectPathType,
   getNamespaceFromPath,
   generateNamespaceWrapperCode,
+  isInPublicDir,
+  toPublicUrl,
+  getLocaleBaseDirForNamespace,
 } from './utils/translations';
 import * as path from 'node:path';
 
@@ -21,10 +24,12 @@ const RESOLVED_PREFIX = '\0';
 interface TranslationInfo {
   locale: string;
   files: string[];
-  /** Glob pattern for dev mode HMR (if applicable) */
-  globPattern?: string;
+  /** Glob pattern for dev mode HMR (if applicable, null for public files) */
+  globPattern?: string | null;
   /** Base directory for this locale (used for namespace calculation) */
   localeBaseDir?: string;
+  /** Whether files are in the public directory (use fetch instead of import) */
+  isPublic?: boolean;
 }
 
 /**
@@ -145,14 +150,18 @@ export function vitePlugin(config: EzI18nConfig): Plugin {
         // Build translation info for each locale
         for (const locale of finalLocales) {
           const files = translations[locale] || [];
+          // Check if files are in public directory
+          const filesInPublic = files.length > 0 && isInPublicDir(files[0], projectRoot);
+
           const info: TranslationInfo = {
             locale,
             files,
             localeBaseDir: localeBaseDirs[locale],
+            isPublic: filesInPublic,
           };
 
-          // For dev mode, determine if we can use import.meta.glob
-          if (isDev && config.translations) {
+          // For dev mode, determine if we can use import.meta.glob (not for public files)
+          if (isDev && config.translations && !filesInPublic) {
             const localeConfig = typeof config.translations === 'string'
               ? path.join(config.translations, locale) + '/'  // Trailing slash ensures detectPathType returns 'folder'
               : config.translations[locale];
@@ -160,7 +169,7 @@ export function vitePlugin(config: EzI18nConfig): Plugin {
             if (localeConfig && typeof localeConfig === 'string') {
               const pathType = detectPathType(localeConfig);
               if (pathType === 'folder' || pathType === 'glob') {
-                // Can use import.meta.glob for HMR
+                // Can use import.meta.glob for HMR (returns null for public files)
                 const basePath = pathType === 'glob'
                   ? localeConfig
                   : toGlobPattern(path.resolve(projectRoot, localeConfig), projectRoot);
@@ -337,6 +346,7 @@ export function t(key, params) {
 /**
  * Generate the translations virtual module for dev mode.
  * Uses import.meta.glob where possible for HMR support.
+ * Uses fetch() for files in public/ directory.
  */
 function generateDevTranslationsModule(
   translationInfo: Map<string, TranslationInfo>,
@@ -358,10 +368,35 @@ function generateDevTranslationsModule(
     if (info.files.length === 0) {
       // No files - return empty object
       loaderEntries.push(`  ${JSON.stringify(locale)}: async () => ({})`);
+    } else if (info.isPublic) {
+      // Public directory files - use fetch() instead of import
+      if (pathBasedNamespacing && info.localeBaseDir) {
+        const localeBaseDirForNs = getLocaleBaseDirForNamespace(info.localeBaseDir, projectRoot);
+        const fileEntries = info.files.map(f => {
+          const url = toPublicUrl(f, projectRoot);
+          const namespace = getNamespaceFromPath(f, info.localeBaseDir!);
+          return `{ url: ${JSON.stringify(url)}, namespace: ${JSON.stringify(namespace)} }`;
+        });
+
+        loaderEntries.push(`  ${JSON.stringify(locale)}: async () => {
+    const fileInfos = [${fileEntries.join(', ')}];
+    const responses = await Promise.all(fileInfos.map(f => fetch(f.url).then(r => r.json())));
+    const wrapped = responses.map((content, i) => __wrapWithNamespace(fileInfos[i].namespace, content));
+    return __deepMerge({}, ...wrapped);
+  }`);
+      } else {
+        const urls = info.files.map(f => toPublicUrl(f, projectRoot));
+        loaderEntries.push(`  ${JSON.stringify(locale)}: async () => {
+    const urls = ${JSON.stringify(urls)};
+    const responses = await Promise.all(urls.map(url => fetch(url).then(r => r.json())));
+    if (responses.length === 1) return responses[0];
+    return __deepMerge({}, ...responses);
+  }`);
+      }
     } else if (info.globPattern && pathBasedNamespacing && info.localeBaseDir) {
       // Use import.meta.glob with namespace wrapping
       const varName = `__${locale}Modules`;
-      const localeBaseDir = info.localeBaseDir.replace(/\\/g, '/');
+      const localeBaseDirForNs = getLocaleBaseDirForNamespace(info.localeBaseDir, projectRoot);
       imports.push(
         `const ${varName} = import.meta.glob(${JSON.stringify(info.globPattern)}, { eager: true, import: 'default' });`
       );
@@ -369,10 +404,11 @@ function generateDevTranslationsModule(
       loaderEntries.push(`  ${JSON.stringify(locale)}: async () => {
     const entries = Object.entries(${varName});
     if (entries.length === 0) return {};
-    const localeBaseDir = ${JSON.stringify(localeBaseDir)};
+    const localeBaseDir = ${JSON.stringify(localeBaseDirForNs)};
     const wrapped = entries.map(([filePath, content]) => {
-      // Extract relative path from locale base dir
-      const relativePath = filePath.replace(localeBaseDir + '/', '').replace(/\\.json$/i, '');
+      // Extract relative path from locale base dir - filePath starts with /
+      const normalizedPath = filePath.startsWith('/') ? filePath.slice(1) : filePath;
+      const relativePath = normalizedPath.replace(localeBaseDir + '/', '').replace(/\\.json$/i, '');
       const namespace = relativePath.replace(/[\\/]/g, '.').replace(/\\.index$/, '');
       return __wrapWithNamespace(namespace, content);
     });
@@ -392,7 +428,7 @@ function generateDevTranslationsModule(
     return __deepMerge({}, ...modules);
   }`);
     } else if (info.files.length === 1) {
-      // Single file
+      // Single file - use import
       const relativePath = toRelativeImport(info.files[0], projectRoot);
       if (pathBasedNamespacing && info.localeBaseDir) {
         const namespace = getNamespaceFromPath(info.files[0], info.localeBaseDir);
@@ -465,6 +501,7 @@ export async function loadTranslations(locale) {
 /**
  * Generate the translations virtual module for production builds.
  * Pre-resolves all imports for optimal bundling.
+ * Uses fetch() for files in public/ directory.
  */
 function generateBuildTranslationsModule(
   translationInfo: Map<string, TranslationInfo>,
@@ -478,8 +515,37 @@ function generateBuildTranslationsModule(
   for (const [locale, info] of translationInfo) {
     if (info.files.length === 0) {
       loaderEntries.push(`  ${JSON.stringify(locale)}: async () => ({})`);
+    } else if (info.isPublic) {
+      // Public directory files - use fetch() instead of import
+      needsDeepMerge = info.files.length > 1;
+      if (pathBasedNamespacing && info.localeBaseDir) {
+        needsNamespaceWrapper = true;
+        const fileEntries = info.files.map(f => {
+          const url = toPublicUrl(f, projectRoot);
+          const namespace = getNamespaceFromPath(f, info.localeBaseDir!);
+          return `{ url: ${JSON.stringify(url)}, namespace: ${JSON.stringify(namespace)} }`;
+        });
+
+        loaderEntries.push(`  ${JSON.stringify(locale)}: async () => {
+    const fileInfos = [${fileEntries.join(', ')}];
+    const responses = await Promise.all(fileInfos.map(f => fetch(f.url).then(r => r.json())));
+    const wrapped = responses.map((content, i) => __wrapWithNamespace(fileInfos[i].namespace, content));
+    return __deepMerge({}, ...wrapped);
+  }`);
+      } else {
+        const urls = info.files.map(f => toPublicUrl(f, projectRoot));
+        if (urls.length === 1) {
+          loaderEntries.push(`  ${JSON.stringify(locale)}: () => fetch(${JSON.stringify(urls[0])}).then(r => r.json())`);
+        } else {
+          loaderEntries.push(`  ${JSON.stringify(locale)}: async () => {
+    const urls = ${JSON.stringify(urls)};
+    const responses = await Promise.all(urls.map(url => fetch(url).then(r => r.json())));
+    return __deepMerge({}, ...responses);
+  }`);
+        }
+      }
     } else if (info.files.length === 1) {
-      // Single file
+      // Single file - use import
       const relativePath = toRelativeImport(info.files[0], projectRoot);
       if (pathBasedNamespacing && info.localeBaseDir) {
         needsNamespaceWrapper = true;