sverweij/dependency-cruiser

Features

• Dependency Visualizers - Generates graphical maps of module relationships to visualize the internal structure of JavaScript and TypeScript projects.
• Dead Code Elimination - Locates orphan modules and unreachable files in a codebase to remove unused logic and reduce bundle size.
• Missing Dependency Detection - Detects dependencies that cannot be resolved on disk to identify missing packages or incorrect file paths.
• Circular Dependency Detectors - Finds and eliminates recursive module import loops in JavaScript and TypeScript projects to avoid runtime errors.
• Module Resolution - Implements resolution logic for various JavaScript ecosystems including CommonJS, ES6, and TypeScript.
• Architecture Rule Enforcement - Enforces structural rules and boundaries in JavaScript and TypeScript codebases to prevent architectural regressions.
• Configuration-Driven Rule Engines - Evaluates the generated dependency graph against a set of user-defined allowed and forbidden relationship rules via configuration files.
• Dependency Blacklists - Specifies a list of prohibited dependencies and emits errors or warnings when a violation is detected.
• Dependency Graph Visualizations - Generates graphical maps of module relationships to visualize and analyze the project's internal architectural structure.
• Dependency Whitelists - Creates a whitelist of permissible dependencies and flags any module that does not satisfy at least one allowed rule.
• JavaScript and TypeScript Dependency Analyzers - Maps, visualizes, and validates module dependencies specifically for JavaScript and TypeScript projects.
• Dependency Boundary Enforcers - Enforces architectural integrity by ensuring specific modules depend on required targets.
• TypeScript - Analyzes TypeScript source files to determine dependency relationships without requiring a separate transpilation step.
• Dependency Tree Traversers - Walks through the module tree starting from root files to map all direct and indirect dependency relationships.
• Module Dependency Analysis - Provides static analysis of module graphs across multiple standards including ES6, CommonJS, and TypeScript.
• Path-Pattern Dependency Restrictions - Defines forbidden or allowed relationships between files or folders using path patterns to prevent regressions.
• Architectural Constraint Validation - Checks a codebase for forbidden dependencies, circular references, or orphan modules and returns a non-zero exit code for violations.
• Architectural Boundary Testing - Analyzes codebase structure to ensure architectural boundaries and constraints are respected during CI.
• TypeScript Static Analysis - Analyzes imports and type-only dependencies in TypeScript projects without requiring a full compilation step.
• Static Code Analysis Tools - Inspects source code without execution to identify orphan modules and unresolved dependencies.
• AST Extraction - Parses source code into abstract syntax trees to identify import and require statements across multiple module systems.
• Regex Path Matchers - Validates architectural boundaries by comparing resolved module paths against regular expression patterns.
• Dependency List Filters - Uses regular expressions to include or exclude specific files or folders from a dependency rule.
• Relationship Graph Visualizers - Generates visual maps of how files and folders relate through imports using directed node graphs.
• Architectural Aggregations - Collapses individual module nodes into folder-level representations to simplify the visualization of large architectural structures.
• Coupling Metrics - Calculates afferent and efferent couplings to determine the instability metric of modules and folders.
• Graph Aggregation - Groups multiple modules and their dependencies into higher-level aggregates to simplify architectural overviews.
• Folder-Level Module Aggregates - Collapses multiple modules into a single folder-level node in visual reports for high-level architectural overviews.
• Sibling Folder Isolation - Provides the ability to ban dependencies between sibling folders using regular expression group matching.
• Dependency Reachability Analysis - Checks if a module can be reached from another either directly or through intermediate modules to find dead code.
• Dependency Type Restrictions - Prevents specific types of dependencies, such as blocking development dependencies from production source files.
• Folder-Level Dependency Aggregates - Collapses individual module dependencies into folder-level aggregates to provide a high-level architectural overview.
• Monorepo Dependency Auditing - Supports complex monorepo structures by merging dependency definitions up to the repository root.
• Dependency Tree Exports - Exports the dependency matrix and internal representations into text, JSON, or CSV files.
• Software Stability Metrics - Calculates afferent and efferent coupling to determine the instability and fragility of specific modules or folders.
• Hierarchical Dependency Restrictions - Prevents modules in a lower folder from importing modules located in a higher folder in the directory hierarchy.
• Instability Analysis - Flags dependencies that are more unstable than the modules depending on them.
• Orphaned Module Detection - Flags modules that have neither incoming nor outgoing dependencies to find unused leftovers.
• Type-Only Import Analysis - Includes TypeScript type-only imports that exist before compilation in the final dependency graph.
• Underused Module Detection - Flags modules with fewer than a specified number of dependents to identify underutilized code.
• Violation Baselining - Records existing dependency violations into a file to isolate new regressions from legacy issues.
• Affected Project Detectors - Identifies all modules directly or indirectly affected by changes since a specific version control revision.
• Architecture Verification - JavaScript/TypeScript tool for validating architecture rules.
• Architecture Visualization - Tool for visualizing and validating module dependencies.

Istoric stele