next
Version:
The React Framework
994 lines (993 loc) • 78.8 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.isLocalURL = isLocalURL;
exports.interpolateAs = interpolateAs;
exports.resolveHref = resolveHref;
exports.createKey = createKey;
exports.default = void 0;
var _async_to_generator = require("@swc/helpers/lib/_async_to_generator.js").default;
var _extends = require("@swc/helpers/lib/_extends.js").default;
var _interop_require_default = require("@swc/helpers/lib/_interop_require_default.js").default;
var _interop_require_wildcard = require("@swc/helpers/lib/_interop_require_wildcard.js").default;
var _normalizeTrailingSlash = require("../../../client/normalize-trailing-slash");
var _removeTrailingSlash = require("./utils/remove-trailing-slash");
var _routeLoader = require("../../../client/route-loader");
var _script = require("../../../client/script");
var _isError = _interop_require_wildcard(require("../../../lib/is-error"));
var _denormalizePagePath = require("../page-path/denormalize-page-path");
var _normalizeLocalePath = require("../i18n/normalize-locale-path");
var _mitt = _interop_require_default(require("../mitt"));
var _utils = require("../utils");
var _isDynamic = require("./utils/is-dynamic");
var _parseRelativeUrl = require("./utils/parse-relative-url");
var _querystring = require("./utils/querystring");
var _resolveRewrites = _interop_require_default(require("./utils/resolve-rewrites"));
var _routeMatcher = require("./utils/route-matcher");
var _routeRegex = require("./utils/route-regex");
var _formatUrl = require("./utils/format-url");
var _detectDomainLocale = require("../../../client/detect-domain-locale");
var _parsePath = require("./utils/parse-path");
var _addLocale = require("../../../client/add-locale");
var _removeLocale = require("../../../client/remove-locale");
var _removeBasePath = require("../../../client/remove-base-path");
var _addBasePath = require("../../../client/add-base-path");
var _hasBasePath = require("../../../client/has-base-path");
var _getNextPathnameInfo = require("./utils/get-next-pathname-info");
var _formatNextPathnameInfo = require("./utils/format-next-pathname-info");
var _compareStates = require("./utils/compare-states");
function buildCancellationError() {
return Object.assign(new Error('Route Cancelled'), {
cancelled: true
});
}
function isLocalURL(url) {
// prevent a hydration mismatch on href for url with anchor refs
if (!(0, _utils).isAbsoluteUrl(url)) return true;
try {
// absolute urls can be local if they are on the same origin
const locationOrigin = (0, _utils).getLocationOrigin();
const resolved = new URL(url, locationOrigin);
return resolved.origin === locationOrigin && (0, _hasBasePath).hasBasePath(resolved.pathname);
} catch (_) {
return false;
}
}
function interpolateAs(route, asPathname, query) {
let interpolatedRoute = '';
const dynamicRegex = (0, _routeRegex).getRouteRegex(route);
const dynamicGroups = dynamicRegex.groups;
const dynamicMatches = // Try to match the dynamic route against the asPath
(asPathname !== route ? (0, _routeMatcher).getRouteMatcher(dynamicRegex)(asPathname) : '') || // Fall back to reading the values from the href
// TODO: should this take priority; also need to change in the router.
query;
interpolatedRoute = route;
const params = Object.keys(dynamicGroups);
if (!params.every((param)=>{
let value = dynamicMatches[param] || '';
const { repeat , optional } = dynamicGroups[param];
// support single-level catch-all
// TODO: more robust handling for user-error (passing `/`)
let replaced = `[${repeat ? '...' : ''}${param}]`;
if (optional) {
replaced = `${!value ? '/' : ''}[${replaced}]`;
}
if (repeat && !Array.isArray(value)) value = [
value
];
return (optional || param in dynamicMatches) && // Interpolate group into data URL if present
(interpolatedRoute = interpolatedRoute.replace(replaced, repeat ? value.map(// these values should be fully encoded instead of just
// path delimiter escaped since they are being inserted
// into the URL and we expect URL encoded segments
// when parsing dynamic route params
(segment)=>encodeURIComponent(segment)).join('/') : encodeURIComponent(value)) || '/');
})) {
interpolatedRoute = '' // did not satisfy all requirements
;
// n.b. We ignore this error because we handle warning for this case in
// development in the `<Link>` component directly.
}
return {
params,
result: interpolatedRoute
};
}
function omit(object, keys) {
const omitted = {};
Object.keys(object).forEach((key)=>{
if (!keys.includes(key)) {
omitted[key] = object[key];
}
});
return omitted;
}
function resolveHref(router, href, resolveAs) {
// we use a dummy base url for relative urls
let base;
let urlAsString = typeof href === 'string' ? href : (0, _formatUrl).formatWithValidation(href);
// repeated slashes and backslashes in the URL are considered
// invalid and will never match a Next.js page/file
const urlProtoMatch = urlAsString.match(/^[a-zA-Z]{1,}:\/\//);
const urlAsStringNoProto = urlProtoMatch ? urlAsString.slice(urlProtoMatch[0].length) : urlAsString;
const urlParts = urlAsStringNoProto.split('?');
if ((urlParts[0] || '').match(/(\/\/|\\)/)) {
console.error(`Invalid href passed to next/router: ${urlAsString}, repeated forward-slashes (//) or backslashes \\ are not valid in the href`);
const normalizedUrl = (0, _utils).normalizeRepeatedSlashes(urlAsStringNoProto);
urlAsString = (urlProtoMatch ? urlProtoMatch[0] : '') + normalizedUrl;
}
// Return because it cannot be routed by the Next.js router
if (!isLocalURL(urlAsString)) {
return resolveAs ? [
urlAsString
] : urlAsString;
}
try {
base = new URL(urlAsString.startsWith('#') ? router.asPath : router.pathname, 'http://n');
} catch (_) {
// fallback to / for invalid asPath values e.g. //
base = new URL('/', 'http://n');
}
try {
const finalUrl = new URL(urlAsString, base);
finalUrl.pathname = (0, _normalizeTrailingSlash).normalizePathTrailingSlash(finalUrl.pathname);
let interpolatedAs = '';
if ((0, _isDynamic).isDynamicRoute(finalUrl.pathname) && finalUrl.searchParams && resolveAs) {
const query = (0, _querystring).searchParamsToUrlQuery(finalUrl.searchParams);
const { result , params } = interpolateAs(finalUrl.pathname, finalUrl.pathname, query);
if (result) {
interpolatedAs = (0, _formatUrl).formatWithValidation({
pathname: result,
hash: finalUrl.hash,
query: omit(query, params)
});
}
}
// if the origin didn't change, it means we received a relative href
const resolvedHref = finalUrl.origin === base.origin ? finalUrl.href.slice(finalUrl.origin.length) : finalUrl.href;
return resolveAs ? [
resolvedHref,
interpolatedAs || resolvedHref
] : resolvedHref;
} catch (_1) {
return resolveAs ? [
urlAsString
] : urlAsString;
}
}
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] = resolveHref(router, url, true);
const origin = (0, _utils).getLocationOrigin();
const hrefHadOrigin = resolvedHref.startsWith(origin);
const asHadOrigin = resolvedAs && resolvedAs.startsWith(origin);
resolvedHref = stripOrigin(resolvedHref);
resolvedAs = resolvedAs ? stripOrigin(resolvedAs) : resolvedAs;
const preparedUrl = hrefHadOrigin ? resolvedHref : (0, _addBasePath).addBasePath(resolvedHref);
const preparedAs = as ? stripOrigin(resolveHref(router, as)) : resolvedAs || resolvedHref;
return {
url: preparedUrl,
as: asHadOrigin ? 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);
}
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/en-US/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;
});
}
const backgroundCache = {};
function fetchNextData({ dataHref , inflightCache , isPrefetch , hasMiddleware , isServerRender , parseJSON , persistCache , isBackground , unstable_skipClientCache }) {
const { href: cacheKey } = new URL(dataHref, window.location.href);
var ref1;
const getData = (params)=>{
return fetchRetry(dataHref, isServerRender ? 3 : 1, {
headers: isPrefetch ? {
purpose: 'prefetch'
} : {},
method: (ref1 = params == null ? void 0 : params.method) != null ? ref1 : 'GET'
}).then((response)=>{
if (response.ok && (params == null ? void 0 : params.method) === 'HEAD') {
return {
dataHref,
response,
text: '',
json: {}
};
}
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: {}
};
}
if (!hasMiddleware && response.status === 404) {
var ref;
if ((ref = tryToParseAsJSON(text)) == null ? void 0 : ref.notFound) {
return {
dataHref,
json: {
notFound: SSG_DATA_NOT_FOUND
},
response,
text
};
}
}
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
};
});
}).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)=>{
delete inflightCache[cacheKey];
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 tryToParseAsJSON(text) {
try {
return JSON.parse(text);
} catch (error) {
return null;
}
}
function createKey() {
return Math.random().toString(36).slice(2, 10);
}
function handleHardNavigation({ url , router }) {
// 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 = ({ route , router })=>{
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();
}
/**
* 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 (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 = {}) {
({ url , as } = prepareUrlAs(this, url, as));
return this.change('replaceState', url, as, options);
}
change(method, url, as, options, forcedScroll) {
var _this = this;
return _async_to_generator(function*() {
if (!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;
const shouldResolveHref = isQueryUpdating || options._shouldResolveHref || (0, _parsePath).parsePath(url).pathname === (0, _parsePath).parsePath(as).pathname;
const nextState = _extends({}, _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 ref;
// if the locale isn't configured hard navigate to show 404 page
if (!((ref = _this.locales) == null ? void 0 : ref.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, _extends({}, options, {
scroll: false
}));
if (scroll) {
_this.scrollToHash(cleanedAs);
}
try {
yield _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;
// 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 }] = yield 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;
// we don't attempt resolve asPath when we need to execute
// middleware as the resolving will occur server-side
const isMiddlewareMatch = yield matchesMiddleware({
asPath: as,
locale: nextState.locale,
router: _this
});
if (options.shallow && isMiddlewareMatch) {
pathname = _this.pathname;
}
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 (!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);
let 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 ? interpolateAs(route, asPathname, query) : {};
if (!routeMatch || shouldInterpolate && !interpolatedAs.result) {
const missingParams = Object.keys(routeRegex.groups).filter((param)=>!query[param]);
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: 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);
}
try {
var ref2, ref3;
let routeInfo = yield _this.getRouteInfo({
route,
pathname,
query,
as,
resolvedAs,
routeProps,
locale: nextState.locale,
isPreview: nextState.isPreview,
hasMiddleware: isMiddlewareMatch
});
if ('route' in routeInfo && isMiddlewareMatch) {
pathname = routeInfo.route || route;
route = pathname;
if (!routeProps.shallow) {
query = Object.assign({}, routeInfo.query || {}, query);
}
if (routeMatch && pathname !== parsed.pathname) {
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)(rewriteAs);
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(()=>{});
}
}
let { error , props , __N_SSG , __N_SSP } = routeInfo;
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 ((__N_SSG || __N_SSP) && props) {
if (props.pageProps && props.pageProps.__N_REDIRECT) {
// Use the destination from redirect without adding locale
options.locale = false;
const destination = 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('/') && 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 = !!props.__N_PREVIEW;
// handle SSG data 404
if (props.notFound === SSG_DATA_NOT_FOUND) {
let notFoundRoute;
try {
yield _this.fetchComponent('/404');
notFoundRoute = '/404';
} catch (_) {
notFoundRoute = '/_error';
}
routeInfo = yield _this.getRouteInfo({
route: notFoundRoute,
pathname: notFoundRoute,
query,
as,
resolvedAs,
routeProps: {
shallow: false
},
locale: nextState.locale,
isPreview: nextState.isPreview
});
if ('type' in routeInfo) {
throw new Error(`Unexpected middleware effect on /404`);
}
}
}
Router.events.emit('beforeHistoryChange', as, routeProps);
_this.changeState(method, url, as, options);
if (isQueryUpdating && pathname === '/_error' && ((ref2 = self.__NEXT_DATA__.props) == null ? void 0 : (ref3 = ref2.pageProps) == null ? void 0 : ref3.statusCode) === 500 && (props == null ? void 0 : props.pageProps)) {
// ensure statusCode is still correct for static 500 page
// when updating query information
props.pageProps.statusCode = 500;
}
var _route;
// shallow routing is only allowed for same page URL changes.
const isValidShallowRoute = options.shallow && nextState.route === ((_route = routeInfo.route) != null ? _route : route);
var _scroll;
const shouldScroll = (_scroll = options.scroll) != null ? _scroll : !options._h && !isValidShallowRoute;
const resetScroll = shouldScroll ? {
x: 0,
y: 0
} : null;
// the new state that the router gonna set
const upcomingRouterState = _extends({}, nextState, {
route,
pathname,
query,
asPath: cleanedAs,
isFallback: false
});
const upcomingScrollState = forcedScroll != null ? forcedScroll : resetScroll;
// 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 = options._h && !upcomingScrollState && !readyStateChange && !localeChange && (0, _compareStates).compareRouterStates(upcomingRouterState, _this.state);
if (!canSkipUpdating) {
yield _this.set(upcomingRouterState, routeInfo, upcomingScrollState).catch((e)=>{
if (e.cancelled) error = error || e;
else throw e;
});
if (error) {
if (!isQueryUpdating) {
Router.events.emit('routeChangeError', error, cleanedAs, routeProps);
}
throw 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 (err1) {
if ((0, _isError).default(err1) && err1.cancelled) {
return false;
}
throw err1;
}
})();
}
changeState(method, url, as, 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/en-US/docs/Web/API/History/replaceState
'', as);
}
}
handleRouteInfoError(err, pathname, query, as, routeProps, loadErrorFail) {
var _this = this;
return _async_to_generator(function*() {
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 } = yield _this.fetchComponent('/_error');
const routeInfo = {
props,
Component,
styleSheets,
err,
error: err
};
if (!routeInfo.props) {
try {
routeInfo.props = yield _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);
}
})();
}
getRouteInfo({ route: requestedRoute , pathname , query , as , resolvedAs , routeProps , locale , hasMiddleware , isPreview , unstable_skipClientCache }) {
var _this = this;
return _async_to_generator(function*() {
/**
* 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 ref, ref4, ref5;
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 fetchNextDataParams = {
dataHref: _this.pageLoader.getDataHref({
href: (0, _formatUrl).formatWithValidation({
pathname,
query
}),
skipInterpolation: true,
asPath: resolvedAs,
locale
}),
hasMiddleware: true,
isServerRender: _this.isSsr,
parseJSON: true,
inflightCache: _this.sdc,
persistCache: !isPreview,
isPrefetch: false,
unstable_skipClientCache
};
const data = yield withMiddlewareEffects({
fetchData: ()=>fetchNextData(fetchNextDataParams),
asPath: resolvedAs,
locale: locale,
router: _this
});
handleCancelled();
if ((data == null ? void 0 : (ref = data.effect) == null ? void 0 : ref.type) === 'redirect-internal' || (data == null ? void 0 : (ref4 = data.effect) == null ? void 0 : ref4.type) === 'redirect-external') {
return data.effect;
}
if ((data == null ? void 0 : (ref5 = data.effect) == null ? void 0 : ref5.type) === 'rewrite') {
route = (0, _removeTrailingSlash).removeTrailingSlash(data.effect.resolvedHref);
pathname = data.effect.resolvedHref;
query = _extends({}, 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 _extends({}, existingInfo, {
route
});
}
}
if (route === '/api' || route.startsWith('/api/')) {
handleHardNavigation({
url: as,
router: _this
});
return new Promise(()=>{});
}
const routeInfo = cachedRouteInfo || (yield _this.fetchComponent(route).then((res)=>({
Component: res.page,
styleSheets: res.styleSheets,
__N_SSG: res.mod.__N_SSG,
__N_SSP: res.mod.__N_SSP,
__N_RSC: !!res.mod.__next_rsc__
})));
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}"`);
}
}
/**
* For server components, non-SSR pages will have statically optimized
* flight data in a production build. So only development and SSR pages
* will always have the real-time generated and streamed flight data.
*/ const useStreamedFlightData = routeInfo.__N_RSC && (process.env.NODE_ENV !== 'production' || routeInfo.__N_SSP);
const shouldFetchData = routeInfo.__N_SSG || routeInfo.__N_SSP || routeInfo.__N_RSC;
const { props } = yield _this._getData(_async_to_generator(function*() {
if (shouldFetchData && !useStreamedFlightData) {
const { json } = (data == null ? void 0 : data.json) ? data : yield fetchNextData({
dataHref: _this.pageLoader.getDataHref({
href: (0, _formatUrl).formatWithValidation({
pathname,
query
}),
asPath: resolvedAs,