@shopify/hydrogen 0.0.0-experimental-20220526194818

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

@@ -0,0 +1,21 @@
+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>);
+    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 declare function hydrogenMiddleware({ dev, cache, indexTemplate, getServerEntrypoint, devServer, }: HydrogenMiddlewareArgs): (request: IncomingMessage, response: ServerResponse, next: NextFunction) => Promise<void>;
+export {};

package/dist/esnext/framework/middleware.js

@@ -0,0 +1,98 @@
+import { graphiqlHtml } from './graphiql';
+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 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) {
+        var _a, _b, _c;
+        try {
+            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 = (_a = entrypoint === null || entrypoint === void 0 ? void 0 : entrypoint.default) !== null && _a !== void 0 ? _a : 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.');
+                }
+            }
+            entrypointError = null;
+            await handleRequest(request, {
+                dev,
+                cache,
+                indexTemplate,
+                streamableResponse: response,
+            });
+        }
+        catch (e) {
+            if (dev && devServer)
+                devServer.ssrFixStacktrace(e);
+            response.statusCode = 500;
+            /**
+             * Attempt to print the error stack within the template.
+             * This allows the react-refresh plugin and other Vite runtime helpers
+             * to display the error and auto-refresh when the error is fixed, instead
+             * of a white screen that needs a manual refresh.
+             */
+            try {
+                const template = typeof indexTemplate === 'function'
+                    ? await indexTemplate((_c = (_b = request.originalUrl) !== null && _b !== void 0 ? _b : request.url) !== null && _c !== void 0 ? _c : '')
+                    : indexTemplate;
+                const html = template.replace(`<div id="root"></div>`, `<div id="root"><pre><code>${e.stack}</code></pre></div>`);
+                response.write(html);
+                next(e);
+            }
+            catch (_e) {
+                // If template loading is the culprit, give up and just return the error stack.
+                response.write(e.stack);
+                next(e);
+            }
+        }
+    };
+}
+/**
+ * /graphiql and /___graphql are supported
+ */
+function isGraphiqlRequest(request) {
+    return /^\/(?:_{3})?graphi?ql/.test(request.url || '');
+}
+async function respondWithGraphiql(response, shopifyConfig) {
+    if (!shopifyConfig) {
+        throw new Error("You must provide a 'shopify' property in your Hydrogen config file");
+    }
+    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));
+}

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

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

package/dist/esnext/framework/plugin.js

@@ -0,0 +1,28 @@
+import hydrogenConfig from './plugins/vite-plugin-hydrogen-config';
+import hydrogenMiddleware from './plugins/vite-plugin-hydrogen-middleware';
+import hydrogenClientMiddleware from './plugins/vite-plugin-hydrogen-client-middleware';
+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';
+import cssModulesRsc from './plugins/vite-plugin-css-modules-rsc';
+import clientImports from './plugins/vite-plugin-client-imports';
+export default (pluginOptions = {}) => {
+    return [
+        process.env.VITE_INSPECT && inspect(),
+        hydrogenConfig(),
+        hydrogenClientMiddleware(),
+        clientImports(),
+        hydrogenMiddleware(pluginOptions),
+        react(),
+        hydrationAutoImport(),
+        ssrInterop(),
+        cssModulesRsc(),
+        rsc(),
+        platformEntry(),
+        pluginOptions.purgeQueryCacheOnBuild && purgeQueryCache(),
+    ];
+};

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 !== null && importer !== void 0 ? 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[];

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

@@ -0,0 +1,98 @@
+import { HYDROGEN_DEFAULT_SERVER_ENTRY } from './vite-plugin-hydrogen-middleware';
+import MagicString from 'magic-string';
+import path from 'path';
+const cssModuleRE = /\.module\.(s?css|sass|less|stylus)/;
+export default function cssModulesRsc() {
+    // 1. Original CSS module: `.myStyle { color: red; }`
+    // 2. CSS module after 'pre' Vite transforms: `.myStyle_hashedXYZ { color: red; }`
+    // 3. CSS module after 'post' Vite transforms: `export const myStyle = 'myStyle_hashedXYZ';`
+    let cssMap = new Map();
+    let config;
+    return [
+        {
+            name: 'css-modules-rsc',
+            configResolved(_config) {
+                config = _config;
+                cssMap = new Map();
+                // Place this plugin before react-refresh to
+                // modify files before JSX is compiled.
+                // @ts-ignore
+                config.plugins.unshift(autoStyleTagPlugin());
+            },
+            transform(code, id) {
+                if (cssModuleRE.test(id)) {
+                    cssMap.set(id, code);
+                }
+            },
+        },
+        {
+            name: 'css-modules-rsc-post',
+            enforce: 'post',
+            transform(code, id) {
+                if (id.includes('.module.') && cssMap.has(id)) {
+                    const isDev = config.command === 'serve';
+                    const key = path.relative(config.root, id.split('?')[0]);
+                    const s = new MagicString(code);
+                    s.prepend((isDev
+                        ? `import {jsxDEV as _jsx} from 'react/jsx-dev-runtime';`
+                        : `import {jsx as _jsx} from 'react/jsx-runtime';`) +
+                        `export const StyleTag = () => _jsx('style', {dangerouslySetInnerHTML: {__html: ${JSON.stringify(cssMap.get(id))}}});` +
+                        `\nStyleTag.key = '${key}';\n`);
+                    s.replace(/export default \{/gs, `export default {\n  StyleTag,`);
+                    return {
+                        code: s.toString(),
+                        map: s.generateMap({ file: id, source: id }),
+                    };
+                }
+            },
+        },
+    ];
+}
+function autoStyleTagPlugin() {
+    return {
+        name: 'css-modules-auto-style-tag',
+        transform(code, id) {
+            id = id.split('?')[0];
+            if (/\.[jt]sx$/.test(id) &&
+                !id.endsWith(HYDROGEN_DEFAULT_SERVER_ENTRY) &&
+                !id.endsWith(path.format({
+                    name: HYDROGEN_DEFAULT_SERVER_ENTRY,
+                    ext: path.extname(id),
+                })) &&
+                cssModuleRE.test(code) &&
+                code.includes('export default')) {
+                const s = new MagicString(code);
+                // 1. Gather style tags in an array
+                let styleCount = 0;
+                s.prepend(`const __styleTags = [];\n`);
+                s.replace(/^import\s+(.+?)\s+from\s+['"]([^'"]+?\.module\.[^'"]+?)['"]/gm, (all, statements, from) => {
+                    if (!cssModuleRE.test(from)) {
+                        return all;
+                    }
+                    if (statements.startsWith('{')) {
+                        // Add default import
+                        const replacement = `__style${styleCount++}, {`;
+                        statements = statements.replace('{', replacement);
+                        all = all.replace('{', replacement);
+                    }
+                    const defaultImport = statements
+                        .split(',')[0]
+                        .replace(/\*\s+as\s+/, '')
+                        .trim();
+                    return all + `; __styleTags.push(${defaultImport}.StyleTag)`;
+                });
+                // 2. Wrap default export in a new component that includes the style tags
+                s.replace(/export default/gm, 'const __defaultExport = ');
+                s.append(`\nconst __ApplyStyleTags = function (props) {\n` +
+                    `  return <>{__styleTags.map(ST => <ST key={ST.key} />)}<__defaultExport {...props} /></>;` +
+                    `\n}\n\n` +
+                    `Object.defineProperty(__ApplyStyleTags, 'name', {value: 'ApplyStyleTags_' + (__defaultExport.name || '')});\n` +
+                    `export default __ApplyStyleTags;`);
+                return {
+                    code: s.toString(),
+                    map: s.generateMap({ file: id, source: id }),
+                };
+            }
+        },
+    };
+}

package/dist/esnext/framework/plugins/vite-plugin-hydration-auto-import.d.ts

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

package/dist/esnext/framework/plugins/vite-plugin-hydration-auto-import.js

@@ -0,0 +1,35 @@
+import { normalizePath } from 'vite';
+import path from 'path';
+import MagicString from 'magic-string';
+const HYDROGEN_ENTRY_FILE = 'hydrogen-entry-client.jsx';
+export default () => {
+    let config;
+    return {
+        name: 'vite-plugin-hydration-auto-import',
+        enforce: 'pre',
+        configResolved(_config) {
+            config = _config;
+        },
+        resolveId(id, importer) {
+            if ((/^\/?@shopify\/hydrogen\/entry-client$/.test(id) ||
+                id.endsWith(path.sep + HYDROGEN_ENTRY_FILE)) &&
+                normalizePath(importer || '').endsWith('/index.html')) {
+                // Make this virtual import look like a local project file
+                // to enable React Refresh normally.
+                return path.join(config.root, HYDROGEN_ENTRY_FILE + '?virtual');
+            }
+            return null;
+        },
+        load(id) {
+            if (id.includes(HYDROGEN_ENTRY_FILE + '?virtual')) {
+                const code = new MagicString(`import renderHydrogen from '@shopify/hydrogen/entry-client';\n` +
+                    `export default renderHydrogen((props) => props.children);`);
+                return {
+                    code: code.toString(),
+                    map: { mappings: '' },
+                };
+            }
+            return null;
+        },
+    };
+};

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

@@ -0,0 +1,9 @@
+import { type Plugin } from 'vite';
+declare const _default: () => Plugin;
+/**
+ * This dev server middleware prevents Vite from applying immutable cache control headers to client
+ * components. These client components are part of the user's local source, but since they are
+ * referenced via import globs in the `react-dom-server-vite` NPM package, Vite assumes they
+ * are 3P deps that can be cached. This middleware responds to the requests early with `no-cache`.
+ */
+export default _default;

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

@@ -0,0 +1,37 @@
+import { send } from 'vite';
+/**
+ * This dev server middleware prevents Vite from applying immutable cache control headers to client
+ * components. These client components are part of the user's local source, but since they are
+ * referenced via import globs in the `react-dom-server-vite` NPM package, Vite assumes they
+ * are 3P deps that can be cached. This middleware responds to the requests early with `no-cache`.
+ */
+export default () => {
+    return {
+        name: 'vite-plugin-hydrogen-client-middleware',
+        enforce: 'pre',
+        configureServer(server) {
+            server.middlewares.use(async (req, res, next) => {
+                const url = req.url;
+                try {
+                    if (url.includes('.client.js') &&
+                        url.includes('?v=') &&
+                        !url.includes('node_modules')) {
+                        const result = await server.transformRequest(url, { html: false });
+                        if (result) {
+                            return send(req, res, result.code, 'js', {
+                                etag: result.etag,
+                                cacheControl: 'no-cache',
+                                headers: server.config.server.headers,
+                                map: result.map,
+                            });
+                        }
+                    }
+                }
+                catch (e) {
+                    next(e);
+                }
+                next();
+            });
+        },
+    };
+};

package/dist/esnext/framework/plugins/vite-plugin-hydrogen-config.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-config.js

@@ -0,0 +1,96 @@
+export default () => {
+    const rollupOptions = {
+        output: {},
+    };
+    const isWorker = Boolean(process.env.WORKER) && process.env.WORKER !== 'undefined';
+    if (isWorker) {
+        /**
+         * By default, SSR dedupe logic gets bundled which runs `require('module')`.
+         * We don't want this in our workers runtime, because `require` is not supported.
+         */
+        rollupOptions.output = {
+            format: 'es',
+        };
+    }
+    if (process.env.NODE_ENV !== 'development') {
+        /**
+         * Ofuscate production asset name - To prevent ad blocker logics that blocks
+         * certain files due to how it is named.
+         */
+        rollupOptions.output = {
+            ...rollupOptions.output,
+            chunkFileNames: 'assets/[hash].js',
+        };
+    }
+    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'),
+                    },
+                },
+                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,
+                },
+                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/**',
+                        ],
+                    },
+                },
+                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,
+            });
+        },
+    };
+};

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

@@ -0,0 +1,11 @@
+import { Plugin } from 'vite';
+import type { HydrogenVitePluginOptions } from '../../types';
+export declare const HYDROGEN_DEFAULT_SERVER_ENTRY: string;
+declare const _default: (pluginOptions: HydrogenVitePluginOptions) => Plugin;
+export default _default;
+declare global {
+    var Oxygen: {
+        env: any;
+        [key: string]: any;
+    };
+}

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

@@ -0,0 +1,110 @@
+import { loadEnv, normalizePath } from 'vite';
+import bodyParser from 'body-parser';
+import path from 'path';
+import { promises as fs } from 'fs';
+import { hydrogenMiddleware, graphiqlMiddleware } from '../middleware';
+import { InMemoryCache } from '../cache/in-memory';
+export const HYDROGEN_DEFAULT_SERVER_ENTRY = process.env.HYDROGEN_SERVER_ENTRY || '/src/App.server';
+const virtualModuleId = 'virtual:hydrogen-config';
+const virtualProxyModuleId = virtualModuleId + ':proxy';
+export default (pluginOptions) => {
+    let config;
+    return {
+        name: 'vite-plugin-hydrogen-middleware',
+        configResolved(_config) {
+            config = _config;
+        },
+        /**
+         * By adding a middleware to the Vite dev server, we can handle SSR without needing
+         * a custom node script. It works by handling any requests for `text/html` documents,
+         * loading them in an SSR context, rendering them using the `entry-server` endpoint in the
+         * user's project, and injecting the static HTML into the template.
+         */
+        async configureServer(server) {
+            const resolve = (p) => path.resolve(server.config.root, p);
+            async function getIndexTemplate(url) {
+                const indexHtml = await fs.readFile(resolve('index.html'), 'utf-8');
+                return await server.transformIndexHtml(url, indexHtml);
+            }
+            await polyfillOxygenEnv(server.config);
+            // The default vite middleware rewrites the URL `/graphqil` to `/index.html`
+            // By running this middleware first, we avoid that.
+            server.middlewares.use(graphiqlMiddleware({
+                dev: true,
+                getShopifyConfig: async (incomingMessage) => {
+                    var _a;
+                    const { default: hydrogenConfig } = await server.ssrLoadModule('virtual:hydrogen-config:proxy');
+                    // @ts-ignore
+                    const { address = 'localhost', port = '3000' } = ((_a = server.httpServer) === null || _a === void 0 ? void 0 : _a.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.
+                    request.normalizedUrl = request.url;
+                    return typeof hydrogenConfig.shopify === 'function'
+                        ? hydrogenConfig.shopify(request)
+                        : hydrogenConfig.shopify;
+                },
+            }));
+            server.middlewares.use(bodyParser.raw({ type: '*/*' }));
+            return () => server.middlewares.use(hydrogenMiddleware({
+                dev: true,
+                indexTemplate: getIndexTemplate,
+                getServerEntrypoint: () => server.ssrLoadModule(HYDROGEN_DEFAULT_SERVER_ENTRY),
+                devServer: server,
+                cache: (pluginOptions === null || pluginOptions === void 0 ? void 0 : pluginOptions.devCache)
+                    ? new InMemoryCache()
+                    : undefined,
+            }));
+        },
+        async resolveId(source, importer) {
+            if (source === virtualModuleId) {
+                const configPath = await findHydrogenConfigPath(config.root, pluginOptions.configPath);
+                return this.resolve(configPath, importer, {
+                    skipSelf: true,
+                });
+            }
+            if (source === virtualProxyModuleId) {
+                // Virtual modules convention
+                // https://vitejs.dev/guide/api-plugin.html#virtual-modules-convention
+                return '\0' + virtualProxyModuleId;
+            }
+        },
+        async load(id) {
+            if (id === '\0' + virtualProxyModuleId) {
+                // Likely due to a bug in Vite, but the config cannot be loaded
+                // directly using ssrLoadModule. It needs to be proxied as follows:
+                return `import hc from 'virtual:hydrogen-config'; export default hc;`;
+            }
+        },
+    };
+};
+async function polyfillOxygenEnv(config) {
+    const env = await loadEnv(config.mode, config.root, '');
+    const publicPrefixes = Array.isArray(config.envPrefix)
+        ? config.envPrefix
+        : [config.envPrefix || ''];
+    for (const key of Object.keys(env)) {
+        if (publicPrefixes.some((prefix) => key.startsWith(prefix))) {
+            delete env[key];
+        }
+    }
+    globalThis.Oxygen = { env };
+}
+async function findHydrogenConfigPath(root, userProvidedPath) {
+    let configPath = userProvidedPath;
+    if (!configPath) {
+        // Find the config file in the project root
+        const files = await fs.readdir(root);
+        configPath = files.find((file) => /^hydrogen\.config\.[jt]s$/.test(file));
+    }
+    if (configPath) {
+        configPath = normalizePath(configPath);
+        if (!configPath.startsWith('/'))
+            configPath = path.resolve(root, configPath);
+    }
+    return (configPath ||
+        require.resolve('@shopify/hydrogen/dist/esnext/utilities/empty-hydrogen-config.js'));
+}

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

@@ -0,0 +1 @@
+export default function (): any;

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

@@ -0,0 +1,35 @@
+// @ts-ignore
+import reactServerDomVite from '@shopify/hydrogen/vendor/react-server-dom-vite/plugin';
+import { HYDROGEN_DEFAULT_SERVER_ENTRY } from './vite-plugin-hydrogen-middleware';
+import { createServer } from 'vite';
+export default function () {
+    return reactServerDomVite({
+        isServerComponentImporterAllowed(importer, source) {
+            return (
+            // Always allow the entry server (e.g. App.server.jsx) to be imported
+            // in other files such as worker.js or server.js.
+            source.includes(HYDROGEN_DEFAULT_SERVER_ENTRY) ||
+                /(index|entry-server|hydrogen\.config)\.[jt]s/.test(importer) ||
+                // Support importing server components for testing
+                // TODO: revisit this when RSC splits into two bundles
+                /\.test\.[tj]sx?$/.test(importer));
+        },
+        async findClientComponentsForClientBuild() {
+            // In client build, we create a local server to discover client compoents.
+            const server = await createServer({
+                clearScreen: false,
+                server: { middlewareMode: 'ssr' },
+            });
+            await Promise.all([
+                // Load server entry to discover client components early
+                server.ssrLoadModule(HYDROGEN_DEFAULT_SERVER_ENTRY),
+                // Route globs are placed in hydrogen.config.js and need to
+                // be loaded to discover client components in routes
+                server.ssrLoadModule('virtual:hydrogen-config:proxy'),
+            ]);
+            await server.close();
+            // 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-platform-entry.d.ts

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