Improve the withFormatting function and config file

Author: arpitkuriyal

language-server/.DS_Store

@@ -48,38 +48,26 @@ export class ExtractSubSchemaToDefs {
         return [];
       }
 
-      let definitionsNode;
-      for (const schemaNode of SchemaNode.allNodes(node.root)) {
-        if (schemaNode.keywordUri === "https://json-schema.org/keyword/definitions") {
-          definitionsNode = schemaNode;
-          break;
-        }
-      }
-
+      let definitionsNode = SchemaNode.step("$defs", node.root) ?? SchemaNode.step("definitions", node.root);
       let highestDefNumber = 0;
       if (definitionsNode) {
         let defNodeKeys = SchemaNode.keys(definitionsNode);
         for (const key of defNodeKeys) {
-          /** @type {string} */
-          const keyValue = String(SchemaNode.value(key));
-          /** @type RegExpMatchArray | null */
+          const keyValue = /** @type {string} */ (SchemaNode.value(key));
+
           const match = /^def(\d+)$/.exec(keyValue);
           if (match) {
             highestDefNumber = Math.max(parseInt(match[1], 10), highestDefNumber);
           }
         }
       }
-      let defName = getKeywordName(
-        /** @type {string} */ (node.root.dialectUri),
-        "https://json-schema.org/keyword/definitions"
-      );
 
-      let newDefName = `def${highestDefNumber + 1}`;
+      let defName = getKeywordName(/** @type {string} */(node.root.dialectUri), "https://json-schema.org/keyword/definitions");
+      const newDefName = `def${highestDefNumber + 1}`;
       const settings = await this.configuration.get();
       const extractedDef = schemaDocument.textDocument.getText(range);
       const defOffset = definitionsNode ? definitionsNode.offset + 1 : node.root.offset + node.root.textLength - 2;
-      const formattedTextEdit = await withFormatting(
-        schemaDocument.textDocument,
+      const formattedTextEdit = withFormatting(
         schemaDocument.textDocument.getText(),
         {
           range: {
@@ -91,6 +79,7 @@ export class ExtractSubSchemaToDefs {
         settings.tabSize,
         settings.insertSpaces,
         settings.detectIndentation,
+        settings.endOfLine,
         defOffset
       );
 

language-server/src/.DS_Store

@@ -14,6 +14,7 @@ import ignore from "ignore";
  *   tabSize: number;
  *   insertSpaces: boolean;
  *   detectIndentation: boolean;
+ *   endOfLine: string;
  * }} DocumentSettings
  */
 
@@ -87,34 +88,31 @@ export class Configuration {
   /** @type (documentUri?: string) => Promise<DocumentSettings> */
   async get(documentUri) {
     if (!this.#settings) {
-      /** @type {unknown} */
-      const extensionSettings = await this.#server.workspace.getConfiguration({
-        section: "jsonSchemaLanguageServer"
-      });
-      /** @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 }} */
+      /** @type {unknown[]} */
+      const config = await this.#server.workspace.getConfiguration([
+        { section: "jsonSchemaLanguageServer" },
+        { section: "editor", scopeUri: documentUri },
+        { section: "files.eol" }
+      ]);
+      const [extensionSettings, editorSettings, eol] = /** @type [{ defaultDialect?: string; schemaFilePatterns?: string[] },{ tabSize?: number; insertSpaces?: boolean; detectIndentation?: boolean }, string ] */ (config);
+      /** @type {{ tabSize?: number; insertSpaces?: boolean; detectIndentation?: boolean, endOfLine?: string }} */
       const indentationSettings = {
-        tabSize: editorSettings?.tabSize,
-        insertSpaces: editorSettings?.insertSpaces,
-        detectIndentation: editorSettings?.detectIndentation
+        tabSize: editorSettings?.tabSize ?? this.#defaultSettings.tabSize,
+        insertSpaces: editorSettings?.insertSpaces ?? this.#defaultSettings.insertSpaces,
+        detectIndentation: editorSettings?.detectIndentation ?? this.#defaultSettings.detectIndentation,
+        endOfLine: eol
       };
 
-      // Merge settings with proper priority
       const fullSettings = {
         ...this.#defaultSettings,
-        ...settings,
+        ...extensionSettings,
         ...indentationSettings
       };
+
       this.#settings = /** @type DocumentSettings */ (fullSettings);
       this.#matcher = undefined;
     }
+
     return /** @type DocumentSettings */ (this.#settings);
   }
 

language-server/src/features/.DS_Store

@@ -1,6 +1,6 @@
 import { getKeywordId, getKeywordName } from "@hyperjump/json-schema/experimental";
 import { resolveIri as hyperjumpResolveIri } from "@hyperjump/uri";
-import { readdir, readFile } from "node:fs/promises";
+import { readdir } from "node:fs/promises";
 import { join, relative } from "node:path";
 import { URI } from "vscode-uri";
 import detectIndent from "detect-indent";
@@ -10,7 +10,6 @@ import * as jsoncParser from "jsonc-parser";
  * @import { SchemaNode as SchemaNodeType } from "../model/schema-node.js"
  * @import { Ignore } from "ignore"
  * @import { TextEdit } from "vscode-languageserver"
- * @import { TextDocument } from "vscode-languageserver-textdocument"
  */
 
 
@@ -113,12 +112,10 @@ export const readDirRecursive = async function* (path, filter, cwd) {
   }
 };
 
-/** @type (uri: string, defaultTabSize: number, insertSpaces: boolean, detectIndentation: boolean) => Promise<{ type: 'tabs' | 'spaces', size: number }> */
-const detectIndentationFromContent = async (uri, defaultTabSize, insertSpaces, detectIndentation) => {
+/** @type (text: string, defaultTabSize: number, insertSpaces: boolean, detectIndentation: boolean) => { type: 'tabs' | 'spaces', size: number } */
+const detectIndentationFromContent = (text, defaultTabSize, insertSpaces, detectIndentation) => {
   try {
-    const filePath = URI.parse(uri).fsPath;
-    const content = await readFile(filePath, "utf-8");
-    const { amount } = detectIndent(content);
+    const { amount } = detectIndent(text);
 
     if (!detectIndentation) {
       return { type: "spaces", size: defaultTabSize };
@@ -132,18 +129,15 @@ const detectIndentationFromContent = async (uri, defaultTabSize, insertSpaces, d
   }
 };
 
-/**
-* @type (textDocument: TextDocument, text: string, textEdit: TextEdit,
-* defaultTabSize: number, insertSpaces: boolean, detectIndentation: boolean, offset: number) => Promise<TextEdit>
-*/
-export const withFormatting = async (textDocument, text, textEdit, defaultTabSize, insertSpaces, detectIndentation, offset) => {
-  const detectedIndent = await detectIndentationFromContent(textDocument.uri, defaultTabSize, insertSpaces, detectIndentation);
+/** @type (text: string, textEdit: TextEdit,defaultTabSize: number, insertSpaces: boolean, detectIndentation: boolean, eol: string, offset: number) => TextEdit */
+export const withFormatting = (text, textEdit, defaultTabSize, insertSpaces, detectIndentation, eol, offset) => {
+  const detectedIndent = detectIndentationFromContent(text, defaultTabSize, insertSpaces, detectIndentation);
 
   const formattingOptions = {
     insertSpaces: detectedIndent?.type === "spaces",
     tabSize: detectedIndent?.size ?? defaultTabSize,
     keepLines: true,
-    eol: "\n"
+    eol: eol
   };
 
   const newText = jsoncParser.applyEdits(text, [