vike 0.4.228-commit-4bed128 → 0.4.228-commit-84954ae

package/dist/cjs/utils/{isNpmPackage.js → parseNpmPackage.js}

@@ -1,46 +1,46 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isNpmPackageImport = isNpmPackageImport;
-exports.isNpmPackageImport_unreliable = isNpmPackageImport_unreliable;
-exports.assertIsNpmPackageImport = assertIsNpmPackageImport;
-exports.isValidPathAlias = isValidPathAlias;
-exports.parse = parse;
+exports.isImportPathNpmPackage = isImportPathNpmPackage;
+exports.isImportPathNpmPackageOrPathAlias = isImportPathNpmPackageOrPathAlias;
+exports.assertIsImportPathNpmPackage = assertIsImportPathNpmPackage;
+exports.isPathAliasRecommended = isPathAliasRecommended;
+exports.parseNpmPackage = parseNpmPackage;
 exports.isDistinguishable = isDistinguishable;
 const assert_js_1 = require("./assert.js");
 const assertIsNotBrowser_js_1 = require("./assertIsNotBrowser.js");
 (0, assertIsNotBrowser_js_1.assertIsNotBrowser)();
-function isNpmPackageImport(str, { cannotBePathAlias }) {
+function isImportPathNpmPackage(str, { cannotBePathAlias }) {
     (0, assert_js_1.assert)(cannotBePathAlias);
-    return isNpmPackageImport_unreliable(str);
+    return isImportPathNpmPackageOrPathAlias(str);
 }
 // We cannot distinguish path aliases that look like npm package imports
-function isNpmPackageImport_unreliable(str) {
-    const res = parse(str);
+function isImportPathNpmPackageOrPathAlias(str) {
+    const res = parseNpmPackage(str);
     return res !== null;
 }
-function assertIsNpmPackageImport(str) {
-    (0, assert_js_1.assert)(isNpmPackageImport(str, {
-        // If `str` is a path alias that looks like an npm package => assertIsNpmPackageImport() is erroneous but that's okay because the assertion will eventually fail for some other user using a disambiguated path alias.
+function assertIsImportPathNpmPackage(str) {
+    (0, assert_js_1.assert)(isImportPathNpmPackage(str, {
+        // If `str` is a path alias that looks like an npm package => assertIsImportPathNpmPackage() is erroneous but that's okay because the assertion will eventually fail for some other user using a disambiguated path alias.
         cannotBePathAlias: true
     }), str);
 }
 function isNpmPackageName(str) {
-    const res = parse(str);
+    const res = parseNpmPackage(str);
     return res !== null && res.importPath === null;
 }
 function getNpmPackageName(str) {
-    const res = parse(str);
+    const res = parseNpmPackage(str);
     if (!res)
         return null;
     return res.pkgName;
 }
 function getNpmPackageImportPath(str) {
-    const res = parse(str);
+    const res = parseNpmPackage(str);
     if (!res)
         return null;
     return res.importPath;
 }
-function isValidPathAlias(alias) {
+function isPathAliasRecommended(alias) {
     // Cannot be distinguished from npm package names
     if (!isDistinguishable(alias))
         return false;
@@ -56,14 +56,14 @@ function isValidPathAlias(alias) {
     return true;
 }
 function isDistinguishable(alias) {
-    return (parse(alias) === null &&
-        parse(`${alias}fake-path`) === null &&
-        parse(`${alias}/fake-path`) === null &&
-        parse(`${alias}fake/deep/path`) === null &&
-        parse(`${alias}/fake/deep/path`) === null &&
+    return (parseNpmPackage(alias) === null &&
+        parseNpmPackage(`${alias}fake-path`) === null &&
+        parseNpmPackage(`${alias}/fake-path`) === null &&
+        parseNpmPackage(`${alias}fake/deep/path`) === null &&
+        parseNpmPackage(`${alias}/fake/deep/path`) === null &&
         // See note about '-' in ./isNpmPackageName.spec.ts
         // ```ts
-        // expect(parse('-')).toBe(null) // actually wrong: https://www.npmjs.com/package/-
+        // expect(parseNpmPackage('-')).toBe(null) // actually wrong: https://www.npmjs.com/package/-
         // ```
         !alias.startsWith('-'));
 }
@@ -71,7 +71,7 @@ function isDistinguishable(alias) {
 //  - https://www.npmjs.com/package/-
 // The correct logic is complex, see https://github.com/npm/validate-npm-package-name
 // We don't need to be accurate: are there npm packages with weird names that are actually being used?
-function parse(str) {
+function parseNpmPackage(str) {
     if (!str)
         return null;
     let scope = null;

package/dist/cjs/utils/path.js

@@ -44,6 +44,16 @@ function assertPosixPath(path) {
     (0, assert_js_1.assert)(path);
     (0, assert_js_1.assert)(!path.includes('\\'), errMsg(path));
 }
-function pathIsRelative(importPath) {
-    return importPath.startsWith('./') || importPath.startsWith('../');
+// See also `import { isImportPathRelative } from './isImportPath.js'`
+function pathIsRelative(path) {
+    assertPosixPath(path);
+    if (path.startsWith('./') || path.startsWith('../')) {
+        return true;
+    }
+    else {
+        /* Not true if `path` starts with a hidden directory  (i.e. a directory with a name that starts with `.`)
+        assert(!path.startsWith('.'))
+        */
+        return false;
+    }
 }

package/dist/cjs/utils/requireResolve.js

@@ -3,10 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.requireResolve = requireResolve;
 exports.requireResolveOptional = requireResolveOptional;
-exports.requireResolveNonUserFile = requireResolveNonUserFile;
-exports.requireResolveOptionalNonUserFile = requireResolveOptionalNonUserFile;
+exports.requireResolveOptionalDir = requireResolveOptionalDir;
+exports.requireResolveNpmPackage = requireResolveNpmPackage;
+exports.requireResolveVikeDistFile = requireResolveVikeDistFile;
+exports.getVikeNodeModulesRoot = getVikeNodeModulesRoot;
 const assert_js_1 = require("./assert.js");
 const assertIsNotBrowser_js_1 = require("./assertIsNotBrowser.js");
 const assertSetup_js_1 = require("./assertSetup.js");
@@ -14,68 +15,94 @@ const path_js_1 = require("./path.js");
 const isScriptFile_js_1 = require("./isScriptFile.js");
 const node_module_1 = require("node:module");
 const node_path_1 = __importDefault(require("node:path"));
+const parseNpmPackage_js_1 = require("./parseNpmPackage.js");
 // @ts-ignore `file:///${__filename.split('\\').join('/')}` is shimmed at dist/cjs by dist-cjs-fixup.js.
 const importMetaUrl = `file:///${__filename.split('\\').join('/')}`;
-const require_ = (0, node_module_1.createRequire)(importMetaUrl);
 (0, assertIsNotBrowser_js_1.assertIsNotBrowser)();
 (0, assertSetup_js_1.assertIsNotProductionRuntime)();
-function requireResolve_(importPath, cwd, options) {
-    (0, path_js_1.assertPosixPath)(cwd);
+function requireResolve_(importPath, importerFile, options) {
+    (0, path_js_1.assertPosixPath)(importerFile);
     (0, path_js_1.assertPosixPath)(importPath);
-    cwd = resolveCwd(cwd);
-    let clean = () => { };
+    (0, path_js_1.assertPosixPath)(importMetaUrl);
+    (0, assert_js_1.assert)(node_path_1.default.posix.basename(importerFile).includes('.'), { cwd: importerFile });
+    const importerPath = addFilePrefix(importerFile);
+    const require_ = (0, node_module_1.createRequire)(importerPath);
     if (!options?.doNotHandleFileExtension) {
-        clean = addFileExtensionsToRequireResolve();
+        addFileExtensionsToRequireResolve(require_);
         importPath = removeFileExtention(importPath);
     }
+    const paths = !options?.paths
+        ? undefined
+        : [
+            // Seems like `importerPath` gets overriden by the `paths` argument, so we add it to `paths`. (For example, passing an empty array to `paths` kills the argument passed to `createRequire()`.)
+            toDirPath(importerFile),
+            ...(options?.paths || [])
+        ];
     let importedFile;
     try {
         // We still can't use import.meta.resolve() as of 23.1.0 (November 2024) because `parent` argument requires an experimental flag.
         // - https://stackoverflow.com/questions/54977743/do-require-resolve-for-es-modules#comment139581675_62272600
-        importedFile = require_.resolve(importPath, { paths: [cwd] });
+        importedFile = require_.resolve(importPath, { paths });
     }
     catch (err) {
-        clean();
         return { importedFile: undefined, err, hasFailed: true };
     }
-    clean();
     importedFile = (0, path_js_1.toPosixPath)(importedFile);
     return { importedFile, err: undefined, hasFailed: false };
 }
-function requireResolveOptional(importPath, cwd) {
-    const res = requireResolve_(importPath, cwd);
+function requireResolveOptional({ importPath, importerFile, userRootDir }) {
+    const paths = getExtraPathsForNpmPackageImport({ importPath, userRootDir });
+    const res = requireResolve_(importPath, importerFile, { paths });
     if (res.hasFailed)
         return null;
     return res.importedFile;
 }
-function requireResolveOptionalNonUserFile(importPath, cwd) {
-    const res = requireResolve_(importPath, cwd, { doNotHandleFileExtension: true });
+function requireResolveOptionalDir({ importPath, importerDir, userRootDir }) {
+    const importerFile = getFakeFilePath(importerDir);
+    const paths = getExtraPathsForNpmPackageImport({ importPath, userRootDir });
+    const res = requireResolve_(importPath, importerFile, { paths });
     if (res.hasFailed)
         return null;
     return res.importedFile;
 }
-function requireResolveNonUserFile(importPath, cwd) {
-    const res = requireResolve_(importPath, cwd, { doNotHandleFileExtension: true });
+function requireResolveNpmPackage({ importPathNpmPackage, userRootDir }) {
+    (0, parseNpmPackage_js_1.assertIsImportPathNpmPackage)(importPathNpmPackage);
+    const importerFile = getFakeFilePath(userRootDir);
+    const paths = getExtraPathsForNpmPackageImport({ importPath: importPathNpmPackage, userRootDir });
+    const res = requireResolve_(importPathNpmPackage, importerFile, { paths });
     if (res.hasFailed)
         throw res.err;
     return res.importedFile;
 }
-function requireResolve(importPath, cwd) {
-    const res = requireResolve_(importPath, cwd);
-    if (res.hasFailed)
-        throw res.err;
-    return res.importedFile;
+function requireResolveVikeDistFile(vikeDistFile) {
+    const vikeNodeModulesRoot = getVikeNodeModulesRoot();
+    (0, path_js_1.assertPosixPath)(vikeNodeModulesRoot);
+    (0, path_js_1.assertPosixPath)(vikeDistFile);
+    const importedFile = node_path_1.default.posix.join(vikeNodeModulesRoot, vikeDistFile);
+    // Double check
+    {
+        const res = requireResolve_(importedFile, 
+        // Passing some dummy context as the context isn't needed since importerFile is already resolved and absolute
+        importMetaUrl, { doNotHandleFileExtension: true });
+        if (res.hasFailed)
+            throw res.err;
+        (0, assert_js_1.assert)(res.importedFile === importedFile);
+    }
+    return importedFile;
 }
-function resolveCwd(cwd) {
-    let prefix = 'file://';
-    if (process.platform === 'win32')
-        prefix += '/';
-    if (cwd.startsWith(prefix)) {
-        cwd = cwd.slice(prefix.length);
-        cwd = node_path_1.default.posix.dirname(cwd);
+function getExtraPathsForNpmPackageImport({ importPath, userRootDir }) {
+    if (
+    // Ideally we'd set `paths` only for npm packages, but unfortunately we cannot always disambiguate between npm package imports and path aliases.
+    !(0, parseNpmPackage_js_1.isImportPathNpmPackageOrPathAlias)(importPath)) {
+        return undefined;
     }
-    (0, assert_js_1.assert)(!cwd.startsWith('file:'));
-    return cwd;
+    const paths = [
+        // Workaround for monorepo resolve issue: https://github.com/vikejs/vike-react/pull/161/commits/dbaa6643e78015ac2797c237552800fef29b72a7
+        userRootDir,
+        // I can't think of a use case where this would be needed, but let's add it to be extra safe
+        toDirPath(importMetaUrl)
+    ];
+    return paths;
 }
 function removeFileExtention(importPath) {
     // Skip for Bun: https://github.com/vikejs/vike/issues/2204
@@ -93,7 +120,7 @@ function removeFileExtention(importPath) {
     }
     return importPath;
 }
-function addFileExtensionsToRequireResolve() {
+function addFileExtensionsToRequireResolve(require_) {
     const added = [];
     isScriptFile_js_1.scriptFileExtensionList.forEach((ext) => {
         (0, assert_js_1.assert)(!ext.includes('.'));
@@ -103,10 +130,42 @@ function addFileExtensionsToRequireResolve() {
             added.push(ext);
         }
     });
-    const clean = () => {
-        added.forEach((ext) => {
-            delete require_.extensions[ext];
-        });
-    };
-    return clean;
+}
+function getVikeNodeModulesRoot() {
+    // [RELATIVE_PATH_FROM_DIST] Current file: vike/dist/esm/utils/requireResolve.js
+    (0, assert_js_1.assert)(importMetaUrl.includes('/dist/esm/') || importMetaUrl.includes('/dist/cjs/'));
+    const vikeNodeModulesRoot = node_path_1.default.posix.join(removeFilePrefix(importMetaUrl), '../../../../');
+    return vikeNodeModulesRoot;
+}
+function toDirPath(filePath) {
+    return node_path_1.default.posix.dirname(removeFilePrefix(filePath));
+}
+function getFakeFilePath(dirPath) {
+    (0, path_js_1.assertPosixPath)(dirPath);
+    (0, assert_js_1.assert)(!dirPath.startsWith('file')); // The file:// prefix is bogus with path.join
+    const filePath = node_path_1.default.posix.join(dirPath, 'fakeFileForNodeResolve.js');
+    return filePath;
+}
+function addFilePrefix(filePath) {
+    const filePrefix = getFilePrefix();
+    if (!filePath.startsWith(filePrefix)) {
+        (0, assert_js_1.assert)(!filePath.startsWith('file'));
+        filePath = filePrefix + filePath;
+    }
+    (0, assert_js_1.assert)(filePath.startsWith(filePrefix));
+    return filePath;
+}
+function removeFilePrefix(filePath) {
+    const filePrefix = getFilePrefix();
+    if (filePath.startsWith(filePrefix)) {
+        filePath = filePath.slice(filePrefix.length);
+    }
+    (0, assert_js_1.assert)(!filePath.startsWith('file'));
+    return filePath;
+}
+function getFilePrefix() {
+    let prefix = 'file://';
+    if (process.platform === 'win32')
+        prefix += '/';
+    return prefix;
 }

package/dist/esm/node/plugin/plugins/baseUrls.js

@@ -2,7 +2,7 @@ export { baseUrls };
 import { resolveBase } from '../../shared/resolveBase.js';
 import { assert } from '../utils.js';
 import { getVikeConfig } from './importUserCode/v1-design/getVikeConfig.js';
-import { getVikeConfigPublic } from './commonConfig.js';
+import { getVikeConfigInternal } from './commonConfig.js';
 function baseUrls() {
     let basesResolved;
     return {
@@ -12,7 +12,7 @@ function baseUrls() {
             const isDev = config._isDev;
             assert(typeof isDev === 'boolean');
             const baseViteOriginal = config.base ?? '/__UNSET__'; // '/__UNSET__' because Vite resolves `_baseViteOriginal: null` to `undefined`
-            const vike = getVikeConfigPublic(config);
+            const vike = getVikeConfigInternal(config);
             basesResolved = resolveBase(baseViteOriginal, vike.config.baseServer ?? null, vike.config.baseAssets ?? null);
             // We cannot define these in configResolved() because Vite picks up the env variables before any configResolved() hook is called
             process.env.BASE_SERVER = basesResolved.baseServer;

package/dist/esm/node/plugin/plugins/build/handleAssetsManifest.js

@@ -15,7 +15,7 @@ import pc from '@brillout/picocolors';
 import { isV1Design } from '../importUserCode/v1-design/getVikeConfig.js';
 import { getOutDirs } from '../../shared/getOutDirs.js';
 import { isViteServerBuild_onlySsrEnv, isViteServerBuild } from '../../shared/isViteServerBuild.js';
-import { getVikeConfigPublic } from '../commonConfig.js';
+import { getVikeConfigInternal } from '../commonConfig.js';
 import { set_macro_ASSETS_MANIFEST } from './pluginBuildEntry.js';
 assertIsSingleModuleInstance('build/handleAssetsManifest.ts');
 let assetsJsonFilePath;
@@ -281,7 +281,7 @@ async function writeManifestFile(manifest, manifestFilePath) {
     await fs.writeFile(manifestFilePath, manifestFileContent, 'utf-8');
 }
 function handleAssetsManifest_getBuildConfig(config) {
-    const vike = getVikeConfigPublic(config);
+    const vike = getVikeConfigInternal(config);
     const isFixEnabled = handleAssetsManifest_isFixEnabled(config);
     return {
         // https://github.com/vikejs/vike/issues/1339

package/dist/esm/node/plugin/plugins/build/pluginBuildApp.js

@@ -2,7 +2,7 @@ export { pluginBuildApp };
 import { runPrerender_forceExit } from '../../../prerender/runPrerender.js';
 import { resolveOutDir } from '../../shared/getOutDirs.js';
 import { assert } from '../../utils.js';
-import { getVikeConfigPublic } from '../commonConfig.js';
+import { getVikeConfigInternal } from '../commonConfig.js';
 import { isPrerenderForceExit } from './pluginAutoFullBuild.js';
 function pluginBuildApp() {
     return [
@@ -10,7 +10,7 @@ function pluginBuildApp() {
             name: 'vike:build:pluginBuildApp',
             apply: 'build',
             config(config) {
-                const vike = getVikeConfigPublic(config);
+                const vike = getVikeConfigInternal(config);
                 if (!vike.config.vite6BuilderApp)
                     return;
                 return {

package/dist/esm/node/plugin/plugins/build/pluginBuildConfig.js

@@ -2,7 +2,7 @@ export { pluginBuildConfig };
 export { assertRollupInput };
 export { analyzeClientEntries };
 export { manifestTempFile };
-import { assert, addOnBeforeLogHook, removeFileExtention, unique, assertUsage, injectRollupInputs, normalizeRollupInput, onSetupBuild, assertIsNpmPackageImport, requireResolveNonUserFile } from '../../utils.js';
+import { assert, addOnBeforeLogHook, removeFileExtention, unique, assertUsage, injectRollupInputs, normalizeRollupInput, onSetupBuild, assertIsImportPathNpmPackage, requireResolveVikeDistFile } from '../../utils.js';
 import { getVikeConfig } from '../importUserCode/v1-design/getVikeConfig.js';
 import { findPageFiles } from '../../shared/findPageFiles.js';
 import { getVirtualFileIdPageConfigValuesAll } from '../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
@@ -13,8 +13,6 @@ import { getConfigValueBuildTime } from '../../../../shared/page-configs/getConf
 import { isViteServerBuild } from '../../shared/isViteServerBuild.js';
 import { resolveOutDir } from '../../shared/getOutDirs.js';
 import { handleAssetsManifest_assertUsageCssCodeSplit, handleAssetsManifest_getBuildConfig } from './handleAssetsManifest.js';
-// @ts-ignore import.meta.url is shimmed at dist/cjs by dist-cjs-fixup.js.
-const importMetaUrl = import.meta.url;
 const manifestTempFile = '_temp_manifest.json';
 function pluginBuildConfig() {
     let config;
@@ -81,8 +79,8 @@ async function getEntries(config) {
             ...clientEntries,
             ...pageFileEntries
         };
-        const clientRoutingEntry = resolve(`dist/esm/client/client-routing-runtime/entry.js`);
-        const serverRoutingEntry = resolve(`dist/esm/client/server-routing-runtime/entry.js`);
+        const clientRoutingEntry = requireResolveVikeDistFile('dist/esm/client/client-routing-runtime/entry.js');
+        const serverRoutingEntry = requireResolveVikeDistFile('dist/esm/client/server-routing-runtime/entry.js');
         if (hasClientRouting) {
             entries['entries/entry-client-routing'] = clientRoutingEntry;
         }
@@ -156,7 +154,7 @@ async function getPageFileEntries(config, includeAssetsImportedByServer) {
 }
 function getEntryFromClientEntry(clientEntry, config, addExtractAssetsQuery) {
     if (!clientEntry.startsWith('/')) {
-        assertIsNpmPackageImport(clientEntry);
+        assertIsImportPathNpmPackage(clientEntry);
         const entryTarget = clientEntry;
         const entryName = prependEntriesDir(clientEntry);
         return { entryName, entryTarget };
@@ -192,11 +190,6 @@ function getEntryFromPageConfig(pageConfig, isForClientSide) {
     assert(!entryName.endsWith('/'));
     return { entryName, entryTarget };
 }
-function resolve(filePath) {
-    assert(filePath.startsWith('dist/'));
-    // [RELATIVE_PATH_FROM_DIST] Current directory: node_modules/vike/dist/esm/node/plugin/plugins/build/
-    return requireResolveNonUserFile(`../../../../../../${filePath}`, importMetaUrl);
-}
 function addLogHook() {
     const tty = process.stdout.isTTY && !process.env.CI; // Equals https://github.com/vitejs/vite/blob/193d55c7b9cbfec5b79ebfca276d4a721e7de14d/packages/vite/src/node/plugins/reporter.ts#L27
     if (!tty)

package/dist/esm/node/plugin/plugins/build/pluginBuildEntry.js

@@ -2,11 +2,9 @@ export { pluginBuildEntry };
 export { set_macro_ASSETS_MANIFEST };
 import { serverProductionEntryPlugin } from '@brillout/vite-plugin-server-entry/plugin';
 import { virtualFileIdImportUserCodeServer } from '../../../shared/virtual-files/virtualFileImportUserCode.js';
-import { assert, PROJECT_VERSION, requireResolveNonUserFile } from '../../utils.js';
+import { assert, PROJECT_VERSION, requireResolveVikeDistFile } from '../../utils.js';
 import fs from 'fs/promises';
 import path from 'path';
-// @ts-ignore import.meta.url is shimmed at dist/cjs by dist-cjs-fixup.js.
-const importMetaUrl = import.meta.url;
 import { isUsingClientRouter } from '../extractExportNamesPlugin.js';
 import { assertBuildInfo } from '../../../runtime/globalContext.js';
 import { getOutDirs } from '../../shared/getOutDirs.js';
@@ -93,8 +91,7 @@ function find_ASSETS_MANIFEST(bundle) {
 }
 function getImportPath(config) {
     // We resolve filePathAbsolute even if we don't use it: we use require.resolve() as an assertion that the relative path is correct
-    // [RELATIVE_PATH_FROM_DIST] Current file: node_modules/vike/dist/esm/node/plugin/plugins/pluginBuildEntry/index.js
-    const filePathAbsolute = requireResolveNonUserFile(`../../../../../../dist/esm/__internal/index.js`, importMetaUrl);
+    const filePathAbsolute = requireResolveVikeDistFile('dist/esm/__internal/index.js');
     if (
     // Let's implement a new config if a user needs the import to be a relative path instead of 'vike/__internal' (AFAIK a relative path is needed only if a framework has npm package 'vike' as direct dependency instead of a peer dependency and if the user of that framework uses pnpm)
     true) {

package/dist/esm/node/plugin/plugins/commonConfig/assertResolveAlias.js

@@ -1,5 +1,5 @@
 export { assertResolveAlias };
-import { assert, assertUsage, assertWarning, isArray, isValidPathAlias } from '../../utils.js';
+import { assert, assertUsage, assertWarning, isArray, isPathAliasRecommended } from '../../utils.js';
 import pc from '@brillout/picocolors';
 // Recommend users to avoid un-distinguishable path aliases.
 // There are a lot of libraries that don't or cannot follow that recommendation, for example:
@@ -59,7 +59,7 @@ function assertResolveAlias(config) {
             //  - determineOptimizeDeps()
             //  - extractAssets
             //  - in general: using un-distinguishable path aliases is asking for trouble
-            if (!isValidPathAlias(find)) {
+            if (!isPathAliasRecommended(find)) {
                 if (find.startsWith('@')) {
                     const msg = `${errPrefix} defines an invalid resolve.alias ${deprecation}: a path alias cannot start with ${pc.cyan('@')}, ${errSuffix1}`;
                     assertWarning(false, msg, { onlyOnce: true });

package/dist/esm/node/plugin/plugins/commonConfig.d.ts

@@ -1,5 +1,6 @@
 export { commonConfig };
 export { getVikeConfigPublic };
+export { getVikeConfigInternal };
 export type { VikeConfigPublic };
 import { type InlineConfig, type Plugin, type ResolvedConfig, type UserConfig } from 'vite';
 import { type VikeConfigObject } from './importUserCode/v1-design/getVikeConfig.js';
@@ -34,4 +35,5 @@ declare function commonConfig(vikeVitePluginOptions: unknown): Plugin[];
  *
  * https://vike.dev/getVikeConfig
  */
+declare function getVikeConfigInternal(config: ResolvedConfig | UserConfig): VikeConfigPublic;
 declare function getVikeConfigPublic(config: ResolvedConfig | UserConfig): VikeConfigPublic;

package/dist/esm/node/plugin/plugins/commonConfig.js

@@ -1,6 +1,7 @@
 export { commonConfig };
 export { getVikeConfigPublic };
-import { assert, assertUsage, assertWarning, findPackageJson, hasProp, isDevCheck, isDocker, isObject } from '../utils.js';
+export { getVikeConfigInternal };
+import { assert, assertUsage, assertWarning, findPackageJson, hasProp, isDevCheck, isDocker, isObject, isVitest } from '../utils.js';
 import { assertRollupInput } from './build/pluginBuildConfig.js';
 import { installRequireShim_setUserRootDir } from '@brillout/require-shim';
 import pc from '@brillout/picocolors';
@@ -85,7 +86,7 @@ function commonConfig(vikeVitePluginOptions) {
                 order: 'post',
                 handler(configFromUser) {
                     let configFromVike = { server: {}, preview: {} };
-                    const vike = getVikeConfigPublic(configFromUser);
+                    const vike = getVikeConfigInternal(configFromUser);
                     if (vike.config.port !== undefined) {
                         // https://vike.dev/port
                         setDefault('port', vike.config.port, configFromUser, configFromVike);
@@ -152,6 +153,8 @@ function assertSingleInstance(config) {
 function assertVikeCliOrApi(config) {
     if (isVikeCliOrApi())
         return;
+    if (isVitest())
+        return;
     if (isViteCliCall()) {
         assertWarning(false, `Vite's CLI is deprecated ${pc.underline('https://vike.dev/migration/cli')}`, {
             onlyOnce: true
@@ -191,7 +194,7 @@ function temp_supportOldInterface(config) {
 }
 // TODO/soon rename:
 // - `getVikeConfig()` => `resolveVikeConfig()` ?
-// - `getVikeConfigPublic()` => `getVikeConfig()`
+// - `getVikeConfigInternal()` => `getVikeConfig()`
 // - `VikeConfigPublic` => `VikeConfig` ?
 // - `VikeConfigObject` => `VikeConfigInternal` ?
 /**
@@ -199,11 +202,16 @@ function temp_supportOldInterface(config) {
  *
  * https://vike.dev/getVikeConfig
  */
-function getVikeConfigPublic(config) {
+function getVikeConfigInternal(config) {
     const vikeConfig = config._vike;
     assert(vikeConfig);
     return vikeConfig;
 }
+function getVikeConfigPublic(config) {
+    const vikeConfig = config._vike;
+    assertUsage(vikeConfig, "getVikeConfig() can only be used when Vite is running with Vike's Vite plugin");
+    return vikeConfig;
+}
 // Only emit dist/server/entry.mjs if necessary
 function emitServerEntryOnlyIfNeeded(config) {
     if (config.vitePluginServerEntry?.inject &&

package/dist/esm/node/plugin/plugins/devConfig/determineFsAllowList.js

@@ -1,7 +1,7 @@
 export { determineFsAllowList };
 import { searchForWorkspaceRoot } from 'vite';
 import path from 'node:path';
-import { assert, assertPosixPath, requireResolveNonUserFile } from '../../utils.js';
+import { assert, assertPosixPath, getVikeNodeModulesRoot } from '../../utils.js';
 import { fileURLToPath } from 'url';
 // @ts-ignore import.meta.url is shimmed at dist/cjs by dist-cjs-fixup.js.
 const importMetaUrl = import.meta.url;
@@ -18,11 +18,6 @@ async function determineFsAllowList(config) {
     // We add it again just to be sure.
     fsAllow.push(searchForWorkspaceRoot(process.cwd()));
     // Add node_modules/vike/
-    {
-        // [RELATIVE_PATH_FROM_DIST] Current directory: node_modules/vike/dist/esm/node/plugin/plugins/config/
-        const vikeRoot = path.posix.join(__dirname_, '../../../../../../');
-        // Assert that `vikeRoot` is indeed pointing to `node_modules/vike/`
-        requireResolveNonUserFile(`${vikeRoot}/dist/esm/node/plugin/plugins/devConfig/index.js`, importMetaUrl);
-        fsAllow.push(vikeRoot);
-    }
+    const vikeNodeModulesRoot = getVikeNodeModulesRoot();
+    fsAllow.push(vikeNodeModulesRoot);
 }

package/dist/esm/node/plugin/plugins/devConfig/determineOptimizeDeps.js

@@ -1,6 +1,6 @@
 export { determineOptimizeDeps };
 import { findPageFiles } from '../../shared/findPageFiles.js';
-import { assert, assertIsNpmPackageImport, createDebugger, isArray, unique } from '../../utils.js';
+import { assert, assertIsImportPathNpmPackage, createDebugger, isArray, unique } from '../../utils.js';
 import { getVikeConfig, isOverriden } from '../importUserCode/v1-design/getVikeConfig.js';
 import { analyzeClientEntries } from '../build/pluginBuildConfig.js';
 import { virtualFileIdImportUserCodeClientCR, virtualFileIdImportUserCodeClientSR } from '../../../shared/virtual-files/virtualFileImportUserCode.js';
@@ -38,7 +38,7 @@ async function getPageDeps(config, pageConfigs) {
     const addInclude = (e) => {
         assert(e);
         // Shouldn't be a path alias, as path aliases would need to be added to config.optimizeDeps.entries instead of config.optimizeDeps.include
-        assertIsNpmPackageImport(e);
+        assertIsImportPathNpmPackage(e);
         include.push(e);
     };
     // V1 design

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/loadFileAtConfigTime.js

@@ -7,7 +7,7 @@ import { transpileAndExecuteFile } from './transpileAndExecuteFile.js';
 import { getConfigDefinitionOptional } from '../getVikeConfig.js';
 import { assertPlusFileExport } from '../../../../../../shared/page-configs/assertPlusFileExport.js';
 import pc from '@brillout/picocolors';
-import { parsePointerImportData } from './transformPointerImports.js';
+import { parsePointerImportData } from './pointerImports.js';
 import { getConfigFileExport } from './getConfigFileExport.js';
 import { resolvePointerImportData } from './resolvePointerImport.js';
 import { getConfigDefinedAt } from '../../../../../../shared/page-configs/getConfigDefinedAt.js';

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/{transformPointerImports.d.ts → pointerImports.d.ts}

@@ -1,6 +1,7 @@
 export { transformPointerImports };
 export { parsePointerImportData };
 export { isPointerImportData };
+export { assertPointerImportPath };
 export type { PointerImportData };
 declare function transformPointerImports(code: string, filePathToShowToUser2: string, pointerImports: Record<string, boolean> | 'all', skipWarnings?: true): string | null;
 /**
@@ -23,6 +24,7 @@ type PointerImportData = {
 };
 declare function isPointerImportData(str: string): boolean;
 declare function parsePointerImportData(importString: string): null | PointerImportData;
+declare function assertPointerImportPath(importPath: string): boolean;
 declare module 'estree' {
     interface BaseNodeWithoutComments {
         start: number;

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/{transformPointerImports.js → pointerImports.js}

@@ -1,6 +1,7 @@
 export { transformPointerImports };
 export { parsePointerImportData };
 export { isPointerImportData };
+export { assertPointerImportPath };
 // Playground: https://github.com/brillout/acorn-playground
 // Notes about `with { type: 'pointer' }`
 // - It works well with TypeScript: it doesn't complain upon `with { type: 'unknown-to-typescript' }` and go-to-definition & types are preserved: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-3.html#import-attributes
@@ -17,7 +18,7 @@ export { isPointerImportData };
 //   - Esbuild removes comments: https://github.com/evanw/esbuild/issues/1439#issuecomment-877656182
 //   - Using source maps to track these magic comments is brittle (source maps can easily break)
 import { parse } from 'acorn';
-import { assert, assertUsage, assertWarning, styleFileRE } from '../../../../utils.js';
+import { assert, assertUsage, assertWarning, isFilePathAbsolute, isImportPath, styleFileRE } from '../../../../utils.js';
 import pc from '@brillout/picocolors';
 function transformPointerImports(code, filePathToShowToUser2, pointerImports, 
 // For ./transformPointerImports.spec.ts
@@ -144,8 +145,20 @@ function parsePointerImportData(importString) {
     assert(parts.length >= 2);
     const exportName = parts[parts.length - 1];
     const importPath = parts.slice(0, -1).join(SEP);
+    if (importPath.startsWith('.') && !(importPath.startsWith('./') || importPath.startsWith('../'))) {
+        assert(!importStringWasGenerated);
+        assertUsage(false, `Invalid relative import path ${pc.code(importPath)} defined by ${pc.code(JSON.stringify(importString))} because it should start with ${pc.code('./')} or ${pc.code('../')}, or use an npm package import instead.`);
+    }
+    assertPointerImportPath(importPath);
     return { importPath, exportName, importStringWasGenerated, importString };
 }
+// `importPath` is one of the following:
+// - A relative import path
+// - An npm package import
+// - A filesystem absolute path, see transpileWithEsbuild()
+function assertPointerImportPath(importPath) {
+    return isImportPath(importPath) || isFilePathAbsolute(importPath);
+}
 function spliceMany(str, operations) {
     let strMod = '';
     let endPrev;

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/resolvePointerImport.d.ts

@@ -2,7 +2,7 @@ export { resolvePointerImport };
 export { resolvePointerImportData };
 export type { PointerImport };
 import type { DefinedAtFilePath } from '../../../../../../shared/page-configs/PageConfig.js';
-import { type PointerImportData } from './transformPointerImports.js';
+import { type PointerImportData } from './pointerImports.js';
 import type { FilePath, FilePathResolved } from '../../../../../../shared/page-configs/FilePath.js';
 type PointerImport = {
     fileExportPath: FileExportPath;