vue-tsc 0.32.1 → 0.33.1

package/README.md

@@ -13,7 +13,7 @@ Roadmap:
 - [x] Make `typescript` as peerDependencies
 - [x] Cleaner dependencies (remove `prettyhtml`, `prettier` etc.) (with `vscode-vue-languageservice` version >= 0.26.4)
 - [x] dts emit support
-- [ ] Watch mode support
+- [x] Watch mode support
 
 ## Using
 
@@ -29,8 +29,8 @@ Check out https://github.com/johnsoncodehk/volar/discussions/640#discussioncomme
 
 ## Sponsors
 
-This company is [sponsoring this project](https://github.com/sponsors/johnsoncodehk) to improve your DX. 💪
-
-<a href="https://github.com/Leniolabs">
-  <img itemprop="image" src="https://github.com/Leniolabs.png" width="100" height="100">
-</a>
+<p align="center">
+  <a href="https://cdn.jsdelivr.net/gh/johnsoncodehk/sponsors/sponsors.svg">
+    <img src='https://cdn.jsdelivr.net/gh/johnsoncodehk/sponsors/sponsors.svg'/>
+  </a>
+</p>

package/bin/vue-tsc.js

@@ -8,13 +8,25 @@ const proxyPath = require.resolve('../out/proxy');
 fs.readFileSync = (...args) => {
     if (args[0] === tscPath) {
         let tsc = readFileSync(...args);
+
+        // add *.vue files to allow extensions
         tsc = tsc.replace(
-            `function createIncrementalProgram(_a) {`,
-            `function createIncrementalProgram(_a) { console.error('incremental mode is not yet supported'); throw 'incremental mode is not yet supported';`,
+            `ts.supportedTSExtensions = [[".ts", ".tsx", ".d.ts"], [".cts", ".d.cts"], [".mts", ".d.mts"]];`,
+            `ts.supportedTSExtensions = [[".ts", ".tsx", ".d.ts"], [".cts", ".d.cts"], [".mts", ".d.mts"], [".vue"]];`,
+        );
+        tsc = tsc.replace(
+            `ts.supportedJSExtensions = [[".js", ".jsx"], [".mjs"], [".cjs"]];`,
+            `ts.supportedJSExtensions = [[".js", ".jsx"], [".mjs"], [".cjs"], [".vue"]];`,
         );
         tsc = tsc.replace(
-            `function createWatchProgram(host) {`,
-            `function createWatchProgram(host) { console.error('watch mode is not yet supported'); throw 'watch mode is not yet supported';`,
+            `var allSupportedExtensions = [[".ts", ".tsx", ".d.ts", ".js", ".jsx"], [".cts", ".d.cts", ".cjs"], [".mts", ".d.mts", ".mjs"]];`,
+            `var allSupportedExtensions = [[".ts", ".tsx", ".d.ts", ".js", ".jsx"], [".cts", ".d.cts", ".cjs"], [".mts", ".d.mts", ".mjs"], [".vue"]];`,
+        );
+
+        // proxy createProgram apis
+        tsc = tsc.replace(
+            `function createIncrementalProgram(_a) {`,
+            `function createIncrementalProgram(_a) { console.error('incremental mode is not yet supported'); throw 'incremental mode is not yet supported';`,
         );
         tsc = tsc.replace(
             `function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _configFileParsingDiagnostics) {`,

package/out/apis.d.ts

@@ -0,0 +1,10 @@
+import type * as ts from 'typescript/lib/tsserverlibrary';
+import type { TypeScriptFeaturesRuntimeContext } from '@volar/vue-typescript';
+export declare function register(ts: typeof import('typescript/lib/tsserverlibrary'), { vueDocuments, templateTsLsRaw, scriptTsLsRaw, templateTsHost, scriptTsHost, vueHost }: TypeScriptFeaturesRuntimeContext): {
+    getRootFileNames: () => string[];
+    emit: (targetSourceFile?: ts.SourceFile | undefined, _writeFile?: ts.WriteFileCallback | undefined, cancellationToken?: ts.CancellationToken | undefined, emitOnlyDtsFiles?: boolean | undefined, customTransformers?: ts.CustomTransformers | undefined) => ts.EmitResult;
+    getSyntacticDiagnostics: (sourceFile?: ts.SourceFile | undefined, cancellationToken?: ts.CancellationToken | undefined) => readonly ts.DiagnosticWithLocation[] | readonly ts.Diagnostic[];
+    getSemanticDiagnostics: (sourceFile?: ts.SourceFile | undefined, cancellationToken?: ts.CancellationToken | undefined) => readonly ts.DiagnosticWithLocation[] | readonly ts.Diagnostic[];
+    getGlobalDiagnostics: (cancellationToken?: ts.CancellationToken | undefined) => readonly ts.Diagnostic[];
+    getBindAndCheckDiagnostics: (sourceFile?: ts.SourceFile | undefined, cancellationToken?: ts.CancellationToken | undefined) => readonly ts.DiagnosticWithLocation[] | readonly ts.Diagnostic[];
+};

package/out/apis.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = void 0;
+const shared = require("@volar/shared");
+const lsTypes = ['script', 'template'];
+function register(ts, { vueDocuments, templateTsLsRaw, scriptTsLsRaw, templateTsHost, scriptTsHost, vueHost }) {
+    return {
+        getRootFileNames,
+        emit,
+        getSyntacticDiagnostics,
+        getSemanticDiagnostics,
+        getGlobalDiagnostics,
+        getBindAndCheckDiagnostics,
+    };
+    function getRootFileNames() {
+        const set = new Set([
+            ...getProgram('script').getRootFileNames().filter(fileName => { var _a; return (_a = scriptTsHost.fileExists) === null || _a === void 0 ? void 0 : _a.call(scriptTsHost, fileName); }),
+            ...getProgram('template').getRootFileNames().filter(fileName => { var _a; return (_a = templateTsHost.fileExists) === null || _a === void 0 ? void 0 : _a.call(templateTsHost, fileName); }),
+        ]);
+        return [...set.values()];
+    }
+    // for vue-tsc --noEmit --watch
+    function getBindAndCheckDiagnostics(sourceFile, cancellationToken) {
+        return getSourceFileDiagnosticsWorker(sourceFile, cancellationToken, 'getBindAndCheckDiagnostics');
+    }
+    // for vue-tsc --noEmit
+    function getSyntacticDiagnostics(sourceFile, cancellationToken) {
+        return getSourceFileDiagnosticsWorker(sourceFile, cancellationToken, 'getSyntacticDiagnostics');
+    }
+    function getSemanticDiagnostics(sourceFile, cancellationToken) {
+        return getSourceFileDiagnosticsWorker(sourceFile, cancellationToken, 'getSemanticDiagnostics');
+    }
+    function getSourceFileDiagnosticsWorker(sourceFile, cancellationToken, api) {
+        if (sourceFile) {
+            const sourceMap = vueDocuments.fromEmbeddedDocumentUri('script', shared.fsPathToUri(sourceFile.fileName));
+            const vueDocument = sourceMap ? vueDocuments.get(sourceMap.sourceDocument.uri) : undefined;
+            if (vueDocument) {
+                let results = [];
+                const sourceMaps = vueDocument.getSourceMaps();
+                for (const sourceMap of sourceMaps) {
+                    if (sourceMap.lsType === 'nonTs' || !sourceMap.capabilities.diagnostics)
+                        continue;
+                    const program = getProgram(sourceMap.lsType);
+                    const embeddedSourceFile = program.getSourceFile(shared.uriToFsPath(sourceMap.mappedDocument.uri));
+                    if (embeddedSourceFile) {
+                        const errors = transformDiagnostics(sourceMap.lsType, program[api](embeddedSourceFile, cancellationToken));
+                        results = results.concat(errors);
+                    }
+                }
+                return results;
+            }
+            else {
+                return getProgram('script')[api](sourceFile, cancellationToken);
+            }
+        }
+        return lsTypes.map(lsType => transformDiagnostics(lsType, getProgram(lsType)[api](sourceFile, cancellationToken))).flat();
+    }
+    function getGlobalDiagnostics(cancellationToken) {
+        return lsTypes.map(lsType => transformDiagnostics(lsType, getProgram(lsType).getGlobalDiagnostics(cancellationToken))).flat();
+    }
+    function emit(targetSourceFile, _writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers) {
+        var _a;
+        const scriptResult = getProgram('script').emit(targetSourceFile, ((_a = vueHost.writeFile) !== null && _a !== void 0 ? _a : ts.sys.writeFile), cancellationToken, emitOnlyDtsFiles, customTransformers);
+        const templateResult = getProgram('template').emit(targetSourceFile, undefined, cancellationToken, emitOnlyDtsFiles, customTransformers);
+        return {
+            emitSkipped: scriptResult.emitSkipped,
+            emittedFiles: scriptResult.emittedFiles,
+            diagnostics: [
+                ...transformDiagnostics('script', scriptResult.diagnostics),
+                ...transformDiagnostics('template', templateResult.diagnostics),
+            ],
+        };
+    }
+    function getProgram(lsType) {
+        const program = (lsType === 'script' ? scriptTsLsRaw : templateTsLsRaw).getProgram();
+        if (!program)
+            throw '!program';
+        return program;
+    }
+    // transform
+    function transformDiagnostics(lsType, diagnostics) {
+        var _a, _b;
+        const result = [];
+        for (const diagnostic of diagnostics) {
+            if (diagnostic.file !== undefined
+                && diagnostic.start !== undefined
+                && diagnostic.length !== undefined) {
+                const fileName = shared.normalizeFileName(diagnostic.file.fileName);
+                for (const tsOrVueLoc of vueDocuments.fromEmbeddedLocation(lsType, shared.fsPathToUri(fileName), diagnostic.start, diagnostic.start + diagnostic.length, data => !!data.capabilities.diagnostic)) {
+                    if (!((_a = vueHost.fileExists) === null || _a === void 0 ? void 0 : _a.call(vueHost, shared.uriToFsPath(tsOrVueLoc.uri))))
+                        continue;
+                    if (tsOrVueLoc.type === 'source-ts' && lsType !== 'script')
+                        continue;
+                    let file = shared.uriToFsPath(tsOrVueLoc.uri) === fileName
+                        ? diagnostic.file
+                        : undefined;
+                    if (!file) {
+                        let docText = (_b = tsOrVueLoc.sourceMap) === null || _b === void 0 ? void 0 : _b.sourceDocument.getText();
+                        if (docText === undefined) {
+                            const snapshot = vueHost.getScriptSnapshot(shared.uriToFsPath(tsOrVueLoc.uri));
+                            if (snapshot) {
+                                docText = snapshot.getText(0, snapshot.getLength());
+                            }
+                        }
+                        if (docText !== undefined) {
+                            file = ts.createSourceFile(shared.uriToFsPath(tsOrVueLoc.uri), docText, tsOrVueLoc.uri.endsWith('.vue') ? ts.ScriptTarget.JSON : ts.ScriptTarget.Latest);
+                        }
+                    }
+                    const newDiagnostic = {
+                        ...diagnostic,
+                        file,
+                        start: tsOrVueLoc.range.start,
+                        length: tsOrVueLoc.range.end - tsOrVueLoc.range.start,
+                    };
+                    const relatedInformation = diagnostic.relatedInformation;
+                    if (relatedInformation) {
+                        newDiagnostic.relatedInformation = transformDiagnostics(lsType, relatedInformation);
+                    }
+                    result.push(newDiagnostic);
+                }
+            }
+            else if (diagnostic.file === undefined) {
+                result.push(diagnostic);
+            }
+        }
+        return result;
+    }
+}
+exports.register = register;
+//# sourceMappingURL=apis.js.map

package/out/proxy.d.ts

@@ -0,0 +1,3 @@
+import * as ts from 'typescript/lib/tsserverlibrary';
+export declare function createProgramProxy(options: ts.CreateProgramOptions, // rootNamesOrOptions: readonly string[] | CreateProgramOptions,
+_options?: ts.CompilerOptions, _host?: ts.CompilerHost, _oldProgram?: ts.Program, _configFileParsingDiagnostics?: readonly ts.Diagnostic[]): void | ts.Program;

package/out/proxy.js

@@ -2,56 +2,48 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createProgramProxy = void 0;
 const ts = require("typescript/lib/tsserverlibrary");
-const vue = require("vscode-vue-languageservice");
-const path = require("path");
 const shared = require("@volar/shared");
-function createProgramProxy(options) {
+const apis = require("./apis");
+const vue_typescript_1 = require("@volar/vue-typescript");
+function createProgramProxy(options, // rootNamesOrOptions: readonly string[] | CreateProgramOptions,
+_options, _host, _oldProgram, _configFileParsingDiagnostics) {
     if (!options.options.noEmit && !options.options.emitDeclarationOnly)
         return doThrow('js emit is not support');
     if (!options.host)
         return doThrow('!options.host');
-    if (!options.host.readDirectory)
-        return doThrow('!options.host.readDirectory');
     const host = options.host;
-    const readDirectory = options.host.readDirectory;
-    const parseConfigHost = {
-        useCaseSensitiveFileNames: host.useCaseSensitiveFileNames(),
-        readDirectory: (path, extensions, exclude, include, depth) => {
-            return readDirectory(path, ['.vue'], exclude, include, depth);
-        },
-        fileExists: fileName => host.fileExists(fileName),
-        readFile: fileName => host.readFile(fileName),
-    };
-    const fileNames = [
-        ...options.rootNames,
-        ...getVueFileNames(),
-    ];
     const vueCompilerOptions = getVueCompilerOptions();
-    const scriptSnapshots = new Map();
+    const scripts = new Map();
     const vueLsHost = {
         ...host,
+        resolveModuleNames: undefined,
         writeFile: undefined,
         getCompilationSettings: () => options.options,
         getVueCompilationSettings: () => vueCompilerOptions,
-        getScriptFileNames: () => fileNames,
-        getScriptVersion: () => '',
+        getScriptFileNames: () => options.rootNames,
+        getScriptVersion: (fileName) => { var _a, _b; return (_b = (_a = scripts.get(fileName)) === null || _a === void 0 ? void 0 : _a.version) !== null && _b !== void 0 ? _b : ''; },
         getScriptSnapshot,
         getProjectVersion: () => '',
         getVueProjectVersion: () => '',
         getProjectReferences: () => options.projectReferences,
     };
-    const vueLs = vue.createLanguageService({ typescript: ts }, vueLsHost);
-    const program = vueLs.__internal__.tsProgramProxy;
-    return program;
-    function getVueFileNames() {
-        const tsConfig = options.options.configFilePath;
-        if (typeof tsConfig === 'string') {
-            const tsConfigFile = ts.readJsonConfigFile(tsConfig, host.readFile);
-            const { fileNames } = ts.parseJsonSourceFileConfigFileContent(tsConfigFile, parseConfigHost, path.dirname(tsConfig), options.options, path.basename(tsConfig));
-            return fileNames;
-        }
-        return [];
+    const services = (0, vue_typescript_1.createBasicRuntime)();
+    const tsRuntime = (0, vue_typescript_1.createTypeScriptRuntime)({ typescript: ts, ...services, compilerOptions: vueCompilerOptions }, vueLsHost, false);
+    const tsProgram = tsRuntime.context.scriptTsLsRaw.getProgram(); // TODO: handle template ls?
+    if (!tsProgram)
+        throw '!tsProgram';
+    const tsProgramApis_2 = apis.register(ts, tsRuntime.context);
+    const tsProgramProxy = new Proxy(tsProgram, {
+        get: (target, property) => {
+            tsRuntime.update(true);
+            return tsProgramApis_2[property] || target[property];
+        },
+    });
+    for (const rootName of options.rootNames) {
+        // register file watchers
+        host.getSourceFile(rootName, ts.ScriptTarget.ESNext);
     }
+    return tsProgramProxy;
     function getVueCompilerOptions() {
         const tsConfig = options.options.configFilePath;
         if (typeof tsConfig === 'string') {
@@ -60,15 +52,19 @@ function createProgramProxy(options) {
         return {};
     }
     function getScriptSnapshot(fileName) {
-        const scriptSnapshot = scriptSnapshots.get(fileName);
-        if (scriptSnapshot) {
-            return scriptSnapshot;
+        var _a, _b, _c;
+        const script = scripts.get(fileName);
+        if (script) {
+            return script.scriptSnapshot;
         }
         if (host.fileExists(fileName)) {
             const fileContent = host.readFile(fileName);
             if (fileContent !== undefined) {
                 const scriptSnapshot = ts.ScriptSnapshot.fromString(fileContent);
-                scriptSnapshots.set(fileName, scriptSnapshot);
+                scripts.set(fileName, {
+                    scriptSnapshot: scriptSnapshot,
+                    version: (_c = (_b = (_a = ts.sys).createHash) === null || _b === void 0 ? void 0 : _b.call(_a, fileContent)) !== null && _c !== void 0 ? _c : fileContent,
+                });
                 return scriptSnapshot;
             }
         }

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "vue-tsc",
-  "version": "0.32.1",
+  "version": "0.33.1",
   "license": "MIT",
   "files": [
     "bin",
-    "out/proxy.js"
+    "out/**/*.js",
+    "out/**/*.d.ts"
   ],
   "repository": {
     "type": "git",
@@ -15,11 +16,11 @@
     "vue-tsc": "./bin/vue-tsc.js"
   },
   "dependencies": {
-    "@volar/shared": "0.32.1",
-    "vscode-vue-languageservice": "0.32.1"
+    "@volar/shared": "0.33.1",
+    "@volar/vue-typescript": "0.33.1"
   },
   "peerDependencies": {
     "typescript": "*"
   },
-  "gitHead": "fb6912ca300ae0a0f4ca0d0aa4c17f691dd930ef"
+  "gitHead": "03eaf26e0b1259ffa2b5690168a2d6a8baa81cbc"
 }