@epic-web/workshop-app 4.0.0

package/node_modules/remix-utils/build/react/external-scripts.js

@@ -0,0 +1,106 @@
+import * as React from "react";
+import { useLocation, useMatches } from "@remix-run/react";
+import { useHydrated } from "./use-hydrated.js";
+/**
+ * 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 function ExternalScripts() {
+    let scripts = useExternalScripts();
+    return (React.createElement(React.Fragment, null, scripts.map((props) => {
+        return React.createElement(ExternalScript, { key: props.src, ...props });
+    })));
+}
+export function useExternalScripts() {
+    let location = useLocation();
+    let matches = useMatches();
+    return React.useMemo(() => {
+        let scripts = matches.flatMap((match, index, matches) => {
+            if (!match.handle)
+                return []; // ignore no-handle routes
+            if (match.handle === null)
+                return []; // ignore null handles
+            if (typeof match.handle !== "object")
+                return []; // and non error handles
+            if (!("scripts" in match.handle))
+                return []; // and without scripts
+            let scripts = match.handle.scripts;
+            // if scripts is an array, suppose it's an array of script descriptors
+            // and return it
+            if (Array.isArray(scripts))
+                return scripts;
+            // if it's not a function (and not an array), ignore it
+            if (typeof scripts !== "function")
+                return [];
+            let result = scripts({
+                id: match.id,
+                data: match.data,
+                params: match.params,
+                location,
+                parentsData: matches.slice(0, index).map((match) => match.data),
+                matches,
+            });
+            if (Array.isArray(result))
+                return result;
+            return [];
+        });
+        let uniqueScripts = new Map();
+        for (let script of scripts)
+            uniqueScripts.set(script.src, script);
+        return [...uniqueScripts.values()];
+    }, [matches, location]);
+}
+export function ExternalScript({ src, preload = false, async = true, defer = true, crossOrigin, integrity, type, referrerPolicy, noModule, nonce, }) {
+    let isHydrated = useHydrated();
+    let startsHydrated = React.useRef(isHydrated);
+    React.useEffect(() => {
+        if (!startsHydrated.current && isHydrated)
+            return;
+        let $script = document.createElement("script");
+        $script.src = src;
+        let attributes = {
+            async,
+            defer,
+            crossOrigin,
+            integrity,
+            type,
+            referrerPolicy,
+            noModule,
+            nonce,
+        };
+        for (let [key, value] of Object.entries(attributes)) {
+            if (value)
+                $script.setAttribute(key, value.toString());
+        }
+        document.body.append($script);
+        return () => $script.remove();
+    }, [
+        async,
+        crossOrigin,
+        defer,
+        integrity,
+        isHydrated,
+        noModule,
+        nonce,
+        referrerPolicy,
+        src,
+        type,
+    ]);
+    if (startsHydrated.current && isHydrated)
+        return null;
+    let rel = noModule ? "modulepreload" : "preload";
+    let as = noModule ? undefined : "script";
+    return (React.createElement(React.Fragment, null,
+        preload && (React.createElement("link", { rel: rel, href: src, as: as, crossOrigin: crossOrigin, integrity: integrity, referrerPolicy: referrerPolicy })),
+        React.createElement("script", { src: src, defer: defer, async: async, type: type, noModule: noModule, nonce: nonce, crossOrigin: crossOrigin, integrity: integrity, referrerPolicy: referrerPolicy })));
+}

package/node_modules/remix-utils/build/react/fetcher-type.d.ts

@@ -0,0 +1,31 @@
+import { type FetcherWithComponents } from "@remix-run/react";
+import { type Navigation } from "@remix-run/router";
+/**
+ * The list of types a fetcher can have
+ */
+export type FetcherType = "init" | "done" | "actionSubmission" | "actionReload" | "actionRedirect" | "loaderSubmission" | "normalLoad";
+/**
+ * Derive the deprecated `fetcher.type` from the current state of a fetcher.
+ * @param fetcher The `fetcher` object returned form `useFetcher`
+ * @example
+ * let fetcher = useFetcher();
+ * let fetcherType = useFetcherType(fetcher);
+ * useEffect(() => {
+ *   if (fetcherType === "done") // do something once fetcher is done
+ * }, [fetcherType]);
+ */
+export declare function useFetcherType(fetcher: FetcherWithComponents<unknown>): FetcherType;
+/**
+ * Derive the deprecated `fetcher.type` from the current state of a fetcher
+ * and navigation.
+ * @param fetcher The `fetcher` object returned form `useFetcher`
+ * @param navigation The `Navigation` object returned from `useNavigation`
+ * @example
+ * let fetcher = useFetcher();
+ * let navigation = useNavigation();
+ * let fetcherType = getFetcherType(fetcher, navigation);
+ * useEffect(() => {
+ *   if (fetcherType === "done") // do something once fetcher is done
+ * }, [fetcherType])
+ */
+export declare function getFetcherType(fetcher: Pick<FetcherWithComponents<unknown>, "state" | "data" | "formMethod">, navigation: Pick<Navigation, "formMethod" | "state">): FetcherType;

package/node_modules/remix-utils/build/react/fetcher-type.js

@@ -0,0 +1,53 @@
+import { useNavigation } from "@remix-run/react";
+/**
+ * Derive the deprecated `fetcher.type` from the current state of a fetcher.
+ * @param fetcher The `fetcher` object returned form `useFetcher`
+ * @example
+ * let fetcher = useFetcher();
+ * let fetcherType = useFetcherType(fetcher);
+ * useEffect(() => {
+ *   if (fetcherType === "done") // do something once fetcher is done
+ * }, [fetcherType]);
+ */
+export function useFetcherType(fetcher) {
+    let navigation = useNavigation();
+    return getFetcherType(fetcher, navigation);
+}
+/**
+ * Derive the deprecated `fetcher.type` from the current state of a fetcher
+ * and navigation.
+ * @param fetcher The `fetcher` object returned form `useFetcher`
+ * @param navigation The `Navigation` object returned from `useNavigation`
+ * @example
+ * let fetcher = useFetcher();
+ * let navigation = useNavigation();
+ * let fetcherType = getFetcherType(fetcher, navigation);
+ * useEffect(() => {
+ *   if (fetcherType === "done") // do something once fetcher is done
+ * }, [fetcherType])
+ */
+export function getFetcherType(fetcher, navigation) {
+    if (fetcher.state === "idle" && fetcher.data != null)
+        return "done";
+    if (fetcher.state === "submitting")
+        return "actionSubmission";
+    if (fetcher.state === "loading" &&
+        fetcher.formMethod != null &&
+        navigation.formMethod !== "GET" &&
+        fetcher.data != null) {
+        return "actionReload";
+    }
+    if (fetcher.state === "loading" &&
+        fetcher.formMethod != null &&
+        navigation.formMethod !== "GET" &&
+        fetcher.data == null) {
+        return "actionRedirect";
+    }
+    if (navigation.state === "loading" && navigation.formMethod === "GET") {
+        return "loaderSubmission";
+    }
+    if (navigation.state === "loading" && navigation.formMethod == null) {
+        return "normalLoad";
+    }
+    return "init";
+}

package/node_modules/remix-utils/build/react/handle-conventions.d.ts

@@ -0,0 +1,10 @@
+import type { RouterState } from "@remix-run/router";
+import type { Location, Params, useMatches } from "@remix-run/react";
+export type HandleConventionArguments<Data = unknown> = {
+    id: string;
+    data: Data;
+    params: Params;
+    matches: ReturnType<typeof useMatches>;
+    location: Location;
+    parentsData: RouterState["loaderData"];
+};

package/node_modules/remix-utils/build/react/handle-conventions.js

@@ -0,0 +1 @@
+export {};

package/node_modules/remix-utils/build/react/honeypot.d.ts

@@ -0,0 +1,11 @@
+import * as React from "react";
+import type { HoneypotInputProps } from "../server/honeypot.js";
+type HoneypotContextType = Partial<HoneypotInputProps>;
+export declare function HoneypotInputs({ label, }: {
+    label?: string;
+}): JSX.Element;
+export type HoneypotProviderProps = HoneypotContextType & {
+    children: React.ReactNode;
+};
+export declare function HoneypotProvider({ children, ...context }: HoneypotProviderProps): React.JSX.Element;
+export {};

package/node_modules/remix-utils/build/react/honeypot.js

@@ -0,0 +1,16 @@
+/* eslint-disable jsx-a11y/autocomplete-valid */
+import * as React from "react";
+const HoneypotContext = React.createContext({});
+export function HoneypotInputs({ label = "Please leave this field blank", }) {
+    let context = React.useContext(HoneypotContext);
+    let { nameFieldName = "name__confirm", validFromFieldName = "from__confirm", encryptedValidFrom, } = context;
+    return (React.createElement("div", { id: `${nameFieldName}_wrap`, style: { display: "none" }, "aria-hidden": "true" },
+        React.createElement("label", { htmlFor: nameFieldName }, label),
+        React.createElement("input", { id: nameFieldName, name: nameFieldName, type: "text", defaultValue: "", autoComplete: "nope", tabIndex: -1 }),
+        validFromFieldName && encryptedValidFrom ? (React.createElement(React.Fragment, null,
+            React.createElement("label", { htmlFor: validFromFieldName }, label),
+            React.createElement("input", { id: validFromFieldName, name: validFromFieldName, type: "text", value: encryptedValidFrom, readOnly: true, autoComplete: "off", tabIndex: -1 }))) : null));
+}
+export function HoneypotProvider({ children, ...context }) {
+    return (React.createElement(HoneypotContext.Provider, { value: context }, children));
+}

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

@@ -0,0 +1,25 @@
+import * as React from "react";
+type Props = {
+    /**
+     * You are encouraged to add a fallback that is the same dimensions
+     * as the server rendered children. This will avoid content layout
+     * shift which is disgusting
+     */
+    children(): React.ReactNode;
+    fallback?: React.ReactNode;
+};
+/**
+ * Render the children only before the JS has loaded client-side. Use an
+ * optional fallback component for once the JS has loaded.
+ *
+ * Example: Render a hidden input to identify if the user has JS.
+ * ```tsx
+ * return (
+ *   <ServerOnly fallback={<FakeChart />}>
+ *     {() => <Chart />}
+ *   </ServerOnly>
+ * );
+ * ```
+ */
+export declare function ServerOnly({ children, fallback }: Props): React.JSX.Element;
+export {};

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

@@ -0,0 +1,18 @@
+import * as React from "react";
+import { useHydrated } from "./use-hydrated.js";
+/**
+ * Render the children only before the JS has loaded client-side. Use an
+ * optional fallback component for once the JS has loaded.
+ *
+ * Example: Render a hidden input to identify if the user has JS.
+ * ```tsx
+ * return (
+ *   <ServerOnly fallback={<FakeChart />}>
+ *     {() => <Chart />}
+ *   </ServerOnly>
+ * );
+ * ```
+ */
+export function ServerOnly({ children, fallback = null }) {
+    return useHydrated() ? React.createElement(React.Fragment, null, fallback) : React.createElement(React.Fragment, null, children());
+}

package/node_modules/remix-utils/build/react/use-debounce-fetcher.d.ts

@@ -0,0 +1,28 @@
+import type { SubmitOptions, FetcherWithComponents, SubmitFunction } from "@remix-run/react";
+type SubmitTarget = Parameters<SubmitFunction>["0"];
+/**
+ * Submits a HTML `<form>` to the server without reloading the page.
+ */
+type DebounceSubmitFunction = (
+/**
+ * Specifies the `<form>` to be submitted to the server, a specific
+ * `<button>` or `<input type="submit">` to use to submit the form, or some
+ * arbitrary data to submit.
+ *
+ * Note: When using a `<button>` its `name` and `value` will also be
+ * included in the form data that is submitted.
+ */
+target: SubmitTarget, 
+/**
+ * Options that override the `<form>`'s own attributes. Required when
+ * submitting arbitrary data without a backing `<form>`. Additionally, you
+ * can specify a `debounceTimeout` to delay the submission of the data.
+ */
+options?: SubmitOptions & {
+    debounceTimeout?: number;
+}) => void;
+type DebouncedFetcher<Data = unknown> = Omit<FetcherWithComponents<Data>, "submit"> & {
+    submit: DebounceSubmitFunction;
+};
+export declare function useDebounceFetcher<Data>(): DebouncedFetcher<Data>;
+export {};

package/node_modules/remix-utils/build/react/use-debounce-fetcher.js

@@ -0,0 +1,27 @@
+import { useFetcher } from "@remix-run/react";
+import { useCallback, useEffect, useRef } from "react";
+export function useDebounceFetcher() {
+    let timeoutRef = useRef();
+    useEffect(() => {
+        // no initialize step required since timeoutRef defaults undefined
+        let timeout = timeoutRef.current;
+        return () => {
+            if (timeout)
+                clearTimeout(timeout);
+        };
+    }, [timeoutRef]);
+    let fetcher = useFetcher();
+    // Clone the original submit to avoid a recursive loop
+    const originalSubmit = fetcher.submit;
+    fetcher.submit = useCallback((target, { debounceTimeout = 0, ...options } = {}) => {
+        if (timeoutRef.current)
+            clearTimeout(timeoutRef.current);
+        if (!debounceTimeout || debounceTimeout <= 0) {
+            return originalSubmit(target, options);
+        }
+        timeoutRef.current = setTimeout(() => {
+            originalSubmit(target, options);
+        }, debounceTimeout);
+    }, [originalSubmit]);
+    return fetcher;
+}

package/node_modules/remix-utils/build/react/use-debounce-submit.d.ts

@@ -0,0 +1,7 @@
+import type { SubmitOptions, SubmitFunction } from "@remix-run/react";
+type SubmitTarget = Parameters<SubmitFunction>["0"];
+export declare function useDebounceSubmit(): (target: SubmitTarget, options?: SubmitOptions & {
+    /** Submissions within this timeout will be canceled */
+    debounceTimeout?: number;
+}) => void;
+export {};

package/node_modules/remix-utils/build/react/use-debounce-submit.js

@@ -0,0 +1,41 @@
+import { useSubmit } from "@remix-run/react";
+import { useCallback, useEffect, useRef } from "react";
+export function useDebounceSubmit() {
+    let timeoutRef = useRef();
+    useEffect(() => {
+        // no initialize step required since timeoutRef defaults undefined
+        let timeout = timeoutRef.current;
+        return () => {
+            if (timeout)
+                clearTimeout(timeout);
+        };
+    }, [timeoutRef]);
+    // Clone the original submit to avoid a recursive loop
+    const originalSubmit = useSubmit();
+    const submit = useCallback((
+    /**
+     * Specifies the `<form>` to be submitted to the server, a specific
+     * `<button>` or `<input type="submit">` to use to submit the form, or some
+     * arbitrary data to submit.
+     *
+     * Note: When using a `<button>` its `name` and `value` will also be
+     * included in the form data that is submitted.
+     */
+    target, 
+    /**
+     * Options that override the `<form>`'s own attributes. Required when
+     * submitting arbitrary data without a backing `<form>`. Additionally, you
+     * can specify a `debounceTimeout` to delay the submission of the data.
+     */
+    options) => {
+        if (timeoutRef.current)
+            clearTimeout(timeoutRef.current);
+        if (!options?.debounceTimeout || options.debounceTimeout <= 0) {
+            return originalSubmit(target, options);
+        }
+        timeoutRef.current = setTimeout(() => {
+            originalSubmit(target, options);
+        }, options.debounceTimeout);
+    }, [originalSubmit]);
+    return submit;
+}

package/node_modules/remix-utils/build/react/use-delegated-anchors.d.ts

@@ -0,0 +1,6 @@
+import * as React from "react";
+export declare function isLinkEvent(event: MouseEvent): HTMLAnchorElement | undefined;
+export declare function useDelegatedAnchors(nodeRef: React.RefObject<HTMLElement>): void;
+export declare function PrefetchPageAnchors({ children, }: {
+    children: React.ReactNode;
+}): React.JSX.Element;

package/node_modules/remix-utils/build/react/use-delegated-anchors.js

@@ -0,0 +1,69 @@
+import { PrefetchPageLinks, useNavigate } from "@remix-run/react";
+import * as React from "react";
+const context = React.createContext(false);
+export function isLinkEvent(event) {
+    if (!(event.target instanceof HTMLElement))
+        return;
+    let a = event.target.closest("a");
+    if (a && a.hasAttribute("href") && a.host === window.location.host)
+        return a;
+    return;
+}
+export function useDelegatedAnchors(nodeRef) {
+    let navigate = useNavigate();
+    let hasParentPrefetch = React.useContext(context);
+    React.useEffect(() => {
+        // if you call useDelegatedAnchors as a children of a PrefetchPageAnchors
+        // then do nothing
+        if (hasParentPrefetch)
+            return;
+        let node = nodeRef.current;
+        node?.addEventListener("click", handleClick);
+        return () => node?.removeEventListener("click", handleClick);
+        function handleClick(event) {
+            if (!node)
+                return;
+            let anchor = isLinkEvent(event);
+            if (!anchor)
+                return;
+            if (event.button !== 0)
+                return;
+            if (anchor.target && anchor.target !== "_self")
+                return;
+            if (event.metaKey || event.altKey || event.ctrlKey || event.shiftKey) {
+                return;
+            }
+            if (anchor.hasAttribute("download"))
+                return;
+            let { pathname, search, hash } = anchor;
+            navigate({ pathname, search, hash });
+            event.preventDefault();
+        }
+    }, [hasParentPrefetch, navigate, nodeRef]);
+}
+export function PrefetchPageAnchors({ children, }) {
+    let nodeRef = React.useRef(null);
+    let [page, setPage] = React.useState(null);
+    let hasParentPrefetch = React.useContext(context);
+    // prefetch is useless without delegated anchors, so we enable it
+    useDelegatedAnchors(nodeRef);
+    React.useEffect(() => {
+        if (hasParentPrefetch)
+            return;
+        let node = nodeRef.current;
+        node?.addEventListener("mouseenter", handleMouseEnter, true);
+        return () => node?.removeEventListener("mouseenter", handleMouseEnter);
+        function handleMouseEnter(event) {
+            if (!nodeRef.current)
+                return;
+            let anchor = isLinkEvent(event);
+            if (!anchor)
+                return;
+            let { pathname, search } = anchor;
+            setPage(pathname + search);
+        }
+    }, [hasParentPrefetch]);
+    return (React.createElement("div", { ref: nodeRef, style: { display: "contents" } },
+        React.createElement(context.Provider, { value: true }, children),
+        page && !hasParentPrefetch && React.createElement(PrefetchPageLinks, { page: page })));
+}

package/node_modules/remix-utils/build/react/use-event-source.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="react" />
+export interface EventSourceOptions {
+    init?: EventSourceInit;
+    event?: string;
+}
+export type EventSourceMap = Map<string, {
+    count: number;
+    source: EventSource;
+}>;
+export declare const EventSourceProvider: import("react").Provider<EventSourceMap>;
+/**
+ * Subscribe to an event source and return the latest event.
+ * @param url The URL of the event source to connect to
+ * @param options The options to pass to the EventSource constructor
+ * @returns The last event received from the server
+ */
+export declare function useEventSource(url: string | URL, { event, init }?: EventSourceOptions): string | null;

package/node_modules/remix-utils/build/react/use-event-source.js

@@ -0,0 +1,37 @@
+import { useEffect, useState, createContext, useContext } from "react";
+const context = createContext(new Map());
+export const EventSourceProvider = context.Provider;
+/**
+ * Subscribe to an event source and return the latest event.
+ * @param url The URL of the event source to connect to
+ * @param options The options to pass to the EventSource constructor
+ * @returns The last event received from the server
+ */
+export function useEventSource(url, { event = "message", init } = {}) {
+    let map = useContext(context);
+    let [data, setData] = useState(null);
+    useEffect(() => {
+        let key = [url.toString(), init?.withCredentials].join("::");
+        let value = map.get(key) ?? {
+            count: 0,
+            source: new EventSource(url, init),
+        };
+        ++value.count;
+        map.set(key, value);
+        value.source.addEventListener(event, handler);
+        // rest data if dependencies change
+        setData(null);
+        function handler(event) {
+            setData(event.data || "UNKNOWN_EVENT_DATA");
+        }
+        return () => {
+            value.source.removeEventListener(event, handler);
+            --value.count;
+            if (value.count <= 0) {
+                value.source.close();
+                map.delete(key);
+            }
+        };
+    }, [url, event, init, map]);
+    return data;
+}

package/node_modules/remix-utils/build/react/use-global-navigation-state.d.ts

@@ -0,0 +1,33 @@
+/**
+ * This is a helper hook that returns the state of every fetcher active on
+ * the app and combine it with the state of the global transition and
+ * revalidator.
+ * @example
+ * let states = useGlobalNavigationState();
+ * if (state.includes("loading")) {
+ *   // The app is loading or revalidating.
+ * }
+ * if (state.includes("submitting")) {
+ *   // The app is submitting.
+ * }
+ * // The app is idle
+ */
+export declare function useGlobalNavigationState(): ("idle" | "loading" | "submitting")[];
+/**
+ * Let you know if the app is pending some request, either global transition
+ * or some fetcher transition.
+ * @returns "idle" | "pending"
+ */
+export declare function useGlobalPendingState(): "idle" | "pending";
+/**
+ * Let you know if the app is submitting some request, either global transition
+ * or some fetcher transition.
+ * @returns "idle" | "submitting"
+ */
+export declare function useGlobalSubmittingState(): "idle" | "submitting";
+/**
+ * Let you know if the app is loading some request, either global transition
+ * or some fetcher transition.
+ * @returns "idle" | "loading"
+ */
+export declare function useGlobalLoadingState(): "idle" | "loading";

package/node_modules/remix-utils/build/react/use-global-navigation-state.js

@@ -0,0 +1,67 @@
+import { useNavigation, useFetchers, useRevalidator } from "@remix-run/react";
+import { useMemo } from "react";
+/**
+ * This is a helper hook that returns the state of every fetcher active on
+ * the app and combine it with the state of the global transition and
+ * revalidator.
+ * @example
+ * let states = useGlobalNavigationState();
+ * if (state.includes("loading")) {
+ *   // The app is loading or revalidating.
+ * }
+ * if (state.includes("submitting")) {
+ *   // The app is submitting.
+ * }
+ * // The app is idle
+ */
+export function useGlobalNavigationState() {
+    let { state: navigationState } = useNavigation();
+    let { state: revalidatorState } = useRevalidator();
+    let fetchers = useFetchers();
+    /**
+     * This gets the state of every fetcher active on the app and combine it with
+     * the state of the global transition (Link and Form) and revalidator.
+     */
+    return useMemo(function getGlobalNavigationState() {
+        return [
+            navigationState,
+            // The type cast here is used to remove RevalidatorState from the union
+            revalidatorState,
+            ...fetchers.map((fetcher) => fetcher.state),
+        ];
+    }, [navigationState, revalidatorState, fetchers]);
+}
+/**
+ * Let you know if the app is pending some request, either global transition
+ * or some fetcher transition.
+ * @returns "idle" | "pending"
+ */
+export function useGlobalPendingState() {
+    let isSubmitting = useGlobalSubmittingState() === "submitting";
+    let isLoading = useGlobalLoadingState() === "loading";
+    if (isLoading || isSubmitting)
+        return "pending";
+    return "idle";
+}
+/**
+ * Let you know if the app is submitting some request, either global transition
+ * or some fetcher transition.
+ * @returns "idle" | "submitting"
+ */
+export function useGlobalSubmittingState() {
+    let states = useGlobalNavigationState();
+    if (states.includes("submitting"))
+        return "submitting";
+    return "idle";
+}
+/**
+ * Let you know if the app is loading some request, either global transition
+ * or some fetcher transition.
+ * @returns "idle" | "loading"
+ */
+export function useGlobalLoadingState() {
+    let states = useGlobalNavigationState();
+    if (states.includes("loading"))
+        return "loading";
+    return "idle";
+}

package/node_modules/remix-utils/build/react/use-hydrated.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Return a boolean indicating if the JS has been hydrated already.
+ * When doing Server-Side Rendering, the result will always be false.
+ * When doing Client-Side Rendering, the result will always be false on the
+ * first render and true from then on. Even if a new component renders it will
+ * always start with true.
+ *
+ * Example: Disable a button that needs JS to work.
+ * ```tsx
+ * let hydrated = useHydrated();
+ * return (
+ *   <button type="button" disabled={!hydrated} onClick={doSomethingCustom}>
+ *     Click me
+ *   </button>
+ * );
+ * ```
+ */
+export declare function useHydrated(): boolean;