@shopify/hydrogen 1.6.5 → 2.0.0-alpha.1

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

@@ -1,65 +0,0 @@
-import React, { createContext, useMemo, useCallback, useTransition, useState, } from 'react';
-const PRIVATE_PROPS = ['request', 'response'];
-export const ServerPropsContext = createContext(null);
-export function ServerPropsProvider({ initialServerProps, setServerPropsForRsc, setRscResponseFromApiRoute, children, }) {
-    const [locationServerProps, setLocationServerProps] = useState(initialServerProps);
-    const [serverProps, setServerProps] = useState({});
-    const [pending, startTransition] = useTransition();
-    const setServerPropsCallback = useCallback((input, propValue) => {
-        startTransition(() => {
-            setServerProps((prev) => getNewValue(prev, input, propValue));
-            setServerPropsForRsc((prev) => getNewValue(prev, input, propValue));
-        });
-    }, [setServerProps, setServerPropsForRsc]);
-    const setLocationServerPropsCallback = useCallback((input) => {
-        // Flush the existing user server state when location changes, leaving only the persisted state
-        startTransition(() => {
-            setServerPropsForRsc(input);
-            setServerProps({});
-            setLocationServerProps(input);
-        });
-    }, [setServerProps, setServerPropsForRsc, setLocationServerProps]);
-    const getProposedLocationServerPropsCallback = 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 (__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.`);
-            }
-        }
-        return {
-            ...prev,
-            ...newValue,
-        };
-    }
-    const value = useMemo(() => ({
-        pending,
-        locationServerProps,
-        serverProps,
-        setServerProps: setServerPropsCallback,
-        setLocationServerProps: setLocationServerPropsCallback,
-        getProposedLocationServerProps: getProposedLocationServerPropsCallback,
-        setRscResponseFromApiRoute,
-    }), [
-        pending,
-        locationServerProps,
-        serverProps,
-        setServerPropsCallback,
-        setLocationServerPropsCallback,
-        getProposedLocationServerPropsCallback,
-        setRscResponseFromApiRoute,
-    ]);
-    return (React.createElement(ServerPropsContext.Provider, { value: value }, children));
-}

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

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

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

@@ -1 +0,0 @@
-export { ServerPropsProvider, ServerPropsContext, } from './ServerPropsProvider.js';

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

@@ -1,23 +0,0 @@
-import React from 'react';
-import type { HydrogenRequest } from '../HydrogenRequest/HydrogenRequest.server.js';
-import type { QueryKey } from '../../types.js';
-declare type ServerRequestProviderProps = {
-    request: HydrogenRequest;
-    children: React.ReactNode;
-};
-export declare function ServerRequestProvider({ request, children, }: ServerRequestProviderProps): JSX.Element;
-export declare function useServerRequest(): HydrogenRequest;
-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: (request: HydrogenRequest) => T | Promise<T>): RequestCacheResult<T>;
-export declare function preloadRequestCacheData(request: HydrogenRequest): void;
-export {};

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

@@ -1,125 +0,0 @@
-import React, { createContext, useContext } from 'react';
-import { getTime } from '../../utilities/timing.js';
-import { hashKey } from '../../utilities/hash.js';
-import { collectQueryTimings } from '../../utilities/log/index.js';
-// Context to inject current request in SSR
-const RequestContextSSR = createContext(null);
-// Cache to inject current request in RSC
-function requestCacheRSC() {
-    return new Map();
-}
-requestCacheRSC.key = Symbol.for('HYDROGEN_REQUEST');
-function getInternalReactDispatcher() {
-    return (
-    // @ts-ignore
-    React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED
-        .ReactCurrentDispatcher.current || {});
-}
-function isRsc() {
-    // This flag is added by RSC Vite plugin
-    return __HYDROGEN_TEST__ || !!getInternalReactDispatcher().isRsc;
-}
-// Note: use this only during RSC/Flight rendering. The React dispatcher
-// for SSR/Fizz rendering does not implement getCacheForType.
-function getCacheForType(resource) {
-    const dispatcher = getInternalReactDispatcher();
-    // @ts-ignore
-    if (__HYDROGEN_TEST__ && !dispatcher.getCacheForType) {
-        // Jest does not have access to the RSC runtime, mock it here:
-        // @ts-ignore
-        return (globalThis.__jestRscCache ??= resource());
-    }
-    return dispatcher.getCacheForType(resource);
-}
-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);
-        requestCache.set(requestCacheRSC.key, request);
-        return React.createElement(React.Fragment, null, children);
-    }
-    // Use a normal provider in SSR to make the request object
-    // available in the current rendering.
-    return (React.createElement(RequestContextSSR.Provider, { value: request }, children));
-}
-export function useServerRequest() {
-    const request = isRsc()
-        ? getCacheForType(requestCacheRSC)?.get(requestCacheRSC.key)
-        : useContext(RequestContextSSR); // eslint-disable-line react-hooks/rules-of-hooks
-    if (!request) {
-        if (__HYDROGEN_TEST__) {
-            // Unit tests are not wrapped in ServerRequestProvider.
-            // This mocks it, instead of providing it in every test.
-            return { ctx: {} };
-        }
-        throw new Error('No ServerRequest Context found');
-    }
-    return request;
-}
-/**
- * Returns data stored in the request cache.
- * It will throw the promise if data is not ready.
- */
-export function useRequestCacheData(key, fetcher) {
-    const request = useServerRequest();
-    const cache = request.ctx.cache;
-    const cacheKey = hashKey(key);
-    if (!cache.has(cacheKey)) {
-        let result;
-        let promise;
-        cache.set(cacheKey, () => {
-            if (result !== undefined) {
-                collectQueryTimings(request, key, 'rendered');
-                return result;
-            }
-            if (!promise) {
-                const startApiTime = getTime();
-                const maybePromise = fetcher(request);
-                if (!(maybePromise instanceof Promise)) {
-                    result = { data: maybePromise };
-                    return result;
-                }
-                promise = maybePromise.then((data) => {
-                    result = { data };
-                    collectQueryTimings(request, key, 'resolved', getTime() - startApiTime);
-                }, (error) => (result = { error }));
-            }
-            throw promise;
-        });
-    }
-    // Making sure the promise has returned data because it can be initated by a preload request,
-    // otherwise, we throw the promise
-    const result = cache.get(cacheKey).call();
-    if (result instanceof Promise)
-        throw result;
-    return result;
-}
-export function preloadRequestCacheData(request) {
-    const preloadQueries = request.getPreloadQueries();
-    const { cache } = request.ctx;
-    preloadQueries?.forEach((preloadQuery, cacheKey) => {
-        collectQueryTimings(request, preloadQuery.key, 'preload');
-        if (!cache.has(cacheKey)) {
-            let result;
-            let promise;
-            cache.set(cacheKey, () => {
-                if (result !== undefined) {
-                    collectQueryTimings(request, preloadQuery.key, 'rendered');
-                    return result;
-                }
-                if (!promise) {
-                    const startApiTime = getTime();
-                    promise = preloadQuery.fetcher(request).then((data) => {
-                        result = { data };
-                        collectQueryTimings(request, preloadQuery.key, 'resolved', getTime() - startApiTime);
-                    }, (error) => {
-                        result = { error };
-                    });
-                }
-                return promise;
-            });
-        }
-        cache.get(cacheKey).call();
-    });
-}

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

@@ -1 +0,0 @@
-export * from './ServerRequestProvider.js';

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

@@ -1 +0,0 @@
-export * from './ServerRequestProvider.js';

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

@@ -1,30 +0,0 @@
-import React, { ReactNode } from 'react';
-declare global {
-    var __HYDROGEN_DEV__: boolean;
-}
-export interface ServerState {
-    pathname: string;
-    search: string;
-    [key: string]: any;
-}
-declare type ServerStateSetterInput = ((prev: ServerState) => Partial<ServerState>) | Partial<ServerState> | string;
-export interface ServerStateSetter {
-    (input: ServerStateSetterInput, propValue?: any): void;
-}
-interface ProposedServerStateSetter {
-    (input: ServerStateSetterInput, propValue?: any): ServerState;
-}
-export interface ServerStateContextValue {
-    pending: boolean;
-    serverState: ServerState;
-    setServerState: ServerStateSetter;
-    getProposedServerState: ProposedServerStateSetter;
-}
-export declare const ServerStateContext: React.Context<ServerStateContextValue>;
-interface ServerStateProviderProps {
-    serverState: ServerState;
-    setServerState: React.Dispatch<React.SetStateAction<ServerState>>;
-    children: ReactNode;
-}
-export declare function ServerStateProvider({ serverState, setServerState, children, }: ServerStateProviderProps): JSX.Element;
-export {};

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

@@ -1,59 +0,0 @@
-import React, { createContext, useMemo, useCallback, 
-// @ts-ignore
-useTransition, } from 'react';
-const PRIVATE_PROPS = ['request', 'response'];
-export const ServerStateContext = createContext(null);
-export function ServerStateProvider({ serverState, setServerState, children, }) {
-    const [pending, startTransition] = useTransition();
-    const setServerStateCallback = useCallback((input, propValue) => {
-        /**
-         * By wrapping this state change in a transition, React renders the new state
-         * concurrently in a new "tree" instead of Suspending and showing the (blank)
-         * fallback. This is preferred behavior, though we may want to revisit how
-         * we make this decision globally for the developer - and consider providing
-         * the `pending` flag also provided by the hook to display in the UI.
-         */
-        startTransition(() => {
-            return setServerState((prev) => getNewServerState(prev, input, propValue));
-        });
-    }, [setServerState, startTransition]);
-    const getProposedServerStateCallback = useCallback((input, propValue) => {
-        return getNewServerState(serverState, input, propValue);
-    }, [serverState]);
-    function getNewServerState(prev, input, propValue) {
-        let newValue;
-        if (typeof input === 'function') {
-            newValue = input(prev);
-        }
-        else if (typeof input === 'string') {
-            newValue = { [input]: propValue };
-        }
-        else {
-            newValue = input;
-        }
-        if (!newValue)
-            return { ...prev };
-        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.`);
-            }
-        }
-        return {
-            ...prev,
-            ...newValue,
-        };
-    }
-    const value = useMemo(() => ({
-        pending,
-        serverState,
-        setServerState: setServerStateCallback,
-        getProposedServerState: getProposedServerStateCallback,
-    }), [
-        serverState,
-        getProposedServerStateCallback,
-        setServerStateCallback,
-        pending,
-    ]);
-    return (React.createElement(ServerStateContext.Provider, { value: value }, children));
-}

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

@@ -1,9 +0,0 @@
-import type { ShopifyContextClientValue, LocalizationContextValue } from './types.js';
-import React, { ReactNode } from 'react';
-export declare const ShopifyContext: React.Context<ShopifyContextClientValue | null>;
-export declare const LocalizationContext: React.Context<LocalizationContextValue | null>;
-export declare function ShopifyProviderClient({ children, shopifyConfig, localization, }: {
-    children: ReactNode;
-    shopifyConfig: ShopifyContextClientValue;
-    localization: LocalizationContextValue;
-}): JSX.Element;

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

@@ -1,10 +0,0 @@
-import React, { createContext } from 'react';
-export const ShopifyContext = createContext(null);
-export const LocalizationContext = createContext(null);
-export function ShopifyProviderClient({ children, shopifyConfig, localization, }) {
-    if (!shopifyConfig) {
-        throw new Error('The `shopifyConfig` prop should be passed to `ShopifyProvider`');
-    }
-    return (React.createElement(ShopifyContext.Provider, { value: shopifyConfig },
-        React.createElement(LocalizationContext.Provider, { value: localization }, children)));
-}

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

@@ -1,19 +0,0 @@
-import type { ShopifyProviderProps, LocalizationContextValue } from './types.js';
-import type { CountryCode, LanguageCode } from '../../storefront-api-types.js';
-export declare const CLIENT_CONTEXT_ALLOW_LIST: readonly ["defaultCountryCode", "defaultLanguageCode", "storeDomain", "storefrontToken", "storefrontApiVersion", "storefrontId"];
-export declare const SHOPIFY_PROVIDER_CONTEXT_KEY: unique symbol;
-/**
- * The `ShopifyProvider` component wraps your entire app and provides support for hooks.
- * You should place it in your app's entry point component. For example, `<App>`.
- * If you're using the Hydrogen framework, you don't need to add this provider
- * because it's automatically wrapped around your app in `renderHydrogen()`.
- */
-export declare function ShopifyProvider({ 
-/**
- * Shopify connection information. Defaults to
- * [the `shopify` property in the `hydrogen.config.js` file](https://shopify.dev/custom-storefronts/hydrogen/configuration).
- */
-shopifyConfig, countryCode, languageCode, 
-/** Any `ReactNode` elements. */
-children, }: ShopifyProviderProps): JSX.Element;
-export declare function getLocalizationContextValue(defaultLanguageCode: `${LanguageCode}`, defaultCountryCode: `${CountryCode}`, languageCode?: `${LanguageCode}`, countryCode?: `${CountryCode}`): LocalizationContextValue;

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

@@ -1,94 +0,0 @@
-import React, { useMemo } from 'react';
-import { ShopifyProviderClient } from './ShopifyProvider.client.js';
-import { DEFAULT_COUNTRY, DEFAULT_LANGUAGE } from '../constants.js';
-import { useRequestCacheData, useServerRequest, } from '../ServerRequestProvider/index.js';
-import { getOxygenVariable } from '../../utilities/storefrontApi.js';
-import { SHOPIFY_STOREFRONT_ID_VARIABLE } from '../../constants.js';
-import { getLocale } from '../../utilities/locale/index.js';
-export const CLIENT_CONTEXT_ALLOW_LIST = [
-    'defaultCountryCode',
-    'defaultLanguageCode',
-    'storeDomain',
-    'storefrontToken',
-    'storefrontApiVersion',
-    'storefrontId',
-];
-function makeShopifyContext(shopifyConfig) {
-    const countryCode = shopifyConfig.defaultCountryCode ?? DEFAULT_COUNTRY;
-    const languageCode = shopifyConfig.defaultLanguageCode ?? DEFAULT_LANGUAGE;
-    const storefrontId = shopifyConfig.storefrontId ??
-        getOxygenVariable(SHOPIFY_STOREFRONT_ID_VARIABLE);
-    const shopifyProviderServerValue = {
-        defaultCountryCode: countryCode.toUpperCase(),
-        defaultLanguageCode: languageCode.toUpperCase(),
-        storeDomain: shopifyConfig?.storeDomain?.replace(/^https?:\/\//, ''),
-        storefrontToken: shopifyConfig.storefrontToken,
-        storefrontApiVersion: shopifyConfig.storefrontApiVersion,
-        storefrontId,
-        privateStorefrontToken: shopifyConfig.privateStorefrontToken,
-    };
-    return {
-        shopifyProviderServerValue,
-        shopifyProviderClientValue: CLIENT_CONTEXT_ALLOW_LIST.reduce((clientConfigValue, key) => {
-            clientConfigValue[key] = shopifyProviderServerValue[key];
-            return clientConfigValue;
-        }, {}),
-    };
-}
-export const SHOPIFY_PROVIDER_CONTEXT_KEY = Symbol.for('SHOPIFY_PROVIDER_RSC');
-/**
- * The `ShopifyProvider` component wraps your entire app and provides support for hooks.
- * You should place it in your app's entry point component. For example, `<App>`.
- * If you're using the Hydrogen framework, you don't need to add this provider
- * because it's automatically wrapped around your app in `renderHydrogen()`.
- */
-export function ShopifyProvider({ 
-/**
- * Shopify connection information. Defaults to
- * [the `shopify` property in the `hydrogen.config.js` file](https://shopify.dev/custom-storefronts/hydrogen/configuration).
- */
-shopifyConfig, countryCode, languageCode, 
-/** Any `ReactNode` elements. */
-children, }) {
-    const request = useServerRequest();
-    if (!shopifyConfig) {
-        shopifyConfig = request.ctx.hydrogenConfig?.shopify;
-        if (!shopifyConfig) {
-            throw new Error('The `shopifyConfig` prop should be passed to `ShopifyProvider`');
-        }
-    }
-    let actualShopifyConfig;
-    if (typeof shopifyConfig === 'function') {
-        const result = useRequestCacheData(['hydrogen-shopify-config'], () => shopifyConfig(request));
-        if (result.error) {
-            if (result.error instanceof Error) {
-                throw result.error;
-            }
-            throw new Error(`Failed to load Shopify config: ${result.error.statusText}`);
-        }
-        actualShopifyConfig = result.data;
-    }
-    else {
-        actualShopifyConfig = shopifyConfig;
-    }
-    const { shopifyProviderServerValue, shopifyProviderClientValue } = useMemo(() => makeShopifyContext(actualShopifyConfig), [actualShopifyConfig]);
-    const localization = getLocalizationContextValue(shopifyProviderServerValue.defaultLanguageCode, shopifyProviderServerValue.defaultCountryCode, languageCode, countryCode);
-    request.ctx.localization = localization;
-    request.ctx.shopifyConfig = shopifyProviderServerValue;
-    return (React.createElement(ShopifyProviderClient, { shopifyConfig: shopifyProviderClientValue, localization: localization }, children));
-}
-export function getLocalizationContextValue(defaultLanguageCode, defaultCountryCode, languageCode, countryCode) {
-    return useMemo(() => {
-        const runtimeLanguageCode = (languageCode ?? defaultLanguageCode).toUpperCase();
-        const runtimeCountryCode = (countryCode ?? defaultCountryCode).toUpperCase();
-        return {
-            country: {
-                isoCode: runtimeCountryCode,
-            },
-            language: {
-                isoCode: runtimeLanguageCode,
-            },
-            locale: getLocale(runtimeLanguageCode, runtimeCountryCode),
-        };
-    }, [defaultLanguageCode, defaultCountryCode, countryCode, languageCode]);
-}

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

@@ -1 +0,0 @@
-export { ShopifyContext } from './ShopifyProvider.client.js';

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

@@ -1 +0,0 @@
-export { ShopifyContext } from './ShopifyProvider.client.js';

package/dist/esnext/foundation/ShopifyProvider/types.d.ts

@@ -1,35 +0,0 @@
-import type { CountryCode, LanguageCode } from '../../storefront-api-types.js';
-import type { ReactNode } from 'react';
-import type { ShopifyConfigFetcher, ShopifyConfig } from '../../types.js';
-import type { CLIENT_CONTEXT_ALLOW_LIST } from './ShopifyProvider.server.js';
-export interface ShopifyContextServerValue extends Omit<ShopifyConfig, 'defaultLanguageCode' | 'defaultCountryCode'> {
-    defaultLanguageCode: `${LanguageCode}`;
-    defaultCountryCode: `${CountryCode}`;
-}
-declare type CLIENT_KEYS = typeof CLIENT_CONTEXT_ALLOW_LIST[number];
-export declare type ShopifyContextClientValue = Pick<ShopifyContextServerValue, CLIENT_KEYS>;
-export declare type Locale = string;
-export interface LocalizationContextValue {
-    country: {
-        isoCode: `${CountryCode}`;
-    };
-    language: {
-        isoCode: `${LanguageCode}`;
-    };
-    locale: Locale;
-}
-export declare type ShopifyProviderProps = {
-    /** Shopify connection information. Defaults to the `shopify` property in the `hydrogen.config.js` file. */
-    shopifyConfig?: ShopifyConfig | ShopifyConfigFetcher;
-    /** Any `ReactNode` elements. */
-    children?: ReactNode;
-    /**
-     * Override the `isoCode` to define the active country
-     */
-    countryCode?: `${CountryCode}`;
-    /**
-     * Override the `languageCode` to define the active language
-     */
-    languageCode?: `${LanguageCode}`;
-};
-export {};

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

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

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

@@ -1,2 +0,0 @@
-export declare const DEFAULT_COUNTRY = "US";
-export declare const DEFAULT_LANGUAGE = "EN";

package/dist/esnext/foundation/constants.js

@@ -1,4 +0,0 @@
-// Note: do not mix this export with other app-only logic
-// to avoid importing unnecessary code in the plugins.
-export const DEFAULT_COUNTRY = 'US';
-export const DEFAULT_LANGUAGE = 'EN';

package/dist/esnext/foundation/fetchSync/ResponseSync.d.ts

@@ -1,15 +0,0 @@
-declare type ResponseSyncInit = [string, ResponseInit, string];
-export declare class ResponseSync extends Response {
-    #private;
-    bodyUsed: boolean;
-    url: string;
-    constructor(init: ResponseSyncInit);
-    text(): string;
-    json(): any;
-    /**
-     * @deprecated Access response properties at the top level instead.
-     */
-    get response(): this;
-    static toSerializable(response: Response): Promise<ResponseSyncInit>;
-}
-export {};

package/dist/esnext/foundation/fetchSync/ResponseSync.js

@@ -1,50 +0,0 @@
-import { parseJSON } from '../../utilities/parse.js';
-import { log } from '../../utilities/log/index.js';
-export class ResponseSync extends Response {
-    bodyUsed = true;
-    #text;
-    #json;
-    url;
-    constructor(init) {
-        super(init[0], init[1]);
-        this.#text = init[0];
-        this.url = init[2];
-    }
-    // @ts-expect-error Changing inherited types
-    text() {
-        return this.#text;
-    }
-    json() {
-        try {
-            return (this.#json ??= parseJSON(this.#text));
-        }
-        catch (e) {
-            if (!this.ok) {
-                throw new Error(`Request to ${this.url} failed with ${this.status} and the response body is not parseable.\nMake sure to handle the error state when using fetchSync.`);
-            }
-            else
-                throw e;
-        }
-    }
-    /**
-     * @deprecated Access response properties at the top level instead.
-     */
-    get response() {
-        if (__HYDROGEN_DEV__) {
-            log.warn(`Property 'response' is deprecated from the result of 'fetchSync'.` +
-                ` Access response properties at the top level instead.`);
-        }
-        return this;
-    }
-    static async toSerializable(response) {
-        return [
-            await response.text(),
-            {
-                status: response.status,
-                statusText: response.statusText,
-                headers: Array.from(response.headers.entries()),
-            },
-            response.url,
-        ];
-    }
-}

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

@@ -1,10 +0,0 @@
-import { ResponseSync } from '../ResponseSync.js';
-/**
- * Fetch a URL for use in a client component Suspense boundary.
- */
-export declare function fetchSync(url: string, options?: RequestInit): ResponseSync;
-/**
- * Preload a URL for use in  a client component Suspense boundary.
- * Useful for placing higher in the tree to avoid waterfalls.
- */
-export declare function preload(url: string, options?: RequestInit): void;

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

@@ -1,23 +0,0 @@
-import { suspendFunction, preloadFunction } from '../../../utilities/suspense.js';
-import { ResponseSync } from '../ResponseSync.js';
-/**
- * Fetch a URL for use in a client component Suspense boundary.
- */
-export function fetchSync(url, options) {
-    const responseSyncInit = suspendFunction([url, options], async () => {
-        const response = await globalThis.fetch(new URL(url, window.location.origin), options);
-        return ResponseSync.toSerializable(response);
-    });
-    return new ResponseSync(responseSyncInit);
-}
-/**
- * Preload a URL for use in  a client component Suspense boundary.
- * Useful for placing higher in the tree to avoid waterfalls.
- */
-export function preload(url, options) {
-    preloadFunction([url, options], async () => {
-        const response = await globalThis.fetch(url, options);
-        const text = await response.text();
-        return [text, response];
-    });
-}

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

@@ -1,8 +0,0 @@
-import { type HydrogenUseQueryOptions } from '../../useQuery/index.js';
-import { ResponseSync } from '../ResponseSync.js';
-/**
- * The `fetchSync` hook makes API requests and is the recommended way to make simple fetch calls on the server and the client.
- * It's designed similar to the [Web API's `fetch`](https://developer.mozilla.org/en-US/docs/Web/API/fetch), only in a way
- * that supports [Suspense](https://reactjs.org/docs/concurrent-mode-suspense.html).
- */
-export declare function fetchSync(originalUrl: string, options?: Omit<RequestInit, 'cache'> & HydrogenUseQueryOptions): ResponseSync;