vike 0.0.0-alpha.0 → 0.4.142-commit-6eb0dd3

package/dist/cjs/shared/getPageFiles/fileTypes.js

@@ -0,0 +1,53 @@
+"use strict";
+// TODO/v1-release: remove
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.determineFileType = exports.isValidFileType = exports.fileTypes = void 0;
+const utils_js_1 = require("../utils.js");
+const isScriptFile_js_1 = require("../../utils/isScriptFile.js");
+const fileTypes = [
+    '.page',
+    '.page.server',
+    '.page.route',
+    '.page.client',
+    // New type `.page.css`/`.page.server.css`/`.page.client.css` for `extensions[number].pageFileDist`.
+    //  - Extensions using `pageFileDist` are expected to use a bundler that generates a `.css` colocated next to the original `.page.js` file (e.g. `/renderer/_default.page.server.css` for `/renderer/_default.page.server.js`.
+    //  - Since these `.page.css` files Bundlers We can therefore expect that there isn't any `.page.server.sass`/...
+    '.css'
+];
+exports.fileTypes = fileTypes;
+function isValidFileType(filePath) {
+    return ['.js', '.mjs', '.cjs', '.css'].some((ext) => filePath.endsWith(ext));
+}
+exports.isValidFileType = isValidFileType;
+function determineFileType(filePath) {
+    (0, utils_js_1.assertPosixPath)(filePath);
+    {
+        const isCSS = filePath.endsWith('.css');
+        if (isCSS) {
+            /* This assert() is skipped to reduce client-side bundle size
+            assert(isNpmPackageImport(filePath), filePath) // `.css` page files are only supported for npm packages
+            */
+            return '.css';
+        }
+    }
+    (0, utils_js_1.assert)((0, isScriptFile_js_1.isScriptFile)(filePath), filePath);
+    const fileName = filePath.split('/').slice(-1)[0];
+    const parts = fileName.split('.');
+    const suffix1 = parts.slice(-3)[0];
+    const suffix2 = parts.slice(-2)[0];
+    if (suffix2 === 'page') {
+        return '.page';
+    }
+    (0, utils_js_1.assert)(suffix1 === 'page', filePath);
+    if (suffix2 === 'server') {
+        return '.page.server';
+    }
+    if (suffix2 === 'client') {
+        return '.page.client';
+    }
+    if (suffix2 === 'route') {
+        return '.page.route';
+    }
+    (0, utils_js_1.assert)(false, filePath);
+}
+exports.determineFileType = determineFileType;

package/dist/cjs/shared/getPageFiles/getAllPageIdFiles.js

@@ -0,0 +1,106 @@
+"use strict";
+// TODO:v1-release: remove this file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPageFilesServerSide = exports.getPageFilesClientSide = void 0;
+const utils_js_1 = require("../utils.js");
+const assertPageFilePath_js_1 = require("../assertPageFilePath.js");
+function getPageFilesClientSide(pageFilesAll, pageId) {
+    return determine(pageFilesAll, pageId, true);
+}
+exports.getPageFilesClientSide = getPageFilesClientSide;
+function getPageFilesServerSide(pageFilesAll, pageId) {
+    return determine(pageFilesAll, pageId, false);
+}
+exports.getPageFilesServerSide = getPageFilesServerSide;
+function determine(pageFilesAll, pageId, envIsClient) {
+    const env = envIsClient ? 'CLIENT_ONLY' : 'SERVER_ONLY';
+    const pageFilesRelevant = pageFilesAll
+        .filter((p) => p.isRelevant(pageId) && p.fileType !== '.page.route')
+        .sort(getPageFilesSorter(envIsClient, pageId));
+    // Load the `.page.js` files specific to `pageId`
+    const getPageIdFile = (iso) => {
+        const files = pageFilesRelevant.filter((p) => p.pageId === pageId && p.isEnv(iso ? 'CLIENT_AND_SERVER' : env));
+        (0, utils_js_1.assertUsage)(files.length <= 1, `Merge the following files into a single file: ${files.map((p) => p.filePath).join(' ')}`);
+        const pageIdFile = files[0];
+        (0, utils_js_1.assert)(pageIdFile === undefined || !pageIdFile.isDefaultPageFile);
+        return pageIdFile;
+    };
+    const pageIdFileEnv = getPageIdFile(false);
+    const pageIdFileIso = getPageIdFile(true);
+    // A page can have only one renderer. In other words: Multiple `renderer/` overwrite each other.
+    // Load only load renderer (`/renderer/_default.*`)
+    const getRendererFile = (iso) => pageFilesRelevant.filter((p) => p.isRendererPageFile && p.isEnv(iso ? 'CLIENT_AND_SERVER' : env))[0];
+    const rendererFileEnv = getRendererFile(false);
+    const rendererFileIso = getRendererFile(true);
+    // A page can load multiple `_defaut.page.*` files of the same `fileType`. In other words: non-renderer `_default.page.*` files are cumulative.
+    // The exception being HTML-only pages because we pick a single page file as client entry. We handle that use case at `renderPage()`.
+    const defaultFilesNonRenderer = pageFilesRelevant.filter((p) => p.isDefaultPageFile && !p.isRendererPageFile && (p.isEnv(env) || p.isEnv('CLIENT_AND_SERVER')));
+    // Ordered by `pageContext.exports` precendence
+    const pageFiles = [pageIdFileEnv, pageIdFileIso, ...defaultFilesNonRenderer, rendererFileEnv, rendererFileIso].filter(utils_js_1.isNotNullish);
+    return pageFiles;
+}
+function getPageFilesSorter(envIsClient, pageId) {
+    const env = envIsClient ? 'CLIENT_ONLY' : 'SERVER_ONLY';
+    const e1First = -1;
+    const e2First = +1;
+    const noOrder = 0;
+    return (e1, e2) => {
+        // `.page.js` files specific to `pageId` first
+        if (!e1.isDefaultPageFile && e2.isDefaultPageFile) {
+            return e1First;
+        }
+        if (!e2.isDefaultPageFile && e1.isDefaultPageFile) {
+            return e2First;
+        }
+        // Non-renderer `_default.page.*` before `renderer/**/_default.page.*`
+        {
+            const e1_isRenderer = e1.isRendererPageFile;
+            const e2_isRenderer = e2.isRendererPageFile;
+            if (!e1_isRenderer && e2_isRenderer) {
+                return e1First;
+            }
+            if (!e2_isRenderer && e1_isRenderer) {
+                return e2First;
+            }
+            (0, utils_js_1.assert)(e1_isRenderer === e2_isRenderer);
+        }
+        // Filesystem nearest first
+        {
+            const e1_distance = getPathDistance(pageId, e1.filePath);
+            const e2_distance = getPathDistance(pageId, e2.filePath);
+            if (e1_distance < e2_distance) {
+                return e1First;
+            }
+            if (e2_distance < e1_distance) {
+                return e2First;
+            }
+            (0, utils_js_1.assert)(e1_distance === e2_distance);
+        }
+        // `.page.server.js`/`.page.client.js` before `.page.js`
+        {
+            if (e1.isEnv(env) && e2.isEnv('CLIENT_AND_SERVER')) {
+                return e1First;
+            }
+            if (e2.isEnv(env) && e1.isEnv('CLIENT_AND_SERVER')) {
+                return e2First;
+            }
+        }
+        return noOrder;
+    };
+}
+function getPathDistance(pathA, pathB) {
+    (0, assertPageFilePath_js_1.assertPageFilePath)(pathA);
+    (0, assertPageFilePath_js_1.assertPageFilePath)(pathB);
+    // Index of first different character
+    let idx = 0;
+    for (; idx < pathA.length && idx < pathB.length; idx++) {
+        if (pathA[idx] !== pathB[idx])
+            break;
+    }
+    const pathAWithoutCommon = pathA.slice(idx);
+    const pathBWithoutCommon = pathB.slice(idx);
+    const distanceA = pathAWithoutCommon.split('/').length;
+    const distanceB = pathBWithoutCommon.split('/').length;
+    const distance = distanceA + distanceB;
+    return distance;
+}

package/dist/cjs/shared/getPageFiles/getExports.js

@@ -0,0 +1,146 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExports = exports.getExportUnion = void 0;
+const isScriptFile_js_1 = require("../../utils/isScriptFile.js");
+const utils_js_1 = require("../utils.js");
+const assertExports_js_1 = require("./assertExports.js");
+const utils_js_2 = require("../page-configs/utils.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+function getExports(pageFiles, pageConfig) {
+    const configEntries = {};
+    const config = {};
+    const exportsAll = {};
+    // V0.4 design
+    // TODO/v1-release: remove
+    pageFiles.forEach((pageFile) => {
+        const exportValues = getExportValues(pageFile);
+        exportValues.forEach(({ exportName, exportValue, isFromDefaultExport }) => {
+            (0, utils_js_1.assert)(exportName !== 'default');
+            exportsAll[exportName] = exportsAll[exportName] ?? [];
+            exportsAll[exportName].push({
+                exportValue,
+                exportSource: `${pageFile.filePath} > ${isFromDefaultExport ? `\`export default { ${exportName} }\`` : `\`export { ${exportName} }\``}`,
+                filePath: pageFile.filePath,
+                _filePath: pageFile.filePath,
+                _fileType: pageFile.fileType,
+                _isFromDefaultExport: isFromDefaultExport
+            });
+        });
+    });
+    // V1 design
+    if (pageConfig) {
+        Object.entries(pageConfig.configValues).forEach(([configName, configValue]) => {
+            const { value, definedAtInfo } = configValue;
+            let filePath = null;
+            if (definedAtInfo) {
+                filePath = definedAtInfo.filePath;
+            }
+            const configDefinedAt = (0, utils_js_2.getConfigDefinedAtString)(configName, configValue, true);
+            config[configName] = config[configName] ?? value;
+            configEntries[configName] = configEntries[configName] ?? [];
+            // Currently each configName has only one entry. Adding an entry for each overriden config value isn't implemented yet. (This is an isomorphic file and it isn't clear whether this can/should be implemented on the client-side. We should load a minimum amount of code on the client-side.)
+            (0, utils_js_1.assert)(configEntries[configName].length === 0);
+            configEntries[configName].push({
+                configValue: value,
+                configDefinedAt,
+                configDefinedByFile: filePath
+            });
+            // TODO/v1-release: remove
+            const exportName = configName;
+            exportsAll[exportName] = exportsAll[exportName] ?? [];
+            exportsAll[exportName].push({
+                exportValue: value,
+                exportSource: configDefinedAt,
+                filePath,
+                _filePath: filePath,
+                _fileType: null,
+                _isFromDefaultExport: null
+            });
+        });
+    }
+    const pageExports = createObjectWithDeprecationWarning();
+    const exports = {};
+    Object.entries(exportsAll).forEach(([exportName, values]) => {
+        values.forEach(({ exportValue, _fileType, _isFromDefaultExport }) => {
+            exports[exportName] = exports[exportName] ?? exportValue;
+            // Legacy pageContext.pageExports
+            if (_fileType === '.page' && !_isFromDefaultExport) {
+                if (!(exportName in pageExports)) {
+                    pageExports[exportName] = exportValue;
+                }
+            }
+        });
+    });
+    (0, utils_js_1.assert)(!('default' in exports));
+    (0, utils_js_1.assert)(!('default' in exportsAll));
+    return {
+        config,
+        configEntries,
+        // TODO/v1-release: remove
+        exports,
+        exportsAll,
+        pageExports
+    };
+}
+exports.getExports = getExports;
+function getExportValues(pageFile) {
+    const { filePath, fileExports } = pageFile;
+    (0, utils_js_1.assert)(fileExports); // assume pageFile.loadFile() was called
+    (0, utils_js_1.assert)((0, isScriptFile_js_1.isScriptFile)(filePath));
+    const exportValues = [];
+    Object.entries(fileExports)
+        .sort((0, utils_js_1.makeLast)(([exportName]) => exportName === 'default')) // `export { bla }` should override `export default { bla }`
+        .forEach(([exportName, exportValue]) => {
+        let isFromDefaultExport = exportName === 'default';
+        if (isFromDefaultExport) {
+            if ((0, isScriptFile_js_1.isTemplateFile)(filePath)) {
+                exportName = 'Page';
+            }
+            else {
+                (0, utils_js_1.assertUsage)((0, utils_js_1.isObject)(exportValue), `The ${picocolors_1.default.cyan('export default')} of ${filePath} should be an object.`);
+                Object.entries(exportValue).forEach(([defaultExportName, defaultExportValue]) => {
+                    (0, assertExports_js_1.assertDefaultExports)(defaultExportName, filePath);
+                    exportValues.push({
+                        exportName: defaultExportName,
+                        exportValue: defaultExportValue,
+                        isFromDefaultExport
+                    });
+                });
+                return;
+            }
+        }
+        exportValues.push({
+            exportName,
+            exportValue,
+            isFromDefaultExport
+        });
+    });
+    exportValues.forEach(({ exportName, isFromDefaultExport }) => {
+        (0, utils_js_1.assert)(!(isFromDefaultExport && assertExports_js_1.forbiddenDefaultExports.includes(exportName)));
+    });
+    return exportValues;
+}
+// TODO/v1-release: remove
+function createObjectWithDeprecationWarning() {
+    return new Proxy({}, {
+        get(...args) {
+            // We only show the warning in Node.js because when using Client Routing Vue integration uses `Object.assign(pageContextReactive, pageContext)` which will wrongully trigger the warning. There is no cross-browser way to catch whether the property accessor was initiated by an `Object.assign()` call.
+            if (!(0, utils_js_1.isBrowser)()) {
+                (0, utils_js_1.assertWarning)(false, '`pageContext.pageExports` is outdated. Use `pageContext.exports` instead, see https://vike.dev/exports', { onlyOnce: true, showStackTrace: true });
+            }
+            return Reflect.get(...args);
+        }
+    });
+}
+function getExportUnion(exportsAll, propName) {
+    return (exportsAll[propName]
+        ?.map((e) => {
+        (0, utils_js_1.assertUsage)((0, utils_js_1.hasProp)(e, 'exportValue', 'string[]'), `${e.exportSource} should be an array of strings.`);
+        return e.exportValue;
+    })
+        .flat() ?? []);
+}
+exports.getExportUnion = getExportUnion;

package/dist/cjs/shared/getPageFiles/getPageFileObject.js

@@ -0,0 +1,62 @@
+"use strict";
+// TODO/v1-release: remove
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPageFileObject = void 0;
+const determinePageIdOld_js_1 = require("../determinePageIdOld.js");
+const assertPageFilePath_js_1 = require("../assertPageFilePath.js");
+const error_page_js_1 = require("../error-page.js");
+const utils_js_1 = require("../utils.js");
+const fileTypes_js_1 = require("./fileTypes.js");
+function getPageFileObject(filePath) {
+    const isRelevant = (pageId) => pageFile.pageId === pageId ||
+        (pageFile.isDefaultPageFile &&
+            (isRendererFilePath(pageFile.filePath) || isAncestorDefaultPage(pageId, pageFile.filePath)));
+    const fileType = (0, fileTypes_js_1.determineFileType)(filePath);
+    const isEnv = (env) => {
+        (0, utils_js_1.assert)(fileType !== '.page.route'); // We can't determine `.page.route.js`
+        if (env === 'CLIENT_ONLY') {
+            return fileType === '.page.client' || fileType === '.css';
+        }
+        if (env === 'SERVER_ONLY') {
+            return fileType === '.page.server';
+        }
+        if (env === 'CLIENT_AND_SERVER') {
+            return fileType === '.page';
+        }
+        (0, utils_js_1.assert)(false);
+    };
+    const pageFile = {
+        filePath,
+        fileType,
+        isEnv,
+        isRelevant,
+        isDefaultPageFile: isDefaultFilePath(filePath),
+        isRendererPageFile: fileType !== '.css' && isDefaultFilePath(filePath) && isRendererFilePath(filePath),
+        isErrorPageFile: (0, error_page_js_1.isErrorPageId)(filePath, false),
+        pageId: (0, determinePageIdOld_js_1.determinePageIdOld)(filePath)
+    };
+    return pageFile;
+}
+exports.getPageFileObject = getPageFileObject;
+function isDefaultFilePath(filePath) {
+    (0, assertPageFilePath_js_1.assertPageFilePath)(filePath);
+    if ((0, error_page_js_1.isErrorPageId)(filePath, false)) {
+        return false;
+    }
+    return filePath.includes('/_default');
+}
+function isRendererFilePath(filePath) {
+    (0, assertPageFilePath_js_1.assertPageFilePath)(filePath);
+    return filePath.includes('/renderer/');
+}
+function isAncestorDefaultPage(pageId, defaultPageFilePath) {
+    (0, assertPageFilePath_js_1.assertPageFilePath)(pageId);
+    (0, assertPageFilePath_js_1.assertPageFilePath)(defaultPageFilePath);
+    (0, utils_js_1.assert)(!pageId.endsWith('/'));
+    (0, utils_js_1.assert)(!defaultPageFilePath.endsWith('/'));
+    (0, utils_js_1.assert)(isDefaultFilePath(defaultPageFilePath));
+    const defaultPageDir = (0, utils_js_1.slice)(defaultPageFilePath.split('/'), 0, -1)
+        .filter((filePathSegment) => filePathSegment !== '_default')
+        .join('/');
+    return pageId.startsWith(defaultPageDir);
+}

package/dist/cjs/shared/getPageFiles/parseGlobResults.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseGlobResults = void 0;
+const utils_js_1 = require("../utils.js");
+const assertExports_js_1 = require("./assertExports.js");
+const getPageFileObject_js_1 = require("./getPageFileObject.js");
+const fileTypes_js_1 = require("./fileTypes.js");
+const assertPageConfigs_js_1 = require("./assertPageConfigs.js");
+function parseGlobResults(pageFilesExports) {
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageFilesExports, 'isGeneratedFile'));
+    (0, utils_js_1.assert)(pageFilesExports.isGeneratedFile !== false, `vike was re-installed(/re-built). Restart your app.`);
+    (0, utils_js_1.assert)(pageFilesExports.isGeneratedFile === true, `\`isGeneratedFile === ${pageFilesExports.isGeneratedFile}\``);
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageFilesExports, 'pageFilesLazy', 'object'));
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageFilesExports, 'pageFilesEager', 'object'));
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageFilesExports, 'pageFilesExportNamesLazy', 'object'));
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageFilesExports, 'pageFilesExportNamesEager', 'object'));
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageFilesExports.pageFilesLazy, '.page'));
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageFilesExports.pageFilesLazy, '.page.client') || (0, utils_js_1.hasProp)(pageFilesExports.pageFilesLazy, '.page.server'));
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageFilesExports, 'pageFilesList', 'string[]'));
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageFilesExports, 'pageConfigs'));
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageFilesExports, 'pageConfigGlobal'));
+    const { pageConfigs, pageConfigGlobal } = pageFilesExports;
+    (0, assertPageConfigs_js_1.assertPageConfigs)(pageConfigs);
+    parsePageConfigs(pageConfigs);
+    (0, assertPageConfigs_js_1.assertPageConfigGlobal)(pageConfigGlobal);
+    const pageFilesMap = {};
+    parseGlobResult(pageFilesExports.pageFilesLazy).forEach(({ filePath, pageFile, globValue }) => {
+        pageFile = pageFilesMap[filePath] = pageFilesMap[filePath] ?? pageFile;
+        const loadModule = globValue;
+        assertLoadModule(loadModule);
+        pageFile.loadFile = async () => {
+            if (!('fileExports' in pageFile)) {
+                pageFile.fileExports = await loadModule();
+                (0, assertExports_js_1.assertExportValues)(pageFile);
+            }
+        };
+    });
+    parseGlobResult(pageFilesExports.pageFilesExportNamesLazy).forEach(({ filePath, pageFile, globValue }) => {
+        pageFile = pageFilesMap[filePath] = pageFilesMap[filePath] ?? pageFile;
+        const loadModule = globValue;
+        assertLoadModule(loadModule);
+        pageFile.loadExportNames = async () => {
+            if (!('exportNames' in pageFile)) {
+                const moduleExports = await loadModule();
+                // Vite 2 seems to choke following assertion: https://github.com/vikejs/vike/issues/455
+                (0, utils_js_1.assertUsage)('exportNames' in moduleExports, 'You seem to be using Vite 2 but the latest vike versions only work with Vite 3');
+                (0, utils_js_1.assert)((0, utils_js_1.hasProp)(moduleExports, 'exportNames', 'string[]'), pageFile.filePath);
+                pageFile.exportNames = moduleExports.exportNames;
+            }
+        };
+    });
+    // `pageFilesEager` contains `.page.route.js` files
+    parseGlobResult(pageFilesExports.pageFilesEager).forEach(({ filePath, pageFile, globValue }) => {
+        pageFile = pageFilesMap[filePath] = pageFilesMap[filePath] ?? pageFile;
+        const moduleExports = globValue;
+        (0, utils_js_1.assert)((0, utils_js_1.isObject)(moduleExports));
+        pageFile.fileExports = moduleExports;
+    });
+    parseGlobResult(pageFilesExports.pageFilesExportNamesEager).forEach(({ filePath, pageFile, globValue }) => {
+        pageFile = pageFilesMap[filePath] = pageFilesMap[filePath] ?? pageFile;
+        const moduleExports = globValue;
+        (0, utils_js_1.assert)((0, utils_js_1.isObject)(moduleExports));
+        (0, utils_js_1.assert)((0, utils_js_1.hasProp)(moduleExports, 'exportNames', 'string[]'), pageFile.filePath);
+        pageFile.exportNames = moduleExports.exportNames;
+    });
+    pageFilesExports.pageFilesList.forEach((filePath) => {
+        pageFilesMap[filePath] = pageFilesMap[filePath] ?? (0, getPageFileObject_js_1.getPageFileObject)(filePath);
+    });
+    const pageFiles = Object.values(pageFilesMap);
+    pageFiles.forEach(({ filePath }) => {
+        (0, utils_js_1.assert)(!filePath.includes('\\'));
+    });
+    return { pageFiles, pageConfigs, pageConfigGlobal };
+}
+exports.parseGlobResults = parseGlobResults;
+function parseGlobResult(globObject) {
+    const ret = [];
+    Object.entries(globObject).forEach(([fileType, globFiles]) => {
+        (0, utils_js_1.cast)(fileType);
+        (0, utils_js_1.assert)(fileTypes_js_1.fileTypes.includes(fileType));
+        (0, utils_js_1.assert)((0, utils_js_1.isObject)(globFiles));
+        Object.entries(globFiles).forEach(([filePath, globValue]) => {
+            const pageFile = (0, getPageFileObject_js_1.getPageFileObject)(filePath);
+            (0, utils_js_1.assert)(pageFile.fileType === fileType);
+            ret.push({ filePath, pageFile, globValue });
+        });
+    });
+    return ret;
+}
+function assertLoadModule(globValue) {
+    (0, utils_js_1.assert)((0, utils_js_1.isCallable)(globValue));
+}
+function parsePageConfigs(pageConfigs) {
+    // TODO: remove
+    /*
+    pageConfigs.forEach((pageConfig) => {
+      Object.entries(pageConfig.configElements).forEach(([configName, configElement]) => {
+        {
+          const { configValueSerialized } = configElement
+          if (configValueSerialized !== undefined) {
+            configElement.configValue = parse(configValueSerialized)
+          }
+        }
+        if (configName === 'route') {
+          assertRouteConfigValue(configElement)
+        }
+      })
+    })
+    */
+}
+// TODO: use again
+// function assertRouteConfigValue(configElement: ConfigElement) {
+//   assert(hasProp(configElement, 'configValue')) // route files are eagerly loaded
+//   const { configValue } = configElement
+//   const configValueType = typeof configValue
+//   assertUsage(
+//     configValueType === 'string' || isCallable(configValue),
+//     `${configElement.configDefinedAt} has an invalid type '${configValueType}': it should be a string or a function instead, see https://vike.dev/route`
+//   )
+//   /* We don't do that to avoid unnecessarily bloating the client-side bundle when using Server Routing
+//    *  - When using Server Routing, this file is loaded as well
+//    *  - When using Server Routing, client-side validation is superfluous as Route Strings only need to be validated on the server-side
+//   if (typeof configValue === 'string') {
+//     assertRouteString(configValue, `${configElement.configDefinedAt} defines an`)
+//   }
+//   */
+// }

package/dist/cjs/shared/getPageFiles/setPageFiles.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPageFilesAll = exports.setPageFilesAsync = exports.setPageFiles = void 0;
+const utils_js_1 = require("../utils.js");
+const parseGlobResults_js_1 = require("./parseGlobResults.js");
+const getGlobalObject_js_1 = require("../../utils/getGlobalObject.js");
+const globalObject = (0, getGlobalObject_js_1.getGlobalObject)('setPageFiles.ts', {});
+// TODO:v1-design-release: rename setPageFiles() getPageFilesAll() parseGlobResult()
+function setPageFiles(pageFilesExports) {
+    const { pageFiles, pageConfigs, pageConfigGlobal } = (0, parseGlobResults_js_1.parseGlobResults)(pageFilesExports);
+    globalObject.pageFilesAll = pageFiles;
+    globalObject.pageConfigs = pageConfigs;
+    globalObject.pageConfigGlobal = pageConfigGlobal;
+}
+exports.setPageFiles = setPageFiles;
+function setPageFilesAsync(getPageFilesExports) {
+    globalObject.pageFilesGetter = async () => {
+        setPageFiles(await getPageFilesExports());
+    };
+}
+exports.setPageFilesAsync = setPageFilesAsync;
+async function getPageFilesAll(isClientSide, isProduction) {
+    if (isClientSide) {
+        (0, utils_js_1.assert)(!globalObject.pageFilesGetter);
+        (0, utils_js_1.assert)(isProduction === undefined);
+    }
+    else {
+        (0, utils_js_1.assert)(globalObject.pageFilesGetter);
+        (0, utils_js_1.assert)(typeof isProduction === 'boolean');
+        if (!globalObject.pageFilesAll ||
+            // We reload all glob imports in dev to make auto-reload work
+            !isProduction) {
+            await globalObject.pageFilesGetter();
+        }
+    }
+    const { pageFilesAll, pageConfigs, pageConfigGlobal } = globalObject;
+    (0, utils_js_1.assert)(pageFilesAll && pageConfigs && pageConfigGlobal);
+    const allPageIds = getAllPageIds(pageFilesAll, pageConfigs);
+    return { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal };
+}
+exports.getPageFilesAll = getPageFilesAll;
+function getAllPageIds(allPageFiles, pageConfigs) {
+    const fileIds = allPageFiles.filter(({ isDefaultPageFile }) => !isDefaultPageFile).map(({ pageId }) => pageId);
+    const allPageIds = (0, utils_js_1.unique)(fileIds);
+    const allPageIds2 = pageConfigs.map((p) => p.pageId);
+    return [...allPageIds, ...allPageIds2];
+}

package/dist/cjs/shared/getPageFiles.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExports = exports.getPageFilesServerSide = exports.getPageFilesClientSide = exports.setPageFilesAsync = exports.setPageFiles = exports.getPageFilesAll = exports.getExportUnion = void 0;
+// Utils
+var getExports_js_1 = require("./getPageFiles/getExports.js");
+Object.defineProperty(exports, "getExportUnion", { enumerable: true, get: function () { return getExports_js_1.getExportUnion; } });
+var setPageFiles_js_1 = require("./getPageFiles/setPageFiles.js");
+Object.defineProperty(exports, "getPageFilesAll", { enumerable: true, get: function () { return setPageFiles_js_1.getPageFilesAll; } });
+var setPageFiles_js_2 = require("./getPageFiles/setPageFiles.js");
+Object.defineProperty(exports, "setPageFiles", { enumerable: true, get: function () { return setPageFiles_js_2.setPageFiles; } });
+var setPageFiles_js_3 = require("./getPageFiles/setPageFiles.js");
+Object.defineProperty(exports, "setPageFilesAsync", { enumerable: true, get: function () { return setPageFiles_js_3.setPageFilesAsync; } });
+var getAllPageIdFiles_js_1 = require("./getPageFiles/getAllPageIdFiles.js");
+Object.defineProperty(exports, "getPageFilesClientSide", { enumerable: true, get: function () { return getAllPageIdFiles_js_1.getPageFilesClientSide; } });
+var getAllPageIdFiles_js_2 = require("./getPageFiles/getAllPageIdFiles.js");
+Object.defineProperty(exports, "getPageFilesServerSide", { enumerable: true, get: function () { return getAllPageIdFiles_js_2.getPageFilesServerSide; } });
+var getExports_js_2 = require("./getPageFiles/getExports.js");
+Object.defineProperty(exports, "getExports", { enumerable: true, get: function () { return getExports_js_2.getExports; } });

package/dist/cjs/shared/hooks/executeHook.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUserHookError = exports.executeHook = void 0;
+const assert_js_1 = require("../../utils/assert.js");
+const getGlobalObject_js_1 = require("../../utils/getGlobalObject.js");
+const humanizeTime_js_1 = require("../../utils/humanizeTime.js");
+const isObject_js_1 = require("../../utils/isObject.js");
+const globalObject = (0, getGlobalObject_js_1.getGlobalObject)('utils/executeHook.ts', {
+    userHookErrors: new Map()
+});
+function isUserHookError(err) {
+    if (!(0, isObject_js_1.isObject)(err))
+        return false;
+    return globalObject.userHookErrors.get(err) ?? false;
+}
+exports.isUserHookError = isUserHookError;
+function executeHook(hookFn, hookName, hookFilePath) {
+    const { timeoutErr, timeoutWarn } = getTimeouts(hookName);
+    let resolve;
+    let reject;
+    const promise = new Promise((resolve_, reject_) => {
+        resolve = (ret) => {
+            clearTimeouts();
+            resolve_(ret);
+        };
+        reject = (err) => {
+            clearTimeouts();
+            reject_(err);
+        };
+    });
+    const clearTimeouts = () => {
+        clearTimeout(t1);
+        clearTimeout(t2);
+    };
+    const t1 = setTimeout(() => {
+        (0, assert_js_1.assertWarning)(false, `The ${hookName}() hook defined by ${hookFilePath} is taking more than ${(0, humanizeTime_js_1.humanizeTime)(timeoutWarn)}`, { onlyOnce: false });
+    }, timeoutWarn);
+    const t2 = setTimeout(() => {
+        const err = (0, assert_js_1.getProjectError)(`Hook timeout: the ${hookName}() hook defined by ${hookFilePath} didn't finish after ${(0, humanizeTime_js_1.humanizeTime)(timeoutErr)}`);
+        reject(err);
+    }, timeoutErr);
+    (async () => {
+        try {
+            const ret = await hookFn();
+            resolve(ret);
+        }
+        catch (err) {
+            if ((0, isObject_js_1.isObject)(err)) {
+                globalObject.userHookErrors.set(err, { hookName, hookFilePath });
+            }
+            reject(err);
+        }
+    })();
+    return promise;
+}
+exports.executeHook = executeHook;
+function getTimeouts(hookName) {
+    if (hookName === 'onBeforeRoute') {
+        return {
+            timeoutErr: 5 * 1000,
+            timeoutWarn: 1 * 1000
+        };
+    }
+    if (hookName === 'onBeforePrerender') {
+        return {
+            timeoutErr: 10 * 60 * 1000,
+            timeoutWarn: 30 * 1000
+        };
+    }
+    return {
+        timeoutErr: 40 * 1000,
+        timeoutWarn: 4 * 1000
+    };
+}

package/dist/cjs/shared/hooks/getHook.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertHookFn = exports.assertHook = exports.getHook = void 0;
+const utils_js_1 = require("../utils.js");
+function getHook(pageContext, hookName) {
+    if (!(hookName in pageContext.exports)) {
+        return null;
+    }
+    const hookFn = pageContext.exports[hookName];
+    const file = pageContext.exportsAll[hookName][0];
+    (0, utils_js_1.assert)(file.exportValue === hookFn);
+    if (hookFn === null)
+        return null;
+    const hookFilePath = file.exportSource;
+    assertHookFn(hookFn, { hookName, hookFilePath });
+    return { hookFn, hookName, hookFilePath };
+}
+exports.getHook = getHook;
+function assertHook(pageContext, hookName) {
+    getHook(pageContext, hookName);
+}
+exports.assertHook = assertHook;
+function assertHookFn(hookFn, { hookName, hookFilePath }) {
+    (0, utils_js_1.assert)(hookName && hookFilePath);
+    (0, utils_js_1.assert)(!hookName.endsWith(')'));
+    (0, utils_js_1.assertUsage)((0, utils_js_1.isCallable)(hookFn), `hook ${hookName}() defined by ${hookFilePath} should be a function`);
+    (0, utils_js_1.checkType)(hookFn);
+}
+exports.assertHookFn = assertHookFn;