@epic-web/workshop-app 5.1.0 → 5.1.1

package/node_modules/@remix-run/react/LICENSE.md

@@ -1,22 +0,0 @@
-MIT License
-
-Copyright (c) Remix Software Inc. 2020-2021
-Copyright (c) Shopify Inc. 2022-2024
-
-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.

package/node_modules/@remix-run/react/README.md

@@ -1,13 +0,0 @@
-# Welcome to Remix!
-
-[Remix](https://remix.run) is a web framework that helps you build better websites with React.
-
-To get started, open a new shell and run:
-
-```sh
-npx create-remix@latest
-```
-
-Then follow the prompts you see in your terminal.
-
-For more information about Remix, [visit remix.run](https://remix.run)!

package/node_modules/@remix-run/react/dist/_virtual/_rollupPluginBabelHelpers.js

@@ -1,30 +0,0 @@
-/**
- * @remix-run/react v2.10.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
- */
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-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);
-}
-
-exports["extends"] = _extends;

package/node_modules/@remix-run/react/dist/browser.d.ts

@@ -1,37 +0,0 @@
-import type { HydrationState, Router } from "@remix-run/router";
-import type { ReactElement } from "react";
-import type { AssetsManifest, FutureConfig } from "./entry";
-import type { RouteModules } from "./routeModules";
-declare global {
-    var __remixContext: {
-        url: string;
-        basename?: string;
-        state: HydrationState;
-        criticalCss?: string;
-        future: FutureConfig;
-        isSpaMode: boolean;
-        stream: ReadableStream<Uint8Array> | undefined;
-        streamController: ReadableStreamDefaultController<Uint8Array>;
-        a?: number;
-        dev?: {
-            port?: number;
-            hmrRuntime?: string;
-        };
-    };
-    var __remixRouter: Router;
-    var __remixRouteModules: RouteModules;
-    var __remixManifest: AssetsManifest;
-    var __remixRevalidation: number | undefined;
-    var __remixClearCriticalCss: (() => void) | undefined;
-    var $RefreshRuntime$: {
-        performReactRefresh: () => void;
-    };
-}
-export interface RemixBrowserProps {
-}
-/**
- * The entry point for a Remix app when it is rendered in the browser (in
- * `app/entry.client.js`). This component is used by React to hydrate the HTML
- * that was received from the server.
- */
-export declare function RemixBrowser(_props: RemixBrowserProps): ReactElement;

package/node_modules/@remix-run/react/dist/browser.js

@@ -1,268 +0,0 @@
-/**
- * @remix-run/react v2.10.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
- */
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var router$1 = require('@remix-run/router');
-var React = require('react');
-var reactRouter = require('react-router');
-var reactRouterDom = require('react-router-dom');
-var components = require('./components.js');
-var errorBoundaries = require('./errorBoundaries.js');
-var errors = require('./errors.js');
-var routes = require('./routes.js');
-var singleFetch = require('./single-fetch.js');
-var invariant = require('./invariant.js');
-var fogOfWar = require('./fog-of-war.js');
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n["default"] = e;
-  return Object.freeze(n);
-}
-
-var React__namespace = /*#__PURE__*/_interopNamespace(React);
-
-/* eslint-disable prefer-let/prefer-let */
-
-/* eslint-enable prefer-let/prefer-let */
-
-let stateDecodingPromise;
-let router;
-let routerInitialized = false;
-let hmrRouterReadyResolve;
-// There's a race condition with HMR where the remix:manifest is signaled before
-// the router is assigned in the RemixBrowser component. This promise gates the
-// HMR handler until the router is ready
-new Promise(resolve => {
-  // body of a promise is executed immediately, so this can be resolved outside
-  // of the promise body
-  hmrRouterReadyResolve = resolve;
-}).catch(() => {
-  // This is a noop catch handler to avoid unhandled promise rejection warnings
-  // in the console. The promise is never rejected.
-  return undefined;
-});
-
-/**
- * The entry point for a Remix app when it is rendered in the browser (in
- * `app/entry.client.js`). This component is used by React to hydrate the HTML
- * that was received from the server.
- */
-function RemixBrowser(_props) {
-  if (!router) {
-    // Hard reload if the path we tried to load is not the current path.
-    // This is usually the result of 2 rapid back/forward clicks from an
-    // external site into a Remix app, where we initially start the load for
-    // one URL and while the JS chunks are loading a second forward click moves
-    // us to a new URL.  Avoid comparing search params because of CDNs which
-    // can be configured to ignore certain params and only pathname is relevant
-    // towards determining the route matches.
-    let initialPathname = window.__remixContext.url;
-    let hydratedPathname = window.location.pathname;
-    if (initialPathname !== hydratedPathname && !window.__remixContext.isSpaMode) {
-      let errorMsg = `Initial URL (${initialPathname}) does not match URL at time of hydration ` + `(${hydratedPathname}), reloading page...`;
-      console.error(errorMsg);
-      window.location.reload();
-      // Get out of here so the reload can happen - don't create the router
-      // since it'll then kick off unnecessary route.lazy() loads
-      return /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null);
-    }
-
-    // When single fetch is enabled, we need to suspend until the initial state
-    // snapshot is decoded into window.__remixContext.state
-    if (window.__remixContext.future.unstable_singleFetch) {
-      // Note: `stateDecodingPromise` is not coupled to `router` - we'll reach this
-      // code potentially many times waiting for our state to arrive, but we'll
-      // then only get past here and create the `router` one time
-      if (!stateDecodingPromise) {
-        let stream = window.__remixContext.stream;
-        invariant(stream, "No stream found for single fetch decoding");
-        window.__remixContext.stream = undefined;
-        stateDecodingPromise = singleFetch.decodeViaTurboStream(stream, window).then(value => {
-          window.__remixContext.state = value.value;
-          stateDecodingPromise.value = true;
-        }).catch(e => {
-          stateDecodingPromise.error = e;
-        });
-      }
-      if (stateDecodingPromise.error) {
-        throw stateDecodingPromise.error;
-      }
-      if (!stateDecodingPromise.value) {
-        throw stateDecodingPromise;
-      }
-    }
-    let routes$1 = routes.createClientRoutes(window.__remixManifest.routes, window.__remixRouteModules, window.__remixContext.state, window.__remixContext.future, window.__remixContext.isSpaMode);
-    let hydrationData = undefined;
-    if (!window.__remixContext.isSpaMode) {
-      // Create a shallow clone of `loaderData` we can mutate for partial hydration.
-      // When a route exports a `clientLoader` and a `HydrateFallback`, the SSR will
-      // render the fallback so we need the client to do the same for hydration.
-      // The server loader data has already been exposed to these route `clientLoader`'s
-      // in `createClientRoutes` above, so we need to clear out the version we pass to
-      // `createBrowserRouter` so it initializes and runs the client loaders.
-      hydrationData = {
-        ...window.__remixContext.state,
-        loaderData: {
-          ...window.__remixContext.state.loaderData
-        }
-      };
-      let initialMatches = reactRouterDom.matchRoutes(routes$1, window.location, window.__remixContext.basename);
-      if (initialMatches) {
-        for (let match of initialMatches) {
-          let routeId = match.route.id;
-          let route = window.__remixRouteModules[routeId];
-          let manifestRoute = window.__remixManifest.routes[routeId];
-          // Clear out the loaderData to avoid rendering the route component when the
-          // route opted into clientLoader hydration and either:
-          // * gave us a HydrateFallback
-          // * or doesn't have a server loader and we have no data to render
-          if (route && routes.shouldHydrateRouteLoader(manifestRoute, route, window.__remixContext.isSpaMode) && (route.HydrateFallback || !manifestRoute.hasLoader)) {
-            hydrationData.loaderData[routeId] = undefined;
-          } else if (manifestRoute && !manifestRoute.hasLoader) {
-            // Since every Remix route gets a `loader` on the client side to load
-            // the route JS module, we need to add a `null` value to `loaderData`
-            // for any routes that don't have server loaders so our partial
-            // hydration logic doesn't kick off the route module loaders during
-            // hydration
-            hydrationData.loaderData[routeId] = null;
-          }
-        }
-      }
-      if (hydrationData && hydrationData.errors) {
-        hydrationData.errors = errors.deserializeErrors(hydrationData.errors);
-      }
-    }
-    let {
-      enabled: isFogOfWarEnabled,
-      patchRoutesOnMiss
-    } = fogOfWar.initFogOfWar(window.__remixManifest, window.__remixRouteModules, window.__remixContext.future, window.__remixContext.isSpaMode, window.__remixContext.basename);
-
-    // We don't use createBrowserRouter here because we need fine-grained control
-    // over initialization to support synchronous `clientLoader` flows.
-    router = router$1.createRouter({
-      routes: routes$1,
-      history: router$1.createBrowserHistory(),
-      basename: window.__remixContext.basename,
-      future: {
-        v7_normalizeFormMethod: true,
-        v7_fetcherPersist: window.__remixContext.future.v3_fetcherPersist,
-        v7_partialHydration: true,
-        v7_prependBasename: true,
-        v7_relativeSplatPath: window.__remixContext.future.v3_relativeSplatPath,
-        // Single fetch enables this underlying behavior
-        unstable_skipActionErrorRevalidation: window.__remixContext.future.unstable_singleFetch === true
-      },
-      hydrationData,
-      mapRouteProperties: reactRouter.UNSAFE_mapRouteProperties,
-      unstable_dataStrategy: window.__remixContext.future.unstable_singleFetch ? singleFetch.getSingleFetchDataStrategy(window.__remixManifest, window.__remixRouteModules) : undefined,
-      ...(isFogOfWarEnabled ? {
-        unstable_patchRoutesOnMiss: patchRoutesOnMiss
-      } : {})
-    });
-
-    // We can call initialize() immediately if the router doesn't have any
-    // loaders to run on hydration
-    if (router.state.initialized) {
-      routerInitialized = true;
-      router.initialize();
-    }
-
-    // @ts-ignore
-    router.createRoutesForHMR = routes.createClientRoutesWithHMRRevalidationOptOut;
-    window.__remixRouter = router;
-
-    // Notify that the router is ready for HMR
-    if (hmrRouterReadyResolve) {
-      hmrRouterReadyResolve(router);
-    }
-  }
-
-  // Critical CSS can become stale after code changes, e.g. styles might be
-  // removed from a component, but the styles will still be present in the
-  // server HTML. This allows our HMR logic to clear the critical CSS state.
-  // eslint-disable-next-line react-hooks/rules-of-hooks
-  let [criticalCss, setCriticalCss] = React__namespace.useState(process.env.NODE_ENV === "development" ? window.__remixContext.criticalCss : undefined);
-  if (process.env.NODE_ENV === "development") {
-    window.__remixClearCriticalCss = () => setCriticalCss(undefined);
-  }
-
-  // This is due to the short circuit return above when the pathname doesn't
-  // match and we force a hard reload.  This is an exceptional scenario in which
-  // we can't hydrate anyway.
-  // eslint-disable-next-line react-hooks/rules-of-hooks
-  let [location, setLocation] = React__namespace.useState(router.state.location);
-
-  // eslint-disable-next-line react-hooks/rules-of-hooks
-  React__namespace.useLayoutEffect(() => {
-    // If we had to run clientLoaders on hydration, we delay initialization until
-    // after we've hydrated to avoid hydration issues from synchronous client loaders
-    if (!routerInitialized) {
-      routerInitialized = true;
-      router.initialize();
-    }
-  }, []);
-
-  // eslint-disable-next-line react-hooks/rules-of-hooks
-  React__namespace.useLayoutEffect(() => {
-    return router.subscribe(newState => {
-      if (newState.location !== location) {
-        setLocation(newState.location);
-      }
-    });
-  }, [location]);
-
-  // eslint-disable-next-line react-hooks/rules-of-hooks
-  fogOfWar.useFogOFWarDiscovery(router, window.__remixManifest, window.__remixRouteModules, window.__remixContext.future, window.__remixContext.isSpaMode);
-
-  // We need to include a wrapper RemixErrorBoundary here in case the root error
-  // boundary also throws and we need to bubble up outside of the router entirely.
-  // Then we need a stateful location here so the user can back-button navigate
-  // out of there
-  return (
-    /*#__PURE__*/
-    // This fragment is important to ensure we match the <RemixServer> JSX
-    // structure so that useId values hydrate correctly
-    React__namespace.createElement(React__namespace.Fragment, null, /*#__PURE__*/React__namespace.createElement(components.RemixContext.Provider, {
-      value: {
-        manifest: window.__remixManifest,
-        routeModules: window.__remixRouteModules,
-        future: window.__remixContext.future,
-        criticalCss,
-        isSpaMode: window.__remixContext.isSpaMode
-      }
-    }, /*#__PURE__*/React__namespace.createElement(errorBoundaries.RemixErrorBoundary, {
-      location: location
-    }, /*#__PURE__*/React__namespace.createElement(reactRouterDom.RouterProvider, {
-      router: router,
-      fallbackElement: null,
-      future: {
-        v7_startTransition: true
-      }
-    }))), window.__remixContext.future.unstable_singleFetch ? /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null) : null)
-  );
-}
-
-exports.RemixBrowser = RemixBrowser;

package/node_modules/@remix-run/react/dist/components.d.ts

@@ -1,137 +0,0 @@
-import * as React from "react";
-import type { UIMatch as UIMatchRR } from "@remix-run/router";
-import type { FetcherWithComponents, LinkProps, NavLinkProps } from "react-router-dom";
-import { useFetcher as useFetcherRR } from "react-router-dom";
-import type { SerializeFrom } from "@remix-run/server-runtime";
-import type { AppData } from "./data";
-import type { RemixContextObject } from "./entry";
-import type { PrefetchPageDescriptor } from "./links";
-import type { RouteHandle } from "./routeModules";
-export declare const RemixContext: React.Context<RemixContextObject | undefined>;
-export declare function useRemixContext(): RemixContextObject;
-/**
- * Defines the discovery behavior of the link:
- *
- * - "render": Eagerly discover when the link is rendered (default)
- * - "none": No eager discovery - discover when the link is clicked
- */
-export type DiscoverBehavior = "render" | "none";
-/**
- * Defines the prefetching behavior of the link:
- *
- * - "none": Never fetched
- * - "intent": Fetched when the user focuses or hovers the link
- * - "render": Fetched when the link is rendered
- * - "viewport": Fetched when the link is in the viewport
- */
-type PrefetchBehavior = "intent" | "render" | "none" | "viewport";
-export interface RemixLinkProps extends LinkProps {
-    discover?: DiscoverBehavior;
-    prefetch?: PrefetchBehavior;
-}
-export interface RemixNavLinkProps extends NavLinkProps {
-    discover?: DiscoverBehavior;
-    prefetch?: PrefetchBehavior;
-}
-/**
- * A special kind of `<Link>` that knows whether it is "active".
- *
- * @see https://remix.run/components/nav-link
- */
-declare let NavLink: React.ForwardRefExoticComponent<RemixNavLinkProps & React.RefAttributes<HTMLAnchorElement>>;
-export { NavLink };
-/**
- * This component renders an anchor tag and is the primary way the user will
- * navigate around your website.
- *
- * @see https://remix.run/components/link
- */
-declare let Link: React.ForwardRefExoticComponent<RemixLinkProps & React.RefAttributes<HTMLAnchorElement>>;
-export { Link };
-export declare function composeEventHandlers<EventType extends React.SyntheticEvent | Event>(theirHandler: ((event: EventType) => any) | undefined, ourHandler: (event: EventType) => any): (event: EventType) => any;
-/**
- * Renders the `<link>` tags for the current routes.
- *
- * @see https://remix.run/components/links
- */
-export declare function Links(): React.JSX.Element;
-/**
- * This component renders all the `<link rel="prefetch">` and
- * `<link rel="modulepreload"/>` tags for all the assets (data, modules, css) of
- * a given page.
- *
- * @param props
- * @param props.page
- * @see https://remix.run/components/prefetch-page-links
- */
-export declare function PrefetchPageLinks({ page, ...dataLinkProps }: PrefetchPageDescriptor): React.JSX.Element | null;
-/**
- * Renders HTML tags related to metadata for the current route.
- *
- * @see https://remix.run/components/meta
- */
-export declare function Meta(): React.JSX.Element;
-export interface AwaitProps<Resolve> {
-    children: React.ReactNode | ((value: Awaited<Resolve>) => React.ReactNode);
-    errorElement?: React.ReactNode;
-    resolve: Resolve;
-}
-export declare function Await<Resolve>(props: AwaitProps<Resolve>): React.JSX.Element;
-export type ScriptProps = Omit<React.HTMLProps<HTMLScriptElement>, "children" | "async" | "defer" | "src" | "type" | "noModule" | "dangerouslySetInnerHTML" | "suppressHydrationWarning">;
-/**
- * Renders the `<script>` tags needed for the initial render. Bundles for
- * additional routes are loaded later as needed.
- *
- * @param props Additional properties to add to each script tag that is rendered.
- * In addition to scripts, \<link rel="modulepreload"> tags receive the crossOrigin
- * property if provided.
- *
- * @see https://remix.run/components/scripts
- */
-export declare function Scripts(props: ScriptProps): React.JSX.Element | null;
-export type UIMatch<D = AppData, H = RouteHandle> = UIMatchRR<SerializeFrom<D>, H>;
-/**
- * Returns the active route matches, useful for accessing loaderData for
- * parent/child routes or the route "handle" property
- *
- * @see https://remix.run/hooks/use-matches
- */
-export declare function useMatches(): UIMatch[];
-/**
- * Returns the JSON parsed data from the current route's `loader`.
- *
- * @see https://remix.run/hooks/use-loader-data
- */
-export declare function useLoaderData<T = AppData>(): SerializeFrom<T>;
-/**
- * Returns the loaderData for the given routeId.
- *
- * @see https://remix.run/hooks/use-route-loader-data
- */
-export declare function useRouteLoaderData<T = AppData>(routeId: string): SerializeFrom<T> | undefined;
-/**
- * Returns the JSON parsed data from the current route's `action`.
- *
- * @see https://remix.run/hooks/use-action-data
- */
-export declare function useActionData<T = AppData>(): SerializeFrom<T> | undefined;
-/**
- * Interacts with route loaders and actions without causing a navigation. Great
- * for any interaction that stays on the same page.
- *
- * @see https://remix.run/hooks/use-fetcher
- */
-export declare function useFetcher<TData = AppData>(opts?: Parameters<typeof useFetcherRR>[0]): FetcherWithComponents<SerializeFrom<TData>>;
-/**
- * This component connects your app to the Remix asset server and
- * automatically reloads the page when files change in development.
- * In production, it renders null, so you can safely render it always in your root route.
- *
- * @see https://remix.run/docs/components/live-reload
- */
-export declare const LiveReload: ({ origin, port, timeoutMs, nonce, }: {
-    origin?: string | undefined;
-    port?: number | undefined;
-    timeoutMs?: number | undefined;
-    nonce?: string | undefined;
-}) => React.JSX.Element | null;