@shopify/hydrogen 0.0.0-experimental-20220526194818

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

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.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/node/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/node/framework/plugins/vite-plugin-hydrogen-middleware.js

@@ -0,0 +1,116 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HYDROGEN_DEFAULT_SERVER_ENTRY = void 0;
+const vite_1 = require("vite");
+const body_parser_1 = __importDefault(require("body-parser"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = require("fs");
+const middleware_1 = require("../middleware");
+const in_memory_1 = require("../cache/in-memory");
+exports.HYDROGEN_DEFAULT_SERVER_ENTRY = process.env.HYDROGEN_SERVER_ENTRY || '/src/App.server';
+const virtualModuleId = 'virtual:hydrogen-config';
+const virtualProxyModuleId = virtualModuleId + ':proxy';
+exports.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_1.default.resolve(server.config.root, p);
+            async function getIndexTemplate(url) {
+                const indexHtml = await fs_1.promises.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((0, middleware_1.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(body_parser_1.default.raw({ type: '*/*' }));
+            return () => server.middlewares.use((0, middleware_1.hydrogenMiddleware)({
+                dev: true,
+                indexTemplate: getIndexTemplate,
+                getServerEntrypoint: () => server.ssrLoadModule(exports.HYDROGEN_DEFAULT_SERVER_ENTRY),
+                devServer: server,
+                cache: (pluginOptions === null || pluginOptions === void 0 ? void 0 : pluginOptions.devCache)
+                    ? new in_memory_1.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 (0, vite_1.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_1.promises.readdir(root);
+        configPath = files.find((file) => /^hydrogen\.config\.[jt]s$/.test(file));
+    }
+    if (configPath) {
+        configPath = (0, vite_1.normalizePath)(configPath);
+        if (!configPath.startsWith('/'))
+            configPath = path_1.default.resolve(root, configPath);
+    }
+    return (configPath ||
+        require.resolve('@shopify/hydrogen/dist/esnext/utilities/empty-hydrogen-config.js'));
+}

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

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

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

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-ignore
+const plugin_1 = __importDefault(require("@shopify/hydrogen/vendor/react-server-dom-vite/plugin"));
+const vite_plugin_hydrogen_middleware_1 = require("./vite-plugin-hydrogen-middleware");
+const vite_1 = require("vite");
+function default_1() {
+    return (0, plugin_1.default)({
+        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(vite_plugin_hydrogen_middleware_1.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 (0, vite_1.createServer)({
+                clearScreen: false,
+                server: { middlewareMode: 'ssr' },
+            });
+            await Promise.all([
+                // Load server entry to discover client components early
+                server.ssrLoadModule(vite_plugin_hydrogen_middleware_1.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 plugin_1.default.findClientComponentsFromServer(server);
+        },
+    });
+}
+exports.default = default_1;

package/dist/node/framework/plugins/vite-plugin-platform-entry.d.ts

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

package/dist/node/framework/plugins/vite-plugin-platform-entry.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vite_1 = require("vite");
+const vite_plugin_hydrogen_middleware_1 = require("./vite-plugin-hydrogen-middleware");
+const magic_string_1 = __importDefault(require("magic-string"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const SSR_BUNDLE_NAME = 'index.js';
+exports.default = () => {
+    let config;
+    let isESM;
+    return {
+        name: 'vite-plugin-platform-entry',
+        enforce: 'pre',
+        configResolved(_config) {
+            config = _config;
+            if (config.build.ssr) {
+                const { output = {} } = config.build.rollupOptions || {};
+                const { format = '' } = (Array.isArray(output) ? output[0] : output) || {};
+                isESM = Boolean(process.env.WORKER) || ['es', 'esm'].includes(format);
+            }
+        },
+        resolveId(source, importer) {
+            if ((0, vite_1.normalizePath)(source).includes('/hydrogen/platforms/')) {
+                const hydrogenPath = path_1.default.dirname(require.resolve('@shopify/hydrogen/package.json'));
+                const platformEntryName = source.split(path_1.default.sep).pop() || '';
+                const platformEntryPath = path_1.default.resolve(hydrogenPath, 'dist', 'esnext', 'platforms', platformEntryName);
+                return this.resolve(platformEntryPath, importer, {
+                    skipSelf: true,
+                });
+            }
+            return null;
+        },
+        transform(code, id) {
+            if ((0, vite_1.normalizePath)(id).includes('/hydrogen/dist/esnext/platforms/')) {
+                const ms = new magic_string_1.default(code);
+                ms.replace('__SERVER_ENTRY__', vite_plugin_hydrogen_middleware_1.HYDROGEN_DEFAULT_SERVER_ENTRY);
+                const indexTemplatePath = (0, vite_1.normalizePath)(path_1.default.resolve(config.root, config.build.outDir, '..', 'client', 'index.html'));
+                ms.replace('__INDEX_TEMPLATE__', indexTemplatePath);
+                return {
+                    code: ms.toString(),
+                    map: ms.generateMap({ file: id, source: id }),
+                };
+            }
+        },
+        generateBundle(options, bundle) {
+            if (config.build.ssr) {
+                const [key, value] = Object.entries(bundle).find(([, value]) => value.type === 'chunk' && value.isEntry);
+                delete bundle[key];
+                value.fileName = SSR_BUNDLE_NAME;
+                bundle[SSR_BUNDLE_NAME] = value;
+                // This ensures the file has a proper
+                // default export instead of exporting an
+                // object containing a 'default' property.
+                if (value.type === 'chunk' && !isESM) {
+                    value.code += `\nmodule.exports = exports.default || exports;`;
+                }
+            }
+        },
+        writeBundle(options) {
+            if (config.build.ssr && options.dir) {
+                const mainFile = `./${SSR_BUNDLE_NAME}`;
+                const packageJson = {
+                    type: isESM ? 'module' : 'commonjs',
+                    main: mainFile,
+                    exports: { '.': mainFile, [mainFile]: mainFile },
+                };
+                fs_1.default.writeFileSync(path_1.default.join(options.dir, 'package.json'), JSON.stringify(packageJson, null, 2), 'utf-8');
+            }
+        },
+    };
+};

package/dist/node/framework/plugins/vite-plugin-purge-query-cache.d.ts

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

package/dist/node/framework/plugins/vite-plugin-purge-query-cache.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = __importDefault(require("crypto"));
+exports.default = () => {
+    const buildCacheId = crypto_1.default.randomBytes(8).toString('hex').slice(0, 8);
+    return {
+        name: 'vite-plugin-purge-query-cache',
+        enforce: 'pre',
+        transform(code) {
+            return code.replace('__QUERY_CACHE_ID__', buildCacheId);
+        },
+    };
+};

package/dist/node/framework/plugins/vite-plugin-ssr-interop.d.ts

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

package/dist/node/framework/plugins/vite-plugin-ssr-interop.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = () => {
+    return {
+        name: 'vite-plugin-ssr-interop',
+        enforce: 'pre',
+        transform(code, id, options = {}) {
+            if (options.ssr && id.includes('foundation/ssr-interop')) {
+                return {
+                    code: code
+                        .replace(/(\s*META_ENV_SSR\s*=\s*)false/, '$1import.meta.env.SSR')
+                        .replace(/\/\/@SSR\s*/g, ''),
+                    map: { mappings: '' },
+                };
+            }
+        },
+    };
+};

package/dist/node/framework/runtime.d.ts

@@ -0,0 +1,13 @@
+export interface RuntimeContext {
+    waitUntil: (fn: Promise<any>) => void;
+}
+/**
+ * Set a global runtime context for the current request.
+ * This is used to encapsulate things like:
+ * - `waitUntil()` to run promises after request has ended
+ */
+export declare function setContext(ctx?: RuntimeContext): void;
+export declare function getContext(): RuntimeContext | undefined;
+export declare function setCache(cache?: Cache): void;
+export declare function getCache(): Cache | undefined;
+export declare function runDelayedFunction(fn: () => Promise<any>): void | Promise<any>;

package/dist/node/framework/runtime.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDelayedFunction = exports.getCache = exports.setCache = exports.getContext = exports.setContext = void 0;
+/**
+ * Set a global runtime context for the current request.
+ * This is used to encapsulate things like:
+ * - `waitUntil()` to run promises after request has ended
+ */
+function setContext(ctx) {
+    globalThis.__ctx = ctx;
+}
+exports.setContext = setContext;
+function getContext() {
+    return globalThis.__ctx;
+}
+exports.getContext = getContext;
+function setCache(cache) {
+    globalThis.__cache = cache;
+}
+exports.setCache = setCache;
+function getCache() {
+    return globalThis.__cache;
+}
+exports.getCache = getCache;
+function runDelayedFunction(fn) {
+    const context = getContext();
+    /**
+     * Runtimes (Oxygen, Node.js) might not have this.
+     */
+    if (!(context === null || context === void 0 ? void 0 : context.waitUntil)) {
+        return fn();
+    }
+    return context.waitUntil(fn());
+}
+exports.runDelayedFunction = runDelayedFunction;