vike 0.4.247 → 0.4.248

package/dist/node/vite/shared/resolveVikeConfigInternal/configDefinitionsBuiltIn.js

@@ -0,0 +1,289 @@
+export { configDefinitionsBuiltIn };
+import { assert, assertUsage } from '../../utils.js';
+import { getConfigDefinedAt, } from '../../../../shared-server-client/page-configs/getConfigDefinedAt.js';
+import { getConfigValueSourceRelevantAnyEnv, getConfigValueSourcesRelevant, isConfigSourceValueNull, } from '../../plugins/pluginVirtualFiles/getConfigValueSourcesRelevant.js';
+const configDefinitionsBuiltIn = {
+    onRenderHtml: {
+        env: { server: true },
+    },
+    onRenderClient: {
+        env: { client: true },
+    },
+    onHydrationEnd: {
+        env: { client: true },
+    },
+    onPageTransitionStart: {
+        env: { client: true },
+    },
+    onPageTransitionEnd: {
+        env: { client: true },
+    },
+    onCreatePageContext: {
+        env: { server: true, client: true },
+        cumulative: true,
+    },
+    onCreateGlobalContext: {
+        env: { server: true, client: true },
+        global: true,
+        cumulative: true,
+    },
+    onError: {
+        env: { server: true },
+        global: true,
+        cumulative: true,
+    },
+    onBeforeRender: {
+        env: { server: true },
+    },
+    onBeforePrerenderStart: {
+        env: { server: true, production: true },
+    },
+    Page: {
+        env: { server: true, client: true },
+    },
+    passToClient: {
+        env: { server: true },
+        cumulative: true,
+    },
+    route: {
+        env: {
+            server: true,
+            client: 'if-client-routing',
+            // For vite-plugin-vercel
+            config: true,
+        },
+        eager: true,
+    },
+    guard: {
+        env: { server: true, client: 'if-client-routing' },
+    },
+    data: {
+        env: { server: true },
+    },
+    onData: {
+        env: { server: true, client: true },
+        cumulative: true,
+    },
+    iKnowThePerformanceRisksOfAsyncRouteFunctions: {
+        env: { server: true, client: 'if-client-routing' },
+        eager: true,
+    },
+    filesystemRoutingRoot: {
+        env: { config: true },
+    },
+    client: {
+        // The value of the client config is merely the file path to the client entry file, which is only needed on the sever-side
+        env: { server: true, config: true },
+        _valueIsFilePath: true,
+    },
+    clientRouting: {
+        // We could make it { client: false } but we don't yet because of some legacy V0.4 design code
+        env: { server: true, client: true, config: true },
+        eager: true,
+    },
+    clientHooks: {
+        env: { config: true },
+    },
+    hydrationCanBeAborted: {
+        env: { client: true },
+    },
+    prefetch: {
+        env: { client: true },
+        eager: true,
+    },
+    // TO-DO/next-major-release: remove
+    prefetchStaticAssets: {
+        env: { client: true },
+    },
+    extends: {
+        env: { config: true },
+    },
+    meta: {
+        env: { config: true },
+    },
+    hasServerOnlyHook: {
+        env: { client: true },
+        eager: true,
+        _computed: (pageConfig) => {
+            const sources = ['data', 'onBeforeRender', 'onCreatePageContext', 'guard']
+                .map((hookName) => getConfigValueSourcesRelevant(hookName, {
+                isForClientSide: false,
+                // TO-DO/eventually/remove-server-router: let's eventually remove support for Server Routing
+                isClientRouting: true,
+            }, pageConfig))
+                .flat(1)
+                // Server-only
+                .filter((source) => !source.configEnv.client)
+                // Exclude `.ssr.js` hooks (they don't require pageContext.json requests)
+                .filter((source) => {
+                const { definedAt } = source;
+                if ('filePathAbsoluteVite' in definedAt && definedAt.filePathAbsoluteVite.includes('.ssr.')) {
+                    return false;
+                }
+                return true;
+            })
+                // Config value isn't `null`
+                .filter((source) => !isConfigSourceValueNull(source));
+            return sources.length > 0;
+        },
+    },
+    // Whether the page loads:
+    //  - Vike's client runtime
+    //  - User's client hooks
+    // In other words, whether the page is "HTML-only" (https://vike.dev/render-modes). HTML-only pages shouldn't load the client runtime nor client hooks.
+    isClientRuntimeLoaded: {
+        env: { server: true, client: true },
+        eager: true,
+        _computed: (pageConfig) => {
+            {
+                const source = getConfigValueSourceRelevantAnyEnv('clientHooks', pageConfig);
+                if (source) {
+                    assert(source.valueIsLoaded);
+                    const { value, definedAt } = source;
+                    const configDefinedAt = getConfigDefinedAt('Config', 'clientHooks', definedAt);
+                    assertUsage(typeof value === 'boolean', `${configDefinedAt} should be a boolean`);
+                    return value;
+                }
+            }
+            return (isConfigSet(pageConfig, 'onRenderClient') &&
+                isConfigSet(pageConfig, 'Page') &&
+                !!getConfigEnv(pageConfig, 'Page')?.client);
+        },
+    },
+    // TO-DO/soon/cumulative-hooks: remove and replace with new computed prop `clientOnlyHooks: string[]` (see other TO-DO/soon/cumulative-hooks comments)
+    onBeforeRenderEnv: {
+        env: { client: true },
+        eager: true,
+        _computed: (pageConfig) => {
+            return !isConfigSet(pageConfig, 'onBeforeRender') ? null : getConfigEnv(pageConfig, 'onBeforeRender');
+        },
+    },
+    // TO-DO/soon/cumulative-hooks: remove and replace with new computed prop `clientOnlyHooks: string[]` (see other TO-DO/soon/cumulative-hooks comments)
+    dataEnv: {
+        env: { client: true },
+        eager: true,
+        _computed: (pageConfig) => {
+            return !isConfigSet(pageConfig, 'data') ? null : getConfigEnv(pageConfig, 'data');
+        },
+    },
+    // TO-DO/soon/cumulative-hooks: remove and replace with new computed prop `clientOnlyHooks: string[]` (see other TO-DO/soon/cumulative-hooks comments)
+    guardEnv: {
+        env: { client: true },
+        eager: true,
+        _computed: (pageConfig) => {
+            return !isConfigSet(pageConfig, 'guard') ? null : getConfigEnv(pageConfig, 'guard');
+        },
+    },
+    hooksTimeout: {
+        env: { server: true, client: true },
+    },
+    cacheControl: {
+        env: { server: true },
+    },
+    host: {
+        env: { config: true },
+        global: true,
+    },
+    port: {
+        env: { config: true },
+        global: true,
+    },
+    mode: {
+        env: { config: true },
+        global: true,
+    },
+    force: {
+        env: { config: true },
+        global: true,
+    },
+    csp: {
+        env: { server: true },
+    },
+    injectScriptsAt: {
+        env: { server: true },
+    },
+    name: {
+        env: { config: true },
+    },
+    require: {
+        env: { config: true },
+    },
+    keepScrollPosition: {
+        env: { client: true },
+    },
+    middleware: { env: { server: true }, cumulative: true, eager: true, global: true },
+    cli: {
+        env: { config: true },
+        global: true,
+    },
+    onPrerenderStart: {
+        env: { server: true, production: true },
+        eager: true,
+        global: true,
+    },
+    onBeforeRoute: {
+        env: { server: true, client: 'if-client-routing' },
+        eager: true,
+        global: true,
+    },
+    prerender: {
+        env: { config: true },
+        global: (value, { isGlobalLocation }) => typeof value === 'object' || isGlobalLocation,
+        cumulative: true,
+    },
+    vite: { env: { config: true }, global: true, cumulative: true },
+    disableAutoFullBuild: {
+        env: { config: true },
+        global: true,
+    },
+    // This is deprecated (since Summer 2025). But don't remove this (yet) — otherwise it will break older Vike extensions that still use it.
+    vite6BuilderApp: {
+        env: { config: true },
+        global: true,
+    },
+    includeAssetsImportedByServer: {
+        env: { config: true },
+        global: true,
+    },
+    baseAssets: {
+        env: { config: true, server: true },
+        global: true,
+    },
+    baseServer: {
+        env: { config: true, server: true },
+        global: true,
+    },
+    redirects: {
+        env: { server: true },
+        global: true,
+        cumulative: true,
+    },
+    trailingSlash: {
+        env: { server: true },
+        global: true,
+    },
+    disableUrlNormalization: {
+        env: { server: true },
+        global: true,
+    },
+    headersResponse: {
+        env: { server: true },
+        cumulative: true,
+    },
+};
+function getConfigEnv(pageConfig, configName) {
+    const source = getConfigValueSourceRelevantAnyEnv(configName, pageConfig);
+    if (!source)
+        return null;
+    const { configEnv } = source;
+    const env = {};
+    if (configEnv.client)
+        env.client = true;
+    if (configEnv.server)
+        env.server = true;
+    return env;
+}
+function isConfigSet(pageConfig, configName) {
+    const source = getConfigValueSourceRelevantAnyEnv(configName, pageConfig);
+    return !!source;
+}

package/dist/node/vite/shared/resolveVikeConfigInternal/crawlPlusFiles.js

@@ -0,0 +1,247 @@
+export { crawlPlusFiles };
+export { isPlusFile };
+export { getPlusFileValueConfigName };
+import { assertPosixPath, assert, scriptFileExtensionPattern, assertIsNotProductionRuntime, isVersionMatch, isScriptFile, scriptFileExtensionList, createDebug, deepEqual, assertUsage, assertFilePathAbsoluteFilesystem, assertWarning, hasProp, isNotNullish, getGlobalObject, } from '../../utils.js';
+import path from 'node:path';
+import { glob } from 'tinyglobby';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import { isTemporaryBuildFile } from './transpileAndExecuteFile.js';
+import { getEnvVarObject } from '../getEnvVarObject.js';
+import pc from '@brillout/picocolors';
+import picomatch from 'picomatch';
+import { ignorePatternsBuiltIn } from './crawlPlusFiles/ignorePatternsBuiltIn.js';
+const execA = promisify(exec);
+const debug = createDebug('vike:crawl');
+assertIsNotProductionRuntime();
+const globalObject = getGlobalObject('getVikeConfig/crawlPlusFiles.ts', {
+    gitIsNotUsable: false,
+});
+async function crawlPlusFiles(userRootDir) {
+    assertPosixPath(userRootDir);
+    assertFilePathAbsoluteFilesystem(userRootDir);
+    const userSettings = getUserSettings();
+    const { ignorePatterns, ignoreMatchers } = getIgnore(userSettings);
+    // Crawl
+    const filesGit = userSettings.git !== false && (await gitLsFiles(userRootDir, ignorePatterns, ignoreMatchers));
+    const filesGitNothingFound = !filesGit || filesGit.length === 0;
+    const filesGlob = (filesGitNothingFound || debug.isActivated) && (await tinyglobby(userRootDir, ignorePatterns));
+    let files = !filesGitNothingFound
+        ? filesGit
+        : // Fallback to tinyglobby for users that dynamically generate plus files. (Assuming that no plus file is found because of the user's .gitignore list.)
+            filesGlob;
+    assert(files);
+    if (debug.isActivated && filesGit && filesGlob) {
+        assertWarning(deepEqual(filesGlob.slice().sort(), filesGit.slice().sort()), "Git and glob results aren't matching.", { onlyOnce: false });
+    }
+    // Filter build files
+    files = files.filter((filePath) => !isTemporaryBuildFile(filePath));
+    // Normalize
+    const plusFiles = files.map((filePath) => {
+        // Both `$ git-ls files` and tinyglobby return posix paths
+        assertPosixPath(filePath);
+        assert(!filePath.startsWith(userRootDir));
+        const filePathAbsoluteUserRootDir = path.posix.join('/', filePath);
+        assert(isPlusFile(filePathAbsoluteUserRootDir));
+        return { filePathAbsoluteUserRootDir };
+    });
+    return plusFiles;
+}
+// Same as tinyglobby() but using `$ git ls-files`
+async function gitLsFiles(userRootDir, ignorePatterns, ignoreMatchers) {
+    if (globalObject.gitIsNotUsable)
+        return null;
+    // Preserve UTF-8 file paths.
+    // https://github.com/vikejs/vike/issues/1658
+    // https://stackoverflow.com/questions/22827239/how-to-make-git-properly-display-utf-8-encoded-pathnames-in-the-console-window/22828826#22828826
+    // https://stackoverflow.com/questions/15884180/how-do-i-override-git-configuration-options-by-command-line-parameters/15884261#15884261
+    const preserveUTF8 = '-c core.quotepath=off';
+    const cmd = [
+        'git',
+        preserveUTF8,
+        'ls-files',
+        // Performance gain seems negligible: https://github.com/vikejs/vike/pull/1688#issuecomment-2166206648
+        ...scriptFileExtensionList.map((ext) => `"**/+*.${ext}" "+*.${ext}"`),
+        // Performance gain is non-negligible.
+        //  - https://github.com/vikejs/vike/pull/1688#issuecomment-2166206648
+        //  - When node_modules/ is untracked the performance gain could be significant?
+        ...ignorePatterns.map((pattern) => `--exclude="${pattern}"`),
+        // --others --exclude-standard => list untracked files (--others) while using .gitignore (--exclude-standard)
+        // --cached => list tracked files
+        '--others --exclude-standard --cached',
+    ].join(' ');
+    let filesAll;
+    let filesDeleted;
+    try {
+        ;
+        [filesAll, filesDeleted] = await Promise.all([
+            // Main command
+            runCmd1(cmd, userRootDir),
+            // Get tracked but deleted files
+            runCmd1('git ls-files --deleted', userRootDir),
+        ]);
+    }
+    catch (err) {
+        if (await isGitNotUsable(userRootDir)) {
+            globalObject.gitIsNotUsable = true;
+            return null;
+        }
+        throw err;
+    }
+    if (debug.isActivated) {
+        debug('[git] userRootDir:', userRootDir);
+        debug('[git] cmd:', cmd);
+        debug('[git] result:', filesAll);
+        debug('[git] filesDeleted:', filesDeleted);
+    }
+    const files = [];
+    for (const filePath of filesAll) {
+        // + file?
+        if (!path.posix.basename(filePath).startsWith('+'))
+            continue;
+        // We have to repeat the same exclusion logic here because the option --exclude of `$ git ls-files` only applies to untracked files. (We use --exclude only to speed up the `$ git ls-files` command.)
+        if (ignoreMatchers.some((m) => m(filePath)))
+            continue;
+        // JavaScript file?
+        if (!isScriptFile(filePath))
+            continue;
+        // Deleted?
+        if (filesDeleted.includes(filePath))
+            continue;
+        files.push(filePath);
+    }
+    return files;
+}
+// Same as gitLsFiles() but using tinyglobby
+async function tinyglobby(userRootDir, ignorePatterns) {
+    const pattern = `**/+*.${scriptFileExtensionPattern}`;
+    const options = {
+        ignore: ignorePatterns,
+        cwd: userRootDir,
+        dot: false,
+    };
+    const files = await glob(pattern, options);
+    // Make build deterministic, in order to get a stable generated hash for dist/client/assets/entries/entry-client-routing.${hash}.js
+    // https://github.com/vikejs/vike/pull/1750
+    files.sort();
+    if (debug.isActivated) {
+        debug('[glob] pattern:', pattern);
+        debug('[glob] options:', options);
+        debug('[glob] result:', files);
+    }
+    return files;
+}
+// Whether Git is installed and whether we can use it
+async function isGitNotUsable(userRootDir) {
+    // Check Git version
+    {
+        const res = await runCmd2('git --version', userRootDir);
+        if ('err' in res)
+            return true;
+        let { stdout, stderr } = res;
+        assert(stderr === '');
+        const prefix = 'git version ';
+        assert(stdout.startsWith(prefix));
+        const gitVersion = stdout.slice(prefix.length);
+        //  - Works with Git 2.43.1 but also (most certainly) with earlier versions.
+        //    - We didn't bother test which is the earliest version that works.
+        //  - Git 2.32.0 doesn't seem to work: https://github.com/vikejs/vike/discussions/1549
+        //    - Maybe it's because of StackBlitz: looking at the release notes, Git 2.32.0 should be working.
+        if (!isVersionMatch(gitVersion, ['2.43.1']))
+            return true;
+    }
+    // Is userRootDir inside a Git repository?
+    {
+        const res = await runCmd2('git rev-parse --is-inside-work-tree', userRootDir);
+        if ('err' in res)
+            return true;
+        let { stdout, stderr } = res;
+        assert(stderr === '');
+        assert(stdout === 'true');
+        return false;
+    }
+}
+async function runCmd1(cmd, cwd) {
+    const { stdout } = await execA(cmd, {
+        cwd,
+        // https://github.com/vikejs/vike/issues/1982
+        maxBuffer: Infinity,
+    });
+    /* Not always true: https://github.com/vikejs/vike/issues/1440#issuecomment-1892831303
+    assert(res.stderr === '')
+    */
+    return stdout.toString().split('\n').filter(Boolean);
+}
+async function runCmd2(cmd, cwd) {
+    let res;
+    try {
+        res = await execA(cmd, { cwd });
+    }
+    catch (err) {
+        return { err };
+    }
+    let { stdout, stderr } = res;
+    stdout = stdout.toString().trim();
+    stderr = stderr.toString().trim();
+    return { stdout, stderr };
+}
+function getUserSettings() {
+    const userSettings = getEnvVarObject('VIKE_CRAWL') ?? {};
+    const wrongUsage = (settingName, settingType) => `Setting ${pc.cyan(settingName)} in VIKE_CRAWL should be a ${pc.cyan(settingType)}`;
+    assertUsage(hasProp(userSettings, 'git', 'boolean') || hasProp(userSettings, 'git', 'undefined'), wrongUsage('git', 'boolean'));
+    assertUsage(hasProp(userSettings, 'ignore', 'string[]') ||
+        hasProp(userSettings, 'ignore', 'string') ||
+        hasProp(userSettings, 'ignore', 'undefined'), wrongUsage('git', 'string or an array of strings'));
+    assertUsage(hasProp(userSettings, 'ignoreBuiltIn', 'boolean') || hasProp(userSettings, 'ignoreBuiltIn', 'undefined'), wrongUsage('ignoreBuiltIn', 'boolean'));
+    const settingNames = ['git', 'ignore', 'ignoreBuiltIn'];
+    Object.keys(userSettings).forEach((name) => {
+        assertUsage(settingNames.includes(name), `Unknown setting ${pc.bold(pc.red(name))} in VIKE_CRAWL`);
+    });
+    return userSettings;
+}
+function isPlusFile(filePath) {
+    assertPosixPath(filePath);
+    if (isTemporaryBuildFile(filePath))
+        return false;
+    const fileName = filePath.split('/').pop();
+    return fileName.startsWith('+');
+}
+function getPlusFileValueConfigName(filePath) {
+    if (!isPlusFile(filePath))
+        return null;
+    const fileName = path.posix.basename(filePath);
+    // assertNoUnexpectedPlusSign(filePath, fileName)
+    const basename = fileName.split('.')[0];
+    assert(basename.startsWith('+'));
+    const configName = basename.slice(1);
+    assertUsage(configName !== '', `${filePath} Invalid filename ${fileName}`);
+    return configName;
+}
+/* https://github.com/vikejs/vike/issues/1407
+function assertNoUnexpectedPlusSign(filePath: string, fileName: string) {
+  const dirs = path.posix.dirname(filePath).split('/')
+  dirs.forEach((dir, i) => {
+    const dirPath = dirs.slice(0, i + 1).join('/')
+    assertUsage(
+      !dir.includes('+'),
+      `Character '+' is a reserved character: remove '+' from the directory name ${dirPath}/`
+    )
+  })
+  assertUsage(
+    !fileName.slice(1).includes('+'),
+    `Character '+' is only allowed at the beginning of filenames: make sure ${filePath} doesn't contain any '+' in its filename other than its first letter`
+  )
+}
+*/
+function getIgnore(userSettings) {
+    const ignorePatternsSetByUser = [userSettings.ignore].flat().filter(isNotNullish);
+    const { ignoreBuiltIn } = userSettings;
+    const ignorePatterns = [...(ignoreBuiltIn === false ? [] : ignorePatternsBuiltIn), ...ignorePatternsSetByUser];
+    const ignoreMatchers = ignorePatterns.map((p) => picomatch(p, {
+        // We must pass the same settings than tinyglobby
+        // https://github.com/SuperchupuDev/tinyglobby/blob/fcfb08a36c3b4d48d5488c21000c95a956d9797c/src/index.ts#L191-L194
+        dot: false,
+        nocase: false,
+    }));
+    return { ignorePatterns, ignoreMatchers };
+}

package/dist/node/vite/shared/resolveVikeConfigInternal/getConfigFileExport.js

@@ -0,0 +1,12 @@
+export { getConfigFileExport };
+import pc from '@brillout/picocolors';
+import { assertPlusFileExport } from '../../../../shared-server-client/page-configs/assertPlusFileExport.js';
+import { assertUsage, isObject } from '../../utils.js';
+function getConfigFileExport(fileExports, filePathToShowToUser) {
+    assertPlusFileExport(fileExports, filePathToShowToUser, 'config');
+    const usesNamedExport = !!fileExports.config;
+    const fileExport = usesNamedExport ? fileExports.config : fileExports.default;
+    const exportName = pc.cyan(usesNamedExport ? 'export { config }' : 'export default');
+    assertUsage(isObject(fileExport), `The ${exportName} of ${filePathToShowToUser} should be an object (but it's ${pc.cyan(`typeof exportedValue === ${JSON.stringify(typeof fileExport)}`)} instead)`);
+    return fileExport;
+}

package/dist/node/vite/shared/resolveVikeConfigInternal/loadFileAtConfigTime.js

@@ -0,0 +1,124 @@
+// Files loaded at config time:
+export { loadPointerImport };
+export { loadValueFile };
+export { loadConfigFile };
+import { assert, assertUsage, assertIsNotProductionRuntime, isArrayOfStrings, isObject } from '../../utils.js';
+import { transpileAndExecuteFile } from './transpileAndExecuteFile.js';
+import { getConfigDefinitionOptional } from '../resolveVikeConfigInternal.js';
+import { assertPlusFileExport } from '../../../../shared-server-client/page-configs/assertPlusFileExport.js';
+import pc from '@brillout/picocolors';
+import { parsePointerImportData } from './pointerImports.js';
+import { getConfigFileExport } from './getConfigFileExport.js';
+import { resolvePointerImportData } from './resolvePointerImport.js';
+import { getConfigDefinedAt } from '../../../../shared-server-client/page-configs/getConfigDefinedAt.js';
+assertIsNotProductionRuntime();
+// Load pointer import
+async function loadPointerImport(pointerImport, userRootDir, configName, configDefinitions, esbuildCache) {
+    // The value of `extends` was already loaded and already used: we don't need the value of `extends` anymore
+    if (configName === 'extends')
+        return;
+    const configDef = getConfigDefinitionOptional(configDefinitions, configName);
+    // Only load pointer import if `env.config===true`
+    if (!configDef || !shouldBeLoadableAtBuildTime(configDef))
+        return;
+    const configDefinedAt = getConfigDefinedAt('Config', configName, pointerImport.fileExportPath);
+    assertUsage(pointerImport.fileExportPath.filePathAbsoluteFilesystem, `${configDefinedAt} cannot be defined over an aliased import`);
+    const { fileExports } = await transpileAndExecuteFile(pointerImport.fileExportPath, userRootDir, false, esbuildCache);
+    const fileExportValue = fileExports[pointerImport.fileExportPath.fileExportName];
+    pointerImport.fileExportValueLoaded = true;
+    assert(pointerImport.fileExportValueLoaded);
+    pointerImport.fileExportValue = fileExportValue;
+}
+// Load +{configName}.js
+async function loadValueFile(interfaceValueFile, configDefinitions, userRootDir, esbuildCache) {
+    const { configName } = interfaceValueFile;
+    const configDef = getConfigDefinitionOptional(configDefinitions, configName);
+    // Only load value files with `env.config===true`
+    if (!configDef || !shouldBeLoadableAtBuildTime(configDef))
+        return;
+    interfaceValueFile.isNotLoaded = false;
+    assert(!interfaceValueFile.isNotLoaded);
+    interfaceValueFile.fileExportsByConfigName = {};
+    const { fileExports } = await transpileAndExecuteFile(interfaceValueFile.filePath, userRootDir, false, esbuildCache);
+    const { filePathToShowToUser } = interfaceValueFile.filePath;
+    assertPlusFileExport(fileExports, filePathToShowToUser, configName);
+    Object.entries(fileExports).forEach(([exportName, configValue]) => {
+        const configName_ = exportName === 'default' ? configName : exportName;
+        interfaceValueFile.fileExportsByConfigName[configName_] = configValue;
+    });
+}
+// Load +config.js, including all its extends pointer imports
+async function loadConfigFile(configFilePath, userRootDir, visited, isExtensionConfig, esbuildCache) {
+    const { filePathAbsoluteFilesystem } = configFilePath;
+    assertNoInfiniteLoop(visited, filePathAbsoluteFilesystem);
+    const { fileExports } = await transpileAndExecuteFile(configFilePath, userRootDir, isExtensionConfig, esbuildCache);
+    const { extendsConfigs, extendsFilePaths } = await loadExtendsConfigs(fileExports, configFilePath, userRootDir, [...visited, filePathAbsoluteFilesystem], esbuildCache);
+    const configFile = {
+        fileExports,
+        filePath: configFilePath,
+        extendsFilePaths,
+    };
+    return { configFile, extendsConfigs };
+}
+function assertNoInfiniteLoop(visited, filePathAbsoluteFilesystem) {
+    const idx = visited.indexOf(filePathAbsoluteFilesystem);
+    if (idx === -1)
+        return;
+    const loop = visited.slice(idx);
+    assert(loop[0] === filePathAbsoluteFilesystem);
+    assertUsage(idx === -1, `Infinite extends loop ${[...loop, filePathAbsoluteFilesystem].join('>')}`);
+}
+async function loadExtendsConfigs(configFileExports, configFilePath, userRootDir, visited, esbuildCache) {
+    const { extendsPointerImportData, extendsConfigs } = getExtendsPointerImportData(configFileExports, configFilePath);
+    const extendsConfigFiles = [];
+    extendsPointerImportData.map((pointerImportData) => {
+        const filePath = resolvePointerImportData(pointerImportData, configFilePath, userRootDir);
+        assert(filePath.filePathAbsoluteFilesystem);
+        extendsConfigFiles.push(filePath);
+    });
+    const results = await Promise.all(extendsConfigFiles.map(async (configFilePath) => await loadConfigFile(configFilePath, userRootDir, visited, true, esbuildCache)));
+    results.forEach((result) => {
+        extendsConfigs.push(result.configFile);
+        extendsConfigs.push(...result.extendsConfigs);
+    });
+    const extendsFilePaths = extendsConfigFiles.map((f) => f.filePathAbsoluteFilesystem);
+    return { extendsConfigs, extendsFilePaths };
+}
+function getExtendsPointerImportData(configFileExports, configFilePath) {
+    const { filePathToShowToUser } = configFilePath;
+    const configFileExport = getConfigFileExport(configFileExports, filePathToShowToUser);
+    const extendsConfigs = [];
+    const extendsPointerImportData = [];
+    if ('extends' in configFileExport) {
+        const extendsValue = configFileExport.extends;
+        const extendList = [];
+        const wrongUsage = `${filePathToShowToUser} sets the config ${pc.cyan('extends')} to an invalid value, see https://vike.dev/extends`;
+        if (typeof extendsValue === 'string') {
+            extendList.push(extendsValue);
+        }
+        else if (isArrayOfStrings(extendsValue)) {
+            extendList.push(...extendsValue);
+        }
+        else if (isObject(extendsValue)) {
+            /* If we want to implement this then we need to make filePath optional
+            extendsConfigs.push({
+              fileExports: extendsValue,
+              filePath: null,
+            })
+            */
+            assertUsage(false, wrongUsage);
+        }
+        else {
+            assertUsage(false, wrongUsage);
+        }
+        extendsPointerImportData.push(...extendList.map((importString) => {
+            const pointerImportData = parsePointerImportData(importString);
+            assertUsage(pointerImportData, wrongUsage);
+            return pointerImportData;
+        }));
+    }
+    return { extendsPointerImportData, extendsConfigs };
+}
+function shouldBeLoadableAtBuildTime(configDef) {
+    return !!configDef.env.config && !configDef._valueIsFilePath;
+}