@danielsimonjr/mathts-workbook 0.1.8 → 0.3.0

package/dist/chunk-L7UWFWMV.js

@@ -1,269 +0,0 @@
-// src/parser.ts
-function parseWorkbook(content) {
-  try {
-    const errors = [];
-    const warnings = [];
-    if (!content.trim()) {
-      return {
-        success: false,
-        errors: ["Empty workbook content"]
-      };
-    }
-    const workbook = {
-      version: "1.0",
-      metadata: {
-        title: "Untitled Workbook"
-      },
-      runtime: {
-        engine: "mathts",
-        execution: "reactive"
-      },
-      cells: []
-    };
-    if (warnings.length > 0 || errors.length > 0) {
-      return {
-        success: errors.length === 0,
-        workbook: errors.length === 0 ? workbook : void 0,
-        errors: errors.length > 0 ? errors : void 0,
-        warnings: warnings.length > 0 ? warnings : void 0
-      };
-    }
-    return {
-      success: true,
-      workbook
-    };
-  } catch (error) {
-    return {
-      success: false,
-      errors: [`Parse error: ${error instanceof Error ? error.message : String(error)}`]
-    };
-  }
-}
-function serializeWorkbook(_workbook) {
-  throw new Error("serializeWorkbook not yet implemented");
-}
-function stripOutputs(workbook) {
-  return {
-    ...workbook,
-    cells: workbook.cells.map((cell) => ({
-      ...cell,
-      output: void 0,
-      error: void 0
-    }))
-  };
-}
-
-// src/graph.ts
-function buildDependencyGraph(cells) {
-  const nodes = /* @__PURE__ */ new Map();
-  for (const cell of cells) {
-    nodes.set(cell.id, {
-      id: cell.id,
-      dependencies: cell.dependsOn ?? [],
-      dependents: []
-    });
-  }
-  for (const cell of cells) {
-    for (const depId of cell.dependsOn ?? []) {
-      const depNode = nodes.get(depId);
-      if (depNode) {
-        depNode.dependents.push(cell.id);
-      }
-    }
-  }
-  const executionOrder = topologicalSort(nodes);
-  return { nodes, executionOrder };
-}
-function topologicalSort(nodes) {
-  const visited = /* @__PURE__ */ new Set();
-  const result = [];
-  function visit(id) {
-    if (visited.has(id)) return;
-    visited.add(id);
-    const node = nodes.get(id);
-    if (node) {
-      for (const depId of node.dependencies) {
-        visit(depId);
-      }
-    }
-    result.push(id);
-  }
-  for (const id of nodes.keys()) {
-    visit(id);
-  }
-  return result;
-}
-function getDependents(graph, cellId) {
-  const result = [];
-  const visited = /* @__PURE__ */ new Set();
-  function collect(id) {
-    const node = graph.nodes.get(id);
-    if (!node) return;
-    for (const depId of node.dependents) {
-      if (!visited.has(depId)) {
-        visited.add(depId);
-        result.push(depId);
-        collect(depId);
-      }
-    }
-  }
-  collect(cellId);
-  return result;
-}
-
-// src/executor.ts
-import { evaluate } from "@danielsimonjr/mathts-functions";
-import { parse as parseYaml } from "yaml";
-var WorkbookExecutor = class {
-  workbook;
-  graph;
-  outputs = /* @__PURE__ */ new Map();
-  handlers = [];
-  constructor(workbook) {
-    this.workbook = workbook;
-    this.graph = buildDependencyGraph(workbook.cells);
-  }
-  /**
-   * Subscribe to execution events
-   */
-  on(handler) {
-    this.handlers.push(handler);
-    return () => {
-      const index = this.handlers.indexOf(handler);
-      if (index >= 0) {
-        this.handlers.splice(index, 1);
-      }
-    };
-  }
-  /**
-   * Emit an event to all handlers
-   */
-  emit(event) {
-    for (const handler of this.handlers) {
-      handler(event);
-    }
-  }
-  /**
-   * Run all cells in order
-   */
-  async runAll() {
-    for (const cellId of this.graph.executionOrder) {
-      await this.runCell(cellId);
-    }
-    this.emit({
-      type: "workbook:complete",
-      timestamp: Date.now()
-    });
-  }
-  /**
-   * Run a specific cell
-   */
-  async runCell(cellId) {
-    const cell = this.workbook.cells.find((c) => c.id === cellId);
-    if (!cell) {
-      throw new Error(`Cell not found: ${cellId}`);
-    }
-    this.emit({
-      type: "cell:start",
-      cellId,
-      timestamp: Date.now()
-    });
-    try {
-      const output = await this.executeCell(cell);
-      this.outputs.set(cellId, output);
-      this.emit({
-        type: "cell:success",
-        cellId,
-        output,
-        timestamp: Date.now()
-      });
-      if (this.workbook.runtime.execution === "reactive") {
-        const dependents = getDependents(this.graph, cellId);
-        for (const depId of dependents) {
-          this.emit({
-            type: "cell:stale",
-            cellId: depId,
-            timestamp: Date.now()
-          });
-        }
-      }
-      return output;
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      this.emit({
-        type: "cell:error",
-        cellId,
-        error: errorMessage,
-        timestamp: Date.now()
-      });
-      throw error;
-    }
-  }
-  /**
-   * Execute a single cell
-   */
-  async executeCell(cell) {
-    switch (cell.type) {
-      case "code":
-        return this.executeCode(cell);
-      case "markdown":
-        return cell.content;
-      // Markdown is pass-through
-      case "data":
-        return this.executeData(cell);
-      default:
-        throw new Error(`Unsupported cell type: ${cell.type}`);
-    }
-  }
-  /**
-   * Execute a code cell by evaluating its content as a MathTS expression.
-   *
-   * Dependency outputs are injected as named variables in the evaluation
-   * scope, so a cell can reference the result of an earlier cell by its id.
-   * Evaluation goes through the MathTS expression engine — property and
-   * method access route through the expression sandbox, so this does not
-   * have the arbitrary-code-execution exposure of the `Function` constructor.
-   */
-  async executeCode(cell) {
-    const scope = {};
-    if (cell.dependsOn) {
-      for (const depId of cell.dependsOn) {
-        const output = this.outputs.get(depId);
-        if (output !== void 0) {
-          scope[depId] = output;
-        }
-      }
-    }
-    return evaluate(cell.content, scope);
-  }
-  /**
-   * Execute a data cell — parse its content as YAML (a superset of JSON).
-   */
-  async executeData(cell) {
-    return parseYaml(cell.content);
-  }
-  /**
-   * Get output from a previous cell
-   */
-  getOutput(cellId) {
-    return this.outputs.get(cellId);
-  }
-};
-function createExecutor(workbook) {
-  return new WorkbookExecutor(workbook);
-}
-
-// src/index.ts
-var VERSION = "0.1.0";
-
-export {
-  parseWorkbook,
-  serializeWorkbook,
-  stripOutputs,
-  buildDependencyGraph,
-  topologicalSort,
-  getDependents,
-  WorkbookExecutor,
-  createExecutor,
-  VERSION
-};