@epic-web/workshop-app 4.0.0

package/node_modules/@remix-run/server-runtime/dist/responses.js

@@ -0,0 +1,135 @@
+/**
+ * @remix-run/server-runtime v2.8.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
+ */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var router = require('@remix-run/router');
+var errors = require('./errors.js');
+
+// must be a type since this is a subtype of response
+// interfaces must conform to the types they extend
+
+/**
+ * This is a shortcut for creating `application/json` responses. Converts `data`
+ * to JSON and sets the `Content-Type` header.
+ *
+ * @see https://remix.run/utils/json
+ */
+const json = (data, init = {}) => {
+  return router.json(data, init);
+};
+
+/**
+ * This is a shortcut for creating Remix deferred responses
+ *
+ * @see https://remix.run/utils/defer
+ */
+const defer = (data, init = {}) => {
+  return router.defer(data, init);
+};
+/**
+ * A redirect response. Sets the status code and the `Location` header.
+ * Defaults to "302 Found".
+ *
+ * @see https://remix.run/utils/redirect
+ */
+const redirect = (url, init = 302) => {
+  return router.redirect(url, init);
+};
+
+/**
+ * A redirect response that will force a document reload to the new location.
+ * Sets the status code and the `Location` header.
+ * Defaults to "302 Found".
+ *
+ * @see https://remix.run/utils/redirect
+ */
+const redirectDocument = (url, init = 302) => {
+  return router.redirectDocument(url, init);
+};
+function isDeferredData(value) {
+  let deferred = value;
+  return deferred && typeof deferred === "object" && typeof deferred.data === "object" && typeof deferred.subscribe === "function" && typeof deferred.cancel === "function" && typeof deferred.resolveData === "function";
+}
+function isResponse(value) {
+  return value != null && typeof value.status === "number" && typeof value.statusText === "string" && typeof value.headers === "object" && typeof value.body !== "undefined";
+}
+const redirectStatusCodes = new Set([301, 302, 303, 307, 308]);
+function isRedirectStatusCode(statusCode) {
+  return redirectStatusCodes.has(statusCode);
+}
+function isRedirectResponse(response) {
+  return isRedirectStatusCode(response.status);
+}
+function isTrackedPromise(value) {
+  return value != null && typeof value.then === "function" && value._tracked === true;
+}
+
+// TODO: Figure out why ReadableStream types are borked sooooooo badly
+// in this file. Probably related to our TS configurations and configs
+// bleeding into each other.
+const DEFERRED_VALUE_PLACEHOLDER_PREFIX = "__deferred_promise:";
+function createDeferredReadableStream(deferredData, signal, serverMode) {
+  let encoder = new TextEncoder();
+  let stream = new ReadableStream({
+    async start(controller) {
+      let criticalData = {};
+      let preresolvedKeys = [];
+      for (let [key, value] of Object.entries(deferredData.data)) {
+        if (isTrackedPromise(value)) {
+          criticalData[key] = `${DEFERRED_VALUE_PLACEHOLDER_PREFIX}${key}`;
+          if (typeof value._data !== "undefined" || typeof value._error !== "undefined") {
+            preresolvedKeys.push(key);
+          }
+        } else {
+          criticalData[key] = value;
+        }
+      }
+
+      // Send the critical data
+      controller.enqueue(encoder.encode(JSON.stringify(criticalData) + "\n\n"));
+      for (let preresolvedKey of preresolvedKeys) {
+        enqueueTrackedPromise(controller, encoder, preresolvedKey, deferredData.data[preresolvedKey], serverMode);
+      }
+      let unsubscribe = deferredData.subscribe((aborted, settledKey) => {
+        if (settledKey) {
+          enqueueTrackedPromise(controller, encoder, settledKey, deferredData.data[settledKey], serverMode);
+        }
+      });
+      await deferredData.resolveData(signal);
+      unsubscribe();
+      controller.close();
+    }
+  });
+  return stream;
+}
+function enqueueTrackedPromise(controller, encoder, settledKey, promise, serverMode) {
+  if ("_error" in promise) {
+    controller.enqueue(encoder.encode("error:" + JSON.stringify({
+      [settledKey]: promise._error instanceof Error ? errors.serializeError(promise._error, serverMode) : promise._error
+    }) + "\n\n"));
+  } else {
+    controller.enqueue(encoder.encode("data:" + JSON.stringify({
+      [settledKey]: promise._data ?? null
+    }) + "\n\n"));
+  }
+}
+
+exports.createDeferredReadableStream = createDeferredReadableStream;
+exports.defer = defer;
+exports.isDeferredData = isDeferredData;
+exports.isRedirectResponse = isRedirectResponse;
+exports.isRedirectStatusCode = isRedirectStatusCode;
+exports.isResponse = isResponse;
+exports.json = json;
+exports.redirect = redirect;
+exports.redirectDocument = redirectDocument;

package/node_modules/@remix-run/server-runtime/dist/routeMatching.d.ts

@@ -0,0 +1,8 @@
+import type { Params } from "@remix-run/router";
+import type { ServerRoute } from "./routes";
+export interface RouteMatch<Route> {
+    params: Params;
+    pathname: string;
+    route: Route;
+}
+export declare function matchServerRoutes(routes: ServerRoute[], pathname: string, basename?: string): RouteMatch<ServerRoute>[] | null;

package/node_modules/@remix-run/server-runtime/dist/routeMatching.js

@@ -0,0 +1,27 @@
+/**
+ * @remix-run/server-runtime v2.8.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
+ */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var router = require('@remix-run/router');
+
+function matchServerRoutes(routes, pathname, basename) {
+  let matches = router.matchRoutes(routes, pathname, basename);
+  if (!matches) return null;
+  return matches.map(match => ({
+    params: match.params,
+    pathname: match.pathname,
+    route: match.route
+  }));
+}
+
+exports.matchServerRoutes = matchServerRoutes;

package/node_modules/@remix-run/server-runtime/dist/routeModules.d.ts

@@ -0,0 +1,211 @@
+import type { ActionFunction as RRActionFunction, ActionFunctionArgs as RRActionFunctionArgs, AgnosticRouteMatch, LoaderFunction as RRLoaderFunction, LoaderFunctionArgs as RRLoaderFunctionArgs, Location, Params } from "@remix-run/router";
+import type { AppData, AppLoadContext } from "./data";
+import type { LinkDescriptor } from "./links";
+import type { SerializeFrom } from "./serialize";
+export interface RouteModules<RouteModule> {
+    [routeId: string]: RouteModule | undefined;
+}
+/**
+ * @deprecated Use `LoaderFunctionArgs`/`ActionFunctionArgs` instead
+ */
+export type DataFunctionArgs = RRActionFunctionArgs<AppLoadContext> & RRLoaderFunctionArgs<AppLoadContext> & {
+    context: AppLoadContext;
+};
+/**
+ * A function that handles data mutations for a route on the server
+ */
+export type ActionFunction = (args: ActionFunctionArgs) => ReturnType<RRActionFunction>;
+/**
+ * Arguments passed to a route `action` function
+ */
+export type ActionFunctionArgs = RRActionFunctionArgs<AppLoadContext> & {
+    context: AppLoadContext;
+};
+/**
+ * A function that handles data mutations for a route on the client
+ * @private Public API is exported from @remix-run/react
+ */
+type ClientActionFunction = (args: ClientActionFunctionArgs) => ReturnType<RRActionFunction>;
+/**
+ * Arguments passed to a route `clientAction` function
+ * @private Public API is exported from @remix-run/react
+ */
+export type ClientActionFunctionArgs = RRActionFunctionArgs<undefined> & {
+    serverAction: <T = AppData>() => Promise<SerializeFrom<T>>;
+};
+/**
+ * A function that loads data for a route on the server
+ */
+export type LoaderFunction = (args: LoaderFunctionArgs) => ReturnType<RRLoaderFunction>;
+/**
+ * Arguments passed to a route `loader` function
+ */
+export type LoaderFunctionArgs = RRLoaderFunctionArgs<AppLoadContext> & {
+    context: AppLoadContext;
+};
+/**
+ * A function that loads data for a route on the client
+ * @private Public API is exported from @remix-run/react
+ */
+type ClientLoaderFunction = ((args: ClientLoaderFunctionArgs) => ReturnType<RRLoaderFunction>) & {
+    hydrate?: boolean;
+};
+/**
+ * Arguments passed to a route `clientLoader` function
+ * @private Public API is exported from @remix-run/react
+ */
+export type ClientLoaderFunctionArgs = RRLoaderFunctionArgs<undefined> & {
+    serverLoader: <T = AppData>() => Promise<SerializeFrom<T>>;
+};
+export type HeadersArgs = {
+    loaderHeaders: Headers;
+    parentHeaders: Headers;
+    actionHeaders: Headers;
+    errorHeaders: Headers | undefined;
+};
+/**
+ * A function that returns HTTP headers to be used for a route. These headers
+ * will be merged with (and take precedence over) headers from parent routes.
+ */
+export interface HeadersFunction {
+    (args: HeadersArgs): Headers | HeadersInit;
+}
+/**
+ * A function that defines `<link>` tags to be inserted into the `<head>` of
+ * the document on route transitions.
+ */
+export interface LinksFunction {
+    (): LinkDescriptor[];
+}
+/**
+ * A function that returns an array of data objects to use for rendering
+ * metadata HTML tags in a route. These tags are not rendered on descendant
+ * routes in the route hierarchy. In other words, they will only be rendered on
+ * the route in which they are exported.
+ *
+ * @param Loader - The type of the current route's loader function
+ * @param MatchLoaders - Mapping from a parent route's filepath to its loader
+ * function type
+ *
+ * Note that parent route filepaths are relative to the `app/` directory.
+ *
+ * For example, if this meta function is for `/sales/customers/$customerId`:
+ *
+ * ```ts
+ * // app/root.tsx
+ * const loader = () => {
+ *  return json({ hello: "world" } as const)
+ * }
+ * export type Loader = typeof loader
+ *
+ * // app/routes/sales.tsx
+ * const loader = () => {
+ *  return json({ salesCount: 1074 })
+ * }
+ * export type Loader = typeof loader
+ *
+ * // app/routes/sales/customers.tsx
+ * const loader = () => {
+ *   return json({ customerCount: 74 })
+ * }
+ * export type Loader = typeof loader
+ *
+ * // app/routes/sales/customers/$customersId.tsx
+ * import type { Loader as RootLoader } from "../../../root"
+ * import type { Loader as SalesLoader } from "../../sales"
+ * import type { Loader as CustomersLoader } from "../../sales/customers"
+ *
+ * const loader = () => {
+ *   return json({ name: "Customer name" })
+ * }
+ *
+ * const meta: MetaFunction<typeof loader, {
+ *  "root": RootLoader,
+ *  "routes/sales": SalesLoader,
+ *  "routes/sales/customers": CustomersLoader,
+ * }> = ({ data, matches }) => {
+ *   const { name } = data
+ *   //      ^? string
+ *   const { customerCount } = matches.find((match) => match.id === "routes/sales/customers").data
+ *   //      ^? number
+ *   const { salesCount } = matches.find((match) => match.id === "routes/sales").data
+ *   //      ^? number
+ *   const { hello } = matches.find((match) => match.id === "root").data
+ *   //      ^? "world"
+ * }
+ * ```
+ */
+export interface ServerRuntimeMetaFunction<Loader extends LoaderFunction | unknown = unknown, ParentsLoaders extends Record<string, LoaderFunction | unknown> = Record<string, unknown>> {
+    (args: ServerRuntimeMetaArgs<Loader, ParentsLoaders>): ServerRuntimeMetaDescriptor[];
+}
+interface ServerRuntimeMetaMatch<RouteId extends string = string, Loader extends LoaderFunction | unknown = unknown> {
+    id: RouteId;
+    pathname: AgnosticRouteMatch["pathname"];
+    data: Loader extends LoaderFunction ? SerializeFrom<Loader> : unknown;
+    handle?: RouteHandle;
+    params: AgnosticRouteMatch["params"];
+    meta: ServerRuntimeMetaDescriptor[];
+    error?: unknown;
+}
+type ServerRuntimeMetaMatches<MatchLoaders extends Record<string, LoaderFunction | unknown> = Record<string, unknown>> = Array<{
+    [K in keyof MatchLoaders]: ServerRuntimeMetaMatch<Exclude<K, number | symbol>, MatchLoaders[K]>;
+}[keyof MatchLoaders]>;
+export interface ServerRuntimeMetaArgs<Loader extends LoaderFunction | unknown = unknown, MatchLoaders extends Record<string, LoaderFunction | unknown> = Record<string, unknown>> {
+    data: (Loader extends LoaderFunction ? SerializeFrom<Loader> : AppData) | undefined;
+    params: Params;
+    location: Location;
+    matches: ServerRuntimeMetaMatches<MatchLoaders>;
+    error?: unknown;
+}
+export type ServerRuntimeMetaDescriptor = {
+    charSet: "utf-8";
+} | {
+    title: string;
+} | {
+    name: string;
+    content: string;
+} | {
+    property: string;
+    content: string;
+} | {
+    httpEquiv: string;
+    content: string;
+} | {
+    "script:ld+json": LdJsonObject;
+} | {
+    tagName: "meta" | "link";
+    [name: string]: string;
+} | {
+    [name: string]: unknown;
+};
+type LdJsonObject = {
+    [Key in string]: LdJsonValue;
+} & {
+    [Key in string]?: LdJsonValue | undefined;
+};
+type LdJsonArray = LdJsonValue[] | readonly LdJsonValue[];
+type LdJsonPrimitive = string | number | boolean | null;
+type LdJsonValue = LdJsonPrimitive | LdJsonObject | LdJsonArray;
+/**
+ * An arbitrary object that is associated with a route.
+ */
+export type RouteHandle = unknown;
+export interface EntryRouteModule {
+    clientAction?: ClientActionFunction;
+    clientLoader?: ClientLoaderFunction;
+    ErrorBoundary?: any;
+    HydrateFallback?: any;
+    Layout?: any;
+    default: any;
+    handle?: RouteHandle;
+    links?: LinksFunction;
+    meta?: ServerRuntimeMetaFunction;
+}
+export interface ServerRouteModule extends EntryRouteModule {
+    action?: ActionFunction;
+    headers?: HeadersFunction | {
+        [name: string]: string;
+    };
+    loader?: LoaderFunction;
+}
+export {};

package/node_modules/@remix-run/server-runtime/dist/routes.d.ts

@@ -0,0 +1,31 @@
+import type { AgnosticDataRouteObject } from "@remix-run/router";
+import type { FutureConfig } from "./entry";
+import type { ServerRouteModule } from "./routeModules";
+export interface RouteManifest<Route> {
+    [routeId: string]: Route;
+}
+export type ServerRouteManifest = RouteManifest<Omit<ServerRoute, "children">>;
+export interface Route {
+    index?: boolean;
+    caseSensitive?: boolean;
+    id: string;
+    parentId?: string;
+    path?: string;
+}
+export interface EntryRoute extends Route {
+    hasAction: boolean;
+    hasLoader: boolean;
+    hasClientAction: boolean;
+    hasClientLoader: boolean;
+    hasErrorBoundary: boolean;
+    imports?: string[];
+    css?: string[];
+    module: string;
+    parentId?: string;
+}
+export interface ServerRoute extends Route {
+    children: ServerRoute[];
+    module: ServerRouteModule;
+}
+export declare function createRoutes(manifest: ServerRouteManifest, parentId?: string, routesByParentId?: Record<string, Omit<ServerRoute, "children">[]>): ServerRoute[];
+export declare function createStaticHandlerDataRoutes(manifest: ServerRouteManifest, future: FutureConfig, parentId?: string, routesByParentId?: Record<string, Omit<ServerRoute, "children">[]>): AgnosticDataRouteObject[];

package/node_modules/@remix-run/server-runtime/dist/routes.js

@@ -0,0 +1,82 @@
+/**
+ * @remix-run/server-runtime v2.8.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
+ */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var data = require('./data.js');
+
+// NOTE: make sure to change the Route in remix-react if you change this
+
+// NOTE: make sure to change the EntryRoute in remix-react if you change this
+
+function groupRoutesByParentId(manifest) {
+  let routes = {};
+  Object.values(manifest).forEach(route => {
+    let parentId = route.parentId || "";
+    if (!routes[parentId]) {
+      routes[parentId] = [];
+    }
+    routes[parentId].push(route);
+  });
+  return routes;
+}
+
+// Create a map of routes by parentId to use recursively instead of
+// repeatedly filtering the manifest.
+function createRoutes(manifest, parentId = "", routesByParentId = groupRoutesByParentId(manifest)) {
+  return (routesByParentId[parentId] || []).map(route => ({
+    ...route,
+    children: createRoutes(manifest, route.id, routesByParentId)
+  }));
+}
+
+// Convert the Remix ServerManifest into DataRouteObject's for use with
+// createStaticHandler
+function createStaticHandlerDataRoutes(manifest, future, parentId = "", routesByParentId = groupRoutesByParentId(manifest)) {
+  return (routesByParentId[parentId] || []).map(route => {
+    let commonRoute = {
+      // Always include root due to default boundaries
+      hasErrorBoundary: route.id === "root" || route.module.ErrorBoundary != null,
+      id: route.id,
+      path: route.path,
+      loader: route.module.loader ?
+      // Need to use RR's version here to permit the optional context even
+      // though we know it'll always be provided in remix
+      args => data.callRouteLoaderRR({
+        request: args.request,
+        params: args.params,
+        loadContext: args.context,
+        loader: route.module.loader,
+        routeId: route.id
+      }) : undefined,
+      action: route.module.action ? args => data.callRouteActionRR({
+        request: args.request,
+        params: args.params,
+        loadContext: args.context,
+        action: route.module.action,
+        routeId: route.id
+      }) : undefined,
+      handle: route.module.handle
+    };
+    return route.index ? {
+      index: true,
+      ...commonRoute
+    } : {
+      caseSensitive: route.caseSensitive,
+      children: createStaticHandlerDataRoutes(manifest, future, route.id, routesByParentId),
+      ...commonRoute
+    };
+  });
+}
+
+exports.createRoutes = createRoutes;
+exports.createStaticHandlerDataRoutes = createStaticHandlerDataRoutes;

package/node_modules/@remix-run/server-runtime/dist/serialize.d.ts

@@ -0,0 +1,25 @@
+import type { Jsonify } from "./jsonify";
+import type { TypedDeferredData, TypedResponse } from "./responses";
+import type { ClientActionFunctionArgs, ClientLoaderFunctionArgs } from "./routeModules";
+/**
+ * Infer JSON serialized data type returned by a loader or action, while
+ * avoiding deserialization if the input type if it's a clientLoader or
+ * clientAction that returns a non-Response
+ *
+ * For example:
+ * `type LoaderData = SerializeFrom<typeof loader>`
+ */
+export type SerializeFrom<T> = T extends (...args: any[]) => infer Output ? Parameters<T> extends [ClientLoaderFunctionArgs | ClientActionFunctionArgs] ? SerializeClient<Awaited<Output>> : Serialize<Awaited<Output>> : Jsonify<Awaited<T>>;
+type SerializeClient<Output> = Output extends TypedDeferredData<infer U> ? {
+    [K in keyof U as K extends symbol ? never : Promise<any> extends U[K] ? K : never]: DeferValueClient<U[K]>;
+} & {
+    [K in keyof U as Promise<any> extends U[K] ? never : K]: U[K];
+} : Output extends TypedResponse<infer U> ? Jsonify<U> : Awaited<Output>;
+type DeferValueClient<T> = T extends undefined ? undefined : T extends Promise<unknown> ? Promise<Awaited<T>> : T;
+type Serialize<Output> = Output extends TypedDeferredData<infer U> ? {
+    [K in keyof U as K extends symbol ? never : Promise<any> extends U[K] ? K : never]: DeferValue<U[K]>;
+} & Jsonify<{
+    [K in keyof U as Promise<any> extends U[K] ? never : K]: U[K];
+}> : Output extends TypedResponse<infer U> ? Jsonify<U> : Jsonify<Output>;
+type DeferValue<T> = T extends undefined ? undefined : T extends Promise<unknown> ? Promise<Jsonify<Awaited<T>>> : Jsonify<T>;
+export {};

package/node_modules/@remix-run/server-runtime/dist/server.d.ts

@@ -0,0 +1,5 @@
+import type { AppLoadContext } from "./data";
+import type { ServerBuild } from "./build";
+export type RequestHandler = (request: Request, loadContext?: AppLoadContext) => Promise<Response>;
+export type CreateRequestHandlerFunction = (build: ServerBuild | (() => ServerBuild | Promise<ServerBuild>), mode?: string) => RequestHandler;
+export declare const createRequestHandler: CreateRequestHandlerFunction;