@epic-web/workshop-app 5.1.0 → 5.1.1

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

@@ -1,34 +0,0 @@
-import * as React from "react";
-import type { ActionFunctionArgs as RRActionArgs, LoaderFunctionArgs as RRLoaderArgs, unstable_DataStrategyFunction as DataStrategyFunction } from "@remix-run/router";
-import type { unstable_Action, unstable_Loader, unstable_Serialize } from "@remix-run/server-runtime";
-import type { DataRouteObject } from "react-router-dom";
-import type { AssetsManifest, EntryContext } from "./entry";
-import type { RouteModules } from "./routeModules";
-type ClientLoaderArgs = RRLoaderArgs<undefined> & {
-    serverLoader: <T extends unstable_Loader>() => Promise<unstable_Serialize<T>>;
-};
-export type ClientLoader = (args: ClientLoaderArgs) => unknown;
-export declare let defineClientLoader: <T extends ClientLoader>(clientLoader: T) => T & {
-    hydrate?: boolean | undefined;
-};
-type ClientActionArgs = RRActionArgs<undefined> & {
-    serverAction: <T extends unstable_Action>() => Promise<unstable_Serialize<T>>;
-};
-export type ClientAction = (args: ClientActionArgs) => unknown;
-export declare let defineClientAction: <T extends ClientAction>(clientAction: T) => T;
-interface StreamTransferProps {
-    context: EntryContext;
-    identifier: number;
-    reader: ReadableStreamDefaultReader<Uint8Array>;
-    textDecoder: TextDecoder;
-    nonce?: string;
-}
-export declare function StreamTransfer({ context, identifier, reader, textDecoder, nonce, }: StreamTransferProps): React.JSX.Element | null;
-export declare function getSingleFetchDataStrategy(manifest: AssetsManifest, routeModules: RouteModules): DataStrategyFunction;
-export declare function addRevalidationParam(manifest: AssetsManifest, routeModules: RouteModules, matchedRoutes: DataRouteObject[], loadRoutes: DataRouteObject[], url: URL): URL;
-export declare function singleFetchUrl(reqUrl: URL | string): URL;
-export declare function decodeViaTurboStream(body: ReadableStream<Uint8Array>, global: Window | typeof globalThis): Promise<{
-    done: Promise<undefined>;
-    value: unknown;
-}>;
-export {};

package/node_modules/@remix-run/react/dist/single-fetch.js

@@ -1,339 +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 React = require('react');
-var router = require('@remix-run/router');
-var serverRuntime = require('@remix-run/server-runtime');
-var turboStream = require('turbo-stream');
-var data = require('./data.js');
-var markup = require('./markup.js');
-var invariant = require('./invariant.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);
-
-// clientLoader
-
-let defineClientLoader = clientLoader => clientLoader;
-
-// clientAction
-
-let defineClientAction = clientAction => clientAction;
-// StreamTransfer recursively renders down chunks of the `serverHandoffStream`
-// into the client-side `streamController`
-function StreamTransfer({
-  context,
-  identifier,
-  reader,
-  textDecoder,
-  nonce
-}) {
-  // If the user didn't render the <Scripts> component then we don't have to
-  // bother streaming anything in
-  if (!context.renderMeta || !context.renderMeta.didRenderScripts) {
-    return null;
-  }
-  if (!context.renderMeta.streamCache) {
-    context.renderMeta.streamCache = {};
-  }
-  let {
-    streamCache
-  } = context.renderMeta;
-  let promise = streamCache[identifier];
-  if (!promise) {
-    promise = streamCache[identifier] = reader.read().then(result => {
-      streamCache[identifier].result = {
-        done: result.done,
-        value: textDecoder.decode(result.value, {
-          stream: true
-        })
-      };
-    }).catch(e => {
-      streamCache[identifier].error = e;
-    });
-  }
-  if (promise.error) {
-    throw promise.error;
-  }
-  if (promise.result === undefined) {
-    throw promise;
-  }
-  let {
-    done,
-    value
-  } = promise.result;
-  let scriptTag = value ? /*#__PURE__*/React__namespace.createElement("script", {
-    nonce: nonce,
-    dangerouslySetInnerHTML: {
-      __html: `window.__remixContext.streamController.enqueue(${markup.escapeHtml(JSON.stringify(value))});`
-    }
-  }) : null;
-  if (done) {
-    return /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, scriptTag, /*#__PURE__*/React__namespace.createElement("script", {
-      nonce: nonce,
-      dangerouslySetInnerHTML: {
-        __html: `window.__remixContext.streamController.close();`
-      }
-    }));
-  } else {
-    return /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, scriptTag, /*#__PURE__*/React__namespace.createElement(React__namespace.Suspense, null, /*#__PURE__*/React__namespace.createElement(StreamTransfer, {
-      context: context,
-      identifier: identifier + 1,
-      reader: reader,
-      textDecoder: textDecoder,
-      nonce: nonce
-    })));
-  }
-}
-function getSingleFetchDataStrategy(manifest, routeModules) {
-  return async ({
-    request,
-    matches
-  }) => request.method !== "GET" ? singleFetchActionStrategy(request, matches) : singleFetchLoaderStrategy(manifest, routeModules, request, matches);
-}
-
-// Actions are simple since they're singular calls to the server
-function singleFetchActionStrategy(request, matches) {
-  return Promise.all(matches.map(async m => {
-    let actionStatus;
-    let result = await m.resolve(async handler => {
-      let result = await handler(async () => {
-        let url = singleFetchUrl(request.url);
-        let init = await data.createRequestInit(request);
-        let {
-          data: data$1,
-          status
-        } = await fetchAndDecode(url, init);
-        actionStatus = status;
-        return unwrapSingleFetchResult(data$1, m.route.id);
-      });
-      return {
-        type: "data",
-        result,
-        status: actionStatus
-      };
-    });
-    return {
-      ...result,
-      // Proxy along the action HTTP response status for thrown errors
-      status: actionStatus
-    };
-  }));
-}
-
-// Loaders are trickier since we only want to hit the server once, so we
-// create a singular promise for all server-loader routes to latch onto.
-function singleFetchLoaderStrategy(manifest, routeModules, request, matches) {
-  let singleFetchPromise;
-  return Promise.all(matches.map(async m => m.resolve(async handler => {
-    let result;
-    let url = stripIndexParam(singleFetchUrl(request.url));
-
-    // When a route has a client loader, it calls it's singular server loader
-    if (manifest.routes[m.route.id].hasClientLoader) {
-      result = await handler(async () => {
-        url.searchParams.set("_routes", m.route.id);
-        let {
-          data
-        } = await fetchAndDecode(url);
-        return unwrapSingleFetchResults(data, m.route.id);
-      });
-    } else {
-      result = await handler(async () => {
-        // Otherwise we let multiple routes hook onto the same promise
-        if (!singleFetchPromise) {
-          url = addRevalidationParam(manifest, routeModules, matches.map(m => m.route), matches.filter(m => m.shouldLoad).map(m => m.route), url);
-          singleFetchPromise = fetchAndDecode(url).then(({
-            data
-          }) => data);
-        }
-        let results = await singleFetchPromise;
-        return unwrapSingleFetchResults(results, m.route.id);
-      });
-    }
-    return {
-      type: "data",
-      result
-    };
-  })));
-}
-function stripIndexParam(url) {
-  let indexValues = url.searchParams.getAll("index");
-  url.searchParams.delete("index");
-  let indexValuesToKeep = [];
-  for (let indexValue of indexValues) {
-    if (indexValue) {
-      indexValuesToKeep.push(indexValue);
-    }
-  }
-  for (let toKeep of indexValuesToKeep) {
-    url.searchParams.append("index", toKeep);
-  }
-  return url;
-}
-
-// Determine which routes we want to load so we can add a `?_routes` search param
-// for fine-grained revalidation if necessary. There's some nuance to this decision:
-//
-//  - The presence of `shouldRevalidate` and `clientLoader` functions are the only
-//    way to trigger fine-grained single fetch loader calls.  without either of
-//    these on the route matches we just always ask for the full `.data` request.
-//  - If any routes have a `shouldRevalidate` or `clientLoader` then we do a
-//    comparison of the routes we matched and the routes we're aiming to load
-//  - If they don't match up, then we add the `_routes` param or fine-grained
-//    loading
-//  - This is used by the single fetch implementation above and by the
-//    `<PrefetchPageLinksImpl>` component so we can prefetch routes using the
-//    same logic
-function addRevalidationParam(manifest, routeModules, matchedRoutes, loadRoutes, url) {
-  let genRouteIds = arr => arr.filter(id => manifest.routes[id].hasLoader).join(",");
-
-  // Look at the `routeModules` for `shouldRevalidate` here instead of the manifest
-  // since HDR adds a wrapper for `shouldRevalidate` even if the route didn't have one
-  // initially.
-  // TODO: We probably can get rid of that wrapper once we're strictly on on
-  // single-fetch in v3 and just leverage a needsRevalidation data structure here
-  // to determine what to fetch
-  let needsParam = matchedRoutes.some(r => {
-    var _routeModules$r$id, _manifest$routes$r$id;
-    return ((_routeModules$r$id = routeModules[r.id]) === null || _routeModules$r$id === void 0 ? void 0 : _routeModules$r$id.shouldRevalidate) || ((_manifest$routes$r$id = manifest.routes[r.id]) === null || _manifest$routes$r$id === void 0 ? void 0 : _manifest$routes$r$id.hasClientLoader);
-  });
-  if (!needsParam) {
-    return url;
-  }
-  let matchedIds = genRouteIds(matchedRoutes.map(r => r.id));
-  let loadIds = genRouteIds(loadRoutes.filter(r => {
-    var _manifest$routes$r$id2;
-    return !((_manifest$routes$r$id2 = manifest.routes[r.id]) !== null && _manifest$routes$r$id2 !== void 0 && _manifest$routes$r$id2.hasClientLoader);
-  }).map(r => r.id));
-  if (matchedIds !== loadIds) {
-    url.searchParams.set("_routes", loadIds);
-  }
-  return url;
-}
-function singleFetchUrl(reqUrl) {
-  let url = typeof reqUrl === "string" ? new URL(reqUrl, window.location.origin) : reqUrl;
-  url.pathname = `${url.pathname === "/" ? "_root" : url.pathname}.data`;
-  return url;
-}
-async function fetchAndDecode(url, init) {
-  let res = await fetch(url, init);
-  // Don't do a hard check against the header here.  We'll get `text/x-turbo`
-  // when we have a running server, but if folks want to prerender `.data` files
-  // and serve them from a CDN we should let them come back with whatever
-  // Content-Type their CDN provides and not force them to make sure `.data`
-  // files are served as `text/x-turbo`.  We'll throw if we can't decode anyway.
-  invariant(res.body, "No response body to decode");
-  try {
-    let decoded = await decodeViaTurboStream(res.body, window);
-    return {
-      status: res.status,
-      data: decoded.value
-    };
-  } catch (e) {
-    console.error(e);
-    throw new Error(`Unable to decode turbo-stream response from URL: ${url.toString()}`);
-  }
-}
-
-// Note: If you change this function please change the corresponding
-// encodeViaTurboStream function in server-runtime
-function decodeViaTurboStream(body, global) {
-  return turboStream.decode(body, {
-    plugins: [(type, ...rest) => {
-      // Decode Errors back into Error instances using the right type and with
-      // the right (potentially undefined) stacktrace
-      if (type === "SanitizedError") {
-        let [name, message, stack] = rest;
-        let Constructor = Error;
-        // @ts-expect-error
-        if (name && name in global && typeof global[name] === "function") {
-          // @ts-expect-error
-          Constructor = global[name];
-        }
-        let error = new Constructor(message);
-        error.stack = stack;
-        return {
-          value: error
-        };
-      }
-      if (type === "ErrorResponse") {
-        let [data, status, statusText] = rest;
-        return {
-          value: new router.UNSAFE_ErrorResponseImpl(status, statusText, data)
-        };
-      }
-      if (type === "SingleFetchRedirect") {
-        return {
-          value: {
-            [serverRuntime.UNSAFE_SingleFetchRedirectSymbol]: rest[0]
-          }
-        };
-      }
-    }]
-  });
-}
-function unwrapSingleFetchResults(results, routeId) {
-  let redirect = results[serverRuntime.UNSAFE_SingleFetchRedirectSymbol];
-  if (redirect) {
-    return unwrapSingleFetchResult(redirect, routeId);
-  }
-  return results[routeId] !== undefined ? unwrapSingleFetchResult(results[routeId], routeId) : null;
-}
-function unwrapSingleFetchResult(result, routeId) {
-  if ("error" in result) {
-    throw result.error;
-  } else if ("redirect" in result) {
-    let headers = {};
-    if (result.revalidate) {
-      headers["X-Remix-Revalidate"] = "yes";
-    }
-    if (result.reload) {
-      headers["X-Remix-Reload-Document"] = "yes";
-    }
-    return router.redirect(result.redirect, {
-      status: result.status,
-      headers
-    });
-  } else if ("data" in result) {
-    return result.data;
-  } else {
-    throw new Error(`No response found for routeId "${routeId}"`);
-  }
-}
-
-exports.StreamTransfer = StreamTransfer;
-exports.addRevalidationParam = addRevalidationParam;
-exports.decodeViaTurboStream = decodeViaTurboStream;
-exports.defineClientAction = defineClientAction;
-exports.defineClientLoader = defineClientLoader;
-exports.getSingleFetchDataStrategy = getSingleFetchDataStrategy;
-exports.singleFetchUrl = singleFetchUrl;

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

@@ -1 +0,0 @@
-export declare function warnOnce(condition: boolean, message: string): void;

package/node_modules/@remix-run/react/future/single-fetch.d.ts

@@ -1,73 +0,0 @@
-import type {
-  MetaArgs,
-  UIMatch,
-  UNSAFE_MetaMatch,
-  unstable_ClientLoader as ClientLoader,
-  unstable_ClientAction as ClientAction,
-} from "@remix-run/react";
-import type {
-  unstable_Loader as Loader,
-  unstable_Action as Action,
-  unstable_Serialize as Serialize,
-} from "@remix-run/server-runtime";
-import type {
-  useFetcher as useFetcherRR,
-  FetcherWithComponents,
-} from "react-router-dom";
-
-declare module "@remix-run/react" {
-  export function useLoaderData<
-    T extends Loader | ClientLoader
-  >(): T extends Loader ? Serialize<T> : Awaited<ReturnType<T>>;
-
-  export function useActionData<T extends Action | ClientAction>():
-    | (T extends Action ? Serialize<T> : Awaited<ReturnType<T>>)
-    | undefined;
-
-  export function useRouteLoaderData<T extends Loader>(
-    routeId: string
-  ): Serialize<T>;
-
-  export function useFetcher<T extends Loader | Action>(
-    opts?: Parameters<typeof useFetcherRR>[0]
-  ): FetcherWithComponents<Serialize<T>>;
-
-  export type UIMatch_SingleFetch<D = unknown, H = unknown> = Omit<
-    UIMatch<D, H>,
-    "data"
-  > & {
-    data: D extends Loader ? Serialize<D> : never;
-  };
-
-  interface MetaMatch_SingleFetch<
-    RouteId extends string = string,
-    L extends Loader | unknown = unknown
-  > extends Omit<UNSAFE_MetaMatch<RouteId, L>, "data"> {
-    data: L extends Loader ? Serialize<L> : unknown;
-  }
-
-  type MetaMatches_SingleFetch<
-    MatchLoaders extends Record<string, Loader | unknown> = Record<
-      string,
-      unknown
-    >
-  > = Array<
-    {
-      [K in keyof MatchLoaders]: MetaMatch_SingleFetch<
-        Exclude<K, number | symbol>,
-        MatchLoaders[K]
-      >;
-    }[keyof MatchLoaders]
-  >;
-
-  export interface MetaArgs_SingleFetch<
-    L extends Loader | unknown = unknown,
-    MatchLoaders extends Record<string, Loader | unknown> = Record<
-      string,
-      unknown
-    >
-  > extends Omit<MetaArgs<L, MatchLoaders>, "data" | "matches"> {
-    data: (L extends Loader ? Serialize<L> : unknown) | undefined;
-    matches: MetaMatches_SingleFetch<MatchLoaders>;
-  }
-}

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

@@ -1,59 +0,0 @@
-{
-  "name": "@remix-run/react",
-  "version": "2.10.0",
-  "description": "React DOM bindings for Remix",
-  "bugs": {
-    "url": "https://github.com/remix-run/remix/issues"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/remix-run/remix",
-    "directory": "packages/remix-react"
-  },
-  "license": "MIT",
-  "sideEffects": false,
-  "main": "dist/index.js",
-  "typings": "dist/index.d.ts",
-  "module": "dist/esm/index.js",
-  "dependencies": {
-    "@remix-run/router": "1.17.0",
-    "react-router": "6.24.0",
-    "react-router-dom": "6.24.0",
-    "turbo-stream": "2.2.0",
-    "@remix-run/server-runtime": "2.10.0"
-  },
-  "devDependencies": {
-    "@testing-library/jest-dom": "^5.17.0",
-    "@testing-library/react": "^13.3.0",
-    "@types/react": "^18.2.20",
-    "jest-environment-jsdom": "^29.6.4",
-    "react": "^18.2.0",
-    "react-dom": "^18.2.0",
-    "typescript": "^5.1.6",
-    "@remix-run/node": "2.10.0",
-    "@remix-run/react": "2.10.0"
-  },
-  "peerDependencies": {
-    "react": "^18.0.0",
-    "react-dom": "^18.0.0",
-    "typescript": "^5.1.0"
-  },
-  "peerDependenciesMeta": {
-    "typescript": {
-      "optional": true
-    }
-  },
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "files": [
-    "dist/",
-    "future/",
-    "CHANGELOG.md",
-    "LICENSE.md",
-    "README.md"
-  ],
-  "scripts": {
-    "tsc": "tsc"
-  }
-}