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

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

@@ -1,9 +1,8 @@
 export { resolvePointerImport };
 export { resolvePointerImportData };
 import pc from '@brillout/picocolors';
-import { assert, assertPosixPath, assertUsage, isFilePathAbsolute, pathIsRelative, requireResolveOptional } from '../../../../utils.js';
-import { parsePointerImportData } from './transformPointerImports.js';
-import path from 'path';
+import { assert, assertPosixPath, assertUsage, isFilePathAbsolute, isImportPathRelative, isImportPathNpmPackageOrPathAlias, requireResolveOptional } from '../../../../utils.js';
+import { assertPointerImportPath, parsePointerImportData } from './pointerImports.js';
 import { getFilePathAbsoluteUserRootDir, getFilePathResolved, getFilePathUnresolved } from '../../../../shared/getFilePath.js';
 function resolvePointerImport(configValue, importerFilePath, userRootDir, configName) {
     if (typeof configValue !== 'string')
@@ -22,24 +21,18 @@ function resolvePointerImport(configValue, importerFilePath, userRootDir, config
     return { fileExportPath };
 }
 function resolvePointerImportData(pointerImportData, importerFilePath, userRootDir) {
-    // `importPath` should be one of the following:
-    // - A relative import path
-    // - A filesystem absolute path
-    // - An npm package import
     const { importPath } = pointerImportData;
-    const filePathAbsoluteFilesystem = resolveImportPathWithNode(pointerImportData, importerFilePath);
+    assertPointerImportPath(importPath);
+    const filePathAbsoluteFilesystem = resolveImportPathWithNode(pointerImportData, importerFilePath, userRootDir);
     let filePath;
     assertPosixPath(importPath);
-    if (importPath.startsWith('.') || isFilePathAbsolute(importPath)) {
-        if (importPath.startsWith('.')) {
-            assertUsage(pathIsRelative(importPath), `Invalid relative import path ${pc.code(importPath)} defined by ${importerFilePath.filePathToShowToUser} because it should start with ${pc.code('./')} or ${pc.code('../')}, or use an npm package import instead.`);
-        }
+    if (isImportPathRelative(importPath) || isFilePathAbsolute(importPath)) {
         // Pointer imports are included in virtual files, thus relative imports need to be resolved. (Virtual modules cannot contain relative imports.)
         assertUsageResolutionSuccess(filePathAbsoluteFilesystem, pointerImportData, importerFilePath);
         // Pointer imports are included in virtual files, and we need filePathAbsoluteUserRootDir because we didn't find a way to have filesystem absolute import paths in virtual files: https://gist.github.com/brillout/2315231c9a8164f950c64b4b4a7bbd39
         const errSuffix = `outside of the ${userRootDir} directory which is forbidden: make sure your import paths resolve inside the ${userRootDir} directory, or import from an npm package.`;
         const filePathAbsoluteUserRootDir = getFilePathAbsoluteUserRootDir({ filePathAbsoluteFilesystem, userRootDir });
-        if (importPath.startsWith('.')) {
+        if (isImportPathRelative(importPath)) {
             assertUsage(filePathAbsoluteUserRootDir, `The relative import ${pc.cyan(importPath)} defined by ${importerFilePath.filePathToShowToUser} resolves to ${filePathAbsoluteFilesystem} ${errSuffix}`);
         }
         else {
@@ -51,6 +44,7 @@ function resolvePointerImportData(pointerImportData, importerFilePath, userRootD
         filePath = getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir });
     }
     else {
+        assert(isImportPathNpmPackageOrPathAlias(importPath));
         const importPathAbsolute = importPath;
         if (filePathAbsoluteFilesystem) {
             filePath = getFilePathResolved({
@@ -68,12 +62,20 @@ function resolvePointerImportData(pointerImportData, importerFilePath, userRootD
     }
     return filePath;
 }
-function resolveImportPathWithNode(pointerImportData, importerFilePath) {
+function resolveImportPathWithNode(pointerImportData, importerFilePath, userRootDir) {
     const importerFilePathAbsolute = importerFilePath.filePathAbsoluteFilesystem;
     assertPosixPath(importerFilePathAbsolute);
-    const cwd = path.posix.dirname(importerFilePathAbsolute);
-    // filePathAbsoluteFilesystem is expected to be null when pointerImportData.importPath is a Vite path alias
-    const filePathAbsoluteFilesystem = requireResolveOptional(pointerImportData.importPath, cwd);
+    // filePathAbsoluteFilesystem is null when pointerImportData.importPath is a path alias that Node.js doesn't know about
+    const filePathAbsoluteFilesystem = requireResolveOptional({
+        importPath: pointerImportData.importPath,
+        importerFile: importerFilePathAbsolute,
+        userRootDir
+    });
+    if (!filePathAbsoluteFilesystem) {
+        assert(!isImportPathRelative(pointerImportData.importPath));
+        // Libraries don't use path aliases => filePathAbsoluteFilesystem should be defined
+        assert(!importerFilePathAbsolute.includes('node_modules'));
+    }
     return filePathAbsoluteFilesystem;
 }
 function assertUsageResolutionSuccess(filePathAbsoluteFilesystem, pointerImportData, importerFilePath) {
@@ -85,8 +87,7 @@ function assertUsageResolutionSuccess(filePathAbsoluteFilesystem, pointerImportD
             ? `The import path ${importPathString} in ${filePathToShowToUser}`
             : `The import ${pc.code(importString)} defined by ${filePathToShowToUser}`;
         const errIntro2 = `${errIntro} couldn't be resolved: does ${importPathString}`;
-        if (importPath.startsWith('.')) {
-            assert(pathIsRelative(importPath));
+        if (isImportPathRelative(importPath)) {
             assertUsage(false, `${errIntro2} point to an existing file?`);
         }
         else {

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

@@ -7,8 +7,8 @@ import fs from 'fs';
 import path from 'path';
 import pc from '@brillout/picocolors';
 import { import_ } from '@brillout/import';
-import { assertPosixPath, getRandomId, assertIsNotProductionRuntime, assert, assertWarning, isObject, toPosixPath, assertUsage, isPlainJavaScriptFile, createDebugger, assertFilePathAbsoluteFilesystem, assertIsNpmPackageImport, genPromise, isVitest, requireResolveOptional, isNpmPackageImport_unreliable } from '../../../../utils.js';
-import { transformPointerImports } from './transformPointerImports.js';
+import { assertPosixPath, getRandomId, assertIsNotProductionRuntime, assert, assertWarning, isObject, toPosixPath, assertUsage, isPlainJavaScriptFile, createDebugger, assertFilePathAbsoluteFilesystem, assertIsImportPathNpmPackage, genPromise, isVitest, isImportPathNpmPackageOrPathAlias, isImportPathRelative, requireResolveOptionalDir } from '../../../../utils.js';
+import { transformPointerImports } from './pointerImports.js';
 import sourceMapSupport from 'source-map-support';
 import { getFilePathAbsoluteUserRootDir } from '../../../../shared/getFilePath.js';
 assertIsNotProductionRuntime();
@@ -121,7 +121,11 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports, esb
                     // - Sitll required for esbuild@0.24.0 (November 2024).
                     // - Let's try to remove this workaround again later.
                     if (resolved.errors.length > 0) {
-                        const resolvedWithNode = requireResolveOptional(path, toPosixPath(args.resolveDir));
+                        const resolvedWithNode = requireResolveOptionalDir({
+                            importPath: path,
+                            importerDir: toPosixPath(args.resolveDir),
+                            userRootDir
+                        });
                         if (debugEsbuildResolve.isActivated)
                             debugEsbuildResolve('resolvedWithNode', resolvedWithNode);
                         if (resolvedWithNode)
@@ -141,8 +145,8 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports, esb
                     const importPathOriginal = args.path;
                     // Esbuild resolves path aliases.
                     // - Enabling us to use:
-                    //   - assertIsNpmPackageImport()
-                    //   - isNpmPackageImport(str, { cannotBePathAlias: true })
+                    //   - assertIsImportPathNpmPackage()
+                    //   - isImportPathNpmPackage(str, { cannotBePathAlias: true })
                     assertFilePathAbsoluteFilesystem(importPathResolved);
                     //  Should be remove this? See comment below.
                     const isVikeExtensionImport = (path.startsWith('vike-') && path.endsWith('/config')) || importPathResolved.endsWith('+config.js');
@@ -160,7 +164,7 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports, esb
                     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(isNpmPackageImport_unreliable(importPathOriginal));
+                            assert(isImportPathNpmPackageOrPathAlias(importPathOriginal));
                             return true;
                         }
                         // Linked npm packages
@@ -169,7 +173,7 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports, esb
                         // - 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.
-                            isNpmPackageImport_unreliable(importPathOriginal)) {
+                            isImportPathNpmPackageOrPathAlias(importPathOriginal)) {
                             return true;
                         }
                         return false;
@@ -186,7 +190,7 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports, esb
                     }
                     let importPathTranspiled;
                     assertPosixPath(importPathOriginal);
-                    if (importPathOriginal.startsWith('./') || importPathOriginal.startsWith('../')) {
+                    if (isImportPathRelative(importPathOriginal)) {
                         importPathTranspiled = importPathResolved;
                     }
                     else {
@@ -203,12 +207,12 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports, esb
                             //   - Vike doesn't resolve path aliases at all.
                             //   - Node.js doesn't support `tsconfig.js#compilerOptions.paths`.
                             // - Esbuild path alias resolution seems reliable, e.g. it supports `tsconfig.js#compilerOptions.paths`.
-                            assert(!isNpmPackageImport_unreliable(importPathOriginal));
+                            assert(!isImportPathNpmPackageOrPathAlias(importPathOriginal));
                             importPathTranspiled = importPathResolved;
                         }
                         else {
                             // `importPathOriginal` is most likely an npm package import.
-                            assertIsNpmPackageImport(importPathOriginal);
+                            assertIsImportPathNpmPackage(importPathOriginal);
                             // For improved error messages, let the resolution be handled by Vike or Node.js.
                             importPathTranspiled = importPathOriginal;
                         }

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

@@ -70,7 +70,7 @@ async function handleReloadSideEffects() {
         }
     }
 }
-// TODO/soon: predominantly use getVikeConfigPublic() instead of getVikeConfig() then maybe refector?
+// TODO/soon: predominantly use getVikeConfigInternal() instead of getVikeConfig() then maybe refector?
 async function getVikeConfig(config, { doNotRestartViteOnError } = {}) {
     const userRootDir = config.root;
     const vikeVitePluginOptions = config._vikeVitePluginOptions;

package/dist/esm/node/plugin/shared/getFilePath.js

@@ -7,7 +7,7 @@ export { getModuleFilePathRelative };
 export { cleanFilePathUnkown };
 export { assertModuleId };
 import path from 'path';
-import { assert, assertIsNpmPackageImport, assertFilePathAbsoluteFilesystem, assertPosixPath, toPosixPath } from '../utils.js';
+import { assert, assertIsImportPathNpmPackage, assertFilePathAbsoluteFilesystem, assertPosixPath, toPosixPath } from '../utils.js';
 function getFilePathResolved(args) {
     const { userRootDir } = args;
     let filePathAbsoluteFilesystem;
@@ -39,7 +39,7 @@ function getComputedProps(args) {
         const importPathAbsolute = args.importPathAbsolute ?? null;
         const { filePathAbsoluteUserRootDir } = args;
         if (importPathAbsolute)
-            assertIsNpmPackageImport(importPathAbsolute);
+            assertIsImportPathNpmPackage(importPathAbsolute);
         return {
             importPathAbsolute,
             filePathAbsoluteUserRootDir,
@@ -53,7 +53,7 @@ function getComputedProps(args) {
 }
 function getComputedPropsImportPathAbsolute(args) {
     const { importPathAbsolute } = args;
-    assertIsNpmPackageImport(importPathAbsolute);
+    assertIsImportPathNpmPackage(importPathAbsolute);
     return {
         filePathAbsoluteUserRootDir: null,
         importPathAbsolute,

package/dist/esm/node/plugin/shared/resolveClientEntriesDev.js

@@ -1,12 +1,10 @@
 export { resolveClientEntriesDev };
-import { assert, assertPosixPath, toPosixPath, pathJoin, assertIsNpmPackageImport, assertIsNotProductionRuntime, requireResolveOptionalNonUserFile, requireResolve } from '../utils.js';
-// @ts-ignore import.meta.url is shimmed at dist/cjs by dist-cjs-fixup.js.
-const importMetaUrl = import.meta.url;
+import { assert, assertPosixPath, toPosixPath, pathJoin, assertIsImportPathNpmPackage, assertIsNotProductionRuntime, requireResolveNpmPackage, requireResolveVikeDistFile } from '../utils.js';
 assertIsNotProductionRuntime();
 async function resolveClientEntriesDev(clientEntry, viteDevServer) {
-    let root = viteDevServer.config.root;
-    assert(root);
-    root = toPosixPath(root);
+    let userRootDir = viteDevServer.config.root;
+    assert(userRootDir);
+    userRootDir = toPosixPath(userRootDir);
     // The `?import` suffix is needed for MDX to be transpiled:
     //   - Not transpiled: `/pages/markdown.page.mdx`
     //   - Transpiled: `/pages/markdown.page.mdx?import`
@@ -20,26 +18,16 @@ async function resolveClientEntriesDev(clientEntry, viteDevServer) {
     assertPosixPath(clientEntry);
     let filePath;
     if (clientEntry.startsWith('/')) {
-        filePath = pathJoin(root, clientEntry);
+        filePath = pathJoin(userRootDir, clientEntry);
     }
     else {
         if (clientEntry.startsWith('@@vike/')) {
             assert(clientEntry.endsWith('.js'));
-            let filePath_;
-            // For Vitest (which doesn't resolve vike to its dist but to its source files)
-            // [RELATIVE_PATH_FROM_DIST] Current file: node_modules/vike/node/plugin/shared/resolveClientEntriesDev.js
-            filePath_ = requireResolveOptionalNonUserFile(clientEntry.replace('@@vike/dist/esm/client/', '../../../client/').replace('.js', '.ts'), importMetaUrl);
-            if (!filePath_) {
-                // For users
-                // [RELATIVE_PATH_FROM_DIST] Current file: node_modules/vike/dist/esm/node/plugin/shared/resolveClientEntriesDev.js
-                filePath_ = requireResolveOptionalNonUserFile(clientEntry.replace('@@vike/dist/esm/client/', '../../../../../dist/esm/client/'), importMetaUrl);
-            }
-            assert(filePath_);
-            filePath = filePath_;
+            filePath = requireResolveVikeDistFile(`dist/esm/${clientEntry.replace('@@vike/dist/esm/', '')}`);
         }
         else {
-            assertIsNpmPackageImport(clientEntry);
-            filePath = requireResolve(clientEntry, root);
+            assertIsImportPathNpmPackage(clientEntry);
+            filePath = requireResolveNpmPackage({ importPathNpmPackage: clientEntry, userRootDir });
         }
     }
     if (!filePath.startsWith('/')) {

package/dist/esm/node/plugin/utils.d.ts

@@ -24,3 +24,4 @@ export * from '../../utils/isEqualStringList.js';
 export * from '../../utils/isDocker.js';
 export * from '../../utils/isVitest.js';
 export * from '../../utils/rollupSourceMap.js';
+export * from '../../utils/isImportPath.js';

package/dist/esm/node/plugin/utils.js

@@ -30,3 +30,4 @@ export * from '../../utils/isEqualStringList.js';
 export * from '../../utils/isDocker.js';
 export * from '../../utils/isVitest.js';
 export * from '../../utils/rollupSourceMap.js';
+export * from '../../utils/isImportPath.js';

package/dist/esm/node/prerender/runPrerender.js

@@ -30,7 +30,7 @@ import { resolvePrerenderConfigGlobal, resolvePrerenderConfigLocal } from './res
 import { getOutDirs } from '../plugin/shared/getOutDirs.js';
 import { isVikeCli } from '../cli/context.js';
 import { isViteCliCall } from '../plugin/shared/isViteCliCall.js';
-import { getVikeConfigPublic } from '../plugin/plugins/commonConfig.js';
+import { getVikeConfigInternal } from '../plugin/plugins/commonConfig.js';
 import fs from 'node:fs';
 async function runPrerenderFromAPI(options = {}) {
     return await runPrerender(options, 'prerender()');
@@ -77,7 +77,7 @@ async function runPrerender(options = {}, standaloneTrigger) {
     await disableReactStreaming();
     const viteConfig = await resolveConfig(options.viteConfig || {}, 'build', 'production');
     const vikeConfig = await getVikeConfig(viteConfig);
-    const vike = getVikeConfigPublic(viteConfig);
+    const vike = getVikeConfigInternal(viteConfig);
     const { outDirClient, outDirServer } = getOutDirs(viteConfig);
     const { root } = viteConfig;
     const prerenderConfigGlobal = resolvePrerenderConfigGlobal(vikeConfig);

package/dist/esm/node/runtime/renderPage/getPageAssets/getManifestEntry.js

@@ -1,5 +1,5 @@
 export { getManifestEntry };
-import { assert, slice, assertIsNpmPackageImport } from '../../utils.js';
+import { assert, slice, assertIsImportPathNpmPackage } from '../../utils.js';
 import { isVirtualFileIdPageConfigValuesAll } from '../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
 import { prependEntriesDir } from '../../../shared/prependEntriesDir.js';
 function getManifestEntry(id, assetsManifest) {
@@ -40,7 +40,7 @@ function getManifestEntry(id, assetsManifest) {
         return { manifestEntry, manifestKey };
     }
     // npm package import
-    assertIsNpmPackageImport(id);
+    assertIsImportPathNpmPackage(id);
     const found = Object.entries(assetsManifest).find(([, e]) => e.name === prependEntriesDir(id));
     assert(found);
     const [manifestKey, manifestEntry] = found;

package/dist/esm/node/runtime/renderPage/getPageAssets/retrieveAssetsProd.js

@@ -1,5 +1,5 @@
 export { retrieveAssetsProd };
-import { assert, isNpmPackageImport } from '../../utils.js';
+import { assert, isImportPathNpmPackage } from '../../utils.js';
 import { getManifestEntry } from './getManifestEntry.js';
 import { extractAssetsAddQuery } from '../../../shared/extractAssetsQuery.js';
 function retrieveAssetsProd(clientDependencies, assetsManifest, includeAssetsImportedByServer) {
@@ -14,7 +14,7 @@ function retrieveAssetsProd(clientDependencies, assetsManifest, includeAssetsImp
             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.
-            !isNpmPackageImport(id, {
+            !isImportPathNpmPackage(id, {
                 // I presume Vite already resolves path aliases when Vite sets the module's id
                 cannotBePathAlias: true
             })) {

package/dist/esm/node/runtime/utils.d.ts

@@ -30,7 +30,7 @@ export * from '../../utils/debug.js';
 export * from '../../utils/urlToFile.js';
 export * from '../../utils/getGlobalObject.js';
 export * from '../../utils/freezePartial.js';
-export * from '../../utils/isNpmPackage.js';
+export * from '../../utils/parseNpmPackage.js';
 export * from '../../utils/isNullish.js';
 export * from '../../utils/isScriptFile.js';
 export * from '../../utils/removeFileExtention.js';

package/dist/esm/node/runtime/utils.js

@@ -34,7 +34,7 @@ export * from '../../utils/debug.js';
 export * from '../../utils/urlToFile.js';
 export * from '../../utils/getGlobalObject.js';
 export * from '../../utils/freezePartial.js';
-export * from '../../utils/isNpmPackage.js';
+export * from '../../utils/parseNpmPackage.js';
 export * from '../../utils/isNullish.js';
 export * from '../../utils/isScriptFile.js';
 export * from '../../utils/removeFileExtention.js';

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

@@ -22,7 +22,7 @@ function determineFileType(filePath) {
         const isCSS = filePath.endsWith('.css');
         if (isCSS) {
             /* This assert() is skipped to reduce client-side bundle size
-            assert(isNpmPackageImport(filePath), filePath) // `.css` page files are only supported for npm packages
+            assert(isImportPathNpmPackage(filePath), filePath) // `.css` page files are only supported for npm packages
             */
             return '.css';
         }

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

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

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

@@ -139,7 +139,7 @@ type PageContextBuiltInCommon<Data> = {
 };
 type PageContextBuiltInServer<Data> = PageContextBuiltInCommon<Data> & PageContextUrlServer & {
     /**
-     * Whether the page is being rendered on the client-side, or rendered on the server-side / pre-rendered.
+     * Whether the page is being rendered on the client- or server-side / pre-rendered.
      *
      * In order to save client-side KBs, we recommend using `import.meta.env.SSR` whenever possible instead, see https://vike.dev/pageContext
      */

package/dist/esm/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.228-commit-4bed128";
+export declare const PROJECT_VERSION: "0.4.228-commit-84954ae";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.228-commit-4bed128';
+export const PROJECT_VERSION = '0.4.228-commit-84954ae';

package/dist/esm/utils/isImportPath.d.ts

@@ -0,0 +1,4 @@
+export { isImportPath };
+export { isImportPathRelative };
+declare function isImportPath(importPath: string): boolean;
+declare function isImportPathRelative(importPath: string): boolean;

package/dist/esm/utils/isImportPath.js

@@ -0,0 +1,19 @@
+export { isImportPath };
+export { isImportPathRelative };
+import { assertPosixPath } from './path.js';
+import { assert } from './assert.js';
+import { isImportPathNpmPackageOrPathAlias } from './parseNpmPackage.js';
+function isImportPath(importPath) {
+    return isImportPathRelative(importPath) || isImportPathNpmPackageOrPathAlias(importPath);
+}
+// See also `import { pathIsRelative } from './path'`
+function isImportPathRelative(importPath) {
+    assertPosixPath(importPath);
+    if (importPath.startsWith('./') || importPath.startsWith('../')) {
+        return true;
+    }
+    else {
+        assert(!importPath.startsWith('.'));
+        return false;
+    }
+}

package/dist/esm/utils/parseNpmPackage.d.ts

@@ -0,0 +1,17 @@
+export { isImportPathNpmPackage };
+export { isImportPathNpmPackageOrPathAlias };
+export { assertIsImportPathNpmPackage };
+export { isPathAliasRecommended };
+export { parseNpmPackage };
+export { isDistinguishable };
+declare function isImportPathNpmPackage(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 isDistinguishable(alias: string): boolean;
+declare function parseNpmPackage(str: string | undefined): null | {
+    pkgName: string;
+    importPath: null | string;
+};

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

@@ -1,50 +1,50 @@
-export { isNpmPackageImport };
-export { isNpmPackageImport_unreliable };
-export { assertIsNpmPackageImport };
-export { isValidPathAlias };
+export { isImportPathNpmPackage };
+export { isImportPathNpmPackageOrPathAlias };
+export { assertIsImportPathNpmPackage };
+export { isPathAliasRecommended };
 /* Currently not used
 export { isNpmPackageName }
 export { getNpmPackageName }
 export { getNpmPackageImportPath }
 */
 // For ./isNpmPackage.spec.ts
-export { parse };
+export { parseNpmPackage };
 export { isDistinguishable };
 import { assert } from './assert.js';
 import { assertIsNotBrowser } from './assertIsNotBrowser.js';
 assertIsNotBrowser();
-function isNpmPackageImport(str, { cannotBePathAlias }) {
+function isImportPathNpmPackage(str, { cannotBePathAlias }) {
     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) {
-    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) {
+    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;
@@ -60,14 +60,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('-'));
 }
@@ -75,7 +75,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/esm/utils/path.d.ts

@@ -11,4 +11,4 @@ declare function pathJoin(path1: string, path2: string): string;
 /**********************/
 declare function toPosixPath(path: string): string;
 declare function assertPosixPath(path: string): void;
-declare function pathIsRelative(importPath: string): boolean;
+declare function pathIsRelative(path: string): boolean;

package/dist/esm/utils/path.js

@@ -42,6 +42,16 @@ function assertPosixPath(path) {
     assert(path);
     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/esm/utils/requireResolve.d.ts

@@ -1,8 +1,21 @@
-export { requireResolve };
 export { requireResolveOptional };
-export { requireResolveNonUserFile };
-export { requireResolveOptionalNonUserFile };
-declare function requireResolveOptional(importPath: string, cwd: string): string | null;
-declare function requireResolveOptionalNonUserFile(importPath: string, cwd: string): string | null;
-declare function requireResolveNonUserFile(importPath: string, cwd: string): string;
-declare function requireResolve(importPath: string, cwd: string): string;
+export { requireResolveOptionalDir };
+export { requireResolveNpmPackage };
+export { requireResolveVikeDistFile };
+export { getVikeNodeModulesRoot };
+declare function requireResolveOptional({ importPath, importerFile, userRootDir }: {
+    importPath: string;
+    importerFile: string;
+    userRootDir: string;
+}): string | null;
+declare function requireResolveOptionalDir({ importPath, importerDir, userRootDir }: {
+    importPath: string;
+    importerDir: string;
+    userRootDir: string;
+}): string | null;
+declare function requireResolveNpmPackage({ importPathNpmPackage, userRootDir }: {
+    importPathNpmPackage: string;
+    userRootDir: string;
+}): string;
+declare function requireResolveVikeDistFile(vikeDistFile: `dist/esm/${string}`): string;
+declare function getVikeNodeModulesRoot(): string;