@epic-web/workshop-app 5.1.0 → 5.1.2

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

@@ -1,145 +0,0 @@
-/**
- * @remix-run/server-runtime 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
- */
-import { isCookie } from './cookies.js';
-import { warnOnce } from './warnings.js';
-
-/**
- * An object of name/value pairs to be used in the session.
- */
-
-/**
- * Session persists data across HTTP requests.
- *
- * @see https://remix.run/utils/sessions#session-api
- */
-
-function flash(name) {
-  return `__flash_${name}__`;
-}
-/**
- * Creates a new Session object.
- *
- * Note: This function is typically not invoked directly by application code.
- * Instead, use a `SessionStorage` object's `getSession` method.
- *
- * @see https://remix.run/utils/sessions#createsession
- */
-const createSession = (initialData = {}, id = "") => {
-  let map = new Map(Object.entries(initialData));
-  return {
-    get id() {
-      return id;
-    },
-    get data() {
-      return Object.fromEntries(map);
-    },
-    has(name) {
-      return map.has(name) || map.has(flash(name));
-    },
-    get(name) {
-      if (map.has(name)) return map.get(name);
-      let flashName = flash(name);
-      if (map.has(flashName)) {
-        let value = map.get(flashName);
-        map.delete(flashName);
-        return value;
-      }
-      return undefined;
-    },
-    set(name, value) {
-      map.set(name, value);
-    },
-    flash(name, value) {
-      map.set(flash(name), value);
-    },
-    unset(name) {
-      map.delete(name);
-    }
-  };
-};
-/**
- * Returns true if an object is a Remix session.
- *
- * @see https://remix.run/utils/sessions#issession
- */
-const isSession = object => {
-  return object != null && typeof object.id === "string" && typeof object.data !== "undefined" && typeof object.has === "function" && typeof object.get === "function" && typeof object.set === "function" && typeof object.flash === "function" && typeof object.unset === "function";
-};
-
-/**
- * SessionStorage stores session data between HTTP requests and knows how to
- * parse and create cookies.
- *
- * A SessionStorage creates Session objects using a `Cookie` header as input.
- * Then, later it generates the `Set-Cookie` header to be used in the response.
- */
-
-/**
- * SessionIdStorageStrategy is designed to allow anyone to easily build their
- * own SessionStorage using `createSessionStorage(strategy)`.
- *
- * This strategy describes a common scenario where the session id is stored in
- * a cookie but the actual session data is stored elsewhere, usually in a
- * database or on disk. A set of create, read, update, and delete operations
- * are provided for managing the session data.
- */
-
-/**
- * Creates a SessionStorage object using a SessionIdStorageStrategy.
- *
- * Note: This is a low-level API that should only be used if none of the
- * existing session storage options meet your requirements.
- *
- * @see https://remix.run/utils/sessions#createsessionstorage
- */
-const createSessionStorageFactory = createCookie => ({
-  cookie: cookieArg,
-  createData,
-  readData,
-  updateData,
-  deleteData
-}) => {
-  let cookie = isCookie(cookieArg) ? cookieArg : createCookie((cookieArg === null || cookieArg === void 0 ? void 0 : cookieArg.name) || "__session", cookieArg);
-  warnOnceAboutSigningSessionCookie(cookie);
-  return {
-    async getSession(cookieHeader, options) {
-      let id = cookieHeader && (await cookie.parse(cookieHeader, options));
-      let data = id && (await readData(id));
-      return createSession(data || {}, id || "");
-    },
-    async commitSession(session, options) {
-      let {
-        id,
-        data
-      } = session;
-      let expires = (options === null || options === void 0 ? void 0 : options.maxAge) != null ? new Date(Date.now() + options.maxAge * 1000) : (options === null || options === void 0 ? void 0 : options.expires) != null ? options.expires : cookie.expires;
-      if (id) {
-        await updateData(id, data, expires);
-      } else {
-        id = await createData(data, expires);
-      }
-      return cookie.serialize(id, options);
-    },
-    async destroySession(session, options) {
-      await deleteData(session.id);
-      return cookie.serialize("", {
-        ...options,
-        maxAge: undefined,
-        expires: new Date(0)
-      });
-    }
-  };
-};
-function warnOnceAboutSigningSessionCookie(cookie) {
-  warnOnce(cookie.isSigned, `The "${cookie.name}" cookie is not signed, but session cookies should be ` + `signed to prevent tampering on the client before they are sent back to the ` + `server. See https://remix.run/utils/cookies#signing-cookies ` + `for more information.`);
-}
-
-export { createSession, createSessionStorageFactory, isSession, warnOnceAboutSigningSessionCookie };

package/node_modules/@remix-run/server-runtime/dist/esm/single-fetch.js

@@ -1,450 +0,0 @@
-/**
- * @remix-run/server-runtime 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
- */
-import { UNSAFE_ErrorResponseImpl, isRouteErrorResponse } from '@remix-run/router';
-import { encode } from 'turbo-stream';
-import { sanitizeError, sanitizeErrors } from './errors.js';
-import { ServerMode } from './mode.js';
-import { isResponse, isDeferredData, isRedirectStatusCode } from './responses.js';
-
-const SingleFetchRedirectSymbol = Symbol("SingleFetchRedirect");
-const ResponseStubActionSymbol = Symbol("ResponseStubAction");
-// We can't use a 3xx status or else the `fetch()` would follow the redirect.
-// We need to communicate the redirect back as data so we can act on it in the
-// client side router.  We use a 202 to avoid any automatic caching we might
-// get from a 200 since a "temporary" redirect should not be cached.  This lets
-// the user control cache behavior via Cache-Control
-const SINGLE_FETCH_REDIRECT_STATUS = 202;
-function getSingleFetchDataStrategy(responseStubs, {
-  isActionDataRequest,
-  loadRouteIds
-} = {}) {
-  return async ({
-    request,
-    matches
-  }) => {
-    // Don't call loaders on action data requests
-    if (isActionDataRequest && request.method === "GET") {
-      return await Promise.all(matches.map(m => m.resolve(async () => ({
-        type: "data",
-        result: null
-      }))));
-    }
-    let results = await Promise.all(matches.map(async match => {
-      let responseStub;
-      if (request.method !== "GET") {
-        responseStub = responseStubs[ResponseStubActionSymbol];
-      } else {
-        responseStub = responseStubs[match.route.id];
-      }
-      let result = await match.resolve(async handler => {
-        // Cast `ResponseStubImpl -> ResponseStub` to hide the symbol in userland
-        let ctx = {
-          response: responseStub
-        };
-        // Only run opt-in loaders when fine-grained revalidation is enabled
-        let data = loadRouteIds && !loadRouteIds.includes(match.route.id) ? null : await handler(ctx);
-        return {
-          type: "data",
-          result: data
-        };
-      });
-
-      // Transfer raw Response status/headers to responseStubs
-      if (isResponse(result.result)) {
-        proxyResponseToResponseStub(result.result.status, result.result.headers, responseStub);
-      } else if (isDeferredData(result.result) && result.result.init) {
-        proxyResponseToResponseStub(result.result.init.status, new Headers(result.result.init.headers), responseStub);
-      }
-      return result;
-    }));
-    return results;
-  };
-}
-function getSingleFetchResourceRouteDataStrategy({
-  responseStubs
-}) {
-  return async ({
-    matches
-  }) => {
-    let results = await Promise.all(matches.map(async match => {
-      let responseStub = match.shouldLoad ? responseStubs[match.route.id] : null;
-      let result = await match.resolve(async handler => {
-        // Cast `ResponseStubImpl -> ResponseStub` to hide the symbol in userland
-        let ctx = {
-          response: responseStub
-        };
-        let data = await handler(ctx);
-        return {
-          type: "data",
-          result: data
-        };
-      });
-      return result;
-    }));
-    return results;
-  };
-}
-async function singleFetchAction(serverMode, staticHandler, request, handlerUrl, loadContext, handleError) {
-  try {
-    let handlerRequest = new Request(handlerUrl, {
-      method: request.method,
-      body: request.body,
-      headers: request.headers,
-      signal: request.signal,
-      ...(request.body ? {
-        duplex: "half"
-      } : undefined)
-    });
-    let responseStubs = getResponseStubs();
-    let result = await staticHandler.query(handlerRequest, {
-      requestContext: loadContext,
-      skipLoaderErrorBubbling: true,
-      unstable_dataStrategy: getSingleFetchDataStrategy(responseStubs, {
-        isActionDataRequest: true
-      })
-    });
-
-    // Unlike `handleDataRequest`, when singleFetch is enabled, query does
-    // let non-Response return values through
-    if (isResponse(result)) {
-      return {
-        result: getSingleFetchRedirect(result.status, result.headers),
-        headers: result.headers,
-        status: SINGLE_FETCH_REDIRECT_STATUS
-      };
-    }
-    let context = result;
-    let singleFetchResult;
-    let {
-      statusCode,
-      headers
-    } = mergeResponseStubs(context, responseStubs, {
-      isActionDataRequest: true
-    });
-    if (isRedirectStatusCode(statusCode) && headers.has("Location")) {
-      return {
-        result: getSingleFetchRedirect(statusCode, headers),
-        headers,
-        status: SINGLE_FETCH_REDIRECT_STATUS
-      };
-    }
-
-    // Sanitize errors outside of development environments
-    if (context.errors) {
-      Object.values(context.errors).forEach(err => {
-        // @ts-expect-error This is "private" from users but intended for internal use
-        if ((!isRouteErrorResponse(err) || err.error) && !isResponseStub(err)) {
-          handleError(err);
-        }
-      });
-      context.errors = sanitizeErrors(context.errors, serverMode);
-    }
-    if (context.errors) {
-      let error = Object.values(context.errors)[0];
-      singleFetchResult = {
-        error: isResponseStub(error) ? convertResponseStubToErrorResponse(error) : error
-      };
-    } else {
-      singleFetchResult = {
-        data: Object.values(context.actionData || {})[0]
-      };
-    }
-    return {
-      result: singleFetchResult,
-      headers,
-      status: statusCode
-    };
-  } catch (error) {
-    handleError(error);
-    // These should only be internal remix errors, no need to deal with responseStubs
-    return {
-      result: {
-        error
-      },
-      headers: new Headers(),
-      status: 500
-    };
-  }
-}
-async function singleFetchLoaders(serverMode, staticHandler, request, handlerUrl, loadContext, handleError) {
-  try {
-    var _URL$searchParams$get;
-    let handlerRequest = new Request(handlerUrl, {
-      headers: request.headers,
-      signal: request.signal
-    });
-    let loadRouteIds = ((_URL$searchParams$get = new URL(request.url).searchParams.get("_routes")) === null || _URL$searchParams$get === void 0 ? void 0 : _URL$searchParams$get.split(",")) || undefined;
-    let responseStubs = getResponseStubs();
-    let result = await staticHandler.query(handlerRequest, {
-      requestContext: loadContext,
-      skipLoaderErrorBubbling: true,
-      unstable_dataStrategy: getSingleFetchDataStrategy(responseStubs, {
-        loadRouteIds
-      })
-    });
-    if (isResponse(result)) {
-      return {
-        result: {
-          [SingleFetchRedirectSymbol]: getSingleFetchRedirect(result.status, result.headers)
-        },
-        headers: result.headers,
-        status: SINGLE_FETCH_REDIRECT_STATUS
-      };
-    }
-    let context = result;
-    let {
-      statusCode,
-      headers
-    } = mergeResponseStubs(context, responseStubs);
-    if (isRedirectStatusCode(statusCode) && headers.has("Location")) {
-      return {
-        result: {
-          [SingleFetchRedirectSymbol]: getSingleFetchRedirect(statusCode, headers)
-        },
-        headers,
-        status: SINGLE_FETCH_REDIRECT_STATUS
-      };
-    }
-
-    // Sanitize errors outside of development environments
-    if (context.errors) {
-      Object.values(context.errors).forEach(err => {
-        // @ts-expect-error This is "private" from users but intended for internal use
-        if ((!isRouteErrorResponse(err) || err.error) && !isResponseStub(err)) {
-          handleError(err);
-        }
-      });
-      context.errors = sanitizeErrors(context.errors, serverMode);
-    }
-
-    // Aggregate results based on the matches we intended to load since we get
-    // `null` values back in `context.loaderData` for routes we didn't load
-    let results = {};
-    let loadedMatches = loadRouteIds ? context.matches.filter(m => m.route.loader && loadRouteIds.includes(m.route.id)) : context.matches;
-    loadedMatches.forEach(m => {
-      var _context$loaderData, _context$errors;
-      let data = (_context$loaderData = context.loaderData) === null || _context$loaderData === void 0 ? void 0 : _context$loaderData[m.route.id];
-      let error = (_context$errors = context.errors) === null || _context$errors === void 0 ? void 0 : _context$errors[m.route.id];
-      if (error !== undefined) {
-        if (isResponseStub(error)) {
-          results[m.route.id] = {
-            error: convertResponseStubToErrorResponse(error)
-          };
-        } else {
-          results[m.route.id] = {
-            error
-          };
-        }
-      } else if (data !== undefined) {
-        results[m.route.id] = {
-          data
-        };
-      }
-    });
-    return {
-      result: results,
-      headers,
-      status: statusCode
-    };
-  } catch (error) {
-    handleError(error);
-    // These should only be internal remix errors, no need to deal with responseStubs
-    return {
-      result: {
-        root: {
-          error
-        }
-      },
-      headers: new Headers(),
-      status: 500
-    };
-  }
-}
-function isResponseStub(value) {
-  return value && typeof value === "object" && ResponseStubOperationsSymbol in value;
-}
-function getResponseStub(status) {
-  let headers = new Headers();
-  let operations = [];
-  let headersProxy = new Proxy(headers, {
-    get(target, prop, receiver) {
-      if (prop === "set" || prop === "append" || prop === "delete") {
-        return (name, value) => {
-          operations.push([prop, name, value]);
-          Reflect.apply(target[prop], target, [name, value]);
-        };
-      }
-      return Reflect.get(target, prop, receiver);
-    }
-  });
-  return {
-    status,
-    headers: headersProxy,
-    [ResponseStubOperationsSymbol]: operations
-  };
-}
-function getResponseStubs() {
-  return new Proxy({}, {
-    get(responseStubCache, prop) {
-      let cached = responseStubCache[prop];
-      if (!cached) {
-        responseStubCache[prop] = cached = getResponseStub();
-      }
-      return cached;
-    }
-  });
-}
-function proxyResponseToResponseStub(status, headers, responseStub) {
-  if (status != null && responseStub.status == null) {
-    responseStub.status = status;
-  }
-  for (let [k, v] of headers) {
-    if (k.toLowerCase() !== "set-cookie") {
-      responseStub.headers.set(k, v);
-    }
-  }
-
-  // Unsure why this is complaining?  It's fine in VSCode but fails with tsc...
-  // @ts-ignore - ignoring instead of expecting because otherwise build fails locally
-  for (let v of headers.getSetCookie()) {
-    responseStub.headers.append("Set-Cookie", v);
-  }
-}
-function convertResponseStubToErrorResponse(stub) {
-  return new UNSAFE_ErrorResponseImpl(stub.status || 500, "", null);
-}
-function mergeResponseStubs(context, responseStubs, {
-  isActionDataRequest
-} = {}) {
-  let statusCode = undefined;
-  let headers = new Headers();
-
-  // Action followed by top-down loaders
-  let actionStub = responseStubs[ResponseStubActionSymbol];
-  let stubs = [actionStub];
-
-  // Nothing to merge at the route level on action data requests
-  if (!isActionDataRequest) {
-    stubs.push(...context.matches.map(m => responseStubs[m.route.id]));
-  }
-  for (let stub of stubs) {
-    // Take the highest error/redirect, or the lowest success value - preferring
-    // action 200's over loader 200s
-    if (
-    // first status found on the way down
-    statusCode === undefined && stub.status ||
-    // deeper 2xx status found while not overriding the action status
-    statusCode !== undefined && statusCode < 300 && stub.status && statusCode !== (actionStub === null || actionStub === void 0 ? void 0 : actionStub.status)) {
-      statusCode = stub.status;
-    }
-
-    // Replay headers operations in order
-    let ops = stub[ResponseStubOperationsSymbol];
-    for (let [op, ...args] of ops) {
-      // @ts-expect-error
-      headers[op](...args);
-    }
-  }
-
-  // If no response stubs set it, use whatever we got back from the router
-  // context which handles internal ErrorResponse cases like 404/405's where
-  // we may never run a loader/action
-  if (statusCode === undefined) {
-    statusCode = context.statusCode;
-  }
-  if (statusCode === undefined) {
-    statusCode = 200;
-  }
-  return {
-    statusCode,
-    headers
-  };
-}
-function getSingleFetchRedirect(status, headers) {
-  return {
-    redirect: headers.get("Location"),
-    status,
-    revalidate:
-    // Technically X-Remix-Revalidate isn't needed here - that was an implementation
-    // detail of ?_data requests as our way to tell the front end to revalidate when
-    // we didn't have a response body to include that information in.
-    // With single fetch, we tell the front end via this revalidate boolean field.
-    // However, we're respecting it for now because it may be something folks have
-    // used in their own responses
-    // TODO(v3): Consider removing or making this official public API
-    headers.has("X-Remix-Revalidate") || headers.has("Set-Cookie"),
-    reload: headers.has("X-Remix-Reload-Document")
-  };
-}
-
-// Note: If you change this function please change the corresponding
-// decodeViaTurboStream function in server-runtime
-function encodeViaTurboStream(data, requestSignal, streamTimeout, serverMode) {
-  let controller = new AbortController();
-  // How long are we willing to wait for all of the promises in `data` to resolve
-  // before timing out?  We default this to 50ms shorter than the default value for
-  // `ABORT_DELAY` in our built-in `entry.server.tsx` so that once we reject we
-  // have time to flush the rejections down through React's rendering stream before `
-  // we call abort() on that.  If the user provides their own it's up to them to
-  // decouple the aborting of the stream from the aborting of React's renderToPipeableStream
-  let timeoutId = setTimeout(() => controller.abort(new Error("Server Timeout")), typeof streamTimeout === "number" ? streamTimeout : 4950);
-  requestSignal.addEventListener("abort", () => clearTimeout(timeoutId));
-  return encode(data, {
-    signal: controller.signal,
-    plugins: [value => {
-      // Even though we sanitized errors on context.errors prior to responding,
-      // we still need to handle this for any deferred data that rejects with an
-      // Error - as those will not be sanitized yet
-      if (value instanceof Error) {
-        let {
-          name,
-          message,
-          stack
-        } = serverMode === ServerMode.Production ? sanitizeError(value, serverMode) : value;
-        return ["SanitizedError", name, message, stack];
-      }
-      if (value instanceof UNSAFE_ErrorResponseImpl) {
-        let {
-          data,
-          status,
-          statusText
-        } = value;
-        return ["ErrorResponse", data, status, statusText];
-      }
-      if (value && typeof value === "object" && SingleFetchRedirectSymbol in value) {
-        return ["SingleFetchRedirect", value[SingleFetchRedirectSymbol]];
-      }
-    }]
-  });
-}
-
-// Backwards-compatible type for Remix v2 where json/defer still use the old types,
-// and only non-json/defer returns use the new types.  This allows for incremental
-// migration of loaders to return naked objects.  In the next major version,
-// json/defer will be removed so everything will use the new simplified typings.
-// prettier-ignore
-
-const ResponseStubOperationsSymbol = Symbol("ResponseStubOperations");
-
-/**
- * A stubbed response to let you set the status/headers of your response from
- * loader/action functions
- */
-
-// loader
-
-let defineLoader = loader => loader;
-
-// action
-
-let defineAction = action => action;
-
-export { ResponseStubOperationsSymbol, SINGLE_FETCH_REDIRECT_STATUS, SingleFetchRedirectSymbol, convertResponseStubToErrorResponse, defineAction, defineLoader, encodeViaTurboStream, getResponseStubs, getSingleFetchDataStrategy, getSingleFetchRedirect, getSingleFetchResourceRouteDataStrategy, isResponseStub, mergeResponseStubs, singleFetchAction, singleFetchLoaders };

package/node_modules/@remix-run/server-runtime/dist/esm/upload/errors.js

@@ -1,19 +0,0 @@
-/**
- * @remix-run/server-runtime 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
- */
-class MaxPartSizeExceededError extends Error {
-  constructor(field, maxBytes) {
-    super(`Field "${field}" exceeded upload size of ${maxBytes} bytes.`);
-    this.field = field;
-    this.maxBytes = maxBytes;
-  }
-}
-
-export { MaxPartSizeExceededError };

package/node_modules/@remix-run/server-runtime/dist/esm/upload/memoryUploadHandler.js

@@ -1,50 +0,0 @@
-/**
- * @remix-run/server-runtime 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
- */
-import { MaxPartSizeExceededError } from './errors.js';
-
-function createMemoryUploadHandler({
-  filter,
-  maxPartSize = 3000000
-} = {}) {
-  return async ({
-    filename,
-    contentType,
-    name,
-    data
-  }) => {
-    if (filter && !(await filter({
-      filename,
-      contentType,
-      name
-    }))) {
-      return undefined;
-    }
-    let size = 0;
-    let chunks = [];
-    for await (let chunk of data) {
-      size += chunk.byteLength;
-      if (size > maxPartSize) {
-        throw new MaxPartSizeExceededError(name, maxPartSize);
-      }
-      chunks.push(chunk);
-    }
-    if (typeof filename === "string") {
-      return new File(chunks, filename, {
-        type: contentType
-      });
-    }
-    return await new Blob(chunks, {
-      type: contentType
-    }).text();
-  };
-}
-
-export { createMemoryUploadHandler };

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

@@ -1,19 +0,0 @@
-/**
- * @remix-run/server-runtime 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
- */
-const alreadyWarned = {};
-function warnOnce(condition, message) {
-  if (!condition && !alreadyWarned[message]) {
-    alreadyWarned[message] = true;
-    console.warn(message);
-  }
-}
-
-export { warnOnce };

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

@@ -1,15 +0,0 @@
-export type UploadHandlerPart = {
-    name: string;
-    filename?: string;
-    contentType: string;
-    data: AsyncIterable<Uint8Array>;
-};
-export type UploadHandler = (part: UploadHandlerPart) => Promise<File | string | null | undefined>;
-export declare function composeUploadHandlers(...handlers: UploadHandler[]): UploadHandler;
-/**
- * Allows you to handle multipart forms (file uploads) for your app.
- *
- * TODO: Update this comment
- * @see https://remix.run/utils/parse-multipart-form-data
- */
-export declare function parseMultipartFormData(request: Request, uploadHandler: UploadHandler): Promise<FormData>;