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

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

@@ -0,0 +1,140 @@
+export { getExportUnion };
+export { getExports };
+import { isScriptFile, isTemplateFile } from '../../utils/isScriptFile.js';
+import { assert, hasProp, isObject, assertWarning, assertUsage, makeLast, isBrowser } from '../utils.js';
+import { assertDefaultExports, forbiddenDefaultExports } from './assertExports.js';
+import { getConfigDefinedAtString } from '../page-configs/utils.js';
+import pc from '@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 }) => {
+            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 = 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.)
+            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;
+                }
+            }
+        });
+    });
+    assert(!('default' in exports));
+    assert(!('default' in exportsAll));
+    return {
+        config,
+        configEntries,
+        // TODO/v1-release: remove
+        exports,
+        exportsAll,
+        pageExports
+    };
+}
+function getExportValues(pageFile) {
+    const { filePath, fileExports } = pageFile;
+    assert(fileExports); // assume pageFile.loadFile() was called
+    assert(isScriptFile(filePath));
+    const exportValues = [];
+    Object.entries(fileExports)
+        .sort(makeLast(([exportName]) => exportName === 'default')) // `export { bla }` should override `export default { bla }`
+        .forEach(([exportName, exportValue]) => {
+        let isFromDefaultExport = exportName === 'default';
+        if (isFromDefaultExport) {
+            if (isTemplateFile(filePath)) {
+                exportName = 'Page';
+            }
+            else {
+                assertUsage(isObject(exportValue), `The ${pc.cyan('export default')} of ${filePath} should be an object.`);
+                Object.entries(exportValue).forEach(([defaultExportName, defaultExportValue]) => {
+                    assertDefaultExports(defaultExportName, filePath);
+                    exportValues.push({
+                        exportName: defaultExportName,
+                        exportValue: defaultExportValue,
+                        isFromDefaultExport
+                    });
+                });
+                return;
+            }
+        }
+        exportValues.push({
+            exportName,
+            exportValue,
+            isFromDefaultExport
+        });
+    });
+    exportValues.forEach(({ exportName, isFromDefaultExport }) => {
+        assert(!(isFromDefaultExport && 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 (!isBrowser()) {
+                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) => {
+        assertUsage(hasProp(e, 'exportValue', 'string[]'), `${e.exportSource} should be an array of strings.`);
+        return e.exportValue;
+    })
+        .flat() ?? []);
+}

package/dist/esm/shared/getPageFiles/getPageFileObject.d.ts

@@ -0,0 +1,18 @@
+export { getPageFileObject };
+export type { PageFile };
+import { FileType } from './fileTypes.js';
+type PageFile = {
+    filePath: string;
+    fileType: FileType;
+    isEnv: (env: 'CLIENT_ONLY' | 'SERVER_ONLY' | 'CLIENT_AND_SERVER') => boolean;
+    fileExports?: Record<string, unknown>;
+    loadFile?: () => Promise<void>;
+    exportNames?: string[];
+    loadExportNames?: () => Promise<void>;
+    isRelevant: (pageId: string) => boolean;
+    isDefaultPageFile: boolean;
+    isRendererPageFile: boolean;
+    isErrorPageFile: boolean;
+    pageId: string;
+};
+declare function getPageFileObject(filePath: string): PageFile;

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

@@ -0,0 +1,59 @@
+// TODO/v1-release: remove
+export { getPageFileObject };
+import { determinePageIdOld } from '../determinePageIdOld.js';
+import { assertPageFilePath } from '../assertPageFilePath.js';
+import { isErrorPageId } from '../error-page.js';
+import { assert, slice } from '../utils.js';
+import { determineFileType } from './fileTypes.js';
+function getPageFileObject(filePath) {
+    const isRelevant = (pageId) => pageFile.pageId === pageId ||
+        (pageFile.isDefaultPageFile &&
+            (isRendererFilePath(pageFile.filePath) || isAncestorDefaultPage(pageId, pageFile.filePath)));
+    const fileType = determineFileType(filePath);
+    const isEnv = (env) => {
+        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';
+        }
+        assert(false);
+    };
+    const pageFile = {
+        filePath,
+        fileType,
+        isEnv,
+        isRelevant,
+        isDefaultPageFile: isDefaultFilePath(filePath),
+        isRendererPageFile: fileType !== '.css' && isDefaultFilePath(filePath) && isRendererFilePath(filePath),
+        isErrorPageFile: isErrorPageId(filePath, false),
+        pageId: determinePageIdOld(filePath)
+    };
+    return pageFile;
+}
+function isDefaultFilePath(filePath) {
+    assertPageFilePath(filePath);
+    if (isErrorPageId(filePath, false)) {
+        return false;
+    }
+    return filePath.includes('/_default');
+}
+function isRendererFilePath(filePath) {
+    assertPageFilePath(filePath);
+    return filePath.includes('/renderer/');
+}
+function isAncestorDefaultPage(pageId, defaultPageFilePath) {
+    assertPageFilePath(pageId);
+    assertPageFilePath(defaultPageFilePath);
+    assert(!pageId.endsWith('/'));
+    assert(!defaultPageFilePath.endsWith('/'));
+    assert(isDefaultFilePath(defaultPageFilePath));
+    const defaultPageDir = slice(defaultPageFilePath.split('/'), 0, -1)
+        .filter((filePathSegment) => filePathSegment !== '_default')
+        .join('/');
+    return pageId.startsWith(defaultPageDir);
+}

package/dist/esm/shared/getPageFiles/parseGlobResults.d.ts

@@ -0,0 +1,8 @@
+export { parseGlobResults };
+import { type PageFile } from './getPageFileObject.js';
+import type { PageConfig, PageConfigGlobal } from '../page-configs/PageConfig.js';
+declare function parseGlobResults(pageFilesExports: unknown): {
+    pageFiles: PageFile[];
+    pageConfigs: PageConfig[];
+    pageConfigGlobal: PageConfigGlobal;
+};

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

@@ -0,0 +1,124 @@
+export { parseGlobResults };
+import { assert, hasProp, isCallable, isObject, cast, assertUsage } from '../utils.js';
+import { assertExportValues } from './assertExports.js';
+import { getPageFileObject } from './getPageFileObject.js';
+import { fileTypes } from './fileTypes.js';
+import { assertPageConfigGlobal, assertPageConfigs } from './assertPageConfigs.js';
+function parseGlobResults(pageFilesExports) {
+    assert(hasProp(pageFilesExports, 'isGeneratedFile'));
+    assert(pageFilesExports.isGeneratedFile !== false, `vike was re-installed(/re-built). Restart your app.`);
+    assert(pageFilesExports.isGeneratedFile === true, `\`isGeneratedFile === ${pageFilesExports.isGeneratedFile}\``);
+    assert(hasProp(pageFilesExports, 'pageFilesLazy', 'object'));
+    assert(hasProp(pageFilesExports, 'pageFilesEager', 'object'));
+    assert(hasProp(pageFilesExports, 'pageFilesExportNamesLazy', 'object'));
+    assert(hasProp(pageFilesExports, 'pageFilesExportNamesEager', 'object'));
+    assert(hasProp(pageFilesExports.pageFilesLazy, '.page'));
+    assert(hasProp(pageFilesExports.pageFilesLazy, '.page.client') || hasProp(pageFilesExports.pageFilesLazy, '.page.server'));
+    assert(hasProp(pageFilesExports, 'pageFilesList', 'string[]'));
+    assert(hasProp(pageFilesExports, 'pageConfigs'));
+    assert(hasProp(pageFilesExports, 'pageConfigGlobal'));
+    const { pageConfigs, pageConfigGlobal } = pageFilesExports;
+    assertPageConfigs(pageConfigs);
+    parsePageConfigs(pageConfigs);
+    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();
+                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
+                assertUsage('exportNames' in moduleExports, 'You seem to be using Vite 2 but the latest vike versions only work with Vite 3');
+                assert(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;
+        assert(isObject(moduleExports));
+        pageFile.fileExports = moduleExports;
+    });
+    parseGlobResult(pageFilesExports.pageFilesExportNamesEager).forEach(({ filePath, pageFile, globValue }) => {
+        pageFile = pageFilesMap[filePath] = pageFilesMap[filePath] ?? pageFile;
+        const moduleExports = globValue;
+        assert(isObject(moduleExports));
+        assert(hasProp(moduleExports, 'exportNames', 'string[]'), pageFile.filePath);
+        pageFile.exportNames = moduleExports.exportNames;
+    });
+    pageFilesExports.pageFilesList.forEach((filePath) => {
+        pageFilesMap[filePath] = pageFilesMap[filePath] ?? getPageFileObject(filePath);
+    });
+    const pageFiles = Object.values(pageFilesMap);
+    pageFiles.forEach(({ filePath }) => {
+        assert(!filePath.includes('\\'));
+    });
+    return { pageFiles, pageConfigs, pageConfigGlobal };
+}
+function parseGlobResult(globObject) {
+    const ret = [];
+    Object.entries(globObject).forEach(([fileType, globFiles]) => {
+        cast(fileType);
+        assert(fileTypes.includes(fileType));
+        assert(isObject(globFiles));
+        Object.entries(globFiles).forEach(([filePath, globValue]) => {
+            const pageFile = getPageFileObject(filePath);
+            assert(pageFile.fileType === fileType);
+            ret.push({ filePath, pageFile, globValue });
+        });
+    });
+    return ret;
+}
+function assertLoadModule(globValue) {
+    assert(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/esm/shared/getPageFiles/setPageFiles.d.ts

@@ -0,0 +1,13 @@
+export { setPageFiles };
+export { setPageFilesAsync };
+export { getPageFilesAll };
+import type { PageFile } from './getPageFileObject.js';
+import type { PageConfig, PageConfigGlobal } from '../page-configs/PageConfig.js';
+declare function setPageFiles(pageFilesExports: unknown): void;
+declare function setPageFilesAsync(getPageFilesExports: () => Promise<unknown>): void;
+declare function getPageFilesAll(isClientSide: boolean, isProduction?: boolean): Promise<{
+    pageFilesAll: PageFile[];
+    allPageIds: string[];
+    pageConfigs: PageConfig[];
+    pageConfigGlobal: PageConfigGlobal;
+}>;

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

@@ -0,0 +1,44 @@
+export { setPageFiles };
+export { setPageFilesAsync };
+export { getPageFilesAll };
+import { assert, unique } from '../utils.js';
+import { parseGlobResults } from './parseGlobResults.js';
+import { getGlobalObject } from '../../utils/getGlobalObject.js';
+const globalObject = getGlobalObject('setPageFiles.ts', {});
+// TODO:v1-design-release: rename setPageFiles() getPageFilesAll() parseGlobResult()
+function setPageFiles(pageFilesExports) {
+    const { pageFiles, pageConfigs, pageConfigGlobal } = parseGlobResults(pageFilesExports);
+    globalObject.pageFilesAll = pageFiles;
+    globalObject.pageConfigs = pageConfigs;
+    globalObject.pageConfigGlobal = pageConfigGlobal;
+}
+function setPageFilesAsync(getPageFilesExports) {
+    globalObject.pageFilesGetter = async () => {
+        setPageFiles(await getPageFilesExports());
+    };
+}
+async function getPageFilesAll(isClientSide, isProduction) {
+    if (isClientSide) {
+        assert(!globalObject.pageFilesGetter);
+        assert(isProduction === undefined);
+    }
+    else {
+        assert(globalObject.pageFilesGetter);
+        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;
+    assert(pageFilesAll && pageConfigs && pageConfigGlobal);
+    const allPageIds = getAllPageIds(pageFilesAll, pageConfigs);
+    return { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal };
+}
+function getAllPageIds(allPageFiles, pageConfigs) {
+    const fileIds = allPageFiles.filter(({ isDefaultPageFile }) => !isDefaultPageFile).map(({ pageId }) => pageId);
+    const allPageIds = unique(fileIds);
+    const allPageIds2 = pageConfigs.map((p) => p.pageId);
+    return [...allPageIds, ...allPageIds2];
+}

package/dist/esm/shared/getPageFiles.d.ts

@@ -0,0 +1,9 @@
+export type { PageFile } from './getPageFiles/getPageFileObject.js';
+export type { ExportsAll, PageContextExports } from './getPageFiles/getExports.js';
+export { getExportUnion } from './getPageFiles/getExports.js';
+export { getPageFilesAll } from './getPageFiles/setPageFiles.js';
+export { setPageFiles } from './getPageFiles/setPageFiles.js';
+export { setPageFilesAsync } from './getPageFiles/setPageFiles.js';
+export { getPageFilesClientSide } from './getPageFiles/getAllPageIdFiles.js';
+export { getPageFilesServerSide } from './getPageFiles/getAllPageIdFiles.js';
+export { getExports } from './getPageFiles/getExports.js';

package/dist/esm/shared/getPageFiles.js

@@ -0,0 +1,8 @@
+// Utils
+export { getExportUnion } from './getPageFiles/getExports.js';
+export { getPageFilesAll } from './getPageFiles/setPageFiles.js';
+export { setPageFiles } from './getPageFiles/setPageFiles.js';
+export { setPageFilesAsync } from './getPageFiles/setPageFiles.js';
+export { getPageFilesClientSide } from './getPageFiles/getAllPageIdFiles.js';
+export { getPageFilesServerSide } from './getPageFiles/getAllPageIdFiles.js';
+export { getExports } from './getPageFiles/getExports.js';

package/dist/esm/shared/hooks/executeHook.d.ts

@@ -0,0 +1,5 @@
+export { executeHook };
+export { isUserHookError };
+import type { HookLoc, HookName } from './getHook.js';
+declare function isUserHookError(err: unknown): false | HookLoc;
+declare function executeHook<T = unknown>(hookFn: () => T, hookName: HookName, hookFilePath: string): Promise<T>;

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

@@ -0,0 +1,71 @@
+export { executeHook };
+export { isUserHookError };
+import { getProjectError, assertWarning } from '../../utils/assert.js';
+import { getGlobalObject } from '../../utils/getGlobalObject.js';
+import { humanizeTime } from '../../utils/humanizeTime.js';
+import { isObject } from '../../utils/isObject.js';
+const globalObject = getGlobalObject('utils/executeHook.ts', {
+    userHookErrors: new Map()
+});
+function isUserHookError(err) {
+    if (!isObject(err))
+        return false;
+    return globalObject.userHookErrors.get(err) ?? false;
+}
+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(() => {
+        assertWarning(false, `The ${hookName}() hook defined by ${hookFilePath} is taking more than ${humanizeTime(timeoutWarn)}`, { onlyOnce: false });
+    }, timeoutWarn);
+    const t2 = setTimeout(() => {
+        const err = getProjectError(`Hook timeout: the ${hookName}() hook defined by ${hookFilePath} didn't finish after ${humanizeTime(timeoutErr)}`);
+        reject(err);
+    }, timeoutErr);
+    (async () => {
+        try {
+            const ret = await hookFn();
+            resolve(ret);
+        }
+        catch (err) {
+            if (isObject(err)) {
+                globalObject.userHookErrors.set(err, { hookName, hookFilePath });
+            }
+            reject(err);
+        }
+    })();
+    return promise;
+}
+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/esm/shared/hooks/getHook.d.ts

@@ -0,0 +1,24 @@
+export { getHook };
+export { assertHook };
+export { assertHookFn };
+export type { Hook };
+export type { HookName };
+export type { HookLoc };
+import { PageContextExports } from '../getPageFiles.js';
+import type { HookName } from '../page-configs/Config.js';
+type Hook = HookLoc & {
+    hookFn: HookFn;
+};
+type HookLoc = {
+    hookName: HookName;
+    hookFilePath: string;
+};
+type HookFn = (arg: unknown) => unknown;
+declare function getHook(pageContext: PageContextExports, hookName: HookName): null | Hook;
+declare function assertHook<TPageContext extends PageContextExports, THookName extends PropertyKey & HookName>(pageContext: TPageContext, hookName: THookName): asserts pageContext is TPageContext & {
+    exports: Record<THookName, Function | undefined>;
+};
+declare function assertHookFn(hookFn: unknown, { hookName, hookFilePath }: {
+    hookName: HookName;
+    hookFilePath: string;
+}): asserts hookFn is HookFn;

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

@@ -0,0 +1,26 @@
+export { getHook };
+export { assertHook };
+export { assertHookFn };
+import { assert, assertUsage, checkType, isCallable } from '../utils.js';
+function getHook(pageContext, hookName) {
+    if (!(hookName in pageContext.exports)) {
+        return null;
+    }
+    const hookFn = pageContext.exports[hookName];
+    const file = pageContext.exportsAll[hookName][0];
+    assert(file.exportValue === hookFn);
+    if (hookFn === null)
+        return null;
+    const hookFilePath = file.exportSource;
+    assertHookFn(hookFn, { hookName, hookFilePath });
+    return { hookFn, hookName, hookFilePath };
+}
+function assertHook(pageContext, hookName) {
+    getHook(pageContext, hookName);
+}
+function assertHookFn(hookFn, { hookName, hookFilePath }) {
+    assert(hookName && hookFilePath);
+    assert(!hookName.endsWith(')'));
+    assertUsage(isCallable(hookFn), `hook ${hookName}() defined by ${hookFilePath} should be a function`);
+    checkType(hookFn);
+}

package/dist/esm/shared/notSerializable.d.ts

@@ -0,0 +1 @@
+export declare const notSerializable = "not-serializable";

package/dist/esm/shared/notSerializable.js

@@ -0,0 +1,2 @@
+// TODO: move to ../node/runtime/html/notSerializable.ts once code is distributed as ESM
+export const notSerializable = 'not-serializable';

package/dist/esm/shared/page-configs/Config/PageContextConfig.d.ts

@@ -0,0 +1,8 @@
+export type { PageContextConfig };
+import type { VikePackages } from '../../VikeNamespace.js';
+import type { ConfigBuiltIn } from '../Config.js';
+import type { Combine, IsNotEmpty, XOR4 } from './helpers.ts';
+type PageContextConfig = ConfigBuiltIn & (ConfigVikePackagesNotEmptyXor extends true ? ConfigVikePackagesIntersection : ConfigVikePackagesCombined);
+type ConfigVikePackagesIntersection = VikePackages.ConfigVikeReact & VikePackages.ConfigVikeVue & VikePackages.ConfigVikeSolid & VikePackages.ConfigVikeSvelte;
+type ConfigVikePackagesCombined = Combine<VikePackages.ConfigVikeReact, Combine<VikePackages.ConfigVikeVue, Combine<VikePackages.ConfigVikeSolid, VikePackages.ConfigVikeSvelte>>>;
+type ConfigVikePackagesNotEmptyXor = XOR4<IsNotEmpty<VikePackages.ConfigVikeReact>, IsNotEmpty<VikePackages.ConfigVikeVue>, IsNotEmpty<VikePackages.ConfigVikeSolid>, IsNotEmpty<VikePackages.ConfigVikeSvelte>>;

package/dist/esm/shared/page-configs/Config/PageContextConfig.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/shared/page-configs/Config/helpers.d.ts

@@ -0,0 +1,10 @@
+export type { IsNotEmpty };
+export type { XOR4 };
+export type { Combine };
+type IsNotEmpty<T> = Not<IsEmpty<T>>;
+type IsEmpty<T> = keyof T extends never ? true : false;
+type Combine<T1, T2> = {
+    [K in keyof T1 | keyof T2]?: (K extends keyof T1 ? T1[K] : never) | (K extends keyof T2 ? T2[K] : never);
+};
+type XOR4<T1 extends boolean, T2 extends boolean, T3 extends boolean, T4 extends boolean> = (T1 extends true ? T2 extends true ? false : T3 extends true ? false : Not<T4> : T2 extends true ? T3 extends true ? false : Not<T4> : T3 extends true ? Not<T4> : T4);
+type Not<T extends boolean> = T extends true ? false : true;

package/dist/esm/shared/page-configs/Config/helpers.js

@@ -0,0 +1 @@
+export {};