make a function to detect the indentation of the currect file

Author: arpitkuriyal

language-server/.DS_Store

@@ -16,9 +16,11 @@
   "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",
+    "vscode": "^1.1.37",
     "vscode-languageserver": "^9.0.1",
     "vscode-languageserver-textdocument": "^1.0.12",
     "vscode-uri": "^3.0.8"

language-server/package-lock.json

@@ -50,7 +50,7 @@ export const buildServer = (connection) => {
   new GotoDefinitionFeature(server, schemas);
   new FindReferencesFeature(server, schemas);
   new HoverFeature(server, schemas);
-  new ExtractSubSchemaToDefs(server, schemas);
+  new ExtractSubSchemaToDefs(server, schemas, configuration);
 
   // TODO: It's awkward that diagnostics needs a variable
   const diagnostics = new DiagnosticsFeature(server, [

language-server/package.json

@@ -5,38 +5,37 @@ import {
 import { getKeywordName } from "@hyperjump/json-schema/experimental";
 import * as SchemaDocument from "../../model/schema-document.js";
 import * as SchemaNode from "../../model/schema-node.js";
-import * as jsoncParser from "jsonc-parser";
+import { formatNewDef } from "../../util/util.js";
+
 /**
- * @import { Server } from "../../services/server.js"
- * @import { Schemas } from "../../services/schemas.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) {
+  constructor(server, schemas, configuration) {
     this.server = server;
     this.schemas = schemas;
+    this.configuration = configuration;
     server.onInitialize(() => ({
       capabilities: {
         codeActionProvider: true
       }
     }));
 
-    // Helper function to format new def using jsonc-parser
-    const formatNewDef = (/** @type {string} */ newDefText) => {
-      try {
-        /** @type {unknown} */
-        const parsedDef = jsoncParser.parse(newDefText);
-        return JSON.stringify(parsedDef, null, 2).replace(/\n/g, "\n    ");
-      } catch {
-        return newDefText;
+    server.onCodeAction(async ({ textDocument, range }) => {
+      if (range.start.line === range.end.line && range.start.character === range.end.character) {
+        return [];
       }
-    };
 
-    server.onCodeAction(async ({ textDocument, range }) => {
       const uri = textDocument.uri;
       let schemaDocument = await schemas.getOpen(uri);
       if (!schemaDocument) {
@@ -48,35 +47,40 @@ export class ExtractSubSchemaToDefs {
       if (!node?.isSchema) {
         return [];
       }
+
       let definitionsNode;
       for (const schemaNode of SchemaNode.allNodes(node.root)) {
         if (schemaNode.keywordUri === "https://json-schema.org/keyword/definitions") {
           definitionsNode = schemaNode;
           break;
         }
       }
+
       let highestDefNumber = 0;
       if (definitionsNode) {
-        const defsContent = schemaDocument.textDocument.getText().slice(
-          definitionsNode.offset,
-          definitionsNode.offset + definitionsNode.textLength
-        );
-        const defMatches = [...defsContent.matchAll(/"def(\d+)":/g)];
-        defMatches.forEach((match) =>
-          highestDefNumber = Math.max(highestDefNumber, parseInt(match[1], 10))
-        );
+        let defNodeKeys = SchemaNode.keys(definitionsNode);
+        for (const key of defNodeKeys) {
+          /** @type {string} */
+          const keyValue = String(SchemaNode.value(key));
+          /** @type RegExpMatchArray | null */
+          const match = /^def(\d+)$/.exec(keyValue);
+          if (match) {
+            highestDefNumber = Math.max(parseInt(match[1], 10), highestDefNumber);
+          }
+        }
       }
       let newDefName = `def${highestDefNumber + 1}`;
+      const settings = await this.configuration.get();
       const extractedDef = schemaDocument.textDocument.getText(range);
-      const newFormattedDef = formatNewDef(extractedDef);
+      const newFormattedDef = await formatNewDef(textDocument.uri, extractedDef, settings.tabSize, settings.insertSpaces, settings.detectIndentation);
       let defName = getKeywordName(
-      /** @type {string} */ (node.root.dialectUri),
+        /** @type {string} */ (node.root.dialectUri),
         "https://json-schema.org/keyword/definitions"
       );
 
       /** @type {CodeAction} */
       const codeAction = {
-        title: `Extract '${newDefName}' to $defs`,
+        title: `Extract '${newDefName}' to ${defName}`,
         kind: CodeActionKind.RefactorExtract,
         edit: {
           documentChanges: [

language-server/src/.DS_Store

@@ -11,6 +11,9 @@ import ignore from "ignore";
  * @typedef {{
  *   defaultDialect?: string;
  *   schemaFilePatterns: string[];
+ *   tabSize: number;
+ *   insertSpaces: boolean;
+ *   detectIndentation: boolean;
  * }} DocumentSettings
  */
 
@@ -81,20 +84,37 @@ export class Configuration {
     });
   }
 
-  /** @type () => Promise<DocumentSettings> */
-  async get() {
+  /** @type (documentUri?: string) => Promise<DocumentSettings> */
+  async get(documentUri) {
     if (!this.#settings) {
-      /** @type unknown */
-      const result = await this.#server.workspace.getConfiguration({
+      /** @type {unknown} */
+      const extensionSettings = await this.#server.workspace.getConfiguration({
         section: "jsonSchemaLanguageServer"
       });
-      const settings = result ?? {};
-      /** @type unknown */
-      const fullSettings = { ...this.#defaultSettings, ...settings };
+      /** @type {{ tabSize?: number; insertSpaces?: boolean; detectIndentation?: boolean }} */
+      const editorSettings = /** @type {unknown} */ (
+        await this.#server.workspace.getConfiguration({
+          section: "editor",
+          scopeUri: documentUri
+        })
+      ) || {};
+      const settings = extensionSettings ?? {};
+      /** @type {{ tabSize?: number; insertSpaces?: boolean; detectIndentation?: boolean }} */
+      const indentationSettings = {
+        tabSize: editorSettings?.tabSize,
+        insertSpaces: editorSettings?.insertSpaces,
+        detectIndentation: editorSettings?.detectIndentation
+      };
+
+      // Merge settings with proper priority
+      const fullSettings = {
+        ...this.#defaultSettings,
+        ...settings,
+        ...indentationSettings
+      };
       this.#settings = /** @type DocumentSettings */ (fullSettings);
       this.#matcher = undefined;
     }
-
     return /** @type DocumentSettings */ (this.#settings);
   }
 

language-server/src/build-server.js

@@ -1,9 +1,10 @@
 import { getKeywordId, getKeywordName } from "@hyperjump/json-schema/experimental";
 import { resolveIri as hyperjumpResolveIri } from "@hyperjump/uri";
-import { readdir } from "node:fs/promises";
+import { readdir, readFile } from "node:fs/promises";
 import { join, relative } from "node:path";
 import { URI } from "vscode-uri";
-
+import detectIndent from "detect-indent";
+import * as jsoncParser from "jsonc-parser";
 /**
  * @import { SchemaNode as SchemaNodeType } from "../model/schema-node.js"
  * @import { Ignore } from "ignore"
@@ -108,3 +109,38 @@ export const readDirRecursive = async function* (path, filter, cwd) {
     }
   }
 };
+
+/** @type (uri: string, defaultTabSize: number, insertSpaces: boolean, detectIndentation: boolean) => Promise<{ type: 'tabs' | 'spaces', size: number }> */
+export const detectIndentationFromContent = async (uri, defaultTabSize, insertSpaces, detectIndentation) => {
+  try {
+    const filePath = URI.parse(uri).fsPath;
+    const content = await readFile(filePath, "utf-8");
+    const { amount } = detectIndent(content);
+
+    if (!detectIndentation) {
+      return { type: "spaces", size: defaultTabSize };
+    }
+
+    return insertSpaces
+      ? { type: "spaces", size: amount }
+      : { type: "tabs", size: amount };
+  } catch {
+    return { type: "spaces", size: defaultTabSize };
+  }
+};
+
+/** @type (uri: string, newDefText: string, defaultTabSize: number, insertSpaces: boolean, detectIndentation: boolean) => Promise<string>} */
+export const formatNewDef = async (uri, newDefText, defaultTabSize, insertSpaces, detectIndentation) => {
+  try {
+    const detectedIndent = await detectIndentationFromContent(uri, defaultTabSize, insertSpaces, detectIndentation);
+
+    const edits = jsoncParser.format(newDefText, undefined, {
+      insertSpaces: detectedIndent?.type === "spaces",
+      tabSize: detectedIndent?.size ?? defaultTabSize
+    });
+
+    return jsoncParser.applyEdits(newDefText, edits).replace(/\n/g, `\n${"  ".repeat(detectedIndent?.size ?? defaultTabSize)}`);
+  } catch {
+    return newDefText;
+  }
+};