@volar/monaco 1.3.0-alpha.0

package/out/utils/provider.js

@@ -0,0 +1,341 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLanguageFeaturesProvider = void 0;
+const markers_1 = require("./markers");
+const monaco2protocol = require("./monaco2protocol");
+const protocol2monaco = require("./protocol2monaco");
+function createLanguageFeaturesProvider(worker) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const completionItems = new WeakMap();
+        const codeLens = new WeakMap();
+        const codeActions = new WeakMap();
+        const colorInfos = new WeakMap();
+        const languageService = yield worker.getProxy();
+        return {
+            triggerCharacters: yield languageService.triggerCharacters(),
+            // TODO
+            autoFormatTriggerCharacters: ['}', ';', '\n'],
+            signatureHelpTriggerCharacters: ['(', ','],
+            provideDocumentSymbols(model, _token) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const worker = yield getLanguageService(model.uri);
+                    const codeResult = yield worker.findDocumentSymbols(model.uri.toString());
+                    if (codeResult) {
+                        return codeResult.map(protocol2monaco.asDocumentSymbol);
+                    }
+                });
+            },
+            provideDocumentHighlights(model, position, _token) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const worker = yield getLanguageService(model.uri);
+                    const codeResult = yield worker.findDocumentHighlights(model.uri.toString(), monaco2protocol.asPosition(position));
+                    if (codeResult) {
+                        return codeResult.map(protocol2monaco.asDocumentHighlight);
+                    }
+                });
+            },
+            provideLinkedEditingRanges(model, position, _token) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const worker = yield getLanguageService(model.uri);
+                    const codeResult = yield worker.findLinkedEditingRanges(model.uri.toString(), monaco2protocol.asPosition(position));
+                    if (codeResult) {
+                        return {
+                            ranges: codeResult.ranges.map(protocol2monaco.asRange),
+                            wordPattern: codeResult.wordPattern
+                                ? new RegExp(codeResult.wordPattern)
+                                : undefined,
+                        };
+                    }
+                });
+            },
+            provideDefinition(model, position, _token) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const worker = yield getLanguageService(model.uri);
+                    const codeResult = yield worker.findDefinition(model.uri.toString(), monaco2protocol.asPosition(position));
+                    // TODO: can't show if only one result from libs
+                    if (codeResult) {
+                        return codeResult.map(protocol2monaco.asLocation);
+                    }
+                });
+            },
+            provideImplementation(model, position, _token) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const worker = yield getLanguageService(model.uri);
+                    const codeResult = yield worker.findImplementations(model.uri.toString(), monaco2protocol.asPosition(position));
+                    if (codeResult) {
+                        return codeResult.map(protocol2monaco.asLocation);
+                    }
+                });
+            },
+            provideTypeDefinition(model, position, _token) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const worker = yield getLanguageService(model.uri);
+                    const codeResult = yield worker.findTypeDefinition(model.uri.toString(), monaco2protocol.asPosition(position));
+                    if (codeResult) {
+                        return codeResult.map(protocol2monaco.asLocation);
+                    }
+                });
+            },
+            provideCodeLenses(model, _token) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const worker = yield getLanguageService(model.uri);
+                    const codeResult = yield worker.doCodeLens(model.uri.toString());
+                    if (codeResult) {
+                        const monacoResult = codeResult.map(protocol2monaco.asCodeLens);
+                        for (let i = 0; i < monacoResult.length; i++) {
+                            codeLens.set(monacoResult[i], codeResult[i]);
+                        }
+                        return {
+                            lenses: monacoResult,
+                            dispose: () => { },
+                        };
+                    }
+                });
+            },
+            resolveCodeLens(model, monacoResult) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    let codeResult = codeLens.get(monacoResult);
+                    if (codeResult) {
+                        const worker = yield getLanguageService(model.uri);
+                        codeResult = yield worker.doCodeLensResolve(codeResult);
+                        if (codeResult) {
+                            monacoResult = protocol2monaco.asCodeLens(codeResult);
+                            codeLens.set(monacoResult, codeResult);
+                        }
+                    }
+                    return monacoResult;
+                });
+            },
+            provideCodeActions(model, range, context, _token) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const diagnostics = [];
+                    for (const marker of context.markers) {
+                        const diagnostic = markers_1.markers.get(marker);
+                        if (diagnostic) {
+                            diagnostics.push(diagnostic);
+                        }
+                    }
+                    const worker = yield getLanguageService(model.uri);
+                    const codeResult = yield worker.doCodeActions(model.uri.toString(), monaco2protocol.asRange(range), {
+                        diagnostics: diagnostics,
+                        only: context.only ? [context.only] : undefined,
+                    });
+                    if (codeResult) {
+                        const monacoResult = codeResult.map(protocol2monaco.asCodeAction);
+                        for (let i = 0; i < monacoResult.length; i++) {
+                            codeActions.set(monacoResult[i], codeResult[i]);
+                        }
+                        return {
+                            actions: monacoResult,
+                            dispose: () => { },
+                        };
+                    }
+                });
+            },
+            resolveCodeAction(monacoResult) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    let codeResult = codeActions.get(monacoResult);
+                    if (codeResult) {
+                        const worker = yield getLanguageService();
+                        codeResult = yield worker.doCodeActionResolve(codeResult);
+                        if (codeResult) {
+                            monacoResult = protocol2monaco.asCodeAction(codeResult);
+                            codeActions.set(monacoResult, codeResult);
+                        }
+                    }
+                    return monacoResult;
+                });
+            },
+            provideDocumentFormattingEdits(model, options, _token) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const worker = yield getLanguageService(model.uri);
+                    const codeResult = yield worker.format(model.uri.toString(), monaco2protocol.asFormattingOptions(options));
+                    if (codeResult) {
+                        return codeResult.map(protocol2monaco.asTextEdit);
+                    }
+                });
+            },
+            provideDocumentRangeFormattingEdits(model, range, options, _token) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const worker = yield getLanguageService(model.uri);
+                    const codeResult = yield worker.format(model.uri.toString(), monaco2protocol.asFormattingOptions(options), monaco2protocol.asRange(range));
+                    if (codeResult) {
+                        return codeResult.map(protocol2monaco.asTextEdit);
+                    }
+                });
+            },
+            provideOnTypeFormattingEdits(model, position, ch, options, _token) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const worker = yield getLanguageService(model.uri);
+                    const codeResult = yield worker.format(model.uri.toString(), monaco2protocol.asFormattingOptions(options), undefined, {
+                        ch: ch,
+                        position: monaco2protocol.asPosition(position),
+                    });
+                    if (codeResult) {
+                        return codeResult.map(protocol2monaco.asTextEdit);
+                    }
+                });
+            },
+            provideLinks(model, _token) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const worker = yield getLanguageService(model.uri);
+                    const codeResult = yield worker.findDocumentLinks(model.uri.toString());
+                    if (codeResult) {
+                        return {
+                            links: codeResult.map(protocol2monaco.asLink),
+                        };
+                    }
+                });
+            },
+            provideCompletionItems(model, position, context, _token) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const worker = yield getLanguageService(model.uri);
+                    const codeResult = yield worker.doComplete(model.uri.toString(), monaco2protocol.asPosition(position), monaco2protocol.asCompletionContext(context));
+                    const fallbackRange = {
+                        start: monaco2protocol.asPosition(position),
+                        end: monaco2protocol.asPosition(position),
+                    };
+                    const monacoResult = protocol2monaco.asCompletionList(codeResult, fallbackRange);
+                    for (let i = 0; i < codeResult.items.length; i++) {
+                        completionItems.set(monacoResult.suggestions[i], codeResult.items[i]);
+                    }
+                    return monacoResult;
+                });
+            },
+            resolveCompletionItem(monacoItem, _token) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    let codeItem = completionItems.get(monacoItem);
+                    if (codeItem) {
+                        const worker = yield getLanguageService();
+                        codeItem = yield worker.doCompletionResolve(codeItem);
+                        const fallbackRange = 'replace' in monacoItem.range
+                            ? monaco2protocol.asRange(monacoItem.range.replace)
+                            : monaco2protocol.asRange(monacoItem.range);
+                        monacoItem = protocol2monaco.asCompletionItem(codeItem, fallbackRange);
+                        completionItems.set(monacoItem, codeItem);
+                    }
+                    return monacoItem;
+                });
+            },
+            provideDocumentColors(model, _token) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const worker = yield getLanguageService(model.uri);
+                    const codeResult = yield worker.findDocumentColors(model.uri.toString());
+                    if (codeResult) {
+                        return codeResult.map(protocol2monaco.asColorInformation);
+                    }
+                });
+            },
+            provideColorPresentations(model, monacoResult) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const worker = yield getLanguageService(model.uri);
+                    const codeResult = colorInfos.get(monacoResult);
+                    if (codeResult) {
+                        const codeColors = yield worker.getColorPresentations(model.uri.toString(), codeResult.color, {
+                            start: monaco2protocol.asPosition(model.getPositionAt(0)),
+                            end: monaco2protocol.asPosition(model.getPositionAt(model.getValueLength())),
+                        });
+                        if (codeColors) {
+                            return codeColors.map(protocol2monaco.asColorPresentation);
+                        }
+                    }
+                });
+            },
+            provideFoldingRanges(model, _context, _token) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const worker = yield getLanguageService(model.uri);
+                    const codeResult = yield worker.getFoldingRanges(model.uri.toString());
+                    if (codeResult) {
+                        return codeResult.map(protocol2monaco.asFoldingRange);
+                    }
+                });
+            },
+            provideDeclaration(model, position, _token) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const worker = yield getLanguageService(model.uri);
+                    const codeResult = yield worker.findDefinition(model.uri.toString(), monaco2protocol.asPosition(position));
+                    if (codeResult) {
+                        return codeResult.map(protocol2monaco.asLocation);
+                    }
+                });
+            },
+            provideSelectionRanges(model, positions, _token) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const worker = yield getLanguageService(model.uri);
+                    const codeResults = yield Promise.all(positions.map((position) => worker.getSelectionRanges(model.uri.toString(), [
+                        monaco2protocol.asPosition(position),
+                    ])));
+                    return codeResults.map((codeResult) => { var _a; return (_a = codeResult === null || codeResult === void 0 ? void 0 : codeResult.map(protocol2monaco.asSelectionRange)) !== null && _a !== void 0 ? _a : []; });
+                });
+            },
+            provideSignatureHelp(model, position, _token, _context) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const worker = yield getLanguageService(model.uri);
+                    const codeResult = yield worker.getSignatureHelp(model.uri.toString(), monaco2protocol.asPosition(position));
+                    if (codeResult) {
+                        return {
+                            value: protocol2monaco.asSignatureHelp(codeResult),
+                            dispose: () => { },
+                        };
+                    }
+                });
+            },
+            provideRenameEdits(model, position, newName, _token) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const worker = yield getLanguageService(model.uri);
+                    const codeResult = yield worker.doRename(model.uri.toString(), monaco2protocol.asPosition(position), newName);
+                    if (codeResult) {
+                        return protocol2monaco.asWorkspaceEdit(codeResult);
+                    }
+                });
+            },
+            provideReferences(model, position, _context, _token) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const worker = yield getLanguageService(model.uri);
+                    const codeResult = yield worker.findReferences(model.uri.toString(), monaco2protocol.asPosition(position));
+                    // TODO: can't show if only one result from libs
+                    if (codeResult) {
+                        return codeResult.map(protocol2monaco.asLocation);
+                    }
+                });
+            },
+            provideInlayHints(model, range, _token) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const worker = yield getLanguageService(model.uri);
+                    const codeResult = yield worker.getInlayHints(model.uri.toString(), monaco2protocol.asRange(range));
+                    if (codeResult) {
+                        return {
+                            hints: codeResult.map(protocol2monaco.asInlayHint),
+                            dispose: () => { },
+                        };
+                    }
+                });
+            },
+            provideHover(model, position, _token) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const worker = yield getLanguageService(model.uri);
+                    const codeResult = yield worker.doHover(model.uri.toString(), monaco2protocol.asPosition(position));
+                    if (codeResult) {
+                        return protocol2monaco.asHover(codeResult);
+                    }
+                });
+            },
+        };
+        function getLanguageService(...uris) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield worker.withSyncedResources(uris);
+                return worker.getProxy();
+            });
+        }
+    });
+}
+exports.createLanguageFeaturesProvider = createLanguageFeaturesProvider;
+//# sourceMappingURL=provider.js.map

package/out/worker.d.ts

@@ -0,0 +1,15 @@
+import { type Config } from '@volar/language-service';
+import type * as monaco from 'monaco-editor-core';
+import type * as ts from 'typescript/lib/tsserverlibrary';
+export declare function createLanguageService(options: {
+    workerContext: monaco.worker.IWorkerContext<any>;
+    config: Config;
+    typescript?: {
+        module: typeof import('typescript/lib/tsserverlibrary');
+        compilerOptions: ts.CompilerOptions;
+        autoFetchTypes?: boolean | {
+            onFetchTypesFiles?(files: Record<string, string>): void;
+            cdn?: string;
+        };
+    };
+}): {};

package/out/worker.js

@@ -0,0 +1,179 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLanguageService = void 0;
+const language_service_1 = require("@volar/language-service");
+const vscode_uri_1 = require("vscode-uri");
+const autoFetchTypes_1 = require("./utils/autoFetchTypes");
+function createLanguageService(options) {
+    var _a, _b, _c, _d, _e, _f;
+    const ts = options.typescript ? options.typescript.module : undefined;
+    const config = (_a = options.config) !== null && _a !== void 0 ? _a : {};
+    const compilerOptions = (_c = (_b = options.typescript) === null || _b === void 0 ? void 0 : _b.compilerOptions) !== null && _c !== void 0 ? _c : {};
+    let autoFetchTypesCdn = 'https://unpkg.com/';
+    if (typeof ((_d = options.typescript) === null || _d === void 0 ? void 0 : _d.autoFetchTypes) === 'object' && options.typescript.autoFetchTypes.cdn) {
+        autoFetchTypesCdn = options.typescript.autoFetchTypes.cdn;
+    }
+    const autoTypeFetchHost = ((_e = options.typescript) === null || _e === void 0 ? void 0 : _e.autoFetchTypes) ? (0, autoFetchTypes_1.createAutoTypesFetchingHost)(autoFetchTypesCdn) : undefined;
+    let host = createLanguageServiceHost();
+    let languageService = (0, language_service_1.createLanguageService)(host, config, { rootUri: vscode_uri_1.URI.file('/') });
+    let webFilesNumOfLanguageService = (_f = autoTypeFetchHost === null || autoTypeFetchHost === void 0 ? void 0 : autoTypeFetchHost.files.size) !== null && _f !== void 0 ? _f : 0;
+    const syncedFiles = new Set();
+    class InnocentRabbit {
+    }
+    ;
+    for (const api in languageService) {
+        const isFunction = typeof languageService[api] === 'function';
+        ;
+        if (!isFunction) {
+            InnocentRabbit.prototype[api] = () => languageService[api];
+            continue;
+        }
+        InnocentRabbit.prototype[api] = (...args) => __awaiter(this, void 0, void 0, function* () {
+            var _g;
+            if (!autoTypeFetchHost) {
+                return languageService[api](...args);
+            }
+            let shouldSync = false;
+            let webFilesNumOfThisCall = autoTypeFetchHost.files.size;
+            let result = yield languageService[api](...args);
+            yield autoTypeFetchHost.wait();
+            while (autoTypeFetchHost.files.size > webFilesNumOfThisCall) {
+                shouldSync = true;
+                webFilesNumOfThisCall = autoTypeFetchHost.files.size;
+                if (autoTypeFetchHost.files.size > webFilesNumOfLanguageService) {
+                    webFilesNumOfLanguageService = autoTypeFetchHost.files.size;
+                    languageService.dispose();
+                    languageService = (0, language_service_1.createLanguageService)(host, config, { rootUri: vscode_uri_1.URI.file('/') });
+                }
+                result = yield languageService[api](...args);
+                yield autoTypeFetchHost.wait();
+            }
+            if (shouldSync && typeof ((_g = options.typescript) === null || _g === void 0 ? void 0 : _g.autoFetchTypes) === 'object' && options.typescript.autoFetchTypes.onFetchTypesFiles) {
+                const files = autoTypeFetchHost.files;
+                const syncFiles = {};
+                for (const [fileName, text] of files) {
+                    if (!syncedFiles.has(fileName) && text !== undefined) {
+                        syncFiles[fileName] = text;
+                        syncedFiles.add(fileName);
+                    }
+                }
+                options.typescript.autoFetchTypes.onFetchTypesFiles(syncFiles);
+            }
+            return result;
+        });
+    }
+    return new InnocentRabbit();
+    function createLanguageServiceHost() {
+        let projectVersion = 0;
+        const modelSnapshot = new WeakMap();
+        const webFileSnapshot = new Map();
+        const modelVersions = new Map();
+        const host = {
+            getProjectVersion() {
+                const models = options.workerContext.getMirrorModels();
+                if (modelVersions.size === options.workerContext.getMirrorModels().length) {
+                    if (models.every(model => modelVersions.get(model) === model.version)) {
+                        return projectVersion.toString();
+                    }
+                }
+                modelVersions.clear();
+                for (const model of options.workerContext.getMirrorModels()) {
+                    modelVersions.set(model, model.version);
+                }
+                projectVersion++;
+                return projectVersion.toString();
+            },
+            getScriptFileNames() {
+                const models = options.workerContext.getMirrorModels();
+                return models.map(model => model.uri.fsPath);
+            },
+            getScriptVersion(fileName) {
+                const model = options.workerContext.getMirrorModels().find(model => model.uri.fsPath === fileName);
+                if (model) {
+                    return model.version.toString();
+                }
+                if (autoTypeFetchHost) {
+                    const dts = autoTypeFetchHost.readFile(fileName);
+                    if (dts) {
+                        return dts.length.toString();
+                    }
+                }
+                return '';
+            },
+            getScriptSnapshot(fileName) {
+                var _a;
+                const model = options.workerContext.getMirrorModels().find(model => model.uri.fsPath === fileName);
+                if (model) {
+                    const cache = modelSnapshot.get(model);
+                    if (cache && cache[0] === model.version) {
+                        return cache[1];
+                    }
+                    const text = model.getValue();
+                    modelSnapshot.set(model, [model.version, {
+                            getText: (start, end) => text.substring(start, end),
+                            getLength: () => text.length,
+                            getChangeRange: () => undefined,
+                        }]);
+                    return (_a = modelSnapshot.get(model)) === null || _a === void 0 ? void 0 : _a[1];
+                }
+                if (webFileSnapshot.has(fileName)) {
+                    return webFileSnapshot.get(fileName);
+                }
+                if (autoTypeFetchHost) {
+                    const webFileText = autoTypeFetchHost.readFile(fileName);
+                    if (webFileText !== undefined) {
+                        webFileSnapshot.set(fileName, {
+                            getText: (start, end) => webFileText.substring(start, end),
+                            getLength: () => webFileText.length,
+                            getChangeRange: () => undefined,
+                        });
+                        return webFileSnapshot.get(fileName);
+                    }
+                }
+            },
+            getCompilationSettings() {
+                return compilerOptions;
+            },
+            getCurrentDirectory() {
+                return '/';
+            },
+            getDefaultLibFileName(options) {
+                if (ts) {
+                    return '/node_modules/typescript/lib/' + ts.getDefaultLibFileName(options);
+                }
+                return '';
+            },
+            readFile(fileName) {
+                const model = options.workerContext.getMirrorModels().find(model => model.uri.fsPath === fileName);
+                if (model) {
+                    return model.getValue();
+                }
+                if (autoTypeFetchHost) {
+                    return autoTypeFetchHost.readFile(fileName);
+                }
+            },
+            fileExists(fileName) {
+                const model = options.workerContext.getMirrorModels().find(model => model.uri.fsPath === fileName);
+                if (model) {
+                    return true;
+                }
+                if (autoTypeFetchHost) {
+                    return autoTypeFetchHost.fileExists(fileName);
+                }
+                return false;
+            },
+            getTypeScriptModule: ts ? (() => ts) : undefined,
+        };
+        return host;
+    }
+}
+exports.createLanguageService = createLanguageService;
+//# sourceMappingURL=worker.js.map

package/package.json

@@ -0,0 +1,25 @@
+{
+	"name": "@volar/monaco",
+	"version": "1.3.0-alpha.0",
+	"main": "out/index.js",
+	"license": "MIT",
+	"files": [
+		"*.js",
+		"*.d.ts",
+		"out/**/*.js",
+		"out/**/*.d.ts"
+	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/volarjs/volar.js.git",
+		"directory": "packages/monaco"
+	},
+	"dependencies": {
+		"@volar/language-service": "1.3.0-alpha.0",
+		"axios": "^1.3.4",
+		"monaco-editor-core": "^0.36.0",
+		"vscode-languageserver-protocol": "^3.17.3",
+		"vscode-uri": "^3.0.7"
+	},
+	"gitHead": "7582403cc521d33f642183a32da44fb1f64e65ef"
+}

package/worker.d.ts

@@ -0,0 +1 @@
+export * from './out/worker';

package/worker.js

@@ -0,0 +1 @@
+module.exports = require('./out/worker');