@hitachivantara/app-shell-vite-plugin 2.2.1 → 2.3.0

package/dist/locales-utils.d.ts

@@ -15,16 +15,20 @@ export declare function readSupportedLocales(filePath: string): string[];
  */
 export declare function discoverLanguageDirs(localesDir: string): string[];
 /**
- * Computes the merged supported-locales list respecting ordering:
+ * Computes the effective supported-locales list.
  *
- * 1. Entries from the **app's** `supported-locales.json` (in their original order).
- * 2. Entries from the **shell's** `supported-locales.json` not already listed
- *    (in their original order).
- * 3. Any language directories discovered on disk that are not in either
- *    manifest (alphabetical order).
+ * Discovers all language directories from both sources (upstream shell and
+ * local app). If the app provides a `supported-locales.json`, it acts as a
+ * **filter**: only locales listed there are kept. Otherwise all discovered
+ * locales are included.
  *
- * @param shellLocalesDir - The app-shell-ui locales directory (lower priority).
- * @param appLocalesDir   - The app's locales directory (higher priority).
+ * The result is always sorted alphabetically.
+ *
+ * Locales listed in the local manifest but without a matching language
+ * directory are warned about and dropped.
+ *
+ * @param shellLocalesDir - The app-shell-ui locales directory (upstream).
+ * @param appLocalesDir   - The app's locales directory (downstream / local).
  */
 export declare function computeSupportedLocales(shellLocalesDir: string | undefined, appLocalesDir: string | undefined): string[];
 /**
@@ -38,7 +42,11 @@ export declare function readJsonFile(filePath: string): unknown;
  * Non-JSON files are skipped (locale bundles are always JSON).
  *
  * `supported-locales.json` is skipped — it is handled separately after the
- * merge so it can reflect the union of both sources plus any discovered
- * language directories.
+ * merge so it can reflect the computed list.
+ *
+ * When `allowedLocales` is provided, only top-level directories whose name
+ * is in the set are merged; all others are skipped. This allows the app's
+ * `supported-locales.json` to act as a filter over upstream locale dirs.
+ * Sub-directories (namespace folders) are always merged recursively.
  */
-export declare function mergeDirs(src: string, dest: string): void;
+export declare function mergeDirs(src: string, dest: string, allowedLocales?: Set<string>): void;

package/dist/locales-utils.js

@@ -54,53 +54,23 @@ export function discoverLanguageDirs(localesDir) {
         .toSorted();
 }
 /**
- * Computes the merged supported-locales list respecting ordering:
+ * Computes the effective supported-locales list.
  *
- * 1. Entries from the **app's** `supported-locales.json` (in their original order).
- * 2. Entries from the **shell's** `supported-locales.json` not already listed
- *    (in their original order).
- * 3. Any language directories discovered on disk that are not in either
- *    manifest (alphabetical order).
+ * Discovers all language directories from both sources (upstream shell and
+ * local app). If the app provides a `supported-locales.json`, it acts as a
+ * **filter**: only locales listed there are kept. Otherwise all discovered
+ * locales are included.
  *
- * @param shellLocalesDir - The app-shell-ui locales directory (lower priority).
- * @param appLocalesDir   - The app's locales directory (higher priority).
+ * The result is always sorted alphabetically.
+ *
+ * Locales listed in the local manifest but without a matching language
+ * directory are warned about and dropped.
+ *
+ * @param shellLocalesDir - The app-shell-ui locales directory (upstream).
+ * @param appLocalesDir   - The app's locales directory (downstream / local).
  */
 export function computeSupportedLocales(shellLocalesDir, appLocalesDir) {
-    const seen = new Set();
-    const result = [];
-    const addUnique = (lng) => {
-        if (!seen.has(lng)) {
-            seen.add(lng);
-            result.push(lng);
-        }
-    };
-    // 1. App manifest entries first (highest priority order)
-    if (appLocalesDir) {
-        for (const lng of readSupportedLocales(path.join(appLocalesDir, SUPPORTED_LOCALES_FILE))) {
-            addUnique(lng);
-        }
-    }
-    // 2. Shell manifest entries that weren't already listed
-    if (shellLocalesDir) {
-        for (const lng of readSupportedLocales(path.join(shellLocalesDir, SUPPORTED_LOCALES_FILE))) {
-            addUnique(lng);
-        }
-    }
-    // 3. Discovered language directories not in either manifest (alphabetical)
-    const discoveredDirs = [];
-    for (const dir of [shellLocalesDir, appLocalesDir]) {
-        if (dir) {
-            for (const lng of discoverLanguageDirs(dir)) {
-                if (!seen.has(lng))
-                    discoveredDirs.push(lng);
-            }
-        }
-    }
-    // deduplicate and sort before appending
-    for (const lng of [...new Set(discoveredDirs)].toSorted()) {
-        addUnique(lng);
-    }
-    // Validate: warn and drop manifest entries without a matching language directory
+    // Collect all language directories that actually exist on disk
     const allDirs = new Set();
     for (const dir of [shellLocalesDir, appLocalesDir]) {
         if (dir) {
@@ -109,12 +79,33 @@ export function computeSupportedLocales(shellLocalesDir, appLocalesDir) {
             }
         }
     }
-    return result.filter((lng) => {
-        if (allDirs.has(lng))
-            return true;
-        console.warn(`[app-shell-locales] Locale "${lng}" is listed in ${SUPPORTED_LOCALES_FILE} but has no corresponding language directory — ignoring.`);
-        return false;
-    });
+    // Determine if the app provides a supported-locales.json file.
+    // Physical existence of the file is what matters — even if it's empty,
+    // malformed, or contains no valid entries, it still acts as a filter
+    // (resulting in an empty effective locale list).
+    const manifestPath = appLocalesDir
+        ? path.join(appLocalesDir, SUPPORTED_LOCALES_FILE)
+        : undefined;
+    const hasLocalManifest = manifestPath ? fs.existsSync(manifestPath) : false;
+    // Read the manifest entries (empty if file is missing/invalid)
+    const localManifest = manifestPath ? readSupportedLocales(manifestPath) : [];
+    // Determine the effective set of locales
+    let result;
+    if (hasLocalManifest) {
+        // Filter: only keep unique locales from the manifest that have a directory.
+        // If the manifest is empty/malformed, this correctly yields an empty list.
+        result = [...new Set(localManifest)].filter((lng) => {
+            if (allDirs.has(lng))
+                return true;
+            console.warn(`[app-shell-locales] Locale "${lng}" is listed in ${SUPPORTED_LOCALES_FILE} but has no corresponding language directory — ignoring.`);
+            return false;
+        });
+    }
+    else {
+        // No local manifest → include everything discovered
+        result = [...allDirs];
+    }
+    return result.toSorted();
 }
 /**
  * Parses a JSON file, wrapping parse errors with the file path for
@@ -135,15 +126,23 @@ export function readJsonFile(filePath) {
  * Non-JSON files are skipped (locale bundles are always JSON).
  *
  * `supported-locales.json` is skipped — it is handled separately after the
- * merge so it can reflect the union of both sources plus any discovered
- * language directories.
+ * merge so it can reflect the computed list.
+ *
+ * When `allowedLocales` is provided, only top-level directories whose name
+ * is in the set are merged; all others are skipped. This allows the app's
+ * `supported-locales.json` to act as a filter over upstream locale dirs.
+ * Sub-directories (namespace folders) are always merged recursively.
  */
-export function mergeDirs(src, dest) {
+export function mergeDirs(src, dest, allowedLocales) {
     fs.mkdirSync(dest, { recursive: true });
     for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
         const srcPath = path.join(src, entry.name);
         const destPath = path.join(dest, entry.name);
         if (entry.isDirectory()) {
+            // At the top level, skip locale dirs not in the allowed set
+            if (allowedLocales && !allowedLocales.has(entry.name))
+                continue;
+            // Sub-directories are always merged (no further filtering)
             mergeDirs(srcPath, destPath);
         }
         else if (entry.name === SUPPORTED_LOCALES_FILE) {

package/dist/vite-crossorigin-fix-plugin.js

@@ -12,7 +12,7 @@ export function addUseCredentials(scriptSrc, html) {
 }
 function processScript(bundle, scriptSrc, html, seen = new Set()) {
     seen.add(scriptSrc);
-    const script = bundle[scriptSrc];
+    const script = bundle?.[scriptSrc];
     if (!script || script.type !== "chunk") {
         return html;
     }

package/dist/vite-locales-plugin.d.ts

@@ -6,7 +6,17 @@ import type { PluginOption } from "vite";
  *
  * Local locale files (from the app's public/locales/) always take priority.
  *
- * `supported-locales.json` is merged by taking the union of both arrays and
- * adding any language directories discovered during the merge.
+ * If the app provides a `supported-locales.json`, it acts as a filter:
+ * only listed locales are included from upstream. If no local file is
+ * provided, all upstream locales are merged in.
+ *
+ * When `mergeUpstream` is false (e.g. `type: "bundle"`), the build skips
+ * upstream merging entirely but still generates `supported-locales.json`
+ * from the local locale directories, filtering by the local manifest when
+ * present. In dev mode, upstream locales are always served regardless of
+ * this flag, since the full app runs locally and needs the shell translations.
+ *
+ * @param mergeUpstream - Whether to merge upstream app-shell-ui locales.
+ *   Defaults to `true` (for `type: "app"`).
  */
-export default function copyAppShellLocales(): PluginOption;
+export default function copyAppShellLocales(mergeUpstream?: boolean): PluginOption;

package/dist/vite-locales-plugin.js

@@ -21,6 +21,24 @@ function resolveAppShellUiLocales() {
     }
     return undefined;
 }
+/**
+ * Computes the effective set of allowed locales for a given locales directory.
+ *
+ * When a local `supported-locales.json` exists, it acts as a filter — even if
+ * it resolves to an empty list (all entries invalid), so that an invalid
+ * manifest doesn't accidentally allow everything.
+ *
+ * @returns The effective locale list (sorted, deduplicated) and the
+ *   corresponding `Set` to use as a filter (or `undefined` when no local
+ *   manifest exists — meaning "allow all").
+ */
+function resolveEffectiveLocales(shellLocalesDir, appLocalesDir) {
+    const hasLocalManifest = fs.existsSync(path.join(appLocalesDir, SUPPORTED_LOCALES_FILE));
+    const locales = computeSupportedLocales(shellLocalesDir, appLocalesDir);
+    // When a local manifest exists, always filter — even with an empty set.
+    const allowedSet = hasLocalManifest ? new Set(locales) : undefined;
+    return { locales, allowedSet };
+}
 /**
  * Vite plugin that handles app-shell locale files:
  * - In dev mode: serves merged locale files via middleware
@@ -28,10 +46,20 @@ function resolveAppShellUiLocales() {
  *
  * Local locale files (from the app's public/locales/) always take priority.
  *
- * `supported-locales.json` is merged by taking the union of both arrays and
- * adding any language directories discovered during the merge.
+ * If the app provides a `supported-locales.json`, it acts as a filter:
+ * only listed locales are included from upstream. If no local file is
+ * provided, all upstream locales are merged in.
+ *
+ * When `mergeUpstream` is false (e.g. `type: "bundle"`), the build skips
+ * upstream merging entirely but still generates `supported-locales.json`
+ * from the local locale directories, filtering by the local manifest when
+ * present. In dev mode, upstream locales are always served regardless of
+ * this flag, since the full app runs locally and needs the shell translations.
+ *
+ * @param mergeUpstream - Whether to merge upstream app-shell-ui locales.
+ *   Defaults to `true` (for `type: "app"`).
  */
-export default function copyAppShellLocales() {
+export default function copyAppShellLocales(mergeUpstream = true) {
     let resolvedOutDir;
     let isBuild = false;
     return {
@@ -42,8 +70,16 @@ export default function copyAppShellLocales() {
             isBuild = config.command === "build";
         },
         // --- DEV MODE: serve merged locales via middleware ---
+        // In dev, always resolve upstream locales regardless of `mergeUpstream`,
+        // because the full app runs locally and needs the shell translations.
+        // The `mergeUpstream` flag only affects the build output.
         configureServer(server) {
             const appShellUiLocalesDir = resolveAppShellUiLocales();
+            const localLocalesDir = path.resolve(server.config.root, "public/locales");
+            // Compute the effective locale set once at server start, using the
+            // same logic as the build path. A server restart is needed when the
+            // locale directory structure or supported-locales.json changes.
+            const { locales: effectiveLocales, allowedSet } = resolveEffectiveLocales(appShellUiLocalesDir, localLocalesDir);
             server.middlewares.use((req, res, next) => {
                 // Parse the pathname, stripping the Vite base and any query string
                 // so locale requests work under non-root base paths (e.g. /myapp/).
@@ -58,19 +94,15 @@ export default function copyAppShellLocales() {
                 if (!pathname.startsWith(base))
                     return next();
                 const relativePath = pathname.slice(base.length);
-                // Handle supported-locales.json separately — it's an array, not a
-                // key/value bundle, and must reflect the union of both sources plus
-                // any language directories that exist on disk.
+                // Serve the computed supported-locales.json
                 if (relativePath === `locales/${SUPPORTED_LOCALES_FILE}`) {
-                    const localLocalesDir = path.resolve(server.config.root, "public/locales");
-                    const merged = computeSupportedLocales(appShellUiLocalesDir, localLocalesDir);
-                    if (merged.length === 0) {
+                    if (effectiveLocales.length === 0) {
                         res.statusCode = 404;
                         res.end();
                         return;
                     }
                     res.setHeader("Content-Type", "application/json");
-                    res.end(JSON.stringify(merged));
+                    res.end(JSON.stringify(effectiveLocales));
                     return;
                 }
                 const match = relativePath.match(/^locales\/([^/]+)\/([^/]+\.json)$/);
@@ -80,9 +112,11 @@ export default function copyAppShellLocales() {
                 // Guard against path traversal (e.g. `..` segments)
                 if (lng.includes("..") || nsFile.includes(".."))
                     return next();
-                const localLocalesBase = path.resolve(server.config.root, "public/locales");
-                const localPath = path.join(localLocalesBase, lng, nsFile);
-                if (!localPath.startsWith(localLocalesBase + path.sep))
+                // Filter by the effective locale set (same logic as build)
+                if (allowedSet && !allowedSet.has(lng))
+                    return next();
+                const localPath = path.join(localLocalesDir, lng, nsFile);
+                if (!localPath.startsWith(localLocalesDir + path.sep))
                     return next();
                 const shellPath = appShellUiLocalesDir
                     ? path.join(appShellUiLocalesDir, lng, nsFile)
@@ -118,19 +152,31 @@ export default function copyAppShellLocales() {
             // guard, locale files would be written to that folder on disk.
             if (!isBuild || !resolvedOutDir)
                 return;
-            const appShellUiLocales = resolveAppShellUiLocales();
-            if (!appShellUiLocales)
-                return;
             const targetLocales = path.resolve(resolvedOutDir, "locales");
-            // Recursive merge: app-shell-ui files are merged into target,
-            // with existing (local) keys taking priority in JSON files.
-            // supported-locales.json is skipped during this step.
-            mergeDirs(appShellUiLocales, targetLocales);
-            // Compute the union of supported locales from both sources and from
-            // the language directories that now exist in the merged output.
-            const merged = computeSupportedLocales(appShellUiLocales, targetLocales);
-            if (merged.length > 0) {
-                fs.writeFileSync(path.join(targetLocales, SUPPORTED_LOCALES_FILE), `${JSON.stringify(merged)}\n`);
+            const appShellUiLocales = mergeUpstream
+                ? resolveAppShellUiLocales()
+                : undefined;
+            if (appShellUiLocales) {
+                const { allowedSet } = resolveEffectiveLocales(appShellUiLocales, targetLocales);
+                // Recursive merge: app-shell-ui files are merged into target,
+                // with existing (local) keys taking priority in JSON files.
+                // supported-locales.json is skipped during this step.
+                // Only locale dirs in the allowed set are merged (if filtering).
+                mergeDirs(appShellUiLocales, targetLocales, allowedSet);
+            }
+            // Generate supported-locales.json from the (possibly merged) output.
+            // When no upstream is involved, this is purely based on local dirs.
+            const { locales: finalLocales } = resolveEffectiveLocales(appShellUiLocales, targetLocales);
+            // Always write/normalize the output supported-locales.json so that any
+            // stale copy from public/ (already placed into dist/ by Vite) is
+            // overwritten with the computed result. If the effective list is empty,
+            // remove the file entirely so the output doesn't ship invalid entries.
+            const manifestPath = path.join(targetLocales, SUPPORTED_LOCALES_FILE);
+            if (finalLocales.length > 0) {
+                fs.writeFileSync(manifestPath, `${JSON.stringify(finalLocales)}\n`);
+            }
+            else if (fs.existsSync(manifestPath)) {
+                fs.unlinkSync(manifestPath);
             }
         },
     };

package/dist/vite-plugin.js

@@ -56,6 +56,7 @@ export async function HvAppShellVitePlugin(opts = {}, env = {}) {
                     {
                         src: resolveModule("es-module-shims"),
                         dest: "bundles",
+                        rename: { stripBase: true },
                     },
                     ...(!devMode && buildEntryPoint
                         ? [
@@ -70,6 +71,7 @@ export async function HvAppShellVitePlugin(opts = {}, env = {}) {
                                     }
                                 }),
                                 dest: "bundles",
+                                rename: { stripBase: true },
                             },
                         ]
                         : []),
@@ -118,6 +120,6 @@ export async function HvAppShellVitePlugin(opts = {}, env = {}) {
         // generate the shell script to replace the placeholders in the index.html
         generateEmptyShell && generateBashScript(externalImportMap, inlineConfig),
         // copy/merge app-shell-ui locales into dist (build) or serve via middleware (dev)
-        (buildEntryPoint || devMode) && copyAppShellLocales(),
+        copyAppShellLocales(buildEntryPoint),
     ];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hitachivantara/app-shell-vite-plugin",
-  "version": "2.2.1",
+  "version": "2.3.0",
   "type": "module",
   "private": false,
   "author": "Hitachi Vantara UI Kit Team",
@@ -21,8 +21,8 @@
     "@emotion/cache": "^11.11.0",
     "@emotion/react": "^11.11.1",
     "@hitachivantara/app-shell-services": "^2.0.3",
-    "@hitachivantara/app-shell-shared": "^2.3.0",
-    "@hitachivantara/app-shell-ui": "^2.3.1",
+    "@hitachivantara/app-shell-shared": "^2.3.1",
+    "@hitachivantara/app-shell-ui": "^2.3.2",
     "@hitachivantara/uikit-react-icons": "^6.0.4",
     "@hitachivantara/uikit-react-shared": "^6.0.4",
     "@rollup/plugin-commonjs": "^29.0.0",
@@ -37,7 +37,7 @@
     "react-dom": "^18.2.0",
     "react-router-dom": "^6.9.0",
     "rollup": "^4.57.1",
-    "vite-plugin-static-copy": "^3.1.0"
+    "vite-plugin-static-copy": "^4.1.0"
   },
   "peerDependencies": {
     "vite": "^4.1.4 || ^5.0.4 || ^6.0.0 || ^7.0.0 || ^8.0.0"
@@ -59,5 +59,5 @@
     },
     "./package.json": "./package.json"
   },
-  "gitHead": "96cf5b00b7c82a85b7ebae56e00d48c0b543bebc"
+  "gitHead": "333e132a9823018d508ebbe71c81d0b467f9008d"
 }