vike 0.0.0-alpha.0 → 0.4.142-commit-8bf568b

package/dist/cjs/utils/sorter.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeLast = exports.makeFirst = exports.lowerFirst = exports.higherFirst = void 0;
+const assert_js_1 = require("./assert.js");
+// -1 => element1 first (i.e. `indexOf(element1) < indexOf(element2)`)
+// +1 => element2 first (i.e. `indexOf(element2) < indexOf(element1)`)
+// 0 => keep original order of element1 and element2
+function higherFirst(getValue) {
+    return (element1, element2) => {
+        const val1 = getValue(element1);
+        const val2 = getValue(element2);
+        if (val1 === val2) {
+            return 0;
+        }
+        return val1 > val2 ? -1 : 1;
+    };
+}
+exports.higherFirst = higherFirst;
+function lowerFirst(getValue) {
+    return (element1, element2) => {
+        const val1 = getValue(element1);
+        const val2 = getValue(element2);
+        if (val1 === val2) {
+            return 0;
+        }
+        return val1 < val2 ? -1 : 1;
+    };
+}
+exports.lowerFirst = lowerFirst;
+function makeFirst(getValue) {
+    return (element1, element2) => {
+        const val1 = getValue(element1);
+        const val2 = getValue(element2);
+        (0, assert_js_1.assert)([true, false, null].includes(val1));
+        (0, assert_js_1.assert)([true, false, null].includes(val2));
+        if (val1 === val2) {
+            return 0;
+        }
+        if (val1 === true || val2 === false) {
+            return -1;
+        }
+        if (val2 === true || val1 === false) {
+            return 1;
+        }
+        (0, assert_js_1.assert)(false);
+    };
+}
+exports.makeFirst = makeFirst;
+function makeLast(getValue) {
+    return makeFirst((element) => {
+        const val = getValue(element);
+        if (val === null) {
+            return null;
+        }
+        else {
+            return !val;
+        }
+    });
+}
+exports.makeLast = makeLast;

package/dist/cjs/utils/stringifyStringArray.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringifyStringArray = void 0;
+function stringifyStringArray(stringList) {
+    return '[' + stringList.map((str) => "'" + str + "'").join(', ') + ']';
+}
+exports.stringifyStringArray = stringifyStringArray;

package/dist/cjs/utils/stripAnsi.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripAnsi = void 0;
+const assertIsNotBrowser_js_1 = require("./assertIsNotBrowser.js");
+(0, assertIsNotBrowser_js_1.assertIsNotBrowser)();
+const ansiRegex = getAnsiRegex();
+// Copied from https://github.com/chalk/strip-ansi/blob/1fdc531d4046cbaa830460f5c74452bf1f0a0884/index.js
+function stripAnsi(string) {
+    // Even though the regex is global, we don't need to reset the `.lastIndex`
+    // because unlike `.exec()` and `.test()`, `.replace()` does it automatically
+    // and doing it manually has a performance penalty.
+    return string.replace(ansiRegex, '');
+}
+exports.stripAnsi = stripAnsi;
+// Copied from https://github.com/chalk/ansi-regex/blob/02fa893d619d3da85411acc8fd4e2eea0e95a9d9/index.js
+function getAnsiRegex() {
+    const pattern = [
+        '[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)',
+        '(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))'
+    ].join('|');
+    return new RegExp(pattern, 'g');
+}

package/dist/cjs/utils/styleFileRE.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.styleFileRE = void 0;
+// Copied from https://github.com/vitejs/vite/blob/d649daba7682791178b711d9a3e44a6b5d00990c/packages/vite/src/node/plugins/css.ts#L90-L91
+exports.styleFileRE = /\.(css|less|sass|scss|styl|stylus|pcss|postcss)($|\?)/;

package/dist/cjs/utils/throttle.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.throttle = void 0;
+function throttle(func, waitTime) {
+    let isQueued = false;
+    return () => {
+        if (!isQueued) {
+            isQueued = true;
+            setTimeout(() => {
+                isQueued = false;
+                func();
+            }, waitTime);
+        }
+    };
+}
+exports.throttle = throttle;

package/dist/cjs/utils/trackLogs.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const debug_js_1 = require("./debug.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const assertIsNotBrowser_js_1 = require("./assertIsNotBrowser.js");
+(0, assertIsNotBrowser_js_1.assertIsNotBrowser)();
+if ((0, debug_js_1.isDebugEnabled)('vike:log')) {
+    trackLogs();
+}
+// https://stackoverflow.com/questions/45395369/how-to-get-console-log-line-numbers-shown-in-nodejs/75109905#75109905
+function trackLogs() {
+    const logOriginal = process.stdout.write;
+    // @ts-ignore
+    const log = (msg) => logOriginal.call(process.stdout, msg + '\n');
+    ['stdout', 'stderr'].forEach((stdName) => {
+        // @ts-ignore
+        var methodOriginal = process[stdName].write;
+        // @ts-ignore
+        process[stdName].write = function (...args) {
+            log(picocolors_1.default.bold(picocolors_1.default.blue('*** LOG ***')));
+            // @ts-ignore
+            methodOriginal.apply(process[stdName], args);
+            // @ts-ignore
+            log(new Error().stack.replace(/^Error(\:|)/, picocolors_1.default.magenta('*** LOG ORIGIN ***')));
+        };
+    });
+    Error.stackTraceLimit = Infinity;
+}

package/dist/cjs/utils/trimWithAnsi.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trimWithAnsiTrailOnly = exports.trimWithAnsi = void 0;
+const assert_js_1 = require("./assert.js");
+const stripAnsi_js_1 = require("./stripAnsi.js");
+const whitespaceRegex = /(\s+)/; // Capturing parathesis so that split preserves seperator
+/* Same as trim() but works with ANSI escape codes */
+function trimWithAnsi(str) {
+    str = trimWithAnsiHead(str);
+    str = trimWithAnsiTrailOnly(str);
+    return str;
+}
+exports.trimWithAnsi = trimWithAnsi;
+function trimWithAnsiHead(str) {
+    return trim(str, false);
+}
+function trimWithAnsiTrailOnly(str) {
+    return trim(str, true);
+}
+exports.trimWithAnsiTrailOnly = trimWithAnsiTrailOnly;
+function trim(str, trail) {
+    let parts = str.split(whitespaceRegex);
+    if (trail)
+        parts.reverse();
+    let visible = false;
+    parts = parts.map((line) => {
+        if (visible)
+            return line;
+        const lineTrimmed = line.trim();
+        const lineTrimmedAndStripped = (0, stripAnsi_js_1.stripAnsi)(lineTrimmed);
+        (0, assert_js_1.assert)(lineTrimmedAndStripped.trim() === lineTrimmedAndStripped);
+        if (lineTrimmedAndStripped !== '')
+            visible = true;
+        return lineTrimmed;
+    });
+    if (trail)
+        parts.reverse();
+    (0, assert_js_1.assert)(str.split(whitespaceRegex).join('') === str);
+    const strTrimmed = parts.join('');
+    return strTrimmed;
+}

package/dist/cjs/utils/truncateString.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.truncateString = void 0;
+function truncateString(str, lenMax, dim) {
+    if (str.length < lenMax) {
+        return str;
+    }
+    else {
+        // May break ANSI codes
+        //  - So far, the str we pass to truncateString(str) are expected to not contain any ANSI code
+        str = str.substring(0, lenMax - 3);
+        let ellipsis = '...';
+        if (dim)
+            ellipsis = dim(ellipsis);
+        str = str + ellipsis;
+        return str;
+    }
+}
+exports.truncateString = truncateString;

package/dist/cjs/utils/unique.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unique = void 0;
+function unique(arr) {
+    return Array.from(new Set(arr));
+}
+exports.unique = unique;

package/dist/cjs/utils/urlToFile.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.baseServer = exports.urlToFile = void 0;
+const assert_js_1 = require("./assert.js");
+const parseUrl_js_1 = require("./parseUrl.js");
+const slice_js_1 = require("./slice.js");
+// - When doing a `.pageContext.json` HTTP request, the base URL should be preserved. (The server-side will handle the base URL.)
+// - While prerendering there is no base URL
+const baseServer = '/';
+exports.baseServer = baseServer;
+function urlToFile(url, fileExtension, doNotCreateExtraDirectory) {
+    const { pathnameOriginal, searchOriginal, hashOriginal } = (0, parseUrl_js_1.parseUrl)(url, baseServer);
+    if (url.startsWith('/')) {
+        (0, assert_js_1.assert)(url === `${pathnameOriginal}${searchOriginal || ''}${hashOriginal || ''}`, { url });
+    }
+    const hasTrailingSlash = pathnameOriginal.endsWith('/');
+    let pathnameModified;
+    if (doNotCreateExtraDirectory && pathnameOriginal !== '/') {
+        if (hasTrailingSlash) {
+            pathnameModified = (0, slice_js_1.slice)(pathnameOriginal, 0, -1);
+        }
+        else {
+            pathnameModified = pathnameOriginal;
+        }
+        (0, assert_js_1.assert)(!pathnameModified.endsWith('/'), { url });
+        (0, assert_js_1.assert)(pathnameModified !== '');
+    }
+    else {
+        pathnameModified = pathnameOriginal + (hasTrailingSlash ? '' : '/') + 'index';
+    }
+    (0, assert_js_1.assert)(pathnameModified);
+    pathnameModified = pathnameModified + fileExtension;
+    const fileUrl = `${pathnameModified}${searchOriginal || ''}${hashOriginal || ''}`;
+    return fileUrl;
+}
+exports.urlToFile = urlToFile;

package/dist/cjs/utils/virtual-files.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveVirtualFileId = exports.getVirtualFileId = exports.isVirtualFileId = void 0;
+const assert_js_1 = require("./assert.js");
+const idBase = 'virtual:vike:';
+// https://vitejs.dev/guide/api-plugin.html#virtual-modules-convention
+const tag = '\0';
+function isVirtualFileId(id) {
+    if (id.startsWith(idBase))
+        return true;
+    if (id.startsWith(tag + idBase))
+        return true;
+    (0, assert_js_1.assert)(!id.includes(idBase));
+    return false;
+}
+exports.isVirtualFileId = isVirtualFileId;
+function getVirtualFileId(id) {
+    if (id.startsWith(tag)) {
+        id = id.slice(tag.length);
+    }
+    (0, assert_js_1.assert)(!id.startsWith(tag));
+    return id;
+}
+exports.getVirtualFileId = getVirtualFileId;
+function resolveVirtualFileId(id) {
+    (0, assert_js_1.assert)(isVirtualFileId(id));
+    if (!id.startsWith(tag)) {
+        id = tag + id;
+    }
+    (0, assert_js_1.assert)(id.startsWith(tag));
+    return id;
+}
+exports.resolveVirtualFileId = resolveVirtualFileId;

package/dist/cjs/utils/viteIsSSR.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.viteIsSSR_options = exports.viteIsSSR = void 0;
+const assert_js_1 = require("./assert.js");
+const isObject_js_1 = require("./isObject.js");
+function viteIsSSR(config) {
+    return !!config?.build?.ssr;
+}
+exports.viteIsSSR = viteIsSSR;
+// https://github.com/vitejs/vite/discussions/5109#discussioncomment-1450726
+function viteIsSSR_options(options) {
+    if (options === undefined) {
+        return false;
+    }
+    if (typeof options === 'boolean') {
+        return options;
+    }
+    if ((0, isObject_js_1.isObject)(options)) {
+        return !!options.ssr;
+    }
+    (0, assert_js_1.assert)(false);
+}
+exports.viteIsSSR_options = viteIsSSR_options;

package/dist/cjs/utils/warnIfErrorIsNotObject.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.warnIfErrorIsNotObject = void 0;
+const assert_js_1 = require("./assert.js");
+const assertIsNotBrowser_js_1 = require("./assertIsNotBrowser.js");
+const isObject_js_1 = require("./isObject.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+(0, assertIsNotBrowser_js_1.assertIsNotBrowser)();
+// It would be cleaner to:
+//  - Call assertUsageErrorIsObject() right after calling the user's hook
+//    - Attach the original error: assertUsageError.originalErrorValue = err
+//      - Show the original error in vike's error handling
+//  - Use assertErrorIsObject() throughout Vike's source code
+function warnIfErrorIsNotObject(err) {
+    if (!(0, isObject_js_1.isObject)(err)) {
+        console.warn('[vike] The thrown value is:');
+        console.warn(err);
+        (0, assert_js_1.assertWarning)(false, `One of your hooks threw an error ${picocolors_1.default.cyan('throw someValue')} but ${picocolors_1.default.cyan('someValue')} isn't an object (it's ${picocolors_1.default.cyan(`typeof someValue === ${typeof err}`)} instead). Make sure thrown values are always wrapped with ${picocolors_1.default.cyan('new Error()')}, in other words: ${picocolors_1.default.cyan('throw someValue')} should be replaced with ${picocolors_1.default.cyan('throw new Error(someValue)')}. The thrown value is printed above.`, { onlyOnce: false });
+    }
+}
+exports.warnIfErrorIsNotObject = warnIfErrorIsNotObject;

package/dist/esm/__internal/index.d.ts

@@ -0,0 +1,17 @@
+import { route, type PageRoutes } from '../shared/route/index.js';
+import { type PageFile } from '../shared/getPageFiles.js';
+import { PageConfig } from '../shared/page-configs/PageConfig.js';
+export { route, getPagesAndRoutes };
+export type { PageRoutes, PageFile, PageConfig };
+/**
+ * Used by {@link https://github.com/magne4000/vite-plugin-vercel|vite-plugin-vercel}
+ * to compute some rewrite rules and extract { isr } configs.
+ * Needs `import 'vike/__internal/setup'`
+ * @param config
+ */
+declare function getPagesAndRoutes(): Promise<{
+    pageRoutes: PageRoutes;
+    pageFilesAll: PageFile[];
+    pageConfigs: PageConfig[];
+    allPageIds: string[];
+}>;

package/dist/esm/__internal/index.js

@@ -0,0 +1,27 @@
+// Internal functions of vike needed by other plugins are exported via this file
+import { route } from '../shared/route/index.js';
+import { getGlobalContext, initGlobalContext } from '../node/runtime/globalContext.js';
+import { setNodeEnvToProduction } from '../utils/nodeEnv.js';
+import { assert } from '../utils/assert.js';
+import { getRenderContext } from '../node/runtime/renderPage/renderPageAlreadyRouted.js';
+export { route, getPagesAndRoutes };
+/**
+ * Used by {@link https://github.com/magne4000/vite-plugin-vercel|vite-plugin-vercel}
+ * to compute some rewrite rules and extract { isr } configs.
+ * Needs `import 'vike/__internal/setup'`
+ * @param config
+ */
+async function getPagesAndRoutes() {
+    setNodeEnvToProduction();
+    await initGlobalContext(true);
+    const globalContext = getGlobalContext();
+    assert(globalContext.isProduction === true);
+    const renderContext = await getRenderContext();
+    const { pageFilesAll, pageConfigs, allPageIds, pageRoutes } = renderContext;
+    return {
+        pageRoutes,
+        pageFilesAll,
+        pageConfigs,
+        allPageIds
+    };
+}

package/dist/esm/client/client-routing-runtime/createPageContext.d.ts

@@ -0,0 +1,18 @@
+export { createPageContext };
+declare function createPageContext<T extends {
+    urlOriginal: string;
+}>(pageContextBase?: T): Promise<{
+    _objectCreatedByVike: boolean;
+    _urlHandler: null;
+    _urlRewrite: null;
+    _baseServer: string;
+    _isProduction: boolean;
+    _pageFilesAll: import("../../shared/getPageFiles/getPageFileObject.js").PageFile[];
+    _pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfig[];
+    _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobal;
+    _allPageIds: string[];
+    _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
+    _onBeforeRouteHook: import("../../shared/route/executeOnBeforeRouteHook.js").OnBeforeRouteHook | null;
+} & T & import("../../shared/addUrlComputedProps.js").PageContextUrlComputedPropsClient & {
+    _urlRewrite: string | null;
+}>;

package/dist/esm/client/client-routing-runtime/createPageContext.js

@@ -0,0 +1,35 @@
+export { createPageContext };
+import { addUrlComputedProps } from '../../shared/addUrlComputedProps.js';
+import { getPageFilesAll } from '../../shared/getPageFiles.js';
+import { loadPageRoutes } from '../../shared/route/loadPageRoutes.js';
+import { getBaseServer } from './getBaseServer.js';
+import { assert, isBaseServer, objectAssign, getGlobalObject } from './utils.js';
+const globalObject = getGlobalObject('createPageContext.ts', {});
+async function createPageContext(pageContextBase) {
+    if (!globalObject.pageFilesData) {
+        globalObject.pageFilesData = await getPageFilesAll(true);
+    }
+    const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal } = globalObject.pageFilesData;
+    const { pageRoutes, onBeforeRouteHook } = await loadPageRoutes(pageFilesAll, pageConfigs, pageConfigGlobal, allPageIds);
+    const baseServer = getBaseServer();
+    assert(isBaseServer(baseServer));
+    // @ts-ignore Since dist/cjs/client/ is never used, we can ignore this error.
+    const isProd = import.meta.env.PROD;
+    const pageContext = {
+        _objectCreatedByVike: true,
+        _urlHandler: null,
+        _urlRewrite: null,
+        _baseServer: baseServer,
+        _isProduction: isProd,
+        // TODO: use GlobalContext instead
+        _pageFilesAll: pageFilesAll,
+        _pageConfigs: pageConfigs,
+        _pageConfigGlobal: pageConfigGlobal,
+        _allPageIds: allPageIds,
+        _pageRoutes: pageRoutes,
+        _onBeforeRouteHook: onBeforeRouteHook
+    };
+    objectAssign(pageContext, pageContextBase);
+    addUrlComputedProps(pageContext);
+    return pageContext;
+}

package/dist/esm/client/client-routing-runtime/entry.d.ts

@@ -0,0 +1 @@
+import './pageFiles';

package/dist/esm/client/client-routing-runtime/entry.js

@@ -0,0 +1,9 @@
+import { assertClientRouting } from '../../utils/assertRoutingType.js';
+assertClientRouting();
+import './pageFiles';
+import { useClientRouter } from './useClientRouter.js';
+import { onClientEntry_ClientRouting } from './utils.js';
+// @ts-ignore Since dist/cjs/client/ is never used, we can ignore this error.
+const isProd = import.meta.env.PROD;
+onClientEntry_ClientRouting(isProd);
+useClientRouter();

package/dist/esm/client/client-routing-runtime/getBaseServer.d.ts

@@ -0,0 +1 @@
+export declare function getBaseServer(): string;

package/dist/esm/client/client-routing-runtime/getBaseServer.js

@@ -0,0 +1,11 @@
+import { assert } from '../server-routing-runtime/utils.js';
+export function getBaseServer() {
+    // @ts-ignore Since dist/cjs/client/ is never used, we can ignore this error.
+    const baseServer = import.meta.env.BASE_SERVER;
+    assert(isBaseServer(baseServer));
+    return baseServer;
+}
+// We don't use isBaseServer() defined in utils/parseUrl.ts to avoid loading the whole file in the browser
+function isBaseServer(baseServer) {
+    return baseServer.startsWith('/');
+}

package/dist/esm/client/client-routing-runtime/getPageContext/removeBuiltInOverrides.d.ts

@@ -0,0 +1,7 @@
+export { removeBuiltInOverrides };
+declare const BUILT_IN_CLIENT_ROUTER: readonly ["urlPathname", "urlParsed"];
+declare const BUILT_IN_CLIENT: readonly ["Page", "pageExports", "exports"];
+type DeletedKeys = (typeof BUILT_IN_CLIENT)[number] | (typeof BUILT_IN_CLIENT_ROUTER)[number];
+declare function removeBuiltInOverrides(pageContext: Record<string, unknown> & {
+    [key in DeletedKeys]?: never;
+}): void;

package/dist/esm/client/client-routing-runtime/getPageContext/removeBuiltInOverrides.js

@@ -0,0 +1,22 @@
+export { removeBuiltInOverrides };
+import { assert, assertWarning } from '../utils.js';
+const BUILT_IN_CLIENT_ROUTER = ['urlPathname', 'urlParsed'];
+const BUILT_IN_CLIENT = ['Page', 'pageExports', 'exports'];
+function removeBuiltInOverrides(pageContext) {
+    const alreadySet = [...BUILT_IN_CLIENT, ...BUILT_IN_CLIENT_ROUTER];
+    alreadySet.forEach((prop) => {
+        if (prop in pageContext) {
+            // We need to cast `BUILT_IN_CLIENT` to `string[]`
+            //  - https://stackoverflow.com/questions/56565528/typescript-const-assertions-how-to-use-array-prototype-includes
+            //  - https://stackoverflow.com/questions/57646355/check-if-string-is-included-in-readonlyarray-in-typescript
+            if (BUILT_IN_CLIENT_ROUTER.includes(prop)) {
+                assert(prop.startsWith('url'));
+                assertWarning(false, `pageContext.${prop} is already available in the browser when using Client Routing; adding '${prop}' to passToClient has no effect`, { onlyOnce: true });
+            }
+            else {
+                assertWarning(false, `pageContext.${prop} is a built-in that cannot be overriden; adding '${prop}' to passToClient has no effect`, { onlyOnce: true });
+            }
+            delete pageContext[prop];
+        }
+    });
+}

package/dist/esm/client/client-routing-runtime/getPageContext.d.ts

@@ -0,0 +1,29 @@
+export { getPageContext };
+export { getPageContextErrorPage };
+export { checkIf404 };
+export { isAlreadyServerSideRouted };
+import type { PageContextExports, PageFile } from '../../shared/getPageFiles.js';
+import type { PageContextUrlComputedPropsInternal } from '../../shared/addUrlComputedProps.js';
+import { PageContextForRoute } from '../../shared/route/index.js';
+import type { PageConfig } from '../../shared/page-configs/PageConfig.js';
+import type { PageContextForPassToClientWarning } from '../shared/getPageContextProxyForUser.js';
+type PageContextAddendum = {
+    _pageId: string;
+    isHydration: boolean;
+    _pageFilesLoaded: PageFile[];
+} & PageContextExports & PageContextForPassToClientWarning;
+type PageContextPassThrough = PageContextUrlComputedPropsInternal & PageContextForRoute & {
+    isBackwardNavigation: boolean | null;
+};
+declare function getPageContext(pageContext: {
+    _isFirstRenderAttempt: boolean;
+} & PageContextPassThrough): Promise<PageContextAddendum>;
+declare function getPageContextErrorPage(pageContext: {
+    urlOriginal: string;
+    _allPageIds: string[];
+    _isFirstRenderAttempt: boolean;
+    _pageFilesAll: PageFile[];
+    _pageConfigs: PageConfig[];
+} & PageContextPassThrough): Promise<PageContextAddendum>;
+declare function checkIf404(err: unknown): boolean;
+declare function isAlreadyServerSideRouted(err: unknown): boolean;