tsfmt 0.2.3 → 0.2.4

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,26 @@
+import { BaseFormattingRule } from "../../BaseFormattingRule";
+export interface IndexGenerationOptions {
+    fileExtension: string;
+    indexFileName: string;
+    recursive: boolean;
+}
+export interface IndexGenerationConfig {
+    enabled?: boolean;
+    directories?: 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/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,5 @@
+export * from "./build-plugins";
+export * from "./core";
+export * from "./formatters";
+export * from "./shared";
+export { tsfmt } from "./tsfmt";

package/dist/index.js

@@ -29,6 +29,7 @@ const StructuralIndentationRule = require("./core/formatters/rules/style/Structu
 const FormatterPipeline = require("./core/pipeline/FormatterPipeline.js");
 const _package = require("./formatters/package.js");
 const types = require("./shared/types.js");
+const tsfmt = require("./tsfmt.js");
 exports.transformGenericsPlugin = transformGenericsPlugin.transformGenericsPlugin;
 exports.ASTAnalyzer = ASTAnalyzer.ASTAnalyzer;
 exports.ASTTransformer = ASTTransformer.ASTTransformer;
@@ -64,3 +65,4 @@ exports.FormatterError = FormatterPipeline.FormatterError;
 exports.FormatterPipeline = FormatterPipeline.FormatterPipeline;
 exports.sortExportsKeys = _package.sortExportsKeys;
 exports.DefaultSortOptions = types.DefaultSortOptions;
+exports.tsfmt = tsfmt.tsfmt;

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/dist/tsfmt.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./core/config/ConfigDefaults.js");
+require("./core/config/ConfigLoader.js");
+const ConfigMerger = require("./core/config/ConfigMerger.js");
+function tsfmt(config = {}) {
+  return ConfigMerger.ConfigMerger.merge(config);
+}
+exports.tsfmt = tsfmt;

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "tsfmt",
     "author": "Encore Digital Group",
-    "version": "0.2.3",
+    "version": "0.2.4",
     "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"