@bleedingdev/modern-js-app-tools 3.5.0-ultramodern.2 → 3.5.0-ultramodern.20

package/dist/esm-node/plugins/deploy/platforms/templates/cloudflare-entry.mjs

@@ -223,6 +223,255 @@ function routeMatches(route, pathname) {
     const requestPath = normalizeRoutePath(pathname);
     return routePath === requestPath || '/' === routePath && route.isSSR || requestPath.startsWith(`${routePath}/`);
 }
+function getRouteI18nEntry(route) {
+    if (!route || 'string' != typeof route.entryName) return;
+    return MODERN_WORKER_MANIFEST.i18n?.entries?.[route.entryName];
+}
+function getRouteBasePath(route) {
+    const routePath = 'string' == typeof route?.urlPath ? normalizeRoutePath(route.urlPath) : '/';
+    return routePath || '/';
+}
+function getRouteRemainingPathname(route, pathname) {
+    const basePath = getRouteBasePath(route);
+    if ('/' === basePath) return pathname || '/';
+    if (!matchesPrefix(pathname, basePath)) return pathname || '/';
+    const remaining = pathname.slice(basePath.length);
+    return remaining ? remaining.startsWith('/') ? remaining : `/${remaining}` : '/';
+}
+function normalizeLanguage(value, languages) {
+    if ('string' != typeof value || '' === value.trim()) return null;
+    const normalized = value.trim().toLowerCase();
+    const exact = languages.find((language)=>language.toLowerCase() === normalized);
+    if (exact) return exact;
+    const baseLanguage = normalized.split(/[-_]/u)[0];
+    return languages.find((language)=>language.toLowerCase() === baseLanguage) || null;
+}
+function getLanguageFromPath(route, pathname, languages) {
+    const remainingPathname = getRouteRemainingPathname(route, pathname);
+    const firstSegment = remainingPathname.split('/').filter(Boolean)[0];
+    return normalizeLanguage(firstSegment, languages);
+}
+function safeDecodeURIComponent(value) {
+    try {
+        return decodeURIComponent(value);
+    } catch  {
+        return value;
+    }
+}
+function detectLanguageFromCookie(cookieHeader, lookupCookie, languages) {
+    if (!cookieHeader) return null;
+    for (const cookiePart of cookieHeader.split(';')){
+        const [rawName, ...rawValue] = cookiePart.trim().split('=');
+        if (rawName === lookupCookie && 0 !== rawValue.length) return normalizeLanguage(safeDecodeURIComponent(rawValue.join('=')), languages);
+    }
+    return null;
+}
+function detectLanguageFromAcceptLanguage(acceptLanguage, languages) {
+    if (!acceptLanguage) return null;
+    return acceptLanguage.split(',').map((entry, index)=>{
+        const [rawRange, ...rawParameters] = entry.trim().split(';');
+        const qualityParameter = rawParameters.find((parameter)=>parameter.trim().startsWith('q='));
+        const quality = qualityParameter ? Number.parseFloat(qualityParameter.split('=')[1] || '') : 1;
+        return {
+            index,
+            language: normalizeLanguage(rawRange, languages),
+            quality: Number.isFinite(quality) ? quality : 1
+        };
+    }).filter((candidate)=>candidate.language && candidate.quality > 0).sort((left, right)=>right.quality - left.quality || left.index - right.index)[0]?.language || null;
+}
+function detectRedirectLanguage(request, entry) {
+    if (!entry.i18nextDetector) return null;
+    const url = new URL(request.url);
+    const detection = entry.detection || {};
+    const order = Array.isArray(detection.order) ? detection.order : [
+        'querystring',
+        'cookie',
+        'header'
+    ];
+    for (const method of order){
+        const language = 'querystring' === method ? normalizeLanguage(url.searchParams.get(detection.lookupQuerystring || 'lng'), entry.languages) : 'cookie' === method ? detectLanguageFromCookie(request.headers.get('cookie'), detection.lookupCookie || 'i18next', entry.languages) : 'header' === method ? detectLanguageFromAcceptLanguage(request.headers.get(detection.lookupHeader || 'accept-language'), entry.languages) : null;
+        if (language) return language;
+    }
+    return null;
+}
+function normaliseSlashes(pathname) {
+    const withoutDuplicateSlashes = pathname.replace(/\/+/g, '/');
+    const withLeadingSlash = withoutDuplicateSlashes.startsWith('/') ? withoutDuplicateSlashes : `/${withoutDuplicateSlashes}`;
+    return withLeadingSlash.length > 1 ? withLeadingSlash.replace(/\/+$/u, '') : withLeadingSlash;
+}
+function normalisePathPattern(pathname) {
+    return normaliseSlashes(pathname).replace(/\[(.+?)\]/g, ':$1');
+}
+function stripLanguagePrefix(pathname, languages) {
+    const segments = pathname.split('/').filter(Boolean);
+    const firstSegment = segments[0];
+    if (firstSegment && normalizeLanguage(firstSegment, languages)) return `/${segments.slice(1).join('/')}` || '/';
+    return pathname || '/';
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function getPatternParamName(segment) {
+    return segment.slice(1).replace(/\?$/, '');
+}
+function compilePathPattern(pattern) {
+    const names = [];
+    const segments = normalisePathPattern(pattern).split('/').filter(Boolean);
+    const source = segments.map((segment)=>{
+        if (segment.startsWith(':')) {
+            names.push(getPatternParamName(segment));
+            return segment.endsWith('?') ? '(?:/([^/]+))?' : '/([^/]+)';
+        }
+        if ('*' === segment) {
+            names.push('*');
+            return '/(.*)';
+        }
+        return `/${escapeRegExp(segment)}`;
+    }).join('');
+    return {
+        names,
+        regexp: new RegExp(`^${source || '/'}$`)
+    };
+}
+function matchPathPattern(pathname, pattern) {
+    const { names, regexp } = compilePathPattern(pattern);
+    const match = regexp.exec(normaliseSlashes(pathname));
+    if (!match) return null;
+    const params = {};
+    for(let index = 0; index < names.length; index++)try {
+        params[names[index]] = decodeURIComponent(match[index + 1] || '');
+    } catch  {
+        return null;
+    }
+    return params;
+}
+function buildPathFromPattern(pattern, params) {
+    const path = normalisePathPattern(pattern).split('/').filter(Boolean).map((segment)=>{
+        if (segment.startsWith(':')) {
+            const param = params[getPatternParamName(segment)];
+            return param ? encodeURIComponent(param) : '';
+        }
+        if ('*' === segment) return params['*'] || '';
+        return segment;
+    }).filter(Boolean).join('/');
+    return `/${path}`;
+}
+function patternSpecificity(pattern) {
+    const segments = normalisePathPattern(pattern).split('/').filter(Boolean);
+    let staticSegments = 0;
+    let dynamicSegments = 0;
+    let splatSegments = 0;
+    for (const segment of segments)if ('*' === segment) splatSegments++;
+    else if (segment.startsWith(':')) dynamicSegments++;
+    else staticSegments++;
+    return {
+        dynamicSegments,
+        splatSegments,
+        staticSegments,
+        totalSegments: segments.length
+    };
+}
+function comparePatternSpecificity(left, right) {
+    const leftSpecificity = patternSpecificity(left);
+    const rightSpecificity = patternSpecificity(right);
+    return rightSpecificity.staticSegments - leftSpecificity.staticSegments || rightSpecificity.totalSegments - leftSpecificity.totalSegments || leftSpecificity.splatSegments - rightSpecificity.splatSegments || leftSpecificity.dynamicSegments - rightSpecificity.dynamicSegments;
+}
+function sortLocalisedPatterns(patterns) {
+    return patterns.map((pattern, index)=>({
+            pattern,
+            index
+        })).sort((left, right)=>comparePatternSpecificity(left.pattern.pattern, right.pattern.pattern) || left.index - right.index).map(({ pattern })=>pattern);
+}
+function resolveLocalisedPath(pathname, targetLanguage, languages, localisedUrls) {
+    const normalizedPathname = normaliseSlashes(pathname);
+    const canonicalCandidates = sortLocalisedPatterns(Object.entries(localisedUrls || {}).map(([canonicalPattern, localisedUrlEntry])=>({
+            canonicalPattern,
+            localisedUrlEntry,
+            pattern: canonicalPattern
+        })));
+    for (const { canonicalPattern, localisedUrlEntry } of canonicalCandidates){
+        const targetPattern = localisedUrlEntry[targetLanguage];
+        const params = targetPattern ? matchPathPattern(normalizedPathname, canonicalPattern) : null;
+        if (params) return buildPathFromPattern(targetPattern, params);
+    }
+    const localisedCandidates = sortLocalisedPatterns(Object.values(localisedUrls || {}).flatMap((localisedUrlEntry)=>{
+        const targetPattern = localisedUrlEntry[targetLanguage];
+        if (!targetPattern) return [];
+        return languages.map((language)=>localisedUrlEntry[language]).filter(Boolean).map((sourcePattern)=>({
+                pattern: sourcePattern,
+                sourcePattern,
+                targetPattern
+            }));
+    }));
+    for (const { sourcePattern, targetPattern } of localisedCandidates){
+        const params = matchPathPattern(normalizedPathname, sourcePattern);
+        if (params) return buildPathFromPattern(targetPattern, params);
+    }
+    return normalizedPathname;
+}
+function localiseTargetPathname(pathname, language, languages, localisedUrls) {
+    const pathWithoutLanguage = stripLanguagePrefix(pathname, languages);
+    const resolvedPath = localisedUrls ? resolveLocalisedPath(pathWithoutLanguage, language, languages, localisedUrls) : pathWithoutLanguage;
+    const resolvedSegments = resolvedPath.split('/').filter(Boolean);
+    return `/${[
+        language,
+        ...resolvedSegments
+    ].join('/')}`;
+}
+function shouldIgnoreLocaleRedirect(pathname, route, entry) {
+    const remainingPathname = getRouteRemainingPathname(route, pathname);
+    const normalizedPathname = remainingPathname.startsWith('/') ? remainingPathname : `/${remainingPathname}`;
+    const ignoredPrefixes = [
+        ...entry.ignoreRedirectRoutes || [],
+        ...entry.staticRoutePrefixes || [],
+        '/static',
+        '/upload'
+    ];
+    return ignoredPrefixes.some((prefix)=>{
+        const normalizedPrefix = normaliseSlashes(prefix);
+        return normalizedPathname === normalizedPrefix || normalizedPathname.startsWith(`${normalizedPrefix}/`);
+    });
+}
+function buildLocalizedUrl(route, request, language, entry) {
+    const url = new URL(request.url);
+    const basePath = getRouteBasePath(route);
+    const remainingPathname = getRouteRemainingPathname(route, url.pathname);
+    const localizedPathname = localiseTargetPathname(remainingPathname, language, entry.languages, entry.localisedUrls);
+    const nextPathname = '/' === basePath ? localizedPathname : normaliseSlashes(`${basePath}/${localizedPathname}`);
+    return `${nextPathname}${url.search}`;
+}
+function createLocaleRedirectResponse(location, entry) {
+    const headers = new Headers({
+        'cache-control': 'private, no-store',
+        location
+    });
+    const vary = [];
+    const detectionOrder = entry.i18nextDetector ? entry.detection?.order || [] : [];
+    if (detectionOrder.includes('header')) vary.push('Accept-Language');
+    if (detectionOrder.includes('cookie')) vary.push('Cookie');
+    if (vary.length > 0) headers.set('vary', vary.join(', '));
+    return new Response(null, {
+        headers,
+        status: 302
+    });
+}
+function createLocaleRedirectResponseForRequest(route, request) {
+    const entry = getRouteI18nEntry(route);
+    if (!entry || !Array.isArray(entry.languages) || 0 === entry.languages.length) return null;
+    const { pathname, search } = new URL(request.url);
+    if (isAssetLikePathname(pathname)) return null;
+    if (shouldIgnoreLocaleRedirect(pathname, route, entry)) return null;
+    const language = getLanguageFromPath(route, pathname, entry.languages);
+    if (!language) {
+        const targetLanguage = detectRedirectLanguage(request, entry) || entry.fallbackLanguage;
+        return createLocaleRedirectResponse(buildLocalizedUrl(route, request, targetLanguage, entry), entry);
+    }
+    if (entry.localisedUrls) {
+        const expectedUrl = buildLocalizedUrl(route, request, language, entry);
+        if (expectedUrl !== `${pathname}${search}`) return createLocaleRedirectResponse(expectedUrl, entry);
+    }
+    return null;
+}
 function findRoute(request) {
     const { pathname } = new URL(request.url);
     const routes = MODERN_WORKER_MANIFEST.routeSpec.routes;
@@ -399,21 +648,40 @@ async function collectRenderedRemoteCssHrefs(html, request, env) {
 function escapeAttribute(value) {
     return String(value).replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
 }
+function isAbsoluteUrl(value) {
+    return /^[a-z][a-z\d+.-]*:/iu.test(value);
+}
+function toRouteCssHtmlHref(asset) {
+    if (isAbsoluteUrl(asset) || asset.startsWith('/')) return asset;
+    return `/${asset.replace(/^\/+/u, '')}`;
+}
 async function withRouteCssLinks(response, route, routeManifest, request, env) {
     const contentType = response.headers.get('content-type') || '';
     if (!contentType.includes('text/html')) return response;
     const html = await response.text();
-    const cssHrefs = [
-        ...collectRouteCssAssets(route, routeManifest).map((asset)=>new URL(asset, request.url).toString()),
-        ...await collectRenderedRemoteCssHrefs(html, request, env)
-    ];
-    if (0 === cssHrefs.length) return response;
-    const uniqueCssHrefs = [
-        ...new Set(cssHrefs)
+    const cssEntries = [
+        ...collectRouteCssAssets(route, routeManifest).map((asset)=>{
+            const href = toRouteCssHtmlHref(asset);
+            return {
+                href,
+                preloadHref: new URL(href, request.url).toString()
+            };
+        }),
+        ...(await collectRenderedRemoteCssHrefs(html, request, env)).map((href)=>({
+                href,
+                preloadHref: new URL(href, request.url).toString()
+            }))
     ];
+    if (0 === cssEntries.length) return response;
+    const seenCssHrefs = new Set();
+    const uniqueCssEntries = cssEntries.filter((entry)=>{
+        if (seenCssHrefs.has(entry.preloadHref)) return false;
+        seenCssHrefs.add(entry.preloadHref);
+        return true;
+    });
     const headers = new Headers(response.headers);
-    for (const href of uniqueCssHrefs)headers.append('link', `<${href}>; rel=preload; as=style`);
-    const links = uniqueCssHrefs.filter((href)=>!html.includes(href)).map((href)=>`<link rel="stylesheet" href="${escapeAttribute(href)}">`);
+    for (const { preloadHref } of uniqueCssEntries)headers.append('link', `<${preloadHref}>; rel=preload; as=style`);
+    const links = uniqueCssEntries.filter(({ href, preloadHref })=>!html.includes(href) && !html.includes(preloadHref)).map(({ href })=>`<link rel="stylesheet" href="${escapeAttribute(href)}">`);
     if (0 === links.length || !html.includes('</head>')) return new Response(html, {
         headers,
         status: response.status,
@@ -554,21 +822,27 @@ export default {
     async fetch (request, env, ctx) {
         const corsPreflightResponse = await createCorsPreflightResponse(request, env);
         if (corsPreflightResponse) return finalizeResponseForRequest(corsPreflightResponse, request);
-        const assetResponse = await fetchAsset(request, env);
-        if (assetResponse) return finalizeResponseForRequest(assetResponse, request);
         const bffResponse = await dispatchBffRequest(request, env);
         if (bffResponse) return finalizeResponseForRequest(withAppCorsHeaders(bffResponse, request), request);
         const route = findRoute(request);
         const { pathname } = new URL(request.url);
-        if (isAssetLikePathname(pathname) && !routeMatchesExactly(route, pathname)) return finalizeResponseForRequest(withAppCorsHeaders(new Response('Not found', {
-            status: 404
-        }), request), request);
+        if (isAssetLikePathname(pathname) && !routeMatchesExactly(route, pathname)) {
+            const assetResponse = await fetchAsset(request, env);
+            if (assetResponse) return finalizeResponseForRequest(assetResponse, request);
+            return finalizeResponseForRequest(withAppCorsHeaders(new Response('Not found', {
+                status: 404
+            }), request), request);
+        }
+        const localeRedirectResponse = createLocaleRedirectResponseForRequest(route, request);
+        if (localeRedirectResponse) return finalizeResponseForRequest(withAppCorsHeaders(localeRedirectResponse, request), request);
         if (route?.worker) {
             const renderableRequest = createRenderableRequest(request);
             return finalizeResponseForRequest(withAppCorsHeaders(await dispatchRouteWorker(route, renderableRequest, env, ctx), request), request);
         }
         const htmlResponse = await fetchRouteHtml(route, request, env);
         if (htmlResponse) return finalizeResponseForRequest(htmlResponse, request);
+        const assetResponse = await fetchAsset(request, env);
+        if (assetResponse) return finalizeResponseForRequest(assetResponse, request);
         return finalizeResponseForRequest(withAppCorsHeaders(new Response('Not found', {
             status: 404
         }), request), request);

package/lib/types.d.ts

@@ -1,8 +1,6 @@
 /// <reference types="node" />
 /// <reference types="react" />
 /// <reference types="react-dom" />
-/// <reference types="@rsbuild/core/types" />
-/// <reference path="../dist/types/index.d.ts" />
 
 declare namespace NodeJS {
   interface ProcessEnv {
@@ -12,7 +10,8 @@ declare namespace NodeJS {
   }
 }
 
-// reference @rsbuild/core/types, but there are some differences, such as svg
+// Keep this app-environment surface independent from framework configuration
+// declarations so strict app typecheck does not enter toolchain internals.
 /**
  * Image assets
  */

package/package.json

@@ -17,7 +17,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "3.5.0-ultramodern.2",
+  "version": "3.5.0-ultramodern.20",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
   "exports": {
@@ -90,16 +90,16 @@
     "ndepe": "^0.1.13",
     "pkg-types": "^2.3.1",
     "std-env": "4.1.0",
-    "@modern-js/builder": "npm:@bleedingdev/modern-js-builder@3.5.0-ultramodern.2",
-    "@modern-js/i18n-utils": "npm:@bleedingdev/modern-js-i18n-utils@3.5.0-ultramodern.2",
-    "@modern-js/plugin-data-loader": "npm:@bleedingdev/modern-js-plugin-data-loader@3.5.0-ultramodern.2",
-    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.5.0-ultramodern.2",
-    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.5.0-ultramodern.2",
-    "@modern-js/prod-server": "npm:@bleedingdev/modern-js-prod-server@3.5.0-ultramodern.2",
-    "@modern-js/server-utils": "npm:@bleedingdev/modern-js-server-utils@3.5.0-ultramodern.2",
-    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.5.0-ultramodern.2",
-    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.5.0-ultramodern.2",
-    "@modern-js/server": "npm:@bleedingdev/modern-js-server@3.5.0-ultramodern.2"
+    "@modern-js/builder": "npm:@bleedingdev/modern-js-builder@3.5.0-ultramodern.20",
+    "@modern-js/i18n-utils": "npm:@bleedingdev/modern-js-i18n-utils@3.5.0-ultramodern.20",
+    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.5.0-ultramodern.20",
+    "@modern-js/plugin-data-loader": "npm:@bleedingdev/modern-js-plugin-data-loader@3.5.0-ultramodern.20",
+    "@modern-js/prod-server": "npm:@bleedingdev/modern-js-prod-server@3.5.0-ultramodern.20",
+    "@modern-js/server": "npm:@bleedingdev/modern-js-server@3.5.0-ultramodern.20",
+    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.5.0-ultramodern.20",
+    "@modern-js/server-utils": "npm:@bleedingdev/modern-js-server-utils@3.5.0-ultramodern.20",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.5.0-ultramodern.20",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.5.0-ultramodern.20"
   },
   "devDependencies": {
     "@rslib/core": "0.23.1",