@ordojs/dev-tools/dist/inspector/index.mjs

Advanced developer tools for OrdoJS with component inspector, AST explorer, and performance profiling

import { EventEmitter } from 'events';

// src/inspector/index.ts
var ComponentInspector = class extends EventEmitter {
  components;
  isRunning;
  port;
  /**
   * Create a new ComponentInspector instance
   *
   * @param port - WebSocket port for inspector
   */
  constructor(port = 24679) {
    super();
    this.components = /* @__PURE__ */ new Map();
    this.isRunning = false;
    this.port = port;
  }
  /**
   * Start the component inspector
   */
  async start() {
    if (this.isRunning) {
      console.warn("Component inspector is already running");
      return;
    }
    try {
      await this.startWebSocketServer();
      this.isRunning = true;
      console.log(`Component inspector started on port ${this.port}`);
      this.emit("started");
    } catch (error) {
      console.error("Failed to start component inspector:", error);
      this.emit("error", error);
      throw error;
    }
  }
  /**
   * Stop the component inspector
   */
  async stop() {
    if (!this.isRunning) {
      console.warn("Component inspector is not running");
      return;
    }
    try {
      await this.stopWebSocketServer();
      this.isRunning = false;
      console.log("Component inspector stopped");
      this.emit("stopped");
    } catch (error) {
      console.error("Failed to stop component inspector:", error);
      this.emit("error", error);
      throw error;
    }
  }
  /**
   * Register a component for inspection
   *
   * @param componentInfo - Component information
   */
  registerComponent(componentInfo) {
    this.components.set(componentInfo.name, componentInfo);
    this.emit("componentRegistered", componentInfo);
  }
  /**
   * Update component information
   *
   * @param componentName - Component name
   * @param updates - Component updates
   */
  updateComponent(componentName, updates) {
    const component = this.components.get(componentName);
    if (component) {
      const updatedComponent = { ...component, ...updates };
      this.components.set(componentName, updatedComponent);
      this.emit("componentUpdated", updatedComponent);
    }
  }
  /**
   * Get component information
   *
   * @param componentName - Component name
   * @returns Component information or undefined
   */
  getComponent(componentName) {
    return this.components.get(componentName);
  }
  /**
   * Get all components
   *
   * @returns Array of all component information
   */
  getAllComponents() {
    return Array.from(this.components.values());
  }
  /**
   * Get component tree
   *
   * @returns Component tree structure
   */
  getComponentTree() {
    const rootComponents = [];
    const componentMap = new Map(this.components);
    for (const component of componentMap.values()) {
      if (!this.hasParent(component, componentMap)) {
        rootComponents.push(component);
      }
    }
    return rootComponents;
  }
  /**
   * Clear all components
   */
  clearComponents() {
    this.components.clear();
    this.emit("componentsCleared");
  }
  /**
   * Get inspector statistics
   *
   * @returns Inspector statistics
   */
  getStats() {
    const components = Array.from(this.components.values());
    const totalRenderCount = components.reduce((sum, comp) => sum + comp.renderCount, 0);
    const averageRenderTime = components.reduce((sum, comp) => sum + comp.performance.averageRenderTime, 0) / components.length || 0;
    const peakMemoryUsage = Math.max(...components.map((comp) => comp.performance.peakMemoryUsage), 0);
    return {
      totalComponents: components.length,
      totalRenderCount,
      averageRenderTime,
      peakMemoryUsage
    };
  }
  /**
   * Start WebSocket server for inspector communication
   */
  async startWebSocketServer() {
    console.log("Starting WebSocket server for component inspector...");
  }
  /**
   * Stop WebSocket server
   */
  async stopWebSocketServer() {
    console.log("Stopping WebSocket server for component inspector...");
  }
  /**
   * Check if component has a parent
   *
   * @param component - Component to check
   * @param componentMap - Map of all components
   * @returns True if component has a parent
   */
  hasParent(component, componentMap) {
    for (const otherComponent of componentMap.values()) {
      if (otherComponent.children.some((child) => child.name === component.name)) {
        return true;
      }
    }
    return false;
  }
};

export { ComponentInspector };
//# sourceMappingURL=index.mjs.map
//# sourceMappingURL=index.mjs.map