@holoscript/core 6.0.3 → 7.0.0

package/dist/chunk-KYM4XRFG.js

@@ -1,421 +0,0 @@
-import { HoloScriptRuntime } from './chunk-C2QHVHZF.js';
-import { HoloScriptCodeParser } from './chunk-EPWRXL6S.js';
-
-// 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 HoloScriptRuntime();
-    this.parser = new 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);
-}
-
-export { HoloScriptDebugger, createDebugger };
-//# sourceMappingURL=chunk-KYM4XRFG.js.map
-//# sourceMappingURL=chunk-KYM4XRFG.js.map