tsfmt 0.0.0 → 0.2.1

package/dist/core/formatters/rules/spacing/BracketSpacingRule.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const ts = require("typescript");
+const BaseFormattingRule = require("../../BaseFormattingRule.js");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const ts__namespace = /* @__PURE__ */ _interopNamespaceDefault(ts);
+class BracketSpacingRule extends BaseFormattingRule.BaseFormattingRule {
+  constructor() {
+    super(...arguments);
+    this.name = "BracketSpacingRule";
+  }
+  apply(source, filePath) {
+    const config = this.getCodeStyleConfig();
+    if (!config || config.bracketSpacing === void 0) {
+      return source;
+    }
+    const sourceFile = ts__namespace.createSourceFile("temp.ts", source, ts__namespace.ScriptTarget.Latest, true, ts__namespace.ScriptKind.TS);
+    const changes = [];
+    const fullText = sourceFile.getFullText();
+    const visit = (node) => {
+      if (ts__namespace.isObjectLiteralExpression(node)) {
+        const openBraceEnd = node.getStart(sourceFile) + 1;
+        const closeBraceStart = node.getEnd() - 1;
+        if (node.properties.length > 0) {
+          if (config.bracketSpacing) {
+            const afterOpenBrace = fullText[openBraceEnd];
+            if (afterOpenBrace !== " " && afterOpenBrace !== "\n") {
+              changes.push({ pos: openBraceEnd, type: "add", text: " " });
+            }
+            const beforeCloseBrace = fullText[closeBraceStart - 1];
+            if (beforeCloseBrace !== " " && beforeCloseBrace !== "\n") {
+              changes.push({ pos: closeBraceStart, type: "add", text: " " });
+            }
+          } else {
+            let pos = openBraceEnd;
+            while (fullText[pos] === " " || fullText[pos] === "	") {
+              changes.push({ pos, type: "remove" });
+              pos++;
+            }
+            pos = closeBraceStart - 1;
+            while (pos >= 0 && (fullText[pos] === " " || fullText[pos] === "	")) {
+              changes.push({ pos, type: "remove" });
+              pos--;
+            }
+          }
+        }
+      }
+      if (ts__namespace.isNamedImports(node)) {
+        const parent = node.parent;
+        if (parent && ts__namespace.isImportClause(parent)) {
+          const openBraceEnd = node.getStart(sourceFile) + 1;
+          const closeBraceStart = node.getEnd() - 1;
+          if (node.elements.length > 0) {
+            if (config.bracketSpacing) {
+              const afterOpenBrace = fullText[openBraceEnd];
+              if (afterOpenBrace !== " ") {
+                changes.push({ pos: openBraceEnd, type: "add", text: " " });
+              }
+              const beforeCloseBrace = fullText[closeBraceStart - 1];
+              if (beforeCloseBrace !== " ") {
+                changes.push({ pos: closeBraceStart, type: "add", text: " " });
+              }
+            } else {
+              let pos = openBraceEnd;
+              while (fullText[pos] === " " || fullText[pos] === "	") {
+                changes.push({ pos, type: "remove" });
+                pos++;
+              }
+              pos = closeBraceStart - 1;
+              while (pos >= 0 && (fullText[pos] === " " || fullText[pos] === "	")) {
+                changes.push({ pos, type: "remove" });
+                pos--;
+              }
+            }
+          }
+        }
+      }
+      ts__namespace.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    changes.sort((a, b) => b.pos - a.pos);
+    let result = source;
+    for (const change of changes) {
+      if (change.type === "add") {
+        result = result.substring(0, change.pos) + (change.text || " ") + result.substring(change.pos);
+      } else {
+        result = result.substring(0, change.pos) + result.substring(change.pos + 1);
+      }
+    }
+    return result;
+  }
+}
+exports.BracketSpacingRule = BracketSpacingRule;

package/dist/core/formatters/rules/style/DocBlockCommentRule.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const BaseFormattingRule = require("../../BaseFormattingRule.js");
+class DocBlockCommentRule extends BaseFormattingRule.BaseFormattingRule {
+  constructor() {
+    super(...arguments);
+    this.name = "DocBlockCommentRule";
+  }
+  apply(source, filePath) {
+    const docBlockPattern = /\/\*\*\s*\n\s*\*\s*([^\n]*?)\s*\n\s*\*\//g;
+    return source.replace(docBlockPattern, (match, content) => {
+      if (content && content.trim()) {
+        return `/** ${content.trim()} */`;
+      }
+      return match;
+    });
+  }
+}
+exports.DocBlockCommentRule = DocBlockCommentRule;

package/dist/core/formatters/rules/style/IndentationRule.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const BaseFormattingRule = require("../../BaseFormattingRule.js");
+class IndentationRule extends BaseFormattingRule.BaseFormattingRule {
+  constructor() {
+    super(...arguments);
+    this.name = "IndentationRule";
+  }
+  apply(source, filePath) {
+    const config = this.getCodeStyleConfig();
+    if (!config?.indentStyle || !config.indentWidth) {
+      return source;
+    }
+    const indentWidth = config.indentWidth;
+    const lines = source.split("\n");
+    const result = [];
+    for (const line of lines) {
+      if (line.trim() === "") {
+        result.push(line);
+        continue;
+      }
+      const leadingWhitespace = line.match(/^\s*/)?.[0] || "";
+      const content = line.substring(leadingWhitespace.length);
+      let indentLevel = 0;
+      if (config.indentStyle === "space") {
+        const tabCount = (leadingWhitespace.match(/\t/g) || []).length;
+        const spaceCount = (leadingWhitespace.match(/ /g) || []).length;
+        indentLevel = tabCount + Math.floor(spaceCount / indentWidth);
+      } else {
+        const spaceCount = (leadingWhitespace.match(/ /g) || []).length;
+        const tabCount = (leadingWhitespace.match(/\t/g) || []).length;
+        indentLevel = tabCount + Math.floor(spaceCount / indentWidth);
+      }
+      let newIndent;
+      if (config.indentStyle === "space") {
+        newIndent = " ".repeat(indentLevel * indentWidth);
+      } else {
+        newIndent = "	".repeat(indentLevel);
+      }
+      result.push(newIndent + content);
+    }
+    return result.join("\n");
+  }
+}
+exports.IndentationRule = IndentationRule;

package/dist/core/formatters/rules/style/QuoteStyleRule.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const ts = require("typescript");
+const BaseFormattingRule = require("../../BaseFormattingRule.js");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const ts__namespace = /* @__PURE__ */ _interopNamespaceDefault(ts);
+class QuoteStyleRule extends BaseFormattingRule.BaseFormattingRule {
+  constructor() {
+    super(...arguments);
+    this.name = "QuoteStyleRule";
+  }
+  apply(source, filePath) {
+    const config = this.getCodeStyleConfig();
+    if (!config?.quoteStyle) {
+      return source;
+    }
+    const sourceFile = ts__namespace.createSourceFile("temp.ts", source, ts__namespace.ScriptTarget.Latest, true, ts__namespace.ScriptKind.TS);
+    const changes = [];
+    const visit = (node) => {
+      if (ts__namespace.isStringLiteral(node)) {
+        const nodeText = node.getText(sourceFile);
+        const currentQuote = nodeText[0];
+        const desiredQuote = config.quoteStyle === "single" ? "'" : '"';
+        if (currentQuote !== desiredQuote) {
+          const content = node.text;
+          const needsEscape = content.includes(desiredQuote);
+          if (!needsEscape) {
+            const newText = desiredQuote + content + desiredQuote;
+            changes.push({
+              start: node.getStart(sourceFile),
+              end: node.getEnd(),
+              text: newText
+            });
+          }
+        }
+      }
+      ts__namespace.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    changes.sort((a, b) => b.start - a.start);
+    let result = source;
+    for (const change of changes) {
+      result = result.substring(0, change.start) + change.text + result.substring(change.end);
+    }
+    return result;
+  }
+}
+exports.QuoteStyleRule = QuoteStyleRule;

package/dist/core/formatters/rules/style/SemicolonRule.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const ts = require("typescript");
+const BaseFormattingRule = require("../../BaseFormattingRule.js");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const ts__namespace = /* @__PURE__ */ _interopNamespaceDefault(ts);
+class SemicolonRule extends BaseFormattingRule.BaseFormattingRule {
+  constructor() {
+    super(...arguments);
+    this.name = "SemicolonRule";
+  }
+  apply(source, filePath) {
+    const config = this.getCodeStyleConfig();
+    if (!config?.semicolons) {
+      return source;
+    }
+    const sourceFile = ts__namespace.createSourceFile("temp.ts", source, ts__namespace.ScriptTarget.Latest, true, ts__namespace.ScriptKind.TS);
+    const changes = [];
+    const visit = (node) => {
+      if (ts__namespace.isVariableStatement(node) || ts__namespace.isExpressionStatement(node) || ts__namespace.isReturnStatement(node) || ts__namespace.isThrowStatement(node) || ts__namespace.isBreakStatement(node) || ts__namespace.isContinueStatement(node) || ts__namespace.isImportDeclaration(node) || ts__namespace.isExportDeclaration(node) || ts__namespace.isTypeAliasDeclaration(node)) {
+        const nodeEnd = node.getEnd();
+        const fullText = sourceFile.getFullText();
+        const hasSemicolon = fullText[nodeEnd - 1] === ";";
+        if (config.semicolons === "always" && !hasSemicolon) {
+          changes.push({ pos: nodeEnd, type: "add" });
+        } else if (config.semicolons === "never" && hasSemicolon) {
+          changes.push({ pos: nodeEnd - 1, type: "remove" });
+        }
+      }
+      if (ts__namespace.isInterfaceDeclaration(node) || ts__namespace.isClassDeclaration(node) || ts__namespace.isEnumDeclaration(node)) {
+        const nodeEnd = node.getEnd();
+        const fullText = sourceFile.getFullText();
+        const hasSemicolon = fullText[nodeEnd] === ";";
+        if (hasSemicolon) {
+          changes.push({ pos: nodeEnd, type: "remove" });
+        }
+      }
+      ts__namespace.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    changes.sort((a, b) => b.pos - a.pos);
+    let result = source;
+    for (const change of changes) {
+      if (change.type === "add") {
+        result = result.substring(0, change.pos) + ";" + result.substring(change.pos);
+      } else {
+        result = result.substring(0, change.pos) + result.substring(change.pos + 1);
+      }
+    }
+    return result;
+  }
+}
+exports.SemicolonRule = SemicolonRule;

package/dist/core/formatters/rules/style/StructuralIndentationRule.js

@@ -0,0 +1,250 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const BaseFormattingRule = require("../../BaseFormattingRule.js");
+class StructuralIndentationRule extends BaseFormattingRule.BaseFormattingRule {
+  constructor() {
+    super(...arguments);
+    this.name = "StructuralIndentationRule";
+  }
+  skipString(source, start, quote) {
+    let i = start + 1;
+    let newlines = 0;
+    const isTemplate = quote === "`";
+    while (i < source.length) {
+      const char = source[i];
+      if (char === "\n") {
+        newlines++;
+        i++;
+        continue;
+      }
+      if (char === "\\") {
+        i += 2;
+        continue;
+      }
+      if (isTemplate && char === "$" && source[i + 1] === "{") {
+        i += 2;
+        let braceCount = 1;
+        while (i < source.length && braceCount > 0) {
+          if (source[i] === "\n") {
+            newlines++;
+          } else if (source[i] === "{") {
+            braceCount++;
+          } else if (source[i] === "}") {
+            braceCount--;
+          } else if (source[i] === '"' || source[i] === "'" || source[i] === "`") {
+            const result = this.skipString(source, i, source[i]);
+            i = result.pos;
+            newlines += result.newlines;
+            continue;
+          }
+          i++;
+        }
+        continue;
+      }
+      if (char === quote) {
+        return { pos: i + 1, newlines };
+      }
+      i++;
+    }
+    return { pos: i, newlines };
+  }
+  isRegexStart(source, index) {
+    let i = index - 1;
+    while (i >= 0 && (source[i] === " " || source[i] === "	")) {
+      i--;
+    }
+    if (i < 0) return true;
+    const char = source[i];
+    const regexPreceders = ["(", ",", "=", ":", "[", "!", "&", "|", "?", "{", "}", ";", "\n", "return", "case"];
+    if (regexPreceders.includes(char)) {
+      return true;
+    }
+    const keywords = ["return", "case", "typeof", "void", "delete", "throw", "in", "instanceof"];
+    for (const kw of keywords) {
+      if (index >= kw.length && source.substring(index - kw.length, index).endsWith(kw)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  skipRegex(source, start) {
+    let i = start + 1;
+    let inCharClass = false;
+    while (i < source.length) {
+      const char = source[i];
+      if (char === "\\") {
+        i += 2;
+        continue;
+      }
+      if (char === "[") {
+        inCharClass = true;
+      } else if (char === "]") {
+        inCharClass = false;
+      } else if (char === "/" && !inCharClass) {
+        i++;
+        while (i < source.length && /[gimsuy]/.test(source[i])) {
+          i++;
+        }
+        return i;
+      } else if (char === "\n") {
+        return i;
+      }
+      i++;
+    }
+    return i;
+  }
+  getLineIndentLevel(line, indentWidth) {
+    const leadingWhitespace = line.match(/^[\t ]*/)?.[0] || "";
+    const tabCount = (leadingWhitespace.match(/\t/g) || []).length;
+    const spaceCount = (leadingWhitespace.match(/ /g) || []).length;
+    return tabCount + Math.floor(spaceCount / indentWidth);
+  }
+  startsWithClosingBracket(trimmedLine) {
+    return /^[}\])]/.test(trimmedLine);
+  }
+  findBracketFixes(source, lines, indentWidth) {
+    const fixes = [];
+    const stack = [];
+    const lineIndentCorrections = /* @__PURE__ */ new Map();
+    let i = 0;
+    let line = 0;
+    let column = 0;
+    let lineStart = 0;
+    const openBrackets = {
+      "{": "}",
+      "[": "]",
+      "(": ")"
+    };
+    const closeBrackets = {
+      "}": "{",
+      "]": "[",
+      ")": "("
+    };
+    while (i < source.length) {
+      const char = source[i];
+      if (char === "\n") {
+        line++;
+        column = 0;
+        lineStart = i + 1;
+        i++;
+        continue;
+      }
+      if (char === '"' || char === "'" || char === "`") {
+        const result = this.skipString(source, i, char);
+        i = result.pos;
+        line += result.newlines;
+        if (result.newlines > 0) {
+          let lastNewline = i - 1;
+          while (lastNewline >= 0 && source[lastNewline] !== "\n") {
+            lastNewline--;
+          }
+          lineStart = lastNewline + 1;
+        }
+        column = i - lineStart;
+        continue;
+      }
+      if (char === "/" && source[i + 1] === "/") {
+        while (i < source.length && source[i] !== "\n") {
+          i++;
+        }
+        continue;
+      }
+      if (char === "/" && source[i + 1] === "*") {
+        i += 2;
+        while (i < source.length - 1 && !(source[i] === "*" && source[i + 1] === "/")) {
+          if (source[i] === "\n") {
+            line++;
+            lineStart = i + 1;
+          }
+          i++;
+        }
+        i += 2;
+        column = i - lineStart;
+        continue;
+      }
+      if (char === "/" && this.isRegexStart(source, i)) {
+        i = this.skipRegex(source, i);
+        column = i - lineStart;
+        continue;
+      }
+      if (openBrackets[char]) {
+        const lineIndent = lineIndentCorrections.has(line) ? lineIndentCorrections.get(line) : this.getLineIndentLevel(lines[line], indentWidth);
+        stack.push({
+          char,
+          position: i,
+          line,
+          lineIndent
+        });
+      }
+      if (closeBrackets[char]) {
+        const expectedOpen = closeBrackets[char];
+        let matchIndex = -1;
+        for (let j = stack.length - 1; j >= 0; j--) {
+          if (stack[j].char === expectedOpen) {
+            matchIndex = j;
+            break;
+          }
+        }
+        if (matchIndex !== -1) {
+          const openBracket = stack[matchIndex];
+          stack.splice(matchIndex, 1);
+          if (line !== openBracket.line) {
+            const currentIndent = this.getLineIndentLevel(lines[line], indentWidth);
+            const trimmedLine = lines[line].trimStart();
+            if (this.startsWithClosingBracket(trimmedLine)) {
+              if (currentIndent !== openBracket.lineIndent) {
+                fixes.push({
+                  position: i,
+                  line,
+                  column,
+                  targetIndent: openBracket.lineIndent
+                });
+                if (!lineIndentCorrections.has(line)) {
+                  lineIndentCorrections.set(line, openBracket.lineIndent);
+                }
+              }
+            }
+          }
+        }
+      }
+      i++;
+      column++;
+    }
+    return fixes;
+  }
+  apply(source, filePath) {
+    const config = this.getCodeStyleConfig();
+    if (!config?.indentStyle || !config.indentWidth) {
+      return source;
+    }
+    const indentWidth = config.indentWidth;
+    const indentUnit = config.indentStyle === "tab" ? "	" : " ".repeat(indentWidth);
+    const lines = source.split("\n");
+    const fixes = this.findBracketFixes(source, lines, indentWidth);
+    if (fixes.length === 0) {
+      return source;
+    }
+    const fixesByLine = /* @__PURE__ */ new Map();
+    for (const fix of fixes) {
+      if (!fixesByLine.has(fix.line)) {
+        fixesByLine.set(fix.line, []);
+      }
+      fixesByLine.get(fix.line).push(fix);
+    }
+    const result = [];
+    for (let i = 0; i < lines.length; i++) {
+      const lineFixes = fixesByLine.get(i);
+      if (lineFixes && lineFixes.length > 0) {
+        lineFixes.sort((a, b) => a.column - b.column);
+        const primaryFix = lineFixes[0];
+        const trimmedLine = lines[i].trimStart();
+        const newIndent = indentUnit.repeat(primaryFix.targetIndent);
+        result.push(newIndent + trimmedLine);
+      } else {
+        result.push(lines[i]);
+      }
+    }
+    return result.join("\n");
+  }
+}
+exports.StructuralIndentationRule = StructuralIndentationRule;