Dependencies Engine

/**
 * Dependencies engine for analyzing and storing project dependencies
 * Uses singleton pattern - access via DependenciesEngine.getInstance() or default export
 */
class DependenciesEngine {
  // Public instance properties
  rawData: ParsedData;
  modules: Object[];
  rawModules: Object[];
  rawModulesForOverview: Object[];
  components: Object[];
  controllers: Object[];
  entities: Object[];
  directives: Object[];
  injectables: Object[];
  interceptors: Object[];
  guards: Object[];
  interfaces: Object[];
  routes: RouteInterface;
  pipes: Object[];
  classes: Object[];
  miscellaneous: MiscellaneousData;
  
  /**
   * Get singleton instance of DependenciesEngine
   * @returns DependenciesEngine instance
   */
  static getInstance(): DependenciesEngine;
  
  /**
   * Initialize the dependencies engine with parsed data
   * @param data - Parsed dependency data from code analysis
   */
  init(data: ParsedData): void;
  
  /**
   * Update the dependencies engine with new parsed data
   * @param data - Updated parsed dependency data
   */
  update(data: ParsedData): void;
  
  /**
   * Find dependency by name across all types
   * @param name - Name of the dependency to find
   * @returns API source result or undefined if not found
   */
  find(name: string): IApiSourceResult<any> | undefined;
  
  /**
   * Find dependency in compodoc data
   * @param name - Name of the dependency to find
   * @returns Found dependency data
   */
  findInCompodoc(name: string): any;
  
  // Data access methods
  getModules(): Object[];
  getComponents(): Object[];
  getDirectives(): Object[];
  getInjectables(): Object[];
  getInterceptors(): Object[];
  getGuards(): Object[];
  getPipes(): Object[];
  getClasses(): Object[];
  getInterfaces(): Object[];
  getControllers(): Object[];
  getEntities(): Object[];
  getRoutes(): RouteInterface;
  getMiscellaneous(): MiscellaneousData;
  getModule(name: string): any;
  getRawModule(name: string): any;
}

import DependenciesEngine from "@compodoc/compodoc";
// or
// import { DependenciesEngine } from "@compodoc/compodoc";
// const engine = DependenciesEngine.getInstance();

// Using the default export (already an instance)
const parsedData = /* ... parsed from TypeScript files ... */;
DependenciesEngine.init(parsedData);

// Access different types of dependencies
const allModules = DependenciesEngine.getModules();
const allComponents = DependenciesEngine.getComponents();
const allServices = DependenciesEngine.getInjectables();

// Get specific module data
const appModule = DependenciesEngine.getRawModule("AppModule");
const specificModule = DependenciesEngine.getModule("MyModule");

// Find specific dependencies
const found = DependenciesEngine.find("MyComponent");
const compodocData = DependenciesEngine.findInCompodoc("MyService");

// Access miscellaneous items (functions, variables, etc.)
const misc = DependenciesEngine.getMiscellaneous();
console.log(misc.functions.length); // Number of standalone functions
console.log(misc.variables.length); // Number of standalone variables

/**
 * Get all Angular modules
 * @returns Array of module objects
 */
getModules(): Object[];

/**
 * Get all Angular components
 * @returns Array of component objects
 */
getComponents(): Object[];

/**
 * Get all Angular directives
 * @returns Array of directive objects
 */
getDirectives(): Object[];

/**
 * Get all Angular injectables (services)
 * @returns Array of injectable objects
 */
getInjectables(): Object[];

/**
 * Get all Angular interceptors
 * @returns Array of interceptor objects
 */
getInterceptors(): Object[];

/**
 * Get all Angular guards
 * @returns Array of guard objects
 */
getGuards(): Object[];

/**
 * Get all Angular pipes
 * @returns Array of pipe objects
 */
getPipes(): Object[];

/**
 * Get all TypeScript classes
 * @returns Array of class objects
 */
getClasses(): Object[];

/**
 * Get all TypeScript interfaces
 * @returns Array of interface objects
 */
getInterfaces(): Object[];

/**
 * Get all controllers (for AngularJS projects)
 * @returns Array of controller objects
 */
getControllers(): Object[];

/**
 * Get all entities
 * @returns Array of entity objects
 */
getEntities(): Object[];

/**
 * Get application routes
 * @returns Route interface containing routing information
 */
getRoutes(): RouteInterface;

/**
 * Get miscellaneous items (functions, variables, type aliases, enums)
 * @returns MiscellaneousData containing various standalone items
 */
getMiscellaneous(): MiscellaneousData;

/**
 * Get module data by name
 * @param name - Name of the module to retrieve
 * @returns Module object
 */
getModule(name: string): any;

/**
 * Get raw module data by name
 * @param name - Name of the module to retrieve
 * @returns Raw module object
 */
getRawModule(name: string): any;

interface ParsedData {
  modules: any[];
  components: any[];
  directives: any[];
  injectables: any[];
  interceptors: any[];
  guards: any[];
  pipes: any[];
  classes: any[];
  interfaces: any[];
  routes: RouteInterface;
  miscellaneous: MiscellaneousData;
}

interface RouteInterface {
  children: any[];
  // Additional route properties
}

interface MiscellaneousData {
  variables: any[];
  functions: any[];
  typealiases: any[];
  enumerations: any[];
  groupedVariables: any[];
  groupedFunctions: any[];
  groupedEnumerations: any[];
  groupedTypeAliases: any[];
}

/**
 * Parser for Angular-specific dependencies and decorators
 */
class AngularDependencies {
  constructor(
    files: string[],
    options: { tsconfigDirectory: string },
    configuration: Configuration,
    routerParser: any
  );
  
  /**
   * Get dependencies from the provided files
   * @returns ParsedData containing all analyzed dependencies
   */
  getDependencies(): ParsedData;
}

/**
 * Parser for AngularJS-specific dependencies
 */
class AngularJSDependencies {
  constructor(
    files: string[],
    options: { tsconfigDirectory: string },
    configuration: Configuration,
    routerParser: any
  );
  
  /**
   * Get dependencies from the provided files
   * @returns ParsedData containing all analyzed dependencies
   */
  getDependencies(): ParsedData;
}

import { AngularDependencies, AngularJSDependencies } from "@compodoc/compodoc";

// For Angular projects
const angularParser = new AngularDependencies(
  ["src/**/*.ts"],
  { tsconfigDirectory: "./src" },
  Configuration.getInstance(),
  RouterParserUtil
);

const angularData = angularParser.getDependencies();

// For AngularJS projects
const angularJSParser = new AngularJSDependencies(
  ["src/**/*.js"],
  { tsconfigDirectory: "./src" },
  Configuration.getInstance(),
  RouterParserUtil
);

const angularJSData = angularJSParser.getDependencies();

interface IComponentDep {
  name: string;
  id: string;
  file: string;
  type: "component";
  selector: string;
  templateUrl: string;
  styleUrls: string[];
  template: string;
  styles: string[];
  standalone?: boolean;
  // Additional component properties
}

interface IDirectiveDep {
  name: string;
  id: string;
  file: string;
  type: "directive";
  selector: string;
  // Additional directive properties
}

interface IModuleDep {
  name: string;
  id: string;
  file: string;
  type: "module";
  declarations: any[];
  imports: any[];
  exports: any[];
  providers: any[];
  bootstrap: any[];
  // Additional module properties
}

interface IInjectableDep {
  name: string;
  id: string;
  file: string;
  type: "injectable";
  providedIn?: string;
  // Additional injectable properties
}

interface IGuardDep {
  name: string;
  id: string;
  file: string;
  type: "guard";
  // Additional guard properties
}

interface IPipeDep {
  name: string;
  id: string;
  file: string;
  type: "pipe";
  name: string;
  pure?: boolean;
  // Additional pipe properties
}

interface IInterceptorDep {
  name: string;
  id: string;
  file: string;
  type: "interceptor";
  // Additional interceptor properties
}