react-router 7.16.0 → 8.0.0-pre.0

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

@@ -0,0 +1,83 @@
+
+import { Action, History, Location, To } from "./router/history.js";
+import { RouteMatch, TrackedPromise } from "./router/utils.js";
+import { RelativeRoutingType, Router, RouterState, StaticHandlerContext } from "./router/router.js";
+import { ClientOnErrorFunction } from "./components.js";
+import * as React$1 from "react";
+
+//#region lib/context.d.ts
+interface DataRouterContextObject extends Omit<NavigationContextObject, "future" | "useTransitions"> {
+  router: Router;
+  staticContext?: StaticHandlerContext;
+  onError?: ClientOnErrorFunction;
+}
+declare const DataRouterContext: React$1.Context<DataRouterContextObject | null>;
+declare const DataRouterStateContext: React$1.Context<RouterState | null>;
+type ViewTransitionContextObject = {
+  isTransitioning: false;
+} | {
+  isTransitioning: true;
+  flushSync: boolean;
+  currentLocation: Location;
+  nextLocation: Location;
+};
+declare const ViewTransitionContext: React$1.Context<ViewTransitionContextObject>;
+type FetchersContextObject = Map<string, any>;
+declare const FetchersContext: React$1.Context<FetchersContextObject>;
+declare const AwaitContext: React$1.Context<TrackedPromise | null>;
+declare const AwaitContextProvider: (props: React$1.ComponentProps<typeof AwaitContext.Provider>) => React$1.FunctionComponentElement<React$1.ProviderProps<TrackedPromise | null>>;
+interface NavigateOptions {
+  /** Replace the current entry in the history stack instead of pushing a new one */
+  replace?: boolean;
+  /** Masked URL */
+  mask?: To;
+  /** Adds persistent client side routing state to the next location */
+  state?: any;
+  /** If you are using {@link ScrollRestoration `<ScrollRestoration>`}, prevent the scroll position from being reset to the top of the window when navigating */
+  preventScrollReset?: boolean;
+  /** Defines the relative path behavior for the link. "route" will use the route hierarchy so ".." will remove all URL segments of the current route pattern while "path" will use the URL path so ".." will remove one URL segment. */
+  relative?: RelativeRoutingType;
+  /** Wraps the initial state update for this navigation in a {@link https://react.dev/reference/react-dom/flushSync ReactDOM.flushSync} call instead of the default {@link https://react.dev/reference/react/startTransition React.startTransition} */
+  flushSync?: boolean;
+  /** Enables a {@link https://developer.mozilla.org/en-US/docs/Web/API/View_Transitions_API View Transition} for this navigation by wrapping the final state update in `document.startViewTransition()`. If you need to apply specific styles for this view transition, you will also need to leverage the {@link useViewTransitionState `useViewTransitionState()`} hook.  */
+  viewTransition?: boolean;
+  /** Specifies the default revalidation behavior after this submission */
+  defaultShouldRevalidate?: boolean;
+}
+/**
+ * A Navigator is a "location changer"; it's how you get to different locations.
+ *
+ * Every history instance conforms to the Navigator interface, but the
+ * distinction is useful primarily when it comes to the low-level `<Router>` API
+ * where both the location and a navigator must be provided separately in order
+ * to avoid "tearing" that may occur in a suspense-enabled app if the action
+ * and/or location were to be read directly from the history instance.
+ */
+interface Navigator {
+  createHref: History["createHref"];
+  encodeLocation?: History["encodeLocation"];
+  go: History["go"];
+  push(to: To, state?: any, opts?: NavigateOptions): void;
+  replace(to: To, state?: any, opts?: NavigateOptions): void;
+}
+interface NavigationContextObject {
+  basename: string;
+  navigator: Navigator;
+  static: boolean;
+  useTransitions: boolean | undefined;
+  future: {};
+}
+declare const NavigationContext: React$1.Context<NavigationContextObject>;
+interface LocationContextObject {
+  location: Location;
+  navigationType: Action;
+}
+declare const LocationContext: React$1.Context<LocationContextObject>;
+interface RouteContextObject {
+  outlet: React$1.ReactElement | null;
+  matches: RouteMatch[];
+  isDataRoute: boolean;
+}
+declare const RouteContext: React$1.Context<RouteContextObject>;
+//#endregion
+export { AwaitContextProvider, DataRouterContext, DataRouterStateContext, FetchersContext, LocationContext, NavigateOptions, NavigationContext, Navigator, RouteContext, ViewTransitionContext };

package/dist/development/lib/context.js

@@ -0,0 +1,41 @@
+/**
+ * react-router v8.0.0-pre.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
+ */
+import * as React$1 from "react";
+//#region lib/context.ts
+const DataRouterContext = React$1.createContext(null);
+DataRouterContext.displayName = "DataRouter";
+const DataRouterStateContext = React$1.createContext(null);
+DataRouterStateContext.displayName = "DataRouterState";
+const RSCRouterContext = React$1.createContext(false);
+function useIsRSCRouterContext() {
+	return React$1.useContext(RSCRouterContext);
+}
+const ViewTransitionContext = React$1.createContext({ isTransitioning: false });
+ViewTransitionContext.displayName = "ViewTransition";
+const FetchersContext = React$1.createContext(/* @__PURE__ */ new Map());
+FetchersContext.displayName = "Fetchers";
+const AwaitContext = React$1.createContext(null);
+AwaitContext.displayName = "Await";
+const AwaitContextProvider = (props) => React$1.createElement(AwaitContext.Provider, props);
+const NavigationContext = React$1.createContext(null);
+NavigationContext.displayName = "Navigation";
+const LocationContext = React$1.createContext(null);
+LocationContext.displayName = "Location";
+const RouteContext = React$1.createContext({
+	outlet: null,
+	matches: [],
+	isDataRoute: false
+});
+RouteContext.displayName = "Route";
+const RouteErrorContext = React$1.createContext(null);
+RouteErrorContext.displayName = "RouteError";
+//#endregion
+export { AwaitContext, AwaitContextProvider, DataRouterContext, DataRouterStateContext, FetchersContext, LocationContext, NavigationContext, RSCRouterContext, RouteContext, RouteErrorContext, ViewTransitionContext, useIsRSCRouterContext };

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

@@ -0,0 +1,119 @@
+
+import { FormEncType, HTMLFormMethod } from "../router/utils.js";
+import { RelativeRoutingType } from "../router/router.js";
+
+//#region lib/dom/dom.d.ts
+type ParamKeyValuePair = [string, string];
+type URLSearchParamsInit = string | ParamKeyValuePair[] | Record<string, string | string[]> | URLSearchParams;
+/**
+  Creates a URLSearchParams object using the given initializer.
+
+  This is identical to `new URLSearchParams(init)` except it also
+  supports arrays as values in the object form of the initializer
+  instead of just strings. This is convenient when you need multiple
+  values for a given key, but don't want to use an array initializer.
+
+  For example, instead of:
+
+  ```tsx
+  let searchParams = new URLSearchParams([
+    ['sort', 'name'],
+    ['sort', 'price']
+  ]);
+  ```
+  you can do:
+
+  ```
+  let searchParams = createSearchParams({
+    sort: ['name', 'price']
+  });
+  ```
+
+  @category Utils
+ */
+declare function createSearchParams(init?: URLSearchParamsInit): URLSearchParams;
+type JsonObject = { [Key in string]: JsonValue } & { [Key in string]?: JsonValue | undefined };
+type JsonArray = JsonValue[] | readonly JsonValue[];
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonObject | JsonArray;
+type SubmitTarget = HTMLFormElement | HTMLButtonElement | HTMLInputElement | FormData | URLSearchParams | JsonValue | null;
+/**
+ * Submit options shared by both navigations and fetchers
+ */
+interface SharedSubmitOptions {
+  /**
+   * The HTTP method used to submit the form. Overrides `<form method>`.
+   * Defaults to "GET".
+   */
+  method?: HTMLFormMethod;
+  /**
+   * The action URL path used to submit the form. Overrides `<form action>`.
+   * Defaults to the path of the current route.
+   */
+  action?: string;
+  /**
+   * The encoding used to submit the form. Overrides `<form encType>`.
+   * Defaults to "application/x-www-form-urlencoded".
+   */
+  encType?: FormEncType;
+  /**
+   * Determines whether the form action is relative to the route hierarchy or
+   * the pathname.  Use this if you want to opt out of navigating the route
+   * hierarchy and want to instead route based on /-delimited URL segments
+   */
+  relative?: RelativeRoutingType;
+  /**
+   * In browser-based environments, prevent resetting scroll after this
+   * navigation when using the <ScrollRestoration> component
+   */
+  preventScrollReset?: boolean;
+  /**
+   * Enable flushSync for this submission's state updates
+   */
+  flushSync?: boolean;
+  /**
+   * Specify the default revalidation behavior after this submission
+   *
+   * If no `shouldRevalidate` functions are present on the active routes, then this
+   * value will be used directly.  Otherwise it will be passed into `shouldRevalidate`
+   * so the route can make the final determination on revalidation. This can be
+   * useful when updating search params and you don't want to trigger a revalidation.
+   *
+   * By default (when not specified), loaders will revalidate according to the routers
+   * standard revalidation behavior.
+   */
+  defaultShouldRevalidate?: boolean;
+}
+/**
+ * Submit options available to fetchers
+ */
+interface FetcherSubmitOptions extends SharedSubmitOptions {}
+/**
+ * Submit options available to navigations
+ */
+interface SubmitOptions extends FetcherSubmitOptions {
+  /**
+   * Set `true` to replace the current entry in the browser's history stack
+   * instead of creating a new one (i.e. stay on "the same page"). Defaults
+   * to `false`.
+   */
+  replace?: boolean;
+  /**
+   * State object to add to the history stack entry for this navigation
+   */
+  state?: any;
+  /**
+   * Indicate a specific fetcherKey to use when using navigate=false
+   */
+  fetcherKey?: string;
+  /**
+   * navigate=false will use a fetcher instead of a navigation
+   */
+  navigate?: boolean;
+  /**
+   * Enable view transitions on this submission navigation
+   */
+  viewTransition?: boolean;
+}
+//#endregion
+export { FetcherSubmitOptions, ParamKeyValuePair, SubmitOptions, SubmitTarget, URLSearchParamsInit, createSearchParams };

package/dist/development/lib/dom/dom.js

@@ -0,0 +1,143 @@
+/**
+ * react-router v8.0.0-pre.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
+ */
+import { warning } from "../router/history.js";
+import { stripBasename } from "../router/utils.js";
+const defaultEncType = "application/x-www-form-urlencoded";
+function isHtmlElement(object) {
+	return typeof HTMLElement !== "undefined" && object instanceof HTMLElement;
+}
+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 && (!target || target === "_self") && !isModifiedEvent(event);
+}
+/**
+Creates a URLSearchParams object using the given initializer.
+
+This is identical to `new URLSearchParams(init)` except it also
+supports arrays as values in the object form of the initializer
+instead of just strings. This is convenient when you need multiple
+values for a given key, but don't want to use an array initializer.
+
+For example, instead of:
+
+```tsx
+let searchParams = new URLSearchParams([
+['sort', 'name'],
+['sort', 'price']
+]);
+```
+you can do:
+
+```
+let searchParams = createSearchParams({
+sort: ['name', 'price']
+});
+```
+
+@category Utils
+*/
+function createSearchParams(init = "") {
+	return new URLSearchParams(typeof init === "string" || Array.isArray(init) || init instanceof URLSearchParams ? init : Object.keys(init).reduce((memo, key) => {
+		let value = init[key];
+		return memo.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;
+}
+let _formDataSupportsSubmitter = null;
+function isFormDataSubmitterSupported() {
+	if (_formDataSupportsSubmitter === null) try {
+		new FormData(document.createElement("form"), 0);
+		_formDataSupportsSubmitter = false;
+	} catch (e) {
+		_formDataSupportsSubmitter = true;
+	}
+	return _formDataSupportsSubmitter;
+}
+const supportedFormEncTypes = new Set([
+	"application/x-www-form-urlencoded",
+	"multipart/form-data",
+	"text/plain"
+]);
+function getFormEncType(encType) {
+	if (encType != null && !supportedFormEncTypes.has(encType)) {
+		warning(false, `"${encType}" is not a valid \`encType\` for \`<Form>\`/\`<fetcher.Form>\` and will default to "${defaultEncType}"`);
+		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") || "get";
+		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") || "get";
+		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 = "get";
+		action = null;
+		encType = defaultEncType;
+		body = target;
+	}
+	if (formData && encType === "text/plain") {
+		body = formData;
+		formData = void 0;
+	}
+	return {
+		action,
+		method: method.toLowerCase(),
+		encType,
+		formData,
+		body
+	};
+}
+//#endregion
+export { createSearchParams, getFormSubmissionInfo, getSearchParamsForLocation, shouldProcessLinkClick };