1292 lines
41 KiB
JavaScript
1292 lines
41 KiB
JavaScript
import {
|
|
typescriptDefaults
|
|
} from "./chunk-4LP7Q3YY.js";
|
|
import {
|
|
createWebWorker
|
|
} from "./chunk-LDDGU7BO.js";
|
|
import {
|
|
MarkerSeverity,
|
|
MarkerTag,
|
|
Range,
|
|
Uri,
|
|
editor,
|
|
languages
|
|
} from "./chunk-FYA5C7HA.js";
|
|
import "./chunk-DC5AMYBS.js";
|
|
|
|
// node_modules/monaco-editor/esm/vs/language/typescript/workerManager.js
|
|
import "E:/Workspace/easysql/node_modules/monaco-editor/esm/vs/base/browser/ui/codicons/codicon/codicon.css";
|
|
import "E:/Workspace/easysql/node_modules/monaco-editor/esm/vs/base/browser/ui/codicons/codicon/codicon-modifiers.css";
|
|
var WorkerManager = class {
|
|
constructor(_modeId, _defaults) {
|
|
this._modeId = _modeId;
|
|
this._defaults = _defaults;
|
|
this._worker = null;
|
|
this._client = null;
|
|
this._configChangeListener = this._defaults.onDidChange(() => this._stopWorker());
|
|
this._updateExtraLibsToken = 0;
|
|
this._extraLibsChangeListener = this._defaults.onDidExtraLibsChange(
|
|
() => this._updateExtraLibs()
|
|
);
|
|
}
|
|
dispose() {
|
|
this._configChangeListener.dispose();
|
|
this._extraLibsChangeListener.dispose();
|
|
this._stopWorker();
|
|
}
|
|
_stopWorker() {
|
|
if (this._worker) {
|
|
this._worker.dispose();
|
|
this._worker = null;
|
|
}
|
|
this._client = null;
|
|
}
|
|
async _updateExtraLibs() {
|
|
if (!this._worker) {
|
|
return;
|
|
}
|
|
const myToken = ++this._updateExtraLibsToken;
|
|
const proxy = await this._worker.getProxy();
|
|
if (this._updateExtraLibsToken !== myToken) {
|
|
return;
|
|
}
|
|
proxy.updateExtraLibs(this._defaults.getExtraLibs());
|
|
}
|
|
_getClient() {
|
|
if (!this._client) {
|
|
this._client = (async () => {
|
|
this._worker = createWebWorker({
|
|
// module that exports the create() method and returns a `TypeScriptWorker` instance
|
|
moduleId: "vs/language/typescript/tsWorker",
|
|
createWorker: () => new Worker(new URL("ts.worker.js", import.meta.url), { type: "module" }),
|
|
label: this._modeId,
|
|
keepIdleModels: true,
|
|
// passed in to the create() method
|
|
createData: {
|
|
compilerOptions: this._defaults.getCompilerOptions(),
|
|
extraLibs: this._defaults.getExtraLibs(),
|
|
customWorkerPath: this._defaults.workerOptions.customWorkerPath,
|
|
inlayHintsOptions: this._defaults.inlayHintsOptions
|
|
}
|
|
});
|
|
if (this._defaults.getEagerModelSync()) {
|
|
return await this._worker.withSyncedResources(
|
|
editor.getModels().filter((model) => model.getLanguageId() === this._modeId).map((model) => model.uri)
|
|
);
|
|
}
|
|
return await this._worker.getProxy();
|
|
})();
|
|
}
|
|
return this._client;
|
|
}
|
|
async getLanguageServiceWorker(...resources) {
|
|
const client = await this._getClient();
|
|
if (this._worker) {
|
|
await this._worker.withSyncedResources(resources);
|
|
}
|
|
return client;
|
|
}
|
|
};
|
|
|
|
// node_modules/monaco-editor/esm/vs/language/typescript/lib/lib.index.js
|
|
var libFileSet = {};
|
|
libFileSet["lib.d.ts"] = true;
|
|
libFileSet["lib.decorators.d.ts"] = true;
|
|
libFileSet["lib.decorators.legacy.d.ts"] = true;
|
|
libFileSet["lib.dom.asynciterable.d.ts"] = true;
|
|
libFileSet["lib.dom.d.ts"] = true;
|
|
libFileSet["lib.dom.iterable.d.ts"] = true;
|
|
libFileSet["lib.es2015.collection.d.ts"] = true;
|
|
libFileSet["lib.es2015.core.d.ts"] = true;
|
|
libFileSet["lib.es2015.d.ts"] = true;
|
|
libFileSet["lib.es2015.generator.d.ts"] = true;
|
|
libFileSet["lib.es2015.iterable.d.ts"] = true;
|
|
libFileSet["lib.es2015.promise.d.ts"] = true;
|
|
libFileSet["lib.es2015.proxy.d.ts"] = true;
|
|
libFileSet["lib.es2015.reflect.d.ts"] = true;
|
|
libFileSet["lib.es2015.symbol.d.ts"] = true;
|
|
libFileSet["lib.es2015.symbol.wellknown.d.ts"] = true;
|
|
libFileSet["lib.es2016.array.include.d.ts"] = true;
|
|
libFileSet["lib.es2016.d.ts"] = true;
|
|
libFileSet["lib.es2016.full.d.ts"] = true;
|
|
libFileSet["lib.es2016.intl.d.ts"] = true;
|
|
libFileSet["lib.es2017.arraybuffer.d.ts"] = true;
|
|
libFileSet["lib.es2017.d.ts"] = true;
|
|
libFileSet["lib.es2017.date.d.ts"] = true;
|
|
libFileSet["lib.es2017.full.d.ts"] = true;
|
|
libFileSet["lib.es2017.intl.d.ts"] = true;
|
|
libFileSet["lib.es2017.object.d.ts"] = true;
|
|
libFileSet["lib.es2017.sharedmemory.d.ts"] = true;
|
|
libFileSet["lib.es2017.string.d.ts"] = true;
|
|
libFileSet["lib.es2017.typedarrays.d.ts"] = true;
|
|
libFileSet["lib.es2018.asyncgenerator.d.ts"] = true;
|
|
libFileSet["lib.es2018.asynciterable.d.ts"] = true;
|
|
libFileSet["lib.es2018.d.ts"] = true;
|
|
libFileSet["lib.es2018.full.d.ts"] = true;
|
|
libFileSet["lib.es2018.intl.d.ts"] = true;
|
|
libFileSet["lib.es2018.promise.d.ts"] = true;
|
|
libFileSet["lib.es2018.regexp.d.ts"] = true;
|
|
libFileSet["lib.es2019.array.d.ts"] = true;
|
|
libFileSet["lib.es2019.d.ts"] = true;
|
|
libFileSet["lib.es2019.full.d.ts"] = true;
|
|
libFileSet["lib.es2019.intl.d.ts"] = true;
|
|
libFileSet["lib.es2019.object.d.ts"] = true;
|
|
libFileSet["lib.es2019.string.d.ts"] = true;
|
|
libFileSet["lib.es2019.symbol.d.ts"] = true;
|
|
libFileSet["lib.es2020.bigint.d.ts"] = true;
|
|
libFileSet["lib.es2020.d.ts"] = true;
|
|
libFileSet["lib.es2020.date.d.ts"] = true;
|
|
libFileSet["lib.es2020.full.d.ts"] = true;
|
|
libFileSet["lib.es2020.intl.d.ts"] = true;
|
|
libFileSet["lib.es2020.number.d.ts"] = true;
|
|
libFileSet["lib.es2020.promise.d.ts"] = true;
|
|
libFileSet["lib.es2020.sharedmemory.d.ts"] = true;
|
|
libFileSet["lib.es2020.string.d.ts"] = true;
|
|
libFileSet["lib.es2020.symbol.wellknown.d.ts"] = true;
|
|
libFileSet["lib.es2021.d.ts"] = true;
|
|
libFileSet["lib.es2021.full.d.ts"] = true;
|
|
libFileSet["lib.es2021.intl.d.ts"] = true;
|
|
libFileSet["lib.es2021.promise.d.ts"] = true;
|
|
libFileSet["lib.es2021.string.d.ts"] = true;
|
|
libFileSet["lib.es2021.weakref.d.ts"] = true;
|
|
libFileSet["lib.es2022.array.d.ts"] = true;
|
|
libFileSet["lib.es2022.d.ts"] = true;
|
|
libFileSet["lib.es2022.error.d.ts"] = true;
|
|
libFileSet["lib.es2022.full.d.ts"] = true;
|
|
libFileSet["lib.es2022.intl.d.ts"] = true;
|
|
libFileSet["lib.es2022.object.d.ts"] = true;
|
|
libFileSet["lib.es2022.regexp.d.ts"] = true;
|
|
libFileSet["lib.es2022.string.d.ts"] = true;
|
|
libFileSet["lib.es2023.array.d.ts"] = true;
|
|
libFileSet["lib.es2023.collection.d.ts"] = true;
|
|
libFileSet["lib.es2023.d.ts"] = true;
|
|
libFileSet["lib.es2023.full.d.ts"] = true;
|
|
libFileSet["lib.es2023.intl.d.ts"] = true;
|
|
libFileSet["lib.es2024.arraybuffer.d.ts"] = true;
|
|
libFileSet["lib.es2024.collection.d.ts"] = true;
|
|
libFileSet["lib.es2024.d.ts"] = true;
|
|
libFileSet["lib.es2024.full.d.ts"] = true;
|
|
libFileSet["lib.es2024.object.d.ts"] = true;
|
|
libFileSet["lib.es2024.promise.d.ts"] = true;
|
|
libFileSet["lib.es2024.regexp.d.ts"] = true;
|
|
libFileSet["lib.es2024.sharedmemory.d.ts"] = true;
|
|
libFileSet["lib.es2024.string.d.ts"] = true;
|
|
libFileSet["lib.es5.d.ts"] = true;
|
|
libFileSet["lib.es6.d.ts"] = true;
|
|
libFileSet["lib.esnext.array.d.ts"] = true;
|
|
libFileSet["lib.esnext.collection.d.ts"] = true;
|
|
libFileSet["lib.esnext.d.ts"] = true;
|
|
libFileSet["lib.esnext.decorators.d.ts"] = true;
|
|
libFileSet["lib.esnext.disposable.d.ts"] = true;
|
|
libFileSet["lib.esnext.error.d.ts"] = true;
|
|
libFileSet["lib.esnext.float16.d.ts"] = true;
|
|
libFileSet["lib.esnext.full.d.ts"] = true;
|
|
libFileSet["lib.esnext.intl.d.ts"] = true;
|
|
libFileSet["lib.esnext.iterator.d.ts"] = true;
|
|
libFileSet["lib.esnext.promise.d.ts"] = true;
|
|
libFileSet["lib.esnext.sharedmemory.d.ts"] = true;
|
|
libFileSet["lib.scripthost.d.ts"] = true;
|
|
libFileSet["lib.webworker.asynciterable.d.ts"] = true;
|
|
libFileSet["lib.webworker.d.ts"] = true;
|
|
libFileSet["lib.webworker.importscripts.d.ts"] = true;
|
|
libFileSet["lib.webworker.iterable.d.ts"] = true;
|
|
|
|
// node_modules/monaco-editor/esm/vs/language/typescript/languageFeatures.js
|
|
import "E:/Workspace/easysql/node_modules/monaco-editor/esm/vs/base/browser/ui/codicons/codicon/codicon.css";
|
|
import "E:/Workspace/easysql/node_modules/monaco-editor/esm/vs/base/browser/ui/codicons/codicon/codicon-modifiers.css";
|
|
function flattenDiagnosticMessageText(diag, newLine, indent = 0) {
|
|
if (typeof diag === "string") {
|
|
return diag;
|
|
} else if (diag === void 0) {
|
|
return "";
|
|
}
|
|
let result = "";
|
|
if (indent) {
|
|
result += newLine;
|
|
for (let i = 0; i < indent; i++) {
|
|
result += " ";
|
|
}
|
|
}
|
|
result += diag.messageText;
|
|
indent++;
|
|
if (diag.next) {
|
|
for (const kid of diag.next) {
|
|
result += flattenDiagnosticMessageText(kid, newLine, indent);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function displayPartsToString(displayParts) {
|
|
if (displayParts) {
|
|
return displayParts.map((displayPart) => displayPart.text).join("");
|
|
}
|
|
return "";
|
|
}
|
|
var Adapter = class {
|
|
constructor(_worker) {
|
|
this._worker = _worker;
|
|
}
|
|
// protected _positionToOffset(model: editor.ITextModel, position: monaco.IPosition): number {
|
|
// return model.getOffsetAt(position);
|
|
// }
|
|
// protected _offsetToPosition(model: editor.ITextModel, offset: number): monaco.IPosition {
|
|
// return model.getPositionAt(offset);
|
|
// }
|
|
_textSpanToRange(model, span) {
|
|
let p1 = model.getPositionAt(span.start);
|
|
let p2 = model.getPositionAt(span.start + span.length);
|
|
let { lineNumber: startLineNumber, column: startColumn } = p1;
|
|
let { lineNumber: endLineNumber, column: endColumn } = p2;
|
|
return { startLineNumber, startColumn, endLineNumber, endColumn };
|
|
}
|
|
};
|
|
var LibFiles = class {
|
|
constructor(_worker) {
|
|
this._worker = _worker;
|
|
this._libFiles = {};
|
|
this._hasFetchedLibFiles = false;
|
|
this._fetchLibFilesPromise = null;
|
|
}
|
|
isLibFile(uri) {
|
|
if (!uri) {
|
|
return false;
|
|
}
|
|
if (uri.path.indexOf("/lib.") === 0) {
|
|
return !!libFileSet[uri.path.slice(1)];
|
|
}
|
|
return false;
|
|
}
|
|
getOrCreateModel(fileName) {
|
|
const uri = Uri.parse(fileName);
|
|
const model = editor.getModel(uri);
|
|
if (model) {
|
|
return model;
|
|
}
|
|
if (this.isLibFile(uri) && this._hasFetchedLibFiles) {
|
|
return editor.createModel(this._libFiles[uri.path.slice(1)], "typescript", uri);
|
|
}
|
|
const matchedLibFile = typescriptDefaults.getExtraLibs()[fileName];
|
|
if (matchedLibFile) {
|
|
return editor.createModel(matchedLibFile.content, "typescript", uri);
|
|
}
|
|
return null;
|
|
}
|
|
_containsLibFile(uris) {
|
|
for (let uri of uris) {
|
|
if (this.isLibFile(uri)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
async fetchLibFilesIfNecessary(uris) {
|
|
if (!this._containsLibFile(uris)) {
|
|
return;
|
|
}
|
|
await this._fetchLibFiles();
|
|
}
|
|
_fetchLibFiles() {
|
|
if (!this._fetchLibFilesPromise) {
|
|
this._fetchLibFilesPromise = this._worker().then((w) => w.getLibFiles()).then((libFiles) => {
|
|
this._hasFetchedLibFiles = true;
|
|
this._libFiles = libFiles;
|
|
});
|
|
}
|
|
return this._fetchLibFilesPromise;
|
|
}
|
|
};
|
|
var DiagnosticsAdapter = class extends Adapter {
|
|
constructor(_libFiles, _defaults, _selector, worker) {
|
|
super(worker);
|
|
this._libFiles = _libFiles;
|
|
this._defaults = _defaults;
|
|
this._selector = _selector;
|
|
this._disposables = [];
|
|
this._listener = /* @__PURE__ */ Object.create(null);
|
|
const onModelAdd = (model) => {
|
|
if (model.getLanguageId() !== _selector) {
|
|
return;
|
|
}
|
|
const maybeValidate = () => {
|
|
const { onlyVisible } = this._defaults.getDiagnosticsOptions();
|
|
if (onlyVisible) {
|
|
if (model.isAttachedToEditor()) {
|
|
this._doValidate(model);
|
|
}
|
|
} else {
|
|
this._doValidate(model);
|
|
}
|
|
};
|
|
let handle;
|
|
const changeSubscription = model.onDidChangeContent(() => {
|
|
clearTimeout(handle);
|
|
handle = window.setTimeout(maybeValidate, 500);
|
|
});
|
|
const visibleSubscription = model.onDidChangeAttached(() => {
|
|
const { onlyVisible } = this._defaults.getDiagnosticsOptions();
|
|
if (onlyVisible) {
|
|
if (model.isAttachedToEditor()) {
|
|
maybeValidate();
|
|
} else {
|
|
editor.setModelMarkers(model, this._selector, []);
|
|
}
|
|
}
|
|
});
|
|
this._listener[model.uri.toString()] = {
|
|
dispose() {
|
|
changeSubscription.dispose();
|
|
visibleSubscription.dispose();
|
|
clearTimeout(handle);
|
|
}
|
|
};
|
|
maybeValidate();
|
|
};
|
|
const onModelRemoved = (model) => {
|
|
editor.setModelMarkers(model, this._selector, []);
|
|
const key = model.uri.toString();
|
|
if (this._listener[key]) {
|
|
this._listener[key].dispose();
|
|
delete this._listener[key];
|
|
}
|
|
};
|
|
this._disposables.push(
|
|
editor.onDidCreateModel((model) => onModelAdd(model))
|
|
);
|
|
this._disposables.push(editor.onWillDisposeModel(onModelRemoved));
|
|
this._disposables.push(
|
|
editor.onDidChangeModelLanguage((event) => {
|
|
onModelRemoved(event.model);
|
|
onModelAdd(event.model);
|
|
})
|
|
);
|
|
this._disposables.push({
|
|
dispose() {
|
|
for (const model of editor.getModels()) {
|
|
onModelRemoved(model);
|
|
}
|
|
}
|
|
});
|
|
const recomputeDiagostics = () => {
|
|
for (const model of editor.getModels()) {
|
|
onModelRemoved(model);
|
|
onModelAdd(model);
|
|
}
|
|
};
|
|
this._disposables.push(this._defaults.onDidChange(recomputeDiagostics));
|
|
this._disposables.push(this._defaults.onDidExtraLibsChange(recomputeDiagostics));
|
|
editor.getModels().forEach((model) => onModelAdd(model));
|
|
}
|
|
dispose() {
|
|
this._disposables.forEach((d) => d && d.dispose());
|
|
this._disposables = [];
|
|
}
|
|
async _doValidate(model) {
|
|
const worker = await this._worker(model.uri);
|
|
if (model.isDisposed()) {
|
|
return;
|
|
}
|
|
const promises = [];
|
|
const { noSyntaxValidation, noSemanticValidation, noSuggestionDiagnostics } = this._defaults.getDiagnosticsOptions();
|
|
if (!noSyntaxValidation) {
|
|
promises.push(worker.getSyntacticDiagnostics(model.uri.toString()));
|
|
}
|
|
if (!noSemanticValidation) {
|
|
promises.push(worker.getSemanticDiagnostics(model.uri.toString()));
|
|
}
|
|
if (!noSuggestionDiagnostics) {
|
|
promises.push(worker.getSuggestionDiagnostics(model.uri.toString()));
|
|
}
|
|
const allDiagnostics = await Promise.all(promises);
|
|
if (!allDiagnostics || model.isDisposed()) {
|
|
return;
|
|
}
|
|
const diagnostics = allDiagnostics.reduce((p, c) => c.concat(p), []).filter(
|
|
(d) => (this._defaults.getDiagnosticsOptions().diagnosticCodesToIgnore || []).indexOf(d.code) === -1
|
|
);
|
|
const relatedUris = diagnostics.map((d) => d.relatedInformation || []).reduce((p, c) => c.concat(p), []).map(
|
|
(relatedInformation) => relatedInformation.file ? Uri.parse(relatedInformation.file.fileName) : null
|
|
);
|
|
await this._libFiles.fetchLibFilesIfNecessary(relatedUris);
|
|
if (model.isDisposed()) {
|
|
return;
|
|
}
|
|
editor.setModelMarkers(
|
|
model,
|
|
this._selector,
|
|
diagnostics.map((d) => this._convertDiagnostics(model, d))
|
|
);
|
|
}
|
|
_convertDiagnostics(model, diag) {
|
|
const diagStart = diag.start || 0;
|
|
const diagLength = diag.length || 1;
|
|
const { lineNumber: startLineNumber, column: startColumn } = model.getPositionAt(diagStart);
|
|
const { lineNumber: endLineNumber, column: endColumn } = model.getPositionAt(
|
|
diagStart + diagLength
|
|
);
|
|
const tags = [];
|
|
if (diag.reportsUnnecessary) {
|
|
tags.push(MarkerTag.Unnecessary);
|
|
}
|
|
if (diag.reportsDeprecated) {
|
|
tags.push(MarkerTag.Deprecated);
|
|
}
|
|
return {
|
|
severity: this._tsDiagnosticCategoryToMarkerSeverity(diag.category),
|
|
startLineNumber,
|
|
startColumn,
|
|
endLineNumber,
|
|
endColumn,
|
|
message: flattenDiagnosticMessageText(diag.messageText, "\n"),
|
|
code: diag.code.toString(),
|
|
tags,
|
|
relatedInformation: this._convertRelatedInformation(model, diag.relatedInformation)
|
|
};
|
|
}
|
|
_convertRelatedInformation(model, relatedInformation) {
|
|
if (!relatedInformation) {
|
|
return [];
|
|
}
|
|
const result = [];
|
|
relatedInformation.forEach((info) => {
|
|
let relatedResource = model;
|
|
if (info.file) {
|
|
relatedResource = this._libFiles.getOrCreateModel(info.file.fileName);
|
|
}
|
|
if (!relatedResource) {
|
|
return;
|
|
}
|
|
const infoStart = info.start || 0;
|
|
const infoLength = info.length || 1;
|
|
const { lineNumber: startLineNumber, column: startColumn } = relatedResource.getPositionAt(infoStart);
|
|
const { lineNumber: endLineNumber, column: endColumn } = relatedResource.getPositionAt(
|
|
infoStart + infoLength
|
|
);
|
|
result.push({
|
|
resource: relatedResource.uri,
|
|
startLineNumber,
|
|
startColumn,
|
|
endLineNumber,
|
|
endColumn,
|
|
message: flattenDiagnosticMessageText(info.messageText, "\n")
|
|
});
|
|
});
|
|
return result;
|
|
}
|
|
_tsDiagnosticCategoryToMarkerSeverity(category) {
|
|
switch (category) {
|
|
case 1:
|
|
return MarkerSeverity.Error;
|
|
case 3:
|
|
return MarkerSeverity.Info;
|
|
case 0:
|
|
return MarkerSeverity.Warning;
|
|
case 2:
|
|
return MarkerSeverity.Hint;
|
|
}
|
|
return MarkerSeverity.Info;
|
|
}
|
|
};
|
|
var SuggestAdapter = class _SuggestAdapter extends Adapter {
|
|
get triggerCharacters() {
|
|
return ["."];
|
|
}
|
|
async provideCompletionItems(model, position, _context, token) {
|
|
const wordInfo = model.getWordUntilPosition(position);
|
|
const wordRange = new Range(
|
|
position.lineNumber,
|
|
wordInfo.startColumn,
|
|
position.lineNumber,
|
|
wordInfo.endColumn
|
|
);
|
|
const resource = model.uri;
|
|
const offset = model.getOffsetAt(position);
|
|
const worker = await this._worker(resource);
|
|
if (model.isDisposed()) {
|
|
return;
|
|
}
|
|
const info = await worker.getCompletionsAtPosition(resource.toString(), offset);
|
|
if (!info || model.isDisposed()) {
|
|
return;
|
|
}
|
|
const suggestions = info.entries.map((entry) => {
|
|
let range = wordRange;
|
|
if (entry.replacementSpan) {
|
|
const p1 = model.getPositionAt(entry.replacementSpan.start);
|
|
const p2 = model.getPositionAt(entry.replacementSpan.start + entry.replacementSpan.length);
|
|
range = new Range(p1.lineNumber, p1.column, p2.lineNumber, p2.column);
|
|
}
|
|
const tags = [];
|
|
if (entry.kindModifiers !== void 0 && entry.kindModifiers.indexOf("deprecated") !== -1) {
|
|
tags.push(languages.CompletionItemTag.Deprecated);
|
|
}
|
|
return {
|
|
uri: resource,
|
|
position,
|
|
offset,
|
|
range,
|
|
label: entry.name,
|
|
insertText: entry.name,
|
|
sortText: entry.sortText,
|
|
kind: _SuggestAdapter.convertKind(entry.kind),
|
|
tags
|
|
};
|
|
});
|
|
return {
|
|
suggestions
|
|
};
|
|
}
|
|
async resolveCompletionItem(item, token) {
|
|
const myItem = item;
|
|
const resource = myItem.uri;
|
|
const position = myItem.position;
|
|
const offset = myItem.offset;
|
|
const worker = await this._worker(resource);
|
|
const details = await worker.getCompletionEntryDetails(
|
|
resource.toString(),
|
|
offset,
|
|
myItem.label
|
|
);
|
|
if (!details) {
|
|
return myItem;
|
|
}
|
|
return {
|
|
uri: resource,
|
|
position,
|
|
label: details.name,
|
|
kind: _SuggestAdapter.convertKind(details.kind),
|
|
detail: displayPartsToString(details.displayParts),
|
|
documentation: {
|
|
value: _SuggestAdapter.createDocumentationString(details)
|
|
}
|
|
};
|
|
}
|
|
static convertKind(kind) {
|
|
switch (kind) {
|
|
case Kind.primitiveType:
|
|
case Kind.keyword:
|
|
return languages.CompletionItemKind.Keyword;
|
|
case Kind.variable:
|
|
case Kind.localVariable:
|
|
return languages.CompletionItemKind.Variable;
|
|
case Kind.memberVariable:
|
|
case Kind.memberGetAccessor:
|
|
case Kind.memberSetAccessor:
|
|
return languages.CompletionItemKind.Field;
|
|
case Kind.function:
|
|
case Kind.memberFunction:
|
|
case Kind.constructSignature:
|
|
case Kind.callSignature:
|
|
case Kind.indexSignature:
|
|
return languages.CompletionItemKind.Function;
|
|
case Kind.enum:
|
|
return languages.CompletionItemKind.Enum;
|
|
case Kind.module:
|
|
return languages.CompletionItemKind.Module;
|
|
case Kind.class:
|
|
return languages.CompletionItemKind.Class;
|
|
case Kind.interface:
|
|
return languages.CompletionItemKind.Interface;
|
|
case Kind.warning:
|
|
return languages.CompletionItemKind.File;
|
|
}
|
|
return languages.CompletionItemKind.Property;
|
|
}
|
|
static createDocumentationString(details) {
|
|
let documentationString = displayPartsToString(details.documentation);
|
|
if (details.tags) {
|
|
for (const tag of details.tags) {
|
|
documentationString += `
|
|
|
|
${tagToString(tag)}`;
|
|
}
|
|
}
|
|
return documentationString;
|
|
}
|
|
};
|
|
function tagToString(tag) {
|
|
let tagLabel = `*@${tag.name}*`;
|
|
if (tag.name === "param" && tag.text) {
|
|
const [paramName, ...rest] = tag.text;
|
|
tagLabel += `\`${paramName.text}\``;
|
|
if (rest.length > 0) tagLabel += ` — ${rest.map((r) => r.text).join(" ")}`;
|
|
} else if (Array.isArray(tag.text)) {
|
|
tagLabel += ` — ${tag.text.map((r) => r.text).join(" ")}`;
|
|
} else if (tag.text) {
|
|
tagLabel += ` — ${tag.text}`;
|
|
}
|
|
return tagLabel;
|
|
}
|
|
var SignatureHelpAdapter = class _SignatureHelpAdapter extends Adapter {
|
|
constructor() {
|
|
super(...arguments);
|
|
this.signatureHelpTriggerCharacters = ["(", ","];
|
|
}
|
|
static _toSignatureHelpTriggerReason(context) {
|
|
switch (context.triggerKind) {
|
|
case languages.SignatureHelpTriggerKind.TriggerCharacter:
|
|
if (context.triggerCharacter) {
|
|
if (context.isRetrigger) {
|
|
return { kind: "retrigger", triggerCharacter: context.triggerCharacter };
|
|
} else {
|
|
return { kind: "characterTyped", triggerCharacter: context.triggerCharacter };
|
|
}
|
|
} else {
|
|
return { kind: "invoked" };
|
|
}
|
|
case languages.SignatureHelpTriggerKind.ContentChange:
|
|
return context.isRetrigger ? { kind: "retrigger" } : { kind: "invoked" };
|
|
case languages.SignatureHelpTriggerKind.Invoke:
|
|
default:
|
|
return { kind: "invoked" };
|
|
}
|
|
}
|
|
async provideSignatureHelp(model, position, token, context) {
|
|
const resource = model.uri;
|
|
const offset = model.getOffsetAt(position);
|
|
const worker = await this._worker(resource);
|
|
if (model.isDisposed()) {
|
|
return;
|
|
}
|
|
const info = await worker.getSignatureHelpItems(resource.toString(), offset, {
|
|
triggerReason: _SignatureHelpAdapter._toSignatureHelpTriggerReason(context)
|
|
});
|
|
if (!info || model.isDisposed()) {
|
|
return;
|
|
}
|
|
const ret = {
|
|
activeSignature: info.selectedItemIndex,
|
|
activeParameter: info.argumentIndex,
|
|
signatures: []
|
|
};
|
|
info.items.forEach((item) => {
|
|
const signature = {
|
|
label: "",
|
|
parameters: []
|
|
};
|
|
signature.documentation = {
|
|
value: displayPartsToString(item.documentation)
|
|
};
|
|
signature.label += displayPartsToString(item.prefixDisplayParts);
|
|
item.parameters.forEach((p, i, a) => {
|
|
const label = displayPartsToString(p.displayParts);
|
|
const parameter = {
|
|
label,
|
|
documentation: {
|
|
value: displayPartsToString(p.documentation)
|
|
}
|
|
};
|
|
signature.label += label;
|
|
signature.parameters.push(parameter);
|
|
if (i < a.length - 1) {
|
|
signature.label += displayPartsToString(item.separatorDisplayParts);
|
|
}
|
|
});
|
|
signature.label += displayPartsToString(item.suffixDisplayParts);
|
|
ret.signatures.push(signature);
|
|
});
|
|
return {
|
|
value: ret,
|
|
dispose() {
|
|
}
|
|
};
|
|
}
|
|
};
|
|
var QuickInfoAdapter = class extends Adapter {
|
|
async provideHover(model, position, token) {
|
|
const resource = model.uri;
|
|
const offset = model.getOffsetAt(position);
|
|
const worker = await this._worker(resource);
|
|
if (model.isDisposed()) {
|
|
return;
|
|
}
|
|
const info = await worker.getQuickInfoAtPosition(resource.toString(), offset);
|
|
if (!info || model.isDisposed()) {
|
|
return;
|
|
}
|
|
const documentation = displayPartsToString(info.documentation);
|
|
const tags = info.tags ? info.tags.map((tag) => tagToString(tag)).join(" \n\n") : "";
|
|
const contents = displayPartsToString(info.displayParts);
|
|
return {
|
|
range: this._textSpanToRange(model, info.textSpan),
|
|
contents: [
|
|
{
|
|
value: "```typescript\n" + contents + "\n```\n"
|
|
},
|
|
{
|
|
value: documentation + (tags ? "\n\n" + tags : "")
|
|
}
|
|
]
|
|
};
|
|
}
|
|
};
|
|
var DocumentHighlightAdapter = class extends Adapter {
|
|
async provideDocumentHighlights(model, position, token) {
|
|
const resource = model.uri;
|
|
const offset = model.getOffsetAt(position);
|
|
const worker = await this._worker(resource);
|
|
if (model.isDisposed()) {
|
|
return;
|
|
}
|
|
const entries = await worker.getDocumentHighlights(resource.toString(), offset, [
|
|
resource.toString()
|
|
]);
|
|
if (!entries || model.isDisposed()) {
|
|
return;
|
|
}
|
|
return entries.flatMap((entry) => {
|
|
return entry.highlightSpans.map((highlightSpans) => {
|
|
return {
|
|
range: this._textSpanToRange(model, highlightSpans.textSpan),
|
|
kind: highlightSpans.kind === "writtenReference" ? languages.DocumentHighlightKind.Write : languages.DocumentHighlightKind.Text
|
|
};
|
|
});
|
|
});
|
|
}
|
|
};
|
|
var DefinitionAdapter = class extends Adapter {
|
|
constructor(_libFiles, worker) {
|
|
super(worker);
|
|
this._libFiles = _libFiles;
|
|
}
|
|
async provideDefinition(model, position, token) {
|
|
const resource = model.uri;
|
|
const offset = model.getOffsetAt(position);
|
|
const worker = await this._worker(resource);
|
|
if (model.isDisposed()) {
|
|
return;
|
|
}
|
|
const entries = await worker.getDefinitionAtPosition(resource.toString(), offset);
|
|
if (!entries || model.isDisposed()) {
|
|
return;
|
|
}
|
|
await this._libFiles.fetchLibFilesIfNecessary(
|
|
entries.map((entry) => Uri.parse(entry.fileName))
|
|
);
|
|
if (model.isDisposed()) {
|
|
return;
|
|
}
|
|
const result = [];
|
|
for (let entry of entries) {
|
|
const refModel = this._libFiles.getOrCreateModel(entry.fileName);
|
|
if (refModel) {
|
|
result.push({
|
|
uri: refModel.uri,
|
|
range: this._textSpanToRange(refModel, entry.textSpan)
|
|
});
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
};
|
|
var ReferenceAdapter = class extends Adapter {
|
|
constructor(_libFiles, worker) {
|
|
super(worker);
|
|
this._libFiles = _libFiles;
|
|
}
|
|
async provideReferences(model, position, context, token) {
|
|
const resource = model.uri;
|
|
const offset = model.getOffsetAt(position);
|
|
const worker = await this._worker(resource);
|
|
if (model.isDisposed()) {
|
|
return;
|
|
}
|
|
const entries = await worker.getReferencesAtPosition(resource.toString(), offset);
|
|
if (!entries || model.isDisposed()) {
|
|
return;
|
|
}
|
|
await this._libFiles.fetchLibFilesIfNecessary(
|
|
entries.map((entry) => Uri.parse(entry.fileName))
|
|
);
|
|
if (model.isDisposed()) {
|
|
return;
|
|
}
|
|
const result = [];
|
|
for (let entry of entries) {
|
|
const refModel = this._libFiles.getOrCreateModel(entry.fileName);
|
|
if (refModel) {
|
|
result.push({
|
|
uri: refModel.uri,
|
|
range: this._textSpanToRange(refModel, entry.textSpan)
|
|
});
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
};
|
|
var OutlineAdapter = class extends Adapter {
|
|
async provideDocumentSymbols(model, token) {
|
|
const resource = model.uri;
|
|
const worker = await this._worker(resource);
|
|
if (model.isDisposed()) {
|
|
return;
|
|
}
|
|
const root = await worker.getNavigationTree(resource.toString());
|
|
if (!root || model.isDisposed()) {
|
|
return;
|
|
}
|
|
const convert = (item, containerLabel) => {
|
|
var _a;
|
|
const result2 = {
|
|
name: item.text,
|
|
detail: "",
|
|
kind: outlineTypeTable[item.kind] || languages.SymbolKind.Variable,
|
|
range: this._textSpanToRange(model, item.spans[0]),
|
|
selectionRange: this._textSpanToRange(model, item.spans[0]),
|
|
tags: [],
|
|
children: (_a = item.childItems) == null ? void 0 : _a.map((child) => convert(child, item.text)),
|
|
containerName: containerLabel
|
|
};
|
|
return result2;
|
|
};
|
|
const result = root.childItems ? root.childItems.map((item) => convert(item)) : [];
|
|
return result;
|
|
}
|
|
};
|
|
var Kind = class {
|
|
};
|
|
Kind.unknown = "";
|
|
Kind.keyword = "keyword";
|
|
Kind.script = "script";
|
|
Kind.module = "module";
|
|
Kind.class = "class";
|
|
Kind.interface = "interface";
|
|
Kind.type = "type";
|
|
Kind.enum = "enum";
|
|
Kind.variable = "var";
|
|
Kind.localVariable = "local var";
|
|
Kind.function = "function";
|
|
Kind.localFunction = "local function";
|
|
Kind.memberFunction = "method";
|
|
Kind.memberGetAccessor = "getter";
|
|
Kind.memberSetAccessor = "setter";
|
|
Kind.memberVariable = "property";
|
|
Kind.constructorImplementation = "constructor";
|
|
Kind.callSignature = "call";
|
|
Kind.indexSignature = "index";
|
|
Kind.constructSignature = "construct";
|
|
Kind.parameter = "parameter";
|
|
Kind.typeParameter = "type parameter";
|
|
Kind.primitiveType = "primitive type";
|
|
Kind.label = "label";
|
|
Kind.alias = "alias";
|
|
Kind.const = "const";
|
|
Kind.let = "let";
|
|
Kind.warning = "warning";
|
|
var outlineTypeTable = /* @__PURE__ */ Object.create(null);
|
|
outlineTypeTable[Kind.module] = languages.SymbolKind.Module;
|
|
outlineTypeTable[Kind.class] = languages.SymbolKind.Class;
|
|
outlineTypeTable[Kind.enum] = languages.SymbolKind.Enum;
|
|
outlineTypeTable[Kind.interface] = languages.SymbolKind.Interface;
|
|
outlineTypeTable[Kind.memberFunction] = languages.SymbolKind.Method;
|
|
outlineTypeTable[Kind.memberVariable] = languages.SymbolKind.Property;
|
|
outlineTypeTable[Kind.memberGetAccessor] = languages.SymbolKind.Property;
|
|
outlineTypeTable[Kind.memberSetAccessor] = languages.SymbolKind.Property;
|
|
outlineTypeTable[Kind.variable] = languages.SymbolKind.Variable;
|
|
outlineTypeTable[Kind.const] = languages.SymbolKind.Variable;
|
|
outlineTypeTable[Kind.localVariable] = languages.SymbolKind.Variable;
|
|
outlineTypeTable[Kind.variable] = languages.SymbolKind.Variable;
|
|
outlineTypeTable[Kind.function] = languages.SymbolKind.Function;
|
|
outlineTypeTable[Kind.localFunction] = languages.SymbolKind.Function;
|
|
var FormatHelper = class extends Adapter {
|
|
static _convertOptions(options) {
|
|
return {
|
|
ConvertTabsToSpaces: options.insertSpaces,
|
|
TabSize: options.tabSize,
|
|
IndentSize: options.tabSize,
|
|
IndentStyle: 2,
|
|
NewLineCharacter: "\n",
|
|
InsertSpaceAfterCommaDelimiter: true,
|
|
InsertSpaceAfterSemicolonInForStatements: true,
|
|
InsertSpaceBeforeAndAfterBinaryOperators: true,
|
|
InsertSpaceAfterKeywordsInControlFlowStatements: true,
|
|
InsertSpaceAfterFunctionKeywordForAnonymousFunctions: true,
|
|
InsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: false,
|
|
InsertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets: false,
|
|
InsertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces: false,
|
|
PlaceOpenBraceOnNewLineForControlBlocks: false,
|
|
PlaceOpenBraceOnNewLineForFunctions: false
|
|
};
|
|
}
|
|
_convertTextChanges(model, change) {
|
|
return {
|
|
text: change.newText,
|
|
range: this._textSpanToRange(model, change.span)
|
|
};
|
|
}
|
|
};
|
|
var FormatAdapter = class extends FormatHelper {
|
|
constructor() {
|
|
super(...arguments);
|
|
this.canFormatMultipleRanges = false;
|
|
}
|
|
async provideDocumentRangeFormattingEdits(model, range, options, token) {
|
|
const resource = model.uri;
|
|
const startOffset = model.getOffsetAt({
|
|
lineNumber: range.startLineNumber,
|
|
column: range.startColumn
|
|
});
|
|
const endOffset = model.getOffsetAt({
|
|
lineNumber: range.endLineNumber,
|
|
column: range.endColumn
|
|
});
|
|
const worker = await this._worker(resource);
|
|
if (model.isDisposed()) {
|
|
return;
|
|
}
|
|
const edits = await worker.getFormattingEditsForRange(
|
|
resource.toString(),
|
|
startOffset,
|
|
endOffset,
|
|
FormatHelper._convertOptions(options)
|
|
);
|
|
if (!edits || model.isDisposed()) {
|
|
return;
|
|
}
|
|
return edits.map((edit) => this._convertTextChanges(model, edit));
|
|
}
|
|
};
|
|
var FormatOnTypeAdapter = class extends FormatHelper {
|
|
get autoFormatTriggerCharacters() {
|
|
return [";", "}", "\n"];
|
|
}
|
|
async provideOnTypeFormattingEdits(model, position, ch, options, token) {
|
|
const resource = model.uri;
|
|
const offset = model.getOffsetAt(position);
|
|
const worker = await this._worker(resource);
|
|
if (model.isDisposed()) {
|
|
return;
|
|
}
|
|
const edits = await worker.getFormattingEditsAfterKeystroke(
|
|
resource.toString(),
|
|
offset,
|
|
ch,
|
|
FormatHelper._convertOptions(options)
|
|
);
|
|
if (!edits || model.isDisposed()) {
|
|
return;
|
|
}
|
|
return edits.map((edit) => this._convertTextChanges(model, edit));
|
|
}
|
|
};
|
|
var CodeActionAdaptor = class extends FormatHelper {
|
|
async provideCodeActions(model, range, context, token) {
|
|
const resource = model.uri;
|
|
const start = model.getOffsetAt({
|
|
lineNumber: range.startLineNumber,
|
|
column: range.startColumn
|
|
});
|
|
const end = model.getOffsetAt({
|
|
lineNumber: range.endLineNumber,
|
|
column: range.endColumn
|
|
});
|
|
const formatOptions = FormatHelper._convertOptions(model.getOptions());
|
|
const errorCodes = context.markers.filter((m) => m.code).map((m) => m.code).map(Number);
|
|
const worker = await this._worker(resource);
|
|
if (model.isDisposed()) {
|
|
return;
|
|
}
|
|
const codeFixes = await worker.getCodeFixesAtPosition(
|
|
resource.toString(),
|
|
start,
|
|
end,
|
|
errorCodes,
|
|
formatOptions
|
|
);
|
|
if (!codeFixes || model.isDisposed()) {
|
|
return { actions: [], dispose: () => {
|
|
} };
|
|
}
|
|
const actions = codeFixes.filter((fix) => {
|
|
return fix.changes.filter((change) => change.isNewFile).length === 0;
|
|
}).map((fix) => {
|
|
return this._tsCodeFixActionToMonacoCodeAction(model, context, fix);
|
|
});
|
|
return {
|
|
actions,
|
|
dispose: () => {
|
|
}
|
|
};
|
|
}
|
|
_tsCodeFixActionToMonacoCodeAction(model, context, codeFix) {
|
|
const edits = [];
|
|
for (const change of codeFix.changes) {
|
|
for (const textChange of change.textChanges) {
|
|
edits.push({
|
|
resource: model.uri,
|
|
versionId: void 0,
|
|
textEdit: {
|
|
range: this._textSpanToRange(model, textChange.span),
|
|
text: textChange.newText
|
|
}
|
|
});
|
|
}
|
|
}
|
|
const action = {
|
|
title: codeFix.description,
|
|
edit: { edits },
|
|
diagnostics: context.markers,
|
|
kind: "quickfix"
|
|
};
|
|
return action;
|
|
}
|
|
};
|
|
var RenameAdapter = class extends Adapter {
|
|
constructor(_libFiles, worker) {
|
|
super(worker);
|
|
this._libFiles = _libFiles;
|
|
}
|
|
async provideRenameEdits(model, position, newName, token) {
|
|
const resource = model.uri;
|
|
const fileName = resource.toString();
|
|
const offset = model.getOffsetAt(position);
|
|
const worker = await this._worker(resource);
|
|
if (model.isDisposed()) {
|
|
return;
|
|
}
|
|
const renameInfo = await worker.getRenameInfo(fileName, offset, {
|
|
allowRenameOfImportPath: false
|
|
});
|
|
if (renameInfo.canRename === false) {
|
|
return {
|
|
edits: [],
|
|
rejectReason: renameInfo.localizedErrorMessage
|
|
};
|
|
}
|
|
if (renameInfo.fileToRename !== void 0) {
|
|
throw new Error("Renaming files is not supported.");
|
|
}
|
|
const renameLocations = await worker.findRenameLocations(
|
|
fileName,
|
|
offset,
|
|
/*strings*/
|
|
false,
|
|
/*comments*/
|
|
false,
|
|
/*prefixAndSuffix*/
|
|
false
|
|
);
|
|
if (!renameLocations || model.isDisposed()) {
|
|
return;
|
|
}
|
|
const edits = [];
|
|
for (const renameLocation of renameLocations) {
|
|
const model2 = this._libFiles.getOrCreateModel(renameLocation.fileName);
|
|
if (model2) {
|
|
edits.push({
|
|
resource: model2.uri,
|
|
versionId: void 0,
|
|
textEdit: {
|
|
range: this._textSpanToRange(model2, renameLocation.textSpan),
|
|
text: newName
|
|
}
|
|
});
|
|
} else {
|
|
throw new Error(`Unknown file ${renameLocation.fileName}.`);
|
|
}
|
|
}
|
|
return { edits };
|
|
}
|
|
};
|
|
var InlayHintsAdapter = class extends Adapter {
|
|
async provideInlayHints(model, range, token) {
|
|
const resource = model.uri;
|
|
const fileName = resource.toString();
|
|
const start = model.getOffsetAt({
|
|
lineNumber: range.startLineNumber,
|
|
column: range.startColumn
|
|
});
|
|
const end = model.getOffsetAt({
|
|
lineNumber: range.endLineNumber,
|
|
column: range.endColumn
|
|
});
|
|
const worker = await this._worker(resource);
|
|
if (model.isDisposed()) {
|
|
return null;
|
|
}
|
|
const tsHints = await worker.provideInlayHints(fileName, start, end);
|
|
const hints = tsHints.map((hint) => {
|
|
return {
|
|
...hint,
|
|
label: hint.text,
|
|
position: model.getPositionAt(hint.position),
|
|
kind: this._convertHintKind(hint.kind)
|
|
};
|
|
});
|
|
return { hints, dispose: () => {
|
|
} };
|
|
}
|
|
_convertHintKind(kind) {
|
|
switch (kind) {
|
|
case "Parameter":
|
|
return languages.InlayHintKind.Parameter;
|
|
case "Type":
|
|
return languages.InlayHintKind.Type;
|
|
default:
|
|
return languages.InlayHintKind.Type;
|
|
}
|
|
}
|
|
};
|
|
|
|
// node_modules/monaco-editor/esm/vs/language/typescript/tsMode.js
|
|
import "E:/Workspace/easysql/node_modules/monaco-editor/esm/vs/base/browser/ui/codicons/codicon/codicon.css";
|
|
import "E:/Workspace/easysql/node_modules/monaco-editor/esm/vs/base/browser/ui/codicons/codicon/codicon-modifiers.css";
|
|
var javaScriptWorker;
|
|
var typeScriptWorker;
|
|
function setupTypeScript(defaults) {
|
|
typeScriptWorker = setupMode(defaults, "typescript");
|
|
}
|
|
function setupJavaScript(defaults) {
|
|
javaScriptWorker = setupMode(defaults, "javascript");
|
|
}
|
|
function getJavaScriptWorker() {
|
|
return new Promise((resolve, reject) => {
|
|
if (!javaScriptWorker) {
|
|
return reject("JavaScript not registered!");
|
|
}
|
|
resolve(javaScriptWorker);
|
|
});
|
|
}
|
|
function getTypeScriptWorker() {
|
|
return new Promise((resolve, reject) => {
|
|
if (!typeScriptWorker) {
|
|
return reject("TypeScript not registered!");
|
|
}
|
|
resolve(typeScriptWorker);
|
|
});
|
|
}
|
|
function setupMode(defaults, modeId) {
|
|
const providers = [];
|
|
const client = new WorkerManager(modeId, defaults);
|
|
const worker = (...uris) => {
|
|
return client.getLanguageServiceWorker(...uris);
|
|
};
|
|
const libFiles = new LibFiles(worker);
|
|
function registerProviders() {
|
|
const { modeConfiguration } = defaults;
|
|
disposeAll(providers);
|
|
if (modeConfiguration.completionItems) {
|
|
providers.push(
|
|
languages.registerCompletionItemProvider(
|
|
modeId,
|
|
new SuggestAdapter(worker)
|
|
)
|
|
);
|
|
}
|
|
if (modeConfiguration.signatureHelp) {
|
|
providers.push(
|
|
languages.registerSignatureHelpProvider(
|
|
modeId,
|
|
new SignatureHelpAdapter(worker)
|
|
)
|
|
);
|
|
}
|
|
if (modeConfiguration.hovers) {
|
|
providers.push(
|
|
languages.registerHoverProvider(modeId, new QuickInfoAdapter(worker))
|
|
);
|
|
}
|
|
if (modeConfiguration.documentHighlights) {
|
|
providers.push(
|
|
languages.registerDocumentHighlightProvider(
|
|
modeId,
|
|
new DocumentHighlightAdapter(worker)
|
|
)
|
|
);
|
|
}
|
|
if (modeConfiguration.definitions) {
|
|
providers.push(
|
|
languages.registerDefinitionProvider(
|
|
modeId,
|
|
new DefinitionAdapter(libFiles, worker)
|
|
)
|
|
);
|
|
}
|
|
if (modeConfiguration.references) {
|
|
providers.push(
|
|
languages.registerReferenceProvider(
|
|
modeId,
|
|
new ReferenceAdapter(libFiles, worker)
|
|
)
|
|
);
|
|
}
|
|
if (modeConfiguration.documentSymbols) {
|
|
providers.push(
|
|
languages.registerDocumentSymbolProvider(
|
|
modeId,
|
|
new OutlineAdapter(worker)
|
|
)
|
|
);
|
|
}
|
|
if (modeConfiguration.rename) {
|
|
providers.push(
|
|
languages.registerRenameProvider(
|
|
modeId,
|
|
new RenameAdapter(libFiles, worker)
|
|
)
|
|
);
|
|
}
|
|
if (modeConfiguration.documentRangeFormattingEdits) {
|
|
providers.push(
|
|
languages.registerDocumentRangeFormattingEditProvider(
|
|
modeId,
|
|
new FormatAdapter(worker)
|
|
)
|
|
);
|
|
}
|
|
if (modeConfiguration.onTypeFormattingEdits) {
|
|
providers.push(
|
|
languages.registerOnTypeFormattingEditProvider(
|
|
modeId,
|
|
new FormatOnTypeAdapter(worker)
|
|
)
|
|
);
|
|
}
|
|
if (modeConfiguration.codeActions) {
|
|
providers.push(
|
|
languages.registerCodeActionProvider(modeId, new CodeActionAdaptor(worker))
|
|
);
|
|
}
|
|
if (modeConfiguration.inlayHints) {
|
|
providers.push(
|
|
languages.registerInlayHintsProvider(modeId, new InlayHintsAdapter(worker))
|
|
);
|
|
}
|
|
if (modeConfiguration.diagnostics) {
|
|
providers.push(new DiagnosticsAdapter(libFiles, defaults, modeId, worker));
|
|
}
|
|
}
|
|
registerProviders();
|
|
return worker;
|
|
}
|
|
function disposeAll(disposables) {
|
|
while (disposables.length) {
|
|
disposables.pop().dispose();
|
|
}
|
|
}
|
|
export {
|
|
Adapter,
|
|
CodeActionAdaptor,
|
|
DefinitionAdapter,
|
|
DiagnosticsAdapter,
|
|
DocumentHighlightAdapter,
|
|
FormatAdapter,
|
|
FormatHelper,
|
|
FormatOnTypeAdapter,
|
|
InlayHintsAdapter,
|
|
Kind,
|
|
LibFiles,
|
|
OutlineAdapter,
|
|
QuickInfoAdapter,
|
|
ReferenceAdapter,
|
|
RenameAdapter,
|
|
SignatureHelpAdapter,
|
|
SuggestAdapter,
|
|
WorkerManager,
|
|
flattenDiagnosticMessageText,
|
|
getJavaScriptWorker,
|
|
getTypeScriptWorker,
|
|
setupJavaScript,
|
|
setupTypeScript
|
|
};
|
|
//# sourceMappingURL=tsMode-HQJKWIQI.js.map
|