Export Engine

/**
 * Export engine for generating documentation in various formats
 */
class ExportEngine {
  /**
   * Get singleton instance of ExportEngine
   * @returns ExportEngine instance
   */
  static getInstance(): ExportEngine;
  
  /**
   * Export documentation in the configured format
   * @param outputFolder - Directory to export documentation to
   * @param data - Main configuration data containing export settings
   * @returns Promise resolving when export is complete
   */
  export(outputFolder: string, data: MainDataInterface): Promise<any>;
}

import ExportEngine from "@compodoc/compodoc";

// Get export engine instance
const exporter = ExportEngine.getInstance();

// Export documentation (format determined by Configuration.mainData.exportFormat)
await exporter.export("./output", Configuration.mainData);

/**
 * Available export formats
 */
type ExportFormat = "html" | "json";

/**
 * Export format configuration
 */
interface ExportFormatConfig {
  /**
   * HTML export (default)
   * Generates complete HTML documentation website
   */
  html: {
    format: "html";
    description: "Complete HTML documentation website";
    features: [
      "Interactive navigation",
      "Search functionality", 
      "Dependency graphs",
      "Coverage reports",
      "Multiple themes"
    ];
  };
  
  /**
   * JSON export
   * Exports all documentation data as structured JSON
   */
  json: {
    format: "json";
    description: "Structured JSON data export";
    features: [
      "Complete API data",
      "Programmatic access",
      "Custom processing",
      "Integration ready"
    ];
  };
}

/**
 * HTML export configuration and features
 */
interface HtmlExportConfig {
  /**
   * Export format identifier
   */
  format: "html";
  
  /**
   * Generated file structure
   */
  structure: {
    "index.html": "Main entry point";
    "modules/": "Angular modules documentation";
    "components/": "Angular components documentation";
    "directives/": "Angular directives documentation";
    "injectables/": "Services and injectables documentation";
    "guards/": "Route guards documentation";
    "pipes/": "Angular pipes documentation";
    "classes/": "TypeScript classes documentation";
    "interfaces/": "TypeScript interfaces documentation";
    "miscellaneous/": "Functions, variables, and type aliases";
    "coverage.html": "Documentation coverage report";
    "routes.html": "Application routes visualization";
    "js/": "JavaScript resources and search index";
    "styles/": "CSS themes and styling";
    "images/": "Icons, logos, and graphics";
  };
  
  /**
   * Interactive features included in HTML export
   */
  features: {
    navigation: "Sidebar navigation with search";
    search: "Client-side search with Lunr.js";
    graphs: "Interactive dependency graphs";
    coverage: "Visual coverage reporting";
    themes: "Multiple visual themes";
    responsive: "Mobile-friendly responsive design";
  };
}

/**
 * JSON export configuration and structure
 */
interface JsonExportConfig {
  /**
   * Export format identifier
   */
  format: "json";
  
  /**
   * Generated JSON structure
   */
  structure: {
    /**
     * Main documentation data file
     */
    "documentation.json": JsonDocumentationStructure;
  };
}

/**
 * Structure of exported JSON documentation
 */
interface JsonDocumentationStructure {
  /**
   * Project metadata
   */
  project: {
    name: string;
    version: string;
    description: string;
    angularVersion: string;
    dependencies: any[];
    peerDependencies: any[];
  };
  
  /**
   * Documentation configuration
   */
  config: {
    theme: string;
    language: string;
    output: string;
    // ... other configuration options
  };
  
  /**
   * Angular modules data
   */
  modules: ModuleData[];
  
  /**
   * Angular components data
   */
  components: ComponentData[];
  
  /**
   * Angular directives data
   */
  directives: DirectiveData[];
  
  /**
   * Services and injectables data
   */
  injectables: InjectableData[];
  
  /**
   * Route guards data
   */
  guards: GuardData[];
  
  /**
   * Angular pipes data
   */
  pipes: PipeData[];
  
  /**
   * TypeScript classes data
   */
  classes: ClassData[];
  
  /**
   * TypeScript interfaces data
   */
  interfaces: InterfaceData[];
  
  /**
   * Application routes data
   */
  routes: RouteData[];
  
  /**
   * Miscellaneous items (functions, variables, etc.)
   */
  miscellaneous: {
    functions: FunctionData[];
    variables: VariableData[];
    typealiases: TypeAliasData[];
    enumerations: EnumData[];
  };
  
  /**
   * Coverage information
   */
  coverage?: CoverageData;
}

interface ModuleData {
  name: string;
  id: string;
  file: string;
  description?: string;
  declarations: any[];
  imports: any[];
  exports: any[];
  providers: any[];
  bootstrap: any[];
}

interface ComponentData {
  name: string;
  id: string;
  file: string;
  selector: string;
  templateUrl?: string;
  template?: string;
  styleUrls?: string[];
  styles?: string[];
  inputs: any[];
  outputs: any[];
  properties: any[];
  methods: any[];
  description?: string;
}

interface InjectableData {
  name: string;
  id: string;
  file: string;
  providedIn?: string;
  properties: any[];
  methods: any[];
  description?: string;
}

interface ClassData {
  name: string;
  id: string;
  file: string;
  properties: any[];
  methods: any[];
  constructor?: any;
  extends?: string;
  implements?: string[];
  description?: string;
}

interface InterfaceData {
  name: string;
  id: string;
  file: string;
  properties: any[];
  methods: any[];
  description?: string;
}

/**
 * JSON-specific export engine
 */
class ExportJsonEngine {
  /**
   * Export documentation data as JSON
   * @param outputFolder - Directory to write JSON files
   * @param data - Main configuration data
   * @returns Promise resolving when export is complete
   */
  static export(outputFolder: string, data: MainDataInterface): Promise<void>;
}

import { ExportJsonEngine } from "@compodoc/compodoc";

// Direct JSON export
await ExportJsonEngine.export("./json-output", Configuration.mainData);

// Access exported JSON data
const exportedData = await FileEngine.get("./json-output/documentation.json");
const documentation = JSON.parse(exportedData);

// Process specific data types
console.log(`Found ${documentation.components.length} components`);
console.log(`Found ${documentation.modules.length} modules`);

interface ExportConfiguration {
  /**
   * Output format selection
   */
  exportFormat: ExportFormat;
  
  /**
   * Supported export formats
   */
  exportFormatsSupported: ExportFormat[];
  
  /**
   * Output directory for exported files
   */
  output: string;
  
  /**
   * Additional export options
   */
  options?: {
    /**
     * Include source code in exports
     */
    includeSourceCode?: boolean;
    
    /**
     * Include coverage data
     */
    includeCoverage?: boolean;
    
    /**
     * Minify output files
     */
    minify?: boolean;
    
    /**
     * Pretty print JSON exports
     */
    prettyPrint?: boolean;
  };
}

// Configure export format
Configuration.mainData.exportFormat = "json";

// Export with custom options
const exporter = ExportEngine.getInstance();
const config = {
  ...Configuration.mainData,
  options: {
    prettyPrint: true,
    includeCoverage: true
  }
};

await exporter.export("./custom-output", config);