@akinon/next 2.0.0-beta.10 → 2.0.0-beta.11

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @akinon/next
 
+## 2.0.0-beta.11
+
+### Minor Changes
+
+- ac783d6: ZERO-3482: Update tailwindcss to version 4.1.11 and enhance button cursor styles
+
 ## 2.0.0-beta.10
 
 ### Minor Changes

package/__tests__/next-config.test.ts

@@ -0,0 +1,83 @@
+import { resolve } from 'path';
+import type { NextConfig } from 'next';
+
+function findBaseDir() {
+  const insideNodeModules = __dirname.includes('node_modules');
+
+  if (insideNodeModules) {
+    return resolve(__dirname, '../../../../');
+  } else {
+    return resolve(__dirname, '../../../apps/projectzeronext');
+  }
+}
+
+const baseDir = findBaseDir();
+
+jest.mock('next-pwa', () => {
+  return () => (config: NextConfig) => config;
+});
+
+jest.mock('@sentry/nextjs', () => ({
+  withSentryConfig: (config: NextConfig) => config
+}));
+
+jest.mock('../with-pz-config.js', () => {
+  return (config: NextConfig) => {
+    const originalHeaders = config.headers;
+
+    config.headers = async () => {
+      const originalHeadersResult = (await originalHeaders?.()) ?? [];
+
+      return [
+        {
+          source: '/(.*)',
+          headers: [
+            {
+              key: 'Content-Security-Policy',
+              value: 'https://*.akifast.com akifast.com'
+            }
+          ]
+        },
+        ...originalHeadersResult
+      ];
+    };
+    return config;
+  };
+});
+
+interface Header {
+  key: string;
+  value: string;
+}
+
+interface HeaderGroup {
+  source: string;
+  headers: Header[];
+}
+
+const nextConfigPath = resolve(baseDir, 'next.config.mjs');
+let nextConfig: any;
+
+beforeAll(async () => {
+  nextConfig = await import(nextConfigPath);
+});
+
+describe('Next.js Configuration', () => {
+  it('should contain Content-Security-Policy header with akifast domain values', async () => {
+    const headers = nextConfig.default.headers;
+    expect(headers).toBeDefined();
+
+    const headersResult = await headers();
+
+    const cspHeaders = headersResult
+      .flatMap((headerGroup: HeaderGroup) => headerGroup.headers)
+      .filter((header: Header) => header.key === 'Content-Security-Policy');
+
+    expect(cspHeaders.length).toBeGreaterThan(0);
+
+    const lastCspHeader = cspHeaders[cspHeaders.length - 1];
+
+    expect(lastCspHeader.value).toContain('akifast.com');
+    expect(lastCspHeader.value).toContain('https://*.akifast.com');
+  });
+});

package/__tests__/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "display": "Default",
+  "compilerOptions": {
+    "composite": false,
+    "declaration": true,
+    "declarationMap": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "inlineSources": false,
+    "isolatedModules": true,
+    "moduleResolution": "node",
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "preserveWatchOutput": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "jsx": "react-jsx",
+    "allowJs": true
+  },
+  "exclude": ["node_modules"],
+  "include": [".", "../."]
+}

package/api/auth.ts

@@ -1,5 +1,5 @@
 import { NextApiRequest, NextApiResponse } from 'next';
-import NextAuth, { Session } from 'next-auth';
+import NextAuth, { Session, NextAuthOptions } from 'next-auth';
 import CredentialProvider from 'next-auth/providers/credentials';
 import { ROUTES } from 'routes';
 import { URLS, user } from '../data/urls';
@@ -7,6 +7,8 @@ import Settings from 'settings';
 import { urlLocaleMatcherRegex } from '../utils';
 import logger from '@akinon/next/utils/log';
 import { AuthError } from '../types';
+import getRootHostname from '../utils/get-root-hostname';
+import { LocaleUrlStrategy } from '../localization';
 
 async function getCurrentUser(sessionId: string, currency = '') {
   const headers = {
@@ -40,7 +42,15 @@ async function getCurrentUser(sessionId: string, currency = '') {
   };
 }
 
-const nextAuthOptions = (req: NextApiRequest, res: NextApiResponse) => {
+type CustomNextAuthOptions = (
+  req: NextApiRequest,
+  res: NextApiResponse
+) => Partial<NextAuthOptions>;
+
+const defaultNextAuthOptions = (
+  req: NextApiRequest,
+  res: NextApiResponse
+): NextAuthOptions => {
   return {
     providers: [
       CredentialProvider({
@@ -150,7 +160,19 @@ const nextAuthOptions = (req: NextApiRequest, res: NextApiResponse) => {
 
           if (sessionId) {
             const maxAge = 30 * 24 * 60 * 60; // 30 days in seconds
-            const cookieOptions = `Path=/; HttpOnly; Secure; Max-Age=${maxAge}`;
+            const { localeUrlStrategy } = Settings.localization;
+
+            const fallbackHost =
+              req.headers['x-forwarded-host']?.toString() ||
+              req.headers.host?.toString();
+            const hostname =
+              process.env.NEXT_PUBLIC_URL || `https://${fallbackHost}`;
+            const rootHostname =
+              localeUrlStrategy === LocaleUrlStrategy.Subdomain
+                ? getRootHostname(hostname)
+                : null;
+            const domainOption = rootHostname ? `Domain=${rootHostname};` : '';
+            const cookieOptions = `Path=/; HttpOnly; Secure; Max-Age=${maxAge}; ${domainOption}`;
 
             res.setHeader('Set-Cookie', [
               `osessionid=${sessionId}; ${cookieOptions}`,
@@ -253,8 +275,36 @@ const nextAuthOptions = (req: NextApiRequest, res: NextApiResponse) => {
   };
 };
 
-const Auth = (req, res) => {
-  return NextAuth(req, res, nextAuthOptions(req, res));
+const Auth = (
+  req: NextApiRequest,
+  res: NextApiResponse,
+  customOptions?: CustomNextAuthOptions
+) => {
+  const baseOptions = defaultNextAuthOptions(req, res);
+  const customOptionsResult = customOptions ? customOptions(req, res) : {};
+
+  const mergedOptions = {
+    ...baseOptions,
+    ...customOptionsResult,
+    providers: [
+      ...baseOptions.providers,
+      ...(customOptionsResult.providers || [])
+    ],
+    callbacks: {
+      ...baseOptions.callbacks,
+      ...customOptionsResult.callbacks
+    },
+    events: {
+      ...baseOptions.events,
+      ...customOptionsResult.events
+    },
+    pages: {
+      ...baseOptions.pages,
+      ...customOptionsResult.pages
+    }
+  };
+
+  return NextAuth(req, res, mergedOptions);
 };
 
 export default Auth;

package/api/client.ts

@@ -5,6 +5,8 @@ import logger from '../utils/log';
 import formatCookieString from '../utils/format-cookie-string';
 import cookieParser from 'set-cookie-parser';
 import { cookies } from 'next/headers';
+import getRootHostname from '../utils/get-root-hostname';
+import { LocaleUrlStrategy } from '../localization';
 
 interface RouteParams {
   params: {
@@ -191,8 +193,23 @@ async function proxyRequest(...args) {
     const responseHeaders: any = {};
 
     if (filteredCookies.length > 0) {
+      const { localeUrlStrategy } = settings.localization;
+
+      const fallbackHost =
+        req.headers.get('x-forwarded-host') || req.headers.get('host');
+      const hostname = process.env.NEXT_PUBLIC_URL || `https://${fallbackHost}`;
+      const rootHostname =
+        localeUrlStrategy === LocaleUrlStrategy.Subdomain
+          ? getRootHostname(hostname)
+          : null;
+
       responseHeaders['set-cookie'] = filteredCookies
-        .map(formatCookieString)
+        .map((cookie) => {
+          if (!cookie.domain && rootHostname) {
+            cookie.domain = rootHostname;
+          }
+          return formatCookieString(cookie);
+        })
         .join(', ');
     }
 

package/babel.config.js

@@ -0,0 +1,6 @@
+module.exports = {
+  presets: [
+    ['@babel/preset-env', { targets: { node: 'current' } }],
+    '@babel/preset-typescript'
+  ]
+};

package/bin/pz-prebuild.js

@@ -2,6 +2,7 @@
 
 const runScript = require('./run-script');
 
+runScript('pz-run-tests.js');
 runScript('pz-install-theme.js');
 runScript('pz-pre-check-dist.js');
 runScript('pz-generate-translations.js');

package/bin/pz-run-tests.js

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const glob = require('glob');
+const findBaseDir = require('../utils/find-base-dir');
+const checkMonorepo = require('../utils/check-monorepo');
+
+const IS_MONOREPO = checkMonorepo() !== null;
+const BASE_DIR = findBaseDir();
+const PLUGINS = require(path.join(BASE_DIR, 'src', 'plugins.js'));
+
+function findPluginTestFiles(akinonNextPackagePath) {
+  const pluginsRootPath = path.join(
+    akinonNextPackagePath,
+    '..',
+    '..',
+    IS_MONOREPO ? 'packages' : '@akinon'
+  );
+
+  if (!fs.existsSync(pluginsRootPath)) {
+    console.log('Plugins directory not found:', pluginsRootPath);
+    return [];
+  }
+
+  return PLUGINS.reduce((testFiles, pluginName) => {
+    const pluginDirectoryPath = path.join(pluginsRootPath, pluginName);
+    if (fs.existsSync(pluginDirectoryPath)) {
+      const pluginTestFiles = glob.sync('**/*.test.ts', {
+        cwd: pluginDirectoryPath,
+        absolute: true
+      });
+
+      return testFiles.concat(pluginTestFiles);
+    } else {
+      console.log(`Plugin directory not found: ${pluginName}`);
+    }
+    return testFiles;
+  }, []);
+}
+
+function isJestInstalled() {
+  try {
+    const jestExecutablePath = path.join(
+      BASE_DIR,
+      'node_modules',
+      '.bin',
+      'jest'
+    );
+    return fs.existsSync(jestExecutablePath);
+  } catch (error) {
+    return false;
+  }
+}
+
+function getAkinonNextPackagePath() {
+  if (!IS_MONOREPO) {
+    return path.resolve(__dirname, '..');
+  }
+
+  return path.resolve(__dirname, '../../../packages/akinon-next');
+}
+
+if (!isJestInstalled()) {
+  console.error('\x1b[31mError: Jest is not installed in the project!\x1b[0m');
+  console.error(
+    'Please install all dependencies by running one of the following commands:'
+  );
+  console.error('  npm install');
+  console.error('  yarn install');
+  process.exit(1);
+}
+
+const jestExecutablePath = path.join(BASE_DIR, 'node_modules', '.bin', 'jest');
+const akinonNextPackagePath = getAkinonNextPackagePath();
+
+const testFiles = [
+  ...glob.sync('__tests__/**/*.test.ts', {
+    cwd: akinonNextPackagePath,
+    absolute: true
+  }),
+  ...findPluginTestFiles(akinonNextPackagePath)
+];
+
+console.log(`Found ${testFiles.length} test files to run`);
+
+const jestArguments = [
+  ...testFiles,
+  `--config ${path.join(akinonNextPackagePath, 'jest.config.js')}`,
+  '--runTestsByPath',
+  '--passWithNoTests'
+];
+
+spawn(jestExecutablePath, jestArguments, {
+  cwd: akinonNextPackagePath,
+  stdio: 'inherit',
+  shell: true
+});

package/components/button.tsx

@@ -35,7 +35,7 @@ export const Button = (props: ButtonProps) => {
 
   const buttonClasses = twMerge(
     clsx(
-      'px-4 text-xs transition-all duration-200',
+      'px-4 text-xs transition-all duration-200 cursor-pointer',
       'inline-flex gap-2 justify-center items-center',
       variants[appearance],
       sizes[size],

package/components/price.tsx

@@ -55,8 +55,8 @@ export const Price = (props: NumericFormatProps & PriceProps) => {
       : formattedValue;
 
   const currentCurrencyDecimalScale = Settings.localization.currencies.find(
-    (currency) => currency.code === currencyCode_
-  ).decimalScale;
+    (currency) => currency?.code === currencyCode_
+  )?.decimalScale;
 
   return (
     <NumericFormat

package/hooks/use-localization.ts

@@ -25,19 +25,33 @@ export const useLocalization = () => {
    * @param locale Locale value defined in the settings.
    */
   const setLocale = (locale: string) => {
-    const localePath =
-      locale === defaultLocaleValue &&
-      localeUrlStrategy !== LocaleUrlStrategy.ShowAllLocales
-        ? ''
-        : `/${locale}`;
+    const { protocol, hostname, port, search, pathname } = location;
+    const pathnameWithoutLocale = pathname.replace(urlLocaleMatcherRegex, '');
 
-    const pathnameWithoutLocale = location.pathname.replace(
-      urlLocaleMatcherRegex,
-      ''
-    );
+    let targetUrl;
+
+    if (localeUrlStrategy === LocaleUrlStrategy.Subdomain) {
+      const hostParts = hostname.split('.');
+      const subDomain = hostParts[0];
+      const isSubdomainLocale = locales.some((loc) => loc.value === subDomain);
+      const baseDomain = isSubdomainLocale
+        ? hostParts.slice(1).join('.')
+        : hostname;
+
+      const formattedPort = port ? `:${port}` : '';
+
+      targetUrl = `${protocol}//${locale}.${baseDomain}${formattedPort}${pathnameWithoutLocale}${search}`;
+    } else {
+      const shouldHideLocale =
+        locale === defaultLocaleValue &&
+        localeUrlStrategy !== LocaleUrlStrategy.ShowAllLocales;
+      const localePath = shouldHideLocale ? '' : `/${locale}`;
+
+      targetUrl = `${localePath}${pathnameWithoutLocale}${search}`;
+    }
 
     // router.push is not used because reloading the page also clears the client side cache.
-    location.href = `${localePath}${pathnameWithoutLocale}${location.search}`;
+    location.href = targetUrl;
   };
 
   /**

package/jest.config.js

@@ -0,0 +1,19 @@
+const path = require('path');
+
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  rootDir: path.resolve(__dirname),
+  roots: [],
+  testMatch: ['**/*.test.ts'],
+  testPathIgnorePatterns: [],
+  transformIgnorePatterns: [],
+  transform: {
+    '^.+\\.(tsx?|jsx?|mjs?)$': [
+      'ts-jest',
+      {
+        tsconfig: path.resolve(__dirname, '__tests__/tsconfig.json')
+      }
+    ]
+  }
+};

package/middlewares/default.ts

@@ -19,6 +19,8 @@ import withLocale from './locale';
 import logger from '../utils/log';
 import { user } from '../data/urls';
 import { getUrlPathWithLocale } from '../utils/localization';
+import getRootHostname from '../utils/get-root-hostname';
+import { LocaleUrlStrategy } from '../localization';
 
 const withPzDefault =
   (middleware: NextMiddleware) =>
@@ -292,6 +294,19 @@ const withPzDefault =
                                   )}`;
                               }
 
+                              if (
+                                !req.middlewareParams.found &&
+                                Settings.customNotFoundEnabled
+                              ) {
+                                const pathname = url.pathname
+                                  .replace(/\/+$/, '')
+                                  .split('/');
+                                url.pathname = url.pathname.replace(
+                                  pathname.pop(),
+                                  'pz-not-found'
+                                );
+                              }
+
                               Settings.rewrites.forEach((rewrite) => {
                                 url.pathname = url.pathname.replace(
                                   rewrite.source,
@@ -328,6 +343,21 @@ const withPzDefault =
                                 middlewareResult = NextResponse.rewrite(url);
                               }
 
+                              const { localeUrlStrategy } =
+                                Settings.localization;
+
+                              const fallbackHost =
+                                req.headers.get('x-forwarded-host') ||
+                                req.headers.get('host');
+                              const hostname =
+                                process.env.NEXT_PUBLIC_URL ||
+                                `https://${fallbackHost}`;
+                              const rootHostname =
+                                localeUrlStrategy ===
+                                LocaleUrlStrategy.Subdomain
+                                  ? getRootHostname(hostname)
+                                  : null;
+
                               if (
                                 !url.pathname.startsWith(`/${currency}/orders`)
                               ) {
@@ -337,6 +367,7 @@ const withPzDefault =
                                     ? locale
                                     : defaultLocaleValue,
                                   {
+                                    domain: rootHostname,
                                     sameSite: 'none',
                                     secure: true,
                                     expires: new Date(
@@ -345,10 +376,12 @@ const withPzDefault =
                                   }
                                 );
                               }
+
                               middlewareResult.cookies.set(
                                 'pz-currency',
                                 currency,
                                 {
+                                  domain: rootHostname,
                                   sameSite: 'none',
                                   secure: true,
                                   expires: new Date(
@@ -397,7 +430,10 @@ const withPzDefault =
                                   ).json();
                                   middlewareResult.cookies.set(
                                     'csrftoken',
-                                    csrf_token
+                                    csrf_token,
+                                    {
+                                      domain: rootHostname
+                                    }
                                   );
                                 }
                               } catch (error) {

package/middlewares/locale.ts

@@ -13,7 +13,8 @@ const getMatchedLocale = (pathname: string, req: PzNextRequest) => {
   const { localeUrlStrategy, defaultLocaleValue } = settings.localization;
 
   if (localeUrlStrategy === LocaleUrlStrategy.Subdomain) {
-    const host = req.headers.get('x-forwarded-host');
+    const host =
+      req.headers.get('x-forwarded-host') || req.headers.get('host') || '';
 
     if (host) {
       const subDomain = host.split('.')[0] || '';
@@ -44,7 +45,9 @@ const withLocale =
     try {
       const url = req.nextUrl.clone();
       const matchedLocale = getMatchedLocale(url.pathname, req);
-      let { localeUrlStrategy, defaultLocaleValue, redirectToDefaultLocale } =
+      let { localeUrlStrategy } = settings.localization;
+
+      const { defaultLocaleValue, redirectToDefaultLocale } =
         settings.localization;
 
       localeUrlStrategy =

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@akinon/next",
   "description": "Core package for Project Zero Next",
-  "version": "2.0.0-beta.10",
+  "version": "2.0.0-beta.11",
   "private": false,
   "license": "MIT",
   "bin": {
@@ -13,14 +13,17 @@
     "pz-predev": "bin/pz-predev.js",
     "pz-postdev": "bin/pz-postdev.js"
   },
+  "scripts": {
+    "test": "jest"
+  },
   "dependencies": {
+    "@neshca/cache-handler": "1.5.1",
     "@opentelemetry/exporter-trace-otlp-http": "0.46.0",
     "@opentelemetry/resources": "1.19.0",
     "@opentelemetry/sdk-node": "0.46.0",
     "@opentelemetry/sdk-trace-node": "1.19.0",
     "@opentelemetry/semantic-conventions": "1.19.0",
     "@reduxjs/toolkit": "1.9.7",
-    "@neshca/cache-handler": "1.5.1",
     "@sentry/nextjs": "9.5.0",
     "cross-spawn": "7.0.3",
     "generic-pool": "3.9.0",
@@ -31,7 +34,7 @@
     "set-cookie-parser": "2.6.0"
   },
   "devDependencies": {
-    "@akinon/eslint-plugin-projectzero": "2.0.0-beta.10",
+    "@akinon/eslint-plugin-projectzero": "2.0.0-beta.11",
     "@types/react-redux": "7.1.30",
     "@types/set-cookie-parser": "2.4.7",
     "@typescript-eslint/eslint-plugin": "8.18.2",

package/redux/middlewares/checkout.ts

@@ -36,6 +36,7 @@ interface CheckoutResult {
     errors?: Record<string, string[]>;
     pre_order?: PreOrder;
     context_list?: CheckoutContext[];
+    redirect_url?: string;
   };
 }
 
@@ -57,6 +58,33 @@ export const errorMiddleware: Middleware = ({ dispatch }: MiddlewareParams) => {
   };
 };
 
+export const redirectUrlMiddleware: Middleware = () => {
+  return (next) => (action) => {
+    const result: CheckoutResult = next(action);
+    const redirectUrl = result?.payload?.redirect_url;
+
+    if (redirectUrl) {
+      const currentLocale = getCookie('pz-locale');
+
+      let url = redirectUrl;
+
+      if (currentLocale && !redirectUrl.includes('/orders/redirection')) {
+        const { defaultLocaleValue, localeUrlStrategy } = settings.localization;
+
+        url =
+          currentLocale === defaultLocaleValue &&
+          localeUrlStrategy !== LocaleUrlStrategy.ShowAllLocales
+            ? redirectUrl
+            : `/${currentLocale}${redirectUrl}`;
+      }
+
+      window.location.href = url;
+    }
+
+    return result;
+  };
+};
+
 export const contextListMiddleware: Middleware = ({
   dispatch,
   getState

package/redux/middlewares/index.ts

@@ -5,6 +5,7 @@ import { ROUTES } from 'routes';
 import type { Middleware } from '@reduxjs/toolkit';
 import {
   errorMiddleware,
+  redirectUrlMiddleware,
   contextListMiddleware,
   hepsiPayMiddleware,
   walletPaymentMiddleware
@@ -50,6 +51,7 @@ const middlewares = [
   rtkQueryResponseHandler,
   rtkQueryErrorHandler,
   errorMiddleware,
+  redirectUrlMiddleware,
   ...preOrderMiddlewares,
   contextListMiddleware,
   hepsiPayMiddleware,

package/tailwind/content.js

@@ -0,0 +1,16 @@
+const defaultPlugins = require('../plugins');
+
+const getAkinonNextContent = (plugins = defaultPlugins) => {
+  return [
+    `./node_modules/@akinon/next/components/**/*.{js,ts,jsx,tsx}`,
+    `../../node_modules/@akinon/next/components/**/*.{js,ts,jsx,tsx}`,
+    ...plugins
+      .map((plugin) => [
+        `./node_modules/@akinon/${plugin}/**/*.{js,ts,jsx,tsx}`,
+        `../../node_modules/@akinon/${plugin}/**/*.{js,ts,jsx,tsx}`
+      ])
+      .flat()
+  ];
+};
+
+module.exports = getAkinonNextContent;

package/types/index.ts

@@ -209,6 +209,7 @@ export interface Settings {
    */
   resetBasketOnCurrencyChange?: boolean;
   frontendIds?: Record<string, number>;
+  customNotFoundEnabled: boolean;
 }
 
 export interface CacheOptions {

package/utils/get-root-hostname.ts

@@ -0,0 +1,28 @@
+import Settings from 'settings';
+
+export default function getRootHostname(
+  url: string | undefined
+): string | null {
+  if (!url) return null;
+
+  try {
+    const urlObj = new URL(url);
+    const hostname = urlObj.hostname;
+    const parts = hostname.split('.');
+
+    const firstPart = parts[0];
+
+    const isLocale = Settings.localization.locales.some(
+      (locale) => locale.value === firstPart
+    );
+
+    if (isLocale) {
+      const hostnameAfterLocale = parts.slice(1).join('.');
+      return `.${hostnameAfterLocale}`;
+    }
+
+    return `.${hostname}`;
+  } catch {
+    return null;
+  }
+}

package/utils/index.ts

@@ -1,6 +1,6 @@
 import settings from 'settings';
 import { LocaleUrlStrategy } from '../localization';
-import { CDNOptions, ClientRequestOptions, Locale } from '../types';
+import { CDNOptions, ClientRequestOptions } from '../types';
 
 export * from './get-currency';
 export * from './menu-generator';
@@ -155,14 +155,15 @@ export function buildCDNUrl(url: string, config?: CDNOptions) {
 const { locales, localeUrlStrategy, defaultLocaleValue } =
   settings.localization;
 
-const isLocaleExcluded = (locale: Locale) =>
-  ![LocaleUrlStrategy.ShowAllLocales, LocaleUrlStrategy.Subdomain].includes(
-    localeUrlStrategy
-  ) && locale.value !== defaultLocaleValue;
-
 export const urlLocaleMatcherRegex = new RegExp(
-  `^/(${locales
-    .filter((l) => !isLocaleExcluded(l))
+  `^/(${settings.localization.locales
+    .filter((l) =>
+      ![LocaleUrlStrategy.ShowAllLocales, LocaleUrlStrategy.Subdomain].includes(
+        settings.localization.localeUrlStrategy
+      )
+        ? l.value !== settings.localization.defaultLocaleValue
+        : l
+    )
     .map((l) => l.value)
     .join('|')})(?=/|$)`
 );