vike 0.4.228 → 0.4.229

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

@@ -3,33 +3,55 @@ export type { VikePackages };
 declare global {
     /** Refine Vike types. */
     namespace Vike {
-        /** Extend and/or refine the `Config` type (`import type { Config } from 'vike/types'`).
-         *
-         *  For example:
-         *  - You can refine the type of `Config['Page']`.
-         *  - You can define the type of custom configurations created with `config.meta` (https://vike.dev/meta)
+        /** Extend the `Config` type (`import type { Config } from 'vike/types'`).
          *
          *  https://vike.dev/meta#typescript
          */
         interface Config {
         }
-        /** Extend and/or refine the `PageContext` type (`import type { PageContext } from 'vike/types'`).
+        /** Refine the `pageContext.config` type.
          *
-         *  For example:
-         *  - You can refine the type of `PageContext['Page']`.
-         *  - You can define the type of custom `pageContext` values such as `pageContext.user`, see https://vike.dev/pageContext#custom
+         *  It's used for cumulative configs: the `pageContext.config[configName]` type is an `array` whereas `Config[configName]` isn't.
+         *
+         *  https://vike.dev/meta#typescript
+         */
+        interface ConfigResolved {
+        }
+        /** Extend the `PageContext` type (`import type { PageContext } from 'vike/types'`).
          *
          *  https://vike.dev/pageContext#typescript
          */
         interface PageContext {
         }
-        /** Refine the `pageContext.config` type.
+        /** Extend the `PageContextClient` type (`import type { PageContextClient } from 'vike/types'`).
          *
-         *  It's used for cumulative configs: the `pageContext.config[configName]` type is an `array` whereas `Config[configName]` isn't.
+         *  https://vike.dev/pageContext#typescript
+         */
+        interface PageContextClient {
+        }
+        /** Extend the `PageContextServer` type (`import type { PageContextServer } from 'vike/types'`).
          *
-         *  https://vike.dev/meta#typescript
+         *  https://vike.dev/pageContext#typescript
          */
-        interface ConfigResolved {
+        interface PageContextServer {
+        }
+        /** Extend the `GlobalContext` type (`import type { GlobalContext } from 'vike/types'`).
+         *
+         *  https://vike.dev/globalContext#typescript
+         */
+        interface GlobalContext {
+        }
+        /** Extend the `GlobalContextClient` type (`import type { GlobalContextClient } from 'vike/types'`).
+         *
+         *  https://vike.dev/globalContext#typescript
+         */
+        interface GlobalContextClient {
+        }
+        /** Extend the `GlobalContextServer` type (`import type { GlobalContextServer } from 'vike/types'`).
+         *
+         *  https://vike.dev/globalContext#typescript
+         */
+        interface GlobalContextServer {
         }
     }
     /** This namespace is only used by:

package/dist/esm/shared/assertPageContextProvidedByUser.js

@@ -7,7 +7,7 @@ function assertPageContextProvidedByUser(pageContextProvidedByUser, { hookName,
     assert(!hookName.endsWith(')'));
     const errPrefix = `The ${pc.cyan('pageContext')} object provided by the ${hookName}() hook defined by ${hookFilePath}`;
     assertUsage(isObject(pageContextProvidedByUser), `${errPrefix} should be an object (but it's ${pc.cyan(`typeof pageContext === ${JSON.stringify(typeof pageContextProvidedByUser)}`)} instead)`);
-    assertUsage(!('_objectCreatedByVike' in pageContextProvidedByUser), `${errPrefix} shouldn't be the whole ${pc.cyan('pageContext')} object, see https://vike.dev/pageContext-manipulation#do-not-return-entire-pagecontext`);
+    assertUsage(!('isPageContext' in pageContextProvidedByUser), `${errPrefix} shouldn't be the whole ${pc.cyan('pageContext')} object, see https://vike.dev/pageContext-manipulation#do-not-return-entire-pagecontext`);
     // In principle, it's possible to use onBeforeRoute()` to override and define the whole routing.
     // Is that a good idea to allow users to do this? Beyond deep integration with Vue Router or React Router, is there a use case for this?
     assertWarning(!('pageId' in pageContextProvidedByUser), `${errPrefix} sets ${pc.cyan('pageContext.pageId')} which means that Vike's routing is overriden. This is an experimental feature: make sure to contact a vike maintainer before using this.`, { onlyOnce: true });

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

@@ -0,0 +1,39 @@
+export { createGlobalContextShared };
+export { getGlobalContextSyncErrMsg };
+export type { GlobalContextShared };
+export type { GlobalContextSharedPublic };
+declare const getGlobalContextSyncErrMsg = "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContext() instead.";
+declare function createGlobalContextShared<GlobalContextAddendum extends object>(virtualFileExports: unknown, globalObject: {
+    globalContext?: Record<string, unknown>;
+}, addGlobalContext?: (globalContext: GlobalContextShared) => Promise<GlobalContextAddendum>): Promise<{
+    /**
+     * Useful for distinguishing `globalContext` from other objects and narrowing down TypeScript unions.
+     *
+     * https://vike.dev/globalContext#typescript
+     */
+    isGlobalContext: true;
+    _virtualFileExports: unknown;
+    _pageFilesAll: import("./getPageFiles.js").PageFile[];
+    _pageConfigs: import("./page-configs/PageConfig.js").PageConfigRuntime[];
+    _pageConfigGlobal: import("./page-configs/PageConfig.js").PageConfigGlobalRuntime;
+    _allPageIds: string[];
+    config: import("./page-configs/Config/PageContextConfig.js").ConfigResolved;
+    pages: import("./page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+} & Awaited<GlobalContextAddendum>>;
+type GlobalContextSharedPublic = Pick<GlobalContextShared, 'config' | 'pages' | 'isGlobalContext'>;
+type GlobalContextShared = ReturnType<typeof createGlobalContextBase>;
+declare function createGlobalContextBase(virtualFileExports: unknown): {
+    /**
+     * Useful for distinguishing `globalContext` from other objects and narrowing down TypeScript unions.
+     *
+     * https://vike.dev/globalContext#typescript
+     */
+    isGlobalContext: true;
+    _virtualFileExports: unknown;
+    _pageFilesAll: import("./getPageFiles.js").PageFile[];
+    _pageConfigs: import("./page-configs/PageConfig.js").PageConfigRuntime[];
+    _pageConfigGlobal: import("./page-configs/PageConfig.js").PageConfigGlobalRuntime;
+    _allPageIds: string[];
+    config: import("./page-configs/Config/PageContextConfig.js").ConfigResolved;
+    pages: import("./page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+};

package/dist/esm/shared/createGlobalContextShared.js

@@ -0,0 +1,51 @@
+export { createGlobalContextShared };
+export { getGlobalContextSyncErrMsg };
+const getGlobalContextSyncErrMsg = "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContext() instead.";
+import { getPageConfigsRuntime } from './getPageConfigsRuntime.js';
+import { executeHookGenericGlobalCumulative } from './hooks/executeHookGeneric.js';
+import { objectAssign } from './utils.js';
+async function createGlobalContextShared(virtualFileExports, globalObject, addGlobalContext) {
+    const globalContext = createGlobalContextBase(virtualFileExports);
+    const globalContextAddendum = await addGlobalContext?.(globalContext);
+    objectAssign(globalContext, globalContextAddendum);
+    if (!globalObject.globalContext) {
+        globalObject.globalContext = globalContext;
+        // - We deliberately call onCreateGlobalContext() only at the beginning and only once per process.
+        // - TO-DO/eventually: HMR
+        //    - Once Photon supports it: `server.hot.send({ type: 'full-server-reload' })`
+        //    - Either use:
+        //      - import.meta.hot
+        //        - https://vite.dev/guide/api-hmr.html
+        //        - Use a Vite transformer to inject import.meta.hot code into each user-land `+onCreateGlobalContext.js` file
+        //        - Seems more idiomatic
+        //      - globalContext._viteDevServer.hot.send()
+        //        - Send 'full-server-reload' signal whenever a onCreateGlobalContext() function is modified => we need a globalObject to track all hooks and see if one of them is new/modified.
+        //        - Seems less idiomatic
+        await executeHookGenericGlobalCumulative('onCreateGlobalContext', globalContext._pageConfigGlobal, null, globalContext);
+    }
+    else {
+        // Singleton: ensure all `globalContext` user-land references are preserved & updated.
+        // We don't use objectReplace() in order to keep user-land properties.
+        objectAssign(globalObject.globalContext, globalContext);
+    }
+    return globalObject.globalContext;
+}
+function createGlobalContextBase(virtualFileExports) {
+    const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal, globalConfig, pageConfigsUserFriendly } = getPageConfigsRuntime(virtualFileExports);
+    const globalContext = {
+        /**
+         * Useful for distinguishing `globalContext` from other objects and narrowing down TypeScript unions.
+         *
+         * https://vike.dev/globalContext#typescript
+         */
+        isGlobalContext: true,
+        _virtualFileExports: virtualFileExports,
+        _pageFilesAll: pageFilesAll,
+        _pageConfigs: pageConfigs,
+        _pageConfigGlobal: pageConfigGlobal,
+        _allPageIds: allPageIds,
+        config: globalConfig.config,
+        pages: pageConfigsUserFriendly
+    };
+    return globalContext;
+}

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

@@ -0,0 +1,9 @@
+export { createPageContextShared };
+import type { PageConfigGlobalRuntime } from './page-configs/PageConfig.js';
+declare function createPageContextShared<T extends object>(pageContextCreated: T, pageConfigGlobal: PageConfigGlobalRuntime): Promise<T & {
+    config: import("./page-configs/Config/PageContextConfig.js").ConfigResolved;
+    _source: import("./page-configs/getPageConfigUserFriendly.js").Source;
+    _sources: import("./page-configs/getPageConfigUserFriendly.js").Sources;
+    _from: import("./page-configs/getPageConfigUserFriendly.js").From;
+    isPageContext: true;
+}>;

package/dist/esm/shared/createPageContextShared.js

@@ -0,0 +1,15 @@
+export { createPageContextShared };
+import { executeHookGenericGlobalCumulative } from './hooks/executeHookGeneric.js';
+import { getPageConfigGlobalUserFriendly } from './page-configs/getPageConfigUserFriendly.js';
+import { objectAssign } from './utils.js';
+async function createPageContextShared(pageContextCreated, pageConfigGlobal) {
+    const pageConfigGlobalUserFriendly = getPageConfigGlobalUserFriendly({
+        pageConfigGlobalValues: pageConfigGlobal.configValues
+    });
+    objectAssign(pageContextCreated, {
+        isPageContext: true,
+        ...pageConfigGlobalUserFriendly
+    }, true);
+    await executeHookGenericGlobalCumulative('onCreatePageContext', pageConfigGlobal, pageContextCreated, pageContextCreated);
+    return pageContextCreated;
+}

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

@@ -22,7 +22,7 @@ function determineFileType(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
+            assert(isImportPathNpmPackage(filePath), filePath) // `.css` page files are only supported for npm packages
             */
             return '.css';
         }

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

@@ -0,0 +1,8 @@
+export { executeHookGeneric };
+export { executeHookGenericGlobalCumulative };
+import type { PageConfigUserFriendlyOld } from '../getPageFiles.js';
+import { type HookName } from './getHook.js';
+import type { HookNameGlobal } from '../page-configs/Config.js';
+import type { PageConfigGlobalRuntime } from '../page-configs/PageConfig.js';
+declare function executeHookGeneric(hookName: HookName, pageContext: PageConfigUserFriendlyOld): Promise<void>;
+declare function executeHookGenericGlobalCumulative(hookName: HookNameGlobal, pageConfigGlobal: PageConfigGlobalRuntime, pageContext: object | null, arg: object): Promise<void>;

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

@@ -0,0 +1,16 @@
+export { executeHookGeneric }; // TO-DO/refactor: start using executeHookGeneric() and, eventually, prominently use it
+export { executeHookGenericGlobalCumulative };
+import { executeHook } from './executeHook.js';
+import { getHookFromPageContext, getHookFromPageConfigGlobalCumulative } from './getHook.js';
+async function executeHookGeneric(hookName, pageContext) {
+    const hook = getHookFromPageContext(pageContext, hookName);
+    if (!hook)
+        return;
+    await executeHook(() => hook.hookFn(pageContext), hook, pageContext);
+}
+async function executeHookGenericGlobalCumulative(hookName, pageConfigGlobal, pageContext, arg) {
+    const hooks = getHookFromPageConfigGlobalCumulative(pageConfigGlobal, hookName);
+    await Promise.all(hooks.map(async (hook) => {
+        await executeHook(() => hook.hookFn(arg), hook, pageContext);
+    }));
+}

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

@@ -1,6 +1,7 @@
-export { getHook };
+export { getHookFromPageContext };
 export { getHookFromPageConfig };
 export { getHookFromPageConfigGlobal };
+export { getHookFromPageConfigGlobalCumulative };
 export { assertHook };
 export { getHook_setIsPrerenderering };
 export type { Hook };
@@ -20,15 +21,16 @@ type HookLoc = {
     hookName: HookName;
     hookFilePath: string;
 };
-type HookFn = (arg: unknown) => unknown;
+type HookFn = (arg: object) => unknown;
 type HookTimeout = {
     error: number | false;
     warning: number | false;
 };
 type HooksTimeoutProvidedByUser = false | Partial<Record<HookName, false | Partial<HookTimeout>>>;
-declare function getHook(pageContext: PageConfigUserFriendlyOld, hookName: HookName): null | Hook;
+declare function getHookFromPageContext(pageContext: PageConfigUserFriendlyOld, hookName: HookName): null | Hook;
 declare function getHookFromPageConfig(pageConfig: PageConfigRuntime, hookName: HookNamePage): null | Hook;
 declare function getHookFromPageConfigGlobal(pageConfigGlobal: PageConfigGlobalRuntime, hookName: HookNameGlobal): null | Hook;
+declare function getHookFromPageConfigGlobalCumulative(pageConfigGlobal: PageConfigGlobalRuntime, hookName: HookNameGlobal): Hook[];
 declare function assertHook<TPageContext extends PageConfigUserFriendlyOld, THookName extends PropertyKey & HookName>(pageContext: TPageContext, hookName: THookName): asserts pageContext is TPageContext & {
     exports: Record<THookName, Function | undefined>;
 };

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

@@ -1,70 +1,88 @@
-export { getHook };
+export { getHookFromPageContext };
 export { getHookFromPageConfig };
 export { getHookFromPageConfigGlobal };
+export { getHookFromPageConfigGlobalCumulative };
 export { assertHook };
 export { getHook_setIsPrerenderering };
 // TODO/v1-release: remove
-// We export for old V0.4 design which doesn't support configooksTimeout
+// We export for old V0.4 design which doesn't support config.hooksTimeout
 export { getHookTimeoutDefault };
 import { getGlobalObject } from '../../utils/getGlobalObject.js';
 import { getHookFilePathToShowToUser } from '../page-configs/helpers.js';
 import { getConfigValueRuntime } from '../page-configs/getConfigValueRuntime.js';
-import { assert, assertUsage, checkType, isCallable, isObject } from '../utils.js';
+import { assert, assertUsage, checkType, isArray, isCallable, isObject } from '../utils.js';
 import pc from '@brillout/picocolors';
 const globalObject = getGlobalObject('hooks/getHook.ts', {});
-function getHook(pageContext, hookName) {
+function getHookFromPageContext(pageContext, hookName) {
     if (!(hookName in pageContext.exports)) {
         return null;
     }
     const { hooksTimeout } = pageContext.config;
     const hookTimeout = getHookTimeout(hooksTimeout, hookName);
     const hookFn = pageContext.exports[hookName];
-    const file = pageContext.exportsAll[hookName][0];
-    assert(file.exportValue === hookFn);
     if (hookFn === null)
         return null;
+    const file = pageContext.exportsAll[hookName][0];
+    assert(file.exportValue === hookFn);
     const hookFilePath = file.filePath;
     assert(hookFilePath);
-    assert(!hookFilePath.endsWith(' '));
-    assertHookFn(hookFn, { hookName, hookFilePath });
-    return { hookFn, hookName, hookFilePath, hookTimeout };
+    return getHook(hookFn, hookName, hookFilePath, hookTimeout);
 }
 function getHookFromPageConfig(pageConfig, hookName) {
     const configValue = getConfigValueRuntime(pageConfig, hookName);
-    const hooksTimeout = getConfigValueRuntime(pageConfig, 'hooksTimeout')?.value;
-    if (!configValue)
+    if (!configValue?.value)
         return null;
-    const hookFn = configValue.value;
-    if (!hookFn)
-        return null;
-    const hookFilePath = getHookFilePathToShowToUser(configValue.definedAtData);
-    // hook isn't a computed nor a cumulative config => hookFilePath should always be defined
-    assert(hookFilePath);
-    assertHookFn(hookFn, { hookName, hookFilePath });
+    const { hookFn, hookFilePath } = getHookFromConfigValue(configValue);
+    const hooksTimeout = getConfigValueRuntime(pageConfig, 'hooksTimeout')?.value;
     const hookTimeout = getHookTimeout(hooksTimeout, hookName);
-    return { hookFn, hookName, hookFilePath, hookTimeout };
+    return getHook(hookFn, hookName, hookFilePath, hookTimeout);
 }
 function getHookFromPageConfigGlobal(pageConfigGlobal, hookName) {
     const configValue = pageConfigGlobal.configValues[hookName];
-    if (!configValue)
-        return null;
-    const hookFn = configValue.value;
-    if (!hookFn)
+    if (!configValue?.value)
         return null;
-    const hookFilePath = getHookFilePathToShowToUser(configValue.definedAtData);
-    // hook isn't a computed nor a cumulative config => hookFilePath should always be defined
+    const { hookFn, hookFilePath } = getHookFromConfigValue(configValue);
+    const hookTimeout = getHookTimeoutGlobal(hookName);
+    return getHook(hookFn, hookName, hookFilePath, hookTimeout);
+}
+function getHookFromPageConfigGlobalCumulative(pageConfigGlobal, hookName) {
+    const configValue = pageConfigGlobal.configValues[hookName];
+    if (!configValue?.value)
+        return [];
+    const val = configValue.value;
+    assert(isArray(val));
+    return val.map((v, i) => {
+        const hookFn = v;
+        const hookTimeout = getHookTimeoutGlobal(hookName);
+        assert(isArray(configValue.definedAtData));
+        const hookFilePath = getHookFilePathToShowToUser(configValue.definedAtData[i]);
+        return getHook(hookFn, hookName, hookFilePath, hookTimeout);
+    });
+}
+function getHookTimeoutGlobal(hookName) {
+    // TO-DO/perfection: we could use the global value of configooksTimeout but it requires some non-trivial refactoring
+    const hookTimeout = getHookTimeoutDefault(hookName);
+    return hookTimeout;
+}
+function getHook(hookFn, hookName, hookFilePath, hookTimeout) {
     assert(hookFilePath);
     assertHookFn(hookFn, { hookName, hookFilePath });
-    // We could use the global value of configooksTimeout but it requires some non-trivial refactoring
-    const hookTimeout = getHookTimeoutDefault(hookName);
-    return { hookFn, hookName, hookFilePath, hookTimeout };
+    const hook = { hookFn, hookName, hookFilePath, hookTimeout };
+    return hook;
+}
+function getHookFromConfigValue(configValue) {
+    const hookFn = configValue.value;
+    assert(hookFn);
+    const hookFilePath = getHookFilePathToShowToUser(configValue.definedAtData);
+    return { hookFn, hookFilePath };
 }
 function assertHook(pageContext, hookName) {
-    getHook(pageContext, hookName);
+    getHookFromPageContext(pageContext, hookName);
 }
 function assertHookFn(hookFn, { hookName, hookFilePath }) {
     assert(hookName && hookFilePath);
     assert(!hookName.endsWith(')'));
+    assert(!hookFilePath.endsWith(' '));
     assertUsage(isCallable(hookFn), `Hook ${hookName}() defined by ${hookFilePath} should be a function`);
     checkType(hookFn);
 }

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

@@ -0,0 +1,2 @@
+export declare const htmlElementId_pageContext = "vike_pageContext";
+export declare const htmlElementId_globalContext = "vike_globalContext";

package/dist/esm/shared/htmlElementIds.js

@@ -0,0 +1,2 @@
+export const htmlElementId_pageContext = 'vike_pageContext';
+export const htmlElementId_globalContext = 'vike_globalContext';

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

@@ -41,11 +41,11 @@ import type { InjectFilterEntry } from '../../types/index.js';
 import type { VikeVitePluginOptions } from '../../node/plugin/index.js';
 import type { Vike, VikePackages } from '../VikeNamespace.js';
 import type { HooksTimeoutProvidedByUser } from '../hooks/getHook.js';
-import type { PageContextClient, PageContextServer } from '../types.js';
+import type { GlobalContext, PageContextClient, PageContextServer } from '../types.js';
 import type { InlineConfig } from 'vite';
 type HookName = HookNamePage | HookNameGlobal | HookNameOldDesign;
 type HookNamePage = 'onHydrationEnd' | 'onBeforePrerenderStart' | 'onBeforeRender' | 'onPageTransitionStart' | 'onPageTransitionEnd' | 'onRenderHtml' | 'onRenderClient' | 'guard' | 'data';
-type HookNameGlobal = 'onBeforePrerender' | 'onBeforeRoute' | 'onPrerenderStart';
+type HookNameGlobal = 'onBeforePrerender' | 'onBeforeRoute' | 'onPrerenderStart' | 'onCreatePageContext' | 'onCreateGlobalContext';
 type HookNameOldDesign = 'render' | 'prerender';
 type ConfigNameBuiltIn = Exclude<keyof Config, keyof VikeVitePluginOptions | 'onBeforeRoute' | 'onPrerenderStart' | 'vite' | 'redirects'> | 'prerender' | 'isClientRuntimeLoaded' | 'onBeforeRenderEnv' | 'dataEnv' | 'hooksTimeout' | 'clientHooks' | 'middleware';
 type ConfigNameGlobal = 'onPrerenderStart' | 'onBeforeRoute' | 'prerender' | 'disableAutoFullBuild' | 'includeAssetsImportedByServer' | 'baseAssets' | 'baseServer' | 'redirects' | 'trailingSlash' | 'disableUrlNormalization' | 'vite';
@@ -330,6 +330,16 @@ type ConfigBuiltIn = {
      *  https://vike.dev/onBeforeRender
      */
     onBeforeRender?: OnBeforeRenderAsync | OnBeforeRenderSync | ImportString | null;
+    /** Hook called when a `pageContext` object is created.
+     *
+     *  https://vike.dev/onCreatePageContext
+     */
+    onCreatePageContext?: ((pageContext: PageContextServer) => void) | ImportString | null;
+    /** Hook called when the `globalContext` object is created.
+     *
+     *  https://vike.dev/onCreateGlobalContext
+     */
+    onCreateGlobalContext?: ((globalContext: GlobalContext) => void) | ImportString | null;
     /** Hook for fetching data.
      *
      *  https://vike.dev/data

package/dist/esm/shared/page-configs/getConfigDefinedAt.d.ts

@@ -10,4 +10,4 @@ type ConfigDefinedAt = `Config ${string} defined at ${string}`;
 declare function getConfigDefinedAt<SentenceBegin extends 'Config' | 'config', ConfigName extends string>(sentenceBegin: SentenceBegin, configName: ConfigName, definedAtData: NonNullable<DefinedAtData>): `${SentenceBegin} ${ConfigName} defined at ${string}`;
 declare function getConfigDefinedAtOptional<SentenceBegin extends 'Config' | 'config', ConfigName extends string>(sentenceBegin: SentenceBegin, configName: ConfigName, definedAtData: DefinedAtData): `${SentenceBegin} ${ConfigName} defined ${'internally' | `at ${string}`}`;
 declare function getDefinedAtString(definedAtData: NonNullable<DefinedAtData>, configName: string): string;
-declare function getDefinedByString(definedAt: DefinedBy, configName: string): `API call dev({ vikeConfig: { ${string} } })` | `API call build({ vikeConfig: { ${string} } })` | `API call preview({ vikeConfig: { ${string} } })` | `API call prerender({ vikeConfig: { ${string} } })` | `CLI option --${string}` | `environment variable VIKE_CONFIG="{${string}}"`;
+declare function getDefinedByString(definedAt: DefinedBy, configName: string): `API call ${string}({ vikeConfig: { ${string} } })` | `CLI option --${string}` | `environment variable VIKE_CONFIG="{${string}}"`;

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

@@ -2,8 +2,8 @@ export { serializeConfigValues };
 export { getConfigValuesBase };
 export { isJsonValue };
 import { assertIsNotProductionRuntime } from '../../../utils/assertSetup.js';
-import { assert, assertPosixPath, assertUsage, deepEqual, getPropAccessNotation } from '../../../node/plugin/utils.js';
-import { parsePointerImportData } from '../../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/transformPointerImports.js';
+import { assert, assertPosixPath, assertUsage, deepEqual, getPropAccessNotation, isImportPathRelative } from '../../../node/plugin/utils.js';
+import { parsePointerImportData } from '../../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/pointerImports.js';
 import { getConfigValueFilePathToShowToUser } from '../helpers.js';
 import { stringify } from '@brillout/json-serializer/stringify';
 import pc from '@brillout/picocolors';
@@ -264,10 +264,10 @@ function addImportStatement(importStatements, importPath, exportName, filesEnv,
     return { importName };
 }
 function assertFileEnv(importPath, configEnv, configName, filesEnv) {
+    assert(!isImportPathRelative(importPath));
     const key = importPath;
     assert(key);
     assertPosixPath(key);
-    assert(!isRelativeImportPath(key));
     if (!filesEnv.has(key)) {
         filesEnv.set(key, []);
     }
@@ -283,7 +283,3 @@ function assertFileEnv(importPath, configEnv, configName, filesEnv) {
         ].join('\n'));
     }
 }
-// TODO/now dedupe
-function isRelativeImportPath(importPath) {
-    return importPath.startsWith('./') || importPath.startsWith('../');
-}

package/dist/esm/shared/route/executeGuardHook.js

@@ -1,5 +1,5 @@
 export { executeGuardHook };
-import { getHook, getHookTimeoutDefault } from '../hooks/getHook.js';
+import { getHookFromPageContext, getHookTimeoutDefault } from '../hooks/getHook.js';
 import { assert, assertUsage, isCallable } from './utils.js';
 import { executeHook } from '../hooks/executeHook.js';
 const errIntro = 'The guard() hook defined by';
@@ -12,7 +12,7 @@ async function executeGuardHook(pageContext, prepareForUserConsumption) {
     }
     else {
         // V1 design
-        hook = getHook(pageContext, 'guard');
+        hook = getHookFromPageContext(pageContext, 'guard');
     }
     if (!hook)
         return;

package/dist/esm/shared/route/loadPageRoutes.js

@@ -8,7 +8,7 @@ import { getDefinedAtString } from '../page-configs/getConfigDefinedAt.js';
 import { warnDeprecatedAllowKey } from './resolveRouteFunction.js';
 import { getHookFromPageConfigGlobal, getHookTimeoutDefault } from '../hooks/getHook.js';
 async function loadPageRoutes(
-// Remove all arguments and use GlobalContextInternal instead?
+// Remove all arguments and use GlobalContextServerInternal instead?
 pageFilesAll, pageConfigs, pageConfigGlobal, allPageIds) {
     // TODO/next-major: remove & make this function sync
     await Promise.all(pageFilesAll.filter((p) => p.fileType === '.page.route').map((p) => p.loadFile?.()));
@@ -45,6 +45,7 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
                     }
                     else {
                         assert(isCallable(route));
+                        // TODO/next-major: remove
                         if (getConfigValueRuntime(pageConfig, 'iKnowThePerformanceRisksOfAsyncRouteFunctions', 'boolean'))
                             warnDeprecatedAllowKey();
                         pageRoute = {