// tslint:disable:no-console "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); 0 && (module.exports = { default: null, matchesMiddleware: null, createKey: null }); function _export(target, all) { for(var name in all)Object.defineProperty(target, name, { enumerable: true, get: all[name] }); } _export(exports, { default: function() { return Router; }, matchesMiddleware: function() { return matchesMiddleware; }, createKey: function() { return createKey; } }); const _interop_require_default = require("@swc/helpers/_/_interop_require_default"); const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard"); const _removetrailingslash = require("./utils/remove-trailing-slash"); const _routeloader = require("../../../client/route-loader"); const _script = require("../../../client/script"); const _iserror = /*#__PURE__*/ _interop_require_wildcard._(require("../../../lib/is-error")); const _denormalizepagepath = require("../page-path/denormalize-page-path"); const _normalizelocalepath = require("../i18n/normalize-locale-path"); const _mitt = /*#__PURE__*/ _interop_require_default._(require("../mitt")); const _utils = require("../utils"); const _isdynamic = require("./utils/is-dynamic"); const _parserelativeurl = require("./utils/parse-relative-url"); const _resolverewrites = /*#__PURE__*/ _interop_require_default._(require("./utils/resolve-rewrites")); const _routematcher = require("./utils/route-matcher"); const _routeregex = require("./utils/route-regex"); const _formaturl = require("./utils/format-url"); const _detectdomainlocale = require("../../../client/detect-domain-locale"); const _parsepath = require("./utils/parse-path"); const _addlocale = require("../../../client/add-locale"); const _removelocale = require("../../../client/remove-locale"); const _removebasepath = require("../../../client/remove-base-path"); const _addbasepath = require("../../../client/add-base-path"); const _hasbasepath = require("../../../client/has-base-path"); const _resolvehref = require("../../../client/resolve-href"); const _isapiroute = require("../../../lib/is-api-route"); const _getnextpathnameinfo = require("./utils/get-next-pathname-info"); const _formatnextpathnameinfo = require("./utils/format-next-pathname-info"); const _comparestates = require("./utils/compare-states"); const _islocalurl = require("./utils/is-local-url"); const _isbot = require("./utils/is-bot"); const _omit = require("./utils/omit"); const _interpolateas = require("./utils/interpolate-as"); const _handlesmoothscroll = require("./utils/handle-smooth-scroll"); function buildCancellationError() { return Object.assign(new Error("Route Cancelled"), { cancelled: true }); } async function matchesMiddleware(options) { const matchers = await Promise.resolve(options.router.pageLoader.getMiddleware()); if (!matchers) return false; const { pathname: asPathname } = (0, _parsepath.parsePath)(options.asPath); // remove basePath first since path prefix has to be in the order of `/${basePath}/${locale}` const cleanedAs = (0, _hasbasepath.hasBasePath)(asPathname) ? (0, _removebasepath.removeBasePath)(asPathname) : asPathname; const asWithBasePathAndLocale = (0, _addbasepath.addBasePath)((0, _addlocale.addLocale)(cleanedAs, options.locale)); // Check only path match on client. Matching "has" should be done on server // where we can access more info such as headers, HttpOnly cookie, etc. return matchers.some((m)=>new RegExp(m.regexp).test(asWithBasePathAndLocale)); } function stripOrigin(url) { const origin = (0, _utils.getLocationOrigin)(); return url.startsWith(origin) ? url.substring(origin.length) : url; } function prepareUrlAs(router, url, as) { // If url and as provided as an object representation, // we'll format them into the string version here. let [resolvedHref, resolvedAs] = (0, _resolvehref.resolveHref)(router, url, true); const origin = (0, _utils.getLocationOrigin)(); const hrefWasAbsolute = resolvedHref.startsWith(origin); const asWasAbsolute = resolvedAs && resolvedAs.startsWith(origin); resolvedHref = stripOrigin(resolvedHref); resolvedAs = resolvedAs ? stripOrigin(resolvedAs) : resolvedAs; const preparedUrl = hrefWasAbsolute ? resolvedHref : (0, _addbasepath.addBasePath)(resolvedHref); const preparedAs = as ? stripOrigin((0, _resolvehref.resolveHref)(router, as)) : resolvedAs || resolvedHref; return { url: preparedUrl, as: asWasAbsolute ? preparedAs : (0, _addbasepath.addBasePath)(preparedAs) }; } function resolveDynamicRoute(pathname, pages) { const cleanPathname = (0, _removetrailingslash.removeTrailingSlash)((0, _denormalizepagepath.denormalizePagePath)(pathname)); if (cleanPathname === "/404" || cleanPathname === "/_error") { return pathname; } // handle resolving href for dynamic routes if (!pages.includes(cleanPathname)) { // eslint-disable-next-line array-callback-return pages.some((page)=>{ if ((0, _isdynamic.isDynamicRoute)(page) && (0, _routeregex.getRouteRegex)(page).re.test(cleanPathname)) { pathname = page; return true; } }); } return (0, _removetrailingslash.removeTrailingSlash)(pathname); } function getMiddlewareData(source, response, options) { const nextConfig = { basePath: options.router.basePath, i18n: { locales: options.router.locales }, trailingSlash: Boolean(process.env.__NEXT_TRAILING_SLASH) }; const rewriteHeader = response.headers.get("x-nextjs-rewrite"); let rewriteTarget = rewriteHeader || response.headers.get("x-nextjs-matched-path"); const matchedPath = response.headers.get("x-matched-path"); if (matchedPath && !rewriteTarget && !matchedPath.includes("__next_data_catchall") && !matchedPath.includes("/_error") && !matchedPath.includes("/404")) { // leverage x-matched-path to detect next.config.js rewrites rewriteTarget = matchedPath; } if (rewriteTarget) { if (rewriteTarget.startsWith("/") || process.env.__NEXT_EXTERNAL_MIDDLEWARE_REWRITE_RESOLVE) { const parsedRewriteTarget = (0, _parserelativeurl.parseRelativeUrl)(rewriteTarget); const pathnameInfo = (0, _getnextpathnameinfo.getNextPathnameInfo)(parsedRewriteTarget.pathname, { nextConfig, parseData: true }); let fsPathname = (0, _removetrailingslash.removeTrailingSlash)(pathnameInfo.pathname); return Promise.all([ options.router.pageLoader.getPageList(), (0, _routeloader.getClientBuildManifest)() ]).then((param)=>{ let [pages, { __rewrites: rewrites }] = param; let as = (0, _addlocale.addLocale)(pathnameInfo.pathname, pathnameInfo.locale); if ((0, _isdynamic.isDynamicRoute)(as) || !rewriteHeader && pages.includes((0, _normalizelocalepath.normalizeLocalePath)((0, _removebasepath.removeBasePath)(as), options.router.locales).pathname)) { const parsedSource = (0, _getnextpathnameinfo.getNextPathnameInfo)((0, _parserelativeurl.parseRelativeUrl)(source).pathname, { nextConfig: process.env.__NEXT_HAS_REWRITES ? undefined : nextConfig, parseData: true }); as = (0, _addbasepath.addBasePath)(parsedSource.pathname); parsedRewriteTarget.pathname = as; } if (process.env.__NEXT_HAS_REWRITES) { const result = (0, _resolverewrites.default)(as, pages, rewrites, parsedRewriteTarget.query, (path)=>resolveDynamicRoute(path, pages), options.router.locales); if (result.matchedPage) { parsedRewriteTarget.pathname = result.parsedAs.pathname; as = parsedRewriteTarget.pathname; Object.assign(parsedRewriteTarget.query, result.parsedAs.query); } } else if (!pages.includes(fsPathname)) { const resolvedPathname = resolveDynamicRoute(fsPathname, pages); if (resolvedPathname !== fsPathname) { fsPathname = resolvedPathname; } } const resolvedHref = !pages.includes(fsPathname) ? resolveDynamicRoute((0, _normalizelocalepath.normalizeLocalePath)((0, _removebasepath.removeBasePath)(parsedRewriteTarget.pathname), options.router.locales).pathname, pages) : fsPathname; if ((0, _isdynamic.isDynamicRoute)(resolvedHref)) { const matches = (0, _routematcher.getRouteMatcher)((0, _routeregex.getRouteRegex)(resolvedHref))(as); Object.assign(parsedRewriteTarget.query, matches || {}); } return { type: "rewrite", parsedAs: parsedRewriteTarget, resolvedHref }; }); } const src = (0, _parsepath.parsePath)(source); const pathname = (0, _formatnextpathnameinfo.formatNextPathnameInfo)({ ...(0, _getnextpathnameinfo.getNextPathnameInfo)(src.pathname, { nextConfig, parseData: true }), defaultLocale: options.router.defaultLocale, buildId: "" }); return Promise.resolve({ type: "redirect-external", destination: "" + pathname + src.query + src.hash }); } const redirectTarget = response.headers.get("x-nextjs-redirect"); if (redirectTarget) { if (redirectTarget.startsWith("/")) { const src = (0, _parsepath.parsePath)(redirectTarget); const pathname = (0, _formatnextpathnameinfo.formatNextPathnameInfo)({ ...(0, _getnextpathnameinfo.getNextPathnameInfo)(src.pathname, { nextConfig, parseData: true }), defaultLocale: options.router.defaultLocale, buildId: "" }); return Promise.resolve({ type: "redirect-internal", newAs: "" + pathname + src.query + src.hash, newUrl: "" + pathname + src.query + src.hash }); } return Promise.resolve({ type: "redirect-external", destination: redirectTarget }); } return Promise.resolve({ type: "next" }); } async function withMiddlewareEffects(options) { const matches = await matchesMiddleware(options); if (!matches || !options.fetchData) { return null; } try { const data = await options.fetchData(); const effect = await getMiddlewareData(data.dataHref, data.response, options); return { dataHref: data.dataHref, json: data.json, response: data.response, text: data.text, cacheKey: data.cacheKey, effect }; } catch (e) { /** * TODO: Revisit this in the future. * For now we will not consider middleware data errors to be fatal. * maybe we should revisit in the future. */ return null; } } const manualScrollRestoration = process.env.__NEXT_SCROLL_RESTORATION && typeof window !== "undefined" && "scrollRestoration" in window.history && !!function() { try { let v = "__next"; // eslint-disable-next-line no-sequences return sessionStorage.setItem(v, v), sessionStorage.removeItem(v), true; } catch (n) {} }(); const SSG_DATA_NOT_FOUND = Symbol("SSG_DATA_NOT_FOUND"); function fetchRetry(url, attempts, options) { return fetch(url, { // Cookies are required to be present for Next.js' SSG "Preview Mode". // Cookies may also be required for `getServerSideProps`. // // > `fetch` won’t send cookies, unless you set the credentials init // > option. // https://developer.mozilla.org/docs/Web/API/Fetch_API/Using_Fetch // // > For maximum browser compatibility when it comes to sending & // > receiving cookies, always supply the `credentials: 'same-origin'` // > option instead of relying on the default. // https://github.com/github/fetch#caveats credentials: "same-origin", method: options.method || "GET", headers: Object.assign({}, options.headers, { "x-nextjs-data": "1" }) }).then((response)=>{ return !response.ok && attempts > 1 && response.status >= 500 ? fetchRetry(url, attempts - 1, options) : response; }); } function tryToParseAsJSON(text) { try { return JSON.parse(text); } catch (error) { return null; } } function fetchNextData(param) { let { dataHref, inflightCache, isPrefetch, hasMiddleware, isServerRender, parseJSON, persistCache, isBackground, unstable_skipClientCache } = param; const { href: cacheKey } = new URL(dataHref, window.location.href); var _params_method; const getData = (params)=>fetchRetry(dataHref, isServerRender ? 3 : 1, { headers: Object.assign({}, isPrefetch ? { purpose: "prefetch" } : {}, isPrefetch && hasMiddleware ? { "x-middleware-prefetch": "1" } : {}), method: (_params_method = params == null ? void 0 : params.method) != null ? _params_method : "GET" }).then((response)=>{ if (response.ok && (params == null ? void 0 : params.method) === "HEAD") { return { dataHref, response, text: "", json: {}, cacheKey }; } return response.text().then((text)=>{ if (!response.ok) { /** * When the data response is a redirect because of a middleware * we do not consider it an error. The headers must bring the * mapped location. * TODO: Change the status code in the handler. */ if (hasMiddleware && [ 301, 302, 307, 308 ].includes(response.status)) { return { dataHref, response, text, json: {}, cacheKey }; } if (response.status === 404) { var _tryToParseAsJSON; if ((_tryToParseAsJSON = tryToParseAsJSON(text)) == null ? void 0 : _tryToParseAsJSON.notFound) { return { dataHref, json: { notFound: SSG_DATA_NOT_FOUND }, response, text, cacheKey }; } } const error = new Error("Failed to load static props"); /** * We should only trigger a server-side transition if this was * caused on a client-side transition. Otherwise, we'd get into * an infinite loop. */ if (!isServerRender) { (0, _routeloader.markAssetError)(error); } throw error; } return { dataHref, json: parseJSON ? tryToParseAsJSON(text) : null, response, text, cacheKey }; }); }).then((data)=>{ if (!persistCache || process.env.NODE_ENV !== "production" || data.response.headers.get("x-middleware-cache") === "no-cache") { delete inflightCache[cacheKey]; } return data; }).catch((err)=>{ if (!unstable_skipClientCache) { delete inflightCache[cacheKey]; } if (// chrome err.message === "Failed to fetch" || // firefox err.message === "NetworkError when attempting to fetch resource." || // safari err.message === "Load failed") { (0, _routeloader.markAssetError)(err); } throw err; }); // when skipping client cache we wait to update // inflight cache until successful data response // this allows racing click event with fetching newer data // without blocking navigation when stale data is available if (unstable_skipClientCache && persistCache) { return getData({}).then((data)=>{ inflightCache[cacheKey] = Promise.resolve(data); return data; }); } if (inflightCache[cacheKey] !== undefined) { return inflightCache[cacheKey]; } return inflightCache[cacheKey] = getData(isBackground ? { method: "HEAD" } : {}); } function createKey() { return Math.random().toString(36).slice(2, 10); } function handleHardNavigation(param) { let { url, router } = param; // ensure we don't trigger a hard navigation to the same // URL as this can end up with an infinite refresh if (url === (0, _addbasepath.addBasePath)((0, _addlocale.addLocale)(router.asPath, router.locale))) { throw new Error("Invariant: attempted to hard navigate to the same URL " + url + " " + location.href); } window.location.href = url; } const getCancelledHandler = (param)=>{ let { route, router } = param; let cancelled = false; const cancel = router.clc = ()=>{ cancelled = true; }; const handleCancelled = ()=>{ if (cancelled) { const error = new Error('Abort fetching component for route: "' + route + '"'); error.cancelled = true; throw error; } if (cancel === router.clc) { router.clc = null; } }; return handleCancelled; }; class Router { reload() { window.location.reload(); } /** * Go back in history */ back() { window.history.back(); } /** * Go forward in history */ forward() { window.history.forward(); } /** * Performs a `pushState` with arguments * @param url of the route * @param as masks `url` for the browser * @param options object you can define `shallow` and other options */ push(url, as, options) { if (options === void 0) options = {}; if (process.env.__NEXT_SCROLL_RESTORATION) { // TODO: remove in the future when we update history before route change // is complete, as the popstate event should handle this capture. if (manualScrollRestoration) { try { // Snapshot scroll position right before navigating to a new page: sessionStorage.setItem("__next_scroll_" + this._key, JSON.stringify({ x: self.pageXOffset, y: self.pageYOffset })); } catch (e) {} } } ({ url, as } = prepareUrlAs(this, url, as)); return this.change("pushState", url, as, options); } /** * Performs a `replaceState` with arguments * @param url of the route * @param as masks `url` for the browser * @param options object you can define `shallow` and other options */ replace(url, as, options) { if (options === void 0) options = {}; ({ url, as } = prepareUrlAs(this, url, as)); return this.change("replaceState", url, as, options); } async _bfl(as, resolvedAs, locale, skipNavigate) { if (process.env.__NEXT_CLIENT_ROUTER_FILTER_ENABLED) { let matchesBflStatic = false; let matchesBflDynamic = false; for (const curAs of [ as, resolvedAs ]){ if (curAs) { const asNoSlash = (0, _removetrailingslash.removeTrailingSlash)(new URL(curAs, "http://n").pathname); const asNoSlashLocale = (0, _addbasepath.addBasePath)((0, _addlocale.addLocale)(asNoSlash, locale || this.locale)); if (asNoSlash !== (0, _removetrailingslash.removeTrailingSlash)(new URL(this.asPath, "http://n").pathname)) { var _this__bfl_s, _this__bfl_s1; matchesBflStatic = matchesBflStatic || !!((_this__bfl_s = this._bfl_s) == null ? void 0 : _this__bfl_s.contains(asNoSlash)) || !!((_this__bfl_s1 = this._bfl_s) == null ? void 0 : _this__bfl_s1.contains(asNoSlashLocale)); for (const normalizedAS of [ asNoSlash, asNoSlashLocale ]){ // if any sub-path of as matches a dynamic filter path // it should be hard navigated const curAsParts = normalizedAS.split("/"); for(let i = 0; !matchesBflDynamic && i < curAsParts.length + 1; i++){ var _this__bfl_d; const currentPart = curAsParts.slice(0, i).join("/"); if (currentPart && ((_this__bfl_d = this._bfl_d) == null ? void 0 : _this__bfl_d.contains(currentPart))) { matchesBflDynamic = true; break; } } } // if the client router filter is matched then we trigger // a hard navigation if (matchesBflStatic || matchesBflDynamic) { if (skipNavigate) { return true; } handleHardNavigation({ url: (0, _addbasepath.addBasePath)((0, _addlocale.addLocale)(as, locale || this.locale, this.defaultLocale)), router: this }); return new Promise(()=>{}); } } } } } return false; } async change(method, url, as, options, forcedScroll) { var _this_components_pathname; if (!(0, _islocalurl.isLocalURL)(url)) { handleHardNavigation({ url, router: this }); return false; } // WARNING: `_h` is an internal option for handing Next.js client-side // hydration. Your app should _never_ use this property. It may change at // any time without notice. const isQueryUpdating = options._h === 1; if (!isQueryUpdating && !options.shallow) { await this._bfl(as, undefined, options.locale); } let shouldResolveHref = isQueryUpdating || options._shouldResolveHref || (0, _parsepath.parsePath)(url).pathname === (0, _parsepath.parsePath)(as).pathname; const nextState = { ...this.state }; // for static pages with query params in the URL we delay // marking the router ready until after the query is updated // or a navigation has occurred const readyStateChange = this.isReady !== true; this.isReady = true; const isSsr = this.isSsr; if (!isQueryUpdating) { this.isSsr = false; } // if a route transition is already in progress before // the query updating is triggered ignore query updating if (isQueryUpdating && this.clc) { return false; } const prevLocale = nextState.locale; if (process.env.__NEXT_I18N_SUPPORT) { nextState.locale = options.locale === false ? this.defaultLocale : options.locale || nextState.locale; if (typeof options.locale === "undefined") { options.locale = nextState.locale; } const parsedAs = (0, _parserelativeurl.parseRelativeUrl)((0, _hasbasepath.hasBasePath)(as) ? (0, _removebasepath.removeBasePath)(as) : as); const localePathResult = (0, _normalizelocalepath.normalizeLocalePath)(parsedAs.pathname, this.locales); if (localePathResult.detectedLocale) { nextState.locale = localePathResult.detectedLocale; parsedAs.pathname = (0, _addbasepath.addBasePath)(parsedAs.pathname); as = (0, _formaturl.formatWithValidation)(parsedAs); url = (0, _addbasepath.addBasePath)((0, _normalizelocalepath.normalizeLocalePath)((0, _hasbasepath.hasBasePath)(url) ? (0, _removebasepath.removeBasePath)(url) : url, this.locales).pathname); } let didNavigate = false; // we need to wrap this in the env check again since regenerator runtime // moves this on its own due to the return if (process.env.__NEXT_I18N_SUPPORT) { var _this_locales; // if the locale isn't configured hard navigate to show 404 page if (!((_this_locales = this.locales) == null ? void 0 : _this_locales.includes(nextState.locale))) { parsedAs.pathname = (0, _addlocale.addLocale)(parsedAs.pathname, nextState.locale); handleHardNavigation({ url: (0, _formaturl.formatWithValidation)(parsedAs), router: this }); // this was previously a return but was removed in favor // of better dead code elimination with regenerator runtime didNavigate = true; } } const detectedDomain = (0, _detectdomainlocale.detectDomainLocale)(this.domainLocales, undefined, nextState.locale); // we need to wrap this in the env check again since regenerator runtime // moves this on its own due to the return if (process.env.__NEXT_I18N_SUPPORT) { // if we are navigating to a domain locale ensure we redirect to the // correct domain if (!didNavigate && detectedDomain && this.isLocaleDomain && self.location.hostname !== detectedDomain.domain) { const asNoBasePath = (0, _removebasepath.removeBasePath)(as); handleHardNavigation({ url: "http" + (detectedDomain.http ? "" : "s") + "://" + detectedDomain.domain + (0, _addbasepath.addBasePath)("" + (nextState.locale === detectedDomain.defaultLocale ? "" : "/" + nextState.locale) + (asNoBasePath === "/" ? "" : asNoBasePath) || "/"), router: this }); // this was previously a return but was removed in favor // of better dead code elimination with regenerator runtime didNavigate = true; } } if (didNavigate) { return new Promise(()=>{}); } } // marking route changes as a navigation start entry if (_utils.ST) { performance.mark("routeChange"); } const { shallow = false, scroll = true } = options; const routeProps = { shallow }; if (this._inFlightRoute && this.clc) { if (!isSsr) { Router.events.emit("routeChangeError", buildCancellationError(), this._inFlightRoute, routeProps); } this.clc(); this.clc = null; } as = (0, _addbasepath.addBasePath)((0, _addlocale.addLocale)((0, _hasbasepath.hasBasePath)(as) ? (0, _removebasepath.removeBasePath)(as) : as, options.locale, this.defaultLocale)); const cleanedAs = (0, _removelocale.removeLocale)((0, _hasbasepath.hasBasePath)(as) ? (0, _removebasepath.removeBasePath)(as) : as, nextState.locale); this._inFlightRoute = as; const localeChange = prevLocale !== nextState.locale; // If the url change is only related to a hash change // We should not proceed. We should only change the state. if (!isQueryUpdating && this.onlyAHashChange(cleanedAs) && !localeChange) { nextState.asPath = cleanedAs; Router.events.emit("hashChangeStart", as, routeProps); // TODO: do we need the resolved href when only a hash change? this.changeState(method, url, as, { ...options, scroll: false }); if (scroll) { this.scrollToHash(cleanedAs); } try { await this.set(nextState, this.components[nextState.route], null); } catch (err) { if ((0, _iserror.default)(err) && err.cancelled) { Router.events.emit("routeChangeError", err, cleanedAs, routeProps); } throw err; } Router.events.emit("hashChangeComplete", as, routeProps); return true; } let parsed = (0, _parserelativeurl.parseRelativeUrl)(url); let { pathname, query } = parsed; // if we detected the path as app route during prefetching // trigger hard navigation if ((_this_components_pathname = this.components[pathname]) == null ? void 0 : _this_components_pathname.__appRouter) { handleHardNavigation({ url: as, router: this }); return new Promise(()=>{}); } // The build manifest needs to be loaded before auto-static dynamic pages // get their query parameters to allow ensuring they can be parsed properly // when rewritten to let pages, rewrites; try { [pages, { __rewrites: rewrites }] = await Promise.all([ this.pageLoader.getPageList(), (0, _routeloader.getClientBuildManifest)(), this.pageLoader.getMiddleware() ]); } catch (err) { // If we fail to resolve the page list or client-build manifest, we must // do a server-side transition: handleHardNavigation({ url: as, router: this }); return false; } // If asked to change the current URL we should reload the current page // (not location.reload() but reload getInitialProps and other Next.js stuffs) // We also need to set the method = replaceState always // as this should not go into the history (That's how browsers work) // We should compare the new asPath to the current asPath, not the url if (!this.urlIsNew(cleanedAs) && !localeChange) { method = "replaceState"; } // we need to resolve the as value using rewrites for dynamic SSG // pages to allow building the data URL correctly let resolvedAs = as; // url and as should always be prefixed with basePath by this // point by either next/link or router.push/replace so strip the // basePath from the pathname to match the pages dir 1-to-1 pathname = pathname ? (0, _removetrailingslash.removeTrailingSlash)((0, _removebasepath.removeBasePath)(pathname)) : pathname; let route = (0, _removetrailingslash.removeTrailingSlash)(pathname); const parsedAsPathname = as.startsWith("/") && (0, _parserelativeurl.parseRelativeUrl)(as).pathname; const isMiddlewareRewrite = !!(parsedAsPathname && route !== parsedAsPathname && (!(0, _isdynamic.isDynamicRoute)(route) || !(0, _routematcher.getRouteMatcher)((0, _routeregex.getRouteRegex)(route))(parsedAsPathname))); // we don't attempt resolve asPath when we need to execute // middleware as the resolving will occur server-side const isMiddlewareMatch = !options.shallow && await matchesMiddleware({ asPath: as, locale: nextState.locale, router: this }); if (isQueryUpdating && isMiddlewareMatch) { shouldResolveHref = false; } if (shouldResolveHref && pathname !== "/_error") { options._shouldResolveHref = true; if (process.env.__NEXT_HAS_REWRITES && as.startsWith("/")) { const rewritesResult = (0, _resolverewrites.default)((0, _addbasepath.addBasePath)((0, _addlocale.addLocale)(cleanedAs, nextState.locale), true), pages, rewrites, query, (p)=>resolveDynamicRoute(p, pages), this.locales); if (rewritesResult.externalDest) { handleHardNavigation({ url: as, router: this }); return true; } if (!isMiddlewareMatch) { resolvedAs = rewritesResult.asPath; } if (rewritesResult.matchedPage && rewritesResult.resolvedHref) { // if this directly matches a page we need to update the href to // allow the correct page chunk to be loaded pathname = rewritesResult.resolvedHref; parsed.pathname = (0, _addbasepath.addBasePath)(pathname); if (!isMiddlewareMatch) { url = (0, _formaturl.formatWithValidation)(parsed); } } } else { parsed.pathname = resolveDynamicRoute(pathname, pages); if (parsed.pathname !== pathname) { pathname = parsed.pathname; parsed.pathname = (0, _addbasepath.addBasePath)(pathname); if (!isMiddlewareMatch) { url = (0, _formaturl.formatWithValidation)(parsed); } } } } if (!(0, _islocalurl.isLocalURL)(as)) { if (process.env.NODE_ENV !== "production") { throw new Error('Invalid href: "' + url + '" and as: "' + as + '", received relative href and external as' + "\nSee more info: https://nextjs.org/docs/messages/invalid-relative-url-external-as"); } handleHardNavigation({ url: as, router: this }); return false; } resolvedAs = (0, _removelocale.removeLocale)((0, _removebasepath.removeBasePath)(resolvedAs), nextState.locale); route = (0, _removetrailingslash.removeTrailingSlash)(pathname); let routeMatch = false; if ((0, _isdynamic.isDynamicRoute)(route)) { const parsedAs = (0, _parserelativeurl.parseRelativeUrl)(resolvedAs); const asPathname = parsedAs.pathname; const routeRegex = (0, _routeregex.getRouteRegex)(route); routeMatch = (0, _routematcher.getRouteMatcher)(routeRegex)(asPathname); const shouldInterpolate = route === asPathname; const interpolatedAs = shouldInterpolate ? (0, _interpolateas.interpolateAs)(route, asPathname, query) : {}; if (!routeMatch || shouldInterpolate && !interpolatedAs.result) { const missingParams = Object.keys(routeRegex.groups).filter((param)=>!query[param] && !routeRegex.groups[param].optional); if (missingParams.length > 0 && !isMiddlewareMatch) { if (process.env.NODE_ENV !== "production") { console.warn("" + (shouldInterpolate ? "Interpolating href" : "Mismatching `as` and `href`") + " failed to manually provide " + ("the params: " + missingParams.join(", ") + " in the `href`'s `query`")); } throw new Error((shouldInterpolate ? "The provided `href` (" + url + ") value is missing query values (" + missingParams.join(", ") + ") to be interpolated properly. " : "The provided `as` value (" + asPathname + ") is incompatible with the `href` value (" + route + "). ") + ("Read more: https://nextjs.org/docs/messages/" + (shouldInterpolate ? "href-interpolation-failed" : "incompatible-href-as"))); } } else if (shouldInterpolate) { as = (0, _formaturl.formatWithValidation)(Object.assign({}, parsedAs, { pathname: interpolatedAs.result, query: (0, _omit.omit)(query, interpolatedAs.params) })); } else { // Merge params into `query`, overwriting any specified in search Object.assign(query, routeMatch); } } if (!isQueryUpdating) { Router.events.emit("routeChangeStart", as, routeProps); } const isErrorRoute = this.pathname === "/404" || this.pathname === "/_error"; try { var _self___NEXT_DATA___props_pageProps, _self___NEXT_DATA___props, _routeInfo_props; let routeInfo = await this.getRouteInfo({ route, pathname, query, as, resolvedAs, routeProps, locale: nextState.locale, isPreview: nextState.isPreview, hasMiddleware: isMiddlewareMatch, unstable_skipClientCache: options.unstable_skipClientCache, isQueryUpdating: isQueryUpdating && !this.isFallback, isMiddlewareRewrite }); if (!isQueryUpdating && !options.shallow) { await this._bfl(as, "resolvedAs" in routeInfo ? routeInfo.resolvedAs : undefined, nextState.locale); } if ("route" in routeInfo && isMiddlewareMatch) { pathname = routeInfo.route || route; route = pathname; if (!routeProps.shallow) { query = Object.assign({}, routeInfo.query || {}, query); } const cleanedParsedPathname = (0, _hasbasepath.hasBasePath)(parsed.pathname) ? (0, _removebasepath.removeBasePath)(parsed.pathname) : parsed.pathname; if (routeMatch && pathname !== cleanedParsedPathname) { Object.keys(routeMatch).forEach((key)=>{ if (routeMatch && query[key] === routeMatch[key]) { delete query[key]; } }); } if ((0, _isdynamic.isDynamicRoute)(pathname)) { const prefixedAs = !routeProps.shallow && routeInfo.resolvedAs ? routeInfo.resolvedAs : (0, _addbasepath.addBasePath)((0, _addlocale.addLocale)(new URL(as, location.href).pathname, nextState.locale), true); let rewriteAs = prefixedAs; if ((0, _hasbasepath.hasBasePath)(rewriteAs)) { rewriteAs = (0, _removebasepath.removeBasePath)(rewriteAs); } if (process.env.__NEXT_I18N_SUPPORT) { const localeResult = (0, _normalizelocalepath.normalizeLocalePath)(rewriteAs, this.locales); nextState.locale = localeResult.detectedLocale || nextState.locale; rewriteAs = localeResult.pathname; } const routeRegex = (0, _routeregex.getRouteRegex)(pathname); const curRouteMatch = (0, _routematcher.getRouteMatcher)(routeRegex)(new URL(rewriteAs, location.href).pathname); if (curRouteMatch) { Object.assign(query, curRouteMatch); } } } // If the routeInfo brings a redirect we simply apply it. if ("type" in routeInfo) { if (routeInfo.type === "redirect-internal") { return this.change(method, routeInfo.newUrl, routeInfo.newAs, options); } else { handleHardNavigation({ url: routeInfo.destination, router: this }); return new Promise(()=>{}); } } const component = routeInfo.Component; if (component && component.unstable_scriptLoader) { const scripts = [].concat(component.unstable_scriptLoader()); scripts.forEach((script)=>{ (0, _script.handleClientScriptLoad)(script.props); }); } // handle redirect on client-transition if ((routeInfo.__N_SSG || routeInfo.__N_SSP) && routeInfo.props) { if (routeInfo.props.pageProps && routeInfo.props.pageProps.__N_REDIRECT) { // Use the destination from redirect without adding locale options.locale = false; const destination = routeInfo.props.pageProps.__N_REDIRECT; // check if destination is internal (resolves to a page) and attempt // client-navigation if it is falling back to hard navigation if // it's not if (destination.startsWith("/") && routeInfo.props.pageProps.__N_REDIRECT_BASE_PATH !== false) { const parsedHref = (0, _parserelativeurl.parseRelativeUrl)(destination); parsedHref.pathname = resolveDynamicRoute(parsedHref.pathname, pages); const { url: newUrl, as: newAs } = prepareUrlAs(this, destination, destination); return this.change(method, newUrl, newAs, options); } handleHardNavigation({ url: destination, router: this }); return new Promise(()=>{}); } nextState.isPreview = !!routeInfo.props.__N_PREVIEW; // handle SSG data 404 if (routeInfo.props.notFound === SSG_DATA_NOT_FOUND) { let notFoundRoute; try { await this.fetchComponent("/404"); notFoundRoute = "/404"; } catch (_) { notFoundRoute = "/_error"; } routeInfo = await this.getRouteInfo({ route: notFoundRoute, pathname: notFoundRoute, query, as, resolvedAs, routeProps: { shallow: false }, locale: nextState.locale, isPreview: nextState.isPreview, isNotFound: true }); if ("type" in routeInfo) { throw new Error("Unexpected middleware effect on /404"); } } } if (isQueryUpdating && this.pathname === "/_error" && ((_self___NEXT_DATA___props = self.__NEXT_DATA__.props) == null ? void 0 : (_self___NEXT_DATA___props_pageProps = _self___NEXT_DATA___props.pageProps) == null ? void 0 : _self___NEXT_DATA___props_pageProps.statusCode) === 500 && ((_routeInfo_props = routeInfo.props) == null ? void 0 : _routeInfo_props.pageProps)) { // ensure statusCode is still correct for static 500 page // when updating query information routeInfo.props.pageProps.statusCode = 500; } var _routeInfo_route; // shallow routing is only allowed for same page URL changes. const isValidShallowRoute = options.shallow && nextState.route === ((_routeInfo_route = routeInfo.route) != null ? _routeInfo_route : route); var _options_scroll; const shouldScroll = (_options_scroll = options.scroll) != null ? _options_scroll : !isQueryUpdating && !isValidShallowRoute; const resetScroll = shouldScroll ? { x: 0, y: 0 } : null; const upcomingScrollState = forcedScroll != null ? forcedScroll : resetScroll; // the new state that the router gonna set const upcomingRouterState = { ...nextState, route, pathname, query, asPath: cleanedAs, isFallback: false }; // When the page being rendered is the 404 page, we should only update the // query parameters. Route changes here might add the basePath when it // wasn't originally present. This is also why this block is before the // below `changeState` call which updates the browser's history (changing // the URL). if (isQueryUpdating && isErrorRoute) { var _self___NEXT_DATA___props_pageProps1, _self___NEXT_DATA___props1, _routeInfo_props1; routeInfo = await this.getRouteInfo({ route: this.pathname, pathname: this.pathname, query, as, resolvedAs, routeProps: { shallow: false }, locale: nextState.locale, isPreview: nextState.isPreview, isQueryUpdating: isQueryUpdating && !this.isFallback }); if ("type" in routeInfo) { throw new Error("Unexpected middleware effect on " + this.pathname); } if (this.pathname === "/_error" && ((_self___NEXT_DATA___props1 = self.__NEXT_DATA__.props) == null ? void 0 : (_self___NEXT_DATA___props_pageProps1 = _self___NEXT_DATA___props1.pageProps) == null ? void 0 : _self___NEXT_DATA___props_pageProps1.statusCode) === 500 && ((_routeInfo_props1 = routeInfo.props) == null ? void 0 : _routeInfo_props1.pageProps)) { // ensure statusCode is still correct for static 500 page // when updating query information routeInfo.props.pageProps.statusCode = 500; } try { await this.set(upcomingRouterState, routeInfo, upcomingScrollState); } catch (err) { if ((0, _iserror.default)(err) && err.cancelled) { Router.events.emit("routeChangeError", err, cleanedAs, routeProps); } throw err; } return true; } Router.events.emit("beforeHistoryChange", as, routeProps); this.changeState(method, url, as, options); // for query updates we can skip it if the state is unchanged and we don't // need to scroll // https://github.com/vercel/next.js/issues/37139 const canSkipUpdating = isQueryUpdating && !upcomingScrollState && !readyStateChange && !localeChange && (0, _comparestates.compareRouterStates)(upcomingRouterState, this.state); if (!canSkipUpdating) { try { await this.set(upcomingRouterState, routeInfo, upcomingScrollState); } catch (e) { if (e.cancelled) routeInfo.error = routeInfo.error || e; else throw e; } if (routeInfo.error) { if (!isQueryUpdating) { Router.events.emit("routeChangeError", routeInfo.error, cleanedAs, routeProps); } throw routeInfo.error; } if (process.env.__NEXT_I18N_SUPPORT) { if (nextState.locale) { document.documentElement.lang = nextState.locale; } } if (!isQueryUpdating) { Router.events.emit("routeChangeComplete", as, routeProps); } // A hash mark # is the optional last part of a URL const hashRegex = /#.+$/; if (shouldScroll && hashRegex.test(as)) { this.scrollToHash(as); } } return true; } catch (err) { if ((0, _iserror.default)(err) && err.cancelled) { return false; } throw err; } } changeState(method, url, as, options) { if (options === void 0) options = {}; if (process.env.NODE_ENV !== "production") { if (typeof window.history === "undefined") { console.error("Warning: window.history is not available."); return; } if (typeof window.history[method] === "undefined") { console.error("Warning: window.history." + method + " is not available"); return; } } if (method !== "pushState" || (0, _utils.getURL)() !== as) { this._shallow = options.shallow; window.history[method]({ url, as, options, __N: true, key: this._key = method !== "pushState" ? this._key : createKey() }, // Most browsers currently ignores this parameter, although they may use it in the future. // Passing the empty string here should be safe against future changes to the method. // https://developer.mozilla.org/docs/Web/API/History/replaceState "", as); } } async handleRouteInfoError(err, pathname, query, as, routeProps, loadErrorFail) { console.error(err); if (err.cancelled) { // bubble up cancellation errors throw err; } if ((0, _routeloader.isAssetError)(err) || loadErrorFail) { Router.events.emit("routeChangeError", err, as, routeProps); // If we can't load the page it could be one of following reasons // 1. Page doesn't exists // 2. Page does exist in a different zone // 3. Internal error while loading the page // So, doing a hard reload is the proper way to deal with this. handleHardNavigation({ url: as, router: this }); // Changing the URL doesn't block executing the current code path. // So let's throw a cancellation error stop the routing logic. throw buildCancellationError(); } try { let props; const { page: Component, styleSheets } = await this.fetchComponent("/_error"); const routeInfo = { props, Component, styleSheets, err, error: err }; if (!routeInfo.props) { try { routeInfo.props = await this.getInitialProps(Component, { err, pathname, query }); } catch (gipErr) { console.error("Error in error page `getInitialProps`: ", gipErr); routeInfo.props = {}; } } return routeInfo; } catch (routeInfoErr) { return this.handleRouteInfoError((0, _iserror.default)(routeInfoErr) ? routeInfoErr : new Error(routeInfoErr + ""), pathname, query, as, routeProps, true); } } async getRouteInfo(param) { let { route: requestedRoute, pathname, query, as, resolvedAs, routeProps, locale, hasMiddleware, isPreview, unstable_skipClientCache, isQueryUpdating, isMiddlewareRewrite, isNotFound } = param; /** * This `route` binding can change if there's a rewrite * so we keep a reference to the original requested route * so we can store the cache for it and avoid re-requesting every time * for shallow routing purposes. */ let route = requestedRoute; try { var _data_effect, _data_effect1, _data_effect2, _data_response; const handleCancelled = getCancelledHandler({ route, router: this }); let existingInfo = this.components[route]; if (routeProps.shallow && existingInfo && this.route === route) { return existingInfo; } if (hasMiddleware) { existingInfo = undefined; } let cachedRouteInfo = existingInfo && !("initial" in existingInfo) && process.env.NODE_ENV !== "development" ? existingInfo : undefined; const isBackground = isQueryUpdating; const fetchNextDataParams = { dataHref: this.pageLoader.getDataHref({ href: (0, _formaturl.formatWithValidation)({ pathname, query }), skipInterpolation: true, asPath: isNotFound ? "/404" : resolvedAs, locale }), hasMiddleware: true, isServerRender: this.isSsr, parseJSON: true, inflightCache: isBackground ? this.sbc : this.sdc, persistCache: !isPreview, isPrefetch: false, unstable_skipClientCache, isBackground }; let data = isQueryUpdating && !isMiddlewareRewrite ? null : await withMiddlewareEffects({ fetchData: ()=>fetchNextData(fetchNextDataParams), asPath: isNotFound ? "/404" : resolvedAs, locale: locale, router: this }).catch((err)=>{ // we don't hard error during query updating // as it's un-necessary and doesn't need to be fatal // unless it is a fallback route and the props can't // be loaded if (isQueryUpdating) { return null; } throw err; }); // when rendering error routes we don't apply middleware // effects if (data && (pathname === "/_error" || pathname === "/404")) { data.effect = undefined; } if (isQueryUpdating) { if (!data) { data = { json: self.__NEXT_DATA__.props }; } else { data.json = self.__NEXT_DATA__.props; } } handleCancelled(); if ((data == null ? void 0 : (_data_effect = data.effect) == null ? void 0 : _data_effect.type) === "redirect-internal" || (data == null ? void 0 : (_data_effect1 = data.effect) == null ? void 0 : _data_effect1.type) === "redirect-external") { return data.effect; } if ((data == null ? void 0 : (_data_effect2 = data.effect) == null ? void 0 : _data_effect2.type) === "rewrite") { const resolvedRoute = (0, _removetrailingslash.removeTrailingSlash)(data.effect.resolvedHref); const pages = await this.pageLoader.getPageList(); // during query updating the page must match although during // client-transition a redirect that doesn't match a page // can be returned and this should trigger a hard navigation // which is valid for incremental migration if (!isQueryUpdating || pages.includes(resolvedRoute)) { route = resolvedRoute; pathname = data.effect.resolvedHref; query = { ...query, ...data.effect.parsedAs.query }; resolvedAs = (0, _removebasepath.removeBasePath)((0, _normalizelocalepath.normalizeLocalePath)(data.effect.parsedAs.pathname, this.locales).pathname); // Check again the cache with the new destination. existingInfo = this.components[route]; if (routeProps.shallow && existingInfo && this.route === route && !hasMiddleware) { // If we have a match with the current route due to rewrite, // we can copy the existing information to the rewritten one. // Then, we return the information along with the matched route. return { ...existingInfo, route }; } } } if ((0, _isapiroute.isAPIRoute)(route)) { handleHardNavigation({ url: as, router: this }); return new Promise(()=>{}); } const routeInfo = cachedRouteInfo || await this.fetchComponent(route).then((res)=>({ Component: res.page, styleSheets: res.styleSheets, __N_SSG: res.mod.__N_SSG, __N_SSP: res.mod.__N_SSP })); if (process.env.NODE_ENV !== "production") { const { isValidElementType } = require("next/dist/compiled/react-is"); if (!isValidElementType(routeInfo.Component)) { throw new Error('The default export is not a React Component in page: "' + pathname + '"'); } } const wasBailedPrefetch = data == null ? void 0 : (_data_response = data.response) == null ? void 0 : _data_response.headers.get("x-middleware-skip"); const shouldFetchData = routeInfo.__N_SSG || routeInfo.__N_SSP; // For non-SSG prefetches that bailed before sending data // we clear the cache to fetch full response if (wasBailedPrefetch && (data == null ? void 0 : data.dataHref)) { delete this.sdc[data.dataHref]; } const { props, cacheKey } = await this._getData(async ()=>{ if (shouldFetchData) { if ((data == null ? void 0 : data.json) && !wasBailedPrefetch) { return { cacheKey: data.cacheKey, props: data.json }; } const dataHref = (data == null ? void 0 : data.dataHref) ? data.dataHref : this.pageLoader.getDataHref({ href: (0, _formaturl.formatWithValidation)({ pathname, query }), asPath: resolvedAs, locale }); const fetched = await fetchNextData({ dataHref, isServerRender: this.isSsr, parseJSON: true, inflightCache: wasBailedPrefetch ? {} : this.sdc, persistCache: !isPreview, isPrefetch: false, unstable_skipClientCache }); return { cacheKey: fetched.cacheKey, props: fetched.json || {} }; } return { headers: {}, props: await this.getInitialProps(routeInfo.Component, // we provide AppTree later so this needs to be `any` { pathname, query, asPath: as, locale, locales: this.locales, defaultLocale: this.defaultLocale }) }; }); // Only bust the data cache for SSP routes although // middleware can skip cache per request with // x-middleware-cache: no-cache as well if (routeInfo.__N_SSP && fetchNextDataParams.dataHref && cacheKey) { delete this.sdc[cacheKey]; } // we kick off a HEAD request in the background // when a non-prefetch request is made to signal revalidation if (!this.isPreview && routeInfo.__N_SSG && process.env.NODE_ENV !== "development" && !isQueryUpdating) { fetchNextData(Object.assign({}, fetchNextDataParams, { isBackground: true, persistCache: false, inflightCache: this.sbc })).catch(()=>{}); } props.pageProps = Object.assign({}, props.pageProps); routeInfo.props = props; routeInfo.route = route; routeInfo.query = query; routeInfo.resolvedAs = resolvedAs; this.components[route] = routeInfo; return routeInfo; } catch (err) { return this.handleRouteInfoError((0, _iserror.getProperError)(err), pathname, query, as, routeProps); } } set(state, data, resetScroll) { this.state = state; return this.sub(data, this.components["/_app"].Component, resetScroll); } /** * Callback to execute before replacing router state * @param cb callback to be executed */ beforePopState(cb) { this._bps = cb; } onlyAHashChange(as) { if (!this.asPath) return false; const [oldUrlNoHash, oldHash] = this.asPath.split("#"); const [newUrlNoHash, newHash] = as.split("#"); // Makes sure we scroll to the provided hash if the url/hash are the same if (newHash && oldUrlNoHash === newUrlNoHash && oldHash === newHash) { return true; } // If the urls are change, there's more than a hash change if (oldUrlNoHash !== newUrlNoHash) { return false; } // If the hash has changed, then it's a hash only change. // This check is necessary to handle both the enter and // leave hash === '' cases. The identity case falls through // and is treated as a next reload. return oldHash !== newHash; } scrollToHash(as) { const [, hash = ""] = as.split("#"); (0, _handlesmoothscroll.handleSmoothScroll)(()=>{ // Scroll to top if the hash is just `#` with no value or `#top` // To mirror browsers if (hash === "" || hash === "top") { window.scrollTo(0, 0); return; } // Decode hash to make non-latin anchor works. const rawHash = decodeURIComponent(hash); // First we check if the element by id is found const idEl = document.getElementById(rawHash); if (idEl) { idEl.scrollIntoView(); return; } // If there's no element with the id, we check the `name` property // To mirror browsers const nameEl = document.getElementsByName(rawHash)[0]; if (nameEl) { nameEl.scrollIntoView(); } }, { onlyHashChange: this.onlyAHashChange(as) }); } urlIsNew(asPath) { return this.asPath !== asPath; } /** * Prefetch page code, you may wait for the data during page rendering. * This feature only works in production! * @param url the href of prefetched page * @param asPath the as path of the prefetched page */ async prefetch(url, asPath, options) { if (asPath === void 0) asPath = url; if (options === void 0) options = {}; // Prefetch is not supported in development mode because it would trigger on-demand-entries if (process.env.NODE_ENV !== "production") { return; } if (typeof window !== "undefined" && (0, _isbot.isBot)(window.navigator.userAgent)) { // No prefetches for bots that render the link since they are typically navigating // links via the equivalent of a hard navigation and hence never utilize these // prefetches. return; } let parsed = (0, _parserelativeurl.parseRelativeUrl)(url); const urlPathname = parsed.pathname; let { pathname, query } = parsed; const originalPathname = pathname; if (process.env.__NEXT_I18N_SUPPORT) { if (options.locale === false) { pathname = (0, _normalizelocalepath.normalizeLocalePath)(pathname, this.locales).pathname; parsed.pathname = pathname; url = (0, _formaturl.formatWithValidation)(parsed); let parsedAs = (0, _parserelativeurl.parseRelativeUrl)(asPath); const localePathResult = (0, _normalizelocalepath.normalizeLocalePath)(parsedAs.pathname, this.locales); parsedAs.pathname = localePathResult.pathname; options.locale = localePathResult.detectedLocale || this.defaultLocale; asPath = (0, _formaturl.formatWithValidation)(parsedAs); } } const pages = await this.pageLoader.getPageList(); let resolvedAs = asPath; const locale = typeof options.locale !== "undefined" ? options.locale || undefined : this.locale; const isMiddlewareMatch = await matchesMiddleware({ asPath: asPath, locale: locale, router: this }); if (process.env.__NEXT_HAS_REWRITES && asPath.startsWith("/")) { let rewrites; ({ __rewrites: rewrites } = await (0, _routeloader.getClientBuildManifest)()); const rewritesResult = (0, _resolverewrites.default)((0, _addbasepath.addBasePath)((0, _addlocale.addLocale)(asPath, this.locale), true), pages, rewrites, parsed.query, (p)=>resolveDynamicRoute(p, pages), this.locales); if (rewritesResult.externalDest) { return; } if (!isMiddlewareMatch) { resolvedAs = (0, _removelocale.removeLocale)((0, _removebasepath.removeBasePath)(rewritesResult.asPath), this.locale); } if (rewritesResult.matchedPage && rewritesResult.resolvedHref) { // if this directly matches a page we need to update the href to // allow the correct page chunk to be loaded pathname = rewritesResult.resolvedHref; parsed.pathname = pathname; if (!isMiddlewareMatch) { url = (0, _formaturl.formatWithValidation)(parsed); } } } parsed.pathname = resolveDynamicRoute(parsed.pathname, pages); if ((0, _isdynamic.isDynamicRoute)(parsed.pathname)) { pathname = parsed.pathname; parsed.pathname = pathname; Object.assign(query, (0, _routematcher.getRouteMatcher)((0, _routeregex.getRouteRegex)(parsed.pathname))((0, _parsepath.parsePath)(asPath).pathname) || {}); if (!isMiddlewareMatch) { url = (0, _formaturl.formatWithValidation)(parsed); } } const data = process.env.__NEXT_MIDDLEWARE_PREFETCH === "strict" ? null : await withMiddlewareEffects({ fetchData: ()=>fetchNextData({ dataHref: this.pageLoader.getDataHref({ href: (0, _formaturl.formatWithValidation)({ pathname: originalPathname, query }), skipInterpolation: true, asPath: resolvedAs, locale }), hasMiddleware: true, isServerRender: this.isSsr, parseJSON: true, inflightCache: this.sdc, persistCache: !this.isPreview, isPrefetch: true }), asPath: asPath, locale: locale, router: this }); /** * If there was a rewrite we apply the effects of the rewrite on the * current parameters for the prefetch. */ if ((data == null ? void 0 : data.effect.type) === "rewrite") { parsed.pathname = data.effect.resolvedHref; pathname = data.effect.resolvedHref; query = { ...query, ...data.effect.parsedAs.query }; resolvedAs = data.effect.parsedAs.pathname; url = (0, _formaturl.formatWithValidation)(parsed); } /** * If there is a redirect to an external destination then we don't have * to prefetch content as it will be unused. */ if ((data == null ? void 0 : data.effect.type) === "redirect-external") { return; } const route = (0, _removetrailingslash.removeTrailingSlash)(pathname); if (await this._bfl(asPath, resolvedAs, options.locale, true)) { this.components[urlPathname] = { __appRouter: true }; } await Promise.all([ this.pageLoader._isSsg(route).then((isSsg)=>{ return isSsg ? fetchNextData({ dataHref: (data == null ? void 0 : data.json) ? data == null ? void 0 : data.dataHref : this.pageLoader.getDataHref({ href: url, asPath: resolvedAs, locale: locale }), isServerRender: false, parseJSON: true, inflightCache: this.sdc, persistCache: !this.isPreview, isPrefetch: true, unstable_skipClientCache: options.unstable_skipClientCache || options.priority && !!process.env.__NEXT_OPTIMISTIC_CLIENT_CACHE }).then(()=>false).catch(()=>false) : false; }), this.pageLoader[options.priority ? "loadPage" : "prefetch"](route) ]); } async fetchComponent(route) { const handleCancelled = getCancelledHandler({ route, router: this }); try { const componentResult = await this.pageLoader.loadPage(route); handleCancelled(); return componentResult; } catch (err) { handleCancelled(); throw err; } } _getData(fn) { let cancelled = false; const cancel = ()=>{ cancelled = true; }; this.clc = cancel; return fn().then((data)=>{ if (cancel === this.clc) { this.clc = null; } if (cancelled) { const err = new Error("Loading initial props cancelled"); err.cancelled = true; throw err; } return data; }); } _getFlightData(dataHref) { // Do not cache RSC flight response since it's not a static resource return fetchNextData({ dataHref, isServerRender: true, parseJSON: false, inflightCache: this.sdc, persistCache: false, isPrefetch: false }).then((param)=>{ let { text } = param; return { data: text }; }); } getInitialProps(Component, ctx) { const { Component: App } = this.components["/_app"]; const AppTree = this._wrapApp(App); ctx.AppTree = AppTree; return (0, _utils.loadGetInitialProps)(App, { AppTree, Component, router: this, ctx }); } get route() { return this.state.route; } get pathname() { return this.state.pathname; } get query() { return this.state.query; } get asPath() { return this.state.asPath; } get locale() { return this.state.locale; } get isFallback() { return this.state.isFallback; } get isPreview() { return this.state.isPreview; } constructor(pathname, query, as, { initialProps, pageLoader, App, wrapApp, Component, err, subscription, isFallback, locale, locales, defaultLocale, domainLocales, isPreview }){ // Server Data Cache (full data requests) this.sdc = {}; // Server Background Cache (HEAD requests) this.sbc = {}; this.isFirstPopStateEvent = true; this._key = createKey(); this.onPopState = (e)=>{ const { isFirstPopStateEvent } = this; this.isFirstPopStateEvent = false; const state = e.state; if (!state) { // We get state as undefined for two reasons. // 1. With older safari (< 8) and older chrome (< 34) // 2. When the URL changed with # // // In the both cases, we don't need to proceed and change the route. // (as it's already changed) // But we can simply replace the state with the new changes. // Actually, for (1) we don't need to nothing. But it's hard to detect that event. // So, doing the following for (1) does no harm. const { pathname, query } = this; this.changeState("replaceState", (0, _formaturl.formatWithValidation)({ pathname: (0, _addbasepath.addBasePath)(pathname), query }), (0, _utils.getURL)()); return; } // __NA is used to identify if the history entry can be handled by the app-router. if (state.__NA) { window.location.reload(); return; } if (!state.__N) { return; } // Safari fires popstateevent when reopening the browser. if (isFirstPopStateEvent && this.locale === state.options.locale && state.as === this.asPath) { return; } let forcedScroll; const { url, as, options, key } = state; if (process.env.__NEXT_SCROLL_RESTORATION) { if (manualScrollRestoration) { if (this._key !== key) { // Snapshot current scroll position: try { sessionStorage.setItem("__next_scroll_" + this._key, JSON.stringify({ x: self.pageXOffset, y: self.pageYOffset })); } catch (e) {} // Restore old scroll position: try { const v = sessionStorage.getItem("__next_scroll_" + key); forcedScroll = JSON.parse(v); } catch (e) { forcedScroll = { x: 0, y: 0 }; } } } } this._key = key; const { pathname } = (0, _parserelativeurl.parseRelativeUrl)(url); // Make sure we don't re-render on initial load, // can be caused by navigating back from an external site if (this.isSsr && as === (0, _addbasepath.addBasePath)(this.asPath) && pathname === (0, _addbasepath.addBasePath)(this.pathname)) { return; } // If the downstream application returns falsy, return. // They will then be responsible for handling the event. if (this._bps && !this._bps(state)) { return; } this.change("replaceState", url, as, Object.assign({}, options, { shallow: options.shallow && this._shallow, locale: options.locale || this.defaultLocale, // @ts-ignore internal value not exposed on types _h: 0 }), forcedScroll); }; // represents the current component key const route = (0, _removetrailingslash.removeTrailingSlash)(pathname); // set up the component cache (by route keys) this.components = {}; // We should not keep the cache, if there's an error // Otherwise, this cause issues when when going back and // come again to the errored page. if (pathname !== "/_error") { this.components[route] = { Component, initial: true, props: initialProps, err, __N_SSG: initialProps && initialProps.__N_SSG, __N_SSP: initialProps && initialProps.__N_SSP }; } this.components["/_app"] = { Component: App, styleSheets: [] }; if (process.env.__NEXT_CLIENT_ROUTER_FILTER_ENABLED) { const { BloomFilter } = require("../../lib/bloom-filter"); const staticFilterData = process.env.__NEXT_CLIENT_ROUTER_S_FILTER; const dynamicFilterData = process.env.__NEXT_CLIENT_ROUTER_D_FILTER; if (staticFilterData == null ? void 0 : staticFilterData.numHashes) { this._bfl_s = new BloomFilter(staticFilterData.numItems, staticFilterData.errorRate); this._bfl_s.import(staticFilterData); } if (dynamicFilterData == null ? void 0 : dynamicFilterData.numHashes) { this._bfl_d = new BloomFilter(dynamicFilterData.numItems, dynamicFilterData.errorRate); this._bfl_d.import(dynamicFilterData); } } // Backwards compat for Router.router.events // TODO: Should be remove the following major version as it was never documented this.events = Router.events; this.pageLoader = pageLoader; // if auto prerendered and dynamic route wait to update asPath // until after mount to prevent hydration mismatch const autoExportDynamic = (0, _isdynamic.isDynamicRoute)(pathname) && self.__NEXT_DATA__.autoExport; this.basePath = process.env.__NEXT_ROUTER_BASEPATH || ""; this.sub = subscription; this.clc = null; this._wrapApp = wrapApp; // make sure to ignore extra popState in safari on navigating // back from external site this.isSsr = true; this.isLocaleDomain = false; this.isReady = !!(self.__NEXT_DATA__.gssp || self.__NEXT_DATA__.gip || self.__NEXT_DATA__.isExperimentalCompile || self.__NEXT_DATA__.appGip && !self.__NEXT_DATA__.gsp || !autoExportDynamic && !self.location.search && !process.env.__NEXT_HAS_REWRITES); if (process.env.__NEXT_I18N_SUPPORT) { this.locales = locales; this.defaultLocale = defaultLocale; this.domainLocales = domainLocales; this.isLocaleDomain = !!(0, _detectdomainlocale.detectDomainLocale)(domainLocales, self.location.hostname); } this.state = { route, pathname, query, asPath: autoExportDynamic ? pathname : as, isPreview: !!isPreview, locale: process.env.__NEXT_I18N_SUPPORT ? locale : undefined, isFallback }; this._initialMatchesMiddlewarePromise = Promise.resolve(false); if (typeof window !== "undefined") { // make sure "as" doesn't start with double slashes or else it can // throw an error as it's considered invalid if (!as.startsWith("//")) { // in order for `e.state` to work on the `onpopstate` event // we have to register the initial route upon initialization const options = { locale }; const asPath = (0, _utils.getURL)(); this._initialMatchesMiddlewarePromise = matchesMiddleware({ router: this, locale, asPath }).then((matches)=>{ options._shouldResolveHref = as !== pathname; this.changeState("replaceState", matches ? asPath : (0, _formaturl.formatWithValidation)({ pathname: (0, _addbasepath.addBasePath)(pathname), query }), asPath, options); return matches; }); } window.addEventListener("popstate", this.onPopState); // enable custom scroll restoration handling when available // otherwise fallback to browser's default handling if (process.env.__NEXT_SCROLL_RESTORATION) { if (manualScrollRestoration) { window.history.scrollRestoration = "manual"; } } } } } Router.events = (0, _mitt.default)(); //# sourceMappingURL=router.js.map