@shopify/hydrogen 0.0.0-experimental-20220526194818

package/dist/node/utilities/image_size.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getShopifyImageDimensions = exports.shopifyImageLoader = exports.addImageSizeParametersToUrl = void 0;
+// TODO: Are there other CDNs missing from here?
+const PRODUCTION_CDN_HOSTNAMES = [
+    'cdn.shopify.com',
+    'cdn.shopifycdn.net',
+    'shopify-assets.shopifycdn.com',
+    'shopify-assets.shopifycdn.net',
+];
+const LOCAL_CDN_HOSTNAMES = ['spin.dev'];
+const ALL_CDN_HOSTNAMES = [...PRODUCTION_CDN_HOSTNAMES, ...LOCAL_CDN_HOSTNAMES];
+/**
+ * Adds image size parameters to an image URL hosted by Shopify's CDN
+ */
+function addImageSizeParametersToUrl({ src, width, height, crop, scale, }) {
+    const newUrl = new URL(src);
+    width && newUrl.searchParams.append('width', width.toString());
+    height && newUrl.searchParams.append('height', height.toString());
+    crop && newUrl.searchParams.append('crop', crop);
+    scale && newUrl.searchParams.append('scale', scale.toString());
+    return newUrl.toString();
+}
+exports.addImageSizeParametersToUrl = addImageSizeParametersToUrl;
+function shopifyImageLoader(params) {
+    const newSrc = new URL(params.src);
+    const isShopifyServedImage = ALL_CDN_HOSTNAMES.some((allowedHostname) => newSrc.hostname.endsWith(allowedHostname));
+    if (!isShopifyServedImage ||
+        (!params.width && !params.height && !params.crop && !params.scale)) {
+        return params.src;
+    }
+    return addImageSizeParametersToUrl(params);
+}
+exports.shopifyImageLoader = shopifyImageLoader;
+function getShopifyImageDimensions(image, options) {
+    // Storefront API could return null dimension values for images that are not hosted on Shopify CDN
+    // The API dimensions references the image's intrinstic/natural dimensions and provides image aspect ratio information
+    const apiWidth = image.width;
+    const apiHeight = image.height;
+    if (apiWidth && apiHeight && ((options === null || options === void 0 ? void 0 : options.width) || (options === null || options === void 0 ? void 0 : options.height))) {
+        const optionWidth = (options === null || options === void 0 ? void 0 : options.width)
+            ? parseInt(options.width.toString(), 10)
+            : undefined;
+        const optionHeight = (options === null || options === void 0 ? void 0 : options.height)
+            ? parseInt(options.height.toString(), 10)
+            : undefined;
+        // Use option defined width & height
+        if (optionWidth && optionHeight) {
+            return { width: optionWidth, height: optionHeight };
+        }
+        // Calculate width from aspect ratio
+        if (!optionWidth && optionHeight) {
+            return {
+                width: Math.round((apiWidth / apiHeight) * optionHeight),
+                height: optionHeight,
+            };
+        }
+        // Calculate height from aspect ratio
+        if (optionWidth && !optionHeight) {
+            return {
+                width: optionWidth,
+                height: Math.round((apiHeight / apiWidth) * optionWidth),
+            };
+        }
+    }
+    return { width: apiWidth, height: apiHeight };
+}
+exports.getShopifyImageDimensions = getShopifyImageDimensions;

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

@@ -0,0 +1,12 @@
+export { addImageSizeParametersToUrl, getShopifyImageDimensions, shopifyImageLoader, } from './image_size';
+export { YouTube, Vimeo, addParametersToEmbeddedVideoUrl, useEmbeddedVideoUrl, } from './video_parameters';
+export { loadScript } from './load_script';
+export { wrapPromise } from './suspense';
+export { flattenConnection } from './flattenConnection';
+export { isClient } from './isClient';
+export { isServer } from './isServer';
+export { getMeasurementAsParts, getMeasurementAsString } from './measurement';
+export { parseMetafieldValue } from './parseMetafieldValue';
+export { fetchBuilder, graphqlRequestBody, decodeShopifyId } from './fetch';
+export { getTime } from './timing';
+export { htmlEncode, htmlDecode } from './html-encoding';

package/dist/node/utilities/index.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.htmlDecode = exports.htmlEncode = 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.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, "getShopifyImageDimensions", { enumerable: true, get: function () { return image_size_1.getShopifyImageDimensions; } });
+Object.defineProperty(exports, "shopifyImageLoader", { enumerable: true, get: function () { return image_size_1.shopifyImageLoader; } });
+var video_parameters_1 = require("./video_parameters");
+Object.defineProperty(exports, "addParametersToEmbeddedVideoUrl", { enumerable: true, get: function () { return video_parameters_1.addParametersToEmbeddedVideoUrl; } });
+Object.defineProperty(exports, "useEmbeddedVideoUrl", { enumerable: true, get: function () { return video_parameters_1.useEmbeddedVideoUrl; } });
+var load_script_1 = require("./load_script");
+Object.defineProperty(exports, "loadScript", { enumerable: true, get: function () { return load_script_1.loadScript; } });
+var suspense_1 = require("./suspense");
+Object.defineProperty(exports, "wrapPromise", { enumerable: true, get: function () { return suspense_1.wrapPromise; } });
+var flattenConnection_1 = require("./flattenConnection");
+Object.defineProperty(exports, "flattenConnection", { enumerable: true, get: function () { return flattenConnection_1.flattenConnection; } });
+var isClient_1 = require("./isClient");
+Object.defineProperty(exports, "isClient", { enumerable: true, get: function () { return isClient_1.isClient; } });
+var isServer_1 = require("./isServer");
+Object.defineProperty(exports, "isServer", { enumerable: true, get: function () { return isServer_1.isServer; } });
+var measurement_1 = require("./measurement");
+Object.defineProperty(exports, "getMeasurementAsParts", { enumerable: true, get: function () { return measurement_1.getMeasurementAsParts; } });
+Object.defineProperty(exports, "getMeasurementAsString", { enumerable: true, get: function () { return measurement_1.getMeasurementAsString; } });
+var parseMetafieldValue_1 = require("./parseMetafieldValue");
+Object.defineProperty(exports, "parseMetafieldValue", { enumerable: true, get: function () { return parseMetafieldValue_1.parseMetafieldValue; } });
+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; } });
+var html_encoding_1 = require("./html-encoding");
+Object.defineProperty(exports, "htmlEncode", { enumerable: true, get: function () { return html_encoding_1.htmlEncode; } });
+Object.defineProperty(exports, "htmlDecode", { enumerable: true, get: function () { return html_encoding_1.htmlDecode; } });

package/dist/node/utilities/isClient/index.d.ts

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

package/dist/node/utilities/isClient/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isClient = void 0;
+var isClient_1 = require("./isClient");
+Object.defineProperty(exports, "isClient", { enumerable: true, get: function () { return isClient_1.isClient; } });

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

@@ -0,0 +1,4 @@
+/** The `isClient` utility is a function that returns a boolean indicating
+ * if the code was run on the client.
+ */
+export declare function isClient(): boolean;

package/dist/node/utilities/isClient/isClient.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isClient = void 0;
+/** The `isClient` utility is a function that returns a boolean indicating
+ * if the code was run on the client.
+ */
+function isClient() {
+    return typeof window !== 'undefined';
+}
+exports.isClient = isClient;

package/dist/node/utilities/isServer/index.d.ts

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

package/dist/node/utilities/isServer/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isServer = void 0;
+var isServer_1 = require("./isServer");
+Object.defineProperty(exports, "isServer", { enumerable: true, get: function () { return isServer_1.isServer; } });

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

@@ -0,0 +1,4 @@
+/** The `isServer` utility is a function that returns a `boolean` indicating
+ * if the code was run on the server.
+ */
+export declare function isServer(): boolean;

package/dist/node/utilities/isServer/isServer.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isServer = void 0;
+const isClient_1 = require("../isClient");
+/** The `isServer` utility is a function that returns a `boolean` indicating
+ * if the code was run on the server.
+ */
+function isServer() {
+    return !(0, isClient_1.isClient)();
+}
+exports.isServer = isServer;

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

@@ -0,0 +1,3 @@
+export declare function loadScript(src: string, options?: {
+    module?: boolean;
+}): Promise<boolean>;

package/dist/node/utilities/load_script.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadScript = void 0;
+const SCRIPTS_LOADED = {};
+function loadScript(src, options) {
+    const isScriptLoaded = SCRIPTS_LOADED[src];
+    if (isScriptLoaded) {
+        return isScriptLoaded;
+    }
+    const promise = new Promise((resolve, reject) => {
+        const script = document.createElement('script');
+        if (options === null || options === void 0 ? void 0 : options.module) {
+            script.type = 'module';
+        }
+        script.src = src;
+        script.onload = () => {
+            resolve(true);
+        };
+        script.onerror = () => {
+            reject(false);
+        };
+        document.body.appendChild(script);
+    });
+    SCRIPTS_LOADED[src] = promise;
+    return promise;
+}
+exports.loadScript = loadScript;

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

@@ -0,0 +1,4 @@
+export { log, setLogger, setLoggerOptions, getLoggerWithContext, Logger, logServerResponse, resetLogger, } from './log';
+export { collectQueryCacheControlHeaders, logCacheControlHeaders, } from './log-cache-header';
+export { logCacheApiStatus } from './log-cache-api-status';
+export { collectQueryTimings, logQueryTimings } from './log-query-timeline';

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logQueryTimings = exports.collectQueryTimings = exports.logCacheApiStatus = exports.logCacheControlHeaders = exports.collectQueryCacheControlHeaders = exports.resetLogger = exports.logServerResponse = exports.getLoggerWithContext = exports.setLoggerOptions = exports.setLogger = exports.log = void 0;
+var log_1 = require("./log");
+Object.defineProperty(exports, "log", { enumerable: true, get: function () { return log_1.log; } });
+Object.defineProperty(exports, "setLogger", { enumerable: true, get: function () { return log_1.setLogger; } });
+Object.defineProperty(exports, "setLoggerOptions", { enumerable: true, get: function () { return log_1.setLoggerOptions; } });
+Object.defineProperty(exports, "getLoggerWithContext", { enumerable: true, get: function () { return log_1.getLoggerWithContext; } });
+Object.defineProperty(exports, "logServerResponse", { enumerable: true, get: function () { return log_1.logServerResponse; } });
+Object.defineProperty(exports, "resetLogger", { enumerable: true, get: function () { return log_1.resetLogger; } });
+var log_cache_header_1 = require("./log-cache-header");
+Object.defineProperty(exports, "collectQueryCacheControlHeaders", { enumerable: true, get: function () { return log_cache_header_1.collectQueryCacheControlHeaders; } });
+Object.defineProperty(exports, "logCacheControlHeaders", { enumerable: true, get: function () { return log_cache_header_1.logCacheControlHeaders; } });
+var log_cache_api_status_1 = require("./log-cache-api-status");
+Object.defineProperty(exports, "logCacheApiStatus", { enumerable: true, get: function () { return log_cache_api_status_1.logCacheApiStatus; } });
+var log_query_timeline_1 = require("./log-query-timeline");
+Object.defineProperty(exports, "collectQueryTimings", { enumerable: true, get: function () { return log_query_timeline_1.collectQueryTimings; } });
+Object.defineProperty(exports, "logQueryTimings", { enumerable: true, get: function () { return log_query_timeline_1.logQueryTimings; } });

package/dist/node/utilities/log/log-cache-api-status.d.ts

@@ -0,0 +1 @@
+export declare function logCacheApiStatus(status: string | null, url: string): void;

package/dist/node/utilities/log/log-cache-api-status.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logCacheApiStatus = void 0;
+const utils_1 = require("./utils");
+const kolorist_1 = require("kolorist");
+const _1 = require(".");
+function logCacheApiStatus(status, url) {
+    if (!_1.log.options().showCacheApiStatus) {
+        return;
+    }
+    let queryName;
+    if (/shopify\.dev/.test(url)) {
+        queryName = (0, utils_1.findQueryName)(url);
+    }
+    _1.log.debug((0, kolorist_1.gray)(`[Cache] ${status === null || status === void 0 ? void 0 : status.padEnd(8)} ${queryName ? `query ${queryName}` : decodeURIComponent(url)}`));
+}
+exports.logCacheApiStatus = logCacheApiStatus;

package/dist/node/utilities/log/log-cache-header.d.ts

@@ -0,0 +1,10 @@
+import { ServerComponentRequest } from '../../framework/Hydration/ServerComponentRequest.server';
+import { ServerComponentResponse } from '../../framework/Hydration/ServerComponentResponse.server';
+import { QueryKey } from '../../types';
+import type { RenderType } from './log';
+export declare type QueryCacheControlHeaders = {
+    name: string;
+    header: string | null;
+};
+export declare function collectQueryCacheControlHeaders(request: ServerComponentRequest, queryKey: QueryKey, cacheControlHeader: string | null): void;
+export declare function logCacheControlHeaders(type: RenderType, request: ServerComponentRequest, response?: ServerComponentResponse): void;

package/dist/node/utilities/log/log-cache-header.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logCacheControlHeaders = exports.collectQueryCacheControlHeaders = void 0;
+const hash_1 = require("../hash");
+const utils_1 = require("./utils");
+const kolorist_1 = require("kolorist");
+const log_1 = require("./log");
+const color = kolorist_1.gray;
+function collectQueryCacheControlHeaders(request, queryKey, cacheControlHeader) {
+    request.ctx.queryCacheControl.push({
+        name: (0, utils_1.findQueryName)((0, hash_1.hashKey)(queryKey)),
+        header: cacheControlHeader,
+    });
+}
+exports.collectQueryCacheControlHeaders = collectQueryCacheControlHeaders;
+function logCacheControlHeaders(type, request, response) {
+    const log = (0, log_1.getLoggerWithContext)(request);
+    if (!log.options().showCacheControlHeader) {
+        return;
+    }
+    log.debug(color(`┌── Cache control header for ${(0, utils_1.parseUrl)(type, request.url)}`));
+    if (response) {
+        log.debug(color(`│ ${response.cacheControlHeader}`));
+    }
+    const queryList = request.ctx.queryCacheControl;
+    const longestQueryNameLength = queryList.reduce((max, query) => Math.max(max, query.name.length), 0);
+    if (queryList.length > 0) {
+        log.debug(color('│'));
+        queryList.forEach((query) => {
+            log.debug(color(`│ query ${query.name.padEnd(longestQueryNameLength + 1)}${query.header}`));
+        });
+    }
+    log.debug(color('└──'));
+}
+exports.logCacheControlHeaders = logCacheControlHeaders;

package/dist/node/utilities/log/log-query-timeline.d.ts

@@ -0,0 +1,12 @@
+import { ServerComponentRequest } from '../../framework/Hydration/ServerComponentRequest.server';
+import { QueryKey } from '../../types';
+import type { RenderType } from './log';
+export declare type TimingType = 'requested' | 'resolved' | 'rendered' | 'preload';
+export declare type QueryTiming = {
+    name: string;
+    timingType: TimingType;
+    timestamp: number;
+    duration?: number;
+};
+export declare function collectQueryTimings(request: ServerComponentRequest, queryKey: QueryKey, timingType: TimingType, duration?: number): void;
+export declare function logQueryTimings(type: RenderType, request: ServerComponentRequest): void;

package/dist/node/utilities/log/log-query-timeline.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logQueryTimings = exports.collectQueryTimings = void 0;
+const hash_1 = require("../hash");
+const utils_1 = require("./utils");
+const kolorist_1 = require("kolorist");
+const log_1 = require("./log");
+const timing_1 = require("../timing");
+const color = kolorist_1.gray;
+const TIMING_MAPPING = {
+    requested: 'Requested',
+    rendered: 'Rendered',
+    resolved: 'Resolved',
+    preload: 'Preload',
+};
+function collectQueryTimings(request, queryKey, timingType, duration) {
+    request.ctx.queryTimings.push({
+        name: (0, utils_1.findQueryName)((0, hash_1.hashKey)(queryKey)),
+        timingType,
+        timestamp: (0, timing_1.getTime)(),
+        duration,
+    });
+}
+exports.collectQueryTimings = collectQueryTimings;
+function logQueryTimings(type, request) {
+    const log = (0, log_1.getLoggerWithContext)(request);
+    if (!log.options().showQueryTiming) {
+        return;
+    }
+    log.debug(color(`┌── Query timings for ${(0, utils_1.parseUrl)(type, request.url)}`));
+    const queryList = request.ctx.queryTimings;
+    if (queryList.length > 0) {
+        const requestStartTime = request.time;
+        const detectSuspenseWaterfall = {};
+        const detectMultipleDataLoad = {};
+        let suspenseWaterfallDetectedCount = 0;
+        queryList.forEach((query, index) => {
+            if (query.timingType === 'requested' || query.timingType === 'preload') {
+                detectSuspenseWaterfall[query.name] = true;
+            }
+            else if (query.timingType === 'rendered') {
+                delete detectSuspenseWaterfall[query.name];
+            }
+            else if (query.timingType === 'resolved') {
+                detectMultipleDataLoad[query.name] = detectMultipleDataLoad[query.name]
+                    ? detectMultipleDataLoad[query.name] + 1
+                    : 1;
+            }
+            const loadColor = query.timingType === 'preload' ? kolorist_1.green : color;
+            const duration = query.duration;
+            log.debug(color(`│ ${`${(query.timestamp - requestStartTime).toFixed(2)}ms`.padEnd(10)} ${loadColor(TIMING_MAPPING[query.timingType].padEnd(10))} ${query.name}${query.timingType === 'resolved'
+                ? ` (Took ${duration === null || duration === void 0 ? void 0 : duration.toFixed(2)}ms)`
+                : ''}`));
+            // SSR + RSC render path generates 2 `load` and `render` for each query
+            // We want to avoid falsely identifying a suspense waterfall near the end
+            // of the query list
+            //
+            // The (index + 4) is detecting that near the end of list.
+            // A complete set of events for a given query is 4 entries
+            // │ (639.62ms)  Requested  Localization
+            // │ (993.33ms)  Resolved   Localization (Took 353.66ms)
+            // │ (993.96ms)  Requested  Localization      <-- second time React tries to load
+            // │ (994.03ms)  Rendered   Localization
+            //
+            // so the end of list index range is 3 (one less from a set entry) + 1 (zero index)
+            if (queryList.length >= index + 4 &&
+                Object.keys(detectSuspenseWaterfall).length === 0) {
+                suspenseWaterfallDetectedCount++;
+                const warningColor = suspenseWaterfallDetectedCount === 1 ? kolorist_1.yellow : kolorist_1.red;
+                log.debug(`${color(`│ `)}${warningColor(`Suspense waterfall detected`)}`);
+            }
+        });
+        const unusedQueries = Object.keys(detectSuspenseWaterfall);
+        if (unusedQueries.length > 0) {
+            unusedQueries.forEach((queryName) => {
+                log.debug(`${color(`│ `)}${(0, kolorist_1.yellow)(`Unused query detected: ${queryName}`)}`);
+            });
+        }
+        Object.keys(detectMultipleDataLoad).forEach((queryName) => {
+            const count = detectMultipleDataLoad[queryName];
+            if (count > 1) {
+                log.debug(`${color(`│ `)}${(0, kolorist_1.yellow)(`Multiple data loads detected: ${queryName}`)}`);
+            }
+        });
+    }
+    log.debug(color('└──'));
+}
+exports.logQueryTimings = logQueryTimings;

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

@@ -0,0 +1,22 @@
+import { ServerComponentRequest } from '../../framework/Hydration/ServerComponentRequest.server';
+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;
+    options: () => LoggerOptions;
+}
+export declare type LoggerOptions = {
+    showCacheControlHeader?: boolean;
+    showCacheApiStatus?: boolean;
+    showQueryTiming?: boolean;
+    showUnusedQueryProperties?: boolean;
+};
+export declare type RenderType = 'str' | 'rsc' | 'ssr' | 'api';
+export declare const log: Logger;
+export declare function getLoggerWithContext(context?: any): Logger;
+export declare function setLogger(newLogger: Logger): void;
+export declare function setLoggerOptions(options: LoggerOptions): void;
+export declare function resetLogger(): void;
+export declare function logServerResponse(type: RenderType, request: ServerComponentRequest, responseStatus: number): void;

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

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logServerResponse = exports.resetLogger = exports.setLoggerOptions = exports.setLogger = exports.getLoggerWithContext = exports.log = void 0;
+const kolorist_1 = require("kolorist");
+const timing_1 = require("../timing");
+const utils_1 = require("./utils");
+const defaultLogger = {
+    trace(context, ...args) {
+        // Re-enable following line to show trace debugging information
+        // console.log(context.id, ...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);
+    },
+    options: () => ({}),
+};
+globalThis.__logger = defaultLogger;
+function buildLogger() {
+    return {
+        trace: (...args) => globalThis.__logger.trace(this, ...args),
+        debug: (...args) => globalThis.__logger.debug(this, ...args),
+        warn: (...args) => globalThis.__logger.warn(this, ...args),
+        error: (...args) => globalThis.__logger.error(this, ...args),
+        fatal: (...args) => globalThis.__logger.fatal(this, ...args),
+        options: () => globalThis.__logger.options(),
+    };
+}
+exports.log = buildLogger.call({});
+function getLoggerWithContext(context = {}) {
+    return buildLogger.call(context);
+}
+exports.getLoggerWithContext = getLoggerWithContext;
+function setLogger(newLogger) {
+    globalThis.__logger = newLogger;
+}
+exports.setLogger = setLogger;
+function setLoggerOptions(options) {
+    globalThis.__logger.options = () => options;
+}
+exports.setLoggerOptions = setLoggerOptions;
+function resetLogger() {
+    globalThis.__logger = defaultLogger;
+}
+exports.resetLogger = resetLogger;
+const SERVER_RESPONSE_MAP = {
+    str: 'streaming SSR',
+    rsc: 'Server Components',
+    ssr: 'buffered SSR',
+};
+function logServerResponse(type, request, responseStatus) {
+    const log = getLoggerWithContext(request);
+    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)(fullType.padEnd(17));
+    const paddedTiming = (((0, timing_1.getTime)() - request.time).toFixed(2) + ' ms').padEnd(10);
+    const url = (0, utils_1.parseUrl)(type, request.url);
+    log.debug(`${request.method} ${styledType} ${coloredResponseStatus} ${paddedTiming} ${url}`);
+}
+exports.logServerResponse = logServerResponse;

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

@@ -0,0 +1,3 @@
+import type { RenderType } from './log';
+export declare function findQueryName(key: string): string;
+export declare function parseUrl(type: RenderType, url: string): string;

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseUrl = exports.findQueryName = void 0;
+function findQueryName(key) {
+    const decodeKey = decodeURIComponent(key);
+    if (key.length < 100) {
+        return key.replace('"__QUERY_CACHE_ID__"', '').replace(/"/g, '');
+    }
+    const match = decodeKey.match(/query ([^\s()]*)\s?(|\(\{)/);
+    if (match && match.length > 1) {
+        return match[1];
+    }
+    return '<unknown>';
+}
+exports.findQueryName = findQueryName;
+function parseUrl(type, url) {
+    return type === 'rsc'
+        ? decodeURIComponent(url.substring(url.indexOf('=') + 1))
+        : url;
+}
+exports.parseUrl = parseUrl;

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/measurement.d.ts

@@ -0,0 +1,3 @@
+import { Measurement } from '../types';
+export declare function getMeasurementAsString(measurement: Measurement, locale?: string, options?: Intl.NumberFormatOptions): string;
+export declare function getMeasurementAsParts(measurement: Measurement, locale?: string, options?: Intl.NumberFormatOptions): Intl.NumberFormatPart[];