ryan/ry.kazcloud.dev
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Clean up dependencies
All checks were successful
Build and Push / build (push) Successful in 18s
Details

Browse Source
This commit is contained in:
Ryan Kazokas
2026-02-16 15:12:59 -05:00
parent d181f77fb2
commit 2f15523a55
14941 changed files with 0 additions and 2078483 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
node_modules/@volar/language-server/lib/features/configurations.d.ts generated vendored
View File

@@ -1,8 +0,0 @@
import * as vscode from 'vscode-languageserver';
import { LanguageServerState } from '../types';
export declare function register(server: LanguageServerState): {
get: <T>(section: string, scopeUri?: string) => Promise<T | undefined>;
onDidChange: (cb: vscode.NotificationHandler<vscode.DidChangeConfigurationParams>) => {
dispose(): void;
};
};

49
node_modules/@volar/language-server/lib/features/configurations.js generated vendored
View File

@@ -1,49 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.register = register;
const vscode = require("vscode-languageserver");
function register(server) {
const configurations = new Map();
const didChangeCallbacks = new Set();
server.onInitialized(() => {
server.connection.onDidChangeConfiguration(params => {
configurations.clear(); // TODO: clear only the configurations that changed
for (const cb of didChangeCallbacks) {
cb(params);
}
});
const didChangeConfiguration = server.initializeParams.capabilities.workspace?.didChangeConfiguration;
if (didChangeConfiguration?.dynamicRegistration) {
server.connection.client.register(vscode.DidChangeConfigurationNotification.type);
}
});
return {
get,
onDidChange,
};
function get(section, scopeUri) {
if (!server.initializeParams.capabilities.workspace?.configuration) {
return Promise.resolve(undefined);
}
const didChangeConfiguration = server.initializeParams.capabilities.workspace?.didChangeConfiguration;
if (!scopeUri && didChangeConfiguration) {
if (!configurations.has(section)) {
configurations.set(section, getConfigurationWorker(section, scopeUri));
}
return configurations.get(section);
}
return getConfigurationWorker(section, scopeUri);
}
function onDidChange(cb) {
didChangeCallbacks.add(cb);
return {
dispose() {
didChangeCallbacks.delete(cb);
},
};
}
async function getConfigurationWorker(section, scopeUri) {
return (await server.connection.workspace.getConfiguration({ scopeUri, section })) ?? undefined /* replace null to undefined */;
}
}
//# sourceMappingURL=configurations.js.map

2
node_modules/@volar/language-server/lib/features/editorFeatures.d.ts generated vendored
View File

@@ -1,2 +0,0 @@
import type { LanguageServerState } from '../types';
export declare function register(server: LanguageServerState): void;

186
node_modules/@volar/language-server/lib/features/editorFeatures.js generated vendored
View File

@@ -1,186 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.register = register;
const language_service_1 = require("@volar/language-service");
const vscode_uri_1 = require("vscode-uri");
const protocol_1 = require("../../protocol");
function register(server) {
server.onInitialize(() => {
const { project } = server;
const scriptVersions = (0, language_service_1.createUriMap)();
const scriptVersionSnapshots = new WeakSet();
server.connection.onRequest(protocol_1.GetMatchTsConfigRequest.type, async (params) => {
const uri = vscode_uri_1.URI.parse(params.uri);
const languageService = (await project.getLanguageService(uri));
const tsProject = languageService.context.project.typescript;
if (tsProject?.configFileName) {
const { configFileName, uriConverter } = tsProject;
return { uri: uriConverter.asUri(configFileName).toString() };
}
});
server.connection.onRequest(protocol_1.GetVirtualFileRequest.type, async (document) => {
const uri = vscode_uri_1.URI.parse(document.uri);
const languageService = (await project.getLanguageService(uri));
const documentUri = vscode_uri_1.URI.parse(document.uri);
const sourceScript = languageService.context.language.scripts.get(documentUri);
if (sourceScript?.generated) {
return prune(sourceScript.generated.root);
}
function prune(virtualCode) {
const uri = languageService.context.encodeEmbeddedDocumentUri(sourceScript.id, virtualCode.id);
let version = scriptVersions.get(uri) ?? 0;
if (!scriptVersionSnapshots.has(virtualCode.snapshot)) {
version++;
scriptVersions.set(uri, version);
scriptVersionSnapshots.add(virtualCode.snapshot);
}
return {
fileUri: sourceScript.id.toString(),
virtualCodeId: virtualCode.id,
languageId: virtualCode.languageId,
embeddedCodes: virtualCode.embeddedCodes?.map(prune) || [],
version,
disabled: languageService.context.disabledEmbeddedDocumentUris.has(uri),
};
}
});
server.connection.onRequest(protocol_1.GetVirtualCodeRequest.type, async (params) => {
const uri = vscode_uri_1.URI.parse(params.fileUri);
const languageService = (await project.getLanguageService(uri));
const sourceScript = languageService.context.language.scripts.get(vscode_uri_1.URI.parse(params.fileUri));
const virtualCode = sourceScript?.generated?.embeddedCodes.get(params.virtualCodeId);
if (virtualCode) {
const mappings = {};
for (const [sourceScript, map] of languageService.context.language.maps.forEach(virtualCode)) {
mappings[sourceScript.id.toString()] = map.mappings;
}
return {
content: virtualCode.snapshot.getText(0, virtualCode.snapshot.getLength()),
mappings,
};
}
});
server.connection.onNotification(protocol_1.WriteVirtualFilesNotification.type, async (params) => {
// webpack compatibility
const _require = eval('require');
const fs = _require('fs');
const uri = vscode_uri_1.URI.parse(params.uri);
const languageService = (await project.getLanguageService(uri));
const tsProject = languageService.context.project.typescript;
if (tsProject) {
const { languageServiceHost } = tsProject;
for (const fileName of languageServiceHost.getScriptFileNames()) {
if (!fs.existsSync(fileName)) {
// global virtual files
const snapshot = languageServiceHost.getScriptSnapshot(fileName);
if (snapshot) {
fs.writeFile(fileName, snapshot.getText(0, snapshot.getLength()), () => { });
}
}
else {
const uri = tsProject.uriConverter.asUri(fileName);
const sourceScript = languageService.context.language.scripts.get(uri);
if (sourceScript?.generated) {
const serviceScript = sourceScript.generated.languagePlugin.typescript?.getServiceScript(sourceScript.generated.root);
if (serviceScript) {
const { snapshot } = serviceScript.code;
fs.writeFile(fileName + serviceScript.extension, snapshot.getText(0, snapshot.getLength()), () => { });
}
if (sourceScript.generated.languagePlugin.typescript?.getExtraServiceScripts) {
for (const extraServiceScript of sourceScript.generated.languagePlugin.typescript.getExtraServiceScripts(uri.toString(), sourceScript.generated.root)) {
const { snapshot } = extraServiceScript.code;
fs.writeFile(fileName, snapshot.getText(0, snapshot.getLength()), () => { });
}
}
}
}
}
}
});
server.connection.onRequest(protocol_1.LoadedTSFilesMetaRequest.type, async () => {
const sourceFilesData = new Map();
for (const languageService of await project.getExistingLanguageServices()) {
const tsLanguageService = languageService.context.inject('typescript/languageService');
const program = tsLanguageService?.getProgram();
const tsProject = languageService.context.project.typescript;
if (program && tsProject) {
const { languageServiceHost, configFileName } = tsProject;
const projectName = configFileName ?? (languageServiceHost.getCurrentDirectory() + '(inferred)');
const sourceFiles = program.getSourceFiles() ?? [];
for (const sourceFile of sourceFiles) {
if (!sourceFilesData.has(sourceFile)) {
let nodes = 0;
sourceFile.forEachChild(function walk(node) {
nodes++;
node.forEachChild(walk);
});
sourceFilesData.set(sourceFile, {
projectNames: [],
size: nodes * 128,
});
}
sourceFilesData.get(sourceFile).projectNames.push(projectName);
}
;
}
}
const result = {
inputs: {},
outputs: {},
};
for (const [sourceFile, fileData] of sourceFilesData) {
let key = fileData.projectNames.sort().join(', ');
if (fileData.projectNames.length >= 2) {
key = `Shared in ${fileData.projectNames.length} projects (${key})`;
}
result.outputs[key] ??= {
imports: [],
exports: [],
entryPoint: '',
inputs: {},
bytes: 0,
};
result.outputs[key].inputs[sourceFile.fileName] = { bytesInOutput: fileData.size };
}
return result;
});
server.connection.onNotification(protocol_1.UpdateVirtualCodeStateNotification.type, async (params) => {
const uri = vscode_uri_1.URI.parse(params.fileUri);
const languageService = await project.getLanguageService(uri);
const virtualFileUri = languageService.context.encodeEmbeddedDocumentUri(vscode_uri_1.URI.parse(params.fileUri), params.virtualCodeId);
if (params.disabled) {
languageService.context.disabledEmbeddedDocumentUris.set(virtualFileUri, true);
}
else {
languageService.context.disabledEmbeddedDocumentUris.delete(virtualFileUri);
}
});
server.connection.onNotification(protocol_1.UpdateServicePluginStateNotification.type, async (params) => {
const uri = vscode_uri_1.URI.parse(params.uri);
const languageService = await project.getLanguageService(uri);
const plugin = languageService.context.plugins[params.serviceId][1];
if (params.disabled) {
languageService.context.disabledServicePlugins.add(plugin);
}
else {
languageService.context.disabledServicePlugins.delete(plugin);
}
});
server.connection.onRequest(protocol_1.GetServicePluginsRequest.type, async (params) => {
const uri = vscode_uri_1.URI.parse(params.uri);
const languageService = await project.getLanguageService(uri);
const result = [];
for (let pluginIndex = 0; pluginIndex < languageService.context.plugins.length; pluginIndex++) {
const plugin = languageService.context.plugins[pluginIndex];
result.push({
id: pluginIndex,
name: plugin[0].name,
disabled: languageService.context.disabledServicePlugins.has(plugin[1]),
features: Object.keys(plugin[1]),
});
}
return result;
});
});
}
//# sourceMappingURL=editorFeatures.js.map

8
node_modules/@volar/language-server/lib/features/fileSystem.d.ts generated vendored
View File

@@ -1,8 +0,0 @@
import { FileSystem } from '@volar/language-service';
import { URI } from 'vscode-uri';
export declare function register(documents: ReturnType<typeof import('./textDocuments').register>, fileWatcher: ReturnType<typeof import('./fileWatcher').register>): {
readFile(uri: URI): string | Thenable<string | undefined>;
stat(uri: URI): import("@volar/language-service").FileStat | Thenable<import("@volar/language-service").FileStat | undefined>;
readDirectory(uri: URI): import("@volar/language-service").ProviderResult<[string, import("@volar/language-service").FileType][]>;
install(scheme: string, provider: FileSystem): void;
};

61
node_modules/@volar/language-server/lib/features/fileSystem.js generated vendored
View File

@@ -1,61 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.register = register;
const language_service_1 = require("@volar/language-service");
const vscode = require("vscode-languageserver");
const vscode_uri_1 = require("vscode-uri");
function register(documents, fileWatcher) {
const providers = new Map();
const readFileCache = (0, language_service_1.createUriMap)();
const statCache = (0, language_service_1.createUriMap)();
const readDirectoryCache = (0, language_service_1.createUriMap)();
documents.onDidSave(({ document }) => {
const uri = vscode_uri_1.URI.parse(document.uri);
readFileCache.set(uri, document.getText());
statCache.delete(uri);
});
fileWatcher.onDidChangeWatchedFiles(({ changes }) => {
for (const change of changes) {
const changeUri = vscode_uri_1.URI.parse(change.uri);
const dir = vscode_uri_1.URI.parse(change.uri.substring(0, change.uri.lastIndexOf('/')));
if (change.type === vscode.FileChangeType.Deleted) {
readFileCache.set(changeUri, undefined);
statCache.set(changeUri, undefined);
readDirectoryCache.delete(dir);
}
else if (change.type === vscode.FileChangeType.Changed) {
readFileCache.delete(changeUri);
statCache.delete(changeUri);
}
else if (change.type === vscode.FileChangeType.Created) {
readFileCache.delete(changeUri);
statCache.delete(changeUri);
readDirectoryCache.delete(dir);
}
}
});
return {
readFile(uri) {
if (!readFileCache.has(uri)) {
readFileCache.set(uri, providers.get(uri.scheme)?.readFile(uri));
}
return readFileCache.get(uri);
},
stat(uri) {
if (!statCache.has(uri)) {
statCache.set(uri, providers.get(uri.scheme)?.stat(uri));
}
return statCache.get(uri);
},
readDirectory(uri) {
if (!readDirectoryCache.has(uri)) {
readDirectoryCache.set(uri, providers.get(uri.scheme)?.readDirectory(uri) ?? []);
}
return readDirectoryCache.get(uri);
},
install(scheme, provider) {
providers.set(scheme, provider);
},
};
}
//# sourceMappingURL=fileSystem.js.map

9
node_modules/@volar/language-server/lib/features/fileWatcher.d.ts generated vendored
View File

@@ -1,9 +0,0 @@
import { Disposable } from '@volar/language-service';
import * as vscode from 'vscode-languageserver';
import { LanguageServerState } from '../types';
export declare function register(server: LanguageServerState): {
watchFiles: (patterns: string[]) => Promise<Disposable>;
onDidChangeWatchedFiles: (cb: vscode.NotificationHandler<vscode.DidChangeWatchedFilesParams>) => {
dispose: () => void;
};
};

63
node_modules/@volar/language-server/lib/features/fileWatcher.js generated vendored
View File

@@ -1,63 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.register = register;
const vscode = require("vscode-languageserver");
function register(server) {
let watchFilesDisposableCounter = 0;
let watchFilesDisposable;
const didChangeWatchedFilesCallbacks = new Set();
return {
watchFiles,
onDidChangeWatchedFiles,
};
async function watchFiles(patterns) {
const disposables = [];
const didChangeWatchedFiles = server.initializeParams.capabilities.workspace?.didChangeWatchedFiles;
const fileOperations = server.initializeParams.capabilities.workspace?.fileOperations;
if (didChangeWatchedFiles) {
if (watchFilesDisposableCounter === 0) {
watchFilesDisposable = server.connection.onDidChangeWatchedFiles(e => {
for (const cb of didChangeWatchedFilesCallbacks) {
cb(e);
}
});
}
watchFilesDisposableCounter++;
disposables.push({
dispose() {
watchFilesDisposableCounter--;
if (watchFilesDisposableCounter === 0) {
watchFilesDisposable?.dispose();
}
}
});
}
if (didChangeWatchedFiles?.dynamicRegistration) {
disposables.push(await server.connection.client.register(vscode.DidChangeWatchedFilesNotification.type, {
watchers: patterns.map(pattern => ({ globPattern: pattern })),
}));
}
if (fileOperations?.dynamicRegistration && fileOperations.willRename) {
disposables.push(await server.connection.client.register(vscode.WillRenameFilesRequest.type, {
filters: patterns.map(pattern => ({ pattern: { glob: pattern } })),
}));
}
return {
dispose() {
for (const disposable of disposables) {
disposable.dispose();
}
disposables.length = 0;
},
};
}
function onDidChangeWatchedFiles(cb) {
didChangeWatchedFilesCallbacks.add(cb);
return {
dispose: () => {
didChangeWatchedFilesCallbacks.delete(cb);
},
};
}
}
//# sourceMappingURL=fileWatcher.js.map

4
node_modules/@volar/language-server/lib/features/languageFeatures.d.ts generated vendored
View File

@@ -1,4 +0,0 @@
import type { LanguageServerState } from '../types.js';
export declare function register(server: LanguageServerState, documents: ReturnType<typeof import('./textDocuments')['register']>, configurations: ReturnType<typeof import('./configurations')['register']>): {
requestRefresh: (clearDiagnostics: boolean) => Promise<void>;
};

768
node_modules/@volar/language-server/lib/features/languageFeatures.js generated vendored
View File

@@ -1,768 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.register = register;
const language_service_1 = require("@volar/language-service");
const vscode = require("vscode-languageserver");
const vscode_uri_1 = require("vscode-uri");
const protocol_1 = require("../../protocol");
const reportedCapabilities = new Set();
function register(server, documents, configurations) {
// Diagnostics support
let refreshReq = 0;
let updateDiagnosticsBatchReq = 0;
const refreshHandlers = [];
server.onInitialize(serverCapabilities => {
let lastCompleteUri;
let lastCompleteLs;
let lastCodeLensLs;
let lastCodeActionLs;
let lastCallHierarchyLs;
let lastTypeHierarchyLs;
let lastDocumentLinkLs;
let lastInlayHintLs;
let languageServiceToId = new WeakMap();
let currentLanguageServiceId = 0;
const languageServiceById = new Map();
const { languageServicePlugins, project, initializeParams } = server;
if (languageServicePlugins.some(({ capabilities }) => capabilities.selectionRangeProvider)) {
serverCapabilities.selectionRangeProvider = true;
server.connection.onSelectionRanges(async (params, token) => {
const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
return await worker(uri, token, languageService => {
return languageService.getSelectionRanges(uri, params.positions, token);
});
});
}
if (languageServicePlugins.some(({ capabilities }) => capabilities.foldingRangeProvider)) {
serverCapabilities.foldingRangeProvider = true;
server.connection.onFoldingRanges(async (params, token) => {
const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
return await worker(uri, token, languageService => {
return languageService.getFoldingRanges(uri, token);
});
});
}
if (languageServicePlugins.some(({ capabilities }) => capabilities.linkedEditingRangeProvider)) {
serverCapabilities.linkedEditingRangeProvider = true;
server.connection.languages.onLinkedEditingRange(async (params, token) => {
const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
return await worker(uri, token, languageService => {
return languageService.getLinkedEditingRanges(uri, params.position, token);
});
});
}
if (languageServicePlugins.some(({ capabilities }) => capabilities.colorProvider)) {
serverCapabilities.colorProvider = true;
server.connection.onDocumentColor(async (params, token) => {
const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
return await worker(uri, token, languageService => {
return languageService.getDocumentColors(uri, token);
});
});
server.connection.onColorPresentation(async (params, token) => {
const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
return await worker(uri, token, languageService => {
return languageService.getColorPresentations(uri, params.color, params.range, token);
});
});
}
if (languageServicePlugins.some(({ capabilities }) => capabilities.documentSymbolProvider)) {
serverCapabilities.documentSymbolProvider = true;
server.connection.onDocumentSymbol(async (params, token) => {
const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
return await worker(uri, token, languageService => {
return languageService.getDocumentSymbols(uri, token);
});
});
}
if (languageServicePlugins.some(({ capabilities }) => capabilities.documentFormattingProvider)) {
serverCapabilities.documentFormattingProvider = true;
serverCapabilities.documentRangeFormattingProvider = true;
server.connection.onDocumentFormatting(async (params, token) => {
const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
return await worker(uri, token, languageService => {
return languageService.getDocumentFormattingEdits(uri, params.options, undefined, undefined, token);
});
});
server.connection.onDocumentRangeFormatting(async (params, token) => {
const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
return await worker(uri, token, languageService => {
return languageService.getDocumentFormattingEdits(uri, params.options, params.range, undefined, token);
});
});
}
if (languageServicePlugins.some(({ capabilities }) => capabilities.referencesProvider)) {
serverCapabilities.referencesProvider = true;
server.connection.onReferences(async (params, token) => {
const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
return await worker(uri, token, languageService => {
return languageService.getReferences(uri, params.position, { includeDeclaration: true }, token);
});
});
}
if (languageServicePlugins.some(({ capabilities }) => capabilities.implementationProvider)) {
serverCapabilities.implementationProvider = true;
server.connection.onImplementation(async (params, token) => {
const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
return await worker(uri, token, async (languageService) => {
const definitions = await languageService.getImplementations(uri, params.position, token);
return handleDefinitions(initializeParams, 'implementation', definitions ?? []);
});
});
}
if (languageServicePlugins.some(({ capabilities }) => capabilities.declarationProvider)) {
serverCapabilities.declarationProvider = true;
server.connection.onDeclaration(async (params, token) => {
const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
return await worker(uri, token, async (languageService) => {
const definitions = await languageService.getDeclaration(uri, params.position, token);
return handleDefinitions(initializeParams, 'declaration', definitions ?? []);
});
});
}
if (languageServicePlugins.some(({ capabilities }) => capabilities.definitionProvider)) {
serverCapabilities.definitionProvider = true;
server.connection.onDefinition(async (params, token) => {
const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
return await worker(uri, token, async (languageService) => {
const definitions = await languageService.getDefinition(uri, params.position, token);
return handleDefinitions(initializeParams, 'definition', definitions ?? []);
});
});
}
if (languageServicePlugins.some(({ capabilities }) => capabilities.typeDefinitionProvider)) {
serverCapabilities.typeDefinitionProvider = true;
server.connection.onTypeDefinition(async (params, token) => {
const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
return await worker(uri, token, async (languageService) => {
const definitions = await languageService.getTypeDefinition(uri, params.position, token);
return handleDefinitions(initializeParams, 'typeDefinition', definitions ?? []);
});
});
}
if (languageServicePlugins.some(({ capabilities }) => capabilities.callHierarchyProvider)) {
serverCapabilities.callHierarchyProvider = true;
server.connection.languages.callHierarchy.onPrepare(async (params, token) => {
const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
return await worker(uri, token, languageService => {
lastCallHierarchyLs = languageService;
return languageService.getCallHierarchyItems(uri, params.position, token);
}) ?? [];
});
server.connection.languages.callHierarchy.onIncomingCalls(async (params, token) => {
return await lastCallHierarchyLs?.getCallHierarchyIncomingCalls(params.item, token) ?? [];
});
server.connection.languages.callHierarchy.onOutgoingCalls(async (params, token) => {
return await lastCallHierarchyLs?.getCallHierarchyOutgoingCalls(params.item, token) ?? [];
});
}
if (languageServicePlugins.some(({ capabilities }) => capabilities.typeHierarchyProvider)) {
serverCapabilities.typeHierarchyProvider = true;
server.connection.languages.typeHierarchy.onPrepare(async (params, token) => {
const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
return await worker(uri, token, languageService => {
lastTypeHierarchyLs = languageService;
return languageService.getTypeHierarchyItems(uri, params.position, token);
}) ?? [];
});
server.connection.languages.typeHierarchy.onSupertypes(async (params, token) => {
return await lastTypeHierarchyLs?.getTypeHierarchySupertypes(params.item, token) ?? [];
});
server.connection.languages.typeHierarchy.onSubtypes(async (params, token) => {
return await lastTypeHierarchyLs?.getTypeHierarchySubtypes(params.item, token) ?? [];
});
}
if (languageServicePlugins.some(({ capabilities }) => capabilities.hoverProvider)) {
serverCapabilities.hoverProvider = true;
server.connection.onHover(async (params, token) => {
const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
return await worker(uri, token, languageService => {
return languageService.getHover(uri, params.position, token);
});
});
}
if (languageServicePlugins.some(({ capabilities }) => capabilities.documentHighlightProvider)) {
serverCapabilities.documentHighlightProvider = true;
server.connection.onDocumentHighlight(async (params, token) => {
const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
return await worker(uri, token, languageService => {
return languageService.getDocumentHighlights(uri, params.position, token);
});
});
}
if (languageServicePlugins.some(({ capabilities }) => capabilities.workspaceSymbolProvider)) {
serverCapabilities.workspaceSymbolProvider = {};
server.connection.onWorkspaceSymbol(async (params, token) => {
let languageServices = await project.getExistingLanguageServices();
if (!languageServices.length) {
for (const document of documents.all()) {
await project.getLanguageService(vscode_uri_1.URI.parse(document.uri));
}
languageServices = await project.getExistingLanguageServices();
}
const symbols = [];
for (const languageService of languageServices) {
if (token.isCancellationRequested) {
return;
}
let languageServiceId = languageServiceToId.get(languageService);
if (languageServiceId === undefined) {
languageServiceId = currentLanguageServiceId;
languageServiceToId.set(languageService, languageServiceId);
languageServiceById.set(languageServiceId, new WeakRef(languageService));
}
const languageServiceResult = await languageService.getWorkspaceSymbols(params.query, token);
for (const symbol of languageServiceResult) {
symbol.data = {
languageServiceId,
originalData: symbol.data,
};
}
symbols.push(...await languageService.getWorkspaceSymbols(params.query, token));
}
return symbols;
});
if (languageServicePlugins.some(({ capabilities }) => capabilities.workspaceSymbolProvider?.resolveProvider)) {
serverCapabilities.workspaceSymbolProvider.resolveProvider = true;
server.connection.onWorkspaceSymbolResolve(async (symbol, token) => {
const languageServiceId = symbol.data?.languageServiceId;
const languageService = languageServiceById.get(languageServiceId)?.deref();
if (!languageService) {
return symbol;
}
symbol.data = symbol.data?.originalData;
return await languageService.resolveWorkspaceSymbol?.(symbol, token);
});
}
}
if (languageServicePlugins.some(({ capabilities }) => capabilities.renameProvider)) {
serverCapabilities.renameProvider = {};
server.connection.onRenameRequest(async (params, token) => {
const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
return await worker(uri, token, languageService => {
return languageService.getRenameEdits(uri, params.position, params.newName, token);
});
});
if (languageServicePlugins.some(({ capabilities }) => capabilities.renameProvider?.prepareProvider)) {
serverCapabilities.renameProvider.prepareProvider = true;
server.connection.onPrepareRename(async (params, token) => {
const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
return await worker(uri, token, async (languageService) => {
const result = await languageService.getRenameRange(uri, params.position, token);
if (result && 'message' in result) {
return new vscode.ResponseError(0, result.message);
}
return result;
});
});
}
}
if (languageServicePlugins.some(({ capabilities }) => capabilities.documentLinkProvider)) {
serverCapabilities.documentLinkProvider = {};
server.connection.onDocumentLinks(async (params, token) => {
const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
return await worker(uri, token, languageService => {
lastDocumentLinkLs = languageService;
return languageService.getDocumentLinks(uri, token);
});
});
if (languageServicePlugins.some(({ capabilities }) => capabilities.documentLinkProvider?.resolveProvider)) {
serverCapabilities.documentLinkProvider.resolveProvider = true;
server.connection.onDocumentLinkResolve(async (link, token) => {
return await lastDocumentLinkLs?.resolveDocumentLink(link, token);
});
}
}
if (languageServicePlugins.some(({ capabilities }) => capabilities.codeLensProvider)) {
serverCapabilities.codeLensProvider = {};
server.connection.onCodeLens(async (params, token) => {
const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
return await worker(uri, token, languageService => {
lastCodeLensLs = languageService;
return languageService.getCodeLenses(uri, token);
});
});
if (languageServicePlugins.some(({ capabilities }) => capabilities.codeLensProvider?.resolveProvider)) {
serverCapabilities.codeLensProvider.resolveProvider = true;
server.connection.onCodeLensResolve(async (codeLens, token) => {
return await lastCodeLensLs?.resolveCodeLens(codeLens, token) ?? codeLens;
});
}
}
if (languageServicePlugins.some(({ capabilities }) => capabilities.inlayHintProvider)) {
serverCapabilities.inlayHintProvider = {};
server.connection.languages.inlayHint.on(async (params, token) => {
const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
return await worker(uri, token, languageService => {
lastInlayHintLs = languageService;
return languageService.getInlayHints(uri, params.range, token);
});
});
if (languageServicePlugins.some(({ capabilities }) => capabilities.inlayHintProvider?.resolveProvider)) {
serverCapabilities.inlayHintProvider.resolveProvider = true;
server.connection.languages.inlayHint.resolve(async (hint, token) => {
return await lastInlayHintLs?.resolveInlayHint(hint, token) ?? hint;
});
}
refreshHandlers.push(() => {
if (initializeParams.capabilities.workspace?.inlayHint?.refreshSupport) {
server.connection.languages.inlayHint.refresh();
}
else {
wranCapabilitiesNotSupported('workspace.inlayHint.refreshSupport');
}
});
}
if (languageServicePlugins.some(({ capabilities }) => capabilities.signatureHelpProvider)) {
serverCapabilities.signatureHelpProvider = {
triggerCharacters: [...new Set(languageServicePlugins.map(({ capabilities }) => capabilities.signatureHelpProvider?.triggerCharacters ?? []).flat())],
retriggerCharacters: [...new Set(languageServicePlugins.map(({ capabilities }) => capabilities.signatureHelpProvider?.retriggerCharacters ?? []).flat())],
};
server.connection.onSignatureHelp(async (params, token) => {
const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
return await worker(uri, token, languageService => {
return languageService.getSignatureHelp(uri, params.position, params.context, token);
});
});
}
if (languageServicePlugins.some(({ capabilities }) => capabilities.completionProvider)) {
serverCapabilities.completionProvider = {
triggerCharacters: [...new Set(languageServicePlugins.map(({ capabilities }) => capabilities.completionProvider?.triggerCharacters ?? []).flat())],
};
server.connection.onCompletion(async (params, token) => {
const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
return await worker(uri, token, async (languageService) => {
lastCompleteUri = params.textDocument.uri;
lastCompleteLs = languageService;
const list = await languageService.getCompletionItems(uri, params.position, params.context, token);
list.items = list.items.map(item => handleCompletionItem(initializeParams, item));
return list;
});
});
if (languageServicePlugins.some(({ capabilities }) => capabilities.completionProvider?.resolveProvider)) {
serverCapabilities.completionProvider.resolveProvider = true;
server.connection.onCompletionResolve(async (item, token) => {
if (lastCompleteUri && lastCompleteLs) {
item = await lastCompleteLs.resolveCompletionItem(item, token);
item = handleCompletionItem(initializeParams, item);
}
return item;
});
}
}
if (languageServicePlugins.some(({ capabilities }) => capabilities.semanticTokensProvider)) {
serverCapabilities.semanticTokensProvider = {
range: true,
full: false, // TODO: enable it after testing
legend: {
tokenTypes: [...new Set(languageServicePlugins.map(({ capabilities }) => capabilities.semanticTokensProvider?.legend?.tokenTypes ?? []).flat())],
tokenModifiers: [...new Set(languageServicePlugins.map(({ capabilities }) => capabilities.semanticTokensProvider?.legend?.tokenModifiers ?? []).flat())],
},
};
server.connection.languages.semanticTokens.on(async (params, token, _, resultProgress) => {
const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
return await worker(uri, token, async (languageService) => {
return await languageService?.getSemanticTokens(uri, undefined, serverCapabilities.semanticTokensProvider.legend, tokens => resultProgress?.report(tokens), token);
}) ?? { data: [] };
});
server.connection.languages.semanticTokens.onRange(async (params, token, _, resultProgress) => {
const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
return await worker(uri, token, async (languageService) => {
return await languageService?.getSemanticTokens(uri, params.range, serverCapabilities.semanticTokensProvider.legend, tokens => resultProgress?.report(tokens), token);
}) ?? { data: [] };
});
refreshHandlers.push(() => {
if (initializeParams.capabilities.workspace?.semanticTokens?.refreshSupport) {
server.connection.languages.semanticTokens.refresh();
}
else {
wranCapabilitiesNotSupported('workspace.semanticTokens.refreshSupport');
}
});
}
if (languageServicePlugins.some(({ capabilities }) => capabilities.codeActionProvider)) {
serverCapabilities.codeActionProvider = {
codeActionKinds: languageServicePlugins.some(({ capabilities }) => capabilities.codeActionProvider?.codeActionKinds)
? [...new Set(languageServicePlugins.map(({ capabilities }) => capabilities.codeActionProvider?.codeActionKinds ?? []).flat())]
: undefined,
};
server.connection.onCodeAction(async (params, token) => {
const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
return await worker(uri, token, async (languageService) => {
lastCodeActionLs = languageService;
let codeActions = await languageService.getCodeActions(uri, params.range, params.context, token) ?? [];
for (const codeAction of codeActions) {
if (codeAction.data && typeof codeAction.data === 'object') {
codeAction.data.uri = params.textDocument.uri;
}
else {
codeAction.data = { uri: params.textDocument.uri };
}
}
if (!initializeParams.capabilities.textDocument?.codeAction?.disabledSupport
&& codeActions.some(codeAction => !codeAction.disabled)) {
codeActions = codeActions.filter(codeAction => !codeAction.disabled);
wranCapabilitiesNotSupported('textDocument.codeAction.disabledSupport');
}
return codeActions;
});
});
if (languageServicePlugins.some(({ capabilities }) => capabilities.codeActionProvider?.resolveProvider)) {
serverCapabilities.codeActionProvider.resolveProvider = true;
server.connection.onCodeActionResolve(async (codeAction, token) => {
return await lastCodeActionLs?.resolveCodeAction(codeAction, token) ?? codeAction;
});
}
}
if (languageServicePlugins.some(({ capabilities }) => capabilities.documentOnTypeFormattingProvider)) {
serverCapabilities.documentOnTypeFormattingProvider = {
firstTriggerCharacter: [...new Set(languageServicePlugins.map(({ capabilities }) => capabilities.documentOnTypeFormattingProvider?.triggerCharacters ?? []).flat())][0],
moreTriggerCharacter: [...new Set(languageServicePlugins.map(({ capabilities }) => capabilities.documentOnTypeFormattingProvider?.triggerCharacters ?? []).flat())].slice(1),
};
server.connection.onDocumentOnTypeFormatting(async (params, token) => {
const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
return await worker(uri, token, languageService => {
return languageService.getDocumentFormattingEdits(uri, params.options, undefined, params, token);
});
});
}
if (languageServicePlugins.some(({ capabilities }) => capabilities.executeCommandProvider)) {
serverCapabilities.executeCommandProvider = {
commands: [...new Set(languageServicePlugins.map(({ capabilities }) => capabilities.executeCommandProvider?.commands ?? []).flat())],
};
server.connection.onExecuteCommand(async (params, token) => {
let languageServices = await project.getExistingLanguageServices();
if (!languageServices.length) {
for (const document of documents.all()) {
await project.getLanguageService(vscode_uri_1.URI.parse(document.uri));
}
languageServices = await project.getExistingLanguageServices();
}
for (const languageService of languageServices) {
if (languageService.executeCommand && languageService.commands.includes(params.command)) {
try {
return await languageService.executeCommand(params.command, params.arguments ?? [], token);
}
catch { }
}
}
});
}
if (languageServicePlugins.some(({ capabilities }) => capabilities.monikerProvider)) {
serverCapabilities.monikerProvider = true;
server.connection.languages.moniker.on(async (params, token) => {
const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
return await worker(uri, token, languageService => {
return languageService.getMoniker(uri, params.position, token);
}) ?? null;
});
}
if (languageServicePlugins.some(({ capabilities }) => capabilities.inlineValueProvider)) {
serverCapabilities.inlineValueProvider = true;
server.connection.languages.inlineValue.on(async (params, token) => {
const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
return await worker(uri, token, languageService => {
return languageService.getInlineValue(uri, params.range, params.context, token);
});
});
refreshHandlers.push(() => {
if (initializeParams.capabilities.workspace?.inlineValue?.refreshSupport) {
server.connection.languages.inlineValue.refresh();
}
else {
wranCapabilitiesNotSupported('workspace.inlineValue.refreshSupport');
}
});
}
if (languageServicePlugins.some(({ capabilities }) => capabilities.autoInsertionProvider)) {
const triggerCharacterToConfigurationSections = new Map();
const tryAdd = (char, section) => {
let sectionSet = triggerCharacterToConfigurationSections.get(char);
if (!sectionSet) {
triggerCharacterToConfigurationSections.set(char, sectionSet = new Set());
}
if (section) {
sectionSet.add(section);
}
};
for (const { capabilities } of languageServicePlugins) {
if (capabilities.autoInsertionProvider) {
const { triggerCharacters, configurationSections } = capabilities.autoInsertionProvider;
if (configurationSections) {
if (configurationSections.length !== triggerCharacters.length) {
throw new Error('configurationSections.length !== triggerCharacters.length');
}
for (let i = 0; i < configurationSections.length; i++) {
tryAdd(triggerCharacters[i], configurationSections[i]);
}
}
else {
for (const char of triggerCharacters) {
tryAdd(char);
}
}
}
}
serverCapabilities.experimental ??= {};
serverCapabilities.experimental.autoInsertionProvider = {
triggerCharacters: [],
configurationSections: [],
};
for (const [char, sections] of triggerCharacterToConfigurationSections) {
if (sections.size) {
serverCapabilities.experimental.autoInsertionProvider.triggerCharacters.push(char);
serverCapabilities.experimental.autoInsertionProvider.configurationSections.push([...sections]);
}
else {
serverCapabilities.experimental.autoInsertionProvider.triggerCharacters.push(char);
serverCapabilities.experimental.autoInsertionProvider.configurationSections.push(null);
}
}
server.connection.onRequest(protocol_1.AutoInsertRequest.type, async (params, token) => {
const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
return await worker(uri, token, languageService => {
return languageService.getAutoInsertSnippet(uri, params.selection, params.change, token);
});
});
}
if (languageServicePlugins.some(({ capabilities }) => capabilities.fileRenameEditsProvider)) {
serverCapabilities.experimental ??= {};
serverCapabilities.experimental.fileRenameEditsProvider = true;
server.connection.workspace.onWillRenameFiles(async (params, token) => {
const _edits = await Promise.all(params.files.map(async (file) => {
const oldUri = vscode_uri_1.URI.parse(file.oldUri);
const newUri = vscode_uri_1.URI.parse(file.newUri);
return await worker(oldUri, token, languageService => {
return languageService.getFileRenameEdits(oldUri, newUri, token) ?? null;
}) ?? null;
}));
const edits = _edits.filter((edit) => !!edit);
if (edits.length) {
(0, language_service_1.mergeWorkspaceEdits)(edits[0], ...edits.slice(1));
return edits[0];
}
return null;
});
}
if (languageServicePlugins.some(({ capabilities }) => capabilities.fileReferencesProvider)) {
serverCapabilities.experimental ??= {};
serverCapabilities.experimental.fileReferencesProvider = true;
server.connection.onRequest(protocol_1.FindFileReferenceRequest.type, async (params, token) => {
const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
return await worker(uri, token, languageService => {
return languageService.getFileReferences(uri, token);
});
});
}
if (languageServicePlugins.some(({ capabilities }) => capabilities.documentDropEditsProvider)) {
serverCapabilities.experimental ??= {};
serverCapabilities.experimental.documentDropEditsProvider = true;
server.connection.onRequest(protocol_1.DocumentDropRequest.type, async ({ textDocument, position, dataTransfer }, token) => {
const dataTransferMap = new Map();
for (const item of dataTransfer) {
dataTransferMap.set(item.mimeType, {
value: item.value,
asString() {
return server.connection.sendRequest(protocol_1.DocumentDrop_DataTransferItemAsStringRequest.type, { mimeType: item.mimeType });
},
asFile() {
if (item.file) {
return {
name: item.file.name,
uri: item.file.uri,
data() {
return server.connection.sendRequest(protocol_1.DocumentDrop_DataTransferItemFileDataRequest.type, { mimeType: item.mimeType });
},
};
}
},
});
}
const uri = vscode_uri_1.URI.parse(textDocument.uri);
const languageService = (await project.getLanguageService(uri));
return languageService.getDocumentDropEdits(uri, position, dataTransferMap, token);
});
}
// Diagnostic support
const supportsDiagnosticPull = !!initializeParams.capabilities.workspace?.diagnostics;
const diagnosticProvider = languageServicePlugins.some(({ capabilities }) => !!capabilities.diagnosticProvider);
const interFileDependencies = languageServicePlugins.some(({ capabilities }) => capabilities.diagnosticProvider?.interFileDependencies);
const workspaceDiagnostics = languageServicePlugins.some(({ capabilities }) => capabilities.diagnosticProvider?.workspaceDiagnostics);
if (diagnosticProvider) {
if (supportsDiagnosticPull && !interFileDependencies) {
serverCapabilities.diagnosticProvider = {
// Unreliable, see https://github.com/microsoft/vscode-languageserver-node/issues/848#issuecomment-2189521060
interFileDependencies: false,
workspaceDiagnostics,
};
refreshHandlers.push(() => {
if (initializeParams.capabilities.workspace?.diagnostics?.refreshSupport) {
server.connection.languages.diagnostics.refresh();
}
else {
wranCapabilitiesNotSupported('workspace.diagnostics.refreshSupport');
}
});
}
else {
documents.onDidChangeContent(({ document }) => {
const changedDocument = documents.get(vscode_uri_1.URI.parse(document.uri));
if (!changedDocument) {
return;
}
if (interFileDependencies) {
const remainingDocuments = [...documents.all()].filter(doc => doc !== changedDocument);
updateDiagnosticsBatch(project, [changedDocument, ...remainingDocuments]);
}
else {
updateDiagnosticsBatch(project, [changedDocument]);
}
});
documents.onDidClose(({ document }) => {
server.connection.sendDiagnostics({ uri: document.uri, diagnostics: [] });
});
configurations.onDidChange(() => requestRefresh(false));
refreshHandlers.push(async (clearDiagnostics) => {
if (clearDiagnostics) {
for (const document of documents.all()) {
server.connection.sendDiagnostics({ uri: document.uri, diagnostics: [] });
}
}
await updateDiagnosticsBatch(project, [...documents.all()]);
});
}
server.connection.languages.diagnostics.on(async (params, token, _workDoneProgressReporter, resultProgressReporter) => {
const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
const result = await worker(uri, token, languageService => {
return languageService.getDiagnostics(uri, errors => {
// resultProgressReporter is undefined in vscode
resultProgressReporter?.report({
relatedDocuments: {
[params.textDocument.uri]: {
kind: vscode.DocumentDiagnosticReportKind.Full,
items: errors,
},
},
});
}, token);
});
return {
kind: vscode.DocumentDiagnosticReportKind.Full,
items: result ?? [],
};
});
}
if (workspaceDiagnostics) {
server.connection.languages.diagnostics.onWorkspace(async (_params, token) => {
let languageServices = await project.getExistingLanguageServices();
if (!languageServices.length) {
for (const document of documents.all()) {
await project.getLanguageService(vscode_uri_1.URI.parse(document.uri));
}
languageServices = await project.getExistingLanguageServices();
}
const items = [];
for (const languageService of languageServices) {
if (token.isCancellationRequested) {
break;
}
const result = await languageService.getWorkspaceDiagnostics(token);
items.push(...result);
}
return { items };
});
}
});
return { requestRefresh };
async function requestRefresh(clearDiagnostics) {
const req = ++refreshReq;
const delay = 250;
await sleep(delay);
if (req !== refreshReq) {
return;
}
for (const handler of refreshHandlers) {
handler(clearDiagnostics);
}
}
async function updateDiagnosticsBatch(project, documents) {
const req = ++updateDiagnosticsBatchReq;
const delay = 250;
const token = {
get isCancellationRequested() {
return req !== updateDiagnosticsBatchReq;
},
onCancellationRequested: vscode.Event.None,
};
for (const doc of documents) {
await sleep(delay);
if (token.isCancellationRequested) {
break;
}
await updateDiagnostics(project, vscode_uri_1.URI.parse(doc.uri), doc.version, token);
}
}
async function updateDiagnostics(project, uri, version, token) {
const languageService = await project.getLanguageService(uri);
const diagnostics = await languageService.getDiagnostics(uri, diagnostics => server.connection.sendDiagnostics({ uri: uri.toString(), diagnostics, version }), token);
if (!token.isCancellationRequested) {
server.connection.sendDiagnostics({ uri: uri.toString(), diagnostics, version });
}
}
function worker(uri, token, cb) {
return new Promise(resolve => {
server.env.timer.setImmediate(async () => {
if (token.isCancellationRequested) {
resolve(undefined);
return;
}
const languageService = (await server.project.getLanguageService((0, language_service_1.decodeEmbeddedDocumentUri)(uri)?.[0] ?? uri));
const result = await cb(languageService);
if (token.isCancellationRequested) {
resolve(undefined);
return;
}
resolve(result);
});
});
}
function handleCompletionItem(initializeParams, item) {
const snippetSupport = initializeParams.capabilities.textDocument?.completion?.completionItem?.snippetSupport ?? false;
const insertReplaceSupport = initializeParams.capabilities.textDocument?.completion?.completionItem?.insertReplaceSupport ?? false;
if (!snippetSupport && item.insertTextFormat === vscode.InsertTextFormat.Snippet) {
item.insertTextFormat = vscode.InsertTextFormat.PlainText;
if (item.insertText) {
item.insertText = item.insertText.replace(/\$\d+/g, '');
item.insertText = item.insertText.replace(/\${\d+:([^}]*)}/g, '');
}
wranCapabilitiesNotSupported('textDocument.completion.completionItem.snippetSupport');
}
if (!insertReplaceSupport && item.textEdit && vscode.InsertReplaceEdit.is(item.textEdit)) {
item.textEdit = vscode.TextEdit.replace(item.textEdit.insert, item.textEdit.newText);
wranCapabilitiesNotSupported('textDocument.completion.completionItem.insertReplaceSupport');
}
return item;
}
function handleDefinitions(initializeParams, type, items) {
const linkSupport = initializeParams.capabilities.textDocument?.[type]?.linkSupport ?? false;
if (!linkSupport) {
wranCapabilitiesNotSupported(`textDocument.${type}.linkSupport`);
return items.map(item => ({
uri: item.targetUri,
range: item.targetRange,
}));
}
return items;
}
}
function wranCapabilitiesNotSupported(path) {
if (reportedCapabilities.has(path)) {
return;
}
reportedCapabilities.add(path);
console.warn(`${path} is not supported by the client but could be used by the server.`);
}
function sleep(ms) {
return new Promise(resolve => setTimeout(resolve, ms));
}
//# sourceMappingURL=languageFeatures.js.map

12
node_modules/@volar/language-server/lib/features/textDocuments.d.ts generated vendored
View File

@@ -1,12 +0,0 @@
import * as vscode from 'vscode-languageserver';
import { URI } from 'vscode-uri';
import { LanguageServerState } from '../types';
import { SnapshotDocument } from '../utils/snapshotDocument';
export declare function register(server: LanguageServerState): {
all: () => SnapshotDocument[];
onDidChangeContent: vscode.Event<vscode.TextDocumentChangeEvent<SnapshotDocument>>;
onDidOpen: vscode.Event<vscode.TextDocumentChangeEvent<SnapshotDocument>>;
onDidClose: vscode.Event<vscode.TextDocumentChangeEvent<SnapshotDocument>>;
onDidSave: vscode.Event<vscode.TextDocumentChangeEvent<SnapshotDocument>>;
get(uri: URI): SnapshotDocument | undefined;
};

54
node_modules/@volar/language-server/lib/features/textDocuments.js generated vendored
View File

@@ -1,54 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.register = register;
const vscode = require("vscode-languageserver");
const vscode_uri_1 = require("vscode-uri");
const snapshotDocument_1 = require("../utils/snapshotDocument");
function register(server) {
const syncedDocumentParsedUriToUri = new Map();
const documentsCache = new Map();
const documents = new vscode.TextDocuments({
create(uri, languageId, version, text) {
const cache = documentsCache.get(uri)?.deref();
if (cache && cache.languageId === languageId && cache.version === version && cache.getText() === text) {
return cache;
}
const document = new snapshotDocument_1.SnapshotDocument(uri, languageId, version, text);
documentsCache.set(uri, new WeakRef(document));
return document;
},
update(snapshot, contentChanges, version) {
snapshot.update(contentChanges, version);
return snapshot;
},
});
documents.listen(server.connection);
documents.onDidOpen(({ document }) => {
const parsedUri = vscode_uri_1.URI.parse(document.uri);
syncedDocumentParsedUriToUri.set(parsedUri.toString(), document.uri);
});
documents.onDidClose(({ document }) => {
const parsedUri = vscode_uri_1.URI.parse(document.uri);
syncedDocumentParsedUriToUri.delete(parsedUri.toString());
});
server.onInitialize(serverCapabilities => {
serverCapabilities.textDocumentSync = vscode.TextDocumentSyncKind.Incremental;
});
return {
all: documents.all.bind(documents),
onDidChangeContent: documents.onDidChangeContent.bind(documents),
onDidOpen: documents.onDidOpen.bind(documents),
onDidClose: documents.onDidClose.bind(documents),
onDidSave: documents.onDidSave.bind(documents),
get(uri) {
return documents.get(getSyncedDocumentKey(uri) ?? uri.toString());
},
};
function getSyncedDocumentKey(uri) {
const originalUri = syncedDocumentParsedUriToUri.get(uri.toString());
if (originalUri) {
return originalUri;
}
}
}
//# sourceMappingURL=textDocuments.js.map

10
node_modules/@volar/language-server/lib/features/workspaceFolders.d.ts generated vendored
View File

@@ -1,10 +0,0 @@
import * as vscode from 'vscode-languageserver';
import { URI } from 'vscode-uri';
import { LanguageServerState } from '../types';
export declare function register(server: LanguageServerState): {
readonly all: URI[];
has(uri: URI): boolean;
onDidChange: (cb: vscode.NotificationHandler<vscode.WorkspaceFoldersChangeEvent>) => {
dispose(): void;
};
};

67
node_modules/@volar/language-server/lib/features/workspaceFolders.js generated vendored
View File

@@ -1,67 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.register = register;
const language_service_1 = require("@volar/language-service");
const vscode_uri_1 = require("vscode-uri");
function register(server) {
const folders = (0, language_service_1.createUriMap)();
const didChangeCallbacks = new Set();
server.onInitialize(serverCapabilities => {
const { initializeParams } = server;
if (initializeParams.workspaceFolders?.length) {
for (const folder of initializeParams.workspaceFolders) {
folders.set(vscode_uri_1.URI.parse(folder.uri), true);
}
}
else if (initializeParams.rootUri) {
folders.set(vscode_uri_1.URI.parse(initializeParams.rootUri), true);
}
else if (initializeParams.rootPath) {
folders.set(vscode_uri_1.URI.file(initializeParams.rootPath), true);
}
// #18
serverCapabilities.workspace ??= {};
serverCapabilities.workspace.workspaceFolders = {
supported: true,
changeNotifications: true,
};
});
server.onInitialized(() => {
if (server.initializeParams.capabilities.workspace?.workspaceFolders) {
server.connection.workspace.onDidChangeWorkspaceFolders(e => {
e.added = e.added.filter(folder => !folders.has(vscode_uri_1.URI.parse(folder.uri)));
e.removed = e.removed.filter(folder => folders.has(vscode_uri_1.URI.parse(folder.uri)));
if (e.added.length || e.removed.length) {
for (const folder of e.added) {
folders.set(vscode_uri_1.URI.parse(folder.uri), true);
}
for (const folder of e.removed) {
folders.delete(vscode_uri_1.URI.parse(folder.uri));
}
server.project.reload();
for (const cb of didChangeCallbacks) {
cb(e);
}
}
});
}
});
return {
get all() {
return [...folders.keys()];
},
has(uri) {
return folders.has(uri);
},
onDidChange,
};
function onDidChange(cb) {
didChangeCallbacks.add(cb);
return {
dispose() {
didChangeCallbacks.delete(cb);
},
};
}
}
//# sourceMappingURL=workspaceFolders.js.map