@shopify/hydrogen 0.0.0-experimental-20220526194818

package/dist/esnext/foundation/useQuery/hooks.js

@@ -0,0 +1,97 @@
+import { getLoggerWithContext, collectQueryCacheControlHeaders, collectQueryTimings, } from '../../utilities/log';
+import { deleteItemFromCache, generateSubRequestCacheControlHeader, getItemFromCache, isStale, setItemInCache, } from '../../framework/cache-sub-request';
+import { runDelayedFunction } from '../../framework/runtime';
+import { useRequestCacheData, useServerRequest } from '../ServerRequestProvider';
+import { CacheSeconds } from '../../framework/CachingStrategy';
+/**
+ * The `useQuery` hook executes an asynchronous operation like `fetch` in a way that
+ * supports [Suspense](https://reactjs.org/docs/concurrent-mode-suspense.html). You can use this
+ * hook to call any third-party APIs from a server component.
+ *
+ * \> Note:
+ * \> If you're making a simple fetch call on the server, then we recommend using the [`fetchSync`](https://shopify.dev/api/hydrogen/hooks/global/fetchsync) hook instead.
+ */
+export function useQuery(
+/** A string or array to uniquely identify the current query. */
+key, 
+/** An asynchronous query function like `fetch` which returns data. */
+queryFn, 
+/** The options to manage the cache behavior of the sub-request. */
+queryOptions) {
+    const request = useServerRequest();
+    const withCacheIdKey = [
+        '__QUERY_CACHE_ID__',
+        ...(typeof key === 'string' ? [key] : key),
+    ];
+    const fetcher = cachedQueryFnBuilder(withCacheIdKey, queryFn, queryOptions);
+    collectQueryTimings(request, withCacheIdKey, 'requested');
+    if (queryOptions === null || queryOptions === void 0 ? void 0 : queryOptions.preload) {
+        request.savePreloadQuery({
+            preload: queryOptions === null || queryOptions === void 0 ? void 0 : queryOptions.preload,
+            key: withCacheIdKey,
+            fetcher,
+        });
+    }
+    return useRequestCacheData(withCacheIdKey, fetcher);
+}
+function cachedQueryFnBuilder(key, queryFn, queryOptions) {
+    var _a;
+    const resolvedQueryOptions = {
+        ...(queryOptions !== null && queryOptions !== void 0 ? queryOptions : {}),
+    };
+    const shouldCacheResponse = (_a = queryOptions === null || queryOptions === void 0 ? void 0 : queryOptions.shouldCacheResponse) !== null && _a !== void 0 ? _a : (() => true);
+    /**
+     * Attempt to read the query from cache. If it doesn't exist or if it's stale, regenerate it.
+     */
+    async function useCachedQueryFn() {
+        // Call this hook before running any async stuff
+        // to prevent losing the current React cycle.
+        const request = useServerRequest();
+        const log = getLoggerWithContext(request);
+        const cacheResponse = await getItemFromCache(key);
+        async function generateNewOutput() {
+            return await queryFn();
+        }
+        if (cacheResponse) {
+            const [output, response] = cacheResponse;
+            collectQueryCacheControlHeaders(request, key, response.headers.get('cache-control'));
+            /**
+             * Important: Do this async
+             */
+            if (isStale(key, response)) {
+                const lockKey = ['lock', ...(typeof key === 'string' ? [key] : key)];
+                runDelayedFunction(async () => {
+                    const lockExists = await getItemFromCache(lockKey);
+                    if (lockExists)
+                        return;
+                    await setItemInCache(lockKey, true, CacheSeconds({
+                        maxAge: 10,
+                    }));
+                    try {
+                        const output = await generateNewOutput();
+                        if (shouldCacheResponse(output)) {
+                            await setItemInCache(key, output, resolvedQueryOptions === null || resolvedQueryOptions === void 0 ? void 0 : resolvedQueryOptions.cache);
+                        }
+                    }
+                    catch (e) {
+                        log.error(`Error generating async response: ${e.message}`);
+                    }
+                    finally {
+                        await deleteItemFromCache(lockKey);
+                    }
+                });
+            }
+            return output;
+        }
+        const newOutput = await generateNewOutput();
+        /**
+         * Important: Do this async
+         */
+        if (shouldCacheResponse(newOutput)) {
+            runDelayedFunction(() => setItemInCache(key, newOutput, resolvedQueryOptions === null || resolvedQueryOptions === void 0 ? void 0 : resolvedQueryOptions.cache));
+        }
+        collectQueryCacheControlHeaders(request, key, generateSubRequestCacheControlHeader(resolvedQueryOptions === null || resolvedQueryOptions === void 0 ? void 0 : resolvedQueryOptions.cache));
+        return newOutput;
+    }
+    return useCachedQueryFn;
+}

package/dist/esnext/foundation/useQuery/index.d.ts

@@ -0,0 +1 @@
+export { useQuery } from './hooks';

package/dist/esnext/foundation/useQuery/index.js

@@ -0,0 +1 @@
+export { useQuery } from './hooks';

package/dist/esnext/foundation/useRouteParams/RouteParamsProvider.client.d.ts

@@ -0,0 +1,9 @@
+import React, { FC } from 'react';
+declare type RouteParamsContextValue = {
+    routeParams: Record<string, string>;
+};
+export declare const RouteParamsContext: React.Context<RouteParamsContextValue>;
+export declare const RouteParamsProvider: FC<{
+    routeParams: Record<string, string>;
+}>;
+export {};

package/dist/esnext/foundation/useRouteParams/RouteParamsProvider.client.js

@@ -0,0 +1,7 @@
+import React, { createContext } from 'react';
+export const RouteParamsContext = createContext({
+    routeParams: {},
+});
+export const RouteParamsProvider = ({ children, routeParams, }) => {
+    return (React.createElement(RouteParamsContext.Provider, { value: { routeParams } }, children));
+};

package/dist/esnext/foundation/useRouteParams/useRouteParams.d.ts

@@ -0,0 +1,4 @@
+/**
+ *  The `useRouteParams` hook retrieves the parameters of an active route. The hook is available in both server and client components.
+ */
+export declare function useRouteParams(): Record<string, string>;

package/dist/esnext/foundation/useRouteParams/useRouteParams.js

@@ -0,0 +1,9 @@
+import { useEnvContext } from '../ssr-interop';
+import { RouteParamsContext } from './RouteParamsProvider.client';
+/**
+ *  The `useRouteParams` hook retrieves the parameters of an active route. The hook is available in both server and client components.
+ */
+export function useRouteParams() {
+    const router = useEnvContext((req) => req.ctx.router, RouteParamsContext);
+    return router.routeParams;
+}

package/dist/esnext/foundation/useServerProps/index.d.ts

@@ -0,0 +1 @@
+export { useServerProps } from './use-server-props';

package/dist/esnext/foundation/useServerProps/index.js

@@ -0,0 +1 @@
+export { useServerProps } from './use-server-props';

package/dist/esnext/foundation/useServerProps/use-server-props.d.ts

@@ -0,0 +1,21 @@
+import { ServerPropsContextValue, InternalServerPropsContextValue } from '../ServerPropsProvider/ServerPropsProvider';
+/**
+ * The `useServerProps` hook allows you to manage the [server props](https://shopify.dev/custom-storefronts/hydrogen/framework/server-props) passed to your server components when using Hydrogen as a React Server Component framework. The server props get cleared when you navigate from one route to another.
+ *
+ * ## Return value
+ *
+ * The `useServerProps` hook returns an object with the following keys:
+ *
+ * | Key              | Description                                                                            |
+ * | ---------------- | -------------------------------------------------------------------------------------- |
+ * | `serverProps`    | The current server props.                                                              |
+ * | `setServerProps` | A function used to modify server props.                                                |
+ * | `pending`        | Whether a [transition is pending](https://github.com/reactwg/react-18/discussions/41). |
+ *
+ */
+export declare function useServerProps(): ServerPropsContextValue;
+/**
+ * Internal-only hook to manage server state, including to set location server state
+ * @internal
+ */
+export declare function useInternalServerProps(): InternalServerPropsContextValue;

package/dist/esnext/foundation/useServerProps/use-server-props.js

@@ -0,0 +1,35 @@
+import { useContext } from 'react';
+import { ServerPropsContext, } from '../ServerPropsProvider/ServerPropsProvider';
+/**
+ * The `useServerProps` hook allows you to manage the [server props](https://shopify.dev/custom-storefronts/hydrogen/framework/server-props) passed to your server components when using Hydrogen as a React Server Component framework. The server props get cleared when you navigate from one route to another.
+ *
+ * ## Return value
+ *
+ * The `useServerProps` hook returns an object with the following keys:
+ *
+ * | Key              | Description                                                                            |
+ * | ---------------- | -------------------------------------------------------------------------------------- |
+ * | `serverProps`    | The current server props.                                                              |
+ * | `setServerProps` | A function used to modify server props.                                                |
+ * | `pending`        | Whether a [transition is pending](https://github.com/reactwg/react-18/discussions/41). |
+ *
+ */
+export function useServerProps() {
+    const internalServerPropsContext = useContext(ServerPropsContext);
+    if (!internalServerPropsContext) {
+        return {};
+    }
+    return {
+        serverProps: internalServerPropsContext.serverProps,
+        setServerProps: internalServerPropsContext.setServerProps,
+        pending: internalServerPropsContext.pending,
+    };
+}
+/**
+ * Internal-only hook to manage server state, including to set location server state
+ * @internal
+ */
+export function useInternalServerProps() {
+    var _a;
+    return ((_a = useContext(ServerPropsContext)) !== null && _a !== void 0 ? _a : {});
+}

package/dist/esnext/foundation/useSession/useSession.d.ts

@@ -0,0 +1,2 @@
+/** The `useSession` hook reads session data in server components. */
+export declare const useSession: () => Record<string, string>;

package/dist/esnext/foundation/useSession/useSession.js

@@ -0,0 +1,8 @@
+import { useServerRequest } from '../ServerRequestProvider';
+/** The `useSession` hook reads session data in server components. */
+export const useSession = function () {
+    var _a;
+    const request = useServerRequest();
+    const session = ((_a = request.ctx.session) === null || _a === void 0 ? void 0 : _a.get()) || {};
+    return session;
+};

package/dist/esnext/foundation/useShop/index.d.ts

@@ -0,0 +1 @@
+export { useShop } from './use-shop';

package/dist/esnext/foundation/useShop/index.js

@@ -0,0 +1 @@
+export { useShop } from './use-shop';

package/dist/esnext/foundation/useShop/use-shop.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The `useShop` hook provides access to values within
+ * [the `shopify` property in the `hydrogen.config.js` file](https://shopify.dev/custom-storefronts/hydrogen/framework/hydrogen-config).
+ * The `useShop` hook must be a descendent of a `ShopifyProvider` component.
+ */
+export declare function useShop(): import("../ShopifyProvider/types").ShopifyContextValue;

package/dist/esnext/foundation/useShop/use-shop.js

@@ -0,0 +1,14 @@
+import { ShopifyContext } from '../ShopifyProvider';
+import { useEnvContext } from '../ssr-interop';
+/**
+ * The `useShop` hook provides access to values within
+ * [the `shopify` property in the `hydrogen.config.js` file](https://shopify.dev/custom-storefronts/hydrogen/framework/hydrogen-config).
+ * The `useShop` hook must be a descendent of a `ShopifyProvider` component.
+ */
+export function useShop() {
+    const config = useEnvContext((req) => req.ctx.shopifyConfig, ShopifyContext);
+    if (!config) {
+        throw new Error('No Shopify Context found');
+    }
+    return config;
+}

package/dist/esnext/foundation/useUrl/index.d.ts

@@ -0,0 +1 @@
+export { useUrl } from './useUrl';

package/dist/esnext/foundation/useUrl/index.js

@@ -0,0 +1 @@
+export { useUrl } from './useUrl';

package/dist/esnext/foundation/useUrl/useUrl.d.ts

@@ -0,0 +1,4 @@
+/**
+ * The `useUrl` hook retrieves the current URL in a server or client component.
+ */
+export declare function useUrl(): URL;

package/dist/esnext/foundation/useUrl/useUrl.js

@@ -0,0 +1,28 @@
+import { useMemo } from 'react';
+import { RSC_PATHNAME } from '../../constants';
+import { parseJSON } from '../../utilities/parse';
+import { useLocation } from '../Router/BrowserRouter.client';
+import { useEnvContext, META_ENV_SSR } from '../ssr-interop';
+/**
+ * The `useUrl` hook retrieves the current URL in a server or client component.
+ */
+export function useUrl() {
+    var _a, _b;
+    if (META_ENV_SSR) {
+        const serverUrl = new URL(useEnvContext((req) => req.url) // eslint-disable-line react-hooks/rules-of-hooks
+        );
+        if (serverUrl.pathname === RSC_PATHNAME) {
+            const state = parseJSON(serverUrl.searchParams.get('state') || '{}');
+            const parsedUrl = `${serverUrl.origin}${(_a = state.pathname) !== null && _a !== void 0 ? _a : ''}${(_b = state.search) !== null && _b !== void 0 ? _b : ''}`;
+            return new URL(parsedUrl);
+        }
+        return new URL(serverUrl);
+    }
+    /**
+     * We return a `URL` object instead of passing through `location` because
+     * the URL object contains important info like hostname, etc.
+     */
+    const location = useLocation(); // eslint-disable-line react-hooks/rules-of-hooks
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    return useMemo(() => new URL(window.location.href), [location]); // eslint-disable-line react-hooks/exhaustive-deps
+}

package/dist/esnext/framework/CachingStrategy/index.d.ts

@@ -0,0 +1,10 @@
+import type { CachingStrategy, AllCacheOptions, NoStoreStrategy } from '../../types';
+export declare function generateCacheControlHeader(cacheOptions: CachingStrategy): string;
+export declare function NoStore(): NoStoreStrategy;
+export declare function CacheSeconds(overrideOptions?: CachingStrategy): AllCacheOptions;
+export declare function CacheMinutes(overrideOptions?: CachingStrategy): AllCacheOptions;
+export declare function CacheHours(overrideOptions?: CachingStrategy): AllCacheOptions;
+export declare function CacheDays(overrideOptions?: CachingStrategy): AllCacheOptions;
+export declare function CacheWeeks(overrideOptions?: CachingStrategy): AllCacheOptions;
+export declare function CacheMonths(overrideOptions?: CachingStrategy): AllCacheOptions;
+export declare function CacheCustom(overrideOptions: CachingStrategy): AllCacheOptions;

package/dist/esnext/framework/CachingStrategy/index.js

@@ -0,0 +1,96 @@
+const PUBLIC = 'public';
+const PRIVATE = 'private';
+const NO_STORE = 'no-store';
+const optionMapping = {
+    maxAge: 'max-age',
+    staleWhileRevalidate: 'stale-while-revalidate',
+    sMaxAge: 's-maxage',
+    staleIfError: 'stale-if-error',
+};
+export function generateCacheControlHeader(cacheOptions) {
+    const cacheControl = [];
+    Object.keys(cacheOptions).forEach((key) => {
+        if (key === 'mode') {
+            cacheControl.push(cacheOptions[key]);
+        }
+        else if (optionMapping[key]) {
+            cacheControl.push(`${optionMapping[key]}=${cacheOptions[key]}`);
+        }
+    });
+    return cacheControl.join(', ');
+}
+export function NoStore() {
+    return {
+        mode: NO_STORE,
+    };
+}
+function guardExpirableModeType(overrideOptions) {
+    if ((overrideOptions === null || overrideOptions === void 0 ? void 0 : overrideOptions.mode) &&
+        (overrideOptions === null || overrideOptions === void 0 ? void 0 : overrideOptions.mode) !== PUBLIC &&
+        (overrideOptions === null || overrideOptions === void 0 ? void 0 : overrideOptions.mode) !== PRIVATE) {
+        throw Error("'mode' must be either 'public' or 'private'");
+    }
+}
+// 10 seconds
+export function CacheSeconds(overrideOptions) {
+    guardExpirableModeType(overrideOptions);
+    return {
+        mode: PUBLIC,
+        maxAge: 1,
+        staleWhileRevalidate: 9,
+        ...overrideOptions,
+    };
+}
+// 30 minutes
+export function CacheMinutes(overrideOptions) {
+    guardExpirableModeType(overrideOptions);
+    return {
+        mode: PUBLIC,
+        maxAge: 900,
+        staleWhileRevalidate: 900,
+        ...overrideOptions,
+    };
+}
+// 1 hour
+export function CacheHours(overrideOptions) {
+    guardExpirableModeType(overrideOptions);
+    return {
+        mode: PUBLIC,
+        maxAge: 1800,
+        staleWhileRevalidate: 1800,
+        ...overrideOptions,
+    };
+}
+// 1 day
+export function CacheDays(overrideOptions) {
+    guardExpirableModeType(overrideOptions);
+    return {
+        mode: PUBLIC,
+        maxAge: 3600,
+        staleWhileRevalidate: 82800,
+        ...overrideOptions,
+    };
+}
+// 2 weeks
+export function CacheWeeks(overrideOptions) {
+    guardExpirableModeType(overrideOptions);
+    return {
+        mode: PUBLIC,
+        maxAge: 604800,
+        staleWhileRevalidate: 604800,
+        ...overrideOptions,
+    };
+}
+// 1 month
+export function CacheMonths(overrideOptions) {
+    guardExpirableModeType(overrideOptions);
+    return {
+        mode: PUBLIC,
+        maxAge: 1296000,
+        staleWhileRevalidate: 1296000,
+        ...overrideOptions,
+    };
+}
+export function CacheCustom(overrideOptions) {
+    return overrideOptions;
+}

package/dist/esnext/framework/Hydration/Html.d.ts

@@ -0,0 +1,11 @@
+import { ReactNode } from 'react';
+import type { HelmetData as HeadData } from 'react-helmet-async';
+declare type HtmlOptions = {
+    children: ReactNode;
+    template: string;
+    htmlAttrs?: Record<string, string>;
+    bodyAttrs?: Record<string, string>;
+};
+export declare function Html({ children, template, htmlAttrs, bodyAttrs }: HtmlOptions): JSX.Element;
+export declare function applyHtmlHead(html: string, head: HeadData, template: string): string;
+export {};

package/dist/esnext/framework/Hydration/Html.js

@@ -0,0 +1,86 @@
+/// <reference types="vite/client" />
+import React from 'react';
+const HTML_ATTR_SEP_RE = /(?<!=)"\s+/gim;
+const getHtmlAttrs = (template) => { var _a; return ((_a = template.match(/<html\s+([^>]+?)\s*>/s)) === null || _a === void 0 ? void 0 : _a[1]) || ''; };
+const getBodyAttrs = (template) => { var _a; return ((_a = template.match(/<body\s+([^>]+?)\s*>/s)) === null || _a === void 0 ? void 0 : _a[1]) || ''; };
+const REACT_ATTR_MAP = Object.create(null);
+REACT_ATTR_MAP.class = 'className';
+REACT_ATTR_MAP.style = 'data-style'; // Ignore string styles, it breaks React
+function attrsToProps(attrs) {
+    attrs = attrs === null || attrs === void 0 ? void 0 : attrs.trim();
+    // Assume all attributes are surrounded by double quotes.
+    return attrs
+        ? Object.fromEntries(attrs.split(HTML_ATTR_SEP_RE).map((attr) => {
+            const [key, value] = attr.replace(/"/g, '').split(/=(.+)/);
+            return [REACT_ATTR_MAP[key.toLowerCase()] || key, value];
+        }))
+        : {};
+}
+function propsToAttrs(props) {
+    return Object.entries(props)
+        .map(([key, value]) => `${key === REACT_ATTR_MAP.class ? 'class' : key}="${value}"`)
+        .join(' ');
+}
+export function Html({ children, template, htmlAttrs, bodyAttrs }) {
+    let head = template.match(/<head>(.+?)<\/head>/s)[1] || '';
+    // @ts-ignore
+    if (import.meta.env.DEV) {
+        // Fix React Refresh for async scripts.
+        // https://github.com/vitejs/vite/issues/6759
+        head =
+            '<script></script>' + // Fix for Firefox: https://bugzilla.mozilla.org/show_bug.cgi?id=1737882
+                head.replace(/>(\s*?import[\s\w]+?['"]\/@react-refresh)/, ' async="">$1');
+    }
+    return (React.createElement("html", { ...attrsToProps(getHtmlAttrs(template)), ...htmlAttrs },
+        React.createElement("head", { dangerouslySetInnerHTML: { __html: head } }),
+        React.createElement("body", { ...attrsToProps(getBodyAttrs(template)), ...bodyAttrs },
+            React.createElement("div", { id: "root" }, children))));
+}
+export function applyHtmlHead(html, head, template) {
+    const { bodyAttrs, htmlAttrs, ...headTags } = extractHeadElements(head, template);
+    return html
+        .replace(/<head>(.*?)<\/head>/s, generateHeadTag(headTags))
+        .replace(/<html[^>]*?>/s, htmlAttrs ? `<html ${htmlAttrs}>` : '$&')
+        .replace(/<body[^>]*?>/s, bodyAttrs ? `<body ${bodyAttrs}>` : '$&');
+}
+function extractHeadElements({ context: { helmet } }, template) {
+    // There might be existing attributes in the template that are
+    // duplicated in the helmet. Transform them to props and back
+    // to string attributes to remove duplicates.
+    const htmlUniqueProps = attrsToProps(`${getHtmlAttrs(template)} ${helmet.htmlAttributes}`);
+    const bodyUniqueProps = attrsToProps(`${getBodyAttrs(template)} ${helmet.bodyAttributes}`);
+    return {
+        htmlAttrs: propsToAttrs(htmlUniqueProps),
+        bodyAttrs: propsToAttrs(bodyUniqueProps),
+        base: helmet.base.toString(),
+        link: helmet.link.toString(),
+        meta: helmet.meta.toString(),
+        noscript: helmet.noscript.toString(),
+        script: helmet.script.toString(),
+        style: helmet.style.toString(),
+        title: helmet.title.toString(),
+    };
+}
+/**
+ * Generate the contents of the `head` tag, and update the existing `<title>` tag
+ * if one exists, and if a title is passed.
+ */
+function generateHeadTag({ title, ...rest }) {
+    const headProps = ['base', 'meta', 'style', 'noscript', 'script', 'link'];
+    const otherHeadProps = headProps
+        .map((prop) => rest[prop])
+        .filter(Boolean)
+        .join('\n');
+    return (_outerHtml, innerHtml) => {
+        let headHtml = otherHeadProps + innerHtml;
+        if (title) {
+            if (headHtml.includes('<title>')) {
+                headHtml = headHtml.replace(/(<title>(?:.|\n)*?<\/title>)/, title);
+            }
+            else {
+                headHtml += title;
+            }
+        }
+        return `<head>${headHtml}</head>`;
+    };
+}

package/dist/esnext/framework/Hydration/ServerComponentRequest.server.d.ts

@@ -0,0 +1,58 @@
+import type { ShopifyContextValue } from '../../foundation/ShopifyProvider/types';
+import type { QueryCacheControlHeaders } from '../../utilities/log/log-cache-header';
+import type { QueryTiming } from '../../utilities/log/log-query-timeline';
+import type { HydrogenConfig, PreloadOptions, QueryKey } from '../../types';
+import { HelmetData as HeadData } from 'react-helmet-async';
+import { SessionSyncApi } from '../../foundation/session/session';
+export declare type PreloadQueryEntry = {
+    key: QueryKey;
+    fetcher: () => Promise<unknown>;
+    preload?: PreloadOptions;
+};
+export declare type PreloadQueriesByURL = Map<string, PreloadQueryEntry>;
+export declare type AllPreloadQueries = Map<string, PreloadQueriesByURL>;
+export declare type RouterContextData = {
+    routeRendered: boolean;
+    serverProps: Record<string, any>;
+    routeParams: Record<string, string>;
+};
+/**
+ * This augments the `Request` object from the Fetch API:
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Request
+ *
+ * - Adds a `cookies` map for easy access
+ * - Adds a static constructor to convert a Node.js `IncomingMessage` to a Request.
+ */
+export declare class ServerComponentRequest extends Request {
+    cookies: Map<string, string>;
+    id: string;
+    time: number;
+    normalizedUrl: string;
+    ctx: {
+        cache: Map<string, any>;
+        head: HeadData;
+        hydrogenConfig?: HydrogenConfig;
+        shopifyConfig?: ShopifyContextValue;
+        queryCacheControl: Array<QueryCacheControlHeaders>;
+        queryTimings: Array<QueryTiming>;
+        preloadQueries: PreloadQueriesByURL;
+        analyticsData: any;
+        router: RouterContextData;
+        buyerIpHeader?: string;
+        session?: SessionSyncApi;
+        [key: string]: any;
+    };
+    constructor(input: any);
+    constructor(input: RequestInfo, init?: RequestInit);
+    private parseCookies;
+    isRscRequest(): boolean;
+    savePreloadQuery(query: PreloadQueryEntry): void;
+    getPreloadQueries(): PreloadQueriesByURL | undefined;
+    savePreloadQueries(): void;
+    /**
+     * Buyer IP varies by hosting provider and runtime. The developer should provide this
+     * as an argument to the `handleRequest` function for their runtime.
+     * Defaults to `x-forwarded-for` header value.
+     */
+    getBuyerIp(): string | null;
+}