tsfmt 0.0.0 → 0.2.1

package/dist/core/config/ConfigDefaults.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("typescript");
+require("./ConfigLoader.js");
+const ConfigTypes = require("./ConfigTypes.js");
+require("reflect-metadata");
+const ClassMemberSortingRule = require("../formatters/rules/ast/ClassMemberSortingRule.js");
+const FileDeclarationSortingRule = require("../formatters/rules/ast/FileDeclarationSortingRule.js");
+require("fs");
+require("path");
+require("fs/promises");
+const types = require("../../shared/types.js");
+class ConfigDefaults {
+  static {
+    this.DEFAULT_EXCLUDE_PATTERNS = ["node_modules/**", "dist/**", "vendor/**", "bin/**"];
+  }
+  static {
+    this.DEFAULT_INDEX_DIRECTORIES = ["src/", "packages/"];
+  }
+  static {
+    this.DEFAULT_JS_INCLUDE_PATTERNS = ["**/*.{js,ts,jsx,tsx}"];
+  }
+  static {
+    this.DEFAULT_TS_INCLUDE_PATTERNS = ["**/*.{ts,tsx}"];
+  }
+  /** Get default code style configuration */
+  static getDefaultCodeStyleConfig() {
+    return {
+      enabled: true,
+      quoteStyle: "double",
+      semicolons: "always",
+      bracketSpacing: false,
+      indentStyle: "space",
+      indentWidth: 4,
+      lineWidth: 120,
+      trailingCommas: "all",
+      arrowParens: "avoid"
+    };
+  }
+  /** Get default directories for index generation */
+  static getDefaultIndexDirectories() {
+    return [...this.DEFAULT_INDEX_DIRECTORIES];
+  }
+  /** Get default index generation configuration */
+  static getDefaultIndexGenerationConfig() {
+    return {
+      enabled: true,
+      directories: this.getDefaultIndexDirectories(),
+      options: {
+        fileExtension: ".ts",
+        indexFileName: "index.ts",
+        recursive: true
+      },
+      updateMainIndex: true
+    };
+  }
+  /** Get default import configuration */
+  static getDefaultImportConfig() {
+    return {
+      enabled: true,
+      sortImports: true,
+      removeUnused: true,
+      removeSideEffects: false,
+      groupImports: true,
+      groupOrder: ConfigTypes.ConfigTypes.getImportGroupOptions(),
+      separateGroups: false
+    };
+  }
+  /** Get default include patterns for TypeScript files */
+  static getDefaultIncludePatterns() {
+    return [...this.DEFAULT_TS_INCLUDE_PATTERNS];
+  }
+  /** Get default exclude patterns for file processing */
+  static getDefaultExcludePatterns() {
+    return [...this.DEFAULT_EXCLUDE_PATTERNS];
+  }
+  /** Get default sorting configuration */
+  static getDefaultSortingConfig() {
+    return {
+      enabled: true,
+      classMembers: {
+        enabled: true,
+        order: ClassMemberSortingRule.DEFAULT_CLASS_ORDER,
+        groupByVisibility: false,
+        respectDependencies: true
+      },
+      reactComponents: {
+        enabled: true,
+        order: ClassMemberSortingRule.DEFAULT_CLASS_ORDER,
+        groupByVisibility: false,
+        respectDependencies: true
+      },
+      fileDeclarations: {
+        enabled: true,
+        order: FileDeclarationSortingRule.DEFAULT_FILE_ORDER,
+        respectDependencies: true
+      },
+      include: this.getDefaultIncludePatterns(),
+      exclude: this.getDefaultExcludePatterns()
+    };
+  }
+  /** Get default spacing configuration */
+  static getDefaultSpacingConfig() {
+    return {
+      enabled: false,
+      betweenDeclarations: true,
+      beforeReturns: true,
+      betweenStatementTypes: true
+    };
+  }
+  /** Get default package.json configuration */
+  static getDefaultPackageJsonConfig() {
+    return {
+      enabled: true,
+      customSortOrder: types.DefaultSortOptions.customSortOrder,
+      indentation: 4
+    };
+  }
+  /** Get default tsconfig.json configuration */
+  static getDefaultTsConfigConfig() {
+    return {
+      enabled: true,
+      indentation: 4
+    };
+  }
+  /** Get default formatter order */
+  static getDefaultFormatterOrder() {
+    return [
+      ConfigTypes.FormatterOrder.IndexGeneration,
+      ConfigTypes.FormatterOrder.CodeStyle,
+      ConfigTypes.FormatterOrder.ImportOrganization,
+      ConfigTypes.FormatterOrder.ASTTransformation,
+      ConfigTypes.FormatterOrder.Spacing
+    ];
+  }
+  /** Get the complete default configuration */
+  static getDefaultConfig() {
+    return {
+      indexGeneration: this.getDefaultIndexGenerationConfig(),
+      codeStyle: this.getDefaultCodeStyleConfig(),
+      imports: this.getDefaultImportConfig(),
+      sorting: this.getDefaultSortingConfig(),
+      spacing: this.getDefaultSpacingConfig(),
+      packageJson: this.getDefaultPackageJsonConfig(),
+      tsConfig: this.getDefaultTsConfigConfig(),
+      formatterOrder: this.getDefaultFormatterOrder()
+    };
+  }
+  /** Get default include patterns for JavaScript files */
+  static getDefaultJavaScriptIncludePatterns() {
+    return [...this.DEFAULT_JS_INCLUDE_PATTERNS];
+  }
+  /** Create a configuration with all features disabled */
+  static getDisabledConfig() {
+    return {
+      indexGeneration: { enabled: false },
+      codeStyle: { enabled: false },
+      imports: { enabled: false },
+      sorting: { enabled: false },
+      spacing: { enabled: false },
+      packageJson: { enabled: false },
+      tsConfig: { enabled: false }
+    };
+  }
+  /** Create a minimal configuration with only enabled features */
+  static getMinimalConfig() {
+    return {
+      indexGeneration: { enabled: true },
+      codeStyle: { enabled: true },
+      imports: { enabled: true },
+      sorting: { enabled: true },
+      spacing: { enabled: false },
+      packageJson: { enabled: true },
+      tsConfig: { enabled: true }
+    };
+  }
+}
+exports.ConfigDefaults = ConfigDefaults;

package/dist/core/config/ConfigLoader.js

@@ -0,0 +1,251 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const fs = require("fs");
+const path = require("path");
+const ts = require("typescript");
+const ConfigDefaults = require("./ConfigDefaults.js");
+const ConfigMerger = require("./ConfigMerger.js");
+const ConfigValidator = require("./ConfigValidator.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);
+const ts__namespace = /* @__PURE__ */ _interopNamespaceDefault(ts);
+class ConfigLoader {
+  static {
+    this.CONFIG_FILE_NAME = "tsfmt.config.ts";
+  }
+  static {
+    this.configCache = /* @__PURE__ */ new Map();
+  }
+  /** Clears the configuration cache */
+  static clearCache() {
+    this.configCache.clear();
+  }
+  /**
+  * Gets the path to the config file
+  * @param projectRoot - The root directory of the project
+  * @returns Full path to the config file
+  */
+  static getConfigFilePath(projectRoot = process.cwd()) {
+    return path__namespace.join(projectRoot, this.CONFIG_FILE_NAME);
+  }
+  /**
+  * Creates a sample configuration file
+  * @param projectRoot - The root directory of the project
+  * @param overwrite - Whether to overwrite existing file (default: false)
+  * @throws Error if file exists and overwrite is false
+  */
+  static createSampleConfig(projectRoot = process.cwd(), overwrite = false) {
+    const configPath = this.getConfigFilePath(projectRoot);
+    if (fs__namespace.existsSync(configPath) && !overwrite) {
+      throw new Error(`Configuration file already exists at ${configPath}. Use overwrite=true to replace it.`);
+    }
+    const sampleConfig = `/*
+* tsfmt Configuration File
+*
+* This file defines the configuration for tsfmt formatting.
+* All options are optional - defaults will be used for missing values.
+*/
+
+import { CoreConfig } from "tsfmt";
+
+const config: CoreConfig = {
+    // Enable/disable index file generation
+    indexGeneration: {
+        enabled: true,
+        directories: ConfigDefaults.getDefaultIndexDirectories(),
+        updateMainIndex: true,
+    },
+
+    // Code style configuration
+    codeStyle: {
+        enabled: true,
+        quoteStyle: "double",
+        semicolons: "always",
+        indentWidth: 4,
+        lineWidth: 120,
+        },
+
+    // Import organization
+    imports: {
+        enabled: true,
+        sortImports: true,
+        removeUnused: true,
+        groupImports: true,
+    },
+
+    // AST-based sorting
+    sorting: {
+        enabled: true,
+        classMembers: { enabled: true },
+        fileDeclarations: { enabled: true },
+    },
+
+    // Spacing rules
+    spacing: {
+        enabled: false,
+        betweenDeclarations: true,
+        beforeReturns: true,
+    },
+
+    // JSON file sorting
+    packageJson: { enabled: true },
+    tsConfig: { enabled: true },
+    };
+
+export default config;
+`;
+    fs__namespace.writeFileSync(configPath, sampleConfig, "utf-8");
+  }
+  /**
+  * Gets cache statistics for debugging
+  * @returns Object with cache information
+  */
+  static getCacheStats() {
+    return {
+      size: this.configCache.size,
+      keys: Array.from(this.configCache.keys())
+    };
+  }
+  /**
+  * Gets file modification time for cache invalidation
+  * @param filePath - Path to the file
+  * @returns File modification time in milliseconds
+  */
+  static getFileModTime(filePath) {
+    try {
+      return fs__namespace.statSync(filePath).mtime.getTime();
+    } catch {
+      return 0;
+    }
+  }
+  /**
+  * Checks if a tsfmt.config.ts file exists in the project
+  * @param projectRoot - The root directory of the project (defaults to current working directory)
+  * @returns true if tsfmt.config.ts exists
+  */
+  static hasConfigFile(projectRoot = process.cwd()) {
+    const configPath = path__namespace.join(projectRoot, this.CONFIG_FILE_NAME);
+    return fs__namespace.existsSync(configPath);
+  }
+  /**
+  * Transpiles TypeScript code to JavaScript
+  * @param code - TypeScript code to transpile
+  * @returns Transpiled JavaScript code
+  */
+  static transpileTypeScript(code) {
+    const result = ts__namespace.transpileModule(code, {
+      compilerOptions: {
+        module: ts__namespace.ModuleKind.CommonJS,
+        target: ts__namespace.ScriptTarget.ES2015,
+        esModuleInterop: true,
+        allowSyntheticDefaultImports: true
+      }
+    });
+    return result.outputText;
+  }
+  /**
+  * Loads and evaluates a TypeScript config file
+  * @param filePath - Path to the config file
+  * @returns Partial configuration from the file
+  * @throws Error if the config file is invalid
+  */
+  static loadTypeScriptConfig(filePath) {
+    try {
+      const code = fs__namespace.readFileSync(filePath, "utf-8");
+      const transpiled = this.transpileTypeScript(code);
+      const module2 = { exports: {} };
+      const exports$1 = module2.exports;
+      const requireFunc = (moduleName) => {
+        if (moduleName.startsWith(".")) {
+          const resolvedPath = path__namespace.resolve(path__namespace.dirname(filePath), moduleName);
+          return require(resolvedPath);
+        }
+        return require(moduleName);
+      };
+      const func = new Function("exports", "module", "require", "__filename", "__dirname", transpiled);
+      func(exports$1, module2, requireFunc, filePath, path__namespace.dirname(filePath));
+      const config = module2.exports.default || module2.exports;
+      if (typeof config !== "object" || config === null) {
+        throw new Error(`${this.CONFIG_FILE_NAME} must export a configuration object. Found: ${typeof config}`);
+      }
+      return config;
+    } catch (error) {
+      throw new Error(`Failed to load ${this.CONFIG_FILE_NAME}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  /**
+  * Loads the configuration from cache if valid, otherwise from file
+  * @param filePath - Path to the config file
+  * @returns Loaded configuration
+  */
+  static loadConfigWithCache(filePath) {
+    const currentMtime = this.getFileModTime(filePath);
+    const cached = this.configCache.get(filePath);
+    if (cached && cached.mtime === currentMtime) {
+      return cached.config;
+    }
+    const config = this.loadTypeScriptConfig(filePath);
+    this.configCache.set(filePath, { config, mtime: currentMtime });
+    return config;
+  }
+  /**
+  * Loads the configuration from tsfmt.config.ts if it exists, otherwise returns default config
+  * @param projectRoot - The root directory of the project (defaults to current working directory)
+  * @param validate - Whether to validate the configuration (default: true)
+  * @returns The merged configuration
+  */
+  static loadConfig(projectRoot = process.cwd(), validate = true) {
+    const configPath = this.getConfigFilePath(projectRoot);
+    if (!fs__namespace.existsSync(configPath)) {
+      return ConfigDefaults.ConfigDefaults.getDefaultConfig();
+    }
+    try {
+      const userConfig = this.loadConfigWithCache(configPath);
+      const mergedConfig = ConfigMerger.ConfigMerger.merge(userConfig);
+      if (validate) {
+        ConfigValidator.ConfigValidator.validateOrThrow(mergedConfig);
+      }
+      return mergedConfig;
+    } catch (error) {
+      console.error(`Error loading configuration from ${configPath}:`);
+      console.error(error instanceof Error ? error.message : String(error));
+      console.error("Falling back to default configuration.");
+      return ConfigDefaults.ConfigDefaults.getDefaultConfig();
+    }
+  }
+  /**
+  * Loads configuration without validation (for debugging or inspection)
+  * @param projectRoot - The root directory of the project
+  * @returns The merged configuration without validation
+  */
+  static loadConfigWithoutValidation(projectRoot = process.cwd()) {
+    return this.loadConfig(projectRoot, false);
+  }
+  /**
+  * Reloads configuration by clearing cache and loading fresh
+  * @param projectRoot - The root directory of the project
+  * @returns The reloaded configuration
+  */
+  static reloadConfig(projectRoot = process.cwd()) {
+    const configPath = this.getConfigFilePath(projectRoot);
+    this.configCache.delete(configPath);
+    return this.loadConfig(projectRoot);
+  }
+}
+exports.ConfigLoader = ConfigLoader;

package/dist/core/config/ConfigMerger.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const ConfigDefaults = require("./ConfigDefaults.js");
+class ConfigMerger {
+  /**
+  * Deep merge two configuration objects
+  * @param target - Target configuration (defaults)
+  * @param source - Source configuration (user overrides)
+  * @returns Merged configuration
+  */
+  static deepMerge(target, source) {
+    const result = { ...target };
+    for (const key in source) {
+      if (source[key] !== void 0) {
+        if (typeof source[key] === "object" && source[key] !== null && !Array.isArray(source[key]) && typeof result[key] === "object" && result[key] !== null && !Array.isArray(result[key])) {
+          result[key] = this.deepMerge(result[key], source[key]);
+        } else {
+          result[key] = source[key];
+        }
+      }
+    }
+    return result;
+  }
+  /**
+  * Merge user config with default config
+  * @param userConfig - Partial user configuration
+  * @returns Complete merged configuration
+  */
+  static merge(userConfig) {
+    return this.deepMerge(ConfigDefaults.ConfigDefaults.getDefaultConfig(), userConfig);
+  }
+  /**
+  * Merge multiple partial configs together
+  * @param configs - Array of partial configurations to merge
+  * @returns Merged configuration
+  */
+  static mergeMultiple(...configs) {
+    let result = ConfigDefaults.ConfigDefaults.getDefaultConfig();
+    for (const config of configs) {
+      result = this.deepMerge(result, config);
+    }
+    return result;
+  }
+}
+exports.ConfigMerger = ConfigMerger;

package/dist/core/config/ConfigTypes.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var FormatterOrder = /* @__PURE__ */ ((FormatterOrder2) => {
+  FormatterOrder2["IndexGeneration"] = "IndexGeneration";
+  FormatterOrder2["CodeStyle"] = "CodeStyle";
+  FormatterOrder2["ImportOrganization"] = "ImportOrganization";
+  FormatterOrder2["ASTTransformation"] = "ASTTransformation";
+  FormatterOrder2["Spacing"] = "Spacing";
+  return FormatterOrder2;
+})(FormatterOrder || {});
+class ConfigTypes {
+  /** Get all available arrow parentheses options */
+  static getArrowParenOptions() {
+    return ["always", "avoid"];
+  }
+  /** Get all formatter order options */
+  static getFormatterOrderOptions() {
+    return Object.values(FormatterOrder);
+  }
+  /** Get all available import group options */
+  static getImportGroupOptions() {
+    return ["external", "internal", "relative"];
+  }
+  /** Get all available indent style options */
+  static getIndentStyleOptions() {
+    return ["tab", "space"];
+  }
+  /** Get all available quote style options */
+  static getQuoteStyleOptions() {
+    return ["single", "double"];
+  }
+  /** Get all available semicolon options */
+  static getSemicolonOptions() {
+    return ["always", "never"];
+  }
+  /** Get all available trailing comma options */
+  static getTrailingCommaOptions() {
+    return ["none", "es5", "all"];
+  }
+  /** Check if a line width is in recommended range */
+  static isRecommendedLineWidth(width) {
+    return width >= 80 && width <= 120;
+  }
+  /** Validate an arrow parentheses option */
+  static isValidArrowParenOption(option) {
+    return this.getArrowParenOptions().includes(option);
+  }
+  /** Validate an indent style option */
+  static isValidIndentStyle(style) {
+    return this.getIndentStyleOptions().includes(style);
+  }
+  /** Check if an indent width is valid */
+  static isValidIndentWidth(width) {
+    return width >= 1 && width <= 8;
+  }
+  /** Validate a quote style option */
+  static isValidQuoteStyle(style) {
+    return this.getQuoteStyleOptions().includes(style);
+  }
+  /** Validate a semicolon option */
+  static isValidSemicolonOption(option) {
+    return this.getSemicolonOptions().includes(option);
+  }
+  /** Validate a trailing comma option */
+  static isValidTrailingCommaOption(option) {
+    return this.getTrailingCommaOptions().includes(option);
+  }
+}
+exports.ConfigTypes = ConfigTypes;
+exports.FormatterOrder = FormatterOrder;

package/dist/core/config/ConfigValidator.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const ConfigTypes = require("./ConfigTypes.js");
+class ConfigValidator {
+  /**
+  * Validate a CoreConfig object
+  * @param config - Configuration to validate
+  * @returns Validation result with errors and warnings
+  */
+  static validate(config) {
+    const errors = [];
+    const warnings = [];
+    if (config.codeStyle) {
+      if (config.codeStyle.enabled && config.codeStyle.quoteStyle) {
+        if (!ConfigTypes.ConfigTypes.isValidQuoteStyle(config.codeStyle.quoteStyle)) {
+          errors.push(`Invalid quoteStyle: ${config.codeStyle.quoteStyle}. Must be ${ConfigTypes.ConfigTypes.getQuoteStyleOptions().map((s) => `'${s}'`).join(" or ")}.`);
+        }
+      }
+      if (config.codeStyle.enabled && config.codeStyle.semicolons) {
+        if (!ConfigTypes.ConfigTypes.isValidSemicolonOption(config.codeStyle.semicolons)) {
+          errors.push(`Invalid semicolons: ${config.codeStyle.semicolons}. Must be ${ConfigTypes.ConfigTypes.getSemicolonOptions().map((s) => `'${s}'`).join(" or ")}.`);
+        }
+      }
+      if (config.codeStyle.indentWidth !== void 0) {
+        if (!ConfigTypes.ConfigTypes.isValidIndentWidth(config.codeStyle.indentWidth)) {
+          errors.push(`Invalid indentWidth: ${config.codeStyle.indentWidth}. Must be between 1 and 8.`);
+        }
+      }
+      if (config.codeStyle.lineWidth !== void 0) {
+        if (config.codeStyle.lineWidth < 40 || config.codeStyle.lineWidth > 200) {
+          if (!ConfigTypes.ConfigTypes.isRecommendedLineWidth(config.codeStyle.lineWidth)) {
+            warnings.push(`Unusual lineWidth: ${config.codeStyle.lineWidth}. Recommended range is 80-120.`);
+          }
+        }
+      }
+    }
+    if (config.imports) {
+      if (config.imports.groupOrder && config.imports.groupOrder.length > 0) {
+        const validGroups = ConfigTypes.ConfigTypes.getImportGroupOptions();
+        const invalidGroups = config.imports.groupOrder.filter((g) => !validGroups.includes(g));
+        if (invalidGroups.length > 0) {
+          errors.push(`Invalid group in groupOrder: ${invalidGroups.join(", ")}. Valid groups: ${validGroups.join(", ")}`);
+        }
+      }
+    }
+    if (config.sorting) {
+      if (config.sorting.include && config.sorting.include.length === 0) {
+        warnings.push("Sorting include patterns is empty - no files will be sorted.");
+      }
+    }
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+  /**
+  * Validate and throw if invalid
+  * @param config - Configuration to validate
+  * @throws Error if configuration is invalid
+  */
+  static validateOrThrow(config) {
+    const result = this.validate(config);
+    if (!result.valid) {
+      throw new Error(`Invalid configuration:
+${result.errors.join("\n")}`);
+    }
+    if (result.warnings.length > 0) {
+      console.warn("Configuration warnings:");
+      result.warnings.forEach((warning) => console.warn(`  - ${warning}`));
+    }
+  }
+}
+exports.ConfigValidator = ConfigValidator;