@shopify/hydrogen 0.13.1 → 0.15.0

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

@@ -14,34 +14,39 @@ export function ServerStateProvider({ serverState, setServerState, children, })
          * the `pending` flag also provided by the hook to display in the UI.
          */
         startTransition(() => {
-            return setServerState((prev) => {
-                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,
-                };
-            });
+            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 (__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, setServerStateCallback, pending]);
     return (React.createElement(ServerStateContext.Provider, { value: value }, children));
 }

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

@@ -4,8 +4,11 @@ import { DEFAULT_LOCALE } from '../constants';
 import { useServerRequest } from '../ServerRequestProvider';
 function makeShopifyContext(shopifyConfig) {
     var _a, _b;
+    const locale = (_a = shopifyConfig.defaultLocale) !== null && _a !== void 0 ? _a : DEFAULT_LOCALE;
+    const languageCode = locale.split(/[-_]/)[0];
     return {
-        locale: (_a = shopifyConfig.defaultLocale) !== null && _a !== void 0 ? _a : DEFAULT_LOCALE,
+        locale: locale.toUpperCase(),
+        languageCode: languageCode.toUpperCase(),
         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,

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

@@ -1,11 +1,10 @@
+import type { CountryCode, LanguageCode } from '../../storefront-api-types';
 import type { ReactNode } from 'react';
 import type { ShopifyConfig } from '../../types';
-export declare type ShopifyContextValue = {
-    locale: string;
-    storeDomain: ShopifyConfig['storeDomain'];
-    storefrontToken: ShopifyConfig['storefrontToken'];
-    storefrontApiVersion: string;
-};
+export interface ShopifyContextValue extends Omit<ShopifyConfig, 'defaultLocale'> {
+    locale: `${LanguageCode}-${CountryCode}`;
+    languageCode: `${LanguageCode}`;
+}
 export declare type ShopifyProviderProps = {
     /** The contents of the `shopify.config.js` file. */
     shopifyConfig: ShopifyConfig;

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

@@ -1 +1 @@
-export declare const DEFAULT_LOCALE = "en-us";
+export declare const DEFAULT_LOCALE = "EN-US";

package/dist/esnext/foundation/constants.js

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

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

@@ -0,0 +1,10 @@
+import type { FetchResponse } from '../types';
+/**
+ * Fetch a URL for use in a client component Suspense boundary.
+ */
+export declare function fetchSync(url: string, options?: RequestInit): FetchResponse;
+/**
+ * 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

@@ -0,0 +1,27 @@
+import { suspendFunction, preloadFunction } from '../../../utilities/suspense';
+/**
+ * Fetch a URL for use in a client component Suspense boundary.
+ */
+export function fetchSync(url, options) {
+    const [text, response] = suspendFunction([url, options], async () => {
+        const response = await globalThis.fetch(url, options);
+        const text = await response.text();
+        return [text, response];
+    });
+    return {
+        response,
+        json: () => JSON.parse(text),
+        text: () => text,
+    };
+}
+/**
+ * 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

@@ -0,0 +1,8 @@
+import { type HydrogenUseQueryOptions } from '../../useQuery/hooks';
+import type { FetchResponse } from '../types';
+/**
+ * The `fetchSync` hook makes third-party API requests and is the recommended way to make simple fetch calls on the server.
+ * 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(url: string, options?: Omit<RequestInit, 'cache'> & HydrogenUseQueryOptions): FetchResponse;

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

@@ -0,0 +1,27 @@
+import { useQuery } from '../../useQuery/hooks';
+/**
+ * The `fetchSync` hook makes third-party API requests and is the recommended way to make simple fetch calls on the server.
+ * 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 function fetchSync(url, options) {
+    const { cache, preload, shouldCacheResponse, ...requestInit } = options !== null && options !== void 0 ? options : {};
+    const { data: useQueryResponse, error } = useQuery([url, requestInit], async () => {
+        const response = await globalThis.fetch(url, requestInit);
+        const text = await response.text();
+        return [text, response];
+    }, {
+        cache,
+        preload,
+        shouldCacheResponse,
+    });
+    if (error) {
+        throw error;
+    }
+    const [data, response] = useQueryResponse;
+    return {
+        response,
+        json: () => JSON.parse(data),
+        text: () => data,
+    };
+}

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

@@ -0,0 +1,5 @@
+export interface FetchResponse {
+    response: Response;
+    json: () => any;
+    text: () => any;
+}

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

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

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

@@ -15,9 +15,11 @@ export interface HydrogenUseQueryOptions {
 }
 /**
  * The `useQuery` hook executes an asynchronous operation like `fetch` in a way that
- * supports [Suspense](https://reactjs.org/docs/concurrent-mode-suspense.html). It's based
- * on [react-query](https://react-query.tanstack.com/reference/useQuery). You can use this
+ * supports [Suspense](https://reactjs.org/docs/concurrent-mode-suspense.html). You can use this
  * hook to call any third-party APIs from a server component.
+ *
+ * \> Note:
+ * \> If you're making a simple fetch call on the server, then we recommend using the [`fetchSync`](/api/hydrogen/hooks/global/fetchsync) hook instead.
  */
 export declare function useQuery<T>(
 /** A string or array to uniquely identify the current query. */

package/dist/esnext/foundation/useQuery/hooks.js

@@ -1,12 +1,15 @@
-import { getLoggerWithContext, collectQueryCacheControlHeaders, collectQueryTimings, } from '../../utilities/log';
+import { getLoggerWithContext, collectQueryCacheControlHeaders, collectQueryTimings, logCacheApiStatus, } from '../../utilities/log';
 import { deleteItemFromCache, generateSubRequestCacheControlHeader, getItemFromCache, isStale, setItemInCache, } from '../../framework/cache';
+import { hashKey } from '../../utilities/hash';
 import { runDelayedFunction } from '../../framework/runtime';
 import { useRequestCacheData, useServerRequest } from '../ServerRequestProvider';
 /**
  * The `useQuery` hook executes an asynchronous operation like `fetch` in a way that
- * supports [Suspense](https://reactjs.org/docs/concurrent-mode-suspense.html). It's based
- * on [react-query](https://react-query.tanstack.com/reference/useQuery). You can use this
+ * supports [Suspense](https://reactjs.org/docs/concurrent-mode-suspense.html). You can use this
  * hook to call any third-party APIs from a server component.
+ *
+ * \> Note:
+ * \> If you're making a simple fetch call on the server, then we recommend using the [`fetchSync`](/api/hydrogen/hooks/global/fetchsync) hook instead.
  */
 export function useQuery(
 /** A string or array to uniquely identify the current query. */
@@ -45,6 +48,7 @@ function cachedQueryFnBuilder(key, queryFn, queryOptions) {
         // to prevent losing the current React cycle.
         const request = useServerRequest();
         const log = getLoggerWithContext(request);
+        const hashedKey = hashKey(key);
         const cacheResponse = await getItemFromCache(key);
         async function generateNewOutput() {
             return await queryFn();
@@ -55,11 +59,11 @@ function cachedQueryFnBuilder(key, queryFn, queryOptions) {
             /**
              * Important: Do this async
              */
-            if (isStale(response)) {
-                log.debug('[useQuery] cache stale; generating new response in background');
+            if (isStale(response, resolvedQueryOptions === null || resolvedQueryOptions === void 0 ? void 0 : resolvedQueryOptions.cache)) {
+                logCacheApiStatus('STALE', hashedKey);
                 const lockKey = `lock-${key}`;
                 runDelayedFunction(async () => {
-                    log.debug(`[stale regen] fetching cache lock`);
+                    logCacheApiStatus('UPDATING', hashedKey);
                     const lockExists = await getItemFromCache(lockKey);
                     if (lockExists)
                         return;

package/dist/esnext/framework/Hydration/ServerComponentRequest.server.d.ts

@@ -34,6 +34,7 @@ export declare class ServerComponentRequest extends Request {
         queryCacheControl: Array<QueryCacheControlHeaders>;
         queryTimings: Array<QueryTiming>;
         preloadQueries: PreloadQueriesByURL;
+        analyticsData: any;
         router: RouterContextData;
         buyerIpHeader?: string;
         [key: string]: any;

package/dist/esnext/framework/Hydration/ServerComponentRequest.server.js

@@ -1,5 +1,5 @@
 import { getTime } from '../../utilities/timing';
-import { hashKey } from '../cache';
+import { hashKey } from '../../utilities/hash';
 import { HelmetData as HeadData } from 'react-helmet-async';
 import { RSC_PATHNAME } from '../../constants';
 let reqCounter = 0; // For debugging
@@ -27,8 +27,11 @@ export class ServerComponentRequest extends Request {
         else {
             super(getUrlFromNodeRequest(input), getInitFromNodeRequest(input));
         }
+        const referer = this.headers.get('referer');
         this.time = getTime();
         this.id = generateId();
+        this.preloadURL =
+            this.isRscRequest() && referer && referer !== '' ? referer : this.url;
         this.ctx = {
             cache: new Map(),
             head: new HeadData({}),
@@ -39,18 +42,21 @@ export class ServerComponentRequest extends Request {
             },
             queryCacheControl: [],
             queryTimings: [],
+            analyticsData: {
+                url: this.url,
+                normalizedRscUrl: this.preloadURL,
+            },
             preloadQueries: new Map(),
         };
         this.cookies = this.parseCookies();
-        const referer = this.headers.get('referer');
-        this.preloadURL =
-            this.isRscRequest() && referer && referer !== '' ? referer : this.url;
     }
     parseCookies() {
         const cookieString = this.headers.get('cookie') || '';
         return new Map(cookieString
             .split(';')
-            .map((chunk) => chunk.trim().split(/=(.+)/)));
+            .map((chunk) => chunk.trim())
+            .filter((chunk) => chunk !== '')
+            .map((chunk) => chunk.split(/=(.+)/)));
     }
     isRscRequest() {
         const url = new URL(this.url);
@@ -123,8 +129,9 @@ function getInitFromNodeRequest(request) {
             ? request.body
             : undefined,
     };
-    if (!init.headers.has('x-forwarded-for')) {
-        init.headers.set('x-forwarded-for', request.socket.remoteAddress);
+    const remoteAddress = request.socket.remoteAddress;
+    if (!init.headers.has('x-forwarded-for') && remoteAddress) {
+        init.headers.set('x-forwarded-for', remoteAddress);
     }
     return init;
 }

package/dist/esnext/framework/cache/in-memory.js

@@ -8,7 +8,7 @@ export class InMemoryCache {
         this.store = new Map();
     }
     put(request, response) {
-        logCacheApiStatus('PUT', request.url);
+        logCacheApiStatus('PUT-dev', request.url);
         this.store.set(request.url, {
             value: response,
             date: new Date(),
@@ -18,7 +18,7 @@ export class InMemoryCache {
         var _a, _b;
         const match = this.store.get(request.url);
         if (!match) {
-            logCacheApiStatus('MISS', request.url);
+            logCacheApiStatus('MISS-dev', request.url);
             return;
         }
         const { value, date } = match;
@@ -28,7 +28,7 @@ export class InMemoryCache {
         const age = (new Date().valueOf() - date.valueOf()) / 1000;
         const isMiss = age > maxAge + swr;
         if (isMiss) {
-            logCacheApiStatus('MISS', request.url);
+            logCacheApiStatus('MISS-dev', request.url);
             this.store.delete(request.url);
             return;
         }
@@ -36,7 +36,7 @@ export class InMemoryCache {
         const headers = new Headers(value.headers);
         headers.set('cache', isStale ? 'STALE' : 'HIT');
         headers.set('date', date.toUTCString());
-        logCacheApiStatus(headers.get('cache'), request.url);
+        logCacheApiStatus(`${headers.get('cache')}-dev`, request.url);
         const response = new Response(value.body, {
             headers,
         });
@@ -44,7 +44,7 @@ export class InMemoryCache {
     }
     delete(request) {
         this.store.delete(request.url);
-        logCacheApiStatus('DELETE', request.url);
+        logCacheApiStatus('DELETE-dev', request.url);
     }
     keys(request) {
         const cacheKeys = [];

package/dist/esnext/framework/cache.d.ts

@@ -1,14 +1,5 @@
 import type { QueryKey, CachingStrategy } from '../types';
 export declare function generateSubRequestCacheControlHeader(userCacheOptions?: CachingStrategy): string;
-/**
- * Use a preview header during development.
- * TODO: Support an override of this to force the cache
- * header to be present during dev. ENV var maybe?
- */
-export declare function getCacheControlHeader({ dev }: {
-    dev?: boolean;
-}): "cache-control-preview" | "cache-control";
-export declare function hashKey(key: QueryKey): string;
 /**
  * Get an item from the cache. If a match is found, returns a tuple
  * containing the `JSON.parse` version of the response as well
@@ -23,4 +14,4 @@ export declare function deleteItemFromCache(key: QueryKey): Promise<void>;
 /**
  * Manually check the response to see if it's stale.
  */
-export declare function isStale(response: Response): boolean;
+export declare function isStale(response: Response, userCacheOptions?: CachingStrategy): boolean;

package/dist/esnext/framework/cache.js

@@ -1,22 +1,20 @@
 import { getCache } from './runtime';
 import { CacheSeconds, generateCacheControlHeader, } from '../framework/CachingStrategy';
-export function generateSubRequestCacheControlHeader(userCacheOptions) {
-    return generateCacheControlHeader(userCacheOptions || CacheSeconds());
-}
-/**
- * Use a preview header during development.
- * TODO: Support an override of this to force the cache
- * header to be present during dev. ENV var maybe?
- */
-export function getCacheControlHeader({ dev }) {
-    return dev ? 'cache-control-preview' : 'cache-control';
+import { hashKey } from '../utilities/hash';
+import { logCacheApiStatus } from '../utilities/log';
+function getCacheControlSetting(userCacheOptions, options) {
+    if (userCacheOptions && options) {
+        return {
+            ...userCacheOptions,
+            ...options,
+        };
+    }
+    else {
+        return userCacheOptions || CacheSeconds();
+    }
 }
-export function hashKey(key) {
-    const rawKey = key instanceof Array ? key : [key];
-    /**
-     * TODO: Smarter hash
-     */
-    return rawKey.map((k) => JSON.stringify(k)).join('');
+export function generateSubRequestCacheControlHeader(userCacheOptions) {
+    return generateCacheControlHeader(getCacheControlSetting(userCacheOptions));
 }
 /**
  * Cache API is weird. We just need a full URL, so we make one up.
@@ -37,8 +35,11 @@ export async function getItemFromCache(key) {
     const url = getKeyUrl(hashKey(key));
     const request = new Request(url);
     const response = await cache.match(request);
-    if (!response)
+    if (!response) {
+        logCacheApiStatus('MISS', url);
         return;
+    }
+    logCacheApiStatus('HIT', url);
     return [await response.json(), response];
 }
 /**
@@ -51,14 +52,53 @@ export async function setItemInCache(key, value, userCacheOptions) {
     }
     const url = getKeyUrl(hashKey(key));
     const request = new Request(url);
+    /**
+     * We are manually managing staled request by adding this workaround.
+     * Why? cache control header support is dependent on hosting platform
+     *
+     * For example:
+     *
+     * Cloudflare's Cache API does not support `stale-while-revalidate`.
+     * Cloudflare cache control header has a very odd behaviour.
+     * Say we have the following cache control header on a request:
+     *
+     *   public, max-age=15, stale-while-revalidate=30
+     *
+     * When there is a cache.match HIT, the cache control header would become
+     *
+     *   public, max-age=14400, stale-while-revalidate=30
+     *
+     * == `stale-while-revalidate` workaround ==
+     * Update response max-age so that:
+     *
+     *   max-age = max-age + stale-while-revalidate
+     *
+     * For example:
+     *
+     *   public, max-age=1, stale-while-revalidate=9
+     *                    |
+     *                    V
+     *   public, max-age=10, stale-while-revalidate=9
+     *
+     * Store the following information in the response header:
+     *
+     *   cache-put-date   - UTC time string of when this request is PUT into cache
+     *
+     * Note on `cache-put-date`: The `response.headers.get('date')` isn't static. I am
+     * not positive what date this is returning but it is never over 500 ms
+     * after subtracting from the current timestamp.
+     *
+     * `isStale` function will use the above information to test for stale-ness of a cached response
+     */
+    const cacheControl = getCacheControlSetting(userCacheOptions);
     const headers = new Headers({
-        'cache-control': generateSubRequestCacheControlHeader(userCacheOptions),
+        'cache-control': generateSubRequestCacheControlHeader(getCacheControlSetting(cacheControl, {
+            maxAge: (cacheControl.maxAge || 0) + (cacheControl.staleWhileRevalidate || 0),
+        })),
+        'cache-put-date': new Date().toUTCString(),
     });
     const response = new Response(JSON.stringify(value), { headers });
-    /**
-     * WARNING: Cloudflare's Cache API does not support `stale-while-revalidate`
-     * so this implementation will not work as expected on that platform.
-     */
+    logCacheApiStatus('PUT', url);
     await cache.put(request, response);
 }
 export async function deleteItemFromCache(key) {
@@ -67,20 +107,17 @@ export async function deleteItemFromCache(key) {
         return;
     const url = getKeyUrl(hashKey(key));
     const request = new Request(url);
+    logCacheApiStatus('DELETE', url);
     await cache.delete(request);
 }
 /**
  * Manually check the response to see if it's stale.
  */
-export function isStale(response) {
-    const responseDate = response.headers.get('date');
-    const responseCacheControl = response.headers.get('cache-control');
-    if (!responseDate || !responseCacheControl)
-        return false;
-    const responseMaxAgeMatch = responseCacheControl.match(/max-age=(\d+)/);
-    if (!responseMaxAgeMatch)
+export function isStale(response, userCacheOptions) {
+    const responseMaxAge = getCacheControlSetting(userCacheOptions).maxAge || 0;
+    const responseDate = response.headers.get('cache-put-date');
+    if (!responseDate)
         return false;
-    const responseMaxAge = parseInt(responseMaxAgeMatch[1]);
     const ageInMs = new Date().valueOf() - new Date(responseDate).valueOf();
     const age = ageInMs / 1000;
     return age > responseMaxAge;

package/dist/esnext/framework/plugin.js

@@ -12,6 +12,15 @@ import react from '@vitejs/plugin-react';
 import path from 'path';
 import cssModulesRsc from './plugins/vite-plugin-css-modules-rsc';
 export default (shopifyConfig, pluginOptions = {}) => {
+    let hydrogenUiPath;
+    try {
+        hydrogenUiPath = path.join(
+        // eslint-disable-next-line node/no-missing-require
+        path.dirname(require.resolve('@shopify/hydrogen-ui/client')));
+    }
+    catch (error) {
+        // hydrogen-ui isn't installed, so don't worry about it
+    }
     return [
         process.env.VITE_INSPECT && inspect(),
         hydrogenConfig(),
@@ -24,6 +33,7 @@ export default (shopifyConfig, pluginOptions = {}) => {
         rsc({
             clientComponentPaths: [
                 path.join(path.dirname(require.resolve('@shopify/hydrogen/package.json'))),
+                ...[hydrogenUiPath].filter(Boolean),
             ],
             isServerComponentImporterAllowed(importer, source) {
                 // Always allow the entry server (e.g. App.server.jsx) to be imported

package/dist/esnext/framework/plugins/vite-plugin-css-modules-rsc.js

@@ -20,7 +20,7 @@ export default function cssModulesRsc() {
             enforce: 'post',
             transform(code, id) {
                 if (id.includes('.module.') && cssMap.has(id)) {
-                    return code.replace(/export default .*$/gms, `import React from 'react'; export const StyleTag = () => React.createElement('style', {}, \`${cssMap.get(id)}\`);`);
+                    return code.replace(/export default .*$/gms, `import React from 'react'; export const StyleTag = () => React.createElement('style', {dangerouslySetInnerHTML: {__html: ${JSON.stringify(cssMap.get(id))}}});`);
                 }
             },
         },

package/dist/esnext/framework/plugins/vite-plugin-hydrogen-config.js

@@ -36,11 +36,18 @@ export default () => {
                 // Reload when updating local Hydrogen lib
                 server: process.env.LOCAL_DEV && {
                     watch: {
-                        ignored: ['!**/node_modules/@shopify/hydrogen/**'],
+                        ignored: [
+                            '!**/node_modules/@shopify/hydrogen/**',
+                            '!**/node_modules/@shopify/hydrogen-ui/**',
+                        ],
                     },
                 },
                 optimizeDeps: {
-                    exclude: ['@shopify/hydrogen/client', '@shopify/hydrogen/entry-client'],
+                    exclude: [
+                        '@shopify/hydrogen/client',
+                        '@shopify/hydrogen/entry-client',
+                        '@shopify/hydrogen-ui',
+                    ],
                     include: [
                         /**
                          * Additionally, the following dependencies have trouble loading the

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

@@ -15,7 +15,7 @@ metafields?: PartialDeep<MetafieldConnection>): {
     key?: string | undefined;
     namespace?: string | undefined;
     parentResource?: import("type-fest/source/partial-deep").PartialObjectDeep<import("../../storefront-api-types").ProductVariant> | import("type-fest/source/partial-deep").PartialObjectDeep<import("../../storefront-api-types").Product> | import("type-fest/source/partial-deep").PartialObjectDeep<import("../../storefront-api-types").Blog> | import("type-fest/source/partial-deep").PartialObjectDeep<import("../../storefront-api-types").Article> | import("type-fest/source/partial-deep").PartialObjectDeep<import("../../storefront-api-types").Customer> | import("type-fest/source/partial-deep").PartialObjectDeep<import("../../storefront-api-types").Order> | import("type-fest/source/partial-deep").PartialObjectDeep<import("../../storefront-api-types").Collection> | import("type-fest/source/partial-deep").PartialObjectDeep<import("../../storefront-api-types").Page> | import("type-fest/source/partial-deep").PartialObjectDeep<import("../../storefront-api-types").Shop> | undefined;
-    reference?: import("type-fest/source/partial-deep").PartialObjectDeep<import("../../storefront-api-types").MediaImage> | import("type-fest/source/partial-deep").PartialObjectDeep<import("../../storefront-api-types").ProductVariant> | import("type-fest/source/partial-deep").PartialObjectDeep<import("../../storefront-api-types").Product> | import("type-fest/source/partial-deep").PartialObjectDeep<import("../../storefront-api-types").Page> | null | undefined;
+    reference?: import("type-fest/source/partial-deep").PartialObjectDeep<import("../../storefront-api-types").Video> | import("type-fest/source/partial-deep").PartialObjectDeep<import("../../storefront-api-types").MediaImage> | import("type-fest/source/partial-deep").PartialObjectDeep<import("../../storefront-api-types").ProductVariant> | import("type-fest/source/partial-deep").PartialObjectDeep<import("../../storefront-api-types").Product> | import("type-fest/source/partial-deep").PartialObjectDeep<import("../../storefront-api-types").Page> | import("type-fest/source/partial-deep").PartialObjectDeep<import("../../storefront-api-types").GenericFile> | null | undefined;
     type?: string | undefined;
     updatedAt?: string | undefined;
 }[];

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

@@ -8,7 +8,7 @@ export interface UseShopQueryResponse<T> {
 /**
  * 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, locale, preload, }: {
+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.
      */