@spyglassmc/language-server 0.1.0

package/README.md

@@ -0,0 +1,75 @@
+# `@spyglassmc/language-server`
+
+![banner](https://raw.githubusercontent.com/SpyglassMC/logo/main/banner.png)
+
+[![npm](https://img.shields.io/npm/v/datapack-language-server.svg?logo=npm&style=flat-square)](https://npmjs.com/package/datapack-language-server)
+
+This is a [language server][lsp] wrapped around some other Spyglass packages.
+
+- [Installation](#installation)
+	- [For Use](#for-use)
+		- [Sublime Text 3](#sublime-text-3)
+		- [Visual Studio Code](#visual-studio-code)
+	- [For Developers](#for-developers)
+
+# Installation
+
+## For Use
+
+### Sublime Text 3
+
+1. Install [Node.js](https://nodejs.org/) if you haven't.
+2. Execute `npm i -g @spyglassmc/language-server` in your command line to install the language server.
+3. Install [Package Control](https://packagecontrol.io/installation) if you haven't.
+4. Install [Arcensoth](https://github.com/Arcensoth)'s language-mcfunction package by following the [instructions](https://github.com/Arcensoth/language-mcfunction#installing-the-sublimetext-package) if you haven't.
+5. Install [LSP](https://packagecontrol.io/packages/LSP) package.
+6. Open the Command Palette and select `Preferences: LSP Settings`.
+7. Configure LSP to add the Data-pack Language Server. Here's one example:
+```json
+{
+	"clients": {
+		"datapack-language-server": {
+			"command": [
+				"datapack-language-server",
+				"--stdio"
+			],
+			"enabled": true,
+			"languages": [
+				{
+					"languageId": "mcfunction",
+					"scopes": [
+						"source.mcfunction"
+					],
+					"syntaxes": [
+						"Packages/language-mcfunction/mcfunction.tmLanguage"
+					]
+				},
+				{
+					"languageId": "json",
+					"scopes": [
+						"source.json"
+					],
+					"syntaxes": [
+						"Packages/JavaScript/JSON.sublime-syntax"
+					]
+				}
+			]
+		}
+	},
+	"only_show_lsp_completions": true
+}
+```
+8. Open the Command Palette, select `LSP: Enable Language Server Globally`, and choose `datapack-language-server`.
+9. Enjoy. Do note that you need to execute the command in step 2 manually if you want to update the language server.
+
+- TODO (for SPGoding): make a fine-tuned Sublime package, so that the language server can be updated automatically and the user doesn't need to set all these crazy stuff.
+
+### Visual Studio Code
+
+We have a ready-for-use [VS Code](https://code.visualstudio.com/) extension: [![VSCode Marketplace](https://img.shields.io/visual-studio-marketplace/v/SPGoding.datapack-language-server.svg?logo=visual-studio-code&style=flat-square)](https://marketplace.visualstudio.com/items?itemName=SPGoding.datapack-language-server)
+
+## For Developers
+
+See our [wiki](https://spyglassmc.com/wiki/Language-Server-Details) for more information.
+
+[lsp]: https://microsoft.github.io/language-server-protocol/

package/bin/server

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('../lib/server.js')

package/lib/server.d.ts

@@ -0,0 +1,2 @@
+export * from './util/types';
+//# sourceMappingURL=server.d.ts.map

package/lib/server.js

@@ -0,0 +1,357 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core = __importStar(require("@spyglassmc/core"));
+const je = __importStar(require("@spyglassmc/java-edition"));
+const locales = __importStar(require("@spyglassmc/locales"));
+const nbtdoc = __importStar(require("@spyglassmc/nbtdoc"));
+const env_paths_1 = __importDefault(require("env-paths"));
+const util = __importStar(require("util"));
+const ls = __importStar(require("vscode-languageserver/node"));
+const util_1 = require("./util");
+__exportStar(require("./util/types"), exports);
+if (process.argv.length === 2) {
+    // When the server is launched from the cmd script, the process arguments
+    // are wiped. I don't know why it happens, but this is what it is.
+    // Therefore, we push a '--stdio' if the argument list is too short.
+    process.argv.push('--stdio');
+}
+const { cache: cacheRoot } = (0, env_paths_1.default)('spyglassmc');
+const connection = ls.createConnection();
+let capabilities;
+let workspaceFolders;
+let hasShutdown = false;
+let progressReporter;
+const logger = {
+    error: (msg, ...args) => connection.console.error(util.format(msg, ...args)),
+    info: (msg, ...args) => connection.console.info(util.format(msg, ...args)),
+    log: (msg, ...args) => connection.console.log(util.format(msg, ...args)),
+    warn: (msg, ...args) => connection.console.warn(util.format(msg, ...args)),
+};
+let service;
+connection.onInitialize(async (params) => {
+    logger.info(`[onInitialize] processId = ${JSON.stringify(params.processId)}`);
+    logger.info(`[onInitialize] clientInfo = ${JSON.stringify(params.clientInfo)}`);
+    logger.info(`[onInitialize] initializationOptions = ${JSON.stringify(params.initializationOptions)}`);
+    capabilities = params.capabilities;
+    workspaceFolders = params.workspaceFolders ?? [];
+    await new Promise(resolve => setTimeout(resolve, 3000));
+    logger.warn('Delayed 3 seconds manually. If you see this in production, it means SPGoding messed up.');
+    if (params.workDoneToken) {
+        progressReporter = connection.window.attachWorkDoneProgress(params.workDoneToken);
+        progressReporter.begin(locales.localize('server.progress.preparing.title'));
+    }
+    try {
+        await locales.loadLocale(params.locale);
+    }
+    catch (e) {
+        logger.error('[loadLocale]', e);
+    }
+    try {
+        service = new core.Service({
+            cacheRoot,
+            initializers: [
+                nbtdoc.initialize,
+                je.initialize,
+            ],
+            isDebugging: false,
+            logger,
+            profilers: new core.ProfilerFactory(logger, [
+                'cache#load',
+                'cache#save',
+                'project#init',
+                'project#ready',
+            ]),
+            projectPath: core.fileUtil.fileUriToPath(workspaceFolders[0].uri),
+        });
+        service.project
+            .on('documentErrorred', ({ doc, errors }) => {
+            connection.sendDiagnostics({
+                diagnostics: util_1.toLS.diagnostics(errors, doc),
+                uri: doc.uri,
+                version: doc.version,
+            });
+        })
+            .on('documentRemoved', ({ uri }) => {
+            connection.sendDiagnostics({ uri, diagnostics: [] });
+        })
+            .on('ready', () => {
+            progressReporter?.done();
+        });
+        await service.project.init();
+    }
+    catch (e) {
+        logger.error('[new Service]', e);
+    }
+    const customCapabilities = {
+        dataHackPubify: true,
+        inlayHints: true,
+        resetProjectCache: true,
+        showCacheRoot: true,
+    };
+    const ans = {
+        serverInfo: {
+            name: 'Spyglass Language Server',
+        },
+        capabilities: {
+            colorProvider: {},
+            completionProvider: {
+                triggerCharacters: service.project.meta.getTriggerCharacters(),
+            },
+            declarationProvider: {},
+            definitionProvider: {},
+            implementationProvider: {},
+            documentFormattingProvider: {},
+            referencesProvider: {},
+            typeDefinitionProvider: {},
+            documentHighlightProvider: {},
+            documentSymbolProvider: {
+                label: 'Spyglass',
+            },
+            hoverProvider: {},
+            semanticTokensProvider: {
+                documentSelector: util_1.toLS.documentSelector(service.project.meta),
+                legend: util_1.toLS.semanticTokensLegend(),
+                full: { delta: false },
+                range: true,
+            },
+            signatureHelpProvider: {
+                triggerCharacters: [' '],
+            },
+            textDocumentSync: {
+                change: ls.TextDocumentSyncKind.Incremental,
+                openClose: true,
+            },
+            workspaceSymbolProvider: {},
+            experimental: {
+                spyglassmc: customCapabilities,
+            },
+        },
+    };
+    if (capabilities.workspace?.workspaceFolders) {
+        ans.capabilities.workspace = {
+            workspaceFolders: {
+                supported: true,
+                changeNotifications: true,
+            },
+        };
+    }
+    return ans;
+});
+connection.onInitialized(async () => {
+    await service.project.ready();
+    if (capabilities.workspace?.workspaceFolders) {
+        connection.workspace.onDidChangeWorkspaceFolders(async () => {
+            // FIXME
+            // service.rawRoots = (await connection.workspace.getWorkspaceFolders() ?? []).map(r => r.uri)
+        });
+    }
+});
+connection.onDidOpenTextDocument(async ({ textDocument: { text, uri, version, languageId: languageID } }) => {
+    service.project.onDidOpen(uri, languageID, version, text);
+});
+connection.onDidChangeTextDocument(async ({ contentChanges, textDocument: { uri, version } }) => {
+    service.project.onDidChange(uri, contentChanges, version);
+});
+connection.onDidCloseTextDocument(({ textDocument: { uri } }) => {
+    service.project.onDidClose(uri);
+});
+connection.workspace.onDidRenameFiles(({}) => {
+});
+connection.onColorPresentation(async ({ textDocument: { uri }, color, range }) => {
+    const docAndNode = await service.project.ensureParsedAndChecked(uri);
+    if (!docAndNode) {
+        return undefined;
+    }
+    const { doc, node } = docAndNode;
+    const presentation = service.getColorPresentation(node, doc, util_1.toCore.range(range, doc), util_1.toCore.color(color));
+    return util_1.toLS.colorPresentationArray(presentation, doc);
+});
+connection.onDocumentColor(async ({ textDocument: { uri } }) => {
+    const docAndNode = await service.project.ensureParsedAndChecked(uri);
+    if (!docAndNode) {
+        return undefined;
+    }
+    const { doc, node } = docAndNode;
+    const info = service.getColorInfo(node, doc);
+    return util_1.toLS.colorInformationArray(info, doc);
+});
+connection.onCompletion(async ({ textDocument: { uri }, position, context }) => {
+    const docAndNode = await service.project.ensureParsedAndChecked(uri);
+    if (!docAndNode) {
+        return undefined;
+    }
+    const { doc, node } = docAndNode;
+    const offset = util_1.toCore.offset(position, doc);
+    const items = service.complete(node, doc, offset, context?.triggerCharacter);
+    return items.map(item => util_1.toLS.completionItem(item, doc, offset, capabilities.textDocument?.completion?.completionItem?.insertReplaceSupport));
+});
+connection.onRequest('spyglassmc/dataHackPubify', ({ initialism }) => {
+    return service.dataHackPubify(initialism);
+});
+connection.onDeclaration(async ({ textDocument: { uri }, position }) => {
+    const docAndNode = await service.project.ensureParsedAndChecked(uri);
+    if (!docAndNode) {
+        return undefined;
+    }
+    const { doc, node } = docAndNode;
+    const ans = service.getSymbolLocations(node, doc, util_1.toCore.offset(position, doc), ['declaration', 'definition']);
+    return util_1.toLS.locationLink(ans, doc, capabilities.textDocument?.declaration?.linkSupport);
+});
+connection.onDefinition(async ({ textDocument: { uri }, position }) => {
+    const docAndNode = await service.project.ensureParsedAndChecked(uri);
+    if (!docAndNode) {
+        return undefined;
+    }
+    const { doc, node } = docAndNode;
+    const ans = service.getSymbolLocations(node, doc, util_1.toCore.offset(position, doc), ['definition', 'declaration', 'implementation', 'typeDefinition']);
+    return util_1.toLS.locationLink(ans, doc, capabilities.textDocument?.definition?.linkSupport);
+});
+connection.onImplementation(async ({ textDocument: { uri }, position }) => {
+    const docAndNode = await service.project.ensureParsedAndChecked(uri);
+    if (!docAndNode) {
+        return undefined;
+    }
+    const { doc, node } = docAndNode;
+    const ans = service.getSymbolLocations(node, doc, util_1.toCore.offset(position, doc), ['implementation', 'definition']);
+    return util_1.toLS.locationLink(ans, doc, capabilities.textDocument?.implementation?.linkSupport);
+});
+connection.onReferences(async ({ textDocument: { uri }, position, context: { includeDeclaration } }) => {
+    const docAndNode = await service.project.ensureParsedAndChecked(uri);
+    if (!docAndNode) {
+        return undefined;
+    }
+    const { doc, node } = docAndNode;
+    const ans = service.getSymbolLocations(node, doc, util_1.toCore.offset(position, doc), includeDeclaration ? undefined : ['reference']);
+    return util_1.toLS.locationLink(ans, doc, false);
+});
+connection.onTypeDefinition(async ({ textDocument: { uri }, position }) => {
+    const docAndNode = await service.project.ensureParsedAndChecked(uri);
+    if (!docAndNode) {
+        return undefined;
+    }
+    const { doc, node } = docAndNode;
+    const ans = service.getSymbolLocations(node, doc, util_1.toCore.offset(position, doc), ['typeDefinition']);
+    return util_1.toLS.locationLink(ans, doc, capabilities.textDocument?.typeDefinition?.linkSupport);
+});
+connection.onDocumentHighlight(async ({ textDocument: { uri }, position }) => {
+    const docAndNode = await service.project.ensureParsedAndChecked(uri);
+    if (!docAndNode) {
+        return undefined;
+    }
+    const { doc, node } = docAndNode;
+    const ans = service.getSymbolLocations(node, doc, util_1.toCore.offset(position, doc), undefined, true);
+    return util_1.toLS.documentHighlight(ans);
+});
+connection.onDocumentSymbol(async ({ textDocument: { uri } }) => {
+    const docAndNode = await service.project.ensureParsedAndChecked(uri);
+    if (!docAndNode) {
+        return undefined;
+    }
+    const { doc, node } = docAndNode;
+    return util_1.toLS.documentSymbolsFromTables([service.project.symbols.global, ...core.AstNode.getLocalsToLeaves(node)], doc, capabilities.textDocument?.documentSymbol?.hierarchicalDocumentSymbolSupport, capabilities.textDocument?.documentSymbol?.symbolKind?.valueSet);
+});
+connection.onHover(async ({ textDocument: { uri }, position }) => {
+    const docAndNode = await service.project.ensureParsedAndChecked(uri);
+    if (!docAndNode) {
+        return undefined;
+    }
+    const { doc, node } = docAndNode;
+    const ans = service.getHover(node, doc, util_1.toCore.offset(position, doc));
+    return ans ? util_1.toLS.hover(ans, doc) : undefined;
+});
+connection.onRequest('spyglassmc/inlayHints', async ({ textDocument: { uri }, range }) => {
+    const docAndNode = await service.project.ensureParsedAndChecked(uri);
+    if (!docAndNode) {
+        return [];
+    }
+    const { doc, node } = docAndNode;
+    const hints = service.getInlayHints(node, doc, util_1.toCore.range(range, doc));
+    return util_1.toLS.inlayHints(hints, doc);
+});
+connection.onRequest('spyglassmc/resetProjectCache', async () => {
+    service.project.resetCache();
+    return service.project.restart();
+});
+connection.onRequest('spyglassmc/showCacheRoot', async () => {
+    return service.project.showCacheRoot();
+});
+connection.languages.semanticTokens.on(async ({ textDocument: { uri } }) => {
+    const docAndNode = await service.project.ensureParsedAndChecked(uri);
+    if (!docAndNode) {
+        return { data: [] };
+    }
+    const { doc, node } = docAndNode;
+    const tokens = service.colorize(node, doc);
+    return util_1.toLS.semanticTokens(tokens, doc);
+});
+connection.languages.semanticTokens.onRange(async ({ textDocument: { uri }, range }) => {
+    const docAndNode = await service.project.ensureParsedAndChecked(uri);
+    if (!docAndNode) {
+        return { data: [] };
+    }
+    const { doc, node } = docAndNode;
+    const tokens = service.colorize(node, doc, util_1.toCore.range(range, doc));
+    return util_1.toLS.semanticTokens(tokens, doc);
+});
+connection.onSignatureHelp(async ({ textDocument: { uri }, position }) => {
+    const docAndNode = await service.project.ensureParsedAndChecked(uri);
+    if (!docAndNode) {
+        return undefined;
+    }
+    const { doc, node } = docAndNode;
+    const help = service.getSignatureHelp(node, doc, util_1.toCore.offset(position, doc));
+    return util_1.toLS.signatureHelp(help);
+});
+connection.onWorkspaceSymbol(({ query }) => {
+    return util_1.toLS.symbolInformationArrayFromTable(service.project.symbols.global, query, capabilities.textDocument?.documentSymbol?.symbolKind?.valueSet);
+});
+connection.onDocumentFormatting(async ({ textDocument: { uri }, options }) => {
+    const docAndNode = await service.project.ensureParsedAndChecked(uri);
+    if (!docAndNode) {
+        return undefined;
+    }
+    const { doc, node } = docAndNode;
+    let text = service.format(node, doc, options.tabSize, options.insertSpaces);
+    if (options.insertFinalNewline && text.charAt(text.length - 1) !== '\n') {
+        text += '\n';
+    }
+    return [util_1.toLS.textEdit(node.range, text, doc)];
+});
+connection.onShutdown(async () => {
+    await service.project.close();
+    hasShutdown = true;
+});
+connection.onExit(() => {
+    connection.dispose();
+    if (!hasShutdown) {
+        console.error('The server has not finished the shutdown request before receiving the exit request.');
+        process.exitCode = 1;
+    }
+});
+connection.listen();
+//# sourceMappingURL=server.js.map

package/lib/util/index.d.ts

@@ -0,0 +1,4 @@
+export * from './toCore';
+export * from './toLS';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/lib/util/index.js

@@ -0,0 +1,16 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./toCore"), exports);
+__exportStar(require("./toLS"), exports);
+__exportStar(require("./types"), exports);
+//# sourceMappingURL=index.js.map

package/lib/util/toCore.d.ts

@@ -0,0 +1,14 @@
+import * as core from '@spyglassmc/core';
+import type { TextDocument } from 'vscode-languageserver-textdocument';
+import type * as ls from 'vscode-languageserver/node';
+/**
+ * A series of functions that can transform `vscode-languageserver` types to `@spyglassmc/core` types.
+ *
+ * Functions are named after types in `@spyglassmc/core`.
+ */
+export declare namespace toCore {
+    function offset(position: ls.Position, doc: TextDocument): number;
+    function range(range: ls.Range, doc: TextDocument): core.Range;
+    function color(color: ls.Color): core.Color;
+}
+//# sourceMappingURL=toCore.d.ts.map

package/lib/util/toCore.js

@@ -0,0 +1,44 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toCore = void 0;
+const core = __importStar(require("@spyglassmc/core"));
+/**
+ * A series of functions that can transform `vscode-languageserver` types to `@spyglassmc/core` types.
+ *
+ * Functions are named after types in `@spyglassmc/core`.
+ */
+var toCore;
+(function (toCore) {
+    function offset(position, doc) {
+        return doc.offsetAt(position);
+    }
+    toCore.offset = offset;
+    function range(range, doc) {
+        return core.Range.create(offset(range.start, doc), offset(range.end, doc));
+    }
+    toCore.range = range;
+    function color(color) {
+        return [color.red, color.green, color.blue, color.alpha];
+    }
+    toCore.color = color;
+})(toCore = exports.toCore || (exports.toCore = {}));
+//# sourceMappingURL=toCore.js.map

package/lib/util/toLS.d.ts

@@ -0,0 +1,52 @@
+import * as core from '@spyglassmc/core';
+import type { TextDocument } from 'vscode-languageserver-textdocument';
+import * as ls from 'vscode-languageserver/node';
+import type { MyLspInlayHint } from './types';
+/**
+ * A series of functions that can transform `@spyglassmc/core` types to `vscode-languageserver` types.
+ *
+ * Functions are named after types in `vscode-languageserver`.
+ */
+export declare namespace toLS {
+    function color(color: core.Color): ls.Color;
+    function colorInformation(info: core.ColorInfo, doc: TextDocument): ls.ColorInformation;
+    function colorInformationArray(info: core.ColorInfo[], doc: TextDocument): ls.ColorInformation[];
+    function colorPresentation(presentation: core.ColorPresentation, doc: TextDocument): ls.ColorPresentation;
+    function colorPresentationArray(presentation: core.ColorPresentation[], doc: TextDocument): ls.ColorPresentation[];
+    function diagnostic(error: core.LanguageError, doc: TextDocument): ls.Diagnostic;
+    function diagnostics(errors: readonly core.LanguageError[], doc: TextDocument): ls.Diagnostic[];
+    function diagnosticSeverity(severity: core.ErrorSeverity): ls.DiagnosticSeverity;
+    function documentHighlight(locations: core.SymbolLocations | undefined): ls.DocumentHighlight[] | undefined;
+    function documentSelector(meta: core.MetaRegistry): ls.DocumentSelector;
+    function documentSymbol(symbol: core.Symbol, symLoc: core.SymbolLocation, doc: TextDocument, hierarchicalSupport: boolean | undefined, supportedKinds?: ls.SymbolKind[]): ls.DocumentSymbol;
+    function documentSymbols(map: core.SymbolMap | undefined, doc: TextDocument, hierarchicalSupport: boolean | undefined, supportedKinds?: ls.SymbolKind[]): ls.DocumentSymbol[];
+    function documentSymbolsFromTable(table: core.SymbolTable, doc: TextDocument, hierarchicalSupport: boolean | undefined, supportedKinds?: ls.SymbolKind[]): ls.DocumentSymbol[];
+    function documentSymbolsFromTables(tables: core.SymbolTable[], doc: TextDocument, hierarchicalSupport: boolean | undefined, supportedKinds?: ls.SymbolKind[]): ls.DocumentSymbol[];
+    function hover(hover: core.Hover, doc: TextDocument): ls.Hover;
+    function inlayHint(hint: core.InlayHint, doc: TextDocument): MyLspInlayHint;
+    function inlayHints(hints: core.InlayHint[], doc: TextDocument): MyLspInlayHint[];
+    function completionItem(completion: core.CompletionItem, doc: TextDocument, requestedOffset: number, insertReplaceSupport: boolean | undefined): ls.CompletionItem;
+    function location(location: {
+        uri: string;
+        posRange: core.PositionRange;
+    }): ls.Location;
+    function locationLink(locations: core.SymbolLocations | undefined, doc: TextDocument, linkSupport: false): ls.Location[] | undefined;
+    function locationLink(locations: core.SymbolLocations | undefined, doc: TextDocument, linkSupport: boolean | undefined): ls.LocationLink[] | ls.Location[] | undefined;
+    function markupContent(value: string): ls.MarkupContent;
+    function position(offset: number, doc: TextDocument): ls.Position;
+    function range(range: core.Range, doc: TextDocument): ls.Range;
+    function semanticTokenModifier(modifier: core.ColorTokenModifier): number;
+    function semanticTokenModifiers(modifiers?: readonly core.ColorTokenModifier[]): number;
+    function semanticTokens(tokens: readonly core.ColorToken[], doc: TextDocument): ls.SemanticTokens;
+    function semanticTokensLegend(): ls.SemanticTokensLegend;
+    function semanticTokenType(type: core.ColorTokenType): number;
+    function signatureHelp(help: core.SignatureHelp | undefined): ls.SignatureHelp | undefined;
+    function signatureInformation(info: core.SignatureInfo): ls.SignatureInformation;
+    function parameterInformation(info: core.ParameterInfo): ls.ParameterInformation;
+    function symbolInformation(symbol: core.Symbol, symLoc: core.SymbolLocation, supportedKinds?: ls.SymbolKind[]): ls.SymbolInformation;
+    function symbolInformationArray(map: core.SymbolMap | undefined, query: string, supportedKinds?: ls.SymbolKind[]): ls.SymbolInformation[];
+    function symbolInformationArrayFromTable(table: core.SymbolTable, query: string, supportedKinds?: ls.SymbolKind[]): ls.SymbolInformation[];
+    function symbolKind(category: string, subcategory?: string, supportedKinds?: ls.SymbolKind[]): ls.SymbolKind;
+    function textEdit(range: core.Range, text: string, doc: TextDocument): ls.TextEdit;
+}
+//# sourceMappingURL=toLS.d.ts.map

package/lib/util/toLS.js

@@ -0,0 +1,327 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toLS = void 0;
+const core = __importStar(require("@spyglassmc/core"));
+const ls = __importStar(require("vscode-languageserver/node"));
+const node_1 = require("vscode-languageserver/node");
+/**
+ * A series of functions that can transform `@spyglassmc/core` types to `vscode-languageserver` types.
+ *
+ * Functions are named after types in `vscode-languageserver`.
+ */
+var toLS;
+(function (toLS) {
+    const ZeroPosition = { line: 0, character: 0 };
+    const ZeroRange = { start: ZeroPosition, end: ZeroPosition };
+    function color(color) {
+        return ls.Color.create(...color);
+    }
+    toLS.color = color;
+    function colorInformation(info, doc) {
+        return ls.ColorInformation.create(range(info.range, doc), color(info.color));
+    }
+    toLS.colorInformation = colorInformation;
+    function colorInformationArray(info, doc) {
+        return info.map(i => colorInformation(i, doc));
+    }
+    toLS.colorInformationArray = colorInformationArray;
+    function colorPresentation(presentation, doc) {
+        const edit = ls.TextEdit.replace(range(presentation.range, doc), presentation.text);
+        return ls.ColorPresentation.create(presentation.label, edit);
+    }
+    toLS.colorPresentation = colorPresentation;
+    function colorPresentationArray(presentation, doc) {
+        return presentation.map(p => colorPresentation(p, doc));
+    }
+    toLS.colorPresentationArray = colorPresentationArray;
+    function diagnostic(error, doc) {
+        const ans = ls.Diagnostic.create(range(error.range, doc), error.message, diagnosticSeverity(error.severity), undefined, 'spyglassmc');
+        if (error.info?.deprecated) {
+            (ans.tags ?? (ans.tags = []))?.push(ls.DiagnosticTag.Deprecated);
+        }
+        if (error.info?.unnecessary) {
+            (ans.tags ?? (ans.tags = []))?.push(ls.DiagnosticTag.Unnecessary);
+        }
+        if (error.info?.codeAction) {
+            ans.data = {
+                codeAction: error.info?.codeAction,
+            };
+        }
+        if (error.info?.related) {
+            ans.relatedInformation = error.info?.related.map(v => ({
+                location: location(v.location),
+                message: v.message,
+            }));
+        }
+        return ans;
+    }
+    toLS.diagnostic = diagnostic;
+    function diagnostics(errors, doc) {
+        return errors.map(e => diagnostic(e, doc));
+    }
+    toLS.diagnostics = diagnostics;
+    function diagnosticSeverity(severity) {
+        switch (severity) {
+            case 0 /* Hint */:
+                return ls.DiagnosticSeverity.Hint;
+            case 1 /* Information */:
+                return ls.DiagnosticSeverity.Information;
+            case 2 /* Warning */:
+                return ls.DiagnosticSeverity.Warning;
+            case 3 /* Error */:
+                return ls.DiagnosticSeverity.Error;
+        }
+    }
+    toLS.diagnosticSeverity = diagnosticSeverity;
+    function documentHighlight(locations) {
+        return locations?.locations
+            ?.filter(loc => loc.posRange)
+            ?.map(loc => ({ range: loc.posRange }));
+    }
+    toLS.documentHighlight = documentHighlight;
+    function documentSelector(meta) {
+        const ans = meta.getLanguages().map(id => ({ language: id }));
+        return ans;
+    }
+    toLS.documentSelector = documentSelector;
+    function documentSymbol(symbol, symLoc, doc, hierarchicalSupport, supportedKinds = []) {
+        return {
+            name: symbol.identifier,
+            kind: symbolKind(symbol.category, symbol.subcategory, supportedKinds),
+            range: symLoc.fullPosRange ?? symLoc.posRange ?? ZeroRange,
+            selectionRange: symLoc.posRange ?? ZeroRange,
+            children: hierarchicalSupport ? documentSymbols(symbol.members, doc, hierarchicalSupport, supportedKinds) : undefined,
+        };
+    }
+    toLS.documentSymbol = documentSymbol;
+    function documentSymbols(map = {}, doc, hierarchicalSupport, supportedKinds = []) {
+        return Object.values(map)
+            .map(s => [s, [...s.declaration ?? [], ...s.definition ?? [], ...s.implementation ?? [], ...s.typeDefinition ?? []].find(l => l.uri === doc.uri)])
+            .filter(([_s, l]) => !!l)
+            .map(([s, l]) => documentSymbol(s, l, doc, hierarchicalSupport, supportedKinds));
+    }
+    toLS.documentSymbols = documentSymbols;
+    function documentSymbolsFromTable(table, doc, hierarchicalSupport, supportedKinds = []) {
+        return Object.values(table)
+            .map(m => documentSymbols(m, doc, hierarchicalSupport, supportedKinds))
+            .flat();
+    }
+    toLS.documentSymbolsFromTable = documentSymbolsFromTable;
+    function documentSymbolsFromTables(tables, doc, hierarchicalSupport, supportedKinds = []) {
+        return tables
+            .map(t => documentSymbolsFromTable(t, doc, hierarchicalSupport, supportedKinds))
+            .flat();
+    }
+    toLS.documentSymbolsFromTables = documentSymbolsFromTables;
+    function hover(hover, doc) {
+        const ans = {
+            contents: markupContent(hover.markdown),
+            range: range(hover.range, doc),
+        };
+        return ans;
+    }
+    toLS.hover = hover;
+    function inlayHint(hint, doc) {
+        return {
+            position: doc.positionAt(hint.offset),
+            text: hint.text,
+        };
+    }
+    toLS.inlayHint = inlayHint;
+    function inlayHints(hints, doc) {
+        return hints.map(h => inlayHint(h, doc));
+    }
+    toLS.inlayHints = inlayHints;
+    function completionItem(completion, doc, requestedOffset, insertReplaceSupport) {
+        const insertText = completion.insertText ?? completion.label;
+        const canInsertReplace = insertReplaceSupport && ![core.CR, core.LF, core.CRLF].includes(insertText);
+        const textEdit = canInsertReplace
+            ? ls.InsertReplaceEdit.create(insertText, 
+            /* insert  */ range(core.Range.create(completion.range.start, requestedOffset), doc), 
+            /* replace */ range(completion.range, doc))
+            : ls.TextEdit.replace(range(completion.range, doc), insertText);
+        const ans = {
+            label: completion.label,
+            kind: completion.kind,
+            detail: completion.detail,
+            documentation: completion.documentation,
+            filterText: completion.filterText,
+            sortText: completion.sortText,
+            textEdit,
+            insertTextFormat: node_1.InsertTextFormat.Snippet,
+            insertTextMode: ls.InsertTextMode.adjustIndentation,
+            ...completion.deprecated ? { tags: [ls.CompletionItemTag.Deprecated] } : {},
+        };
+        return ans;
+    }
+    toLS.completionItem = completionItem;
+    function location(location) {
+        return {
+            uri: location.uri,
+            range: location.posRange,
+        };
+    }
+    toLS.location = location;
+    function locationLink(locations, doc, linkSupport) {
+        return locations?.locations
+            ? linkSupport
+                ? locations.locations.map(loc => ({
+                    originSelectionRange: range(locations.range, doc),
+                    targetUri: loc.uri,
+                    targetRange: loc.fullPosRange ?? loc.posRange ?? ZeroRange,
+                    targetSelectionRange: loc.posRange ?? ZeroRange,
+                }))
+                : (locations.locations).map(loc => location({ uri: loc.uri, posRange: loc.posRange ?? ZeroRange }))
+            : undefined;
+    }
+    toLS.locationLink = locationLink;
+    function markupContent(value) {
+        return {
+            kind: ls.MarkupKind.Markdown,
+            value: value,
+        };
+    }
+    toLS.markupContent = markupContent;
+    function position(offset, doc) {
+        return doc.positionAt(offset);
+    }
+    toLS.position = position;
+    function range(range, doc) {
+        return ls.Range.create(position(range.start, doc), position(range.end, doc));
+    }
+    toLS.range = range;
+    function semanticTokenModifier(modifier) {
+        return core.ColorTokenModifiers.indexOf(modifier);
+    }
+    toLS.semanticTokenModifier = semanticTokenModifier;
+    function semanticTokenModifiers(modifiers = []) {
+        let ans = 0;
+        for (const modifier of modifiers) {
+            ans += 1 << semanticTokenModifier(modifier);
+        }
+        return ans;
+    }
+    toLS.semanticTokenModifiers = semanticTokenModifiers;
+    function semanticTokens(tokens, doc) {
+        const builder = new ls.SemanticTokensBuilder();
+        for (const token of tokens) {
+            const pos = position(token.range.start, doc);
+            const length = token.range.end - token.range.start;
+            builder.push(pos.line, pos.character, length, semanticTokenType(token.type), semanticTokenModifiers(token.modifiers));
+        }
+        return builder.build();
+    }
+    toLS.semanticTokens = semanticTokens;
+    function semanticTokensLegend() {
+        const ans = {
+            tokenTypes: core.ColorTokenTypes,
+            tokenModifiers: core.ColorTokenModifiers,
+        };
+        return ans;
+    }
+    toLS.semanticTokensLegend = semanticTokensLegend;
+    function semanticTokenType(type) {
+        return core.ColorTokenTypes.indexOf(type);
+    }
+    toLS.semanticTokenType = semanticTokenType;
+    function signatureHelp(help) {
+        if (!help || help.signatures.length === 0) {
+            return undefined;
+        }
+        return {
+            signatures: help.signatures.map(signatureInformation),
+            activeParameter: help.signatures[help.activeSignature].activeParameter,
+            activeSignature: help.activeSignature,
+        };
+    }
+    toLS.signatureHelp = signatureHelp;
+    function signatureInformation(info) {
+        return {
+            label: info.label,
+            activeParameter: info.activeParameter,
+            documentation: info.documentation ? markupContent(info.documentation) : undefined,
+            parameters: info.parameters.map(parameterInformation),
+        };
+    }
+    toLS.signatureInformation = signatureInformation;
+    function parameterInformation(info) {
+        return {
+            label: info.label,
+            documentation: info.documentation ? markupContent(info.documentation) : undefined,
+        };
+    }
+    toLS.parameterInformation = parameterInformation;
+    function symbolInformation(symbol, symLoc, supportedKinds = []) {
+        return {
+            name: symbol.identifier,
+            kind: symbolKind(symbol.category, symbol.subcategory, supportedKinds),
+            location: location({ uri: symLoc.uri, posRange: symLoc.fullPosRange ?? symLoc.posRange ?? ZeroRange }),
+        };
+    }
+    toLS.symbolInformation = symbolInformation;
+    function symbolInformationArray(map = {}, query, supportedKinds = []) {
+        return Object.values(map)
+            .filter(s => s.identifier.includes(query))
+            .map(s => [s, [...s.declaration ?? [], ...s.definition ?? [], ...s.implementation ?? [], ...s.typeDefinition ?? []][0]])
+            .filter(([_s, l]) => !!l)
+            .map(([s, l]) => symbolInformation(s, l, supportedKinds));
+    }
+    toLS.symbolInformationArray = symbolInformationArray;
+    function symbolInformationArrayFromTable(table, query, supportedKinds = []) {
+        return Object.values(table)
+            .map(m => symbolInformationArray(m, query, supportedKinds))
+            .flat();
+    }
+    toLS.symbolInformationArrayFromTable = symbolInformationArrayFromTable;
+    function symbolKind(category, subcategory = '', supportedKinds = []) {
+        const UltimateFallback = ls.SymbolKind.Variable;
+        const getKind = (kind, fallback) => supportedKinds?.includes(kind) ? kind : fallback;
+        if (core.ResourceLocationCategory.is(category)) {
+            return ls.SymbolKind.Function;
+        }
+        if (category === 'nbtdoc') {
+            const map = new Map([
+                ['enum', ls.SymbolKind.Enum],
+                ['enum_key', getKind(ls.SymbolKind.EnumMember, ls.SymbolKind.Field)],
+                ['compound', getKind(ls.SymbolKind.Struct, ls.SymbolKind.Interface)],
+                ['compound_key', ls.SymbolKind.Field],
+                ['module', ls.SymbolKind.Module],
+            ]);
+            return map.get(subcategory) ?? UltimateFallback;
+        }
+        const map = new Map([
+            ['attribute_modifier_uuid', ls.SymbolKind.Number],
+            ['nbtdoc/description', ls.SymbolKind.Constructor],
+            ['objective', ls.SymbolKind.Variable],
+            ['score_holder', ls.SymbolKind.Class],
+            ['tag', ls.SymbolKind.String],
+            ['team', ls.SymbolKind.Array],
+        ]);
+        return map.get(category) ?? UltimateFallback;
+    }
+    toLS.symbolKind = symbolKind;
+    function textEdit(range, text, doc) {
+        return ls.TextEdit.replace(toLS.range(range, doc), text);
+    }
+    toLS.textEdit = textEdit;
+})(toLS = exports.toLS || (exports.toLS = {}));
+//# sourceMappingURL=toLS.js.map

package/lib/util/types.d.ts

@@ -0,0 +1,21 @@
+import type * as ls from 'vscode-languageserver/node';
+export interface CustomServerCapabilities {
+    dataHackPubify?: boolean;
+    inlayHints?: boolean;
+    resetProjectCache?: boolean;
+    showCacheRoot?: boolean;
+}
+export interface MyLspDataHackPubifyRequestParams {
+    initialism: string;
+}
+export interface MyLspInlayHint {
+    position: ls.Position;
+    text: string;
+}
+export interface MyLspInlayHintRequestParams {
+    textDocument: {
+        uri: string;
+    };
+    range: ls.Range;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/util/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@spyglassmc/language-server",
+  "version": "0.1.0",
+  "main": "lib/server.js",
+  "types": "lib/server.d.ts",
+  "author": "SPGoding",
+  "license": "MIT",
+  "directories": {
+    "man": "man",
+    "test": "test"
+  },
+  "bin": {
+    "spyglassmc-language-server": "./bin/server"
+  },
+  "scripts": {
+    "release": "npm publish",
+    "release:dry": "npm publish --dry-run"
+  },
+  "dependencies": {
+    "env-paths": "^2.2.1",
+    "vscode-languageserver": "^7.0.0",
+    "vscode-languageserver-textdocument": "^1.0.1",
+    "@spyglassmc/core": "0.1.0",
+    "@spyglassmc/java-edition": "0.1.0",
+    "@spyglassmc/locales": "0.1.0",
+    "@spyglassmc/nbtdoc": "0.1.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/SpyglassMC/Spyglass.git"
+  },
+  "homepage": "https://spyglassmc.com",
+  "bugs": {
+    "url": "https://github.com/SpyglassMC/Spyglass/issues"
+  }
+}