cspell-lib 8.1.2 → 8.2.0

package/dist/esm/util/resolveFile.js

@@ -1,165 +1,258 @@
 import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
 import { resolveGlobal } from '@cspell/cspell-resolver';
 import { importResolveModuleName } from '@cspell/dynamic-import';
-import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
 import resolveFrom from 'resolve-from';
 import { fileURLToPath } from 'url';
 import { srcDirectory } from '../../lib-cjs/pkg-info.cjs';
-import { fileURLOrPathToPath, isDataURL, isFileURL, isURLLike, resolveFileWithURL, toFilePathOrHref, toURL, } from './url.js';
-const testNodeModules = /^node_modules\//;
-/**
- * Resolve filename to absolute paths.
- * It tries to look for local files as well as node_modules
- * @param filename an absolute path, relative path, `~` path, or a node_module.
- * @param relativeTo absolute path
- */
-export function resolveFile(filename, relativeTo) {
-    filename = filename.replace(/^~/, os.homedir());
-    const steps = [
-        { filename, fn: tryUrl },
-        { filename, fn: tryCreateRequire },
-        { filename, fn: tryNodeRequireResolve },
-        { filename, fn: tryImportResolve },
-        { filename, fn: tryResolveExists },
-        { filename, fn: tryNodeResolveDefaultPaths },
-        { filename, fn: tryResolveFrom },
-        { filename: filename.replace(testNodeModules, ''), fn: tryResolveFrom },
-        { filename, fn: tryResolveGlobal },
-    ];
-    for (const step of steps) {
-        const r = step.fn(step.filename, relativeTo);
-        if (r?.found)
-            return r;
+import { getFileSystem } from '../fileSystem.js';
+import { envToTemplateVars, replaceTemplate } from './templates.js';
+import { fileURLOrPathToPath, isDataURL, isFileURL, isURLLike, resolveFileWithURL, toFilePathOrHref, toFileUrl, toURL, } from './url.js';
+const regExpStartsWidthNodeModules = /^node_modules[/\\]/;
+export class FileResolver {
+    fs;
+    templateReplacements;
+    constructor(fs, templateReplacements) {
+        this.fs = fs;
+        this.templateReplacements = templateReplacements;
     }
-    const r = tryUrl(filename, relativeTo);
-    return (r || {
-        filename: isRelative(filename) ? joinWith(filename, relativeTo) : filename.toString(),
-        relativeTo: relativeTo.toString(),
-        found: false,
-    });
-}
-/**
- * Check to see if it is a URL.
- * Note: URLs are absolute!
- * If relativeTo is a non-file URL, then it will try to resolve the filename relative to it.
- * @param filename - url string
- * @returns ResolveFileResult
- */
-function tryUrl(filename, relativeToURL) {
-    if (isURLLike(filename)) {
-        if (isFileURL(filename)) {
-            const file = fileURLToPath(filename);
+    /**
+     * Resolve filename to absolute paths.
+     * - Replaces `${env:NAME}` with the value of the environment variable `NAME`.
+     * - Replaces `~` with the user's home directory.
+     * It tries to look for local files as well as node_modules
+     * @param filename an absolute path, relative path, `~` path, a node_module, or URL.
+     * @param relativeTo absolute path
+     */
+    async resolveFile(filename, relativeTo) {
+        if (filename instanceof URL) {
             return {
-                filename: file,
-                relativeTo: undefined,
-                found: fs.existsSync(file),
+                filename: toFilePathOrHref(filename),
+                relativeTo: relativeTo.toString(),
+                found: await this.doesExist(filename),
+                method: 'url',
             };
         }
-        return { filename: filename.toString(), relativeTo: undefined, found: true };
+        const result = await this._resolveFile(filename, relativeTo);
+        const match = filename.match(regExpStartsWidthNodeModules);
+        if (match) {
+            result.warning ??= `Import of '${filename}' should not start with '${match[0]}' in '${toFilePathOrHref(relativeTo)}'. Use '${filename.replace(regExpStartsWidthNodeModules, '')}' or a relative path instead.`;
+        }
+        return result;
     }
-    if (isURLLike(relativeToURL) && !isDataURL(relativeToURL)) {
-        const relToURL = toURL(relativeToURL);
-        const isRelToAFile = isFileURL(relToURL);
-        const url = resolveFileWithURL(filename, relToURL);
-        return {
-            filename: toFilePathOrHref(url),
-            relativeTo: toFilePathOrHref(relToURL),
-            found: !isRelToAFile || fs.existsSync(url),
+    async _resolveFile(filename, relativeTo) {
+        filename = patchFilename(filename, this.templateReplacements);
+        const steps = [
+            { filename, fn: this.tryUrl },
+            { filename, fn: this.tryCreateRequire },
+            { filename, fn: this.tryNodeRequireResolve },
+            { filename, fn: this.tryImportResolve },
+            { filename, fn: this.tryResolveExists },
+            { filename, fn: this.tryNodeResolveDefaultPaths },
+            { filename, fn: this.tryResolveFrom },
+            { filename, fn: this.tryResolveGlobal },
+            { filename, fn: this.tryLegacyResolve },
+        ];
+        for (const step of steps) {
+            const r = await step.fn(step.filename, relativeTo);
+            if (r?.found)
+                return r;
+        }
+        const result = (await this.tryUrl(filename, relativeTo)) || {
+            filename: isRelative(filename) ? joinWith(filename, relativeTo) : filename.toString(),
+            relativeTo: relativeTo.toString(),
+            found: false,
+            method: 'not found',
         };
+        return result;
     }
-    return undefined;
-}
-function tryCreateRequire(filename, relativeTo) {
-    if (filename instanceof URL)
-        return undefined;
-    const require = createRequire(relativeTo);
-    try {
-        const r = require.resolve(filename);
-        return { filename: r, relativeTo: relativeTo.toString(), found: true };
-    }
-    catch (_) {
-        return undefined;
-    }
-}
-function tryNodeResolveDefaultPaths(filename) {
-    try {
-        const r = require.resolve(filename);
-        return { filename: r, relativeTo: undefined, found: true };
+    async doesExist(file) {
+        try {
+            const s = await this.fs.stat(file);
+            return s.isFile() || s.isUnknown();
+        }
+        catch (error) {
+            return false;
+        }
     }
-    catch (_) {
+    /**
+     * Check to see if it is a URL.
+     * Note: URLs are absolute!
+     * If relativeTo is a non-file URL, then it will try to resolve the filename relative to it.
+     * @param filename - url string
+     * @returns ResolveFileResult
+     */
+    tryUrl = async (filename, relativeToURL) => {
+        if (isURLLike(filename)) {
+            const fileURL = toURL(filename);
+            return {
+                filename: toFilePathOrHref(fileURL),
+                relativeTo: undefined,
+                found: await this.doesExist(fileURL),
+                method: 'tryUrl',
+            };
+        }
+        if (isURLLike(relativeToURL) && !isDataURL(relativeToURL)) {
+            const relToURL = toURL(relativeToURL);
+            const url = resolveFileWithURL(filename, relToURL);
+            return {
+                filename: toFilePathOrHref(url),
+                relativeTo: toFilePathOrHref(relToURL),
+                found: await this.doesExist(url),
+                method: 'tryUrl',
+            };
+        }
         return undefined;
-    }
-}
-function tryNodeRequireResolve(filenameOrURL, relativeTo) {
-    const filename = fileURLOrPathToPath(filenameOrURL);
-    const relativeToPath = fileURLOrPathToPath(relativeTo);
-    const home = os.homedir();
-    function calcPaths(p) {
-        const paths = [p];
-        // Do not progress towards the root if it is a relative filename.
-        if (isRelative(filename)) {
+    };
+    tryCreateRequire = (filename, relativeTo) => {
+        if (filename instanceof URL)
+            return undefined;
+        const rel = !isURLLike(relativeTo) || isFileURL(relativeTo) ? relativeTo : pathToFileURL('./');
+        const require = createRequire(rel);
+        try {
+            const r = require.resolve(filename);
+            return { filename: r, relativeTo: rel.toString(), found: true, method: 'tryCreateRequire' };
+        }
+        catch (_) {
+            return undefined;
+        }
+    };
+    tryNodeResolveDefaultPaths = (filename) => {
+        try {
+            const r = require.resolve(filename);
+            return { filename: r, relativeTo: undefined, found: true, method: 'tryNodeResolveDefaultPaths' };
+        }
+        catch (_) {
+            return undefined;
+        }
+    };
+    tryNodeRequireResolve = (filenameOrURL, relativeTo) => {
+        if (isURLLike(relativeTo) && !isFileURL(relativeTo))
+            return undefined;
+        const filename = fileURLOrPathToPath(filenameOrURL);
+        const relativeToPath = pathFromRelativeTo(relativeTo);
+        const home = os.homedir();
+        function calcPaths(p) {
+            const paths = [p];
+            // Do not progress towards the root if it is a relative filename.
+            if (isRelative(filename)) {
+                return paths;
+            }
+            for (; p && path.dirname(p) !== p && p !== home; p = path.dirname(p)) {
+                paths.push(p);
+            }
             return paths;
         }
-        for (; p && path.dirname(p) !== p && p !== home; p = path.dirname(p)) {
-            paths.push(p);
+        const paths = calcPaths(path.resolve(relativeToPath));
+        try {
+            const r = require.resolve(filename, { paths });
+            return { filename: r, relativeTo: relativeToPath, found: true, method: 'tryNodeRequireResolve' };
+        }
+        catch (_) {
+            return undefined;
+        }
+    };
+    tryImportResolve = (filename, relativeTo) => {
+        try {
+            const paths = isRelative(filename) ? [relativeTo] : [relativeTo, srcDirectory];
+            const resolved = fileURLToPath(importResolveModuleName(filename, paths));
+            return { filename: resolved, relativeTo: relativeTo.toString(), found: true, method: 'tryImportResolve' };
+        }
+        catch (_) {
+            return undefined;
+        }
+    };
+    tryResolveGlobal = (filename) => {
+        const r = resolveGlobal(filename);
+        return (r && { filename: r, relativeTo: undefined, found: true, method: 'tryResolveGlobal' }) || undefined;
+    };
+    tryResolveExists = async (filename, relativeTo) => {
+        if (filename instanceof URL || isURLLike(filename) || (isURLLike(relativeTo) && !isFileURL(relativeTo))) {
+            return undefined;
+        }
+        relativeTo = pathFromRelativeTo(relativeTo);
+        const toTry = [{ filename }, { filename: path.resolve(relativeTo, filename), relativeTo }];
+        for (const { filename, relativeTo } of toTry) {
+            const found = path.isAbsolute(filename) && (await this.doesExist(toFileUrl(filename)));
+            if (found)
+                return { filename, relativeTo: relativeTo?.toString(), found, method: 'tryResolveExists' };
+        }
+        filename = path.resolve(filename);
+        return {
+            filename,
+            relativeTo: path.resolve('.'),
+            found: await this.doesExist(toFileUrl(filename)),
+            method: 'tryResolveExists',
+        };
+    };
+    tryResolveFrom = (filename, relativeTo) => {
+        if (relativeTo instanceof URL)
+            return undefined;
+        try {
+            return {
+                filename: resolveFrom(pathFromRelativeTo(relativeTo), filename),
+                relativeTo,
+                found: true,
+                method: 'tryResolveFrom',
+            };
+        }
+        catch (error) {
+            // Failed to resolve a relative module request
+            return undefined;
+        }
+    };
+    tryLegacyResolve = (filename, relativeTo) => {
+        if (filename instanceof URL || isURLLike(filename) || (isURLLike(relativeTo) && !isFileURL(relativeTo))) {
+            return undefined;
+        }
+        const relativeToPath = isURLLike(relativeTo) ? fileURLToPath(new URL('./', relativeTo)) : relativeTo.toString();
+        const match = filename.match(regExpStartsWidthNodeModules);
+        if (match) {
+            const fixedFilename = filename.replace(regExpStartsWidthNodeModules, '');
+            const found = this.tryImportResolve(fixedFilename, relativeToPath) ||
+                this.tryResolveFrom(fixedFilename, relativeToPath);
+            if (found?.found) {
+                found.method = 'tryLegacyResolve';
+                return found;
+            }
         }
-        return paths;
-    }
-    const paths = calcPaths(path.resolve(relativeToPath));
-    try {
-        const r = require.resolve(filename, { paths });
-        return { filename: r, relativeTo: relativeToPath, found: true };
-    }
-    catch (_) {
-        return undefined;
-    }
-}
-function tryImportResolve(filename, relativeTo) {
-    try {
-        const paths = isRelative(filename) ? [relativeTo] : [relativeTo, srcDirectory];
-        const resolved = fileURLToPath(importResolveModuleName(filename, paths));
-        return { filename: resolved, relativeTo: relativeTo.toString(), found: true };
-    }
-    catch (_) {
         return undefined;
-    }
-}
-function tryResolveGlobal(filename) {
-    const r = resolveGlobal(filename);
-    return (r && { filename: r, relativeTo: undefined, found: true }) || undefined;
+    };
 }
-function tryResolveExists(filename, relativeTo) {
-    if (filename instanceof URL || isURLLike(filename) || isURLLike(relativeTo))
-        return undefined;
-    const toTry = [{ filename }, { filename: path.resolve(relativeTo.toString(), filename), relativeTo }];
-    for (const { filename, relativeTo } of toTry) {
-        const found = path.isAbsolute(filename) && fs.existsSync(filename);
-        if (found)
-            return { filename, relativeTo: relativeTo?.toString(), found };
-    }
-    filename = path.resolve(filename);
-    return {
-        filename,
-        relativeTo: path.resolve('.'),
-        found: fs.existsSync(filename),
+export function patchFilename(filename, templateReplacements) {
+    const defaultReplacements = {
+        cwd: process.cwd(),
+        pathSeparator: path.sep,
+        userHome: os.homedir(),
     };
+    filename = filename.replace(/^~(?=[/\\])/, defaultReplacements.userHome);
+    filename = replaceTemplate(filename, { ...defaultReplacements, ...templateReplacements });
+    return filename;
 }
-function tryResolveFrom(filename, relativeTo) {
-    if (relativeTo instanceof URL)
-        return undefined;
-    try {
-        return { filename: resolveFrom(relativeTo, filename), relativeTo, found: true };
-    }
-    catch (error) {
-        // Failed to resolve a relative module request
-        return undefined;
-    }
+/**
+ * Resolve filename to a URL
+ * - Replaces `${env:NAME}` with the value of the environment variable `NAME`.
+ * - Replaces `~` with the user's home directory.
+ * It will not resolve Node modules.
+ * @param filename - a filename, path, relative path, or URL.
+ * @param relativeTo - a path, or URL.
+ * @param env - environment variables used to patch the filename.
+ * @returns a URL
+ */
+export function resolveRelativeTo(filename, relativeTo, templateReplacements = envToTemplateVars(process.env)) {
+    if (filename instanceof URL)
+        return filename;
+    filename = patchFilename(filename, templateReplacements);
+    const relativeToUrl = toFileUrl(relativeTo);
+    return resolveFileWithURL(filename, relativeToUrl);
 }
 function isRelative(filename) {
     if (filename instanceof URL)
         return false;
+    if (isURLLike(filename))
+        return false;
     if (filename.startsWith('./'))
         return true;
     if (filename.startsWith('../'))
@@ -175,17 +268,20 @@ function joinWith(filename, relativeTo) {
         ? toFilePathOrHref(new URL(filename, relativeTo))
         : path.resolve(relativeTo, filename);
 }
-export const __testing__ = {
-    isRelative,
-    isFileURL,
-    isURLLike,
-    fileURLOrPathToPath,
-    tryResolveFrom,
-    tryResolveExists,
-    tryResolveGlobal,
-    tryImportResolve,
-    tryNodeRequireResolve,
-    tryNodeResolveDefaultPaths,
-    tryUrl,
-};
+function pathFromRelativeTo(relativeTo) {
+    return relativeTo instanceof URL || isURLLike(relativeTo) ? fileURLToPath(new URL('./', relativeTo)) : relativeTo;
+}
+const loaderCache = new WeakMap();
+export function createFileResolver(fs, templateVariables = envToTemplateVars(process.env)) {
+    let loader = loaderCache.get(fs);
+    if (!loader) {
+        loader = new FileResolver(fs, templateVariables);
+        loaderCache.set(fs, loader);
+    }
+    return loader;
+}
+export async function resolveFile(filename, relativeTo, fs = getFileSystem()) {
+    const resolver = createFileResolver(fs);
+    return resolver.resolveFile(filename, relativeTo);
+}
 //# sourceMappingURL=resolveFile.js.map

package/dist/esm/util/templates.d.ts

@@ -0,0 +1,3 @@
+export declare function replaceTemplate(template: string, replacements: Record<string, string | undefined>): string;
+export declare function envToTemplateVars(env: Record<string, string | undefined>): Record<string, string>;
+//# sourceMappingURL=templates.d.ts.map

package/dist/esm/util/templates.js

@@ -0,0 +1,36 @@
+export function replaceTemplate(template, replacements) {
+    const templateStart = '${';
+    const tLen = templateStart.length;
+    const templateEnd = '}';
+    const parts = [];
+    let lastPos = 0;
+    let p = template.indexOf(templateStart, lastPos);
+    if (p < 0)
+        return template;
+    while (p >= 0) {
+        parts.push(template.substring(lastPos, p));
+        lastPos = p;
+        const end = template.indexOf(templateEnd, p);
+        if (end < 0)
+            break;
+        const name = template.substring(p + tLen, end);
+        if (name in replacements) {
+            parts.push(replacements[name] || '');
+        }
+        else {
+            parts.push(template.substring(p, end + 1));
+        }
+        lastPos = end + 1;
+        p = template.indexOf(templateStart, lastPos);
+    }
+    parts.push(template.substring(lastPos));
+    return parts.join('');
+}
+export function envToTemplateVars(env) {
+    const vars = {};
+    for (const [key, value] of Object.entries(env)) {
+        vars[`env:${key}`] = value || '';
+    }
+    return vars;
+}
+//# sourceMappingURL=templates.js.map

package/dist/esm/util/url.d.ts

@@ -17,7 +17,7 @@ export declare function getSourceDirectoryUrl(): URL;
 export declare function relativeTo(path: string, relativeTo?: URL | string): URL;
 export declare function cwdURL(): URL;
 export declare function resolveFileWithURL(file: string | URL, relativeToURL: URL): URL;
-export declare function normalizePathSlashesForUrl(filePath: string, sep?: "/" | "\\"): string;
+export declare function normalizePathSlashesForUrl(filePath: string, sep?: string | RegExp): string;
 export declare function toFileUrl(file: string | URL): URL;
 export declare function toFileDirUrl(dir: string | URL): URL;
 export declare function addTrailingSlash(url: URL): URL;
@@ -26,4 +26,5 @@ export declare function fileURLOrPathToPath(filenameOrURL: string | URL): string
 export declare function isURLLike(url: string | URL): boolean;
 export declare function isFileURL(url: string | URL): boolean;
 export declare function isDataURL(url: string | URL): boolean;
+export declare function windowsDriveLetterToUpper(absoluteFilePath: string): string;
 //# sourceMappingURL=url.d.ts.map

package/dist/esm/util/url.js

@@ -1,7 +1,7 @@
 import path from 'path';
 import { fileURLToPath, pathToFileURL } from 'url';
 import { srcDirectory } from '../../lib-cjs/pkg-info.cjs';
-const isUrlRegExp = /^(?:\w+:\/\/|data:)/i;
+const isUrlRegExp = /^(?:[\w][\w-]+:\/|data:|untitled:)/i;
 /**
  * Convert a URL into a string. If it is a file URL, convert it to a path.
  * @param url - URL
@@ -47,7 +47,7 @@ export function resolveFileWithURL(file, relativeToURL) {
     }
     return relativeTo(file, relativeToURL);
 }
-export function normalizePathSlashesForUrl(filePath, sep = path.sep) {
+export function normalizePathSlashesForUrl(filePath, sep = /[/\\]/g) {
     return filePath
         .replace(/^([a-z]:)/i, '/$1')
         .split(sep)
@@ -72,7 +72,10 @@ export function toURL(href, relativeTo) {
     return href instanceof URL ? href : new URL(href, relativeTo);
 }
 export function fileURLOrPathToPath(filenameOrURL) {
-    return isFileURL(filenameOrURL) ? fileURLToPath(filenameOrURL) : filenameOrURL.toString();
+    return isFileURL(filenameOrURL) ? toFilePath(filenameOrURL) : filenameOrURL.toString();
+}
+function toFilePath(url) {
+    return windowsDriveLetterToUpper(fileURLToPath(url));
 }
 export function isURLLike(url) {
     return url instanceof URL || isUrlRegExp.test(url);
@@ -87,4 +90,7 @@ function isUrlWithProtocol(url, protocol) {
     protocol = protocol.endsWith(':') ? protocol : protocol + ':';
     return url instanceof URL ? url.protocol === protocol : url.startsWith(protocol);
 }
+export function windowsDriveLetterToUpper(absoluteFilePath) {
+    return absoluteFilePath.replace(/^([a-z]):\\/, (s) => s.toUpperCase());
+}
 //# sourceMappingURL=url.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell-lib",
-  "version": "8.1.2",
+  "version": "8.2.0",
   "description": "A library of useful functions used across various cspell tools.",
   "type": "module",
   "sideEffects": false,
@@ -57,21 +57,21 @@
   },
   "homepage": "https://github.com/streetsidesoftware/cspell#readme",
   "dependencies": {
-    "@cspell/cspell-bundled-dicts": "8.1.2",
-    "@cspell/cspell-pipe": "8.1.2",
-    "@cspell/cspell-resolver": "8.1.2",
-    "@cspell/cspell-types": "8.1.2",
-    "@cspell/dynamic-import": "8.1.2",
-    "@cspell/strong-weak-map": "8.1.2",
+    "@cspell/cspell-bundled-dicts": "8.2.0",
+    "@cspell/cspell-pipe": "8.2.0",
+    "@cspell/cspell-resolver": "8.2.0",
+    "@cspell/cspell-types": "8.2.0",
+    "@cspell/dynamic-import": "8.2.0",
+    "@cspell/strong-weak-map": "8.2.0",
     "clear-module": "^4.1.2",
     "comment-json": "^4.2.3",
     "configstore": "^6.0.0",
-    "cspell-config-lib": "8.1.2",
-    "cspell-dictionary": "8.1.2",
-    "cspell-glob": "8.1.2",
-    "cspell-grammar": "8.1.2",
-    "cspell-io": "8.1.2",
-    "cspell-trie-lib": "8.1.2",
+    "cspell-config-lib": "8.2.0",
+    "cspell-dictionary": "8.2.0",
+    "cspell-glob": "8.2.0",
+    "cspell-grammar": "8.2.0",
+    "cspell-io": "8.2.0",
+    "cspell-trie-lib": "8.2.0",
     "fast-equals": "^5.0.1",
     "gensequence": "^6.0.0",
     "import-fresh": "^3.3.0",
@@ -95,5 +95,5 @@
     "cspell-dict-nl-nl": "^1.1.2",
     "lorem-ipsum": "^2.0.8"
   },
-  "gitHead": "ba4eef94480562e7641298b32cb99723fd64aeca"
+  "gitHead": "3bcd6430bb33fb221d07030a60a2d61a2479e7ae"
 }

package/dist/esm/static.d.ts

@@ -1,3 +0,0 @@
-import type { CSpellIO } from 'cspell-io';
-export declare function getCSpellIO(): CSpellIO;
-//# sourceMappingURL=static.d.ts.map

package/dist/esm/static.js

@@ -1,6 +0,0 @@
-import { CSpellIONode } from 'cspell-io';
-const cspellIO = new CSpellIONode();
-export function getCSpellIO() {
-    return cspellIO;
-}
-//# sourceMappingURL=static.js.map