@shopify/hydrogen 1.0.0-alpha.21 → 1.0.1

package/dist/esnext/foundation/FileSessionStorage/FileSessionStorage.js

@@ -0,0 +1,149 @@
+import { Cookie } from '../Cookie/Cookie';
+import { v4 as uid } from 'uuid';
+import path from 'path';
+import { promises as fsp } from 'fs';
+import { parseJSON } from '../../utilities/parse';
+async function wait() {
+    return new Promise((resolve) => setTimeout(resolve));
+}
+let writingLock = false;
+/**
+ * Concurrent requests with the same session can write interfere
+ * writing at the same file, which crashes the process. This locks
+ * so that only one file can be written at a time.
+ *
+ * A better solution would be to have a lock only for the same session.
+ */
+async function startFileLock(promise) {
+    if (!writingLock) {
+        writingLock = true;
+        await promise();
+        writingLock = false;
+    }
+    else {
+        await wait();
+        await startFileLock(promise);
+    }
+}
+/** The `FileSessionStorage` component persists session data to the file system.
+ */
+export const FileSessionStorage = function (
+/** The name of the cookie stored in the browser. */
+name, 
+/** A directory to store the session files in. Each session is stored in a separate file on the file system. */
+dir, 
+/** An optional object to configure [how the cookie is persisted in the browser](https://shopify.dev/api/hydrogen/components/framework/cookie#cookie-options). */
+cookieOptions) {
+    return function (log) {
+        const cookie = new Cookie(name, cookieOptions);
+        let data;
+        return {
+            async get(request) {
+                if (data)
+                    return data;
+                const sid = cookie.getSessionId(request) || uid();
+                const file = getSessionFile(dir, sid);
+                const fileContents = await getFile(file, cookie.expires, log);
+                data = fileContents.data;
+                return data;
+            },
+            async set(request, value) {
+                const sid = cookie.getSessionId(request) || uid();
+                const file = getSessionFile(dir, sid);
+                await writeFile(file, value, cookie.expires);
+                data = value;
+                cookie.setSessionid(sid);
+                return cookie.serialize();
+            },
+            async destroy(request) {
+                const sid = cookie.getSessionId(request);
+                if (sid) {
+                    const file = getSessionFile(dir, sid);
+                    await deleteFile(file);
+                }
+                data = undefined;
+                // @todo - set expires for Date in past
+                return cookie.destroy();
+            },
+        };
+    };
+};
+async function getFile(file, expires, log) {
+    let content = null;
+    const defaultFileContent = {
+        data: {},
+        expires,
+    };
+    await startFileLock(async () => {
+        try {
+            const textContent = await fsp.readFile(file, { encoding: 'utf-8' });
+            try {
+                content = parseJSON(textContent);
+            }
+            catch (error) {
+                log.warn(`Cannot parse existing session file: ${file}`);
+                content = defaultFileContent;
+            }
+            if (content.expires < new Date().getTime() ||
+                content === defaultFileContent) {
+                await fsp.unlink(file);
+                await fsp.writeFile(file, JSON.stringify(defaultFileContent), {
+                    encoding: 'utf-8',
+                    flag: 'wx',
+                });
+                content = defaultFileContent;
+            }
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+            await fsp.mkdir(path.dirname(file), { recursive: true });
+            await fsp.writeFile(file, JSON.stringify(defaultFileContent), {
+                encoding: 'utf-8',
+                flag: 'wx',
+            });
+        }
+    });
+    return content ? content : defaultFileContent;
+}
+async function writeFile(file, data, expires) {
+    const content = {
+        data,
+        expires,
+    };
+    await startFileLock(async () => {
+        try {
+            await fsp.mkdir(path.dirname(file), { recursive: true });
+        }
+        catch (error) {
+            // directory already exists
+            if (error.code !== 'EEXIST')
+                throw error;
+        }
+        try {
+            await fsp.unlink(file);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        await fsp.writeFile(file, JSON.stringify(content), {
+            encoding: 'utf-8',
+            flag: 'wx',
+        });
+    });
+}
+async function deleteFile(file) {
+    try {
+        await startFileLock(async () => {
+            await fsp.unlink(file);
+        });
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+}
+function getSessionFile(dir, sid) {
+    return path.join(dir, sid.slice(0, 3), sid.slice(3));
+}

package/dist/esnext/foundation/Head/Head.client.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { HelmetProps as HeadProps } from 'react-helmet-async';
+export declare function Head({ children, ...props }: HeadProps & {
+    children: React.ReactNode;
+}): JSX.Element;

package/dist/esnext/foundation/Head/Head.client.js

@@ -0,0 +1,10 @@
+import React from 'react';
+import { Helmet, HelmetData as HeadData, } from 'react-helmet-async';
+import { useEnvContext } from '../ssr-interop';
+const clientHeadData = new HeadData({});
+export function Head({ children, ...props }) {
+    const headData = useEnvContext((req) => req.ctx.head, clientHeadData);
+    return (
+    // @ts-ignore
+    React.createElement(Helmet, { ...props, helmetData: headData }, children));
+}

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

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

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

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

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

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

package/dist/esnext/foundation/Html/Html.js

@@ -0,0 +1,96 @@
+/// <reference types="vite/client" />
+import React from 'react';
+const HTML_ATTR_SEP_RE = /(?<!=)"\s+/gim;
+const getHtmlAttrs = (template) => template.match(/<html\s+([^>]+?)\s*>/s)?.[1] || '';
+const getBodyAttrs = (template) => template.match(/<body\s+([^>]+?)\s*>/s)?.[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?.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(' ');
+}
+const clientConfigOptions = ['strictMode'];
+export function Html({ children, template, htmlAttrs, bodyAttrs, hydrogenConfig, }) {
+    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');
+    }
+    const clientConfig = {};
+    for (const key of clientConfigOptions) {
+        if (hydrogenConfig[key] != null) {
+            clientConfig[key] = hydrogenConfig[key];
+        }
+    }
+    const clientConfigAttr = Object.keys(clientConfig).length > 0
+        ? JSON.stringify(clientConfig)
+        : undefined;
+    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", "data-client-config": clientConfigAttr }, 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/foundation/HydrogenRequest/HydrogenRequest.server.d.ts

@@ -0,0 +1,76 @@
+import type { ShopifyContextValue } from '../ShopifyProvider/types';
+import type { QueryCacheControlHeaders } from '../../utilities/log/log-cache-header';
+import type { QueryTiming } from '../../utilities/log/log-query-timeline';
+import type { ResolvedHydrogenConfig, PreloadOptions, QueryKey, RuntimeContext } from '../../types';
+import { HelmetData as HeadData } from 'react-helmet-async';
+import { SessionSyncApi } from '../session/session';
+import { LocalizationContextValue } from '../../components/LocalizationProvider/LocalizationContext.client';
+export declare type PreloadQueryEntry = {
+    key: QueryKey;
+    fetcher: (request: HydrogenRequest) => 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 HydrogenRequest extends Request {
+    /**
+     * A Map of cookies for easy access.
+     */
+    cookies: Map<string, string>;
+    id: string;
+    time: number;
+    /**
+     * Get the canonical URL for the current page, across SSR and RSC requests.
+     */
+    normalizedUrl: string;
+    ctx: {
+        cache: Map<string, any>;
+        head: HeadData;
+        hydrogenConfig?: ResolvedHydrogenConfig;
+        shopifyConfig?: ShopifyContextValue;
+        queryCacheControl: Array<QueryCacheControlHeaders>;
+        queryTimings: Array<QueryTiming>;
+        preloadQueries: PreloadQueriesByURL;
+        analyticsData: any;
+        router: RouterContextData;
+        buyerIpHeader?: string;
+        session?: SessionSyncApi;
+        runtime?: RuntimeContext;
+        scopes: Map<string, Record<string, any>>;
+        localization?: LocalizationContextValue;
+        [key: string]: any;
+    };
+    constructor(input: any);
+    constructor(input: RequestInfo, init?: RequestInit);
+    previouslyLoadedRequest(): boolean;
+    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;
+    /**
+     * Build a `cacheKey` in the form of a `Request` to be used in full-page
+     * caching.
+     * - lockKey generates a placeholder cache key
+     */
+    cacheKey(lockKey?: boolean): Request;
+    formData(): Promise<FormData>;
+}

package/dist/esnext/foundation/HydrogenRequest/HydrogenRequest.server.js

@@ -0,0 +1,210 @@
+import { getTime } from '../../utilities/timing';
+import { hashKey } from '../../utilities/hash';
+import { HelmetData as HeadData } from 'react-helmet-async';
+import { RSC_PATHNAME } from '../../constants';
+import { parseJSON } from '../../utilities/parse';
+let reqCounter = 0; // For debugging
+const generateId = typeof crypto !== 'undefined' &&
+    // @ts-ignore
+    !!crypto.randomUUID
+    ? // @ts-ignore
+        () => crypto.randomUUID()
+    : () => `req${++reqCounter}`;
+// Stores queries by url or '*'
+const preloadCache = new Map();
+const previouslyLoadedUrls = {};
+const PRELOAD_ALL = '*';
+/**
+ * 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 class HydrogenRequest extends Request {
+    /**
+     * A Map of cookies for easy access.
+     */
+    cookies;
+    id;
+    time;
+    /**
+     * Get the canonical URL for the current page, across SSR and RSC requests.
+     */
+    normalizedUrl;
+    // CFW Request has a reserved 'context' property, use 'ctx' instead.
+    ctx;
+    constructor(input, init) {
+        if (input instanceof Request) {
+            super(input, init);
+        }
+        else {
+            super(getUrlFromNodeRequest(input), getInitFromNodeRequest(input));
+        }
+        this.time = getTime();
+        this.id = generateId();
+        this.normalizedUrl = this.isRscRequest()
+            ? normalizeUrl(this.url)
+            : this.url;
+        this.ctx = {
+            cache: new Map(),
+            head: new HeadData({}),
+            router: {
+                routeRendered: false,
+                serverProps: {},
+                routeParams: {},
+            },
+            queryCacheControl: [],
+            queryTimings: [],
+            analyticsData: {
+                url: this.url,
+                normalizedRscUrl: this.normalizedUrl,
+            },
+            preloadQueries: new Map(),
+            scopes: new Map(),
+        };
+        this.cookies = this.parseCookies();
+    }
+    previouslyLoadedRequest() {
+        if (previouslyLoadedUrls[this.normalizedUrl] > 1)
+            return true;
+        previouslyLoadedUrls[this.normalizedUrl] = previouslyLoadedUrls[this.normalizedUrl]
+            ? 2
+            : 1;
+        return false;
+    }
+    parseCookies() {
+        const cookieString = this.headers.get('cookie') || '';
+        return new Map(cookieString
+            .split(';')
+            .map((chunk) => chunk.trim())
+            .filter((chunk) => chunk !== '')
+            .map((chunk) => chunk.split(/=(.+)/)));
+    }
+    isRscRequest() {
+        const url = new URL(this.url);
+        return url.pathname === RSC_PATHNAME;
+    }
+    savePreloadQuery(query) {
+        if (query.preload === PRELOAD_ALL) {
+            saveToPreloadAllPreload(query);
+        }
+        else {
+            this.ctx.preloadQueries.set(hashKey(query.key), query);
+        }
+    }
+    getPreloadQueries() {
+        if (preloadCache.has(this.normalizedUrl)) {
+            const combinedPreloadQueries = new Map();
+            const urlPreloadCache = preloadCache.get(this.normalizedUrl);
+            mergeMapEntries(combinedPreloadQueries, urlPreloadCache);
+            mergeMapEntries(combinedPreloadQueries, preloadCache.get(PRELOAD_ALL));
+            return combinedPreloadQueries;
+        }
+        else if (preloadCache.has(PRELOAD_ALL)) {
+            return preloadCache.get(PRELOAD_ALL);
+        }
+    }
+    savePreloadQueries() {
+        preloadCache.set(this.normalizedUrl, this.ctx.preloadQueries);
+    }
+    /**
+     * 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() {
+        return this.headers.get(this.ctx.buyerIpHeader ?? 'x-forwarded-for');
+    }
+    /**
+     * Build a `cacheKey` in the form of a `Request` to be used in full-page
+     * caching.
+     * - lockKey generates a placeholder cache key
+     */
+    cacheKey(lockKey = false) {
+        const url = new URL(this.url);
+        if (lockKey) {
+            url.searchParams.set('cache-lock', 'true');
+        }
+        return new Request(url.href, this);
+    }
+    async formData() {
+        // @ts-ignore
+        if (!__HYDROGEN_WORKER__ && super.formData)
+            return super.formData();
+        const contentType = this.headers.get('Content-Type') || '';
+        // If mimeType’s essence is "multipart/form-data", then:
+        if (/multipart\/form-data/.test(contentType)) {
+            throw new Error('multipart/form-data not supported');
+        }
+        else if (/application\/x-www-form-urlencoded/.test(contentType)) {
+            // Otherwise, if mimeType’s essence is "application/x-www-form-urlencoded", then:
+            // 1. Let entries be the result of parsing bytes.
+            let entries;
+            try {
+                entries = new URLSearchParams(await this.text());
+            }
+            catch (err) {
+                // istanbul ignore next: Unclear when new URLSearchParams can fail on a string.
+                // 2. If entries is failure, then throw a TypeError.
+                throw new TypeError(undefined, { cause: err });
+            }
+            // 3. Return a new FormData object whose entries are entries.
+            const formData = new FormData();
+            for (const [name, value] of entries) {
+                formData.append(name, value);
+            }
+            return formData;
+        }
+        else {
+            // Otherwise, throw a TypeError.
+            throw new TypeError();
+        }
+    }
+}
+function mergeMapEntries(map1, map2) {
+    map2 && map2.forEach((v, k) => map1.set(k, v));
+}
+function saveToPreloadAllPreload(query) {
+    let setCache = preloadCache.get(PRELOAD_ALL);
+    if (!setCache) {
+        setCache = new Map();
+    }
+    setCache?.set(hashKey(query.key), query);
+    preloadCache.set(PRELOAD_ALL, setCache);
+}
+/**
+ * @see https://github.com/frandiox/vitedge/blob/17f3cd943e86d7c0c71a862985ddd6caa2899425/src/node/utils.js#L19-L24
+ *
+ * Note: Request can sometimes be an instance of Express request, where `originalUrl` is the true source of what the
+ * URL pathname is. We want to use that if it's present, so we union type this to `any`.
+ */
+function getUrlFromNodeRequest(request) {
+    const url = request.originalUrl ?? request.url;
+    if (url && !url.startsWith('/'))
+        return url;
+    // TODO: Find out how to determine https from `request` object without forwarded proto
+    const secure = request.headers['x-forwarded-proto'] === 'https';
+    return new URL(`${secure ? 'https' : 'http'}://${request.headers.host + url}`).toString();
+}
+function getInitFromNodeRequest(request) {
+    const init = {
+        headers: new Headers(request.headers),
+        method: request.method,
+        body: request.method !== 'GET' && request.method !== 'HEAD'
+            ? request.body
+            : undefined,
+    };
+    const remoteAddress = request.socket.remoteAddress;
+    if (!init.headers.has('x-forwarded-for') && remoteAddress) {
+        init.headers.set('x-forwarded-for', remoteAddress);
+    }
+    return init;
+}
+function normalizeUrl(rawUrl) {
+    const url = new URL(rawUrl);
+    const state = parseJSON(url.searchParams.get('state') ?? '');
+    const normalizedUrl = new URL(state?.pathname ?? '', url.origin);
+    normalizedUrl.search = state?.search;
+    return normalizedUrl.toString();
+}

package/dist/esnext/foundation/HydrogenResponse/HydrogenResponse.server.d.ts

@@ -0,0 +1,21 @@
+import type { CachingStrategy } from '../../types';
+import React from 'react';
+export declare class HydrogenResponse extends Response {
+    private wait;
+    private cacheOptions;
+    private proxy;
+    status: number;
+    statusText: string;
+    constructor(...args: ConstructorParameters<typeof Response>);
+    /**
+     * Buffer the current response until all queries have resolved,
+     * and prevent it from streaming back early.
+     */
+    doNotStream(): void;
+    canStream(): boolean;
+    cache(options?: CachingStrategy): import("../../types").AllCacheOptions;
+    get cacheControlHeader(): string;
+    redirect(location: string, status?: number): React.FunctionComponentElement<{
+        to: string;
+    }>;
+}

package/dist/esnext/foundation/HydrogenResponse/HydrogenResponse.server.js

@@ -0,0 +1,48 @@
+import { CacheShort, generateCacheControlHeader } from '../Cache/strategies';
+import Redirect from '../Redirect/Redirect.client';
+import React from 'react';
+export class HydrogenResponse extends Response {
+    wait = false;
+    cacheOptions = CacheShort();
+    proxy = Object.defineProperties(Object.create(null), {
+        // Default values:
+        status: { value: 200, writable: true },
+        statusText: { value: '', writable: true },
+    });
+    // @ts-ignore
+    status;
+    // @ts-ignore
+    statusText;
+    constructor(...args) {
+        super(...args);
+        return new Proxy(this, {
+            get: (target, key) => target.proxy[key] ?? Reflect.get(target, key),
+            set: (target, key, value) => Reflect.set(key in target.proxy ? target.proxy : target, key, value),
+        });
+    }
+    /**
+     * Buffer the current response until all queries have resolved,
+     * and prevent it from streaming back early.
+     */
+    doNotStream() {
+        this.wait = true;
+    }
+    canStream() {
+        return !this.wait;
+    }
+    cache(options) {
+        if (options) {
+            this.cacheOptions = options;
+        }
+        return this.cacheOptions;
+    }
+    get cacheControlHeader() {
+        return generateCacheControlHeader(this.cacheOptions);
+    }
+    redirect(location, status = 307) {
+        this.status = status;
+        this.headers.set('location', location);
+        // in the case of an RSC request, instead render a client component that will redirect
+        return React.createElement(Redirect, { to: location });
+    }
+}

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

@@ -0,0 +1,5 @@
+import type { SessionStorageAdapter } from '../session/session';
+import type { CookieOptions } from '../Cookie/Cookie';
+/** The `MemorySessionStorage` component stores session data within Hydrogen runtime memory.
+ */
+export declare const MemorySessionStorage: (name: string, options: CookieOptions) => () => SessionStorageAdapter;