tsfmt 0.0.0 → 0.2.1

package/dist/core/pipeline/FormatterPipeline.js

@@ -0,0 +1,252 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const fs = require("fs/promises");
+const path = require("path");
+require("../config/ConfigDefaults.js");
+require("../config/ConfigLoader.js");
+const ConfigTypes = require("../config/ConfigTypes.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 fs__namespace = /* @__PURE__ */ _interopNamespaceDefault(fs);
+const path__namespace = /* @__PURE__ */ _interopNamespaceDefault(path);
+class FormatterError extends Error {
+  constructor(formatterName, filePath, originalError) {
+    super(`Formatter '${formatterName}' failed for file '${filePath}': ${originalError.message}`);
+    this.formatterName = formatterName;
+    this.filePath = filePath;
+    this.originalError = originalError;
+    this.name = "FormatterError";
+  }
+}
+class FormatterPipeline {
+  constructor(config, container) {
+    this.config = config;
+    this.container = container;
+    this.rules = /* @__PURE__ */ new Map();
+    this.formatterOrder = config.formatterOrder || [
+      ConfigTypes.FormatterOrder.IndexGeneration,
+      ConfigTypes.FormatterOrder.CodeStyle,
+      ConfigTypes.FormatterOrder.ImportOrganization,
+      ConfigTypes.FormatterOrder.ASTTransformation,
+      ConfigTypes.FormatterOrder.Spacing
+    ];
+    this.initializeRules();
+  }
+  /** Extract type name from call stack by reading source code */
+  extractTypeNameFromStack() {
+    const stack = new Error().stack;
+    if (!stack) {
+      throw new Error("Cannot determine type name from stack");
+    }
+    const lines = stack.split("\n");
+    for (const line of lines) {
+      if (line.includes("FormatterPipeline.extractTypeNameFromStack") || line.includes("FormatterPipeline.addRule")) {
+        continue;
+      }
+      const match = line.match(/at\s+.*\s+\((.+):(\d+):(\d+)\)/);
+      if (match) {
+        const [, filePath, lineNum] = match;
+        try {
+          const fs2 = require("fs");
+          const sourceCode = fs2.readFileSync(filePath, "utf8");
+          const sourceLines = sourceCode.split("\n");
+          const callLine = sourceLines[parseInt(lineNum) - 1];
+          const typeMatch = callLine.match(/\.addRule<([^>]+)>/);
+          if (typeMatch && typeMatch[1]) {
+            return typeMatch[1].trim();
+          }
+        } catch (error) {
+          continue;
+        }
+      }
+    }
+    throw new Error("Cannot extract type name from addRule call. Use format: addRule<RuleName>(order)");
+  }
+  /** Add a rule to the pipeline at a specific order position using magical syntax */
+  addRule(order) {
+    if (!this.rules.has(order)) {
+      this.rules.set(order, []);
+    }
+    const typeName = this.extractTypeNameFromStack();
+    const ruleInstance = this.container.resolve(typeName);
+    this.rules.get(order).push(ruleInstance);
+  }
+  /** Add a rule to the pipeline by explicit name - used by Vite build transformation */
+  // @ts-ignore - This method is called after Vite build transformation replaces addRule<T>() calls
+  addRuleByName(ruleName, order) {
+    if (!this.rules.has(order)) {
+      this.rules.set(order, []);
+    }
+    const ruleInstance = this.container.resolve(ruleName);
+    this.rules.get(order).push(ruleInstance);
+  }
+  /** Get all files in a directory recursively */
+  async getFilesRecursively(dirPath, extensions) {
+    const files = [];
+    const entries = await fs__namespace.readdir(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path__namespace.join(dirPath, entry.name);
+      if (entry.isDirectory()) {
+        if (["node_modules", ".git", "dist", "build"].includes(entry.name)) {
+          continue;
+        }
+        const subFiles = await this.getFilesRecursively(fullPath, extensions);
+        files.push(...subFiles);
+      } else if (entry.isFile()) {
+        if (extensions.some((ext) => entry.name.endsWith(ext))) {
+          files.push(fullPath);
+        }
+      }
+    }
+    return files;
+  }
+  /** Check if source code contains a tsfmt-ignore directive */
+  shouldIgnoreFile(source) {
+    const header = source.slice(0, 1e3);
+    return /(?:\/\/|\/\*|\*)\s*tsfmt-ignore|^\s*tsfmt-ignore\s*$/m.test(header);
+  }
+  /**
+  * Format a file using the configured formatters in sequence
+  * @param filePath - Absolute path to the file to format
+  * @param dryRun - If true, don't write changes to disk
+  * @returns Pipeline context with execution details
+  * @throws FormatterError if any formatter fails (fail-fast)
+  */
+  async formatFile(filePath, dryRun = false) {
+    const originalSource = await fs__namespace.readFile(filePath, "utf-8");
+    if (this.shouldIgnoreFile(originalSource)) {
+      return {
+        filePath,
+        originalSource,
+        currentSource: originalSource,
+        executions: [],
+        changed: false,
+        dryRun
+      };
+    }
+    const context = {
+      filePath,
+      originalSource,
+      currentSource: originalSource,
+      executions: [],
+      changed: false,
+      dryRun
+    };
+    for (const order of this.formatterOrder) {
+      const rulesAtOrder = this.rules.get(order);
+      if (!rulesAtOrder || rulesAtOrder.length === 0) {
+        continue;
+      }
+      for (const rule of rulesAtOrder) {
+        const execution = {
+          formatterName: rule.name,
+          order,
+          changed: false
+        };
+        try {
+          const beforeSource = context.currentSource;
+          const afterSource = rule.apply(context.currentSource, filePath);
+          execution.changed = beforeSource !== afterSource;
+          context.currentSource = afterSource;
+          if (execution.changed) {
+            context.changed = true;
+          }
+          context.executions.push(execution);
+        } catch (error) {
+          execution.error = error;
+          context.executions.push(execution);
+          throw new FormatterError(rule.name, filePath, error);
+        }
+      }
+    }
+    if (context.changed && !dryRun) {
+      await fs__namespace.writeFile(filePath, context.currentSource, "utf-8");
+    }
+    return context;
+  }
+  /**
+  * Format multiple files in sequence
+  * @param filePaths - Array of file paths to format
+  * @param dryRun - If true, don't write changes to disk
+  * @returns Array of pipeline contexts for each file
+  * @throws FormatterError if any formatter fails for any file
+  */
+  async formatFiles(filePaths, dryRun = false) {
+    const results = [];
+    for (const filePath of filePaths) {
+      const context = await this.formatFile(filePath, dryRun);
+      results.push(context);
+    }
+    return results;
+  }
+  /**
+  * Format all files in a directory recursively
+  * @param dirPath - Directory path to format
+  * @param dryRun - If true, don't write changes to disk
+  * @param extensions - File extensions to include (default: .ts, .tsx, .js, .jsx)
+  * @returns Array of pipeline contexts for each file
+  */
+  async formatDirectory(dirPath, dryRun = false, extensions = [".ts", ".tsx", ".js", ".jsx"]) {
+    const files = await this.getFilesRecursively(dirPath, extensions);
+    return this.formatFiles(files, dryRun);
+  }
+  /** Get the list of formatters in execution order */
+  getFormatterOrder() {
+    return [...this.formatterOrder];
+  }
+  /** Get all rules at a specific order position */
+  getRulesAtOrder(order) {
+    return this.rules.get(order) || [];
+  }
+  /** Check if any rules are configured */
+  hasRules() {
+    return this.rules.size > 0;
+  }
+  /** Initialize rules based on configuration using clean DI pattern */
+  initializeRules() {
+    if (this.config.indexGeneration?.enabled) {
+      this.addRuleByName("IndexGenerationRule", ConfigTypes.FormatterOrder.IndexGeneration);
+    }
+    if (this.config.codeStyle?.enabled) {
+      this.addRuleByName("QuoteStyleRule", ConfigTypes.FormatterOrder.CodeStyle);
+      this.addRuleByName("SemicolonRule", ConfigTypes.FormatterOrder.CodeStyle);
+      this.addRuleByName("BracketSpacingRule", ConfigTypes.FormatterOrder.CodeStyle);
+      this.addRuleByName("IndentationRule", ConfigTypes.FormatterOrder.CodeStyle);
+      this.addRuleByName("StructuralIndentationRule", ConfigTypes.FormatterOrder.CodeStyle);
+      this.addRuleByName("BlockSpacingRule", ConfigTypes.FormatterOrder.CodeStyle);
+      this.addRuleByName("DocBlockCommentRule", ConfigTypes.FormatterOrder.CodeStyle);
+    }
+    if (this.config.imports?.enabled) {
+      this.addRuleByName("ImportOrganizationRule", ConfigTypes.FormatterOrder.ImportOrganization);
+    }
+    if (this.config.sorting?.enabled) {
+      if (this.config.sorting.classMembers?.enabled) {
+        this.addRuleByName("ClassMemberSortingRule", ConfigTypes.FormatterOrder.ASTTransformation);
+      }
+      if (this.config.sorting.fileDeclarations?.enabled) {
+        this.addRuleByName("FileDeclarationSortingRule", ConfigTypes.FormatterOrder.ASTTransformation);
+      }
+    }
+    if (this.config.spacing?.enabled) {
+      this.addRuleByName("BlankLineBetweenDeclarationsRule", ConfigTypes.FormatterOrder.Spacing);
+      this.addRuleByName("BlankLineBetweenStatementTypesRule", ConfigTypes.FormatterOrder.Spacing);
+      this.addRuleByName("BlankLineBeforeReturnsRule", ConfigTypes.FormatterOrder.Spacing);
+    }
+  }
+}
+exports.FormatterError = FormatterError;
+exports.FormatterPipeline = FormatterPipeline;

package/dist/formatters/package.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function sortExportsKeys(exports$1) {
+  if (!exports$1 || typeof exports$1 !== "object") {
+    return exports$1;
+  }
+  const sortedExports = {};
+  const exportKeyOrder = ["types", "import", "require"];
+  for (const [key, value] of Object.entries(exports$1)) {
+    if (typeof value === "object" && value !== null) {
+      const sortedSubObject = {};
+      exportKeyOrder.forEach((subKey) => {
+        if (subKey in value) {
+          sortedSubObject[subKey] = value[subKey];
+        }
+      });
+      for (const subKey of Object.keys(value)) {
+        if (!exportKeyOrder.includes(subKey)) {
+          sortedSubObject[subKey] = value[subKey];
+        }
+      }
+      sortedExports[key] = sortedSubObject;
+    } else {
+      sortedExports[key] = value;
+    }
+  }
+  return sortedExports;
+}
+exports.sortExportsKeys = sortExportsKeys;

package/dist/index.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const transformGenericsPlugin = require("./build-plugins/transformGenericsPlugin.js");
+const ASTAnalyzer = require("./core/ast/ASTAnalyzer.js");
+const ASTTransformer = require("./core/ast/ASTTransformer.js");
+const DependencyResolver = require("./core/ast/DependencyResolver.js");
+const ConfigDefaults = require("./core/config/ConfigDefaults.js");
+const ConfigLoader = require("./core/config/ConfigLoader.js");
+const ConfigMerger = require("./core/config/ConfigMerger.js");
+const ConfigTypes = require("./core/config/ConfigTypes.js");
+const ConfigValidator = require("./core/config/ConfigValidator.js");
+const Container = require("./core/di/Container.js");
+const ServiceRegistration = require("./core/di/ServiceRegistration.js");
+const BaseFormattingRule = require("./core/formatters/BaseFormattingRule.js");
+const ClassMemberSortingRule = require("./core/formatters/rules/ast/ClassMemberSortingRule.js");
+const FileDeclarationSortingRule = require("./core/formatters/rules/ast/FileDeclarationSortingRule.js");
+const ImportOrganizationRule = require("./core/formatters/rules/imports/ImportOrganizationRule.js");
+const IndexGenerationRule = require("./core/formatters/rules/index-generation/IndexGenerationRule.js");
+const BlankLineBeforeReturnsRule = require("./core/formatters/rules/spacing/BlankLineBeforeReturnsRule.js");
+const BlankLineBetweenDeclarationsRule = require("./core/formatters/rules/spacing/BlankLineBetweenDeclarationsRule.js");
+const BlankLineBetweenStatementTypesRule = require("./core/formatters/rules/spacing/BlankLineBetweenStatementTypesRule.js");
+const BlockSpacingRule = require("./core/formatters/rules/spacing/BlockSpacingRule.js");
+const BracketSpacingRule = require("./core/formatters/rules/spacing/BracketSpacingRule.js");
+const DocBlockCommentRule = require("./core/formatters/rules/style/DocBlockCommentRule.js");
+const IndentationRule = require("./core/formatters/rules/style/IndentationRule.js");
+const QuoteStyleRule = require("./core/formatters/rules/style/QuoteStyleRule.js");
+const SemicolonRule = require("./core/formatters/rules/style/SemicolonRule.js");
+const StructuralIndentationRule = require("./core/formatters/rules/style/StructuralIndentationRule.js");
+const FormatterPipeline = require("./core/pipeline/FormatterPipeline.js");
+const _package = require("./formatters/package.js");
+const types = require("./shared/types.js");
+exports.transformGenericsPlugin = transformGenericsPlugin.transformGenericsPlugin;
+exports.ASTAnalyzer = ASTAnalyzer.ASTAnalyzer;
+exports.ASTTransformer = ASTTransformer.ASTTransformer;
+exports.DependencyResolver = DependencyResolver.DependencyResolver;
+exports.ConfigDefaults = ConfigDefaults.ConfigDefaults;
+exports.ConfigLoader = ConfigLoader.ConfigLoader;
+exports.ConfigMerger = ConfigMerger.ConfigMerger;
+exports.ConfigTypes = ConfigTypes.ConfigTypes;
+exports.FormatterOrder = ConfigTypes.FormatterOrder;
+exports.ConfigValidator = ConfigValidator.ConfigValidator;
+exports.Container = Container.Container;
+exports.ServiceRegistration = ServiceRegistration.ServiceRegistration;
+exports.BaseFormattingRule = BaseFormattingRule.BaseFormattingRule;
+exports.ClassMemberSortingRule = ClassMemberSortingRule.ClassMemberSortingRule;
+exports.DEFAULT_CLASS_ORDER = ClassMemberSortingRule.DEFAULT_CLASS_ORDER;
+exports.MemberType = ClassMemberSortingRule.MemberType;
+exports.DEFAULT_FILE_ORDER = FileDeclarationSortingRule.DEFAULT_FILE_ORDER;
+exports.DeclarationType = FileDeclarationSortingRule.DeclarationType;
+exports.FileDeclarationSortingRule = FileDeclarationSortingRule.FileDeclarationSortingRule;
+exports.ImportOrganizationRule = ImportOrganizationRule.ImportOrganizationRule;
+exports.IndexGenerationRule = IndexGenerationRule.IndexGenerationRule;
+exports.BlankLineBeforeReturnsRule = BlankLineBeforeReturnsRule.BlankLineBeforeReturnsRule;
+exports.BlankLineBetweenDeclarationsRule = BlankLineBetweenDeclarationsRule.BlankLineBetweenDeclarationsRule;
+exports.BlankLineBetweenStatementTypesRule = BlankLineBetweenStatementTypesRule.BlankLineBetweenStatementTypesRule;
+exports.BlockSpacingRule = BlockSpacingRule.BlockSpacingRule;
+exports.BracketSpacingRule = BracketSpacingRule.BracketSpacingRule;
+exports.DocBlockCommentRule = DocBlockCommentRule.DocBlockCommentRule;
+exports.IndentationRule = IndentationRule.IndentationRule;
+exports.QuoteStyleRule = QuoteStyleRule.QuoteStyleRule;
+exports.SemicolonRule = SemicolonRule.SemicolonRule;
+exports.StructuralIndentationRule = StructuralIndentationRule.StructuralIndentationRule;
+exports.FormatterError = FormatterPipeline.FormatterError;
+exports.FormatterPipeline = FormatterPipeline.FormatterPipeline;
+exports.sortExportsKeys = _package.sortExportsKeys;
+exports.DefaultSortOptions = types.DefaultSortOptions;

package/dist/shared/types.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const DefaultSortOptions = {
+  customSortOrder: [
+    "name",
+    "type",
+    "author",
+    "version",
+    "description",
+    "publishConfig",
+    "keywords",
+    "homepage",
+    "engines",
+    "dependencies",
+    "devDependencies",
+    "scripts",
+    "types",
+    "main",
+    "module",
+    "exports",
+    "files",
+    "repository",
+    "bugs"
+  ],
+  indentation: 4,
+  dryRun: false
+};
+exports.DefaultSortOptions = DefaultSortOptions;

package/dist/sortPackage.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const fs = require("fs");
+const path = require("path");
+const sortPackageJson$1 = require("sort-package-json");
+const _package = require("./formatters/package.js");
+const types = require("./shared/types.js");
+function sortPackageJson(packageObj, options = {}) {
+  const sortOrder = options.customSortOrder || types.DefaultSortOptions.customSortOrder;
+  let sortedPackage = sortPackageJson$1.sortPackageJson(packageObj, {
+    sortOrder
+  });
+  if (sortedPackage.exports) {
+    sortedPackage.exports = _package.sortExportsKeys(sortedPackage.exports);
+  }
+  return sortedPackage;
+}
+function sortPackageFile(filePath, options = {}) {
+  const packagePath = filePath || path.join(process.cwd(), "package.json");
+  const indentation = options.indentation || types.DefaultSortOptions.indentation;
+  try {
+    const packageJson = JSON.parse(fs.readFileSync(packagePath, "utf8"));
+    const sortedPackageJson = sortPackageJson(packageJson, options);
+    if (!options.dryRun) {
+      fs.writeFileSync(packagePath, JSON.stringify(sortedPackageJson, null, indentation) + "\n");
+    }
+    return sortedPackageJson;
+  } catch (error) {
+    console.error(`Error processing ${packagePath}:`, error);
+    throw error;
+  }
+}
+exports.sortPackageFile = sortPackageFile;
+exports.sortPackageJson = sortPackageJson;

package/dist/sortTSConfig.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const fs = require("fs");
+const path = require("path");
+const types = require("./shared/types.js");
+function sortObjectKeysAlphabetically(obj) {
+  if (typeof obj !== "object" || obj === null || Array.isArray(obj)) {
+    return obj;
+  }
+  return Object.keys(obj).sort().reduce((result, key) => {
+    result[key] = sortObjectKeysAlphabetically(obj[key]);
+    return result;
+  }, {});
+}
+function sortTsConfig(tsConfig) {
+  return sortObjectKeysAlphabetically(tsConfig);
+}
+function sortTsConfigFile(filePath, options = {}) {
+  const tsConfigPath = filePath || path.join(process.cwd(), "tsconfig.json");
+  const indentation = options.indentation || types.DefaultSortOptions.indentation;
+  try {
+    const tsConfig = JSON.parse(fs.readFileSync(tsConfigPath, "utf8"));
+    const sortedTsConfig = sortTsConfig(tsConfig);
+    if (!options.dryRun) {
+      fs.writeFileSync(tsConfigPath, JSON.stringify(sortedTsConfig, null, indentation) + "\n");
+    }
+    return sortedTsConfig;
+  } catch (error) {
+    console.error(`Error processing ${tsConfigPath}:`, error);
+    throw error;
+  }
+}
+exports.sortTsConfig = sortTsConfig;
+exports.sortTsConfigFile = sortTsConfigFile;

package/package.json

@@ -1,35 +1,38 @@
 {
     "name": "tsfmt",
     "author": "Encore Digital Group",
-    "version": "0.0.0",
+    "version": "0.2.1",
     "description": "An opinionated TypeScript code formatter",
     "publishConfig": {
         "access": "public",
         "registry": "https://registry.npmjs.org"
     },
     "engines": {
-        "node": ">=20.0.0"
+        "node": ">=22.0.0"
     },
     "dependencies": {
         "glob": "^13.0.0",
         "json-sort-cli": "^4.0.9",
+        "reflect-metadata": "^0.2.2",
         "sort-package-json": "^3.0.0",
-        "tsx": "^4.21.0",
         "typescript": "^5.0.0"
     },
     "devDependencies": {
         "@types/jest": "^30.0.0",
         "@types/node": "^25.0.3",
         "jest": "^30.1.1",
-        "ts-jest": "^29.0.0"
+        "ts-jest": "^29.0.0",
+        "vite": "^7.0.0"
     },
     "scripts": {
-        "format": "node bin/cli.js",
+        "build": "vite build",
+        "dev": "tsx src/cli.ts",
+        "format": "node dist/cli.js",
         "test": "jest"
     },
-    "main": "bin/cli.js",
+    "main": "dist/cli.js",
     "files": [
-        "bin",
+        "dist",
         "README.md"
     ],
     "repository": {
@@ -38,6 +41,6 @@
     },
     "license": "BSD-3-Clause",
     "bin": {
-        "tsfmt": "./bin/cli.js"
+        "tsfmt": "./dist/cli.js"
     }
 }

package/bin/ci_build.sh

@@ -1,50 +0,0 @@
-#!/bin/bash
-#
-# Copyright (c) 2025. Encore Digital Group.
-# All Rights Reserved.
-#
-
-git config --global user.name "EncoreBot"
-git config --global user.email "ghbot@encoredigitalgroup.com"
-
-# Change to workspace directory
-cd "$GITHUB_WORKSPACE" || {
-  echo "Error: Failed to change directory to $GITHUB_WORKSPACE"
-  exit 1
-}
-
-# Run build and capture exit code
-npm run format
-BUILD_EXIT_CODE=$?
-
-# If build failed, exit with the same code
-if [ $BUILD_EXIT_CODE -ne 0 ]; then
-  echo "Build failed with exit code $BUILD_EXIT_CODE"
-  exit $BUILD_EXIT_CODE
-fi
-
-# Run format and capture exit code
-npm run format
-FORMAT_EXIT_CODE=$?
-
-# If format failed, exit with the same code
-if [ $FORMAT_EXIT_CODE -ne 0 ]; then
-  echo "Format failed with exit code $FORMAT_EXIT_CODE"
-  exit $FORMAT_EXIT_CODE
-fi
-
-# Build and format succeeded, check for changes
-if [ -z "$(git status --porcelain)" ]; then
-  # Working directory clean
-  echo "Working Tree is Clean! Nothing to commit."
-else
-  # Add all changes to staging
-  git add .
-
-  # Commit changes
-  commit_message="Apply Formatting"
-  git commit -m "$commit_message"
-
-  # Push changes to origin
-  git push origin --force
-fi

package/bin/cli.js

@@ -1,20 +0,0 @@
-#!/usr/bin/env node
-/*
- * Copyright (c) 2026. Encore Digital Group.
- * All Rights Reserved.
- */
-
-// This is the entry point for consumers of the package
-// It uses tsx to run the TypeScript source directly without requiring a build step
-
-const { register } = require('tsx/cjs/api');
-const path = require('path');
-
-// Register tsx to handle TypeScript files
-const unregister = register();
-
-// Load and run the CLI
-require(path.join(__dirname, '../src/cli.ts'));
-
-// Cleanup
-process.on('exit', () => unregister());