volar-service-json 0.0.0

package/out/index.d.ts

@@ -0,0 +1,4 @@
+import type { Service } from '@volar/language-service';
+import * as json from 'vscode-json-languageservice';
+declare const _default: (settings?: json.LanguageSettings) => Service;
+export default _default;

package/out/index.js

@@ -0,0 +1,137 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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 });
+const json = __importStar(require("vscode-json-languageservice"));
+exports.default = (settings) => (context) => {
+    // https://github.com/microsoft/vscode/blob/09850876e652688fb142e2e19fd00fd38c0bc4ba/extensions/json-language-features/server/src/jsonServer.ts#L150
+    const triggerCharacters = ['"', ':'];
+    if (!context) {
+        return { triggerCharacters };
+    }
+    const jsonDocuments = new WeakMap();
+    const jsonLs = json.getLanguageService({ schemaRequestService: context.env.schemaRequestService });
+    if (settings) {
+        jsonLs.configure(settings);
+    }
+    return {
+        triggerCharacters,
+        async resolveRuleContext(context) {
+            await worker(context.document, async (jsonDocument) => {
+                context.json = {
+                    document: jsonDocument,
+                    languageService: jsonLs,
+                };
+            });
+            return context;
+        },
+        provideCompletionItems(document, position) {
+            return worker(document, async (jsonDocument) => {
+                return await jsonLs.doComplete(document, position, jsonDocument);
+            });
+        },
+        resolveCompletionItem(item) {
+            return jsonLs.doResolve(item);
+        },
+        provideDefinition(document, position) {
+            return worker(document, async (jsonDocument) => {
+                return await jsonLs.findDefinition(document, position, jsonDocument);
+            });
+        },
+        provideDiagnostics(document) {
+            return worker(document, async (jsonDocument) => {
+                const documentLanguageSettings = undefined; // await getSettings(); // TODO
+                return await jsonLs.doValidation(document, jsonDocument, documentLanguageSettings, undefined);
+            });
+        },
+        provideHover(document, position) {
+            return worker(document, async (jsonDocument) => {
+                return await jsonLs.doHover(document, position, jsonDocument);
+            });
+        },
+        provideDocumentLinks(document) {
+            return worker(document, async (jsonDocument) => {
+                return await jsonLs.findLinks(document, jsonDocument);
+            });
+        },
+        provideDocumentSymbols(document) {
+            return worker(document, async (jsonDocument) => {
+                return await jsonLs.findDocumentSymbols2(document, jsonDocument);
+            });
+        },
+        provideDocumentColors(document) {
+            return worker(document, async (jsonDocument) => {
+                return await jsonLs.findDocumentColors(document, jsonDocument);
+            });
+        },
+        provideColorPresentations(document, color, range) {
+            return worker(document, async (jsonDocument) => {
+                return await jsonLs.getColorPresentations(document, jsonDocument, color, range);
+            });
+        },
+        provideFoldingRanges(document) {
+            return worker(document, async () => {
+                return await jsonLs.getFoldingRanges(document);
+            });
+        },
+        provideSelectionRanges(document, positions) {
+            return worker(document, async (jsonDocument) => {
+                return await jsonLs.getSelectionRanges(document, positions, jsonDocument);
+            });
+        },
+        provideDocumentFormattingEdits(document, range, options) {
+            return worker(document, async () => {
+                const options_2 = await context.env.getConfiguration?.('json.format');
+                if (!(options_2?.enable ?? true)) {
+                    return;
+                }
+                return jsonLs.format(document, range, {
+                    ...options_2,
+                    ...options,
+                });
+            });
+        },
+    };
+    function worker(document, callback) {
+        const jsonDocument = getJsonDocument(document);
+        if (!jsonDocument)
+            return;
+        return callback(jsonDocument);
+    }
+    function getJsonDocument(textDocument) {
+        if (textDocument.languageId !== 'json' && textDocument.languageId !== 'jsonc')
+            return;
+        const cache = jsonDocuments.get(textDocument);
+        if (cache) {
+            const [cacheVersion, cacheDoc] = cache;
+            if (cacheVersion === textDocument.version) {
+                return cacheDoc;
+            }
+        }
+        const doc = jsonLs.parseJSONDocument(textDocument);
+        jsonDocuments.set(textDocument, [textDocument.version, doc]);
+        return doc;
+    }
+};
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,30 @@
+{
+	"name": "volar-service-json",
+	"version": "0.0.0",
+	"main": "out/index.js",
+	"license": "MIT",
+	"files": [
+		"rules.d.ts",
+		"out/**/*.js",
+		"out/**/*.d.ts"
+	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/volarjs/services.git",
+		"directory": "packages/json"
+	},
+	"dependencies": {
+		"vscode-json-languageservice": "^5.2.0",
+		"vscode-languageserver-protocol": "^3.17.3",
+		"vscode-languageserver-textdocument": "^1.0.8"
+	},
+	"peerDependencies": {
+		"@volar/language-service": "*"
+	},
+	"peerDependenciesMeta": {
+		"@volar/language-service": {
+			"optional": true
+		}
+	},
+	"gitHead": "1011561ac4bbf79c53c3b80c27692569bf861519"
+}

package/rules.d.ts

@@ -0,0 +1,10 @@
+import * as json from 'vscode-json-languageservice';
+
+declare module '@volar/language-service' {
+	interface RuleContext {
+		json?: {
+			document: json.JSONDocument;
+			languageService: json.LanguageService;
+		}
+	}
+}