Added codeAction (extract subSchema to defs)

.gitignore

@@ -5,3 +5,5 @@ dist/
 .vscode/
 scratch/
 TODO
+.DS_Store
+

language-server/package.json

@@ -16,6 +16,7 @@
   "keywords": [],
   "dependencies": {
     "chokidar": "^4.0.1",
+    "detect-indent": "^7.0.1",
     "ignore": "^7.0.1",
     "jsonc-parser": "^3.3.1",
     "merge-anything": "^6.0.2",

language-server/src/build-server.js

@@ -22,6 +22,7 @@ import { ValidationErrorsDiagnosticsProvider } from "./features/diagnostics/vali
 import { IfThenCompletionProvider } from "./features/completion/if-then-completion.js";
 import { KeywordCompletionProvider } from "./features/completion/keyword-completion.js";
 import { SchemaCompletionProvider } from "./features/completion/schema-completion.js";
+import { ExtractSubSchemaToDefs } from "./features/codeAction/extractSubschema.js";
 
 // Hyperjump
 import { removeMediaTypePlugin } from "@hyperjump/browser";
@@ -49,6 +50,7 @@ export const buildServer = (connection) => {
   new GotoDefinitionFeature(server, schemas);
   new FindReferencesFeature(server, schemas);
   new HoverFeature(server, schemas);
+  new ExtractSubSchemaToDefs(server, schemas, configuration);
 
   // TODO: It's awkward that diagnostics needs a variable
   const diagnostics = new DiagnosticsFeature(server, [

language-server/src/features/codeAction/extractSubschema.js

@@ -0,0 +1,111 @@
+import {
+  CodeActionKind,
+  TextDocumentEdit
+} from "vscode-languageserver";
+import { getKeywordName } from "@hyperjump/json-schema/experimental";
+import * as SchemaDocument from "../../model/schema-document.js";
+import * as SchemaNode from "../../model/schema-node.js";
+import { withFormatting } from "../../util/util.js";
+
+/**
+ * @import { Server } from "../../services/server.js";
+ * @import { Schemas } from "../../services/schemas.js";
+ * @import { CodeAction } from "vscode-languageserver";
+ * @import { Configuration } from "../../services/configuration.js";
+ */
+
+
+export class ExtractSubSchemaToDefs {
+  /**
+   * @param {Server} server
+   * @param {Schemas} schemas
+   * @param {Configuration} configuration
+   */
+  constructor(server, schemas, configuration) {
+    this.server = server;
+    this.schemas = schemas;
+    this.configuration = configuration;
+
+    server.onInitialize(() => ({
+      capabilities: {
+        codeActionProvider: true
+      }
+    }));
+
+    server.onCodeAction(async ({ textDocument, range }) => {
+      if (range.start.line === range.end.line && range.start.character === range.end.character) {
+        return [];
+      }
+
+      const uri = textDocument.uri;
+      let schemaDocument = await schemas.getOpen(uri);
+      if (!schemaDocument) {
+        return [];
+      }
+
+      const offset = schemaDocument.textDocument.offsetAt(range.start);
+      const node = SchemaDocument.findNodeAtOffset(schemaDocument, offset);
+      if (!node?.isSchema) {
+        return [];
+      }
+
+      const dialectUri = /** @type {string} */ (node.root.dialectUri);
+      const definitionsKeyword = getKeywordName(dialectUri, "https://json-schema.org/keyword/definitions");
+      const definitionsNode = SchemaNode.step(definitionsKeyword, node.root);
+      let highestDefNumber = 0;
+      if (definitionsNode) {
+        let defNodeKeys = SchemaNode.keys(definitionsNode);
+        for (const key of defNodeKeys) {
+          const keyValue = /** @type {string} */ (SchemaNode.value(key));
+
+          const match = /^def(\d+)$/.exec(keyValue);
+          if (match) {
+            highestDefNumber = Math.max(parseInt(match[1], 10), highestDefNumber);
+          }
+        }
+      }
+
+      const newDefName = `def${highestDefNumber + 1}`;
+      const extractedDef = schemaDocument.textDocument.getText(range);
+      const settings = await this.configuration.get();
+      const lastSubschema = node.root.children.slice(-1)[0];
+      const lastSubschemaPosition = lastSubschema.offset + lastSubschema.textLength;
+      const lastDefinition = definitionsNode?.children.at(-1);
+      const lastDefinitionPosition = (lastDefinition)
+        ? lastDefinition.offset + lastDefinition.textLength
+        : /** @type {number} */ (definitionsNode?.offset) + 1;
+      /** @type {CodeAction} */
+      const codeAction = {
+        title: `Extract '${newDefName}' to ${definitionsKeyword}`,
+        kind: CodeActionKind.RefactorExtract,
+        edit: {
+          documentChanges: [
+            TextDocumentEdit.create({ uri: textDocument.uri, version: null }, [
+              {
+                range: range,
+                newText: `{ "$ref": "#/${definitionsKeyword}/${newDefName}" }`
+              },
+              definitionsNode
+                ? withFormatting(schemaDocument.textDocument, {
+                    range: {
+                      start: schemaDocument.textDocument.positionAt(lastDefinitionPosition),
+                      end: schemaDocument.textDocument.positionAt(lastDefinitionPosition)
+                    },
+                    newText: lastDefinition ? `,\n"${newDefName}": ${extractedDef}` : `\n"${newDefName}": ${extractedDef}`
+                  }, settings)
+                : withFormatting(schemaDocument.textDocument, {
+                    range: {
+                      start: schemaDocument.textDocument.positionAt(lastSubschemaPosition),
+                      end: schemaDocument.textDocument.positionAt(lastSubschemaPosition)
+                    },
+                    newText: `,\n"${definitionsKeyword}": {\n"${newDefName}": ${extractedDef}\n}`
+                  }, settings)
+            ])
+          ]
+        }
+      };
+
+      return [codeAction];
+    });
+  }
+}