mirror of
https://github.com/Snigdha-OS/Snigdha-OS.github.io.git
synced 2025-09-06 04:35:18 +02:00
6017 lines
203 KiB
JavaScript
6017 lines
203 KiB
JavaScript
import {
|
|
require_react_dom
|
|
} from "./chunk-OR6547GA.js";
|
|
import {
|
|
require_react
|
|
} from "./chunk-THYVJR3I.js";
|
|
import {
|
|
__toESM
|
|
} from "./chunk-4B2QHNJT.js";
|
|
|
|
// node_modules/.pnpm/react-router-dom@6.28.1_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/react-router-dom/dist/index.js
|
|
var React2 = __toESM(require_react());
|
|
var ReactDOM = __toESM(require_react_dom());
|
|
|
|
// node_modules/.pnpm/react-router@6.28.1_react@18.3.1/node_modules/react-router/dist/index.js
|
|
var React = __toESM(require_react());
|
|
|
|
// node_modules/.pnpm/@remix-run+router@1.21.0/node_modules/@remix-run/router/dist/router.js
|
|
function _extends() {
|
|
_extends = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) {
|
|
if (Object.prototype.hasOwnProperty.call(source, key)) {
|
|
target[key] = source[key];
|
|
}
|
|
}
|
|
}
|
|
return target;
|
|
};
|
|
return _extends.apply(this, arguments);
|
|
}
|
|
var Action;
|
|
(function(Action2) {
|
|
Action2["Pop"] = "POP";
|
|
Action2["Push"] = "PUSH";
|
|
Action2["Replace"] = "REPLACE";
|
|
})(Action || (Action = {}));
|
|
var PopStateEventType = "popstate";
|
|
function createMemoryHistory(options) {
|
|
if (options === void 0) {
|
|
options = {};
|
|
}
|
|
let {
|
|
initialEntries = ["/"],
|
|
initialIndex,
|
|
v5Compat = false
|
|
} = options;
|
|
let entries;
|
|
entries = initialEntries.map((entry, index2) => createMemoryLocation(entry, typeof entry === "string" ? null : entry.state, index2 === 0 ? "default" : void 0));
|
|
let index = clampIndex(initialIndex == null ? entries.length - 1 : initialIndex);
|
|
let action = Action.Pop;
|
|
let listener = null;
|
|
function clampIndex(n) {
|
|
return Math.min(Math.max(n, 0), entries.length - 1);
|
|
}
|
|
function getCurrentLocation() {
|
|
return entries[index];
|
|
}
|
|
function createMemoryLocation(to, state, key) {
|
|
if (state === void 0) {
|
|
state = null;
|
|
}
|
|
let location = createLocation(entries ? getCurrentLocation().pathname : "/", to, state, key);
|
|
warning(location.pathname.charAt(0) === "/", "relative pathnames are not supported in memory history: " + JSON.stringify(to));
|
|
return location;
|
|
}
|
|
function createHref(to) {
|
|
return typeof to === "string" ? to : createPath(to);
|
|
}
|
|
let history = {
|
|
get index() {
|
|
return index;
|
|
},
|
|
get action() {
|
|
return action;
|
|
},
|
|
get location() {
|
|
return getCurrentLocation();
|
|
},
|
|
createHref,
|
|
createURL(to) {
|
|
return new URL(createHref(to), "http://localhost");
|
|
},
|
|
encodeLocation(to) {
|
|
let path = typeof to === "string" ? parsePath(to) : to;
|
|
return {
|
|
pathname: path.pathname || "",
|
|
search: path.search || "",
|
|
hash: path.hash || ""
|
|
};
|
|
},
|
|
push(to, state) {
|
|
action = Action.Push;
|
|
let nextLocation = createMemoryLocation(to, state);
|
|
index += 1;
|
|
entries.splice(index, entries.length, nextLocation);
|
|
if (v5Compat && listener) {
|
|
listener({
|
|
action,
|
|
location: nextLocation,
|
|
delta: 1
|
|
});
|
|
}
|
|
},
|
|
replace(to, state) {
|
|
action = Action.Replace;
|
|
let nextLocation = createMemoryLocation(to, state);
|
|
entries[index] = nextLocation;
|
|
if (v5Compat && listener) {
|
|
listener({
|
|
action,
|
|
location: nextLocation,
|
|
delta: 0
|
|
});
|
|
}
|
|
},
|
|
go(delta) {
|
|
action = Action.Pop;
|
|
let nextIndex = clampIndex(index + delta);
|
|
let nextLocation = entries[nextIndex];
|
|
index = nextIndex;
|
|
if (listener) {
|
|
listener({
|
|
action,
|
|
location: nextLocation,
|
|
delta
|
|
});
|
|
}
|
|
},
|
|
listen(fn) {
|
|
listener = fn;
|
|
return () => {
|
|
listener = null;
|
|
};
|
|
}
|
|
};
|
|
return history;
|
|
}
|
|
function createBrowserHistory(options) {
|
|
if (options === void 0) {
|
|
options = {};
|
|
}
|
|
function createBrowserLocation(window2, globalHistory) {
|
|
let {
|
|
pathname,
|
|
search,
|
|
hash
|
|
} = window2.location;
|
|
return createLocation(
|
|
"",
|
|
{
|
|
pathname,
|
|
search,
|
|
hash
|
|
},
|
|
// state defaults to `null` because `window.history.state` does
|
|
globalHistory.state && globalHistory.state.usr || null,
|
|
globalHistory.state && globalHistory.state.key || "default"
|
|
);
|
|
}
|
|
function createBrowserHref(window2, to) {
|
|
return typeof to === "string" ? to : createPath(to);
|
|
}
|
|
return getUrlBasedHistory(createBrowserLocation, createBrowserHref, null, options);
|
|
}
|
|
function createHashHistory(options) {
|
|
if (options === void 0) {
|
|
options = {};
|
|
}
|
|
function createHashLocation(window2, globalHistory) {
|
|
let {
|
|
pathname = "/",
|
|
search = "",
|
|
hash = ""
|
|
} = parsePath(window2.location.hash.substr(1));
|
|
if (!pathname.startsWith("/") && !pathname.startsWith(".")) {
|
|
pathname = "/" + pathname;
|
|
}
|
|
return createLocation(
|
|
"",
|
|
{
|
|
pathname,
|
|
search,
|
|
hash
|
|
},
|
|
// state defaults to `null` because `window.history.state` does
|
|
globalHistory.state && globalHistory.state.usr || null,
|
|
globalHistory.state && globalHistory.state.key || "default"
|
|
);
|
|
}
|
|
function createHashHref(window2, to) {
|
|
let base = window2.document.querySelector("base");
|
|
let href = "";
|
|
if (base && base.getAttribute("href")) {
|
|
let url = window2.location.href;
|
|
let hashIndex = url.indexOf("#");
|
|
href = hashIndex === -1 ? url : url.slice(0, hashIndex);
|
|
}
|
|
return href + "#" + (typeof to === "string" ? to : createPath(to));
|
|
}
|
|
function validateHashLocation(location, to) {
|
|
warning(location.pathname.charAt(0) === "/", "relative pathnames are not supported in hash history.push(" + JSON.stringify(to) + ")");
|
|
}
|
|
return getUrlBasedHistory(createHashLocation, createHashHref, validateHashLocation, options);
|
|
}
|
|
function invariant(value, message) {
|
|
if (value === false || value === null || typeof value === "undefined") {
|
|
throw new Error(message);
|
|
}
|
|
}
|
|
function warning(cond, message) {
|
|
if (!cond) {
|
|
if (typeof console !== "undefined") console.warn(message);
|
|
try {
|
|
throw new Error(message);
|
|
} catch (e) {
|
|
}
|
|
}
|
|
}
|
|
function createKey() {
|
|
return Math.random().toString(36).substr(2, 8);
|
|
}
|
|
function getHistoryState(location, index) {
|
|
return {
|
|
usr: location.state,
|
|
key: location.key,
|
|
idx: index
|
|
};
|
|
}
|
|
function createLocation(current, to, state, key) {
|
|
if (state === void 0) {
|
|
state = null;
|
|
}
|
|
let location = _extends({
|
|
pathname: typeof current === "string" ? current : current.pathname,
|
|
search: "",
|
|
hash: ""
|
|
}, typeof to === "string" ? parsePath(to) : to, {
|
|
state,
|
|
// TODO: This could be cleaned up. push/replace should probably just take
|
|
// full Locations now and avoid the need to run through this flow at all
|
|
// But that's a pretty big refactor to the current test suite so going to
|
|
// keep as is for the time being and just let any incoming keys take precedence
|
|
key: to && to.key || key || createKey()
|
|
});
|
|
return location;
|
|
}
|
|
function createPath(_ref) {
|
|
let {
|
|
pathname = "/",
|
|
search = "",
|
|
hash = ""
|
|
} = _ref;
|
|
if (search && search !== "?") pathname += search.charAt(0) === "?" ? search : "?" + search;
|
|
if (hash && hash !== "#") pathname += hash.charAt(0) === "#" ? hash : "#" + hash;
|
|
return pathname;
|
|
}
|
|
function parsePath(path) {
|
|
let parsedPath = {};
|
|
if (path) {
|
|
let hashIndex = path.indexOf("#");
|
|
if (hashIndex >= 0) {
|
|
parsedPath.hash = path.substr(hashIndex);
|
|
path = path.substr(0, hashIndex);
|
|
}
|
|
let searchIndex = path.indexOf("?");
|
|
if (searchIndex >= 0) {
|
|
parsedPath.search = path.substr(searchIndex);
|
|
path = path.substr(0, searchIndex);
|
|
}
|
|
if (path) {
|
|
parsedPath.pathname = path;
|
|
}
|
|
}
|
|
return parsedPath;
|
|
}
|
|
function getUrlBasedHistory(getLocation, createHref, validateLocation, options) {
|
|
if (options === void 0) {
|
|
options = {};
|
|
}
|
|
let {
|
|
window: window2 = document.defaultView,
|
|
v5Compat = false
|
|
} = options;
|
|
let globalHistory = window2.history;
|
|
let action = Action.Pop;
|
|
let listener = null;
|
|
let index = getIndex();
|
|
if (index == null) {
|
|
index = 0;
|
|
globalHistory.replaceState(_extends({}, globalHistory.state, {
|
|
idx: index
|
|
}), "");
|
|
}
|
|
function getIndex() {
|
|
let state = globalHistory.state || {
|
|
idx: null
|
|
};
|
|
return state.idx;
|
|
}
|
|
function handlePop() {
|
|
action = Action.Pop;
|
|
let nextIndex = getIndex();
|
|
let delta = nextIndex == null ? null : nextIndex - index;
|
|
index = nextIndex;
|
|
if (listener) {
|
|
listener({
|
|
action,
|
|
location: history.location,
|
|
delta
|
|
});
|
|
}
|
|
}
|
|
function push(to, state) {
|
|
action = Action.Push;
|
|
let location = createLocation(history.location, to, state);
|
|
if (validateLocation) validateLocation(location, to);
|
|
index = getIndex() + 1;
|
|
let historyState = getHistoryState(location, index);
|
|
let url = history.createHref(location);
|
|
try {
|
|
globalHistory.pushState(historyState, "", url);
|
|
} catch (error) {
|
|
if (error instanceof DOMException && error.name === "DataCloneError") {
|
|
throw error;
|
|
}
|
|
window2.location.assign(url);
|
|
}
|
|
if (v5Compat && listener) {
|
|
listener({
|
|
action,
|
|
location: history.location,
|
|
delta: 1
|
|
});
|
|
}
|
|
}
|
|
function replace2(to, state) {
|
|
action = Action.Replace;
|
|
let location = createLocation(history.location, to, state);
|
|
if (validateLocation) validateLocation(location, to);
|
|
index = getIndex();
|
|
let historyState = getHistoryState(location, index);
|
|
let url = history.createHref(location);
|
|
globalHistory.replaceState(historyState, "", url);
|
|
if (v5Compat && listener) {
|
|
listener({
|
|
action,
|
|
location: history.location,
|
|
delta: 0
|
|
});
|
|
}
|
|
}
|
|
function createURL(to) {
|
|
let base = window2.location.origin !== "null" ? window2.location.origin : window2.location.href;
|
|
let href = typeof to === "string" ? to : createPath(to);
|
|
href = href.replace(/ $/, "%20");
|
|
invariant(base, "No window.location.(origin|href) available to create URL for href: " + href);
|
|
return new URL(href, base);
|
|
}
|
|
let history = {
|
|
get action() {
|
|
return action;
|
|
},
|
|
get location() {
|
|
return getLocation(window2, globalHistory);
|
|
},
|
|
listen(fn) {
|
|
if (listener) {
|
|
throw new Error("A history only accepts one active listener");
|
|
}
|
|
window2.addEventListener(PopStateEventType, handlePop);
|
|
listener = fn;
|
|
return () => {
|
|
window2.removeEventListener(PopStateEventType, handlePop);
|
|
listener = null;
|
|
};
|
|
},
|
|
createHref(to) {
|
|
return createHref(window2, to);
|
|
},
|
|
createURL,
|
|
encodeLocation(to) {
|
|
let url = createURL(to);
|
|
return {
|
|
pathname: url.pathname,
|
|
search: url.search,
|
|
hash: url.hash
|
|
};
|
|
},
|
|
push,
|
|
replace: replace2,
|
|
go(n) {
|
|
return globalHistory.go(n);
|
|
}
|
|
};
|
|
return history;
|
|
}
|
|
var ResultType;
|
|
(function(ResultType2) {
|
|
ResultType2["data"] = "data";
|
|
ResultType2["deferred"] = "deferred";
|
|
ResultType2["redirect"] = "redirect";
|
|
ResultType2["error"] = "error";
|
|
})(ResultType || (ResultType = {}));
|
|
var immutableRouteKeys = /* @__PURE__ */ new Set(["lazy", "caseSensitive", "path", "id", "index", "children"]);
|
|
function isIndexRoute(route) {
|
|
return route.index === true;
|
|
}
|
|
function convertRoutesToDataRoutes(routes, mapRouteProperties2, parentPath, manifest) {
|
|
if (parentPath === void 0) {
|
|
parentPath = [];
|
|
}
|
|
if (manifest === void 0) {
|
|
manifest = {};
|
|
}
|
|
return routes.map((route, index) => {
|
|
let treePath = [...parentPath, String(index)];
|
|
let id = typeof route.id === "string" ? route.id : treePath.join("-");
|
|
invariant(route.index !== true || !route.children, "Cannot specify children on an index route");
|
|
invariant(!manifest[id], 'Found a route id collision on id "' + id + `". Route id's must be globally unique within Data Router usages`);
|
|
if (isIndexRoute(route)) {
|
|
let indexRoute = _extends({}, route, mapRouteProperties2(route), {
|
|
id
|
|
});
|
|
manifest[id] = indexRoute;
|
|
return indexRoute;
|
|
} else {
|
|
let pathOrLayoutRoute = _extends({}, route, mapRouteProperties2(route), {
|
|
id,
|
|
children: void 0
|
|
});
|
|
manifest[id] = pathOrLayoutRoute;
|
|
if (route.children) {
|
|
pathOrLayoutRoute.children = convertRoutesToDataRoutes(route.children, mapRouteProperties2, treePath, manifest);
|
|
}
|
|
return pathOrLayoutRoute;
|
|
}
|
|
});
|
|
}
|
|
function matchRoutes(routes, locationArg, basename) {
|
|
if (basename === void 0) {
|
|
basename = "/";
|
|
}
|
|
return matchRoutesImpl(routes, locationArg, basename, false);
|
|
}
|
|
function matchRoutesImpl(routes, locationArg, basename, allowPartial) {
|
|
let location = typeof locationArg === "string" ? parsePath(locationArg) : locationArg;
|
|
let pathname = stripBasename(location.pathname || "/", basename);
|
|
if (pathname == null) {
|
|
return null;
|
|
}
|
|
let branches = flattenRoutes(routes);
|
|
rankRouteBranches(branches);
|
|
let matches = null;
|
|
for (let i = 0; matches == null && i < branches.length; ++i) {
|
|
let decoded = decodePath(pathname);
|
|
matches = matchRouteBranch(branches[i], decoded, allowPartial);
|
|
}
|
|
return matches;
|
|
}
|
|
function convertRouteMatchToUiMatch(match, loaderData) {
|
|
let {
|
|
route,
|
|
pathname,
|
|
params
|
|
} = match;
|
|
return {
|
|
id: route.id,
|
|
pathname,
|
|
params,
|
|
data: loaderData[route.id],
|
|
handle: route.handle
|
|
};
|
|
}
|
|
function flattenRoutes(routes, branches, parentsMeta, parentPath) {
|
|
if (branches === void 0) {
|
|
branches = [];
|
|
}
|
|
if (parentsMeta === void 0) {
|
|
parentsMeta = [];
|
|
}
|
|
if (parentPath === void 0) {
|
|
parentPath = "";
|
|
}
|
|
let flattenRoute = (route, index, relativePath) => {
|
|
let meta = {
|
|
relativePath: relativePath === void 0 ? route.path || "" : relativePath,
|
|
caseSensitive: route.caseSensitive === true,
|
|
childrenIndex: index,
|
|
route
|
|
};
|
|
if (meta.relativePath.startsWith("/")) {
|
|
invariant(meta.relativePath.startsWith(parentPath), 'Absolute route path "' + meta.relativePath + '" nested under path ' + ('"' + parentPath + '" is not valid. An absolute child route path ') + "must start with the combined path of all its parent routes.");
|
|
meta.relativePath = meta.relativePath.slice(parentPath.length);
|
|
}
|
|
let path = joinPaths([parentPath, meta.relativePath]);
|
|
let routesMeta = parentsMeta.concat(meta);
|
|
if (route.children && route.children.length > 0) {
|
|
invariant(
|
|
// Our types know better, but runtime JS may not!
|
|
// @ts-expect-error
|
|
route.index !== true,
|
|
"Index routes must not have child routes. Please remove " + ('all child routes from route path "' + path + '".')
|
|
);
|
|
flattenRoutes(route.children, branches, routesMeta, path);
|
|
}
|
|
if (route.path == null && !route.index) {
|
|
return;
|
|
}
|
|
branches.push({
|
|
path,
|
|
score: computeScore(path, route.index),
|
|
routesMeta
|
|
});
|
|
};
|
|
routes.forEach((route, index) => {
|
|
var _route$path;
|
|
if (route.path === "" || !((_route$path = route.path) != null && _route$path.includes("?"))) {
|
|
flattenRoute(route, index);
|
|
} else {
|
|
for (let exploded of explodeOptionalSegments(route.path)) {
|
|
flattenRoute(route, index, exploded);
|
|
}
|
|
}
|
|
});
|
|
return branches;
|
|
}
|
|
function explodeOptionalSegments(path) {
|
|
let segments = path.split("/");
|
|
if (segments.length === 0) return [];
|
|
let [first, ...rest] = segments;
|
|
let isOptional = first.endsWith("?");
|
|
let required = first.replace(/\?$/, "");
|
|
if (rest.length === 0) {
|
|
return isOptional ? [required, ""] : [required];
|
|
}
|
|
let restExploded = explodeOptionalSegments(rest.join("/"));
|
|
let result = [];
|
|
result.push(...restExploded.map((subpath) => subpath === "" ? required : [required, subpath].join("/")));
|
|
if (isOptional) {
|
|
result.push(...restExploded);
|
|
}
|
|
return result.map((exploded) => path.startsWith("/") && exploded === "" ? "/" : exploded);
|
|
}
|
|
function rankRouteBranches(branches) {
|
|
branches.sort((a, b) => a.score !== b.score ? b.score - a.score : compareIndexes(a.routesMeta.map((meta) => meta.childrenIndex), b.routesMeta.map((meta) => meta.childrenIndex)));
|
|
}
|
|
var paramRe = /^:[\w-]+$/;
|
|
var dynamicSegmentValue = 3;
|
|
var indexRouteValue = 2;
|
|
var emptySegmentValue = 1;
|
|
var staticSegmentValue = 10;
|
|
var splatPenalty = -2;
|
|
var isSplat = (s) => s === "*";
|
|
function computeScore(path, index) {
|
|
let segments = path.split("/");
|
|
let initialScore = segments.length;
|
|
if (segments.some(isSplat)) {
|
|
initialScore += splatPenalty;
|
|
}
|
|
if (index) {
|
|
initialScore += indexRouteValue;
|
|
}
|
|
return segments.filter((s) => !isSplat(s)).reduce((score, segment) => score + (paramRe.test(segment) ? dynamicSegmentValue : segment === "" ? emptySegmentValue : staticSegmentValue), initialScore);
|
|
}
|
|
function compareIndexes(a, b) {
|
|
let siblings = a.length === b.length && a.slice(0, -1).every((n, i) => n === b[i]);
|
|
return siblings ? (
|
|
// If two routes are siblings, we should try to match the earlier sibling
|
|
// first. This allows people to have fine-grained control over the matching
|
|
// behavior by simply putting routes with identical paths in the order they
|
|
// want them tried.
|
|
a[a.length - 1] - b[b.length - 1]
|
|
) : (
|
|
// Otherwise, it doesn't really make sense to rank non-siblings by index,
|
|
// so they sort equally.
|
|
0
|
|
);
|
|
}
|
|
function matchRouteBranch(branch, pathname, allowPartial) {
|
|
if (allowPartial === void 0) {
|
|
allowPartial = false;
|
|
}
|
|
let {
|
|
routesMeta
|
|
} = branch;
|
|
let matchedParams = {};
|
|
let matchedPathname = "/";
|
|
let matches = [];
|
|
for (let i = 0; i < routesMeta.length; ++i) {
|
|
let meta = routesMeta[i];
|
|
let end = i === routesMeta.length - 1;
|
|
let remainingPathname = matchedPathname === "/" ? pathname : pathname.slice(matchedPathname.length) || "/";
|
|
let match = matchPath({
|
|
path: meta.relativePath,
|
|
caseSensitive: meta.caseSensitive,
|
|
end
|
|
}, remainingPathname);
|
|
let route = meta.route;
|
|
if (!match && end && allowPartial && !routesMeta[routesMeta.length - 1].route.index) {
|
|
match = matchPath({
|
|
path: meta.relativePath,
|
|
caseSensitive: meta.caseSensitive,
|
|
end: false
|
|
}, remainingPathname);
|
|
}
|
|
if (!match) {
|
|
return null;
|
|
}
|
|
Object.assign(matchedParams, match.params);
|
|
matches.push({
|
|
// TODO: Can this as be avoided?
|
|
params: matchedParams,
|
|
pathname: joinPaths([matchedPathname, match.pathname]),
|
|
pathnameBase: normalizePathname(joinPaths([matchedPathname, match.pathnameBase])),
|
|
route
|
|
});
|
|
if (match.pathnameBase !== "/") {
|
|
matchedPathname = joinPaths([matchedPathname, match.pathnameBase]);
|
|
}
|
|
}
|
|
return matches;
|
|
}
|
|
function generatePath(originalPath, params) {
|
|
if (params === void 0) {
|
|
params = {};
|
|
}
|
|
let path = originalPath;
|
|
if (path.endsWith("*") && path !== "*" && !path.endsWith("/*")) {
|
|
warning(false, 'Route path "' + path + '" will be treated as if it were ' + ('"' + path.replace(/\*$/, "/*") + '" because the `*` character must ') + "always follow a `/` in the pattern. To get rid of this warning, " + ('please change the route path to "' + path.replace(/\*$/, "/*") + '".'));
|
|
path = path.replace(/\*$/, "/*");
|
|
}
|
|
const prefix = path.startsWith("/") ? "/" : "";
|
|
const stringify = (p) => p == null ? "" : typeof p === "string" ? p : String(p);
|
|
const segments = path.split(/\/+/).map((segment, index, array) => {
|
|
const isLastSegment = index === array.length - 1;
|
|
if (isLastSegment && segment === "*") {
|
|
const star = "*";
|
|
return stringify(params[star]);
|
|
}
|
|
const keyMatch = segment.match(/^:([\w-]+)(\??)$/);
|
|
if (keyMatch) {
|
|
const [, key, optional] = keyMatch;
|
|
let param = params[key];
|
|
invariant(optional === "?" || param != null, 'Missing ":' + key + '" param');
|
|
return stringify(param);
|
|
}
|
|
return segment.replace(/\?$/g, "");
|
|
}).filter((segment) => !!segment);
|
|
return prefix + segments.join("/");
|
|
}
|
|
function matchPath(pattern, pathname) {
|
|
if (typeof pattern === "string") {
|
|
pattern = {
|
|
path: pattern,
|
|
caseSensitive: false,
|
|
end: true
|
|
};
|
|
}
|
|
let [matcher, compiledParams] = compilePath(pattern.path, pattern.caseSensitive, pattern.end);
|
|
let match = pathname.match(matcher);
|
|
if (!match) return null;
|
|
let matchedPathname = match[0];
|
|
let pathnameBase = matchedPathname.replace(/(.)\/+$/, "$1");
|
|
let captureGroups = match.slice(1);
|
|
let params = compiledParams.reduce((memo2, _ref, index) => {
|
|
let {
|
|
paramName,
|
|
isOptional
|
|
} = _ref;
|
|
if (paramName === "*") {
|
|
let splatValue = captureGroups[index] || "";
|
|
pathnameBase = matchedPathname.slice(0, matchedPathname.length - splatValue.length).replace(/(.)\/+$/, "$1");
|
|
}
|
|
const value = captureGroups[index];
|
|
if (isOptional && !value) {
|
|
memo2[paramName] = void 0;
|
|
} else {
|
|
memo2[paramName] = (value || "").replace(/%2F/g, "/");
|
|
}
|
|
return memo2;
|
|
}, {});
|
|
return {
|
|
params,
|
|
pathname: matchedPathname,
|
|
pathnameBase,
|
|
pattern
|
|
};
|
|
}
|
|
function compilePath(path, caseSensitive, end) {
|
|
if (caseSensitive === void 0) {
|
|
caseSensitive = false;
|
|
}
|
|
if (end === void 0) {
|
|
end = true;
|
|
}
|
|
warning(path === "*" || !path.endsWith("*") || path.endsWith("/*"), 'Route path "' + path + '" will be treated as if it were ' + ('"' + path.replace(/\*$/, "/*") + '" because the `*` character must ') + "always follow a `/` in the pattern. To get rid of this warning, " + ('please change the route path to "' + path.replace(/\*$/, "/*") + '".'));
|
|
let params = [];
|
|
let regexpSource = "^" + path.replace(/\/*\*?$/, "").replace(/^\/*/, "/").replace(/[\\.*+^${}|()[\]]/g, "\\$&").replace(/\/:([\w-]+)(\?)?/g, (_, paramName, isOptional) => {
|
|
params.push({
|
|
paramName,
|
|
isOptional: isOptional != null
|
|
});
|
|
return isOptional ? "/?([^\\/]+)?" : "/([^\\/]+)";
|
|
});
|
|
if (path.endsWith("*")) {
|
|
params.push({
|
|
paramName: "*"
|
|
});
|
|
regexpSource += path === "*" || path === "/*" ? "(.*)$" : "(?:\\/(.+)|\\/*)$";
|
|
} else if (end) {
|
|
regexpSource += "\\/*$";
|
|
} else if (path !== "" && path !== "/") {
|
|
regexpSource += "(?:(?=\\/|$))";
|
|
} else ;
|
|
let matcher = new RegExp(regexpSource, caseSensitive ? void 0 : "i");
|
|
return [matcher, params];
|
|
}
|
|
function decodePath(value) {
|
|
try {
|
|
return value.split("/").map((v) => decodeURIComponent(v).replace(/\//g, "%2F")).join("/");
|
|
} catch (error) {
|
|
warning(false, 'The URL path "' + value + '" could not be decoded because it is is a malformed URL segment. This is probably due to a bad percent ' + ("encoding (" + error + ")."));
|
|
return value;
|
|
}
|
|
}
|
|
function stripBasename(pathname, basename) {
|
|
if (basename === "/") return pathname;
|
|
if (!pathname.toLowerCase().startsWith(basename.toLowerCase())) {
|
|
return null;
|
|
}
|
|
let startIndex = basename.endsWith("/") ? basename.length - 1 : basename.length;
|
|
let nextChar = pathname.charAt(startIndex);
|
|
if (nextChar && nextChar !== "/") {
|
|
return null;
|
|
}
|
|
return pathname.slice(startIndex) || "/";
|
|
}
|
|
function resolvePath(to, fromPathname) {
|
|
if (fromPathname === void 0) {
|
|
fromPathname = "/";
|
|
}
|
|
let {
|
|
pathname: toPathname,
|
|
search = "",
|
|
hash = ""
|
|
} = typeof to === "string" ? parsePath(to) : to;
|
|
let pathname = toPathname ? toPathname.startsWith("/") ? toPathname : resolvePathname(toPathname, fromPathname) : fromPathname;
|
|
return {
|
|
pathname,
|
|
search: normalizeSearch(search),
|
|
hash: normalizeHash(hash)
|
|
};
|
|
}
|
|
function resolvePathname(relativePath, fromPathname) {
|
|
let segments = fromPathname.replace(/\/+$/, "").split("/");
|
|
let relativeSegments = relativePath.split("/");
|
|
relativeSegments.forEach((segment) => {
|
|
if (segment === "..") {
|
|
if (segments.length > 1) segments.pop();
|
|
} else if (segment !== ".") {
|
|
segments.push(segment);
|
|
}
|
|
});
|
|
return segments.length > 1 ? segments.join("/") : "/";
|
|
}
|
|
function getInvalidPathError(char, field, dest, path) {
|
|
return "Cannot include a '" + char + "' character in a manually specified " + ("`to." + field + "` field [" + JSON.stringify(path) + "]. Please separate it out to the ") + ("`to." + dest + "` field. Alternatively you may provide the full path as ") + 'a string in <Link to="..."> and the router will parse it for you.';
|
|
}
|
|
function getPathContributingMatches(matches) {
|
|
return matches.filter((match, index) => index === 0 || match.route.path && match.route.path.length > 0);
|
|
}
|
|
function getResolveToMatches(matches, v7_relativeSplatPath) {
|
|
let pathMatches = getPathContributingMatches(matches);
|
|
if (v7_relativeSplatPath) {
|
|
return pathMatches.map((match, idx) => idx === pathMatches.length - 1 ? match.pathname : match.pathnameBase);
|
|
}
|
|
return pathMatches.map((match) => match.pathnameBase);
|
|
}
|
|
function resolveTo(toArg, routePathnames, locationPathname, isPathRelative) {
|
|
if (isPathRelative === void 0) {
|
|
isPathRelative = false;
|
|
}
|
|
let to;
|
|
if (typeof toArg === "string") {
|
|
to = parsePath(toArg);
|
|
} else {
|
|
to = _extends({}, toArg);
|
|
invariant(!to.pathname || !to.pathname.includes("?"), getInvalidPathError("?", "pathname", "search", to));
|
|
invariant(!to.pathname || !to.pathname.includes("#"), getInvalidPathError("#", "pathname", "hash", to));
|
|
invariant(!to.search || !to.search.includes("#"), getInvalidPathError("#", "search", "hash", to));
|
|
}
|
|
let isEmptyPath = toArg === "" || to.pathname === "";
|
|
let toPathname = isEmptyPath ? "/" : to.pathname;
|
|
let from;
|
|
if (toPathname == null) {
|
|
from = locationPathname;
|
|
} else {
|
|
let routePathnameIndex = routePathnames.length - 1;
|
|
if (!isPathRelative && toPathname.startsWith("..")) {
|
|
let toSegments = toPathname.split("/");
|
|
while (toSegments[0] === "..") {
|
|
toSegments.shift();
|
|
routePathnameIndex -= 1;
|
|
}
|
|
to.pathname = toSegments.join("/");
|
|
}
|
|
from = routePathnameIndex >= 0 ? routePathnames[routePathnameIndex] : "/";
|
|
}
|
|
let path = resolvePath(to, from);
|
|
let hasExplicitTrailingSlash = toPathname && toPathname !== "/" && toPathname.endsWith("/");
|
|
let hasCurrentTrailingSlash = (isEmptyPath || toPathname === ".") && locationPathname.endsWith("/");
|
|
if (!path.pathname.endsWith("/") && (hasExplicitTrailingSlash || hasCurrentTrailingSlash)) {
|
|
path.pathname += "/";
|
|
}
|
|
return path;
|
|
}
|
|
var joinPaths = (paths) => paths.join("/").replace(/\/\/+/g, "/");
|
|
var normalizePathname = (pathname) => pathname.replace(/\/+$/, "").replace(/^\/*/, "/");
|
|
var normalizeSearch = (search) => !search || search === "?" ? "" : search.startsWith("?") ? search : "?" + search;
|
|
var normalizeHash = (hash) => !hash || hash === "#" ? "" : hash.startsWith("#") ? hash : "#" + hash;
|
|
var json = function json2(data, init) {
|
|
if (init === void 0) {
|
|
init = {};
|
|
}
|
|
let responseInit = typeof init === "number" ? {
|
|
status: init
|
|
} : init;
|
|
let headers = new Headers(responseInit.headers);
|
|
if (!headers.has("Content-Type")) {
|
|
headers.set("Content-Type", "application/json; charset=utf-8");
|
|
}
|
|
return new Response(JSON.stringify(data), _extends({}, responseInit, {
|
|
headers
|
|
}));
|
|
};
|
|
var AbortedDeferredError = class extends Error {
|
|
};
|
|
var DeferredData = class {
|
|
constructor(data, responseInit) {
|
|
this.pendingKeysSet = /* @__PURE__ */ new Set();
|
|
this.subscribers = /* @__PURE__ */ new Set();
|
|
this.deferredKeys = [];
|
|
invariant(data && typeof data === "object" && !Array.isArray(data), "defer() only accepts plain objects");
|
|
let reject;
|
|
this.abortPromise = new Promise((_, r) => reject = r);
|
|
this.controller = new AbortController();
|
|
let onAbort = () => reject(new AbortedDeferredError("Deferred data aborted"));
|
|
this.unlistenAbortSignal = () => this.controller.signal.removeEventListener("abort", onAbort);
|
|
this.controller.signal.addEventListener("abort", onAbort);
|
|
this.data = Object.entries(data).reduce((acc, _ref2) => {
|
|
let [key, value] = _ref2;
|
|
return Object.assign(acc, {
|
|
[key]: this.trackPromise(key, value)
|
|
});
|
|
}, {});
|
|
if (this.done) {
|
|
this.unlistenAbortSignal();
|
|
}
|
|
this.init = responseInit;
|
|
}
|
|
trackPromise(key, value) {
|
|
if (!(value instanceof Promise)) {
|
|
return value;
|
|
}
|
|
this.deferredKeys.push(key);
|
|
this.pendingKeysSet.add(key);
|
|
let promise = Promise.race([value, this.abortPromise]).then((data) => this.onSettle(promise, key, void 0, data), (error) => this.onSettle(promise, key, error));
|
|
promise.catch(() => {
|
|
});
|
|
Object.defineProperty(promise, "_tracked", {
|
|
get: () => true
|
|
});
|
|
return promise;
|
|
}
|
|
onSettle(promise, key, error, data) {
|
|
if (this.controller.signal.aborted && error instanceof AbortedDeferredError) {
|
|
this.unlistenAbortSignal();
|
|
Object.defineProperty(promise, "_error", {
|
|
get: () => error
|
|
});
|
|
return Promise.reject(error);
|
|
}
|
|
this.pendingKeysSet.delete(key);
|
|
if (this.done) {
|
|
this.unlistenAbortSignal();
|
|
}
|
|
if (error === void 0 && data === void 0) {
|
|
let undefinedError = new Error('Deferred data for key "' + key + '" resolved/rejected with `undefined`, you must resolve/reject with a value or `null`.');
|
|
Object.defineProperty(promise, "_error", {
|
|
get: () => undefinedError
|
|
});
|
|
this.emit(false, key);
|
|
return Promise.reject(undefinedError);
|
|
}
|
|
if (data === void 0) {
|
|
Object.defineProperty(promise, "_error", {
|
|
get: () => error
|
|
});
|
|
this.emit(false, key);
|
|
return Promise.reject(error);
|
|
}
|
|
Object.defineProperty(promise, "_data", {
|
|
get: () => data
|
|
});
|
|
this.emit(false, key);
|
|
return data;
|
|
}
|
|
emit(aborted, settledKey) {
|
|
this.subscribers.forEach((subscriber) => subscriber(aborted, settledKey));
|
|
}
|
|
subscribe(fn) {
|
|
this.subscribers.add(fn);
|
|
return () => this.subscribers.delete(fn);
|
|
}
|
|
cancel() {
|
|
this.controller.abort();
|
|
this.pendingKeysSet.forEach((v, k) => this.pendingKeysSet.delete(k));
|
|
this.emit(true);
|
|
}
|
|
async resolveData(signal) {
|
|
let aborted = false;
|
|
if (!this.done) {
|
|
let onAbort = () => this.cancel();
|
|
signal.addEventListener("abort", onAbort);
|
|
aborted = await new Promise((resolve) => {
|
|
this.subscribe((aborted2) => {
|
|
signal.removeEventListener("abort", onAbort);
|
|
if (aborted2 || this.done) {
|
|
resolve(aborted2);
|
|
}
|
|
});
|
|
});
|
|
}
|
|
return aborted;
|
|
}
|
|
get done() {
|
|
return this.pendingKeysSet.size === 0;
|
|
}
|
|
get unwrappedData() {
|
|
invariant(this.data !== null && this.done, "Can only unwrap data on initialized and settled deferreds");
|
|
return Object.entries(this.data).reduce((acc, _ref3) => {
|
|
let [key, value] = _ref3;
|
|
return Object.assign(acc, {
|
|
[key]: unwrapTrackedPromise(value)
|
|
});
|
|
}, {});
|
|
}
|
|
get pendingKeys() {
|
|
return Array.from(this.pendingKeysSet);
|
|
}
|
|
};
|
|
function isTrackedPromise(value) {
|
|
return value instanceof Promise && value._tracked === true;
|
|
}
|
|
function unwrapTrackedPromise(value) {
|
|
if (!isTrackedPromise(value)) {
|
|
return value;
|
|
}
|
|
if (value._error) {
|
|
throw value._error;
|
|
}
|
|
return value._data;
|
|
}
|
|
var defer = function defer2(data, init) {
|
|
if (init === void 0) {
|
|
init = {};
|
|
}
|
|
let responseInit = typeof init === "number" ? {
|
|
status: init
|
|
} : init;
|
|
return new DeferredData(data, responseInit);
|
|
};
|
|
var redirect = function redirect2(url, init) {
|
|
if (init === void 0) {
|
|
init = 302;
|
|
}
|
|
let responseInit = init;
|
|
if (typeof responseInit === "number") {
|
|
responseInit = {
|
|
status: responseInit
|
|
};
|
|
} else if (typeof responseInit.status === "undefined") {
|
|
responseInit.status = 302;
|
|
}
|
|
let headers = new Headers(responseInit.headers);
|
|
headers.set("Location", url);
|
|
return new Response(null, _extends({}, responseInit, {
|
|
headers
|
|
}));
|
|
};
|
|
var redirectDocument = (url, init) => {
|
|
let response = redirect(url, init);
|
|
response.headers.set("X-Remix-Reload-Document", "true");
|
|
return response;
|
|
};
|
|
var replace = (url, init) => {
|
|
let response = redirect(url, init);
|
|
response.headers.set("X-Remix-Replace", "true");
|
|
return response;
|
|
};
|
|
var ErrorResponseImpl = class {
|
|
constructor(status, statusText, data, internal) {
|
|
if (internal === void 0) {
|
|
internal = false;
|
|
}
|
|
this.status = status;
|
|
this.statusText = statusText || "";
|
|
this.internal = internal;
|
|
if (data instanceof Error) {
|
|
this.data = data.toString();
|
|
this.error = data;
|
|
} else {
|
|
this.data = data;
|
|
}
|
|
}
|
|
};
|
|
function isRouteErrorResponse(error) {
|
|
return error != null && typeof error.status === "number" && typeof error.statusText === "string" && typeof error.internal === "boolean" && "data" in error;
|
|
}
|
|
var validMutationMethodsArr = ["post", "put", "patch", "delete"];
|
|
var validMutationMethods = new Set(validMutationMethodsArr);
|
|
var validRequestMethodsArr = ["get", ...validMutationMethodsArr];
|
|
var validRequestMethods = new Set(validRequestMethodsArr);
|
|
var redirectStatusCodes = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
|
|
var redirectPreserveMethodStatusCodes = /* @__PURE__ */ new Set([307, 308]);
|
|
var IDLE_NAVIGATION = {
|
|
state: "idle",
|
|
location: void 0,
|
|
formMethod: void 0,
|
|
formAction: void 0,
|
|
formEncType: void 0,
|
|
formData: void 0,
|
|
json: void 0,
|
|
text: void 0
|
|
};
|
|
var IDLE_FETCHER = {
|
|
state: "idle",
|
|
data: void 0,
|
|
formMethod: void 0,
|
|
formAction: void 0,
|
|
formEncType: void 0,
|
|
formData: void 0,
|
|
json: void 0,
|
|
text: void 0
|
|
};
|
|
var IDLE_BLOCKER = {
|
|
state: "unblocked",
|
|
proceed: void 0,
|
|
reset: void 0,
|
|
location: void 0
|
|
};
|
|
var ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
|
|
var defaultMapRouteProperties = (route) => ({
|
|
hasErrorBoundary: Boolean(route.hasErrorBoundary)
|
|
});
|
|
var TRANSITIONS_STORAGE_KEY = "remix-router-transitions";
|
|
function createRouter(init) {
|
|
const routerWindow = init.window ? init.window : typeof window !== "undefined" ? window : void 0;
|
|
const isBrowser2 = typeof routerWindow !== "undefined" && typeof routerWindow.document !== "undefined" && typeof routerWindow.document.createElement !== "undefined";
|
|
const isServer = !isBrowser2;
|
|
invariant(init.routes.length > 0, "You must provide a non-empty routes array to createRouter");
|
|
let mapRouteProperties2;
|
|
if (init.mapRouteProperties) {
|
|
mapRouteProperties2 = init.mapRouteProperties;
|
|
} else if (init.detectErrorBoundary) {
|
|
let detectErrorBoundary = init.detectErrorBoundary;
|
|
mapRouteProperties2 = (route) => ({
|
|
hasErrorBoundary: detectErrorBoundary(route)
|
|
});
|
|
} else {
|
|
mapRouteProperties2 = defaultMapRouteProperties;
|
|
}
|
|
let manifest = {};
|
|
let dataRoutes = convertRoutesToDataRoutes(init.routes, mapRouteProperties2, void 0, manifest);
|
|
let inFlightDataRoutes;
|
|
let basename = init.basename || "/";
|
|
let dataStrategyImpl = init.dataStrategy || defaultDataStrategy;
|
|
let patchRoutesOnNavigationImpl = init.patchRoutesOnNavigation;
|
|
let future = _extends({
|
|
v7_fetcherPersist: false,
|
|
v7_normalizeFormMethod: false,
|
|
v7_partialHydration: false,
|
|
v7_prependBasename: false,
|
|
v7_relativeSplatPath: false,
|
|
v7_skipActionErrorRevalidation: false
|
|
}, init.future);
|
|
let unlistenHistory = null;
|
|
let subscribers = /* @__PURE__ */ new Set();
|
|
let savedScrollPositions2 = null;
|
|
let getScrollRestorationKey = null;
|
|
let getScrollPosition = null;
|
|
let initialScrollRestored = init.hydrationData != null;
|
|
let initialMatches = matchRoutes(dataRoutes, init.history.location, basename);
|
|
let initialErrors = null;
|
|
if (initialMatches == null && !patchRoutesOnNavigationImpl) {
|
|
let error = getInternalRouterError(404, {
|
|
pathname: init.history.location.pathname
|
|
});
|
|
let {
|
|
matches,
|
|
route
|
|
} = getShortCircuitMatches(dataRoutes);
|
|
initialMatches = matches;
|
|
initialErrors = {
|
|
[route.id]: error
|
|
};
|
|
}
|
|
if (initialMatches && !init.hydrationData) {
|
|
let fogOfWar = checkFogOfWar(initialMatches, dataRoutes, init.history.location.pathname);
|
|
if (fogOfWar.active) {
|
|
initialMatches = null;
|
|
}
|
|
}
|
|
let initialized;
|
|
if (!initialMatches) {
|
|
initialized = false;
|
|
initialMatches = [];
|
|
if (future.v7_partialHydration) {
|
|
let fogOfWar = checkFogOfWar(null, dataRoutes, init.history.location.pathname);
|
|
if (fogOfWar.active && fogOfWar.matches) {
|
|
initialMatches = fogOfWar.matches;
|
|
}
|
|
}
|
|
} else if (initialMatches.some((m) => m.route.lazy)) {
|
|
initialized = false;
|
|
} else if (!initialMatches.some((m) => m.route.loader)) {
|
|
initialized = true;
|
|
} else if (future.v7_partialHydration) {
|
|
let loaderData = init.hydrationData ? init.hydrationData.loaderData : null;
|
|
let errors = init.hydrationData ? init.hydrationData.errors : null;
|
|
if (errors) {
|
|
let idx = initialMatches.findIndex((m) => errors[m.route.id] !== void 0);
|
|
initialized = initialMatches.slice(0, idx + 1).every((m) => !shouldLoadRouteOnHydration(m.route, loaderData, errors));
|
|
} else {
|
|
initialized = initialMatches.every((m) => !shouldLoadRouteOnHydration(m.route, loaderData, errors));
|
|
}
|
|
} else {
|
|
initialized = init.hydrationData != null;
|
|
}
|
|
let router;
|
|
let state = {
|
|
historyAction: init.history.action,
|
|
location: init.history.location,
|
|
matches: initialMatches,
|
|
initialized,
|
|
navigation: IDLE_NAVIGATION,
|
|
// Don't restore on initial updateState() if we were SSR'd
|
|
restoreScrollPosition: init.hydrationData != null ? false : null,
|
|
preventScrollReset: false,
|
|
revalidation: "idle",
|
|
loaderData: init.hydrationData && init.hydrationData.loaderData || {},
|
|
actionData: init.hydrationData && init.hydrationData.actionData || null,
|
|
errors: init.hydrationData && init.hydrationData.errors || initialErrors,
|
|
fetchers: /* @__PURE__ */ new Map(),
|
|
blockers: /* @__PURE__ */ new Map()
|
|
};
|
|
let pendingAction = Action.Pop;
|
|
let pendingPreventScrollReset = false;
|
|
let pendingNavigationController;
|
|
let pendingViewTransitionEnabled = false;
|
|
let appliedViewTransitions = /* @__PURE__ */ new Map();
|
|
let removePageHideEventListener = null;
|
|
let isUninterruptedRevalidation = false;
|
|
let isRevalidationRequired = false;
|
|
let cancelledDeferredRoutes = [];
|
|
let cancelledFetcherLoads = /* @__PURE__ */ new Set();
|
|
let fetchControllers = /* @__PURE__ */ new Map();
|
|
let incrementingLoadId = 0;
|
|
let pendingNavigationLoadId = -1;
|
|
let fetchReloadIds = /* @__PURE__ */ new Map();
|
|
let fetchRedirectIds = /* @__PURE__ */ new Set();
|
|
let fetchLoadMatches = /* @__PURE__ */ new Map();
|
|
let activeFetchers = /* @__PURE__ */ new Map();
|
|
let deletedFetchers = /* @__PURE__ */ new Set();
|
|
let activeDeferreds = /* @__PURE__ */ new Map();
|
|
let blockerFunctions = /* @__PURE__ */ new Map();
|
|
let unblockBlockerHistoryUpdate = void 0;
|
|
function initialize() {
|
|
unlistenHistory = init.history.listen((_ref) => {
|
|
let {
|
|
action: historyAction,
|
|
location,
|
|
delta
|
|
} = _ref;
|
|
if (unblockBlockerHistoryUpdate) {
|
|
unblockBlockerHistoryUpdate();
|
|
unblockBlockerHistoryUpdate = void 0;
|
|
return;
|
|
}
|
|
warning(blockerFunctions.size === 0 || delta != null, "You are trying to use a blocker on a POP navigation to a location that was not created by @remix-run/router. This will fail silently in production. This can happen if you are navigating outside the router via `window.history.pushState`/`window.location.hash` instead of using router navigation APIs. This can also happen if you are using createHashRouter and the user manually changes the URL.");
|
|
let blockerKey = shouldBlockNavigation({
|
|
currentLocation: state.location,
|
|
nextLocation: location,
|
|
historyAction
|
|
});
|
|
if (blockerKey && delta != null) {
|
|
let nextHistoryUpdatePromise = new Promise((resolve) => {
|
|
unblockBlockerHistoryUpdate = resolve;
|
|
});
|
|
init.history.go(delta * -1);
|
|
updateBlocker(blockerKey, {
|
|
state: "blocked",
|
|
location,
|
|
proceed() {
|
|
updateBlocker(blockerKey, {
|
|
state: "proceeding",
|
|
proceed: void 0,
|
|
reset: void 0,
|
|
location
|
|
});
|
|
nextHistoryUpdatePromise.then(() => init.history.go(delta));
|
|
},
|
|
reset() {
|
|
let blockers = new Map(state.blockers);
|
|
blockers.set(blockerKey, IDLE_BLOCKER);
|
|
updateState({
|
|
blockers
|
|
});
|
|
}
|
|
});
|
|
return;
|
|
}
|
|
return startNavigation(historyAction, location);
|
|
});
|
|
if (isBrowser2) {
|
|
restoreAppliedTransitions(routerWindow, appliedViewTransitions);
|
|
let _saveAppliedTransitions = () => persistAppliedTransitions(routerWindow, appliedViewTransitions);
|
|
routerWindow.addEventListener("pagehide", _saveAppliedTransitions);
|
|
removePageHideEventListener = () => routerWindow.removeEventListener("pagehide", _saveAppliedTransitions);
|
|
}
|
|
if (!state.initialized) {
|
|
startNavigation(Action.Pop, state.location, {
|
|
initialHydration: true
|
|
});
|
|
}
|
|
return router;
|
|
}
|
|
function dispose() {
|
|
if (unlistenHistory) {
|
|
unlistenHistory();
|
|
}
|
|
if (removePageHideEventListener) {
|
|
removePageHideEventListener();
|
|
}
|
|
subscribers.clear();
|
|
pendingNavigationController && pendingNavigationController.abort();
|
|
state.fetchers.forEach((_, key) => deleteFetcher(key));
|
|
state.blockers.forEach((_, key) => deleteBlocker(key));
|
|
}
|
|
function subscribe(fn) {
|
|
subscribers.add(fn);
|
|
return () => subscribers.delete(fn);
|
|
}
|
|
function updateState(newState, opts) {
|
|
if (opts === void 0) {
|
|
opts = {};
|
|
}
|
|
state = _extends({}, state, newState);
|
|
let completedFetchers = [];
|
|
let deletedFetchersKeys = [];
|
|
if (future.v7_fetcherPersist) {
|
|
state.fetchers.forEach((fetcher, key) => {
|
|
if (fetcher.state === "idle") {
|
|
if (deletedFetchers.has(key)) {
|
|
deletedFetchersKeys.push(key);
|
|
} else {
|
|
completedFetchers.push(key);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
[...subscribers].forEach((subscriber) => subscriber(state, {
|
|
deletedFetchers: deletedFetchersKeys,
|
|
viewTransitionOpts: opts.viewTransitionOpts,
|
|
flushSync: opts.flushSync === true
|
|
}));
|
|
if (future.v7_fetcherPersist) {
|
|
completedFetchers.forEach((key) => state.fetchers.delete(key));
|
|
deletedFetchersKeys.forEach((key) => deleteFetcher(key));
|
|
}
|
|
}
|
|
function completeNavigation(location, newState, _temp) {
|
|
var _location$state, _location$state2;
|
|
let {
|
|
flushSync
|
|
} = _temp === void 0 ? {} : _temp;
|
|
let isActionReload = state.actionData != null && state.navigation.formMethod != null && isMutationMethod(state.navigation.formMethod) && state.navigation.state === "loading" && ((_location$state = location.state) == null ? void 0 : _location$state._isRedirect) !== true;
|
|
let actionData;
|
|
if (newState.actionData) {
|
|
if (Object.keys(newState.actionData).length > 0) {
|
|
actionData = newState.actionData;
|
|
} else {
|
|
actionData = null;
|
|
}
|
|
} else if (isActionReload) {
|
|
actionData = state.actionData;
|
|
} else {
|
|
actionData = null;
|
|
}
|
|
let loaderData = newState.loaderData ? mergeLoaderData(state.loaderData, newState.loaderData, newState.matches || [], newState.errors) : state.loaderData;
|
|
let blockers = state.blockers;
|
|
if (blockers.size > 0) {
|
|
blockers = new Map(blockers);
|
|
blockers.forEach((_, k) => blockers.set(k, IDLE_BLOCKER));
|
|
}
|
|
let preventScrollReset = pendingPreventScrollReset === true || state.navigation.formMethod != null && isMutationMethod(state.navigation.formMethod) && ((_location$state2 = location.state) == null ? void 0 : _location$state2._isRedirect) !== true;
|
|
if (inFlightDataRoutes) {
|
|
dataRoutes = inFlightDataRoutes;
|
|
inFlightDataRoutes = void 0;
|
|
}
|
|
if (isUninterruptedRevalidation) ;
|
|
else if (pendingAction === Action.Pop) ;
|
|
else if (pendingAction === Action.Push) {
|
|
init.history.push(location, location.state);
|
|
} else if (pendingAction === Action.Replace) {
|
|
init.history.replace(location, location.state);
|
|
}
|
|
let viewTransitionOpts;
|
|
if (pendingAction === Action.Pop) {
|
|
let priorPaths = appliedViewTransitions.get(state.location.pathname);
|
|
if (priorPaths && priorPaths.has(location.pathname)) {
|
|
viewTransitionOpts = {
|
|
currentLocation: state.location,
|
|
nextLocation: location
|
|
};
|
|
} else if (appliedViewTransitions.has(location.pathname)) {
|
|
viewTransitionOpts = {
|
|
currentLocation: location,
|
|
nextLocation: state.location
|
|
};
|
|
}
|
|
} else if (pendingViewTransitionEnabled) {
|
|
let toPaths = appliedViewTransitions.get(state.location.pathname);
|
|
if (toPaths) {
|
|
toPaths.add(location.pathname);
|
|
} else {
|
|
toPaths = /* @__PURE__ */ new Set([location.pathname]);
|
|
appliedViewTransitions.set(state.location.pathname, toPaths);
|
|
}
|
|
viewTransitionOpts = {
|
|
currentLocation: state.location,
|
|
nextLocation: location
|
|
};
|
|
}
|
|
updateState(_extends({}, newState, {
|
|
actionData,
|
|
loaderData,
|
|
historyAction: pendingAction,
|
|
location,
|
|
initialized: true,
|
|
navigation: IDLE_NAVIGATION,
|
|
revalidation: "idle",
|
|
restoreScrollPosition: getSavedScrollPosition(location, newState.matches || state.matches),
|
|
preventScrollReset,
|
|
blockers
|
|
}), {
|
|
viewTransitionOpts,
|
|
flushSync: flushSync === true
|
|
});
|
|
pendingAction = Action.Pop;
|
|
pendingPreventScrollReset = false;
|
|
pendingViewTransitionEnabled = false;
|
|
isUninterruptedRevalidation = false;
|
|
isRevalidationRequired = false;
|
|
cancelledDeferredRoutes = [];
|
|
}
|
|
async function navigate(to, opts) {
|
|
if (typeof to === "number") {
|
|
init.history.go(to);
|
|
return;
|
|
}
|
|
let normalizedPath = normalizeTo(state.location, state.matches, basename, future.v7_prependBasename, to, future.v7_relativeSplatPath, opts == null ? void 0 : opts.fromRouteId, opts == null ? void 0 : opts.relative);
|
|
let {
|
|
path,
|
|
submission,
|
|
error
|
|
} = normalizeNavigateOptions(future.v7_normalizeFormMethod, false, normalizedPath, opts);
|
|
let currentLocation = state.location;
|
|
let nextLocation = createLocation(state.location, path, opts && opts.state);
|
|
nextLocation = _extends({}, nextLocation, init.history.encodeLocation(nextLocation));
|
|
let userReplace = opts && opts.replace != null ? opts.replace : void 0;
|
|
let historyAction = Action.Push;
|
|
if (userReplace === true) {
|
|
historyAction = Action.Replace;
|
|
} else if (userReplace === false) ;
|
|
else if (submission != null && isMutationMethod(submission.formMethod) && submission.formAction === state.location.pathname + state.location.search) {
|
|
historyAction = Action.Replace;
|
|
}
|
|
let preventScrollReset = opts && "preventScrollReset" in opts ? opts.preventScrollReset === true : void 0;
|
|
let flushSync = (opts && opts.flushSync) === true;
|
|
let blockerKey = shouldBlockNavigation({
|
|
currentLocation,
|
|
nextLocation,
|
|
historyAction
|
|
});
|
|
if (blockerKey) {
|
|
updateBlocker(blockerKey, {
|
|
state: "blocked",
|
|
location: nextLocation,
|
|
proceed() {
|
|
updateBlocker(blockerKey, {
|
|
state: "proceeding",
|
|
proceed: void 0,
|
|
reset: void 0,
|
|
location: nextLocation
|
|
});
|
|
navigate(to, opts);
|
|
},
|
|
reset() {
|
|
let blockers = new Map(state.blockers);
|
|
blockers.set(blockerKey, IDLE_BLOCKER);
|
|
updateState({
|
|
blockers
|
|
});
|
|
}
|
|
});
|
|
return;
|
|
}
|
|
return await startNavigation(historyAction, nextLocation, {
|
|
submission,
|
|
// Send through the formData serialization error if we have one so we can
|
|
// render at the right error boundary after we match routes
|
|
pendingError: error,
|
|
preventScrollReset,
|
|
replace: opts && opts.replace,
|
|
enableViewTransition: opts && opts.viewTransition,
|
|
flushSync
|
|
});
|
|
}
|
|
function revalidate() {
|
|
interruptActiveLoads();
|
|
updateState({
|
|
revalidation: "loading"
|
|
});
|
|
if (state.navigation.state === "submitting") {
|
|
return;
|
|
}
|
|
if (state.navigation.state === "idle") {
|
|
startNavigation(state.historyAction, state.location, {
|
|
startUninterruptedRevalidation: true
|
|
});
|
|
return;
|
|
}
|
|
startNavigation(pendingAction || state.historyAction, state.navigation.location, {
|
|
overrideNavigation: state.navigation,
|
|
// Proxy through any rending view transition
|
|
enableViewTransition: pendingViewTransitionEnabled === true
|
|
});
|
|
}
|
|
async function startNavigation(historyAction, location, opts) {
|
|
pendingNavigationController && pendingNavigationController.abort();
|
|
pendingNavigationController = null;
|
|
pendingAction = historyAction;
|
|
isUninterruptedRevalidation = (opts && opts.startUninterruptedRevalidation) === true;
|
|
saveScrollPosition(state.location, state.matches);
|
|
pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;
|
|
pendingViewTransitionEnabled = (opts && opts.enableViewTransition) === true;
|
|
let routesToUse = inFlightDataRoutes || dataRoutes;
|
|
let loadingNavigation = opts && opts.overrideNavigation;
|
|
let matches = matchRoutes(routesToUse, location, basename);
|
|
let flushSync = (opts && opts.flushSync) === true;
|
|
let fogOfWar = checkFogOfWar(matches, routesToUse, location.pathname);
|
|
if (fogOfWar.active && fogOfWar.matches) {
|
|
matches = fogOfWar.matches;
|
|
}
|
|
if (!matches) {
|
|
let {
|
|
error,
|
|
notFoundMatches,
|
|
route
|
|
} = handleNavigational404(location.pathname);
|
|
completeNavigation(location, {
|
|
matches: notFoundMatches,
|
|
loaderData: {},
|
|
errors: {
|
|
[route.id]: error
|
|
}
|
|
}, {
|
|
flushSync
|
|
});
|
|
return;
|
|
}
|
|
if (state.initialized && !isRevalidationRequired && isHashChangeOnly(state.location, location) && !(opts && opts.submission && isMutationMethod(opts.submission.formMethod))) {
|
|
completeNavigation(location, {
|
|
matches
|
|
}, {
|
|
flushSync
|
|
});
|
|
return;
|
|
}
|
|
pendingNavigationController = new AbortController();
|
|
let request = createClientSideRequest(init.history, location, pendingNavigationController.signal, opts && opts.submission);
|
|
let pendingActionResult;
|
|
if (opts && opts.pendingError) {
|
|
pendingActionResult = [findNearestBoundary(matches).route.id, {
|
|
type: ResultType.error,
|
|
error: opts.pendingError
|
|
}];
|
|
} else if (opts && opts.submission && isMutationMethod(opts.submission.formMethod)) {
|
|
let actionResult = await handleAction(request, location, opts.submission, matches, fogOfWar.active, {
|
|
replace: opts.replace,
|
|
flushSync
|
|
});
|
|
if (actionResult.shortCircuited) {
|
|
return;
|
|
}
|
|
if (actionResult.pendingActionResult) {
|
|
let [routeId, result] = actionResult.pendingActionResult;
|
|
if (isErrorResult(result) && isRouteErrorResponse(result.error) && result.error.status === 404) {
|
|
pendingNavigationController = null;
|
|
completeNavigation(location, {
|
|
matches: actionResult.matches,
|
|
loaderData: {},
|
|
errors: {
|
|
[routeId]: result.error
|
|
}
|
|
});
|
|
return;
|
|
}
|
|
}
|
|
matches = actionResult.matches || matches;
|
|
pendingActionResult = actionResult.pendingActionResult;
|
|
loadingNavigation = getLoadingNavigation(location, opts.submission);
|
|
flushSync = false;
|
|
fogOfWar.active = false;
|
|
request = createClientSideRequest(init.history, request.url, request.signal);
|
|
}
|
|
let {
|
|
shortCircuited,
|
|
matches: updatedMatches,
|
|
loaderData,
|
|
errors
|
|
} = await handleLoaders(request, location, matches, fogOfWar.active, loadingNavigation, opts && opts.submission, opts && opts.fetcherSubmission, opts && opts.replace, opts && opts.initialHydration === true, flushSync, pendingActionResult);
|
|
if (shortCircuited) {
|
|
return;
|
|
}
|
|
pendingNavigationController = null;
|
|
completeNavigation(location, _extends({
|
|
matches: updatedMatches || matches
|
|
}, getActionDataForCommit(pendingActionResult), {
|
|
loaderData,
|
|
errors
|
|
}));
|
|
}
|
|
async function handleAction(request, location, submission, matches, isFogOfWar, opts) {
|
|
if (opts === void 0) {
|
|
opts = {};
|
|
}
|
|
interruptActiveLoads();
|
|
let navigation = getSubmittingNavigation(location, submission);
|
|
updateState({
|
|
navigation
|
|
}, {
|
|
flushSync: opts.flushSync === true
|
|
});
|
|
if (isFogOfWar) {
|
|
let discoverResult = await discoverRoutes(matches, location.pathname, request.signal);
|
|
if (discoverResult.type === "aborted") {
|
|
return {
|
|
shortCircuited: true
|
|
};
|
|
} else if (discoverResult.type === "error") {
|
|
let boundaryId = findNearestBoundary(discoverResult.partialMatches).route.id;
|
|
return {
|
|
matches: discoverResult.partialMatches,
|
|
pendingActionResult: [boundaryId, {
|
|
type: ResultType.error,
|
|
error: discoverResult.error
|
|
}]
|
|
};
|
|
} else if (!discoverResult.matches) {
|
|
let {
|
|
notFoundMatches,
|
|
error,
|
|
route
|
|
} = handleNavigational404(location.pathname);
|
|
return {
|
|
matches: notFoundMatches,
|
|
pendingActionResult: [route.id, {
|
|
type: ResultType.error,
|
|
error
|
|
}]
|
|
};
|
|
} else {
|
|
matches = discoverResult.matches;
|
|
}
|
|
}
|
|
let result;
|
|
let actionMatch = getTargetMatch(matches, location);
|
|
if (!actionMatch.route.action && !actionMatch.route.lazy) {
|
|
result = {
|
|
type: ResultType.error,
|
|
error: getInternalRouterError(405, {
|
|
method: request.method,
|
|
pathname: location.pathname,
|
|
routeId: actionMatch.route.id
|
|
})
|
|
};
|
|
} else {
|
|
let results = await callDataStrategy("action", state, request, [actionMatch], matches, null);
|
|
result = results[actionMatch.route.id];
|
|
if (request.signal.aborted) {
|
|
return {
|
|
shortCircuited: true
|
|
};
|
|
}
|
|
}
|
|
if (isRedirectResult(result)) {
|
|
let replace2;
|
|
if (opts && opts.replace != null) {
|
|
replace2 = opts.replace;
|
|
} else {
|
|
let location2 = normalizeRedirectLocation(result.response.headers.get("Location"), new URL(request.url), basename);
|
|
replace2 = location2 === state.location.pathname + state.location.search;
|
|
}
|
|
await startRedirectNavigation(request, result, true, {
|
|
submission,
|
|
replace: replace2
|
|
});
|
|
return {
|
|
shortCircuited: true
|
|
};
|
|
}
|
|
if (isDeferredResult(result)) {
|
|
throw getInternalRouterError(400, {
|
|
type: "defer-action"
|
|
});
|
|
}
|
|
if (isErrorResult(result)) {
|
|
let boundaryMatch = findNearestBoundary(matches, actionMatch.route.id);
|
|
if ((opts && opts.replace) !== true) {
|
|
pendingAction = Action.Push;
|
|
}
|
|
return {
|
|
matches,
|
|
pendingActionResult: [boundaryMatch.route.id, result]
|
|
};
|
|
}
|
|
return {
|
|
matches,
|
|
pendingActionResult: [actionMatch.route.id, result]
|
|
};
|
|
}
|
|
async function handleLoaders(request, location, matches, isFogOfWar, overrideNavigation, submission, fetcherSubmission, replace2, initialHydration, flushSync, pendingActionResult) {
|
|
let loadingNavigation = overrideNavigation || getLoadingNavigation(location, submission);
|
|
let activeSubmission = submission || fetcherSubmission || getSubmissionFromNavigation(loadingNavigation);
|
|
let shouldUpdateNavigationState = !isUninterruptedRevalidation && (!future.v7_partialHydration || !initialHydration);
|
|
if (isFogOfWar) {
|
|
if (shouldUpdateNavigationState) {
|
|
let actionData = getUpdatedActionData(pendingActionResult);
|
|
updateState(_extends({
|
|
navigation: loadingNavigation
|
|
}, actionData !== void 0 ? {
|
|
actionData
|
|
} : {}), {
|
|
flushSync
|
|
});
|
|
}
|
|
let discoverResult = await discoverRoutes(matches, location.pathname, request.signal);
|
|
if (discoverResult.type === "aborted") {
|
|
return {
|
|
shortCircuited: true
|
|
};
|
|
} else if (discoverResult.type === "error") {
|
|
let boundaryId = findNearestBoundary(discoverResult.partialMatches).route.id;
|
|
return {
|
|
matches: discoverResult.partialMatches,
|
|
loaderData: {},
|
|
errors: {
|
|
[boundaryId]: discoverResult.error
|
|
}
|
|
};
|
|
} else if (!discoverResult.matches) {
|
|
let {
|
|
error,
|
|
notFoundMatches,
|
|
route
|
|
} = handleNavigational404(location.pathname);
|
|
return {
|
|
matches: notFoundMatches,
|
|
loaderData: {},
|
|
errors: {
|
|
[route.id]: error
|
|
}
|
|
};
|
|
} else {
|
|
matches = discoverResult.matches;
|
|
}
|
|
}
|
|
let routesToUse = inFlightDataRoutes || dataRoutes;
|
|
let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, activeSubmission, location, future.v7_partialHydration && initialHydration === true, future.v7_skipActionErrorRevalidation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, pendingActionResult);
|
|
cancelActiveDeferreds((routeId) => !(matches && matches.some((m) => m.route.id === routeId)) || matchesToLoad && matchesToLoad.some((m) => m.route.id === routeId));
|
|
pendingNavigationLoadId = ++incrementingLoadId;
|
|
if (matchesToLoad.length === 0 && revalidatingFetchers.length === 0) {
|
|
let updatedFetchers2 = markFetchRedirectsDone();
|
|
completeNavigation(location, _extends({
|
|
matches,
|
|
loaderData: {},
|
|
// Commit pending error if we're short circuiting
|
|
errors: pendingActionResult && isErrorResult(pendingActionResult[1]) ? {
|
|
[pendingActionResult[0]]: pendingActionResult[1].error
|
|
} : null
|
|
}, getActionDataForCommit(pendingActionResult), updatedFetchers2 ? {
|
|
fetchers: new Map(state.fetchers)
|
|
} : {}), {
|
|
flushSync
|
|
});
|
|
return {
|
|
shortCircuited: true
|
|
};
|
|
}
|
|
if (shouldUpdateNavigationState) {
|
|
let updates = {};
|
|
if (!isFogOfWar) {
|
|
updates.navigation = loadingNavigation;
|
|
let actionData = getUpdatedActionData(pendingActionResult);
|
|
if (actionData !== void 0) {
|
|
updates.actionData = actionData;
|
|
}
|
|
}
|
|
if (revalidatingFetchers.length > 0) {
|
|
updates.fetchers = getUpdatedRevalidatingFetchers(revalidatingFetchers);
|
|
}
|
|
updateState(updates, {
|
|
flushSync
|
|
});
|
|
}
|
|
revalidatingFetchers.forEach((rf) => {
|
|
abortFetcher(rf.key);
|
|
if (rf.controller) {
|
|
fetchControllers.set(rf.key, rf.controller);
|
|
}
|
|
});
|
|
let abortPendingFetchRevalidations = () => revalidatingFetchers.forEach((f) => abortFetcher(f.key));
|
|
if (pendingNavigationController) {
|
|
pendingNavigationController.signal.addEventListener("abort", abortPendingFetchRevalidations);
|
|
}
|
|
let {
|
|
loaderResults,
|
|
fetcherResults
|
|
} = await callLoadersAndMaybeResolveData(state, matches, matchesToLoad, revalidatingFetchers, request);
|
|
if (request.signal.aborted) {
|
|
return {
|
|
shortCircuited: true
|
|
};
|
|
}
|
|
if (pendingNavigationController) {
|
|
pendingNavigationController.signal.removeEventListener("abort", abortPendingFetchRevalidations);
|
|
}
|
|
revalidatingFetchers.forEach((rf) => fetchControllers.delete(rf.key));
|
|
let redirect3 = findRedirect(loaderResults);
|
|
if (redirect3) {
|
|
await startRedirectNavigation(request, redirect3.result, true, {
|
|
replace: replace2
|
|
});
|
|
return {
|
|
shortCircuited: true
|
|
};
|
|
}
|
|
redirect3 = findRedirect(fetcherResults);
|
|
if (redirect3) {
|
|
fetchRedirectIds.add(redirect3.key);
|
|
await startRedirectNavigation(request, redirect3.result, true, {
|
|
replace: replace2
|
|
});
|
|
return {
|
|
shortCircuited: true
|
|
};
|
|
}
|
|
let {
|
|
loaderData,
|
|
errors
|
|
} = processLoaderData(state, matches, loaderResults, pendingActionResult, revalidatingFetchers, fetcherResults, activeDeferreds);
|
|
activeDeferreds.forEach((deferredData, routeId) => {
|
|
deferredData.subscribe((aborted) => {
|
|
if (aborted || deferredData.done) {
|
|
activeDeferreds.delete(routeId);
|
|
}
|
|
});
|
|
});
|
|
if (future.v7_partialHydration && initialHydration && state.errors) {
|
|
errors = _extends({}, state.errors, errors);
|
|
}
|
|
let updatedFetchers = markFetchRedirectsDone();
|
|
let didAbortFetchLoads = abortStaleFetchLoads(pendingNavigationLoadId);
|
|
let shouldUpdateFetchers = updatedFetchers || didAbortFetchLoads || revalidatingFetchers.length > 0;
|
|
return _extends({
|
|
matches,
|
|
loaderData,
|
|
errors
|
|
}, shouldUpdateFetchers ? {
|
|
fetchers: new Map(state.fetchers)
|
|
} : {});
|
|
}
|
|
function getUpdatedActionData(pendingActionResult) {
|
|
if (pendingActionResult && !isErrorResult(pendingActionResult[1])) {
|
|
return {
|
|
[pendingActionResult[0]]: pendingActionResult[1].data
|
|
};
|
|
} else if (state.actionData) {
|
|
if (Object.keys(state.actionData).length === 0) {
|
|
return null;
|
|
} else {
|
|
return state.actionData;
|
|
}
|
|
}
|
|
}
|
|
function getUpdatedRevalidatingFetchers(revalidatingFetchers) {
|
|
revalidatingFetchers.forEach((rf) => {
|
|
let fetcher = state.fetchers.get(rf.key);
|
|
let revalidatingFetcher = getLoadingFetcher(void 0, fetcher ? fetcher.data : void 0);
|
|
state.fetchers.set(rf.key, revalidatingFetcher);
|
|
});
|
|
return new Map(state.fetchers);
|
|
}
|
|
function fetch(key, routeId, href, opts) {
|
|
if (isServer) {
|
|
throw new Error("router.fetch() was called during the server render, but it shouldn't be. You are likely calling a useFetcher() method in the body of your component. Try moving it to a useEffect or a callback.");
|
|
}
|
|
abortFetcher(key);
|
|
let flushSync = (opts && opts.flushSync) === true;
|
|
let routesToUse = inFlightDataRoutes || dataRoutes;
|
|
let normalizedPath = normalizeTo(state.location, state.matches, basename, future.v7_prependBasename, href, future.v7_relativeSplatPath, routeId, opts == null ? void 0 : opts.relative);
|
|
let matches = matchRoutes(routesToUse, normalizedPath, basename);
|
|
let fogOfWar = checkFogOfWar(matches, routesToUse, normalizedPath);
|
|
if (fogOfWar.active && fogOfWar.matches) {
|
|
matches = fogOfWar.matches;
|
|
}
|
|
if (!matches) {
|
|
setFetcherError(key, routeId, getInternalRouterError(404, {
|
|
pathname: normalizedPath
|
|
}), {
|
|
flushSync
|
|
});
|
|
return;
|
|
}
|
|
let {
|
|
path,
|
|
submission,
|
|
error
|
|
} = normalizeNavigateOptions(future.v7_normalizeFormMethod, true, normalizedPath, opts);
|
|
if (error) {
|
|
setFetcherError(key, routeId, error, {
|
|
flushSync
|
|
});
|
|
return;
|
|
}
|
|
let match = getTargetMatch(matches, path);
|
|
let preventScrollReset = (opts && opts.preventScrollReset) === true;
|
|
if (submission && isMutationMethod(submission.formMethod)) {
|
|
handleFetcherAction(key, routeId, path, match, matches, fogOfWar.active, flushSync, preventScrollReset, submission);
|
|
return;
|
|
}
|
|
fetchLoadMatches.set(key, {
|
|
routeId,
|
|
path
|
|
});
|
|
handleFetcherLoader(key, routeId, path, match, matches, fogOfWar.active, flushSync, preventScrollReset, submission);
|
|
}
|
|
async function handleFetcherAction(key, routeId, path, match, requestMatches, isFogOfWar, flushSync, preventScrollReset, submission) {
|
|
interruptActiveLoads();
|
|
fetchLoadMatches.delete(key);
|
|
function detectAndHandle405Error(m) {
|
|
if (!m.route.action && !m.route.lazy) {
|
|
let error = getInternalRouterError(405, {
|
|
method: submission.formMethod,
|
|
pathname: path,
|
|
routeId
|
|
});
|
|
setFetcherError(key, routeId, error, {
|
|
flushSync
|
|
});
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
if (!isFogOfWar && detectAndHandle405Error(match)) {
|
|
return;
|
|
}
|
|
let existingFetcher = state.fetchers.get(key);
|
|
updateFetcherState(key, getSubmittingFetcher(submission, existingFetcher), {
|
|
flushSync
|
|
});
|
|
let abortController = new AbortController();
|
|
let fetchRequest = createClientSideRequest(init.history, path, abortController.signal, submission);
|
|
if (isFogOfWar) {
|
|
let discoverResult = await discoverRoutes(requestMatches, path, fetchRequest.signal);
|
|
if (discoverResult.type === "aborted") {
|
|
return;
|
|
} else if (discoverResult.type === "error") {
|
|
setFetcherError(key, routeId, discoverResult.error, {
|
|
flushSync
|
|
});
|
|
return;
|
|
} else if (!discoverResult.matches) {
|
|
setFetcherError(key, routeId, getInternalRouterError(404, {
|
|
pathname: path
|
|
}), {
|
|
flushSync
|
|
});
|
|
return;
|
|
} else {
|
|
requestMatches = discoverResult.matches;
|
|
match = getTargetMatch(requestMatches, path);
|
|
if (detectAndHandle405Error(match)) {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
fetchControllers.set(key, abortController);
|
|
let originatingLoadId = incrementingLoadId;
|
|
let actionResults = await callDataStrategy("action", state, fetchRequest, [match], requestMatches, key);
|
|
let actionResult = actionResults[match.route.id];
|
|
if (fetchRequest.signal.aborted) {
|
|
if (fetchControllers.get(key) === abortController) {
|
|
fetchControllers.delete(key);
|
|
}
|
|
return;
|
|
}
|
|
if (future.v7_fetcherPersist && deletedFetchers.has(key)) {
|
|
if (isRedirectResult(actionResult) || isErrorResult(actionResult)) {
|
|
updateFetcherState(key, getDoneFetcher(void 0));
|
|
return;
|
|
}
|
|
} else {
|
|
if (isRedirectResult(actionResult)) {
|
|
fetchControllers.delete(key);
|
|
if (pendingNavigationLoadId > originatingLoadId) {
|
|
updateFetcherState(key, getDoneFetcher(void 0));
|
|
return;
|
|
} else {
|
|
fetchRedirectIds.add(key);
|
|
updateFetcherState(key, getLoadingFetcher(submission));
|
|
return startRedirectNavigation(fetchRequest, actionResult, false, {
|
|
fetcherSubmission: submission,
|
|
preventScrollReset
|
|
});
|
|
}
|
|
}
|
|
if (isErrorResult(actionResult)) {
|
|
setFetcherError(key, routeId, actionResult.error);
|
|
return;
|
|
}
|
|
}
|
|
if (isDeferredResult(actionResult)) {
|
|
throw getInternalRouterError(400, {
|
|
type: "defer-action"
|
|
});
|
|
}
|
|
let nextLocation = state.navigation.location || state.location;
|
|
let revalidationRequest = createClientSideRequest(init.history, nextLocation, abortController.signal);
|
|
let routesToUse = inFlightDataRoutes || dataRoutes;
|
|
let matches = state.navigation.state !== "idle" ? matchRoutes(routesToUse, state.navigation.location, basename) : state.matches;
|
|
invariant(matches, "Didn't find any matches after fetcher action");
|
|
let loadId = ++incrementingLoadId;
|
|
fetchReloadIds.set(key, loadId);
|
|
let loadFetcher = getLoadingFetcher(submission, actionResult.data);
|
|
state.fetchers.set(key, loadFetcher);
|
|
let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, submission, nextLocation, false, future.v7_skipActionErrorRevalidation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, [match.route.id, actionResult]);
|
|
revalidatingFetchers.filter((rf) => rf.key !== key).forEach((rf) => {
|
|
let staleKey = rf.key;
|
|
let existingFetcher2 = state.fetchers.get(staleKey);
|
|
let revalidatingFetcher = getLoadingFetcher(void 0, existingFetcher2 ? existingFetcher2.data : void 0);
|
|
state.fetchers.set(staleKey, revalidatingFetcher);
|
|
abortFetcher(staleKey);
|
|
if (rf.controller) {
|
|
fetchControllers.set(staleKey, rf.controller);
|
|
}
|
|
});
|
|
updateState({
|
|
fetchers: new Map(state.fetchers)
|
|
});
|
|
let abortPendingFetchRevalidations = () => revalidatingFetchers.forEach((rf) => abortFetcher(rf.key));
|
|
abortController.signal.addEventListener("abort", abortPendingFetchRevalidations);
|
|
let {
|
|
loaderResults,
|
|
fetcherResults
|
|
} = await callLoadersAndMaybeResolveData(state, matches, matchesToLoad, revalidatingFetchers, revalidationRequest);
|
|
if (abortController.signal.aborted) {
|
|
return;
|
|
}
|
|
abortController.signal.removeEventListener("abort", abortPendingFetchRevalidations);
|
|
fetchReloadIds.delete(key);
|
|
fetchControllers.delete(key);
|
|
revalidatingFetchers.forEach((r) => fetchControllers.delete(r.key));
|
|
let redirect3 = findRedirect(loaderResults);
|
|
if (redirect3) {
|
|
return startRedirectNavigation(revalidationRequest, redirect3.result, false, {
|
|
preventScrollReset
|
|
});
|
|
}
|
|
redirect3 = findRedirect(fetcherResults);
|
|
if (redirect3) {
|
|
fetchRedirectIds.add(redirect3.key);
|
|
return startRedirectNavigation(revalidationRequest, redirect3.result, false, {
|
|
preventScrollReset
|
|
});
|
|
}
|
|
let {
|
|
loaderData,
|
|
errors
|
|
} = processLoaderData(state, matches, loaderResults, void 0, revalidatingFetchers, fetcherResults, activeDeferreds);
|
|
if (state.fetchers.has(key)) {
|
|
let doneFetcher = getDoneFetcher(actionResult.data);
|
|
state.fetchers.set(key, doneFetcher);
|
|
}
|
|
abortStaleFetchLoads(loadId);
|
|
if (state.navigation.state === "loading" && loadId > pendingNavigationLoadId) {
|
|
invariant(pendingAction, "Expected pending action");
|
|
pendingNavigationController && pendingNavigationController.abort();
|
|
completeNavigation(state.navigation.location, {
|
|
matches,
|
|
loaderData,
|
|
errors,
|
|
fetchers: new Map(state.fetchers)
|
|
});
|
|
} else {
|
|
updateState({
|
|
errors,
|
|
loaderData: mergeLoaderData(state.loaderData, loaderData, matches, errors),
|
|
fetchers: new Map(state.fetchers)
|
|
});
|
|
isRevalidationRequired = false;
|
|
}
|
|
}
|
|
async function handleFetcherLoader(key, routeId, path, match, matches, isFogOfWar, flushSync, preventScrollReset, submission) {
|
|
let existingFetcher = state.fetchers.get(key);
|
|
updateFetcherState(key, getLoadingFetcher(submission, existingFetcher ? existingFetcher.data : void 0), {
|
|
flushSync
|
|
});
|
|
let abortController = new AbortController();
|
|
let fetchRequest = createClientSideRequest(init.history, path, abortController.signal);
|
|
if (isFogOfWar) {
|
|
let discoverResult = await discoverRoutes(matches, path, fetchRequest.signal);
|
|
if (discoverResult.type === "aborted") {
|
|
return;
|
|
} else if (discoverResult.type === "error") {
|
|
setFetcherError(key, routeId, discoverResult.error, {
|
|
flushSync
|
|
});
|
|
return;
|
|
} else if (!discoverResult.matches) {
|
|
setFetcherError(key, routeId, getInternalRouterError(404, {
|
|
pathname: path
|
|
}), {
|
|
flushSync
|
|
});
|
|
return;
|
|
} else {
|
|
matches = discoverResult.matches;
|
|
match = getTargetMatch(matches, path);
|
|
}
|
|
}
|
|
fetchControllers.set(key, abortController);
|
|
let originatingLoadId = incrementingLoadId;
|
|
let results = await callDataStrategy("loader", state, fetchRequest, [match], matches, key);
|
|
let result = results[match.route.id];
|
|
if (isDeferredResult(result)) {
|
|
result = await resolveDeferredData(result, fetchRequest.signal, true) || result;
|
|
}
|
|
if (fetchControllers.get(key) === abortController) {
|
|
fetchControllers.delete(key);
|
|
}
|
|
if (fetchRequest.signal.aborted) {
|
|
return;
|
|
}
|
|
if (deletedFetchers.has(key)) {
|
|
updateFetcherState(key, getDoneFetcher(void 0));
|
|
return;
|
|
}
|
|
if (isRedirectResult(result)) {
|
|
if (pendingNavigationLoadId > originatingLoadId) {
|
|
updateFetcherState(key, getDoneFetcher(void 0));
|
|
return;
|
|
} else {
|
|
fetchRedirectIds.add(key);
|
|
await startRedirectNavigation(fetchRequest, result, false, {
|
|
preventScrollReset
|
|
});
|
|
return;
|
|
}
|
|
}
|
|
if (isErrorResult(result)) {
|
|
setFetcherError(key, routeId, result.error);
|
|
return;
|
|
}
|
|
invariant(!isDeferredResult(result), "Unhandled fetcher deferred data");
|
|
updateFetcherState(key, getDoneFetcher(result.data));
|
|
}
|
|
async function startRedirectNavigation(request, redirect3, isNavigation, _temp2) {
|
|
let {
|
|
submission,
|
|
fetcherSubmission,
|
|
preventScrollReset,
|
|
replace: replace2
|
|
} = _temp2 === void 0 ? {} : _temp2;
|
|
if (redirect3.response.headers.has("X-Remix-Revalidate")) {
|
|
isRevalidationRequired = true;
|
|
}
|
|
let location = redirect3.response.headers.get("Location");
|
|
invariant(location, "Expected a Location header on the redirect Response");
|
|
location = normalizeRedirectLocation(location, new URL(request.url), basename);
|
|
let redirectLocation = createLocation(state.location, location, {
|
|
_isRedirect: true
|
|
});
|
|
if (isBrowser2) {
|
|
let isDocumentReload = false;
|
|
if (redirect3.response.headers.has("X-Remix-Reload-Document")) {
|
|
isDocumentReload = true;
|
|
} else if (ABSOLUTE_URL_REGEX.test(location)) {
|
|
const url = init.history.createURL(location);
|
|
isDocumentReload = // Hard reload if it's an absolute URL to a new origin
|
|
url.origin !== routerWindow.location.origin || // Hard reload if it's an absolute URL that does not match our basename
|
|
stripBasename(url.pathname, basename) == null;
|
|
}
|
|
if (isDocumentReload) {
|
|
if (replace2) {
|
|
routerWindow.location.replace(location);
|
|
} else {
|
|
routerWindow.location.assign(location);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
pendingNavigationController = null;
|
|
let redirectHistoryAction = replace2 === true || redirect3.response.headers.has("X-Remix-Replace") ? Action.Replace : Action.Push;
|
|
let {
|
|
formMethod,
|
|
formAction,
|
|
formEncType
|
|
} = state.navigation;
|
|
if (!submission && !fetcherSubmission && formMethod && formAction && formEncType) {
|
|
submission = getSubmissionFromNavigation(state.navigation);
|
|
}
|
|
let activeSubmission = submission || fetcherSubmission;
|
|
if (redirectPreserveMethodStatusCodes.has(redirect3.response.status) && activeSubmission && isMutationMethod(activeSubmission.formMethod)) {
|
|
await startNavigation(redirectHistoryAction, redirectLocation, {
|
|
submission: _extends({}, activeSubmission, {
|
|
formAction: location
|
|
}),
|
|
// Preserve these flags across redirects
|
|
preventScrollReset: preventScrollReset || pendingPreventScrollReset,
|
|
enableViewTransition: isNavigation ? pendingViewTransitionEnabled : void 0
|
|
});
|
|
} else {
|
|
let overrideNavigation = getLoadingNavigation(redirectLocation, submission);
|
|
await startNavigation(redirectHistoryAction, redirectLocation, {
|
|
overrideNavigation,
|
|
// Send fetcher submissions through for shouldRevalidate
|
|
fetcherSubmission,
|
|
// Preserve these flags across redirects
|
|
preventScrollReset: preventScrollReset || pendingPreventScrollReset,
|
|
enableViewTransition: isNavigation ? pendingViewTransitionEnabled : void 0
|
|
});
|
|
}
|
|
}
|
|
async function callDataStrategy(type, state2, request, matchesToLoad, matches, fetcherKey) {
|
|
let results;
|
|
let dataResults = {};
|
|
try {
|
|
results = await callDataStrategyImpl(dataStrategyImpl, type, state2, request, matchesToLoad, matches, fetcherKey, manifest, mapRouteProperties2);
|
|
} catch (e) {
|
|
matchesToLoad.forEach((m) => {
|
|
dataResults[m.route.id] = {
|
|
type: ResultType.error,
|
|
error: e
|
|
};
|
|
});
|
|
return dataResults;
|
|
}
|
|
for (let [routeId, result] of Object.entries(results)) {
|
|
if (isRedirectDataStrategyResultResult(result)) {
|
|
let response = result.result;
|
|
dataResults[routeId] = {
|
|
type: ResultType.redirect,
|
|
response: normalizeRelativeRoutingRedirectResponse(response, request, routeId, matches, basename, future.v7_relativeSplatPath)
|
|
};
|
|
} else {
|
|
dataResults[routeId] = await convertDataStrategyResultToDataResult(result);
|
|
}
|
|
}
|
|
return dataResults;
|
|
}
|
|
async function callLoadersAndMaybeResolveData(state2, matches, matchesToLoad, fetchersToLoad, request) {
|
|
let currentMatches = state2.matches;
|
|
let loaderResultsPromise = callDataStrategy("loader", state2, request, matchesToLoad, matches, null);
|
|
let fetcherResultsPromise = Promise.all(fetchersToLoad.map(async (f) => {
|
|
if (f.matches && f.match && f.controller) {
|
|
let results = await callDataStrategy("loader", state2, createClientSideRequest(init.history, f.path, f.controller.signal), [f.match], f.matches, f.key);
|
|
let result = results[f.match.route.id];
|
|
return {
|
|
[f.key]: result
|
|
};
|
|
} else {
|
|
return Promise.resolve({
|
|
[f.key]: {
|
|
type: ResultType.error,
|
|
error: getInternalRouterError(404, {
|
|
pathname: f.path
|
|
})
|
|
}
|
|
});
|
|
}
|
|
}));
|
|
let loaderResults = await loaderResultsPromise;
|
|
let fetcherResults = (await fetcherResultsPromise).reduce((acc, r) => Object.assign(acc, r), {});
|
|
await Promise.all([resolveNavigationDeferredResults(matches, loaderResults, request.signal, currentMatches, state2.loaderData), resolveFetcherDeferredResults(matches, fetcherResults, fetchersToLoad)]);
|
|
return {
|
|
loaderResults,
|
|
fetcherResults
|
|
};
|
|
}
|
|
function interruptActiveLoads() {
|
|
isRevalidationRequired = true;
|
|
cancelledDeferredRoutes.push(...cancelActiveDeferreds());
|
|
fetchLoadMatches.forEach((_, key) => {
|
|
if (fetchControllers.has(key)) {
|
|
cancelledFetcherLoads.add(key);
|
|
}
|
|
abortFetcher(key);
|
|
});
|
|
}
|
|
function updateFetcherState(key, fetcher, opts) {
|
|
if (opts === void 0) {
|
|
opts = {};
|
|
}
|
|
state.fetchers.set(key, fetcher);
|
|
updateState({
|
|
fetchers: new Map(state.fetchers)
|
|
}, {
|
|
flushSync: (opts && opts.flushSync) === true
|
|
});
|
|
}
|
|
function setFetcherError(key, routeId, error, opts) {
|
|
if (opts === void 0) {
|
|
opts = {};
|
|
}
|
|
let boundaryMatch = findNearestBoundary(state.matches, routeId);
|
|
deleteFetcher(key);
|
|
updateState({
|
|
errors: {
|
|
[boundaryMatch.route.id]: error
|
|
},
|
|
fetchers: new Map(state.fetchers)
|
|
}, {
|
|
flushSync: (opts && opts.flushSync) === true
|
|
});
|
|
}
|
|
function getFetcher(key) {
|
|
if (future.v7_fetcherPersist) {
|
|
activeFetchers.set(key, (activeFetchers.get(key) || 0) + 1);
|
|
if (deletedFetchers.has(key)) {
|
|
deletedFetchers.delete(key);
|
|
}
|
|
}
|
|
return state.fetchers.get(key) || IDLE_FETCHER;
|
|
}
|
|
function deleteFetcher(key) {
|
|
let fetcher = state.fetchers.get(key);
|
|
if (fetchControllers.has(key) && !(fetcher && fetcher.state === "loading" && fetchReloadIds.has(key))) {
|
|
abortFetcher(key);
|
|
}
|
|
fetchLoadMatches.delete(key);
|
|
fetchReloadIds.delete(key);
|
|
fetchRedirectIds.delete(key);
|
|
deletedFetchers.delete(key);
|
|
cancelledFetcherLoads.delete(key);
|
|
state.fetchers.delete(key);
|
|
}
|
|
function deleteFetcherAndUpdateState(key) {
|
|
if (future.v7_fetcherPersist) {
|
|
let count = (activeFetchers.get(key) || 0) - 1;
|
|
if (count <= 0) {
|
|
activeFetchers.delete(key);
|
|
deletedFetchers.add(key);
|
|
} else {
|
|
activeFetchers.set(key, count);
|
|
}
|
|
} else {
|
|
deleteFetcher(key);
|
|
}
|
|
updateState({
|
|
fetchers: new Map(state.fetchers)
|
|
});
|
|
}
|
|
function abortFetcher(key) {
|
|
let controller = fetchControllers.get(key);
|
|
if (controller) {
|
|
controller.abort();
|
|
fetchControllers.delete(key);
|
|
}
|
|
}
|
|
function markFetchersDone(keys) {
|
|
for (let key of keys) {
|
|
let fetcher = getFetcher(key);
|
|
let doneFetcher = getDoneFetcher(fetcher.data);
|
|
state.fetchers.set(key, doneFetcher);
|
|
}
|
|
}
|
|
function markFetchRedirectsDone() {
|
|
let doneKeys = [];
|
|
let updatedFetchers = false;
|
|
for (let key of fetchRedirectIds) {
|
|
let fetcher = state.fetchers.get(key);
|
|
invariant(fetcher, "Expected fetcher: " + key);
|
|
if (fetcher.state === "loading") {
|
|
fetchRedirectIds.delete(key);
|
|
doneKeys.push(key);
|
|
updatedFetchers = true;
|
|
}
|
|
}
|
|
markFetchersDone(doneKeys);
|
|
return updatedFetchers;
|
|
}
|
|
function abortStaleFetchLoads(landedId) {
|
|
let yeetedKeys = [];
|
|
for (let [key, id] of fetchReloadIds) {
|
|
if (id < landedId) {
|
|
let fetcher = state.fetchers.get(key);
|
|
invariant(fetcher, "Expected fetcher: " + key);
|
|
if (fetcher.state === "loading") {
|
|
abortFetcher(key);
|
|
fetchReloadIds.delete(key);
|
|
yeetedKeys.push(key);
|
|
}
|
|
}
|
|
}
|
|
markFetchersDone(yeetedKeys);
|
|
return yeetedKeys.length > 0;
|
|
}
|
|
function getBlocker(key, fn) {
|
|
let blocker = state.blockers.get(key) || IDLE_BLOCKER;
|
|
if (blockerFunctions.get(key) !== fn) {
|
|
blockerFunctions.set(key, fn);
|
|
}
|
|
return blocker;
|
|
}
|
|
function deleteBlocker(key) {
|
|
state.blockers.delete(key);
|
|
blockerFunctions.delete(key);
|
|
}
|
|
function updateBlocker(key, newBlocker) {
|
|
let blocker = state.blockers.get(key) || IDLE_BLOCKER;
|
|
invariant(blocker.state === "unblocked" && newBlocker.state === "blocked" || blocker.state === "blocked" && newBlocker.state === "blocked" || blocker.state === "blocked" && newBlocker.state === "proceeding" || blocker.state === "blocked" && newBlocker.state === "unblocked" || blocker.state === "proceeding" && newBlocker.state === "unblocked", "Invalid blocker state transition: " + blocker.state + " -> " + newBlocker.state);
|
|
let blockers = new Map(state.blockers);
|
|
blockers.set(key, newBlocker);
|
|
updateState({
|
|
blockers
|
|
});
|
|
}
|
|
function shouldBlockNavigation(_ref2) {
|
|
let {
|
|
currentLocation,
|
|
nextLocation,
|
|
historyAction
|
|
} = _ref2;
|
|
if (blockerFunctions.size === 0) {
|
|
return;
|
|
}
|
|
if (blockerFunctions.size > 1) {
|
|
warning(false, "A router only supports one blocker at a time");
|
|
}
|
|
let entries = Array.from(blockerFunctions.entries());
|
|
let [blockerKey, blockerFunction] = entries[entries.length - 1];
|
|
let blocker = state.blockers.get(blockerKey);
|
|
if (blocker && blocker.state === "proceeding") {
|
|
return;
|
|
}
|
|
if (blockerFunction({
|
|
currentLocation,
|
|
nextLocation,
|
|
historyAction
|
|
})) {
|
|
return blockerKey;
|
|
}
|
|
}
|
|
function handleNavigational404(pathname) {
|
|
let error = getInternalRouterError(404, {
|
|
pathname
|
|
});
|
|
let routesToUse = inFlightDataRoutes || dataRoutes;
|
|
let {
|
|
matches,
|
|
route
|
|
} = getShortCircuitMatches(routesToUse);
|
|
cancelActiveDeferreds();
|
|
return {
|
|
notFoundMatches: matches,
|
|
route,
|
|
error
|
|
};
|
|
}
|
|
function cancelActiveDeferreds(predicate) {
|
|
let cancelledRouteIds = [];
|
|
activeDeferreds.forEach((dfd, routeId) => {
|
|
if (!predicate || predicate(routeId)) {
|
|
dfd.cancel();
|
|
cancelledRouteIds.push(routeId);
|
|
activeDeferreds.delete(routeId);
|
|
}
|
|
});
|
|
return cancelledRouteIds;
|
|
}
|
|
function enableScrollRestoration(positions, getPosition, getKey) {
|
|
savedScrollPositions2 = positions;
|
|
getScrollPosition = getPosition;
|
|
getScrollRestorationKey = getKey || null;
|
|
if (!initialScrollRestored && state.navigation === IDLE_NAVIGATION) {
|
|
initialScrollRestored = true;
|
|
let y = getSavedScrollPosition(state.location, state.matches);
|
|
if (y != null) {
|
|
updateState({
|
|
restoreScrollPosition: y
|
|
});
|
|
}
|
|
}
|
|
return () => {
|
|
savedScrollPositions2 = null;
|
|
getScrollPosition = null;
|
|
getScrollRestorationKey = null;
|
|
};
|
|
}
|
|
function getScrollKey(location, matches) {
|
|
if (getScrollRestorationKey) {
|
|
let key = getScrollRestorationKey(location, matches.map((m) => convertRouteMatchToUiMatch(m, state.loaderData)));
|
|
return key || location.key;
|
|
}
|
|
return location.key;
|
|
}
|
|
function saveScrollPosition(location, matches) {
|
|
if (savedScrollPositions2 && getScrollPosition) {
|
|
let key = getScrollKey(location, matches);
|
|
savedScrollPositions2[key] = getScrollPosition();
|
|
}
|
|
}
|
|
function getSavedScrollPosition(location, matches) {
|
|
if (savedScrollPositions2) {
|
|
let key = getScrollKey(location, matches);
|
|
let y = savedScrollPositions2[key];
|
|
if (typeof y === "number") {
|
|
return y;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
function checkFogOfWar(matches, routesToUse, pathname) {
|
|
if (patchRoutesOnNavigationImpl) {
|
|
if (!matches) {
|
|
let fogMatches = matchRoutesImpl(routesToUse, pathname, basename, true);
|
|
return {
|
|
active: true,
|
|
matches: fogMatches || []
|
|
};
|
|
} else {
|
|
if (Object.keys(matches[0].params).length > 0) {
|
|
let partialMatches = matchRoutesImpl(routesToUse, pathname, basename, true);
|
|
return {
|
|
active: true,
|
|
matches: partialMatches
|
|
};
|
|
}
|
|
}
|
|
}
|
|
return {
|
|
active: false,
|
|
matches: null
|
|
};
|
|
}
|
|
async function discoverRoutes(matches, pathname, signal) {
|
|
if (!patchRoutesOnNavigationImpl) {
|
|
return {
|
|
type: "success",
|
|
matches
|
|
};
|
|
}
|
|
let partialMatches = matches;
|
|
while (true) {
|
|
let isNonHMR = inFlightDataRoutes == null;
|
|
let routesToUse = inFlightDataRoutes || dataRoutes;
|
|
let localManifest = manifest;
|
|
try {
|
|
await patchRoutesOnNavigationImpl({
|
|
path: pathname,
|
|
matches: partialMatches,
|
|
patch: (routeId, children) => {
|
|
if (signal.aborted) return;
|
|
patchRoutesImpl(routeId, children, routesToUse, localManifest, mapRouteProperties2);
|
|
}
|
|
});
|
|
} catch (e) {
|
|
return {
|
|
type: "error",
|
|
error: e,
|
|
partialMatches
|
|
};
|
|
} finally {
|
|
if (isNonHMR && !signal.aborted) {
|
|
dataRoutes = [...dataRoutes];
|
|
}
|
|
}
|
|
if (signal.aborted) {
|
|
return {
|
|
type: "aborted"
|
|
};
|
|
}
|
|
let newMatches = matchRoutes(routesToUse, pathname, basename);
|
|
if (newMatches) {
|
|
return {
|
|
type: "success",
|
|
matches: newMatches
|
|
};
|
|
}
|
|
let newPartialMatches = matchRoutesImpl(routesToUse, pathname, basename, true);
|
|
if (!newPartialMatches || partialMatches.length === newPartialMatches.length && partialMatches.every((m, i) => m.route.id === newPartialMatches[i].route.id)) {
|
|
return {
|
|
type: "success",
|
|
matches: null
|
|
};
|
|
}
|
|
partialMatches = newPartialMatches;
|
|
}
|
|
}
|
|
function _internalSetRoutes(newRoutes) {
|
|
manifest = {};
|
|
inFlightDataRoutes = convertRoutesToDataRoutes(newRoutes, mapRouteProperties2, void 0, manifest);
|
|
}
|
|
function patchRoutes(routeId, children) {
|
|
let isNonHMR = inFlightDataRoutes == null;
|
|
let routesToUse = inFlightDataRoutes || dataRoutes;
|
|
patchRoutesImpl(routeId, children, routesToUse, manifest, mapRouteProperties2);
|
|
if (isNonHMR) {
|
|
dataRoutes = [...dataRoutes];
|
|
updateState({});
|
|
}
|
|
}
|
|
router = {
|
|
get basename() {
|
|
return basename;
|
|
},
|
|
get future() {
|
|
return future;
|
|
},
|
|
get state() {
|
|
return state;
|
|
},
|
|
get routes() {
|
|
return dataRoutes;
|
|
},
|
|
get window() {
|
|
return routerWindow;
|
|
},
|
|
initialize,
|
|
subscribe,
|
|
enableScrollRestoration,
|
|
navigate,
|
|
fetch,
|
|
revalidate,
|
|
// Passthrough to history-aware createHref used by useHref so we get proper
|
|
// hash-aware URLs in DOM paths
|
|
createHref: (to) => init.history.createHref(to),
|
|
encodeLocation: (to) => init.history.encodeLocation(to),
|
|
getFetcher,
|
|
deleteFetcher: deleteFetcherAndUpdateState,
|
|
dispose,
|
|
getBlocker,
|
|
deleteBlocker,
|
|
patchRoutes,
|
|
_internalFetchControllers: fetchControllers,
|
|
_internalActiveDeferreds: activeDeferreds,
|
|
// TODO: Remove setRoutes, it's temporary to avoid dealing with
|
|
// updating the tree while validating the update algorithm.
|
|
_internalSetRoutes
|
|
};
|
|
return router;
|
|
}
|
|
var UNSAFE_DEFERRED_SYMBOL = Symbol("deferred");
|
|
function isSubmissionNavigation(opts) {
|
|
return opts != null && ("formData" in opts && opts.formData != null || "body" in opts && opts.body !== void 0);
|
|
}
|
|
function normalizeTo(location, matches, basename, prependBasename, to, v7_relativeSplatPath, fromRouteId, relative) {
|
|
let contextualMatches;
|
|
let activeRouteMatch;
|
|
if (fromRouteId) {
|
|
contextualMatches = [];
|
|
for (let match of matches) {
|
|
contextualMatches.push(match);
|
|
if (match.route.id === fromRouteId) {
|
|
activeRouteMatch = match;
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
contextualMatches = matches;
|
|
activeRouteMatch = matches[matches.length - 1];
|
|
}
|
|
let path = resolveTo(to ? to : ".", getResolveToMatches(contextualMatches, v7_relativeSplatPath), stripBasename(location.pathname, basename) || location.pathname, relative === "path");
|
|
if (to == null) {
|
|
path.search = location.search;
|
|
path.hash = location.hash;
|
|
}
|
|
if ((to == null || to === "" || to === ".") && activeRouteMatch) {
|
|
let nakedIndex = hasNakedIndexQuery(path.search);
|
|
if (activeRouteMatch.route.index && !nakedIndex) {
|
|
path.search = path.search ? path.search.replace(/^\?/, "?index&") : "?index";
|
|
} else if (!activeRouteMatch.route.index && nakedIndex) {
|
|
let params = new URLSearchParams(path.search);
|
|
let indexValues = params.getAll("index");
|
|
params.delete("index");
|
|
indexValues.filter((v) => v).forEach((v) => params.append("index", v));
|
|
let qs = params.toString();
|
|
path.search = qs ? "?" + qs : "";
|
|
}
|
|
}
|
|
if (prependBasename && basename !== "/") {
|
|
path.pathname = path.pathname === "/" ? basename : joinPaths([basename, path.pathname]);
|
|
}
|
|
return createPath(path);
|
|
}
|
|
function normalizeNavigateOptions(normalizeFormMethod, isFetcher, path, opts) {
|
|
if (!opts || !isSubmissionNavigation(opts)) {
|
|
return {
|
|
path
|
|
};
|
|
}
|
|
if (opts.formMethod && !isValidMethod(opts.formMethod)) {
|
|
return {
|
|
path,
|
|
error: getInternalRouterError(405, {
|
|
method: opts.formMethod
|
|
})
|
|
};
|
|
}
|
|
let getInvalidBodyError = () => ({
|
|
path,
|
|
error: getInternalRouterError(400, {
|
|
type: "invalid-body"
|
|
})
|
|
});
|
|
let rawFormMethod = opts.formMethod || "get";
|
|
let formMethod = normalizeFormMethod ? rawFormMethod.toUpperCase() : rawFormMethod.toLowerCase();
|
|
let formAction = stripHashFromPath(path);
|
|
if (opts.body !== void 0) {
|
|
if (opts.formEncType === "text/plain") {
|
|
if (!isMutationMethod(formMethod)) {
|
|
return getInvalidBodyError();
|
|
}
|
|
let text = typeof opts.body === "string" ? opts.body : opts.body instanceof FormData || opts.body instanceof URLSearchParams ? (
|
|
// https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#plain-text-form-data
|
|
Array.from(opts.body.entries()).reduce((acc, _ref3) => {
|
|
let [name, value] = _ref3;
|
|
return "" + acc + name + "=" + value + "\n";
|
|
}, "")
|
|
) : String(opts.body);
|
|
return {
|
|
path,
|
|
submission: {
|
|
formMethod,
|
|
formAction,
|
|
formEncType: opts.formEncType,
|
|
formData: void 0,
|
|
json: void 0,
|
|
text
|
|
}
|
|
};
|
|
} else if (opts.formEncType === "application/json") {
|
|
if (!isMutationMethod(formMethod)) {
|
|
return getInvalidBodyError();
|
|
}
|
|
try {
|
|
let json3 = typeof opts.body === "string" ? JSON.parse(opts.body) : opts.body;
|
|
return {
|
|
path,
|
|
submission: {
|
|
formMethod,
|
|
formAction,
|
|
formEncType: opts.formEncType,
|
|
formData: void 0,
|
|
json: json3,
|
|
text: void 0
|
|
}
|
|
};
|
|
} catch (e) {
|
|
return getInvalidBodyError();
|
|
}
|
|
}
|
|
}
|
|
invariant(typeof FormData === "function", "FormData is not available in this environment");
|
|
let searchParams;
|
|
let formData;
|
|
if (opts.formData) {
|
|
searchParams = convertFormDataToSearchParams(opts.formData);
|
|
formData = opts.formData;
|
|
} else if (opts.body instanceof FormData) {
|
|
searchParams = convertFormDataToSearchParams(opts.body);
|
|
formData = opts.body;
|
|
} else if (opts.body instanceof URLSearchParams) {
|
|
searchParams = opts.body;
|
|
formData = convertSearchParamsToFormData(searchParams);
|
|
} else if (opts.body == null) {
|
|
searchParams = new URLSearchParams();
|
|
formData = new FormData();
|
|
} else {
|
|
try {
|
|
searchParams = new URLSearchParams(opts.body);
|
|
formData = convertSearchParamsToFormData(searchParams);
|
|
} catch (e) {
|
|
return getInvalidBodyError();
|
|
}
|
|
}
|
|
let submission = {
|
|
formMethod,
|
|
formAction,
|
|
formEncType: opts && opts.formEncType || "application/x-www-form-urlencoded",
|
|
formData,
|
|
json: void 0,
|
|
text: void 0
|
|
};
|
|
if (isMutationMethod(submission.formMethod)) {
|
|
return {
|
|
path,
|
|
submission
|
|
};
|
|
}
|
|
let parsedPath = parsePath(path);
|
|
if (isFetcher && parsedPath.search && hasNakedIndexQuery(parsedPath.search)) {
|
|
searchParams.append("index", "");
|
|
}
|
|
parsedPath.search = "?" + searchParams;
|
|
return {
|
|
path: createPath(parsedPath),
|
|
submission
|
|
};
|
|
}
|
|
function getLoaderMatchesUntilBoundary(matches, boundaryId, includeBoundary) {
|
|
if (includeBoundary === void 0) {
|
|
includeBoundary = false;
|
|
}
|
|
let index = matches.findIndex((m) => m.route.id === boundaryId);
|
|
if (index >= 0) {
|
|
return matches.slice(0, includeBoundary ? index + 1 : index);
|
|
}
|
|
return matches;
|
|
}
|
|
function getMatchesToLoad(history, state, matches, submission, location, initialHydration, skipActionErrorRevalidation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, pendingActionResult) {
|
|
let actionResult = pendingActionResult ? isErrorResult(pendingActionResult[1]) ? pendingActionResult[1].error : pendingActionResult[1].data : void 0;
|
|
let currentUrl = history.createURL(state.location);
|
|
let nextUrl = history.createURL(location);
|
|
let boundaryMatches = matches;
|
|
if (initialHydration && state.errors) {
|
|
boundaryMatches = getLoaderMatchesUntilBoundary(matches, Object.keys(state.errors)[0], true);
|
|
} else if (pendingActionResult && isErrorResult(pendingActionResult[1])) {
|
|
boundaryMatches = getLoaderMatchesUntilBoundary(matches, pendingActionResult[0]);
|
|
}
|
|
let actionStatus = pendingActionResult ? pendingActionResult[1].statusCode : void 0;
|
|
let shouldSkipRevalidation = skipActionErrorRevalidation && actionStatus && actionStatus >= 400;
|
|
let navigationMatches = boundaryMatches.filter((match, index) => {
|
|
let {
|
|
route
|
|
} = match;
|
|
if (route.lazy) {
|
|
return true;
|
|
}
|
|
if (route.loader == null) {
|
|
return false;
|
|
}
|
|
if (initialHydration) {
|
|
return shouldLoadRouteOnHydration(route, state.loaderData, state.errors);
|
|
}
|
|
if (isNewLoader(state.loaderData, state.matches[index], match) || cancelledDeferredRoutes.some((id) => id === match.route.id)) {
|
|
return true;
|
|
}
|
|
let currentRouteMatch = state.matches[index];
|
|
let nextRouteMatch = match;
|
|
return shouldRevalidateLoader(match, _extends({
|
|
currentUrl,
|
|
currentParams: currentRouteMatch.params,
|
|
nextUrl,
|
|
nextParams: nextRouteMatch.params
|
|
}, submission, {
|
|
actionResult,
|
|
actionStatus,
|
|
defaultShouldRevalidate: shouldSkipRevalidation ? false : (
|
|
// Forced revalidation due to submission, useRevalidator, or X-Remix-Revalidate
|
|
isRevalidationRequired || currentUrl.pathname + currentUrl.search === nextUrl.pathname + nextUrl.search || // Search params affect all loaders
|
|
currentUrl.search !== nextUrl.search || isNewRouteInstance(currentRouteMatch, nextRouteMatch)
|
|
)
|
|
}));
|
|
});
|
|
let revalidatingFetchers = [];
|
|
fetchLoadMatches.forEach((f, key) => {
|
|
if (initialHydration || !matches.some((m) => m.route.id === f.routeId) || deletedFetchers.has(key)) {
|
|
return;
|
|
}
|
|
let fetcherMatches = matchRoutes(routesToUse, f.path, basename);
|
|
if (!fetcherMatches) {
|
|
revalidatingFetchers.push({
|
|
key,
|
|
routeId: f.routeId,
|
|
path: f.path,
|
|
matches: null,
|
|
match: null,
|
|
controller: null
|
|
});
|
|
return;
|
|
}
|
|
let fetcher = state.fetchers.get(key);
|
|
let fetcherMatch = getTargetMatch(fetcherMatches, f.path);
|
|
let shouldRevalidate = false;
|
|
if (fetchRedirectIds.has(key)) {
|
|
shouldRevalidate = false;
|
|
} else if (cancelledFetcherLoads.has(key)) {
|
|
cancelledFetcherLoads.delete(key);
|
|
shouldRevalidate = true;
|
|
} else if (fetcher && fetcher.state !== "idle" && fetcher.data === void 0) {
|
|
shouldRevalidate = isRevalidationRequired;
|
|
} else {
|
|
shouldRevalidate = shouldRevalidateLoader(fetcherMatch, _extends({
|
|
currentUrl,
|
|
currentParams: state.matches[state.matches.length - 1].params,
|
|
nextUrl,
|
|
nextParams: matches[matches.length - 1].params
|
|
}, submission, {
|
|
actionResult,
|
|
actionStatus,
|
|
defaultShouldRevalidate: shouldSkipRevalidation ? false : isRevalidationRequired
|
|
}));
|
|
}
|
|
if (shouldRevalidate) {
|
|
revalidatingFetchers.push({
|
|
key,
|
|
routeId: f.routeId,
|
|
path: f.path,
|
|
matches: fetcherMatches,
|
|
match: fetcherMatch,
|
|
controller: new AbortController()
|
|
});
|
|
}
|
|
});
|
|
return [navigationMatches, revalidatingFetchers];
|
|
}
|
|
function shouldLoadRouteOnHydration(route, loaderData, errors) {
|
|
if (route.lazy) {
|
|
return true;
|
|
}
|
|
if (!route.loader) {
|
|
return false;
|
|
}
|
|
let hasData = loaderData != null && loaderData[route.id] !== void 0;
|
|
let hasError = errors != null && errors[route.id] !== void 0;
|
|
if (!hasData && hasError) {
|
|
return false;
|
|
}
|
|
if (typeof route.loader === "function" && route.loader.hydrate === true) {
|
|
return true;
|
|
}
|
|
return !hasData && !hasError;
|
|
}
|
|
function isNewLoader(currentLoaderData, currentMatch, match) {
|
|
let isNew = (
|
|
// [a] -> [a, b]
|
|
!currentMatch || // [a, b] -> [a, c]
|
|
match.route.id !== currentMatch.route.id
|
|
);
|
|
let isMissingData = currentLoaderData[match.route.id] === void 0;
|
|
return isNew || isMissingData;
|
|
}
|
|
function isNewRouteInstance(currentMatch, match) {
|
|
let currentPath = currentMatch.route.path;
|
|
return (
|
|
// param change for this match, /users/123 -> /users/456
|
|
currentMatch.pathname !== match.pathname || // splat param changed, which is not present in match.path
|
|
// e.g. /files/images/avatar.jpg -> files/finances.xls
|
|
currentPath != null && currentPath.endsWith("*") && currentMatch.params["*"] !== match.params["*"]
|
|
);
|
|
}
|
|
function shouldRevalidateLoader(loaderMatch, arg) {
|
|
if (loaderMatch.route.shouldRevalidate) {
|
|
let routeChoice = loaderMatch.route.shouldRevalidate(arg);
|
|
if (typeof routeChoice === "boolean") {
|
|
return routeChoice;
|
|
}
|
|
}
|
|
return arg.defaultShouldRevalidate;
|
|
}
|
|
function patchRoutesImpl(routeId, children, routesToUse, manifest, mapRouteProperties2) {
|
|
var _childrenToPatch;
|
|
let childrenToPatch;
|
|
if (routeId) {
|
|
let route = manifest[routeId];
|
|
invariant(route, "No route found to patch children into: routeId = " + routeId);
|
|
if (!route.children) {
|
|
route.children = [];
|
|
}
|
|
childrenToPatch = route.children;
|
|
} else {
|
|
childrenToPatch = routesToUse;
|
|
}
|
|
let uniqueChildren = children.filter((newRoute) => !childrenToPatch.some((existingRoute) => isSameRoute(newRoute, existingRoute)));
|
|
let newRoutes = convertRoutesToDataRoutes(uniqueChildren, mapRouteProperties2, [routeId || "_", "patch", String(((_childrenToPatch = childrenToPatch) == null ? void 0 : _childrenToPatch.length) || "0")], manifest);
|
|
childrenToPatch.push(...newRoutes);
|
|
}
|
|
function isSameRoute(newRoute, existingRoute) {
|
|
if ("id" in newRoute && "id" in existingRoute && newRoute.id === existingRoute.id) {
|
|
return true;
|
|
}
|
|
if (!(newRoute.index === existingRoute.index && newRoute.path === existingRoute.path && newRoute.caseSensitive === existingRoute.caseSensitive)) {
|
|
return false;
|
|
}
|
|
if ((!newRoute.children || newRoute.children.length === 0) && (!existingRoute.children || existingRoute.children.length === 0)) {
|
|
return true;
|
|
}
|
|
return newRoute.children.every((aChild, i) => {
|
|
var _existingRoute$childr;
|
|
return (_existingRoute$childr = existingRoute.children) == null ? void 0 : _existingRoute$childr.some((bChild) => isSameRoute(aChild, bChild));
|
|
});
|
|
}
|
|
async function loadLazyRouteModule(route, mapRouteProperties2, manifest) {
|
|
if (!route.lazy) {
|
|
return;
|
|
}
|
|
let lazyRoute = await route.lazy();
|
|
if (!route.lazy) {
|
|
return;
|
|
}
|
|
let routeToUpdate = manifest[route.id];
|
|
invariant(routeToUpdate, "No route found in manifest");
|
|
let routeUpdates = {};
|
|
for (let lazyRouteProperty in lazyRoute) {
|
|
let staticRouteValue = routeToUpdate[lazyRouteProperty];
|
|
let isPropertyStaticallyDefined = staticRouteValue !== void 0 && // This property isn't static since it should always be updated based
|
|
// on the route updates
|
|
lazyRouteProperty !== "hasErrorBoundary";
|
|
warning(!isPropertyStaticallyDefined, 'Route "' + routeToUpdate.id + '" has a static property "' + lazyRouteProperty + '" defined but its lazy function is also returning a value for this property. ' + ('The lazy route property "' + lazyRouteProperty + '" will be ignored.'));
|
|
if (!isPropertyStaticallyDefined && !immutableRouteKeys.has(lazyRouteProperty)) {
|
|
routeUpdates[lazyRouteProperty] = lazyRoute[lazyRouteProperty];
|
|
}
|
|
}
|
|
Object.assign(routeToUpdate, routeUpdates);
|
|
Object.assign(routeToUpdate, _extends({}, mapRouteProperties2(routeToUpdate), {
|
|
lazy: void 0
|
|
}));
|
|
}
|
|
async function defaultDataStrategy(_ref4) {
|
|
let {
|
|
matches
|
|
} = _ref4;
|
|
let matchesToLoad = matches.filter((m) => m.shouldLoad);
|
|
let results = await Promise.all(matchesToLoad.map((m) => m.resolve()));
|
|
return results.reduce((acc, result, i) => Object.assign(acc, {
|
|
[matchesToLoad[i].route.id]: result
|
|
}), {});
|
|
}
|
|
async function callDataStrategyImpl(dataStrategyImpl, type, state, request, matchesToLoad, matches, fetcherKey, manifest, mapRouteProperties2, requestContext) {
|
|
let loadRouteDefinitionsPromises = matches.map((m) => m.route.lazy ? loadLazyRouteModule(m.route, mapRouteProperties2, manifest) : void 0);
|
|
let dsMatches = matches.map((match, i) => {
|
|
let loadRoutePromise = loadRouteDefinitionsPromises[i];
|
|
let shouldLoad = matchesToLoad.some((m) => m.route.id === match.route.id);
|
|
let resolve = async (handlerOverride) => {
|
|
if (handlerOverride && request.method === "GET" && (match.route.lazy || match.route.loader)) {
|
|
shouldLoad = true;
|
|
}
|
|
return shouldLoad ? callLoaderOrAction(type, request, match, loadRoutePromise, handlerOverride, requestContext) : Promise.resolve({
|
|
type: ResultType.data,
|
|
result: void 0
|
|
});
|
|
};
|
|
return _extends({}, match, {
|
|
shouldLoad,
|
|
resolve
|
|
});
|
|
});
|
|
let results = await dataStrategyImpl({
|
|
matches: dsMatches,
|
|
request,
|
|
params: matches[0].params,
|
|
fetcherKey,
|
|
context: requestContext
|
|
});
|
|
try {
|
|
await Promise.all(loadRouteDefinitionsPromises);
|
|
} catch (e) {
|
|
}
|
|
return results;
|
|
}
|
|
async function callLoaderOrAction(type, request, match, loadRoutePromise, handlerOverride, staticContext) {
|
|
let result;
|
|
let onReject;
|
|
let runHandler = (handler) => {
|
|
let reject;
|
|
let abortPromise = new Promise((_, r) => reject = r);
|
|
onReject = () => reject();
|
|
request.signal.addEventListener("abort", onReject);
|
|
let actualHandler = (ctx) => {
|
|
if (typeof handler !== "function") {
|
|
return Promise.reject(new Error("You cannot call the handler for a route which defines a boolean " + ('"' + type + '" [routeId: ' + match.route.id + "]")));
|
|
}
|
|
return handler({
|
|
request,
|
|
params: match.params,
|
|
context: staticContext
|
|
}, ...ctx !== void 0 ? [ctx] : []);
|
|
};
|
|
let handlerPromise = (async () => {
|
|
try {
|
|
let val = await (handlerOverride ? handlerOverride((ctx) => actualHandler(ctx)) : actualHandler());
|
|
return {
|
|
type: "data",
|
|
result: val
|
|
};
|
|
} catch (e) {
|
|
return {
|
|
type: "error",
|
|
result: e
|
|
};
|
|
}
|
|
})();
|
|
return Promise.race([handlerPromise, abortPromise]);
|
|
};
|
|
try {
|
|
let handler = match.route[type];
|
|
if (loadRoutePromise) {
|
|
if (handler) {
|
|
let handlerError;
|
|
let [value] = await Promise.all([
|
|
// If the handler throws, don't let it immediately bubble out,
|
|
// since we need to let the lazy() execution finish so we know if this
|
|
// route has a boundary that can handle the error
|
|
runHandler(handler).catch((e) => {
|
|
handlerError = e;
|
|
}),
|
|
loadRoutePromise
|
|
]);
|
|
if (handlerError !== void 0) {
|
|
throw handlerError;
|
|
}
|
|
result = value;
|
|
} else {
|
|
await loadRoutePromise;
|
|
handler = match.route[type];
|
|
if (handler) {
|
|
result = await runHandler(handler);
|
|
} else if (type === "action") {
|
|
let url = new URL(request.url);
|
|
let pathname = url.pathname + url.search;
|
|
throw getInternalRouterError(405, {
|
|
method: request.method,
|
|
pathname,
|
|
routeId: match.route.id
|
|
});
|
|
} else {
|
|
return {
|
|
type: ResultType.data,
|
|
result: void 0
|
|
};
|
|
}
|
|
}
|
|
} else if (!handler) {
|
|
let url = new URL(request.url);
|
|
let pathname = url.pathname + url.search;
|
|
throw getInternalRouterError(404, {
|
|
pathname
|
|
});
|
|
} else {
|
|
result = await runHandler(handler);
|
|
}
|
|
invariant(result.result !== void 0, "You defined " + (type === "action" ? "an action" : "a loader") + " for route " + ('"' + match.route.id + "\" but didn't return anything from your `" + type + "` ") + "function. Please return a value or `null`.");
|
|
} catch (e) {
|
|
return {
|
|
type: ResultType.error,
|
|
result: e
|
|
};
|
|
} finally {
|
|
if (onReject) {
|
|
request.signal.removeEventListener("abort", onReject);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
async function convertDataStrategyResultToDataResult(dataStrategyResult) {
|
|
let {
|
|
result,
|
|
type
|
|
} = dataStrategyResult;
|
|
if (isResponse(result)) {
|
|
let data;
|
|
try {
|
|
let contentType = result.headers.get("Content-Type");
|
|
if (contentType && /\bapplication\/json\b/.test(contentType)) {
|
|
if (result.body == null) {
|
|
data = null;
|
|
} else {
|
|
data = await result.json();
|
|
}
|
|
} else {
|
|
data = await result.text();
|
|
}
|
|
} catch (e) {
|
|
return {
|
|
type: ResultType.error,
|
|
error: e
|
|
};
|
|
}
|
|
if (type === ResultType.error) {
|
|
return {
|
|
type: ResultType.error,
|
|
error: new ErrorResponseImpl(result.status, result.statusText, data),
|
|
statusCode: result.status,
|
|
headers: result.headers
|
|
};
|
|
}
|
|
return {
|
|
type: ResultType.data,
|
|
data,
|
|
statusCode: result.status,
|
|
headers: result.headers
|
|
};
|
|
}
|
|
if (type === ResultType.error) {
|
|
if (isDataWithResponseInit(result)) {
|
|
var _result$init2;
|
|
if (result.data instanceof Error) {
|
|
var _result$init;
|
|
return {
|
|
type: ResultType.error,
|
|
error: result.data,
|
|
statusCode: (_result$init = result.init) == null ? void 0 : _result$init.status
|
|
};
|
|
}
|
|
result = new ErrorResponseImpl(((_result$init2 = result.init) == null ? void 0 : _result$init2.status) || 500, void 0, result.data);
|
|
}
|
|
return {
|
|
type: ResultType.error,
|
|
error: result,
|
|
statusCode: isRouteErrorResponse(result) ? result.status : void 0
|
|
};
|
|
}
|
|
if (isDeferredData(result)) {
|
|
var _result$init3, _result$init4;
|
|
return {
|
|
type: ResultType.deferred,
|
|
deferredData: result,
|
|
statusCode: (_result$init3 = result.init) == null ? void 0 : _result$init3.status,
|
|
headers: ((_result$init4 = result.init) == null ? void 0 : _result$init4.headers) && new Headers(result.init.headers)
|
|
};
|
|
}
|
|
if (isDataWithResponseInit(result)) {
|
|
var _result$init5, _result$init6;
|
|
return {
|
|
type: ResultType.data,
|
|
data: result.data,
|
|
statusCode: (_result$init5 = result.init) == null ? void 0 : _result$init5.status,
|
|
headers: (_result$init6 = result.init) != null && _result$init6.headers ? new Headers(result.init.headers) : void 0
|
|
};
|
|
}
|
|
return {
|
|
type: ResultType.data,
|
|
data: result
|
|
};
|
|
}
|
|
function normalizeRelativeRoutingRedirectResponse(response, request, routeId, matches, basename, v7_relativeSplatPath) {
|
|
let location = response.headers.get("Location");
|
|
invariant(location, "Redirects returned/thrown from loaders/actions must have a Location header");
|
|
if (!ABSOLUTE_URL_REGEX.test(location)) {
|
|
let trimmedMatches = matches.slice(0, matches.findIndex((m) => m.route.id === routeId) + 1);
|
|
location = normalizeTo(new URL(request.url), trimmedMatches, basename, true, location, v7_relativeSplatPath);
|
|
response.headers.set("Location", location);
|
|
}
|
|
return response;
|
|
}
|
|
function normalizeRedirectLocation(location, currentUrl, basename) {
|
|
if (ABSOLUTE_URL_REGEX.test(location)) {
|
|
let normalizedLocation = location;
|
|
let url = normalizedLocation.startsWith("//") ? new URL(currentUrl.protocol + normalizedLocation) : new URL(normalizedLocation);
|
|
let isSameBasename = stripBasename(url.pathname, basename) != null;
|
|
if (url.origin === currentUrl.origin && isSameBasename) {
|
|
return url.pathname + url.search + url.hash;
|
|
}
|
|
}
|
|
return location;
|
|
}
|
|
function createClientSideRequest(history, location, signal, submission) {
|
|
let url = history.createURL(stripHashFromPath(location)).toString();
|
|
let init = {
|
|
signal
|
|
};
|
|
if (submission && isMutationMethod(submission.formMethod)) {
|
|
let {
|
|
formMethod,
|
|
formEncType
|
|
} = submission;
|
|
init.method = formMethod.toUpperCase();
|
|
if (formEncType === "application/json") {
|
|
init.headers = new Headers({
|
|
"Content-Type": formEncType
|
|
});
|
|
init.body = JSON.stringify(submission.json);
|
|
} else if (formEncType === "text/plain") {
|
|
init.body = submission.text;
|
|
} else if (formEncType === "application/x-www-form-urlencoded" && submission.formData) {
|
|
init.body = convertFormDataToSearchParams(submission.formData);
|
|
} else {
|
|
init.body = submission.formData;
|
|
}
|
|
}
|
|
return new Request(url, init);
|
|
}
|
|
function convertFormDataToSearchParams(formData) {
|
|
let searchParams = new URLSearchParams();
|
|
for (let [key, value] of formData.entries()) {
|
|
searchParams.append(key, typeof value === "string" ? value : value.name);
|
|
}
|
|
return searchParams;
|
|
}
|
|
function convertSearchParamsToFormData(searchParams) {
|
|
let formData = new FormData();
|
|
for (let [key, value] of searchParams.entries()) {
|
|
formData.append(key, value);
|
|
}
|
|
return formData;
|
|
}
|
|
function processRouteLoaderData(matches, results, pendingActionResult, activeDeferreds, skipLoaderErrorBubbling) {
|
|
let loaderData = {};
|
|
let errors = null;
|
|
let statusCode;
|
|
let foundError = false;
|
|
let loaderHeaders = {};
|
|
let pendingError = pendingActionResult && isErrorResult(pendingActionResult[1]) ? pendingActionResult[1].error : void 0;
|
|
matches.forEach((match) => {
|
|
if (!(match.route.id in results)) {
|
|
return;
|
|
}
|
|
let id = match.route.id;
|
|
let result = results[id];
|
|
invariant(!isRedirectResult(result), "Cannot handle redirect results in processLoaderData");
|
|
if (isErrorResult(result)) {
|
|
let error = result.error;
|
|
if (pendingError !== void 0) {
|
|
error = pendingError;
|
|
pendingError = void 0;
|
|
}
|
|
errors = errors || {};
|
|
if (skipLoaderErrorBubbling) {
|
|
errors[id] = error;
|
|
} else {
|
|
let boundaryMatch = findNearestBoundary(matches, id);
|
|
if (errors[boundaryMatch.route.id] == null) {
|
|
errors[boundaryMatch.route.id] = error;
|
|
}
|
|
}
|
|
loaderData[id] = void 0;
|
|
if (!foundError) {
|
|
foundError = true;
|
|
statusCode = isRouteErrorResponse(result.error) ? result.error.status : 500;
|
|
}
|
|
if (result.headers) {
|
|
loaderHeaders[id] = result.headers;
|
|
}
|
|
} else {
|
|
if (isDeferredResult(result)) {
|
|
activeDeferreds.set(id, result.deferredData);
|
|
loaderData[id] = result.deferredData.data;
|
|
if (result.statusCode != null && result.statusCode !== 200 && !foundError) {
|
|
statusCode = result.statusCode;
|
|
}
|
|
if (result.headers) {
|
|
loaderHeaders[id] = result.headers;
|
|
}
|
|
} else {
|
|
loaderData[id] = result.data;
|
|
if (result.statusCode && result.statusCode !== 200 && !foundError) {
|
|
statusCode = result.statusCode;
|
|
}
|
|
if (result.headers) {
|
|
loaderHeaders[id] = result.headers;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
if (pendingError !== void 0 && pendingActionResult) {
|
|
errors = {
|
|
[pendingActionResult[0]]: pendingError
|
|
};
|
|
loaderData[pendingActionResult[0]] = void 0;
|
|
}
|
|
return {
|
|
loaderData,
|
|
errors,
|
|
statusCode: statusCode || 200,
|
|
loaderHeaders
|
|
};
|
|
}
|
|
function processLoaderData(state, matches, results, pendingActionResult, revalidatingFetchers, fetcherResults, activeDeferreds) {
|
|
let {
|
|
loaderData,
|
|
errors
|
|
} = processRouteLoaderData(
|
|
matches,
|
|
results,
|
|
pendingActionResult,
|
|
activeDeferreds,
|
|
false
|
|
// This method is only called client side so we always want to bubble
|
|
);
|
|
revalidatingFetchers.forEach((rf) => {
|
|
let {
|
|
key,
|
|
match,
|
|
controller
|
|
} = rf;
|
|
let result = fetcherResults[key];
|
|
invariant(result, "Did not find corresponding fetcher result");
|
|
if (controller && controller.signal.aborted) {
|
|
return;
|
|
} else if (isErrorResult(result)) {
|
|
let boundaryMatch = findNearestBoundary(state.matches, match == null ? void 0 : match.route.id);
|
|
if (!(errors && errors[boundaryMatch.route.id])) {
|
|
errors = _extends({}, errors, {
|
|
[boundaryMatch.route.id]: result.error
|
|
});
|
|
}
|
|
state.fetchers.delete(key);
|
|
} else if (isRedirectResult(result)) {
|
|
invariant(false, "Unhandled fetcher revalidation redirect");
|
|
} else if (isDeferredResult(result)) {
|
|
invariant(false, "Unhandled fetcher deferred data");
|
|
} else {
|
|
let doneFetcher = getDoneFetcher(result.data);
|
|
state.fetchers.set(key, doneFetcher);
|
|
}
|
|
});
|
|
return {
|
|
loaderData,
|
|
errors
|
|
};
|
|
}
|
|
function mergeLoaderData(loaderData, newLoaderData, matches, errors) {
|
|
let mergedLoaderData = _extends({}, newLoaderData);
|
|
for (let match of matches) {
|
|
let id = match.route.id;
|
|
if (newLoaderData.hasOwnProperty(id)) {
|
|
if (newLoaderData[id] !== void 0) {
|
|
mergedLoaderData[id] = newLoaderData[id];
|
|
}
|
|
} else if (loaderData[id] !== void 0 && match.route.loader) {
|
|
mergedLoaderData[id] = loaderData[id];
|
|
}
|
|
if (errors && errors.hasOwnProperty(id)) {
|
|
break;
|
|
}
|
|
}
|
|
return mergedLoaderData;
|
|
}
|
|
function getActionDataForCommit(pendingActionResult) {
|
|
if (!pendingActionResult) {
|
|
return {};
|
|
}
|
|
return isErrorResult(pendingActionResult[1]) ? {
|
|
// Clear out prior actionData on errors
|
|
actionData: {}
|
|
} : {
|
|
actionData: {
|
|
[pendingActionResult[0]]: pendingActionResult[1].data
|
|
}
|
|
};
|
|
}
|
|
function findNearestBoundary(matches, routeId) {
|
|
let eligibleMatches = routeId ? matches.slice(0, matches.findIndex((m) => m.route.id === routeId) + 1) : [...matches];
|
|
return eligibleMatches.reverse().find((m) => m.route.hasErrorBoundary === true) || matches[0];
|
|
}
|
|
function getShortCircuitMatches(routes) {
|
|
let route = routes.length === 1 ? routes[0] : routes.find((r) => r.index || !r.path || r.path === "/") || {
|
|
id: "__shim-error-route__"
|
|
};
|
|
return {
|
|
matches: [{
|
|
params: {},
|
|
pathname: "",
|
|
pathnameBase: "",
|
|
route
|
|
}],
|
|
route
|
|
};
|
|
}
|
|
function getInternalRouterError(status, _temp5) {
|
|
let {
|
|
pathname,
|
|
routeId,
|
|
method,
|
|
type,
|
|
message
|
|
} = _temp5 === void 0 ? {} : _temp5;
|
|
let statusText = "Unknown Server Error";
|
|
let errorMessage = "Unknown @remix-run/router error";
|
|
if (status === 400) {
|
|
statusText = "Bad Request";
|
|
if (method && pathname && routeId) {
|
|
errorMessage = "You made a " + method + ' request to "' + pathname + '" but ' + ('did not provide a `loader` for route "' + routeId + '", ') + "so there is no way to handle the request.";
|
|
} else if (type === "defer-action") {
|
|
errorMessage = "defer() is not supported in actions";
|
|
} else if (type === "invalid-body") {
|
|
errorMessage = "Unable to encode submission body";
|
|
}
|
|
} else if (status === 403) {
|
|
statusText = "Forbidden";
|
|
errorMessage = 'Route "' + routeId + '" does not match URL "' + pathname + '"';
|
|
} else if (status === 404) {
|
|
statusText = "Not Found";
|
|
errorMessage = 'No route matches URL "' + pathname + '"';
|
|
} else if (status === 405) {
|
|
statusText = "Method Not Allowed";
|
|
if (method && pathname && routeId) {
|
|
errorMessage = "You made a " + method.toUpperCase() + ' request to "' + pathname + '" but ' + ('did not provide an `action` for route "' + routeId + '", ') + "so there is no way to handle the request.";
|
|
} else if (method) {
|
|
errorMessage = 'Invalid request method "' + method.toUpperCase() + '"';
|
|
}
|
|
}
|
|
return new ErrorResponseImpl(status || 500, statusText, new Error(errorMessage), true);
|
|
}
|
|
function findRedirect(results) {
|
|
let entries = Object.entries(results);
|
|
for (let i = entries.length - 1; i >= 0; i--) {
|
|
let [key, result] = entries[i];
|
|
if (isRedirectResult(result)) {
|
|
return {
|
|
key,
|
|
result
|
|
};
|
|
}
|
|
}
|
|
}
|
|
function stripHashFromPath(path) {
|
|
let parsedPath = typeof path === "string" ? parsePath(path) : path;
|
|
return createPath(_extends({}, parsedPath, {
|
|
hash: ""
|
|
}));
|
|
}
|
|
function isHashChangeOnly(a, b) {
|
|
if (a.pathname !== b.pathname || a.search !== b.search) {
|
|
return false;
|
|
}
|
|
if (a.hash === "") {
|
|
return b.hash !== "";
|
|
} else if (a.hash === b.hash) {
|
|
return true;
|
|
} else if (b.hash !== "") {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function isRedirectDataStrategyResultResult(result) {
|
|
return isResponse(result.result) && redirectStatusCodes.has(result.result.status);
|
|
}
|
|
function isDeferredResult(result) {
|
|
return result.type === ResultType.deferred;
|
|
}
|
|
function isErrorResult(result) {
|
|
return result.type === ResultType.error;
|
|
}
|
|
function isRedirectResult(result) {
|
|
return (result && result.type) === ResultType.redirect;
|
|
}
|
|
function isDataWithResponseInit(value) {
|
|
return typeof value === "object" && value != null && "type" in value && "data" in value && "init" in value && value.type === "DataWithResponseInit";
|
|
}
|
|
function isDeferredData(value) {
|
|
let deferred = value;
|
|
return deferred && typeof deferred === "object" && typeof deferred.data === "object" && typeof deferred.subscribe === "function" && typeof deferred.cancel === "function" && typeof deferred.resolveData === "function";
|
|
}
|
|
function isResponse(value) {
|
|
return value != null && typeof value.status === "number" && typeof value.statusText === "string" && typeof value.headers === "object" && typeof value.body !== "undefined";
|
|
}
|
|
function isValidMethod(method) {
|
|
return validRequestMethods.has(method.toLowerCase());
|
|
}
|
|
function isMutationMethod(method) {
|
|
return validMutationMethods.has(method.toLowerCase());
|
|
}
|
|
async function resolveNavigationDeferredResults(matches, results, signal, currentMatches, currentLoaderData) {
|
|
let entries = Object.entries(results);
|
|
for (let index = 0; index < entries.length; index++) {
|
|
let [routeId, result] = entries[index];
|
|
let match = matches.find((m) => (m == null ? void 0 : m.route.id) === routeId);
|
|
if (!match) {
|
|
continue;
|
|
}
|
|
let currentMatch = currentMatches.find((m) => m.route.id === match.route.id);
|
|
let isRevalidatingLoader = currentMatch != null && !isNewRouteInstance(currentMatch, match) && (currentLoaderData && currentLoaderData[match.route.id]) !== void 0;
|
|
if (isDeferredResult(result) && isRevalidatingLoader) {
|
|
await resolveDeferredData(result, signal, false).then((result2) => {
|
|
if (result2) {
|
|
results[routeId] = result2;
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
async function resolveFetcherDeferredResults(matches, results, revalidatingFetchers) {
|
|
for (let index = 0; index < revalidatingFetchers.length; index++) {
|
|
let {
|
|
key,
|
|
routeId,
|
|
controller
|
|
} = revalidatingFetchers[index];
|
|
let result = results[key];
|
|
let match = matches.find((m) => (m == null ? void 0 : m.route.id) === routeId);
|
|
if (!match) {
|
|
continue;
|
|
}
|
|
if (isDeferredResult(result)) {
|
|
invariant(controller, "Expected an AbortController for revalidating fetcher deferred result");
|
|
await resolveDeferredData(result, controller.signal, true).then((result2) => {
|
|
if (result2) {
|
|
results[key] = result2;
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
async function resolveDeferredData(result, signal, unwrap) {
|
|
if (unwrap === void 0) {
|
|
unwrap = false;
|
|
}
|
|
let aborted = await result.deferredData.resolveData(signal);
|
|
if (aborted) {
|
|
return;
|
|
}
|
|
if (unwrap) {
|
|
try {
|
|
return {
|
|
type: ResultType.data,
|
|
data: result.deferredData.unwrappedData
|
|
};
|
|
} catch (e) {
|
|
return {
|
|
type: ResultType.error,
|
|
error: e
|
|
};
|
|
}
|
|
}
|
|
return {
|
|
type: ResultType.data,
|
|
data: result.deferredData.data
|
|
};
|
|
}
|
|
function hasNakedIndexQuery(search) {
|
|
return new URLSearchParams(search).getAll("index").some((v) => v === "");
|
|
}
|
|
function getTargetMatch(matches, location) {
|
|
let search = typeof location === "string" ? parsePath(location).search : location.search;
|
|
if (matches[matches.length - 1].route.index && hasNakedIndexQuery(search || "")) {
|
|
return matches[matches.length - 1];
|
|
}
|
|
let pathMatches = getPathContributingMatches(matches);
|
|
return pathMatches[pathMatches.length - 1];
|
|
}
|
|
function getSubmissionFromNavigation(navigation) {
|
|
let {
|
|
formMethod,
|
|
formAction,
|
|
formEncType,
|
|
text,
|
|
formData,
|
|
json: json3
|
|
} = navigation;
|
|
if (!formMethod || !formAction || !formEncType) {
|
|
return;
|
|
}
|
|
if (text != null) {
|
|
return {
|
|
formMethod,
|
|
formAction,
|
|
formEncType,
|
|
formData: void 0,
|
|
json: void 0,
|
|
text
|
|
};
|
|
} else if (formData != null) {
|
|
return {
|
|
formMethod,
|
|
formAction,
|
|
formEncType,
|
|
formData,
|
|
json: void 0,
|
|
text: void 0
|
|
};
|
|
} else if (json3 !== void 0) {
|
|
return {
|
|
formMethod,
|
|
formAction,
|
|
formEncType,
|
|
formData: void 0,
|
|
json: json3,
|
|
text: void 0
|
|
};
|
|
}
|
|
}
|
|
function getLoadingNavigation(location, submission) {
|
|
if (submission) {
|
|
let navigation = {
|
|
state: "loading",
|
|
location,
|
|
formMethod: submission.formMethod,
|
|
formAction: submission.formAction,
|
|
formEncType: submission.formEncType,
|
|
formData: submission.formData,
|
|
json: submission.json,
|
|
text: submission.text
|
|
};
|
|
return navigation;
|
|
} else {
|
|
let navigation = {
|
|
state: "loading",
|
|
location,
|
|
formMethod: void 0,
|
|
formAction: void 0,
|
|
formEncType: void 0,
|
|
formData: void 0,
|
|
json: void 0,
|
|
text: void 0
|
|
};
|
|
return navigation;
|
|
}
|
|
}
|
|
function getSubmittingNavigation(location, submission) {
|
|
let navigation = {
|
|
state: "submitting",
|
|
location,
|
|
formMethod: submission.formMethod,
|
|
formAction: submission.formAction,
|
|
formEncType: submission.formEncType,
|
|
formData: submission.formData,
|
|
json: submission.json,
|
|
text: submission.text
|
|
};
|
|
return navigation;
|
|
}
|
|
function getLoadingFetcher(submission, data) {
|
|
if (submission) {
|
|
let fetcher = {
|
|
state: "loading",
|
|
formMethod: submission.formMethod,
|
|
formAction: submission.formAction,
|
|
formEncType: submission.formEncType,
|
|
formData: submission.formData,
|
|
json: submission.json,
|
|
text: submission.text,
|
|
data
|
|
};
|
|
return fetcher;
|
|
} else {
|
|
let fetcher = {
|
|
state: "loading",
|
|
formMethod: void 0,
|
|
formAction: void 0,
|
|
formEncType: void 0,
|
|
formData: void 0,
|
|
json: void 0,
|
|
text: void 0,
|
|
data
|
|
};
|
|
return fetcher;
|
|
}
|
|
}
|
|
function getSubmittingFetcher(submission, existingFetcher) {
|
|
let fetcher = {
|
|
state: "submitting",
|
|
formMethod: submission.formMethod,
|
|
formAction: submission.formAction,
|
|
formEncType: submission.formEncType,
|
|
formData: submission.formData,
|
|
json: submission.json,
|
|
text: submission.text,
|
|
data: existingFetcher ? existingFetcher.data : void 0
|
|
};
|
|
return fetcher;
|
|
}
|
|
function getDoneFetcher(data) {
|
|
let fetcher = {
|
|
state: "idle",
|
|
formMethod: void 0,
|
|
formAction: void 0,
|
|
formEncType: void 0,
|
|
formData: void 0,
|
|
json: void 0,
|
|
text: void 0,
|
|
data
|
|
};
|
|
return fetcher;
|
|
}
|
|
function restoreAppliedTransitions(_window, transitions) {
|
|
try {
|
|
let sessionPositions = _window.sessionStorage.getItem(TRANSITIONS_STORAGE_KEY);
|
|
if (sessionPositions) {
|
|
let json3 = JSON.parse(sessionPositions);
|
|
for (let [k, v] of Object.entries(json3 || {})) {
|
|
if (v && Array.isArray(v)) {
|
|
transitions.set(k, new Set(v || []));
|
|
}
|
|
}
|
|
}
|
|
} catch (e) {
|
|
}
|
|
}
|
|
function persistAppliedTransitions(_window, transitions) {
|
|
if (transitions.size > 0) {
|
|
let json3 = {};
|
|
for (let [k, v] of transitions) {
|
|
json3[k] = [...v];
|
|
}
|
|
try {
|
|
_window.sessionStorage.setItem(TRANSITIONS_STORAGE_KEY, JSON.stringify(json3));
|
|
} catch (error) {
|
|
warning(false, "Failed to save applied view transitions in sessionStorage (" + error + ").");
|
|
}
|
|
}
|
|
}
|
|
|
|
// node_modules/.pnpm/react-router@6.28.1_react@18.3.1/node_modules/react-router/dist/index.js
|
|
function _extends2() {
|
|
_extends2 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) {
|
|
if (Object.prototype.hasOwnProperty.call(source, key)) {
|
|
target[key] = source[key];
|
|
}
|
|
}
|
|
}
|
|
return target;
|
|
};
|
|
return _extends2.apply(this, arguments);
|
|
}
|
|
var DataRouterContext = React.createContext(null);
|
|
if (true) {
|
|
DataRouterContext.displayName = "DataRouter";
|
|
}
|
|
var DataRouterStateContext = React.createContext(null);
|
|
if (true) {
|
|
DataRouterStateContext.displayName = "DataRouterState";
|
|
}
|
|
var AwaitContext = React.createContext(null);
|
|
if (true) {
|
|
AwaitContext.displayName = "Await";
|
|
}
|
|
var NavigationContext = React.createContext(null);
|
|
if (true) {
|
|
NavigationContext.displayName = "Navigation";
|
|
}
|
|
var LocationContext = React.createContext(null);
|
|
if (true) {
|
|
LocationContext.displayName = "Location";
|
|
}
|
|
var RouteContext = React.createContext({
|
|
outlet: null,
|
|
matches: [],
|
|
isDataRoute: false
|
|
});
|
|
if (true) {
|
|
RouteContext.displayName = "Route";
|
|
}
|
|
var RouteErrorContext = React.createContext(null);
|
|
if (true) {
|
|
RouteErrorContext.displayName = "RouteError";
|
|
}
|
|
function useHref(to, _temp) {
|
|
let {
|
|
relative
|
|
} = _temp === void 0 ? {} : _temp;
|
|
!useInRouterContext() ? true ? invariant(
|
|
false,
|
|
// TODO: This error is probably because they somehow have 2 versions of the
|
|
// router loaded. We can help them understand how to avoid that.
|
|
"useHref() may be used only in the context of a <Router> component."
|
|
) : invariant(false) : void 0;
|
|
let {
|
|
basename,
|
|
navigator
|
|
} = React.useContext(NavigationContext);
|
|
let {
|
|
hash,
|
|
pathname,
|
|
search
|
|
} = useResolvedPath(to, {
|
|
relative
|
|
});
|
|
let joinedPathname = pathname;
|
|
if (basename !== "/") {
|
|
joinedPathname = pathname === "/" ? basename : joinPaths([basename, pathname]);
|
|
}
|
|
return navigator.createHref({
|
|
pathname: joinedPathname,
|
|
search,
|
|
hash
|
|
});
|
|
}
|
|
function useInRouterContext() {
|
|
return React.useContext(LocationContext) != null;
|
|
}
|
|
function useLocation() {
|
|
!useInRouterContext() ? true ? invariant(
|
|
false,
|
|
// TODO: This error is probably because they somehow have 2 versions of the
|
|
// router loaded. We can help them understand how to avoid that.
|
|
"useLocation() may be used only in the context of a <Router> component."
|
|
) : invariant(false) : void 0;
|
|
return React.useContext(LocationContext).location;
|
|
}
|
|
function useNavigationType() {
|
|
return React.useContext(LocationContext).navigationType;
|
|
}
|
|
function useMatch(pattern) {
|
|
!useInRouterContext() ? true ? invariant(
|
|
false,
|
|
// TODO: This error is probably because they somehow have 2 versions of the
|
|
// router loaded. We can help them understand how to avoid that.
|
|
"useMatch() may be used only in the context of a <Router> component."
|
|
) : invariant(false) : void 0;
|
|
let {
|
|
pathname
|
|
} = useLocation();
|
|
return React.useMemo(() => matchPath(pattern, decodePath(pathname)), [pathname, pattern]);
|
|
}
|
|
var navigateEffectWarning = "You should call navigate() in a React.useEffect(), not when your component is first rendered.";
|
|
function useIsomorphicLayoutEffect(cb) {
|
|
let isStatic = React.useContext(NavigationContext).static;
|
|
if (!isStatic) {
|
|
React.useLayoutEffect(cb);
|
|
}
|
|
}
|
|
function useNavigate() {
|
|
let {
|
|
isDataRoute
|
|
} = React.useContext(RouteContext);
|
|
return isDataRoute ? useNavigateStable() : useNavigateUnstable();
|
|
}
|
|
function useNavigateUnstable() {
|
|
!useInRouterContext() ? true ? invariant(
|
|
false,
|
|
// TODO: This error is probably because they somehow have 2 versions of the
|
|
// router loaded. We can help them understand how to avoid that.
|
|
"useNavigate() may be used only in the context of a <Router> component."
|
|
) : invariant(false) : void 0;
|
|
let dataRouterContext = React.useContext(DataRouterContext);
|
|
let {
|
|
basename,
|
|
future,
|
|
navigator
|
|
} = React.useContext(NavigationContext);
|
|
let {
|
|
matches
|
|
} = React.useContext(RouteContext);
|
|
let {
|
|
pathname: locationPathname
|
|
} = useLocation();
|
|
let routePathnamesJson = JSON.stringify(getResolveToMatches(matches, future.v7_relativeSplatPath));
|
|
let activeRef = React.useRef(false);
|
|
useIsomorphicLayoutEffect(() => {
|
|
activeRef.current = true;
|
|
});
|
|
let navigate = React.useCallback(function(to, options) {
|
|
if (options === void 0) {
|
|
options = {};
|
|
}
|
|
true ? warning(activeRef.current, navigateEffectWarning) : void 0;
|
|
if (!activeRef.current) return;
|
|
if (typeof to === "number") {
|
|
navigator.go(to);
|
|
return;
|
|
}
|
|
let path = resolveTo(to, JSON.parse(routePathnamesJson), locationPathname, options.relative === "path");
|
|
if (dataRouterContext == null && basename !== "/") {
|
|
path.pathname = path.pathname === "/" ? basename : joinPaths([basename, path.pathname]);
|
|
}
|
|
(!!options.replace ? navigator.replace : navigator.push)(path, options.state, options);
|
|
}, [basename, navigator, routePathnamesJson, locationPathname, dataRouterContext]);
|
|
return navigate;
|
|
}
|
|
var OutletContext = React.createContext(null);
|
|
function useOutletContext() {
|
|
return React.useContext(OutletContext);
|
|
}
|
|
function useOutlet(context) {
|
|
let outlet = React.useContext(RouteContext).outlet;
|
|
if (outlet) {
|
|
return React.createElement(OutletContext.Provider, {
|
|
value: context
|
|
}, outlet);
|
|
}
|
|
return outlet;
|
|
}
|
|
function useParams() {
|
|
let {
|
|
matches
|
|
} = React.useContext(RouteContext);
|
|
let routeMatch = matches[matches.length - 1];
|
|
return routeMatch ? routeMatch.params : {};
|
|
}
|
|
function useResolvedPath(to, _temp2) {
|
|
let {
|
|
relative
|
|
} = _temp2 === void 0 ? {} : _temp2;
|
|
let {
|
|
future
|
|
} = React.useContext(NavigationContext);
|
|
let {
|
|
matches
|
|
} = React.useContext(RouteContext);
|
|
let {
|
|
pathname: locationPathname
|
|
} = useLocation();
|
|
let routePathnamesJson = JSON.stringify(getResolveToMatches(matches, future.v7_relativeSplatPath));
|
|
return React.useMemo(() => resolveTo(to, JSON.parse(routePathnamesJson), locationPathname, relative === "path"), [to, routePathnamesJson, locationPathname, relative]);
|
|
}
|
|
function useRoutes(routes, locationArg) {
|
|
return useRoutesImpl(routes, locationArg);
|
|
}
|
|
function useRoutesImpl(routes, locationArg, dataRouterState, future) {
|
|
!useInRouterContext() ? true ? invariant(
|
|
false,
|
|
// TODO: This error is probably because they somehow have 2 versions of the
|
|
// router loaded. We can help them understand how to avoid that.
|
|
"useRoutes() may be used only in the context of a <Router> component."
|
|
) : invariant(false) : void 0;
|
|
let {
|
|
navigator
|
|
} = React.useContext(NavigationContext);
|
|
let {
|
|
matches: parentMatches
|
|
} = React.useContext(RouteContext);
|
|
let routeMatch = parentMatches[parentMatches.length - 1];
|
|
let parentParams = routeMatch ? routeMatch.params : {};
|
|
let parentPathname = routeMatch ? routeMatch.pathname : "/";
|
|
let parentPathnameBase = routeMatch ? routeMatch.pathnameBase : "/";
|
|
let parentRoute = routeMatch && routeMatch.route;
|
|
if (true) {
|
|
let parentPath = parentRoute && parentRoute.path || "";
|
|
warningOnce(parentPathname, !parentRoute || parentPath.endsWith("*"), "You rendered descendant <Routes> (or called `useRoutes()`) at " + ('"' + parentPathname + '" (under <Route path="' + parentPath + '">) but the ') + `parent route path has no trailing "*". This means if you navigate deeper, the parent won't match anymore and therefore the child routes will never render.
|
|
|
|
` + ('Please change the parent <Route path="' + parentPath + '"> to <Route ') + ('path="' + (parentPath === "/" ? "*" : parentPath + "/*") + '">.'));
|
|
}
|
|
let locationFromContext = useLocation();
|
|
let location;
|
|
if (locationArg) {
|
|
var _parsedLocationArg$pa;
|
|
let parsedLocationArg = typeof locationArg === "string" ? parsePath(locationArg) : locationArg;
|
|
!(parentPathnameBase === "/" || ((_parsedLocationArg$pa = parsedLocationArg.pathname) == null ? void 0 : _parsedLocationArg$pa.startsWith(parentPathnameBase))) ? true ? invariant(false, "When overriding the location using `<Routes location>` or `useRoutes(routes, location)`, the location pathname must begin with the portion of the URL pathname that was " + ('matched by all parent routes. The current pathname base is "' + parentPathnameBase + '" ') + ('but pathname "' + parsedLocationArg.pathname + '" was given in the `location` prop.')) : invariant(false) : void 0;
|
|
location = parsedLocationArg;
|
|
} else {
|
|
location = locationFromContext;
|
|
}
|
|
let pathname = location.pathname || "/";
|
|
let remainingPathname = pathname;
|
|
if (parentPathnameBase !== "/") {
|
|
let parentSegments = parentPathnameBase.replace(/^\//, "").split("/");
|
|
let segments = pathname.replace(/^\//, "").split("/");
|
|
remainingPathname = "/" + segments.slice(parentSegments.length).join("/");
|
|
}
|
|
let matches = matchRoutes(routes, {
|
|
pathname: remainingPathname
|
|
});
|
|
if (true) {
|
|
true ? warning(parentRoute || matches != null, 'No routes matched location "' + location.pathname + location.search + location.hash + '" ') : void 0;
|
|
true ? warning(matches == null || matches[matches.length - 1].route.element !== void 0 || matches[matches.length - 1].route.Component !== void 0 || matches[matches.length - 1].route.lazy !== void 0, 'Matched leaf route at location "' + location.pathname + location.search + location.hash + '" does not have an element or Component. This means it will render an <Outlet /> with a null value by default resulting in an "empty" page.') : void 0;
|
|
}
|
|
let renderedMatches = _renderMatches(matches && matches.map((match) => Object.assign({}, match, {
|
|
params: Object.assign({}, parentParams, match.params),
|
|
pathname: joinPaths([
|
|
parentPathnameBase,
|
|
// Re-encode pathnames that were decoded inside matchRoutes
|
|
navigator.encodeLocation ? navigator.encodeLocation(match.pathname).pathname : match.pathname
|
|
]),
|
|
pathnameBase: match.pathnameBase === "/" ? parentPathnameBase : joinPaths([
|
|
parentPathnameBase,
|
|
// Re-encode pathnames that were decoded inside matchRoutes
|
|
navigator.encodeLocation ? navigator.encodeLocation(match.pathnameBase).pathname : match.pathnameBase
|
|
])
|
|
})), parentMatches, dataRouterState, future);
|
|
if (locationArg && renderedMatches) {
|
|
return React.createElement(LocationContext.Provider, {
|
|
value: {
|
|
location: _extends2({
|
|
pathname: "/",
|
|
search: "",
|
|
hash: "",
|
|
state: null,
|
|
key: "default"
|
|
}, location),
|
|
navigationType: Action.Pop
|
|
}
|
|
}, renderedMatches);
|
|
}
|
|
return renderedMatches;
|
|
}
|
|
function DefaultErrorComponent() {
|
|
let error = useRouteError();
|
|
let message = isRouteErrorResponse(error) ? error.status + " " + error.statusText : error instanceof Error ? error.message : JSON.stringify(error);
|
|
let stack = error instanceof Error ? error.stack : null;
|
|
let lightgrey = "rgba(200,200,200, 0.5)";
|
|
let preStyles = {
|
|
padding: "0.5rem",
|
|
backgroundColor: lightgrey
|
|
};
|
|
let codeStyles = {
|
|
padding: "2px 4px",
|
|
backgroundColor: lightgrey
|
|
};
|
|
let devInfo = null;
|
|
if (true) {
|
|
console.error("Error handled by React Router default ErrorBoundary:", error);
|
|
devInfo = React.createElement(React.Fragment, null, React.createElement("p", null, "💿 Hey developer 👋"), React.createElement("p", null, "You can provide a way better UX than this when your app throws errors by providing your own ", React.createElement("code", {
|
|
style: codeStyles
|
|
}, "ErrorBoundary"), " or", " ", React.createElement("code", {
|
|
style: codeStyles
|
|
}, "errorElement"), " prop on your route."));
|
|
}
|
|
return React.createElement(React.Fragment, null, React.createElement("h2", null, "Unexpected Application Error!"), React.createElement("h3", {
|
|
style: {
|
|
fontStyle: "italic"
|
|
}
|
|
}, message), stack ? React.createElement("pre", {
|
|
style: preStyles
|
|
}, stack) : null, devInfo);
|
|
}
|
|
var defaultErrorElement = React.createElement(DefaultErrorComponent, null);
|
|
var RenderErrorBoundary = class extends React.Component {
|
|
constructor(props) {
|
|
super(props);
|
|
this.state = {
|
|
location: props.location,
|
|
revalidation: props.revalidation,
|
|
error: props.error
|
|
};
|
|
}
|
|
static getDerivedStateFromError(error) {
|
|
return {
|
|
error
|
|
};
|
|
}
|
|
static getDerivedStateFromProps(props, state) {
|
|
if (state.location !== props.location || state.revalidation !== "idle" && props.revalidation === "idle") {
|
|
return {
|
|
error: props.error,
|
|
location: props.location,
|
|
revalidation: props.revalidation
|
|
};
|
|
}
|
|
return {
|
|
error: props.error !== void 0 ? props.error : state.error,
|
|
location: state.location,
|
|
revalidation: props.revalidation || state.revalidation
|
|
};
|
|
}
|
|
componentDidCatch(error, errorInfo) {
|
|
console.error("React Router caught the following error during render", error, errorInfo);
|
|
}
|
|
render() {
|
|
return this.state.error !== void 0 ? React.createElement(RouteContext.Provider, {
|
|
value: this.props.routeContext
|
|
}, React.createElement(RouteErrorContext.Provider, {
|
|
value: this.state.error,
|
|
children: this.props.component
|
|
})) : this.props.children;
|
|
}
|
|
};
|
|
function RenderedRoute(_ref) {
|
|
let {
|
|
routeContext,
|
|
match,
|
|
children
|
|
} = _ref;
|
|
let dataRouterContext = React.useContext(DataRouterContext);
|
|
if (dataRouterContext && dataRouterContext.static && dataRouterContext.staticContext && (match.route.errorElement || match.route.ErrorBoundary)) {
|
|
dataRouterContext.staticContext._deepestRenderedBoundaryId = match.route.id;
|
|
}
|
|
return React.createElement(RouteContext.Provider, {
|
|
value: routeContext
|
|
}, children);
|
|
}
|
|
function _renderMatches(matches, parentMatches, dataRouterState, future) {
|
|
var _dataRouterState;
|
|
if (parentMatches === void 0) {
|
|
parentMatches = [];
|
|
}
|
|
if (dataRouterState === void 0) {
|
|
dataRouterState = null;
|
|
}
|
|
if (future === void 0) {
|
|
future = null;
|
|
}
|
|
if (matches == null) {
|
|
var _future;
|
|
if (!dataRouterState) {
|
|
return null;
|
|
}
|
|
if (dataRouterState.errors) {
|
|
matches = dataRouterState.matches;
|
|
} else if ((_future = future) != null && _future.v7_partialHydration && parentMatches.length === 0 && !dataRouterState.initialized && dataRouterState.matches.length > 0) {
|
|
matches = dataRouterState.matches;
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
let renderedMatches = matches;
|
|
let errors = (_dataRouterState = dataRouterState) == null ? void 0 : _dataRouterState.errors;
|
|
if (errors != null) {
|
|
let errorIndex = renderedMatches.findIndex((m) => m.route.id && (errors == null ? void 0 : errors[m.route.id]) !== void 0);
|
|
!(errorIndex >= 0) ? true ? invariant(false, "Could not find a matching route for errors on route IDs: " + Object.keys(errors).join(",")) : invariant(false) : void 0;
|
|
renderedMatches = renderedMatches.slice(0, Math.min(renderedMatches.length, errorIndex + 1));
|
|
}
|
|
let renderFallback = false;
|
|
let fallbackIndex = -1;
|
|
if (dataRouterState && future && future.v7_partialHydration) {
|
|
for (let i = 0; i < renderedMatches.length; i++) {
|
|
let match = renderedMatches[i];
|
|
if (match.route.HydrateFallback || match.route.hydrateFallbackElement) {
|
|
fallbackIndex = i;
|
|
}
|
|
if (match.route.id) {
|
|
let {
|
|
loaderData,
|
|
errors: errors2
|
|
} = dataRouterState;
|
|
let needsToRunLoader = match.route.loader && loaderData[match.route.id] === void 0 && (!errors2 || errors2[match.route.id] === void 0);
|
|
if (match.route.lazy || needsToRunLoader) {
|
|
renderFallback = true;
|
|
if (fallbackIndex >= 0) {
|
|
renderedMatches = renderedMatches.slice(0, fallbackIndex + 1);
|
|
} else {
|
|
renderedMatches = [renderedMatches[0]];
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return renderedMatches.reduceRight((outlet, match, index) => {
|
|
let error;
|
|
let shouldRenderHydrateFallback = false;
|
|
let errorElement = null;
|
|
let hydrateFallbackElement = null;
|
|
if (dataRouterState) {
|
|
error = errors && match.route.id ? errors[match.route.id] : void 0;
|
|
errorElement = match.route.errorElement || defaultErrorElement;
|
|
if (renderFallback) {
|
|
if (fallbackIndex < 0 && index === 0) {
|
|
warningOnce("route-fallback", false, "No `HydrateFallback` element provided to render during initial hydration");
|
|
shouldRenderHydrateFallback = true;
|
|
hydrateFallbackElement = null;
|
|
} else if (fallbackIndex === index) {
|
|
shouldRenderHydrateFallback = true;
|
|
hydrateFallbackElement = match.route.hydrateFallbackElement || null;
|
|
}
|
|
}
|
|
}
|
|
let matches2 = parentMatches.concat(renderedMatches.slice(0, index + 1));
|
|
let getChildren = () => {
|
|
let children;
|
|
if (error) {
|
|
children = errorElement;
|
|
} else if (shouldRenderHydrateFallback) {
|
|
children = hydrateFallbackElement;
|
|
} else if (match.route.Component) {
|
|
children = React.createElement(match.route.Component, null);
|
|
} else if (match.route.element) {
|
|
children = match.route.element;
|
|
} else {
|
|
children = outlet;
|
|
}
|
|
return React.createElement(RenderedRoute, {
|
|
match,
|
|
routeContext: {
|
|
outlet,
|
|
matches: matches2,
|
|
isDataRoute: dataRouterState != null
|
|
},
|
|
children
|
|
});
|
|
};
|
|
return dataRouterState && (match.route.ErrorBoundary || match.route.errorElement || index === 0) ? React.createElement(RenderErrorBoundary, {
|
|
location: dataRouterState.location,
|
|
revalidation: dataRouterState.revalidation,
|
|
component: errorElement,
|
|
error,
|
|
children: getChildren(),
|
|
routeContext: {
|
|
outlet: null,
|
|
matches: matches2,
|
|
isDataRoute: true
|
|
}
|
|
}) : getChildren();
|
|
}, null);
|
|
}
|
|
var DataRouterHook = function(DataRouterHook3) {
|
|
DataRouterHook3["UseBlocker"] = "useBlocker";
|
|
DataRouterHook3["UseRevalidator"] = "useRevalidator";
|
|
DataRouterHook3["UseNavigateStable"] = "useNavigate";
|
|
return DataRouterHook3;
|
|
}(DataRouterHook || {});
|
|
var DataRouterStateHook = function(DataRouterStateHook3) {
|
|
DataRouterStateHook3["UseBlocker"] = "useBlocker";
|
|
DataRouterStateHook3["UseLoaderData"] = "useLoaderData";
|
|
DataRouterStateHook3["UseActionData"] = "useActionData";
|
|
DataRouterStateHook3["UseRouteError"] = "useRouteError";
|
|
DataRouterStateHook3["UseNavigation"] = "useNavigation";
|
|
DataRouterStateHook3["UseRouteLoaderData"] = "useRouteLoaderData";
|
|
DataRouterStateHook3["UseMatches"] = "useMatches";
|
|
DataRouterStateHook3["UseRevalidator"] = "useRevalidator";
|
|
DataRouterStateHook3["UseNavigateStable"] = "useNavigate";
|
|
DataRouterStateHook3["UseRouteId"] = "useRouteId";
|
|
return DataRouterStateHook3;
|
|
}(DataRouterStateHook || {});
|
|
function getDataRouterConsoleError(hookName) {
|
|
return hookName + " must be used within a data router. See https://reactrouter.com/v6/routers/picking-a-router.";
|
|
}
|
|
function useDataRouterContext(hookName) {
|
|
let ctx = React.useContext(DataRouterContext);
|
|
!ctx ? true ? invariant(false, getDataRouterConsoleError(hookName)) : invariant(false) : void 0;
|
|
return ctx;
|
|
}
|
|
function useDataRouterState(hookName) {
|
|
let state = React.useContext(DataRouterStateContext);
|
|
!state ? true ? invariant(false, getDataRouterConsoleError(hookName)) : invariant(false) : void 0;
|
|
return state;
|
|
}
|
|
function useRouteContext(hookName) {
|
|
let route = React.useContext(RouteContext);
|
|
!route ? true ? invariant(false, getDataRouterConsoleError(hookName)) : invariant(false) : void 0;
|
|
return route;
|
|
}
|
|
function useCurrentRouteId(hookName) {
|
|
let route = useRouteContext(hookName);
|
|
let thisRoute = route.matches[route.matches.length - 1];
|
|
!thisRoute.route.id ? true ? invariant(false, hookName + ' can only be used on routes that contain a unique "id"') : invariant(false) : void 0;
|
|
return thisRoute.route.id;
|
|
}
|
|
function useRouteId() {
|
|
return useCurrentRouteId(DataRouterStateHook.UseRouteId);
|
|
}
|
|
function useNavigation() {
|
|
let state = useDataRouterState(DataRouterStateHook.UseNavigation);
|
|
return state.navigation;
|
|
}
|
|
function useRevalidator() {
|
|
let dataRouterContext = useDataRouterContext(DataRouterHook.UseRevalidator);
|
|
let state = useDataRouterState(DataRouterStateHook.UseRevalidator);
|
|
return React.useMemo(() => ({
|
|
revalidate: dataRouterContext.router.revalidate,
|
|
state: state.revalidation
|
|
}), [dataRouterContext.router.revalidate, state.revalidation]);
|
|
}
|
|
function useMatches() {
|
|
let {
|
|
matches,
|
|
loaderData
|
|
} = useDataRouterState(DataRouterStateHook.UseMatches);
|
|
return React.useMemo(() => matches.map((m) => convertRouteMatchToUiMatch(m, loaderData)), [matches, loaderData]);
|
|
}
|
|
function useLoaderData() {
|
|
let state = useDataRouterState(DataRouterStateHook.UseLoaderData);
|
|
let routeId = useCurrentRouteId(DataRouterStateHook.UseLoaderData);
|
|
if (state.errors && state.errors[routeId] != null) {
|
|
console.error("You cannot `useLoaderData` in an errorElement (routeId: " + routeId + ")");
|
|
return void 0;
|
|
}
|
|
return state.loaderData[routeId];
|
|
}
|
|
function useRouteLoaderData(routeId) {
|
|
let state = useDataRouterState(DataRouterStateHook.UseRouteLoaderData);
|
|
return state.loaderData[routeId];
|
|
}
|
|
function useActionData() {
|
|
let state = useDataRouterState(DataRouterStateHook.UseActionData);
|
|
let routeId = useCurrentRouteId(DataRouterStateHook.UseLoaderData);
|
|
return state.actionData ? state.actionData[routeId] : void 0;
|
|
}
|
|
function useRouteError() {
|
|
var _state$errors;
|
|
let error = React.useContext(RouteErrorContext);
|
|
let state = useDataRouterState(DataRouterStateHook.UseRouteError);
|
|
let routeId = useCurrentRouteId(DataRouterStateHook.UseRouteError);
|
|
if (error !== void 0) {
|
|
return error;
|
|
}
|
|
return (_state$errors = state.errors) == null ? void 0 : _state$errors[routeId];
|
|
}
|
|
function useAsyncValue() {
|
|
let value = React.useContext(AwaitContext);
|
|
return value == null ? void 0 : value._data;
|
|
}
|
|
function useAsyncError() {
|
|
let value = React.useContext(AwaitContext);
|
|
return value == null ? void 0 : value._error;
|
|
}
|
|
var blockerId = 0;
|
|
function useBlocker(shouldBlock) {
|
|
let {
|
|
router,
|
|
basename
|
|
} = useDataRouterContext(DataRouterHook.UseBlocker);
|
|
let state = useDataRouterState(DataRouterStateHook.UseBlocker);
|
|
let [blockerKey, setBlockerKey] = React.useState("");
|
|
let blockerFunction = React.useCallback((arg) => {
|
|
if (typeof shouldBlock !== "function") {
|
|
return !!shouldBlock;
|
|
}
|
|
if (basename === "/") {
|
|
return shouldBlock(arg);
|
|
}
|
|
let {
|
|
currentLocation,
|
|
nextLocation,
|
|
historyAction
|
|
} = arg;
|
|
return shouldBlock({
|
|
currentLocation: _extends2({}, currentLocation, {
|
|
pathname: stripBasename(currentLocation.pathname, basename) || currentLocation.pathname
|
|
}),
|
|
nextLocation: _extends2({}, nextLocation, {
|
|
pathname: stripBasename(nextLocation.pathname, basename) || nextLocation.pathname
|
|
}),
|
|
historyAction
|
|
});
|
|
}, [basename, shouldBlock]);
|
|
React.useEffect(() => {
|
|
let key = String(++blockerId);
|
|
setBlockerKey(key);
|
|
return () => router.deleteBlocker(key);
|
|
}, [router]);
|
|
React.useEffect(() => {
|
|
if (blockerKey !== "") {
|
|
router.getBlocker(blockerKey, blockerFunction);
|
|
}
|
|
}, [router, blockerKey, blockerFunction]);
|
|
return blockerKey && state.blockers.has(blockerKey) ? state.blockers.get(blockerKey) : IDLE_BLOCKER;
|
|
}
|
|
function useNavigateStable() {
|
|
let {
|
|
router
|
|
} = useDataRouterContext(DataRouterHook.UseNavigateStable);
|
|
let id = useCurrentRouteId(DataRouterStateHook.UseNavigateStable);
|
|
let activeRef = React.useRef(false);
|
|
useIsomorphicLayoutEffect(() => {
|
|
activeRef.current = true;
|
|
});
|
|
let navigate = React.useCallback(function(to, options) {
|
|
if (options === void 0) {
|
|
options = {};
|
|
}
|
|
true ? warning(activeRef.current, navigateEffectWarning) : void 0;
|
|
if (!activeRef.current) return;
|
|
if (typeof to === "number") {
|
|
router.navigate(to);
|
|
} else {
|
|
router.navigate(to, _extends2({
|
|
fromRouteId: id
|
|
}, options));
|
|
}
|
|
}, [router, id]);
|
|
return navigate;
|
|
}
|
|
var alreadyWarned$1 = {};
|
|
function warningOnce(key, cond, message) {
|
|
if (!cond && !alreadyWarned$1[key]) {
|
|
alreadyWarned$1[key] = true;
|
|
true ? warning(false, message) : void 0;
|
|
}
|
|
}
|
|
var alreadyWarned = {};
|
|
function warnOnce(key, message) {
|
|
if (!alreadyWarned[message]) {
|
|
alreadyWarned[message] = true;
|
|
console.warn(message);
|
|
}
|
|
}
|
|
var logDeprecation = (flag, msg, link) => warnOnce(flag, "⚠️ React Router Future Flag Warning: " + msg + ". " + ("You can use the `" + flag + "` future flag to opt-in early. ") + ("For more information, see " + link + "."));
|
|
function logV6DeprecationWarnings(renderFuture, routerFuture) {
|
|
if ((renderFuture == null ? void 0 : renderFuture.v7_startTransition) === void 0) {
|
|
logDeprecation("v7_startTransition", "React Router will begin wrapping state updates in `React.startTransition` in v7", "https://reactrouter.com/v6/upgrading/future#v7_starttransition");
|
|
}
|
|
if ((renderFuture == null ? void 0 : renderFuture.v7_relativeSplatPath) === void 0 && (!routerFuture || !routerFuture.v7_relativeSplatPath)) {
|
|
logDeprecation("v7_relativeSplatPath", "Relative route resolution within Splat routes is changing in v7", "https://reactrouter.com/v6/upgrading/future#v7_relativesplatpath");
|
|
}
|
|
if (routerFuture) {
|
|
if (routerFuture.v7_fetcherPersist === void 0) {
|
|
logDeprecation("v7_fetcherPersist", "The persistence behavior of fetchers is changing in v7", "https://reactrouter.com/v6/upgrading/future#v7_fetcherpersist");
|
|
}
|
|
if (routerFuture.v7_normalizeFormMethod === void 0) {
|
|
logDeprecation("v7_normalizeFormMethod", "Casing of `formMethod` fields is being normalized to uppercase in v7", "https://reactrouter.com/v6/upgrading/future#v7_normalizeformmethod");
|
|
}
|
|
if (routerFuture.v7_partialHydration === void 0) {
|
|
logDeprecation("v7_partialHydration", "`RouterProvider` hydration behavior is changing in v7", "https://reactrouter.com/v6/upgrading/future#v7_partialhydration");
|
|
}
|
|
if (routerFuture.v7_skipActionErrorRevalidation === void 0) {
|
|
logDeprecation("v7_skipActionErrorRevalidation", "The revalidation behavior after 4xx/5xx `action` responses is changing in v7", "https://reactrouter.com/v6/upgrading/future#v7_skipactionerrorrevalidation");
|
|
}
|
|
}
|
|
}
|
|
var START_TRANSITION = "startTransition";
|
|
var startTransitionImpl = React[START_TRANSITION];
|
|
function MemoryRouter(_ref3) {
|
|
let {
|
|
basename,
|
|
children,
|
|
initialEntries,
|
|
initialIndex,
|
|
future
|
|
} = _ref3;
|
|
let historyRef = React.useRef();
|
|
if (historyRef.current == null) {
|
|
historyRef.current = createMemoryHistory({
|
|
initialEntries,
|
|
initialIndex,
|
|
v5Compat: true
|
|
});
|
|
}
|
|
let history = historyRef.current;
|
|
let [state, setStateImpl] = React.useState({
|
|
action: history.action,
|
|
location: history.location
|
|
});
|
|
let {
|
|
v7_startTransition
|
|
} = future || {};
|
|
let setState = React.useCallback((newState) => {
|
|
v7_startTransition && startTransitionImpl ? startTransitionImpl(() => setStateImpl(newState)) : setStateImpl(newState);
|
|
}, [setStateImpl, v7_startTransition]);
|
|
React.useLayoutEffect(() => history.listen(setState), [history, setState]);
|
|
React.useEffect(() => logV6DeprecationWarnings(future), [future]);
|
|
return React.createElement(Router, {
|
|
basename,
|
|
children,
|
|
location: state.location,
|
|
navigationType: state.action,
|
|
navigator: history,
|
|
future
|
|
});
|
|
}
|
|
function Navigate(_ref4) {
|
|
let {
|
|
to,
|
|
replace: replace2,
|
|
state,
|
|
relative
|
|
} = _ref4;
|
|
!useInRouterContext() ? true ? invariant(
|
|
false,
|
|
// TODO: This error is probably because they somehow have 2 versions of
|
|
// the router loaded. We can help them understand how to avoid that.
|
|
"<Navigate> may be used only in the context of a <Router> component."
|
|
) : invariant(false) : void 0;
|
|
let {
|
|
future,
|
|
static: isStatic
|
|
} = React.useContext(NavigationContext);
|
|
true ? warning(!isStatic, "<Navigate> must not be used on the initial render in a <StaticRouter>. This is a no-op, but you should modify your code so the <Navigate> is only ever rendered in response to some user interaction or state change.") : void 0;
|
|
let {
|
|
matches
|
|
} = React.useContext(RouteContext);
|
|
let {
|
|
pathname: locationPathname
|
|
} = useLocation();
|
|
let navigate = useNavigate();
|
|
let path = resolveTo(to, getResolveToMatches(matches, future.v7_relativeSplatPath), locationPathname, relative === "path");
|
|
let jsonPath = JSON.stringify(path);
|
|
React.useEffect(() => navigate(JSON.parse(jsonPath), {
|
|
replace: replace2,
|
|
state,
|
|
relative
|
|
}), [navigate, jsonPath, relative, replace2, state]);
|
|
return null;
|
|
}
|
|
function Outlet(props) {
|
|
return useOutlet(props.context);
|
|
}
|
|
function Route(_props) {
|
|
true ? invariant(false, "A <Route> is only ever to be used as the child of <Routes> element, never rendered directly. Please wrap your <Route> in a <Routes>.") : invariant(false);
|
|
}
|
|
function Router(_ref5) {
|
|
let {
|
|
basename: basenameProp = "/",
|
|
children = null,
|
|
location: locationProp,
|
|
navigationType = Action.Pop,
|
|
navigator,
|
|
static: staticProp = false,
|
|
future
|
|
} = _ref5;
|
|
!!useInRouterContext() ? true ? invariant(false, "You cannot render a <Router> inside another <Router>. You should never have more than one in your app.") : invariant(false) : void 0;
|
|
let basename = basenameProp.replace(/^\/*/, "/");
|
|
let navigationContext = React.useMemo(() => ({
|
|
basename,
|
|
navigator,
|
|
static: staticProp,
|
|
future: _extends2({
|
|
v7_relativeSplatPath: false
|
|
}, future)
|
|
}), [basename, future, navigator, staticProp]);
|
|
if (typeof locationProp === "string") {
|
|
locationProp = parsePath(locationProp);
|
|
}
|
|
let {
|
|
pathname = "/",
|
|
search = "",
|
|
hash = "",
|
|
state = null,
|
|
key = "default"
|
|
} = locationProp;
|
|
let locationContext = React.useMemo(() => {
|
|
let trailingPathname = stripBasename(pathname, basename);
|
|
if (trailingPathname == null) {
|
|
return null;
|
|
}
|
|
return {
|
|
location: {
|
|
pathname: trailingPathname,
|
|
search,
|
|
hash,
|
|
state,
|
|
key
|
|
},
|
|
navigationType
|
|
};
|
|
}, [basename, pathname, search, hash, state, key, navigationType]);
|
|
true ? warning(locationContext != null, '<Router basename="' + basename + '"> is not able to match the URL ' + ('"' + pathname + search + hash + '" because it does not start with the ') + "basename, so the <Router> won't render anything.") : void 0;
|
|
if (locationContext == null) {
|
|
return null;
|
|
}
|
|
return React.createElement(NavigationContext.Provider, {
|
|
value: navigationContext
|
|
}, React.createElement(LocationContext.Provider, {
|
|
children,
|
|
value: locationContext
|
|
}));
|
|
}
|
|
function Routes(_ref6) {
|
|
let {
|
|
children,
|
|
location
|
|
} = _ref6;
|
|
return useRoutes(createRoutesFromChildren(children), location);
|
|
}
|
|
function Await(_ref7) {
|
|
let {
|
|
children,
|
|
errorElement,
|
|
resolve
|
|
} = _ref7;
|
|
return React.createElement(AwaitErrorBoundary, {
|
|
resolve,
|
|
errorElement
|
|
}, React.createElement(ResolveAwait, null, children));
|
|
}
|
|
var AwaitRenderStatus = function(AwaitRenderStatus2) {
|
|
AwaitRenderStatus2[AwaitRenderStatus2["pending"] = 0] = "pending";
|
|
AwaitRenderStatus2[AwaitRenderStatus2["success"] = 1] = "success";
|
|
AwaitRenderStatus2[AwaitRenderStatus2["error"] = 2] = "error";
|
|
return AwaitRenderStatus2;
|
|
}(AwaitRenderStatus || {});
|
|
var neverSettledPromise = new Promise(() => {
|
|
});
|
|
var AwaitErrorBoundary = class extends React.Component {
|
|
constructor(props) {
|
|
super(props);
|
|
this.state = {
|
|
error: null
|
|
};
|
|
}
|
|
static getDerivedStateFromError(error) {
|
|
return {
|
|
error
|
|
};
|
|
}
|
|
componentDidCatch(error, errorInfo) {
|
|
console.error("<Await> caught the following error during render", error, errorInfo);
|
|
}
|
|
render() {
|
|
let {
|
|
children,
|
|
errorElement,
|
|
resolve
|
|
} = this.props;
|
|
let promise = null;
|
|
let status = AwaitRenderStatus.pending;
|
|
if (!(resolve instanceof Promise)) {
|
|
status = AwaitRenderStatus.success;
|
|
promise = Promise.resolve();
|
|
Object.defineProperty(promise, "_tracked", {
|
|
get: () => true
|
|
});
|
|
Object.defineProperty(promise, "_data", {
|
|
get: () => resolve
|
|
});
|
|
} else if (this.state.error) {
|
|
status = AwaitRenderStatus.error;
|
|
let renderError = this.state.error;
|
|
promise = Promise.reject().catch(() => {
|
|
});
|
|
Object.defineProperty(promise, "_tracked", {
|
|
get: () => true
|
|
});
|
|
Object.defineProperty(promise, "_error", {
|
|
get: () => renderError
|
|
});
|
|
} else if (resolve._tracked) {
|
|
promise = resolve;
|
|
status = "_error" in promise ? AwaitRenderStatus.error : "_data" in promise ? AwaitRenderStatus.success : AwaitRenderStatus.pending;
|
|
} else {
|
|
status = AwaitRenderStatus.pending;
|
|
Object.defineProperty(resolve, "_tracked", {
|
|
get: () => true
|
|
});
|
|
promise = resolve.then((data) => Object.defineProperty(resolve, "_data", {
|
|
get: () => data
|
|
}), (error) => Object.defineProperty(resolve, "_error", {
|
|
get: () => error
|
|
}));
|
|
}
|
|
if (status === AwaitRenderStatus.error && promise._error instanceof AbortedDeferredError) {
|
|
throw neverSettledPromise;
|
|
}
|
|
if (status === AwaitRenderStatus.error && !errorElement) {
|
|
throw promise._error;
|
|
}
|
|
if (status === AwaitRenderStatus.error) {
|
|
return React.createElement(AwaitContext.Provider, {
|
|
value: promise,
|
|
children: errorElement
|
|
});
|
|
}
|
|
if (status === AwaitRenderStatus.success) {
|
|
return React.createElement(AwaitContext.Provider, {
|
|
value: promise,
|
|
children
|
|
});
|
|
}
|
|
throw promise;
|
|
}
|
|
};
|
|
function ResolveAwait(_ref8) {
|
|
let {
|
|
children
|
|
} = _ref8;
|
|
let data = useAsyncValue();
|
|
let toRender = typeof children === "function" ? children(data) : children;
|
|
return React.createElement(React.Fragment, null, toRender);
|
|
}
|
|
function createRoutesFromChildren(children, parentPath) {
|
|
if (parentPath === void 0) {
|
|
parentPath = [];
|
|
}
|
|
let routes = [];
|
|
React.Children.forEach(children, (element, index) => {
|
|
if (!React.isValidElement(element)) {
|
|
return;
|
|
}
|
|
let treePath = [...parentPath, index];
|
|
if (element.type === React.Fragment) {
|
|
routes.push.apply(routes, createRoutesFromChildren(element.props.children, treePath));
|
|
return;
|
|
}
|
|
!(element.type === Route) ? true ? invariant(false, "[" + (typeof element.type === "string" ? element.type : element.type.name) + "] is not a <Route> component. All component children of <Routes> must be a <Route> or <React.Fragment>") : invariant(false) : void 0;
|
|
!(!element.props.index || !element.props.children) ? true ? invariant(false, "An index route cannot have child routes.") : invariant(false) : void 0;
|
|
let route = {
|
|
id: element.props.id || treePath.join("-"),
|
|
caseSensitive: element.props.caseSensitive,
|
|
element: element.props.element,
|
|
Component: element.props.Component,
|
|
index: element.props.index,
|
|
path: element.props.path,
|
|
loader: element.props.loader,
|
|
action: element.props.action,
|
|
errorElement: element.props.errorElement,
|
|
ErrorBoundary: element.props.ErrorBoundary,
|
|
hasErrorBoundary: element.props.ErrorBoundary != null || element.props.errorElement != null,
|
|
shouldRevalidate: element.props.shouldRevalidate,
|
|
handle: element.props.handle,
|
|
lazy: element.props.lazy
|
|
};
|
|
if (element.props.children) {
|
|
route.children = createRoutesFromChildren(element.props.children, treePath);
|
|
}
|
|
routes.push(route);
|
|
});
|
|
return routes;
|
|
}
|
|
function renderMatches(matches) {
|
|
return _renderMatches(matches);
|
|
}
|
|
function mapRouteProperties(route) {
|
|
let updates = {
|
|
// Note: this check also occurs in createRoutesFromChildren so update
|
|
// there if you change this -- please and thank you!
|
|
hasErrorBoundary: route.ErrorBoundary != null || route.errorElement != null
|
|
};
|
|
if (route.Component) {
|
|
if (true) {
|
|
if (route.element) {
|
|
true ? warning(false, "You should not include both `Component` and `element` on your route - `Component` will be used.") : void 0;
|
|
}
|
|
}
|
|
Object.assign(updates, {
|
|
element: React.createElement(route.Component),
|
|
Component: void 0
|
|
});
|
|
}
|
|
if (route.HydrateFallback) {
|
|
if (true) {
|
|
if (route.hydrateFallbackElement) {
|
|
true ? warning(false, "You should not include both `HydrateFallback` and `hydrateFallbackElement` on your route - `HydrateFallback` will be used.") : void 0;
|
|
}
|
|
}
|
|
Object.assign(updates, {
|
|
hydrateFallbackElement: React.createElement(route.HydrateFallback),
|
|
HydrateFallback: void 0
|
|
});
|
|
}
|
|
if (route.ErrorBoundary) {
|
|
if (true) {
|
|
if (route.errorElement) {
|
|
true ? warning(false, "You should not include both `ErrorBoundary` and `errorElement` on your route - `ErrorBoundary` will be used.") : void 0;
|
|
}
|
|
}
|
|
Object.assign(updates, {
|
|
errorElement: React.createElement(route.ErrorBoundary),
|
|
ErrorBoundary: void 0
|
|
});
|
|
}
|
|
return updates;
|
|
}
|
|
function createMemoryRouter(routes, opts) {
|
|
return createRouter({
|
|
basename: opts == null ? void 0 : opts.basename,
|
|
future: _extends2({}, opts == null ? void 0 : opts.future, {
|
|
v7_prependBasename: true
|
|
}),
|
|
history: createMemoryHistory({
|
|
initialEntries: opts == null ? void 0 : opts.initialEntries,
|
|
initialIndex: opts == null ? void 0 : opts.initialIndex
|
|
}),
|
|
hydrationData: opts == null ? void 0 : opts.hydrationData,
|
|
routes,
|
|
mapRouteProperties,
|
|
dataStrategy: opts == null ? void 0 : opts.dataStrategy,
|
|
patchRoutesOnNavigation: opts == null ? void 0 : opts.patchRoutesOnNavigation
|
|
}).initialize();
|
|
}
|
|
|
|
// node_modules/.pnpm/react-router-dom@6.28.1_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/react-router-dom/dist/index.js
|
|
function _extends3() {
|
|
_extends3 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var key in source) {
|
|
if (Object.prototype.hasOwnProperty.call(source, key)) {
|
|
target[key] = source[key];
|
|
}
|
|
}
|
|
}
|
|
return target;
|
|
};
|
|
return _extends3.apply(this, arguments);
|
|
}
|
|
function _objectWithoutPropertiesLoose(source, excluded) {
|
|
if (source == null) return {};
|
|
var target = {};
|
|
var sourceKeys = Object.keys(source);
|
|
var key, i;
|
|
for (i = 0; i < sourceKeys.length; i++) {
|
|
key = sourceKeys[i];
|
|
if (excluded.indexOf(key) >= 0) continue;
|
|
target[key] = source[key];
|
|
}
|
|
return target;
|
|
}
|
|
var defaultMethod = "get";
|
|
var defaultEncType = "application/x-www-form-urlencoded";
|
|
function isHtmlElement(object) {
|
|
return object != null && typeof object.tagName === "string";
|
|
}
|
|
function isButtonElement(object) {
|
|
return isHtmlElement(object) && object.tagName.toLowerCase() === "button";
|
|
}
|
|
function isFormElement(object) {
|
|
return isHtmlElement(object) && object.tagName.toLowerCase() === "form";
|
|
}
|
|
function isInputElement(object) {
|
|
return isHtmlElement(object) && object.tagName.toLowerCase() === "input";
|
|
}
|
|
function isModifiedEvent(event) {
|
|
return !!(event.metaKey || event.altKey || event.ctrlKey || event.shiftKey);
|
|
}
|
|
function shouldProcessLinkClick(event, target) {
|
|
return event.button === 0 && // Ignore everything but left clicks
|
|
(!target || target === "_self") && // Let browser handle "target=_blank" etc.
|
|
!isModifiedEvent(event);
|
|
}
|
|
function createSearchParams(init) {
|
|
if (init === void 0) {
|
|
init = "";
|
|
}
|
|
return new URLSearchParams(typeof init === "string" || Array.isArray(init) || init instanceof URLSearchParams ? init : Object.keys(init).reduce((memo2, key) => {
|
|
let value = init[key];
|
|
return memo2.concat(Array.isArray(value) ? value.map((v) => [key, v]) : [[key, value]]);
|
|
}, []));
|
|
}
|
|
function getSearchParamsForLocation(locationSearch, defaultSearchParams) {
|
|
let searchParams = createSearchParams(locationSearch);
|
|
if (defaultSearchParams) {
|
|
defaultSearchParams.forEach((_, key) => {
|
|
if (!searchParams.has(key)) {
|
|
defaultSearchParams.getAll(key).forEach((value) => {
|
|
searchParams.append(key, value);
|
|
});
|
|
}
|
|
});
|
|
}
|
|
return searchParams;
|
|
}
|
|
var _formDataSupportsSubmitter = null;
|
|
function isFormDataSubmitterSupported() {
|
|
if (_formDataSupportsSubmitter === null) {
|
|
try {
|
|
new FormData(
|
|
document.createElement("form"),
|
|
// @ts-expect-error if FormData supports the submitter parameter, this will throw
|
|
0
|
|
);
|
|
_formDataSupportsSubmitter = false;
|
|
} catch (e) {
|
|
_formDataSupportsSubmitter = true;
|
|
}
|
|
}
|
|
return _formDataSupportsSubmitter;
|
|
}
|
|
var supportedFormEncTypes = /* @__PURE__ */ new Set(["application/x-www-form-urlencoded", "multipart/form-data", "text/plain"]);
|
|
function getFormEncType(encType) {
|
|
if (encType != null && !supportedFormEncTypes.has(encType)) {
|
|
true ? warning(false, '"' + encType + '" is not a valid `encType` for `<Form>`/`<fetcher.Form>` ' + ('and will default to "' + defaultEncType + '"')) : void 0;
|
|
return null;
|
|
}
|
|
return encType;
|
|
}
|
|
function getFormSubmissionInfo(target, basename) {
|
|
let method;
|
|
let action;
|
|
let encType;
|
|
let formData;
|
|
let body;
|
|
if (isFormElement(target)) {
|
|
let attr = target.getAttribute("action");
|
|
action = attr ? stripBasename(attr, basename) : null;
|
|
method = target.getAttribute("method") || defaultMethod;
|
|
encType = getFormEncType(target.getAttribute("enctype")) || defaultEncType;
|
|
formData = new FormData(target);
|
|
} else if (isButtonElement(target) || isInputElement(target) && (target.type === "submit" || target.type === "image")) {
|
|
let form = target.form;
|
|
if (form == null) {
|
|
throw new Error('Cannot submit a <button> or <input type="submit"> without a <form>');
|
|
}
|
|
let attr = target.getAttribute("formaction") || form.getAttribute("action");
|
|
action = attr ? stripBasename(attr, basename) : null;
|
|
method = target.getAttribute("formmethod") || form.getAttribute("method") || defaultMethod;
|
|
encType = getFormEncType(target.getAttribute("formenctype")) || getFormEncType(form.getAttribute("enctype")) || defaultEncType;
|
|
formData = new FormData(form, target);
|
|
if (!isFormDataSubmitterSupported()) {
|
|
let {
|
|
name,
|
|
type,
|
|
value
|
|
} = target;
|
|
if (type === "image") {
|
|
let prefix = name ? name + "." : "";
|
|
formData.append(prefix + "x", "0");
|
|
formData.append(prefix + "y", "0");
|
|
} else if (name) {
|
|
formData.append(name, value);
|
|
}
|
|
}
|
|
} else if (isHtmlElement(target)) {
|
|
throw new Error('Cannot submit element that is not <form>, <button>, or <input type="submit|image">');
|
|
} else {
|
|
method = defaultMethod;
|
|
action = null;
|
|
encType = defaultEncType;
|
|
body = target;
|
|
}
|
|
if (formData && encType === "text/plain") {
|
|
body = formData;
|
|
formData = void 0;
|
|
}
|
|
return {
|
|
action,
|
|
method: method.toLowerCase(),
|
|
encType,
|
|
formData,
|
|
body
|
|
};
|
|
}
|
|
var _excluded = ["onClick", "relative", "reloadDocument", "replace", "state", "target", "to", "preventScrollReset", "viewTransition"];
|
|
var _excluded2 = ["aria-current", "caseSensitive", "className", "end", "style", "to", "viewTransition", "children"];
|
|
var _excluded3 = ["fetcherKey", "navigate", "reloadDocument", "replace", "state", "method", "action", "onSubmit", "relative", "preventScrollReset", "viewTransition"];
|
|
var REACT_ROUTER_VERSION = "6";
|
|
try {
|
|
window.__reactRouterVersion = REACT_ROUTER_VERSION;
|
|
} catch (e) {
|
|
}
|
|
function createBrowserRouter(routes, opts) {
|
|
return createRouter({
|
|
basename: opts == null ? void 0 : opts.basename,
|
|
future: _extends3({}, opts == null ? void 0 : opts.future, {
|
|
v7_prependBasename: true
|
|
}),
|
|
history: createBrowserHistory({
|
|
window: opts == null ? void 0 : opts.window
|
|
}),
|
|
hydrationData: (opts == null ? void 0 : opts.hydrationData) || parseHydrationData(),
|
|
routes,
|
|
mapRouteProperties,
|
|
dataStrategy: opts == null ? void 0 : opts.dataStrategy,
|
|
patchRoutesOnNavigation: opts == null ? void 0 : opts.patchRoutesOnNavigation,
|
|
window: opts == null ? void 0 : opts.window
|
|
}).initialize();
|
|
}
|
|
function createHashRouter(routes, opts) {
|
|
return createRouter({
|
|
basename: opts == null ? void 0 : opts.basename,
|
|
future: _extends3({}, opts == null ? void 0 : opts.future, {
|
|
v7_prependBasename: true
|
|
}),
|
|
history: createHashHistory({
|
|
window: opts == null ? void 0 : opts.window
|
|
}),
|
|
hydrationData: (opts == null ? void 0 : opts.hydrationData) || parseHydrationData(),
|
|
routes,
|
|
mapRouteProperties,
|
|
dataStrategy: opts == null ? void 0 : opts.dataStrategy,
|
|
patchRoutesOnNavigation: opts == null ? void 0 : opts.patchRoutesOnNavigation,
|
|
window: opts == null ? void 0 : opts.window
|
|
}).initialize();
|
|
}
|
|
function parseHydrationData() {
|
|
var _window;
|
|
let state = (_window = window) == null ? void 0 : _window.__staticRouterHydrationData;
|
|
if (state && state.errors) {
|
|
state = _extends3({}, state, {
|
|
errors: deserializeErrors(state.errors)
|
|
});
|
|
}
|
|
return state;
|
|
}
|
|
function deserializeErrors(errors) {
|
|
if (!errors) return null;
|
|
let entries = Object.entries(errors);
|
|
let serialized = {};
|
|
for (let [key, val] of entries) {
|
|
if (val && val.__type === "RouteErrorResponse") {
|
|
serialized[key] = new ErrorResponseImpl(val.status, val.statusText, val.data, val.internal === true);
|
|
} else if (val && val.__type === "Error") {
|
|
if (val.__subType) {
|
|
let ErrorConstructor = window[val.__subType];
|
|
if (typeof ErrorConstructor === "function") {
|
|
try {
|
|
let error = new ErrorConstructor(val.message);
|
|
error.stack = "";
|
|
serialized[key] = error;
|
|
} catch (e) {
|
|
}
|
|
}
|
|
}
|
|
if (serialized[key] == null) {
|
|
let error = new Error(val.message);
|
|
error.stack = "";
|
|
serialized[key] = error;
|
|
}
|
|
} else {
|
|
serialized[key] = val;
|
|
}
|
|
}
|
|
return serialized;
|
|
}
|
|
var ViewTransitionContext = React2.createContext({
|
|
isTransitioning: false
|
|
});
|
|
if (true) {
|
|
ViewTransitionContext.displayName = "ViewTransition";
|
|
}
|
|
var FetchersContext = React2.createContext(/* @__PURE__ */ new Map());
|
|
if (true) {
|
|
FetchersContext.displayName = "Fetchers";
|
|
}
|
|
var START_TRANSITION2 = "startTransition";
|
|
var startTransitionImpl2 = React2[START_TRANSITION2];
|
|
var FLUSH_SYNC = "flushSync";
|
|
var flushSyncImpl = ReactDOM[FLUSH_SYNC];
|
|
var USE_ID = "useId";
|
|
var useIdImpl = React2[USE_ID];
|
|
function startTransitionSafe(cb) {
|
|
if (startTransitionImpl2) {
|
|
startTransitionImpl2(cb);
|
|
} else {
|
|
cb();
|
|
}
|
|
}
|
|
function flushSyncSafe(cb) {
|
|
if (flushSyncImpl) {
|
|
flushSyncImpl(cb);
|
|
} else {
|
|
cb();
|
|
}
|
|
}
|
|
var Deferred = class {
|
|
constructor() {
|
|
this.status = "pending";
|
|
this.promise = new Promise((resolve, reject) => {
|
|
this.resolve = (value) => {
|
|
if (this.status === "pending") {
|
|
this.status = "resolved";
|
|
resolve(value);
|
|
}
|
|
};
|
|
this.reject = (reason) => {
|
|
if (this.status === "pending") {
|
|
this.status = "rejected";
|
|
reject(reason);
|
|
}
|
|
};
|
|
});
|
|
}
|
|
};
|
|
function RouterProvider(_ref) {
|
|
let {
|
|
fallbackElement,
|
|
router,
|
|
future
|
|
} = _ref;
|
|
let [state, setStateImpl] = React2.useState(router.state);
|
|
let [pendingState, setPendingState] = React2.useState();
|
|
let [vtContext, setVtContext] = React2.useState({
|
|
isTransitioning: false
|
|
});
|
|
let [renderDfd, setRenderDfd] = React2.useState();
|
|
let [transition, setTransition] = React2.useState();
|
|
let [interruption, setInterruption] = React2.useState();
|
|
let fetcherData = React2.useRef(/* @__PURE__ */ new Map());
|
|
let {
|
|
v7_startTransition
|
|
} = future || {};
|
|
let optInStartTransition = React2.useCallback((cb) => {
|
|
if (v7_startTransition) {
|
|
startTransitionSafe(cb);
|
|
} else {
|
|
cb();
|
|
}
|
|
}, [v7_startTransition]);
|
|
let setState = React2.useCallback((newState, _ref2) => {
|
|
let {
|
|
deletedFetchers,
|
|
flushSync,
|
|
viewTransitionOpts
|
|
} = _ref2;
|
|
deletedFetchers.forEach((key) => fetcherData.current.delete(key));
|
|
newState.fetchers.forEach((fetcher, key) => {
|
|
if (fetcher.data !== void 0) {
|
|
fetcherData.current.set(key, fetcher.data);
|
|
}
|
|
});
|
|
let isViewTransitionUnavailable = router.window == null || router.window.document == null || typeof router.window.document.startViewTransition !== "function";
|
|
if (!viewTransitionOpts || isViewTransitionUnavailable) {
|
|
if (flushSync) {
|
|
flushSyncSafe(() => setStateImpl(newState));
|
|
} else {
|
|
optInStartTransition(() => setStateImpl(newState));
|
|
}
|
|
return;
|
|
}
|
|
if (flushSync) {
|
|
flushSyncSafe(() => {
|
|
if (transition) {
|
|
renderDfd && renderDfd.resolve();
|
|
transition.skipTransition();
|
|
}
|
|
setVtContext({
|
|
isTransitioning: true,
|
|
flushSync: true,
|
|
currentLocation: viewTransitionOpts.currentLocation,
|
|
nextLocation: viewTransitionOpts.nextLocation
|
|
});
|
|
});
|
|
let t = router.window.document.startViewTransition(() => {
|
|
flushSyncSafe(() => setStateImpl(newState));
|
|
});
|
|
t.finished.finally(() => {
|
|
flushSyncSafe(() => {
|
|
setRenderDfd(void 0);
|
|
setTransition(void 0);
|
|
setPendingState(void 0);
|
|
setVtContext({
|
|
isTransitioning: false
|
|
});
|
|
});
|
|
});
|
|
flushSyncSafe(() => setTransition(t));
|
|
return;
|
|
}
|
|
if (transition) {
|
|
renderDfd && renderDfd.resolve();
|
|
transition.skipTransition();
|
|
setInterruption({
|
|
state: newState,
|
|
currentLocation: viewTransitionOpts.currentLocation,
|
|
nextLocation: viewTransitionOpts.nextLocation
|
|
});
|
|
} else {
|
|
setPendingState(newState);
|
|
setVtContext({
|
|
isTransitioning: true,
|
|
flushSync: false,
|
|
currentLocation: viewTransitionOpts.currentLocation,
|
|
nextLocation: viewTransitionOpts.nextLocation
|
|
});
|
|
}
|
|
}, [router.window, transition, renderDfd, fetcherData, optInStartTransition]);
|
|
React2.useLayoutEffect(() => router.subscribe(setState), [router, setState]);
|
|
React2.useEffect(() => {
|
|
if (vtContext.isTransitioning && !vtContext.flushSync) {
|
|
setRenderDfd(new Deferred());
|
|
}
|
|
}, [vtContext]);
|
|
React2.useEffect(() => {
|
|
if (renderDfd && pendingState && router.window) {
|
|
let newState = pendingState;
|
|
let renderPromise = renderDfd.promise;
|
|
let transition2 = router.window.document.startViewTransition(async () => {
|
|
optInStartTransition(() => setStateImpl(newState));
|
|
await renderPromise;
|
|
});
|
|
transition2.finished.finally(() => {
|
|
setRenderDfd(void 0);
|
|
setTransition(void 0);
|
|
setPendingState(void 0);
|
|
setVtContext({
|
|
isTransitioning: false
|
|
});
|
|
});
|
|
setTransition(transition2);
|
|
}
|
|
}, [optInStartTransition, pendingState, renderDfd, router.window]);
|
|
React2.useEffect(() => {
|
|
if (renderDfd && pendingState && state.location.key === pendingState.location.key) {
|
|
renderDfd.resolve();
|
|
}
|
|
}, [renderDfd, transition, state.location, pendingState]);
|
|
React2.useEffect(() => {
|
|
if (!vtContext.isTransitioning && interruption) {
|
|
setPendingState(interruption.state);
|
|
setVtContext({
|
|
isTransitioning: true,
|
|
flushSync: false,
|
|
currentLocation: interruption.currentLocation,
|
|
nextLocation: interruption.nextLocation
|
|
});
|
|
setInterruption(void 0);
|
|
}
|
|
}, [vtContext.isTransitioning, interruption]);
|
|
React2.useEffect(() => {
|
|
true ? warning(fallbackElement == null || !router.future.v7_partialHydration, "`<RouterProvider fallbackElement>` is deprecated when using `v7_partialHydration`, use a `HydrateFallback` component instead") : void 0;
|
|
}, []);
|
|
let navigator = React2.useMemo(() => {
|
|
return {
|
|
createHref: router.createHref,
|
|
encodeLocation: router.encodeLocation,
|
|
go: (n) => router.navigate(n),
|
|
push: (to, state2, opts) => router.navigate(to, {
|
|
state: state2,
|
|
preventScrollReset: opts == null ? void 0 : opts.preventScrollReset
|
|
}),
|
|
replace: (to, state2, opts) => router.navigate(to, {
|
|
replace: true,
|
|
state: state2,
|
|
preventScrollReset: opts == null ? void 0 : opts.preventScrollReset
|
|
})
|
|
};
|
|
}, [router]);
|
|
let basename = router.basename || "/";
|
|
let dataRouterContext = React2.useMemo(() => ({
|
|
router,
|
|
navigator,
|
|
static: false,
|
|
basename
|
|
}), [router, navigator, basename]);
|
|
let routerFuture = React2.useMemo(() => ({
|
|
v7_relativeSplatPath: router.future.v7_relativeSplatPath
|
|
}), [router.future.v7_relativeSplatPath]);
|
|
React2.useEffect(() => logV6DeprecationWarnings(future, router.future), [future, router.future]);
|
|
return React2.createElement(React2.Fragment, null, React2.createElement(DataRouterContext.Provider, {
|
|
value: dataRouterContext
|
|
}, React2.createElement(DataRouterStateContext.Provider, {
|
|
value: state
|
|
}, React2.createElement(FetchersContext.Provider, {
|
|
value: fetcherData.current
|
|
}, React2.createElement(ViewTransitionContext.Provider, {
|
|
value: vtContext
|
|
}, React2.createElement(Router, {
|
|
basename,
|
|
location: state.location,
|
|
navigationType: state.historyAction,
|
|
navigator,
|
|
future: routerFuture
|
|
}, state.initialized || router.future.v7_partialHydration ? React2.createElement(MemoizedDataRoutes, {
|
|
routes: router.routes,
|
|
future: router.future,
|
|
state
|
|
}) : fallbackElement))))), null);
|
|
}
|
|
var MemoizedDataRoutes = React2.memo(DataRoutes);
|
|
function DataRoutes(_ref3) {
|
|
let {
|
|
routes,
|
|
future,
|
|
state
|
|
} = _ref3;
|
|
return useRoutesImpl(routes, void 0, state, future);
|
|
}
|
|
function BrowserRouter(_ref4) {
|
|
let {
|
|
basename,
|
|
children,
|
|
future,
|
|
window: window2
|
|
} = _ref4;
|
|
let historyRef = React2.useRef();
|
|
if (historyRef.current == null) {
|
|
historyRef.current = createBrowserHistory({
|
|
window: window2,
|
|
v5Compat: true
|
|
});
|
|
}
|
|
let history = historyRef.current;
|
|
let [state, setStateImpl] = React2.useState({
|
|
action: history.action,
|
|
location: history.location
|
|
});
|
|
let {
|
|
v7_startTransition
|
|
} = future || {};
|
|
let setState = React2.useCallback((newState) => {
|
|
v7_startTransition && startTransitionImpl2 ? startTransitionImpl2(() => setStateImpl(newState)) : setStateImpl(newState);
|
|
}, [setStateImpl, v7_startTransition]);
|
|
React2.useLayoutEffect(() => history.listen(setState), [history, setState]);
|
|
React2.useEffect(() => logV6DeprecationWarnings(future), [future]);
|
|
return React2.createElement(Router, {
|
|
basename,
|
|
children,
|
|
location: state.location,
|
|
navigationType: state.action,
|
|
navigator: history,
|
|
future
|
|
});
|
|
}
|
|
function HashRouter(_ref5) {
|
|
let {
|
|
basename,
|
|
children,
|
|
future,
|
|
window: window2
|
|
} = _ref5;
|
|
let historyRef = React2.useRef();
|
|
if (historyRef.current == null) {
|
|
historyRef.current = createHashHistory({
|
|
window: window2,
|
|
v5Compat: true
|
|
});
|
|
}
|
|
let history = historyRef.current;
|
|
let [state, setStateImpl] = React2.useState({
|
|
action: history.action,
|
|
location: history.location
|
|
});
|
|
let {
|
|
v7_startTransition
|
|
} = future || {};
|
|
let setState = React2.useCallback((newState) => {
|
|
v7_startTransition && startTransitionImpl2 ? startTransitionImpl2(() => setStateImpl(newState)) : setStateImpl(newState);
|
|
}, [setStateImpl, v7_startTransition]);
|
|
React2.useLayoutEffect(() => history.listen(setState), [history, setState]);
|
|
React2.useEffect(() => logV6DeprecationWarnings(future), [future]);
|
|
return React2.createElement(Router, {
|
|
basename,
|
|
children,
|
|
location: state.location,
|
|
navigationType: state.action,
|
|
navigator: history,
|
|
future
|
|
});
|
|
}
|
|
function HistoryRouter(_ref6) {
|
|
let {
|
|
basename,
|
|
children,
|
|
future,
|
|
history
|
|
} = _ref6;
|
|
let [state, setStateImpl] = React2.useState({
|
|
action: history.action,
|
|
location: history.location
|
|
});
|
|
let {
|
|
v7_startTransition
|
|
} = future || {};
|
|
let setState = React2.useCallback((newState) => {
|
|
v7_startTransition && startTransitionImpl2 ? startTransitionImpl2(() => setStateImpl(newState)) : setStateImpl(newState);
|
|
}, [setStateImpl, v7_startTransition]);
|
|
React2.useLayoutEffect(() => history.listen(setState), [history, setState]);
|
|
React2.useEffect(() => logV6DeprecationWarnings(future), [future]);
|
|
return React2.createElement(Router, {
|
|
basename,
|
|
children,
|
|
location: state.location,
|
|
navigationType: state.action,
|
|
navigator: history,
|
|
future
|
|
});
|
|
}
|
|
if (true) {
|
|
HistoryRouter.displayName = "unstable_HistoryRouter";
|
|
}
|
|
var isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined";
|
|
var ABSOLUTE_URL_REGEX2 = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
|
|
var Link = React2.forwardRef(function LinkWithRef(_ref7, ref) {
|
|
let {
|
|
onClick,
|
|
relative,
|
|
reloadDocument,
|
|
replace: replace2,
|
|
state,
|
|
target,
|
|
to,
|
|
preventScrollReset,
|
|
viewTransition
|
|
} = _ref7, rest = _objectWithoutPropertiesLoose(_ref7, _excluded);
|
|
let {
|
|
basename
|
|
} = React2.useContext(NavigationContext);
|
|
let absoluteHref;
|
|
let isExternal = false;
|
|
if (typeof to === "string" && ABSOLUTE_URL_REGEX2.test(to)) {
|
|
absoluteHref = to;
|
|
if (isBrowser) {
|
|
try {
|
|
let currentUrl = new URL(window.location.href);
|
|
let targetUrl = to.startsWith("//") ? new URL(currentUrl.protocol + to) : new URL(to);
|
|
let path = stripBasename(targetUrl.pathname, basename);
|
|
if (targetUrl.origin === currentUrl.origin && path != null) {
|
|
to = path + targetUrl.search + targetUrl.hash;
|
|
} else {
|
|
isExternal = true;
|
|
}
|
|
} catch (e) {
|
|
true ? warning(false, '<Link to="' + to + '"> contains an invalid URL which will probably break when clicked - please update to a valid URL path.') : void 0;
|
|
}
|
|
}
|
|
}
|
|
let href = useHref(to, {
|
|
relative
|
|
});
|
|
let internalOnClick = useLinkClickHandler(to, {
|
|
replace: replace2,
|
|
state,
|
|
target,
|
|
preventScrollReset,
|
|
relative,
|
|
viewTransition
|
|
});
|
|
function handleClick(event) {
|
|
if (onClick) onClick(event);
|
|
if (!event.defaultPrevented) {
|
|
internalOnClick(event);
|
|
}
|
|
}
|
|
return (
|
|
// eslint-disable-next-line jsx-a11y/anchor-has-content
|
|
React2.createElement("a", _extends3({}, rest, {
|
|
href: absoluteHref || href,
|
|
onClick: isExternal || reloadDocument ? onClick : handleClick,
|
|
ref,
|
|
target
|
|
}))
|
|
);
|
|
});
|
|
if (true) {
|
|
Link.displayName = "Link";
|
|
}
|
|
var NavLink = React2.forwardRef(function NavLinkWithRef(_ref8, ref) {
|
|
let {
|
|
"aria-current": ariaCurrentProp = "page",
|
|
caseSensitive = false,
|
|
className: classNameProp = "",
|
|
end = false,
|
|
style: styleProp,
|
|
to,
|
|
viewTransition,
|
|
children
|
|
} = _ref8, rest = _objectWithoutPropertiesLoose(_ref8, _excluded2);
|
|
let path = useResolvedPath(to, {
|
|
relative: rest.relative
|
|
});
|
|
let location = useLocation();
|
|
let routerState = React2.useContext(DataRouterStateContext);
|
|
let {
|
|
navigator,
|
|
basename
|
|
} = React2.useContext(NavigationContext);
|
|
let isTransitioning = routerState != null && // Conditional usage is OK here because the usage of a data router is static
|
|
// eslint-disable-next-line react-hooks/rules-of-hooks
|
|
useViewTransitionState(path) && viewTransition === true;
|
|
let toPathname = navigator.encodeLocation ? navigator.encodeLocation(path).pathname : path.pathname;
|
|
let locationPathname = location.pathname;
|
|
let nextLocationPathname = routerState && routerState.navigation && routerState.navigation.location ? routerState.navigation.location.pathname : null;
|
|
if (!caseSensitive) {
|
|
locationPathname = locationPathname.toLowerCase();
|
|
nextLocationPathname = nextLocationPathname ? nextLocationPathname.toLowerCase() : null;
|
|
toPathname = toPathname.toLowerCase();
|
|
}
|
|
if (nextLocationPathname && basename) {
|
|
nextLocationPathname = stripBasename(nextLocationPathname, basename) || nextLocationPathname;
|
|
}
|
|
const endSlashPosition = toPathname !== "/" && toPathname.endsWith("/") ? toPathname.length - 1 : toPathname.length;
|
|
let isActive = locationPathname === toPathname || !end && locationPathname.startsWith(toPathname) && locationPathname.charAt(endSlashPosition) === "/";
|
|
let isPending = nextLocationPathname != null && (nextLocationPathname === toPathname || !end && nextLocationPathname.startsWith(toPathname) && nextLocationPathname.charAt(toPathname.length) === "/");
|
|
let renderProps = {
|
|
isActive,
|
|
isPending,
|
|
isTransitioning
|
|
};
|
|
let ariaCurrent = isActive ? ariaCurrentProp : void 0;
|
|
let className;
|
|
if (typeof classNameProp === "function") {
|
|
className = classNameProp(renderProps);
|
|
} else {
|
|
className = [classNameProp, isActive ? "active" : null, isPending ? "pending" : null, isTransitioning ? "transitioning" : null].filter(Boolean).join(" ");
|
|
}
|
|
let style = typeof styleProp === "function" ? styleProp(renderProps) : styleProp;
|
|
return React2.createElement(Link, _extends3({}, rest, {
|
|
"aria-current": ariaCurrent,
|
|
className,
|
|
ref,
|
|
style,
|
|
to,
|
|
viewTransition
|
|
}), typeof children === "function" ? children(renderProps) : children);
|
|
});
|
|
if (true) {
|
|
NavLink.displayName = "NavLink";
|
|
}
|
|
var Form = React2.forwardRef((_ref9, forwardedRef) => {
|
|
let {
|
|
fetcherKey,
|
|
navigate,
|
|
reloadDocument,
|
|
replace: replace2,
|
|
state,
|
|
method = defaultMethod,
|
|
action,
|
|
onSubmit,
|
|
relative,
|
|
preventScrollReset,
|
|
viewTransition
|
|
} = _ref9, props = _objectWithoutPropertiesLoose(_ref9, _excluded3);
|
|
let submit = useSubmit();
|
|
let formAction = useFormAction(action, {
|
|
relative
|
|
});
|
|
let formMethod = method.toLowerCase() === "get" ? "get" : "post";
|
|
let submitHandler = (event) => {
|
|
onSubmit && onSubmit(event);
|
|
if (event.defaultPrevented) return;
|
|
event.preventDefault();
|
|
let submitter = event.nativeEvent.submitter;
|
|
let submitMethod = (submitter == null ? void 0 : submitter.getAttribute("formmethod")) || method;
|
|
submit(submitter || event.currentTarget, {
|
|
fetcherKey,
|
|
method: submitMethod,
|
|
navigate,
|
|
replace: replace2,
|
|
state,
|
|
relative,
|
|
preventScrollReset,
|
|
viewTransition
|
|
});
|
|
};
|
|
return React2.createElement("form", _extends3({
|
|
ref: forwardedRef,
|
|
method: formMethod,
|
|
action: formAction,
|
|
onSubmit: reloadDocument ? onSubmit : submitHandler
|
|
}, props));
|
|
});
|
|
if (true) {
|
|
Form.displayName = "Form";
|
|
}
|
|
function ScrollRestoration(_ref10) {
|
|
let {
|
|
getKey,
|
|
storageKey
|
|
} = _ref10;
|
|
useScrollRestoration({
|
|
getKey,
|
|
storageKey
|
|
});
|
|
return null;
|
|
}
|
|
if (true) {
|
|
ScrollRestoration.displayName = "ScrollRestoration";
|
|
}
|
|
var DataRouterHook2;
|
|
(function(DataRouterHook3) {
|
|
DataRouterHook3["UseScrollRestoration"] = "useScrollRestoration";
|
|
DataRouterHook3["UseSubmit"] = "useSubmit";
|
|
DataRouterHook3["UseSubmitFetcher"] = "useSubmitFetcher";
|
|
DataRouterHook3["UseFetcher"] = "useFetcher";
|
|
DataRouterHook3["useViewTransitionState"] = "useViewTransitionState";
|
|
})(DataRouterHook2 || (DataRouterHook2 = {}));
|
|
var DataRouterStateHook2;
|
|
(function(DataRouterStateHook3) {
|
|
DataRouterStateHook3["UseFetcher"] = "useFetcher";
|
|
DataRouterStateHook3["UseFetchers"] = "useFetchers";
|
|
DataRouterStateHook3["UseScrollRestoration"] = "useScrollRestoration";
|
|
})(DataRouterStateHook2 || (DataRouterStateHook2 = {}));
|
|
function getDataRouterConsoleError2(hookName) {
|
|
return hookName + " must be used within a data router. See https://reactrouter.com/v6/routers/picking-a-router.";
|
|
}
|
|
function useDataRouterContext2(hookName) {
|
|
let ctx = React2.useContext(DataRouterContext);
|
|
!ctx ? true ? invariant(false, getDataRouterConsoleError2(hookName)) : invariant(false) : void 0;
|
|
return ctx;
|
|
}
|
|
function useDataRouterState2(hookName) {
|
|
let state = React2.useContext(DataRouterStateContext);
|
|
!state ? true ? invariant(false, getDataRouterConsoleError2(hookName)) : invariant(false) : void 0;
|
|
return state;
|
|
}
|
|
function useLinkClickHandler(to, _temp) {
|
|
let {
|
|
target,
|
|
replace: replaceProp,
|
|
state,
|
|
preventScrollReset,
|
|
relative,
|
|
viewTransition
|
|
} = _temp === void 0 ? {} : _temp;
|
|
let navigate = useNavigate();
|
|
let location = useLocation();
|
|
let path = useResolvedPath(to, {
|
|
relative
|
|
});
|
|
return React2.useCallback((event) => {
|
|
if (shouldProcessLinkClick(event, target)) {
|
|
event.preventDefault();
|
|
let replace2 = replaceProp !== void 0 ? replaceProp : createPath(location) === createPath(path);
|
|
navigate(to, {
|
|
replace: replace2,
|
|
state,
|
|
preventScrollReset,
|
|
relative,
|
|
viewTransition
|
|
});
|
|
}
|
|
}, [location, navigate, path, replaceProp, state, target, to, preventScrollReset, relative, viewTransition]);
|
|
}
|
|
function useSearchParams(defaultInit) {
|
|
true ? warning(typeof URLSearchParams !== "undefined", "You cannot use the `useSearchParams` hook in a browser that does not support the URLSearchParams API. If you need to support Internet Explorer 11, we recommend you load a polyfill such as https://github.com/ungap/url-search-params.") : void 0;
|
|
let defaultSearchParamsRef = React2.useRef(createSearchParams(defaultInit));
|
|
let hasSetSearchParamsRef = React2.useRef(false);
|
|
let location = useLocation();
|
|
let searchParams = React2.useMemo(() => (
|
|
// Only merge in the defaults if we haven't yet called setSearchParams.
|
|
// Once we call that we want those to take precedence, otherwise you can't
|
|
// remove a param with setSearchParams({}) if it has an initial value
|
|
getSearchParamsForLocation(location.search, hasSetSearchParamsRef.current ? null : defaultSearchParamsRef.current)
|
|
), [location.search]);
|
|
let navigate = useNavigate();
|
|
let setSearchParams = React2.useCallback((nextInit, navigateOptions) => {
|
|
const newSearchParams = createSearchParams(typeof nextInit === "function" ? nextInit(searchParams) : nextInit);
|
|
hasSetSearchParamsRef.current = true;
|
|
navigate("?" + newSearchParams, navigateOptions);
|
|
}, [navigate, searchParams]);
|
|
return [searchParams, setSearchParams];
|
|
}
|
|
function validateClientSideSubmission() {
|
|
if (typeof document === "undefined") {
|
|
throw new Error("You are calling submit during the server render. Try calling submit within a `useEffect` or callback instead.");
|
|
}
|
|
}
|
|
var fetcherId = 0;
|
|
var getUniqueFetcherId = () => "__" + String(++fetcherId) + "__";
|
|
function useSubmit() {
|
|
let {
|
|
router
|
|
} = useDataRouterContext2(DataRouterHook2.UseSubmit);
|
|
let {
|
|
basename
|
|
} = React2.useContext(NavigationContext);
|
|
let currentRouteId = useRouteId();
|
|
return React2.useCallback(function(target, options) {
|
|
if (options === void 0) {
|
|
options = {};
|
|
}
|
|
validateClientSideSubmission();
|
|
let {
|
|
action,
|
|
method,
|
|
encType,
|
|
formData,
|
|
body
|
|
} = getFormSubmissionInfo(target, basename);
|
|
if (options.navigate === false) {
|
|
let key = options.fetcherKey || getUniqueFetcherId();
|
|
router.fetch(key, currentRouteId, options.action || action, {
|
|
preventScrollReset: options.preventScrollReset,
|
|
formData,
|
|
body,
|
|
formMethod: options.method || method,
|
|
formEncType: options.encType || encType,
|
|
flushSync: options.flushSync
|
|
});
|
|
} else {
|
|
router.navigate(options.action || action, {
|
|
preventScrollReset: options.preventScrollReset,
|
|
formData,
|
|
body,
|
|
formMethod: options.method || method,
|
|
formEncType: options.encType || encType,
|
|
replace: options.replace,
|
|
state: options.state,
|
|
fromRouteId: currentRouteId,
|
|
flushSync: options.flushSync,
|
|
viewTransition: options.viewTransition
|
|
});
|
|
}
|
|
}, [router, basename, currentRouteId]);
|
|
}
|
|
function useFormAction(action, _temp2) {
|
|
let {
|
|
relative
|
|
} = _temp2 === void 0 ? {} : _temp2;
|
|
let {
|
|
basename
|
|
} = React2.useContext(NavigationContext);
|
|
let routeContext = React2.useContext(RouteContext);
|
|
!routeContext ? true ? invariant(false, "useFormAction must be used inside a RouteContext") : invariant(false) : void 0;
|
|
let [match] = routeContext.matches.slice(-1);
|
|
let path = _extends3({}, useResolvedPath(action ? action : ".", {
|
|
relative
|
|
}));
|
|
let location = useLocation();
|
|
if (action == null) {
|
|
path.search = location.search;
|
|
let params = new URLSearchParams(path.search);
|
|
let indexValues = params.getAll("index");
|
|
let hasNakedIndexParam = indexValues.some((v) => v === "");
|
|
if (hasNakedIndexParam) {
|
|
params.delete("index");
|
|
indexValues.filter((v) => v).forEach((v) => params.append("index", v));
|
|
let qs = params.toString();
|
|
path.search = qs ? "?" + qs : "";
|
|
}
|
|
}
|
|
if ((!action || action === ".") && match.route.index) {
|
|
path.search = path.search ? path.search.replace(/^\?/, "?index&") : "?index";
|
|
}
|
|
if (basename !== "/") {
|
|
path.pathname = path.pathname === "/" ? basename : joinPaths([basename, path.pathname]);
|
|
}
|
|
return createPath(path);
|
|
}
|
|
function useFetcher(_temp3) {
|
|
var _route$matches;
|
|
let {
|
|
key
|
|
} = _temp3 === void 0 ? {} : _temp3;
|
|
let {
|
|
router
|
|
} = useDataRouterContext2(DataRouterHook2.UseFetcher);
|
|
let state = useDataRouterState2(DataRouterStateHook2.UseFetcher);
|
|
let fetcherData = React2.useContext(FetchersContext);
|
|
let route = React2.useContext(RouteContext);
|
|
let routeId = (_route$matches = route.matches[route.matches.length - 1]) == null ? void 0 : _route$matches.route.id;
|
|
!fetcherData ? true ? invariant(false, "useFetcher must be used inside a FetchersContext") : invariant(false) : void 0;
|
|
!route ? true ? invariant(false, "useFetcher must be used inside a RouteContext") : invariant(false) : void 0;
|
|
!(routeId != null) ? true ? invariant(false, 'useFetcher can only be used on routes that contain a unique "id"') : invariant(false) : void 0;
|
|
let defaultKey = useIdImpl ? useIdImpl() : "";
|
|
let [fetcherKey, setFetcherKey] = React2.useState(key || defaultKey);
|
|
if (key && key !== fetcherKey) {
|
|
setFetcherKey(key);
|
|
} else if (!fetcherKey) {
|
|
setFetcherKey(getUniqueFetcherId());
|
|
}
|
|
React2.useEffect(() => {
|
|
router.getFetcher(fetcherKey);
|
|
return () => {
|
|
router.deleteFetcher(fetcherKey);
|
|
};
|
|
}, [router, fetcherKey]);
|
|
let load = React2.useCallback((href, opts) => {
|
|
!routeId ? true ? invariant(false, "No routeId available for fetcher.load()") : invariant(false) : void 0;
|
|
router.fetch(fetcherKey, routeId, href, opts);
|
|
}, [fetcherKey, routeId, router]);
|
|
let submitImpl = useSubmit();
|
|
let submit = React2.useCallback((target, opts) => {
|
|
submitImpl(target, _extends3({}, opts, {
|
|
navigate: false,
|
|
fetcherKey
|
|
}));
|
|
}, [fetcherKey, submitImpl]);
|
|
let FetcherForm = React2.useMemo(() => {
|
|
let FetcherForm2 = React2.forwardRef((props, ref) => {
|
|
return React2.createElement(Form, _extends3({}, props, {
|
|
navigate: false,
|
|
fetcherKey,
|
|
ref
|
|
}));
|
|
});
|
|
if (true) {
|
|
FetcherForm2.displayName = "fetcher.Form";
|
|
}
|
|
return FetcherForm2;
|
|
}, [fetcherKey]);
|
|
let fetcher = state.fetchers.get(fetcherKey) || IDLE_FETCHER;
|
|
let data = fetcherData.get(fetcherKey);
|
|
let fetcherWithComponents = React2.useMemo(() => _extends3({
|
|
Form: FetcherForm,
|
|
submit,
|
|
load
|
|
}, fetcher, {
|
|
data
|
|
}), [FetcherForm, submit, load, fetcher, data]);
|
|
return fetcherWithComponents;
|
|
}
|
|
function useFetchers() {
|
|
let state = useDataRouterState2(DataRouterStateHook2.UseFetchers);
|
|
return Array.from(state.fetchers.entries()).map((_ref11) => {
|
|
let [key, fetcher] = _ref11;
|
|
return _extends3({}, fetcher, {
|
|
key
|
|
});
|
|
});
|
|
}
|
|
var SCROLL_RESTORATION_STORAGE_KEY = "react-router-scroll-positions";
|
|
var savedScrollPositions = {};
|
|
function useScrollRestoration(_temp4) {
|
|
let {
|
|
getKey,
|
|
storageKey
|
|
} = _temp4 === void 0 ? {} : _temp4;
|
|
let {
|
|
router
|
|
} = useDataRouterContext2(DataRouterHook2.UseScrollRestoration);
|
|
let {
|
|
restoreScrollPosition,
|
|
preventScrollReset
|
|
} = useDataRouterState2(DataRouterStateHook2.UseScrollRestoration);
|
|
let {
|
|
basename
|
|
} = React2.useContext(NavigationContext);
|
|
let location = useLocation();
|
|
let matches = useMatches();
|
|
let navigation = useNavigation();
|
|
React2.useEffect(() => {
|
|
window.history.scrollRestoration = "manual";
|
|
return () => {
|
|
window.history.scrollRestoration = "auto";
|
|
};
|
|
}, []);
|
|
usePageHide(React2.useCallback(() => {
|
|
if (navigation.state === "idle") {
|
|
let key = (getKey ? getKey(location, matches) : null) || location.key;
|
|
savedScrollPositions[key] = window.scrollY;
|
|
}
|
|
try {
|
|
sessionStorage.setItem(storageKey || SCROLL_RESTORATION_STORAGE_KEY, JSON.stringify(savedScrollPositions));
|
|
} catch (error) {
|
|
true ? warning(false, "Failed to save scroll positions in sessionStorage, <ScrollRestoration /> will not work properly (" + error + ").") : void 0;
|
|
}
|
|
window.history.scrollRestoration = "auto";
|
|
}, [storageKey, getKey, navigation.state, location, matches]));
|
|
if (typeof document !== "undefined") {
|
|
React2.useLayoutEffect(() => {
|
|
try {
|
|
let sessionPositions = sessionStorage.getItem(storageKey || SCROLL_RESTORATION_STORAGE_KEY);
|
|
if (sessionPositions) {
|
|
savedScrollPositions = JSON.parse(sessionPositions);
|
|
}
|
|
} catch (e) {
|
|
}
|
|
}, [storageKey]);
|
|
React2.useLayoutEffect(() => {
|
|
let getKeyWithoutBasename = getKey && basename !== "/" ? (location2, matches2) => getKey(
|
|
// Strip the basename to match useLocation()
|
|
_extends3({}, location2, {
|
|
pathname: stripBasename(location2.pathname, basename) || location2.pathname
|
|
}),
|
|
matches2
|
|
) : getKey;
|
|
let disableScrollRestoration = router == null ? void 0 : router.enableScrollRestoration(savedScrollPositions, () => window.scrollY, getKeyWithoutBasename);
|
|
return () => disableScrollRestoration && disableScrollRestoration();
|
|
}, [router, basename, getKey]);
|
|
React2.useLayoutEffect(() => {
|
|
if (restoreScrollPosition === false) {
|
|
return;
|
|
}
|
|
if (typeof restoreScrollPosition === "number") {
|
|
window.scrollTo(0, restoreScrollPosition);
|
|
return;
|
|
}
|
|
if (location.hash) {
|
|
let el = document.getElementById(decodeURIComponent(location.hash.slice(1)));
|
|
if (el) {
|
|
el.scrollIntoView();
|
|
return;
|
|
}
|
|
}
|
|
if (preventScrollReset === true) {
|
|
return;
|
|
}
|
|
window.scrollTo(0, 0);
|
|
}, [location, restoreScrollPosition, preventScrollReset]);
|
|
}
|
|
}
|
|
function useBeforeUnload(callback, options) {
|
|
let {
|
|
capture
|
|
} = options || {};
|
|
React2.useEffect(() => {
|
|
let opts = capture != null ? {
|
|
capture
|
|
} : void 0;
|
|
window.addEventListener("beforeunload", callback, opts);
|
|
return () => {
|
|
window.removeEventListener("beforeunload", callback, opts);
|
|
};
|
|
}, [callback, capture]);
|
|
}
|
|
function usePageHide(callback, options) {
|
|
let {
|
|
capture
|
|
} = options || {};
|
|
React2.useEffect(() => {
|
|
let opts = capture != null ? {
|
|
capture
|
|
} : void 0;
|
|
window.addEventListener("pagehide", callback, opts);
|
|
return () => {
|
|
window.removeEventListener("pagehide", callback, opts);
|
|
};
|
|
}, [callback, capture]);
|
|
}
|
|
function usePrompt(_ref12) {
|
|
let {
|
|
when,
|
|
message
|
|
} = _ref12;
|
|
let blocker = useBlocker(when);
|
|
React2.useEffect(() => {
|
|
if (blocker.state === "blocked") {
|
|
let proceed = window.confirm(message);
|
|
if (proceed) {
|
|
setTimeout(blocker.proceed, 0);
|
|
} else {
|
|
blocker.reset();
|
|
}
|
|
}
|
|
}, [blocker, message]);
|
|
React2.useEffect(() => {
|
|
if (blocker.state === "blocked" && !when) {
|
|
blocker.reset();
|
|
}
|
|
}, [blocker, when]);
|
|
}
|
|
function useViewTransitionState(to, opts) {
|
|
if (opts === void 0) {
|
|
opts = {};
|
|
}
|
|
let vtContext = React2.useContext(ViewTransitionContext);
|
|
!(vtContext != null) ? true ? invariant(false, "`useViewTransitionState` must be used within `react-router-dom`'s `RouterProvider`. Did you accidentally import `RouterProvider` from `react-router`?") : invariant(false) : void 0;
|
|
let {
|
|
basename
|
|
} = useDataRouterContext2(DataRouterHook2.useViewTransitionState);
|
|
let path = useResolvedPath(to, {
|
|
relative: opts.relative
|
|
});
|
|
if (!vtContext.isTransitioning) {
|
|
return false;
|
|
}
|
|
let currentPath = stripBasename(vtContext.currentLocation.pathname, basename) || vtContext.currentLocation.pathname;
|
|
let nextPath = stripBasename(vtContext.nextLocation.pathname, basename) || vtContext.nextLocation.pathname;
|
|
return matchPath(path.pathname, nextPath) != null || matchPath(path.pathname, currentPath) != null;
|
|
}
|
|
export {
|
|
AbortedDeferredError,
|
|
Await,
|
|
BrowserRouter,
|
|
Form,
|
|
HashRouter,
|
|
Link,
|
|
MemoryRouter,
|
|
NavLink,
|
|
Navigate,
|
|
Action as NavigationType,
|
|
Outlet,
|
|
Route,
|
|
Router,
|
|
RouterProvider,
|
|
Routes,
|
|
ScrollRestoration,
|
|
DataRouterContext as UNSAFE_DataRouterContext,
|
|
DataRouterStateContext as UNSAFE_DataRouterStateContext,
|
|
ErrorResponseImpl as UNSAFE_ErrorResponseImpl,
|
|
FetchersContext as UNSAFE_FetchersContext,
|
|
LocationContext as UNSAFE_LocationContext,
|
|
NavigationContext as UNSAFE_NavigationContext,
|
|
RouteContext as UNSAFE_RouteContext,
|
|
ViewTransitionContext as UNSAFE_ViewTransitionContext,
|
|
useRouteId as UNSAFE_useRouteId,
|
|
useScrollRestoration as UNSAFE_useScrollRestoration,
|
|
createBrowserRouter,
|
|
createHashRouter,
|
|
createMemoryRouter,
|
|
createPath,
|
|
createRoutesFromChildren,
|
|
createRoutesFromChildren as createRoutesFromElements,
|
|
createSearchParams,
|
|
defer,
|
|
generatePath,
|
|
isRouteErrorResponse,
|
|
json,
|
|
matchPath,
|
|
matchRoutes,
|
|
parsePath,
|
|
redirect,
|
|
redirectDocument,
|
|
renderMatches,
|
|
replace,
|
|
resolvePath,
|
|
HistoryRouter as unstable_HistoryRouter,
|
|
usePrompt as unstable_usePrompt,
|
|
useActionData,
|
|
useAsyncError,
|
|
useAsyncValue,
|
|
useBeforeUnload,
|
|
useBlocker,
|
|
useFetcher,
|
|
useFetchers,
|
|
useFormAction,
|
|
useHref,
|
|
useInRouterContext,
|
|
useLinkClickHandler,
|
|
useLoaderData,
|
|
useLocation,
|
|
useMatch,
|
|
useMatches,
|
|
useNavigate,
|
|
useNavigation,
|
|
useNavigationType,
|
|
useOutlet,
|
|
useOutletContext,
|
|
useParams,
|
|
useResolvedPath,
|
|
useRevalidator,
|
|
useRouteError,
|
|
useRouteLoaderData,
|
|
useRoutes,
|
|
useSearchParams,
|
|
useSubmit,
|
|
useViewTransitionState
|
|
};
|
|
/*! Bundled license information:
|
|
|
|
@remix-run/router/dist/router.js:
|
|
(**
|
|
* @remix-run/router v1.21.0
|
|
*
|
|
* Copyright (c) Remix Software Inc.
|
|
*
|
|
* This source code is licensed under the MIT license found in the
|
|
* LICENSE.md file in the root directory of this source tree.
|
|
*
|
|
* @license MIT
|
|
*)
|
|
|
|
react-router/dist/index.js:
|
|
(**
|
|
* React Router v6.28.1
|
|
*
|
|
* Copyright (c) Remix Software Inc.
|
|
*
|
|
* This source code is licensed under the MIT license found in the
|
|
* LICENSE.md file in the root directory of this source tree.
|
|
*
|
|
* @license MIT
|
|
*)
|
|
|
|
react-router-dom/dist/index.js:
|
|
(**
|
|
* React Router DOM v6.28.1
|
|
*
|
|
* Copyright (c) Remix Software Inc.
|
|
*
|
|
* This source code is licensed under the MIT license found in the
|
|
* LICENSE.md file in the root directory of this source tree.
|
|
*
|
|
* @license MIT
|
|
*)
|
|
*/
|
|
//# sourceMappingURL=react-router-dom.js.map
|