122 lines
4.1 KiB
JavaScript
122 lines
4.1 KiB
JavaScript
"use strict";
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
0 && (module.exports = {
|
|
isInterceptionAppRoute: null,
|
|
isNormalizedAppRoute: null,
|
|
parseAppRoute: null,
|
|
parseAppRouteSegment: null
|
|
});
|
|
function _export(target, all) {
|
|
for(var name in all)Object.defineProperty(target, name, {
|
|
enumerable: true,
|
|
get: all[name]
|
|
});
|
|
}
|
|
_export(exports, {
|
|
isInterceptionAppRoute: function() {
|
|
return isInterceptionAppRoute;
|
|
},
|
|
isNormalizedAppRoute: function() {
|
|
return isNormalizedAppRoute;
|
|
},
|
|
parseAppRoute: function() {
|
|
return parseAppRoute;
|
|
},
|
|
parseAppRouteSegment: function() {
|
|
return parseAppRouteSegment;
|
|
}
|
|
});
|
|
const _invarianterror = require("../../invariant-error");
|
|
const _getsegmentparam = require("../utils/get-segment-param");
|
|
const _interceptionroutes = require("../utils/interception-routes");
|
|
function parseAppRouteSegment(segment) {
|
|
if (segment === '') {
|
|
return null;
|
|
}
|
|
// Check if the segment starts with an interception marker
|
|
const interceptionMarker = _interceptionroutes.INTERCEPTION_ROUTE_MARKERS.find((m)=>segment.startsWith(m));
|
|
const param = (0, _getsegmentparam.getSegmentParam)(segment);
|
|
if (param) {
|
|
return {
|
|
type: 'dynamic',
|
|
name: segment,
|
|
param,
|
|
interceptionMarker
|
|
};
|
|
} else if (segment.startsWith('(') && segment.endsWith(')')) {
|
|
return {
|
|
type: 'route-group',
|
|
name: segment,
|
|
interceptionMarker
|
|
};
|
|
} else if (segment.startsWith('@')) {
|
|
return {
|
|
type: 'parallel-route',
|
|
name: segment,
|
|
interceptionMarker
|
|
};
|
|
} else {
|
|
return {
|
|
type: 'static',
|
|
name: segment,
|
|
interceptionMarker
|
|
};
|
|
}
|
|
}
|
|
function isNormalizedAppRoute(route) {
|
|
return route.normalized;
|
|
}
|
|
function isInterceptionAppRoute(route) {
|
|
return route.interceptionMarker !== undefined && route.interceptingRoute !== undefined && route.interceptedRoute !== undefined;
|
|
}
|
|
function parseAppRoute(pathname, normalized) {
|
|
const pathnameSegments = pathname.split('/').filter(Boolean);
|
|
// Build segments array with static and dynamic segments
|
|
const segments = [];
|
|
// Parse if this is an interception route.
|
|
let interceptionMarker;
|
|
let interceptingRoute;
|
|
let interceptedRoute;
|
|
for (const segment of pathnameSegments){
|
|
// Parse the segment into an AppSegment.
|
|
const appSegment = parseAppRouteSegment(segment);
|
|
if (!appSegment) {
|
|
continue;
|
|
}
|
|
if (normalized && (appSegment.type === 'route-group' || appSegment.type === 'parallel-route')) {
|
|
throw Object.defineProperty(new _invarianterror.InvariantError(`${pathname} is being parsed as a normalized route, but it has a route group or parallel route segment.`), "__NEXT_ERROR_CODE", {
|
|
value: "E923",
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
}
|
|
segments.push(appSegment);
|
|
if (appSegment.interceptionMarker) {
|
|
const parts = pathname.split(appSegment.interceptionMarker);
|
|
if (parts.length !== 2) {
|
|
throw Object.defineProperty(new Error(`Invalid interception route: ${pathname}`), "__NEXT_ERROR_CODE", {
|
|
value: "E924",
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
}
|
|
interceptingRoute = normalized ? parseAppRoute(parts[0], true) : parseAppRoute(parts[0], false);
|
|
interceptedRoute = normalized ? parseAppRoute(parts[1], true) : parseAppRoute(parts[1], false);
|
|
interceptionMarker = appSegment.interceptionMarker;
|
|
}
|
|
}
|
|
const dynamicSegments = segments.filter((segment)=>segment.type === 'dynamic');
|
|
return {
|
|
normalized,
|
|
pathname,
|
|
segments,
|
|
dynamicSegments,
|
|
interceptionMarker,
|
|
interceptingRoute,
|
|
interceptedRoute
|
|
};
|
|
}
|
|
|
|
//# sourceMappingURL=app.js.map
|