Configuration Management

/**
 * Reads and parses dependency-cruiser configuration file with extends support
 * @param configFileName - Path to configuration file
 * @param alreadyVisited - Set of already visited files (for circular detection)
 * @param baseDirectory - Base directory for resolving relative paths
 * @returns Promise resolving to parsed configuration object
 */
function extractDepcruiseConfig(
  configFileName: string,
  alreadyVisited?: Set<string>,
  baseDirectory?: string
): Promise<IConfiguration>;

/**
 * Extracts cruise options from configuration file
 * @param configFileName - Path to configuration file
 * @returns Promise resolving to cruise options
 */
function extractDepcruiseOptions(configFileName: string): Promise<ICruiseOptions>;

import extractDepcruiseConfig from "dependency-cruiser/config-utl/extract-depcruise-config";
import extractDepcruiseOptions from "dependency-cruiser/config-utl/extract-depcruise-options";

// Extract full configuration
const config = await extractDepcruiseConfig("./.dependency-cruiser.js");
console.log(config.forbidden.length); // Number of forbidden rules

// Extract only cruise options
const options = await extractDepcruiseOptions("./.dependency-cruiser.js");
console.log(options.validate); // Whether validation is enabled

// Use configuration with cruise
import { cruise } from "dependency-cruiser";
const result = await cruise(["src"], options);

/**
 * Reads and parses TypeScript configuration file
 * @param tsConfigFileName - Path to tsconfig.json file
 * @returns Promise resolving to parsed TypeScript configuration
 */
function extractTsConfig(tsConfigFileName: string): Promise<object>;

import extractTsConfig from "dependency-cruiser/config-utl/extract-ts-config";

// Extract TypeScript configuration
const tsConfig = await extractTsConfig("./tsconfig.json");

// Use with cruise for TypeScript projects
import { cruise } from "dependency-cruiser";
const result = await cruise(
  ["src"],
  { tsPreCompilationDeps: true },
  { extensions: [".ts", ".tsx"] },
  { tsConfig }
);

/**
 * Reads and parses Babel configuration file
 * @param babelConfigFileName - Path to Babel configuration file
 * @returns Promise resolving to parsed Babel configuration
 * @throws Error when config has unknown extension or is invalid
 */
function extractBabelConfig(babelConfigFileName: string): Promise<object>;

import extractBabelConfig from "dependency-cruiser/config-utl/extract-babel-config";

// Extract Babel configuration
const babelConfig = await extractBabelConfig("./.babelrc.js");

// Use with cruise for Babel-transpiled projects
import { cruise } from "dependency-cruiser";
const result = await cruise(
  ["src"],
  {},
  {},
  { babelConfig }
);

/**
 * Extracts webpack resolve configuration from webpack config file
 * @param webpackConfigFileName - Path to webpack configuration file
 * @param env - Environment variables passed to webpack config
 * @param argv - Arguments passed to webpack config
 * @returns Promise resolving to webpack resolve configuration
 */
function extractWebpackResolveConfig(
  webpackConfigFileName: string,
  env?: WebpackEnvType,
  argv?: any
): Promise<object>;

import extractWebpackResolveConfig from "dependency-cruiser/config-utl/extract-webpack-resolve-config";

// Extract webpack resolve config
const webpackResolve = await extractWebpackResolveConfig("./webpack.config.js");

// Use with cruise for webpack-configured projects
import { cruise } from "dependency-cruiser";
const result = await cruise(
  ["src"],
  {},
  webpackResolve // Use as resolve options
);

// Extract with environment and arguments
const webpackResolve = await extractWebpackResolveConfig(
  "./webpack.config.js",
  { NODE_ENV: "production" },
  { mode: "production" }
);

interface IConfiguration {
  /** Forbidden dependency rules */
  forbidden?: IRegularForbiddenRuleType[];
  
  /** Allowed dependency rules */
  allowed?: IRegularAllowedRuleType[];
  
  /** Required dependency rules */
  required?: IRegularRequiredRuleType[];
  
  /** Default severity for allowed rules */
  allowedSeverity?: SeverityType;
  
  /** Rule set options */
  options?: IRuleSetOptions;
  
  /** Cruise options */
  options?: ICruiseOptions;
  
  /** Configuration inheritance */
  extends?: string | string[];
}

interface ITsConfig {
  /** Path to TypeScript configuration file */
  fileName?: string;
  
  /** Parsed TypeScript compiler options */
  compilerOptions?: any;
  
  /** TypeScript project references */
  references?: any[];
  
  /** Include patterns */
  include?: string[];
  
  /** Exclude patterns */
  exclude?: string[];
}

interface IBabelConfig {
  /** Path to Babel configuration file */
  fileName?: string;
  
  /** Babel presets */
  presets?: any[];
  
  /** Babel plugins */
  plugins?: any[];
  
  /** Additional Babel options */
  [key: string]: any;
}

interface IWebpackConfig {
  /** Arguments used with webpack config */
  arguments?: { [key: string]: any };
  
  /** Environment variables passed to webpack config */
  env?: WebpackEnvType;
  
  /** Path to webpack configuration file */
  fileName?: string;
}

type WebpackEnvType = { [key: string]: any } | string;

module.exports = {
  forbidden: [
    {
      name: "no-circular",
      comment: "Prevent circular dependencies",
      severity: "error",
      from: {},
      to: { circular: true }
    },
    {
      name: "no-deprecated-core",
      comment: "Don't use deprecated core modules",
      severity: "warn",
      from: {},
      to: {
        dependencyTypes: ["core"],
        path: "^(punycode|domain|sys)$"
      }
    }
  ],
  options: {
    doNotFollow: "node_modules",
    moduleSystems: ["amd", "cjs", "es6"],
    tsPreCompilationDeps: true,
    progress: { type: "cli-feedback" }
  }
};

// .dependency-cruiser.js
module.exports = {
  extends: ["./shared-rules.js"],
  forbidden: [
    // Additional project-specific rules
    {
      name: "no-test-imports-in-src",
      from: { path: "^src/" },
      to: { path: "test/" }
    }
  ],
  options: {
    tsConfig: { fileName: "./tsconfig.json" }
  }
};

// shared-rules.js
module.exports = {
  forbidden: [
    {
      name: "no-circular",
      from: {},
      to: { circular: true }
    }
  ]
};

import { cruise } from "dependency-cruiser";
import extractTsConfig from "dependency-cruiser/config-utl/extract-ts-config";
import extractDepcruiseOptions from "dependency-cruiser/config-utl/extract-depcruise-options";

// Extract configurations
const [cruiseOptions, tsConfig] = await Promise.all([
  extractDepcruiseOptions("./.dependency-cruiser.js"),
  extractTsConfig("./tsconfig.json")
]);

// Analyze with both configurations
const result = await cruise(
  ["src", "test"],
  {
    ...cruiseOptions,
    tsPreCompilationDeps: true
  },
  { extensions: [".ts", ".tsx", ".js"] },
  { tsConfig }
);

import { cruise } from "dependency-cruiser";
import extractDepcruiseConfig from "dependency-cruiser/config-utl/extract-depcruise-config";
import extractBabelConfig from "dependency-cruiser/config-utl/extract-babel-config";
import extractWebpackResolveConfig from "dependency-cruiser/config-utl/extract-webpack-resolve-config";

// Extract all configurations
const [config, babelConfig, webpackResolve] = await Promise.all([
  extractDepcruiseConfig("./.dependency-cruiser.js"),
  extractBabelConfig("./babel.config.js"),
  extractWebpackResolveConfig("./webpack.config.js")
]);

// Convert config to options
const cruiseOptions = {
  ...config.options,
  ruleSet: config,
  validate: true
};

// Analyze with all configurations
const result = await cruise(
  ["src"],
  cruiseOptions,
  webpackResolve,
  { babelConfig }
);

try {
  const config = await extractDepcruiseConfig("./missing-config.js");
} catch (error) {
  console.error("Configuration error:", error.message);
  // Handle missing or invalid configuration
}

try {
  const babelConfig = await extractBabelConfig("./invalid-babel.config.js");
} catch (error) {
  if (error.message.includes("returns a function")) {
    console.error("Function-format Babel configs not supported");
  }
}

import { cruise } from "dependency-cruiser";

try {
  const result = await cruise(
    ["src"],
    {
      validate: true,
      ruleSet: {
        forbidden: [
          {
            // Invalid rule - missing required properties
            severity: "error"
          }
        ]
      }
    }
  );
} catch (error) {
  console.error("Invalid configuration:", error.message);
}