@shopify/hydrogen 0.11.0-experimental.1 → 0.11.1-experimental.0

package/dist/node/foundation/ServerRequestProvider/ServerRequestProvider.js

@@ -0,0 +1,132 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preloadRequestCacheData = exports.useRequestCacheData = exports.useServerRequest = exports.ServerRequestProvider = void 0;
+const react_1 = __importStar(require("react"));
+const timing_1 = require("../../utilities/timing");
+const cache_1 = require("../../framework/cache");
+const log_1 = require("../../utilities/log");
+// Context to inject current request in SSR
+const RequestContextSSR = (0, react_1.createContext)(null);
+// Cache to inject current request in RSC
+function requestCacheRSC() {
+    return new Map();
+}
+requestCacheRSC.key = Symbol.for('HYDROGEN_REQUEST');
+function ServerRequestProvider({ isRSC, request, children, }) {
+    if (isRSC) {
+        // Save the request object in a React cache that is
+        // scoped to this current rendering.
+        // @ts-ignore
+        const requestCache = react_1.default.unstable_getCacheForType(requestCacheRSC);
+        requestCache.set(requestCacheRSC.key, request);
+        return children;
+    }
+    // Use a normal provider in SSR to make the request object
+    // available in the current rendering.
+    return (react_1.default.createElement(RequestContextSSR.Provider, { value: request }, children));
+}
+exports.ServerRequestProvider = ServerRequestProvider;
+function useServerRequest() {
+    let request;
+    try {
+        // Context only works in SSR rendering
+        request = (0, react_1.useContext)(RequestContextSSR);
+    }
+    catch (error) {
+        // If normal context failed it means this is not an SSR request.
+        // Try getting RSC cache instead:
+        // @ts-ignore
+        const cache = react_1.default.unstable_getCacheForType(requestCacheRSC);
+        request = cache ? cache.get(requestCacheRSC.key) : null;
+    }
+    if (!request) {
+        // @ts-ignore
+        if (__DEV__ && typeof jest !== 'undefined') {
+            // Unit tests are not wrapped in ServerRequestProvider.
+            // This mocks it, instead of providing it in every test.
+            return { ctx: {} };
+        }
+        throw new Error('No ServerRequest Context found');
+    }
+    return request;
+}
+exports.useServerRequest = useServerRequest;
+/**
+ * Returns data stored in the request cache.
+ * It will throw the promise if data is not ready.
+ */
+function useRequestCacheData(key, fetcher) {
+    const request = useServerRequest();
+    const cache = request.ctx.cache;
+    const cacheKey = (0, cache_1.hashKey)(key);
+    if (!cache.has(cacheKey)) {
+        let data;
+        let promise;
+        cache.set(cacheKey, () => {
+            if (data !== undefined) {
+                (0, log_1.collectQueryTimings)(request, key, 'rendered');
+                return data;
+            }
+            if (!promise) {
+                const startApiTime = (0, timing_1.getTime)();
+                promise = fetcher().then((r) => {
+                    data = { data: r };
+                    (0, log_1.collectQueryTimings)(request, key, 'resolved', (0, timing_1.getTime)() - startApiTime);
+                }, (e) => (data = { error: e }));
+            }
+            throw promise;
+        });
+    }
+    // Making sure the promise has returned data because it can be initated by a preload request,
+    // otherwise, we throw the promise
+    const result = cache.get(cacheKey).call();
+    if (result instanceof Promise)
+        throw result;
+    return result;
+}
+exports.useRequestCacheData = useRequestCacheData;
+function preloadRequestCacheData(request, preloadQueries) {
+    const cache = request.ctx.cache;
+    preloadQueries === null || preloadQueries === void 0 ? void 0 : preloadQueries.forEach((preloadQuery, cacheKey) => {
+        (0, log_1.collectQueryTimings)(request, preloadQuery.key, 'preload');
+        if (!cache.has(cacheKey)) {
+            let data;
+            let promise;
+            cache.set(cacheKey, () => {
+                if (data !== undefined) {
+                    (0, log_1.collectQueryTimings)(request, preloadQuery.key, 'rendered');
+                    return data;
+                }
+                if (!promise) {
+                    const startApiTime = (0, timing_1.getTime)();
+                    promise = preloadQuery.fetcher().then((r) => {
+                        data = { data: r };
+                        (0, log_1.collectQueryTimings)(request, preloadQuery.key, 'resolved', (0, timing_1.getTime)() - startApiTime);
+                    }, (e) => (data = { error: e }));
+                }
+                return promise;
+            });
+        }
+        cache.get(cacheKey).call();
+    });
+}
+exports.preloadRequestCacheData = preloadRequestCacheData;

package/dist/node/foundation/ServerRequestProvider/index.d.ts

@@ -0,0 +1 @@
+export * from './ServerRequestProvider';

package/dist/node/foundation/ServerRequestProvider/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ServerRequestProvider"), exports);

package/dist/node/foundation/ServerStateProvider/ServerStateProvider.client.d.ts

@@ -0,0 +1,25 @@
+import React, { ReactNode } from 'react';
+declare global {
+    var __DEV__: boolean;
+}
+export interface ServerState {
+    pathname: string;
+    search: string;
+    [key: string]: any;
+}
+export interface ServerStateSetter {
+    (input: ((prev: ServerState) => Partial<ServerState>) | Partial<ServerState> | string, propValue?: any): void;
+}
+export interface ServerStateContextValue {
+    pending: boolean;
+    serverState: ServerState;
+    setServerState: ServerStateSetter;
+}
+export declare const ServerStateContext: React.Context<ServerStateContextValue>;
+interface ServerStateProviderProps {
+    serverState: ServerState;
+    setServerState: React.Dispatch<React.SetStateAction<ServerState>>;
+    children: ReactNode;
+}
+export declare function ServerStateProvider({ serverState, setServerState, children, }: ServerStateProviderProps): JSX.Element;
+export {};

package/dist/node/foundation/ServerStateProvider/ServerStateProvider.client.js

@@ -0,0 +1,68 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerStateProvider = exports.ServerStateContext = void 0;
+const react_1 = __importStar(require("react"));
+const PRIVATE_PROPS = ['request', 'response'];
+exports.ServerStateContext = (0, react_1.createContext)(null);
+function ServerStateProvider({ serverState, setServerState, children, }) {
+    const [pending, startTransition] = (0, react_1.useTransition)();
+    const setServerStateCallback = (0, react_1.useCallback)((input, propValue) => {
+        /**
+         * By wrapping this state change in a transition, React renders the new state
+         * concurrently in a new "tree" instead of Suspending and showing the (blank)
+         * fallback. This is preferred behavior, though we may want to revisit how
+         * we make this decision globally for the developer - and consider providing
+         * the `pending` flag also provided by the hook to display in the UI.
+         */
+        startTransition(() => {
+            return setServerState((prev) => {
+                let newValue;
+                if (typeof input === 'function') {
+                    newValue = input(prev);
+                }
+                else if (typeof input === 'string') {
+                    newValue = { [input]: propValue };
+                }
+                else {
+                    newValue = input;
+                }
+                if (__DEV__) {
+                    const privateProp = PRIVATE_PROPS.find((prop) => prop in newValue);
+                    if (privateProp) {
+                        console.warn(`Custom "${privateProp}" property in server state is ignored. Use a different name.`);
+                    }
+                }
+                return {
+                    ...prev,
+                    ...newValue,
+                };
+            });
+        });
+    }, [setServerState, startTransition]);
+    const value = (0, react_1.useMemo)(() => ({
+        pending,
+        serverState,
+        setServerState: setServerStateCallback,
+    }), [serverState, setServerStateCallback, pending]);
+    return (react_1.default.createElement(exports.ServerStateContext.Provider, { value: value }, children));
+}
+exports.ServerStateProvider = ServerStateProvider;

package/dist/node/foundation/ServerStateProvider/index.d.ts

@@ -0,0 +1,2 @@
+export { ServerStateProvider, ServerStateContext, } from './ServerStateProvider.client';
+export type { ServerState, ServerStateContextValue, } from './ServerStateProvider.client';

package/dist/node/foundation/ServerStateProvider/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerStateContext = exports.ServerStateProvider = void 0;
+var ServerStateProvider_client_1 = require("./ServerStateProvider.client");
+Object.defineProperty(exports, "ServerStateProvider", { enumerable: true, get: function () { return ServerStateProvider_client_1.ServerStateProvider; } });
+Object.defineProperty(exports, "ServerStateContext", { enumerable: true, get: function () { return ServerStateProvider_client_1.ServerStateContext; } });

package/dist/node/framework/CachingStrategy/index.d.ts

@@ -0,0 +1,10 @@
+import type { CachingStrategy, AllCacheOptions, NoStoreStrategy } from '../../types';
+export declare function generateCacheControlHeader(cacheOptions: CachingStrategy): string;
+export declare function NoStore(): NoStoreStrategy;
+export declare function CacheSeconds(overrideOptions?: CachingStrategy): AllCacheOptions;
+export declare function CacheMinutes(overrideOptions?: CachingStrategy): AllCacheOptions;
+export declare function CacheHours(overrideOptions?: CachingStrategy): AllCacheOptions;
+export declare function CacheDays(overrideOptions?: CachingStrategy): AllCacheOptions;
+export declare function CacheWeeks(overrideOptions?: CachingStrategy): AllCacheOptions;
+export declare function CacheMonths(overrideOptions?: CachingStrategy): AllCacheOptions;
+export declare function CacheCustom(overrideOptions: CachingStrategy): AllCacheOptions;

package/dist/node/framework/CachingStrategy/index.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheCustom = exports.CacheMonths = exports.CacheWeeks = exports.CacheDays = exports.CacheHours = exports.CacheMinutes = exports.CacheSeconds = exports.NoStore = exports.generateCacheControlHeader = void 0;
+const PUBLIC = 'public';
+const PRIVATE = 'private';
+const NO_STORE = 'no-store';
+const optionMapping = {
+    maxAge: 'max-age',
+    staleWhileRevalidate: 'stale-while-revalidate',
+    sMaxAge: 's-maxage',
+    staleIfError: 'stale-if-error',
+};
+function generateCacheControlHeader(cacheOptions) {
+    const cacheControl = [];
+    Object.keys(cacheOptions).forEach((key) => {
+        if (key === 'mode') {
+            cacheControl.push(cacheOptions[key]);
+        }
+        else if (optionMapping[key]) {
+            cacheControl.push(`${optionMapping[key]}=${cacheOptions[key]}`);
+        }
+    });
+    return cacheControl.join(', ');
+}
+exports.generateCacheControlHeader = generateCacheControlHeader;
+function NoStore() {
+    return {
+        mode: NO_STORE,
+    };
+}
+exports.NoStore = NoStore;
+function guardExpirableModeType(overrideOptions) {
+    if ((overrideOptions === null || overrideOptions === void 0 ? void 0 : overrideOptions.mode) &&
+        (overrideOptions === null || overrideOptions === void 0 ? void 0 : overrideOptions.mode) !== PUBLIC &&
+        (overrideOptions === null || overrideOptions === void 0 ? void 0 : overrideOptions.mode) !== PRIVATE) {
+        throw Error("'mode' must be either 'public' or 'private'");
+    }
+}
+// 10 seconds
+function CacheSeconds(overrideOptions) {
+    guardExpirableModeType(overrideOptions);
+    return {
+        mode: PUBLIC,
+        maxAge: 1,
+        staleWhileRevalidate: 9,
+        ...overrideOptions,
+    };
+}
+exports.CacheSeconds = CacheSeconds;
+// 30 minutes
+function CacheMinutes(overrideOptions) {
+    guardExpirableModeType(overrideOptions);
+    return {
+        mode: PUBLIC,
+        maxAge: 900,
+        staleWhileRevalidate: 900,
+        ...overrideOptions,
+    };
+}
+exports.CacheMinutes = CacheMinutes;
+// 1 hour
+function CacheHours(overrideOptions) {
+    guardExpirableModeType(overrideOptions);
+    return {
+        mode: PUBLIC,
+        maxAge: 1800,
+        staleWhileRevalidate: 1800,
+        ...overrideOptions,
+    };
+}
+exports.CacheHours = CacheHours;
+// 1 day
+function CacheDays(overrideOptions) {
+    guardExpirableModeType(overrideOptions);
+    return {
+        mode: PUBLIC,
+        maxAge: 3600,
+        staleWhileRevalidate: 82800,
+        ...overrideOptions,
+    };
+}
+exports.CacheDays = CacheDays;
+// 2 weeks
+function CacheWeeks(overrideOptions) {
+    guardExpirableModeType(overrideOptions);
+    return {
+        mode: PUBLIC,
+        maxAge: 604800,
+        staleWhileRevalidate: 604800,
+        ...overrideOptions,
+    };
+}
+exports.CacheWeeks = CacheWeeks;
+// 1 month
+function CacheMonths(overrideOptions) {
+    guardExpirableModeType(overrideOptions);
+    return {
+        mode: PUBLIC,
+        maxAge: 1296000,
+        staleWhileRevalidate: 1296000,
+        ...overrideOptions,
+    };
+}
+exports.CacheMonths = CacheMonths;
+function CacheCustom(overrideOptions) {
+    return overrideOptions;
+}
+exports.CacheCustom = CacheCustom;

package/dist/node/framework/Hydration/Html.js

@@ -7,23 +7,16 @@ exports.Html = void 0;
 /// <reference types="vite/client" />
 const react_1 = __importDefault(require("react"));
 function Html({ children, template, htmlAttrs, bodyAttrs }) {
-    var _a;
-    const head = template.match(/<head>(.+?)<\/head>/s)[1] || '';
-    let devEntryPoint = '';
+    let head = template.match(/<head>(.+?)<\/head>/s)[1] || '';
     // @ts-ignore
     if (import.meta.env.DEV) {
-        devEntryPoint =
-            ((_a = template
-                .substring(template.lastIndexOf('<script type="module"'))
-                .match(/src="(.*?)">/i)) === null || _a === void 0 ? void 0 : _a[1]) || '';
-        if (!devEntryPoint) {
-            throw new Error('Could not find entry-client module in index.html');
-        }
+        // Fix React Refresh for async scripts.
+        // https://github.com/vitejs/vite/issues/6759
+        head = head.replace(/>(\s*?import[\s\w]+?['"]\/@react-refresh)/, ' async="">$1');
     }
     return (react_1.default.createElement("html", { ...htmlAttrs },
         react_1.default.createElement("head", { dangerouslySetInnerHTML: { __html: head } }),
         react_1.default.createElement("body", { ...bodyAttrs },
-            react_1.default.createElement("div", { id: "root" }, children),
-            import.meta.env.DEV && (react_1.default.createElement("script", { type: "module", src: devEntryPoint })))));
+            react_1.default.createElement("div", { id: "root" }, children))));
 }
 exports.Html = Html;

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

@@ -1,5 +1,15 @@
 import type { ShopifyContextValue } from '../../foundation/ShopifyProvider/types';
-import type { RealHelmetData } from '../../foundation/Helmet';
+import type { QueryCacheControlHeaders } from '../../utilities/log/log-cache-header';
+import type { QueryTiming } from '../../utilities/log/log-query-timeline';
+import type { PreloadOptions, QueryKey } from '../../types';
+import { HelmetData as HeadData } from 'react-helmet-async';
+export declare type PreloadQueryEntry = {
+    key: QueryKey;
+    fetcher: () => Promise<unknown>;
+    preload?: PreloadOptions;
+};
+export declare type PreloadQueriesByURL = Map<string, PreloadQueryEntry>;
+export declare type AllPreloadQueries = Map<string, PreloadQueriesByURL>;
 /**
  * This augments the `Request` object from the Fetch API:
  * @see https://developer.mozilla.org/en-US/docs/Web/API/Request
@@ -11,13 +21,21 @@ export declare class ServerComponentRequest extends Request {
     cookies: Map<string, string>;
     id: string;
     time: number;
+    preloadURL: string;
     ctx: {
         cache: Map<string, any>;
-        helmet: RealHelmetData;
+        head: HeadData;
         shopifyConfig?: ShopifyContextValue;
+        queryCacheControl: Array<QueryCacheControlHeaders>;
+        queryTimings: Array<QueryTiming>;
+        preloadQueries: PreloadQueriesByURL;
         [key: string]: any;
     };
     constructor(input: any);
     constructor(input: RequestInfo, init?: RequestInit);
     private parseCookies;
+    isRscRequest(): boolean;
+    savePreloadQuery(query: PreloadQueryEntry): void;
+    getPreloadQueries(): PreloadQueriesByURL | undefined;
+    savePreloadQueries(): void;
 }

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

@@ -2,7 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ServerComponentRequest = void 0;
 const timing_1 = require("../../utilities/timing");
+const cache_1 = require("../cache");
 const react_helmet_async_1 = require("react-helmet-async");
+const constants_1 = require("../../constants");
 let reqCounter = 0; // For debugging
 const generateId = typeof crypto !== 'undefined' &&
     // @ts-ignore
@@ -10,6 +12,9 @@ const generateId = typeof crypto !== 'undefined' &&
     ? // @ts-ignore
         () => crypto.randomUUID()
     : () => `req${++reqCounter}`;
+// Stores queries by url or '*'
+const preloadCache = new Map();
+const PRELOAD_ALL = '*';
 /**
  * This augments the `Request` object from the Fetch API:
  * @see https://developer.mozilla.org/en-US/docs/Web/API/Request
@@ -35,9 +40,15 @@ class ServerComponentRequest extends Request {
         this.id = generateId();
         this.ctx = {
             cache: new Map(),
-            helmet: new react_helmet_async_1.HelmetData({}),
+            head: new react_helmet_async_1.HelmetData({}),
+            queryCacheControl: [],
+            queryTimings: [],
+            preloadQueries: new Map(),
         };
         this.cookies = this.parseCookies();
+        const referer = this.headers.get('referer');
+        this.preloadURL =
+            this.isRscRequest() && referer && referer !== '' ? referer : this.url;
     }
     parseCookies() {
         const cookieString = this.headers.get('cookie') || '';
@@ -45,8 +56,46 @@ class ServerComponentRequest extends Request {
             .split(';')
             .map((chunk) => chunk.trim().split(/=(.+)/)));
     }
+    isRscRequest() {
+        const url = new URL(this.url);
+        return url.pathname === constants_1.RSC_PATHNAME;
+    }
+    savePreloadQuery(query) {
+        if (typeof query.preload === 'string' && query.preload === PRELOAD_ALL) {
+            saveToPreloadAllPreload(query);
+        }
+        else if (query.preload) {
+            this.ctx.preloadQueries.set((0, cache_1.hashKey)(query.key), query);
+        }
+    }
+    getPreloadQueries() {
+        if (preloadCache.has(this.preloadURL)) {
+            const combinedPreloadQueries = new Map();
+            const urlPreloadCache = preloadCache.get(this.preloadURL);
+            mergeMapEntries(combinedPreloadQueries, urlPreloadCache);
+            mergeMapEntries(combinedPreloadQueries, preloadCache.get(PRELOAD_ALL));
+            return combinedPreloadQueries;
+        }
+        else if (preloadCache.has(PRELOAD_ALL)) {
+            return preloadCache.get(PRELOAD_ALL);
+        }
+    }
+    savePreloadQueries() {
+        preloadCache.set(this.preloadURL, this.ctx.preloadQueries);
+    }
 }
 exports.ServerComponentRequest = ServerComponentRequest;
+function mergeMapEntries(map1, map2) {
+    map2 && map2.forEach((v, k) => map1.set(k, v));
+}
+function saveToPreloadAllPreload(query) {
+    let setCache = preloadCache.get(PRELOAD_ALL);
+    if (!setCache) {
+        setCache = new Map();
+    }
+    setCache === null || setCache === void 0 ? void 0 : setCache.set((0, cache_1.hashKey)(query.key), query);
+    preloadCache.set(PRELOAD_ALL, setCache);
+}
 /**
  * @see https://github.com/frandiox/vitedge/blob/17f3cd943e86d7c0c71a862985ddd6caa2899425/src/node/utils.js#L19-L24
  *

package/dist/node/framework/Hydration/ServerComponentResponse.server.d.ts

@@ -1,4 +1,4 @@
-import { CacheOptions } from '../../types';
+import type { CachingStrategy } from '../../types';
 export declare class ServerComponentResponse extends Response {
     private wait;
     private cacheOptions?;
@@ -16,7 +16,7 @@ export declare class ServerComponentResponse extends Response {
      */
     doNotStream(): void;
     canStream(): boolean;
-    cache(options: CacheOptions): void;
+    cache(options: CachingStrategy): void;
     get cacheControlHeader(): string;
     writeHead({ status, statusText, headers, }?: {
         status?: number;

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

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ServerComponentResponse = void 0;
 const server_1 = require("react-dom/server");
-const cache_1 = require("../cache");
+const CachingStrategy_1 = require("../CachingStrategy");
 class ServerComponentResponse extends Response {
     constructor() {
         super(...arguments);
@@ -26,12 +26,7 @@ class ServerComponentResponse extends Response {
         this.cacheOptions = options;
     }
     get cacheControlHeader() {
-        var _a;
-        const options = {
-            ...DEFAULT_CACHE_OPTIONS,
-            ...((_a = this.cacheOptions) !== null && _a !== void 0 ? _a : {}),
-        };
-        return (0, cache_1.generateCacheControlHeader)(options);
+        return (0, CachingStrategy_1.generateCacheControlHeader)(this.cacheOptions || (0, CachingStrategy_1.CacheSeconds)());
     }
     writeHead({ status, statusText, headers, } = {}) {
         if (status || statusText) {
@@ -62,7 +57,3 @@ class ServerComponentResponse extends Response {
     }
 }
 exports.ServerComponentResponse = ServerComponentResponse;
-const DEFAULT_CACHE_OPTIONS = {
-    maxAge: 60 * 60,
-    staleWhileRevalidate: 23 * 60 * 60,
-};

package/dist/node/framework/cache/in-memory.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InMemoryCache = void 0;
+const log_1 = require("../../utilities/log");
 /**
  * This is an in-memory implementation of `Cache` that *barely*
  * works and is only meant to be used during development.
@@ -10,7 +11,7 @@ class InMemoryCache {
         this.store = new Map();
     }
     put(request, response) {
-        console.log(`[Cache] PUT ${request.url.slice(0, 100)}`);
+        (0, log_1.logCacheApiStatus)('PUT', request.url);
         this.store.set(request.url, {
             value: response,
             date: new Date(),
@@ -19,7 +20,7 @@ class InMemoryCache {
     match(request) {
         const match = this.store.get(request.url);
         if (!match) {
-            console.log(`[Cache] MISS ${request.url.slice(0, 100)}`);
+            (0, log_1.logCacheApiStatus)('MISS', request.url);
             return;
         }
         const { value, date } = match;
@@ -29,7 +30,7 @@ class InMemoryCache {
         const age = (new Date().valueOf() - date) / 1000;
         const isMiss = age > maxAge + swr;
         if (isMiss) {
-            console.log(`[Cache] MISS ${request.url.slice(0, 100)}`);
+            (0, log_1.logCacheApiStatus)('MISS', request.url);
             this.store.delete(request.url);
             return;
         }
@@ -37,7 +38,7 @@ class InMemoryCache {
         const headers = new Headers(value.headers);
         headers.set('cache', isStale ? 'STALE' : 'HIT');
         headers.set('date', date.toGMTString());
-        console.log(`[Cache] ${headers.get('cache')} ${request.url.slice(0, 100)}`);
+        (0, log_1.logCacheApiStatus)(headers.get('cache'), request.url);
         const response = new Response(value.body, {
             headers,
         });
@@ -45,7 +46,7 @@ class InMemoryCache {
     }
     delete(request) {
         this.store.delete(request.url);
-        console.log(`[Cache] DELETE ${request.url.slice(0, 100)}`);
+        (0, log_1.logCacheApiStatus)('DELETE', request.url);
     }
 }
 exports.InMemoryCache = InMemoryCache;

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

@@ -1,5 +1,5 @@
-import type { CacheOptions, QueryKey } from '../types';
-export declare function generateCacheControlHeader(options: CacheOptions): string;
+import type { QueryKey, CachingStrategy } from '../types';
+export declare function generateSubRequestCacheControlHeader(userCacheOptions?: CachingStrategy): string;
 /**
  * Use a preview header during development.
  * TODO: Support an override of this to force the cache
@@ -18,7 +18,7 @@ export declare function getItemFromCache(key: QueryKey): Promise<undefined | [an
 /**
  * Put an item into the cache.
  */
-export declare function setItemInCache(key: QueryKey, value: any, userCacheOptions?: CacheOptions): Promise<void>;
+export declare function setItemInCache(key: QueryKey, value: any, userCacheOptions?: CachingStrategy): Promise<void>;
 export declare function deleteItemFromCache(key: QueryKey): Promise<void>;
 /**
  * Manually check the response to see if it's stale.