react-router 7.18.0 → 8.0.0-pre.1

package/dist/development/lib/href.d.ts

@@ -0,0 +1,20 @@
+
+import { Equal } from "./types/utils.js";
+import { Pages } from "./types/register.js";
+
+//#region lib/href.d.ts
+type Args = { [K in keyof Pages]: ToArgs<Pages[K]["params"]> };
+type ToArgs<Params extends Record<string, string | undefined>> = Equal<Params, {}> extends true ? [] : Partial<Params> extends Params ? [Params] | [] : [Params];
+/**
+  Returns a resolved URL path for the specified route.
+
+  ```tsx
+  const h = href("/:lang?/about", { lang: "en" })
+  // -> `/en/about`
+
+  <Link to={href("/products/:id", { id: "abc123" })} />
+  ```
+ */
+declare function href<Path extends keyof Args>(path: Path, ...args: Args[Path]): string;
+//#endregion
+export { href };

package/dist/development/lib/href.js

@@ -0,0 +1,50 @@
+/**
+ * react-router v8.0.0-pre.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
+ */
+//#region lib/href.ts
+/**
+Returns a resolved URL path for the specified route.
+
+```tsx
+const h = href("/:lang?/about", { lang: "en" })
+// -> `/en/about`
+
+<Link to={href("/products/:id", { id: "abc123" })} />
+```
+*/
+function href(path, ...args) {
+	let params = args[0];
+	let result = trimTrailingSplat(path).replace(/\/:([\w-]+)(\?)?/g, (_, param, questionMark) => {
+		const isRequired = questionMark === void 0;
+		const value = params?.[param];
+		if (isRequired && value === void 0) throw new Error(`Path '${path}' requires param '${param}' but it was not provided`);
+		return value === void 0 ? "" : "/" + value;
+	});
+	if (path.endsWith("*")) {
+		const value = params?.["*"];
+		if (value !== void 0) result += "/" + value;
+	}
+	return result || "/";
+}
+/**
+* Removes a trailing splat and any number of slashes from the end of the path.
+*
+* Benchmarked to be faster than `path.replace(/\/*\*?$/, "")`, which backtracks.
+*/
+function trimTrailingSplat(path) {
+	let i = path.length - 1;
+	let char = path[i];
+	if (char !== "*" && char !== "/") return path;
+	i--;
+	for (; i >= 0; i--) if (path[i] !== "/") break;
+	return path.slice(0, i + 1);
+}
+//#endregion
+export { href };

package/dist/development/lib/router/history.d.ts

@@ -0,0 +1,258 @@
+
+//#region lib/router/history.d.ts
+/**
+ * Actions represent the type of change to a location value.
+ */
+declare enum Action {
+  /**
+   * A POP indicates a change to an arbitrary index in the history stack, such
+   * as a back or forward navigation. It does not describe the direction of the
+   * navigation, only that the current index changed.
+   *
+   * Note: This is the default action for newly created history objects.
+   */
+  Pop = "POP",
+  /**
+   * A PUSH indicates a new entry being added to the history stack, such as when
+   * a link is clicked and a new page loads. When this happens, all subsequent
+   * entries in the stack are lost.
+   */
+  Push = "PUSH",
+  /**
+   * A REPLACE indicates the entry at the current index in the history stack
+   * being replaced by a new one.
+   */
+  Replace = "REPLACE"
+}
+/**
+ * The pathname, search, and hash values of a URL.
+ */
+interface Path {
+  /**
+   * A URL pathname, beginning with a /.
+   */
+  pathname: string;
+  /**
+   * A URL search string, beginning with a ?.
+   */
+  search: string;
+  /**
+   * A URL fragment identifier, beginning with a #.
+   */
+  hash: string;
+}
+/**
+ * An entry in a history stack. A location contains information about the
+ * URL path, as well as possibly some arbitrary state and a key.
+ */
+interface Location<State = any> extends Path {
+  /**
+   * A value of arbitrary data associated with this location.
+   */
+  state: State;
+  /**
+   * A unique string associated with this location. May be used to safely store
+   * and retrieve data in some other storage API, like `localStorage`.
+   *
+   * Note: This value is always "default" on the initial location.
+   */
+  key: string;
+  /**
+   * The masked location displayed in the URL bar, which differs from the URL the
+   * router is operating on
+   */
+  mask?: Path;
+}
+/**
+ * A change to the current location.
+ */
+interface Update {
+  /**
+   * The action that triggered the change.
+   */
+  action: Action;
+  /**
+   * The new location.
+   */
+  location: Location;
+  /**
+   * The delta between this location and the former location in the history stack
+   */
+  delta: number | null;
+}
+/**
+ * A function that receives notifications about location changes.
+ */
+interface Listener {
+  (update: Update): void;
+}
+/**
+ * Describes a location that is the destination of some navigation used in
+ * {@link Link}, {@link useNavigate}, etc.
+ */
+type To = string | Partial<Path>;
+/**
+ * A history is an interface to the navigation stack. The history serves as the
+ * source of truth for the current location, as well as provides a set of
+ * methods that may be used to change it.
+ *
+ * It is similar to the DOM's `window.history` object, but with a smaller, more
+ * focused API.
+ */
+interface History {
+  /**
+   * The last action that modified the current location. This will always be
+   * Action.Pop when a history instance is first created. This value is mutable.
+   */
+  readonly action: Action;
+  /**
+   * The current location. This value is mutable.
+   */
+  readonly location: Location;
+  /**
+   * Returns a valid href for the given `to` value that may be used as
+   * the value of an <a href> attribute.
+   *
+   * @param to - The destination URL
+   */
+  createHref(to: To): string;
+  /**
+   * Returns a URL for the given `to` value
+   *
+   * @param to - The destination URL
+   */
+  createURL(to: To): URL;
+  /**
+   * Encode a location the same way window.history would do (no-op for memory
+   * history) so we ensure our PUSH/REPLACE navigations for data routers
+   * behave the same as POP
+   *
+   * @param to Unencoded path
+   */
+  encodeLocation(to: To): Path;
+  /**
+   * Pushes a new location onto the history stack, increasing its length by one.
+   * If there were any entries in the stack after the current one, they are
+   * lost.
+   *
+   * @param to - The new URL
+   * @param state - Data to associate with the new location
+   */
+  push(to: To, state?: any): void;
+  /**
+   * Replaces the current location in the history stack with a new one.  The
+   * location that was replaced will no longer be available.
+   *
+   * @param to - The new URL
+   * @param state - Data to associate with the new location
+   */
+  replace(to: To, state?: any): void;
+  /**
+   * Navigates `n` entries backward/forward in the history stack relative to the
+   * current index. For example, a "back" navigation would use go(-1).
+   *
+   * @param delta - The delta in the stack index
+   */
+  go(delta: number): void;
+  /**
+   * Sets up a listener that will be called whenever the current location
+   * changes.
+   *
+   * @param listener - A function that will be called when the location changes
+   * @returns unlisten - A function that may be used to stop listening
+   */
+  listen(listener: Listener): () => void;
+}
+/**
+ * A user-supplied object that describes a location. Used when providing
+ * entries to `createMemoryHistory` via its `initialEntries` option.
+ */
+type InitialEntry = string | Partial<Location>;
+type MemoryHistoryOptions = {
+  initialEntries?: InitialEntry[];
+  initialIndex?: number;
+  v5Compat?: boolean;
+};
+/**
+ * A memory history stores locations in memory. This is useful in stateful
+ * environments where there is no web browser, such as node tests or React
+ * Native.
+ */
+interface MemoryHistory extends History {
+  /**
+   * The current index in the history stack.
+   */
+  readonly index: number;
+}
+/**
+ * Memory history stores the current location in memory. It is designed for use
+ * in stateful non-browser environments like tests and React Native.
+ */
+declare function createMemoryHistory(options?: MemoryHistoryOptions): MemoryHistory;
+/**
+ * A browser history stores the current location in regular URLs in a web
+ * browser environment. This is the standard for most web apps and provides the
+ * cleanest URLs the browser's address bar.
+ *
+ * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#browserhistory
+ */
+interface BrowserHistory extends UrlHistory {}
+type BrowserHistoryOptions = UrlHistoryOptions;
+/**
+ * Browser history stores the location in regular URLs. This is the standard for
+ * most web apps, but it requires some configuration on the server to ensure you
+ * serve the same app at multiple URLs.
+ *
+ * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createbrowserhistory
+ */
+declare function createBrowserHistory(options?: BrowserHistoryOptions): BrowserHistory;
+/**
+ * A hash history stores the current location in the fragment identifier portion
+ * of the URL in a web browser environment.
+ *
+ * This is ideal for apps that do not control the server for some reason
+ * (because the fragment identifier is never sent to the server), including some
+ * shared hosting environments that do not provide fine-grained controls over
+ * which pages are served at which URLs.
+ *
+ * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#hashhistory
+ */
+interface HashHistory extends UrlHistory {}
+type HashHistoryOptions = UrlHistoryOptions;
+/**
+ * Hash history stores the location in window.location.hash. This makes it ideal
+ * for situations where you don't want to send the location to the server for
+ * some reason, either because you do cannot configure it or the URL space is
+ * reserved for something else.
+ *
+ * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createhashhistory
+ */
+declare function createHashHistory(options?: HashHistoryOptions): HashHistory;
+/**
+ * @private
+ */
+declare function invariant(value: boolean, message?: string): asserts value;
+declare function invariant<T>(value: T | null | undefined, message?: string): asserts value is T;
+/**
+ * Creates a string URL path from the given pathname, search, and hash components.
+ *
+ * @category Utils
+ */
+declare function createPath({
+  pathname,
+  search,
+  hash
+}: Partial<Path>): string;
+/**
+ * Parses a string URL path into its separate pathname, search, and hash components.
+ *
+ * @category Utils
+ */
+declare function parsePath(path: string): Partial<Path>;
+interface UrlHistory extends History {}
+type UrlHistoryOptions = {
+  window?: Window;
+  v5Compat?: boolean;
+};
+//#endregion
+export { Action, History, InitialEntry, Location, Path, To, createBrowserHistory, createHashHistory, createMemoryHistory, createPath, invariant, parsePath };

package/dist/development/lib/router/history.js

@@ -0,0 +1,372 @@
+/**
+ * react-router v8.0.0-pre.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
+ */
+import { PROTOCOL_RELATIVE_URL_REGEX } from "./url.js";
+//#region lib/router/history.ts
+/**
+* Actions represent the type of change to a location value.
+*/
+let Action = /* @__PURE__ */ function(Action) {
+	/**
+	* A POP indicates a change to an arbitrary index in the history stack, such
+	* as a back or forward navigation. It does not describe the direction of the
+	* navigation, only that the current index changed.
+	*
+	* Note: This is the default action for newly created history objects.
+	*/
+	Action["Pop"] = "POP";
+	/**
+	* A PUSH indicates a new entry being added to the history stack, such as when
+	* a link is clicked and a new page loads. When this happens, all subsequent
+	* entries in the stack are lost.
+	*/
+	Action["Push"] = "PUSH";
+	/**
+	* A REPLACE indicates the entry at the current index in the history stack
+	* being replaced by a new one.
+	*/
+	Action["Replace"] = "REPLACE";
+	return Action;
+}({});
+const PopStateEventType = "popstate";
+function isLocation(obj) {
+	return typeof obj === "object" && obj != null && "pathname" in obj && "search" in obj && "hash" in obj && "state" in obj && "key" in obj;
+}
+/**
+* Memory history stores the current location in memory. It is designed for use
+* in stateful non-browser environments like tests and React Native.
+*/
+function createMemoryHistory(options = {}) {
+	let { initialEntries = ["/"], initialIndex, v5Compat = false } = options;
+	let entries;
+	entries = initialEntries.map((entry, index) => createMemoryLocation(entry, typeof entry === "string" ? null : entry.state, index === 0 ? "default" : void 0, typeof entry === "string" ? void 0 : entry.mask));
+	let index = clampIndex(initialIndex == null ? entries.length - 1 : initialIndex);
+	let 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 = null, key, mask) {
+		let location = createLocation(entries ? getCurrentLocation().pathname : "/", to, state, key, mask);
+		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);
+	}
+	return {
+		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 = "PUSH";
+			let nextLocation = isLocation(to) ? to : createMemoryLocation(to, state);
+			index += 1;
+			entries.splice(index, entries.length, nextLocation);
+			if (v5Compat && listener) listener({
+				action,
+				location: nextLocation,
+				delta: 1
+			});
+		},
+		replace(to, state) {
+			action = "REPLACE";
+			let nextLocation = isLocation(to) ? to : createMemoryLocation(to, state);
+			entries[index] = nextLocation;
+			if (v5Compat && listener) listener({
+				action,
+				location: nextLocation,
+				delta: 0
+			});
+		},
+		go(delta) {
+			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;
+			};
+		}
+	};
+}
+/**
+* Browser history stores the location in regular URLs. This is the standard for
+* most web apps, but it requires some configuration on the server to ensure you
+* serve the same app at multiple URLs.
+*
+* @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createbrowserhistory
+*/
+function createBrowserHistory(options = {}) {
+	function createBrowserLocation(window, globalHistory) {
+		let maskedLocation = globalHistory.state?.masked;
+		let { pathname, search, hash } = maskedLocation || window.location;
+		return createLocation("", {
+			pathname,
+			search,
+			hash
+		}, globalHistory.state && globalHistory.state.usr || null, globalHistory.state && globalHistory.state.key || "default", maskedLocation ? {
+			pathname: window.location.pathname,
+			search: window.location.search,
+			hash: window.location.hash
+		} : void 0);
+	}
+	function createBrowserHref(window, to) {
+		return typeof to === "string" ? to : createPath(to);
+	}
+	return getUrlBasedHistory(createBrowserLocation, createBrowserHref, null, options);
+}
+/**
+* Hash history stores the location in window.location.hash. This makes it ideal
+* for situations where you don't want to send the location to the server for
+* some reason, either because you do cannot configure it or the URL space is
+* reserved for something else.
+*
+* @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createhashhistory
+*/
+function createHashHistory(options = {}) {
+	function createHashLocation(window, globalHistory) {
+		let { pathname = "/", search = "", hash = "" } = parsePath(window.location.hash.substring(1));
+		if (!pathname.startsWith("/") && !pathname.startsWith(".")) pathname = "/" + pathname;
+		return createLocation("", {
+			pathname,
+			search,
+			hash
+		}, globalHistory.state && globalHistory.state.usr || null, globalHistory.state && globalHistory.state.key || "default");
+	}
+	function createHashHref(window, to) {
+		let base = window.document.querySelector("base");
+		let href = "";
+		if (base && base.getAttribute("href")) {
+			let url = window.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).substring(2, 10);
+}
+/**
+* For browser-based histories, we combine the state and key into an object
+*/
+function getHistoryState(location, index) {
+	return {
+		usr: location.state,
+		key: location.key,
+		idx: index,
+		masked: location.mask ? {
+			pathname: location.pathname,
+			search: location.search,
+			hash: location.hash
+		} : void 0
+	};
+}
+/**
+* Creates a Location object with a unique key from the given Path
+*/
+function createLocation(current, to, state = null, key, mask) {
+	return {
+		pathname: typeof current === "string" ? current : current.pathname,
+		search: "",
+		hash: "",
+		...typeof to === "string" ? parsePath(to) : to,
+		state,
+		key: to && to.key || key || createKey(),
+		mask
+	};
+}
+/**
+* Creates a string URL path from the given pathname, search, and hash components.
+*
+* @category Utils
+*/
+function createPath({ pathname = "/", search = "", hash = "" }) {
+	if (search && search !== "?") pathname += search.charAt(0) === "?" ? search : "?" + search;
+	if (hash && hash !== "#") pathname += hash.charAt(0) === "#" ? hash : "#" + hash;
+	return pathname;
+}
+/**
+* Parses a string URL path into its separate pathname, search, and hash components.
+*
+* @category Utils
+*/
+function parsePath(path) {
+	let parsedPath = {};
+	if (path) {
+		let hashIndex = path.indexOf("#");
+		if (hashIndex >= 0) {
+			parsedPath.hash = path.substring(hashIndex);
+			path = path.substring(0, hashIndex);
+		}
+		let searchIndex = path.indexOf("?");
+		if (searchIndex >= 0) {
+			parsedPath.search = path.substring(searchIndex);
+			path = path.substring(0, searchIndex);
+		}
+		if (path) parsedPath.pathname = path;
+	}
+	return parsedPath;
+}
+function getUrlBasedHistory(getLocation, createHref, validateLocation, options = {}) {
+	let { window = document.defaultView, v5Compat = false } = options;
+	let globalHistory = window.history;
+	let action = "POP";
+	let listener = null;
+	let index = getIndex();
+	if (index == null) {
+		index = 0;
+		globalHistory.replaceState({
+			...globalHistory.state,
+			idx: index
+		}, "");
+	}
+	function getIndex() {
+		return (globalHistory.state || { idx: null }).idx;
+	}
+	function handlePop() {
+		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 = "PUSH";
+		let location = isLocation(to) ? to : createLocation(history.location, to, state);
+		if (validateLocation) validateLocation(location, to);
+		index = getIndex() + 1;
+		let historyState = getHistoryState(location, index);
+		let url = history.createHref(location.mask || location);
+		try {
+			globalHistory.pushState(historyState, "", url);
+		} catch (error) {
+			if (error instanceof DOMException && error.name === "DataCloneError") throw error;
+			window.location.assign(url);
+		}
+		if (v5Compat && listener) listener({
+			action,
+			location: history.location,
+			delta: 1
+		});
+	}
+	function replace(to, state) {
+		action = "REPLACE";
+		let location = isLocation(to) ? to : createLocation(history.location, to, state);
+		if (validateLocation) validateLocation(location, to);
+		index = getIndex();
+		let historyState = getHistoryState(location, index);
+		let url = history.createHref(location.mask || location);
+		globalHistory.replaceState(historyState, "", url);
+		if (v5Compat && listener) listener({
+			action,
+			location: history.location,
+			delta: 0
+		});
+	}
+	function createURL(to) {
+		return createBrowserURLImpl(window, to);
+	}
+	let history = {
+		get action() {
+			return action;
+		},
+		get location() {
+			return getLocation(window, globalHistory);
+		},
+		listen(fn) {
+			if (listener) throw new Error("A history only accepts one active listener");
+			window.addEventListener(PopStateEventType, handlePop);
+			listener = fn;
+			return () => {
+				window.removeEventListener(PopStateEventType, handlePop);
+				listener = null;
+			};
+		},
+		createHref(to) {
+			return createHref(window, to);
+		},
+		createURL,
+		encodeLocation(to) {
+			let url = createURL(to);
+			return {
+				pathname: url.pathname,
+				search: url.search,
+				hash: url.hash
+			};
+		},
+		push,
+		replace,
+		go(n) {
+			return globalHistory.go(n);
+		}
+	};
+	return history;
+}
+function createBrowserURLImpl(windowImpl, to, isAbsolute = false) {
+	let base = "http://localhost";
+	if (windowImpl) base = windowImpl.location.origin !== "null" ? windowImpl.location.origin : windowImpl.location.href;
+	invariant(base, "No window.location.(origin|href) available to create URL");
+	let href = typeof to === "string" ? to : createPath(to);
+	href = href.replace(/ $/, "%20");
+	if (!isAbsolute && PROTOCOL_RELATIVE_URL_REGEX.test(href)) href = base + href;
+	return new URL(href, base);
+}
+//#endregion
+export { Action, createBrowserHistory, createBrowserURLImpl, createHashHistory, createLocation, createMemoryHistory, createPath, invariant, parsePath, warning };