@shopify/hydrogen 0.8.3 → 0.9.0

package/dist/esnext/components/ProductProvider/ProductProvider.client.d.ts

@@ -1,4 +1,5 @@
 import { ReactNode } from 'react';
+import { useProductOptions } from '../../hooks';
 import { Product } from './types';
 /**
  * The `ProductProvider` component sets up a context with product details. Descendents of
@@ -9,8 +10,8 @@ export declare function ProductProvider({ children, product, initialVariantId, }
     children: ReactNode;
     /** A [Product object](/api/storefront/reference/products/product). */
     product: Product;
-    /** The initially selected variant. */
-    initialVariantId: string;
+    /** The initially selected variant. This is required only if you're using a `SelectedVariantX` hook in the `ProductProvider` component.*/
+    initialVariantId?: Parameters<typeof useProductOptions>['0']['initialVariantId'];
 }): JSX.Element;
 export declare namespace ProductProvider {
     var Fragment: string;

package/dist/esnext/entry-server.js

@@ -5,7 +5,7 @@ renderToPipeableStream, // Only available in Node context
 // @ts-ignore
 renderToReadableStream, // Only available in Browser/Worker context
  } from 'react-dom/server';
-import { logServerResponse, getLoggerFromContext, } from './utilities/log/log';
+import { logServerResponse, getLoggerFromContext, log, } from './utilities/log/log';
 import { renderToString } from 'react-dom/server';
 import { getErrorMarkup } from './utilities/error';
 import ssrPrepass from 'react-ssr-prepass';
@@ -18,6 +18,7 @@ import { HydrationWriter } from './framework/Hydration/writer.server';
 import { ServerComponentResponse } from './framework/Hydration/ServerComponentResponse.server';
 import { getCacheControlHeader } from './framework/cache';
 import { RenderCacheProvider } from './foundation/RenderCacheProvider';
+import { getApiRouteFromURL, getApiRoutesFromPages } from './utilities/apiRoutes';
 /**
  * react-dom/unstable-fizz provides different entrypoints based on runtime:
  * - `renderToReadableStream` for "browser" (aka worker)
@@ -30,7 +31,7 @@ const isWorker = Boolean(renderToReadableStream);
  * on the client to hydrate and build the React tree.
  */
 const STREAM_ABORT_TIMEOUT_MS = 3000;
-const renderHydrogen = (App, hook) => {
+const renderHydrogen = (App, { pages } = {}, hook) => {
     /**
      * The render function is responsible for turning the provided `App` into an HTML string,
      * and returning any initial state that needs to be hydrated into the client version of the app.
@@ -49,6 +50,7 @@ const renderHydrogen = (App, hook) => {
             request,
             dev,
             log,
+            pages,
         });
         const body = await renderApp(ReactApp, state, log, isReactHydrationRequest);
         logServerResponse('ssr', log, request, (_f = (_d = (_c = componentResponse.customStatus) === null || _c === void 0 ? void 0 : _c.code) !== null && _d !== void 0 ? _d : componentResponse.status) !== null && _f !== void 0 ? _f : 200);
@@ -78,6 +80,7 @@ const renderHydrogen = (App, hook) => {
             request,
             dev,
             log,
+            pages,
         });
         response.socket.on('error', (error) => {
             log.fatal(error);
@@ -151,6 +154,7 @@ const renderHydrogen = (App, hook) => {
             request,
             dev,
             log,
+            pages,
         });
         response.socket.on('error', (error) => {
             log.fatal(error);
@@ -183,13 +187,19 @@ const renderHydrogen = (App, hook) => {
             log.error(`The app failed to render RSC after ${STREAM_ABORT_TIMEOUT_MS} ms`);
         }, STREAM_ABORT_TIMEOUT_MS);
     };
+    function getApiRoute(url) {
+        const routes = getApiRoutesFromPages(pages);
+        return getApiRouteFromURL(url, routes);
+    }
     return {
         render,
         stream,
         hydrate,
+        getApiRoute,
+        log,
     };
 };
-function buildReactApp({ App, state, context, request, dev, log, }) {
+function buildReactApp({ App, state, context, request, dev, log, pages, }) {
     const renderCache = {};
     const helmetContext = {};
     const componentResponse = new ServerComponentResponse();
@@ -201,7 +211,7 @@ function buildReactApp({ App, state, context, request, dev, log, }) {
     const ReactApp = (props) => (React.createElement(RenderCacheProvider, { cache: renderCache },
         React.createElement(StaticRouter, { location: { pathname: state.pathname, search: state.search }, context: context },
             React.createElement(HelmetProvider, { context: helmetContext },
-                React.createElement(App, { ...props, ...hydrogenServerProps })))));
+                React.createElement(App, { ...props, ...hydrogenServerProps, pages: pages })))));
     return { helmetContext, ReactApp, componentResponse };
 }
 function extractHeadElements(helmetContext) {

package/dist/esnext/foundation/Router/DefaultRoutes.d.ts

@@ -1,6 +1,6 @@
 import { ReactElement } from 'react';
-import type { Logger } from '../../utilities/log/log';
-export declare type ImportGlobEagerOutput = Record<string, Record<'default', any>>;
+import { Logger } from '../../utilities/log/log';
+import type { ImportGlobEagerOutput } from '../../types';
 /**
  * Build a set of default Hydrogen routes based on the output provided by Vite's
  * import.meta.globEager method.

package/dist/esnext/foundation/Router/DefaultRoutes.js

@@ -16,7 +16,8 @@ export function DefaultRoutes({ pages, serverState, fallback, log, }) {
 }
 export function createRoutesFromPages(pages, topLevelPath = '*') {
     const topLevelPrefix = topLevelPath.replace('*', '').replace(/\/$/, '');
-    const routes = Object.keys(pages).map((key) => {
+    const routes = Object.keys(pages)
+        .map((key) => {
         const path = key
             .replace('./pages', '')
             .replace(/\.server\.(t|j)sx?$/, '')
@@ -38,12 +39,15 @@ export function createRoutesFromPages(pages, topLevelPath = '*') {
          * https://reactrouter.com/core/api/Route/exact-bool
          */
         const exact = !/\[(?:[.]{3})(\w+?)\]/.test(key);
+        if (!pages[key].default && !pages[key].api)
+            throw new Error(`${key} doesn't export a default React component or an API function`);
         return {
             path: topLevelPrefix + path,
             component: pages[key].default,
             exact,
         };
-    });
+    })
+        .filter((route) => route.component);
     /**
      * Place static paths BEFORE dynamic paths to grant priority.
      */

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

@@ -14,7 +14,8 @@ key,
 queryFn, 
 /** Options including `cache` to manage the cache behavior of the sub-request. */
 queryOptions) {
-    return useRenderCacheData(key, cachedQueryFnBuilder(key, queryFn, queryOptions));
+    const withCacheIdKey = ['__QUERY_CACHE_ID__', ...key];
+    return useRenderCacheData(withCacheIdKey, cachedQueryFnBuilder(withCacheIdKey, queryFn, queryOptions));
 }
 function cachedQueryFnBuilder(key, queryFn, queryOptions) {
     const resolvedQueryOptions = {

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

@@ -15,6 +15,9 @@ export class ServerComponentRequest extends Request {
             super(getUrlFromNodeRequest(input), {
                 headers: new Headers(input.headers),
                 method: input.method,
+                body: input.method !== 'GET' && input.method !== 'HEAD'
+                    ? input.body
+                    : undefined,
             });
         }
         this.time = getTime();

package/dist/esnext/framework/middleware.js

@@ -16,32 +16,24 @@ export function graphiqlMiddleware({ shopifyConfig, dev, }) {
 export function hydrogenMiddleware({ dev, cache, indexTemplate, getServerEntrypoint, devServer, }) {
     return async function (request, response, next) {
         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');
+                const { fetch, Request, Response, Headers } = await import('undici');
+                const { default: AbortController } = await import('abort-controller');
+                // @ts-ignore
+                globalThis.fetch = fetch;
                 // @ts-ignore
-                globalThis.fetch = fetch.default;
+                globalThis.Request = Request;
                 // @ts-ignore
-                globalThis.Request = fetch.Request;
+                globalThis.Response = Response;
                 // @ts-ignore
-                globalThis.Response = fetch.Response;
+                globalThis.Headers = Headers;
                 // @ts-ignore
-                globalThis.Headers = fetch.Headers;
+                globalThis.AbortController = AbortController;
             }
             /**
              * Dynamically import ServerComponentResponse after the `fetch`
@@ -69,7 +61,18 @@ export function hydrogenMiddleware({ dev, cache, indexTemplate, getServerEntrypo
                     response.setHeader(key, value);
                 });
                 response.statusCode = eventResponse.status;
-                response.end(eventResponse.body);
+                if (eventResponse.body) {
+                    const reader = eventResponse.body.getReader();
+                    while (true) {
+                        const { done, value } = await reader.read();
+                        if (done)
+                            return response.end();
+                        response.write(value);
+                    }
+                }
+                else {
+                    response.end();
+                }
             }
         }
         catch (e) {
@@ -99,11 +102,6 @@ export function hydrogenMiddleware({ dev, cache, indexTemplate, getServerEntrypo
         }
     };
 }
-function shouldInterceptRequest(request, isReactHydrationRequest) {
-    var _a;
-    return (/text\/html|application\/hydrogen/.test((_a = request.headers['accept']) !== null && _a !== void 0 ? _a : '') ||
-        isReactHydrationRequest);
-}
 /**
  * /graphiql and /___graphql are supported
  */

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

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

package/dist/esnext/framework/plugin.js

@@ -1,14 +1,16 @@
 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 purgeQueryCache from './plugins/vite-plugin-purge-query-cache';
 import inspect from 'vite-plugin-inspect';
 import react from '@vitejs/plugin-react';
-export default (shopifyConfig, pluginOptions) => {
+export default (shopifyConfig, pluginOptions = {}) => {
     return [
         process.env.VITE_INSPECT && inspect(),
         hydrogenConfig(),
         hydrogenMiddleware(shopifyConfig, pluginOptions),
         reactServerComponentShim(),
         react(),
+        pluginOptions.purgeQueryCacheOnBuild && purgeQueryCache(),
     ];
 };

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

@@ -1,4 +1,5 @@
 import { loadEnv } from 'vite';
+import bodyParser from 'body-parser';
 import path from 'path';
 import { promises as fs } from 'fs';
 import { hydrogenMiddleware, graphiqlMiddleware } from '../middleware';
@@ -25,6 +26,7 @@ export default (shopifyConfig, pluginOptions) => {
                 shopifyConfig,
                 dev: true,
             }));
+            server.middlewares.use(bodyParser.raw({ type: '*/*' }));
             return () => server.middlewares.use(hydrogenMiddleware({
                 dev: true,
                 shopifyConfig,

package/dist/esnext/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/esnext/framework/plugins/vite-plugin-purge-query-cache.js

@@ -0,0 +1,11 @@
+import Crypto from 'crypto';
+export default () => {
+    const buildCacheId = Crypto.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/esnext/handle-event.js

@@ -1,6 +1,7 @@
 import { getCacheControlHeader } from './framework/cache';
 import { setContext, setCache } from './framework/runtime';
 import { setConfig } from './framework/config';
+import { renderApiRoute } from './utilities/apiRoutes';
 export default async function handleEvent(event, { request, entrypoint, indexTemplate, assetHandler, streamableResponse, dev, cache, context, }) {
     var _a, _b, _c, _d, _e;
     const url = new URL(request.url);
@@ -21,12 +22,21 @@ export default async function handleEvent(event, { request, entrypoint, indexTem
         assetHandler) {
         return assetHandler(event, url);
     }
-    const { render, hydrate, stream } = entrypoint.default || entrypoint;
+    const { render, hydrate, stream, getApiRoute, log } = entrypoint.default || entrypoint;
     // @ts-ignore
-    if (dev && !(render && hydrate && stream)) {
+    if (dev && !(render && hydrate && stream && getApiRoute)) {
         throw new Error(`entry-server.jsx could not be loaded. This likely occurred because of a Vite compilation error.\n` +
             `Please check your server logs for more information.`);
     }
+    if (!isReactHydrationRequest) {
+        const apiRoute = getApiRoute(url);
+        // The API Route might have a default export, making it also a server component
+        // If it does, only render the API route if the request method is GET
+        if (apiRoute &&
+            (!apiRoute.hasServerComponent || request.method !== 'GET')) {
+            return renderApiRoute(request, apiRoute, log);
+        }
+    }
     const userAgent = request.headers.get('user-agent');
     const isStreamable = streamableResponse && !isBotUA(url, userAgent);
     /**

package/dist/esnext/types.d.ts

@@ -3,6 +3,8 @@ import { ServerResponse } from 'http';
 import type { ServerComponentResponse } from './framework/Hydration/ServerComponentResponse.server';
 import type { ServerComponentRequest } from './framework/Hydration/ServerComponentRequest.server';
 import type { Metafield, Image, MediaContentType } from './graphql/types/types';
+import { ApiRouteMatch } from './utilities/apiRoutes';
+import { Logger } from './utilities/log/log';
 export declare type Renderer = (url: URL, options: {
     request: ServerComponentRequest;
     context?: Record<string, any>;
@@ -29,6 +31,8 @@ export declare type EntryServerHandler = {
     render: Renderer;
     stream: Streamer;
     hydrate: Hydrator;
+    getApiRoute: (url: URL) => ApiRouteMatch | null;
+    log: Logger;
 };
 export declare type ShopifyConfig = {
     locale?: string;
@@ -39,11 +43,11 @@ export declare type ShopifyConfig = {
 export declare type Hook = (params: {
     url: URL;
 } & Record<string, any>) => any | Promise<any>;
-export declare type ServerHandler = (App: any, hook?: Hook) => {
-    render: Renderer;
-    stream: Streamer;
-    hydrate: Hydrator;
+export declare type ImportGlobEagerOutput = Record<string, Record<'default' | 'api', any>>;
+export declare type ServerHandlerConfig = {
+    pages?: ImportGlobEagerOutput;
 };
+export declare type ServerHandler = (App: any, config?: ServerHandlerConfig, hook?: Hook) => EntryServerHandler;
 export declare type ClientHandler = (App: any, hook?: Hook) => Promise<void>;
 export interface GraphQLConnection<T> {
     edges?: {
@@ -87,5 +91,6 @@ export interface CacheOptions {
 }
 export interface HydrogenVitePluginOptions {
     devCache?: boolean;
+    purgeQueryCacheOnBuild?: boolean;
 }
 export {};

package/dist/esnext/utilities/apiRoutes.d.ts

@@ -0,0 +1,21 @@
+import { ImportGlobEagerOutput } from '../types';
+import { Logger } from '../utilities/log/log';
+declare type RouteParams = Record<string, string>;
+declare type RequestOptions = {
+    params: RouteParams;
+};
+declare type ResourceGetter = (request: Request, requestOptions: RequestOptions) => Promise<Response>;
+interface HydrogenApiRoute {
+    path: string;
+    resource: ResourceGetter;
+    hasServerComponent: boolean;
+}
+export declare type ApiRouteMatch = {
+    resource: ResourceGetter;
+    hasServerComponent: boolean;
+    params: RouteParams;
+};
+export declare function getApiRoutesFromPages(pages: ImportGlobEagerOutput | undefined, topLevelPath?: string): Array<HydrogenApiRoute>;
+export declare function getApiRouteFromURL(url: URL, routes: Array<HydrogenApiRoute>): ApiRouteMatch | null;
+export declare function renderApiRoute(request: Request, route: ApiRouteMatch, log: Logger): Promise<Response>;
+export {};

package/dist/esnext/utilities/apiRoutes.js

@@ -0,0 +1,73 @@
+import { matchPath } from './matchPath';
+import { logServerResponse } from '../utilities/log/log';
+let cachedRoutes = [];
+export function getApiRoutesFromPages(pages, topLevelPath = '*') {
+    if ((cachedRoutes === null || cachedRoutes === void 0 ? void 0 : cachedRoutes.length) || !pages)
+        return cachedRoutes;
+    const topLevelPrefix = topLevelPath.replace('*', '').replace(/\/$/, '');
+    const routes = Object.keys(pages)
+        .filter((key) => pages[key].api)
+        .map((key) => {
+        const path = key
+            .replace('./pages', '')
+            .replace(/\.server\.(t|j)sx?$/, '')
+            /**
+             * Replace /index with /
+             */
+            .replace(/\/index$/i, '/')
+            /**
+             * Only lowercase the first letter. This allows the developer to use camelCase
+             * dynamic paths while ensuring their standard routes are normalized to lowercase.
+             */
+            .replace(/\b[A-Z]/, (firstLetter) => firstLetter.toLowerCase())
+            /**
+             * Convert /[handle].jsx and /[...handle].jsx to /:handle.jsx for react-router-dom
+             */
+            .replace(/\[(?:[.]{3})?(\w+?)\]/g, (_match, param) => `:${param}`);
+        /**
+         * Catch-all routes [...handle].jsx don't need an exact match
+         * https://reactrouter.com/core/api/Route/exact-bool
+         */
+        const exact = !/\[(?:[.]{3})(\w+?)\]/.test(key);
+        return {
+            path: topLevelPrefix + path,
+            resource: pages[key].api,
+            hasServerComponent: !!pages[key].default,
+            exact,
+        };
+    });
+    cachedRoutes = [
+        ...routes.filter((route) => !route.path.includes(':')),
+        ...routes.filter((route) => route.path.includes(':')),
+    ];
+    return cachedRoutes;
+}
+export function getApiRouteFromURL(url, routes) {
+    let foundRoute, foundRouteDetails;
+    for (let i = 0; i < routes.length; i++) {
+        foundRouteDetails = matchPath(url.pathname, routes[i]);
+        if (foundRouteDetails) {
+            foundRoute = routes[i];
+            break;
+        }
+    }
+    if (!foundRoute)
+        return null;
+    return {
+        resource: foundRoute.resource,
+        params: foundRouteDetails.params,
+        hasServerComponent: foundRoute.hasServerComponent,
+    };
+}
+export async function renderApiRoute(request, route, log) {
+    let response;
+    try {
+        response = await route.resource(request, { params: route.params });
+    }
+    catch (e) {
+        log.error(e);
+        response = new Response('Error processing: ' + request.url, { status: 500 });
+    }
+    logServerResponse('api', log, request, response.status);
+    return response;
+}

package/dist/esnext/utilities/flattenConnection/flattenConnection.d.ts

@@ -1,5 +1,5 @@
 import { GraphQLConnection } from '../../types';
 /**
- * The `flattenConnection` utility transforms a connection object from the Storefront API (for example, [Product-related connections](api/storefront/reference/products/product#connections)) into a flat array of nodes.
+ * The `flattenConnection` utility transforms a connection object from the Storefront API (for example, [Product-related connections](/api/storefront/reference/products/product)) into a flat array of nodes.
  */
 export declare function flattenConnection<T>(connection: GraphQLConnection<T>): T[];

package/dist/esnext/utilities/flattenConnection/flattenConnection.js

@@ -1,5 +1,5 @@
 /**
- * The `flattenConnection` utility transforms a connection object from the Storefront API (for example, [Product-related connections](api/storefront/reference/products/product#connections)) into a flat array of nodes.
+ * The `flattenConnection` utility transforms a connection object from the Storefront API (for example, [Product-related connections](/api/storefront/reference/products/product)) into a flat array of nodes.
  */
 export function flattenConnection(connection) {
     var _a;

package/dist/esnext/utilities/log/log.d.ts

@@ -14,4 +14,4 @@ export declare function getLoggerFromContext(context: any): Logger;
 export declare function setLogger(newLogger: Logger): void;
 export declare function resetLogger(): void;
 export declare const log: Logger;
-export declare function logServerResponse(type: 'str' | 'rsc' | 'ssr', log: Logger, request: ServerComponentRequest, responseStatus: number): void;
+export declare function logServerResponse(type: 'str' | 'rsc' | 'ssr' | 'api', log: Logger, request: ServerComponentRequest, responseStatus: number): void;

package/dist/esnext/utilities/log/log.js

@@ -50,6 +50,11 @@ export const log = {
         return logger.fatal({}, ...args);
     },
 };
+const SERVER_RESPONSE_MAP = {
+    str: 'streaming SSR',
+    rsc: 'server Components',
+    ssr: 'buffered SSR',
+};
 export function logServerResponse(type, log, request, responseStatus) {
     const coloredResponseStatus = responseStatus >= 500
         ? red(responseStatus)
@@ -58,11 +63,7 @@ export function logServerResponse(type, log, request, responseStatus) {
             : responseStatus >= 300
                 ? lightBlue(responseStatus)
                 : green(responseStatus);
-    const fullType = type === 'str'
-        ? 'streaming SSR'
-        : type === 'rsc'
-            ? 'server components'
-            : 'buffered SSR';
+    const fullType = SERVER_RESPONSE_MAP[type] || type;
     const styledType = italic(pad(fullType, '                 '));
     const paddedTiming = pad((getTime() - request.time).toFixed(2) + ' ms', '          ');
     const url = type === 'rsc'

package/dist/esnext/utilities/matchPath.d.ts

@@ -0,0 +1,10 @@
+import { TokensToRegexpOptions } from 'path-to-regexp';
+interface MatchPathOptions extends TokensToRegexpOptions {
+    path?: string;
+    exact?: boolean;
+}
+/**
+ * Public API for matching a URL pathname to a path.
+ */
+export declare function matchPath(pathname: string, options?: MatchPathOptions): any;
+export {};

package/dist/esnext/utilities/matchPath.js

@@ -0,0 +1,54 @@
+import { pathToRegexp } from 'path-to-regexp';
+// Modified from React Router v5
+// https://github.com/remix-run/react-router/blob/v5/packages/react-router/modules/matchPath.js
+const cache = {};
+const cacheLimit = 10000;
+let cacheCount = 0;
+function compilePath(path, options) {
+    const cacheKey = `${options.end}${options.strict}${options.sensitive}`;
+    const pathCache = cache[cacheKey] || (cache[cacheKey] = {});
+    if (pathCache[path])
+        return pathCache[path];
+    const keys = [];
+    const regexp = pathToRegexp(path, keys, options);
+    const result = { regexp, keys };
+    if (cacheCount < cacheLimit) {
+        pathCache[path] = result;
+        cacheCount++;
+    }
+    return result;
+}
+/**
+ * Public API for matching a URL pathname to a path.
+ */
+export function matchPath(pathname, options = {}) {
+    const { path, exact = false, strict = false, sensitive = false } = options;
+    const paths = [].concat(path);
+    return paths.reduce((matched, path) => {
+        if (!path && path !== '')
+            return null;
+        if (matched)
+            return matched;
+        const { regexp, keys } = compilePath(path, {
+            end: exact,
+            strict,
+            sensitive,
+        });
+        const match = regexp.exec(pathname);
+        if (!match)
+            return null;
+        const [url, ...values] = match;
+        const isExact = pathname === url;
+        if (exact && !isExact)
+            return null;
+        return {
+            path,
+            url: path === '/' && url === '' ? '/' : url,
+            isExact,
+            params: keys.reduce((memo, key, index) => {
+                memo[key.name] = values[index];
+                return memo;
+            }, {}),
+        };
+    }, null);
+}

package/dist/esnext/version.d.ts

@@ -1 +1 @@
-export declare const LIB_VERSION = "0.8.3";
+export declare const LIB_VERSION = "0.9.0";

package/dist/esnext/version.js

@@ -1 +1 @@
-export const LIB_VERSION = '0.8.3';
+export const LIB_VERSION = '0.9.0';

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

@@ -18,6 +18,9 @@ class ServerComponentRequest extends Request {
             super(getUrlFromNodeRequest(input), {
                 headers: new Headers(input.headers),
                 method: input.method,
+                body: input.method !== 'GET' && input.method !== 'HEAD'
+                    ? input.body
+                    : undefined,
             });
         }
         this.time = (0, timing_1.getTime)();