@shopify/hydrogen 1.0.0-alpha.22 → 1.0.0

package/dist/esnext/foundation/useRouteParams/RouteParamsProvider.client.js

@@ -0,0 +1,12 @@
+import React, { useContext, createContext } from 'react';
+export const RouteParamsContext = createContext({
+    routeParams: {},
+    basePath: '/',
+});
+export const RouteParamsProvider = ({ children, routeParams, basePath }) => {
+    return (React.createElement(RouteParamsContext.Provider, { value: { routeParams, basePath } }, children));
+};
+export function useBasePath() {
+    const router = useContext(RouteParamsContext);
+    return router.basePath;
+}

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

@@ -0,0 +1,4 @@
+/**
+ *  The `useRouteParams` hook retrieves the parameters of an active route. The hook is available in both server and client components.
+ */
+export declare function useRouteParams(): Record<string, string>;

package/dist/esnext/foundation/useRouteParams/useRouteParams.js

@@ -0,0 +1,9 @@
+import { useEnvContext } from '../ssr-interop';
+import { RouteParamsContext } from './RouteParamsProvider.client';
+/**
+ *  The `useRouteParams` hook retrieves the parameters of an active route. The hook is available in both server and client components.
+ */
+export function useRouteParams() {
+    const router = useEnvContext((req) => req.ctx.router, RouteParamsContext);
+    return router.routeParams;
+}

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

@@ -0,0 +1 @@
+export { useServerProps } from './use-server-props';

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

@@ -0,0 +1 @@
+export { useServerProps } from './use-server-props';

package/dist/esnext/foundation/useServerProps/use-server-props.d.ts

@@ -0,0 +1,21 @@
+import { ServerPropsContextValue, InternalServerPropsContextValue } from '../ServerPropsProvider/ServerPropsProvider';
+/**
+ * The `useServerProps` hook allows you to manage the [server props](https://shopify.dev/custom-storefronts/hydrogen/framework/server-props) passed to your server components when using Hydrogen as a React Server Component framework. The server props get cleared when you navigate from one route to another.
+ *
+ * ## Return value
+ *
+ * The `useServerProps` hook returns an object with the following keys:
+ *
+ * | Key              | Description                                                                            |
+ * | ---------------- | -------------------------------------------------------------------------------------- |
+ * | `serverProps`    | The current server props.                                                              |
+ * | `setServerProps` | A function used to modify server props.                                                |
+ * | `pending`        | Whether a [transition is pending](https://github.com/reactwg/react-18/discussions/41). |
+ *
+ */
+export declare function useServerProps(): ServerPropsContextValue;
+/**
+ * Internal-only hook to manage server state, including to set location server state
+ * @internal
+ */
+export declare function useInternalServerProps(): InternalServerPropsContextValue;

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

@@ -0,0 +1,35 @@
+import { useContext } from 'react';
+import { ServerPropsContext, } from '../ServerPropsProvider/ServerPropsProvider';
+/**
+ * The `useServerProps` hook allows you to manage the [server props](https://shopify.dev/custom-storefronts/hydrogen/framework/server-props) passed to your server components when using Hydrogen as a React Server Component framework. The server props get cleared when you navigate from one route to another.
+ *
+ * ## Return value
+ *
+ * The `useServerProps` hook returns an object with the following keys:
+ *
+ * | Key              | Description                                                                            |
+ * | ---------------- | -------------------------------------------------------------------------------------- |
+ * | `serverProps`    | The current server props.                                                              |
+ * | `setServerProps` | A function used to modify server props.                                                |
+ * | `pending`        | Whether a [transition is pending](https://github.com/reactwg/react-18/discussions/41). |
+ *
+ */
+export function useServerProps() {
+    const internalServerPropsContext = useContext(ServerPropsContext);
+    if (!internalServerPropsContext) {
+        return {};
+    }
+    return {
+        serverProps: internalServerPropsContext.serverProps,
+        setServerProps: internalServerPropsContext.setServerProps,
+        pending: internalServerPropsContext.pending,
+    };
+}
+/**
+ * Internal-only hook to manage server state, including to set location server state
+ * @internal
+ */
+export function useInternalServerProps() {
+    return (useContext(ServerPropsContext) ??
+        {});
+}

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

@@ -0,0 +1,2 @@
+/** The `useSession` hook reads session data in server components. */
+export declare const useSession: () => Record<string, string>;

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

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

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

@@ -0,0 +1 @@
+export { useShop } from './use-shop';

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

@@ -0,0 +1 @@
+export { useShop } from './use-shop';

package/dist/esnext/foundation/useShop/use-shop.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The `useShop` hook provides access to values within
+ * [the `shopify` property in the `hydrogen.config.js` file](https://shopify.dev/custom-storefronts/hydrogen/framework/hydrogen-config).
+ * The `useShop` hook must be a descendent of a `ShopifyProvider` component.
+ */
+export declare function useShop(): import("../ShopifyProvider/types").ShopifyContextValue;

package/dist/esnext/foundation/useShop/use-shop.js

@@ -0,0 +1,14 @@
+import { ShopifyContext } from '../ShopifyProvider';
+import { useEnvContext } from '../ssr-interop';
+/**
+ * The `useShop` hook provides access to values within
+ * [the `shopify` property in the `hydrogen.config.js` file](https://shopify.dev/custom-storefronts/hydrogen/framework/hydrogen-config).
+ * The `useShop` hook must be a descendent of a `ShopifyProvider` component.
+ */
+export function useShop() {
+    const config = useEnvContext((req) => req.ctx.shopifyConfig, ShopifyContext);
+    if (!config) {
+        throw new Error('No Shopify Context found');
+    }
+    return config;
+}

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

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

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

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

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

@@ -0,0 +1,4 @@
+/**
+ * The `useUrl` hook retrieves the current URL in a server or client component.
+ */
+export declare function useUrl(): URL;

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

@@ -0,0 +1,29 @@
+import { useContext, useMemo } from 'react';
+import { RSC_PATHNAME } from '../../constants';
+import { parseJSON } from '../../utilities/parse';
+import { RouterContext } from '../Router/BrowserRouter.client';
+import { useEnvContext, META_ENV_SSR } from '../ssr-interop';
+/**
+ * The `useUrl` hook retrieves the current URL in a server or client component.
+ */
+export function useUrl() {
+    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}${state.pathname ?? ''}${state.search ?? ''}`;
+            return new URL(parsedUrl);
+        }
+        return new URL(serverUrl);
+    }
+    /**
+     * We return a `URL` object instead of passing through `location` because
+     * the URL object contains important info like hostname, etc.
+     * Note: do not call `useLocation` directly here to avoid throwing errors
+     * when `useUrl` is used outside of a Router component (e.g. in <Seo>).
+     */
+    const location = useContext(RouterContext); // eslint-disable-line react-hooks/rules-of-hooks
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    return useMemo(() => new URL(window.location.href), [location]); // eslint-disable-line react-hooks/exhaustive-deps
+}

package/dist/esnext/framework/cache/in-memory.d.ts

@@ -0,0 +1,17 @@
+/**
+ * This is a limited implementation of an in-memory cache.
+ * It only supports the `cache-control` header.
+ * It does NOT support `age` or `expires` headers.
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Cache
+ */
+export declare class InMemoryCache implements Cache {
+    #private;
+    constructor();
+    add(request: RequestInfo): Promise<void>;
+    addAll(requests: RequestInfo[]): Promise<void>;
+    matchAll(request?: RequestInfo, options?: CacheQueryOptions): Promise<readonly Response[]>;
+    put(request: Request, response: Response): Promise<void>;
+    match(request: Request): Promise<Response | undefined>;
+    delete(request: Request): Promise<boolean>;
+    keys(request?: Request): Promise<Request[]>;
+}

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

@@ -0,0 +1,80 @@
+/**
+ * This is a limited implementation of an in-memory cache.
+ * It only supports the `cache-control` header.
+ * It does NOT support `age` or `expires` headers.
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Cache
+ */
+export class InMemoryCache {
+    #store;
+    constructor() {
+        this.#store = new Map();
+    }
+    add(request) {
+        throw new Error('Method not implemented. Use `put` instead.');
+    }
+    addAll(requests) {
+        throw new Error('Method not implemented. Use `put` instead.');
+    }
+    matchAll(request, options) {
+        throw new Error('Method not implemented. Use `match` instead.');
+    }
+    async put(request, response) {
+        if (request.method !== 'GET') {
+            throw new TypeError('Cannot cache response to non-GET request.');
+        }
+        if (response.status === 206) {
+            throw new TypeError('Cannot cache response to a range request (206 Partial Content).');
+        }
+        if (response.headers.get('vary')?.includes('*')) {
+            throw new TypeError("Cannot cache response with 'Vary: *' header.");
+        }
+        this.#store.set(request.url, {
+            body: new Uint8Array(await response.arrayBuffer()),
+            status: response.status,
+            headers: [...response.headers],
+            timestamp: Date.now(),
+        });
+    }
+    async match(request) {
+        if (request.method !== 'GET')
+            return;
+        const match = this.#store.get(request.url);
+        if (!match) {
+            return;
+        }
+        const { body, timestamp, ...metadata } = match;
+        const headers = new Headers(metadata.headers);
+        const cacheControl = headers.get('cache-control') || '';
+        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 = (Date.now() - timestamp) / 1000;
+        const isMiss = age > maxAge + swr;
+        if (isMiss) {
+            this.#store.delete(request.url);
+            return;
+        }
+        const isStale = age > maxAge;
+        headers.set('cache', isStale ? 'STALE' : 'HIT');
+        headers.set('date', new Date(timestamp).toUTCString());
+        return new Response(body, {
+            status: metadata.status ?? 200,
+            headers,
+        });
+    }
+    async delete(request) {
+        if (this.#store.has(request.url)) {
+            this.#store.delete(request.url);
+            return true;
+        }
+        return false;
+    }
+    keys(request) {
+        const cacheKeys = [];
+        for (const url of this.#store.keys()) {
+            if (!request || request.url === url) {
+                cacheKeys.push(new Request(url));
+            }
+        }
+        return Promise.resolve(cacheKeys);
+    }
+}

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

@@ -1 +1 @@
-export declare function graphiqlHtml(shop: string, token: string, apiVersion?: string): string;
+export declare function graphiqlHtml(shop: string, token: string, apiVersion: string): string;

package/dist/esnext/framework/graphiql.js

@@ -1,5 +1,4 @@
-import { DEFAULT_API_VERSION } from '../foundation';
-export function graphiqlHtml(shop, token, apiVersion = DEFAULT_API_VERSION) {
+export function graphiqlHtml(shop, token, apiVersion) {
     return `<html>
   <head>
     <title>Shopify Storefront API</title>

package/dist/esnext/framework/load-config.d.ts

@@ -0,0 +1,5 @@
+export declare function loadConfig(options?: {
+    root: string;
+}): Promise<{
+    configuration: any;
+}>;

package/dist/esnext/framework/load-config.js

@@ -0,0 +1,7 @@
+// Provide Hydrogen config loader to external tools like the CLI
+import { VIRTUAL_PROXY_HYDROGEN_CONFIG_ID } from './plugins/vite-plugin-hydrogen-virtual-files';
+import { viteception } from './viteception';
+export async function loadConfig(options = { root: process.cwd() }) {
+    const { loaded } = await viteception([VIRTUAL_PROXY_HYDROGEN_CONFIG_ID], options);
+    return { configuration: loaded[0].default };
+}

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

@@ -1,17 +1,21 @@
-import { IncomingMessage, NextFunction } from 'connect';
-import http from 'http';
-import { ViteDevServer } from 'vite';
-import { ShopifyConfig } from '../types';
+import type { ShopifyConfig } from '../shared-types';
+import type { IncomingMessage, NextFunction } from 'connect';
+import type { ServerResponse } from 'http';
+import type { ViteDevServer } from 'vite';
 declare type HydrogenMiddlewareArgs = {
     dev?: boolean;
-    shopifyConfig?: ShopifyConfig;
     indexTemplate: string | ((url: string) => Promise<string>);
-    getServerEntrypoint: () => Record<string, any> | Promise<Record<string, any>>;
+    getServerEntrypoint: () => any;
     devServer?: ViteDevServer;
+    cache?: Cache;
 };
+export declare function graphiqlMiddleware({ getShopifyConfig, dev, }: {
+    getShopifyConfig: (request: IncomingMessage) => ShopifyConfig | Promise<ShopifyConfig>;
+    dev?: boolean;
+}): (request: IncomingMessage, response: ServerResponse, next: NextFunction) => Promise<void>;
 /**
  * Provides middleware to Node.js Express-like servers. Used by the Hydrogen
  * Vite dev server plugin as well as production Node.js implementation.
  */
-export default function hydrogenMiddleware({ dev, shopifyConfig, indexTemplate, getServerEntrypoint, devServer, }: HydrogenMiddlewareArgs): (request: IncomingMessage, response: http.ServerResponse, next: NextFunction) => Promise<void>;
+export declare function hydrogenMiddleware({ dev, cache, indexTemplate, getServerEntrypoint, devServer, }: HydrogenMiddlewareArgs): (request: IncomingMessage, response: ServerResponse, next: NextFunction) => Promise<void>;
 export {};

package/dist/esnext/framework/middleware.js

@@ -1,75 +1,63 @@
 import { graphiqlHtml } from './graphiql';
-import handleEvent from '../handle-event';
+export function graphiqlMiddleware({ getShopifyConfig, dev, }) {
+    return async function (request, response, next) {
+        if (dev && isGraphiqlRequest(request)) {
+            const shopifyConfig = await getShopifyConfig(request);
+            return respondWithGraphiql(response, shopifyConfig);
+        }
+        next();
+    };
+}
+let entrypointError = null;
 /**
  * Provides middleware to Node.js Express-like servers. Used by the Hydrogen
  * Vite dev server plugin as well as production Node.js implementation.
  */
-export default function hydrogenMiddleware({ dev, shopifyConfig, indexTemplate, getServerEntrypoint, devServer, }) {
+export function hydrogenMiddleware({ dev, cache, indexTemplate, getServerEntrypoint, devServer, }) {
+    if (dev && devServer) {
+        // Store this globally for devtools
+        // @ts-ignore
+        globalThis.__viteDevServer = devServer;
+    }
+    /**
+     * We're running in the Node.js runtime without access to `fetch`,
+     * which is needed for proxy requests and server-side API requests.
+     */
+    const webPolyfills = !globalThis.fetch || !globalThis.ReadableStream
+        ? import('../utilities/web-api-polyfill')
+        : undefined;
     return async function (request, response, next) {
-        const graphiqlRequest = dev && isGraphiqlRequest(request);
-        if (graphiqlRequest) {
-            return respondWithGraphiql(response, shopifyConfig);
-        }
-        const url = new URL('http://' + request.headers.host + request.originalUrl);
-        const isReactHydrationRequest = url.pathname === '/react';
-        /**
-         * If it's a dev environment, it's assumed that Vite's dev server is handling
-         * any static or JS requests, so we need to ensure that we don't try to handle them.
-         *
-         * If it's a product environment, it's assumed that the developer is handling
-         * static requests with e.g. static middleware.
-         */
-        if (dev && !shouldInterceptRequest(request, isReactHydrationRequest)) {
-            return next();
-        }
         try {
-            /**
-             * We're running in the Node.js runtime without access to `fetch`,
-             * which is needed for proxy requests and server-side API requests.
-             */
-            if (!globalThis.fetch) {
-                const fetch = await import('node-fetch');
-                // @ts-ignore
-                globalThis.fetch = fetch.default;
-                // @ts-ignore
-                globalThis.Request = fetch.Request;
-                // @ts-ignore
-                globalThis.Response = fetch.Response;
-                // @ts-ignore
-                globalThis.Headers = fetch.Headers;
+            await webPolyfills;
+            const entrypoint = await Promise.resolve(getServerEntrypoint()).catch((error) => {
+                // Errors are only thrown the first time we try to load the entry point.
+                // After refreshing the browser, this just loads an empty module
+                // and doesn't throw anymore. Store this error in the outer scope
+                // to keep throwing it on refresh until things are fixed.
+                entrypointError = error;
+            });
+            const handleRequest = entrypoint?.default ?? entrypoint;
+            if (typeof handleRequest !== 'function') {
+                if (entrypointError) {
+                    throw entrypointError;
+                }
+                else {
+                    // This means there is no error when loading the entry point but
+                    // we are still not getting a function as the default export.
+                    throw new Error('Something is wrong in your project. Make sure to add "export default renderHydrogen(...)" in your server entry file.');
+                }
             }
-            /**
-             * Dynamically import ServerComponentResponse after the `fetch`
-             * polyfill has loaded above.
-             */
-            const { ServerComponentRequest } = await import('../foundation/Hydration/ServerComponentRequest.server');
-            const eventResponse = await handleEvent(
-            /**
-             * Mimic a `FetchEvent`
-             */
-            {}, {
-                request: new ServerComponentRequest(request),
-                entrypoint: await getServerEntrypoint(),
+            entrypointError = null;
+            await handleRequest(request, {
+                dev,
+                cache,
                 indexTemplate,
                 streamableResponse: response,
-                dev,
             });
-            /**
-             * If a `Response` was returned, that means it was not streamed.
-             * Convert the response into a proper Node.js response.
-             */
-            if (eventResponse) {
-                eventResponse.headers.forEach((value, key) => {
-                    response.setHeader(key, value);
-                });
-                response.statusCode = eventResponse.status;
-                response.end(eventResponse.body);
-            }
         }
         catch (e) {
             if (dev && devServer)
                 devServer.ssrFixStacktrace(e);
-            console.log(e.stack);
             response.statusCode = 500;
             /**
              * Attempt to print the error stack within the template.
@@ -79,7 +67,7 @@ export default function hydrogenMiddleware({ dev, shopifyConfig, indexTemplate,
              */
             try {
                 const template = typeof indexTemplate === 'function'
-                    ? await indexTemplate(url.toString())
+                    ? 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);
@@ -93,13 +81,6 @@ export default function hydrogenMiddleware({ dev, shopifyConfig, indexTemplate,
         }
     };
 }
-function shouldInterceptRequest(request, isReactHydrationRequest) {
-    var _a;
-    return ((((_a = request.headers['accept']) === null || _a === void 0 ? void 0 : _a.includes('text/html')) ||
-        isReactHydrationRequest) &&
-        request.method === 'GET' &&
-        request.url !== '/favicon.ico');
-}
 /**
  * /graphiql and /___graphql are supported
  */
@@ -108,9 +89,9 @@ function isGraphiqlRequest(request) {
 }
 async function respondWithGraphiql(response, shopifyConfig) {
     if (!shopifyConfig) {
-        throw new Error("You must provide shopifyConfig to Hydrogen's Vite middleware");
+        throw new Error("You must provide a 'shopify' property in your Hydrogen config file");
     }
-    const { storeDomain, storefrontToken, graphqlApiVersion } = shopifyConfig;
+    const { storeDomain, storefrontToken, storefrontApiVersion } = shopifyConfig;
     response.setHeader('Content-Type', 'text/html');
-    response.end(graphiqlHtml(storeDomain, storefrontToken, graphqlApiVersion));
+    response.end(graphiqlHtml(storeDomain?.replace(/^https?:\/\//, ''), storefrontToken, storefrontApiVersion));
 }

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

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

package/dist/esnext/framework/plugin.js

@@ -1,14 +1,33 @@
 import hydrogenConfig from './plugins/vite-plugin-hydrogen-config';
 import hydrogenMiddleware from './plugins/vite-plugin-hydrogen-middleware';
-import reactServerComponentShim from './plugins/vite-plugin-react-server-components-shim';
+import hydrogenClientMiddleware from './plugins/vite-plugin-hydrogen-client-middleware';
+import hydrogenVirtualFiles from './plugins/vite-plugin-hydrogen-virtual-files';
+import platformEntry from './plugins/vite-plugin-platform-entry';
+import rsc from './plugins/vite-plugin-hydrogen-rsc';
+import ssrInterop from './plugins/vite-plugin-ssr-interop';
+import purgeQueryCache from './plugins/vite-plugin-purge-query-cache';
+import hydrationAutoImport from './plugins/vite-plugin-hydration-auto-import';
 import inspect from 'vite-plugin-inspect';
 import react from '@vitejs/plugin-react';
-export default (shopifyConfig) => {
+import cssModulesRsc from './plugins/vite-plugin-css-modules-rsc';
+import clientImports from './plugins/vite-plugin-client-imports';
+import suppressWarnings from './plugins/vite-plugin-hydrogen-suppress-warnings';
+const hydrogenPlugin = (pluginOptions = {}) => {
     return [
         process.env.VITE_INSPECT && inspect(),
         hydrogenConfig(),
-        hydrogenMiddleware(shopifyConfig),
-        reactServerComponentShim(),
+        hydrogenClientMiddleware(),
+        clientImports(),
+        hydrogenMiddleware(pluginOptions),
+        hydrogenVirtualFiles(pluginOptions),
         react(),
+        hydrationAutoImport(),
+        ssrInterop(),
+        cssModulesRsc(),
+        rsc(pluginOptions),
+        platformEntry(),
+        suppressWarnings(),
+        pluginOptions.purgeQueryCacheOnBuild && purgeQueryCache(),
     ];
 };
+export default hydrogenPlugin; // For ESM

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

@@ -0,0 +1,2 @@
+import type { Plugin } from 'vite';
+export default function clientImports(): Plugin;

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

@@ -0,0 +1,25 @@
+export default function clientImports() {
+    return {
+        name: 'hydrogen:client-imports',
+        enforce: 'pre',
+        /**
+         * When importer does not end in `server.jsx`, and source is `@shopify/hydrogen`,
+         * replace with `@shopify/hydrogen/client`. This prevents other server-only imports
+         * from "leaking" into the client bundle.
+         */
+        async resolveId(source, importer, { ssr }) {
+            if (ssr)
+                return;
+            if (/\.server\.(j|t)sx?/.test(importer ?? ''))
+                return;
+            if ('@shopify/hydrogen' !== source)
+                return;
+            const resolution = await this.resolve('@shopify/hydrogen/client', importer, {
+                skipSelf: true,
+            });
+            if (resolution) {
+                return resolution.id;
+            }
+        },
+    };
+}

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

@@ -0,0 +1,2 @@
+import type { Plugin } from 'vite';
+export default function cssModulesRsc(): Plugin[];