rintenki-lsp-server 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026-PRESENT Kazuhiro Kobayashi<https://github.com/kzhrk>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/server.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/server.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_js_1 = require("vscode-languageserver/node.js");
+const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
+const rintenki_1 = require("rintenki");
+const connection = (0, node_js_1.createConnection)(node_js_1.ProposedFeatures.all);
+const documents = new node_js_1.TextDocuments(vscode_languageserver_textdocument_1.TextDocument);
+let config;
+connection.onInitialize((_params) => {
+    return {
+        capabilities: {
+            textDocumentSync: node_js_1.TextDocumentSyncKind.Full,
+            codeActionProvider: {
+                codeActionKinds: [node_js_1.CodeActionKind.QuickFix],
+            },
+        },
+    };
+});
+connection.onInitialized(() => {
+    connection.workspace.getConfiguration("rintenki").then((settings) => {
+        if (settings?.rules) {
+            config = { rules: settings.rules };
+        }
+    }, () => {
+        // Configuration not available, use defaults
+    });
+});
+connection.onDidChangeConfiguration((_change) => {
+    connection.workspace.getConfiguration("rintenki").then((settings) => {
+        if (settings?.rules) {
+            config = { rules: settings.rules };
+        }
+        else {
+            config = undefined;
+        }
+        documents.all().forEach(validateDocument);
+    }, () => {
+        // Configuration not available, use defaults
+    });
+});
+documents.onDidChangeContent((change) => {
+    validateDocument(change.document);
+});
+function toDiagnosticSeverity(severity) {
+    return severity === "error"
+        ? node_js_1.DiagnosticSeverity.Error
+        : node_js_1.DiagnosticSeverity.Warning;
+}
+function toLspDiagnostic(d) {
+    const line = Math.max((d.line ?? 1) - 1, 0);
+    return {
+        range: {
+            start: { line, character: 0 },
+            end: { line, character: Number.MAX_SAFE_INTEGER },
+        },
+        severity: toDiagnosticSeverity(d.severity),
+        source: "rintenki",
+        code: d.rule,
+        message: d.message,
+        data: { fixable: d.fixable },
+    };
+}
+function validateDocument(document) {
+    if (document.languageId !== "html") {
+        return;
+    }
+    const text = document.getText();
+    const result = (0, rintenki_1.lint)(text, config);
+    const diagnostics = result.diagnostics.map(toLspDiagnostic);
+    connection.sendDiagnostics({ uri: document.uri, diagnostics });
+}
+connection.onCodeAction((params) => {
+    const document = documents.get(params.textDocument.uri);
+    if (!document)
+        return [];
+    const fixableDiagnostics = params.context.diagnostics.filter((d) => d.source === "rintenki" && d.data?.fixable);
+    if (fixableDiagnostics.length === 0)
+        return [];
+    const text = document.getText();
+    const fixResult = (0, rintenki_1.fix)(text, config);
+    if (fixResult.fixedCount === 0)
+        return [];
+    const lastLine = Math.max(document.lineCount - 1, 0);
+    return [
+        {
+            title: "Fix all auto-fixable rintenki issues",
+            kind: node_js_1.CodeActionKind.QuickFix,
+            diagnostics: fixableDiagnostics,
+            edit: {
+                changes: {
+                    [params.textDocument.uri]: [
+                        node_js_1.TextEdit.replace({
+                            start: { line: 0, character: 0 },
+                            end: { line: lastLine, character: Number.MAX_SAFE_INTEGER },
+                        }, fixResult.output),
+                    ],
+                },
+            },
+        },
+    ];
+});
+documents.listen(connection);
+connection.listen();

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "rintenki-lsp-server",
+  "version": "0.0.0",
+  "description": "LSP server for rintenki HTML linter",
+  "author": "Kazuhiro Kobayashi <https://github.com/kzhrk>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kzhrk/rintenki",
+    "directory": "packages/rintenki-lsp-server"
+  },
+  "homepage": "https://github.com/kzhrk/rintenki",
+  "bugs": {
+    "url": "https://github.com/kzhrk/rintenki/issues"
+  },
+  "keywords": [
+    "html",
+    "linter",
+    "lsp",
+    "language-server"
+  ],
+  "main": "dist/server.js",
+  "dependencies": {
+    "vscode-languageserver": "9.0.1",
+    "vscode-languageserver-textdocument": "1.0.12",
+    "rintenki": "0.0.0"
+  },
+  "devDependencies": {
+    "typescript": "6.0.2"
+  },
+  "scripts": {
+    "build": "tsc",
+    "watch": "tsc --watch"
+  }
+}

package/src/server.ts

@@ -0,0 +1,138 @@
+import {
+  createConnection,
+  TextDocuments,
+  ProposedFeatures,
+  InitializeParams,
+  InitializeResult,
+  TextDocumentSyncKind,
+  Diagnostic,
+  DiagnosticSeverity,
+  CodeAction,
+  CodeActionKind,
+  TextEdit,
+  CodeActionParams,
+} from "vscode-languageserver/node.js";
+import { TextDocument } from "vscode-languageserver-textdocument";
+import { lint, fix, type LintConfig, type LintDiagnostic } from "rintenki";
+
+const connection = createConnection(ProposedFeatures.all);
+const documents = new TextDocuments(TextDocument);
+
+let config: LintConfig | undefined;
+
+connection.onInitialize((_params: InitializeParams): InitializeResult => {
+  return {
+    capabilities: {
+      textDocumentSync: TextDocumentSyncKind.Full,
+      codeActionProvider: {
+        codeActionKinds: [CodeActionKind.QuickFix],
+      },
+    },
+  };
+});
+
+connection.onInitialized(() => {
+  connection.workspace.getConfiguration("rintenki").then(
+    (settings) => {
+      if (settings?.rules) {
+        config = { rules: settings.rules };
+      }
+    },
+    () => {
+      // Configuration not available, use defaults
+    }
+  );
+});
+
+connection.onDidChangeConfiguration((_change) => {
+  connection.workspace.getConfiguration("rintenki").then(
+    (settings) => {
+      if (settings?.rules) {
+        config = { rules: settings.rules };
+      } else {
+        config = undefined;
+      }
+      documents.all().forEach(validateDocument);
+    },
+    () => {
+      // Configuration not available, use defaults
+    }
+  );
+});
+
+documents.onDidChangeContent((change) => {
+  validateDocument(change.document);
+});
+
+function toDiagnosticSeverity(severity: string): DiagnosticSeverity {
+  return severity === "error"
+    ? DiagnosticSeverity.Error
+    : DiagnosticSeverity.Warning;
+}
+
+function toLspDiagnostic(d: LintDiagnostic): Diagnostic {
+  const line = Math.max((d.line ?? 1) - 1, 0);
+  return {
+    range: {
+      start: { line, character: 0 },
+      end: { line, character: Number.MAX_SAFE_INTEGER },
+    },
+    severity: toDiagnosticSeverity(d.severity),
+    source: "rintenki",
+    code: d.rule,
+    message: d.message,
+    data: { fixable: d.fixable },
+  };
+}
+
+function validateDocument(document: TextDocument): void {
+  if (document.languageId !== "html") {
+    return;
+  }
+
+  const text = document.getText();
+  const result = lint(text, config);
+  const diagnostics = result.diagnostics.map(toLspDiagnostic);
+  connection.sendDiagnostics({ uri: document.uri, diagnostics });
+}
+
+connection.onCodeAction((params: CodeActionParams): CodeAction[] => {
+  const document = documents.get(params.textDocument.uri);
+  if (!document) return [];
+
+  const fixableDiagnostics = params.context.diagnostics.filter(
+    (d) => d.source === "rintenki" && (d.data as any)?.fixable
+  );
+
+  if (fixableDiagnostics.length === 0) return [];
+
+  const text = document.getText();
+  const fixResult = fix(text, config);
+
+  if (fixResult.fixedCount === 0) return [];
+
+  const lastLine = Math.max(document.lineCount - 1, 0);
+  return [
+    {
+      title: "Fix all auto-fixable rintenki issues",
+      kind: CodeActionKind.QuickFix,
+      diagnostics: fixableDiagnostics,
+      edit: {
+        changes: {
+          [params.textDocument.uri]: [
+            TextEdit.replace(
+              {
+                start: { line: 0, character: 0 },
+                end: { line: lastLine, character: Number.MAX_SAFE_INTEGER },
+              },
+              fixResult.output
+            ),
+          ],
+        },
+      },
+    },
+  ];
+});
+
+documents.listen(connection);
+connection.listen();

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "declaration": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
+}