@wular/pnext 0.0.4 → 0.0.7

package/src/routing/handler.ts

@@ -1,12 +1,13 @@
-import { isNotFoundError, isRedirectError } from '../api/navigation';
-import { getWorkUnit, runWithRequest } from '../request/context';
-import { nextResponseMeta, toNextRequest } from '../api/server';
-import { reportRequestError } from '../extensions';
-import type { NextRequest, RouteManifestEntry, RouteParamValue } from '../types';
+import { isNotFoundError, isRedirectError } from '../api/navigation'
+import { getWorkUnit, runWithRequest } from '../request/context'
+import { nextResponseMeta, toNextRequest } from '../api/server'
+import { reportRequestError } from '../extensions'
+import type { NextRequest, RouteManifestEntry, RouteParamValue } from '../types'
+import { safeDecode } from '../utils/decode'
 
-const routeMethods = ['GET', 'HEAD', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'] as const;
+const routeMethods = ['GET', 'HEAD', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'] as const
 
-type RouteMethod = (typeof routeMethods)[number];
+type RouteMethod = (typeof routeMethods)[number]
 
 // Methods that are valid HTTP verbs but may be unimplemented on a route (405),
 // vs. tokens that are not HTTP methods at all (400). Next answers 400 for the
@@ -21,32 +22,32 @@ const httpMethods = new Set([
   'OPTIONS',
   'CONNECT',
   'TRACE',
-]);
+])
 
 interface RouteHandlerContext {
-  params?: Promise<Record<string, RouteParamValue>>;
+  params?: Promise<Record<string, RouteParamValue>>
 }
 
 interface HandleRouteOptions {
   /** Absolute route file path, used in the "no response returned" CLI error. */
-  routeFile?: string;
+  routeFile?: string
 }
 
 export interface RouteHandlerModule {
-  params?: () => Record<string, RouteParamValue>[] | Promise<Record<string, RouteParamValue>[]>;
-  GET?: RouteHandler;
-  HEAD?: RouteHandler;
-  POST?: RouteHandler;
-  PUT?: RouteHandler;
-  PATCH?: RouteHandler;
-  DELETE?: RouteHandler;
-  OPTIONS?: RouteHandler;
+  params?: () => Record<string, RouteParamValue>[] | Promise<Record<string, RouteParamValue>[]>
+  GET?: RouteHandler
+  HEAD?: RouteHandler
+  POST?: RouteHandler
+  PUT?: RouteHandler
+  PATCH?: RouteHandler
+  DELETE?: RouteHandler
+  OPTIONS?: RouteHandler
 }
 
 type RouteHandler = (
   request: NextRequest,
   context: RouteHandlerContext,
-) => Response | undefined | void | Promise<Response | undefined | void>;
+) => Response | undefined | void | Promise<Response | undefined | void>
 
 export async function handleRouteModule(
   module: RouteHandlerModule,
@@ -58,16 +59,16 @@ export async function handleRouteModule(
   // draftMode().enable() append set-cookie here while the handler runs, and
   // the headers are merged onto whatever response goes out — including the
   // synthesized redirect response when the handler throws redirect().
-  const responseHeaders = new Headers();
-  const method = request.method.toUpperCase();
+  const responseHeaders = new Headers()
+  const method = request.method.toUpperCase()
   try {
     // A request method that is not a valid HTTP verb is a bad request, not an
     // unimplemented one (Next returns 400 with an empty body).
-    if (!httpMethods.has(method)) return new Response(null, { status: 400 });
+    if (!httpMethods.has(method)) return new Response(null, { status: 400 })
 
     const handler = routeMethods.includes(method as RouteMethod)
       ? module[method as RouteMethod]
-      : undefined;
+      : undefined
 
     if (!handler) {
       if (method === 'HEAD' && module.GET) {
@@ -77,10 +78,10 @@ export async function handleRouteModule(
           request,
           responseHeaders,
           options,
-        );
-        return new Response(null, { status: response.status, headers: response.headers });
+        )
+        return new Response(null, { status: response.status, headers: response.headers })
       }
-      return missingMethodResponse(module, method);
+      return missingMethodResponse(module, method)
     }
 
     return finalizeResponse(
@@ -88,21 +89,21 @@ export async function handleRouteModule(
       request,
       responseHeaders,
       options,
-    );
+    )
   } catch (error) {
     if (isRedirectError(error)) {
       // POST submissions get a 303 (Next's behavior for redirect() and
       // permanentRedirect() thrown in route handlers): the browser follows
       // with a GET instead of replaying the POST against the target.
-      const status = method === 'POST' ? 303 : error.status;
+      const status = method === 'POST' ? 303 : error.status
       return withResponseHeaders(
         new Response(null, { status, headers: { location: error.location } }),
         responseHeaders,
-      );
+      )
     }
     // notFound() thrown inside a handler is a 404 with an empty body.
     if (isNotFoundError(error)) {
-      return withResponseHeaders(new Response(null, { status: 404 }), responseHeaders);
+      return withResponseHeaders(new Response(null, { status: 404 }), responseHeaders)
     }
     // Any other throw is a 500 with an empty body. Report it through the error
     // funnel (onRequestError) here since core no longer sees it as uncaught.
@@ -110,9 +111,9 @@ export async function handleRouteModule(
       error,
       { method, url: request.url, headers: request.headers },
       { phase: 'handler', routeKind: 'route-handler', ...(getWorkUnit()?.responseHints ?? {}) },
-    );
-    console.error(error);
-    return new Response(null, { status: 500 });
+    )
+    console.error(error)
+    return new Response(null, { status: 500 })
   }
 }
 
@@ -128,21 +129,21 @@ function finalizeResponse(
   responseHeaders: Headers,
   options: HandleRouteOptions,
 ) {
-  const method = request.method.toUpperCase();
+  const method = request.method.toUpperCase()
   if (!response) {
-    const file = options.routeFile ?? '<route>';
+    const file = options.routeFile ?? '<route>'
     console.error(
       `No response is returned from route handler '${file}'. Expected a Response object but ` +
         `received '${typeof response}' (method: ${method}, url: ${request.url}). Ensure you ` +
         'return a `Response` or a `NextResponse` in all branches of your handler.',
-    );
-    return new Response(null, { status: 500 });
+    )
+    return new Response(null, { status: 500 })
   }
   if (nextResponseMeta(response)?.kind === 'next') {
-    console.error('https://nextjs.org/docs/messages/next-response-next-in-app-route-handler');
-    return new Response(null, { status: 500 });
+    console.error('https://nextjs.org/docs/messages/next-response-next-in-app-route-handler')
+    return new Response(null, { status: 500 })
   }
-  return withResponseHeaders(response, responseHeaders);
+  return withResponseHeaders(response, responseHeaders)
 }
 
 function callHandler(
@@ -151,121 +152,113 @@ function callHandler(
   params: Record<string, RouteParamValue>,
   responseHeaders: Headers,
 ) {
-  const nextRequest = toNextRequest(request);
+  const nextRequest = toNextRequest(request)
   // Static routes (no dynamic segments) get no `params` in context — Next
   // omits it, so `context.params` is `undefined` rather than a promise of `{}`.
   const context: RouteHandlerContext =
-    Object.keys(params).length > 0 ? { params: Promise.resolve(params) } : {};
+    Object.keys(params).length > 0 ? { params: Promise.resolve(params) } : {}
   return runWithRequest(nextRequest, () => handler(nextRequest, context), params, {
     responseHeaders,
-  });
+  })
 }
 
 /** Merge scope-collected headers (set-cookie appends, everything else sets) onto the response. */
 function withResponseHeaders(response: Response, extra: Headers) {
-  const withSetCookie = extra as Headers & { getSetCookie?: () => string[] };
-  const scopeCookies = withSetCookie.getSetCookie?.() ?? [];
-  let hasOthers = false;
+  const withSetCookie = extra as Headers & { getSetCookie?: () => string[] }
+  const scopeCookies = withSetCookie.getSetCookie?.() ?? []
+  let hasOthers = false
   extra.forEach((_, key) => {
-    if (key !== 'set-cookie') hasOthers = true;
-  });
-  if (scopeCookies.length === 0 && !hasOthers) return response;
+    if (key !== 'set-cookie') hasOthers = true
+  })
+  if (scopeCookies.length === 0 && !hasOthers) return response
 
   const apply = (headers: Headers) => {
     extra.forEach((value, key) => {
-      if (key !== 'set-cookie') headers.set(key, value);
-    });
+      if (key !== 'set-cookie') headers.set(key, value)
+    })
     // Cookie-jar merge (Next's ResponseCookies semantics): scope cookies
     // (cookies().set during the handler) first, the response's own Set-Cookie
     // headers override same-name entries, and every cookie is normalized with
     // a default Path=/.
     const responseCookies =
-      (headers as Headers & { getSetCookie?: () => string[] }).getSetCookie?.() ?? [];
-    const jar = new Map<string, string>();
+      (headers as Headers & { getSetCookie?: () => string[] }).getSetCookie?.() ?? []
+    const jar = new Map<string, string>()
     for (const cookie of [...scopeCookies, ...responseCookies]) {
-      jar.set(cookieName(cookie), normalizeSetCookie(cookie));
+      jar.set(cookieName(cookie), normalizeSetCookie(cookie))
     }
-    headers.delete('set-cookie');
-    for (const cookie of jar.values()) headers.append('set-cookie', cookie);
-  };
+    headers.delete('set-cookie')
+    for (const cookie of jar.values()) headers.append('set-cookie', cookie)
+  }
   try {
-    apply(response.headers);
-    return response;
+    apply(response.headers)
+    return response
   } catch {
     // Immutable headers (e.g. a Response forwarded from fetch): re-wrap.
-    const headers = new Headers(response.headers);
-    apply(headers);
+    const headers = new Headers(response.headers)
+    apply(headers)
     return new Response(response.body, {
       status: response.status,
       statusText: response.statusText,
       headers,
-    });
+    })
   }
 }
 
 function cookieName(setCookie: string) {
-  return (setCookie.split('=')[0] ?? '').trim();
+  return (setCookie.split('=')[0] ?? '').trim()
 }
 
 function normalizeSetCookie(setCookie: string) {
-  return /;\s*path=/i.test(setCookie) ? setCookie : `${setCookie}; Path=/`;
+  return /;\s*path=/i.test(setCookie) ? setCookie : `${setCookie}; Path=/`
 }
 
 export async function staticRouteParams(route: RouteManifestEntry, module: RouteHandlerModule) {
-  if (typeof module.GET !== 'function') return [];
+  if (typeof module.GET !== 'function') return []
   // `dynamic = 'force-static'` and `dynamic = 'error'` both evaluate a static
   // request; the latter lets request APIs fail at their call sites. A
   // `revalidate` export opts a request-independent GET into static/ISR output.
-  const config = route.segmentConfig;
+  const config = route.segmentConfig
   const optedStatic =
     config?.dynamic === 'force-static' ||
     config?.dynamic === 'error' ||
     config?.revalidate === false ||
-    (typeof config?.revalidate === 'number' && config.revalidate > 0);
-  if (route.hasStaticParams) return module.params?.() ?? [];
-  if (route.usesRequest && !optedStatic) return [];
-  return route.mode === 'static' || optedStatic ? [{}] : [];
+    (typeof config?.revalidate === 'number' && config.revalidate > 0)
+  if (route.hasStaticParams) return module.params?.() ?? []
+  if (route.usesRequest && !optedStatic) return []
+  return route.mode === 'static' || optedStatic ? [{}] : []
 }
 
 export function routeParamsFromPath(
   route: Pick<RouteManifestEntry, 'catchAll' | 'params' | 'pattern'>,
   pathname: string,
 ) {
-  const match = new RegExp(`^${route.pattern}$`).exec(pathname);
-  const params: Record<string, RouteParamValue> = {};
-  if (!match) return params;
+  const match = new RegExp(`^${route.pattern}$`).exec(pathname)
+  const params: Record<string, RouteParamValue> = {}
+  if (!match) return params
 
   for (let index = 0; index < route.params.length; index += 1) {
-    params[route.params[index]!] = safeDecode(match[index + 1] ?? '');
+    params[route.params[index]!] = safeDecode(match[index + 1] ?? '')
   }
   if (route.catchAll) {
     params[route.catchAll] = (match[route.params.length + 1] ?? '')
       .split('/')
       .filter(Boolean)
-      .map(safeDecode);
+      .map(safeDecode)
   }
-  return params;
+  return params
 }
 
 function missingMethodResponse(module: RouteHandlerModule, method: string) {
-  const headers = { Allow: allowedMethods(module).join(', ') };
-  if (method === 'OPTIONS') return new Response(null, { status: 204, headers });
-  return new Response(null, { status: 405, headers });
+  const headers = { Allow: allowedMethods(module).join(', ') }
+  if (method === 'OPTIONS') return new Response(null, { status: 204, headers })
+  return new Response(null, { status: 405, headers })
 }
 
 function allowedMethods(module: RouteHandlerModule) {
-  const allowed = new Set(routeMethods.filter(method => typeof module[method] === 'function'));
+  const allowed = new Set(routeMethods.filter(method => typeof module[method] === 'function'))
   // GET implies auto-HEAD; every route gets auto-OPTIONS. The Allow header is
   // sorted (Next emits e.g. `OPTIONS, POST`).
-  if (allowed.has('GET')) allowed.add('HEAD');
-  allowed.add('OPTIONS');
-  return [...allowed].sort();
-}
-
-function safeDecode(value: string) {
-  try {
-    return decodeURIComponent(value);
-  } catch {
-    return value;
-  }
+  if (allowed.has('GET')) allowed.add('HEAD')
+  allowed.add('OPTIONS')
+  return [...allowed].sort()
 }

package/src/routing/href.ts

@@ -1,26 +1,28 @@
-import type { RouteParamValue } from '../types';
+import type { PrefetchMode, RouteParamValue } from '../types'
 
-export type SearchValue = string | number | boolean | null | undefined;
-export type SearchInput = URLSearchParams | Record<string, SearchValue | SearchValue[]>;
+export type SearchValue = string | number | boolean | null | undefined
+export type SearchInput = URLSearchParams | Record<string, SearchValue | SearchValue[]>
 
 export interface HrefParts {
-  params?: Record<string, RouteParamValue>;
-  search?: SearchInput;
-  hash?: string;
+  params?: Record<string, RouteParamValue>
+  search?: SearchInput
+  hash?: string
 }
 
 export function routeHref(route: string, options: HrefParts = {}) {
-  const path = applyTrailingSlash(fillParams(route, options.params ?? {}));
-  const search = searchString(options.search);
-  const hash = hashString(options.hash);
-  return `${path}${search}${hash}`;
+  const path = applyTrailingSlash(fillParams(route, options.params ?? {}))
+  const search = searchString(options.search)
+  const hash = hashString(options.hash)
+  return `${path}${search}${hash}`
 }
 
 declare global {
   interface Window {
-    __PNEXT_TRAILING_SLASH__?: boolean;
+    __PNEXT_TRAILING_SLASH__?: boolean
+    __PNEXT_PREFETCH__?: PrefetchMode
   }
-  var __PNEXT_TRAILING_SLASH__: boolean | undefined;
+  var __PNEXT_TRAILING_SLASH__: boolean | undefined
+  var __PNEXT_PREFETCH__: PrefetchMode | undefined
 }
 
 // With `trailingSlash: true` the server 308s bare page URLs to their slashed
@@ -31,16 +33,33 @@ declare global {
 // Anchored on globalThis, not a module local: this module is dual-copied into
 // the client/prebundled bundles, where setTrailingSlashUrls never runs.
 export function setTrailingSlashUrls(enabled: boolean) {
-  globalThis.__PNEXT_TRAILING_SLASH__ = enabled;
+  globalThis.__PNEXT_TRAILING_SLASH__ = enabled
 }
 
 function isTrailingSlashEnabled(): boolean {
-  if (process.browser || typeof window !== 'undefined') return window.__PNEXT_TRAILING_SLASH__ === true;
-  return globalThis.__PNEXT_TRAILING_SLASH__ === true;
+  if (process.browser || typeof window !== 'undefined')
+    return window.__PNEXT_TRAILING_SLASH__ === true
+  return globalThis.__PNEXT_TRAILING_SLASH__ === true
 }
 
 export function getTrailingSlashUrls() {
-  return isTrailingSlashEnabled();
+  return isTrailingSlashEnabled()
+}
+
+// The app-wide default prefetch mode (config `prefetch`), for links that set
+// none of their own. Isomorphic like the trailing-slash seam: the server sets it
+// from the resolved config, the client reads the injected window global
+// (renderer's prefetchModeScript).
+export function setDefaultPrefetchMode(mode: PrefetchMode | undefined) {
+  globalThis.__PNEXT_PREFETCH__ = mode
+}
+
+export function getDefaultPrefetchMode(): PrefetchMode {
+  const mode =
+    process.browser || typeof window !== 'undefined'
+      ? window.__PNEXT_PREFETCH__
+      : globalThis.__PNEXT_PREFETCH__
+  return mode === undefined ? 'visible' : mode
 }
 
 // The configured basePath ('' when unset). Set once per process by the server
@@ -48,14 +67,14 @@ export function getTrailingSlashUrls() {
 // trailing-slash seam. Core render code (metadata) reads it through
 // withBasePath so file-convention asset hrefs (og-image, manifest) carry the
 // prefix without a compat/next.config import in core.
-let basePathPrefix = '';
+let basePathPrefix = ''
 
 export function setBasePathPrefix(value: string) {
-  basePathPrefix = value;
+  basePathPrefix = value
 }
 
 export function getBasePathPrefix() {
-  return basePathPrefix;
+  return basePathPrefix
 }
 
 /**
@@ -65,26 +84,26 @@ export function getBasePathPrefix() {
  * always a no-op. Any query/hash on the path rides along untouched.
  */
 export function withBasePath(path: string) {
-  const base = basePathPrefix;
-  if (!base) return path;
-  if (!path.startsWith('/') || path.startsWith('//')) return path;
-  if (path === base || path.startsWith(`${base}/`)) return path;
-  return `${base}${path}`;
+  const base = basePathPrefix
+  if (!base) return path
+  if (!path.startsWith('/') || path.startsWith('//')) return path
+  if (path === base || path.startsWith(`${base}/`)) return path
+  return `${base}${path}`
 }
 
 export function applyTrailingSlash(pathname: string) {
-  const [, path = '', rest = ''] = /^([^?#]*)([\s\S]*)$/.exec(pathname) ?? [];
-  if (!path.startsWith('/')) return pathname;
+  const [, path = '', rest = ''] = /^([^?#]*)([\s\S]*)$/.exec(pathname) ?? []
+  if (!path.startsWith('/')) return pathname
   if (isTrailingSlashEnabled()) {
     // Add the canonical trailing slash (skip root, already-slashed, and files).
-    if (path === '/' || path.endsWith('/') || /\.[^/]+$/.test(path)) return pathname;
-    return `${path}/${rest}`;
+    if (path === '/' || path.endsWith('/') || /\.[^/]+$/.test(path)) return pathname
+    return `${path}/${rest}`
   }
   // trailingSlash:false — Next strips a trailing slash from hrefs so the anchor
   // matches the canonical (unslashed) form and avoids a 308 on click. Root and
   // file paths (`/a.txt/` is not a thing) are left alone.
-  if (path === '/' || !path.endsWith('/') || /\.[^/]+\/$/.test(path)) return pathname;
-  return `${path.replace(/\/+$/, '')}${rest}`;
+  if (path === '/' || !path.endsWith('/') || /\.[^/]+\/$/.test(path)) return pathname
+  return `${path.replace(/\/+$/, '')}${rest}`
 }
 
 function fillParams(route: string, params: Record<string, RouteParamValue>) {
@@ -93,47 +112,47 @@ function fillParams(route: string, params: Record<string, RouteParamValue>) {
     // catch-all form so its doubled brackets aren't mis-parsed.
     .replace(/\[\[\.\.\.([^\]]+)\]\]/g, (_match, key: string) => encodeParam(params[key], true))
     .replace(/\[\.\.\.([^\]]+)\]/g, (_match, key: string) => encodeParam(params[key], true))
-    .replace(/\[([^\]]+)\]/g, (_match, key: string) => encodeParam(params[key], false));
+    .replace(/\[([^\]]+)\]/g, (_match, key: string) => encodeParam(params[key], false))
   // An absent optional catch-all (`[[...slug]]`) leaves a dangling `/`; drop it
   // so /docs/:slug* with no params yields /docs, not /docs/.
-  return collapseTrailingSlash(filled);
+  return collapseTrailingSlash(filled)
 }
 
 function collapseTrailingSlash(pathname: string) {
-  if (pathname.length <= 1) return pathname;
-  return pathname.replace(/\/+$/, '') || '/';
+  if (pathname.length <= 1) return pathname
+  return pathname.replace(/\/+$/, '') || '/'
 }
 
 function encodeParam(value: RouteParamValue | undefined, catchAll: boolean) {
   if (Array.isArray(value)) {
-    const encoded = value.map(segment => encodeURIComponent(segment));
-    return catchAll ? encoded.join('/') : encoded[0] ?? '';
+    const encoded = value.map(segment => encodeURIComponent(segment))
+    return catchAll ? encoded.join('/') : (encoded[0] ?? '')
   }
-  return encodeURIComponent(value ?? '');
+  return encodeURIComponent(value ?? '')
 }
 
 function searchString(search: SearchInput | undefined) {
-  if (!search) return '';
-  const params = search instanceof URLSearchParams ? search : objectSearchParams(search);
-  const value = params.toString();
-  return value ? `?${value}` : '';
+  if (!search) return ''
+  const params = search instanceof URLSearchParams ? search : objectSearchParams(search)
+  const value = params.toString()
+  return value ? `?${value}` : ''
 }
 
 function objectSearchParams(search: Record<string, SearchValue | SearchValue[]>) {
-  const params = new URLSearchParams();
+  const params = new URLSearchParams()
   for (const [key, value] of Object.entries(search)) {
-    const values = Array.isArray(value) ? value : [value];
+    const values = Array.isArray(value) ? value : [value]
     for (const item of values) {
-      if (item == null) continue;
-      params.append(key, String(item));
+      if (item == null) continue
+      params.append(key, String(item))
     }
   }
-  return params;
+  return params
 }
 
 function hashString(hash: string | undefined) {
-  if (!hash) return '';
-  return hash.startsWith('#') ? hash : `#${hash}`;
+  if (!hash) return ''
+  return hash.startsWith('#') ? hash : `#${hash}`
 }
 
 /**
@@ -142,18 +161,18 @@ function hashString(hash: string | undefined) {
  * Next. Returns the response when the path cannot be decoded, else null.
  */
 export function malformedUrlResponse(request: Request): Response | null {
-  let pathname: string;
+  let pathname: string
   try {
-    pathname = new URL(request.url).pathname;
+    pathname = new URL(request.url).pathname
   } catch {
-    return new Response('Bad Request', { status: 400 });
+    return new Response('Bad Request', { status: 400 })
   }
-  if (!pathname.includes('%')) return null;
+  if (!pathname.includes('%')) return null
   try {
-    decodeURIComponent(pathname);
-    return null;
+    decodeURIComponent(pathname)
+    return null
   } catch {
-    return new Response('Bad Request', { status: 400 });
+    return new Response('Bad Request', { status: 400 })
   }
 }
 
@@ -165,13 +184,11 @@ export function malformedUrlResponse(request: Request): Response | null {
  * already canonical.
  */
 export function canonicalTrailingSlashPath(pathname: string, trailingSlash: boolean): string {
-  if (pathname === '/' || pathname === '') return pathname;
-  if (/\.[^/]+$/.test(pathname)) return pathname;
-  const slashed = pathname.endsWith('/');
-  if (trailingSlash ? slashed : !slashed) return pathname;
-  return trailingSlash
-    ? `${pathname.replace(/\/+$/, '')}/`
-    : pathname.replace(/\/+$/, '') || '/';
+  if (pathname === '/' || pathname === '') return pathname
+  if (/\.[^/]+$/.test(pathname)) return pathname
+  const slashed = pathname.endsWith('/')
+  if (trailingSlash ? slashed : !slashed) return pathname
+  return trailingSlash ? `${pathname.replace(/\/+$/, '')}/` : pathname.replace(/\/+$/, '') || '/'
 }
 
 /**
@@ -188,15 +205,15 @@ export function trailingSlashRedirect(
   // skipTrailingSlashRedirect: the app serves both slashed and unslashed URLs
   // as-is, so no canonical redirect is ever emitted (route matching already
   // tolerates a trailing slash via normalizePathname).
-  if (config.skipTrailingSlashRedirect) return null;
-  if (method !== 'GET' && method !== 'HEAD') return null;
-  const pathname = url.pathname;
-  if (pathname === '/' || pathname === '') return null;
-  if (pathname.startsWith('/__pnext') || pathname.startsWith('/assets/')) return null;
-  const target = canonicalTrailingSlashPath(pathname, Boolean(config.trailingSlash));
-  if (target === pathname) return null;
+  if (config.skipTrailingSlashRedirect) return null
+  if (method !== 'GET' && method !== 'HEAD') return null
+  const pathname = url.pathname
+  if (pathname === '/' || pathname === '') return null
+  if (pathname.startsWith('/__pnext') || pathname.startsWith('/assets/')) return null
+  const target = canonicalTrailingSlashPath(pathname, Boolean(config.trailingSlash))
+  if (target === pathname) return null
   return new Response(null, {
     status: 308,
     headers: { location: `${target}${url.search}` },
-  });
+  })
 }