{"version":3,"sources":["../../../src/server/server-utils.ts"],"sourcesContent":["import type { Rewrite } from '../lib/load-custom-routes'\nimport type { RouteMatchFn } from '../shared/lib/router/utils/route-matcher'\nimport type { NextConfig } from './config'\nimport type { BaseNextRequest } from './base-http'\nimport type { NextUrlWithParsedQuery } from './request-meta'\nimport type { ParsedUrlQuery } from 'querystring'\n\nimport { normalizeLocalePath } from '../shared/lib/i18n/normalize-locale-path'\nimport { getPathMatch } from '../shared/lib/router/utils/path-match'\nimport { getNamedRouteRegex } from '../shared/lib/router/utils/route-regex'\nimport { getRouteMatcher } from '../shared/lib/router/utils/route-matcher'\nimport {\n  matchHas,\n  prepareDestination,\n} from '../shared/lib/router/utils/prepare-destination'\nimport { removeTrailingSlash } from '../shared/lib/router/utils/remove-trailing-slash'\nimport { normalizeRscURL } from '../shared/lib/router/utils/app-paths'\nimport {\n  NEXT_CACHE_REVALIDATE_TAG_TOKEN_HEADER,\n  NEXT_CACHE_REVALIDATED_TAGS_HEADER,\n  NEXT_INTERCEPTION_MARKER_PREFIX,\n  NEXT_QUERY_PARAM_PREFIX,\n} from '../lib/constants'\nimport { normalizeNextQueryParam } from './web/utils'\nimport type { IncomingHttpHeaders, IncomingMessage } from 'http'\nimport { decodeQueryPathParameter } from './lib/decode-query-path-parameter'\nimport type { DeepReadonly } from '../shared/lib/deep-readonly'\nimport { parseReqUrl } from '../lib/url'\nimport { formatUrl } from '../shared/lib/router/utils/format-url'\n\nfunction filterInternalQuery(\n  query: Record<string, undefined | string | string[]>,\n  paramKeys: string[]\n) {\n  // this is used to pass query information in rewrites\n  // but should not be exposed in final query\n  delete query['nextInternalLocale']\n\n  for (const key in query) {\n    const isNextQueryPrefix =\n      key !== NEXT_QUERY_PARAM_PREFIX && key.startsWith(NEXT_QUERY_PARAM_PREFIX)\n\n    const isNextInterceptionMarkerPrefix =\n      key !== NEXT_INTERCEPTION_MARKER_PREFIX &&\n      key.startsWith(NEXT_INTERCEPTION_MARKER_PREFIX)\n\n    if (\n      isNextQueryPrefix ||\n      isNextInterceptionMarkerPrefix ||\n      paramKeys.includes(key)\n    ) {\n      delete query[key]\n    }\n  }\n}\n\nexport function normalizeCdnUrl(\n  req: BaseNextRequest | IncomingMessage,\n  paramKeys: string[]\n) {\n  // make sure to normalize req.url from CDNs to strip dynamic and rewrite\n  // params from the query which are added during routing\n  const _parsedUrl = parseReqUrl(req.url!)\n\n  // we can't normalize if we can't parse\n  if (!_parsedUrl) {\n    return req.url\n  }\n  delete (_parsedUrl as any).search\n  filterInternalQuery(_parsedUrl.query, paramKeys)\n\n  req.url = formatUrl(_parsedUrl)\n}\n\nexport function interpolateDynamicPath(\n  pathname: string,\n  params: ParsedUrlQuery,\n  defaultRouteRegex?: ReturnType<typeof getNamedRouteRegex> | undefined\n) {\n  if (!defaultRouteRegex) return pathname\n\n  for (const param of Object.keys(defaultRouteRegex.groups)) {\n    const { optional, repeat } = defaultRouteRegex.groups[param]\n    let builtParam = `[${repeat ? '...' : ''}${param}]`\n\n    if (optional) {\n      builtParam = `[${builtParam}]`\n    }\n\n    let paramValue: string\n    const value = params[param]\n\n    if (Array.isArray(value)) {\n      paramValue = value.map((v) => v && encodeURIComponent(v)).join('/')\n    } else if (value) {\n      paramValue = encodeURIComponent(value)\n    } else {\n      paramValue = ''\n    }\n\n    if (paramValue || optional) {\n      pathname = pathname.replaceAll(builtParam, paramValue)\n    }\n  }\n\n  return pathname\n}\n\nexport function normalizeDynamicRouteParams(\n  query: ParsedUrlQuery,\n  defaultRouteRegex: ReturnType<typeof getNamedRouteRegex>,\n  defaultRouteMatches: ParsedUrlQuery,\n  ignoreMissingOptional: boolean\n) {\n  const isDefaultValueMatch = (\n    candidateValue: string | undefined,\n    defaultValue: string\n  ) => {\n    if (!candidateValue) {\n      return false\n    }\n\n    let normalizedCandidateValue = normalizeRscURL(candidateValue)\n    for (let i = 0; i < 3; i++) {\n      if (normalizedCandidateValue === defaultValue) {\n        return true\n      }\n\n      const decodedCandidateValue = decodeQueryPathParameter(\n        normalizedCandidateValue\n      )\n\n      if (decodedCandidateValue === normalizedCandidateValue) {\n        break\n      }\n\n      normalizedCandidateValue = decodedCandidateValue\n    }\n\n    return false\n  }\n\n  let hasValidParams = true\n  let params: ParsedUrlQuery = {}\n\n  for (const key of Object.keys(defaultRouteRegex.groups)) {\n    let value: string | string[] | undefined = query[key]\n\n    if (typeof value === 'string') {\n      value = normalizeRscURL(value)\n    } else if (Array.isArray(value)) {\n      value = value.map(normalizeRscURL)\n    }\n\n    // if the value matches the default value we can't rely\n    // on the parsed params, this is used to signal if we need\n    // to parse x-now-route-matches or not\n    const defaultValue = defaultRouteMatches![key]\n    const isOptional = defaultRouteRegex!.groups[key].optional\n\n    const isDefaultValue = Array.isArray(defaultValue)\n      ? defaultValue.some((defaultVal) => {\n          return Array.isArray(value)\n            ? value.some((val) => isDefaultValueMatch(val, defaultVal))\n            : isDefaultValueMatch(value, defaultVal)\n        })\n      : Array.isArray(value)\n        ? value.some((val) => isDefaultValueMatch(val, defaultValue as string))\n        : isDefaultValueMatch(value, defaultValue as string)\n\n    if (\n      isDefaultValue ||\n      (typeof value === 'undefined' && !(isOptional && ignoreMissingOptional))\n    ) {\n      return { params: {}, hasValidParams: false }\n    }\n\n    // non-provided optional values should be undefined so normalize\n    // them to undefined\n    if (\n      isOptional &&\n      (!value ||\n        (Array.isArray(value) &&\n          value.length === 1 &&\n          // fallback optional catch-all SSG pages have\n          // [[...paramName]] for the root path on Vercel\n          (value[0] === 'index' || value[0] === `[[...${key}]]`)) ||\n        value === 'index' ||\n        value === `[[...${key}]]`)\n    ) {\n      value = undefined\n      delete query[key]\n    }\n\n    // query values from the proxy aren't already split into arrays\n    // so make sure to normalize catch-all values\n    if (\n      value &&\n      typeof value === 'string' &&\n      defaultRouteRegex!.groups[key].repeat\n    ) {\n      value = value.split('/')\n    }\n\n    if (value) {\n      params[key] = value\n    }\n  }\n\n  return {\n    params,\n    hasValidParams,\n  }\n}\n\nexport function getServerUtils({\n  page,\n  i18n,\n  basePath,\n  rewrites,\n  pageIsDynamic,\n  trailingSlash,\n  caseSensitive,\n}: {\n  page: string\n  i18n?: NextConfig['i18n']\n  basePath: string\n  rewrites: DeepReadonly<{\n    fallback?: ReadonlyArray<Rewrite>\n    afterFiles?: ReadonlyArray<Rewrite>\n    beforeFiles?: ReadonlyArray<Rewrite>\n  }>\n  pageIsDynamic: boolean\n  trailingSlash?: boolean\n  caseSensitive: boolean\n}) {\n  let defaultRouteRegex: ReturnType<typeof getNamedRouteRegex> | undefined\n  let dynamicRouteMatcher: RouteMatchFn | undefined\n  let defaultRouteMatches: ParsedUrlQuery | undefined\n\n  if (pageIsDynamic) {\n    defaultRouteRegex = getNamedRouteRegex(page, {\n      prefixRouteKeys: false,\n    })\n    dynamicRouteMatcher = getRouteMatcher(defaultRouteRegex)\n    defaultRouteMatches = dynamicRouteMatcher(page) as ParsedUrlQuery\n  }\n\n  function handleRewrites(\n    req: BaseNextRequest | IncomingMessage,\n    parsedUrl: DeepReadonly<NextUrlWithParsedQuery>\n  ) {\n    // Here we deep clone the parsedUrl to avoid mutating the original. We also\n    // cast this to a mutable type so we can mutate it within this scope.\n    const rewrittenParsedUrl = structuredClone(\n      parsedUrl\n    ) as NextUrlWithParsedQuery\n    const rewriteParams: Record<string, string> = {}\n    let fsPathname = rewrittenParsedUrl.pathname\n\n    const matchesPage = () => {\n      const fsPathnameNoSlash = removeTrailingSlash(fsPathname || '')\n      return (\n        fsPathnameNoSlash === removeTrailingSlash(page) ||\n        dynamicRouteMatcher?.(fsPathnameNoSlash)\n      )\n    }\n\n    const checkRewrite = (rewrite: DeepReadonly<Rewrite>): boolean => {\n      const matcher = getPathMatch(\n        rewrite.source + (trailingSlash ? '(/)?' : ''),\n        {\n          removeUnnamedParams: true,\n          strict: true,\n          sensitive: !!caseSensitive,\n        }\n      )\n\n      if (!rewrittenParsedUrl.pathname) return false\n\n      let params = matcher(rewrittenParsedUrl.pathname)\n\n      if ((rewrite.has || rewrite.missing) && params) {\n        const hasParams = matchHas(\n          req,\n          rewrittenParsedUrl.query,\n          rewrite.has as Rewrite['has'],\n          rewrite.missing as Rewrite['missing']\n        )\n\n        if (hasParams) {\n          Object.assign(params, hasParams)\n        } else {\n          params = false\n        }\n      }\n\n      if (params) {\n        const { parsedDestination, destQuery } = prepareDestination({\n          appendParamsToQuery: true,\n          destination: rewrite.destination,\n          params: params,\n          query: rewrittenParsedUrl.query,\n        })\n\n        // if the rewrite destination is external break rewrite chain\n        if (parsedDestination.protocol) {\n          return true\n        }\n\n        Object.assign(rewriteParams, destQuery, params)\n        Object.assign(rewrittenParsedUrl.query, parsedDestination.query)\n        delete (parsedDestination as any).query\n\n        Object.assign(rewrittenParsedUrl, parsedDestination)\n\n        fsPathname = rewrittenParsedUrl.pathname\n        if (!fsPathname) return false\n\n        if (basePath) {\n          fsPathname = fsPathname.replace(new RegExp(`^${basePath}`), '') || '/'\n        }\n\n        if (i18n) {\n          const result = normalizeLocalePath(fsPathname, i18n.locales)\n          fsPathname = result.pathname\n          rewrittenParsedUrl.query.nextInternalLocale =\n            result.detectedLocale || params.nextInternalLocale\n        }\n\n        if (fsPathname === page) {\n          return true\n        }\n\n        if (pageIsDynamic && dynamicRouteMatcher) {\n          const dynamicParams = dynamicRouteMatcher(fsPathname)\n          if (dynamicParams) {\n            rewrittenParsedUrl.query = {\n              ...rewrittenParsedUrl.query,\n              ...dynamicParams,\n            }\n            return true\n          }\n        }\n      }\n\n      return false\n    }\n\n    for (const rewrite of rewrites.beforeFiles || []) {\n      checkRewrite(rewrite)\n    }\n\n    if (fsPathname !== page) {\n      let finished = false\n\n      for (const rewrite of rewrites.afterFiles || []) {\n        finished = checkRewrite(rewrite)\n        if (finished) break\n      }\n\n      if (!finished && !matchesPage()) {\n        for (const rewrite of rewrites.fallback || []) {\n          finished = checkRewrite(rewrite)\n          if (finished) break\n        }\n      }\n    }\n\n    return { rewriteParams, rewrittenParsedUrl }\n  }\n\n  function getParamsFromRouteMatches(routeMatchesHeader: string) {\n    // If we don't have a default route regex, we can't get params from route\n    // matches\n    if (!defaultRouteRegex) return null\n\n    const { groups, routeKeys } = defaultRouteRegex\n\n    const matcher = getRouteMatcher({\n      re: {\n        // Simulate a RegExp match from the \\`req.url\\` input\n        exec: (str: string) => {\n          // Normalize all the prefixed query params.\n          const obj: Record<string, string> = Object.fromEntries(\n            new URLSearchParams(str)\n          )\n          for (const [key, value] of Object.entries(obj)) {\n            const normalizedKey = normalizeNextQueryParam(key)\n            if (!normalizedKey) continue\n\n            obj[normalizedKey] = value\n            delete obj[key]\n          }\n\n          // Use all the named route keys.\n          const result = {} as RegExpExecArray\n          for (const keyName of Object.keys(routeKeys)) {\n            const paramName = routeKeys[keyName]\n\n            // If this param name is not a valid parameter name, then skip it.\n            if (!paramName) continue\n\n            const group = groups[paramName]\n            const value = obj[keyName]\n\n            // When we're missing a required param, we can't match the route.\n            if (!group.optional && !value) return null\n\n            result[group.pos] = value\n          }\n\n          return result\n        },\n      },\n      groups,\n    })\n\n    const routeMatches = matcher(routeMatchesHeader)\n    if (!routeMatches) return null\n\n    return routeMatches\n  }\n\n  function normalizeQueryParams(\n    query: Record<string, string | string[] | undefined>,\n    routeParamKeys: Set<string>\n  ) {\n    // this is used to pass query information in rewrites\n    // but should not be exposed in final query\n    delete query['nextInternalLocale']\n\n    for (const [key, value] of Object.entries(query)) {\n      const normalizedKey = normalizeNextQueryParam(key)\n      if (!normalizedKey) continue\n\n      // Remove the prefixed key from the query params because we want\n      // to consume it for the dynamic route matcher.\n      delete query[key]\n      routeParamKeys.add(normalizedKey)\n\n      if (typeof value === 'undefined') continue\n\n      query[normalizedKey] = Array.isArray(value)\n        ? value.map((v) => decodeQueryPathParameter(v))\n        : decodeQueryPathParameter(value)\n    }\n  }\n\n  return {\n    handleRewrites,\n    defaultRouteRegex,\n    dynamicRouteMatcher,\n    defaultRouteMatches,\n    normalizeQueryParams,\n    getParamsFromRouteMatches,\n    /**\n     * Normalize dynamic route params.\n     *\n     * @param query - The query params to normalize.\n     * @param ignoreMissingOptional - Whether to ignore missing optional params.\n     * @returns The normalized params and whether they are valid.\n     */\n    normalizeDynamicRouteParams: (\n      query: ParsedUrlQuery,\n      ignoreMissingOptional: boolean\n    ) => {\n      if (!defaultRouteRegex || !defaultRouteMatches) {\n        return { params: {}, hasValidParams: false }\n      }\n\n      return normalizeDynamicRouteParams(\n        query,\n        defaultRouteRegex,\n        defaultRouteMatches,\n        ignoreMissingOptional\n      )\n    },\n\n    normalizeCdnUrl: (\n      req: BaseNextRequest | IncomingMessage,\n      paramKeys: string[]\n    ) => normalizeCdnUrl(req, paramKeys),\n\n    interpolateDynamicPath: (\n      pathname: string,\n      params: Record<string, undefined | string | string[]>\n    ) => interpolateDynamicPath(pathname, params, defaultRouteRegex),\n\n    filterInternalQuery: (query: ParsedUrlQuery, paramKeys: string[]) =>\n      filterInternalQuery(query, paramKeys),\n  }\n}\n\nexport function getPreviouslyRevalidatedTags(\n  headers: IncomingHttpHeaders,\n  previewModeId: string | undefined\n): string[] {\n  return typeof headers[NEXT_CACHE_REVALIDATED_TAGS_HEADER] === 'string' &&\n    headers[NEXT_CACHE_REVALIDATE_TAG_TOKEN_HEADER] === previewModeId\n    ? headers[NEXT_CACHE_REVALIDATED_TAGS_HEADER].split(',')\n    : []\n}\n"],"names":["normalizeLocalePath","getPathMatch","getNamedRouteRegex","getRouteMatcher","matchHas","prepareDestination","removeTrailingSlash","normalizeRscURL","NEXT_CACHE_REVALIDATE_TAG_TOKEN_HEADER","NEXT_CACHE_REVALIDATED_TAGS_HEADER","NEXT_INTERCEPTION_MARKER_PREFIX","NEXT_QUERY_PARAM_PREFIX","normalizeNextQueryParam","decodeQueryPathParameter","parseReqUrl","formatUrl","filterInternalQuery","query","paramKeys","key","isNextQueryPrefix","startsWith","isNextInterceptionMarkerPrefix","includes","normalizeCdnUrl","req","_parsedUrl","url","search","interpolateDynamicPath","pathname","params","defaultRouteRegex","param","Object","keys","groups","optional","repeat","builtParam","paramValue","value","Array","isArray","map","v","encodeURIComponent","join","replaceAll","normalizeDynamicRouteParams","defaultRouteMatches","ignoreMissingOptional","isDefaultValueMatch","candidateValue","defaultValue","normalizedCandidateValue","i","decodedCandidateValue","hasValidParams","isOptional","isDefaultValue","some","defaultVal","val","length","undefined","split","getServerUtils","page","i18n","basePath","rewrites","pageIsDynamic","trailingSlash","caseSensitive","dynamicRouteMatcher","prefixRouteKeys","handleRewrites","parsedUrl","rewrittenParsedUrl","structuredClone","rewriteParams","fsPathname","matchesPage","fsPathnameNoSlash","checkRewrite","rewrite","matcher","source","removeUnnamedParams","strict","sensitive","has","missing","hasParams","assign","parsedDestination","destQuery","appendParamsToQuery","destination","protocol","replace","RegExp","result","locales","nextInternalLocale","detectedLocale","dynamicParams","beforeFiles","finished","afterFiles","fallback","getParamsFromRouteMatches","routeMatchesHeader","routeKeys","re","exec","str","obj","fromEntries","URLSearchParams","entries","normalizedKey","keyName","paramName","group","pos","routeMatches","normalizeQueryParams","routeParamKeys","add","getPreviouslyRevalidatedTags","headers","previewModeId"],"mappings":"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","ignoreList":[0]}