@volar/typescript 1.7.10 → 1.8.1

package/out/dtsHost.d.ts

@@ -1,8 +1,8 @@
-import type { FileStat, FileType } from '@volar/language-service';
-export interface IDtsHost {
-    stat(uri: string): Promise<FileStat | undefined>;
-    readFile(fileName: string): Promise<string | undefined>;
-    readDirectory(dirName: string): Promise<[string, FileType][]>;
-}
-export declare function createJsDelivrDtsHost(versions?: Record<string, string>, onFetch?: (fileName: string, text: string) => void): IDtsHost;
-export declare function getPackageNameOfDtsPath(path: string): string | undefined;
+import { FileSystem, ServiceEnvironment } from '@volar/language-service';
+export declare const jsDelivrUriBase = "https://cdn.jsdelivr.net/npm";
+export declare function decorateServiceEnvironment(env: ServiceEnvironment, jsDelivrUriResolver: ReturnType<typeof createJsDelivrUriResolver>, jsDelivrFs: FileSystem): void;
+export declare function createJsDelivrUriResolver(versions?: Record<string, string>, fileNameBase?: string): {
+    uriToFileName: (uri: string) => string | undefined;
+    fileNameToUri: (fileName: string) => string | undefined;
+};
+export declare function createJsDelivrFs(): FileSystem;

package/out/dtsHost.js

@@ -1,127 +1,203 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPackageNameOfDtsPath = exports.createJsDelivrDtsHost = void 0;
-function createJsDelivrDtsHost(versions = {}, onFetch) {
-    return new DtsHost(async (fileName) => {
-        const requestFileName = resolveRequestFileName(fileName);
-        const url = 'https://cdn.jsdelivr.net/npm/' + requestFileName.slice('/node_modules/'.length);
-        const text = await fetchText(url);
-        if (text !== undefined) {
-            onFetch?.(fileName, text);
-        }
-        return text;
-    }, async (pkg) => {
-        let version = versions[pkg];
-        if (!version) {
-            const data = await fetchJson(`https://data.jsdelivr.com/v1/package/resolve/npm/${pkg}@latest`);
-            if (data?.version) {
-                version = data.version;
+exports.createJsDelivrFs = exports.createJsDelivrUriResolver = exports.decorateServiceEnvironment = exports.jsDelivrUriBase = void 0;
+exports.jsDelivrUriBase = 'https://cdn.jsdelivr.net/npm';
+function decorateServiceEnvironment(env, jsDelivrUriResolver, jsDelivrFs) {
+    const fileNameToUri = env.fileNameToUri;
+    const uriToFileName = env.uriToFileName;
+    const fs = env.fs;
+    env.fileNameToUri = fileName => {
+        return jsDelivrUriResolver.fileNameToUri(fileName) ?? fileNameToUri(fileName);
+    };
+    env.uriToFileName = fileName => {
+        return jsDelivrUriResolver.uriToFileName(fileName) ?? uriToFileName(fileName);
+    };
+    env.fs = {
+        stat(uri) {
+            if (jsDelivrUriResolver.uriToFileName(uri)) {
+                return jsDelivrFs.stat(uri);
             }
+            return fs?.stat(uri);
+        },
+        readDirectory(uri) {
+            if (jsDelivrUriResolver.uriToFileName(uri)) {
+                return jsDelivrFs.readDirectory(uri);
+            }
+            return fs?.readDirectory(uri) ?? [];
+        },
+        readFile(uri) {
+            if (jsDelivrUriResolver.uriToFileName(uri)) {
+                return jsDelivrFs.readFile(uri);
+            }
+            return fs?.readFile(uri);
+        },
+    };
+}
+exports.decorateServiceEnvironment = decorateServiceEnvironment;
+function createJsDelivrUriResolver(versions = {}, fileNameBase = '/node_modules') {
+    return {
+        uriToFileName,
+        fileNameToUri,
+    };
+    function uriToFileName(uri) {
+        if (uri === exports.jsDelivrUriBase) {
+            return fileNameBase;
         }
-        if (!version) {
-            return [];
+        if (uri.startsWith(exports.jsDelivrUriBase + '/')) {
+            const path = uri.substring(exports.jsDelivrUriBase.length);
+            const pkgName = getPackageName(path);
+            if (pkgName?.substring(1).includes('@')) {
+                const trimedVersion = pkgName.substring(0, pkgName.lastIndexOf('@'));
+                return `${fileNameBase}${path.replace(pkgName, trimedVersion)}`;
+            }
+            return `${fileNameBase}${path}`;
         }
-        const flat = await fetchJson(`https://data.jsdelivr.com/v1/package/npm/${pkg}@${version}/flat`);
-        if (!flat) {
-            return [];
+    }
+    function fileNameToUri(fileName) {
+        if (fileName === fileNameBase) {
+            return exports.jsDelivrUriBase;
         }
-        return flat.files.map(file => file.name);
-    });
-    function resolveRequestFileName(fileName) {
-        for (const [key, version] of Object.entries(versions)) {
-            if (fileName.startsWith(`/node_modules/${key}/`)) {
-                fileName = fileName.replace(`/node_modules/${key}/`, `/node_modules/${key}@${version}/`);
-                return fileName;
+        if (fileName.startsWith(fileNameBase + '/')) {
+            const path = fileName.substring(fileNameBase.length);
+            const pkgName = getPackageName(path);
+            if (pkgName) {
+                const version = versions[pkgName] ?? 'latest';
+                return `${exports.jsDelivrUriBase}/${pkgName}@${version}${path.substring(1 + pkgName.length)}`;
             }
+            return `${exports.jsDelivrUriBase}${path}`;
         }
-        return fileName;
     }
 }
-exports.createJsDelivrDtsHost = createJsDelivrDtsHost;
-class DtsHost {
-    constructor(fetchText, flat) {
-        this.fetchText = fetchText;
-        this.flat = flat;
-        this.fetchResults = new Map();
-        this.flatResults = new Map();
-    }
-    async stat(fileName) {
-        if (!await this.valid(fileName)) {
-            return;
-        }
-        const pkgName = getPackageNameOfDtsPath(fileName);
-        if (!pkgName) {
-            return;
-        }
-        if (!this.flatResults.has(pkgName)) {
-            this.flatResults.set(pkgName, this.flat(pkgName));
-        }
-        const flat = await this.flatResults.get(pkgName);
-        const filePath = fileName.slice(`/node_modules/${pkgName}`.length);
-        if (flat.includes(filePath)) {
-            return {
-                type: 1,
-                ctime: -1,
-                mtime: -1,
-                size: -1,
-            };
-        }
-        else if (flat.some(f => f.startsWith(filePath + '/'))) {
+exports.createJsDelivrUriResolver = createJsDelivrUriResolver;
+function createJsDelivrFs() {
+    const fetchResults = new Map();
+    const flatResults = new Map();
+    return {
+        stat,
+        readDirectory,
+        readFile,
+    };
+    function stat(uri) {
+        if (uri === exports.jsDelivrUriBase) {
             return {
                 type: 2,
+                size: -1,
                 ctime: -1,
                 mtime: -1,
-                size: -1,
             };
         }
-    }
-    async readDirectory(dirName) {
-        if (!await this.valid(dirName)) {
-            return [];
-        }
-        const pkgName = getPackageNameOfDtsPath(dirName);
-        if (!pkgName) {
-            return [];
+        if (uri.startsWith(exports.jsDelivrUriBase + '/')) {
+            const path = uri.substring(exports.jsDelivrUriBase.length);
+            const pkgName = getPackageName(path);
+            if (!pkgName || !isValidPackageNameSync(pkgName)) {
+                return;
+            }
+            return (async () => {
+                if (!await isValidPackageNameAsync(pkgName)) {
+                    return;
+                }
+                if (!flatResults.has(pkgName)) {
+                    flatResults.set(pkgName, flat(pkgName));
+                }
+                const flatResult = await flatResults.get(pkgName);
+                const filePath = path.slice(`/${pkgName}`.length);
+                const file = flatResult.find(file => file.name === filePath);
+                if (file) {
+                    return {
+                        type: 1,
+                        ctime: new Date(file.time).valueOf(),
+                        mtime: new Date(file.time).valueOf(),
+                        size: file.size,
+                    };
+                }
+                else if (flatResult.some(file => file.name.startsWith(filePath + '/'))) {
+                    return {
+                        type: 2,
+                        ctime: -1,
+                        mtime: -1,
+                        size: -1,
+                    };
+                }
+            })();
         }
-        if (!this.flatResults.has(pkgName)) {
-            this.flatResults.set(pkgName, this.flat(pkgName));
-        }
-        const flat = await this.flatResults.get(pkgName);
-        const dirPath = dirName.slice(`/node_modules/${pkgName}`.length);
-        const files = flat
-            .filter(f => f.substring(0, f.lastIndexOf('/')) === dirPath)
-            .map(f => f.slice(dirPath.length + 1));
-        const dirs = flat
-            .filter(f => f.startsWith(dirPath + '/') && f.substring(dirPath.length + 1).split('/').length >= 2)
-            .map(f => f.slice(dirPath.length + 1).split('/')[0]);
-        return [
-            ...files.map(f => [f, 1]),
-            ...[...new Set(dirs)].map(f => [f, 2]),
-        ];
     }
-    async readFile(fileName) {
-        if (!await this.valid(fileName)) {
-            return;
+    function readDirectory(uri) {
+        if (uri.startsWith(exports.jsDelivrUriBase + '/')) {
+            const path = uri.substring(exports.jsDelivrUriBase.length);
+            const pkgName = getPackageName(path);
+            if (!pkgName || !isValidPackageNameSync(pkgName)) {
+                return [];
+            }
+            return (async () => {
+                if (!await isValidPackageNameAsync(pkgName)) {
+                    return [];
+                }
+                if (!flatResults.has(pkgName)) {
+                    flatResults.set(pkgName, flat(pkgName));
+                }
+                const flatResult = await flatResults.get(pkgName);
+                const dirPath = path.slice(`/${pkgName}`.length);
+                const files = flatResult
+                    .filter(f => f.name.substring(0, f.name.lastIndexOf('/')) === dirPath)
+                    .map(f => f.name.slice(dirPath.length + 1));
+                const dirs = flatResult
+                    .filter(f => f.name.startsWith(dirPath + '/') && f.name.substring(dirPath.length + 1).split('/').length >= 2)
+                    .map(f => f.name.slice(dirPath.length + 1).split('/')[0]);
+                return [
+                    ...files.map(f => [f, 1]),
+                    ...[...new Set(dirs)].map(f => [f, 2]),
+                ];
+            })();
         }
-        if (!this.fetchResults.has(fileName)) {
-            this.fetchResults.set(fileName, this.fetchFile(fileName));
+        return [];
+    }
+    function readFile(uri) {
+        if (uri.startsWith(exports.jsDelivrUriBase + '/')) {
+            const path = uri.substring(exports.jsDelivrUriBase.length);
+            const pkgName = getPackageName(path);
+            if (!pkgName || !isValidPackageNameSync(pkgName)) {
+                return;
+            }
+            return (async () => {
+                if (!await isValidPackageNameAsync(pkgName)) {
+                    return;
+                }
+                if (!fetchResults.has(path)) {
+                    fetchResults.set(path, (async () => {
+                        if ((await stat(uri))?.type !== 1) {
+                            return;
+                        }
+                        return await fetchText(uri);
+                    })());
+                }
+                return await fetchResults.get(path);
+            })();
         }
-        return await this.fetchResults.get(fileName);
     }
-    async fetchFile(fileName) {
-        const pkgName = getPackageNameOfDtsPath(fileName);
-        if (!pkgName) {
-            return undefined;
+    async function flat(pkgNameWithVersion) {
+        let pkgName = pkgNameWithVersion;
+        let version = 'latest';
+        if (pkgNameWithVersion.substring(1).includes('@')) {
+            pkgName = pkgNameWithVersion.substring(0, pkgNameWithVersion.lastIndexOf('@'));
+            version = pkgNameWithVersion.substring(pkgNameWithVersion.lastIndexOf('@') + 1);
         }
-        if ((await this.stat(fileName))?.type !== 1) {
-            return undefined;
+        // resolve tag version
+        if (version === 'latest') {
+            const data = await fetchJson(`https://data.jsdelivr.com/v1/package/resolve/npm/${pkgName}@latest`);
+            if (!data?.version) {
+                return [];
+            }
+            version = data.version;
+        }
+        const flat = await fetchJson(`https://data.jsdelivr.com/v1/package/npm/${pkgName}@${version}/flat`);
+        if (!flat) {
+            return [];
         }
-        return await this.fetchText(fileName);
+        return flat.files;
     }
-    async valid(fileName) {
-        const pkgName = getPackageNameOfDtsPath(fileName);
-        if (!pkgName) {
-            return false;
+    function isValidPackageNameSync(pkgName) {
+        if (pkgName.substring(1).includes('@')) {
+            pkgName = pkgName.substring(0, pkgName.lastIndexOf('@'));
         }
         if (pkgName.indexOf('.') >= 0 || pkgName.endsWith('/node_modules')) {
             return false;
@@ -130,19 +206,25 @@ class DtsHost {
         if (pkgName.startsWith('@typescript/') || pkgName.startsWith('@types/typescript__')) {
             return false;
         }
+        return true;
+    }
+    async function isValidPackageNameAsync(pkgName) {
+        if (pkgName.substring(1).includes('@')) {
+            pkgName = pkgName.substring(0, pkgName.lastIndexOf('@'));
+        }
         // don't check @types if original package already having types
         if (pkgName.startsWith('@types/')) {
             let originalPkgName = pkgName.slice('@types/'.length);
             if (originalPkgName.indexOf('__') >= 0) {
                 originalPkgName = '@' + originalPkgName.replace('__', '/');
             }
-            const packageJson = await this.readFile(`/node_modules/${originalPkgName}/package.json`);
+            const packageJson = await readFile(`${exports.jsDelivrUriBase}/${originalPkgName}/package.json`);
             if (packageJson) {
                 const packageJsonObj = JSON.parse(packageJson);
                 if (packageJsonObj.types || packageJsonObj.typings) {
                     return false;
                 }
-                const indexDts = await this.stat(`/node_modules/${originalPkgName}/index.d.ts`);
+                const indexDts = await stat(`${exports.jsDelivrUriBase}/${originalPkgName}/index.d.ts`);
                 if (indexDts?.type === 1) {
                     return false;
                 }
@@ -151,6 +233,7 @@ class DtsHost {
         return true;
     }
 }
+exports.createJsDelivrFs = createJsDelivrFs;
 async function fetchText(url) {
     try {
         const res = await fetch(url);
@@ -173,18 +256,21 @@ async function fetchJson(url) {
         // ignore
     }
 }
-function getPackageNameOfDtsPath(path) {
-    if (!path.startsWith('/node_modules/')) {
-        return undefined;
-    }
-    let pkgName = path.split('/')[2];
+/**
+ * @example
+ * "/a/b/c" -> "a"
+ * "/@a/b/c" -> "@a/b"
+ * "/@a/b@1.2.3/c" -> "@a/b@1.2.3"
+ */
+function getPackageName(path) {
+    const parts = path.split('/');
+    let pkgName = parts[1];
     if (pkgName.startsWith('@')) {
-        if (path.split('/').length < 4) {
+        if (parts.length < 3 || !parts[2]) {
             return undefined;
         }
-        pkgName += '/' + path.split('/')[3];
+        pkgName += '/' + parts[2];
     }
     return pkgName;
 }
-exports.getPackageNameOfDtsPath = getPackageNameOfDtsPath;
 //# sourceMappingURL=dtsHost.js.map

package/out/index.d.ts

@@ -1,5 +1,4 @@
 export * from './documentRegistry';
-export * from './dtsHost';
 export * from './languageService';
 export * from './languageServiceHost';
 export * from './sys';

package/out/index.js

@@ -15,7 +15,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./documentRegistry"), exports);
-__exportStar(require("./dtsHost"), exports);
 __exportStar(require("./languageService"), exports);
 __exportStar(require("./languageServiceHost"), exports);
 __exportStar(require("./sys"), exports);

package/out/languageServiceHost.d.ts

@@ -1,4 +1,4 @@
-import type { LanguageContext } from '@volar/language-service';
+import type { LanguageContext } from '@volar/language-core';
 import type * as ts from 'typescript/lib/tsserverlibrary';
 export declare function createLanguageServiceHost(ctx: LanguageContext, ts: typeof import('typescript/lib/tsserverlibrary'), sys: ts.System & {
     version?: number;

package/out/sys.d.ts

@@ -1,7 +1,6 @@
 import type { ServiceEnvironment, Disposable } from '@volar/language-service';
 import type * as ts from 'typescript/lib/tsserverlibrary';
-import { IDtsHost } from './dtsHost';
-export declare function createSys(ts: typeof import('typescript/lib/tsserverlibrary'), env: ServiceEnvironment, dtsHost?: IDtsHost): ts.System & {
+export declare function createSys(ts: typeof import('typescript/lib/tsserverlibrary'), env: ServiceEnvironment): ts.System & {
     version: number;
     sync(): Promise<number>;
 } & Disposable;

package/out/sys.js

@@ -3,9 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createSys = void 0;
 const path_1 = require("path");
 const utilities_1 = require("./typescript/utilities");
-const dtsHost_1 = require("./dtsHost");
 let currentCwd = '';
-function createSys(ts, env, dtsHost) {
+function createSys(ts, env) {
     let version = 0;
     const rootPath = env.uriToFileName(env.rootUri.toString());
     const sys = ts.sys;
@@ -105,17 +104,9 @@ function createSys(ts, env, dtsHost) {
     function directoryExists(dirName) {
         dirName = resolvePath(dirName);
         const dir = getDir(dirName);
-        if (dirName === '/node_modules' && dtsHost) {
-            dir.exists = true;
-        }
-        else if (dirName.startsWith('/node_modules/') && dtsHost && !(0, dtsHost_1.getPackageNameOfDtsPath)(dirName)) {
-            dir.exists = true;
-        }
-        else if (dir.exists === undefined) {
+        if (dir.exists === undefined) {
             dir.exists = false;
-            const result = dirName.startsWith('/node_modules/') && dtsHost
-                ? dtsHost.stat(dirName)
-                : env.fs?.stat(env.fileNameToUri(dirName));
+            const result = env.fs?.stat(env.fileNameToUri(dirName));
             if (typeof result === 'object' && 'then' in result) {
                 const promise = result;
                 promises.add(promise);
@@ -141,9 +132,7 @@ function createSys(ts, env, dtsHost) {
         const file = dir.files[baseName] ??= {};
         if (file.exists === undefined) {
             file.exists = false;
-            const result = fileName.startsWith('/node_modules/') && dtsHost
-                ? dtsHost.stat(fileName)
-                : env.fs?.stat(env.fileNameToUri(fileName));
+            const result = env.fs?.stat(env.fileNameToUri(fileName));
             if (typeof result === 'object' && 'then' in result) {
                 const promise = result;
                 promises.add(promise);
@@ -192,9 +181,7 @@ function createSys(ts, env, dtsHost) {
         }
         file.requested = true;
         const uri = env.fileNameToUri(fileName);
-        const result = fileName.startsWith('/node_modules/') && dtsHost
-            ? dtsHost.readFile(fileName)
-            : env.fs?.readFile(uri, encoding);
+        const result = env.fs?.readFile(uri, encoding);
         if (typeof result === 'object' && 'then' in result) {
             const promise = result;
             promises.add(promise);
@@ -228,9 +215,7 @@ function createSys(ts, env, dtsHost) {
             return;
         }
         dir.requested = true;
-        const result = dirName.startsWith('/node_modules/') && dtsHost
-            ? dtsHost.readDirectory(dirName)
-            : env.fs?.readDirectory(env.fileNameToUri(dirName || '.'));
+        const result = env.fs?.readDirectory(env.fileNameToUri(dirName || '.'));
         if (typeof result === 'object' && 'then' in result) {
             const promise = result;
             promises.add(promise);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@volar/typescript",
-	"version": "1.7.10",
+	"version": "1.8.1",
 	"main": "out/index.js",
 	"license": "MIT",
 	"files": [
@@ -13,10 +13,10 @@
 		"directory": "packages/typescript"
 	},
 	"dependencies": {
-		"@volar/language-core": "1.7.10"
+		"@volar/language-core": "1.8.1"
 	},
 	"devDependencies": {
-		"@volar/language-service": "1.7.10"
+		"@volar/language-service": "1.8.1"
 	},
-	"gitHead": "53c67c3fd1d11be3dba0ef199c282e605c980638"
+	"gitHead": "1fec004d7e3c5a28c0ad1d6a1d7a41ab98381abd"
 }