vike 0.4.228 → 0.4.229-commit-a19745d

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

@@ -1,42 +1,59 @@
-export { PageContext };
-export { PageContextServer };
-export { PageContextClient };
-export { PageContextWithServerRouting };
-export { PageContextClientWithServerRouting };
-export { PageContextBuiltInServerInternal };
-export { PageContextBuiltInServer_deprecated as PageContextBuiltInServer };
-export { PageContextBuiltInClientWithClientRouting_deprecated as PageContextBuiltInClientWithClientRouting };
-export { PageContextBuiltInClientWithServerRouting_deprecated as PageContextBuiltInClientWithServerRouting };
+export type { PageContext };
+export type { PageContextServer };
+export type { PageContextClient };
+export type { GlobalContext };
+export type { GlobalContextServer };
+export type { GlobalContextClient };
+export type { PageContextWithServerRouting };
+export type { PageContextClientWithServerRouting };
+export type { GlobalContextClientWithServerRouting };
+export type { PageContextBuiltInServerInternal };
+export type { PageContextBuiltInServer_deprecated as PageContextBuiltInServer };
+export type { PageContextBuiltInClientWithClientRouting_deprecated as PageContextBuiltInClientWithClientRouting };
+export type { PageContextBuiltInClientWithServerRouting_deprecated as PageContextBuiltInClientWithServerRouting };
 import type { PageContextUrlInternal, PageContextUrlClient, PageContextUrlServer } from './getPageContextUrlComputed.js';
 import type { ConfigEntries, ExportsAll, From, Source, Sources } from './page-configs/getPageConfigUserFriendly.js';
 import type { Config } from './page-configs/Config.js';
 import type { PageContextConfig } from './page-configs/Config/PageContextConfig.js';
 import type { AbortStatusCode } from './route/abort.js';
-import type { GlobalContextPublic } from '../node/runtime/globalContext.js';
-type PageContextServer<Data = unknown> = PageContextBuiltInServer<Data> & Vike.PageContext;
+import type { GlobalContextServer } from '../node/runtime/globalContext.js';
+import type { GlobalContextClient } from '../client/client-routing-runtime/globalContext.js';
+import type { GlobalContextClientWithServerRouting } from '../client/server-routing-runtime/globalContext.js';
+type PageContextServer<Data = unknown> = PageContextBuiltInServer<Data> & Vike.PageContext & Vike.PageContextServer;
 type PageContext<Data = unknown> = PageContextClient<Data> | PageContextServer<Data>;
-type PageContextClient<Data = unknown> = PageContextBuiltInClientWithClientRouting<Data> & Vike.PageContext;
+type PageContextClient<Data = unknown> = PageContextBuiltInClientWithClientRouting<Data> & Vike.PageContext & Vike.PageContextClient;
+type GlobalContext = GlobalContextServer | GlobalContextClient;
 type PageContextWithServerRouting<Data = unknown> = PageContextClientWithServerRouting<Data> | PageContextServer<Data>;
-type PageContextClientWithServerRouting<Data = unknown> = PageContextBuiltInClientWithServerRouting<Data> & Vike.PageContext;
+type PageContextClientWithServerRouting<Data = unknown> = PageContextBuiltInClientWithServerRouting<Data> & Vike.PageContext & Vike.PageContextClient;
 type PageContextBuiltInCommon<Data> = {
+    /**
+     * Useful for distinguishing `pageContext` from other objects and narrowing down TypeScript unions.
+     *
+     * https://vike.dev/pageContext#typescript
+     */
+    isPageContext: true;
     /** The `export { Page }` of your `.page.js` file.
      *
      * https://vike.dev/Page
+     * https://vike.dev/pageContext#Page
      */
     Page: Config['Page'];
     /** Route Parameters, e.g. `pageContext.routeParams.productId` for a Route String `/product/@productId`.
      *
      * https://vike.dev/route-string
+     * https://vike.dev/pageContext#routeParams
      */
     routeParams: Record<string, string>;
     /** The page's data which was fetched using the data() hook.
      *
      * https://vike.dev/data
+     * https://vike.dev/pageContext#data
      */
     data: Data;
     /** The page's configuration values.
      *
      * https://vike.dev/config
+     * https://vike.dev/pageContext#config
      */
     config: PageContextConfig;
     /** The page's configuration, including the configs origin and overriden configs.
@@ -65,9 +82,8 @@ type PageContextBuiltInCommon<Data> = {
      *
      * As a string object normalized by Vike.
      *
-     * See also:
-     * - https://vike.dev/headers
-     * - `pageContext.headersOriginal`
+     * https://vike.dev/headers
+     * https://vike.dev/pageContext#headers
      */
     headers: Record<string, string> | null;
     /**
@@ -75,9 +91,8 @@ type PageContextBuiltInCommon<Data> = {
      *
      * The original object provided by the server.
      *
-     * See also:
-     * - https://vike.dev/headers
-     * - `pageContext.headers`
+     * https://vike.dev/headers
+     * https://vike.dev/pageContext#headersOriginal
      */
     headersOriginal?: unknown;
     /** If an error occurs, whether the error is a `404 Page Not Found`.
@@ -88,25 +103,28 @@ type PageContextBuiltInCommon<Data> = {
     /**
      * Whether the page was navigated by the client-side router.
      *
-     * https://vike.dev/pageContext
+     * https://vike.dev/pageContext#isClientSideNavigation
      */
     isClientSideNavigation: boolean;
     /**
      * The reason why the original page was aborted. Usually used for showing a custom message on the error page.
      *
      * https://vike.dev/render
+     * https://vike.dev/pageContext#abortReason
      */
     abortReason?: unknown;
     /**
      * The status code set by `throw render(abortStatusCode)`.
      *
      * https://vike.dev/render
+     * https://vike.dev/pageContext#abortStatusCode
      */
     abortStatusCode?: AbortStatusCode;
     /**
      * Error that occured while rendering.
      *
      * https://vike.dev/error-tracking
+     * https://vike.dev/pageContext#errorWhileRendering
      */
     errorWhileRendering?: unknown;
     /**
@@ -119,12 +137,6 @@ type PageContextBuiltInCommon<Data> = {
     source: Source;
     /** @experimental https://github.com/vikejs/vike/issues/1268 */
     sources: Sources;
-    /**
-     * Runtime information about your app.
-     *
-     * https://vike.dev/getGlobalContext
-     */
-    globalContext: GlobalContextPublic;
     /** @deprecated */
     url: string;
     /** @deprecated */
@@ -133,14 +145,17 @@ type PageContextBuiltInCommon<Data> = {
      * Whether the Base URL is missing in the URL of the HTTP request made to the SSR server.
      *
      * https://vike.dev/base-url#setup
+     * https://vike.dev/pageContext#isBaseMissing
      */
     isBaseMissing?: true;
 };
 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-side or server-side / pre-rendered.
+     *
+     * We recommend using `import.meta.env.SSR` instead, see https://vike.dev/pageContext#isClientSide
      *
-     * In order to save client-side KBs, we recommend using `import.meta.env.SSR` whenever possible instead, see https://vike.dev/pageContext
+     * https://vike.dev/pageContext#isClientSide
      */
     isClientSide: false;
     /**
@@ -149,9 +164,16 @@ type PageContextBuiltInServer<Data> = PageContextBuiltInCommon<Data> & PageConte
      * The value is always `false` in development.
      *
      * https://vike.dev/pre-rendering
-     * https://vike.dev/pageContext
+     * https://vike.dev/pageContext#isPrerendering
      */
     isPrerendering: boolean;
+    /**
+     * Runtime information about your app.
+     *
+     * https://vike.dev/getGlobalContext
+     * https://vike.dev/pageContext#globalContext
+     */
+    globalContext: GlobalContextServer;
     isHydration?: undefined;
     isBackwardNavigation?: undefined;
     previousPageContext?: undefined;
@@ -163,34 +185,44 @@ type PageContextBuiltInClientWithClientRouting<Data> = Partial<PageContextBuiltI
      * Whether the user is navigating back in history.
      *
      * The value is `true` when the user clicks on his browser's backward navigation button, or when invoking `history.back()`.
+     *
+     * https://vike.dev/pageContext#isBackwardNavigation
      */
     isBackwardNavigation: boolean | null;
     /**
      * Upon client-side page navigation, you can use `pageContext.previousPageContext` to access the `pageContext` of the previous page.
      *
-     * https://vike.dev/pageContext
+     * https://vike.dev/pageContext#previousPageContext
      */
     previousPageContext: PageContextClient<Data> | null;
+    globalContext: GlobalContextClient;
 } & PageContextUrlClient;
 type PageContextBuiltInClientWithServerRouting<Data> = Partial<PageContextBuiltInCommon<Data>> & Pick<PageContextBuiltInCommon<Data>, 'Page' | 'pageExports' | 'exports' | 'abortReason' | 'pageId' | 'data'> & PageContextClientCommon & {
     /**
      * Whether the current page is already rendered to HTML.
      *
      * The `isHydration` value is always `true` when using Server Routing.
+     *
+     * https://vike.dev/pageContext#isHydration
      */
     isHydration: true;
     /**
      * Whether the user is navigating back in history.
      *
      * The `isBackwardNavigation` property only works with Client Routing. (The value is always `null` when using Server Routing.)
+     *
+     * https://vike.dev/pageContext#isBackwardNavigation
      */
     isBackwardNavigation: null;
+    globalContext: GlobalContextClientWithServerRouting;
 };
 type PageContextClientCommon = {
     /**
      * Whether the page is being rendered on the client-side, or rendered on the 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
+     * In order to save client-side KBs, we recommend using `import.meta.env.SSR` whenever possible instead, see https://vike.dev/pageContext#isClientSide
+     *
+     * https://vike.dev/pageContext#isClientSide
      */
     isClientSide: true;
     /**
@@ -199,7 +231,7 @@ type PageContextClientCommon = {
      * The value is always `false` in development.
      *
      * https://vike.dev/pre-rendering
-     * https://vike.dev/pageContext
+     * https://vike.dev/pageContext#isPrerendering
      */
     isPrerendering: false;
 };

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

@@ -1,8 +1,4 @@
-export type { PageContext } from '../shared/types.js';
-export type { PageContextServer } from '../shared/types.js';
-export type { PageContextClient } from '../shared/types.js';
-export type { PageContextWithServerRouting } from '../shared/types.js';
-export type { PageContextClientWithServerRouting } from '../shared/types.js';
+export type { PageContext, PageContextServer, PageContextClient, GlobalContext, GlobalContextServer, GlobalContextClient, PageContextWithServerRouting, PageContextClientWithServerRouting, GlobalContextClientWithServerRouting } from '../shared/types.js';
 export type { PageContextBuiltInServer } from '../shared/types.js';
 export type { PageContextBuiltInClientWithClientRouting } from '../shared/types.js';
 export type { PageContextBuiltInClientWithServerRouting } from '../shared/types.js';

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

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.228";
+export declare const PROJECT_VERSION: "0.4.229-commit-a19745d";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.228';
+export const PROJECT_VERSION = '0.4.229-commit-a19745d';

package/dist/esm/utils/catchInfiniteLoop.js

@@ -1,5 +1,5 @@
 export { catchInfiniteLoop };
-import { assert, assertWarning } from './assert.js';
+import { assertUsage, assertWarning } from './assert.js';
 const trackers = {};
 function catchInfiniteLoop(functionName, maxNumberOfCalls = 100, withinSeconds = 5) {
     // Init
@@ -12,14 +12,14 @@ function catchInfiniteLoop(functionName, maxNumberOfCalls = 100, withinSeconds =
     // Count
     tracker.count++;
     // Error
-    const msg = `[Infinite Loop] ${functionName} called ${tracker.count} times within ${withinSeconds} seconds`;
+    const msg = `[Infinite Loop] Rendering ${tracker.count} times within ${withinSeconds} seconds [${functionName}]`;
     if (tracker.count > maxNumberOfCalls) {
-        assert(false, msg);
+        assertUsage(false, msg);
     }
     // Warning, at 50% threshold
     if (!tracker.warned && tracker.count > maxNumberOfCalls * 0.5) {
         // Warning is shown upon 10 calls a second, on average during 5 seconds, given the default parameters
-        assertWarning(false, msg, { onlyOnce: false });
+        assertWarning(false, msg, { onlyOnce: false, showStackTrace: true });
         tracker.warned = true;
     }
 }

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

@@ -1,7 +1,7 @@
 export { createDebugger };
 export { isDebugActivated };
 export type { Debug };
-declare const flags: readonly ["vike:crawl", "vike:error", "vike:esbuild-resolve", "vike:extractAssets", "vike:extractExportNames", "vike:glob", "vike:globalContext", "vike:log", "vike:optimizeDeps", "vike:outDir", "vike:pageFiles", "vike:pointer-imports", "vike:routing", "vike:setup", "vike:stream", "vike:virtual-files"];
+declare const flags: readonly ["vike:crawl", "vike:error", "vike:esbuild-resolve", "vike:extractAssets", "vike:extractExportNames", "vike:glob", "vike:globalContext", "vike:log", "vike:optimizeDeps", "vike:outDir", "vike:pageFiles", "vike:pointer-imports", "vike:resolve", "vike:routing", "vike:setup", "vike:stream", "vike:virtual-files"];
 type Flag = (typeof flags)[number];
 type Debug = ReturnType<typeof createDebugger>;
 type Options = {

package/dist/esm/utils/debug.js

@@ -26,6 +26,7 @@ const flags = [
     'vike:outDir',
     'vike:pageFiles',
     'vike:pointer-imports',
+    'vike:resolve',
     'vike:routing',
     'vike:setup',
     'vike:stream',

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

@@ -1,6 +1,6 @@
 export { getGlobalObject };
 export { assertIsSingleModuleInstance };
-type Key = `${string}/${string}.ts`;
+type Key = `${string}.ts`;
 /** Share information across module instances. */
 declare function getGlobalObject<T extends Record<string, unknown> = never>(key: Key, defaultValue: T): T;
 /** Assert that the module is instantiated only once. */

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

@@ -0,0 +1,2 @@
+export { getPublicProxy };
+declare function getPublicProxy<Obj extends Record<string, unknown>, PropsPublic extends readonly (keyof Obj)[]>(obj: Obj, objName: string, propsPublic: PropsPublic, expectCustomUserLandProps?: true): Pick<Obj, PropsPublic[number]>;

package/dist/esm/utils/getPublicProxy.js

@@ -0,0 +1,25 @@
+export { getPublicProxy };
+// We use a proxy instead of property getters.
+// - The issue with property getters is that they can't be `writable: true` but we do want the user to be able to modify the value of internal properties.
+//   ```console
+//   TypeError: Invalid property descriptor. Cannot both specify accessors and a value or writable attribute, #<Object>
+//   ```
+// - Previous implementation using property getters: https://github.com/vikejs/vike/blob/main/vike/utils/makePublicCopy.ts
+import { assert, assertWarning } from './assert.js';
+// Show warning when user is accessing internal `_` properties.
+function getPublicProxy(obj, objName, propsPublic, expectCustomUserLandProps) {
+    if (!expectCustomUserLandProps) {
+        Object.keys(obj).forEach((key) => assert(key.startsWith('_') || propsPublic.includes(key)));
+        propsPublic.forEach((prop) => prop in obj);
+    }
+    return new Proxy(obj, {
+        get(_, prop) {
+            const propStr = String(prop);
+            if (propStr.startsWith('_')) {
+                assertWarning(false, `Using internal ${objName}.${propStr} which may break in any minor version update. Reach out on GitHub and elaborate your use case so that the Vike team can add official support for your use case.`, { onlyOnce: true });
+            }
+            // @ts-ignore Seems to be TypeScript bug
+            return Reflect.get(...arguments);
+        }
+    });
+}

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/isScriptFile.d.ts

@@ -1,10 +1,10 @@
 export { isScriptFile };
-export { isPlainJavaScriptFile };
+export { isPlainScriptFile };
 export { isTemplateFile };
-export { scriptFileExtensions };
+export { scriptFileExtensionPattern };
 export { scriptFileExtensionList };
-declare const scriptFileExtensionList: readonly [...string[], "jsx", "tsx", "cjsx", "ctsx", "mjsx", "mtsx", "vue", "svelte", "marko", "md", "mdx"];
-declare const scriptFileExtensions: string;
+declare const scriptFileExtensionList: readonly ["js", "cjs", "mjs", "ts", "cts", "mts", "jsx", "cjsx", "mjsx", "tsx", "ctsx", "mtsx", "vue", "svelte", "marko", "md", "mdx"];
+declare const scriptFileExtensionPattern: string;
 declare function isScriptFile(filePath: string): boolean;
-declare function isPlainJavaScriptFile(filePath: string): boolean;
+declare function isPlainScriptFile(filePath: string): boolean;
 declare function isTemplateFile(filePath: string): boolean;

package/dist/esm/utils/isScriptFile.js

@@ -1,9 +1,8 @@
 export { isScriptFile };
-export { isPlainJavaScriptFile };
+export { isPlainScriptFile };
 export { isTemplateFile };
-export { scriptFileExtensions };
+export { scriptFileExtensionPattern };
 export { scriptFileExtensionList };
-import { assert } from './assert.js';
 // We can't use a RegExp:
 //  - Needs to work with Micromatch: https://github.com/micromatch/micromatch because:
 //    - Vite's `import.meta.glob()` uses Micromatch
@@ -15,26 +14,36 @@ import { assert } from './assert.js';
 //     - A post `import.meta.glob()` blocklist filtering doesn't work because Vite would still process the files (e.g. including them in the bundle).
 // prettier-ignore
 // biome-ignore format:
-const extJavaScript = [
+const extJs = [
     'js',
-    'ts',
     'cjs',
-    'cts',
     'mjs',
+];
+// prettier-ignore
+// biome-ignore format:
+const extTs = [
+    'ts',
+    'cts',
     'mts',
 ];
+const extJsOrTs = [...extJs, ...extTs];
 // prettier-ignore
 // biome-ignore format:
 const extJsx = [
     'jsx',
-    'tsx',
     'cjsx',
-    'ctsx',
     'mjsx',
-    'mtsx',
 ];
 // prettier-ignore
 // biome-ignore format:
+const extTsx = [
+    'tsx',
+    'ctsx',
+    'mtsx'
+];
+const extJsxOrTsx = [...extJsx, ...extTsx];
+// prettier-ignore
+// biome-ignore format:
 const extTemplates = [
     'vue',
     'svelte',
@@ -42,19 +51,13 @@ const extTemplates = [
     'md',
     'mdx'
 ];
-const scriptFileExtensionList = [...extJavaScript, ...extJsx, ...extTemplates];
-const scriptFileExtensions = '(' + scriptFileExtensionList.join('|') + ')';
+const scriptFileExtensionList = [...extJsOrTs, ...extJsxOrTsx, ...extTemplates];
+const scriptFileExtensionPattern = '(' + scriptFileExtensionList.join('|') + ')';
 function isScriptFile(filePath) {
-    const yes = scriptFileExtensionList.some((ext) => filePath.endsWith('.' + ext));
-    if (isPlainJavaScriptFile(filePath))
-        assert(yes);
-    return yes;
+    return scriptFileExtensionList.some((ext) => filePath.endsWith('.' + ext));
 }
-function isPlainJavaScriptFile(filePath) {
-    const yes1 = /\.(c|m)?(j|t)s$/.test(filePath);
-    const yes2 = extJavaScript.some((ext) => filePath.endsWith('.' + ext));
-    assert(yes1 === yes2);
-    return yes1;
+function isPlainScriptFile(filePath) {
+    return extJsOrTs.some((ext) => filePath.endsWith('.' + ext));
 }
 function isTemplateFile(filePath) {
     return extTemplates.some((ext) => filePath.endsWith('.' + ext));

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

@@ -1,2 +1,2 @@
 export { objectAssign };
-declare function objectAssign<Obj extends object, ObjAddendum extends object | null>(obj: Obj, objAddendum: ObjAddendum, objAddendumCanBePageContextObject?: true): asserts obj is Obj & ObjAddendum;
+declare function objectAssign<Obj extends object, ObjAddendum extends object | null | undefined>(obj: Obj, objAddendum: ObjAddendum, objAddendumCanBePageContextObject?: true): asserts obj is Obj & ObjAddendum;

package/dist/esm/utils/objectAssign.js

@@ -2,15 +2,11 @@ export { objectAssign };
 import { assert } from './assert.js';
 // Same as Object.assign() but:
 //  - With type inference
-//  - Preserves property descriptors, which we need for preserving the getters added by getPageContextUrlComputed()
+//  - Preserves property descriptors, which we need for preserving the getters of getPageContextUrlComputed()
 function objectAssign(obj, objAddendum, objAddendumCanBePageContextObject) {
-    if (objAddendum) {
-        if (!objAddendumCanBePageContextObject) {
-            // We only need this assert() in the rare case when the user is expected to mutate `pageContext` after the Vike hook was executed (and its promise resolved).
-            // - The only use case I can think of is the user mutating `pageContext` after the onRenderClient() promise resolved (which can happen when client-side rendering finishes after onRenderClient() resolves). In that case, having Vike await async Vike hooks isn't enough.
-            // - IIRC this assert() was mostly needed for preserving the getters added by getPageContextUrlComputed() but we don't need this anymore.
-            assert(!('_isPageContextObject' in objAddendum));
-        }
-        Object.defineProperties(obj, Object.getOwnPropertyDescriptors(objAddendum));
-    }
+    if (!objAddendum)
+        return;
+    if (!objAddendumCanBePageContextObject)
+        assert(!('isPageContext' in objAddendum));
+    Object.defineProperties(obj, Object.getOwnPropertyDescriptors(objAddendum));
 }

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

@@ -1 +1 @@
-export declare function objectReplace(obj: object, objNew: object, except?: string[]): void;
+export declare function objectReplace<T extends object>(objOld: T, objNew: T, except?: string[]): void;

package/dist/esm/utils/objectReplace.js

@@ -1,6 +1,6 @@
-export function objectReplace(obj, objNew, except) {
-    Object.keys(obj)
+export function objectReplace(objOld, objNew, except) {
+    Object.keys(objOld)
         .filter((key) => !except?.includes(key))
-        .forEach((key) => delete obj[key]);
-    Object.assign(obj, objNew);
+        .forEach((key) => delete objOld[key]);
+    Object.defineProperties(objOld, Object.getOwnPropertyDescriptors(objNew));
 }

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

@@ -0,0 +1,19 @@
+export { isImportPathNpmPackage };
+export { isImportPathNpmPackageOrPathAlias };
+export { assertIsImportPathNpmPackage };
+export { isPathAliasRecommended };
+export { getNpmPackageName };
+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 getNpmPackageName(str: string): null | string;
+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 };
+export { getNpmPackageName };
 /* 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;