volar-service-markdown 0.0.13

package/out/index.d.ts

@@ -0,0 +1,7 @@
+import type { Service } from '@volar/language-service';
+import type { IMdLanguageService } from 'vscode-markdown-languageservice';
+export interface Provide {
+    'markdown/languageService': () => IMdLanguageService;
+}
+export declare function create(): Service<Provide>;
+export default create;

package/out/index.js

@@ -0,0 +1,247 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = void 0;
+const vscode_jsonrpc_1 = require("vscode-jsonrpc");
+const vscode_markdown_languageservice_1 = require("vscode-markdown-languageservice");
+const vscode_uri_1 = require("vscode-uri");
+const MarkdownIt = require("markdown-it");
+const md = new MarkdownIt();
+function isMarkdown(document) {
+    return document.languageId === 'markdown';
+}
+function assert(condition, message) {
+    if (!condition) {
+        throw new Error(message);
+    }
+}
+function create() {
+    return (context) => {
+        if (!context) {
+            return {};
+        }
+        let lastProjectVersion = context.host.getProjectVersion();
+        assert(context.env, 'context.env must be defined');
+        const { fs, onDidChangeWatchedFiles } = context.env;
+        assert(fs, 'context.env.fs must be defined');
+        assert(onDidChangeWatchedFiles, 'context.env.fs.onDidChangeWatchedFiles must be defined');
+        const logger = {
+            level: vscode_markdown_languageservice_1.LogLevel.Off,
+            log(_logLevel, message) {
+                context.env.console?.log(message);
+            }
+        };
+        const parser = {
+            slugifier: vscode_markdown_languageservice_1.githubSlugifier,
+            async tokenize(document) {
+                return md.parse(document.getText(), {});
+            }
+        };
+        const onDidChangeMarkdownDocument = new vscode_jsonrpc_1.Emitter();
+        const onDidCreateMarkdownDocument = new vscode_jsonrpc_1.Emitter();
+        const onDidDeleteMarkdownDocument = new vscode_jsonrpc_1.Emitter();
+        const fileWatcher = onDidChangeWatchedFiles((event) => {
+            for (const change of event.changes) {
+                switch (change.type) {
+                    case 2: {
+                        const document = context.getTextDocument(change.uri);
+                        if (document) {
+                            onDidChangeMarkdownDocument.fire(document);
+                        }
+                        break;
+                    }
+                    case 1: {
+                        const document = context.getTextDocument(change.uri);
+                        if (document) {
+                            onDidCreateMarkdownDocument.fire(document);
+                        }
+                        break;
+                    }
+                    case 3: {
+                        onDidDeleteMarkdownDocument.fire(vscode_uri_1.URI.parse(change.uri));
+                        break;
+                    }
+                }
+            }
+        });
+        const workspace = {
+            async getAllMarkdownDocuments() {
+                sync();
+                return syncedVersions.values();
+            },
+            getContainingDocument() {
+                return undefined;
+            },
+            hasMarkdownDocument(resource) {
+                const document = context.getTextDocument(String(resource));
+                return Boolean(document && isMarkdown(document));
+            },
+            onDidChangeMarkdownDocument: onDidChangeMarkdownDocument.event,
+            onDidCreateMarkdownDocument: onDidCreateMarkdownDocument.event,
+            onDidDeleteMarkdownDocument: onDidDeleteMarkdownDocument.event,
+            async openMarkdownDocument(resource) {
+                return context.getTextDocument(String(resource));
+            },
+            async readDirectory(resource) {
+                const directory = await fs.readDirectory(String(resource));
+                return directory.map(([fileName, fileType]) => [
+                    fileName,
+                    { isDirectory: fileType === 2 }
+                ]);
+            },
+            async stat(resource) {
+                const stat = await fs.stat(String(resource));
+                if (stat) {
+                    return { isDirectory: stat.type === 2 };
+                }
+            },
+            workspaceFolders: []
+        };
+        const ls = (0, vscode_markdown_languageservice_1.createLanguageService)({
+            logger,
+            parser,
+            workspace
+        });
+        const syncedVersions = new Map();
+        const sync = () => {
+            const newProjectVersion = context.host.getProjectVersion();
+            const shouldUpdate = newProjectVersion !== lastProjectVersion;
+            if (!shouldUpdate) {
+                return;
+            }
+            lastProjectVersion = newProjectVersion;
+            const oldVersions = new Set(syncedVersions.keys());
+            const newVersions = new Map();
+            for (const { root } of context.virtualFiles.allSources()) {
+                const embeddeds = [root];
+                root.embeddedFiles.forEach(function walk(embedded) {
+                    embeddeds.push(embedded);
+                    embedded.embeddedFiles.forEach(walk);
+                });
+                for (const embedded of embeddeds) {
+                    const document = context.getTextDocument(embedded.fileName);
+                    if (document && isMarkdown(document)) {
+                        newVersions.set(String(document.uri), document);
+                    }
+                }
+            }
+            for (const [uri, document] of newVersions) {
+                const old = syncedVersions.get(uri);
+                syncedVersions.set(uri, document);
+                if (old) {
+                    onDidChangeMarkdownDocument.fire(document);
+                }
+                else {
+                    onDidCreateMarkdownDocument.fire(document);
+                }
+            }
+            for (const uri of oldVersions) {
+                if (!newVersions.has(uri)) {
+                    syncedVersions.delete(uri);
+                    onDidDeleteMarkdownDocument.fire(vscode_uri_1.URI.parse(uri));
+                }
+            }
+        };
+        const prepare = (document) => {
+            if (!isMarkdown(document)) {
+                return false;
+            }
+            sync();
+            return true;
+        };
+        return {
+            dispose() {
+                ls.dispose();
+                fileWatcher.dispose();
+                onDidDeleteMarkdownDocument.dispose();
+                onDidCreateMarkdownDocument.dispose();
+                onDidChangeMarkdownDocument.dispose();
+            },
+            provide: {
+                'markdown/languageService': () => ls
+            },
+            provideCodeActions(document, range, context, token) {
+                if (prepare(document)) {
+                    return ls.getCodeActions(document, range, context, token);
+                }
+            },
+            async provideCompletionItems(document, position, context, token) {
+                if (prepare(document)) {
+                    const items = await ls.getCompletionItems(document, position, {}, token);
+                    return {
+                        isIncomplete: false,
+                        items
+                    };
+                }
+            },
+            provideDiagnostics(document, token) {
+                if (prepare(document)) {
+                    return ls.computeDiagnostics(document, {
+                        ignoreLinks: [],
+                        validateDuplicateLinkDefinitions: vscode_markdown_languageservice_1.DiagnosticLevel.warning,
+                        validateFileLinks: vscode_markdown_languageservice_1.DiagnosticLevel.warning,
+                        validateFragmentLinks: vscode_markdown_languageservice_1.DiagnosticLevel.warning,
+                        validateMarkdownFileLinkFragments: vscode_markdown_languageservice_1.DiagnosticLevel.warning,
+                        validateReferences: vscode_markdown_languageservice_1.DiagnosticLevel.warning,
+                        validateUnusedLinkDefinitions: vscode_markdown_languageservice_1.DiagnosticLevel.warning
+                    }, token);
+                }
+            },
+            provideDocumentHighlights(document, position, token) {
+                if (prepare(document)) {
+                    return ls.getDocumentHighlights(document, position, token);
+                }
+            },
+            provideDocumentLinks(document, token) {
+                if (prepare(document)) {
+                    return ls.getDocumentLinks(document, token);
+                }
+            },
+            provideDocumentSymbols(document, token) {
+                if (prepare(document)) {
+                    return ls.getDocumentSymbols(document, { includeLinkDefinitions: true }, token);
+                }
+            },
+            provideFileReferences(document, token) {
+                if (prepare(document)) {
+                    return ls.getFileReferences(vscode_uri_1.URI.parse(document.uri), token);
+                }
+            },
+            provideFoldingRanges(document, token) {
+                if (prepare(document)) {
+                    return ls.getFoldingRanges(document, token);
+                }
+            },
+            provideReferences(document, position, token) {
+                if (prepare(document)) {
+                    return ls.getReferences(document, position, { includeDeclaration: true }, token);
+                }
+            },
+            provideRenameEdits(document, position, newName, token) {
+                if (prepare(document)) {
+                    return ls.getRenameEdit(document, position, newName, token);
+                }
+            },
+            provideRenameRange(document, position, token) {
+                if (prepare(document)) {
+                    return ls.prepareRename(document, position, token);
+                }
+            },
+            provideSelectionRanges(document, positions, token) {
+                if (prepare(document)) {
+                    return ls.getSelectionRanges(document, positions, token);
+                }
+            },
+            provideWorkspaceSymbols(query, token) {
+                sync();
+                return ls.getWorkspaceSymbols(query, token);
+            },
+            async resolveDocumentLink(link, token) {
+                const result = await ls.resolveDocumentLink(link, token);
+                return result || link;
+            }
+        };
+    };
+}
+exports.create = create;
+exports.default = create;
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,33 @@
+{
+	"name": "volar-service-markdown",
+	"version": "0.0.13",
+	"main": "out/index.js",
+	"license": "MIT",
+	"files": [
+		"out/**/*.js",
+		"out/**/*.d.ts"
+	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/volarjs/services.git",
+		"directory": "packages/markdown"
+	},
+	"dependencies": {
+		"markdown-it": "^13.0.1",
+		"vscode-jsonrpc": "^8.1.0",
+		"vscode-markdown-languageservice": "~0.4.0-alpha.5",
+		"vscode-uri": "^3.0.7"
+	},
+	"devDependencies": {
+		"@types/markdown-it": "^13.0.1",
+		"vscode-languageserver-textdocument": "^1.0.8"
+	},
+	"peerDependencies": {
+		"@volar/language-service": "~1.10.0"
+	},
+	"peerDependenciesMeta": {
+		"@volar/language-service": {
+			"optional": true
+		}
+	}
+}