@shopify/hydrogen 0.22.1 → 0.25.0

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

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

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

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

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

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

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

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

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

@@ -1,8 +1,7 @@
 import { getLoggerWithContext, collectQueryCacheControlHeaders, collectQueryTimings, } from '../../utilities/log';
-import { deleteItemFromCache, generateSubRequestCacheControlHeader, getItemFromCache, isStale, setItemInCache, } from '../../framework/cache-sub-request';
-import { runDelayedFunction } from '../../framework/runtime';
+import { deleteItemFromCache, generateSubRequestCacheControlHeader, getItemFromCache, isStale, setItemInCache, } from '../Cache/cache-sub-request';
 import { useRequestCacheData, useServerRequest } from '../ServerRequestProvider';
-import { CacheSeconds } from '../../framework/CachingStrategy';
+import { CacheShort, NO_STORE } from '../Cache/strategies';
 /**
  * The `useQuery` hook executes an asynchronous operation like `fetch` in a way that
  * supports [Suspense](https://reactjs.org/docs/concurrent-mode-suspense.html). You can use this
@@ -25,21 +24,33 @@ queryOptions) {
     ];
     const fetcher = cachedQueryFnBuilder(withCacheIdKey, queryFn, queryOptions);
     collectQueryTimings(request, withCacheIdKey, 'requested');
-    if (queryOptions === null || queryOptions === void 0 ? void 0 : queryOptions.preload) {
+    if (shouldPreloadQuery(queryOptions)) {
         request.savePreloadQuery({
-            preload: queryOptions === null || queryOptions === void 0 ? void 0 : queryOptions.preload,
+            preload: queryOptions?.preload,
             key: withCacheIdKey,
             fetcher,
         });
     }
     return useRequestCacheData(withCacheIdKey, fetcher);
 }
-function cachedQueryFnBuilder(key, queryFn, queryOptions) {
-    var _a;
+export function shouldPreloadQuery(queryOptions) {
+    if (!queryOptions)
+        return true;
+    const hasCacheOverride = typeof queryOptions?.cache?.mode !== 'undefined';
+    const hasPreloadOverride = typeof queryOptions?.preload !== 'undefined';
+    const cacheValue = queryOptions?.cache?.mode;
+    const preloadValue = queryOptions?.preload;
+    // If preload is explicitly defined, then it takes precedence
+    if (hasPreloadOverride) {
+        return !!preloadValue;
+    }
+    return hasCacheOverride ? cacheValue !== NO_STORE : true;
+}
+function cachedQueryFnBuilder(key, generateNewOutput, queryOptions) {
     const resolvedQueryOptions = {
-        ...(queryOptions !== null && queryOptions !== void 0 ? queryOptions : {}),
+        ...(queryOptions ?? {}),
     };
-    const shouldCacheResponse = (_a = queryOptions === null || queryOptions === void 0 ? void 0 : queryOptions.shouldCacheResponse) !== null && _a !== void 0 ? _a : (() => true);
+    const shouldCacheResponse = queryOptions?.shouldCacheResponse ?? (() => true);
     /**
      * Attempt to read the query from cache. If it doesn't exist or if it's stale, regenerate it.
      */
@@ -49,9 +60,6 @@ function cachedQueryFnBuilder(key, queryFn, queryOptions) {
         const request = useServerRequest();
         const log = getLoggerWithContext(request);
         const cacheResponse = await getItemFromCache(key);
-        async function generateNewOutput() {
-            return await queryFn();
-        }
         if (cacheResponse) {
             const [output, response] = cacheResponse;
             collectQueryCacheControlHeaders(request, key, response.headers.get('cache-control'));
@@ -60,17 +68,17 @@ function cachedQueryFnBuilder(key, queryFn, queryOptions) {
              */
             if (isStale(key, response)) {
                 const lockKey = ['lock', ...(typeof key === 'string' ? [key] : key)];
-                runDelayedFunction(async () => {
-                    const lockExists = await getItemFromCache(lockKey);
+                // Run revalidation asynchronously
+                const revalidatingPromise = getItemFromCache(lockKey).then(async (lockExists) => {
                     if (lockExists)
                         return;
-                    await setItemInCache(lockKey, true, CacheSeconds({
+                    await setItemInCache(lockKey, true, CacheShort({
                         maxAge: 10,
                     }));
                     try {
                         const output = await generateNewOutput();
                         if (shouldCacheResponse(output)) {
-                            await setItemInCache(key, output, resolvedQueryOptions === null || resolvedQueryOptions === void 0 ? void 0 : resolvedQueryOptions.cache);
+                            await setItemInCache(key, output, resolvedQueryOptions?.cache);
                         }
                     }
                     catch (e) {
@@ -80,6 +88,8 @@ function cachedQueryFnBuilder(key, queryFn, queryOptions) {
                         await deleteItemFromCache(lockKey);
                     }
                 });
+                // Asynchronously wait for it in workers
+                request.ctx.runtime?.waitUntil?.(revalidatingPromise);
             }
             return output;
         }
@@ -88,9 +98,10 @@ function cachedQueryFnBuilder(key, queryFn, queryOptions) {
          * Important: Do this async
          */
         if (shouldCacheResponse(newOutput)) {
-            runDelayedFunction(() => setItemInCache(key, newOutput, resolvedQueryOptions === null || resolvedQueryOptions === void 0 ? void 0 : resolvedQueryOptions.cache));
+            const setItemInCachePromise = setItemInCache(key, newOutput, resolvedQueryOptions?.cache);
+            request.ctx.runtime?.waitUntil?.(setItemInCachePromise);
         }
-        collectQueryCacheControlHeaders(request, key, generateSubRequestCacheControlHeader(resolvedQueryOptions === null || resolvedQueryOptions === void 0 ? void 0 : resolvedQueryOptions.cache));
+        collectQueryCacheControlHeaders(request, key, generateSubRequestCacheControlHeader(resolvedQueryOptions?.cache));
         return newOutput;
     }
     return useCachedQueryFn;

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

@@ -0,0 +1,15 @@
+declare type ScopedContext = Record<string, any>;
+/**
+ * Provides access to the current request context.
+ * @param scope - An optional string used to scope the request context. It is recommended to
+ * prevent modifying the properties added by other plugins.
+ * @returns A request-scoped object that can be modified to provide and consume information
+ * across different React components in the tree.
+ * @example
+ * ```js
+ * import {useRequestContext} from '@shopify/hydrogen';
+ * useRequestContext('my-plugin-name');
+ * ```
+ */
+export declare function useRequestContext<T extends ScopedContext>(scope?: string): T;
+export {};

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

@@ -0,0 +1,23 @@
+import { META_ENV_SSR, useEnvContext } from '../ssr-interop';
+/**
+ * Provides access to the current request context.
+ * @param scope - An optional string used to scope the request context. It is recommended to
+ * prevent modifying the properties added by other plugins.
+ * @returns A request-scoped object that can be modified to provide and consume information
+ * across different React components in the tree.
+ * @example
+ * ```js
+ * import {useRequestContext} from '@shopify/hydrogen';
+ * useRequestContext('my-plugin-name');
+ * ```
+ */
+export function useRequestContext(scope = 'default') {
+    if (__HYDROGEN_DEV__ && !META_ENV_SSR) {
+        throw new Error('useRequestContext can only be used in the server');
+    }
+    const scopes = useEnvContext((req) => req.ctx.scopes);
+    if (!scopes.has(scope)) {
+        scopes.set(scope, Object.create(null));
+    }
+    return scopes.get(scope);
+}

package/dist/esnext/foundation/useServerProps/use-server-props.js

@@ -30,6 +30,6 @@ export function useServerProps() {
  * @internal
  */
 export function useInternalServerProps() {
-    var _a;
-    return ((_a = useContext(ServerPropsContext)) !== null && _a !== void 0 ? _a : {});
+    return (useContext(ServerPropsContext) ??
+        {});
 }

package/dist/esnext/foundation/useSession/useSession.js

@@ -1,8 +1,7 @@
 import { useServerRequest } from '../ServerRequestProvider';
 /** The `useSession` hook reads session data in server components. */
 export const useSession = function () {
-    var _a;
     const request = useServerRequest();
-    const session = ((_a = request.ctx.session) === null || _a === void 0 ? void 0 : _a.get()) || {};
+    const session = request.ctx.session?.get() || {};
     return session;
 };

package/dist/esnext/foundation/useUrl/useUrl.js

@@ -7,13 +7,12 @@ import { useEnvContext, META_ENV_SSR } from '../ssr-interop';
  * The `useUrl` hook retrieves the current URL in a server or client component.
  */
 export function useUrl() {
-    var _a, _b;
     if (META_ENV_SSR) {
         const serverUrl = new URL(useEnvContext((req) => req.url) // eslint-disable-line react-hooks/rules-of-hooks
         );
         if (serverUrl.pathname === RSC_PATHNAME) {
             const state = parseJSON(serverUrl.searchParams.get('state') || '{}');
-            const parsedUrl = `${serverUrl.origin}${(_a = state.pathname) !== null && _a !== void 0 ? _a : ''}${(_b = state.search) !== null && _b !== void 0 ? _b : ''}`;
+            const parsedUrl = `${serverUrl.origin}${state.pathname ?? ''}${state.search ?? ''}`;
             return new URL(parsedUrl);
         }
         return new URL(serverUrl);

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

@@ -3,6 +3,7 @@
  * works and is only meant to be used during development.
  */
 export class InMemoryCache {
+    store;
     constructor() {
         this.store = new Map();
     }
@@ -13,15 +14,14 @@ export class InMemoryCache {
         });
     }
     match(request) {
-        var _a, _b;
         const match = this.store.get(request.url);
         if (!match) {
             return;
         }
         const { value, date } = match;
         const cacheControl = value.headers.get('cache-control') || '';
-        const maxAge = parseInt(((_a = cacheControl.match(/max-age=(\d+)/)) === null || _a === void 0 ? void 0 : _a[1]) || '0', 10);
-        const swr = parseInt(((_b = cacheControl.match(/stale-while-revalidate=(\d+)/)) === null || _b === void 0 ? void 0 : _b[1]) || '0', 10);
+        const maxAge = parseInt(cacheControl.match(/max-age=(\d+)/)?.[1] || '0', 10);
+        const swr = parseInt(cacheControl.match(/stale-while-revalidate=(\d+)/)?.[1] || '0', 10);
         const age = (new Date().valueOf() - date.valueOf()) / 1000;
         const isMiss = age > maxAge + swr;
         if (isMiss) {

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

@@ -1,7 +1,7 @@
+import type { ShopifyConfig } from '../shared-types';
 import type { IncomingMessage, NextFunction } from 'connect';
 import type { ServerResponse } from 'http';
 import type { ViteDevServer } from 'vite';
-import type { ShopifyConfig } from '../types';
 declare type HydrogenMiddlewareArgs = {
     dev?: boolean;
     indexTemplate: string | ((url: string) => Promise<string>);

package/dist/esnext/framework/middleware.js

@@ -27,7 +27,6 @@ export function hydrogenMiddleware({ dev, cache, indexTemplate, getServerEntrypo
         ? import('../utilities/web-api-polyfill')
         : undefined;
     return async function (request, response, next) {
-        var _a, _b, _c;
         try {
             await webPolyfills;
             const entrypoint = await Promise.resolve(getServerEntrypoint()).catch((error) => {
@@ -37,7 +36,7 @@ export function hydrogenMiddleware({ dev, cache, indexTemplate, getServerEntrypo
                 // to keep throwing it on refresh until things are fixed.
                 entrypointError = error;
             });
-            const handleRequest = (_a = entrypoint === null || entrypoint === void 0 ? void 0 : entrypoint.default) !== null && _a !== void 0 ? _a : entrypoint;
+            const handleRequest = entrypoint?.default ?? entrypoint;
             if (typeof handleRequest !== 'function') {
                 if (entrypointError) {
                     throw entrypointError;
@@ -68,7 +67,7 @@ export function hydrogenMiddleware({ dev, cache, indexTemplate, getServerEntrypo
              */
             try {
                 const template = typeof indexTemplate === 'function'
-                    ? await indexTemplate((_c = (_b = request.originalUrl) !== null && _b !== void 0 ? _b : request.url) !== null && _c !== void 0 ? _c : '')
+                    ? await indexTemplate(request.originalUrl ?? request.url ?? '')
                     : indexTemplate;
                 const html = template.replace(`<div id="root"></div>`, `<div id="root"><pre><code>${e.stack}</code></pre></div>`);
                 response.write(html);
@@ -94,5 +93,5 @@ async function respondWithGraphiql(response, shopifyConfig) {
     }
     const { storeDomain, storefrontToken, storefrontApiVersion } = shopifyConfig;
     response.setHeader('Content-Type', 'text/html');
-    response.end(graphiqlHtml(storeDomain === null || storeDomain === void 0 ? void 0 : storeDomain.replace(/^https?:\/\//, ''), storefrontToken, storefrontApiVersion));
+    response.end(graphiqlHtml(storeDomain?.replace(/^https?:\/\//, ''), storefrontToken, storefrontApiVersion));
 }

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

@@ -1,4 +1,8 @@
-import type { HydrogenVitePluginOptions } from '../types';
+import type { HydrogenVitePluginOptions } from './types';
 import type { Plugin } from 'vite';
-declare const _default: (pluginOptions?: HydrogenVitePluginOptions) => Plugin[];
-export default _default;
+declare const hydrogenPlugin: {
+    (pluginOptions?: HydrogenVitePluginOptions): Plugin[];
+    default: any;
+};
+export = hydrogenPlugin;
+export default hydrogenPlugin;

package/dist/esnext/framework/plugin.js

@@ -11,7 +11,8 @@ import inspect from 'vite-plugin-inspect';
 import react from '@vitejs/plugin-react';
 import cssModulesRsc from './plugins/vite-plugin-css-modules-rsc';
 import clientImports from './plugins/vite-plugin-client-imports';
-export default (pluginOptions = {}) => {
+import suppressWarnings from './plugins/vite-plugin-hydrogen-suppress-warnings';
+const hydrogenPlugin = (pluginOptions = {}) => {
     return [
         process.env.VITE_INSPECT && inspect(),
         hydrogenConfig(),
@@ -25,6 +26,8 @@ export default (pluginOptions = {}) => {
         cssModulesRsc(),
         rsc(),
         platformEntry(),
+        suppressWarnings(),
         pluginOptions.purgeQueryCacheOnBuild && purgeQueryCache(),
     ];
 };
+export default hydrogenPlugin; // For ESM

package/dist/esnext/framework/plugins/vite-plugin-client-imports.js

@@ -10,7 +10,7 @@ export default function clientImports() {
         async resolveId(source, importer, { ssr }) {
             if (ssr)
                 return;
-            if (/\.server\.(j|t)sx?/.test(importer !== null && importer !== void 0 ? importer : ''))
+            if (/\.server\.(j|t)sx?/.test(importer ?? ''))
                 return;
             if ('@shopify/hydrogen' !== source)
                 return;

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

@@ -24,73 +24,79 @@ export default () => {
     }
     return {
         name: 'vite-plugin-hydrogen-config',
-        config: async (config, env) => {
-            var _a, _b, _c;
-            return ({
-                resolve: {
-                    alias: {
-                        // This library is currently included as a compiled vendor lib, not published yet to NPM
-                        'react-server-dom-vite/client-proxy': require.resolve('@shopify/hydrogen/vendor/react-server-dom-vite/esm/react-server-dom-vite-client-proxy.js'),
-                    },
+        config: async (config, env) => ({
+            resolve: {
+                alias: {
+                    // This library is currently included as a compiled vendor lib, not published yet to NPM
+                    'react-server-dom-vite/client-proxy': require.resolve('@shopify/hydrogen/vendor/react-server-dom-vite/esm/react-server-dom-vite-client-proxy.js'),
                 },
-                build: {
-                    minify: (_b = (_a = config.build) === null || _a === void 0 ? void 0 : _a.minify) !== null && _b !== void 0 ? _b : 'esbuild',
-                    sourcemap: true,
-                    rollupOptions: ((_c = config.build) === null || _c === void 0 ? void 0 : _c.rollupOptions)
-                        ? Object.assign(rollupOptions, config.build.rollupOptions)
-                        : rollupOptions,
+            },
+            build: {
+                minify: config.build?.minify ?? 'esbuild',
+                sourcemap: true,
+                rollupOptions: config.build?.rollupOptions
+                    ? Object.assign(rollupOptions, config.build.rollupOptions)
+                    : rollupOptions,
+                target: config.build?.ssr
+                    ? isWorker
+                        ? 'es2022' // CFW (Updates weekly to latest V8)
+                        : 'es2020' // Node (Support for v14.19 used in SB)
+                    : 'modules', // Browsers (Vite default value)
+            },
+            ssr: {
+                /**
+                 * Tell Vite to bundle everything when we're building for Workers.
+                 * Otherwise, bundle RSC plugin as a workaround to apply the vendor alias above.
+                 */
+                noExternal: isWorker || [/react-server-dom-vite/],
+                target: isWorker ? 'webworker' : 'node',
+            },
+            // Reload when updating local Hydrogen lib
+            server: process.env.LOCAL_DEV && {
+                watch: {
+                    ignored: [
+                        '!**/node_modules/@shopify/hydrogen/**',
+                        '!**/node_modules/@shopify/hydrogen-ui/**',
+                    ],
                 },
-                ssr: {
+            },
+            optimizeDeps: {
+                exclude: [
+                    '@shopify/hydrogen',
+                    '@shopify/hydrogen/client',
+                    '@shopify/hydrogen/entry-client',
+                    '@shopify/hydrogen-ui',
+                ],
+                include: [
                     /**
-                     * Tell Vite to bundle everything when we're building for Workers.
-                     * Otherwise, bundle RSC plugin as a workaround to apply the vendor alias above.
+                     * Additionally, the following dependencies have trouble loading the
+                     * correct version of the dependency (server vs client). This tells Vite to take the
+                     * server versions and optimize them for ESM.
                      */
-                    noExternal: isWorker || [/react-server-dom-vite/],
-                    target: isWorker ? 'webworker' : 'node',
-                },
-                // Reload when updating local Hydrogen lib
-                server: process.env.LOCAL_DEV && {
-                    watch: {
-                        ignored: [
-                            '!**/node_modules/@shopify/hydrogen/**',
-                            '!**/node_modules/@shopify/hydrogen-ui/**',
-                        ],
-                    },
-                },
-                optimizeDeps: {
-                    exclude: [
-                        '@shopify/hydrogen',
-                        '@shopify/hydrogen/client',
-                        '@shopify/hydrogen/entry-client',
-                        '@shopify/hydrogen-ui',
-                    ],
-                    include: [
-                        /**
-                         * Additionally, the following dependencies have trouble loading the
-                         * correct version of the dependency (server vs client). This tells Vite to take the
-                         * server versions and optimize them for ESM.
-                         */
-                        'react-helmet-async',
-                        'react-error-boundary',
-                        /**
-                         * Vite cannot find the following dependencies since they might be
-                         * required in RSC asynchronously. This tells Vite to optimize them
-                         * at server start to avoid posterior page reloads and issues (#429 #430).
-                         */
-                        'react',
-                        'react-dom/client',
-                        'react-server-dom-vite/client-proxy',
-                        // https://github.com/vitejs/vite/issues/6215
-                        'react/jsx-runtime',
-                    ],
-                },
-                define: {
-                    __DEV__: env.mode !== 'production',
-                    __WORKER__: isWorker,
-                },
-                envPrefix: ['VITE_', 'PUBLIC_'],
-                base: process.env.HYDROGEN_ASSET_BASE_URL,
-            });
-        },
+                    'react-helmet-async',
+                    'react-error-boundary',
+                    /**
+                     * Vite cannot find the following dependencies since they might be
+                     * required in RSC asynchronously. This tells Vite to optimize them
+                     * at server start to avoid posterior page reloads and issues (#429 #430).
+                     */
+                    'react',
+                    'react-dom/client',
+                    'react-server-dom-vite/client-proxy',
+                    // https://github.com/vitejs/vite/issues/6215
+                    'react/jsx-runtime',
+                    // https://github.com/nfriedly/set-cookie-parser/issues/50
+                    'set-cookie-parser',
+                    'undici',
+                ],
+            },
+            define: {
+                __HYDROGEN_DEV__: env.mode !== 'production',
+                __HYDROGEN_WORKER__: isWorker,
+                __HYDROGEN_TEST__: false, // Used in unit tests
+            },
+            envPrefix: ['VITE_', 'PUBLIC_'],
+            base: process.env.HYDROGEN_ASSET_BASE_URL,
+        }),
     };
 };

package/dist/esnext/framework/plugins/vite-plugin-hydrogen-middleware.d.ts

@@ -1,5 +1,5 @@
 import { Plugin } from 'vite';
-import type { HydrogenVitePluginOptions } from '../../types';
+import type { HydrogenVitePluginOptions } from '../types';
 export declare const HYDROGEN_DEFAULT_SERVER_ENTRY: string;
 declare const _default: (pluginOptions: HydrogenVitePluginOptions) => Plugin;
 export default _default;

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

@@ -27,16 +27,15 @@ export default (pluginOptions) => {
             server.middlewares.use(graphiqlMiddleware({
                 dev: true,
                 getShopifyConfig: async (incomingMessage) => {
-                    var _a;
                     const { default: hydrogenConfig } = await server.ssrLoadModule(VIRTUAL_PROXY_HYDROGEN_CONFIG_ID);
                     // @ts-ignore
-                    const { address = 'localhost', port = '3000' } = ((_a = server.httpServer) === null || _a === void 0 ? void 0 : _a.address()) || {};
+                    const { address = 'localhost', port = '3000' } = server.httpServer?.address() || {};
                     const url = new URL(`http://${address}:${port}${incomingMessage.url}`);
                     const request = new Request(url.toString(), {
                         headers: incomingMessage.headers,
                     });
                     // @ts-expect-error Manually set `normalizedUrl` which a developer expects to be available
-                    // via `ServerComponentRequest` during production runtime.
+                    // via `HydrogenRequest` during production runtime.
                     request.normalizedUrl = request.url;
                     const { shopify } = hydrogenConfig;
                     return typeof shopify === 'function' ? shopify(request) : shopify;
@@ -48,7 +47,7 @@ export default (pluginOptions) => {
                 indexTemplate: getIndexTemplate,
                 getServerEntrypoint: () => server.ssrLoadModule(HYDROGEN_DEFAULT_SERVER_ENTRY),
                 devServer: server,
-                cache: (pluginOptions === null || pluginOptions === void 0 ? void 0 : pluginOptions.devCache)
+                cache: pluginOptions?.devCache
                     ? new InMemoryCache()
                     : undefined,
             }));

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

@@ -1,10 +1,13 @@
 // @ts-ignore
-import reactServerDomVite from '@shopify/hydrogen/vendor/react-server-dom-vite/plugin';
+import reactServerDomVite from '@shopify/hydrogen/vendor/react-server-dom-vite/plugin.js';
 import { HYDROGEN_DEFAULT_SERVER_ENTRY } from './vite-plugin-hydrogen-middleware';
 import { VIRTUAL_PROXY_HYDROGEN_ROUTES_ID } from './vite-plugin-hydrogen-virtual-files';
-import { viteception } from '../viteception';
 export default function () {
     return reactServerDomVite({
+        serverBuildEntries: [
+            HYDROGEN_DEFAULT_SERVER_ENTRY,
+            VIRTUAL_PROXY_HYDROGEN_ROUTES_ID,
+        ],
         isServerComponentImporterAllowed(importer, source) {
             return (
             // Always allow the entry server (e.g. App.server.jsx) to be imported
@@ -15,16 +18,5 @@ export default function () {
                 // TODO: revisit this when RSC splits into two bundles
                 /\.test\.[tj]sx?$/.test(importer));
         },
-        async findClientComponentsForClientBuild() {
-            const { server } = await viteception([
-                // Load server entry to discover client components early
-                HYDROGEN_DEFAULT_SERVER_ENTRY,
-                // Route globs are placed in a virtual module and need to
-                // be loaded to discover client components in routes
-                VIRTUAL_PROXY_HYDROGEN_ROUTES_ID,
-            ]);
-            // At this point, the server has loaded all the components in the module graph
-            return reactServerDomVite.findClientComponentsFromServer(server);
-        },
     });
 }

package/dist/esnext/framework/plugins/vite-plugin-hydrogen-suppress-warnings.d.ts

@@ -0,0 +1,3 @@
+import { Plugin } from 'vite';
+declare const _default: () => Plugin;
+export default _default;

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

@@ -0,0 +1,19 @@
+export default () => {
+    return {
+        name: 'hydrogen:suppress-warnings',
+        configResolved(config) {
+            // TODO: Fix the actual issues that cause these warnings
+            const filterOut = (msg) => msg.startsWith("@shopify/hydrogen doesn't appear to be written in CJS") ||
+                (msg.includes('missing source files') &&
+                    ['kolorist'].some((lib) => msg.includes(lib)));
+            for (const method of ['warn', 'warnOnce']) {
+                const original = config.logger[method];
+                config.logger[method] = (msg, ...args) => {
+                    if (filterOut(msg))
+                        return;
+                    return original(msg, ...args);
+                };
+            }
+        },
+    };
+};

package/dist/esnext/framework/plugins/vite-plugin-hydrogen-virtual-files.d.ts

@@ -1,5 +1,5 @@
 import { Plugin } from 'vite';
-import type { HydrogenVitePluginOptions } from '../../types';
+import type { HydrogenVitePluginOptions } from '../types';
 export declare const HYDROGEN_DEFAULT_SERVER_ENTRY: string;
 export declare const VIRTUAL_PROXY_HYDROGEN_CONFIG_ID: string;
 export declare const VIRTUAL_PROXY_HYDROGEN_ROUTES_ID: string;

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

@@ -51,8 +51,8 @@ export default (pluginOptions) => {
             }
             if (id === '\0' + VIRTUAL_HYDROGEN_ROUTES_ID) {
                 return importHydrogenConfig().then((hc) => {
-                    var _a, _b, _c, _d;
-                    let routesPath = (_b = (typeof hc.routes === 'string' ? hc.routes : (_a = hc.routes) === null || _a === void 0 ? void 0 : _a.files)) !== null && _b !== void 0 ? _b : '/src/routes';
+                    let routesPath = (typeof hc.routes === 'string' ? hc.routes : hc.routes?.files) ??
+                        '/src/routes';
                     if (routesPath.startsWith('./')) {
                         routesPath = routesPath.slice(1);
                     }
@@ -63,7 +63,7 @@ export default (pluginOptions) => {
                         routesPath += '**/*.server.[jt](s|sx)';
                     }
                     const [dirPrefix] = routesPath.split('/*');
-                    let code = `export default {\n  dirPrefix: '${dirPrefix}',\n  basePath: '${(_d = (_c = hc.routes) === null || _c === void 0 ? void 0 : _c.basePath) !== null && _d !== void 0 ? _d : ''}',\n  files: import.meta.globEager('${routesPath}')\n};`;
+                    let code = `export default {\n  dirPrefix: '${dirPrefix}',\n  basePath: '${hc.routes?.basePath ?? ''}',\n  files: import.meta.globEager('${routesPath}')\n};`;
                     if (config.command === 'serve') {
                         // Add dependency on Hydrogen config for HMR
                         code += `\nimport '${VIRTUAL_HYDROGEN_CONFIG_ID}';`;
@@ -95,5 +95,7 @@ async function findHydrogenConfigPath(root, userProvidedPath) {
             configPath = path.resolve(root, configPath);
     }
     return (configPath ||
-        require.resolve('@shopify/hydrogen/dist/esnext/utilities/empty-hydrogen-config.js'));
+        require.resolve(
+        // eslint-disable-next-line node/no-missing-require
+        '@shopify/hydrogen/utilities/empty-hydrogen-config'));
 }

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

@@ -0,0 +1,5 @@
+export interface HydrogenVitePluginOptions {
+    devCache?: boolean;
+    purgeQueryCacheOnBuild?: boolean;
+    configPath?: string;
+}