@angular/ssr 19.1.0-next.0 → 19.1.0-next.1

package/fesm2022/ssr.mjs

@@ -1,5 +1,5 @@
 import { APP_BASE_HREF, PlatformLocation } from '@angular/common';
-import { ɵConsole as _Console, InjectionToken, makeEnvironmentProviders, runInInjectionContext, ApplicationRef, Compiler, REQUEST, REQUEST_CONTEXT, RESPONSE_INIT, LOCALE_ID, ɵresetCompiledComponents as _resetCompiledComponents } from '@angular/core';
+import { ɵConsole as _Console, InjectionToken, makeEnvironmentProviders, runInInjectionContext, APP_INITIALIZER, inject, ApplicationRef, Compiler, REQUEST, REQUEST_CONTEXT, RESPONSE_INIT, LOCALE_ID, ɵresetCompiledComponents as _resetCompiledComponents } from '@angular/core';
 import { ɵSERVER_CONTEXT as _SERVER_CONTEXT, renderModule, renderApplication, platformServer, INITIAL_CONFIG } from '@angular/platform-server';
 import { ɵloadChildren as _loadChildren, Router } from '@angular/router';
 import Beasties from '../third_party/beasties/index.js';
@@ -51,6 +51,10 @@ class ServerAssets {
     }
 }
 
+/**
+ * A set of log messages that should be ignored and not printed to the console.
+ */
+const IGNORED_LOGS = new Set(['Angular is running in development mode.']);
 /**
  * Custom implementation of the Angular Console service that filters out specific log messages.
  *
@@ -58,21 +62,17 @@ class ServerAssets {
  * It overrides the `log` method to suppress logs that match certain predefined messages.
  */
 class Console extends _Console {
-    /**
-     * A set of log messages that should be ignored and not printed to the console.
-     */
-    ignoredLogs = new Set(['Angular is running in development mode.']);
     /**
      * Logs a message to the console if it is not in the set of ignored messages.
      *
      * @param message - The message to log to the console.
      *
      * This method overrides the `log` method of the `ɵConsole` class. It checks if the
-     * message is in the `ignoredLogs` set. If it is not, it delegates the logging to
+     * message is in the `IGNORED_LOGS` set. If it is not, it delegates the logging to
      * the parent class's `log` method. Otherwise, the message is suppressed.
      */
     log(message) {
-        if (!this.ignoredLogs.has(message)) {
+        if (!IGNORED_LOGS.has(message)) {
             super.log(message);
         }
     }
@@ -454,8 +454,6 @@ const SERVER_ROUTES_CONFIG = new InjectionToken('SERVER_ROUTES_CONFIG');
  * @param options - (Optional) An object containing additional configuration options for server routes.
  * @returns An `EnvironmentProviders` instance with the server routes configuration.
  *
- * @returns An `EnvironmentProviders` object that contains the server routes configuration.
- *
  * @see {@link ServerRoute}
  * @see {@link ServerRoutesConfigOptions}
  * @developerPreview
@@ -657,6 +655,11 @@ class RouteTree {
     }
 }
 
+/**
+ * The maximum number of module preload link elements that should be added for
+ * initial scripts.
+ */
+const MODULE_PRELOAD_MAX = 10;
 /**
  * Regular expression to match segments preceded by a colon in a string.
  */
@@ -675,10 +678,10 @@ const VALID_REDIRECT_RESPONSE_CODES = new Set([301, 302, 303, 307, 308]);
  * @returns An async iterable iterator yielding either route tree node metadata or an error object with an error message.
  */
 async function* traverseRoutesConfig(options) {
-    const { routes, compiler, parentInjector, parentRoute, serverConfigRouteTree, invokeGetPrerenderParams, includePrerenderFallbackRoutes, } = options;
+    const { routes, compiler, parentInjector, parentRoute, serverConfigRouteTree, entryPointToBrowserMapping, parentPreloads, invokeGetPrerenderParams, includePrerenderFallbackRoutes, } = options;
     for (const route of routes) {
         try {
-            const { path = '', redirectTo, loadChildren, children } = route;
+            const { path = '', redirectTo, loadChildren, loadComponent, children, ɵentryName } = route;
             const currentRoutePath = joinUrlParts(parentRoute, path);
             // Get route metadata from the server config route tree, if available
             let matchedMetaData;
@@ -696,12 +699,16 @@ async function* traverseRoutesConfig(options) {
             const metadata = {
                 renderMode: RenderMode.Prerender,
                 ...matchedMetaData,
+                preload: parentPreloads,
                 // Match Angular router behavior
                 // ['one', 'two', ''] -> 'one/two/'
                 // ['one', 'two', 'three'] -> 'one/two/three'
                 route: path === '' ? addTrailingSlash(currentRoutePath) : currentRoutePath,
+                presentInClientRouter: undefined,
             };
-            delete metadata.presentInClientRouter;
+            if (ɵentryName && loadComponent) {
+                appendPreloadToMetadata(ɵentryName, entryPointToBrowserMapping, metadata, true);
+            }
             if (metadata.renderMode === RenderMode.Prerender) {
                 // Handle SSG routes
                 yield* handleSSGRoute(typeof redirectTo === 'string' ? redirectTo : undefined, metadata, parentInjector, invokeGetPrerenderParams, includePrerenderFallbackRoutes);
@@ -726,10 +733,18 @@ async function* traverseRoutesConfig(options) {
                     ...options,
                     routes: children,
                     parentRoute: currentRoutePath,
+                    parentPreloads: metadata.preload,
                 });
             }
             // Load and process lazy-loaded child routes
             if (loadChildren) {
+                if (ɵentryName) {
+                    // When using `loadChildren`, the entire feature area (including multiple routes) is loaded.
+                    // As a result, we do not want all dynamic-import dependencies to be preload, because it involves multiple dependencies
+                    // across different child routes. In contrast, `loadComponent` only loads a single component, which allows
+                    // for precise control over preloading, ensuring that the files preloaded are exactly those required for that specific route.
+                    appendPreloadToMetadata(ɵentryName, entryPointToBrowserMapping, metadata, false);
+                }
                 const loadedChildRoutes = await _loadChildren(route, compiler, parentInjector).toPromise();
                 if (loadedChildRoutes) {
                     const { routes: childRoutes, injector = parentInjector } = loadedChildRoutes;
@@ -738,6 +753,7 @@ async function* traverseRoutesConfig(options) {
                         routes: childRoutes,
                         parentInjector: injector,
                         parentRoute: currentRoutePath,
+                        parentPreloads: metadata.preload,
                     });
                 }
             }
@@ -749,6 +765,27 @@ async function* traverseRoutesConfig(options) {
         }
     }
 }
+/**
+ * Appends preload information to the metadata object based on the specified entry-point and chunk mappings.
+ *
+ * This function extracts preload data for a given entry-point from the provided chunk mappings. It adds the
+ * corresponding browser bundles to the metadata's preload list, ensuring no duplicates and limiting the total
+ * preloads to a predefined maximum.
+ */
+function appendPreloadToMetadata(entryName, entryPointToBrowserMapping, metadata, includeDynamicImports) {
+    if (!entryPointToBrowserMapping) {
+        return;
+    }
+    const preload = entryPointToBrowserMapping[entryName];
+    if (preload?.length) {
+        // Merge existing preloads with new ones, ensuring uniqueness and limiting the total to the maximum allowed.
+        const preloadPaths = preload
+            .filter(({ dynamicImport }) => includeDynamicImports || !dynamicImport)
+            .map(({ path }) => path) ?? [];
+        const combinedPreloads = [...(metadata.preload ?? []), ...preloadPaths];
+        metadata.preload = Array.from(new Set(combinedPreloads)).slice(0, MODULE_PRELOAD_MAX);
+    }
+}
 /**
  * Handles SSG (Static Site Generation) routes by invoking `getPrerenderParams` and yielding
  * all parameterized paths, returning any errors encountered.
@@ -893,10 +930,11 @@ function buildServerConfigRouteTree({ routes, appShellRoute }) {
  * @param invokeGetPrerenderParams - A boolean flag indicating whether to invoke `getPrerenderParams` for parameterized SSG routes
  * to handle prerendering paths. Defaults to `false`.
  * @param includePrerenderFallbackRoutes - A flag indicating whether to include fallback routes in the result. Defaults to `true`.
+ * @param entryPointToBrowserMapping - Maps the entry-point name to the associated JavaScript browser bundles.
  *
  * @returns A promise that resolves to an object of type `AngularRouterConfigResult` or errors.
  */
-async function getRoutesFromAngularRouterConfig(bootstrap, document, url, invokeGetPrerenderParams = false, includePrerenderFallbackRoutes = true) {
+async function getRoutesFromAngularRouterConfig(bootstrap, document, url, invokeGetPrerenderParams = false, includePrerenderFallbackRoutes = true, entryPointToBrowserMapping = undefined) {
     const { protocol, host } = url;
     // Create and initialize the Angular platform for server-side rendering.
     const platformRef = platformServer([
@@ -905,9 +943,25 @@ async function getRoutesFromAngularRouterConfig(bootstrap, document, url, invoke
             useValue: { document, url: `${protocol}//${host}/` },
         },
         {
+            // An Angular Console Provider that does not print a set of predefined logs.
             provide: _Console,
+            // Using `useClass` would necessitate decorating `Console` with `@Injectable`,
+            // which would require switching from `ts_library` to `ng_module`. This change
+            // would also necessitate various patches of `@angular/bazel` to support ESM.
             useFactory: () => new Console(),
         },
+        {
+            // We cannot replace `ApplicationRef` with a different provider here due to the dependency injection (DI) hierarchy.
+            // This code is running at the platform level, where `ApplicationRef` is provided in the root injector.
+            // As a result, any attempt to replace it will cause the root provider to override the platform provider.
+            // TODO(alanagius): investigate exporting the app config directly which would help with: https://github.com/angular/angular/issues/59144
+            provide: APP_INITIALIZER,
+            multi: true,
+            useFactory: () => () => {
+                const appRef = inject(ApplicationRef);
+                appRef.bootstrap = () => undefined;
+            },
+        },
     ]);
     try {
         let applicationRef;
@@ -954,6 +1008,7 @@ async function getRoutesFromAngularRouterConfig(bootstrap, document, url, invoke
                 serverConfigRouteTree,
                 invokeGetPrerenderParams,
                 includePrerenderFallbackRoutes,
+                entryPointToBrowserMapping,
             });
             for await (const result of traverseRoutes) {
                 if ('error' in result) {
@@ -1026,7 +1081,7 @@ function extractRoutesAndCreateRouteTree(options) {
         const routeTree = new RouteTree();
         const document = await new ServerAssets(manifest).getIndexServerHtml().text();
         const bootstrap = await manifest.bootstrap();
-        const { baseHref, appShellRoute, routes, errors } = await getRoutesFromAngularRouterConfig(bootstrap, document, url, invokeGetPrerenderParams, includePrerenderFallbackRoutes);
+        const { baseHref, appShellRoute, routes, errors } = await getRoutesFromAngularRouterConfig(bootstrap, document, url, invokeGetPrerenderParams, includePrerenderFallbackRoutes, manifest.entryPointToBrowserMapping);
         for (const { route, ...metadata } of routes) {
             if (metadata.redirectTo !== undefined) {
                 metadata.redirectTo = joinUrlParts(baseHref, metadata.redirectTo);
@@ -1648,10 +1703,11 @@ class AngularServerApp {
             return null;
         }
         const assetPath = this.buildServerAssetPathFromRequest(request);
-        if (!this.assets.hasServerAsset(assetPath)) {
+        const { manifest: { locale }, assets, } = this;
+        if (!assets.hasServerAsset(assetPath)) {
             return null;
         }
-        const { text, hash, size } = this.assets.getServerAsset(assetPath);
+        const { text, hash, size } = assets.getServerAsset(assetPath);
         const etag = `"${hash}"`;
         return request.headers.get('if-none-match') === etag
             ? new Response(undefined, { status: 304, statusText: 'Not Modified' })
@@ -1660,6 +1716,7 @@ class AngularServerApp {
                     'Content-Length': size.toString(),
                     'ETag': etag,
                     'Content-Type': 'text/html;charset=UTF-8',
+                    ...(locale !== undefined ? { 'Content-Language': locale } : {}),
                     ...headers,
                 },
             });
@@ -1676,17 +1733,19 @@ class AngularServerApp {
      * @returns A promise that resolves to the rendered response, or null if no matching route is found.
      */
     async handleRendering(request, matchedRoute, requestContext) {
-        const { renderMode, headers, status } = matchedRoute;
+        const { renderMode, headers, status, preload } = matchedRoute;
         if (!this.allowStaticRouteRender && renderMode === RenderMode.Prerender) {
             return null;
         }
         const url = new URL(request.url);
         const platformProviders = [];
+        const { manifest: { bootstrap, inlineCriticalCss, locale }, assets, } = this;
         // Initialize the response with status and headers if available.
         const responseInit = {
             status,
             headers: new Headers({
                 'Content-Type': 'text/html;charset=UTF-8',
+                ...(locale !== undefined ? { 'Content-Language': locale } : {}),
                 ...headers,
             }),
         };
@@ -1706,10 +1765,9 @@ class AngularServerApp {
         else if (renderMode === RenderMode.Client) {
             // Serve the client-side rendered version if the route is configured for CSR.
             let html = await this.assets.getServerAsset('index.csr.html').text();
-            html = await this.runTransformsOnHtml(html, url);
+            html = await this.runTransformsOnHtml(html, url, preload);
             return new Response(html, responseInit);
         }
-        const { manifest: { bootstrap, inlineCriticalCss, locale }, hooks, assets, } = this;
         if (locale !== undefined) {
             platformProviders.push({
                 provide: LOCALE_ID,
@@ -1718,7 +1776,7 @@ class AngularServerApp {
         }
         this.boostrap ??= await bootstrap();
         let html = await assets.getIndexServerHtml().text();
-        html = await this.runTransformsOnHtml(html, url);
+        html = await this.runTransformsOnHtml(html, url, preload);
         html = await renderAngular(html, this.boostrap, url, platformProviders, SERVER_CONTEXT_VALUE[renderMode]);
         if (inlineCriticalCss) {
             // Optionally inline critical CSS.
@@ -1778,12 +1836,16 @@ class AngularServerApp {
      *
      * @param html - The raw HTML content to be transformed.
      * @param url - The URL associated with the HTML content, used for context during transformations.
+     * @param preload - An array of URLs representing the JavaScript resources to preload.
      * @returns A promise that resolves to the transformed HTML string.
      */
-    async runTransformsOnHtml(html, url) {
+    async runTransformsOnHtml(html, url, preload) {
         if (this.hooks.has('html:transform:pre')) {
             html = await this.hooks.run('html:transform:pre', { html, url });
         }
+        if (preload?.length) {
+            html = appendPreloadHintsToHtml(html, preload);
+        }
         return html;
     }
 }
@@ -1816,6 +1878,31 @@ function destroyAngularServerApp() {
     }
     angularServerApp = undefined;
 }
+/**
+ * Appends module preload hints to an HTML string for specified JavaScript resources.
+ * This function enhances the HTML by injecting `<link rel="modulepreload">` elements
+ * for each provided resource, allowing browsers to preload the specified JavaScript
+ * modules for better performance.
+ *
+ * @param html - The original HTML string to which preload hints will be added.
+ * @param preload - An array of URLs representing the JavaScript resources to preload.
+ * @returns The modified HTML string with the preload hints injected before the closing `</body>` tag.
+ *          If `</body>` is not found, the links are not added.
+ */
+function appendPreloadHintsToHtml(html, preload) {
+    const bodyCloseIdx = html.lastIndexOf('</body>');
+    if (bodyCloseIdx === -1) {
+        return html;
+    }
+    // Note: Module preloads should be placed at the end before the closing body tag to avoid a performance penalty.
+    // Placing them earlier can cause the browser to prioritize downloading these modules
+    // over other critical page resources like images, CSS, and fonts.
+    return [
+        html.slice(0, bodyCloseIdx),
+        ...preload.map((val) => `<link rel="modulepreload" href="${val}">`),
+        html.slice(bodyCloseIdx),
+    ].join('\n');
+}
 
 // ɵgetRoutesFromAngularRouterConfig is only used by the Webpack based server builder.
 
@@ -1853,6 +1940,144 @@ function getPotentialLocaleIdFromUrl(url, basePath) {
     // Extract the potential locale id.
     return pathname.slice(start, end);
 }
+/**
+ * Parses the `Accept-Language` header and returns a list of locale preferences with their respective quality values.
+ *
+ * The `Accept-Language` header is typically a comma-separated list of locales, with optional quality values
+ * in the form of `q=<value>`. If no quality value is specified, a default quality of `1` is assumed.
+ * Special case: if the header is `*`, it returns the default locale with a quality of `1`.
+ *
+ * @param header - The value of the `Accept-Language` header, typically a comma-separated list of locales
+ *                  with optional quality values (e.g., `en-US;q=0.8,fr-FR;q=0.9`). If the header is `*`,
+ *                  it represents a wildcard for any language, returning the default locale.
+ *
+ * @returns A `ReadonlyMap` where the key is the locale (e.g., `en-US`, `fr-FR`), and the value is
+ *          the associated quality value (a number between 0 and 1). If no quality value is provided,
+ *          a default of `1` is used.
+ *
+ * @example
+ * ```js
+ * parseLanguageHeader('en-US;q=0.8,fr-FR;q=0.9')
+ * // returns new Map([['en-US', 0.8], ['fr-FR', 0.9]])
+
+ * parseLanguageHeader('*')
+ * // returns new Map([['*', 1]])
+ * ```
+ */
+function parseLanguageHeader(header) {
+    if (header === '*') {
+        return new Map([['*', 1]]);
+    }
+    const parsedValues = header
+        .split(',')
+        .map((item) => {
+        const [locale, qualityValue] = item.split(';', 2).map((v) => v.trim());
+        let quality = qualityValue?.startsWith('q=') ? parseFloat(qualityValue.slice(2)) : undefined;
+        if (typeof quality !== 'number' || isNaN(quality) || quality < 0 || quality > 1) {
+            quality = 1; // Invalid quality value defaults to 1
+        }
+        return [locale, quality];
+    })
+        .sort(([_localeA, qualityA], [_localeB, qualityB]) => qualityB - qualityA);
+    return new Map(parsedValues);
+}
+/**
+ * Gets the preferred locale based on the highest quality value from the provided `Accept-Language` header
+ * and the set of available locales.
+ *
+ * This function adheres to the HTTP `Accept-Language` header specification as defined in
+ * [RFC 7231](https://datatracker.ietf.org/doc/html/rfc7231#section-5.3.5), including:
+ * - Case-insensitive matching of language tags.
+ * - Quality value handling (e.g., `q=1`, `q=0.8`). If no quality value is provided, it defaults to `q=1`.
+ * - Prefix matching (e.g., `en` matching `en-US` or `en-GB`).
+ *
+ * @param header - The `Accept-Language` header string to parse and evaluate. It may contain multiple
+ *                 locales with optional quality values, for example: `'en-US;q=0.8,fr-FR;q=0.9'`.
+ * @param supportedLocales - An array of supported locales (e.g., `['en-US', 'fr-FR']`),
+ *                           representing the locales available in the application.
+ * @returns The best matching locale from the supported languages, or `undefined` if no match is found.
+ *
+ * @example
+ * ```js
+ * getPreferredLocale('en-US;q=0.8,fr-FR;q=0.9', ['en-US', 'fr-FR', 'de-DE'])
+ * // returns 'fr-FR'
+ *
+ * getPreferredLocale('en;q=0.9,fr-FR;q=0.8', ['en-US', 'fr-FR', 'de-DE'])
+ * // returns 'en-US'
+ *
+ * getPreferredLocale('es-ES;q=0.7', ['en-US', 'fr-FR', 'de-DE'])
+ * // returns undefined
+ * ```
+ */
+function getPreferredLocale(header, supportedLocales) {
+    if (supportedLocales.length < 2) {
+        return supportedLocales[0];
+    }
+    const parsedLocales = parseLanguageHeader(header);
+    // Handle edge cases:
+    // - No preferred locales provided.
+    // - Only one supported locale.
+    // - Wildcard preference.
+    if (parsedLocales.size === 0 || (parsedLocales.size === 1 && parsedLocales.has('*'))) {
+        return supportedLocales[0];
+    }
+    // Create a map for case-insensitive lookup of supported locales.
+    // Keys are normalized (lowercase) locale values, values are original casing.
+    const normalizedSupportedLocales = new Map();
+    for (const locale of supportedLocales) {
+        normalizedSupportedLocales.set(normalizeLocale(locale), locale);
+    }
+    // Iterate through parsed locales in descending order of quality.
+    let bestMatch;
+    const qualityZeroNormalizedLocales = new Set();
+    for (const [locale, quality] of parsedLocales) {
+        const normalizedLocale = normalizeLocale(locale);
+        if (quality === 0) {
+            qualityZeroNormalizedLocales.add(normalizedLocale);
+            continue; // Skip locales with quality value of 0.
+        }
+        // Exact match found.
+        if (normalizedSupportedLocales.has(normalizedLocale)) {
+            return normalizedSupportedLocales.get(normalizedLocale);
+        }
+        // If an exact match is not found, try prefix matching (e.g., "en" matches "en-US").
+        // Store the first prefix match encountered, as it has the highest quality value.
+        if (bestMatch !== undefined) {
+            continue;
+        }
+        const [languagePrefix] = normalizedLocale.split('-', 1);
+        for (const supportedLocale of normalizedSupportedLocales.keys()) {
+            if (supportedLocale.startsWith(languagePrefix)) {
+                bestMatch = normalizedSupportedLocales.get(supportedLocale);
+                break; // No need to continue searching for this locale.
+            }
+        }
+    }
+    if (bestMatch !== undefined) {
+        return bestMatch;
+    }
+    // Return the first locale that is not quality zero.
+    for (const [normalizedLocale, locale] of normalizedSupportedLocales) {
+        if (!qualityZeroNormalizedLocales.has(normalizedLocale)) {
+            return locale;
+        }
+    }
+}
+/**
+ * Normalizes a locale string by converting it to lowercase.
+ *
+ * @param locale - The locale string to normalize.
+ * @returns The normalized locale string in lowercase.
+ *
+ * @example
+ * ```ts
+ * const normalized = normalizeLocale('EN-US');
+ * console.log(normalized); // Output: "en-us"
+ * ```
+ */
+function normalizeLocale(locale) {
+    return locale.toLowerCase();
+}
 
 /**
  * Angular server application engine.
@@ -1887,9 +2112,9 @@ class AngularAppEngine {
      */
     manifest = getAngularAppEngineManifest();
     /**
-     * The number of entry points available in the server application's manifest.
+     * A map of supported locales from the server application's manifest.
      */
-    entryPointsCount = Object.keys(this.manifest.entryPoints).length;
+    supportedLocales = Object.keys(this.manifest.supportedLocales);
     /**
      * A cache that holds entry points, keyed by their potential locale string.
      */
@@ -1907,7 +2132,47 @@ class AngularAppEngine {
      */
     async handle(request, requestContext) {
         const serverApp = await this.getAngularServerAppForRequest(request);
-        return serverApp ? serverApp.handle(request, requestContext) : null;
+        if (serverApp) {
+            return serverApp.handle(request, requestContext);
+        }
+        if (this.supportedLocales.length > 1) {
+            // Redirect to the preferred language if i18n is enabled.
+            return this.redirectBasedOnAcceptLanguage(request);
+        }
+        return null;
+    }
+    /**
+     * Handles requests for the base path when i18n is enabled.
+     * Redirects the user to a locale-specific path based on the `Accept-Language` header.
+     *
+     * @param request The incoming request.
+     * @returns A `Response` object with a 302 redirect, or `null` if i18n is not enabled
+     *          or the request is not for the base path.
+     */
+    redirectBasedOnAcceptLanguage(request) {
+        const { basePath, supportedLocales } = this.manifest;
+        // If the request is not for the base path, it's not our responsibility to handle it.
+        const url = new URL(request.url);
+        if (url.pathname !== basePath) {
+            return null;
+        }
+        // For requests to the base path (typically '/'), attempt to extract the preferred locale
+        // from the 'Accept-Language' header.
+        const preferredLocale = getPreferredLocale(request.headers.get('Accept-Language') || '*', this.supportedLocales);
+        if (preferredLocale) {
+            const subPath = supportedLocales[preferredLocale];
+            if (subPath !== undefined) {
+                url.pathname = joinUrlParts(url.pathname, subPath);
+                return new Response(null, {
+                    status: 302, // Use a 302 redirect as language preference may change.
+                    headers: {
+                        'Location': url.toString(),
+                        'Vary': 'Accept-Language',
+                    },
+                });
+            }
+        }
+        return null;
     }
     /**
      * Retrieves the Angular server application instance for a given request.
@@ -1969,11 +2234,11 @@ class AngularAppEngine {
      */
     getEntryPointExportsForUrl(url) {
         const { basePath } = this.manifest;
-        if (this.entryPointsCount === 1) {
+        if (this.supportedLocales.length === 1) {
             return this.getEntryPointExports('');
         }
         const potentialLocale = getPotentialLocaleIdFromUrl(url, basePath);
-        return this.getEntryPointExports(potentialLocale);
+        return this.getEntryPointExports(potentialLocale) ?? this.getEntryPointExports('');
     }
 }