@ordojs/core/src/compiler/index.ts

Core compiler and runtime for OrdoJS framework

/**
 * @fileoverview OrdoJS Compiler - Main compiler exports
 */

// Export compiler components
export { OrdoJSCodeGenerator } from './code-generator-fixed.js';
export { CodeSplitter } from './code-splitter.js';
export { OrdoJSCSSInJSCompiler } from './css-in-js-compiler.js';
export { OrdoJSCSSOptimizer } from './css-optimizer.js';
export { DeadCodeEliminator } from './dead-code-eliminator.js';
export { DependencyAnalyzer } from './dependency-analyzer.js';
export { DOMOptimizer } from './dom-optimizer.js';
export { FileSystemRouter } from './fs-router.js';
export { OrdoJSLexer } from './lexer.js';
export { OrdoJSParser } from './parser.js';
export { RPCGenerator } from './rpc-generator.js';
export { OrdoJSSSR } from './ssr-engine.js';

// Import required classes for internal use
import { OrdoJSCodeGenerator } from './code-generator-fixed.js';
import { DeadCodeEliminator } from './dead-code-eliminator.js';
import { OrdoJSLexer } from './lexer.js';
import { OrdoJSParser } from './parser.js';

// Export dependency analyzer types
export { DependencyType, UpdateType } from './dependency-analyzer.js';
export type {
  Dependency, DependencyGraph, DependencyNode, UpdateFunction
} from './dependency-analyzer.js';

// Export DOM optimizer types
export { DOMUpdateType } from './dom-optimizer.js';
export type {
  DOMUpdateOperation, TwoWayBinding, UpdateBatch
} from './dom-optimizer.js';

// Export dead code eliminator types
export type { DeadCodeEliminationResult, DeadCodeEliminatorOptions, UsageAnalysis } from './dead-code-eliminator.js';

// Export code splitter types
export type {
  ChunkInfo, CodeSplittingConfig, CodeSplittingResult
} from './code-splitter.js';

// Export RPC generator types
export type { RPCCallMetadata, RPCGeneratorOptions, RPCStub } from './rpc-generator.js';

// Export SSR engine types
export type { RouteConfig, SSROptions } from './ssr-engine.js';

// Export FileSystemRouter types
export type { Route, RouterOptions } from './fs-router.js';

// Export CSS optimizer types
export type {
  CSSOptimizationOptions, CSSOptimizationResult, CSSUsageAnalysis
} from './css-optimizer.js';

// Export CSS-in-JS compiler types
export type { CSSFunctionExpression, CSSInJSCompilationResult, CSSInJSExpression, CSSInJSOptions, CSSObjectExpression, CSSTemplateExpression } from './css-in-js-compiler.js';

// Compiler options
export interface CompilerOptions {
  target: 'es2022' | 'es2020' | 'es2018';
  optimize: boolean;
  sourceMaps: boolean;
  minify: boolean;
}

export interface BasicCompilationResult {
  success: boolean;
  output?: string;
  errors: string[];
  warnings: string[];
}

/**
 * Main compiler interface
 */
export class OrdoJSCompiler {
  constructor(private options: CompilerOptions) { }

  compile(source: string): BasicCompilationResult {
    try {
      // Create lexer and tokenize the source
      const lexer = new OrdoJSLexer();
      const tokens = lexer.tokenize();

      // Parse tokens into AST
      const parser = new OrdoJSParser(tokens);
      const ast = parser.parse();

      // Apply optimizations if enabled
      let optimizedAst = ast;
      if (this.options.optimize) {
        // Apply dead code elimination and tree shaking
        const deadCodeEliminator = new DeadCodeEliminator({
          aggressiveTreeShaking: true,
          inlineSmallFunctions: true,
          maxInlineSize: 5,
          removeUnusedVariables: true,
          removeUnreachableCode: true
        });

        optimizedAst = deadCodeEliminator.optimize(ast);
      }

      // Generate code from optimized AST
      const generator = new OrdoJSCodeGenerator({
        minify: this.options.minify,
        sourceMaps: this.options.sourceMaps,
        target: this.options.minify ? 'production' : 'development'
      });

      const result = generator.generate(optimizedAst);

      return {
        success: true,
        output: result.client,
        errors: [],
        warnings: []
      };
    } catch (error) {
      return {
        success: false,
        errors: [error instanceof Error ? error.message : String(error)],
        warnings: []
      };
    }
  }
}

// Import required types