Ajout de promotion et de commande

node_modules/@remix-run/router/LICENSE.md

@@ -0,0 +1,23 @@
+MIT License
+
+Copyright (c) React Training LLC 2015-2019
+Copyright (c) Remix Software Inc. 2020-2021
+Copyright (c) Shopify Inc. 2022-2023
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/@remix-run/router/README.md

@@ -0,0 +1,135 @@
+# Remix Router
+
+The `@remix-run/router` package is a framework-agnostic routing package (sometimes referred to as a browser-emulator) that serves as the heart of [React Router][react-router] and [Remix][remix] and provides all the core functionality for routing coupled with data loading and data mutations. It comes with built-in handling of errors, race-conditions, interruptions, cancellations, lazy-loading data, and much, much more.
+
+If you're using React Router, you should never `import` anything directly from the `@remix-run/router` - you should have everything you need in `react-router-dom` (or `react-router`/`react-router-native` if you're not rendering in the browser). All of those packages should re-export everything you would otherwise need from `@remix-run/router`.
+
+> [!WARNING]
+>
+> This router is a low-level package intended to be consumed by UI layer routing libraries. You should very likely not be using this package directly unless you are authoring a routing library such as [`react-router-dom`][react-router-repo] or one of it's other [UI ports][remix-routers-repo].
+
+## API
+
+A Router instance can be created using `createRouter`:
+
+```js
+// Create and initialize a router.  "initialize" contains all side effects
+// including history listeners and kicking off the initial data fetch
+let router = createRouter({
+  // Required properties
+  routes: [{
+    path: '/',
+    loader: ({ request, params }) => { /* ... */ },
+    children: [{
+      path: 'home',
+      loader: ({ request, params }) => { /* ... */ },
+    }]
+  },
+  history: createBrowserHistory(),
+
+  // Optional properties
+  basename, // Base path
+  mapRouteProperties, // Map framework-agnostic routes to framework-aware routes
+  future, // Future flags
+  hydrationData, // Hydration data if using server-side-rendering
+}).initialize();
+```
+
+Internally, the Router represents the state in an object of the following format, which is available through `router.state`. You can also register a subscriber of the signature `(state: RouterState) => void` to execute when the state updates via `router.subscribe()`;
+
+```ts
+interface RouterState {
+  // False during the initial data load, true once we have our initial data
+  initialized: boolean;
+  // The `history` action of the most recently completed navigation
+  historyAction: Action;
+  // The current location of the router.  During a navigation this reflects
+  // the "old" location and is updated upon completion of the navigation
+  location: Location;
+  // The current set of route matches
+  matches: DataRouteMatch[];
+  // The state of the current navigation
+  navigation: Navigation;
+  // The state of any in-progress router.revalidate() calls
+  revalidation: RevalidationState;
+  // Data from the loaders for the current matches
+  loaderData: RouteData;
+  // Data from the action for the current matches
+  actionData: RouteData | null;
+  // Errors thrown from loaders/actions for the current matches
+  errors: RouteData | null;
+  // Map of all active fetchers
+  fetchers: Map<string, Fetcher>;
+  // Scroll position to restore to for the active Location, false if we
+  // should not restore, or null if we don't have a saved position
+  // Note: must be enabled via router.enableScrollRestoration()
+  restoreScrollPosition: number | false | null;
+  // Proxied `preventScrollReset` value passed to router.navigate()
+  preventScrollReset: boolean;
+}
+```
+
+### Navigations
+
+All navigations are done through the `router.navigate` API which is overloaded to support different types of navigations:
+
+```js
+// Link navigation (pushes onto the history stack by default)
+router.navigate("/page");
+
+// Link navigation (replacing the history stack)
+router.navigate("/page", { replace: true });
+
+// Pop navigation (moving backward/forward in the history stack)
+router.navigate(-1);
+
+// Form submission navigation
+let formData = new FormData();
+formData.append(key, value);
+router.navigate("/page", {
+  formMethod: "post",
+  formData,
+});
+
+// Relative routing from a source routeId
+router.navigate("../../somewhere", {
+  fromRouteId: "active-route-id",
+});
+```
+
+### Fetchers
+
+Fetchers are a mechanism to call loaders/actions without triggering a navigation, and are done through the `router.fetch()` API. All fetch calls require a unique key to identify the fetcher.
+
+```js
+// Execute the loader for /page
+router.fetch("key", "/page");
+
+// Submit to the action for /page
+let formData = new FormData();
+formData.append(key, value);
+router.fetch("key", "/page", {
+  formMethod: "post",
+  formData,
+});
+```
+
+### Revalidation
+
+By default, active loaders will revalidate after any navigation or fetcher mutation. If you need to kick off a revalidation for other use-cases, you can use `router.revalidate()` to re-execute all active loaders.
+
+### Future Flags
+
+We use _Future Flags_ in the router to help us introduce breaking changes in an opt-in fashion ahead of major releases. Please check out the [blog post][future-flags-post] and [React Router Docs][api-development-strategy] for more information on this process. The currently available future flags in `@remix-run/router` are:
+
+| Flag                     | Description                                                               |
+| ------------------------ | ------------------------------------------------------------------------- |
+| `v7_normalizeFormMethod` | Normalize `useNavigation().formMethod` to be an uppercase HTTP Method     |
+| `v7_prependBasename`     | Prepend the `basename` to incoming `router.navigate`/`router.fetch` paths |
+
+[react-router]: https://reactrouter.com
+[remix]: https://remix.run
+[react-router-repo]: https://github.com/remix-run/react-router
+[remix-routers-repo]: https://github.com/brophdawg11/remix-routers
+[api-development-strategy]: https://reactrouter.com/v6/guides/api-development-strategy
+[future-flags-post]: https://remix.run/blog/future-flags

node_modules/@remix-run/router/dist/history.d.ts

@@ -0,0 +1,250 @@
+/**
+ * Actions represent the type of change to a location value.
+ */
+export 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.
+ */
+export 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.
+ */
+export 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;
+}
+/**
+ * A change to the current location.
+ */
+export 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.
+ */
+export interface Listener {
+    (update: Update): void;
+}
+/**
+ * Describes a location that is the destination of some navigation, either via
+ * `history.push` or `history.replace`. This may be either a URL or the pieces
+ * of a URL path.
+ */
+export 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.
+ */
+export 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.
+ */
+export type InitialEntry = string | Partial<Location>;
+export 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.
+ */
+export 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.
+ */
+export 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
+ */
+export interface BrowserHistory extends UrlHistory {
+}
+export 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
+ */
+export 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
+ */
+export interface HashHistory extends UrlHistory {
+}
+export 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
+ */
+export declare function createHashHistory(options?: HashHistoryOptions): HashHistory;
+/**
+ * @private
+ */
+export declare function invariant(value: boolean, message?: string): asserts value;
+export declare function invariant<T>(value: T | null | undefined, message?: string): asserts value is T;
+export declare function warning(cond: any, message: string): void;
+/**
+ * Creates a Location object with a unique key from the given Path
+ */
+export declare function createLocation(current: string | Location, to: To, state?: any, key?: string): Readonly<Location>;
+/**
+ * Creates a string URL path from the given pathname, search, and hash components.
+ */
+export declare function createPath({ pathname, search, hash, }: Partial<Path>): string;
+/**
+ * Parses a string URL path into its separate pathname, search, and hash components.
+ */
+export declare function parsePath(path: string): Partial<Path>;
+export interface UrlHistory extends History {
+}
+export type UrlHistoryOptions = {
+    window?: Window;
+    v5Compat?: boolean;
+};

node_modules/@remix-run/router/dist/index.d.ts

@@ -0,0 +1,9 @@
+export type { ActionFunction, ActionFunctionArgs, AgnosticDataIndexRouteObject, AgnosticDataNonIndexRouteObject, AgnosticDataRouteMatch, AgnosticDataRouteObject, AgnosticIndexRouteObject, AgnosticNonIndexRouteObject, AgnosticPatchRoutesOnNavigationFunction, AgnosticPatchRoutesOnNavigationFunctionArgs, AgnosticRouteMatch, AgnosticRouteObject, DataStrategyFunction, DataStrategyFunctionArgs, DataStrategyMatch, DataStrategyResult, ErrorResponse, FormEncType, FormMethod, HTMLFormMethod, JsonFunction, LazyRouteFunction, LoaderFunction, LoaderFunctionArgs, ParamParseKey, Params, PathMatch, PathParam, PathPattern, RedirectFunction, ShouldRevalidateFunction, ShouldRevalidateFunctionArgs, TrackedPromise, UIMatch, V7_FormMethod, DataWithResponseInit as UNSAFE_DataWithResponseInit, } from "./utils";
+export { AbortedDeferredError, data, defer, generatePath, getToPathname, isRouteErrorResponse, joinPaths, json, matchPath, matchRoutes, normalizePathname, redirect, redirectDocument, replace, resolvePath, resolveTo, stripBasename, } from "./utils";
+export type { BrowserHistory, BrowserHistoryOptions, HashHistory, HashHistoryOptions, History, InitialEntry, Location, MemoryHistory, MemoryHistoryOptions, Path, To, } from "./history";
+export { Action, createBrowserHistory, createHashHistory, createMemoryHistory, createPath, parsePath, } from "./history";
+export * from "./router";
+/** @internal */
+export type { RouteManifest as UNSAFE_RouteManifest } from "./utils";
+export { DeferredData as UNSAFE_DeferredData, ErrorResponseImpl as UNSAFE_ErrorResponseImpl, convertRoutesToDataRoutes as UNSAFE_convertRoutesToDataRoutes, convertRouteMatchToUiMatch as UNSAFE_convertRouteMatchToUiMatch, decodePath as UNSAFE_decodePath, getResolveToMatches as UNSAFE_getResolveToMatches, } from "./utils";
+export { invariant as UNSAFE_invariant, warning as UNSAFE_warning, } from "./history";

node_modules/@remix-run/router/index.ts

@@ -0,0 +1,106 @@
+export type {
+  ActionFunction,
+  ActionFunctionArgs,
+  AgnosticDataIndexRouteObject,
+  AgnosticDataNonIndexRouteObject,
+  AgnosticDataRouteMatch,
+  AgnosticDataRouteObject,
+  AgnosticIndexRouteObject,
+  AgnosticNonIndexRouteObject,
+  AgnosticPatchRoutesOnNavigationFunction,
+  AgnosticPatchRoutesOnNavigationFunctionArgs,
+  AgnosticRouteMatch,
+  AgnosticRouteObject,
+  DataStrategyFunction,
+  DataStrategyFunctionArgs,
+  DataStrategyMatch,
+  DataStrategyResult,
+  ErrorResponse,
+  FormEncType,
+  FormMethod,
+  HTMLFormMethod,
+  JsonFunction,
+  LazyRouteFunction,
+  LoaderFunction,
+  LoaderFunctionArgs,
+  ParamParseKey,
+  Params,
+  PathMatch,
+  PathParam,
+  PathPattern,
+  RedirectFunction,
+  ShouldRevalidateFunction,
+  ShouldRevalidateFunctionArgs,
+  TrackedPromise,
+  UIMatch,
+  V7_FormMethod,
+  DataWithResponseInit as UNSAFE_DataWithResponseInit,
+} from "./utils";
+
+export {
+  AbortedDeferredError,
+  data,
+  defer,
+  generatePath,
+  getToPathname,
+  isRouteErrorResponse,
+  joinPaths,
+  json,
+  matchPath,
+  matchRoutes,
+  normalizePathname,
+  redirect,
+  redirectDocument,
+  replace,
+  resolvePath,
+  resolveTo,
+  stripBasename,
+} from "./utils";
+
+export type {
+  BrowserHistory,
+  BrowserHistoryOptions,
+  HashHistory,
+  HashHistoryOptions,
+  History,
+  InitialEntry,
+  Location,
+  MemoryHistory,
+  MemoryHistoryOptions,
+  Path,
+  To,
+} from "./history";
+
+export {
+  Action,
+  createBrowserHistory,
+  createHashHistory,
+  createMemoryHistory,
+  createPath,
+  parsePath,
+} from "./history";
+
+export * from "./router";
+
+///////////////////////////////////////////////////////////////////////////////
+// DANGER! PLEASE READ ME!
+// We consider these exports an implementation detail and do not guarantee
+// against any breaking changes, regardless of the semver release. Use with
+// extreme caution and only if you understand the consequences. Godspeed.
+///////////////////////////////////////////////////////////////////////////////
+
+/** @internal */
+export type { RouteManifest as UNSAFE_RouteManifest } from "./utils";
+export {
+  DeferredData as UNSAFE_DeferredData,
+  ErrorResponseImpl as UNSAFE_ErrorResponseImpl,
+  convertRoutesToDataRoutes as UNSAFE_convertRoutesToDataRoutes,
+  convertRouteMatchToUiMatch as UNSAFE_convertRouteMatchToUiMatch,
+  decodePath as UNSAFE_decodePath,
+  getResolveToMatches as UNSAFE_getResolveToMatches,
+} from "./utils";
+
+export {
+  invariant as UNSAFE_invariant,
+  warning as UNSAFE_warning,
+} from "./history";

node_modules/@remix-run/router/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@remix-run/router",
+  "version": "1.23.2",
+  "description": "Nested/Data-driven/Framework-agnostic Routing",
+  "keywords": [
+    "remix",
+    "router",
+    "location"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/remix-run/react-router",
+    "directory": "packages/router"
+  },
+  "license": "MIT",
+  "author": "Remix Software <hello@remix.run>",
+  "sideEffects": false,
+  "main": "./dist/router.cjs.js",
+  "unpkg": "./dist/router.umd.min.js",
+  "module": "./dist/router.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/",
+    "*.ts",
+    "CHANGELOG.md"
+  ],
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}