Initial boiler plate project

node_modules/next/dist/server/async-storage/request-async-storage-wrapper.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "RequestAsyncStorageWrapper", {
+    enumerable: true,
+    get: function() {
+        return RequestAsyncStorageWrapper;
+    }
+});
+const _approuterheaders = require("../../client/components/app-router-headers");
+const _headers = require("../web/spec-extension/adapters/headers");
+const _requestcookies = require("../web/spec-extension/adapters/request-cookies");
+const _cookies = require("../web/spec-extension/cookies");
+const _draftmodeprovider = require("./draft-mode-provider");
+const _utils = require("../web/utils");
+function getHeaders(headers) {
+    const cleaned = _headers.HeadersAdapter.from(headers);
+    for (const param of _approuterheaders.FLIGHT_PARAMETERS){
+        cleaned.delete(param.toString().toLowerCase());
+    }
+    return _headers.HeadersAdapter.seal(cleaned);
+}
+function getMutableCookies(headers, onUpdateCookies) {
+    const cookies = new _cookies.RequestCookies(_headers.HeadersAdapter.from(headers));
+    return _requestcookies.MutableRequestCookiesAdapter.wrap(cookies, onUpdateCookies);
+}
+/**
+ * If middleware set cookies in this request (indicated by `x-middleware-set-cookie`),
+ * then merge those into the existing cookie object, so that when `cookies()` is accessed
+ * it's able to read the newly set cookies.
+ */ function mergeMiddlewareCookies(req, existingCookies) {
+    if ("x-middleware-set-cookie" in req.headers && typeof req.headers["x-middleware-set-cookie"] === "string") {
+        const setCookieValue = req.headers["x-middleware-set-cookie"];
+        const responseHeaders = new Headers();
+        for (const cookie of (0, _utils.splitCookiesString)(setCookieValue)){
+            responseHeaders.append("set-cookie", cookie);
+        }
+        const responseCookies = new _cookies.ResponseCookies(responseHeaders);
+        // Transfer cookies from ResponseCookies to RequestCookies
+        for (const cookie of responseCookies.getAll()){
+            existingCookies.set(cookie);
+        }
+    }
+}
+const RequestAsyncStorageWrapper = {
+    /**
+   * Wrap the callback with the given store so it can access the underlying
+   * store using hooks.
+   *
+   * @param storage underlying storage object returned by the module
+   * @param context context to seed the store
+   * @param callback function to call within the scope of the context
+   * @returns the result returned by the callback
+   */ wrap (storage, { req, res, renderOpts }, callback) {
+        let previewProps = undefined;
+        if (renderOpts && "previewProps" in renderOpts) {
+            // TODO: investigate why previewProps isn't on RenderOpts
+            previewProps = renderOpts.previewProps;
+        }
+        function defaultOnUpdateCookies(cookies) {
+            if (res) {
+                res.setHeader("Set-Cookie", cookies);
+            }
+        }
+        const cache = {};
+        const store = {
+            get headers () {
+                if (!cache.headers) {
+                    // Seal the headers object that'll freeze out any methods that could
+                    // mutate the underlying data.
+                    cache.headers = getHeaders(req.headers);
+                }
+                return cache.headers;
+            },
+            get cookies () {
+                if (!cache.cookies) {
+                    // if middleware is setting cookie(s), then include those in
+                    // the initial cached cookies so they can be read in render
+                    const requestCookies = new _cookies.RequestCookies(_headers.HeadersAdapter.from(req.headers));
+                    mergeMiddlewareCookies(req, requestCookies);
+                    // Seal the cookies object that'll freeze out any methods that could
+                    // mutate the underlying data.
+                    cache.cookies = _requestcookies.RequestCookiesAdapter.seal(requestCookies);
+                }
+                return cache.cookies;
+            },
+            get mutableCookies () {
+                if (!cache.mutableCookies) {
+                    const mutableCookies = getMutableCookies(req.headers, (renderOpts == null ? void 0 : renderOpts.onUpdateCookies) || (res ? defaultOnUpdateCookies : undefined));
+                    mergeMiddlewareCookies(req, mutableCookies);
+                    cache.mutableCookies = mutableCookies;
+                }
+                return cache.mutableCookies;
+            },
+            get draftMode () {
+                if (!cache.draftMode) {
+                    cache.draftMode = new _draftmodeprovider.DraftModeProvider(previewProps, req, this.cookies, this.mutableCookies);
+                }
+                return cache.draftMode;
+            },
+            reactLoadableManifest: (renderOpts == null ? void 0 : renderOpts.reactLoadableManifest) || {},
+            assetPrefix: (renderOpts == null ? void 0 : renderOpts.assetPrefix) || ""
+        };
+        return storage.run(store, callback, store);
+    }
+};
+
+//# sourceMappingURL=request-async-storage-wrapper.js.map