@angular/ssr 19.0.1 → 19.0.3

package/fesm2022/ssr.mjs

@@ -1,5 +1,5 @@
 import { APP_BASE_HREF, PlatformLocation } from '@angular/common';
-import { ɵConsole as _Console, InjectionToken, makeEnvironmentProviders, runInInjectionContext, ApplicationRef, ɵwhenStable as _whenStable, Compiler, REQUEST, REQUEST_CONTEXT, RESPONSE_INIT, LOCALE_ID, ɵresetCompiledComponents as _resetCompiledComponents } from '@angular/core';
+import { ɵConsole as _Console, InjectionToken, makeEnvironmentProviders, runInInjectionContext, 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';
@@ -25,7 +25,7 @@ class ServerAssets {
      * @throws Error - Throws an error if the asset does not exist.
      */
     getServerAsset(path) {
-        const asset = this.manifest.assets.get(path);
+        const asset = this.manifest.assets[path];
         if (!asset) {
             throw new Error(`Server asset '${path}' does not exist.`);
         }
@@ -38,7 +38,7 @@ class ServerAssets {
      * @returns A boolean indicating whether the asset exists.
      */
     hasServerAsset(path) {
-        return this.manifest.assets.has(path);
+        return !!this.manifest.assets[path];
     }
     /**
      * Retrieves the asset for 'index.server.html'.
@@ -183,6 +183,22 @@ function addLeadingSlash(url) {
     // Check if the URL already starts with a slash
     return url[0] === '/' ? url : `/${url}`;
 }
+/**
+ * Adds a trailing slash to a URL if it does not already have one.
+ *
+ * @param url - The URL string to which the trailing slash will be added.
+ * @returns The URL string with a trailing slash.
+ *
+ * @example
+ * ```js
+ * addTrailingSlash('path'); // 'path/'
+ * addTrailingSlash('path/'); // 'path/'
+ * ```
+ */
+function addTrailingSlash(url) {
+    // Check if the URL already end with a slash
+    return url[url.length - 1] === '/' ? url : `${url}/`;
+}
 /**
  * Joins URL parts into a single URL string.
  *
@@ -245,6 +261,50 @@ function stripIndexHtmlFromURL(url) {
     }
     return url;
 }
+/**
+ * Resolves `*` placeholders in a path template by mapping them to corresponding segments
+ * from a base path. This is useful for constructing paths dynamically based on a given base path.
+ *
+ * The function processes the `toPath` string, replacing each `*` placeholder with
+ * the corresponding segment from the `fromPath`. If the `toPath` contains no placeholders,
+ * it is returned as-is. Invalid `toPath` formats (not starting with `/`) will throw an error.
+ *
+ * @param toPath - A path template string that may contain `*` placeholders. Each `*` is replaced
+ * by the corresponding segment from the `fromPath`. Static paths (e.g., `/static/path`) are returned
+ * directly without placeholder replacement.
+ * @param fromPath - A base path string, split into segments, that provides values for
+ * replacing `*` placeholders in the `toPath`.
+ * @returns A resolved path string with `*` placeholders replaced by segments from the `fromPath`,
+ * or the `toPath` returned unchanged if it contains no placeholders.
+ *
+ * @throws If the `toPath` does not start with a `/`, indicating an invalid path format.
+ *
+ * @example
+ * ```typescript
+ * // Example with placeholders resolved
+ * const resolvedPath = buildPathWithParams('/*\/details', '/123/abc');
+ * console.log(resolvedPath); // Outputs: '/123/details'
+ *
+ * // Example with a static path
+ * const staticPath = buildPathWithParams('/static/path', '/base/unused');
+ * console.log(staticPath); // Outputs: '/static/path'
+ * ```
+ */
+function buildPathWithParams(toPath, fromPath) {
+    if (toPath[0] !== '/') {
+        throw new Error(`Invalid toPath: The string must start with a '/'. Received: '${toPath}'`);
+    }
+    if (fromPath[0] !== '/') {
+        throw new Error(`Invalid fromPath: The string must start with a '/'. Received: '${fromPath}'`);
+    }
+    if (!toPath.includes('/*')) {
+        return toPath;
+    }
+    const fromPathParts = fromPath.split('/');
+    const toPathParts = toPath.split('/');
+    const resolvedParts = toPathParts.map((part, index) => toPathParts[index] === '*' ? fromPathParts[index] : part);
+    return joinUrlParts(...resolvedParts);
+}
 
 /**
  * Renders an Angular application or module to an HTML string.
@@ -306,6 +366,39 @@ function isNgModule(value) {
     return 'ɵmod' in value;
 }
 
+/**
+ * Creates a promise that resolves with the result of the provided `promise` or rejects with an
+ * `AbortError` if the `AbortSignal` is triggered before the promise resolves.
+ *
+ * @param promise - The promise to monitor for completion.
+ * @param signal - An `AbortSignal` used to monitor for an abort event. If the signal is aborted,
+ *                 the returned promise will reject.
+ * @param errorMessagePrefix - A custom message prefix to include in the error message when the operation is aborted.
+ * @returns A promise that either resolves with the value of the provided `promise` or rejects with
+ *          an `AbortError` if the `AbortSignal` is triggered.
+ *
+ * @throws {AbortError} If the `AbortSignal` is triggered before the `promise` resolves.
+ */
+function promiseWithAbort(promise, signal, errorMessagePrefix) {
+    return new Promise((resolve, reject) => {
+        const abortHandler = () => {
+            reject(new DOMException(`${errorMessagePrefix} was aborted.\n${signal.reason}`, 'AbortError'));
+        };
+        // Check for abort signal
+        if (signal.aborted) {
+            abortHandler();
+            return;
+        }
+        signal.addEventListener('abort', abortHandler, { once: true });
+        promise
+            .then(resolve)
+            .catch(reject)
+            .finally(() => {
+            signal.removeEventListener('abort', abortHandler);
+        });
+    });
+}
+
 /**
  * Different rendering modes for server routes.
  * @see {@link provideServerRoutesConfig}
@@ -409,6 +502,7 @@ class RouteTree {
     insert(route, metadata) {
         let node = this.root;
         const segments = this.getPathSegments(route);
+        const normalizedSegments = [];
         for (const segment of segments) {
             // Replace parameterized segments (e.g., :id) with a wildcard (*) for matching
             const normalizedSegment = segment[0] === ':' ? '*' : segment;
@@ -418,11 +512,12 @@ class RouteTree {
                 node.children.set(normalizedSegment, childNode);
             }
             node = childNode;
+            normalizedSegments.push(normalizedSegment);
         }
         // At the leaf node, store the full route and its associated metadata
         node.metadata = {
             ...metadata,
-            route: segments.join('/'),
+            route: normalizedSegments.join('/'),
         };
         node.insertionIndex = this.insertionIndexCounter++;
     }
@@ -601,12 +696,18 @@ async function* traverseRoutesConfig(options) {
             const metadata = {
                 renderMode: RenderMode.Prerender,
                 ...matchedMetaData,
-                route: currentRoutePath,
+                // Match Angular router behavior
+                // ['one', 'two', ''] -> 'one/two/'
+                // ['one', 'two', 'three'] -> 'one/two/three'
+                route: path === '' ? addTrailingSlash(currentRoutePath) : currentRoutePath,
             };
             delete metadata.presentInClientRouter;
-            // Handle redirects
-            if (typeof redirectTo === 'string') {
-                const redirectToResolved = resolveRedirectTo(currentRoutePath, redirectTo);
+            if (metadata.renderMode === RenderMode.Prerender) {
+                // Handle SSG routes
+                yield* handleSSGRoute(typeof redirectTo === 'string' ? redirectTo : undefined, metadata, parentInjector, invokeGetPrerenderParams, includePrerenderFallbackRoutes);
+            }
+            else if (typeof redirectTo === 'string') {
+                // Handle redirects
                 if (metadata.status && !VALID_REDIRECT_RESPONSE_CODES.has(metadata.status)) {
                     yield {
                         error: `The '${metadata.status}' status code is not a valid redirect response code. ` +
@@ -614,11 +715,7 @@ async function* traverseRoutesConfig(options) {
                     };
                     continue;
                 }
-                yield { ...metadata, redirectTo: redirectToResolved };
-            }
-            else if (metadata.renderMode === RenderMode.Prerender) {
-                // Handle SSG routes
-                yield* handleSSGRoute(metadata, parentInjector, invokeGetPrerenderParams, includePrerenderFallbackRoutes);
+                yield { ...metadata, redirectTo: resolveRedirectTo(metadata.route, redirectTo) };
             }
             else {
                 yield metadata;
@@ -656,13 +753,14 @@ async function* traverseRoutesConfig(options) {
  * Handles SSG (Static Site Generation) routes by invoking `getPrerenderParams` and yielding
  * all parameterized paths, returning any errors encountered.
  *
+ * @param redirectTo - Optional path to redirect to, if specified.
  * @param metadata - The metadata associated with the route tree node.
  * @param parentInjector - The dependency injection container for the parent route.
  * @param invokeGetPrerenderParams - A flag indicating whether to invoke the `getPrerenderParams` function.
  * @param includePrerenderFallbackRoutes - A flag indicating whether to include fallback routes in the result.
  * @returns An async iterable iterator that yields route tree node metadata for each SSG path or errors.
  */
-async function* handleSSGRoute(metadata, parentInjector, invokeGetPrerenderParams, includePrerenderFallbackRoutes) {
+async function* handleSSGRoute(redirectTo, metadata, parentInjector, invokeGetPrerenderParams, includePrerenderFallbackRoutes) {
     if (metadata.renderMode !== RenderMode.Prerender) {
         throw new Error(`'handleSSGRoute' was called for a route which rendering mode is not prerender.`);
     }
@@ -671,6 +769,9 @@ async function* handleSSGRoute(metadata, parentInjector, invokeGetPrerenderParam
     if ('getPrerenderParams' in meta) {
         delete meta['getPrerenderParams'];
     }
+    if (redirectTo !== undefined) {
+        meta.redirectTo = resolveRedirectTo(currentRoutePath, redirectTo);
+    }
     if (!URL_PARAMETER_REGEXP.test(currentRoutePath)) {
         // Route has no parameters
         yield {
@@ -702,7 +803,13 @@ async function* handleSSGRoute(metadata, parentInjector, invokeGetPrerenderParam
                     }
                     return value;
                 });
-                yield { ...meta, route: routeWithResolvedParams };
+                yield {
+                    ...meta,
+                    route: routeWithResolvedParams,
+                    redirectTo: redirectTo === undefined
+                        ? undefined
+                        : resolveRedirectTo(routeWithResolvedParams, redirectTo),
+                };
             }
         }
         catch (error) {
@@ -737,7 +844,7 @@ function resolveRedirectTo(routePath, redirectTo) {
         return redirectTo;
     }
     // Resolve relative redirectTo based on the current route path.
-    const segments = routePath.split('/');
+    const segments = routePath.replace(URL_PARAMETER_REGEXP, '*').split('/');
     segments.pop(); // Remove the last segment to make it relative.
     return joinUrlParts(...segments, redirectTo);
 }
@@ -812,7 +919,7 @@ async function getRoutesFromAngularRouterConfig(bootstrap, document, url, invoke
             applicationRef = await bootstrap();
         }
         // Wait until the application is stable.
-        await _whenStable(applicationRef);
+        await applicationRef.whenStable();
         const injector = applicationRef.injector;
         const router = injector.get(Router);
         const routesResults = [];
@@ -848,7 +955,6 @@ async function getRoutesFromAngularRouterConfig(bootstrap, document, url, invoke
                 invokeGetPrerenderParams,
                 includePrerenderFallbackRoutes,
             });
-            let seenAppShellRoute;
             for await (const result of traverseRoutes) {
                 if ('error' in result) {
                     errors.push(result.error);
@@ -896,39 +1002,53 @@ async function getRoutesFromAngularRouterConfig(bootstrap, document, url, invoke
  * Asynchronously extracts routes from the Angular application configuration
  * and creates a `RouteTree` to manage server-side routing.
  *
- * @param url - The URL for server-side rendering. The URL is used to configure `ServerPlatformLocation`. This configuration is crucial
- * for ensuring that API requests for relative paths succeed, which is essential for accurate route extraction.
- * See:
- *  - https://github.com/angular/angular/blob/d608b857c689d17a7ffa33bbb510301014d24a17/packages/platform-server/src/location.ts#L51
- *  - https://github.com/angular/angular/blob/6882cc7d9eed26d3caeedca027452367ba25f2b9/packages/platform-server/src/http.ts#L44
- * @param manifest - An optional `AngularAppManifest` that contains the application's routing and configuration details.
- * If not provided, the default manifest is retrieved using `getAngularAppManifest()`.
- * @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 options - An object containing the following options:
+ *  - `url`: The URL for server-side rendering. The URL is used to configure `ServerPlatformLocation`. This configuration is crucial
+ *     for ensuring that API requests for relative paths succeed, which is essential for accurate route extraction.
+ *     See:
+ *      - https://github.com/angular/angular/blob/d608b857c689d17a7ffa33bbb510301014d24a17/packages/platform-server/src/location.ts#L51
+ *      - https://github.com/angular/angular/blob/6882cc7d9eed26d3caeedca027452367ba25f2b9/packages/platform-server/src/http.ts#L44
+ *  - `manifest`: An optional `AngularAppManifest` that contains the application's routing and configuration details.
+ *     If not provided, the default manifest is retrieved using `getAngularAppManifest()`.
+ *  - `invokeGetPrerenderParams`: A boolean flag indicating whether to invoke `getPrerenderParams` for parameterized SSG routes
+ *     to handle prerendering paths. Defaults to `false`.
+ *  - `includePrerenderFallbackRoutes`: A flag indicating whether to include fallback routes in the result. Defaults to `true`.
+ *  - `signal`: An optional `AbortSignal` that can be used to abort the operation.
  *
  * @returns A promise that resolves to an object containing:
  *  - `routeTree`: A populated `RouteTree` containing all extracted routes from the Angular application.
  *  - `appShellRoute`: The specified route for the app-shell, if configured.
  *  - `errors`: An array of strings representing any errors encountered during the route extraction process.
  */
-async function extractRoutesAndCreateRouteTree(url, manifest = getAngularAppManifest(), invokeGetPrerenderParams = false, includePrerenderFallbackRoutes = true) {
-    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);
-    for (const { route, ...metadata } of routes) {
-        if (metadata.redirectTo !== undefined) {
-            metadata.redirectTo = joinUrlParts(baseHref, metadata.redirectTo);
-        }
-        const fullRoute = joinUrlParts(baseHref, route);
-        routeTree.insert(fullRoute, metadata);
-    }
-    return {
-        appShellRoute,
-        routeTree,
-        errors,
-    };
+function extractRoutesAndCreateRouteTree(options) {
+    const { url, manifest = getAngularAppManifest(), invokeGetPrerenderParams = false, includePrerenderFallbackRoutes = true, signal, } = options;
+    async function extract() {
+        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);
+        for (const { route, ...metadata } of routes) {
+            if (metadata.redirectTo !== undefined) {
+                metadata.redirectTo = joinUrlParts(baseHref, metadata.redirectTo);
+            }
+            // Remove undefined fields
+            // Helps avoid unnecessary test updates
+            for (const [key, value] of Object.entries(metadata)) {
+                if (value === undefined) {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    delete metadata[key];
+                }
+            }
+            const fullRoute = joinUrlParts(baseHref, route);
+            routeTree.insert(fullRoute, metadata);
+        }
+        return {
+            appShellRoute,
+            routeTree,
+            errors,
+        };
+    }
+    return signal ? promiseWithAbort(extract(), signal, 'Routes extraction') : extract();
 }
 
 /**
@@ -1061,7 +1181,7 @@ class ServerRouter {
         }
         // Create and store a new promise for the build process.
         // This prevents concurrent builds by re-using the same promise.
-        ServerRouter.#extractionPromise ??= extractRoutesAndCreateRouteTree(url, manifest)
+        ServerRouter.#extractionPromise ??= extractRoutesAndCreateRouteTree({ url, manifest })
             .then(({ routeTree, errors }) => {
             if (errors.length > 0) {
                 throw new Error('Error(s) occurred while extracting routes:\n' +
@@ -1493,11 +1613,12 @@ class AngularServerApp {
         }
         const { redirectTo, status, renderMode } = matchedRoute;
         if (redirectTo !== undefined) {
+            return Response.redirect(new URL(buildPathWithParams(redirectTo, url.pathname), url), 
             // Note: The status code is validated during route extraction.
             // 302 Found is used by default for redirections
             // See: https://developer.mozilla.org/en-US/docs/Web/API/Response/redirect_static#status
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            return Response.redirect(new URL(redirectTo, url), status ?? 302);
+            status ?? 302);
         }
         if (renderMode === RenderMode.Prerender) {
             const response = await this.handleServe(request, matchedRoute);
@@ -1505,10 +1626,7 @@ class AngularServerApp {
                 return response;
             }
         }
-        return Promise.race([
-            this.waitForRequestAbort(request),
-            this.handleRendering(request, matchedRoute, requestContext),
-        ]);
+        return promiseWithAbort(this.handleRendering(request, matchedRoute, requestContext), request.signal, `Request for: ${request.url}`);
     }
     /**
      * Handles serving a prerendered static asset if available for the matched route.
@@ -1529,8 +1647,7 @@ class AngularServerApp {
         if (method !== 'GET' && method !== 'HEAD') {
             return null;
         }
-        const { pathname } = stripIndexHtmlFromURL(new URL(request.url));
-        const assetPath = stripLeadingSlash(joinUrlParts(pathname, 'index.html'));
+        const assetPath = this.buildServerAssetPathFromRequest(request);
         if (!this.assets.hasServerAsset(assetPath)) {
             return null;
         }
@@ -1559,18 +1676,11 @@ 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 { redirectTo, status } = matchedRoute;
-        if (redirectTo !== undefined) {
-            // Note: The status code is validated during route extraction.
-            // 302 Found is used by default for redirections
-            // See: https://developer.mozilla.org/en-US/docs/Web/API/Response/redirect_static#status
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            return Response.redirect(new URL(redirectTo, new URL(request.url)), status ?? 302);
-        }
-        const { renderMode, headers } = matchedRoute;
+        const { renderMode, headers, status } = matchedRoute;
         if (!this.allowStaticRouteRender && renderMode === RenderMode.Prerender) {
             return null;
         }
+        const url = new URL(request.url);
         const platformProviders = [];
         // Initialize the response with status and headers if available.
         const responseInit = {
@@ -1595,7 +1705,9 @@ class AngularServerApp {
         }
         else if (renderMode === RenderMode.Client) {
             // Serve the client-side rendered version if the route is configured for CSR.
-            return new Response(await this.assets.getServerAsset('index.csr.html').text(), responseInit);
+            let html = await this.assets.getServerAsset('index.csr.html').text();
+            html = await this.runTransformsOnHtml(html, url);
+            return new Response(html, responseInit);
         }
         const { manifest: { bootstrap, inlineCriticalCss, locale }, hooks, assets, } = this;
         if (locale !== undefined) {
@@ -1604,13 +1716,9 @@ class AngularServerApp {
                 useValue: locale,
             });
         }
-        const url = new URL(request.url);
-        let html = await assets.getIndexServerHtml().text();
-        // Skip extra microtask if there are no pre hooks.
-        if (hooks.has('html:transform:pre')) {
-            html = await hooks.run('html:transform:pre', { html, url });
-        }
         this.boostrap ??= await bootstrap();
+        let html = await assets.getIndexServerHtml().text();
+        html = await this.runTransformsOnHtml(html, url);
         html = await renderAngular(html, this.boostrap, url, platformProviders, SERVER_CONTEXT_VALUE[renderMode]);
         if (inlineCriticalCss) {
             // Optionally inline critical CSS.
@@ -1642,20 +1750,41 @@ class AngularServerApp {
         return new Response(html, responseInit);
     }
     /**
-     * Returns a promise that rejects if the request is aborted.
+     * Constructs the asset path on the server based on the provided HTTP request.
      *
-     * @param request - The HTTP request object being monitored for abortion.
-     * @returns A promise that never resolves and rejects with an `AbortError`
-     * if the request is aborted.
-     */
-    waitForRequestAbort(request) {
-        return new Promise((_, reject) => {
-            request.signal.addEventListener('abort', () => {
-                const abortError = new Error(`Request for: ${request.url} was aborted.\n${request.signal.reason}`);
-                abortError.name = 'AbortError';
-                reject(abortError);
-            }, { once: true });
-        });
+     * This method processes the incoming request URL to derive a path corresponding
+     * to the requested asset. It ensures the path points to the correct file (e.g.,
+     * `index.html`) and removes any base href if it is not part of the asset path.
+     *
+     * @param request - The incoming HTTP request object.
+     * @returns The server-relative asset path derived from the request.
+     */
+    buildServerAssetPathFromRequest(request) {
+        let { pathname: assetPath } = new URL(request.url);
+        if (!assetPath.endsWith('/index.html')) {
+            // Append "index.html" to build the default asset path.
+            assetPath = joinUrlParts(assetPath, 'index.html');
+        }
+        const { baseHref } = this.manifest;
+        // Check if the asset path starts with the base href and the base href is not (`/` or ``).
+        if (baseHref.length > 1 && assetPath.startsWith(baseHref)) {
+            // Remove the base href from the start of the asset path to align with server-asset expectations.
+            assetPath = assetPath.slice(baseHref.length);
+        }
+        return stripLeadingSlash(assetPath);
+    }
+    /**
+     * Runs the registered transform hooks on the given HTML content.
+     *
+     * @param html - The raw HTML content to be transformed.
+     * @param url - The URL associated with the HTML content, used for context during transformations.
+     * @returns A promise that resolves to the transformed HTML string.
+     */
+    async runTransformsOnHtml(html, url) {
+        if (this.hooks.has('html:transform:pre')) {
+            html = await this.hooks.run('html:transform:pre', { html, url });
+        }
+        return html;
     }
 }
 let angularServerApp;
@@ -1757,6 +1886,10 @@ class AngularAppEngine {
      * The manifest for the server application.
      */
     manifest = getAngularAppEngineManifest();
+    /**
+     * The number of entry points available in the server application's manifest.
+     */
+    entryPointsCount = Object.keys(this.manifest.entryPoints).length;
     /**
      * A cache that holds entry points, keyed by their potential locale string.
      */
@@ -1815,7 +1948,7 @@ class AngularAppEngine {
             return cachedEntryPoint;
         }
         const { entryPoints } = this.manifest;
-        const entryPoint = entryPoints.get(potentialLocale);
+        const entryPoint = entryPoints[potentialLocale];
         if (!entryPoint) {
             return undefined;
         }
@@ -1835,8 +1968,8 @@ class AngularAppEngine {
      * @returns A promise that resolves to the entry point exports or `undefined` if not found.
      */
     getEntryPointExportsForUrl(url) {
-        const { entryPoints, basePath } = this.manifest;
-        if (entryPoints.size === 1) {
+        const { basePath } = this.manifest;
+        if (this.entryPointsCount === 1) {
             return this.getEntryPointExports('');
         }
         const potentialLocale = getPotentialLocaleIdFromUrl(url, basePath);