vue-tsc 0.33.3 → 0.33.6

package/out/apis.d.ts

@@ -0,0 +1,10 @@
+import type * as ts from 'typescript/lib/tsserverlibrary';
+import type { TypeScriptRuntime } from '@volar/vue-typescript';
+export declare function register(ts: typeof import('typescript/lib/tsserverlibrary'), context: TypeScriptRuntime): {
+    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,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = void 0;
+const lsTypes = ['script', 'template'];
+function register(ts, context) {
+    return {
+        getRootFileNames,
+        emit,
+        getSyntacticDiagnostics,
+        getSemanticDiagnostics,
+        getGlobalDiagnostics,
+        getBindAndCheckDiagnostics,
+    };
+    function getRootFileNames() {
+        const set = new Set([
+            ...getProgram('script')?.getRootFileNames().filter(fileName => context.getTsLsHost('script').fileExists?.(fileName)) ?? [],
+            ...getProgram('template')?.getRootFileNames().filter(fileName => context.getTsLsHost('template')?.fileExists?.(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 maped = context.vueFiles.fromEmbeddedFileName('script', sourceFile.fileName);
+            if (maped) {
+                let results = [];
+                const embeddeds = maped.vueFile.getAllEmbeddeds();
+                for (const embedded of embeddeds) {
+                    if (embedded.file.lsType === 'nonTs' || !embedded.file.capabilities.diagnostics)
+                        continue;
+                    const program = getProgram(embedded.file.lsType);
+                    const embeddedSourceFile = program?.getSourceFile(embedded.file.fileName);
+                    if (embeddedSourceFile) {
+                        const errors = transformDiagnostics(embedded.file.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) {
+        const scriptResult = getProgram('script').emit(targetSourceFile, (context.vueLsHost.writeFile ?? 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) {
+        return context.getTsLs(lsType)?.getProgram();
+    }
+    // transform
+    function transformDiagnostics(lsType, diagnostics) {
+        const result = [];
+        for (const diagnostic of diagnostics) {
+            if (diagnostic.file !== undefined
+                && diagnostic.start !== undefined
+                && diagnostic.length !== undefined) {
+                for (const tsOrVueLoc of context.vueFiles.fromEmbeddedLocation(lsType, diagnostic.file.fileName, diagnostic.start, diagnostic.start + diagnostic.length, data => !!data.capabilities.diagnostic)) {
+                    if (!context.vueLsHost.fileExists?.(tsOrVueLoc.fileName))
+                        continue;
+                    if (!tsOrVueLoc.maped && lsType !== 'script')
+                        continue;
+                    let file = tsOrVueLoc.fileName === diagnostic.file.fileName
+                        ? diagnostic.file
+                        : undefined;
+                    if (!file) {
+                        let docText = tsOrVueLoc.maped?.vueFile.getContent();
+                        if (docText === undefined) {
+                            const snapshot = context.vueLsHost.getScriptSnapshot(tsOrVueLoc.fileName);
+                            if (snapshot) {
+                                docText = snapshot.getText(0, snapshot.getLength());
+                            }
+                        }
+                        else {
+                            file = ts.createSourceFile(tsOrVueLoc.fileName, docText, tsOrVueLoc.fileName.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

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProgramProxy = void 0;
+const ts = require("typescript/lib/tsserverlibrary");
+const apis = require("./apis");
+const vue_typescript_1 = require("@volar/vue-typescript");
+const vue_typescript_2 = 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');
+    const host = options.host;
+    const vueCompilerOptions = getVueCompilerOptions();
+    const scripts = new Map();
+    const vueLsHost = {
+        ...host,
+        resolveModuleNames: undefined,
+        writeFile: undefined,
+        getCompilationSettings: () => options.options,
+        getVueCompilationSettings: () => vueCompilerOptions,
+        getScriptFileNames: () => options.rootNames,
+        getScriptVersion: (fileName) => scripts.get(fileName)?.version ?? '',
+        getScriptSnapshot,
+        getProjectVersion: () => '',
+        getVueProjectVersion: () => '',
+        getProjectReferences: () => options.projectReferences,
+    };
+    const tsRuntime = (0, vue_typescript_1.createTypeScriptRuntime)({
+        typescript: ts,
+        baseCssModuleType: 'any',
+        getCssClasses: () => ({}),
+        vueCompilerOptions,
+        vueLsHost: vueLsHost,
+        isVueTsc: true,
+    });
+    const tsProgram = tsRuntime.getTsLs('script').getProgram();
+    if (!tsProgram)
+        throw '!tsProgram';
+    const tsProgramApis_2 = apis.register(ts, tsRuntime);
+    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') {
+            return vue_typescript_2.tsShared.createParsedCommandLine(ts, ts.sys, tsConfig).vueOptions;
+        }
+        return {};
+    }
+    function getScriptSnapshot(fileName) {
+        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);
+                scripts.set(fileName, {
+                    scriptSnapshot: scriptSnapshot,
+                    version: ts.sys.createHash?.(fileContent) ?? fileContent,
+                });
+                return scriptSnapshot;
+            }
+        }
+    }
+}
+exports.createProgramProxy = createProgramProxy;
+function doThrow(msg) {
+    console.error(msg);
+    throw msg;
+}
+//# sourceMappingURL=proxy.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vue-tsc",
-  "version": "0.33.3",
+  "version": "0.33.6",
   "license": "MIT",
   "files": [
     "bin",
@@ -16,10 +16,10 @@
     "vue-tsc": "./bin/vue-tsc.js"
   },
   "dependencies": {
-    "@volar/vue-typescript": "0.33.3"
+    "@volar/vue-typescript": "0.33.6"
   },
   "peerDependencies": {
     "typescript": "*"
   },
-  "gitHead": "bfc0d807da4448e1628048728950cdcf27582ae3"
+  "gitHead": "833757bb59d53202e844243a5d1bdd2bf5856c75"
 }