vike 0.4.254 → 0.4.255

package/dist/node/vite/plugins/build/pluginBuildConfig.js

@@ -4,7 +4,7 @@ export { analyzeClientEntries };
 import { assert, setAssertOnBeforeLog, assertUsage } from '../../../../utils/assert.js';
 import { onSetupBuild } from '../../../../utils/assertSetup.js';
 import { injectRollupInputs, normalizeRollupInput } from '../../../../utils/injectRollupInputs.js';
-import { assertIsImportPathNpmPackage } from '../../../../utils/parseNpmPackage.js';
+import { assertImportIsNpmPackage } from '../../../../utils/parseNpmPackage.js';
 import { removeFileExtension } from '../../../../utils/removeFileExtension.js';
 import { requireResolveDistFile } from '../../../../utils/requireResolve.js';
 import { unique } from '../../../../utils/unique.js';
@@ -154,7 +154,7 @@ async function getPageFileEntries(config, includeAssetsImportedByServer) {
 }
 function getEntryFromClientEntry(clientEntry, config, addExtractAssetsQuery) {
     if (!clientEntry.startsWith('/')) {
-        assertIsImportPathNpmPackage(clientEntry);
+        assertImportIsNpmPackage(clientEntry);
         const entryTarget = clientEntry;
         const entryName = prependEntriesDir(clientEntry);
         return { entryName, entryTarget };

package/dist/node/vite/plugins/pluginCommon/assertResolveAlias.js

@@ -1,7 +1,7 @@
 export { assertResolveAlias };
 import { assert, assertUsage, assertWarning } from '../../../../utils/assert.js';
 import { isArray } from '../../../../utils/isArray.js';
-import { isPathAliasRecommended } from '../../../../utils/parseNpmPackage.js';
+import { isPathAliasRecommendation } from '../../../../utils/parseNpmPackage.js';
 import pc from '@brillout/picocolors';
 import '../../assertEnvVite.js';
 // Recommend users to avoid un-distinguishable path aliases.
@@ -62,7 +62,7 @@ function assertResolveAlias(config) {
             //  - resolveOptimizeDeps()
             //  - extractAssets
             //  - in general: using un-distinguishable path aliases is asking for trouble
-            if (!isPathAliasRecommended(find)) {
+            if (!isPathAliasRecommendation(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/node/vite/plugins/pluginDev/optimizeDeps.js

@@ -5,7 +5,7 @@ import { assert } from '../../../../utils/assert.js';
 import { createDebug } from '../../../../utils/debug.js';
 import { isArray } from '../../../../utils/isArray.js';
 import { isFilePathAbsoluteFilesystem } from '../../../../utils/isFilePathAbsoluteFilesystem.js';
-import { assertIsImportPathNpmPackage, getNpmPackageName } from '../../../../utils/parseNpmPackage.js';
+import { assertImportIsNpmPackage, getNpmPackageName } from '../../../../utils/parseNpmPackage.js';
 import { requireResolveOptional } from '../../../../utils/requireResolve.js';
 import { isVirtualFileId } from '../../../../utils/virtualFileId.js';
 import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
@@ -146,7 +146,7 @@ async function getPageDeps(config, pageConfigs) {
         // optimizeDeps.include expects npm packages
         assert(!e.startsWith('/'));
         // Shouldn't be a path alias, as path aliases would need to be added to optimizeDeps.entries instead of optimizeDeps.include
-        assertIsImportPathNpmPackage(e);
+        assertImportIsNpmPackage(e);
         if (isExcluded(e, isForClientSide, definedAt))
             return;
         if (isForClientSide) {

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

@@ -1,8 +1,8 @@
 export { pluginStripPointerImportAttribute };
 import { getMagicString } from '../shared/getMagicString.js';
 import '../assertEnvVite.js';
-// Match `with { type: 'vike-pointer' }` (with optional whitespace variations)
-const runtimeAttrRE = /\bwith\s*\{\s*type\s*:\s*['"]vike-pointer['"]\s*\}/g;
+// Match `with { type: 'vike:pointer' }` (with optional whitespace variations)
+const runtimeAttrRE = /\bwith\s*\{\s*type\s*:\s*['"]vike:pointer['"]\s*\}/g;
 function pluginStripPointerImportAttribute() {
     return [
         {
@@ -10,7 +10,7 @@ function pluginStripPointerImportAttribute() {
             transform: {
                 filter: {
                     code: {
-                        include: 'vike-pointer',
+                        include: 'vike:pointer',
                     },
                 },
                 handler(code, id) {

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

@@ -1,6 +1,6 @@
 export { getClientEntrySrcDev };
 import { assertIsNotProductionRuntime } from '../../../utils/assertSetup.js';
-import { assertIsImportPathNpmPackage } from '../../../utils/parseNpmPackage.js';
+import { assertImportIsNpmPackage } from '../../../utils/parseNpmPackage.js';
 import { toPosixPath, pathJoin } from '../../../utils/path.js';
 import { requireResolveNpmPackage, requireResolveDistFile } from '../../../utils/requireResolve.js';
 import { assert } from '../../../utils/assert.js';
@@ -32,7 +32,7 @@ function getClientEntrySrcDev(clientEntry, viteDevServer) {
             filePath = requireResolveDistFile(`dist/${clientEntry.replace('@@vike/dist/', '')}`);
         }
         else {
-            assertIsImportPathNpmPackage(clientEntry);
+            assertImportIsNpmPackage(clientEntry);
             filePath = requireResolveNpmPackage({ importPathNpmPackage: clientEntry, userRootDir });
         }
     }

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

@@ -7,7 +7,7 @@ export { cleanFilePathUnknown };
 export { assertModuleId };
 import path from 'node:path';
 import { assertFilePathAbsoluteFilesystem } from '../../../utils/isFilePathAbsoluteFilesystem.js';
-import { assertIsImportPathNpmPackage } from '../../../utils/parseNpmPackage.js';
+import { assertImportIsNpmPackage } from '../../../utils/parseNpmPackage.js';
 import { toPosixPath } from '../../../utils/path.js';
 import { assert } from '../../../utils/assert.js';
 import { assertPosixPath } from '../../../utils/path.js';
@@ -43,7 +43,7 @@ function getComputedProps(args) {
         const importPathAbsolute = args.importPathAbsolute ?? null;
         const { filePathAbsoluteUserRootDir } = args;
         if (importPathAbsolute)
-            assertIsImportPathNpmPackage(importPathAbsolute);
+            assertImportIsNpmPackage(importPathAbsolute);
         return {
             importPathAbsolute,
             filePathAbsoluteUserRootDir,
@@ -57,7 +57,7 @@ function getComputedProps(args) {
 }
 function getComputedPropsImportPathAbsolute(args) {
     const { importPathAbsolute } = args;
-    assertIsImportPathNpmPackage(importPathAbsolute);
+    assertImportIsNpmPackage(importPathAbsolute);
     return {
         filePathAbsoluteUserRootDir: null,
         importPathAbsolute,

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

@@ -1,6 +1,5 @@
 export { transformPointerImports };
 export { parsePointerImportData };
-export { isPointerImportData };
 export { assertPointerImportPath };
 export type { PointerImportData };
 import '../../assertEnvVite.js';
@@ -23,7 +22,6 @@ type PointerImportData = {
     importString: string;
     importStringWasGenerated: boolean;
 };
-declare function isPointerImportData(str: string): boolean;
 declare function parsePointerImportData(importString: string): null | PointerImportData;
 declare function assertPointerImportPath(importPath: string): boolean;
 declare module 'estree' {

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

@@ -1,6 +1,5 @@
 export { transformPointerImports };
 export { parsePointerImportData };
-export { isPointerImportData };
 export { assertPointerImportPath };
 // Playground: https://github.com/brillout/acorn-playground
 // Notes about `with { type: 'pointer' }`
@@ -30,6 +29,10 @@ function transformPointerImports(code, filePathToShowToUser2, pointerImports,
 // For ./transformPointerImports.spec.ts
 skipWarnings) {
     const spliceOperations = [];
+    // Collect all const declarations to prepend at the top, so that they are
+    // available before any code runs (import declarations are hoisted but const
+    // is not, so we must place them at the top to avoid TDZ errors).
+    const constDeclarations = [];
     // Performance trick
     if (!code.includes('import'))
         return null;
@@ -78,7 +81,7 @@ skipWarnings) {
                 assertWarning(false, errMsg, { onlyOnce: true });
             }
         }
-        let replacement = '';
+        let constDeclaration = '';
         node.specifiers.forEach((specifier) => {
             assert(specifier.type === 'ImportSpecifier' ||
                 specifier.type === 'ImportDefaultSpecifier' ||
@@ -97,16 +100,23 @@ skipWarnings) {
                 return importLocalName;
             })();
             const importString = serializePointerImportData({ importPath, exportName, importStringWasGenerated: true });
-            replacement += `const ${importLocalName} = '${importString}';`;
+            constDeclaration += `const ${importLocalName} = '${importString}';`;
         });
+        if (constDeclaration)
+            constDeclarations.push(constDeclaration);
+        // Replace the import with blank lines to preserve source map line numbers.
         spliceOperations.push({
             start,
             end,
-            replacement,
+            replacement: '\n'.repeat(importStatementCode.split('\n').length - 1),
         });
     });
-    const codeMod = spliceMany(code, spliceOperations);
-    return codeMod;
+    if (constDeclarations.length === 0 && spliceOperations.length === 0)
+        return null;
+    const codeWithImportsRemoved = spliceMany(code, spliceOperations);
+    if (constDeclarations.length === 0)
+        return codeWithImportsRemoved;
+    return constDeclarations.join('') + '\n' + codeWithImportsRemoved;
 }
 function getImports(code) {
     const result = parseSync(code, {

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

@@ -4,7 +4,7 @@ import pc from '@brillout/picocolors';
 import { assert, assertUsage } from '../../../../utils/assert.js';
 import { isFilePathAbsolute } from '../../../../utils/isFilePathAbsoluteFilesystem.js';
 import { isImportPathRelative } from '../../../../utils/isImportPath.js';
-import { isImportPathNpmPackageOrPathAlias } from '../../../../utils/parseNpmPackage.js';
+import { isImportNpmPackageOrPathAlias } from '../../../../utils/parseNpmPackage.js';
 import { assertPosixPath } from '../../../../utils/path.js';
 import { requireResolveOptional } from '../../../../utils/requireResolve.js';
 import { assertPointerImportPath, parsePointerImportData } from './pointerImports.js';
@@ -50,7 +50,7 @@ function resolvePointerImportData(pointerImportData, importerFilePath, userRootD
         filePath = getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir });
     }
     else {
-        assert(isImportPathNpmPackageOrPathAlias(importPath));
+        assert(isImportNpmPackageOrPathAlias(importPath));
         const importPathAbsolute = importPath;
         if (filePathAbsoluteFilesystem) {
             filePath = getFilePathResolved({

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

@@ -15,9 +15,9 @@ import { genPromise } from '../../../../utils/genPromise.js';
 import { assertFilePathAbsoluteFilesystem } from '../../../../utils/isFilePathAbsoluteFilesystem.js';
 import { isImportPathRelative } from '../../../../utils/isImportPath.js';
 import { isObject } from '../../../../utils/isObject.js';
-import { isPlainScriptFile } from '../../../../utils/isScriptFile.js';
+import { isPlainJavaScriptFile, isPlainScriptFile } from '../../../../utils/isScriptFile.js';
 import { isVitest } from '../../../../utils/isVitest.js';
-import { assertIsImportPathNpmPackage, isImportPathNpmPackageOrPathAlias } from '../../../../utils/parseNpmPackage.js';
+import { assertImportIsNpmPackage, isImportNpmPackageOrPathAlias } from '../../../../utils/parseNpmPackage.js';
 import { assertPosixPath, toPosixPath } from '../../../../utils/path.js';
 import { requireResolveOptionalDir } from '../../../../utils/requireResolve.js';
 import { transformPointerImports } from './pointerImports.js';
@@ -179,10 +179,10 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports, esb
                     const importPathOriginal = args.path;
                     // Esbuild resolves path aliases.
                     // - Enabling us to use:
-                    //   - assertIsImportPathNpmPackage()
-                    //   - isImportPathNpmPackage(str, { cannotBePathAlias: true })
+                    //   - assertImportIsNpmPackage()
+                    //   - isImportNpmPackage(str, { cannotBePathAlias: true })
                     assertFilePathAbsoluteFilesystem(importPathResolved);
-                    //  Should be remove this? See comment below.
+                    //  Should we remove this? See comment below.
                     const isVikeExtensionImport = (path.startsWith('vike-') && path.endsWith('/config')) || importPathResolved.endsWith('+config.js');
                     const isPointerImport = transformImports === 'all' ||
                         // .jsx, .vue, .svg, ... => obviously not config code => pointer import
@@ -193,32 +193,20 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports, esb
                         //      - vike@0.4.162 started soft-requiring Vike extensions to set the name config.
                         //    - In practice, it seems like it requires some (non-trivial?) refactoring.
                         isVikeExtensionImport ||
-                        args.with?.['type'] === 'vike-pointer';
+                        args.with?.['type'] === 'vike:pointer';
                     assertPosixPath(importPathResolved);
-                    // `isNpmPkgImport` => `importPathOriginal` is most likely an npm package import, but it can also be a path alias that a) looks like an npm package import and b) resolves outside of `userRootDir`.
-                    const isNpmPkgImport = (() => {
-                        if (importPathResolved.includes('/node_modules/')) {
-                            // So far I can't think of a use case where this assertion would fail, but let's eventually remove it to avoid artificially restricting the user.
-                            assert(isImportPathNpmPackageOrPathAlias(importPathOriginal));
-                            return true;
-                        }
-                        // Linked npm packages
-                        if (
-                        // Assuming path aliases usually resolve inside `userRootDir`.
-                        // - This isn't always the case: https://github.com/vikejs/vike/issues/2326
-                        !importPathResolved.startsWith(userRootDir) &&
-                            // False positive if `importPathOriginal` is a path alias that a) looks like an npm package import and b) resolves outside of `userRootDir` => we then we wrongfully assume that `importPathOriginal` is an npm package import.
-                            isImportPathNpmPackageOrPathAlias(importPathOriginal)) {
-                            return true;
-                        }
-                        return false;
-                    })();
+                    // False positive if `importPathOriginal` is a path alias that a) looks like an npm package import and b) resolves outside of `userRootDir` => we then we wrongfully assume that `importPathOriginal` is an npm package import.
+                    // - For example: https://github.com/vikejs/vike/issues/2326
+                    const isMostLikelyNpmPkgImport = isImportNpmPackageOrPathAlias(importPathOriginal) &&
+                        (importPathResolved.includes('/node_modules/') ||
+                            // Linked npm package
+                            !importPathResolved.startsWith(userRootDir));
                     const isExternal = isPointerImport ||
                         // Performance: npm package imports can be externalized. (We could as well let esbuild transpile /node_modules/ code but it's useless as /node_modules/ code is already built. It would unnecessarily slow down transpilation.)
-                        isNpmPkgImport;
+                        (isMostLikelyNpmPkgImport && isPlainJavaScriptFile(importPathResolved));
                     if (!isExternal) {
                         // User-land config code (i.e. not runtime code) => let esbuild transpile it
-                        assert(!isPointerImport && !isNpmPkgImport);
+                        assert(!isPointerImport);
                         if (debug.isActivated)
                             debug('onResolve() [non-external]', { args, resolved, isPointerImport, isExternal });
                         return resolved;
@@ -236,7 +224,7 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports, esb
                             filePathAbsoluteFilesystem: importPathResolved,
                             userRootDir,
                         });
-                        if (filePathAbsoluteUserRootDir && !isNpmPkgImport) {
+                        if (filePathAbsoluteUserRootDir && !isMostLikelyNpmPkgImport) {
                             // `importPathOriginal` is most likely a path alias.
                             // - We have to use esbuild's path alias resolution, because:
                             //   - Vike doesn't resolve path aliases at all.
@@ -246,19 +234,13 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports, esb
                         }
                         else {
                             // `importPathOriginal` is most likely an npm package import.
-                            assertIsImportPathNpmPackage(importPathOriginal);
+                            assertImportIsNpmPackage(importPathOriginal);
                             // For improved error messages, let the resolution be handled by Vike or Node.js.
                             importPathTranspiled = importPathOriginal;
                         }
                     }
                     if (debug.isActivated)
                         debug('onResolve() [external]', { args, resolved, importPathTranspiled, isPointerImport, isExternal });
-                    assert(isExternal);
-                    assert(
-                    // Import of runtime code => handled by Vike
-                    isPointerImport ||
-                        // Import of config code => loaded by Node.js at build-time
-                        isNpmPkgImport);
                     pointerImports[importPathTranspiled] = isPointerImport;
                     return { external: true, path: importPathTranspiled };
                 });

package/dist/server/runtime/renderPageServer/getPageAssets/getManifestEntry.js

@@ -1,6 +1,6 @@
 export { getManifestEntry };
 import { slice } from '../../../../utils/slice.js';
-import { assertIsImportPathNpmPackage } from '../../../../utils/parseNpmPackage.js';
+import { assertImportIsNpmPackage } from '../../../../utils/parseNpmPackage.js';
 import { assert } from '../../../../utils/assert.js';
 import { parseVirtualFileId } from '../../../../shared-server-node/virtualFileId.js';
 import { prependEntriesDir } from '../../../../shared-server-node/prependEntriesDir.js';
@@ -44,7 +44,7 @@ function getManifestEntry(id, assetsManifest) {
         return { manifestEntry, manifestKey };
     }
     // npm package import
-    assertIsImportPathNpmPackage(id);
+    assertImportIsNpmPackage(id);
     const found = Object.entries(assetsManifest).find(([, e]) => e.name === prependEntriesDir(id));
     assert(found);
     const [manifestKey, manifestEntry] = found;

package/dist/server/runtime/renderPageServer/getPageAssets/retrievePageAssetsProd.js

@@ -1,6 +1,6 @@
 export { retrievePageAssetsProd };
 export { resolveIncludeAssetsImportedByServer };
-import { isImportPathNpmPackage } from '../../../../utils/parseNpmPackage.js';
+import { isImportNpmPackage } from '../../../../utils/parseNpmPackage.js';
 import { assert } from '../../../../utils/assert.js';
 import { getManifestEntry } from './getManifestEntry.js';
 import { extractAssetsAddQuery } from '../../../../shared-server-node/extractAssetsQuery.js';
@@ -30,7 +30,7 @@ function getAssetsUrl(clientDependencies, assetsManifest, config) {
             onlyAssets &&
             id.includes('.page.server.') &&
             // We assume that all npm packages have already built their files: bundlers (Rollup, esbuild, tsup, ...) extract the CSS out of JavaScript => we can assume JavaScript to not import any CSS/assets.
-            !isImportPathNpmPackage(id, {
+            !isImportNpmPackage(id, {
                 // I presume Vite already resolves path aliases when Vite sets the module's id
                 cannotBePathAlias: true,
             })) {

package/dist/shared-server-client/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(isImportPathNpmPackage(filePath), filePath) // `.css` page files are only supported for npm packages
+            assert(isImportNpmPackage(filePath), filePath) // `.css` page files are only supported for npm packages
             */
             return '.css';
         }

package/dist/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.254";
+export declare const PROJECT_VERSION: "0.4.255";

package/dist/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.254';
+export const PROJECT_VERSION = '0.4.255';

package/dist/utils/isImportPath.js

@@ -2,9 +2,9 @@ export { isImportPath };
 export { isImportPathRelative };
 import { assertPosixPath } from './path.js';
 import { assert } from './assert.js';
-import { isImportPathNpmPackageOrPathAlias } from './parseNpmPackage.js';
+import { isImportNpmPackageOrPathAlias } from './parseNpmPackage.js';
 function isImportPath(importPath) {
-    return isImportPathRelative(importPath) || isImportPathNpmPackageOrPathAlias(importPath);
+    return isImportPathRelative(importPath) || isImportNpmPackageOrPathAlias(importPath);
 }
 // See also `import { pathIsRelative } from './path'`
 function isImportPathRelative(importPath) {

package/dist/utils/isScriptFile.d.ts

@@ -1,5 +1,6 @@
 export { isScriptFile };
 export { isPlainScriptFile };
+export { isPlainJavaScriptFile };
 export { isTemplateFile };
 export { scriptFileExtensionList };
 export { scriptFileExtensionPattern };
@@ -7,4 +8,5 @@ declare const scriptFileExtensionList: readonly ["js", "cjs", "mjs", "ts", "cts"
 declare const scriptFileExtensionPattern: string;
 declare function isScriptFile(filePath: string): boolean;
 declare function isPlainScriptFile(filePath: string): boolean;
+declare function isPlainJavaScriptFile(filePath: string): boolean;
 declare function isTemplateFile(filePath: string): boolean;

package/dist/utils/isScriptFile.js

@@ -1,5 +1,6 @@
 export { isScriptFile };
 export { isPlainScriptFile };
+export { isPlainJavaScriptFile };
 export { isTemplateFile };
 export { scriptFileExtensionList };
 export { scriptFileExtensionPattern };
@@ -59,6 +60,9 @@ function isScriptFile(filePath) {
 function isPlainScriptFile(filePath) {
     return extJsOrTs.some((ext) => filePath.endsWith('.' + ext));
 }
+function isPlainJavaScriptFile(filePath) {
+    return extJs.some((ext) => filePath.endsWith('.' + ext));
+}
 function isTemplateFile(filePath) {
     return extTemplates.some((ext) => filePath.endsWith('.' + ext));
 }

package/dist/utils/parseNpmPackage.d.ts

@@ -1,17 +1,17 @@
-export { isImportPathNpmPackage };
-export { isImportPathNpmPackageOrPathAlias };
-export { assertIsImportPathNpmPackage };
-export { isPathAliasRecommended };
+export { isImportNpmPackage };
+export { isImportNpmPackageOrPathAlias };
+export { assertImportIsNpmPackage };
+export { isPathAliasRecommendation };
 export { getNpmPackageName };
 export { parseNpmPackage };
 export { isDistinguishable };
 declare function getNpmPackageName(str: string): null | string;
-declare function isImportPathNpmPackage(str: string, { cannotBePathAlias }: {
+declare function isImportNpmPackage(str: string, { cannotBePathAlias }: {
     cannotBePathAlias: true;
 }): boolean;
-declare function isImportPathNpmPackageOrPathAlias(str: string): boolean;
-declare function assertIsImportPathNpmPackage(str: string): void;
-declare function isPathAliasRecommended(alias: string): boolean;
+declare function isImportNpmPackageOrPathAlias(str: string): boolean;
+declare function assertImportIsNpmPackage(str: string): void;
+declare function isPathAliasRecommendation(alias: string): boolean;
 declare function isDistinguishable(alias: string): boolean;
 declare function parseNpmPackage(str: string | undefined): null | {
     pkgName: string;

package/dist/utils/parseNpmPackage.js

@@ -1,7 +1,7 @@
-export { isImportPathNpmPackage };
-export { isImportPathNpmPackageOrPathAlias };
-export { assertIsImportPathNpmPackage };
-export { isPathAliasRecommended };
+export { isImportNpmPackage };
+export { isImportNpmPackageOrPathAlias };
+export { assertImportIsNpmPackage };
+export { isPathAliasRecommendation };
 export { getNpmPackageName };
 // For ./isNpmPackage.spec.ts
 export { parseNpmPackage };
@@ -16,7 +16,7 @@ function getNpmPackageName(str) {
     return res.pkgName;
 }
 /* Currently not used
-export function isNpmPackageName(str: string | undefined): boolean {
+export function isValidNpmPackageName(str: string | undefined): boolean {
   const res = parseNpmPackage(str)
   return res !== null && res.importPath === null
 }
@@ -28,22 +28,22 @@ export function getNpmPackageImportPath(str: string): null | string {
   return res.importPath
 }
 //*/
-function isImportPathNpmPackage(str, { cannotBePathAlias }) {
+function isImportNpmPackage(str, { cannotBePathAlias }) {
     assert(cannotBePathAlias);
-    return isImportPathNpmPackageOrPathAlias(str);
+    return isImportNpmPackageOrPathAlias(str);
 }
 // We cannot distinguish path aliases that look like npm package imports
-function isImportPathNpmPackageOrPathAlias(str) {
+function isImportNpmPackageOrPathAlias(str) {
     const res = parseNpmPackage(str);
     return res !== null;
 }
-function assertIsImportPathNpmPackage(str) {
-    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.
+function assertImportIsNpmPackage(str) {
+    assert(isImportNpmPackage(str, {
+        // If `str` is a path alias that looks like an npm package => assertImportIsNpmPackage() 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 isPathAliasRecommended(alias) {
+function isPathAliasRecommendation(alias) {
     // Cannot be distinguished from npm package names
     if (!isDistinguishable(alias))
         return false;
@@ -64,7 +64,7 @@ function isDistinguishable(alias) {
         parseNpmPackage(`${alias}/fake-path`) === null &&
         parseNpmPackage(`${alias}fake/deep/path`) === null &&
         parseNpmPackage(`${alias}/fake/deep/path`) === null &&
-        // See note about '-' in ./isNpmPackageName.spec.ts
+        // See note about '-' in ./parseNpmPackage.spec.ts
         // ```ts
         // expect(parseNpmPackage('-')).toBe(null) // actually wrong: https://www.npmjs.com/package/-
         // ```

package/dist/utils/requireResolve.js

@@ -10,7 +10,7 @@ import { assertPosixPath, toPosixPath } from './path.js';
 import { scriptFileExtensionList } from './isScriptFile.js';
 import { createRequire } from 'node:module';
 import path from 'node:path';
-import { assertIsImportPathNpmPackage, isImportPathNpmPackageOrPathAlias } from './parseNpmPackage.js';
+import { assertImportIsNpmPackage, isImportNpmPackageOrPathAlias } from './parseNpmPackage.js';
 import { isNotNullish } from './isNullish.js';
 import { createDebug } from './debug.js';
 const importMetaUrl = import.meta.url;
@@ -96,7 +96,7 @@ function requireResolveOptionalDir({ importPath, importerDir, userRootDir, }) {
     return res.importPathResolvedFilePath;
 }
 function requireResolveNpmPackage({ importPathNpmPackage, userRootDir, }) {
-    assertIsImportPathNpmPackage(importPathNpmPackage);
+    assertImportIsNpmPackage(importPathNpmPackage);
     const importerFilePath = getFakeImporterFile(userRootDir);
     const res = requireResolve_(importPathNpmPackage, importerFilePath, userRootDir);
     if (res.hasFailed)
@@ -121,7 +121,7 @@ function requireResolveDistFile(distFile) {
 }
 function addExtraContextForNpmPackageImport(contexts, importPath, userRootDir) {
     // We should add extra context only for npm packages, but unfortunately we cannot always disambiguate between npm package imports and path aliases.
-    if (!isImportPathNpmPackageOrPathAlias(importPath))
+    if (!isImportNpmPackageOrPathAlias(importPath))
         return;
     const userRootDirFakeFile = userRootDir && getFakeImporterFile(userRootDir);
     [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.254",
+  "version": "0.4.255",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {