vike 0.4.228 → 0.4.229-commit-2a06dcc

package/dist/cjs/node/runtime/html/injectAssets/getHtmlTags.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getHtmlTags = getHtmlTags;
 const isFontFallback_js_1 = require("../../renderPage/isFontFallback.js");
 const utils_js_1 = require("../../utils.js");
-const serializePageContextClientSide_js_1 = require("../serializePageContextClientSide.js");
+const serializeContext_js_1 = require("../serializeContext.js");
 const sanitizeJson_js_1 = require("./sanitizeJson.js");
 const inferHtmlTags_js_1 = require("./inferHtmlTags.js");
 const mergeScriptTags_js_1 = require("./mergeScriptTags.js");
@@ -14,11 +14,12 @@ const helpers_js_1 = require("../../../../shared/page-configs/helpers.js");
 const getConfigValueRuntime_js_1 = require("../../../../shared/page-configs/getConfigValueRuntime.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const getConfigDefinedAt_js_1 = require("../../../../shared/page-configs/getConfigDefinedAt.js");
+const htmlElementIds_js_1 = require("../../../../shared/htmlElementIds.js");
 const stamp = '__injectFilterEntry';
 async function getHtmlTags(pageContext, streamFromReactStreamingPackage, injectFilter, pageAssets, viteDevScript, isStream) {
     (0, utils_js_1.assert)([true, false].includes(pageContext._isHtmlOnly));
     const isHtmlOnly = pageContext._isHtmlOnly;
-    const { isProduction } = pageContext._globalContext;
+    const { _isProduction: isProduction } = pageContext._globalContext;
     const injectScriptsAt = getInjectScriptsAt(pageContext.pageId, pageContext._pageConfigs);
     const injectFilterEntries = [];
     pageAssets
@@ -124,14 +125,21 @@ async function getHtmlTags(pageContext, streamFromReactStreamingPackage, injectF
         //   - https://github.com/vikejs/vike-vue/issues/85
         (0, utils_js_1.assertWarning)(false, "We recommend against using HTML streaming and a pageContext promise (https://vike.dev/streaming#initial-data-after-stream-end) at the same time, because progressive hydration (https://vike.dev/streaming#progressive-rendering) won't work.", { onlyOnce: true });
     }
-    // <script id="vike_pageContext" type="application/json">
     if (!isHtmlOnly) {
+        // <script id="vike_pageContext" type="application/json">
         htmlTags.push({
             htmlTag: () => 
             // Needs to be called after resolvePageContextPromise()
             getPageContextJsonScriptTag(pageContext),
             position: positionJavaScriptEntry
         });
+        // <script id="vike_globalContext" type="application/json">
+        htmlTags.push({
+            htmlTag: () => 
+            // Needs to be called after resolvePageContextPromise()
+            getGlobalContextJsonScriptTag(pageContext),
+            position: positionJavaScriptEntry
+        });
     }
     // The JavaScript entry <script> tag
     const scriptEntry = mergeScriptEntries(pageAssets, viteDevScript);
@@ -162,13 +170,18 @@ function mergeScriptEntries(pageAssets, viteDevScript) {
     return scriptTag;
 }
 function getPageContextJsonScriptTag(pageContext) {
-    const pageContextSerialized = (0, sanitizeJson_js_1.sanitizeJson)((0, serializePageContextClientSide_js_1.serializePageContextClientSide)(pageContext));
-    const htmlTag = `<script id="vike_pageContext" type="application/json">${pageContextSerialized}</script>`;
+    const pageContextClientSerialized = (0, sanitizeJson_js_1.sanitizeJson)((0, serializeContext_js_1.getPageContextClientSerialized)(pageContext));
+    const htmlTag = `<script id="${htmlElementIds_js_1.htmlElementId_pageContext}" type="application/json">${pageContextClientSerialized}</script>`;
     // Used by contra.com https://github.com/gajus
     // @ts-expect-error
     pageContext._pageContextHtmlTag = htmlTag;
     return htmlTag;
 }
+function getGlobalContextJsonScriptTag(pageContext) {
+    const globalContextClientSerialized = (0, sanitizeJson_js_1.sanitizeJson)((0, serializeContext_js_1.getGlobalContextClientSerialized)(pageContext));
+    const htmlTag = `<script id="${htmlElementIds_js_1.htmlElementId_globalContext}" type="application/json">${globalContextClientSerialized}</script>`;
+    return htmlTag;
+}
 function assertInjectFilterEntries(injectFilterEntries) {
     try {
         checkForWrongUsage(injectFilterEntries);

package/dist/cjs/node/runtime/html/injectAssets/getViteDevScript.js

@@ -9,10 +9,10 @@ const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const reachOutCTA = 'Create a new GitHub issue to discuss a solution.';
 async function getViteDevScript(pageContext) {
     const globalContext = pageContext._globalContext;
-    if (globalContext.isProduction) {
+    if (globalContext._isProduction) {
         return '';
     }
-    const { viteDevServer } = globalContext;
+    const { _viteDevServer: viteDevServer } = globalContext;
     const fakeHtmlBegin = '<html> <head>'; // White space to test whether user is using a minifier
     const fakeHtmlEnd = '</head><body></body></html>';
     let fakeHtml = fakeHtmlBegin + fakeHtmlEnd;

package/dist/cjs/node/runtime/html/propKeys.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPropVal = getPropVal;
+exports.setPropVal = setPropVal;
+exports.getPropKeys = getPropKeys;
+const utils_js_1 = require("../utils.js");
+// Get a nested property from an object using a dot-separated path such as 'user.id'
+function getPropVal(obj, prop) {
+    const keys = getPropKeys(prop);
+    let value = obj;
+    for (const key of keys) {
+        if ((0, utils_js_1.isObject)(value) && key in value) {
+            value = value[key];
+        }
+        else {
+            return null; // Property or intermediate property doesn't exist
+        }
+    }
+    return { value };
+}
+// Set a nested property in an object using a dot-separated path such as 'user.id'
+function setPropVal(obj, prop, val) {
+    const keys = getPropKeys(prop);
+    let currentObj = obj;
+    // Creating intermediate objects if necessary
+    for (let i = 0; i <= keys.length - 2; i++) {
+        const key = keys[i];
+        if (!(key in currentObj)) {
+            // Create intermediate object
+            currentObj[key] = {};
+        }
+        if (!(0, utils_js_1.isObject)(currentObj[key])) {
+            // Skip value upon data structure conflict
+            return;
+        }
+        currentObj = currentObj[key];
+    }
+    // Set the final key to the value
+    const finalKey = keys[keys.length - 1];
+    currentObj[finalKey] = val;
+}
+function getPropKeys(prop) {
+    // Like `prop.split('.')` but with added support for `\` escaping, see getPageContextClientSerialized.spec.ts
+    return prop
+        .split(/(?<!\\)\./) // Split on unescaped dots
+        .map((key) => key.replace(/\\\./g, '.')); // Replace escaped dots with literal dots
+}

package/dist/cjs/node/runtime/html/renderHtml.js

@@ -76,7 +76,13 @@ async function renderHtmlStream(streamOriginal, injectString, pageContext, onErr
             return injectAtStreamAfterFirstChunk();
         };
     }
+    let makeClosableAgain = () => { };
+    if ((0, react_streaming_js_1.isStreamFromReactStreamingPackage)(streamOriginal)) {
+        // Make sure Vike injects its HTML fragments, such as `<script id="vike_pageContext" type="application/json">`, before the stream is closed
+        makeClosableAgain = streamOriginal.doNotClose();
+    }
     const streamWrapper = await (0, stream_js_1.processStream)(streamOriginal, processStreamOptions);
+    makeClosableAgain();
     return streamWrapper;
 }
 function isTemplateWrapped(something) {
@@ -197,7 +203,7 @@ function renderTemplate(templateContent, pageContext) {
             }
         }
         {
-            const { isProduction } = pageContext._globalContext;
+            const { _isProduction: isProduction } = pageContext._globalContext;
             if ((0, utils_js_1.isHtml)(templateVar) &&
                 // We don't show this warning in production because it's expected that some users may (un)willingly do some XSS injection: we avoid flooding the production logs.
                 !isProduction) {

package/dist/cjs/node/runtime/html/{serializePageContextClientSide.js → serializeContext.js}

@@ -3,9 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.serializePageContextClientSide = serializePageContextClientSide;
-exports.serializePageContextAbort = serializePageContextAbort;
-exports.getPropKeys = getPropKeys;
+exports.getPageContextClientSerialized = getPageContextClientSerialized;
+exports.getPageContextClientSerializedAbort = getPageContextClientSerializedAbort;
+exports.getGlobalContextClientSerialized = getGlobalContextClientSerialized;
 const stringify_1 = require("@brillout/json-serializer/stringify");
 const utils_js_1 = require("../utils.js");
 const error_page_js_1 = require("../../../shared/error-page.js");
@@ -14,7 +14,8 @@ const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const NOT_SERIALIZABLE_js_1 = require("../../../shared/NOT_SERIALIZABLE.js");
 const pageContextInitIsPassedToClient_js_1 = require("../../../shared/misc/pageContextInitIsPassedToClient.js");
 const isServerSideError_js_1 = require("../../../shared/misc/isServerSideError.js");
-const PASS_TO_CLIENT = [
+const propKeys_js_1 = require("./propKeys.js");
+const passToClientBuiltInPageContext = [
     'abortReason',
     '_urlRewrite',
     '_urlRedirect',
@@ -28,29 +29,39 @@ const PASS_TO_CLIENT = [
     'routeParams',
     'data' // for data() hook
 ];
-const PASS_TO_CLIENT_ERROR_PAGE = ['pageProps', 'is404', isServerSideError_js_1.isServerSideError];
-function serializePageContextClientSide(pageContext) {
-    const passToClient = getPassToClient(pageContext);
-    const pageContextClient = applyPassToClient(passToClient, pageContext);
-    if (passToClient.some((prop) => getPropVal(pageContext._pageContextInit, prop))) {
+const pageToClientBuiltInPageContextError = ['pageProps', 'is404', isServerSideError_js_1.isServerSideError];
+function getPageContextClientSerialized(pageContext) {
+    const passToClientPageContext = getPassToClientPageContext(pageContext);
+    const pageContextClient = applyPassToClient(passToClientPageContext, pageContext);
+    if (passToClientPageContext.some((prop) => (0, propKeys_js_1.getPropVal)(pageContext._pageContextInit, prop))) {
         pageContextClient[pageContextInitIsPassedToClient_js_1.pageContextInitIsPassedToClient] = true;
     }
-    let pageContextSerialized;
+    const pageContextClientSerialized = serializeObject(pageContextClient, 'pageContext', passToClientPageContext);
+    return pageContextClientSerialized;
+}
+function getGlobalContextClientSerialized(pageContext) {
+    const passToClient = pageContext._passToClient;
+    const globalContextClient = applyPassToClient(passToClient, pageContext.globalContext);
+    const globalContextClientSerialized = serializeObject(globalContextClient, 'globalContext', passToClient);
+    return globalContextClientSerialized;
+}
+function serializeObject(obj, objName, passToClient) {
+    let serialized;
     try {
-        pageContextSerialized = serialize(pageContextClient);
+        serialized = serializeValue(obj);
     }
     catch (err) {
         const h = (s) => picocolors_1.default.cyan(s);
         let hasWarned = false;
         const propsNonSerializable = [];
         passToClient.forEach((prop) => {
-            const res = getPropVal(pageContext, prop);
+            const res = (0, propKeys_js_1.getPropVal)(obj, prop);
             if (!res)
                 return;
             const { value } = res;
-            const varName = `pageContext${getPropKeys(prop).map(utils_js_1.getPropAccessNotation).join('')}`;
+            const varName = `${objName}${(0, propKeys_js_1.getPropKeys)(prop).map(utils_js_1.getPropAccessNotation).join('')}`;
             try {
-                serialize(value, varName);
+                serializeValue(value, varName);
             }
             catch (err) {
                 propsNonSerializable.push(prop);
@@ -62,7 +73,7 @@ function serializePageContextClientSide(pageContext) {
                     }
                     (0, utils_js_1.assertUsage)(false, `Cannot serialize config ${h(pathString)} set by useConfig(), see https://vike.dev/useConfig#serialization-error`);
                 }
-                // Non-serializable pageContext set by the user
+                // Non-serializable property set by the user
                 let msg = [
                     `${h(varName)} can't be serialized and, therefore, can't be passed to the client side.`,
                     `Make sure ${h(varName)} is serializable, or remove ${h(JSON.stringify(prop))} from ${h('passToClient')}.`
@@ -83,31 +94,31 @@ function serializePageContextClientSide(pageContext) {
         });
         (0, utils_js_1.assert)(hasWarned);
         propsNonSerializable.forEach((prop) => {
-            pageContextClient[getPropKeys(prop)[0]] = NOT_SERIALIZABLE_js_1.NOT_SERIALIZABLE;
+            obj[(0, propKeys_js_1.getPropKeys)(prop)[0]] = NOT_SERIALIZABLE_js_1.NOT_SERIALIZABLE;
         });
         try {
-            pageContextSerialized = serialize(pageContextClient);
+            serialized = serializeValue(obj);
         }
         catch (err) {
             (0, utils_js_1.assert)(false);
         }
     }
-    return pageContextSerialized;
+    return serialized;
 }
-function serialize(value, varName) {
+function serializeValue(value, varName) {
     return (0, stringify_1.stringify)(value, { forbidReactElements: true, valueName: varName });
 }
-function getPassToClient(pageContext) {
-    let passToClient = [...pageContext._passToClient, ...PASS_TO_CLIENT];
+function getPassToClientPageContext(pageContext) {
+    let passToClient = [...pageContext._passToClient, ...passToClientBuiltInPageContext];
     if ((0, error_page_js_1.isErrorPage)(pageContext.pageId, pageContext._pageConfigs)) {
         (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContext, 'is404', 'boolean'));
         (0, addIs404ToPageProps_js_1.addIs404ToPageProps)(pageContext);
-        passToClient.push(...PASS_TO_CLIENT_ERROR_PAGE);
+        passToClient.push(...pageToClientBuiltInPageContextError);
     }
     passToClient = (0, utils_js_1.unique)(passToClient);
     return passToClient;
 }
-function serializePageContextAbort(pageContext) {
+function getPageContextClientSerializedAbort(pageContext) {
     (0, utils_js_1.assert)(pageContext._urlRedirect || pageContext._urlRewrite || pageContext.abortStatusCode);
     (0, utils_js_1.assert)(pageContext._abortCall);
     (0, utils_js_1.assert)(pageContext._abortCaller);
@@ -140,59 +151,18 @@ function serializePageContextAbort(pageContext) {
             onlyOnce: false
         });
     }
-    return serialize(pageContext);
+    return serializeValue(pageContext);
 }
 function applyPassToClient(passToClient, pageContext) {
     const pageContextClient = {};
     passToClient.forEach((prop) => {
         // Get value from pageContext
-        const res = getPropVal(pageContext, prop);
+        const res = (0, propKeys_js_1.getPropVal)(pageContext, prop);
         if (!res)
             return;
         const { value } = res;
         // Set value to pageContextClient
-        setPropVal(pageContextClient, prop, value);
+        (0, propKeys_js_1.setPropVal)(pageContextClient, prop, value);
     });
     return pageContextClient;
 }
-// Get a nested property from an object using a dot-separated path such as 'user.id'
-function getPropVal(obj, prop) {
-    const keys = getPropKeys(prop);
-    let value = obj;
-    for (const key of keys) {
-        if ((0, utils_js_1.isObject)(value) && key in value) {
-            value = value[key];
-        }
-        else {
-            return null; // Property or intermediate property doesn't exist
-        }
-    }
-    return { value };
-}
-// Set a nested property in an object using a dot-separated path such as 'user.id'
-function setPropVal(obj, prop, val) {
-    const keys = getPropKeys(prop);
-    let currentObj = obj;
-    // Creating intermediate objects if necessary
-    for (let i = 0; i <= keys.length - 2; i++) {
-        const key = keys[i];
-        if (!(key in currentObj)) {
-            // Create intermediate object
-            currentObj[key] = {};
-        }
-        if (!(0, utils_js_1.isObject)(currentObj[key])) {
-            // Skip value upon data structure conflict
-            return;
-        }
-        currentObj = currentObj[key];
-    }
-    // Set the final key to the value
-    const finalKey = keys[keys.length - 1];
-    currentObj[finalKey] = val;
-}
-function getPropKeys(prop) {
-    // Like `prop.split('.')` but with added support for `\` escaping, see serializePageContextClientSide.spec.ts
-    return prop
-        .split(/(?<!\\)\./) // Split on unescaped dots
-        .map((key) => key.replace(/\\\./g, '.')); // Replace escaped dots with literal dots
-}

package/dist/cjs/node/runtime/index-deprecated.js

@@ -1,6 +1,4 @@
 "use strict";
-// TODO/v1-release: replace this with:
-// assertUsage(false, "`import { something } from 'vike'` doesn't exist: instead import from 'vike/server', 'vike/client', 'vike/plugin', ...")
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -19,44 +17,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RenderErrorPage = void 0;
-const isBrowser_js_1 = require("../../utils/isBrowser.js");
-const assert_js_1 = require("../../utils/assert.js");
-(0, assert_js_1.assertUsage)(!(0, isBrowser_js_1.isBrowser)(), "It's forbidden to `import { something } from 'vike'` on the client-side: the module 'vike' is a server-only module.", { showStackTrace: true });
-__exportStar(require("./index-common.js"), exports);
-__exportStar(require("../../types/index-dreprecated.js"), exports);
+// TODO/soon: point package.json#exports['./server'] to this file.
+// - Write migration guide, see comment below.
+__exportStar(require("./index.js"), exports);
 const utils_js_1 = require("./utils.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-const abort_js_1 = require("../../shared/route/abort.js");
-/** @deprecated
- * Replace:
- *   ```
- *   import { RenderErrorPage } from 'vike'
- *   ```
- * With:
- *   ```
- *   import { render } from 'vike/abort'
- *   ```
- *
- * See https://vike.dev/render
- */
-const RenderErrorPage = (...args) => {
-    (0, utils_js_1.assertWarning)(false, [
-        'Replace:',
-        picocolors_1.default.red("  import { RenderErrorPage } from 'vike'"),
-        'With:',
-        picocolors_1.default.green("  import { render } from 'vike/abort'"),
-        'See https://vike.dev/render'
-    ].join('\n'), { onlyOnce: true, showStackTrace: true });
-    return (0, abort_js_1.RenderErrorPage)(...args);
-};
-exports.RenderErrorPage = RenderErrorPage;
 (0, utils_js_1.assertWarning)(false, [
-    'You have following imports which are outdated:',
-    picocolors_1.default.red("  import { something } from 'vike'"),
+    'You have outdated imports:',
+    picocolors_1.default.bold(picocolors_1.default.red("  import { something } from 'vike/server'")),
     'Replace them with:',
-    picocolors_1.default.green("  import { something } from 'vike/server'"),
-    `Or if ${picocolors_1.default.cyan('something')} is a type:`,
-    picocolors_1.default.green("  import type { something } from 'vike/types'"),
-    "Make sure to import renderPage(), escapeInject, html, dangerouslySkipEscape(), pipeWebStream(), pipeNodeStream(), pipeStream(), stampPipe() from 'vike/server'. (Or inspect the error stack below to find the import causing this warning.)"
+    picocolors_1.default.bold(picocolors_1.default.green("  import { something } from 'vike'"))
+    /* Add migration guide, with migration scritps such as `$ rename vike/server vike`
+    `See ${pc.underline('https://vike.dev/migration/0.4.xxx')}`
+    */
 ].join('\n'), { showStackTrace: true, onlyOnce: true });

package/dist/cjs/node/runtime/index.js

@@ -13,8 +13,62 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
 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);
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.RenderErrorPage = exports.createPageRenderer = exports._injectAssets = exports.createDevMiddleware = exports.getGlobalContextAsync = exports.getGlobalContextSync = exports.getGlobalContext = exports.version = exports.stampPipe = exports.pipeStream = exports.pipeNodeStream = exports.pipeWebStream = exports.dangerouslySkipEscape = exports.escapeInject = exports.renderPage = void 0;
 const isBrowser_js_1 = require("../../utils/isBrowser.js");
 const assert_js_1 = require("../../utils/assert.js");
-(0, assert_js_1.assertUsage)(!(0, isBrowser_js_1.isBrowser)(), "It's forbidden to `import { something } from 'vike/server'` on the client-side: the module 'vike/server' is a server-only module.", { showStackTrace: true });
-__exportStar(require("./index-common.js"), exports);
+(0, assert_js_1.assert)(!(0, isBrowser_js_1.isBrowser)());
+var renderPage_js_1 = require("./renderPage.js");
+Object.defineProperty(exports, "renderPage", { enumerable: true, get: function () { return renderPage_js_1.renderPage; } });
+var renderHtml_js_1 = require("./html/renderHtml.js");
+Object.defineProperty(exports, "escapeInject", { enumerable: true, get: function () { return renderHtml_js_1.escapeInject; } });
+Object.defineProperty(exports, "dangerouslySkipEscape", { enumerable: true, get: function () { return renderHtml_js_1.dangerouslySkipEscape; } });
+var stream_js_1 = require("./html/stream.js");
+Object.defineProperty(exports, "pipeWebStream", { enumerable: true, get: function () { return stream_js_1.pipeWebStream; } });
+Object.defineProperty(exports, "pipeNodeStream", { enumerable: true, get: function () { return stream_js_1.pipeNodeStream; } });
+Object.defineProperty(exports, "pipeStream", { enumerable: true, get: function () { return stream_js_1.pipeStream; } });
+Object.defineProperty(exports, "stampPipe", { enumerable: true, get: function () { return stream_js_1.stampPipe; } });
+var utils_js_1 = require("./utils.js");
+Object.defineProperty(exports, "version", { enumerable: true, get: function () { return utils_js_1.PROJECT_VERSION; } });
+var globalContext_js_1 = require("./globalContext.js");
+Object.defineProperty(exports, "getGlobalContext", { enumerable: true, get: function () { return globalContext_js_1.getGlobalContext; } });
+Object.defineProperty(exports, "getGlobalContextSync", { enumerable: true, get: function () { return globalContext_js_1.getGlobalContextSync; } });
+Object.defineProperty(exports, "getGlobalContextAsync", { enumerable: true, get: function () { return globalContext_js_1.getGlobalContextAsync; } });
+var index_js_1 = require("../runtime-dev/index.js");
+Object.defineProperty(exports, "createDevMiddleware", { enumerable: true, get: function () { return index_js_1.createDevMiddleware; } });
+// TODO/v1-release: remove
+// Deprecated exports
+__exportStar(require("../../types/index-dreprecated.js"), exports);
+var injectAssets__public_js_1 = require("./html/injectAssets/injectAssets__public.js");
+Object.defineProperty(exports, "_injectAssets", { enumerable: true, get: function () { return injectAssets__public_js_1.injectAssets__public; } });
+var createPageRenderer_js_1 = require("../createPageRenderer.js");
+Object.defineProperty(exports, "createPageRenderer", { enumerable: true, get: function () { return createPageRenderer_js_1.createPageRenderer; } });
+const utils_js_2 = require("./utils.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const abort_js_1 = require("../../shared/route/abort.js");
+/** @deprecated
+ * Replace:
+ *   ```
+ *   import { RenderErrorPage } from 'vike'
+ *   ```
+ * With:
+ *   ```
+ *   import { render } from 'vike/abort'
+ *   ```
+ *
+ * See https://vike.dev/render
+ */
+const RenderErrorPage = (...args) => {
+    (0, utils_js_2.assertWarning)(false, [
+        'Replace:',
+        picocolors_1.default.red("  import { RenderErrorPage } from 'vike'"),
+        'With:',
+        picocolors_1.default.green("  import { render } from 'vike/abort'"),
+        'See https://vike.dev/render'
+    ].join('\n'), { onlyOnce: true, showStackTrace: true });
+    return (0, abort_js_1.RenderErrorPage)(...args);
+};
+exports.RenderErrorPage = RenderErrorPage;

package/dist/cjs/node/runtime/renderPage/analyzePage.js

@@ -22,7 +22,7 @@ async function analyzePage(pageFilesAll, pageConfig, pageId, globalContext) {
             eagerlyImported: false
         });
         // In production we inject the import of the server virtual module with ?extractAssets inside the client virtual module
-        if (!globalContext.isProduction) {
+        if (!globalContext._isProduction) {
             clientDependencies.push({
                 id: (0, virtualFilePageConfigValuesAll_js_1.getVirtualFileIdPageConfigValuesAll)(pageConfig.pageId, false),
                 onlyAssets: true,

package/dist/cjs/node/runtime/renderPage/createHttpResponse.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createHttpResponsePage = createHttpResponsePage;
 exports.createHttpResponsePageContextJson = createHttpResponsePageContextJson;
 exports.createHttpResponseError = createHttpResponseError;
+exports.createHttpResponseErrorWithoutGlobalContext = createHttpResponseErrorWithoutGlobalContext;
 exports.createHttpResponseRedirect = createHttpResponseRedirect;
 exports.createHttpResponseFavicon404 = createHttpResponseFavicon404;
 exports.createHttpResponseBaseIsMissing = createHttpResponseBaseIsMissing;
@@ -66,9 +67,6 @@ function createHttpResponseBaseIsMissing(urlOriginal, baseServer) {
 }
 function createHttpResponseError(pageContext) {
     const reason = (() => {
-        if (!pageContext) {
-            return 'no error page (https://vike.dev/error-page) could be rendered';
-        }
         const errorPageId = (0, error_page_js_1.getErrorPageId)(pageContext._pageFilesAll, pageContext._pageConfigs);
         if (errorPageId) {
             return "the error page (https://vike.dev/error-page) couldn't be rendered (for example if an error occurred while rendering the error page)";
@@ -77,6 +75,13 @@ function createHttpResponseError(pageContext) {
             return 'no error page (https://vike.dev/error-page) is defined, make sure to create one';
         }
     })();
+    return createHttpResponseError_(reason);
+}
+function createHttpResponseErrorWithoutGlobalContext() {
+    const reason = 'no error page (https://vike.dev/error-page) could be rendered';
+    return createHttpResponseError_(reason);
+}
+function createHttpResponseError_(reason) {
     const httpResponse = createHttpResponse(500, 'text/html;charset=utf-8', [], `<p>An error occurred.</p><script>console.log(${JSON.stringify(`This HTTP response was generated by Vike. Vike returned this response because ${reason}.`)})</script>`);
     return httpResponse;
 }

package/dist/cjs/node/runtime/renderPage/createPageContextServerSide.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPageContextServerSide = createPageContextServerSide;
+exports.createPageContextServerSideWithoutGlobalContext = createPageContextServerSideWithoutGlobalContext;
+const utils_js_1 = require("../utils.js");
+const getPageContextUrlComputed_js_1 = require("../../../shared/getPageContextUrlComputed.js");
+const createPageContextShared_js_1 = require("../../../shared/createPageContextShared.js");
+async function createPageContextServerSide(pageContextInit, globalContext, globalObject_public, { isPrerendering, ssr: { urlHandler, isClientSideNavigation } = {
+    urlHandler: null,
+    isClientSideNavigation: false
+} }) {
+    (0, utils_js_1.assert)(pageContextInit.urlOriginal);
+    const pageContextCreated = createPageContext(pageContextInit, isPrerendering);
+    (0, utils_js_1.objectAssign)(pageContextCreated, {
+        /* Don't spread globalContext for now? Or never spread it as it leads to confusion? The convenience isn't worth the added confusion?
+        // We must use Flatten<T> otherwise TypeScript complains upon assigning types
+        ...(globalContext as Flatten<typeof globalContext>), // least precedence
+        */
+        globalContext: globalObject_public,
+        _globalContext: globalContext,
+        // The following is defined on `pageContext` because we can eventually make these non-global
+        _baseServer: globalContext.baseServer,
+        _baseAssets: globalContext.baseAssets,
+        // TODO/now: add meta.default
+        _includeAssetsImportedByServer: globalContext.config.includeAssetsImportedByServer ?? true,
+        // TODO/soon: use GloablContext instead
+        _pageFilesAll: globalContext._pageFilesAll,
+        _pageConfigs: globalContext._pageConfigs,
+        _pageConfigGlobal: globalContext._pageConfigGlobal,
+        _allPageIds: globalContext._allPageIds,
+        _pageRoutes: globalContext._pageRoutes,
+        _onBeforeRouteHook: globalContext._onBeforeRouteHook,
+        _pageContextInit: pageContextInit,
+        _urlRewrite: null,
+        _urlHandler: urlHandler,
+        isClientSideNavigation
+    });
+    // pageContext.urlParsed
+    const pageContextUrlComputed = (0, getPageContextUrlComputed_js_1.getPageContextUrlComputed)(pageContextCreated);
+    (0, utils_js_1.objectAssign)(pageContextCreated, pageContextUrlComputed);
+    // pageContext.headers
+    {
+        let headers;
+        if (pageContextInit.headersOriginal) {
+            headers = (0, utils_js_1.normalizeHeaders)(pageContextInit.headersOriginal);
+            (0, utils_js_1.assertUsage)(!('headers' in pageContextInit), "You're defining pageContextInit.headersOriginal as well as pageContextInit.headers but you should only define pageContextInit.headersOriginal instead, see https://vike.dev/headers");
+        }
+        else if (pageContextInit.headers) {
+            headers = pageContextInit.headers;
+            // TODO/next-major-release: remove
+            (0, utils_js_1.assertWarning)(false, 'Setting pageContextInit.headers is deprecated: set pageContextInit.headersOriginal instead, see https://vike.dev/headers', { onlyOnce: true });
+        }
+        else {
+            headers = null;
+        }
+        (0, utils_js_1.objectAssign)(pageContextCreated, { headers });
+    }
+    const pageContextAugmented = await (0, createPageContextShared_js_1.createPageContextShared)(pageContextCreated, globalContext._pageConfigGlobal);
+    (0, utils_js_1.augmentType)(pageContextCreated, pageContextAugmented);
+    return pageContextCreated;
+}
+function createPageContextServerSideWithoutGlobalContext(pageContextInit) {
+    const pageContext = createPageContext(pageContextInit, false);
+    return pageContext;
+}
+function createPageContext(pageContextInit, isPrerendering) {
+    const pageContext = {
+        isClientSide: false,
+        isPrerendering
+    };
+    (0, utils_js_1.objectAssign)(pageContext, pageContextInit);
+    return pageContext;
+}

package/dist/cjs/node/runtime/renderPage/executeOnBeforeRenderAndDataHooks.js

@@ -9,8 +9,8 @@ async function executeOnBeforeRenderAndDataHooks(pageContext) {
     if (pageContext._pageContextAlreadyProvidedByOnPrerenderHook) {
         return;
     }
-    const dataHook = (0, getHook_js_1.getHook)(pageContext, 'data');
-    const onBeforeRenderHook = (0, getHook_js_1.getHook)(pageContext, 'onBeforeRender');
+    const dataHook = (0, getHook_js_1.getHookFromPageContext)(pageContext, 'data');
+    const onBeforeRenderHook = (0, getHook_js_1.getHookFromPageContext)(pageContext, 'onBeforeRender');
     if (!dataHook && !onBeforeRenderHook) {
         return;
     }

package/dist/cjs/node/runtime/renderPage/executeOnRenderHtmlHook.js

@@ -41,12 +41,12 @@ function getRenderHook(pageContext) {
     {
         let hook;
         let hookName = undefined;
-        hook = (0, getHook_js_1.getHook)(pageContext, 'onRenderHtml');
+        hook = (0, getHook_js_1.getHookFromPageContext)(pageContext, 'onRenderHtml');
         if (hook) {
             hookName = 'onRenderHtml';
         }
         else {
-            hook = (0, getHook_js_1.getHook)(pageContext, 'render');
+            hook = (0, getHook_js_1.getHookFromPageContext)(pageContext, 'render');
             if (hook) {
                 hookName = 'render';
             }

package/dist/cjs/node/runtime/renderPage/getPageAssets/getManifestEntry.js

@@ -42,7 +42,7 @@ function getManifestEntry(id, assetsManifest) {
         return { manifestEntry, manifestKey };
     }
     // npm package import
-    (0, utils_js_1.assertIsNpmPackageImport)(id);
+    (0, utils_js_1.assertIsImportPathNpmPackage)(id);
     const found = Object.entries(assetsManifest).find(([, e]) => e.name === (0, prependEntriesDir_js_1.prependEntriesDir)(id));
     (0, utils_js_1.assert)(found);
     const [manifestKey, manifestEntry] = found;