@epic-web/workshop-app 5.0.3 → 5.1.1

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

@@ -1,65 +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
- */
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-/**
- * Creates and returns a simple in-memory SessionStorage object, mostly useful
- * for testing and as a reference implementation.
- *
- * Note: This storage does not scale beyond a single process, so it is not
- * suitable for most production scenarios.
- *
- * @see https://remix.run/utils/sessions#creatememorysessionstorage
- */
-const createMemorySessionStorageFactory = createSessionStorage => ({
-  cookie
-} = {}) => {
-  let map = new Map();
-  return createSessionStorage({
-    cookie,
-    async createData(data, expires) {
-      let id = Math.random().toString(36).substring(2, 10);
-      map.set(id, {
-        data,
-        expires
-      });
-      return id;
-    },
-    async readData(id) {
-      if (map.has(id)) {
-        let {
-          data,
-          expires
-        } = map.get(id);
-        if (!expires || expires > new Date()) {
-          return data;
-        }
-
-        // Remove expired session data.
-        if (expires) map.delete(id);
-      }
-      return null;
-    },
-    async updateData(id, data, expires) {
-      map.set(id, {
-        data,
-        expires
-      });
-    },
-    async deleteData(id) {
-      map.delete(id);
-    }
-  });
-};
-
-exports.createMemorySessionStorageFactory = createMemorySessionStorageFactory;

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

@@ -1,143 +0,0 @@
-import type { CookieParseOptions, CookieSerializeOptions } from "cookie";
-import type { Cookie, CookieOptions, CreateCookieFunction } from "./cookies";
-/**
- * An object of name/value pairs to be used in the session.
- */
-export interface SessionData {
-    [name: string]: any;
-}
-/**
- * Session persists data across HTTP requests.
- *
- * @see https://remix.run/utils/sessions#session-api
- */
-export interface Session<Data = SessionData, FlashData = Data> {
-    /**
-     * A unique identifier for this session.
-     *
-     * Note: This will be the empty string for newly created sessions and
-     * sessions that are not backed by a database (i.e. cookie-based sessions).
-     */
-    readonly id: string;
-    /**
-     * The raw data contained in this session.
-     *
-     * This is useful mostly for SessionStorage internally to access the raw
-     * session data to persist.
-     */
-    readonly data: FlashSessionData<Data, FlashData>;
-    /**
-     * Returns `true` if the session has a value for the given `name`, `false`
-     * otherwise.
-     */
-    has(name: (keyof Data | keyof FlashData) & string): boolean;
-    /**
-     * Returns the value for the given `name` in this session.
-     */
-    get<Key extends (keyof Data | keyof FlashData) & string>(name: Key): (Key extends keyof Data ? Data[Key] : undefined) | (Key extends keyof FlashData ? FlashData[Key] : undefined) | undefined;
-    /**
-     * Sets a value in the session for the given `name`.
-     */
-    set<Key extends keyof Data & string>(name: Key, value: Data[Key]): void;
-    /**
-     * Sets a value in the session that is only valid until the next `get()`.
-     * This can be useful for temporary values, like error messages.
-     */
-    flash<Key extends keyof FlashData & string>(name: Key, value: FlashData[Key]): void;
-    /**
-     * Removes a value from the session.
-     */
-    unset(name: keyof Data & string): void;
-}
-export type FlashSessionData<Data, FlashData> = Partial<Data & {
-    [Key in keyof FlashData as FlashDataKey<Key & string>]: FlashData[Key];
-}>;
-type FlashDataKey<Key extends string> = `__flash_${Key}__`;
-export type CreateSessionFunction = <Data = SessionData, FlashData = Data>(initialData?: Data, id?: string) => Session<Data, FlashData>;
-/**
- * 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
- */
-export declare const createSession: CreateSessionFunction;
-export type IsSessionFunction = (object: any) => object is Session;
-/**
- * Returns true if an object is a Remix session.
- *
- * @see https://remix.run/utils/sessions#issession
- */
-export declare const isSession: IsSessionFunction;
-/**
- * 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.
- */
-export interface SessionStorage<Data = SessionData, FlashData = Data> {
-    /**
-     * Parses a Cookie header from a HTTP request and returns the associated
-     * Session. If there is no session associated with the cookie, this will
-     * return a new Session with no data.
-     */
-    getSession: (cookieHeader?: string | null, options?: CookieParseOptions) => Promise<Session<Data, FlashData>>;
-    /**
-     * Stores all data in the Session and returns the Set-Cookie header to be
-     * used in the HTTP response.
-     */
-    commitSession: (session: Session<Data, FlashData>, options?: CookieSerializeOptions) => Promise<string>;
-    /**
-     * Deletes all data associated with the Session and returns the Set-Cookie
-     * header to be used in the HTTP response.
-     */
-    destroySession: (session: Session<Data, FlashData>, options?: CookieSerializeOptions) => Promise<string>;
-}
-/**
- * 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.
- */
-export interface SessionIdStorageStrategy<Data = SessionData, FlashData = Data> {
-    /**
-     * The Cookie used to store the session id, or options used to automatically
-     * create one.
-     */
-    cookie?: Cookie | (CookieOptions & {
-        name?: string;
-    });
-    /**
-     * Creates a new record with the given data and returns the session id.
-     */
-    createData: (data: FlashSessionData<Data, FlashData>, expires?: Date) => Promise<string>;
-    /**
-     * Returns data for a given session id, or `null` if there isn't any.
-     */
-    readData: (id: string) => Promise<FlashSessionData<Data, FlashData> | null>;
-    /**
-     * Updates data for the given session id.
-     */
-    updateData: (id: string, data: FlashSessionData<Data, FlashData>, expires?: Date) => Promise<void>;
-    /**
-     * Deletes data for a given session id from the data store.
-     */
-    deleteData: (id: string) => Promise<void>;
-}
-export type CreateSessionStorageFunction = <Data = SessionData, FlashData = Data>(strategy: SessionIdStorageStrategy<Data, FlashData>) => SessionStorage<Data, FlashData>;
-/**
- * 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
- */
-export declare const createSessionStorageFactory: (createCookie: CreateCookieFunction) => CreateSessionStorageFunction;
-export declare function warnOnceAboutSigningSessionCookie(cookie: Cookie): void;
-export {};

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

@@ -1,152 +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
- */
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var cookies = require('./cookies.js');
-var warnings = require('./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 = cookies.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) {
-  warnings.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.`);
-}
-
-exports.createSession = createSession;
-exports.createSessionStorageFactory = createSessionStorageFactory;
-exports.isSession = isSession;
-exports.warnOnceAboutSigningSessionCookie = warnOnceAboutSigningSessionCookie;

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

@@ -1,90 +0,0 @@
-import type { ActionFunctionArgs as RRActionArgs, LoaderFunctionArgs as RRLoaderArgs, StaticHandler, unstable_DataStrategyFunction as DataStrategyFunction, StaticHandlerContext } from "@remix-run/router";
-import { UNSAFE_ErrorResponseImpl as ErrorResponseImpl } from "@remix-run/router";
-import type { AppLoadContext } from "./data";
-import { ServerMode } from "./mode";
-import type { TypedDeferredData, TypedResponse } from "./responses";
-import type { SerializeFrom } from "./serialize";
-export declare const SingleFetchRedirectSymbol: unique symbol;
-type SingleFetchRedirectResult = {
-    redirect: string;
-    status: number;
-    revalidate: boolean;
-    reload: boolean;
-};
-export type SingleFetchResult = {
-    data: unknown;
-} | {
-    error: unknown;
-} | SingleFetchRedirectResult;
-export type SingleFetchResults = {
-    [key: string]: SingleFetchResult;
-    [SingleFetchRedirectSymbol]?: SingleFetchRedirectResult;
-};
-export type DataStrategyCtx = {
-    response: ResponseStub;
-};
-export declare const SINGLE_FETCH_REDIRECT_STATUS = 202;
-export declare function getSingleFetchDataStrategy(responseStubs: ReturnType<typeof getResponseStubs>, { isActionDataRequest, loadRouteIds, }?: {
-    isActionDataRequest?: boolean;
-    loadRouteIds?: string[];
-}): DataStrategyFunction;
-export declare function getSingleFetchResourceRouteDataStrategy({ responseStubs, }: {
-    responseStubs: ReturnType<typeof getResponseStubs>;
-}): DataStrategyFunction;
-export declare function singleFetchAction(serverMode: ServerMode, staticHandler: StaticHandler, request: Request, handlerUrl: URL, loadContext: AppLoadContext, handleError: (err: unknown) => void): Promise<{
-    result: SingleFetchResult;
-    headers: Headers;
-    status: number;
-}>;
-export declare function singleFetchLoaders(serverMode: ServerMode, staticHandler: StaticHandler, request: Request, handlerUrl: URL, loadContext: AppLoadContext, handleError: (err: unknown) => void): Promise<{
-    result: SingleFetchResults;
-    headers: Headers;
-    status: number;
-}>;
-export declare function isResponseStub(value: any): value is ResponseStubImpl;
-export declare function getResponseStubs(): Record<string | symbol, ResponseStubImpl>;
-export declare function convertResponseStubToErrorResponse(stub: ResponseStub): ErrorResponseImpl;
-export declare function mergeResponseStubs(context: StaticHandlerContext, responseStubs: ReturnType<typeof getResponseStubs>, { isActionDataRequest }?: {
-    isActionDataRequest?: boolean;
-}): {
-    statusCode: number;
-    headers: Headers;
-};
-export declare function getSingleFetchRedirect(status: number, headers: Headers): SingleFetchRedirectResult;
-export declare function encodeViaTurboStream(data: any, requestSignal: AbortSignal, streamTimeout: number | undefined, serverMode: ServerMode): ReadableStream<Uint8Array>;
-type MaybePromise<T> = T | Promise<T>;
-type Serializable = undefined | null | boolean | string | symbol | number | Array<Serializable> | {
-    [key: PropertyKey]: Serializable;
-} | bigint | Date | URL | RegExp | Error | Map<Serializable, Serializable> | Set<Serializable> | Promise<Serializable>;
-type DataFunctionReturnValue = Serializable | TypedDeferredData<Record<string, unknown>> | TypedResponse<Record<string, unknown>>;
-export type Serialize<T extends Loader | Action> = Awaited<ReturnType<T>> extends TypedDeferredData<infer D> ? D : Awaited<ReturnType<T>> extends TypedResponse<Record<string, unknown>> ? SerializeFrom<T> : Awaited<ReturnType<T>>;
-export declare const ResponseStubOperationsSymbol: unique symbol;
-export type ResponseStubOperation = [
-    "set" | "append" | "delete",
-    string,
-    string?
-];
-/**
- * A stubbed response to let you set the status/headers of your response from
- * loader/action functions
- */
-export type ResponseStub = {
-    status: number | undefined;
-    headers: Headers;
-};
-export type ResponseStubImpl = ResponseStub & {
-    [ResponseStubOperationsSymbol]: ResponseStubOperation[];
-};
-type LoaderArgs = RRLoaderArgs<AppLoadContext> & {
-    context: AppLoadContext;
-    response: ResponseStub;
-};
-export type Loader = (args: LoaderArgs) => MaybePromise<DataFunctionReturnValue>;
-export declare let defineLoader: <T extends Loader>(loader: T) => T;
-type ActionArgs = RRActionArgs<AppLoadContext> & {
-    context: AppLoadContext;
-    response: ResponseStub;
-};
-export type Action = (args: ActionArgs) => MaybePromise<DataFunctionReturnValue>;
-export declare let defineAction: <T extends Action>(action: T) => T;
-export {};