vike 0.4.249 → 0.4.250-commit-193dea3

package/dist/node/vite/plugins/pluginVirtualFiles.js

@@ -9,15 +9,17 @@ import pc from '@brillout/picocolors';
 import { logConfigInfo } from '../shared/loggerDev.js';
 import { getFilePathToShowToUserModule } from '../shared/getFilePath.js';
 import { updateUserFiles } from '../../../server/runtime/globalContext.js';
-import { isPlusFile } from '../shared/resolveVikeConfigInternal/crawlPlusFiles.js';
+import { isPlusFile } from '../shared/resolveVikeConfigInternal/crawlPlusFilePaths.js';
 import { isTemporaryBuildFile } from '../shared/resolveVikeConfigInternal/transpileAndExecuteFile.js';
 import { debugFileChange, getVikeConfigError } from '../../../shared-server-node/getVikeConfigError.js';
+// === Rolldown filter
 const filterRolldown = {
     id: {
         include: new RegExp(`^(${escapeRegex(virtualFileIdPrefix1)}|${escapeRegex(virtualFileIdPrefix2)})`),
     },
 };
 const filterFunction = (id) => isVirtualFileId(id);
+// ===
 function pluginVirtualFiles() {
     let config;
     return [
@@ -38,11 +40,12 @@ function pluginVirtualFiles() {
                     return addVirtualFileIdPrefix(id);
                 },
             },
+            // Vite calls handleHotUpdate() whenever *any file* is modified — including files that aren't in Vite's module graph such as +config.js
             handleHotUpdate: {
                 async handler(ctx) {
                     debugFileChange('handleHotUpdate()', ctx.file);
                     try {
-                        return await handleHotUpdate(ctx, config);
+                        return await onFileModified(ctx, config);
                     }
                     catch (err) {
                         // Vite swallows errors thrown by handleHotUpdate()
@@ -73,106 +76,89 @@ function pluginVirtualFiles() {
             },
             configureServer: {
                 handler(server) {
-                    handleFileAddRemove(server, config);
+                    server.watcher.prependListener('add', (file) => onFileCreatedOrRemoved(file, false, server, config));
+                    server.watcher.prependListener('unlink', (file) => onFileCreatedOrRemoved(file, true, server, config));
                 },
             },
         },
     ];
 }
-function handleFileAddRemove(server, config) {
-    server.watcher.prependListener('add', (f) => listener(f, false));
-    server.watcher.prependListener('unlink', (f) => listener(f, true));
-    return;
-    async function listener(file, isRemove) {
-        file = normalizePath(file);
-        if (isTemporaryBuildFile(file))
-            return;
-        const operation = isRemove ? 'removed' : 'created';
-        debugFileChange('server.watcher', file, operation);
-        const { moduleGraph } = server;
-        const isVikeConfigDep = await isVikeConfigDependency(file, moduleGraph);
-        const reload = () => reloadConfig(file, config, operation, server);
-        // Config code
-        if (isVikeConfigDep && !isVikeConfigDep.isProcessedByVite) {
-            reload();
-            return;
-        }
-        // New or deleted + file
-        if (isPlusFile(file)) {
-            reload();
-            return;
-        }
-        // Runtime code => let Vite handle it
-        if (isVikeConfigDep && isVikeConfigDep.isProcessedByVite) {
-            assert(existsInViteModuleGraph(file, moduleGraph));
-            return;
-        }
-        // Trick: when importing a file that doesn't exist => we don't know whether `file` is that missing file => we take a leap of faith when the conditions below are met.
+async function onFileModified(ctx, config) {
+    const { file, server } = ctx;
+    const isAppFile = await isAppDependency(ctx.file, ctx.server.moduleGraph);
+    debugFileChange(isAppFile);
+    if (!isAppFile)
+        return;
+    const reloadVikeConfig = () => reloadConfig(file, config, 'modified', server);
+    if (isAppFile.isRuntimeDependency) {
+        // Ensure we invalidate `file` *before* server.ssrLoadModule() in updateUserFiles()
+        // Vite also invalidates it, but *after* handleHotUpdate() and thus after server.ssrLoadModule()
+        ctx.modules.forEach((mod) => server.moduleGraph.invalidateModule(mod));
+        // Re-running ssrLoadModule() is cheap (Vite uses a cache) => eagerly calling updateUserFiles() makes sense.
+        // - Even for SPA apps that don't have (m)any server files? Ideally, we should set `isRuntimeDependency: true` only for server modules (let's do it once Vite has a clear separate per-environment module graphs).
+        await updateUserFiles();
+    }
+    if (isAppFile.isConfigDependency) {
+        /* Tailwind breaks this assertion, see https://github.com/vikejs/vike/discussions/1330#discussioncomment-7787238
+        const isViteModule = ctx.modules.length > 0
+        assert(!isViteModule)
+        */
+        reloadVikeConfig();
+        // Trigger a full page reload. (Because files such as +config.js can potentially modify Vike's virtual files.)
+        const vikeVirtualFiles = getVikeVirtualFiles(server);
+        return vikeVirtualFiles;
+    }
+}
+async function onFileCreatedOrRemoved(file, isRemove, server, config) {
+    file = normalizePath(file);
+    if (isTemporaryBuildFile(file))
+        return;
+    const operation = isRemove ? 'removed' : 'created';
+    debugFileChange('server.watcher', file, operation);
+    const { moduleGraph } = server;
+    const isAppFile = await isAppDependency(file, moduleGraph);
+    const reloadVikeConfig = () => reloadConfig(file, config, operation, server);
+    if (
+    // Vike config (non-runtime) code
+    isAppFile?.isConfigDependency ||
+        // New + file => not tracked yet by Vike (`vikeConfigObject._vikeConfigDependencies`) nor Vite (`moduleGraph`)
+        isPlusFile(file) ||
+        // Trick: when fixing the path of a relative import => we don't know whether `file` is the imported file => we take a leap of faith when the conditions below are met.
+        // - Reloading Vike's config is cheap => eagerly reloading it makes sense when it's in an erroneous state.
         // - Not sure how reliable that trick is.
-        // - Reloading Vike's config is cheap and file creation/removal is rare => the trick is worth it.
         // - Reproduction:
         //   ```bash
-        //   rm someDep.js && sleep 2 && git checkout someDep.js
+        //   rm someImportedFile.js && sleep 2 && git checkout someImportedFile.js
         //   ```
-        if (isScriptFile(file) && getVikeConfigError() && !existsInViteModuleGraph(file, moduleGraph)) {
-            reload();
-            return;
-        }
+        (isScriptFile(file) && getVikeConfigError())) {
+        reloadVikeConfig();
     }
 }
-function invalidateVikeVirtualFiles(server) {
-    const vikeVirtualFiles = getVikeVirtualFiles(server);
-    vikeVirtualFiles.forEach((mod) => {
-        server.moduleGraph.invalidateModule(mod);
-    });
-}
-// Vite calls its hook handleHotUpdate() whenever *any file* is modified — including files that aren't in Vite's module graph such as `pages/+config.js`
-async function handleHotUpdate(ctx, config) {
-    const { file, server } = ctx;
-    const isVikeConfigDep = await isVikeConfigDependency(ctx.file, ctx.server.moduleGraph);
-    debugFileChange(isVikeConfigDep);
-    if (isVikeConfigDep) {
-        if (!isVikeConfigDep.isProcessedByVite) {
-            /* Tailwind breaks this assertion, see https://github.com/vikejs/vike/discussions/1330#discussioncomment-7787238
-            const isViteModule = ctx.modules.length > 0
-            assert(!isViteModule)
-            */
-            reloadConfig(file, config, 'modified', server);
-            // Files such as `pages/+config.js` can potentially modify Vike's virtual files.
-            // Triggers a full page reload
-            const vikeVirtualFiles = getVikeVirtualFiles(server);
-            return vikeVirtualFiles;
-        }
-        else {
-            // Ensure we invalidate `file` *before* server.ssrLoadModule() in updateUserFiles()
-            // Vite also invalidates it, but *after* handleHotUpdate() and thus after server.ssrLoadModule()
-            ctx.modules.forEach((mod) => server.moduleGraph.invalidateModule(mod));
-            await updateUserFiles();
-        }
-    }
-}
-async function isVikeConfigDependency(filePathAbsoluteFilesystem, moduleGraph) {
-    // Non-runtime Vike config files such as `pages/+config.js` which aren't processed by Vite.
+async function isAppDependency(filePathAbsoluteFilesystem, moduleGraph) {
+    const isAppFile = {};
+    // =============================
+    // { isConfigDependency: false }
+    // =============================
+    // Vike config (non-runtime) files such as +config.js which aren't processed by Vite.
     // - They're missing in Vite's module graph.
     // - Potentially modifies Vike's virtual files.
-    // - Same for all `pages/+config.js` dependencies.
+    // - Same for all `pages/+config.js` transitive dependencies.
     assertPosixPath(filePathAbsoluteFilesystem);
     const vikeConfigObject = await getVikeConfigInternalOptional();
     if (vikeConfigObject) {
         const { _vikeConfigDependencies: vikeConfigDependencies } = vikeConfigObject;
         vikeConfigDependencies.forEach((f) => assertPosixPath(f));
-        if (vikeConfigDependencies.has(filePathAbsoluteFilesystem))
-            return { isProcessedByVite: false };
+        isAppFile.isConfigDependency = vikeConfigDependencies.has(filePathAbsoluteFilesystem);
     }
-    // Runtime Vike config files such as +data.js which are processed by Vite.
+    // =============================
+    // { isRuntimeDependency: true }
+    // =============================
+    // Vike runtime files such as +data.js which are processed by Vite.
     // - They're included in Vite's module graph.
     // - They never modify Vike's virtual files.
-    // - Same for all `+data.js` dependencies.
-    const importers = getImporters(filePathAbsoluteFilesystem, moduleGraph);
-    const isPlusValueFileDependency = Array.from(importers).some((importer) => importer.file && isPlusFile(importer.file));
-    if (isPlusValueFileDependency)
-        return { isProcessedByVite: true };
-    return null;
+    // - Same for all `+data.js` transitive dependencies.
+    isAppFile.isRuntimeDependency = existsInViteModuleGraph(filePathAbsoluteFilesystem, moduleGraph);
+    return isAppFile;
 }
 function reloadConfig(filePath, config, operation, server) {
     // Ensure server.ssrLoadModule() loads fresh Vike virtual files (`reloadConfig()` > `updateUserFiles()` > `server.ssrLoadModule()`)
@@ -185,6 +171,12 @@ function reloadConfig(filePath, config, operation, server) {
     reloadVikeConfig();
     updateUserFiles();
 }
+function invalidateVikeVirtualFiles(server) {
+    const vikeVirtualFiles = getVikeVirtualFiles(server);
+    vikeVirtualFiles.forEach((mod) => {
+        server.moduleGraph.invalidateModule(mod);
+    });
+}
 function getVikeVirtualFiles(server) {
     const vikeVirtualFiles = Array.from(server.moduleGraph.urlToModuleMap.keys())
         .filter((url) => parseVirtualFileId(url))
@@ -195,38 +187,6 @@ function getVikeVirtualFiles(server) {
     });
     return vikeVirtualFiles;
 }
-// Get all transitive importers (including the module itself)
-function getImporters(file, moduleGraph) {
-    const importers = new Set();
-    const mods = moduleGraph.getModulesByFile(file);
-    if (!mods)
-        return importers;
-    for (const mod of mods) {
-        getModuleImporters(mod).forEach((importer) => {
-            if (importer)
-                importers.add(importer);
-        });
-    }
-    return importers;
-}
-function getModuleImporters(mod, seen = new Set()) {
-    if (seen.has(mod))
-        return new Set();
-    seen.add(mod);
-    const importers = new Set();
-    if (mod.id)
-        importers.add(mod);
-    // Traverse through the importers (modules that import this module)
-    for (const importer of mod.importers) {
-        if (importer.id)
-            importers.add(importer);
-        getModuleImporters(importer, seen).forEach((importerTransitive) => {
-            if (importerTransitive)
-                importers.add(importerTransitive);
-        });
-    }
-    return importers;
-}
 function existsInViteModuleGraph(file, moduleGraph) {
     return !!moduleGraph.getModulesByFile(file);
 }

package/dist/node/vite/plugins/pluginViteConfigVikeExtensions.d.ts

@@ -1,3 +1,4 @@
 export { pluginViteConfigVikeExtensions };
 import type { Plugin } from 'vite';
-declare function pluginViteConfigVikeExtensions(): Promise<Plugin[]>;
+import type { VikeConfigInternal } from '../shared/resolveVikeConfigInternal.js';
+declare function pluginViteConfigVikeExtensions(vikeConfig: VikeConfigInternal): Promise<Plugin[]>;

package/dist/node/vite/plugins/pluginViteConfigVikeExtensions.js

@@ -1,11 +1,9 @@
 export { pluginViteConfigVikeExtensions };
 import { mergeConfig } from 'vite';
 import { assertUsage, isCallable, isObject } from '../utils.js';
-import { getVikeConfigInternalEarly } from '../../api/resolveViteConfigFromUser.js';
 // Apply +vite
 // - For example, Vike extensions adding Vite plugins
-async function pluginViteConfigVikeExtensions() {
-    const vikeConfig = await getVikeConfigInternalEarly();
+async function pluginViteConfigVikeExtensions(vikeConfig) {
     if (vikeConfig === null)
         return [];
     let viteConfigFromExtensions = {};

package/dist/node/vite/shared/importString.d.ts

@@ -0,0 +1,50 @@
+export { parseImportString };
+export { isImportString };
+export { serializeImportString };
+export type { ImportString };
+export type { ImportStringList };
+export type { ImportStringParsed };
+/** `import:${importPath}:${exportName}`
+ * @example import:./Layout:default
+ */
+type ImportString = `import:${string}:${string}`;
+type ImportStringList = ImportString | ImportString[];
+type ImportStringParsed = {
+    importPath: string;
+    exportName: string;
+};
+/**
+ * Parse import string in format: import:importPath:exportName
+ *
+ * @example parseImportString('import:react/jsx-runtime:jsx')
+ * // => { importPath: 'react/jsx-runtime', exportName: 'jsx' }
+ *
+ * @example parseImportString('import:./Layout:default')
+ * // => { importPath: './Layout', exportName: 'default' }
+ *
+ * @example parseImportString('import:./Layout', { legacy: true })
+ * // => { importPath: './Layout', exportName: 'default' }
+ */
+declare function parseImportString(importString: string, { legacy }?: {
+    legacy?: boolean;
+}): null | ImportStringParsed;
+/**
+ * Check if a string is an import string (starts with 'import:').
+ *
+ * @example isImportString('import:react:jsx')
+ * // => true
+ *
+ * @example isImportString('some-other-string')
+ * // => false
+ */
+declare function isImportString(str: string): str is ImportString;
+/**
+ * Serialize import string from importPath and export name.
+ *
+ * @example serializeImportString({ importPath: 'react/jsx-runtime', exportName: 'jsx' })
+ * // => 'import:react/jsx-runtime:jsx'
+ *
+ * @example serializeImportString({ importPath: './Layout', exportName: 'default' })
+ * // => 'import:./Layout:default'
+ */
+declare function serializeImportString({ importPath, exportName }: ImportStringParsed): `import:${string}:${string}`;

package/dist/node/vite/shared/importString.js

@@ -0,0 +1,63 @@
+export { parseImportString };
+export { isImportString };
+export { serializeImportString };
+import pc from '@brillout/picocolors';
+import { assert, assertWarning } from '../utils.js';
+const IMPORT = 'import';
+const SEP = ':';
+/**
+ * Parse import string in format: import:importPath:exportName
+ *
+ * @example parseImportString('import:react/jsx-runtime:jsx')
+ * // => { importPath: 'react/jsx-runtime', exportName: 'jsx' }
+ *
+ * @example parseImportString('import:./Layout:default')
+ * // => { importPath: './Layout', exportName: 'default' }
+ *
+ * @example parseImportString('import:./Layout', { legacy: true })
+ * // => { importPath: './Layout', exportName: 'default' }
+ */
+function parseImportString(importString, { legacy = false } = {}) {
+    if (!importString.startsWith(`${IMPORT}${SEP}`))
+        return null;
+    const parts = importString.split(SEP);
+    assert(parts[0] === IMPORT);
+    if (legacy && parts.length === 2) {
+        assertWarning(false, `Replace ${pc.cyan(importString)} with ${pc.cyan(importString)}${pc.cyan(':default')} (import strings must include the export name)`, { onlyOnce: true });
+        const exportName = 'default';
+        const importPath = parts[1];
+        assert(importPath);
+        return { importPath, exportName };
+    }
+    assert(parts.length >= 3);
+    const exportName = parts[parts.length - 1];
+    const importPath = parts.slice(1, -1).join(SEP);
+    assert(exportName);
+    assert(importPath);
+    return { importPath, exportName };
+}
+/**
+ * Check if a string is an import string (starts with 'import:').
+ *
+ * @example isImportString('import:react:jsx')
+ * // => true
+ *
+ * @example isImportString('some-other-string')
+ * // => false
+ */
+function isImportString(str) {
+    return !!parseImportString(str, { legacy: true });
+}
+/**
+ * Serialize import string from importPath and export name.
+ *
+ * @example serializeImportString({ importPath: 'react/jsx-runtime', exportName: 'jsx' })
+ * // => 'import:react/jsx-runtime:jsx'
+ *
+ * @example serializeImportString({ importPath: './Layout', exportName: 'default' })
+ * // => 'import:./Layout:default'
+ */
+function serializeImportString({ importPath, exportName }) {
+    const importString = `${IMPORT}${SEP}${importPath}${SEP}${exportName}`;
+    return importString;
+}

package/dist/node/vite/shared/loggerDev.d.ts

@@ -2,11 +2,11 @@ export { logVite };
 export { logConfigInfo };
 export { logErrorServerDev };
 export type { LogType };
-export type { AddTagsDev };
+export type { AddAssertTagsDev };
 import { type PageContext_logRuntime } from '../../../server/runtime/loggerRuntime.js';
 type LogType = 'info' | 'warn' | 'error' | 'error-resolve';
 declare function logConfigInfo(msg: string, logType: LogType): void;
 declare function logVite(msg: string, logType: LogType, requestId: number | null, prependViteTag: boolean): void;
 declare function logErrorServerDev(err: unknown, pageContext: PageContext_logRuntime, errorComesFromVite?: boolean): void;
-type AddTagsDev = typeof addTagsDev;
-declare function addTagsDev<TagVike extends string, TagType extends string>(tagVike: TagVike, tagType: TagType): `1:37:00 PM ${TagVike}[request(n)]${TagType}`;
+type AddAssertTagsDev = typeof addAssertTagsDev;
+declare function addAssertTagsDev<TagVike extends string, TagType extends string>(tagVike: TagVike, tagType: TagType): `1:37:00 PM ${TagVike}[request(n)]${TagType}`;

package/dist/node/vite/shared/loggerDev.js

@@ -12,7 +12,7 @@ export { logErrorServerDev };
 import { isAbortError } from '../../../shared-server-client/route/abort.js';
 import { getViteConfig } from '../../../server/runtime/globalContext.js';
 import { assertPageContext_logRuntime, setLogRuntimeDev, } from '../../../server/runtime/loggerRuntime.js';
-import { setAssertOnBeforeErr, assert, assertIsNotProductionRuntime, colorVike, colorVite, formatHintLog, hasGreen, hasProp, hasRed, hasYellow, isDebugError, stripAnsi, colorError, colorWarning, setAssertAddTagsDev, } from '../utils.js';
+import { setAssertOnBeforeErr, assert, assertIsNotProductionRuntime, colorVike, colorVite, formatHintLog, hasGreen, hasProp, hasRed, hasYellow, isDebugError, stripAnsi, colorError, colorWarning, setAssertAddAssertTagsDev, } from '../utils.js';
 import { isErrorWithCodeSnippet, getPrettyErrorWithCodeSnippet } from './loggerDev/errorWithCodeSnippet.js';
 import { getConfigExecutionErrorIntroMsg, getConfigBuildErrorFormatted, } from './resolveVikeConfigInternal/transpileAndExecuteFile.js';
 import pc from '@brillout/picocolors';
@@ -27,7 +27,7 @@ setAssertOnBeforeErr((err) => {
     // We must directly apply vite.ssrFixStacktrace() to `assertWarning(..., { showStackTrace: true })` because warnings aren't caught by the try-catch of renderPageServer()
     applyViteSourceMap(err);
 });
-setAssertAddTagsDev(addTagsDev);
+setAssertAddAssertTagsDev(addAssertTagsDev);
 // Note shown to user when Vike completely modifies the error message (which is somewhat risky)
 const errorDebugNote = pc.dim(formatHintLog("Error isn't helpful? See https://vike.dev/debug#verbose-errors"));
 function logRuntimeInfoDev(msg, pageContext, logType) {
@@ -186,7 +186,7 @@ function getTagSourceOuter(tagSource) {
     const tagSourceOuter = (!tagSource ? '' : pc.dim(`[${tagSource}]`));
     return tagSourceOuter;
 }
-function addTagsDev(tagVike, tagType) {
+function addAssertTagsDev(tagVike, tagType) {
     const timestamp = getTagTimestamp();
     const tagSource = getTagSource();
     const tagSourceOuter = getTagSourceOuter(tagSource);

package/dist/node/vite/shared/resolveVikeConfigInternal/assertExtensions.d.ts

@@ -1,5 +1,5 @@
 export { assertExtensionsConventions };
 export { assertExtensionsRequire };
-import type { PlusFile } from './getPlusFilesAll.js';
+import type { PlusFile } from './getPlusFilesByLocationId.js';
 declare function assertExtensionsConventions(plusFile: PlusFile): void;
 declare function assertExtensionsRequire(plusFiles: PlusFile[]): void;

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

@@ -2,6 +2,7 @@ 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';
+import { getFileSuffixes } from '../../../../shared-server-node/getFileSuffixes.js';
 const configDefinitionsBuiltIn = {
     onRenderHtml: {
         env: { server: true },
@@ -117,7 +118,7 @@ const configDefinitionsBuiltIn = {
                 // Exclude `.ssr.js` hooks (they don't require pageContext.json requests)
                 .filter((source) => {
                 const { definedAt } = source;
-                if ('filePathAbsoluteVite' in definedAt && definedAt.filePathAbsoluteVite.includes('.ssr.')) {
+                if ('fileName' in definedAt && getFileSuffixes(definedAt.fileName).includes('ssr')) {
                     return false;
                 }
                 return true;
@@ -270,6 +271,14 @@ const configDefinitionsBuiltIn = {
         env: { server: true },
         cumulative: true,
     },
+    staticReplace: {
+        env: { config: true },
+        cumulative: true,
+        global: true,
+        /* TODO
+        vite: true,
+        */
+    },
 };
 function getConfigEnv(pageConfig, configName) {
     const source = getConfigValueSourceRelevantAnyEnv(configName, pageConfig);

package/dist/node/vite/shared/resolveVikeConfigInternal/{crawlPlusFiles.d.ts → crawlPlusFilePaths.d.ts}

@@ -1,7 +1,7 @@
-export { crawlPlusFiles };
+export { crawlPlusFilePaths };
 export { isPlusFile };
 export { getPlusFileValueConfigName };
-declare function crawlPlusFiles(userRootDir: string): Promise<{
+declare function crawlPlusFilePaths(userRootDir: string): Promise<{
     filePathAbsoluteUserRootDir: string;
 }[]>;
 declare function isPlusFile(filePath: string): boolean;

package/dist/node/vite/shared/resolveVikeConfigInternal/{crawlPlusFiles.js → crawlPlusFilePaths.js}

@@ -1,4 +1,4 @@
-export { crawlPlusFiles };
+export { crawlPlusFilePaths };
 export { isPlusFile };
 export { getPlusFileValueConfigName };
 import { assertPosixPath, assert, scriptFileExtensionPattern, assertIsNotProductionRuntime, isVersionMatch, isScriptFile, scriptFileExtensionList, createDebug, deepEqual, assertUsage, assertFilePathAbsoluteFilesystem, assertWarning, hasProp, isNotNullish, getGlobalObject, } from '../../utils.js';
@@ -10,14 +10,14 @@ 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';
+import { ignorePatternsBuiltIn } from './crawlPlusFilePaths/ignorePatternsBuiltIn.js';
 const execA = promisify(exec);
 const debug = createDebug('vike:crawl');
 assertIsNotProductionRuntime();
-const globalObject = getGlobalObject('getVikeConfig/crawlPlusFiles.ts', {
+const globalObject = getGlobalObject('getVikeConfig/crawlPlusFilePaths.ts', {
     gitIsNotUsable: false,
 });
-async function crawlPlusFiles(userRootDir) {
+async function crawlPlusFilePaths(userRootDir) {
     assertPosixPath(userRootDir);
     assertFilePathAbsoluteFilesystem(userRootDir);
     const userSettings = getUserSettings();

package/dist/node/vite/shared/resolveVikeConfigInternal/{getPlusFilesAll.d.ts → getPlusFilesByLocationId.d.ts}

@@ -1,4 +1,4 @@
-export { getPlusFilesAll };
+export { getPlusFilesByLocationId };
 export type { PlusFileValue };
 export type { PlusFile };
 export type { PlusFilesByLocationId };
@@ -7,21 +7,23 @@ import { type EsbuildCache } from './transpileAndExecuteFile.js';
 import { PointerImportLoaded } from './loadFileAtConfigTime.js';
 import type { FilePathResolved } from '../../../../types/FilePath.js';
 type PlusFile = PlusFileConfig | PlusFileValue;
-type PlusFileCommons = {
+type PlusFileCommon = {
     locationId: LocationId;
     filePath: FilePathResolved;
 };
-type PlusFileConfig = PlusFileCommons & {
+/** +config.js */
+type PlusFileConfig = PlusFileCommon & {
     isConfigFile: true;
     fileExportsByConfigName: Record<string, // configName
     unknown>;
     pointerImportsByConfigName: Record<string, // configName
-    PointerImportLoaded>;
+    PointerImportLoaded[]>;
     isExtensionConfig: boolean;
     extendsFilePaths: string[];
     isNotLoaded?: undefined;
 };
-type PlusFileValue = PlusFileCommons & {
+/** +{configName}.js */
+type PlusFileValue = PlusFileCommon & {
     isConfigFile: false;
     configName: string;
 } & ({
@@ -34,4 +36,4 @@ type PlusFileValue = PlusFileCommons & {
     isExtensionConfig?: undefined;
 };
 type PlusFilesByLocationId = Record<LocationId, PlusFile[]>;
-declare function getPlusFilesAll(userRootDir: string, esbuildCache: EsbuildCache): Promise<PlusFilesByLocationId>;
+declare function getPlusFilesByLocationId(userRootDir: string, esbuildCache: EsbuildCache): Promise<PlusFilesByLocationId>;