main repo

node_modules/next/dist/server/response-cache/index.d.ts

@@ -0,0 +1,17 @@
+import type { IncrementalCache, ResponseCacheEntry, ResponseGenerator } from './types';
+export * from './types';
+export default class ResponseCache {
+    pendingResponses: Map<string, Promise<ResponseCacheEntry | null>>;
+    previousCacheItem?: {
+        key: string;
+        entry: ResponseCacheEntry | null;
+        expiresAt: number;
+    };
+    minimalMode?: boolean;
+    constructor(minimalMode: boolean);
+    get(key: string | null, responseGenerator: ResponseGenerator, context: {
+        isOnDemandRevalidate?: boolean;
+        isPrefetch?: boolean;
+        incrementalCache: IncrementalCache;
+    }): Promise<ResponseCacheEntry | null>;
+}

node_modules/next/dist/server/response-cache/index.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return ResponseCache;
+    }
+});
+0 && __export(require("./types"));
+const _renderresult = /*#__PURE__*/ _interop_require_default(require("../render-result"));
+_export_star(require("./types"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+class ResponseCache {
+    constructor(minimalMode){
+        this.pendingResponses = new Map();
+        // this is a hack to avoid Webpack knowing this is equal to this.minimalMode
+        // because we replace this.minimalMode to true in production bundles.
+        const minimalModeKey = "minimalMode";
+        this[minimalModeKey] = minimalMode;
+    }
+    get(key, responseGenerator, context) {
+        var _this_previousCacheItem;
+        const { incrementalCache } = context;
+        // ensure on-demand revalidate doesn't block normal requests
+        const pendingResponseKey = key ? `${key}-${context.isOnDemandRevalidate ? "1" : "0"}` : null;
+        const pendingResponse = pendingResponseKey ? this.pendingResponses.get(pendingResponseKey) : null;
+        if (pendingResponse) {
+            return pendingResponse;
+        }
+        let resolver = ()=>{};
+        let rejecter = ()=>{};
+        const promise = new Promise((resolve, reject)=>{
+            resolver = resolve;
+            rejecter = reject;
+        });
+        if (pendingResponseKey) {
+            this.pendingResponses.set(pendingResponseKey, promise);
+        }
+        let resolved = false;
+        const resolve = (cacheEntry)=>{
+            if (pendingResponseKey) {
+                // Ensure all reads from the cache get the latest value.
+                this.pendingResponses.set(pendingResponseKey, Promise.resolve(cacheEntry));
+            }
+            if (!resolved) {
+                resolved = true;
+                resolver(cacheEntry);
+            }
+        };
+        // we keep the previous cache entry around to leverage
+        // when the incremental cache is disabled in minimal mode
+        if (pendingResponseKey && this.minimalMode && ((_this_previousCacheItem = this.previousCacheItem) == null ? void 0 : _this_previousCacheItem.key) === pendingResponseKey && this.previousCacheItem.expiresAt > Date.now()) {
+            resolve(this.previousCacheItem.entry);
+            this.pendingResponses.delete(pendingResponseKey);
+            return promise;
+        }
+        (async ()=>{
+            let cachedResponse = null;
+            try {
+                cachedResponse = key && !this.minimalMode ? await incrementalCache.get(key) : null;
+                if (cachedResponse && !context.isOnDemandRevalidate) {
+                    var _cachedResponse_value, _cachedResponse_value1;
+                    if (((_cachedResponse_value = cachedResponse.value) == null ? void 0 : _cachedResponse_value.kind) === "FETCH") {
+                        throw new Error(`invariant: unexpected cachedResponse of kind fetch in response cache`);
+                    }
+                    resolve({
+                        isStale: cachedResponse.isStale,
+                        revalidate: cachedResponse.curRevalidate,
+                        value: ((_cachedResponse_value1 = cachedResponse.value) == null ? void 0 : _cachedResponse_value1.kind) === "PAGE" ? {
+                            kind: "PAGE",
+                            html: _renderresult.default.fromStatic(cachedResponse.value.html),
+                            pageData: cachedResponse.value.pageData,
+                            headers: cachedResponse.value.headers,
+                            status: cachedResponse.value.status
+                        } : cachedResponse.value
+                    });
+                    if (!cachedResponse.isStale || context.isPrefetch) {
+                        // The cached value is still valid, so we don't need
+                        // to update it yet.
+                        return;
+                    }
+                }
+                const cacheEntry = await responseGenerator(resolved, cachedResponse);
+                const resolveValue = cacheEntry === null ? null : {
+                    ...cacheEntry,
+                    isMiss: !cachedResponse
+                };
+                // for on-demand revalidate wait to resolve until cache is set
+                if (!context.isOnDemandRevalidate) {
+                    resolve(resolveValue);
+                }
+                if (key && cacheEntry && typeof cacheEntry.revalidate !== "undefined") {
+                    if (this.minimalMode) {
+                        this.previousCacheItem = {
+                            key: pendingResponseKey || key,
+                            entry: cacheEntry,
+                            expiresAt: Date.now() + 1000
+                        };
+                    } else {
+                        var _cacheEntry_value;
+                        await incrementalCache.set(key, ((_cacheEntry_value = cacheEntry.value) == null ? void 0 : _cacheEntry_value.kind) === "PAGE" ? {
+                            kind: "PAGE",
+                            html: cacheEntry.value.html.toUnchunkedString(),
+                            pageData: cacheEntry.value.pageData,
+                            headers: cacheEntry.value.headers,
+                            status: cacheEntry.value.status
+                        } : cacheEntry.value, {
+                            revalidate: cacheEntry.revalidate
+                        });
+                    }
+                } else {
+                    this.previousCacheItem = undefined;
+                }
+                if (context.isOnDemandRevalidate) {
+                    resolve(resolveValue);
+                }
+            } catch (err) {
+                // when a getStaticProps path is erroring we automatically re-set the
+                // existing cache under a new expiration to prevent non-stop retrying
+                if (cachedResponse && key) {
+                    await incrementalCache.set(key, cachedResponse.value, {
+                        revalidate: Math.min(Math.max(cachedResponse.revalidate || 3, 3), 30)
+                    });
+                }
+                // while revalidating in the background we can't reject as
+                // we already resolved the cache entry so log the error here
+                if (resolved) {
+                    console.error(err);
+                } else {
+                    rejecter(err);
+                }
+            } finally{
+                if (pendingResponseKey) {
+                    this.pendingResponses.delete(pendingResponseKey);
+                }
+            }
+        })();
+        return promise;
+    }
+}
+
+//# sourceMappingURL=index.js.map

node_modules/next/dist/server/response-cache/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/response-cache/index.ts"],"names":["ResponseCache","constructor","minimalMode","pendingResponses","Map","minimalModeKey","get","key","responseGenerator","context","incrementalCache","pendingResponseKey","isOnDemandRevalidate","pendingResponse","resolver","rejecter","promise","Promise","resolve","reject","set","resolved","cacheEntry","previousCacheItem","expiresAt","Date","now","entry","delete","cachedResponse","value","kind","Error","isStale","revalidate","curRevalidate","html","RenderResult","fromStatic","pageData","headers","status","isPrefetch","resolveValue","isMiss","toUnchunkedString","undefined","err","Math","min","max","console","error"],"mappings":"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"}

node_modules/next/dist/server/response-cache/types.d.ts

@@ -0,0 +1,88 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import type { OutgoingHttpHeaders } from 'http';
+import type RenderResult from '../render-result';
+export interface ResponseCacheBase {
+    get(key: string | null, responseGenerator: ResponseGenerator, context: {
+        isOnDemandRevalidate?: boolean;
+        isPrefetch?: boolean;
+        incrementalCache: IncrementalCache;
+    }): Promise<ResponseCacheEntry | null>;
+}
+export interface CachedFetchValue {
+    kind: 'FETCH';
+    data: {
+        headers: {
+            [k: string]: string;
+        };
+        body: string;
+        url: string;
+        status?: number;
+        tags?: string[];
+    };
+    revalidate: number;
+}
+export interface CachedRedirectValue {
+    kind: 'REDIRECT';
+    props: Object;
+}
+interface CachedPageValue {
+    kind: 'PAGE';
+    html: RenderResult;
+    pageData: Object;
+    status?: number;
+    headers?: OutgoingHttpHeaders;
+}
+export interface CachedRouteValue {
+    kind: 'ROUTE';
+    body: Buffer;
+    status: number;
+    headers: OutgoingHttpHeaders;
+}
+export interface CachedImageValue {
+    kind: 'IMAGE';
+    etag: string;
+    buffer: Buffer;
+    extension: string;
+    isMiss?: boolean;
+    isStale?: boolean;
+}
+interface IncrementalCachedPageValue {
+    kind: 'PAGE';
+    html: string;
+    pageData: Object;
+    headers?: OutgoingHttpHeaders;
+    status?: number;
+}
+export type IncrementalCacheEntry = {
+    curRevalidate?: number | false;
+    revalidateAfter: number | false;
+    isStale?: boolean | -1;
+    value: IncrementalCacheValue | null;
+};
+export type IncrementalCacheValue = CachedRedirectValue | IncrementalCachedPageValue | CachedImageValue | CachedFetchValue | CachedRouteValue;
+export type ResponseCacheValue = CachedRedirectValue | CachedPageValue | CachedImageValue | CachedRouteValue;
+export type ResponseCacheEntry = {
+    revalidate?: number | false;
+    value: ResponseCacheValue | null;
+    isStale?: boolean | -1;
+    isMiss?: boolean;
+};
+export type ResponseGenerator = (hasResolved: boolean, cacheEntry?: IncrementalCacheItem) => Promise<ResponseCacheEntry | null>;
+export type IncrementalCacheItem = {
+    revalidateAfter?: number | false;
+    curRevalidate?: number | false;
+    revalidate?: number | false;
+    value: IncrementalCacheValue | null;
+    isStale?: boolean | -1;
+    isMiss?: boolean;
+} | null;
+export interface IncrementalCache {
+    get: (key: string, ctx?: {
+        fetchCache?: boolean;
+    }) => Promise<IncrementalCacheItem>;
+    set: (key: string, data: IncrementalCacheValue | null, ctx: {
+        revalidate: number | false;
+    }) => Promise<void>;
+}
+export {};

node_modules/next/dist/server/response-cache/types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=types.js.map

node_modules/next/dist/server/response-cache/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":""}

node_modules/next/dist/server/response-cache/web.d.ts

@@ -0,0 +1,20 @@
+import type { ResponseCacheEntry, ResponseGenerator } from './types';
+/**
+ * In the web server, there is currently no incremental cache provided and we
+ * always SSR the page.
+ */
+export default class WebResponseCache {
+    pendingResponses: Map<string, Promise<ResponseCacheEntry | null>>;
+    previousCacheItem?: {
+        key: string;
+        entry: ResponseCacheEntry | null;
+        expiresAt: number;
+    };
+    minimalMode?: boolean;
+    constructor(minimalMode: boolean);
+    get(key: string | null, responseGenerator: ResponseGenerator, context: {
+        isOnDemandRevalidate?: boolean;
+        isPrefetch?: boolean;
+        incrementalCache: any;
+    }): Promise<ResponseCacheEntry | null>;
+}

node_modules/next/dist/server/response-cache/web.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, /**
+ * In the web server, there is currently no incremental cache provided and we
+ * always SSR the page.
+ */ "default", {
+    enumerable: true,
+    get: function() {
+        return WebResponseCache;
+    }
+});
+class WebResponseCache {
+    constructor(minimalMode){
+        this.pendingResponses = new Map();
+        // this is a hack to avoid Webpack knowing this is equal to this.minimalMode
+        // because we replace this.minimalMode to true in production bundles.
+        Object.assign(this, {
+            minimalMode
+        });
+    }
+    get(key, responseGenerator, context) {
+        var _this_previousCacheItem;
+        // ensure on-demand revalidate doesn't block normal requests
+        const pendingResponseKey = key ? `${key}-${context.isOnDemandRevalidate ? "1" : "0"}` : null;
+        const pendingResponse = pendingResponseKey ? this.pendingResponses.get(pendingResponseKey) : null;
+        if (pendingResponse) {
+            return pendingResponse;
+        }
+        let resolver = ()=>{};
+        let rejecter = ()=>{};
+        const promise = new Promise((resolve, reject)=>{
+            resolver = resolve;
+            rejecter = reject;
+        });
+        if (pendingResponseKey) {
+            this.pendingResponses.set(pendingResponseKey, promise);
+        }
+        let resolved = false;
+        const resolve = (cacheEntry)=>{
+            if (pendingResponseKey) {
+                // Ensure all reads from the cache get the latest value.
+                this.pendingResponses.set(pendingResponseKey, Promise.resolve(cacheEntry));
+            }
+            if (!resolved) {
+                resolved = true;
+                resolver(cacheEntry);
+            }
+        };
+        // we keep the previous cache entry around to leverage
+        // when the incremental cache is disabled in minimal mode
+        if (pendingResponseKey && this.minimalMode && ((_this_previousCacheItem = this.previousCacheItem) == null ? void 0 : _this_previousCacheItem.key) === pendingResponseKey && this.previousCacheItem.expiresAt > Date.now()) {
+            resolve(this.previousCacheItem.entry);
+            this.pendingResponses.delete(pendingResponseKey);
+            return promise;
+        }
+        (async ()=>{
+            try {
+                const cacheEntry = await responseGenerator(resolved);
+                const resolveValue = cacheEntry === null ? null : {
+                    ...cacheEntry,
+                    isMiss: true
+                };
+                // for on-demand revalidate wait to resolve until cache is set
+                if (!context.isOnDemandRevalidate) {
+                    resolve(resolveValue);
+                }
+                if (key && cacheEntry && typeof cacheEntry.revalidate !== "undefined") {
+                    this.previousCacheItem = {
+                        key: pendingResponseKey || key,
+                        entry: cacheEntry,
+                        expiresAt: Date.now() + 1000
+                    };
+                } else {
+                    this.previousCacheItem = undefined;
+                }
+                if (context.isOnDemandRevalidate) {
+                    resolve(resolveValue);
+                }
+            } catch (err) {
+                // while revalidating in the background we can't reject as
+                // we already resolved the cache entry so log the error here
+                if (resolved) {
+                    console.error(err);
+                } else {
+                    rejecter(err);
+                }
+            } finally{
+                if (pendingResponseKey) {
+                    this.pendingResponses.delete(pendingResponseKey);
+                }
+            }
+        })();
+        return promise;
+    }
+}
+
+//# sourceMappingURL=web.js.map

node_modules/next/dist/server/response-cache/web.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/response-cache/web.ts"],"names":["WebResponseCache","constructor","minimalMode","pendingResponses","Map","Object","assign","get","key","responseGenerator","context","pendingResponseKey","isOnDemandRevalidate","pendingResponse","resolver","rejecter","promise","Promise","resolve","reject","set","resolved","cacheEntry","previousCacheItem","expiresAt","Date","now","entry","delete","resolveValue","isMiss","revalidate","undefined","err","console","error"],"mappings":";;;;+BAEA;;;CAGC,GACD;;;eAAqBA;;;AAAN,MAAMA;IASnBC,YAAYC,WAAoB,CAAE;QAChC,IAAI,CAACC,gBAAgB,GAAG,IAAIC;QAC5B,4EAA4E;QAC5E,qEAAqE;QACrEC,OAAOC,MAAM,CAAC,IAAI,EAAE;YAAEJ;QAAY;IACpC;IAEOK,IACLC,GAAkB,EAClBC,iBAAoC,EACpCC,OAIC,EACmC;YA6ClC;QA5CF,4DAA4D;QAC5D,MAAMC,qBAAqBH,MACvB,CAAC,EAAEA,IAAI,CAAC,EAAEE,QAAQE,oBAAoB,GAAG,MAAM,IAAI,CAAC,GACpD;QAEJ,MAAMC,kBAAkBF,qBACpB,IAAI,CAACR,gBAAgB,CAACI,GAAG,CAACI,sBAC1B;QACJ,IAAIE,iBAAiB;YACnB,OAAOA;QACT;QAEA,IAAIC,WAA4D,KAAO;QACvE,IAAIC,WAAmC,KAAO;QAC9C,MAAMC,UAA8C,IAAIC,QACtD,CAACC,SAASC;YACRL,WAAWI;YACXH,WAAWI;QACb;QAEF,IAAIR,oBAAoB;YACtB,IAAI,CAACR,gBAAgB,CAACiB,GAAG,CAACT,oBAAoBK;QAChD;QAEA,IAAIK,WAAW;QACf,MAAMH,UAAU,CAACI;YACf,IAAIX,oBAAoB;gBACtB,wDAAwD;gBACxD,IAAI,CAACR,gBAAgB,CAACiB,GAAG,CACvBT,oBACAM,QAAQC,OAAO,CAACI;YAEpB;YACA,IAAI,CAACD,UAAU;gBACbA,WAAW;gBACXP,SAASQ;YACX;QACF;QAEA,sDAAsD;QACtD,yDAAyD;QACzD,IACEX,sBACA,IAAI,CAACT,WAAW,IAChB,EAAA,0BAAA,IAAI,CAACqB,iBAAiB,qBAAtB,wBAAwBf,GAAG,MAAKG,sBAChC,IAAI,CAACY,iBAAiB,CAACC,SAAS,GAAGC,KAAKC,GAAG,IAC3C;YACAR,QAAQ,IAAI,CAACK,iBAAiB,CAACI,KAAK;YACpC,IAAI,CAACxB,gBAAgB,CAACyB,MAAM,CAACjB;YAC7B,OAAOK;QACT;QAKE,CAAA;YACA,IAAI;gBACF,MAAMM,aAAa,MAAMb,kBAAkBY;gBAC3C,MAAMQ,eACJP,eAAe,OACX,OACA;oBACE,GAAGA,UAAU;oBACbQ,QAAQ;gBACV;gBAEN,8DAA8D;gBAC9D,IAAI,CAACpB,QAAQE,oBAAoB,EAAE;oBACjCM,QAAQW;gBACV;gBAEA,IAAIrB,OAAOc,cAAc,OAAOA,WAAWS,UAAU,KAAK,aAAa;oBACrE,IAAI,CAACR,iBAAiB,GAAG;wBACvBf,KAAKG,sBAAsBH;wBAC3BmB,OAAOL;wBACPE,WAAWC,KAAKC,GAAG,KAAK;oBAC1B;gBACF,OAAO;oBACL,IAAI,CAACH,iBAAiB,GAAGS;gBAC3B;gBAEA,IAAItB,QAAQE,oBAAoB,EAAE;oBAChCM,QAAQW;gBACV;YACF,EAAE,OAAOI,KAAK;gBACZ,0DAA0D;gBAC1D,4DAA4D;gBAC5D,IAAIZ,UAAU;oBACZa,QAAQC,KAAK,CAACF;gBAChB,OAAO;oBACLlB,SAASkB;gBACX;YACF,SAAU;gBACR,IAAItB,oBAAoB;oBACtB,IAAI,CAACR,gBAAgB,CAACyB,MAAM,CAACjB;gBAC/B;YACF;QACF,CAAA;QACA,OAAOK;IACT;AACF"}