tsfmt 0.2.3 → 0.2.5

package/dist/build-plugins/index.d.ts

@@ -0,0 +1 @@
+export * from "./transformGenericsPlugin";

package/dist/build-plugins/transformGenericsPlugin.d.ts

@@ -0,0 +1,4 @@
+export declare function transformGenericsPlugin(): {
+    name: string;
+    generateBundle(options: any, bundle: any): void;
+};

package/dist/cli.d.ts

@@ -0,0 +1 @@
+import "reflect-metadata";

package/dist/core/ast/ASTAnalyzer.d.ts

@@ -0,0 +1,16 @@
+import * as ts from "typescript";
+export interface ReferenceInfo {
+    identifiers: Set<string>;
+    thisReferences: Set<string>;
+    directCalls: Set<string>;
+}
+export declare class ASTAnalyzer {
+    static extractReferences(node: ts.Node, scopeFilter?: (name: string) => boolean): ReferenceInfo;
+    static extractClassMemberReferences(member: ts.ClassElement, availableMembers: Set<string>): Set<string>;
+    static extractFileDeclarationReferences(declaration: ts.Statement, availableDeclarations: Set<string>): Set<string>;
+    static getClassMemberName(member: ts.ClassElement): string;
+    static getDeclarationName(declaration: ts.Statement): string;
+    static hasModifier(node: ts.Node, kind: ts.SyntaxKind): boolean;
+    static isDefaultExport(node: ts.Statement): boolean;
+    static isExported(node: ts.Statement): boolean;
+}

package/dist/core/ast/ASTTransformer.d.ts

@@ -0,0 +1,9 @@
+import * as ts from "typescript";
+export declare class ASTTransformer {
+    static createSourceFile(source: string, filePath: string): ts.SourceFile;
+    static printNode(node: ts.Node, sourceFile: ts.SourceFile, removeComments?: boolean): string;
+    static printSourceFile(sourceFile: ts.SourceFile): string;
+    static reorderClassMembers(classNode: ts.ClassDeclaration, orderedMembers: ts.ClassElement[]): ts.ClassDeclaration;
+    static reorderSourceFileStatements(sourceFile: ts.SourceFile, orderedStatements: ts.Statement[]): ts.SourceFile;
+    static transformSourceFile(sourceFile: ts.SourceFile, visitor: (node: ts.Node) => ts.Node | undefined): ts.SourceFile;
+}

package/dist/core/ast/DependencyResolver.d.ts

@@ -0,0 +1,16 @@
+export interface DependencyNode {
+    name: string;
+    dependencies: Set<string>;
+    originalIndex: number;
+    sortedIndex: number;
+}
+export interface DependencyGraph {
+    nodes: Map<string, DependencyNode>;
+    circularGroups: Set<string>[];
+}
+export declare class DependencyResolver {
+    private static findStronglyConnectedComponents;
+    static buildGraph<T>(items: T[], getName: (item: T) => string, getDependencies: (item: T) => Set<string>): DependencyGraph;
+    static topologicalSort(graph: DependencyGraph, sortedNames: string[]): string[];
+    static reorderWithDependencies<T>(items: T[], getName: (item: T) => string): T[];
+}

package/dist/core/ast/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./ASTAnalyzer";
+export * from "./ASTTransformer";
+export * from "./DependencyResolver";

package/dist/core/config/ConfigDefaults.d.ts

@@ -0,0 +1,82 @@
+import { CoreConfig, FormatterOrder } from "./ConfigTypes";
+export declare class ConfigDefaults {
+    static readonly DEFAULT_EXCLUDE_PATTERNS: readonly ["node_modules/**", "dist/**", "vendor/**", "bin/**"];
+    static readonly DEFAULT_INDEX_DIRECTORIES: readonly ["src/", "packages/"];
+    static readonly DEFAULT_JS_INCLUDE_PATTERNS: readonly ["**/*.{js,ts,jsx,tsx}"];
+    static readonly DEFAULT_TS_INCLUDE_PATTERNS: readonly ["**/*.{ts,tsx}"];
+    static getDefaultCodeStyleConfig(): {
+        enabled: boolean;
+        quoteStyle: "double";
+        semicolons: "always";
+        bracketSpacing: boolean;
+        indentStyle: "space";
+        indentWidth: number;
+        lineWidth: number;
+        trailingCommas: "all";
+        arrowParens: "avoid";
+    };
+    static getDefaultIndexDirectories(): string[];
+    static getDefaultIndexGenerationConfig(): {
+        enabled: boolean;
+        directories: string[];
+        options: {
+            fileExtension: string;
+            indexFileName: string;
+            recursive: boolean;
+        };
+        updateMainIndex: boolean;
+    };
+    static getDefaultImportConfig(): {
+        enabled: boolean;
+        sortImports: boolean;
+        removeUnused: boolean;
+        removeSideEffects: boolean;
+        groupImports: boolean;
+        groupOrder: string[];
+        separateGroups: boolean;
+    };
+    static getDefaultIncludePatterns(): string[];
+    static getDefaultExcludePatterns(): string[];
+    static getDefaultSortingConfig(): {
+        enabled: boolean;
+        classMembers: {
+            enabled: boolean;
+            order: import("../").MemberType[];
+            groupByVisibility: boolean;
+            respectDependencies: boolean;
+        };
+        reactComponents: {
+            enabled: boolean;
+            order: import("../").MemberType[];
+            groupByVisibility: boolean;
+            respectDependencies: boolean;
+        };
+        fileDeclarations: {
+            enabled: boolean;
+            order: import("../").DeclarationType[];
+            respectDependencies: boolean;
+        };
+        include: string[];
+        exclude: string[];
+    };
+    static getDefaultSpacingConfig(): {
+        enabled: boolean;
+        betweenDeclarations: boolean;
+        beforeReturns: boolean;
+        betweenStatementTypes: boolean;
+    };
+    static getDefaultPackageJsonConfig(): {
+        enabled: boolean;
+        customSortOrder: string[] | undefined;
+        indentation: number;
+    };
+    static getDefaultTsConfigConfig(): {
+        enabled: boolean;
+        indentation: number;
+    };
+    static getDefaultFormatterOrder(): FormatterOrder[];
+    static getDefaultConfig(): CoreConfig;
+    static getDefaultJavaScriptIncludePatterns(): string[];
+    static getDisabledConfig(): CoreConfig;
+    static getMinimalConfig(): CoreConfig;
+}

package/dist/core/config/ConfigLoader.d.ts

@@ -0,0 +1,20 @@
+import { CoreConfig } from "./ConfigTypes";
+export declare class ConfigLoader {
+    static readonly CONFIG_FILE_NAME = "tsfmt.config.ts";
+    private static configCache;
+    static clearCache(): void;
+    static getConfigFilePath(projectRoot?: string): string;
+    static createSampleConfig(projectRoot?: string, overwrite?: boolean): void;
+    static getCacheStats(): {
+        size: number;
+        keys: string[];
+    };
+    private static getFileModTime;
+    static hasConfigFile(projectRoot?: string): boolean;
+    private static transpileTypeScript;
+    private static loadTypeScriptConfig;
+    private static loadConfigWithCache;
+    static loadConfig(projectRoot?: string, validate?: boolean): CoreConfig;
+    static loadConfigWithoutValidation(projectRoot?: string): CoreConfig;
+    static reloadConfig(projectRoot?: string): CoreConfig;
+}

package/dist/core/config/ConfigMerger.d.ts

@@ -0,0 +1,6 @@
+import { CoreConfig } from "./ConfigTypes";
+export declare class ConfigMerger {
+    private static deepMerge;
+    static merge(userConfig: Partial<CoreConfig>): CoreConfig;
+    static mergeMultiple(...configs: Partial<CoreConfig>[]): CoreConfig;
+}

package/dist/core/config/ConfigTypes.d.ts

@@ -0,0 +1,97 @@
+import { MemberType } from "../";
+import { DeclarationType } from "../";
+import { IndexGenerationConfig } from "../";
+export interface ClassMemberConfig {
+    enabled?: boolean;
+    order?: MemberType[];
+    groupByVisibility?: boolean;
+    respectDependencies?: boolean;
+}
+export interface CodeStyleConfig {
+    enabled?: boolean;
+    quoteStyle?: "single" | "double";
+    semicolons?: "always" | "never";
+    bracketSpacing?: boolean;
+    indentStyle?: "tab" | "space";
+    indentWidth?: number;
+    lineWidth?: number;
+    trailingCommas?: "none" | "es5" | "all";
+    arrowParens?: "always" | "avoid";
+}
+export interface ImportConfig {
+    enabled?: boolean;
+    sortImports?: boolean;
+    removeUnused?: boolean;
+    removeSideEffects?: boolean;
+    groupImports?: boolean;
+    groupOrder?: string[];
+    separateGroups?: boolean;
+}
+export interface ReactComponentConfig {
+    enabled?: boolean;
+    order?: MemberType[];
+    groupByVisibility?: boolean;
+    respectDependencies?: boolean;
+}
+export interface FileDeclarationConfig {
+    enabled?: boolean;
+    order?: DeclarationType[];
+    respectDependencies?: boolean;
+}
+export interface SortingConfig {
+    enabled?: boolean;
+    classMembers?: ClassMemberConfig;
+    reactComponents?: ReactComponentConfig;
+    fileDeclarations?: FileDeclarationConfig;
+    include?: string[];
+    exclude?: string[];
+}
+export interface SpacingConfig {
+    enabled?: boolean;
+    betweenDeclarations?: boolean;
+    beforeReturns?: boolean;
+    betweenStatementTypes?: boolean;
+}
+export interface PackageJsonConfig {
+    enabled?: boolean;
+    customSortOrder?: string[];
+    indentation?: number;
+}
+export interface TsConfigConfig {
+    enabled?: boolean;
+    indentation?: number;
+}
+export declare enum FormatterOrder {
+    IndexGeneration = "IndexGeneration",
+    CodeStyle = "CodeStyle",
+    ImportOrganization = "ImportOrganization",
+    ASTTransformation = "ASTTransformation",
+    Spacing = "Spacing"
+}
+export interface CoreConfig {
+    indexGeneration?: IndexGenerationConfig;
+    codeStyle?: CodeStyleConfig;
+    imports?: ImportConfig;
+    sorting?: SortingConfig;
+    spacing?: SpacingConfig;
+    packageJson?: PackageJsonConfig;
+    tsConfig?: TsConfigConfig;
+    formatterOrder?: FormatterOrder[];
+    skipReactFiles?: boolean;
+}
+export declare class ConfigTypes {
+    static getArrowParenOptions(): Array<"always" | "avoid">;
+    static getFormatterOrderOptions(): FormatterOrder[];
+    static getImportGroupOptions(): string[];
+    static getIndentStyleOptions(): Array<"tab" | "space">;
+    static getQuoteStyleOptions(): Array<"single" | "double">;
+    static getSemicolonOptions(): Array<"always" | "never">;
+    static getTrailingCommaOptions(): Array<"none" | "es5" | "all">;
+    static isRecommendedLineWidth(width: number): boolean;
+    static isValidArrowParenOption(option: string): option is "always" | "avoid";
+    static isValidIndentStyle(style: string): style is "tab" | "space";
+    static isValidIndentWidth(width: number): boolean;
+    static isValidQuoteStyle(style: string): style is "single" | "double";
+    static isValidSemicolonOption(option: string): option is "always" | "never";
+    static isValidTrailingCommaOption(option: string): option is "none" | "es5" | "all";
+}

package/dist/core/config/ConfigValidator.d.ts

@@ -0,0 +1,10 @@
+import { CoreConfig } from "./ConfigTypes";
+export interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+export declare class ConfigValidator {
+    static validate(config: CoreConfig): ValidationResult;
+    static validateOrThrow(config: CoreConfig): void;
+}

package/dist/core/config/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./ConfigDefaults";
+export * from "./ConfigLoader";
+export * from "./ConfigMerger";
+export * from "./ConfigTypes";
+export * from "./ConfigValidator";

package/dist/core/di/Container.d.ts

@@ -0,0 +1,17 @@
+import "reflect-metadata";
+export declare class Container {
+    private factories;
+    private services;
+    private singletons;
+    static inject(...dependencies: string[]): (target: any) => any;
+    clear(): void;
+    private extractGenericTypeName;
+    private extractGenericTypeNameForRegistration;
+    has(name: string): boolean;
+    private isConstructorFunction;
+    register<T>(name: string, instance: T): void;
+    private resolveByKey;
+    resolve<T>(name?: string): T;
+    private resolveDependencies;
+    singleton<T>(nameOrInstanceOrConstructor: string | T | (() => T) | (new (...args: any[]) => T), instance?: T | (() => T)): void;
+}

package/dist/core/di/ServiceRegistration.d.ts

@@ -0,0 +1,5 @@
+import { CoreConfig } from "../config";
+import { Container } from "./Container";
+export declare class ServiceRegistration {
+    static registerServices(container: Container, config: CoreConfig): void;
+}

package/dist/core/di/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Container";
+export * from "./ServiceRegistration";

package/dist/core/formatters/BaseFormattingRule.d.ts

@@ -0,0 +1,16 @@
+import { CoreConfig } from "../config";
+import { Container } from "../di";
+import { IFormattingRule } from "./IFormattingRule";
+export declare abstract class BaseFormattingRule implements IFormattingRule {
+    protected readonly container: Container;
+    protected readonly config: CoreConfig;
+    abstract readonly name: string;
+    constructor(container: Container, config?: CoreConfig);
+    abstract apply(source: string, filePath?: string): string;
+    protected getConfig(): CoreConfig;
+    protected getCodeStyleConfig(): import("../config").CodeStyleConfig | undefined;
+    protected getImportsConfig(): import("../config").ImportConfig | undefined;
+    protected getIndexGenerationConfig(): import("./rules").IndexGenerationConfig | undefined;
+    protected getSortingConfig(): import("../config").SortingConfig | undefined;
+    protected getSpacingConfig(): import("../config").SpacingConfig | undefined;
+}

package/dist/core/formatters/IFormattingRule.d.ts

@@ -0,0 +1,4 @@
+export interface IFormattingRule {
+    readonly name: string;
+    apply(source: string, filePath?: string): string;
+}

package/dist/core/formatters/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./BaseFormattingRule";
+export * from "./IFormattingRule";
+export * from "./rules";

package/dist/core/formatters/rules/ast/ClassMemberSortingRule.d.ts

@@ -0,0 +1,34 @@
+import * as ts from "typescript";
+import { BaseFormattingRule } from "../../BaseFormattingRule";
+export declare enum MemberType {
+    StaticProperty = "static_property",
+    InstanceProperty = "instance_property",
+    Constructor = "constructor",
+    StaticMethod = "static_method",
+    InstanceMethod = "instance_method",
+    GetAccessor = "get_accessor",
+    SetAccessor = "set_accessor"
+}
+export interface ClassMember {
+    node: ts.ClassElement;
+    type: MemberType;
+    name: string;
+    isPublic: boolean;
+    isProtected: boolean;
+    isPrivate: boolean;
+    isStatic: boolean;
+    hasDecorator: boolean;
+    text: string;
+    dependencies?: Set<string>;
+    originalIndex?: number;
+}
+export declare const DEFAULT_CLASS_ORDER: MemberType[];
+export declare class ClassMemberSortingRule extends BaseFormattingRule {
+    readonly name = "ClassMemberSortingRule";
+    private getMemberType;
+    private analyzeClassMember;
+    private createSourceFile;
+    private compareMembers;
+    private sortClassMembers;
+    apply(source: string, filePath?: string): string;
+}

package/dist/core/formatters/rules/ast/FileDeclarationSortingRule.d.ts

@@ -0,0 +1,33 @@
+import * as ts from "typescript";
+import { BaseFormattingRule } from "../../BaseFormattingRule";
+export declare enum DeclarationType {
+    Interface = "interface",
+    TypeAlias = "type_alias",
+    Enum = "enum",
+    HelperFunction = "helper_function",
+    HelperVariable = "helper_variable",
+    ExportedFunction = "exported_function",
+    ExportedVariable = "exported_variable",
+    ExportedClass = "exported_class",
+    DefaultExport = "default_export",
+    Other = "other"
+}
+export interface FileDeclaration {
+    node: ts.Statement;
+    type: DeclarationType;
+    name: string;
+    isExported: boolean;
+    isDefaultExport: boolean;
+    text: string;
+    dependencies?: Set<string>;
+    originalIndex?: number;
+}
+export declare const DEFAULT_FILE_ORDER: DeclarationType[];
+export declare class FileDeclarationSortingRule extends BaseFormattingRule {
+    readonly name = "FileDeclarationSortingRule";
+    private getDeclarationType;
+    private analyzeDeclaration;
+    private createSourceFile;
+    private sortFileDeclarations;
+    apply(source: string, filePath?: string): string;
+}

package/dist/core/formatters/rules/ast/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./ClassMemberSortingRule";
+export * from "./FileDeclarationSortingRule";

package/dist/core/formatters/rules/imports/ImportOrganizationRule.d.ts

@@ -0,0 +1,15 @@
+import { BaseFormattingRule } from "../../BaseFormattingRule";
+export declare class ImportOrganizationRule extends BaseFormattingRule {
+    readonly name = "ImportOrganizationRule";
+    private createSourceFile;
+    private determineImportGroup;
+    private extractImports;
+    private getImportedIdentifiers;
+    private isIdentifierUsed;
+    private isImportUsed;
+    private filterUnusedImports;
+    private sortImports;
+    private groupImports;
+    private reconstructSource;
+    apply(source: string, filePath?: string): string;
+}

package/dist/core/formatters/rules/imports/index.d.ts

@@ -0,0 +1 @@
+export * from "./ImportOrganizationRule";

package/dist/core/formatters/rules/index-generation/IndexGenerationRule.d.ts

@@ -0,0 +1,27 @@
+import { BaseFormattingRule } from "../../BaseFormattingRule";
+export interface IndexGenerationOptions {
+    fileExtension: string;
+    indexFileName: string;
+    recursive: boolean;
+}
+export interface IndexGenerationConfig {
+    enabled?: boolean;
+    directories?: string[];
+    skipDirectories?: string[];
+    options?: Partial<IndexGenerationOptions>;
+    updateMainIndex?: boolean;
+}
+export declare class IndexGenerationRule extends BaseFormattingRule {
+    private readonly defaultOptions;
+    readonly name = "IndexGenerationRule";
+    private findProjectRoot;
+    private isTestDirectory;
+    private isTestFile;
+    private generateSingleDirectoryIndex;
+    private generateIndexExportRecursive;
+    private generateIndexExport;
+    private discoverExportableModules;
+    private updateMainIndex;
+    private generateIndexFiles;
+    apply(source: string, filePath?: string): string;
+}

package/dist/core/formatters/rules/index-generation/IndexGenerationRule.js

@@ -62,7 +62,7 @@ class IndexGenerationRule extends BaseFormattingRule.BaseFormattingRule {
     ];
     return testPatterns.some((pattern) => pattern.test(fileName));
   }
-  generateSingleDirectoryIndex(dir, options) {
+  generateSingleDirectoryIndex(dir, skipPaths, options) {
     try {
       const entries = fs__namespace.readdirSync(dir, { withFileTypes: true });
       const exports$1 = [];
@@ -74,7 +74,11 @@ class IndexGenerationRule extends BaseFormattingRule.BaseFormattingRule {
           if (this.isTestDirectory(entry.name)) {
             continue;
           }
-          const subIndexPath = path__namespace.join(dir, entry.name, options.indexFileName);
+          const subDir = path__namespace.join(dir, entry.name);
+          if (skipPaths.has(subDir)) {
+            continue;
+          }
+          const subIndexPath = path__namespace.join(subDir, options.indexFileName);
           if (fs__namespace.existsSync(subIndexPath)) {
             exports$1.push(`export * from "./${entry.name}";`);
           }
@@ -104,7 +108,7 @@ ${exports$1.join("\n")}
       console.warn(`Warning: Failed to generate index for ${dir}: ${error.message}`);
     }
   }
-  generateIndexExportRecursive(dir, options) {
+  generateIndexExportRecursive(dir, skipPaths, options) {
     try {
       const entries = fs__namespace.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
@@ -113,22 +117,25 @@ ${exports$1.join("\n")}
             continue;
           }
           const subDir = path__namespace.join(dir, entry.name);
-          this.generateIndexExportRecursive(subDir, options);
+          if (skipPaths.has(subDir)) {
+            continue;
+          }
+          this.generateIndexExportRecursive(subDir, skipPaths, options);
         }
       }
-      this.generateSingleDirectoryIndex(dir, options);
+      this.generateSingleDirectoryIndex(dir, skipPaths, options);
     } catch (error) {
       console.warn(`Warning: Failed to process directory ${dir}: ${error.message}`);
     }
   }
-  generateIndexExport(dir, options) {
+  generateIndexExport(dir, skipPaths, options) {
     if (!fs__namespace.existsSync(dir)) {
       return;
     }
     if (options.recursive) {
-      this.generateIndexExportRecursive(dir, options);
+      this.generateIndexExportRecursive(dir, skipPaths, options);
     } else {
-      this.generateSingleDirectoryIndex(dir, options);
+      this.generateSingleDirectoryIndex(dir, skipPaths, options);
     }
   }
   discoverExportableModules(srcDir) {
@@ -180,9 +187,15 @@ ${exports$1}
       const config = this.getIndexGenerationConfig();
       const directories = config?.directories || [];
       const options = { ...this.defaultOptions, ...config?.options };
+      const skipPaths = new Set(
+        (config?.skipDirectories || []).map((d) => path__namespace.resolve(projectRoot, d))
+      );
       for (const dir of directories) {
         const fullDirPath = path__namespace.resolve(projectRoot, dir);
-        this.generateIndexExport(fullDirPath, options);
+        if (skipPaths.has(fullDirPath)) {
+          continue;
+        }
+        this.generateIndexExport(fullDirPath, skipPaths, options);
       }
       if (config?.updateMainIndex !== false) {
         const srcDir = path__namespace.join(projectRoot, "src");

package/dist/core/formatters/rules/index-generation/index.d.ts

@@ -0,0 +1 @@
+export * from "./IndexGenerationRule";

package/dist/core/formatters/rules/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./ast";
+export * from "./imports";
+export * from "./index-generation";
+export * from "./spacing";
+export * from "./style";

package/dist/core/formatters/rules/spacing/BlankLineBeforeReturnsRule.d.ts

@@ -0,0 +1,5 @@
+import { BaseFormattingRule } from "../../BaseFormattingRule";
+export declare class BlankLineBeforeReturnsRule extends BaseFormattingRule {
+    readonly name = "BlankLineBeforeReturnsRule";
+    apply(source: string, filePath?: string): string;
+}

package/dist/core/formatters/rules/spacing/BlankLineBetweenDeclarationsRule.d.ts

@@ -0,0 +1,6 @@
+import { BaseFormattingRule } from "../../BaseFormattingRule";
+export declare class BlankLineBetweenDeclarationsRule extends BaseFormattingRule {
+    readonly name = "BlankLineBetweenDeclarationsRule";
+    private getDeclarationKeyword;
+    apply(source: string, filePath?: string): string;
+}

package/dist/core/formatters/rules/spacing/BlankLineBetweenStatementTypesRule.d.ts

@@ -0,0 +1,6 @@
+import { BaseFormattingRule } from "../../BaseFormattingRule";
+export declare class BlankLineBetweenStatementTypesRule extends BaseFormattingRule {
+    readonly name = "BlankLineBetweenStatementTypesRule";
+    private getStatementType;
+    apply(source: string, filePath?: string): string;
+}

package/dist/core/formatters/rules/spacing/BlockSpacingRule.d.ts

@@ -0,0 +1,5 @@
+import { BaseFormattingRule } from "../../BaseFormattingRule";
+export declare class BlockSpacingRule extends BaseFormattingRule {
+    readonly name = "BlockSpacingRule";
+    apply(source: string, filePath?: string): string;
+}

package/dist/core/formatters/rules/spacing/BracketSpacingRule.d.ts

@@ -0,0 +1,5 @@
+import { BaseFormattingRule } from "../../BaseFormattingRule";
+export declare class BracketSpacingRule extends BaseFormattingRule {
+    readonly name = "BracketSpacingRule";
+    apply(source: string, filePath?: string): string;
+}

package/dist/core/formatters/rules/spacing/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./BlankLineBeforeReturnsRule";
+export * from "./BlankLineBetweenDeclarationsRule";
+export * from "./BlankLineBetweenStatementTypesRule";
+export * from "./BlockSpacingRule";
+export * from "./BracketSpacingRule";

package/dist/core/formatters/rules/style/DocBlockCommentRule.d.ts

@@ -0,0 +1,5 @@
+import { BaseFormattingRule } from "../../BaseFormattingRule";
+export declare class DocBlockCommentRule extends BaseFormattingRule {
+    readonly name = "DocBlockCommentRule";
+    apply(source: string, filePath?: string): string;
+}

package/dist/core/formatters/rules/style/IndentationRule.d.ts

@@ -0,0 +1,5 @@
+import { BaseFormattingRule } from "../../BaseFormattingRule";
+export declare class IndentationRule extends BaseFormattingRule {
+    readonly name = "IndentationRule";
+    apply(source: string, filePath?: string): string;
+}

package/dist/core/formatters/rules/style/QuoteStyleRule.d.ts

@@ -0,0 +1,5 @@
+import { BaseFormattingRule } from "../../BaseFormattingRule";
+export declare class QuoteStyleRule extends BaseFormattingRule {
+    readonly name = "QuoteStyleRule";
+    apply(source: string, filePath?: string): string;
+}

package/dist/core/formatters/rules/style/SemicolonRule.d.ts

@@ -0,0 +1,5 @@
+import { BaseFormattingRule } from "../../BaseFormattingRule";
+export declare class SemicolonRule extends BaseFormattingRule {
+    readonly name = "SemicolonRule";
+    apply(source: string, filePath?: string): string;
+}

package/dist/core/formatters/rules/style/StructuralIndentationRule.d.ts

@@ -0,0 +1,11 @@
+import { BaseFormattingRule } from "../../BaseFormattingRule";
+export declare class StructuralIndentationRule extends BaseFormattingRule {
+    readonly name = "StructuralIndentationRule";
+    private skipString;
+    private isRegexStart;
+    private skipRegex;
+    private getLineIndentLevel;
+    private startsWithClosingBracket;
+    private findBracketFixes;
+    apply(source: string, filePath?: string): string;
+}

package/dist/core/formatters/rules/style/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./DocBlockCommentRule";
+export * from "./IndentationRule";
+export * from "./QuoteStyleRule";
+export * from "./SemicolonRule";
+export * from "./StructuralIndentationRule";

package/dist/core/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./ast";
+export * from "./config";
+export * from "./di";
+export * from "./formatters";
+export * from "./pipeline";

package/dist/core/pipeline/FormatterPipeline.d.ts

@@ -0,0 +1,42 @@
+import { CoreConfig, FormatterOrder } from "../config";
+import { Container } from "../di";
+import { IFormattingRule } from "../formatters";
+export interface FormatterExecution {
+    formatterName: string;
+    order: FormatterOrder;
+    changed: boolean;
+    error?: Error;
+}
+export interface PipelineContext {
+    filePath: string;
+    originalSource: string;
+    currentSource: string;
+    executions: FormatterExecution[];
+    changed: boolean;
+    dryRun: boolean;
+}
+export declare class FormatterError extends Error {
+    readonly formatterName: string;
+    readonly filePath: string;
+    readonly originalError: Error;
+    constructor(formatterName: string, filePath: string, originalError: Error);
+}
+export declare class FormatterPipeline {
+    private readonly config;
+    private readonly container;
+    private formatterOrder;
+    private rules;
+    constructor(config: CoreConfig, container: Container);
+    private extractTypeNameFromStack;
+    private addRule;
+    private addRuleByName;
+    private getFilesRecursively;
+    private shouldIgnoreFile;
+    formatFile(filePath: string, dryRun?: boolean): Promise<PipelineContext>;
+    formatFiles(filePaths: string[], dryRun?: boolean): Promise<PipelineContext[]>;
+    formatDirectory(dirPath: string, dryRun?: boolean, extensions?: string[]): Promise<PipelineContext[]>;
+    getFormatterOrder(): FormatterOrder[];
+    getRulesAtOrder(order: FormatterOrder): IFormattingRule[];
+    hasRules(): boolean;
+    private initializeRules;
+}

package/dist/core/pipeline/index.d.ts

@@ -0,0 +1 @@
+export * from "./FormatterPipeline";

package/dist/formatters/index.d.ts

@@ -0,0 +1 @@
+export * from "./package";

package/dist/formatters/package.d.ts

@@ -0,0 +1 @@
+export declare function sortExportsKeys(exports: Record<string, any>): Record<string, any>;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./build-plugins";
+export * from "./core";
+export * from "./formatters";
+export * from "./shared";

package/dist/shared/index.d.ts

@@ -0,0 +1 @@
+export * from "./types";

package/dist/shared/types.d.ts

@@ -0,0 +1,7 @@
+export interface SortOptions {
+    customSortOrder?: string[];
+    indentation?: number;
+    filePath?: string;
+    dryRun?: boolean;
+}
+export declare const DefaultSortOptions: SortOptions;

package/dist/sortPackage.d.ts

@@ -0,0 +1,3 @@
+import { SortOptions } from "./shared";
+export declare function sortPackageJson(packageObj: Record<string, any>, options?: SortOptions): Record<string, any>;
+export declare function sortPackageFile(filePath?: string, options?: SortOptions): Record<string, any>;

package/dist/sortTSConfig.d.ts

@@ -0,0 +1,3 @@
+import { SortOptions } from "./shared/types";
+export declare function sortTsConfig(tsConfig: Record<string, any>): Record<string, any>;
+export declare function sortTsConfigFile(filePath?: string, options?: SortOptions): Record<string, any>;

package/dist/tsfmt.d.ts

@@ -0,0 +1,2 @@
+import { CoreConfig } from "./core/config";
+export declare function tsfmt(config?: Partial<CoreConfig>): CoreConfig;

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "tsfmt",
     "author": "Encore Digital Group",
-    "version": "0.2.3",
+    "version": "0.2.5",
     "description": "An opinionated TypeScript code formatter",
     "publishConfig": {
         "access": "public",
@@ -25,12 +25,19 @@
         "vite": "^7.0.0"
     },
     "scripts": {
-        "build": "vite build",
+        "build": "vite build && tsc --emitDeclarationOnly --declarationDir dist",
         "dev": "tsx src/cli.ts",
         "format": "node dist/cli.js",
         "test": "jest"
     },
-    "main": "dist/cli.js",
+    "types": "dist/index.d.ts",
+    "main": "dist/index.js",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "require": "./dist/index.js"
+        }
+    },
     "files": [
         "dist",
         "README.md"