@epic-web/workshop-app 4.0.0

package/node_modules/remix-utils/build/client/cache-assets.d.ts

@@ -0,0 +1,22 @@
+export interface CacheAssetsOptions {
+    /**
+     * The name of the cache to use inside the browser Cache Storage
+     * @default "assets"
+     */
+    cacheName?: string;
+    /**
+     * The path prefix for all build assets, if you used a subdomain ensure this
+     * is only the pathname part.
+     * @default "/build/"
+     */
+    buildPath?: string;
+}
+/**
+ * Caches all JS files built by Remix in a browser cache.
+ * This will use the Remix manifest to determine which files to cache.
+ * It will get every JS file, get all the already cached URLs, remove any
+ * old file, and finally add the new files to the cache.
+ *
+ * **This can only be run inside entry.client**
+ */
+export declare function cacheAssets({ cacheName, buildPath, }?: CacheAssetsOptions): Promise<void>;

package/node_modules/remix-utils/build/client/cache-assets.js

@@ -0,0 +1,66 @@
+/**
+ * Caches all JS files built by Remix in a browser cache.
+ * This will use the Remix manifest to determine which files to cache.
+ * It will get every JS file, get all the already cached URLs, remove any
+ * old file, and finally add the new files to the cache.
+ *
+ * **This can only be run inside entry.client**
+ */
+export async function cacheAssets({ cacheName = "assets", buildPath = "/build/", } = {}) {
+    let paths = getFilePaths();
+    let cache = await caches.open(cacheName);
+    let urls = await getCachedUrls(cache, buildPath);
+    await removeOldAssets(cache, paths, urls);
+    await addNewAssets(cache, paths, urls);
+}
+function getFilePaths() {
+    try {
+        return unique([
+            ...Object.values(window.__remixManifest.routes).flatMap((route) => {
+                return [route.module, ...(route.imports ?? [])];
+            }),
+            window.__remixManifest.url,
+            window.__remixManifest.entry.module,
+            ...window.__remixManifest.entry.imports,
+        ]);
+    }
+    catch {
+        throw new Error("Failed to get file paths from Remix manifest");
+    }
+}
+async function getCachedUrls(cache, buildPath = "/build/") {
+    try {
+        let keys = await cache.keys();
+        return keys
+            .map((key) => {
+            return new URL(key.url);
+        })
+            .filter((url) => url.hostname === window.location.hostname)
+            .map((url) => url.pathname)
+            .filter((pathname) => pathname.startsWith(buildPath));
+    }
+    catch {
+        throw new Error("Failed to retrieve cached URLs");
+    }
+}
+async function removeOldAssets(cache, paths, urls) {
+    try {
+        await Promise.all(urls
+            .filter((pathname) => !paths.includes(pathname))
+            .map((pathname) => cache.delete(pathname)));
+    }
+    catch {
+        throw new Error("Failed to remove old assets from the cache");
+    }
+}
+async function addNewAssets(cache, paths, urls) {
+    try {
+        await cache.addAll(paths.filter((path) => !urls.includes(path)));
+    }
+    catch {
+        throw new Error("Failed to add new assets to the cache");
+    }
+}
+function unique(array) {
+    return [...new Set(array)];
+}

package/node_modules/remix-utils/build/common/promise.d.ts

@@ -0,0 +1,87 @@
+/**
+ * @see https://twitter.com/buildsghost/status/1507109734519750680
+ */
+export type PromiseHash = Record<string, Promise<unknown>>;
+export type AwaitedPromiseHash<Hash extends PromiseHash> = {
+    [Key in keyof Hash]: Awaited<Hash[Key]>;
+};
+/**
+ * Get a hash of promises and await them all.
+ * Then return the same hash with the resolved values.
+ * @example
+ * export async function loader({ request }: LoaderArgs) {
+ *   return json(
+ *     promiseHash({
+ *       user: getUser(request),
+ *       posts: getPosts(request),
+ *     })
+ *   );
+ * }
+ * @example
+ * export async function loader({ request }: LoaderArgs) {
+ *   return json(
+ *     promiseHash({
+ *       user: getUser(request),
+ *       posts: promiseHash({
+ *         list: getPosts(request),
+ *         comments: promiseHash({
+ *           list: getComments(request),
+ *           likes: getLikes(request),
+ *         }),
+ *       }),
+ *     })
+ *   );
+ * }
+ */
+export declare function promiseHash<Hash extends PromiseHash>(hash: Hash): Promise<AwaitedPromiseHash<Hash>>;
+/**
+ * Attach a timeout to any promise, if the timeout resolves first ignore the
+ * original promise and throw an error
+ * @param promise The promise to attach a timeout to
+ * @param options The options to use
+ * @param options.ms The number of milliseconds to wait before timing out
+ * @param options.controller An AbortController to abort the original promise
+ * @returns The result of the promise
+ * @throws TimeoutError If the timeout resolves first
+ * @example
+ * try {
+ *   let result = await timeout(
+ *     fetch("https://example.com"),
+ *     { ms: 100 }
+ *   );
+ * } catch (error) {
+ *   if (error instanceof TimeoutError) {
+ *     // Handle timeout
+ *   }
+ * }
+ * @example
+ * try {
+ *   let controller = new AbortController();
+ *   let result = await timeout(
+ *     fetch("https://example.com", { signal: controller.signal }),
+ *     { ms: 100, controller }
+ *   );
+ * } catch (error) {
+ *   if (error instanceof TimeoutError) {
+ *     // Handle timeout
+ *   }
+ * }
+ */
+export declare function timeout<Value>(promise: Promise<Value>, options: {
+    controller?: AbortController;
+    ms: number;
+}): Promise<Value>;
+/**
+ * An error thrown when a timeout occurs
+ * @example
+ * try {
+ *   let result = await timeout(fetch("https://example.com"), { ms: 100 });
+ * } catch (error) {
+ *   if (error instanceof TimeoutError) {
+ *    // Handle timeout
+ *   }
+ * }
+ */
+export declare class TimeoutError extends Error {
+    constructor(message: string);
+}

package/node_modules/remix-utils/build/common/promise.js

@@ -0,0 +1,112 @@
+/**
+ * Get a hash of promises and await them all.
+ * Then return the same hash with the resolved values.
+ * @example
+ * export async function loader({ request }: LoaderArgs) {
+ *   return json(
+ *     promiseHash({
+ *       user: getUser(request),
+ *       posts: getPosts(request),
+ *     })
+ *   );
+ * }
+ * @example
+ * export async function loader({ request }: LoaderArgs) {
+ *   return json(
+ *     promiseHash({
+ *       user: getUser(request),
+ *       posts: promiseHash({
+ *         list: getPosts(request),
+ *         comments: promiseHash({
+ *           list: getComments(request),
+ *           likes: getLikes(request),
+ *         }),
+ *       }),
+ *     })
+ *   );
+ * }
+ */
+export async function promiseHash(hash) {
+    return Object.fromEntries(await Promise.all(Object.entries(hash).map(async ([key, promise]) => [key, await promise])));
+}
+/**
+ * Used to uniquely identify a timeout
+ * @private
+ */
+let TIMEOUT = Symbol("TIMEOUT");
+/**
+ * Attach a timeout to any promise, if the timeout resolves first ignore the
+ * original promise and throw an error
+ * @param promise The promise to attach a timeout to
+ * @param options The options to use
+ * @param options.ms The number of milliseconds to wait before timing out
+ * @param options.controller An AbortController to abort the original promise
+ * @returns The result of the promise
+ * @throws TimeoutError If the timeout resolves first
+ * @example
+ * try {
+ *   let result = await timeout(
+ *     fetch("https://example.com"),
+ *     { ms: 100 }
+ *   );
+ * } catch (error) {
+ *   if (error instanceof TimeoutError) {
+ *     // Handle timeout
+ *   }
+ * }
+ * @example
+ * try {
+ *   let controller = new AbortController();
+ *   let result = await timeout(
+ *     fetch("https://example.com", { signal: controller.signal }),
+ *     { ms: 100, controller }
+ *   );
+ * } catch (error) {
+ *   if (error instanceof TimeoutError) {
+ *     // Handle timeout
+ *   }
+ * }
+ */
+export function timeout(promise, options) {
+    return new Promise(async (resolve, reject) => {
+        let timer = null;
+        try {
+            let result = await Promise.race([
+                promise,
+                new Promise((resolve) => {
+                    timer = setTimeout(() => resolve(TIMEOUT), options.ms);
+                }),
+            ]);
+            if (timer)
+                clearTimeout(timer);
+            if (result === TIMEOUT) {
+                if (options.controller)
+                    options.controller.abort();
+                return reject(new TimeoutError(`Timed out after ${options.ms}ms`));
+            }
+            return resolve(result);
+        }
+        catch (error) {
+            if (timer)
+                clearTimeout(timer);
+            reject(error);
+        }
+    });
+}
+/**
+ * An error thrown when a timeout occurs
+ * @example
+ * try {
+ *   let result = await timeout(fetch("https://example.com"), { ms: 100 });
+ * } catch (error) {
+ *   if (error instanceof TimeoutError) {
+ *    // Handle timeout
+ *   }
+ * }
+ */
+export class TimeoutError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "TimeoutError";
+    }
+}

package/node_modules/remix-utils/build/common/timers.d.ts

@@ -0,0 +1,27 @@
+interface Options {
+    signal?: AbortSignal;
+}
+/**
+ * Wait for a specified amount of time, accepts a signal to abort the timer.
+ * @param ms The amount of time to wait in milliseconds
+ * @param options The options for the timer
+ * @example
+ * let controller = new AbortController();
+ * await wait(1000, { signal: controller.signal });
+ */
+export declare function wait(ms: number, options?: Options): Promise<void>;
+/**
+ * Get an async iterable that yields on an interval until aborted.
+ * @param ms The amount of time to wait between intervals, in milliseconds
+ * @param options The options for the timer
+ * @returns An async iterable that yields on each intervals
+ * @example
+ * let controller = new AbortController();
+ * for await (let _ of interval(1000, { signal: controller.signal })) {
+ *  // Do something every second until aborted
+ * }
+ */
+export declare function interval(ms: number, options?: Options): AsyncGenerator<void, void, unknown>;
+export declare class TimersError extends globalThis.Error {
+}
+export {};

package/node_modules/remix-utils/build/common/timers.js

@@ -0,0 +1,47 @@
+/**
+ * Wait for a specified amount of time, accepts a signal to abort the timer.
+ * @param ms The amount of time to wait in milliseconds
+ * @param options The options for the timer
+ * @example
+ * let controller = new AbortController();
+ * await wait(1000, { signal: controller.signal });
+ */
+export function wait(ms, options) {
+    return new Promise((resolve, reject) => {
+        let timeout = setTimeout(() => {
+            if (options?.signal?.aborted)
+                return reject(new TimersError("Aborted"));
+            return resolve();
+        }, ms);
+        if (options?.signal) {
+            options.signal.addEventListener("abort", () => {
+                clearTimeout(timeout);
+                reject(new TimersError("Aborted"));
+            });
+        }
+    });
+}
+/**
+ * Get an async iterable that yields on an interval until aborted.
+ * @param ms The amount of time to wait between intervals, in milliseconds
+ * @param options The options for the timer
+ * @returns An async iterable that yields on each intervals
+ * @example
+ * let controller = new AbortController();
+ * for await (let _ of interval(1000, { signal: controller.signal })) {
+ *  // Do something every second until aborted
+ * }
+ */
+export async function* interval(ms, options) {
+    let signal = options?.signal ?? new AbortSignal();
+    while (!signal.aborted) {
+        try {
+            yield await wait(ms, { signal });
+        }
+        catch {
+            return;
+        }
+    }
+}
+export class TimersError extends globalThis.Error {
+}

package/node_modules/remix-utils/build/react/authenticity-token.d.ts

@@ -0,0 +1,50 @@
+import * as React from "react";
+export interface AuthenticityTokenProviderProps {
+    children: React.ReactNode;
+    token: string;
+}
+export interface AuthenticityTokenInputProps {
+    name?: string;
+}
+/**
+ * Save the Authenticity Token into context
+ * @example
+ * // Add `<AuthenticityTokenProvider>` wrapping your Outlet
+ * let { csrf } = useLoaderData<typeof loader>();
+ * return (
+ *   <AuthenticityTokenProvider token={csrf}>
+ *     <Outlet />
+ *   </AuthenticityTokenProvider>
+ * )
+ */
+export declare function AuthenticityTokenProvider({ children, token, }: AuthenticityTokenProviderProps): React.JSX.Element;
+/**
+ * Get the authenticity token, this should be used to send it in a submit.
+ * @example
+ * let token = useAuthenticityToken();
+ * let submit = useSubmit();
+ * function sendFormWithCode() {
+ *   submit(
+ *     { csrf: token, ...otherData },
+ *     { action: "/action", method: "post" },
+ *   );
+ * }
+ */
+export declare function useAuthenticityToken(): string;
+/**
+ * Render a hidden input with the name csrf and the authenticity token as value.
+ * @example
+ * // Default usage
+ * return (
+ *   <Form action="/login" method="post">
+ *     <AuthenticityTokenInput />
+ *     <input name="email" type="email" />
+ *     <input name="password" type="password" />
+ *     <button type="submit">Login</button>
+ *   </Form>
+ * );
+ * @example
+ * // Customizing the name
+ * <AuthenticityTokenInput name="authenticity_token" />
+ */
+export declare function AuthenticityTokenInput({ name, }: AuthenticityTokenInputProps): React.JSX.Element;

package/node_modules/remix-utils/build/react/authenticity-token.js

@@ -0,0 +1,54 @@
+import * as React from "react";
+let context = React.createContext(null);
+/**
+ * Save the Authenticity Token into context
+ * @example
+ * // Add `<AuthenticityTokenProvider>` wrapping your Outlet
+ * let { csrf } = useLoaderData<typeof loader>();
+ * return (
+ *   <AuthenticityTokenProvider token={csrf}>
+ *     <Outlet />
+ *   </AuthenticityTokenProvider>
+ * )
+ */
+export function AuthenticityTokenProvider({ children, token, }) {
+    return React.createElement(context.Provider, { value: token }, children);
+}
+/**
+ * Get the authenticity token, this should be used to send it in a submit.
+ * @example
+ * let token = useAuthenticityToken();
+ * let submit = useSubmit();
+ * function sendFormWithCode() {
+ *   submit(
+ *     { csrf: token, ...otherData },
+ *     { action: "/action", method: "post" },
+ *   );
+ * }
+ */
+export function useAuthenticityToken() {
+    let token = React.useContext(context);
+    if (!token)
+        throw new Error("Missing AuthenticityTokenProvider.");
+    return token;
+}
+/**
+ * Render a hidden input with the name csrf and the authenticity token as value.
+ * @example
+ * // Default usage
+ * return (
+ *   <Form action="/login" method="post">
+ *     <AuthenticityTokenInput />
+ *     <input name="email" type="email" />
+ *     <input name="password" type="password" />
+ *     <button type="submit">Login</button>
+ *   </Form>
+ * );
+ * @example
+ * // Customizing the name
+ * <AuthenticityTokenInput name="authenticity_token" />
+ */
+export function AuthenticityTokenInput({ name = "csrf", }) {
+    let token = useAuthenticityToken();
+    return React.createElement("input", { type: "hidden", value: token, name: name });
+}

package/node_modules/remix-utils/build/react/client-only.d.ts

@@ -0,0 +1,27 @@
+import * as React from "react";
+type Props = {
+    /**
+     * You are encouraged to add a fallback that is the same dimensions
+     * as the client rendered children. This will avoid content layout
+     * shift which is disgusting
+     */
+    children(): React.ReactNode;
+    fallback?: React.ReactNode;
+};
+/**
+ * Render the children only after the JS has loaded client-side. Use an optional
+ * fallback component if the JS is not yet loaded.
+ *
+ * Example: Render a Chart component if JS loads, renders a simple FakeChart
+ * component server-side or if there is no JS. The FakeChart can have only the
+ * UI without the behavior or be a loading spinner or skeleton.
+ * ```tsx
+ * return (
+ *   <ClientOnly fallback={<FakeChart />}>
+ *     {() => <Chart />}
+ *   </ClientOnly>
+ * );
+ * ```
+ */
+export declare function ClientOnly({ children, fallback }: Props): React.JSX.Element;
+export {};

package/node_modules/remix-utils/build/react/client-only.js

@@ -0,0 +1,20 @@
+import * as React from "react";
+import { useHydrated } from "./use-hydrated.js";
+/**
+ * Render the children only after the JS has loaded client-side. Use an optional
+ * fallback component if the JS is not yet loaded.
+ *
+ * Example: Render a Chart component if JS loads, renders a simple FakeChart
+ * component server-side or if there is no JS. The FakeChart can have only the
+ * UI without the behavior or be a loading spinner or skeleton.
+ * ```tsx
+ * return (
+ *   <ClientOnly fallback={<FakeChart />}>
+ *     {() => <Chart />}
+ *   </ClientOnly>
+ * );
+ * ```
+ */
+export function ClientOnly({ children, fallback = null }) {
+    return useHydrated() ? React.createElement(React.Fragment, null, children()) : React.createElement(React.Fragment, null, fallback);
+}

package/node_modules/remix-utils/build/react/existing-search-params.d.ts

@@ -0,0 +1,34 @@
+import * as React from "react";
+type Props = {
+    /**
+     * These query params will not be included as hidden inputs.
+     *  - add params handled by this form to this list
+     *  - any params from other forms you want to clear on submit
+     */
+    exclude?: Array<string | undefined>;
+} & Omit<React.InputHTMLAttributes<HTMLInputElement>, "name" | "value" | "type" | "id">;
+/**
+ * Include existing query params as hidden inputs in a form.
+ *
+ * @example
+ * A pagination bar that does not clear the search query
+ * ```tsx
+ * <Form>
+ *   <ExistingSearchParams exclude={['page']} />
+ *   <button type="submit" name="page" value="1">1</button>
+ *   <button type="submit" name="page" value="2">2</button>
+ *   <button type="submit" name="page" value="3">3</button>
+ * </Form>
+ * ```
+ *
+ * @example
+ * A search form that clears the page param
+ * ```tsx
+ * <Form>
+ *   <ExistingSearchParams exclude={['q', 'page']} />
+ *   <input type="search" name="q" />
+ * </Form>
+ * ```
+ */
+export declare function ExistingSearchParams({ exclude, ...props }: Props): React.JSX.Element;
+export {};

package/node_modules/remix-utils/build/react/existing-search-params.js

@@ -0,0 +1,32 @@
+import * as React from "react";
+import { useSearchParams } from "@remix-run/react";
+/**
+ * Include existing query params as hidden inputs in a form.
+ *
+ * @example
+ * A pagination bar that does not clear the search query
+ * ```tsx
+ * <Form>
+ *   <ExistingSearchParams exclude={['page']} />
+ *   <button type="submit" name="page" value="1">1</button>
+ *   <button type="submit" name="page" value="2">2</button>
+ *   <button type="submit" name="page" value="3">3</button>
+ * </Form>
+ * ```
+ *
+ * @example
+ * A search form that clears the page param
+ * ```tsx
+ * <Form>
+ *   <ExistingSearchParams exclude={['q', 'page']} />
+ *   <input type="search" name="q" />
+ * </Form>
+ * ```
+ */
+export function ExistingSearchParams({ exclude, ...props }) {
+    const [searchParams] = useSearchParams();
+    const existingSearchParams = [...searchParams.entries()].filter(([key]) => !exclude?.includes(key));
+    return (React.createElement(React.Fragment, null, existingSearchParams.map(([key, value]) => {
+        return (React.createElement("input", { key: `${key}=${value}`, ...props, type: "hidden", name: key, value: value }));
+    })));
+}

package/node_modules/remix-utils/build/react/external-scripts.d.ts

@@ -0,0 +1,91 @@
+import * as React from "react";
+import { HandleConventionArguments } from "./handle-conventions.js";
+export type ReferrerPolicy = "no-referrer-when-downgrade" | "no-referrer" | "origin-when-cross-origin" | "origin" | "same-origin" | "strict-origin-when-cross-origin" | "strict-origin" | "unsafe-url";
+export type CrossOrigin = "anonymous" | "use-credentials";
+export type ScriptType = "module" | "text/javascript";
+export type ScriptDescriptor = {
+    /** Enable preloading of this script on SSR */
+    preload?: boolean;
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script#async
+     */
+    async?: boolean;
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script#attr-crossorigin
+     */
+    crossOrigin?: CrossOrigin;
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script#attr-defer
+     */
+    defer?: boolean;
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script#attr-integrity
+     */
+    integrity?: string;
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script#attr-nomodule
+     */
+    noModule?: boolean;
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script#attr-nonce
+     */
+    nonce?: string;
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script#attr-referrerpolicy
+     */
+    referrerPolicy?: ReferrerPolicy;
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script#attr-src
+     */
+    src: string;
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script#attr-type
+     */
+    type?: ScriptType;
+};
+export interface ExternalScriptsFunction<Loader = unknown> {
+    (args: HandleConventionArguments<Loader>): ScriptDescriptor[];
+}
+/**
+ * Define the shape of the `handle` export if you want to use `scripts`. Combine
+ * it with your own `handle` type to add `scripts` to your route.
+ * @description Add a scripts function that access the route's loader data
+ * @example
+ * export const handle: ExternalScriptsHandle<SerializeFrom<typeof loader>> = {
+ *   scripts(loaderData) { ... }
+ * }
+ * @description Add a static scripts array
+ * @example
+ * export const handle: ExternalScriptsHandle = {
+ *   scripts: [...]
+ * }
+ * @description Extend it with your own handle type
+ * @example
+ * interface Handle<Data = unknown> extends ExternalScriptsHandle<Data> {
+ *   // extra things here
+ * }
+ * export const handle: Handle = {
+ *   scripts, // define scripts here
+ *   // and any other handle properties here
+ * }
+ */
+export interface ExternalScriptsHandle<Data = unknown> {
+    scripts?: ExternalScriptsFunction<Data> | ScriptDescriptor[];
+}
+/**
+ * Load scripts defined by each route in a single place, often in `root`.
+ * @example
+ * // Defines a `scripts` function in a route `handle`
+ * export const handle: ExternalScriptsHandle<SerializeFrom<typeof loader>> = {
+ *   scripts(loaderData) { ... }
+ * }
+ * // Or define a scripts array directly
+ * export const handle: ExternalScriptsHandle = {
+ *   scripts: [...]
+ * }
+ * // Then render ExternalScripts in your root
+ * return <ExternalScripts />
+ */
+export declare function ExternalScripts(): React.JSX.Element;
+export declare function useExternalScripts(): any[];
+export declare function ExternalScript({ src, preload, async, defer, crossOrigin, integrity, type, referrerPolicy, noModule, nonce, }: ScriptDescriptor): React.JSX.Element | null;