@bleedingdev/modern-js-app-tools 3.5.0-ultramodern.9 → 3.5.0-ultramodern.91

package/dist/esm/plugins/deploy/platforms/templates/cloudflare-entry.002-assets-routes.mjs

@@ -0,0 +1,191 @@
+function isFingerprintedAssetPathname(pathname) {
+  return /(?:^|\/)[^/]+\.[a-f0-9]{8,}\.(?:css|js|mjs|json|svg|png|jpe?g|webp|avif|gif|woff2?|ttf)$/iu.test(
+    pathname,
+  );
+}
+
+function withAssetHeaders(response, request) {
+  const corsResponse = withAssetCorsHeaders(response);
+  const headers = new Headers(corsResponse.headers);
+  const { pathname } = new URL(request.url);
+
+  if (isFingerprintedAssetPathname(pathname)) {
+    headers.set('cache-control', 'public, max-age=31536000, immutable');
+  }
+
+  return new Response(corsResponse.body, {
+    headers,
+    status: corsResponse.status,
+    statusText: corsResponse.statusText,
+  });
+}
+
+async function createCorsPreflightResponse(request, env) {
+  if (request.method !== 'OPTIONS') {
+    return null;
+  }
+
+  const allowedOrigin = getAllowedAppCorsOrigin(request);
+
+  if (allowedOrigin) {
+    const headers = new Headers({
+      'access-control-allow-headers': APP_CORS_ALLOWED_HEADERS,
+      'access-control-allow-methods': APP_CORS_ALLOWED_METHODS,
+      'access-control-allow-origin': allowedOrigin,
+    });
+
+    if (allowedOrigin !== '*') {
+      headers.set('vary', 'origin');
+    }
+
+    return new Response(null, {
+      headers,
+      status: 204,
+    });
+  }
+
+  return null;
+}
+
+async function fetchAsset(request, env) {
+  if (request.method !== 'GET' && request.method !== 'HEAD') {
+    return null;
+  }
+
+  const assets = env?.[ASSETS_BINDING];
+
+  if (!assets || typeof assets.fetch !== 'function') {
+    return null;
+  }
+
+  const response = await assets.fetch(request);
+
+  if (response.status === 404) {
+    return null;
+  }
+
+  return withAssetHeaders(response, request);
+}
+
+async function fetchAssetByPath(pathname, request, env) {
+  const url = new URL(request.url);
+  url.pathname = `/${pathname.replace(/^\/+/u, '')}`;
+
+  return fetchAsset(new Request(url, request), env);
+}
+
+async function fetchAssetByPathFollowingRedirects(
+  pathname,
+  request,
+  env,
+  visited = new Set(),
+) {
+  const normalizedPathname = pathname.startsWith('/')
+    ? pathname
+    : `/${pathname}`;
+
+  if (visited.has(normalizedPathname)) {
+    return null;
+  }
+
+  visited.add(normalizedPathname);
+
+  const response = await fetchAssetByPath(normalizedPathname, request, env);
+
+  if (
+    response &&
+    response.status >= 300 &&
+    response.status < 400 &&
+    response.headers.has('location')
+  ) {
+    const location = response.headers.get('location');
+
+    if (location) {
+      const nextUrl = new URL(location, request.url);
+      const currentUrl = new URL(request.url);
+
+      if (nextUrl.origin === currentUrl.origin) {
+        return fetchAssetByPathFollowingRedirects(
+          nextUrl.pathname,
+          request,
+          env,
+          visited,
+        );
+      }
+    }
+  }
+
+  return response;
+}
+
+async function readAssetText(pathname, request, env) {
+  const response = await fetchAssetByPathFollowingRedirects(
+    pathname,
+    request,
+    env,
+  );
+
+  if (!response || !response.ok) {
+    return undefined;
+  }
+
+  return response.text();
+}
+
+async function readAssetJson(pathname, request, env) {
+  const text = await readAssetText(pathname, request, env);
+
+  if (!text) {
+    return {};
+  }
+
+  return JSON.parse(text);
+}
+
+function normalizeRoutePath(pathname) {
+  if (pathname === '/') {
+    return pathname;
+  }
+
+  return pathname.replace(/\/+$/u, '');
+}
+
+function getPathExtension(pathname) {
+  const lastSegment = pathname.split('/').pop() || '';
+  const dotIndex = lastSegment.lastIndexOf('.');
+
+  if (dotIndex <= 0 || dotIndex === lastSegment.length - 1) {
+    return '';
+  }
+
+  return lastSegment.slice(dotIndex).toLowerCase();
+}
+
+function isAssetLikePathname(pathname) {
+  const extension = getPathExtension(pathname);
+
+  return extension !== '';
+}
+
+function routeMatchesExactly(route, pathname) {
+  if (typeof route?.urlPath !== 'string') {
+    return false;
+  }
+
+  return normalizeRoutePath(route.urlPath) === normalizeRoutePath(pathname);
+}
+
+function routeMatches(route, pathname) {
+  if (typeof route.urlPath !== 'string') {
+    return false;
+  }
+
+  const routePath = normalizeRoutePath(route.urlPath);
+  const requestPath = normalizeRoutePath(pathname);
+
+  return (
+    routePath === requestPath ||
+    (routePath === '/' && route.isSSR) ||
+    requestPath.startsWith(`${routePath}/`)
+  );
+}

package/dist/esm/plugins/deploy/platforms/templates/cloudflare-entry.003-i18n-locales.mjs

@@ -0,0 +1,514 @@
+function getRouteI18nEntry(route) {
+  if (!route || typeof route.entryName !== 'string') {
+    return undefined;
+  }
+
+  return MODERN_WORKER_MANIFEST.i18n?.entries?.[route.entryName];
+}
+
+function getRouteBasePath(route) {
+  const routePath =
+    typeof route?.urlPath === 'string'
+      ? 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 (typeof value !== 'string' || 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 || rawValue.length === 0) {
+      continue;
+    }
+
+    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 =
+      method === 'querystring'
+        ? normalizeLanguage(
+            url.searchParams.get(detection.lookupQuerystring || 'lng'),
+            entry.languages,
+          )
+        : method === 'cookie'
+          ? detectLanguageFromCookie(
+              request.headers.get('cookie'),
+              detection.lookupCookie || 'i18next',
+              entry.languages,
+            )
+          : method === 'header'
+            ? 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) ||
+    entry.languages.length === 0
+  ) {
+    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;
+
+  return [...routes]
+    .sort((left, right) => {
+      const leftLength = left.urlPath?.length || 0;
+      const rightLength = right.urlPath?.length || 0;
+
+      return rightLength - leftLength;
+    })
+    .find(route => routeMatches(route, pathname));
+}
+
+async function fetchRouteHtml(route, request, env) {
+  if (!route?.entryPath) {
+    return null;
+  }
+
+  return fetchAssetByPath(route.entryPath, request, env);
+}