Spaces:
Running
Running
File size: 4,398 Bytes
c592d77 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 | /**
* Client-safe utilities for route matching that don't import server-side
* utilities to avoid bundling issues with Turbopack
*/ "use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
0 && (module.exports = {
safeCompile: null,
safePathToRegexp: null,
safeRegexpToFunction: null,
safeRouteMatcher: null
});
function _export(target, all) {
for(var name in all)Object.defineProperty(target, name, {
enumerable: true,
get: all[name]
});
}
_export(exports, {
safeCompile: function() {
return safeCompile;
},
safePathToRegexp: function() {
return safePathToRegexp;
},
safeRegexpToFunction: function() {
return safeRegexpToFunction;
},
safeRouteMatcher: function() {
return safeRouteMatcher;
}
});
const _pathtoregexp = require("next/dist/compiled/path-to-regexp");
const _routepatternnormalizer = require("../../../../lib/route-pattern-normalizer");
function safePathToRegexp(route, keys, options) {
if (typeof route !== 'string') {
return (0, _pathtoregexp.pathToRegexp)(route, keys, options);
}
// Check if normalization is needed and cache the result
const needsNormalization = (0, _routepatternnormalizer.hasAdjacentParameterIssues)(route);
const routeToUse = needsNormalization ? (0, _routepatternnormalizer.normalizeAdjacentParameters)(route) : route;
try {
return (0, _pathtoregexp.pathToRegexp)(routeToUse, keys, options);
} catch (error) {
// Only try normalization if we haven't already normalized
if (!needsNormalization) {
try {
const normalizedRoute = (0, _routepatternnormalizer.normalizeAdjacentParameters)(route);
return (0, _pathtoregexp.pathToRegexp)(normalizedRoute, keys, options);
} catch (retryError) {
// If that doesn't work, fall back to original error
throw error;
}
}
throw error;
}
}
function safeCompile(route, options) {
// Check if normalization is needed and cache the result
const needsNormalization = (0, _routepatternnormalizer.hasAdjacentParameterIssues)(route);
const routeToUse = needsNormalization ? (0, _routepatternnormalizer.normalizeAdjacentParameters)(route) : route;
try {
const compiler = (0, _pathtoregexp.compile)(routeToUse, options);
// If we normalized the route, wrap the compiler to strip separators from output
// The normalization inserts _NEXTSEP_ as a literal string in the pattern to satisfy
// path-to-regexp validation, but we don't want it in the final compiled URL
if (needsNormalization) {
return (params)=>{
return (0, _routepatternnormalizer.stripNormalizedSeparators)(compiler(params));
};
}
return compiler;
} catch (error) {
// Only try normalization if we haven't already normalized
if (!needsNormalization) {
try {
const normalizedRoute = (0, _routepatternnormalizer.normalizeAdjacentParameters)(route);
const compiler = (0, _pathtoregexp.compile)(normalizedRoute, options);
// Wrap the compiler to strip separators from output
return (params)=>{
return (0, _routepatternnormalizer.stripNormalizedSeparators)(compiler(params));
};
} catch (retryError) {
// If that doesn't work, fall back to original error
throw error;
}
}
throw error;
}
}
function safeRegexpToFunction(regexp, keys) {
const originalMatcher = (0, _pathtoregexp.regexpToFunction)(regexp, keys || []);
return (pathname)=>{
const result = originalMatcher(pathname);
if (!result) return false;
// Clean parameters before returning
return {
...result,
params: (0, _routepatternnormalizer.stripParameterSeparators)(result.params)
};
};
}
function safeRouteMatcher(matcherFn) {
return (pathname)=>{
const result = matcherFn(pathname);
if (!result) return false;
// Clean parameters before returning
return (0, _routepatternnormalizer.stripParameterSeparators)(result);
};
}
//# sourceMappingURL=route-match-utils.js.map |