@shopify/hydrogen 0.22.0 → 0.24.0

package/dist/esnext/foundation/Analytics/hook.js

@@ -1,7 +1,9 @@
 import { useServerRequest } from '../ServerRequestProvider';
+import { mergeDeep } from './utils';
 export function useServerAnalytics(data) {
     const request = useServerRequest();
-    if (data)
-        request.ctx.analyticsData = Object.assign({}, request.ctx.analyticsData, data);
+    if (data) {
+        request.ctx.analyticsData = mergeDeep(request.ctx.analyticsData, data);
+    }
     return request.ctx.analyticsData;
 }

package/dist/esnext/foundation/Analytics/utils.d.ts

@@ -1 +1,3 @@
 export declare function getNamedspacedEventname(eventname: string): string;
+export declare function isObject(item: any): any;
+export declare function mergeDeep(target: any, ...sources: any[]): any;

package/dist/esnext/foundation/Analytics/utils.js

@@ -6,3 +6,24 @@ export function getNamedspacedEventname(eventname) {
         ? `c-${eventname}`
         : eventname;
 }
+export function isObject(item) {
+    return item && typeof item === 'object' && !Array.isArray(item);
+}
+export function mergeDeep(target, ...sources) {
+    if (!sources.length)
+        return target;
+    const source = sources.shift();
+    if (isObject(target) && isObject(source)) {
+        for (const key in source) {
+            if (isObject(source[key])) {
+                if (!target[key])
+                    Object.assign(target, { [key]: {} });
+                mergeDeep(target[key], source[key]);
+            }
+            else {
+                Object.assign(target, { [key]: source[key] });
+            }
+        }
+    }
+    return mergeDeep(target, ...sources);
+}

package/dist/{node/framework → esnext/foundation/Cache}/cache-sub-request.d.ts

@@ -1,4 +1,4 @@
-import type { QueryKey, CachingStrategy } from '../types';
+import type { QueryKey, CachingStrategy } from '../../types';
 export declare function generateSubRequestCacheControlHeader(userCacheOptions?: CachingStrategy): string;
 /**
  * Get an item from the cache. If a match is found, returns a tuple

package/dist/esnext/{framework → foundation/Cache}/cache-sub-request.js

@@ -1,7 +1,7 @@
-import { getCache } from './runtime';
-import { hashKey } from '../utilities/hash';
+import { getCache } from '../runtime';
+import { hashKey } from '../../utilities/hash';
 import * as CacheApi from './cache';
-import { CacheSeconds } from './CachingStrategy';
+import { CacheSeconds } from './strategies';
 /**
  * Wrapper Cache functions for sub queries
  */

package/dist/esnext/{framework → foundation/Cache}/cache.d.ts

@@ -1,4 +1,4 @@
-import type { CachingStrategy } from '../types';
+import type { CachingStrategy } from '../../types';
 export declare function generateDefaultCacheControlHeader(userCacheOptions?: CachingStrategy): string;
 /**
  * Get an item from the cache. If a match is found, returns a tuple

package/dist/esnext/{framework → foundation/Cache}/cache.js

@@ -1,6 +1,6 @@
-import { getCache } from './runtime';
-import { CacheSeconds, generateCacheControlHeader, } from '../framework/CachingStrategy';
-import { logCacheApiStatus } from '../utilities/log';
+import { getCache } from '../runtime';
+import { CacheSeconds, generateCacheControlHeader } from './strategies';
+import { logCacheApiStatus } from '../../utilities/log';
 function getCacheControlSetting(userCacheOptions, options) {
     if (userCacheOptions && options) {
         return {

package/dist/{node/framework/CachingStrategy → esnext/foundation/Cache/strategies}/index.d.ts

@@ -1,4 +1,5 @@
-import type { CachingStrategy, AllCacheOptions, NoStoreStrategy } from '../../types';
+import type { CachingStrategy, AllCacheOptions, NoStoreStrategy } from '../../../types';
+export declare const NO_STORE = "no-store";
 export declare function generateCacheControlHeader(cacheOptions: CachingStrategy): string;
 export declare function NoStore(): NoStoreStrategy;
 export declare function CacheSeconds(overrideOptions?: CachingStrategy): AllCacheOptions;

package/dist/esnext/{framework/CachingStrategy → foundation/Cache/strategies}/index.js

@@ -1,6 +1,6 @@
 const PUBLIC = 'public';
 const PRIVATE = 'private';
-const NO_STORE = 'no-store';
+export const NO_STORE = 'no-store';
 const optionMapping = {
     maxAge: 'max-age',
     staleWhileRevalidate: 'stale-while-revalidate',

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

@@ -1,9 +1,9 @@
 export declare type CookieOptions = {
-    /** Whether to secure the cookie so that the browser only sends it over HTTPS. Some
-     * browsers [don't work with secure cookies on localhost](https://owasp.org/www-community/controls/SecureCookieAttribute).
+    /** Whether to secure the cookie so that [client-side JavaScript can't read the cookie](https://owasp.org/www-community/HttpOnly).
      */
     httpOnly?: boolean;
-    /** Whether to secure the cookie so that [client JavaScript is unable to read it](https://owasp.org/www-community/HttpOnly).
+    /** Whether to secure the cookie so that the browser only sends the cookie over HTTPS. Some
+     * browsers [don't work with secure cookies on localhost](https://owasp.org/www-community/controls/SecureCookieAttribute).
      */
     secure?: boolean;
     /** Declares that the cookie should be restricted to a first-party

package/dist/{node/framework/Hydration → esnext/foundation/Html}/Html.d.ts

@@ -1,11 +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 }: HtmlOptions): JSX.Element;
+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/{framework/Hydration → foundation/Html}/Html.js

@@ -21,7 +21,11 @@ function propsToAttrs(props) {
         .map(([key, value]) => `${key === REACT_ATTR_MAP.class ? 'class' : key}="${value}"`)
         .join(' ');
 }
-export function Html({ children, template, htmlAttrs, bodyAttrs }) {
+const clientConfigOptions = [
+    'strictMode',
+    'showDevTools',
+];
+export function Html({ children, template, htmlAttrs, bodyAttrs, hydrogenConfig, }) {
     let head = template.match(/<head>(.+?)<\/head>/s)[1] || '';
     // @ts-ignore
     if (import.meta.env.DEV) {
@@ -31,10 +35,19 @@ export function Html({ children, template, htmlAttrs, bodyAttrs }) {
             '<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" }, children))));
+            React.createElement("div", { id: "root", "data-client-config": clientConfigAttr }, children))));
 }
 export function applyHtmlHead(html, head, template) {
     const { bodyAttrs, htmlAttrs, ...headTags } = extractHeadElements(head, template);

package/dist/{node/framework/Hydration/ServerComponentRequest.server.d.ts → esnext/foundation/HydrogenRequest/HydrogenRequest.server.d.ts}

@@ -1,9 +1,12 @@
-import type { ShopifyContextValue } from '../../foundation/ShopifyProvider/types';
+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 } from '../../types';
 import { HelmetData as HeadData } from 'react-helmet-async';
-import { SessionSyncApi } from '../../foundation/session/session';
+import { SessionSyncApi } from '../session/session';
+export interface RuntimeContext {
+    waitUntil: (fn: Promise<any>) => void;
+}
 export declare type PreloadQueryEntry = {
     key: QueryKey;
     fetcher: () => Promise<unknown>;
@@ -23,7 +26,7 @@ export declare type RouterContextData = {
  * - 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 {
+export declare class HydrogenRequest extends Request {
     cookies: Map<string, string>;
     id: string;
     time: number;
@@ -40,6 +43,8 @@ export declare class ServerComponentRequest extends Request {
         router: RouterContextData;
         buyerIpHeader?: string;
         session?: SessionSyncApi;
+        runtime?: RuntimeContext;
+        scopes: Map<string, Record<string, any>>;
         [key: string]: any;
     };
     constructor(input: any);

package/dist/esnext/{framework/Hydration/ServerComponentRequest.server.js → foundation/HydrogenRequest/HydrogenRequest.server.js}

@@ -20,7 +20,7 @@ const PRELOAD_ALL = '*';
  * - Adds a `cookies` map for easy access
  * - Adds a static constructor to convert a Node.js `IncomingMessage` to a Request.
  */
-export class ServerComponentRequest extends Request {
+export class HydrogenRequest extends Request {
     constructor(input, init) {
         if (input instanceof Request) {
             super(input, init);
@@ -48,6 +48,7 @@ export class ServerComponentRequest extends Request {
                 normalizedRscUrl: this.normalizedUrl,
             },
             preloadQueries: new Map(),
+            scopes: new Map(),
         };
         this.cookies = this.parseCookies();
     }
@@ -67,7 +68,7 @@ export class ServerComponentRequest extends Request {
         if (typeof query.preload === 'string' && query.preload === PRELOAD_ALL) {
             saveToPreloadAllPreload(query);
         }
-        else if (query.preload) {
+        else {
             this.ctx.preloadQueries.set(hashKey(query.key), query);
         }
     }

package/dist/{node/framework/Hydration/ServerComponentResponse.server.d.ts → esnext/foundation/HydrogenResponse/HydrogenResponse.server.d.ts}

@@ -1,12 +1,14 @@
 import type { CachingStrategy } from '../../types';
 import React from 'react';
-export declare class ServerComponentResponse extends Response {
+export declare class HydrogenResponse extends Response {
     private wait;
     private cacheOptions;
-    customStatus?: {
-        code?: number;
-        text?: string;
-    };
+    private customStatus?;
+    private customStatusText?;
+    get status(): number;
+    set status(number: number);
+    get statusText(): string;
+    set statusText(text: string);
     /**
      * Buffer the current response until all queries have resolved,
      * and prevent it from streaming back early.
@@ -15,11 +17,6 @@ export declare class ServerComponentResponse extends Response {
     canStream(): boolean;
     cache(options: CachingStrategy): void;
     get cacheControlHeader(): string;
-    writeHead({ status, statusText, headers, }?: {
-        status?: number;
-        statusText?: string;
-        headers?: Record<string, any>;
-    }): void;
     redirect(location: string, status?: number): React.FunctionComponentElement<{
         to: string;
     }>;

package/dist/esnext/{framework/Hydration/ServerComponentResponse.server.js → foundation/HydrogenResponse/HydrogenResponse.server.js}

@@ -1,12 +1,26 @@
-import { CacheSeconds, generateCacheControlHeader } from '../CachingStrategy';
-import Redirect from '../../foundation/Redirect/Redirect.client';
+import { CacheSeconds, generateCacheControlHeader } from '../Cache/strategies';
+import Redirect from '../Redirect/Redirect.client';
 import React from 'react';
-export class ServerComponentResponse extends Response {
+export class HydrogenResponse extends Response {
     constructor() {
         super(...arguments);
         this.wait = false;
         this.cacheOptions = CacheSeconds();
     }
+    get status() {
+        var _a;
+        return (_a = this.customStatus) !== null && _a !== void 0 ? _a : super.status;
+    }
+    set status(number) {
+        this.customStatus = number;
+    }
+    get statusText() {
+        var _a;
+        return (_a = this.customStatusText) !== null && _a !== void 0 ? _a : super.statusText;
+    }
+    set statusText(text) {
+        this.customStatusText = text;
+    }
     /**
      * Buffer the current response until all queries have resolved,
      * and prevent it from streaming back early.
@@ -23,19 +37,9 @@ export class ServerComponentResponse extends Response {
     get cacheControlHeader() {
         return generateCacheControlHeader(this.cacheOptions);
     }
-    writeHead({ status, statusText, headers, } = {}) {
-        if (status || statusText) {
-            this.customStatus = { code: status, text: statusText };
-        }
-        if (headers) {
-            for (const [key, value] of Object.entries(headers)) {
-                this.headers.set(key, value);
-            }
-        }
-    }
     redirect(location, status = 307) {
-        // writeHead is used for SSR, so that the server responds with a redirect
-        this.writeHead({ status, headers: { location } });
+        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/Router/BrowserRouter.client.js

@@ -11,30 +11,37 @@ export const BrowserRouter = ({ history: pHistory, children }) => {
     /* eslint-disable react-hooks/rules-of-hooks */
     const history = useMemo(() => pHistory || createBrowserHistory(), [pHistory]);
     const [location, setLocation] = useState(history.location);
-    const [locationChanged, setLocationChanged] = useState(false);
+    const [scrollNeedsRestoration, setScrollNeedsRestoration] = useState(false);
     const { pending, locationServerProps, setLocationServerProps } = useInternalServerProps();
     useScrollRestoration({
         location,
         pending,
         serverProps: locationServerProps,
-        locationChanged,
-        onFinishNavigating: () => setLocationChanged(false),
+        scrollNeedsRestoration,
+        onFinishNavigating: () => setScrollNeedsRestoration(false),
     });
     useLayoutEffect(() => {
-        const unlisten = history.listen(({ location: newLocation }) => {
+        const unlisten = history.listen(({ location: newLocation, action }) => {
+            var _a;
             positions[location.key] = window.scrollY;
             setLocationServerProps({
                 pathname: newLocation.pathname,
                 search: newLocation.search,
             });
             setLocation(newLocation);
-            setLocationChanged(true);
+            const state = ((_a = newLocation.state) !== null && _a !== void 0 ? _a : {});
+            /**
+             * "pop" navigations, like forward/backward buttons, always restore scroll position
+             * regardless of what the original forward navigation intent was.
+             */
+            const needsScrollRestoration = action === 'POP' || !!state.scroll;
+            setScrollNeedsRestoration(needsScrollRestoration);
         });
         return () => unlisten();
     }, [
         history,
         location,
-        setLocationChanged,
+        setScrollNeedsRestoration,
         setLocation,
         setLocationServerProps,
     ]);
@@ -65,7 +72,7 @@ function useBeforeUnload(callback) {
         };
     }, [callback]);
 }
-function useScrollRestoration({ location, pending, serverProps, locationChanged, onFinishNavigating, }) {
+function useScrollRestoration({ location, pending, serverProps, scrollNeedsRestoration, onFinishNavigating, }) {
     /**
      * Browsers have an API for scroll restoration. We wait for the page to load first,
      * in case the browser is able to restore scroll position automatically, and then
@@ -82,7 +89,7 @@ function useScrollRestoration({ location, pending, serverProps, locationChanged,
     }, []));
     useLayoutEffect(() => {
         // The app has just loaded
-        if (isFirstLoad || !locationChanged) {
+        if (isFirstLoad || !scrollNeedsRestoration) {
             isFirstLoad = false;
             return;
         }
@@ -124,7 +131,7 @@ function useScrollRestoration({ location, pending, serverProps, locationChanged,
         pending,
         serverProps.pathname,
         serverProps.search,
-        locationChanged,
+        scrollNeedsRestoration,
         onFinishNavigating,
     ]);
 }

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

@@ -1,6 +1,7 @@
 import React, { ReactNode } from 'react';
 declare global {
-    var __DEV__: boolean;
+    var __HYDROGEN_DEV__: boolean;
+    var __HYDROGEN_TEST__: boolean;
 }
 export interface LocationServerProps {
     pathname: string;

package/dist/esnext/foundation/ServerPropsProvider/ServerPropsProvider.js

@@ -35,7 +35,7 @@ export function ServerPropsProvider({ initialServerProps, setServerPropsForRsc,
         else {
             newValue = input;
         }
-        if (__DEV__) {
+        if (__HYDROGEN_DEV__) {
             const privateProp = PRIVATE_PROPS.find((prop) => prop in newValue);
             if (privateProp) {
                 console.warn(`Custom "${privateProp}" property in server state is ignored. Use a different name.`);

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

@@ -1,12 +1,11 @@
-import type { PreloadQueriesByURL, ServerComponentRequest } from '../../framework/Hydration/ServerComponentRequest.server';
+import type { PreloadQueriesByURL, HydrogenRequest } from '../HydrogenRequest/HydrogenRequest.server';
 import type { QueryKey } from '../../types';
 declare type ServerRequestProviderProps = {
-    isRSC: boolean;
-    request: ServerComponentRequest;
+    request: HydrogenRequest;
     children: JSX.Element;
 };
-export declare function ServerRequestProvider({ isRSC, request, children, }: ServerRequestProviderProps): JSX.Element;
-export declare function useServerRequest(): ServerComponentRequest;
+export declare function ServerRequestProvider({ request, children, }: ServerRequestProviderProps): JSX.Element;
+export declare function useServerRequest(): HydrogenRequest;
 declare type RequestCacheResult<T> = {
     data: T;
     error?: never;
@@ -19,5 +18,5 @@ declare type RequestCacheResult<T> = {
  * It will throw the promise if data is not ready.
  */
 export declare function useRequestCacheData<T>(key: QueryKey, fetcher: () => T | Promise<T>): RequestCacheResult<T>;
-export declare function preloadRequestCacheData(request: ServerComponentRequest, preloadQueries?: PreloadQueriesByURL): void;
+export declare function preloadRequestCacheData(request: HydrogenRequest, preloadQueries?: PreloadQueriesByURL): void;
 export {};

package/dist/esnext/foundation/ServerRequestProvider/ServerRequestProvider.js

@@ -9,24 +9,30 @@ function requestCacheRSC() {
     return new Map();
 }
 requestCacheRSC.key = Symbol.for('HYDROGEN_REQUEST');
+function getInternalReactDispatcher() {
+    // @ts-ignore
+    return React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED
+        .ReactCurrentDispatcher.current;
+}
+function isRsc() {
+    // This method is only available during RSC
+    return __HYDROGEN_TEST__ || !!getInternalReactDispatcher().getCacheForType;
+}
 // Note: use this only during RSC/Flight rendering. The React dispatcher
 // for SSR/Fizz rendering does not implement getCacheForType.
 function getCacheForType(resource) {
     var _a;
-    const dispatcher = 
-    // @ts-ignore
-    React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED
-        .ReactCurrentDispatcher.current;
+    const dispatcher = getInternalReactDispatcher();
     // @ts-ignore
-    if (__DEV__ && typeof jest !== 'undefined' && !dispatcher.getCacheForType) {
+    if (__HYDROGEN_TEST__ && !dispatcher.getCacheForType) {
         // Jest does not have access to the RSC runtime, mock it here:
         // @ts-ignore
         return ((_a = globalThis.__jestRscCache) !== null && _a !== void 0 ? _a : (globalThis.__jestRscCache = resource()));
     }
     return dispatcher.getCacheForType(resource);
 }
-export function ServerRequestProvider({ isRSC, request, children, }) {
-    if (isRSC) {
+export function ServerRequestProvider({ request, children, }) {
+    if (isRsc()) {
         // Save the request object in a React cache that is
         // scoped to this current rendering.
         const requestCache = getCacheForType(requestCacheRSC);
@@ -38,21 +44,12 @@ export function ServerRequestProvider({ isRSC, request, children, }) {
     return (React.createElement(RequestContextSSR.Provider, { value: request }, children));
 }
 export function useServerRequest() {
-    let request;
-    try {
-        // This cache only works during RSC rendering:
-        // @ts-ignore
-        const cache = getCacheForType(requestCacheRSC);
-        request = cache ? cache.get(requestCacheRSC.key) : null;
-    }
-    catch (_a) {
-        // If RSC cache failed it means this is not an RSC request.
-        // Try getting SSR context instead:
-        request = useContext(RequestContextSSR); // eslint-disable-line react-hooks/rules-of-hooks
-    }
+    var _a;
+    const request = isRsc()
+        ? (_a = getCacheForType(requestCacheRSC)) === null || _a === void 0 ? void 0 : _a.get(requestCacheRSC.key)
+        : useContext(RequestContextSSR); // eslint-disable-line react-hooks/rules-of-hooks
     if (!request) {
-        // @ts-ignore
-        if (__DEV__ && typeof jest !== 'undefined') {
+        if (__HYDROGEN_TEST__) {
             // Unit tests are not wrapped in ServerRequestProvider.
             // This mocks it, instead of providing it in every test.
             return { ctx: {} };

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

@@ -1,6 +1,6 @@
 import React, { ReactNode } from 'react';
 declare global {
-    var __DEV__: boolean;
+    var __HYDROGEN_DEV__: boolean;
 }
 export interface ServerState {
     pathname: string;

package/dist/esnext/foundation/ServerStateProvider/ServerStateProvider.js

@@ -33,7 +33,7 @@ export function ServerStateProvider({ serverState, setServerState, children, })
         }
         if (!newValue)
             return { ...prev };
-        if (__DEV__) {
+        if (__HYDROGEN_DEV__) {
             const privateProp = PRIVATE_PROPS.find((prop) => prop in newValue);
             if (privateProp) {
                 console.warn(`Custom "${privateProp}" property in server state is ignored. Use a different name.`);

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

@@ -12,6 +12,7 @@ function makeShopifyContext(shopifyConfig) {
         storeDomain: (_b = shopifyConfig === null || shopifyConfig === void 0 ? void 0 : shopifyConfig.storeDomain) === null || _b === void 0 ? void 0 : _b.replace(/^https?:\/\//, ''),
         storefrontToken: shopifyConfig.storefrontToken,
         storefrontApiVersion: shopifyConfig.storefrontApiVersion,
+        multipassSecret: shopifyConfig.multipassSecret,
     };
 }
 export const SHOPIFY_PROVIDER_CONTEXT_KEY = Symbol.for('SHOPIFY_PROVIDER_RSC');

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

@@ -1,3 +1,3 @@
-export * from './ServerPropsProvider';
+export { ServerPropsProvider, ServerPropsContext, type ServerProps, type ServerPropsContextValue, } from './ServerPropsProvider';
 export { useShop } from './useShop';
 export { useUrl } from './useUrl';

package/dist/esnext/foundation/index.js

@@ -1,3 +1,3 @@
-export * from './ServerPropsProvider';
+export { ServerPropsProvider, ServerPropsContext, } from './ServerPropsProvider';
 export { useShop } from './useShop';
 export { useUrl } from './useUrl';

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

@@ -0,0 +1,2 @@
+export declare function setCache(cache?: Cache): void;
+export declare function getCache(): Cache | undefined;

package/dist/esnext/foundation/runtime.js

@@ -0,0 +1,6 @@
+export function setCache(cache) {
+    globalThis.__cache = cache;
+}
+export function getCache() {
+    return globalThis.__cache;
+}

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

@@ -1,6 +1,6 @@
 import { Logger } from '../../utilities/log';
-import type { ServerComponentResponse } from '../../framework/Hydration/ServerComponentResponse.server';
-import type { ServerComponentRequest } from '../../framework/Hydration/ServerComponentRequest.server';
+import type { HydrogenResponse } from '../HydrogenResponse/HydrogenResponse.server';
+import type { HydrogenRequest } from '../HydrogenRequest/HydrogenRequest.server';
 export declare type SessionSyncApi = {
     get: () => Record<string, string>;
 };
@@ -14,7 +14,7 @@ export declare type SessionStorageAdapter = {
     set: (request: Request, value: Record<string, string>) => Promise<string>;
     destroy: (request: Request) => Promise<string>;
 };
-export declare function getSyncSessionApi(request: ServerComponentRequest, componentResponse: ServerComponentResponse, log: Logger, session?: SessionStorageAdapter): {
+export declare function getSyncSessionApi(request: HydrogenRequest, componentResponse: HydrogenResponse, log: Logger, session?: SessionStorageAdapter): {
     get(): any;
 };
 export declare const emptySessionImplementation: (log: Logger) => {

package/dist/esnext/foundation/ssr-interop.d.ts

@@ -4,9 +4,9 @@
  * In the server, this file is transformed by Vite to inject server logic.
  * NOTE: Do not remove SSR-prefixed comments in this file.
  */
-import type { ServerComponentRequest } from '../framework/Hydration/ServerComponentRequest.server';
+import type { HydrogenRequest } from './HydrogenRequest/HydrogenRequest.server';
 export declare const META_ENV_SSR = false;
-declare type ServerGetter<T> = (request: ServerComponentRequest) => T;
+declare type ServerGetter<T> = (request: HydrogenRequest) => T;
 /**
  * Isomorphic hook to access context data. It gives access to the current request
  * when running on the server, and returns the provided client fallback in the browser.

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

@@ -5,6 +5,8 @@ declare type NavigationOptions = {
     reloadDocument?: boolean;
     /** The custom client state with the navigation. */
     clientState?: any;
+    /** Whether to emulate natural browser behavior and restore scroll position on navigation. Defaults to true. */
+    scroll?: any;
 };
 /**
  * The useNavigate hook imperatively navigates between routes.

package/dist/esnext/foundation/useNavigate/useNavigate.js

@@ -5,10 +5,17 @@ import { useRouter } from '../Router/BrowserRouter.client';
 export function useNavigate() {
     const router = useRouter();
     return (path, options = { replace: false, reloadDocument: false }) => {
+        var _a;
+        const state = {
+            ...options === null || options === void 0 ? void 0 : options.clientState,
+            scroll: (_a = options === null || options === void 0 ? void 0 : options.scroll) !== null && _a !== void 0 ? _a : true,
+        };
         // @todo wait for RSC and then change focus for a11y?
-        if (options === null || options === void 0 ? void 0 : options.replace)
-            router.history.replace(path, (options === null || options === void 0 ? void 0 : options.clientState) || {});
-        else
-            router.history.push(path, (options === null || options === void 0 ? void 0 : options.clientState) || {});
+        if (options === null || options === void 0 ? void 0 : options.replace) {
+            router.history.replace(path, state);
+        }
+        else {
+            router.history.push(path, state);
+        }
     };
 }

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

@@ -34,3 +34,4 @@ queryOptions?: HydrogenUseQueryOptions): {
     data: T;
     error?: undefined;
 };
+export declare function shouldPreloadQuery(queryOptions?: HydrogenUseQueryOptions): boolean;