vike 0.4.239 → 0.4.240-commit-a80417c

package/dist/cjs/shared/page-configs/serialize/serializeConfigValues.js

@@ -1,290 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.serializeConfigValues = serializeConfigValues;
-exports.getConfigValuesBase = getConfigValuesBase;
-exports.isJsonValue = isJsonValue;
-const assertSetup_js_1 = require("../../../utils/assertSetup.js");
-const utils_js_1 = require("../../../node/vite/utils.js");
-const pointerImports_js_1 = require("../../../node/vite/shared/resolveVikeConfigInternal/pointerImports.js");
-const helpers_js_1 = require("../helpers.js");
-const stringify_1 = require("@brillout/json-serializer/stringify");
-const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-const getConfigValueSourcesRelevant_js_1 = require("../../../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.
-(0, utils_js_1.assertIsNotBrowser)();
-(0, assertSetup_js_1.assertIsNotProductionRuntime)();
-function serializeConfigValues(pageConfig, importStatements, filesEnv, runtimeEnv, tabspace, isEager) {
-    const lines = [];
-    tabspace += '  ';
-    getConfigValuesBase(pageConfig, runtimeEnv, isEager).forEach((entry) => {
-        if (entry.configValueBase.type === 'computed') {
-            (0, utils_js_1.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') {
-            (0, utils_js_1.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') {
-            (0, utils_js_1.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) {
-    (0, utils_js_1.assert)(!configValueSource.valueIsFilePath);
-    const { valueIsDefinedByPlusValueFile, definedAt, configEnv } = configValueSource;
-    (0, utils_js_1.assert)(!definedAt.definedBy);
-    const { filePathAbsoluteVite, fileExportName } = definedAt;
-    if (valueIsDefinedByPlusValueFile)
-        (0, utils_js_1.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${(0, utils_js_1.getPropAccessNotation)(configName)}`;
-    let configValueSerialized;
-    try {
-        configValueSerialized = (0, stringify_1.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 = (0, pointerImports_js_1.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);
-        (0, utils_js_1.assert)(false);
-    }
-    configValueSerialized = configValueSerialized.replaceAll(`"${REPLACE_ME_BEFORE}`, '');
-    configValueSerialized = configValueSerialized.replaceAll(`${REPLACE_ME_AFTER}"`, '');
-    (0, utils_js_1.assert)(!configValueSerialized.includes(REPLACE_ME_BEFORE));
-    (0, utils_js_1.assert)(!configValueSerialized.includes(REPLACE_ME_AFTER));
-    return configValueSerialized;
-}
-function isJsonValue(value) {
-    try {
-        (0, stringify_1.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 = (0, helpers_js_1.getConfigValueFilePathToShowToUser)(definedAtData);
-    (0, utils_js_1.assert)(configValueFilePathToShowToUser);
-    (0, utils_js_1.assertUsage)(false, `${picocolors_1.default.cyan(configName)} defined by ${configValueFilePathToShowToUser} must be defined using a separate file ${picocolors_1.default.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 (!(0, getConfigValueSourcesRelevant_js_1.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];
-        (0, utils_js_1.assert)(configDef);
-        if (isEager !== null && isEager !== !!configDef.eager)
-            return 'SKIP';
-        if (!configDef.cumulative) {
-            const sourcesRelevant = (0, getConfigValueSourcesRelevant_js_1.getConfigValueSourcesRelevant)(configName, runtimeEnv, pageConfig);
-            const source = sourcesRelevant[0];
-            if (!source)
-                return 'SKIP';
-            (0, utils_js_1.assert)(sourcesRelevant.length === 1);
-            const definedAtFile = getDefinedAtFileSource(source);
-            const configValueBase = {
-                type: 'standard',
-                definedAtData: definedAtFile,
-            };
-            return { configValueBase, sourceRelevant: source, configName };
-        }
-        else {
-            const sourcesRelevant = (0, getConfigValueSourcesRelevant_js_1.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) {
-    (0, utils_js_1.assert)(!(0, utils_js_1.isImportPathRelative)(importPath));
-    const key = importPath;
-    (0, utils_js_1.assert)(key);
-    (0, utils_js_1.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) => !(0, utils_js_1.deepEqual)(c.configEnv, configEnv))[0];
-    if (fileEnvDiff) {
-        (0, utils_js_1.assertUsage)(false, [
-            `${importPath} defines the value of configs living in different environments:`,
-            ...[fileEnvDiff, fileEnvNew].map((c) => `  - config ${picocolors_1.default.code(c.configName)} which value lives in environment ${picocolors_1.default.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/cjs/shared/prepareGlobalContextForPublicUsage.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.prepareGlobalContextForPublicUsage = prepareGlobalContextForPublicUsage;
-const getProxyForPublicUsage_js_1 = require("./getProxyForPublicUsage.js");
-const utils_js_1 = require("./utils.js");
-function prepareGlobalContextForPublicUsage(globalContext) {
-    (0, utils_js_1.assert)(globalContext._isOriginalObject); // ensure we preserve the original object reference
-    const globalContextPublic = (0, getProxyForPublicUsage_js_1.getProxyForPublicUsage)(globalContext, 'globalContext');
-    return globalContextPublic;
-}

package/dist/cjs/shared/preparePageContextForPublicUsage.js

@@ -1,80 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.preparePageContextForPublicUsage = preparePageContextForPublicUsage;
-exports.assertPropertyGetters = assertPropertyGetters;
-const utils_js_1 = require("./utils.js");
-const addIs404ToPageProps_js_1 = require("./addIs404ToPageProps.js");
-const prepareGlobalContextForPublicUsage_js_1 = require("./prepareGlobalContextForPublicUsage.js");
-const getProxyForPublicUsage_js_1 = require("./getProxyForPublicUsage.js");
-function preparePageContextForPublicUsage(pageContext) {
-    (0, utils_js_1.assert)(!pageContext._isProxyObject);
-    (0, utils_js_1.assert)(!pageContext.globalContext); // pageContext.globalContext should only be available to users — Vike itself should use pageContext._globalContext instead
-    (0, utils_js_1.assert)(pageContext._isOriginalObject); // ensure we preserve the original object reference
-    (0, addIs404ToPageProps_js_1.addIs404ToPageProps)(pageContext);
-    // TO-DO/next-major-release: remove
-    if (!('_pageId' in pageContext)) {
-        Object.defineProperty(pageContext, '_pageId', {
-            get() {
-                (0, utils_js_1.assertWarning)(false, 'pageContext._pageId has been renamed to pageContext.pageId', {
-                    showStackTrace: true,
-                    onlyOnce: true,
-                });
-                return pageContext.pageId;
-            },
-            enumerable: false,
-        });
-    }
-    // For a more readable `console.log(pageContext)` output
-    sortPageContext(pageContext);
-    const globalContextPublic = (0, prepareGlobalContextForPublicUsage_js_1.prepareGlobalContextForPublicUsage)(pageContext._globalContext);
-    const pageContextPublic = (0, getProxyForPublicUsage_js_1.getProxyForPublicUsage)(pageContext, 'pageContext', 
-    // We must skip it in the client-side because of the reactivity mechanism of UI frameworks like Solid.
-    // - TO-DO/soon/proxy: double check whether that's true
-    true, (prop) => {
-        if (prop === 'globalContext') {
-            return globalContextPublic;
-        }
-        if (prop in globalContextPublic) {
-            return globalContextPublic[prop];
-        }
-    });
-    return pageContextPublic;
-}
-// Sort `pageContext` keys alphabetically, in order to make reading the `console.log(pageContext)` output easier
-function sortPageContext(pageContext) {
-    let descriptors = Object.getOwnPropertyDescriptors(pageContext);
-    for (const key of Object.keys(pageContext))
-        delete pageContext[key];
-    descriptors = Object.fromEntries(Object.entries(descriptors).sort(([key1], [key2]) => (0, utils_js_1.compareString)(key1, key2)));
-    Object.defineProperties(pageContext, descriptors);
-}
-function assertPropertyGetters(pageContext) {
-    /*
-    If the isPropertyGetter() assertions fail then it's most likely because Object.assign() was used instead of `objectAssign()`:
-    ```js
-    const PageContextUrlComputed = getPageContextUrlComputed(pageContext)
-  
-    // ❌ Breaks the property descriptors/getters of pageContext defined by getPageContextUrlComputed() such as pageContext.urlPathname
-    Object.assign(pageContext, pageContextUrlComputed)
-  
-    // ❌ Also breaks property descriptors/getters
-    const pageContext = { ...pageContextUrlComputed }
-  
-    // ✅ Preserves property descriptors/getters (see objectAssign() implementation)
-    objectAssign(pageContext, pageContextUrlComputed)
-    ```
-    */
-    ;
-    [
-        'urlPathname',
-        // TO-DO/next-major-release: remove
-        'urlParsed',
-        // TO-DO/next-major-release: remove
-        'url',
-        // TO-DO/next-major-release: remove
-        'pageExports',
-    ].forEach((prop) => {
-        if (pageContext.prop)
-            (0, utils_js_1.assert)((0, utils_js_1.isPropertyGetter)(pageContext, prop));
-    });
-}

package/dist/cjs/shared/route/abort.js

@@ -1,178 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.redirect = redirect;
-exports.render = render;
-exports.RenderErrorPage = RenderErrorPage;
-exports.isAbortError = isAbortError;
-exports.isAbortPageContext = isAbortPageContext;
-exports.logAbortErrorHandled = logAbortErrorHandled;
-exports.getPageContextFromAllRewrites = getPageContextFromAllRewrites;
-exports.AbortRender = AbortRender;
-exports.assertNoInfiniteAbortLoop = assertNoInfiniteAbortLoop;
-const execHook_js_1 = require("../hooks/execHook.js");
-const utils_js_1 = require("./utils.js");
-const picocolors_1 = __importDefault(require("@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 a temporary redirection (`302`) is performed. For permanent redirections (`301`), use `config.redirects` https://vike.dev/redirects instead or, alternatively, set the `statusCode` argument to `301`.
- */
-function redirect(url, statusCode) {
-    const abortCaller = 'throw redirect()';
-    (0, utils_js_1.assertUsageUrlRedirectTarget)(url, getErrPrefix(abortCaller));
-    const args = [JSON.stringify(url)];
-    if (!statusCode) {
-        statusCode = 302;
-    }
-    else {
-        assertStatusCode(statusCode, [301, 302], 'redirect');
-        args.push(String(statusCode));
-    }
-    const pageContextAbort = {};
-    (0, utils_js_1.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((0, utils_js_1.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) {
-        (0, utils_js_1.assert)(pageContextAddendum._isLegacyRenderErrorPage === true);
-        (0, utils_js_1.objectAssign)(pageContextAbort, pageContextAddendum);
-    }
-    if (typeof urlOrStatusCode === 'string') {
-        const url = urlOrStatusCode;
-        (0, utils_js_1.assertUsageUrlPathnameAbsolute)(url, getErrPrefix(abortCaller));
-        (0, utils_js_1.objectAssign)(pageContextAbort, {
-            _urlRewrite: url,
-        });
-        return AbortRender(pageContextAbort);
-    }
-    else {
-        const abortStatusCode = urlOrStatusCode;
-        assertStatusCode(urlOrStatusCode, [401, 403, 404, 410, 429, 500, 503], 'render');
-        (0, utils_js_1.objectAssign)(pageContextAbort, {
-            abortStatusCode,
-            is404: abortStatusCode === 404,
-        });
-        return AbortRender(pageContextAbort);
-    }
-}
-function AbortRender(pageContextAbort) {
-    const err = new Error('AbortRender');
-    (0, utils_js_1.objectAssign)(err, { _pageContextAbort: pageContextAbort, [stamp]: true });
-    (0, utils_js_1.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 = {} } = {}) {
-    (0, utils_js_1.assertWarning)(false, `${picocolors_1.default.cyan('throw RenderErrorPage()')} is deprecated and will be removed in the next major release. Use ${picocolors_1.default.cyan('throw render()')} or ${picocolors_1.default.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';
-    }
-    (0, utils_js_1.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;
-    }
-    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContext, '_abortCall', 'string'));
-    /* Isn't needed and is missing on the client-side
-    assert(hasProp(pageContext, '_abortCaller', 'string'))
-    */
-    (0, utils_js_1.checkType)(pageContext);
-    return true;
-}
-function logAbortErrorHandled(err, isProduction, pageContext) {
-    if (isProduction)
-        return;
-    const urlCurrent = pageContext._urlRewrite ?? pageContext.urlOriginal;
-    (0, utils_js_1.assert)(urlCurrent);
-    const abortCall = err._pageContextAbort._abortCall;
-    (0, utils_js_1.assert)(abortCall);
-    const hookLoc = (0, execHook_js_1.isUserHookError)(err);
-    let thrownBy = '';
-    if (hookLoc) {
-        thrownBy = ` by ${picocolors_1.default.cyan(`${hookLoc.hookName}()`)} hook defined at ${hookLoc.hookFilePath}`;
-    }
-    else {
-        // hookLoc is missing when serializing abort errors from server to client
-    }
-    (0, utils_js_1.assertInfo)(false, `${picocolors_1.default.cyan(abortCall)} thrown${thrownBy} while rendering ${picocolors_1.default.cyan(urlCurrent)}`, {
-        onlyOnce: false,
-    });
-}
-function assertStatusCode(statusCode, expected, caller) {
-    const expectedEnglish = (0, utils_js_1.joinEnglish)(expected.map((s) => s.toString()), 'or');
-    (0, utils_js_1.assertWarning)(expected.includes(statusCode), `Unepexected status code ${statusCode} passed to ${caller}(), we recommend ${expectedEnglish} instead. (Or reach out at https://github.com/vikejs/vike/issues/1008 if you believe ${statusCode} should be added.)`, { onlyOnce: true });
-}
-function getPageContextFromAllRewrites(pageContextsFromRewrite) {
-    assertNoInfiniteLoop(pageContextsFromRewrite);
-    const pageContextFromAllRewrites = { _urlRewrite: null };
-    pageContextsFromRewrite.forEach((pageContextFromRewrite) => {
-        Object.assign(pageContextFromAllRewrites, pageContextFromRewrite);
-    });
-    return pageContextFromAllRewrites;
-}
-function assertNoInfiniteLoop(pageContextsFromRewrite) {
-    const urlRewrites = [];
-    pageContextsFromRewrite.forEach((pageContext) => {
-        const urlRewrite = pageContext._urlRewrite;
-        {
-            const idx = urlRewrites.indexOf(urlRewrite);
-            if (idx !== -1) {
-                const loop = [...urlRewrites.slice(idx), urlRewrite].map((url) => `render('${url}')`).join(' => ');
-                (0, utils_js_1.assertUsage)(false, `Infinite loop of render() calls: ${loop}`);
-            }
-        }
-        urlRewrites.push(urlRewrite);
-    });
-}
-function assertNoInfiniteAbortLoop(rewriteCount, redirectCount) {
-    const abortCalls = [
-        // prettier-ignore
-        // biome-ignore format:
-        rewriteCount > 0 && picocolors_1.default.cyan("throw render('/some-url')"),
-        redirectCount > 0 && picocolors_1.default.cyan("throw redirect('/some-url')"),
-    ]
-        .filter(Boolean)
-        .join(' and ');
-    (0, utils_js_1.assertUsage)(rewriteCount + redirectCount <= 7, `Maximum chain length of 7 ${abortCalls} exceeded. Did you define an infinite loop of ${abortCalls}?`);
-}
-function getErrPrefix(abortCaller) {
-    return `URL passed to ${picocolors_1.default.code(abortCaller)}`;
-}

package/dist/cjs/shared/route/debug.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.debug = debug;
-exports.setCreateDebugger = setCreateDebugger;
-// Using createDebugger() for isomorphic code without bloating the client-side.
-// On the server-side, this is just a transparent proxy.
-// On the client-side, this is an empty shell.
-const getGlobalObject_js_1 = require("../../utils/getGlobalObject.js");
-const globalObject = (0, getGlobalObject_js_1.getGlobalObject)('route/debug.ts', {});
-function debug(...args) {
-    // Client-side => does nothing
-    if (!globalObject.createDebugger)
-        return;
-    // Server-side => just a proxy
-    if (!globalObject.debug) {
-        globalObject.debug = globalObject.createDebugger('vike:routing');
-    }
-    globalObject.debug(...args);
-}
-// Called only on the server-side
-function setCreateDebugger(createDebugger) {
-    globalObject.createDebugger = createDebugger;
-}

package/dist/cjs/shared/route/deduceRouteStringFromFilesystemPath.js

@@ -1,52 +0,0 @@
-"use strict";
-// Unit tests at ./deduceRouteStringFromFilesystemPath.spec.ts
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.deduceRouteStringFromFilesystemPath = deduceRouteStringFromFilesystemPath;
-const utils_js_1 = require("./utils.js");
-// TO-DO/next-major-release: remove this and whole filesystemRoot mechanism
-function deduceRouteStringFromFilesystemPath(pageId, filesystemRoots) {
-    // Handle Filesystem Routing Root
-    const filesystemRootsMatch = filesystemRoots
-        .filter(({ filesystemRoot }) => pageId.startsWith(filesystemRoot))
-        .sort((0, utils_js_1.higherFirst)(({ filesystemRoot }) => filesystemRoot.length));
-    const fsBase = filesystemRootsMatch[0];
-    let filesystemRoute;
-    if (fsBase) {
-        // Example values:
-        //  - `{"pageId":"/pages/index","filesystemRoot":"/","urlRoot":"/client_portal"}`
-        const { filesystemRoot, urlRoot } = fsBase;
-        const debugInfo = { pageId, filesystemRoot, urlRoot };
-        (0, utils_js_1.assert)(urlRoot.startsWith('/') && pageId.startsWith('/') && filesystemRoot.startsWith('/'), debugInfo);
-        (0, utils_js_1.assert)(pageId.startsWith(filesystemRoot), debugInfo);
-        if (filesystemRoot !== '/') {
-            (0, utils_js_1.assert)(!filesystemRoot.endsWith('/'), debugInfo);
-            filesystemRoute = (0, utils_js_1.slice)(pageId, filesystemRoot.length, 0);
-        }
-        else {
-            filesystemRoute = pageId;
-        }
-        (0, utils_js_1.assert)(filesystemRoute.startsWith('/'), debugInfo);
-        filesystemRoute = urlRoot + (urlRoot.endsWith('/') ? '' : '/') + (0, utils_js_1.slice)(filesystemRoute, 1, 0);
-    }
-    else {
-        filesystemRoute = pageId;
-    }
-    (0, utils_js_1.assert)(filesystemRoute.startsWith('/'));
-    // Remove `pages/`, `index/, and `src/`, directories
-    filesystemRoute = filesystemRoute
-        .split('/')
-        .filter((dir) => dir !== 'pages' && dir !== 'src' && dir !== 'index')
-        .join('/');
-    // Handle `/index.page.*` suffix
-    (0, utils_js_1.assert)(!filesystemRoute.includes('.page.'));
-    (0, utils_js_1.assert)(!filesystemRoute.endsWith('.'));
-    if (filesystemRoute.endsWith('/index')) {
-        filesystemRoute = (0, utils_js_1.slice)(filesystemRoute, 0, -'/index'.length);
-    }
-    if (filesystemRoute === '') {
-        filesystemRoute = '/';
-    }
-    (0, utils_js_1.assert)(filesystemRoute.startsWith('/'));
-    (0, utils_js_1.assert)(!filesystemRoute.endsWith('/') || filesystemRoute === '/');
-    return filesystemRoute;
-}

package/dist/cjs/shared/route/execHookGuard.js

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.execHookGuard = execHookGuard;
-const getHook_js_1 = require("../hooks/getHook.js");
-const utils_js_1 = require("./utils.js");
-const execHook_js_1 = require("../hooks/execHook.js");
-const errIntro = 'The guard() hook defined by';
-async function execHookGuard(pageContext, prepareForPublicUsage) {
-    let hook;
-    if (pageContext._globalContext._pageFilesAll.length > 0) {
-        // TO-DO/next-major-release: remove
-        // V0.4 design
-        (0, utils_js_1.assert)(pageContext._globalContext._pageConfigs.length === 0);
-        hook = findPageGuard(pageContext.pageId, pageContext._globalContext._pageFilesAll);
-    }
-    else {
-        // V1 design
-        hook = (0, getHook_js_1.getHookFromPageContext)(pageContext, 'guard');
-    }
-    if (!hook)
-        return;
-    await (0, execHook_js_1.execHookDirectSingle)(hook, pageContext, prepareForPublicUsage);
-}
-function findPageGuard(pageId, pageFilesAll) {
-    const pageRouteFile = pageFilesAll.find((p) => p.pageId === pageId && p.fileType === '.page.route');
-    if (!pageRouteFile)
-        return null;
-    const { filePath, fileExports } = pageRouteFile;
-    (0, utils_js_1.assert)(fileExports); // loadPageRoutes() should already have been called
-    const hookFn = fileExports.guard;
-    if (!hookFn)
-        return null;
-    const hookFilePath = filePath;
-    const hookTimeout = (0, getHook_js_1.getHookTimeoutDefault)('guard');
-    (0, utils_js_1.assertUsage)((0, utils_js_1.isCallable)(hookFn), `${errIntro} ${hookFilePath} should be a function`);
-    return { hookFn, hookName: 'guard', hookFilePath, hookTimeout };
-}