vike 0.4.247-commit-903de25 → 0.4.247-commit-14351e3

package/dist/shared-server-client/page-configs/serialize/serializeConfigValues.js

@@ -0,0 +1,285 @@
+export { serializeConfigValues };
+export { getConfigValuesBase };
+export { isJsonValue };
+import { assertIsNotProductionRuntime } from '../../../utils/assertSetup.js';
+import { assert, assertIsNotBrowser, assertPosixPath, assertUsage, deepEqual, getPropAccessNotation, isImportPathRelative, } from '../../../node/vite/utils.js';
+import { parsePointerImportData } from '../../../node/vite/shared/resolveVikeConfigInternal/pointerImports.js';
+import { getConfigValueFilePathToShowToUser } from '../helpers.js';
+import { stringify } from '@brillout/json-serializer/stringify';
+import pc from '@brillout/picocolors';
+import { getConfigValueSourcesRelevant, isRuntimeEnvMatch, } from '../../../node/vite/plugins/pluginVirtualFiles/getConfigValueSourcesRelevant.js';
+const stringifyOptions = { forbidReactElements: true };
+const REPLACE_ME_BEFORE = '__VIKE__REPLACE_ME_BEFORE__';
+const REPLACE_ME_AFTER = '__VIKE__REPLACE_ME_AFTER__';
+// This file is never loaded on the client-side but we save it under the vike/shared/ directory in order to collocate it with parsePageConfigsSerialized()
+// - vike/shared/page-configs/serialize/parsePageConfigsSerialized.ts
+// - parsePageConfigsSerialized() is loaded on both the client- and server-side.
+assertIsNotBrowser();
+assertIsNotProductionRuntime();
+function serializeConfigValues(pageConfig, importStatements, filesEnv, runtimeEnv, tabspace, isEager) {
+    const lines = [];
+    tabspace += '  ';
+    getConfigValuesBase(pageConfig, runtimeEnv, isEager).forEach((entry) => {
+        if (entry.configValueBase.type === 'computed') {
+            assert('value' in entry); // Help TS
+            const { configValueBase, value, configName, configEnv } = entry;
+            const valueData = getValueSerializedWithJson(value, configName, configValueBase.definedAtData, importStatements, filesEnv, configEnv);
+            serializeConfigValue(configValueBase, valueData, configName, lines, tabspace);
+        }
+        if (entry.configValueBase.type === 'standard') {
+            assert('sourceRelevant' in entry); // Help TS
+            const { configValueBase, sourceRelevant, configName } = entry;
+            const valueData = getValueSerializedFromSource(sourceRelevant, configName, importStatements, filesEnv);
+            serializeConfigValue(configValueBase, valueData, configName, lines, tabspace);
+        }
+        if (entry.configValueBase.type === 'cumulative') {
+            assert('sourcesRelevant' in entry); // Help TS
+            const { configValueBase, sourcesRelevant, configName } = entry;
+            const valueDataList = [];
+            sourcesRelevant.forEach((source) => {
+                const valueData = getValueSerializedFromSource(source, configName, importStatements, filesEnv);
+                valueDataList.push(valueData);
+            });
+            serializeConfigValue(configValueBase, valueDataList, configName, lines, tabspace);
+        }
+    });
+    return lines;
+}
+function getValueSerializedFromSource(configValueSource, configName, importStatements, filesEnv) {
+    let valueData;
+    if (configValueSource.valueIsLoaded && !configValueSource.valueIsLoadedWithImport) {
+        valueData = getValueSerializedWithJson(configValueSource.value, configName, configValueSource.definedAt, importStatements, filesEnv, configValueSource.configEnv);
+    }
+    else {
+        valueData = getValueSerializedWithImport(configValueSource, importStatements, filesEnv, configName);
+    }
+    return valueData;
+}
+function serializeConfigValue(configValueBase, valueData, configName, lines, tabspace) {
+    lineAdd(`[${JSON.stringify(configName)}]: {`);
+    {
+        tab();
+        lineAdd(`type: "${configValueBase.type}",`);
+        lineAdd(`definedAtData: ${JSON.stringify(configValueBase.definedAtData)},`);
+        lineAdd(`valueSerialized:`);
+        if (!Array.isArray(valueData)) {
+            serializeValueData(valueData);
+        }
+        else {
+            lineAppend(' [');
+            valueData.forEach(serializeValueData);
+            lineAppend(` ],`);
+        }
+        untab();
+    }
+    lineAdd('},');
+    return;
+    function serializeValueData(valueData) {
+        lineAppend(` {`);
+        tab();
+        lineAdd(`type: "${valueData.type}",`);
+        const valueProp = valueData.type !== 'plus-file' ? 'value' : 'exportValues';
+        lineAdd(`${valueProp}: ${valueData.valueAsJsCode},`);
+        untab();
+        lineAdd(`},`);
+    }
+    function lineAppend(str) {
+        const i = lines.length - 1;
+        lines[i] = lines[i] += str;
+    }
+    function lineAdd(str) {
+        lines.push(`${tabspace}${str}`);
+    }
+    function tab() {
+        tabspace += '  ';
+    }
+    function untab() {
+        tabspace = tabspace.slice(2);
+    }
+}
+function getValueSerializedWithImport(configValueSource, importStatements, filesEnv, configName) {
+    assert(!configValueSource.valueIsFilePath);
+    const { valueIsDefinedByPlusValueFile, definedAt, configEnv } = configValueSource;
+    assert(!definedAt.definedBy);
+    const { filePathAbsoluteVite, fileExportName } = definedAt;
+    if (valueIsDefinedByPlusValueFile)
+        assert(fileExportName === undefined);
+    const { importName } = addImportStatement(importStatements, filePathAbsoluteVite, fileExportName || '*', filesEnv, configEnv, configName);
+    return {
+        type: valueIsDefinedByPlusValueFile ? 'plus-file' : 'pointer-import',
+        valueAsJsCode: importName,
+    };
+}
+function getValueSerializedWithJson(value, configName, definedAtData, importStatements, filesEnv, configEnv) {
+    const valueAsJsCode = valueToJson(value, configName, definedAtData, importStatements, filesEnv, configEnv);
+    return {
+        type: 'js-serialized',
+        valueAsJsCode,
+    };
+}
+function valueToJson(value, configName, definedAtData, importStatements, filesEnv, configEnv) {
+    const valueName = `config${getPropAccessNotation(configName)}`;
+    let configValueSerialized;
+    try {
+        configValueSerialized = stringify(value, {
+            valueName,
+            ...stringifyOptions,
+            // Replace import strings with import variables.
+            // - We don't need this anymore and could remove it.
+            //   - We temporarily needed it for nested document configs (`config.document.{title,description,favicon}`), but we finally decided to go for flat document configs instead (`config.{title,description,favicon}`).
+            //   - https://github.com/vikejs/vike-react/pull/113
+            replacer(_, value) {
+                if (typeof value === 'string') {
+                    const importData = parsePointerImportData(value);
+                    if (importData) {
+                        const { importName } = addImportStatement(importStatements, importData.importPath, importData.exportName, filesEnv, configEnv, configName);
+                        const replacement = [REPLACE_ME_BEFORE, importName, REPLACE_ME_AFTER].join('');
+                        return { replacement };
+                    }
+                }
+            },
+        });
+    }
+    catch (err) {
+        logJsonSerializeError(err, configName, definedAtData);
+        assert(false);
+    }
+    configValueSerialized = configValueSerialized.replaceAll(`"${REPLACE_ME_BEFORE}`, '');
+    configValueSerialized = configValueSerialized.replaceAll(`${REPLACE_ME_AFTER}"`, '');
+    assert(!configValueSerialized.includes(REPLACE_ME_BEFORE));
+    assert(!configValueSerialized.includes(REPLACE_ME_AFTER));
+    return configValueSerialized;
+}
+function isJsonValue(value) {
+    try {
+        stringify(value, stringifyOptions);
+    }
+    catch (err) {
+        return false;
+    }
+    return true;
+}
+function logJsonSerializeError(_err, configName, definedAtData) {
+    /*
+    // import { isJsonSerializerError } from '@brillout/json-serializer/stringify'
+    let serializationErrMsg = ''
+    if (isJsonSerializerError(_err)) {
+      serializationErrMsg = _err.messageCore
+    } else {
+      // When a property getter throws an error
+      console.error('Serialization error:')
+      console.error(_err)
+      serializationErrMsg = 'see serialization error printed above'
+    }
+    //*/
+    const configValueFilePathToShowToUser = getConfigValueFilePathToShowToUser(definedAtData);
+    assert(configValueFilePathToShowToUser);
+    assertUsage(false, `${pc.cyan(configName)} defined by ${configValueFilePathToShowToUser} must be defined using a separate file ${pc.bold(`+${configName}.js`)}, see https://vike.dev/error/runtime-in-config`);
+}
+function getConfigValuesBase(pageConfig, runtimeEnv, isEager) {
+    const fromComputed = Object.entries(pageConfig.configValuesComputed ?? {}).map(([configName, valueInfo]) => {
+        const { configEnv, value } = valueInfo;
+        if (!isRuntimeEnvMatch(configEnv, runtimeEnv))
+            return 'SKIP';
+        // AFAICT this should never happen: I ain't aware of a use case for overriding computed values. If there is a use case, then configValueSources has higher precedence.
+        if (pageConfig.configValueSources[configName])
+            return 'SKIP';
+        const configValueBase = {
+            type: 'computed',
+            definedAtData: null,
+        };
+        return { configValueBase, value, configName, configEnv };
+    });
+    const fromSources = Object.entries(pageConfig.configValueSources).map(([configName]) => {
+        const configDef = pageConfig.configDefinitions[configName];
+        assert(configDef);
+        if (isEager !== null && isEager !== !!configDef.eager)
+            return 'SKIP';
+        if (!configDef.cumulative) {
+            const sourcesRelevant = getConfigValueSourcesRelevant(configName, runtimeEnv, pageConfig);
+            const source = sourcesRelevant[0];
+            if (!source)
+                return 'SKIP';
+            assert(sourcesRelevant.length === 1);
+            const definedAtFile = getDefinedAtFileSource(source);
+            const configValueBase = {
+                type: 'standard',
+                definedAtData: definedAtFile,
+            };
+            return { configValueBase, sourceRelevant: source, configName };
+        }
+        else {
+            const sourcesRelevant = getConfigValueSourcesRelevant(configName, runtimeEnv, pageConfig);
+            if (sourcesRelevant.length === 0)
+                return 'SKIP';
+            const definedAtData = [];
+            sourcesRelevant.forEach((source) => {
+                const definedAtFile = getDefinedAtFileSource(source);
+                definedAtData.push(definedAtFile);
+            });
+            const configValueBase = {
+                type: 'cumulative',
+                definedAtData,
+            };
+            return { configValueBase, sourcesRelevant, configName };
+        }
+    });
+    return [...fromComputed, ...fromSources].filter((r) => r !== 'SKIP');
+}
+function getDefinedAtFileSource(source) {
+    const { definedAt } = source;
+    if (definedAt.definedBy)
+        return definedAt;
+    const definedAtFile = {
+        filePathToShowToUser: definedAt.filePathToShowToUser,
+        fileExportPathToShowToUser: definedAt.fileExportPathToShowToUser,
+    };
+    return definedAtFile;
+}
+/*
+ * Naming:
+ *   `import { someExport as someImport } from './some-file'`
+ * <=>
+ *   `{`
+ *      `importPath: './some-file',`
+ *      `exportName: 'someExport',`
+ *      `importName: 'someImport',`
+ *    `}`
+ */
+function addImportStatement(importStatements, importPath, exportName, filesEnv, configEnv, configName) {
+    const importCounter = importStatements.length + 1;
+    const importName = `import${importCounter}`;
+    const importLiteral = (() => {
+        if (exportName === '*') {
+            return `* as ${importName}`;
+        }
+        if (exportName === 'default') {
+            return importName;
+        }
+        return `{ ${exportName} as ${importName} }`;
+    })();
+    const importStatement = `import ${importLiteral} from '${importPath}';`;
+    importStatements.push(importStatement);
+    assertFileEnv(importPath, configEnv, configName, filesEnv);
+    return { importName };
+}
+function assertFileEnv(importPath, configEnv, configName, filesEnv) {
+    assert(!isImportPathRelative(importPath));
+    const key = importPath;
+    assert(key);
+    assertPosixPath(key);
+    if (!filesEnv.has(key)) {
+        filesEnv.set(key, []);
+    }
+    const fileEnvs = filesEnv.get(key);
+    const fileEnvNew = { configEnv, configName };
+    fileEnvs.push(fileEnvNew);
+    const fileEnvDiff = fileEnvs.filter((c) => !deepEqual(c.configEnv, configEnv))[0];
+    if (fileEnvDiff) {
+        assertUsage(false, [
+            `${importPath} defines the value of configs living in different environments:`,
+            ...[fileEnvDiff, fileEnvNew].map((c) => `  - config ${pc.code(c.configName)} which value lives in environment ${pc.code(JSON.stringify(c.configEnv))}`),
+            'Defining config values in the same file is allowed only if they live in the same environment, see https://vike.dev/config#pointer-imports',
+        ].join('\n'));
+    }
+}

package/dist/shared-server-client/prepareGlobalContextForPublicUsage.d.ts

@@ -0,0 +1,11 @@
+export { prepareGlobalContextForPublicUsage };
+export type { GlobalContextPrepareMinimum };
+type GlobalContextPrepareMinimum = {
+    _isOriginalObject: true;
+    isGlobalContext: true;
+};
+declare function prepareGlobalContextForPublicUsage<GlobalContext extends GlobalContextPrepareMinimum>(globalContext: GlobalContext): GlobalContext & {
+    _isProxyObject: true;
+    _originalObject: GlobalContext;
+    dangerouslyUseInternals: GlobalContext;
+};

package/dist/shared-server-client/preparePageContextForPublicUsage.d.ts

@@ -0,0 +1,15 @@
+export { preparePageContextForPublicUsage };
+export { assertPropertyGetters };
+export type { PageContextPrepareMinimum };
+import { type GlobalContextPrepareMinimum } from './prepareGlobalContextForPublicUsage.js';
+type PageContextPrepareMinimum = {
+    _isOriginalObject: true;
+    isPageContext: true;
+    _globalContext: GlobalContextPrepareMinimum;
+};
+declare function preparePageContextForPublicUsage<PageContext extends PageContextPrepareMinimum>(pageContext: PageContext): PageContext & {
+    _isProxyObject: true;
+    _originalObject: PageContext;
+    dangerouslyUseInternals: PageContext;
+};
+declare function assertPropertyGetters(pageContext: Record<string, unknown>): void;

package/dist/shared-server-client/route/abort.d.ts

@@ -0,0 +1,120 @@
+export { redirect };
+export { render };
+export { RenderErrorPage };
+export { isAbortError };
+export { isAbortPageContext };
+export { logAbort };
+export { getPageContextAddendumAbort };
+export { addNewPageContextAborted };
+export { AbortRender };
+export type { RedirectStatusCode };
+export type { AbortStatusCode };
+export type { ErrorAbort };
+export type { PageContextAborted };
+export type { UrlRedirect };
+export type { PageContextAbort };
+type RedirectStatusCode = number & Parameters<typeof redirect>[1];
+type AbortStatusCode = number & Parameters<InferTwoOverloads<typeof render>[0]>[0];
+type UrlRedirect = {
+    url: string;
+    statusCode: RedirectStatusCode;
+};
+type AbortRedirect = Error;
+type AbortReason = Required<({
+    abortReason?: unknown;
+} & Vike.PageContext)['abortReason']>;
+/**
+ * Abort the rendering of the current page, and redirect the user to another URL instead.
+ *
+ * https://vike.dev/redirect
+ *
+ * @param url The URL to redirect to.
+ * @param statusCode By default the temporary redirection status code (`302`) is sent. For permanent redirections (`301`), use `+redirects` (https://vike.dev/redirects) or set this `statusCode` argument to `301`.
+ */
+declare function redirect(url: string, statusCode?: 301 | 302): AbortRedirect;
+/**
+ * Abort the rendering of the current page, and render the error page instead.
+ *
+ * https://vike.dev/render
+ *
+ *
+ * **Recommended** status codes:
+ *   `401` — Unauthorized (user isn't logged in)
+ *   `403` — Forbidden (user is logged in but isn't allowed)
+ *   `404` — Not Found
+ *   `410` — Gone (use this instead of `404` if the page existed in the past, see https://github.com/vikejs/vike/issues/1097#issuecomment-1695260887)
+ *   `429` — Too Many Requests (rate limiting)
+ *   `500` — Internal Server Error (your client or server has a bug)
+ *   `503` — Service Unavailable (server is overloaded, or a third-party API isn't responding)
+ *
+ * **Not recommended** status codes:
+ *   `400` — See https://github.com/vikejs/vike/issues/1008#issuecomment-3270894445
+ *   Other status codes — See https://github.com/vikejs/vike/issues/1008
+ *
+ * @param abortStatusCode - One of the recommended status codes listed above.
+ *
+ * @param abortReason - Sets `pageContext.abortReason` which is usually used by the error page to show a message to the user, see https://vike.dev/error-page
+ */
+declare function render(abortStatusCode: 401 | 403 | 404 | 410 | 429 | 500 | 503, abortReason?: AbortReason): Error;
+/**
+ * Abort the rendering of the current page, and render another page instead.
+ *
+ * https://vike.dev/render
+ *
+ * @param url The URL to render.
+ * @param abortReason Sets `pageContext.abortReason` which is used by the error page to show a message to the user, see https://vike.dev/error-page
+ */
+declare function render(url: `/${string}`, abortReason?: AbortReason): Error;
+type AbortCall = `redirect(${string})` | `render(${string})` | `RenderErrorPage()`;
+type AbortCaller = `throw redirect()` | `throw render()` | `throw RenderErrorPage()`;
+type PageContextAbort = {
+    _abortCall: AbortCall;
+    _abortCaller: AbortCaller;
+} & (({
+    _abortCall: `redirect(${string})`;
+    _abortCaller: 'throw redirect()';
+    _urlRedirect: UrlRedirect;
+} & Omit<AbortUndefined, '_urlRedirect'>) | ({
+    _abortCall: `render(${string})` | `RenderErrorPage()`;
+    _abortCaller: 'throw render()' | 'throw RenderErrorPage()';
+    abortReason: undefined | unknown;
+    _urlRewrite: string;
+} & Omit<AbortUndefined, '_urlRewrite'>) | ({
+    _abortCall: `render(${string})` | `RenderErrorPage()`;
+    _abortCaller: 'throw render()' | 'throw RenderErrorPage()';
+    abortReason: undefined | unknown;
+    abortStatusCode: AbortStatusCode;
+} & Omit<AbortUndefined, 'abortStatusCode'>));
+type AbortUndefined = {
+    _urlRedirect?: undefined;
+    _urlRewrite?: undefined;
+    abortStatusCode?: undefined;
+};
+declare function AbortRender(pageContextAbort: PageContextAbort): Error;
+/**
+ * @deprecated Use `throw render()` or `throw redirect()` instead, see https://vike.dev/render'
+ */
+declare function RenderErrorPage({ pageContext }?: {
+    pageContext?: Record<string, unknown>;
+}): Error;
+type ErrorAbort = {
+    _pageContextAbort: PageContextAbort;
+};
+declare function isAbortError(thing: unknown): thing is ErrorAbort;
+declare function isAbortPageContext(pageContext: Record<string, unknown>): pageContext is PageContextAbort;
+declare function logAbort(err: ErrorAbort, isProduction: boolean, pageContext: {
+    urlOriginal: string;
+    _urlRewrite?: string;
+}): void;
+type PageContextMin = {
+    urlOriginal: string;
+};
+type PageContextAborted = {
+    _pageContextAbort: PageContextAbort;
+} & PageContextMin;
+declare function getPageContextAddendumAbort(pageContextsAborted: PageContextAborted[]): PageContextAbort | null;
+declare function addNewPageContextAborted(pageContextsAborted: PageContextAborted[], pageContext: PageContextMin, pageContextAbort: PageContextAbort): void;
+type InferTwoOverloads<F extends Function> = F extends {
+    (...a1: infer A1): infer R1;
+    (...a0: infer A0): infer R0;
+} ? [(...a1: A1) => R1, (...a0: A0) => R0] : never;

package/dist/shared-server-client/route/abort.js

@@ -0,0 +1,207 @@
+export { redirect };
+export { render };
+export { RenderErrorPage };
+export { isAbortError };
+export { isAbortPageContext };
+export { logAbort };
+export { getPageContextAddendumAbort };
+export { addNewPageContextAborted };
+export { AbortRender };
+import { isUserHookError } from '../hooks/execHook.js';
+import { assert, assertInfo, assertUsage, assertUsageUrlPathAbsolute, assertUsageUrlRedirectTarget, assertWarning, checkType, hasProp, isBrowser, joinEnglish, objectAssign, truncateString, unique, } from './utils.js';
+import pc from '@brillout/picocolors';
+/**
+ * Abort the rendering of the current page, and redirect the user to another URL instead.
+ *
+ * https://vike.dev/redirect
+ *
+ * @param url The URL to redirect to.
+ * @param statusCode By default the temporary redirection status code (`302`) is sent. For permanent redirections (`301`), use `+redirects` (https://vike.dev/redirects) or set this `statusCode` argument to `301`.
+ */
+function redirect(url, statusCode) {
+    const abortCaller = 'throw redirect()';
+    assertUsageUrlRedirectTarget(url, getErrPrefix(abortCaller));
+    const args = [JSON.stringify(url)];
+    if (!statusCode) {
+        statusCode = 302;
+    }
+    else {
+        if (
+        // Tree-shaking to save client-side KBs
+        !globalThis.__VIKE__IS_CLIENT ||
+            globalThis.__VIKE__IS_DEV ||
+            globalThis.__VIKE__IS_DEBUG) {
+            assertStatusCode(statusCode, [301, 302], 'redirect');
+        }
+        args.push(String(statusCode));
+    }
+    const pageContextAbort = {};
+    objectAssign(pageContextAbort, {
+        _abortCaller: abortCaller,
+        _abortCall: `redirect(${args.join(', ')})`,
+        _urlRedirect: {
+            url,
+            statusCode,
+        },
+    });
+    return AbortRender(pageContextAbort);
+}
+function render(urlOrStatusCode, abortReason) {
+    const args = [typeof urlOrStatusCode === 'number' ? String(urlOrStatusCode) : JSON.stringify(urlOrStatusCode)];
+    if (abortReason !== undefined)
+        args.push(truncateString(JSON.stringify(abortReason), 30));
+    const abortCaller = 'throw render()';
+    const abortCall = `render(${args.join(', ')})`;
+    return render_(urlOrStatusCode, abortReason, abortCall, abortCaller);
+}
+function render_(urlOrStatusCode, abortReason, abortCall, abortCaller, pageContextAddendum) {
+    const pageContextAbort = {
+        abortReason,
+        _abortCaller: abortCaller,
+        _abortCall: abortCall,
+    };
+    if (pageContextAddendum) {
+        assert(pageContextAddendum._isLegacyRenderErrorPage === true);
+        objectAssign(pageContextAbort, pageContextAddendum);
+    }
+    if (typeof urlOrStatusCode === 'string') {
+        const url = urlOrStatusCode;
+        assertUsageUrlPathAbsolute(url, getErrPrefix(abortCaller));
+        objectAssign(pageContextAbort, {
+            _urlRewrite: url,
+        });
+        return AbortRender(pageContextAbort);
+    }
+    else {
+        if (
+        // Tree-shaking to save client-side KBs
+        !globalThis.__VIKE__IS_CLIENT ||
+            globalThis.__VIKE__IS_DEV ||
+            globalThis.__VIKE__IS_DEBUG) {
+            assertStatusCode(urlOrStatusCode, [401, 403, 404, 410, 429, 500, 503], 'render');
+        }
+        const abortStatusCode = urlOrStatusCode;
+        objectAssign(pageContextAbort, {
+            abortStatusCode,
+            is404: abortStatusCode === 404,
+        });
+        return AbortRender(pageContextAbort);
+    }
+}
+function AbortRender(pageContextAbort) {
+    const err = new Error('AbortRender');
+    objectAssign(err, { _pageContextAbort: pageContextAbort, [stamp]: true });
+    checkType(err);
+    return err;
+}
+// TO-DO/next-major-release: remove
+/**
+ * @deprecated Use `throw render()` or `throw redirect()` instead, see https://vike.dev/render'
+ */
+function RenderErrorPage({ pageContext = {} } = {}) {
+    assertWarning(false, `${pc.cyan('throw RenderErrorPage()')} is deprecated and will be removed in the next major release. Use ${pc.cyan('throw render()')} or ${pc.cyan('throw redirect()')} instead, see https://vike.dev/render`, { onlyOnce: false });
+    let abortStatusCode = 404;
+    let abortReason = 'Page Not Found';
+    if (pageContext.is404 === false || pageContext.pageProps?.is404 === false) {
+        abortStatusCode = 500;
+        abortReason = 'Something went wrong';
+    }
+    objectAssign(pageContext, { _isLegacyRenderErrorPage: true });
+    return render_(abortStatusCode, abortReason, 'RenderErrorPage()', 'throw RenderErrorPage()', pageContext);
+}
+const stamp = '_isAbortError';
+function isAbortError(thing) {
+    return typeof thing === 'object' && thing !== null && stamp in thing;
+}
+function isAbortPageContext(pageContext) {
+    if (!(pageContext._urlRewrite || pageContext._urlRedirect || pageContext.abortStatusCode)) {
+        return false;
+    }
+    assert(hasProp(pageContext, '_abortCall', 'string'));
+    /* Isn't needed and is missing on the client-side
+    assert(hasProp(pageContext, '_abortCaller', 'string'))
+    */
+    checkType(pageContext);
+    return true;
+}
+function logAbort(err, isProduction, pageContext) {
+    if (isProduction)
+        return;
+    const urlCurrent = pageContext._urlRewrite ?? pageContext.urlOriginal;
+    assert(urlCurrent);
+    const abortCall = err._pageContextAbort._abortCall;
+    assert(abortCall);
+    const hookLoc = isUserHookError(err);
+    let thrownBy = '';
+    if (hookLoc) {
+        thrownBy = ` by ${pc.cyan(`${hookLoc.hookName}()`)} hook defined at ${hookLoc.hookFilePath}`;
+    }
+    else {
+        // hookLoc is missing when serializing abort errors from server to client
+    }
+    assertInfo(false, `${pc.cyan(abortCall)} thrown${thrownBy} while rendering ${pc.cyan(urlCurrent)}`, {
+        onlyOnce: false,
+    });
+}
+function assertStatusCode(statusCode, expected, caller) {
+    assert(!globalThis.__VIKE__IS_CLIENT || globalThis.__VIKE__IS_DEV || globalThis.__VIKE__IS_DEBUG); // assert tree-shaking
+    // double check vike:pluginReplaceConstantsGlobalThis
+    if (globalThis.__VIKE__IS_CLIENT) {
+        assert(isBrowser());
+        assert(typeof globalThis.__VIKE__IS_DEV === 'boolean');
+        assert(typeof globalThis.__VIKE__IS_CLIENT === 'boolean');
+        assert(import.meta.env.SSR === false);
+        assert(import.meta.env.DEV === globalThis.__VIKE__IS_DEV);
+    }
+    else {
+        assert(!isBrowser());
+        if (import.meta.env) {
+            assert(typeof globalThis.__VIKE__IS_DEV === 'boolean');
+            assert(typeof globalThis.__VIKE__IS_CLIENT === 'boolean');
+            assert(import.meta.env.SSR === true);
+            assert(import.meta.env.DEV === globalThis.__VIKE__IS_DEV);
+        }
+        else {
+            // import.meta.env isn't defined when 'vike' is ssr.external
+        }
+    }
+    const expectedEnglish = joinEnglish(expected.map((s) => pc.bold(String(s))), 'or');
+    const statusCodeWithColor = pc.bold(String(statusCode));
+    if (statusCode === 400) {
+        assert(!expected.includes(statusCode));
+        assertWarning(false, `We recommend against using the status code ${statusCodeWithColor} passed to ${caller}() — we recommend using ${pc.bold('404')} instead, see https://github.com/vikejs/vike/issues/1008#issuecomment-3270894445`, { onlyOnce: true, showStackTrace: true });
+    }
+    else {
+        assertWarning(expected.includes(statusCode), `Unexpected status code ${statusCodeWithColor} passed to ${caller}() — we recommend using ${expectedEnglish} instead. (Or reach out at https://github.com/vikejs/vike/issues/1008 if you believe ${statusCodeWithColor} should be added.)`, { onlyOnce: true, showStackTrace: true });
+    }
+}
+function getPageContextAddendumAbort(pageContextsAborted) {
+    const pageContextAbortedLast = pageContextsAborted.at(-1);
+    if (!pageContextAbortedLast)
+        return null;
+    const pageContextAbort = pageContextAbortedLast._pageContextAbort;
+    assert(pageContextAbort);
+    // Sets pageContext._urlRewrite from pageContextAbort._urlRewrite
+    return pageContextAbort;
+}
+function addNewPageContextAborted(pageContextsAborted, pageContext, pageContextAbort) {
+    objectAssign(pageContext, { _pageContextAbort: pageContextAbort });
+    pageContextsAborted.push(pageContext);
+    assertNoInfiniteAbortLoop(pageContextsAborted);
+}
+// There doesn't seem to be a way to count the number of HTTP redirects (Vike doesn't have access to the HTTP request headers/cookies)
+// https://stackoverflow.com/questions/9683007/detect-infinite-http-redirect-loop-on-server-side
+function assertNoInfiniteAbortLoop(pageContextsAborted) {
+    if (pageContextsAborted.length < 10)
+        return;
+    const loop = pageContextsAborted.map((pageContext) => {
+        return pageContext._pageContextAbort._abortCall;
+    });
+    // Unique array => no redundant call => no infinite loop
+    if (unique(loop).length === loop.length)
+        return;
+    assertUsage(false, `Infinite loop: ${loop.join(' => ')}`);
+}
+function getErrPrefix(abortCaller) {
+    return `URL passed to ${pc.code(abortCaller)}`;
+}

package/dist/shared-server-node/api-context.d.ts

@@ -0,0 +1,13 @@
+export { isVikeCliOrApi };
+export { setContextVikeApiOperation };
+export { clearContextVikeApiOperation };
+export { getVikeApiOperation };
+import type { ApiOptions, ApiOperation } from '../node/api/types.js';
+type VikeApiOperation = {
+    operation: ApiOperation;
+    options: ApiOptions;
+};
+declare function getVikeApiOperation(): VikeApiOperation | null;
+declare function isVikeCliOrApi(): boolean;
+declare function setContextVikeApiOperation(operation: ApiOperation, options: ApiOptions): void;
+declare function clearContextVikeApiOperation(): void;

package/dist/shared-server-node/api-context.js

@@ -0,0 +1,21 @@
+export { isVikeCliOrApi };
+export { setContextVikeApiOperation };
+export { clearContextVikeApiOperation };
+export { getVikeApiOperation };
+// We don't import ./utils.js because this file is imported by server/
+import { assert, getGlobalObject } from '../server/utils.js';
+const globalObject = getGlobalObject('api/context.ts', {});
+function getVikeApiOperation() {
+    return globalObject.vikeApiOperation ?? null;
+}
+function isVikeCliOrApi() {
+    // The CLI uses the API
+    return !!globalObject.vikeApiOperation;
+}
+function setContextVikeApiOperation(operation, options) {
+    assert(!globalObject.vikeApiOperation);
+    globalObject.vikeApiOperation = { operation, options };
+}
+function clearContextVikeApiOperation() {
+    globalObject.vikeApiOperation = undefined;
+}