@shopify/hydrogen 0.8.0 → 0.9.0

package/dist/node/utilities/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.decodeShopifyId = exports.graphqlRequestBody = exports.fetchBuilder = exports.parseMetafieldValue = exports.getMeasurementAsString = exports.getMeasurementAsParts = exports.isServer = exports.isClient = exports.flattenConnection = exports.wrapPromise = exports.loadScript = exports.useEmbeddedVideoUrl = exports.addParametersToEmbeddedVideoUrl = exports.shopifyImageLoader = exports.getShopifyImageDimensions = exports.useImageUrl = exports.addImageSizeParametersToUrl = void 0;
+exports.getTime = exports.decodeShopifyId = exports.graphqlRequestBody = exports.fetchBuilder = exports.parseMetafieldValue = exports.getMeasurementAsString = exports.getMeasurementAsParts = exports.isServer = exports.isClient = exports.flattenConnection = exports.wrapPromise = exports.loadScript = exports.useEmbeddedVideoUrl = exports.addParametersToEmbeddedVideoUrl = exports.shopifyImageLoader = exports.getShopifyImageDimensions = exports.useImageUrl = exports.addImageSizeParametersToUrl = void 0;
 var image_size_1 = require("./image_size");
 Object.defineProperty(exports, "addImageSizeParametersToUrl", { enumerable: true, get: function () { return image_size_1.addImageSizeParametersToUrl; } });
 Object.defineProperty(exports, "useImageUrl", { enumerable: true, get: function () { return image_size_1.useImageUrl; } });
@@ -28,3 +28,5 @@ var fetch_1 = require("./fetch");
 Object.defineProperty(exports, "fetchBuilder", { enumerable: true, get: function () { return fetch_1.fetchBuilder; } });
 Object.defineProperty(exports, "graphqlRequestBody", { enumerable: true, get: function () { return fetch_1.graphqlRequestBody; } });
 Object.defineProperty(exports, "decodeShopifyId", { enumerable: true, get: function () { return fetch_1.decodeShopifyId; } });
+var timing_1 = require("./timing");
+Object.defineProperty(exports, "getTime", { enumerable: true, get: function () { return timing_1.getTime; } });

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

@@ -0,0 +1,17 @@
+import { ServerComponentRequest } from '../../framework/Hydration/ServerComponentRequest.server';
+/** A utility for logging debugging, warning, and error information about the application.
+ * Use by importing `log` `@shopify/hydrogen` or by using a `log` prop passed to each page
+ * component. Using the latter is ideal, because it will ty your log to the current request in progress.
+ */
+export interface Logger {
+    trace: (...args: Array<any>) => void;
+    debug: (...args: Array<any>) => void;
+    warn: (...args: Array<any>) => void;
+    error: (...args: Array<any>) => void;
+    fatal: (...args: Array<any>) => void;
+}
+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' | 'api', log: Logger, request: ServerComponentRequest, responseStatus: number): void;

package/dist/node/utilities/log/log.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logServerResponse = exports.log = exports.resetLogger = exports.setLogger = exports.getLoggerFromContext = void 0;
+const kolorist_1 = require("kolorist");
+const timing_1 = require("../timing");
+const defaultLogger = {
+    trace(context, ...args) {
+        console.log(...args);
+    },
+    debug(context, ...args) {
+        console.log(...args);
+    },
+    warn(context, ...args) {
+        console.warn((0, kolorist_1.yellow)('WARN: '), ...args);
+    },
+    error(context, ...args) {
+        console.error((0, kolorist_1.red)('ERROR: '), ...args);
+    },
+    fatal(context, ...args) {
+        console.error((0, kolorist_1.red)('FATAL: '), ...args);
+    },
+};
+let logger = defaultLogger;
+function getLoggerFromContext(context) {
+    return {
+        trace: (...args) => logger.trace(context, ...args),
+        debug: (...args) => logger.debug(context, ...args),
+        warn: (...args) => logger.warn(context, ...args),
+        error: (...args) => logger.error(context, ...args),
+        fatal: (...args) => logger.fatal(context, ...args),
+    };
+}
+exports.getLoggerFromContext = getLoggerFromContext;
+function setLogger(newLogger) {
+    logger = newLogger;
+}
+exports.setLogger = setLogger;
+function resetLogger() {
+    logger = defaultLogger;
+}
+exports.resetLogger = resetLogger;
+exports.log = {
+    trace(...args) {
+        return logger.trace({}, ...args);
+    },
+    debug(...args) {
+        return logger.debug({}, ...args);
+    },
+    warn(...args) {
+        return logger.warn({}, ...args);
+    },
+    error(...args) {
+        return logger.error({}, ...args);
+    },
+    fatal(...args) {
+        return logger.fatal({}, ...args);
+    },
+};
+const SERVER_RESPONSE_MAP = {
+    str: 'streaming SSR',
+    rsc: 'server Components',
+    ssr: 'buffered SSR',
+};
+function logServerResponse(type, log, request, responseStatus) {
+    const coloredResponseStatus = responseStatus >= 500
+        ? (0, kolorist_1.red)(responseStatus)
+        : responseStatus >= 400
+            ? (0, kolorist_1.yellow)(responseStatus)
+            : responseStatus >= 300
+                ? (0, kolorist_1.lightBlue)(responseStatus)
+                : (0, kolorist_1.green)(responseStatus);
+    const fullType = SERVER_RESPONSE_MAP[type] || type;
+    const styledType = (0, kolorist_1.italic)(pad(fullType, '                 '));
+    const paddedTiming = pad(((0, timing_1.getTime)() - request.time).toFixed(2) + ' ms', '          ');
+    const url = type === 'rsc'
+        ? decodeURIComponent(request.url.substring(request.url.indexOf('=') + 1))
+        : request.url;
+    log.debug(`${request.method} ${styledType} ${coloredResponseStatus} ${paddedTiming} ${url}`);
+}
+exports.logServerResponse = logServerResponse;
+function pad(str, _pad) {
+    return (str + _pad).substring(0, _pad.length);
+}

package/dist/node/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/node/utilities/matchPath.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchPath = void 0;
+const path_to_regexp_1 = require("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 = (0, path_to_regexp_1.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.
+ */
+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);
+}
+exports.matchPath = matchPath;

package/dist/node/utilities/timing.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Not all environments have access to Performance.now(). This is to prevent
+ * timing side channel attacks.
+ *
+ * See: https://community.cloudflare.com/t/cloudflare-workers-how-do-i-measure-execution-time-of-my-method/69672
+ */
+export declare function getTime(): number;

package/dist/node/utilities/timing.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTime = void 0;
+/**
+ * Not all environments have access to Performance.now(). This is to prevent
+ * timing side channel attacks.
+ *
+ * See: https://community.cloudflare.com/t/cloudflare-workers-how-do-i-measure-execution-time-of-my-method/69672
+ */
+function getTime() {
+    if (typeof performance !== 'undefined' && performance.now) {
+        return performance.now();
+    }
+    else {
+        return Date.now();
+    }
+}
+exports.getTime = getTime;

package/dist/node/version.d.ts

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

package/dist/node/version.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LIB_VERSION = void 0;
-exports.LIB_VERSION = '0.8.0';
+exports.LIB_VERSION = '0.9.0';

package/dist/worker/framework/Hydration/ServerComponentRequest.server.d.ts

@@ -7,6 +7,7 @@
  */
 export declare class ServerComponentRequest extends Request {
     cookies: Map<string, string>;
+    time: number;
     constructor(input: any);
     constructor(input: RequestInfo, init?: RequestInit);
     private parseCookies;

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

@@ -1,3 +1,4 @@
+import { getTime } from '../../utilities/timing';
 /**
  * This augments the `Request` object from the Fetch API:
  * @see https://developer.mozilla.org/en-US/docs/Web/API/Request
@@ -14,8 +15,12 @@ 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();
         this.cookies = this.parseCookies();
     }
     parseCookies() {

package/dist/worker/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,13 +22,23 @@ 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.`);
     }
-    const isStreamable = streamableResponse && isStreamableRequest(url);
+    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);
     /**
      * Stream back real-user responses, but for bots/etc,
      * use `render` instead. This is because we need to inject <head>
@@ -35,7 +46,12 @@ export default async function handleEvent(event, { request, entrypoint, indexTem
      */
     if (isStreamable) {
         if (isReactHydrationRequest) {
-            hydrate(url, { context: {}, request, response: streamableResponse, dev });
+            hydrate(url, {
+                context: {},
+                request,
+                response: streamableResponse,
+                dev,
+            });
         }
         else {
             stream(url, {
@@ -48,7 +64,12 @@ export default async function handleEvent(event, { request, entrypoint, indexTem
         }
         return;
     }
-    const { body, bodyAttributes, htmlAttributes, componentResponse, ...head } = await render(url, { request, context: {}, isReactHydrationRequest, dev });
+    const { body, bodyAttributes, htmlAttributes, componentResponse, ...head } = await render(url, {
+        request,
+        context: {},
+        isReactHydrationRequest,
+        dev,
+    });
     const headers = componentResponse.headers;
     /**
      * TODO: Also add `Vary` headers for `accept-language` and any other keys
@@ -86,13 +107,6 @@ export default async function handleEvent(event, { request, entrypoint, indexTem
     }
     return response;
 }
-function isStreamableRequest(url) {
-    /**
-     * TODO: Add UA detection.
-     */
-    const isBot = url.searchParams.has('_bot');
-    return !isBot;
-}
 /**
  * Generate the contents of the `head` tag, and update the existing `<title>` tag
  * if one exists, and if a title is passed.
@@ -117,3 +131,57 @@ function generateHeadTag(head) {
         return `<head>${headHtml}</head>`;
     };
 }
+/**
+ * Determines if the request is from a bot, using the URL and User Agent
+ */
+function isBotUA(url, userAgent) {
+    return (url.searchParams.has('_bot') || (!!userAgent && botUARegex.test(userAgent)));
+}
+/**
+ * An alphabetized list of User Agents of known bots, combined from lists found at:
+ * https://github.com/vercel/next.js/blob/d87dc2b5a0b3fdbc0f6806a47be72bad59564bd0/packages/next/server/utils.ts#L18-L22
+ * https://github.com/GoogleChrome/rendertron/blob/6f681688737846b28754fbfdf5db173846a826df/middleware/src/middleware.ts#L24-L41
+ */
+const botUserAgents = [
+    'AdsBot-Google',
+    'applebot',
+    'Baiduspider',
+    'baiduspider',
+    'bingbot',
+    'Bingbot',
+    'BingPreview',
+    'bitlybot',
+    'Discordbot',
+    'DuckDuckBot',
+    'Embedly',
+    'facebookcatalog',
+    'facebookexternalhit',
+    'Google-PageRenderer',
+    'Googlebot',
+    'googleweblight',
+    'ia_archive',
+    'LinkedInBot',
+    'Mediapartners-Google',
+    'outbrain',
+    'pinterest',
+    'quora link preview',
+    'redditbot',
+    'rogerbot',
+    'showyoubot',
+    'SkypeUriPreview',
+    'Slackbot',
+    'Slurp',
+    'sogou',
+    'Storebot-Google',
+    'TelegramBot',
+    'tumblr',
+    'Twitterbot',
+    'vkShare',
+    'W3C_Validator',
+    'WhatsApp',
+    'yandex',
+];
+/**
+ * Creates a regex based on the botUserAgents array
+ */
+const botUARegex = new RegExp(botUserAgents.join('|'), 'i');

package/dist/worker/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/worker/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/worker/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/worker/utilities/log/log.d.ts

@@ -0,0 +1,17 @@
+import { ServerComponentRequest } from '../../framework/Hydration/ServerComponentRequest.server';
+/** A utility for logging debugging, warning, and error information about the application.
+ * Use by importing `log` `@shopify/hydrogen` or by using a `log` prop passed to each page
+ * component. Using the latter is ideal, because it will ty your log to the current request in progress.
+ */
+export interface Logger {
+    trace: (...args: Array<any>) => void;
+    debug: (...args: Array<any>) => void;
+    warn: (...args: Array<any>) => void;
+    error: (...args: Array<any>) => void;
+    fatal: (...args: Array<any>) => void;
+}
+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' | 'api', log: Logger, request: ServerComponentRequest, responseStatus: number): void;

package/dist/worker/utilities/log/log.js

@@ -0,0 +1,76 @@
+import { yellow, red, green, italic, lightBlue } from 'kolorist';
+import { getTime } from '../timing';
+const defaultLogger = {
+    trace(context, ...args) {
+        console.log(...args);
+    },
+    debug(context, ...args) {
+        console.log(...args);
+    },
+    warn(context, ...args) {
+        console.warn(yellow('WARN: '), ...args);
+    },
+    error(context, ...args) {
+        console.error(red('ERROR: '), ...args);
+    },
+    fatal(context, ...args) {
+        console.error(red('FATAL: '), ...args);
+    },
+};
+let logger = defaultLogger;
+export function getLoggerFromContext(context) {
+    return {
+        trace: (...args) => logger.trace(context, ...args),
+        debug: (...args) => logger.debug(context, ...args),
+        warn: (...args) => logger.warn(context, ...args),
+        error: (...args) => logger.error(context, ...args),
+        fatal: (...args) => logger.fatal(context, ...args),
+    };
+}
+export function setLogger(newLogger) {
+    logger = newLogger;
+}
+export function resetLogger() {
+    logger = defaultLogger;
+}
+export const log = {
+    trace(...args) {
+        return logger.trace({}, ...args);
+    },
+    debug(...args) {
+        return logger.debug({}, ...args);
+    },
+    warn(...args) {
+        return logger.warn({}, ...args);
+    },
+    error(...args) {
+        return logger.error({}, ...args);
+    },
+    fatal(...args) {
+        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)
+        : responseStatus >= 400
+            ? yellow(responseStatus)
+            : responseStatus >= 300
+                ? lightBlue(responseStatus)
+                : green(responseStatus);
+    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'
+        ? decodeURIComponent(request.url.substring(request.url.indexOf('=') + 1))
+        : request.url;
+    log.debug(`${request.method} ${styledType} ${coloredResponseStatus} ${paddedTiming} ${url}`);
+}
+function pad(str, _pad) {
+    return (str + _pad).substring(0, _pad.length);
+}

package/dist/worker/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 {};