@holoscript/core 7.0.0 → 8.0.0

package/dist/chunk-KH4CNH66.cjs

@@ -0,0 +1,424 @@
+'use strict';
+
+var chunkEUDQTK7N_cjs = require('./chunk-EUDQTK7N.cjs');
+var chunkJIYN45TV_cjs = require('./chunk-JIYN45TV.cjs');
+
+// src/HoloScriptDebugger.ts
+var HoloScriptDebugger = class {
+  constructor(runtime) {
+    this.breakpoints = /* @__PURE__ */ new Map();
+    this.callStack = [];
+    this.currentAST = [];
+    this.currentNodeIndex = 0;
+    this.frameIdCounter = 0;
+    this.breakpointIdCounter = 0;
+    this.eventHandlers = /* @__PURE__ */ new Map();
+    this.state = {
+      status: "stopped",
+      currentLine: 0,
+      currentColumn: 0,
+      currentNode: null,
+      callStack: [],
+      breakpoints: []
+    };
+    this.runtime = runtime || new chunkEUDQTK7N_cjs.HoloScriptRuntime();
+    this.parser = new chunkJIYN45TV_cjs.HoloScriptCodeParser();
+  }
+  /**
+   * Load source code for debugging
+   */
+  loadSource(code, file) {
+    const parseResult = this.parser.parse(code);
+    if (!parseResult.success) {
+      return {
+        success: false,
+        errors: parseResult.errors.map((e) => `Line ${e.line}: ${e.message}`)
+      };
+    }
+    this.currentAST = parseResult.ast;
+    this.currentNodeIndex = 0;
+    this.state.status = "stopped";
+    this.callStack = [];
+    if (file) {
+      for (const node of this.currentAST) {
+        node.file = file;
+      }
+    }
+    return { success: true };
+  }
+  /**
+   * Set a breakpoint at a line
+   */
+  setBreakpoint(line, options = {}) {
+    const id = `bp_${++this.breakpointIdCounter}`;
+    const breakpoint = {
+      id,
+      line,
+      column: options.column,
+      condition: options.condition,
+      hitCount: 0,
+      enabled: options.enabled !== false,
+      file: options.file
+    };
+    this.breakpoints.set(id, breakpoint);
+    this.updateBreakpointList();
+    return breakpoint;
+  }
+  /**
+   * Remove a breakpoint by ID
+   */
+  removeBreakpoint(id) {
+    const removed = this.breakpoints.delete(id);
+    if (removed) {
+      this.updateBreakpointList();
+    }
+    return removed;
+  }
+  /**
+   * Remove all breakpoints at a line
+   */
+  removeBreakpointsAtLine(line) {
+    let removed = 0;
+    for (const [id, bp] of this.breakpoints) {
+      if (bp.line === line) {
+        this.breakpoints.delete(id);
+        removed++;
+      }
+    }
+    if (removed > 0) {
+      this.updateBreakpointList();
+    }
+    return removed;
+  }
+  /**
+   * Toggle breakpoint enabled state
+   */
+  toggleBreakpoint(id) {
+    const bp = this.breakpoints.get(id);
+    if (bp) {
+      bp.enabled = !bp.enabled;
+      this.updateBreakpointList();
+      return bp.enabled;
+    }
+    return false;
+  }
+  /**
+   * Get all breakpoints
+   */
+  getBreakpoints() {
+    return Array.from(this.breakpoints.values());
+  }
+  /**
+   * Clear all breakpoints
+   */
+  clearBreakpoints() {
+    this.breakpoints.clear();
+    this.updateBreakpointList();
+  }
+  /**
+   * Start debugging from the beginning
+   */
+  async start() {
+    this.currentNodeIndex = 0;
+    this.callStack = [];
+    this.frameIdCounter = 0;
+    this.runtime.reset();
+    this.state.status = "running";
+    await this.runUntilBreakpoint();
+  }
+  /**
+   * Continue execution until next breakpoint or end
+   */
+  async continue() {
+    if (this.state.status !== "paused") return;
+    this.state.status = "running";
+    this.currentNodeIndex++;
+    await this.runUntilBreakpoint();
+  }
+  /**
+   * Step into the next node
+   */
+  async stepInto() {
+    if (this.state.status !== "paused") return;
+    this.state.status = "stepping";
+    await this.executeStep("into");
+  }
+  /**
+   * Step over the current node
+   */
+  async stepOver() {
+    if (this.state.status !== "paused") return;
+    this.state.status = "stepping";
+    await this.executeStep("over");
+  }
+  /**
+   * Step out of the current function
+   */
+  async stepOut() {
+    if (this.state.status !== "paused") return;
+    this.state.status = "stepping";
+    await this.executeStep("out");
+  }
+  /**
+   * Stop debugging
+   */
+  stop() {
+    this.state.status = "stopped";
+    this.callStack = [];
+    this.currentNodeIndex = 0;
+    this.emitEvent({ type: "state-change", data: { status: "stopped" } });
+  }
+  /**
+   * Pause execution
+   */
+  pause() {
+    if (this.state.status === "running") {
+      this.state.status = "paused";
+      this.emitEvent({ type: "state-change", data: { status: "paused" } });
+    }
+  }
+  /**
+   * Get current debug state
+   */
+  getState() {
+    return { ...this.state };
+  }
+  /**
+   * Get call stack
+   */
+  getCallStack() {
+    return [...this.callStack];
+  }
+  /**
+   * Get variables at a specific stack frame
+   */
+  getVariables(frameId) {
+    if (frameId !== void 0) {
+      const frame = this.callStack.find((f) => f.id === frameId);
+      return frame?.variables || /* @__PURE__ */ new Map();
+    }
+    return new Map(this.runtime.getContext().variables);
+  }
+  /**
+   * Evaluate an expression in the current context
+   */
+  async evaluate(expression) {
+    try {
+      const varValue = this.runtime.getVariable(expression);
+      if (varValue !== void 0) {
+        return { value: varValue };
+      }
+      const parseResult = this.parser.parse(expression);
+      if (!parseResult.success) {
+        return { value: void 0, error: parseResult.errors[0]?.message };
+      }
+      const results = await this.runtime.executeProgram(parseResult.ast);
+      const lastResult = results[results.length - 1];
+      return { value: lastResult?.output };
+    } catch (error) {
+      return { value: void 0, error: String(error) };
+    }
+  }
+  /**
+   * Set a watch expression
+   */
+  watch(expression) {
+    const id = `watch_${Date.now()}`;
+    return { id, expression };
+  }
+  /**
+   * Register an event handler
+   */
+  on(event, handler) {
+    if (!this.eventHandlers.has(event)) {
+      this.eventHandlers.set(event, []);
+    }
+    this.eventHandlers.get(event).push(handler);
+  }
+  /**
+   * Remove an event handler
+   */
+  off(event, handler) {
+    const handlers = this.eventHandlers.get(event);
+    if (handlers) {
+      const index = handlers.indexOf(handler);
+      if (index !== -1) {
+        handlers.splice(index, 1);
+      }
+    }
+  }
+  /**
+   * Get the underlying runtime
+   */
+  getRuntime() {
+    return this.runtime;
+  }
+  // Private methods
+  async runUntilBreakpoint() {
+    while (this.currentNodeIndex < this.currentAST.length) {
+      if (this.state.status === "stopped") break;
+      const node = this.currentAST[this.currentNodeIndex];
+      if (this.shouldBreakAt(node)) {
+        this.state.status = "paused";
+        this.updateCurrentState(node);
+        const bp = this.findBreakpointAtLine(node.line ?? 0);
+        if (bp) {
+          bp.hitCount++;
+          this.emitEvent({
+            type: "breakpoint-hit",
+            data: { breakpoint: bp, node, line: node.line ?? 0 }
+          });
+        }
+        return;
+      }
+      await this.executeNode(node);
+      this.currentNodeIndex++;
+    }
+    this.state.status = "stopped";
+    this.emitEvent({ type: "state-change", data: { status: "stopped", reason: "complete" } });
+  }
+  async executeStep(mode) {
+    const startStackDepth = this.callStack.length;
+    if (this.currentNodeIndex >= this.currentAST.length) {
+      this.state.status = "stopped";
+      return;
+    }
+    const node = this.currentAST[this.currentNodeIndex];
+    switch (mode) {
+      case "into":
+        await this.executeNode(node);
+        this.currentNodeIndex++;
+        break;
+      case "over":
+        await this.executeNode(node);
+        this.currentNodeIndex++;
+        break;
+      case "out":
+        while (this.currentNodeIndex < this.currentAST.length) {
+          await this.executeNode(this.currentAST[this.currentNodeIndex]);
+          this.currentNodeIndex++;
+          if (this.callStack.length < startStackDepth) {
+            break;
+          }
+        }
+        break;
+    }
+    if (this.currentNodeIndex < this.currentAST.length) {
+      this.state.status = "paused";
+      this.updateCurrentState(this.currentAST[this.currentNodeIndex]);
+      this.emitEvent({
+        type: "step-complete",
+        data: { mode, node: this.currentAST[this.currentNodeIndex] }
+      });
+    } else {
+      this.state.status = "stopped";
+      this.emitEvent({ type: "state-change", data: { status: "stopped", reason: "complete" } });
+    }
+  }
+  async executeNode(node) {
+    if (node.type === "function") {
+      const funcNode = node;
+      this.pushStackFrame(funcNode.name, node);
+    }
+    try {
+      const result = await this.runtime.executeNode(node);
+      if (!result.success && result.error) {
+        this.emitEvent({
+          type: "exception",
+          data: { error: result.error, node, line: node.line }
+        });
+      }
+      if (result.output !== void 0) {
+        this.emitEvent({
+          type: "output",
+          data: { output: result.output, node }
+        });
+      }
+    } catch (error) {
+      this.emitEvent({
+        type: "exception",
+        data: { error: String(error), node, line: node.line }
+      });
+    }
+    if (node.type === "function") {
+      this.popStackFrame();
+    }
+  }
+  shouldBreakAt(node) {
+    const line = node.line;
+    for (const bp of this.breakpoints.values()) {
+      if (!bp.enabled) continue;
+      if (bp.line !== line) continue;
+      if (bp.condition) {
+        try {
+          const value = this.runtime.getVariable(bp.condition);
+          if (!value) continue;
+        } catch {
+          continue;
+        }
+      }
+      return true;
+    }
+    return false;
+  }
+  findBreakpointAtLine(line) {
+    for (const bp of this.breakpoints.values()) {
+      if (bp.line === line && bp.enabled) {
+        return bp;
+      }
+    }
+    return null;
+  }
+  pushStackFrame(name, node) {
+    const frame = {
+      id: ++this.frameIdCounter,
+      name,
+      file: node.file,
+      line: node.line ?? 0,
+      column: node.column ?? 0,
+      variables: new Map(this.runtime.getContext().variables),
+      node
+    };
+    this.callStack.push(frame);
+    this.state.callStack = [...this.callStack];
+  }
+  popStackFrame() {
+    const frame = this.callStack.pop();
+    this.state.callStack = [...this.callStack];
+    return frame;
+  }
+  updateCurrentState(node) {
+    this.state.currentLine = node.line ?? 0;
+    this.state.currentColumn = node.column ?? 0;
+    this.state.currentNode = node;
+  }
+  updateBreakpointList() {
+    this.state.breakpoints = Array.from(this.breakpoints.values());
+  }
+  emitEvent(event) {
+    const handlers = this.eventHandlers.get(event.type) || [];
+    for (const handler of handlers) {
+      try {
+        handler(event);
+      } catch (error) {
+        console.error("Debug event handler error:", error);
+      }
+    }
+    const allHandlers = this.eventHandlers.get("all") || [];
+    for (const handler of allHandlers) {
+      try {
+        handler(event);
+      } catch (error) {
+        console.error("Debug event handler error:", error);
+      }
+    }
+  }
+};
+function createDebugger(runtime) {
+  return new HoloScriptDebugger(runtime);
+}
+
+exports.HoloScriptDebugger = HoloScriptDebugger;
+exports.createDebugger = createDebugger;
+//# sourceMappingURL=chunk-KH4CNH66.cjs.map
+//# sourceMappingURL=chunk-KH4CNH66.cjs.map