@shopify/hydrogen 0.0.0-experimental-20220526194818

package/dist/esnext/hooks/useProduct/useProduct.js

@@ -0,0 +1,43 @@
+import { useContext } from 'react';
+import { ProductContext, ProductOptionsContext, } from '../../components/ProductProvider/context';
+/**
+ * The `useProduct` hook returns the product object of the nearest `ProductProvider`. It must be a descendent of
+ * a `ProductProvider` component.
+ */
+export function useProduct() {
+    var _a;
+    const data = useContext(ProductContext);
+    let state;
+    try {
+        state = (_a = useContext(ProductOptionsContext)) !== null && _a !== void 0 ? _a : { ...stateFallback }; // eslint-disable-line react-hooks/rules-of-hooks
+    }
+    catch (error) {
+        // for server components which can't use state
+        state = { ...stateFallback };
+    }
+    return {
+        ...state,
+        ...data,
+    };
+}
+const stateFallback = {
+    variants: undefined,
+    variantsConnection: undefined,
+    options: undefined,
+    selectedVariant: undefined,
+    setSelectedVariant: NotAvailable('setSelectedVariant'),
+    selectedOptions: undefined,
+    setSelectedOption: NotAvailable('setSelectedOption'),
+    setSelectedOptions: NotAvailable('setSelectedOptions'),
+    isOptionInStock: undefined,
+    setSelectedSellingPlan: NotAvailable('setSelectedSellingPlan'),
+    selectedSellingPlan: undefined,
+    selectedSellingPlanAllocation: undefined,
+    sellingPlanGroups: undefined,
+    sellingPlanGroupsConnection: undefined,
+};
+function NotAvailable(propName) {
+    return () => {
+        throw new Error(`The '${propName}' function is not available in server components`);
+    };
+}

package/dist/esnext/hooks/useProductOptions/helpers.d.ts

@@ -0,0 +1,6 @@
+import { SelectedOptions, OptionWithValues } from './types';
+import type { ProductVariant as ProductVariantType } from '../../storefront-api-types';
+import type { PartialDeep } from 'type-fest';
+export declare function getAllOptionValues(variants: ProductVariantType[], option: string): string[];
+export declare function getSelectedVariant(variants: PartialDeep<ProductVariantType>[], choices: SelectedOptions): PartialDeep<ProductVariantType> | undefined;
+export declare function getOptions(variants: PartialDeep<ProductVariantType>[]): OptionWithValues[];

package/dist/esnext/hooks/useProductOptions/helpers.js

@@ -0,0 +1,40 @@
+export function getAllOptionValues(variants, option) {
+    return Array.from(new Set(variants.map((variant) => variant.selectedOptions.find((selection) => selection.name == option)
+        .value)));
+}
+export function getSelectedVariant(variants, choices) {
+    var _a, _b;
+    /**
+     * Ensure the user has selected all the required options, not just some.
+     */
+    if (!variants.length ||
+        ((_b = (_a = variants === null || variants === void 0 ? void 0 : variants[0]) === null || _a === void 0 ? void 0 : _a.selectedOptions) === null || _b === void 0 ? void 0 : _b.length) !== Object.keys(choices).length) {
+        return;
+    }
+    return variants === null || variants === void 0 ? void 0 : variants.find((variant) => {
+        return Object.entries(choices).every(([name, value]) => {
+            var _a;
+            return (_a = variant === null || variant === void 0 ? void 0 : variant.selectedOptions) === null || _a === void 0 ? void 0 : _a.some((option) => (option === null || option === void 0 ? void 0 : option.name) === name && (option === null || option === void 0 ? void 0 : option.value) === value);
+        });
+    });
+}
+export function getOptions(variants) {
+    const map = variants.reduce((memo, variant) => {
+        var _a;
+        if (!variant.selectedOptions) {
+            throw new Error(`getOptions requires 'variant.selectedOptions`);
+        }
+        (_a = variant === null || variant === void 0 ? void 0 : variant.selectedOptions) === null || _a === void 0 ? void 0 : _a.forEach((opt) => {
+            var _a, _b, _c, _d;
+            memo[(_a = opt === null || opt === void 0 ? void 0 : opt.name) !== null && _a !== void 0 ? _a : ''] = memo[(_b = opt === null || opt === void 0 ? void 0 : opt.name) !== null && _b !== void 0 ? _b : ''] || new Set();
+            memo[(_c = opt === null || opt === void 0 ? void 0 : opt.name) !== null && _c !== void 0 ? _c : ''].add((_d = opt === null || opt === void 0 ? void 0 : opt.value) !== null && _d !== void 0 ? _d : '');
+        });
+        return memo;
+    }, {});
+    return Object.keys(map).map((option) => {
+        return {
+            name: option,
+            values: Array.from(map[option]),
+        };
+    });
+}

package/dist/esnext/hooks/useProductOptions/index.d.ts

@@ -0,0 +1,2 @@
+export { useProductOptions } from './useProductOptions.client';
+export * from './types';

package/dist/esnext/hooks/useProductOptions/index.js

@@ -0,0 +1,2 @@
+export { useProductOptions } from './useProductOptions.client';
+export * from './types';

package/dist/esnext/hooks/useProductOptions/types.d.ts

@@ -0,0 +1,42 @@
+import type { SelectedOption as SelectedOptionType, ProductVariant as ProductVariantType, ProductVariantConnection, SellingPlan as SellingPlanType, SellingPlanAllocation as SellingPlanAllocationType, SellingPlanGroup as SellingPlanGroupType, SellingPlanConnection } from '../../storefront-api-types';
+export declare type SelectedOptions = {
+    [key: string]: string;
+};
+export declare type SelectVariantCallback = (variant: ProductVariantType) => void;
+export declare type SelectOptionCallback = (name: SelectedOptionType['name'], value: SelectedOptionType['value']) => void;
+export declare type SelectOptionsCallback = (options: SelectedOptions) => void;
+export declare type OptionsInStockCallback = (name: SelectedOptionType['name'], value: SelectedOptionType['value']) => boolean;
+export declare type SelectedSellingPlanCallback = (sellingPlan: SellingPlanType) => void;
+export interface OptionWithValues {
+    name: SelectedOptionType['name'];
+    values: SelectedOptionType['value'][];
+}
+export interface ProductOptionsHookValue {
+    /** An array of the variant `nodes` from the `VariantConnection`. */
+    variants: ProductVariantType[];
+    variantsConnection?: ProductVariantConnection;
+    /** An array of the product's options and values. */
+    options: OptionWithValues[];
+    /** The selected variant. */
+    selectedVariant?: ProductVariantType | null;
+    /** A callback to set the selected variant to the variant passed as an argument. */
+    setSelectedVariant: SelectVariantCallback;
+    selectedOptions: SelectedOptions;
+    /** A callback to set the selected option. */
+    setSelectedOption: SelectOptionCallback;
+    /** A callback to set multiple selected options at once. */
+    setSelectedOptions: SelectOptionsCallback;
+    /** A callback that returns a boolean indicating if the option is in stock. */
+    isOptionInStock: OptionsInStockCallback;
+    /** A callback to set the selected selling plan to the one passed as an argument. */
+    setSelectedSellingPlan: SelectedSellingPlanCallback;
+    /** The selected selling plan. */
+    selectedSellingPlan?: SellingPlanType;
+    /** The selected selling plan allocation. */
+    selectedSellingPlanAllocation?: SellingPlanAllocationType;
+    /** The selling plan groups. */
+    sellingPlanGroups?: (Omit<SellingPlanGroupType, 'sellingPlans'> & {
+        sellingPlans: SellingPlanType[];
+    })[];
+    sellingPlanGroupsConnection?: SellingPlanConnection;
+}

package/dist/esnext/hooks/useProductOptions/types.js

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

package/dist/esnext/hooks/useProductOptions/useProductOptions.client.d.ts

@@ -0,0 +1,15 @@
+import { ProductOptionsHookValue } from './types';
+import type { ProductVariantConnection, SellingPlanGroupConnection, ProductVariant as ProductVariantType } from '../../storefront-api-types';
+import type { PartialDeep } from 'type-fest';
+/**
+ * The `useProductOptions` hook returns an object that enables you to keep track of the
+ * selected variant and/or selling plan state, as well as callbacks for modifying the state.
+ */
+export declare function useProductOptions({ variants: variantsConnection, sellingPlanGroups: sellingPlanGroupsConnection, initialVariantId: explicitVariantId, }: {
+    /** The product's `VariantConnection`. */
+    variants?: PartialDeep<ProductVariantConnection>;
+    /** The product's `SellingPlanGroups`. */
+    sellingPlanGroups?: PartialDeep<SellingPlanGroupConnection>;
+    /** The initially selected variant. */
+    initialVariantId?: ProductVariantType['id'] | null;
+}): ProductOptionsHookValue;

package/dist/esnext/hooks/useProductOptions/useProductOptions.client.js

@@ -0,0 +1,108 @@
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { flattenConnection } from '../../utilities';
+import { getOptions, getSelectedVariant } from './helpers';
+/**
+ * The `useProductOptions` hook returns an object that enables you to keep track of the
+ * selected variant and/or selling plan state, as well as callbacks for modifying the state.
+ */
+export function useProductOptions({ variants: variantsConnection, sellingPlanGroups: sellingPlanGroupsConnection, initialVariantId: explicitVariantId, }) {
+    // The flattened variants
+    const variants = useMemo(() => (variantsConnection ? flattenConnection(variantsConnection) : []), [variantsConnection]);
+    // All the options available for a product, based on all the variants
+    const options = useMemo(() => getOptions(variants), [variants]);
+    // TODO: we have some weird variable shadowing going on here that probably needs to be looked at. This variable is the same name as a prop
+    const initialVariantId = explicitVariantId === null
+        ? explicitVariantId
+        : variants.find((variant) => variant.id === explicitVariantId) ||
+            variants.find((variant) => variant.availableForSale) ||
+            variants[0];
+    /**
+     * Track the selectedVariant within the hook. If `initialVariantId`
+     * is passed, use that as an initial value.
+     */
+    const [selectedVariant, setSelectedVariant] = useState(initialVariantId);
+    /**
+     * Track the selectedOptions within the hook. If a `initialVariantId`
+     * is passed, use that to select initial options.
+     */
+    const [selectedOptions, setSelectedOptions] = useState((selectedVariant === null || selectedVariant === void 0 ? void 0 : selectedVariant.selectedOptions)
+        ? selectedVariant.selectedOptions.reduce((memo, optionSet) => {
+            var _a, _b;
+            memo[(_a = optionSet === null || optionSet === void 0 ? void 0 : optionSet.name) !== null && _a !== void 0 ? _a : ''] = (_b = optionSet === null || optionSet === void 0 ? void 0 : optionSet.value) !== null && _b !== void 0 ? _b : '';
+            return memo;
+        }, {})
+        : {});
+    /**
+     * When the initialVariantId changes, we need to make sure we
+     * update the selected variant and selected options. If not,
+     * then the selected variant and options will reference incorrect
+     * values.
+     */
+    useEffect(() => {
+        const variant = getSelectedVariant(variants, selectedOptions);
+        setSelectedVariant(variant);
+    }, [selectedOptions, variants]);
+    /**
+     * Allow the developer to select an option.
+     */
+    const setSelectedOption = useCallback((name, value) => {
+        setSelectedOptions((selectedOptions) => ({
+            ...selectedOptions,
+            [name]: value,
+        }));
+    }, [setSelectedOptions]);
+    const isOptionInStock = useCallback((option, value) => {
+        var _a;
+        const proposedVariant = getSelectedVariant(variants, {
+            ...selectedOptions,
+            ...{ [option]: value },
+        });
+        return (_a = proposedVariant === null || proposedVariant === void 0 ? void 0 : proposedVariant.availableForSale) !== null && _a !== void 0 ? _a : true;
+    }, [selectedOptions, variants]);
+    const sellingPlanGroups = useMemo(() => sellingPlanGroupsConnection
+        ? flattenConnection(sellingPlanGroupsConnection).map((sellingPlanGroup) => ({
+            ...sellingPlanGroup,
+            sellingPlans: (sellingPlanGroup === null || sellingPlanGroup === void 0 ? void 0 : sellingPlanGroup.sellingPlans)
+                ? flattenConnection(sellingPlanGroup.sellingPlans)
+                : [],
+        }))
+        : [], [sellingPlanGroupsConnection]);
+    /**
+     * Track the selectedSellingPlan within the hook. If `initialSellingPlanId`
+     * is passed, use that as an initial value. Look it up from the `selectedVariant`, since
+     * that is also a requirement.
+     */
+    const [selectedSellingPlan, setSelectedSellingPlan] = useState(undefined);
+    const selectedSellingPlanAllocation = useMemo(() => {
+        if (!selectedVariant || !selectedSellingPlan) {
+            return;
+        }
+        if (!selectedVariant.sellingPlanAllocations) {
+            throw new Error(`You must include sellingPlanAllocations in your variants in order to calculate selectedSellingPlanAllocation`);
+        }
+        return flattenConnection(selectedVariant.sellingPlanAllocations).find(
+        // @ts-ignore The types here are broken on main, need to come back and fix them sometime
+        (allocation) => allocation.sellingPlan.id === selectedSellingPlan.id);
+    }, [selectedVariant, selectedSellingPlan]);
+    return {
+        // @ts-ignore The types here are broken on main, need to come back and fix them sometime
+        variants,
+        // @ts-ignore The types here are broken on main, need to come back and fix them sometime
+        variantsConnection,
+        options,
+        // @ts-ignore The types here are broken on main, need to come back and fix them sometime
+        selectedVariant,
+        setSelectedVariant,
+        selectedOptions,
+        setSelectedOption,
+        setSelectedOptions,
+        isOptionInStock,
+        selectedSellingPlan,
+        setSelectedSellingPlan,
+        selectedSellingPlanAllocation,
+        // @ts-ignore The types here are broken on main, need to come back and fix them sometime
+        sellingPlanGroups,
+        // @ts-ignore The types here are broken on main, need to come back and fix them sometime
+        sellingPlanGroupsConnection,
+    };
+}

package/dist/esnext/hooks/useShopQuery/hooks.d.ts

@@ -0,0 +1,28 @@
+import type { CachingStrategy, PreloadOptions } from '../../types';
+export interface UseShopQueryResponse<T> {
+    /** The data returned by the query. */
+    data: T;
+    errors: any;
+}
+/**
+ * The `useShopQuery` hook allows you to make server-only GraphQL queries to the Storefront API. It must be a descendent of a `ShopifyProvider` component.
+ */
+export declare function useShopQuery<T>({ query, variables, cache, preload, }: {
+    /** A string of the GraphQL query.
+     * If no query is provided, useShopQuery will make no calls to the Storefront API.
+     */
+    query?: string;
+    /** An object of the variables for the GraphQL query. */
+    variables?: Record<string, any>;
+    /** The [caching strategy](https://shopify.dev/custom-storefronts/hydrogen/framework/cache#caching-strategies) to
+     * help you determine which cache control header to set.
+     */
+    cache?: CachingStrategy;
+    /** A string corresponding to a valid locale identifier like `en-us` used to make the request. */
+    locale?: string;
+    /** Whether to[preload the query](https://shopify.dev/custom-storefronts/hydrogen/framework/preloaded-queries).
+     * Defaults to `false`. Specify `true` to preload the query for the URL or `'*'`
+     * to preload the query for all requests.
+     */
+    preload?: PreloadOptions;
+}): UseShopQueryResponse<T>;

package/dist/esnext/hooks/useShopQuery/hooks.js

@@ -0,0 +1,161 @@
+import { useShop } from '../../foundation/useShop';
+import { getLoggerWithContext } from '../../utilities/log';
+import { graphqlRequestBody } from '../../utilities';
+import { getConfig } from '../../framework/config';
+import { useServerRequest } from '../../foundation/ServerRequestProvider';
+import { injectGraphQLTracker } from '../../utilities/graphql-tracker';
+import { sendMessageToClient } from '../../utilities/devtools';
+import { fetchSync } from '../../foundation/fetchSync/server/fetchSync';
+import { META_ENV_SSR } from '../../foundation/ssr-interop';
+import { getStorefrontApiRequestHeaders } from '../../utilities/storefrontApi';
+import { parseJSON } from '../../utilities/parse';
+// Check if the response body has GraphQL errors
+// https://spec.graphql.org/June2018/#sec-Response-Format
+const shouldCacheResponse = ([body]) => {
+    var _a;
+    try {
+        return !((_a = parseJSON(body)) === null || _a === void 0 ? void 0 : _a.errors);
+    }
+    catch (_b) {
+        // If we can't parse the response, then assume
+        // an error and don't cache the response
+        return false;
+    }
+};
+/**
+ * The `useShopQuery` hook allows you to make server-only GraphQL queries to the Storefront API. It must be a descendent of a `ShopifyProvider` component.
+ */
+export function useShopQuery({ query, variables = {}, cache, preload = false, }) {
+    var _a;
+    /**
+     * If no query is passed, we no-op here to allow developers to obey the Rules of Hooks.
+     */
+    if (!query) {
+        return { data: undefined, errors: undefined };
+    }
+    if (!META_ENV_SSR) {
+        throw new Error('Shopify Storefront API requests should only be made from the server.');
+    }
+    const serverRequest = useServerRequest(); // eslint-disable-line react-hooks/rules-of-hooks
+    const log = getLoggerWithContext(serverRequest);
+    const body = query ? graphqlRequestBody(query, variables) : '';
+    const { url, requestInit } = useCreateShopRequest(body); // eslint-disable-line react-hooks/rules-of-hooks
+    let data;
+    let useQueryError;
+    try {
+        data = fetchSync(url, {
+            ...requestInit,
+            cache,
+            preload,
+            shouldCacheResponse,
+        }).json();
+    }
+    catch (error) {
+        // Pass-through thrown promise for Suspense functionality
+        if (error === null || error === void 0 ? void 0 : error.then) {
+            throw error;
+        }
+        useQueryError = error;
+    }
+    /**
+     * The fetch request itself failed, so we handle that differently than a GraphQL error
+     */
+    if (useQueryError) {
+        const errorMessage = createErrorMessage(useQueryError);
+        log.error(errorMessage);
+        log.error(useQueryError);
+        if (getConfig().dev) {
+            throw new Error(errorMessage);
+        }
+        else {
+            // in non-dev environments, we probably don't want super-detailed error messages for the user
+            throw new Error(`The fetch attempt failed; there was an issue connecting to the data source.`);
+        }
+    }
+    /**
+     * GraphQL errors get printed to the console but ultimately
+     * get returned to the consumer.
+     */
+    if (data === null || data === void 0 ? void 0 : data.errors) {
+        const errors = Array.isArray(data.errors) ? data.errors : [data.errors];
+        for (const error of errors) {
+            if (getConfig().dev) {
+                throw new Error(error.message);
+            }
+            else {
+                log.error('GraphQL Error', error);
+            }
+        }
+        log.error(`GraphQL errors: ${errors.length}`);
+    }
+    if (__DEV__ &&
+        log.options().showUnusedQueryProperties &&
+        query &&
+        (data === null || data === void 0 ? void 0 : data.data)) {
+        const fileLine = (_a = new Error('').stack) === null || _a === void 0 ? void 0 : _a.split('\n').find((line) => line.includes('.server.'));
+        const [, functionName, fileName] = (fileLine === null || fileLine === void 0 ? void 0 : fileLine.match(/^\s*at (\w+) \(([^)]+)\)/)) || [];
+        injectGraphQLTracker({
+            query,
+            data,
+            onUnusedData: ({ queryName, properties }) => {
+                const footer = `Examine the list of fields above to confirm that they are being used.\n`;
+                const header = `Potentially overfetching fields in GraphQL query.\n`;
+                let info = `Query \`${queryName}\``;
+                if (fileName) {
+                    info += ` in file \`${fileName}\` (function \`${functionName}\`)`;
+                }
+                const n = 6;
+                const shouldTrim = properties.length > n + 1;
+                const shownProperties = shouldTrim
+                    ? properties.slice(0, n)
+                    : properties;
+                const hiddenInfo = shouldTrim
+                    ? `  ...and ${properties.length - shownProperties.length} more\n`
+                    : '';
+                const warning = header +
+                    info +
+                    `:\n• ${shownProperties.join(`\n• `)}\n` +
+                    hiddenInfo +
+                    footer;
+                log.warn(warning);
+                sendMessageToClient({ type: 'warn', data: warning });
+            },
+        });
+    }
+    return data;
+}
+function useCreateShopRequest(body) {
+    const { storeDomain, storefrontToken, storefrontApiVersion } = useShop();
+    const request = useServerRequest();
+    const buyerIp = request.getBuyerIp();
+    const extraHeaders = getStorefrontApiRequestHeaders({
+        buyerIp,
+        storefrontToken,
+    });
+    return {
+        key: [storeDomain, storefrontApiVersion, body],
+        url: `https://${storeDomain}/api/${storefrontApiVersion}/graphql.json`,
+        requestInit: {
+            body,
+            method: 'POST',
+            headers: {
+                'X-SDK-Variant': 'hydrogen',
+                'X-SDK-Version': storefrontApiVersion,
+                'content-type': 'application/json',
+                ...extraHeaders,
+            },
+        },
+    };
+}
+function createErrorMessage(fetchError) {
+    if (fetchError instanceof Response) {
+        return `An error occurred while fetching from the Storefront API. ${
+        // 403s to the SF API (almost?) always mean that your Shopify credentials are bad/wrong
+        fetchError.status === 403
+            ? `You may have a bad value in 'hydrogen.config.js'`
+            : `${fetchError.statusText}`}`;
+    }
+    else {
+        return `Failed to connect to the Storefront API: ${fetchError.message}`;
+    }
+}

package/dist/esnext/hooks/useShopQuery/index.d.ts

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

package/dist/esnext/hooks/useShopQuery/index.js

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

package/dist/esnext/index.d.ts

@@ -0,0 +1,27 @@
+export * from './foundation/';
+export * from './components/';
+export * from './hooks/';
+export { flattenConnection, fetchBuilder, graphqlRequestBody, decodeShopifyId, isClient, getTime, } from './utilities';
+export { gql } from './utilities/graphql-tag';
+export { FileRoutes } from './foundation/FileRoutes/FileRoutes.server';
+export { Route } from './foundation/Route/Route.server';
+export { Router } from './foundation/Router/Router.server';
+export { log, setLogger, setLoggerOptions, Logger } from './utilities/log';
+export { useRouteParams } from './foundation/useRouteParams/useRouteParams';
+export { LocalizationProvider } from './components/LocalizationProvider/LocalizationProvider.server';
+export { ShopifyProvider } from './foundation/ShopifyProvider/ShopifyProvider.server';
+export * from './hooks/useShopQuery/hooks';
+export * from './foundation/useQuery/hooks';
+export * from './foundation/useServerProps';
+export { Head } from './foundation/Head';
+export { CartQuery } from './components/CartProvider/cart-queries';
+export { generateCacheControlHeader, NoStore, CacheSeconds, CacheMinutes, CacheHours, CacheDays, CacheWeeks, CacheMonths, CacheCustom, } from './framework/CachingStrategy';
+export { fetchSync } from './foundation/fetchSync/server/fetchSync';
+export { useServerAnalytics } from './foundation/Analytics';
+export * as PerformanceMetricsServerAnalyticsConnector from './foundation/Analytics/connectors/PerformanceMetrics/PerformanceMetrics.server';
+export { PerformanceMetrics } from './foundation/Analytics/connectors/PerformanceMetrics/PerformanceMetrics.client';
+export { PerformanceMetricsDebug } from './foundation/Analytics/connectors/PerformanceMetrics/PerformanceMetricsDebug.client';
+export { useSession } from './foundation/useSession/useSession';
+export { CookieSessionStorage } from './foundation/CookieSessionStorage/CookieSessionStorage';
+export { MemorySessionStorage } from './foundation/MemorySessionStorage/MemorySessionStorage';
+export { Cookie } from './foundation/Cookie/Cookie';

package/dist/esnext/index.js

@@ -0,0 +1,31 @@
+export * from './foundation/';
+export * from './components/';
+export * from './hooks/';
+export { flattenConnection, fetchBuilder, graphqlRequestBody, decodeShopifyId, isClient, getTime, } from './utilities';
+export { gql } from './utilities/graphql-tag';
+export { FileRoutes } from './foundation/FileRoutes/FileRoutes.server';
+export { Route } from './foundation/Route/Route.server';
+export { Router } from './foundation/Router/Router.server';
+export { log, setLogger, setLoggerOptions } from './utilities/log';
+export { useRouteParams } from './foundation/useRouteParams/useRouteParams';
+// This is exported here because it contains a Server Component
+export { LocalizationProvider } from './components/LocalizationProvider/LocalizationProvider.server';
+export { ShopifyProvider } from './foundation/ShopifyProvider/ShopifyProvider.server';
+// Exported here because users shouldn't be making `useShopQuery` calls from the client
+export * from './hooks/useShopQuery/hooks';
+export * from './foundation/useQuery/hooks';
+export * from './foundation/useServerProps';
+export { Head } from './foundation/Head';
+// Export server-only CartQuery here instead of `CartProvider.client` to prevent
+// it from being bundled with other client components
+export { CartQuery } from './components/CartProvider/cart-queries';
+export { generateCacheControlHeader, NoStore, CacheSeconds, CacheMinutes, CacheHours, CacheDays, CacheWeeks, CacheMonths, CacheCustom, } from './framework/CachingStrategy';
+export { fetchSync } from './foundation/fetchSync/server/fetchSync';
+export { useServerAnalytics } from './foundation/Analytics';
+export * as PerformanceMetricsServerAnalyticsConnector from './foundation/Analytics/connectors/PerformanceMetrics/PerformanceMetrics.server';
+export { PerformanceMetrics } from './foundation/Analytics/connectors/PerformanceMetrics/PerformanceMetrics.client';
+export { PerformanceMetricsDebug } from './foundation/Analytics/connectors/PerformanceMetrics/PerformanceMetricsDebug.client';
+export { useSession } from './foundation/useSession/useSession';
+export { CookieSessionStorage } from './foundation/CookieSessionStorage/CookieSessionStorage';
+export { MemorySessionStorage } from './foundation/MemorySessionStorage/MemorySessionStorage';
+export { Cookie } from './foundation/Cookie/Cookie';

package/dist/esnext/node.d.ts

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

package/dist/esnext/node.js

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

package/dist/esnext/platforms/node.d.ts

@@ -0,0 +1,9 @@
+import '../utilities/web-api-polyfill';
+import connect from 'connect';
+declare type CreateServerOptions = {
+    cache?: Cache;
+};
+export declare function createServer({ cache }?: CreateServerOptions): Promise<{
+    app: connect.Server;
+}>;
+export {};

package/dist/esnext/platforms/node.js

@@ -0,0 +1,40 @@
+import '../utilities/web-api-polyfill';
+import path from 'path';
+// @ts-ignore
+// eslint-disable-next-line node/no-missing-import
+import entrypoint from '__SERVER_ENTRY__';
+// @ts-ignore
+// eslint-disable-next-line node/no-missing-import
+import indexTemplate from '__INDEX_TEMPLATE__?raw';
+import { hydrogenMiddleware } from '../framework/middleware';
+// @ts-ignore
+import serveStatic from 'serve-static';
+// @ts-ignore
+import compression from 'compression';
+import bodyParser from 'body-parser';
+import connect from 'connect';
+const handleRequest = entrypoint;
+export async function createServer({ cache } = {}) {
+    // @ts-ignore
+    globalThis.Oxygen = { env: process.env };
+    const app = connect();
+    app.use(compression());
+    app.use(serveStatic(path.resolve(__dirname, '../client'), {
+        index: false,
+    }));
+    app.use(bodyParser.raw({ type: '*/*' }));
+    app.use(hydrogenMiddleware({
+        getServerEntrypoint: () => handleRequest,
+        indexTemplate,
+        cache,
+    }));
+    return { app };
+}
+if (require.main === module) {
+    createServer().then(({ app }) => {
+        const port = process.env.PORT || 8080;
+        app.listen(port, () => {
+            console.log(`Hydrogen server running at http://localhost:${port}`);
+        });
+    });
+}

package/dist/esnext/platforms/worker-event.d.ts

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

package/dist/esnext/platforms/worker-event.js

@@ -0,0 +1,3 @@
+import moduleEntry from './worker';
+// @ts-ignore
+addEventListener('fetch', (event) => event.respondWith(moduleEntry.fetch(event.request, globalThis, event)));

package/dist/esnext/platforms/worker.d.ts

@@ -0,0 +1,14 @@
+declare global {
+    var globalThis: {
+        Oxygen: {
+            env: any;
+        };
+        [key: string]: any;
+    };
+}
+declare const _default: {
+    fetch(request: Request, env: unknown, context: {
+        waitUntil: (promise: Promise<any>) => void;
+    }): Promise<Response>;
+};
+export default _default;

package/dist/esnext/platforms/worker.js

@@ -0,0 +1,25 @@
+// @ts-ignore
+// eslint-disable-next-line node/no-missing-import
+import entrypoint from '__SERVER_ENTRY__';
+// @ts-ignore
+// eslint-disable-next-line node/no-missing-import
+import indexTemplate from '__INDEX_TEMPLATE__?raw';
+const handleRequest = entrypoint;
+export default {
+    async fetch(request, env, context) {
+        if (!globalThis.Oxygen) {
+            globalThis.Oxygen = { env };
+        }
+        try {
+            return (await handleRequest(request, {
+                indexTemplate,
+                cache: await caches.open('oxygen'),
+                context,
+                buyerIpHeader: 'oxygen-buyer-ip',
+            }));
+        }
+        catch (error) {
+            return new Response(error.message || error.toString(), { status: 500 });
+        }
+    },
+};