@cspell/url 8.16.0 → 8.17.0

package/dist/FileUrlBuilder.d.mts

@@ -1,5 +1,4 @@
 import Path from 'node:path';
-export declare const isWindows: boolean;
 export declare const percentRegEx: RegExp;
 export declare const backslashRegEx: RegExp;
 export declare const newlineRegEx: RegExp;

package/dist/FileUrlBuilder.mjs

@@ -1,9 +1,8 @@
 import assert from 'node:assert';
 import Path from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { pathWindowsDriveLetterToUpper, regExpWindowsPathDriveLetter, toFilePathOrHref } from './fileUrl.mjs';
+import { isFileURL, isWindows, isWindowsFileUrl, isWindowsPathnameWithDriveLatter, pathWindowsDriveLetterToUpper, regExpWindowsPathDriveLetter, toFilePathOrHref, } from './fileUrl.mjs';
 import { addTrailingSlash, isUrlLike, normalizeWindowsUrl, regExpWindowsPath, urlParent, urlToUrlRelative, } from './url.mjs';
-export const isWindows = process.platform === 'win32';
 const isWindowsPathRegEx = regExpWindowsPathDriveLetter;
 const isWindowsPathname = regExpWindowsPath;
 export const percentRegEx = /%/g;
@@ -94,17 +93,25 @@ export class FileUrlBuilder {
         if (typeof filenameOrUrl !== 'string')
             return filenameOrUrl;
         if (isUrlLike(filenameOrUrl))
-            return new URL(filenameOrUrl);
+            return normalizeWindowsUrl(new URL(filenameOrUrl));
         relativeTo ??= this.cwd;
         isWindows && (filenameOrUrl = filenameOrUrl.replaceAll('\\', '/'));
+        if (this.isAbsolute(filenameOrUrl) && isFileURL(relativeTo)) {
+            const pathname = this.normalizeFilePathForUrl(filenameOrUrl);
+            if (isWindowsFileUrl(relativeTo) && !isWindowsPathnameWithDriveLatter(pathname)) {
+                const relFilePrefix = relativeTo.toString().slice(0, 10);
+                return normalizeWindowsUrl(new URL(relFilePrefix + pathname));
+            }
+            return normalizeWindowsUrl(new URL('file://' + pathname));
+        }
         if (isUrlLike(relativeTo)) {
             const pathname = this.normalizeFilePathForUrl(filenameOrUrl);
-            return new URL(pathname, relativeTo);
+            return normalizeWindowsUrl(new URL(pathname, relativeTo));
         }
         // Resolve removes the trailing slash, so we need to add it back.
         const appendSlash = filenameOrUrl.endsWith('/') ? '/' : '';
         const pathname = this.normalizeFilePathForUrl(this.path.resolve(relativeTo.toString(), filenameOrUrl)) + appendSlash;
-        return this.pathToFileURL(pathname, this.cwd);
+        return normalizeWindowsUrl(new URL('file://' + pathname));
     }
     /**
      * Try to make a URL for a directory.
@@ -121,7 +128,7 @@ export class FileUrlBuilder {
         return this.#urlToFilePathOrHref(url);
     }
     #urlToFilePathOrHref(url) {
-        if (url.protocol !== ProtocolFile)
+        if (url.protocol !== ProtocolFile || url.hostname)
             return url.href;
         const p = this.path === Path
             ? toFilePathOrHref(url)

package/dist/fileUrl.d.mts

@@ -1,3 +1,5 @@
+export declare const isWindows: boolean;
+export declare function isWindowsPathnameWithDriveLatter(pathname: string): boolean;
 /**
  * @param url - URL or string to check if it is a file URL.
  * @returns true if the URL is a file URL.
@@ -11,4 +13,10 @@ export declare function isFileURL(url: URL | string): boolean;
 export declare function toFilePathOrHref(url: URL | string): string;
 export declare const regExpWindowsPathDriveLetter: RegExp;
 export declare function pathWindowsDriveLetterToUpper(absoluteFilePath: string): string;
+/**
+ * Test if a url is a file url with a windows path. It does check for UNC paths.
+ * @param url - the url
+ * @returns true if the url is a file url with a windows path with a drive letter.
+ */
+export declare function isWindowsFileUrl(url: URL | string): boolean;
 //# sourceMappingURL=fileUrl.d.mts.map

package/dist/fileUrl.mjs

@@ -1,5 +1,10 @@
-import { fileURLToPath } from 'node:url';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 import { hasProtocol } from './url.mjs';
+export const isWindows = process.platform === 'win32';
+const windowsUrlPathRegExp = /^\/[a-zA-Z]:\//;
+export function isWindowsPathnameWithDriveLatter(pathname) {
+    return windowsUrlPathRegExp.test(pathname);
+}
 /**
  * @param url - URL or string to check if it is a file URL.
  * @returns true if the URL is a file URL.
@@ -13,13 +18,41 @@ export function isFileURL(url) {
  * @returns path or href
  */
 export function toFilePathOrHref(url) {
-    return isFileURL(url) ? toFilePath(url) : url.toString();
+    return isFileURL(url) && url.toString().startsWith('file:///') ? toFilePath(url) : url.toString();
 }
 function toFilePath(url) {
-    return pathWindowsDriveLetterToUpper(fileURLToPath(url));
+    try {
+        // Fix drive letter if necessary.
+        if (isWindows) {
+            const u = new URL(url);
+            if (!isWindowsPathnameWithDriveLatter(u.pathname)) {
+                const cwdUrl = pathToFileURL(process.cwd());
+                if (cwdUrl.hostname) {
+                    return fileURLToPath(new URL(u.pathname, cwdUrl));
+                }
+                const drive = cwdUrl.pathname.split('/')[1];
+                u.pathname = `/${drive}${u.pathname}`;
+                return fileURLToPath(u);
+            }
+        }
+        return pathWindowsDriveLetterToUpper(fileURLToPath(url));
+    }
+    catch {
+        // console.error('Failed to convert URL to path', url);
+        return url.toString();
+    }
 }
 export const regExpWindowsPathDriveLetter = /^([a-zA-Z]):[\\/]/;
 export function pathWindowsDriveLetterToUpper(absoluteFilePath) {
     return absoluteFilePath.replace(regExpWindowsPathDriveLetter, (s) => s.toUpperCase());
 }
+const regExpWindowsFileUrl = /^file:\/\/\/[a-zA-Z]:\//;
+/**
+ * Test if a url is a file url with a windows path. It does check for UNC paths.
+ * @param url - the url
+ * @returns true if the url is a file url with a windows path with a drive letter.
+ */
+export function isWindowsFileUrl(url) {
+    return regExpWindowsFileUrl.test(url.toString());
+}
 //# sourceMappingURL=fileUrl.mjs.map

package/dist/index.d.mts

@@ -3,5 +3,5 @@ export { encodePathChars, normalizeFilePathForUrl, toFileDirURL, toFileURL } fro
 export { isFileURL, toFilePathOrHref } from './fileUrl.mjs';
 export type { BuilderOptions, PathInterface } from './FileUrlBuilder.mjs';
 export { FileUrlBuilder } from './FileUrlBuilder.mjs';
-export { addTrailingSlash, basenameOfUrlPathname, hasProtocol, isNotUrlLike, isURL, isUrlLike, toURL, urlDirname, urlParent, urlRelative, } from './url.mjs';
+export { addTrailingSlash, basenameOfUrlPathname, fixUncUrl, hasProtocol, isNotUrlLike, isURL, isUrlLike, normalizeWindowsUrl, toURL, urlDirname, urlParent, urlRelative, } from './url.mjs';
 //# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -2,5 +2,5 @@ export { isDataURL, urlBasename } from './dataUrl.mjs';
 export { encodePathChars, normalizeFilePathForUrl, toFileDirURL, toFileURL } from './defaultFileUrlBuilder.mjs';
 export { isFileURL, toFilePathOrHref } from './fileUrl.mjs';
 export { FileUrlBuilder } from './FileUrlBuilder.mjs';
-export { addTrailingSlash, basenameOfUrlPathname, hasProtocol, isNotUrlLike, isURL, isUrlLike, toURL, urlDirname, urlParent, urlRelative, } from './url.mjs';
+export { addTrailingSlash, basenameOfUrlPathname, fixUncUrl, hasProtocol, isNotUrlLike, isURL, isUrlLike, normalizeWindowsUrl, toURL, urlDirname, urlParent, urlRelative, } from './url.mjs';
 //# sourceMappingURL=index.mjs.map

package/dist/url.d.mts

@@ -105,4 +105,10 @@ export declare const regExpEncodedColon: RegExp;
  * @returns a new URL if modified or converted from a string.
  */
 export declare function normalizeWindowsUrl(url: URL | string): URL;
+/**
+ * There is a bug is NodeJS that sometimes causes UNC paths converted to a URL to be prefixed with `file:////`.
+ * @param url - URL to check.
+ * @returns fixed URL if needed.
+ */
+export declare function fixUncUrl(url: URL): URL;
 //# sourceMappingURL=url.d.mts.map

package/dist/url.mjs

@@ -150,6 +150,7 @@ export function urlToUrlRelative(urlFrom, urlTo) {
 }
 export const regExpWindowsPath = /^[\\/]([a-zA-Z]:[\\/])/;
 export const regExpEncodedColon = /%3[aA]/g;
+const badUncLocalhostUrl = /^(\/+[a-zA-Z])\$/;
 /**
  * Ensure that a windows file url is correctly formatted with a capitol letter for the drive.
  *
@@ -159,15 +160,28 @@ export const regExpEncodedColon = /%3[aA]/g;
 export function normalizeWindowsUrl(url) {
     url = typeof url === 'string' ? new URL(url) : url;
     if (url.protocol === 'file:') {
-        const pathname = url.pathname
-            .replaceAll(regExpEncodedColon, ':')
-            .replace(regExpWindowsPath, (d) => d.toUpperCase());
+        let pathname = url.pathname.replaceAll('%3A', ':').replaceAll('%3a', ':').replaceAll('%24', '$');
+        if (!url.host) {
+            pathname = pathname.replace(badUncLocalhostUrl, '$1:');
+        }
+        pathname = pathname.replace(regExpWindowsPath, (d) => d.toUpperCase());
         if (pathname !== url.pathname) {
             url = new URL(url);
             url.pathname = pathname;
-            return url;
+            return fixUncUrl(url);
         }
     }
+    return fixUncUrl(url);
+}
+/**
+ * There is a bug is NodeJS that sometimes causes UNC paths converted to a URL to be prefixed with `file:////`.
+ * @param url - URL to check.
+ * @returns fixed URL if needed.
+ */
+export function fixUncUrl(url) {
+    if (url.href.startsWith('file:////')) {
+        return new URL(url.href.replace(/^file:\/{4}/, 'file://'));
+    }
     return url;
 }
 //# sourceMappingURL=url.mjs.map

package/package.json

@@ -4,7 +4,7 @@
     "access": "public",
     "provenance": true
   },
-  "version": "8.16.0",
+  "version": "8.17.0",
   "description": "URL parsing and manipulation utilities for cspell",
   "keywords": [
     "cspell",
@@ -57,5 +57,5 @@
   "engines": {
     "node": ">=18.0"
   },
-  "gitHead": "41cd50f9ba34033b6da32408855d7fc3b888c5e0"
+  "gitHead": "cac17fe7b993db5965aa441648b1c22cb5486929"
 }