@shopify/hydrogen 0.0.0-experimental-20220526194818

package/dist/node/foundation/Analytics/ClientAnalytics.d.ts

@@ -0,0 +1,25 @@
+import type { Subscriber, SubscriberFunction } from './types';
+declare function pushToPageAnalyticsData(data: any, namespace?: string): void;
+declare function getPageAnalyticsData(): any;
+declare function resetPageAnalyticsData(): void;
+declare function publish(eventname: string, guardDup?: boolean, payload?: any): void;
+declare function subscribe(eventname: string, callbackFunction: SubscriberFunction): Subscriber;
+declare function pushToServer(init?: RequestInit, searchParam?: string): Promise<Response>;
+export declare const ClientAnalytics: {
+    pushToPageAnalyticsData: typeof pushToPageAnalyticsData;
+    getPageAnalyticsData: typeof getPageAnalyticsData;
+    resetPageAnalyticsData: typeof resetPageAnalyticsData;
+    publish: typeof publish;
+    subscribe: typeof subscribe;
+    pushToServer: typeof pushToServer;
+    eventNames: {
+        PAGE_VIEW: string;
+        VIEWED_PRODUCT: string;
+        ADD_TO_CART: string;
+        REMOVE_FROM_CART: string;
+        UPDATE_CART: string;
+        DISCOUNT_CODE_UPDATED: string;
+        PERFORMANCE: string;
+    };
+};
+export {};

package/dist/node/foundation/Analytics/ClientAnalytics.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientAnalytics = void 0;
+const utils_1 = require("./utils");
+const utilities_1 = require("../../utilities");
+const const_1 = require("./const");
+const constants_1 = require("../../constants");
+const subscribers = {};
+let pageAnalyticsData = {};
+const guardDupEvents = {};
+const USAGE_ERROR = 'ClientAnalytics should only be used within the useEffect callback or event handlers';
+function isInvokedFromServer() {
+    if ((0, utilities_1.isServer)()) {
+        console.warn(USAGE_ERROR);
+        return true;
+    }
+    return false;
+}
+function pushToPageAnalyticsData(data, namespace) {
+    if (isInvokedFromServer())
+        return;
+    if (namespace) {
+        pageAnalyticsData[namespace] = Object.assign({}, pageAnalyticsData[namespace] || {}, data);
+    }
+    else {
+        pageAnalyticsData = Object.assign({}, pageAnalyticsData, data);
+    }
+}
+function getPageAnalyticsData() {
+    if (isInvokedFromServer())
+        return;
+    return pageAnalyticsData;
+}
+function resetPageAnalyticsData() {
+    if (isInvokedFromServer())
+        return;
+    pageAnalyticsData = {};
+}
+function publish(eventname, guardDup = false, payload) {
+    if (isInvokedFromServer())
+        return;
+    const namedspacedEventname = (0, utils_1.getNamedspacedEventname)(eventname);
+    const subs = subscribers[namedspacedEventname];
+    const combinedPayload = Object.assign({}, pageAnalyticsData, payload);
+    // De-dup events due to re-renders
+    if (guardDup) {
+        const eventGuardTimeout = guardDupEvents[namedspacedEventname];
+        if (eventGuardTimeout) {
+            clearTimeout(eventGuardTimeout);
+        }
+        const namespacedTimeout = setTimeout(() => {
+            publishEvent(subs, combinedPayload);
+        }, 100);
+        guardDupEvents[namedspacedEventname] = namespacedTimeout;
+    }
+    else {
+        publishEvent(subs, combinedPayload);
+    }
+}
+function publishEvent(subs, payload) {
+    if (subs) {
+        Object.keys(subs).forEach((key) => {
+            subs[key](payload);
+        });
+    }
+}
+function subscribe(eventname, callbackFunction) {
+    if (isInvokedFromServer())
+        return { unsubscribe: () => { } };
+    const namedspacedEventname = (0, utils_1.getNamedspacedEventname)(eventname);
+    const subs = subscribers[namedspacedEventname];
+    if (!subs) {
+        subscribers[namedspacedEventname] = {};
+    }
+    const subscriberId = Date.now().toString();
+    subscribers[namedspacedEventname][subscriberId] = callbackFunction;
+    return {
+        unsubscribe: () => {
+            delete subscribers[namedspacedEventname][subscriberId];
+        },
+    };
+}
+function pushToServer(init, searchParam) {
+    return fetch(`${constants_1.EVENT_PATHNAME}${searchParam ? `?${searchParam}` : ''}`, Object.assign({
+        method: 'post',
+        headers: {
+            'cache-control': 'no-cache',
+            'Content-Type': 'application/json',
+        },
+    }, init));
+}
+exports.ClientAnalytics = {
+    pushToPageAnalyticsData,
+    getPageAnalyticsData,
+    resetPageAnalyticsData,
+    publish,
+    subscribe,
+    pushToServer,
+    eventNames: const_1.eventNames,
+};

package/dist/node/foundation/Analytics/ServerAnalyticsRoute.server.d.ts

@@ -0,0 +1,2 @@
+import type { ServerAnalyticsConnector } from '../../types';
+export declare function ServerAnalyticsRoute(request: Request, serverAnalyticsConnectors?: Array<ServerAnalyticsConnector>): Response;

package/dist/node/foundation/Analytics/ServerAnalyticsRoute.server.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerAnalyticsRoute = void 0;
+const log_1 = require("../../utilities/log");
+function ServerAnalyticsRoute(request, serverAnalyticsConnectors) {
+    if (request.headers.get('Content-Length') === '0') {
+        serverAnalyticsConnectors === null || serverAnalyticsConnectors === void 0 ? void 0 : serverAnalyticsConnectors.forEach((connector) => {
+            connector.request(request);
+        });
+    }
+    else if (request.headers.get('Content-Type') === 'application/json') {
+        Promise.resolve(request.json())
+            .then((data) => {
+            serverAnalyticsConnectors === null || serverAnalyticsConnectors === void 0 ? void 0 : serverAnalyticsConnectors.forEach((connector) => {
+                connector.request(request, data, 'json');
+            });
+        })
+            .catch((error) => {
+            log_1.log.warn('Fail to resolve server analytics: ', error);
+        });
+    }
+    else {
+        Promise.resolve(request.text())
+            .then((data) => {
+            serverAnalyticsConnectors === null || serverAnalyticsConnectors === void 0 ? void 0 : serverAnalyticsConnectors.forEach((connector) => {
+                connector.request(request, data, 'text');
+            });
+        })
+            .catch((error) => {
+            log_1.log.warn('Fail to resolve server analytics: ', error);
+        });
+    }
+    return new Response(null, {
+        status: 200,
+    });
+}
+exports.ServerAnalyticsRoute = ServerAnalyticsRoute;

package/dist/node/foundation/Analytics/const.d.ts

@@ -0,0 +1,9 @@
+export declare const eventNames: {
+    PAGE_VIEW: string;
+    VIEWED_PRODUCT: string;
+    ADD_TO_CART: string;
+    REMOVE_FROM_CART: string;
+    UPDATE_CART: string;
+    DISCOUNT_CODE_UPDATED: string;
+    PERFORMANCE: string;
+};

package/dist/node/foundation/Analytics/const.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventNames = void 0;
+exports.eventNames = {
+    PAGE_VIEW: 'page-view',
+    VIEWED_PRODUCT: 'viewed-product',
+    ADD_TO_CART: 'add-to-cart',
+    REMOVE_FROM_CART: 'remove-from-cart',
+    UPDATE_CART: 'update-cart',
+    DISCOUNT_CODE_UPDATED: 'discount-code-updated',
+    PERFORMANCE: 'performance',
+};

package/dist/node/foundation/Analytics/hook.d.ts

@@ -0,0 +1 @@
+export declare function useServerAnalytics(data?: any): any;

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useServerAnalytics = void 0;
+const ServerRequestProvider_1 = require("../ServerRequestProvider");
+function useServerAnalytics(data) {
+    const request = (0, ServerRequestProvider_1.useServerRequest)();
+    if (data)
+        request.ctx.analyticsData = Object.assign({}, request.ctx.analyticsData, data);
+    return request.ctx.analyticsData;
+}
+exports.useServerAnalytics = useServerAnalytics;

package/dist/node/foundation/Analytics/index.d.ts

@@ -0,0 +1,2 @@
+export { useServerAnalytics } from './hook';
+export { ClientAnalytics } from './ClientAnalytics';

package/dist/node/foundation/Analytics/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientAnalytics = exports.useServerAnalytics = void 0;
+var hook_1 = require("./hook");
+Object.defineProperty(exports, "useServerAnalytics", { enumerable: true, get: function () { return hook_1.useServerAnalytics; } });
+var ClientAnalytics_1 = require("./ClientAnalytics");
+Object.defineProperty(exports, "ClientAnalytics", { enumerable: true, get: function () { return ClientAnalytics_1.ClientAnalytics; } });

package/dist/node/foundation/Analytics/types.d.ts

@@ -0,0 +1,5 @@
+export declare type Subscriber = {
+    unsubscribe: () => void;
+};
+export declare type SubscriberFunction = (payload: any) => void;
+export declare type Subscribers = Record<string, Record<string, SubscriberFunction>>;

package/dist/node/foundation/Analytics/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1 @@
+export declare function getNamedspacedEventname(eventname: string): string;

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNamedspacedEventname = void 0;
+const const_1 = require("./const");
+const RESERVED_EVENT_NAMES = Object.values(const_1.eventNames);
+function getNamedspacedEventname(eventname) {
+    // Any event name that is not in the reserved space will be prefix with `c-`
+    return RESERVED_EVENT_NAMES.indexOf(eventname) === -1
+        ? `c-${eventname}`
+        : eventname;
+}
+exports.getNamedspacedEventname = getNamedspacedEventname;

package/dist/node/foundation/AnalyticsErrorBoundary.client.d.ts

@@ -0,0 +1,4 @@
+import type { ReactNode } from 'react';
+export default function AnalyticsErrorBoundary({ children, }: {
+    children: ReactNode;
+}): JSX.Element;

package/dist/node/foundation/AnalyticsErrorBoundary.client.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const react_error_boundary_1 = require("react-error-boundary");
+function AnalyticsErrorBoundary({ children, }) {
+    // Analytics fail to load, most likely due to an ad blocker
+    return (react_1.default.createElement(react_error_boundary_1.ErrorBoundary, { fallbackRender: () => {
+            return null;
+        } }, children));
+}
+exports.default = AnalyticsErrorBoundary;

package/dist/node/foundation/Redirect/Redirect.client.d.ts

@@ -0,0 +1,5 @@
+declare type RedirectProps = {
+    to: string;
+};
+export default function Redirect({ to }: RedirectProps): null;
+export {};

package/dist/node/foundation/Redirect/Redirect.client.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
+const useNavigate_1 = require("../../foundation/useNavigate/useNavigate");
+function Redirect({ to }) {
+    const navigate = (0, useNavigate_1.useNavigate)();
+    (0, react_1.useEffect)(() => {
+        if (to.startsWith('http')) {
+            window.location.href = to;
+        }
+        else {
+            navigate(to);
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    return null;
+}
+exports.default = Redirect;

package/dist/node/foundation/Router/BrowserRouter.client.d.ts

@@ -0,0 +1,13 @@
+import { BrowserHistory, Location } from 'history';
+import React, { FC } from 'react';
+declare type RouterContextValue = {
+    history: BrowserHistory;
+    location: Location;
+};
+export declare const RouterContext: React.Context<{} | RouterContextValue>;
+export declare const BrowserRouter: FC<{
+    history?: BrowserHistory;
+}>;
+export declare function useRouter(): RouterContextValue;
+export declare function useLocation(): Location;
+export {};

package/dist/node/foundation/Router/BrowserRouter.client.js

@@ -0,0 +1,159 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useLocation = exports.useRouter = exports.BrowserRouter = exports.RouterContext = void 0;
+const history_1 = require("history");
+const react_1 = __importStar(require("react"));
+const ssr_interop_1 = require("../ssr-interop");
+const use_server_props_1 = require("../useServerProps/use-server-props");
+exports.RouterContext = (0, react_1.createContext)({});
+let isFirstLoad = true;
+const positions = {};
+const BrowserRouter = ({ history: pHistory, children, }) => {
+    if (ssr_interop_1.META_ENV_SSR)
+        return react_1.default.createElement(react_1.default.Fragment, null, children);
+    /* eslint-disable react-hooks/rules-of-hooks */
+    const history = (0, react_1.useMemo)(() => pHistory || (0, history_1.createBrowserHistory)(), [pHistory]);
+    const [location, setLocation] = (0, react_1.useState)(history.location);
+    const [locationChanged, setLocationChanged] = (0, react_1.useState)(false);
+    const { pending, locationServerProps, setLocationServerProps } = (0, use_server_props_1.useInternalServerProps)();
+    useScrollRestoration({
+        location,
+        pending,
+        serverProps: locationServerProps,
+        locationChanged,
+        onFinishNavigating: () => setLocationChanged(false),
+    });
+    (0, react_1.useLayoutEffect)(() => {
+        const unlisten = history.listen(({ location: newLocation }) => {
+            positions[location.key] = window.scrollY;
+            setLocationServerProps({
+                pathname: newLocation.pathname,
+                search: newLocation.search,
+            });
+            setLocation(newLocation);
+            setLocationChanged(true);
+        });
+        return () => unlisten();
+    }, [
+        history,
+        location,
+        setLocationChanged,
+        setLocation,
+        setLocationServerProps,
+    ]);
+    /* eslint-enable react-hooks/rules-of-hooks */
+    return (react_1.default.createElement(exports.RouterContext.Provider, { value: {
+            history,
+            location,
+        } }, children));
+};
+exports.BrowserRouter = BrowserRouter;
+function useRouter() {
+    const router = (0, react_1.useContext)(exports.RouterContext);
+    if (!router && ssr_interop_1.META_ENV_SSR) {
+        throw new Error('useRouter must be used within a <Router> component');
+    }
+    return router;
+}
+exports.useRouter = useRouter;
+function useLocation() {
+    return useRouter().location;
+}
+exports.useLocation = useLocation;
+/**
+ * Run a callback before browser unload.
+ */
+function useBeforeUnload(callback) {
+    react_1.default.useEffect(() => {
+        window.addEventListener('beforeunload', callback);
+        return () => {
+            window.removeEventListener('beforeunload', callback);
+        };
+    }, [callback]);
+}
+function useScrollRestoration({ location, pending, serverProps, locationChanged, 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
+     * set it to manual mode.
+     */
+    (0, react_1.useEffect)(() => {
+        window.history.scrollRestoration = 'manual';
+    }, []);
+    /**
+     * If the page is reloading, allow the browser to handle its own scroll restoration.
+     */
+    useBeforeUnload((0, react_1.useCallback)(() => {
+        window.history.scrollRestoration = 'auto';
+    }, []));
+    (0, react_1.useLayoutEffect)(() => {
+        // The app has just loaded
+        if (isFirstLoad || !locationChanged) {
+            isFirstLoad = false;
+            return;
+        }
+        const position = positions[location.key];
+        /**
+         * When serverState gets updated, `pending` is true while the fetch is in progress.
+         * When that resolves, the serverState is updated. We should wait until the internal
+         * location pointer and serverState match, and pending is false, to do any scrolling.
+         */
+        const finishedNavigating = !pending &&
+            location.pathname === serverProps.pathname &&
+            location.search === serverProps.search;
+        if (!finishedNavigating) {
+            return;
+        }
+        // If there is a location hash, scroll to it
+        if (location.hash) {
+            const element = document.querySelector(location.hash);
+            if (element) {
+                element.scrollIntoView();
+                onFinishNavigating();
+                return;
+            }
+        }
+        // If we have a matching position, scroll to it
+        if (position) {
+            window.scrollTo(0, position);
+            onFinishNavigating();
+            return;
+        }
+        // Scroll to the top of new pages
+        window.scrollTo(0, 0);
+        onFinishNavigating();
+    }, [
+        location.pathname,
+        location.search,
+        location.hash,
+        location.key,
+        pending,
+        serverProps.pathname,
+        serverProps.search,
+        locationChanged,
+        onFinishNavigating,
+    ]);
+}

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

@@ -0,0 +1,40 @@
+import React, { ReactNode } from 'react';
+declare global {
+    var __DEV__: boolean;
+}
+export interface LocationServerProps {
+    pathname: string;
+    search: string;
+}
+export interface ServerProps {
+    [key: string]: any;
+}
+declare type ServerPropsSetterInput = ((prev: ServerProps) => Partial<ServerProps>) | Partial<ServerProps> | string;
+export interface ServerPropsSetter {
+    (input: ServerPropsSetterInput, propValue?: any): void;
+}
+interface ProposedServerPropsSetter {
+    (input: ServerPropsSetterInput, propValue?: any): LocationServerProps;
+}
+interface BaseServerPropsContextValue {
+    pending: boolean;
+}
+export interface InternalServerPropsContextValue extends BaseServerPropsContextValue {
+    setLocationServerProps: ServerPropsSetter;
+    setServerProps: ServerPropsSetter;
+    serverProps: ServerProps;
+    locationServerProps: LocationServerProps;
+    getProposedLocationServerProps: ProposedServerPropsSetter;
+}
+export interface ServerPropsContextValue extends BaseServerPropsContextValue {
+    serverProps: ServerProps;
+    setServerProps: ServerPropsSetter;
+}
+export declare const ServerPropsContext: React.Context<InternalServerPropsContextValue>;
+interface ServerPropsProviderProps {
+    initialServerProps: LocationServerProps;
+    setServerPropsForRsc: React.Dispatch<React.SetStateAction<LocationServerProps>>;
+    children: ReactNode;
+}
+export declare function ServerPropsProvider({ initialServerProps, setServerPropsForRsc, children, }: ServerPropsProviderProps): JSX.Element;
+export {};

package/dist/node/foundation/ServerPropsProvider/ServerPropsProvider.js

@@ -0,0 +1,92 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerPropsProvider = exports.ServerPropsContext = void 0;
+/* eslint-disable hydrogen/no-state-in-server-components */
+const react_1 = __importStar(require("react"));
+const PRIVATE_PROPS = ['request', 'response'];
+exports.ServerPropsContext = (0, react_1.createContext)(null);
+function ServerPropsProvider({ initialServerProps, setServerPropsForRsc, children, }) {
+    const [locationServerProps, setLocationServerProps] = (0, react_1.useState)(initialServerProps);
+    const [serverProps, setServerProps] = (0, react_1.useState)({});
+    const [pending, startTransition] = (0, react_1.useTransition)();
+    const setServerPropsCallback = (0, react_1.useCallback)((input, propValue) => {
+        startTransition(() => {
+            setServerProps((prev) => getNewValue(prev, input, propValue));
+            setServerPropsForRsc((prev) => getNewValue(prev, input, propValue));
+        });
+    }, [setServerProps, setServerPropsForRsc]);
+    const setLocationServerPropsCallback = (0, react_1.useCallback)((input, propValue) => {
+        // Flush the existing user server state when location changes, leaving only the persisted state
+        startTransition(() => {
+            setServerPropsForRsc((prev) => getNewValue(prev, input, propValue));
+            setServerProps({});
+            setLocationServerProps((prev) => getNewValue(prev, input, propValue));
+        });
+    }, [setServerProps, setServerPropsForRsc, setLocationServerProps]);
+    const getProposedLocationServerPropsCallback = (0, react_1.useCallback)((input, propValue) => {
+        return getNewValue(locationServerProps, input, propValue);
+    }, [locationServerProps]);
+    function getNewValue(prev, input, propValue) {
+        let newValue;
+        if (typeof input === 'function') {
+            newValue = input(prev);
+        }
+        else if (typeof input === 'string') {
+            newValue = { [input]: propValue };
+        }
+        else {
+            newValue = input;
+        }
+        if (__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.`);
+            }
+        }
+        return {
+            ...prev,
+            ...newValue,
+        };
+    }
+    const value = (0, react_1.useMemo)(() => ({
+        pending,
+        locationServerProps,
+        serverProps,
+        setServerProps: setServerPropsCallback,
+        setLocationServerProps: setLocationServerPropsCallback,
+        getProposedLocationServerProps: getProposedLocationServerPropsCallback,
+    }), [
+        pending,
+        locationServerProps,
+        serverProps,
+        setServerPropsCallback,
+        setLocationServerPropsCallback,
+        getProposedLocationServerPropsCallback,
+    ]);
+    return (react_1.default.createElement(exports.ServerPropsContext.Provider, { value: value }, children));
+}
+exports.ServerPropsProvider = ServerPropsProvider;
+/* eslint-enable hydrogen/no-state-in-server-components */

package/dist/node/foundation/ServerPropsProvider/index.d.ts

@@ -0,0 +1,2 @@
+export { ServerPropsProvider, ServerPropsContext } from './ServerPropsProvider';
+export type { ServerProps, ServerPropsContextValue } from './ServerPropsProvider';

package/dist/node/foundation/ServerPropsProvider/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerPropsContext = exports.ServerPropsProvider = void 0;
+var ServerPropsProvider_1 = require("./ServerPropsProvider");
+Object.defineProperty(exports, "ServerPropsProvider", { enumerable: true, get: function () { return ServerPropsProvider_1.ServerPropsProvider; } });
+Object.defineProperty(exports, "ServerPropsContext", { enumerable: true, get: function () { return ServerPropsProvider_1.ServerPropsContext; } });

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

@@ -0,0 +1,23 @@
+import type { PreloadQueriesByURL, ServerComponentRequest } from '../../framework/Hydration/ServerComponentRequest.server';
+import type { QueryKey } from '../../types';
+declare type ServerRequestProviderProps = {
+    isRSC: boolean;
+    request: ServerComponentRequest;
+    children: JSX.Element;
+};
+export declare function ServerRequestProvider({ isRSC, request, children, }: ServerRequestProviderProps): JSX.Element;
+export declare function useServerRequest(): ServerComponentRequest;
+declare type RequestCacheResult<T> = {
+    data: T;
+    error?: never;
+} | {
+    data?: never;
+    error: Response | Error;
+};
+/**
+ * Returns data stored in the request cache.
+ * 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 {};