@tscircuit/ngspice-spice-engine 0.0.16 → 0.0.18

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { ResultType } from '@tscircuit/eecircuit-engine';
 import { SpiceEngine } from '@tscircuit/props';
+import { SimulationTransientVoltageGraph, SimulationTransientCurrentGraph } from 'circuit-json';
 
 interface TranParams {
     tstep?: number;
@@ -12,20 +12,71 @@ declare const parseTranParams: (spiceString: string) => TranParams | null;
 
 declare const rewritePspiceCompatibilitySyntax: (spiceString: string) => string;
 
-interface VoltageGraph {
-    netName: string;
-    time: number[];
-    voltage: number[];
-    probeMetadata?: ProbeMetadata;
-}
-interface ProbeMetadata {
+type ComplexNumber = {
+    real: number;
+    img: number;
+};
+type RealDataType = {
+    name: string;
+    type: "voltage" | "current" | "time" | "frequency" | "notype";
+    values: number[];
+};
+type ComplexDataType = {
+    name: string;
+    type: RealDataType["type"];
+    values: ComplexNumber[];
+};
+type ResultType = {
+    header: string;
+    numVariables: number;
+    variableNames: string[];
+    numPoints: number;
+    dataType: "real";
+    data: RealDataType[];
+} | {
+    header: string;
+    numVariables: number;
+    variableNames: string[];
+    numPoints: number;
+    dataType: "complex";
+    data: ComplexDataType[];
+};
+
+interface VoltageProbeMetadata {
     simulation_voltage_probe_id: string;
     name?: string;
     spice_vector: string;
     source_node_name: string;
     reference_node_name?: string;
 }
+interface CurrentProbeMetadata {
+    simulation_current_probe_id: string;
+    name?: string;
+    spice_vector: string;
+    source_component_id?: string;
+    source_trace_id?: string;
+}
+interface VoltageGraph {
+    graphType: "voltage";
+    netName: string;
+    time: number[];
+    voltage: number[];
+    probeMetadata?: VoltageProbeMetadata;
+}
+interface CurrentGraph {
+    graphType: "current";
+    currentName: string;
+    time: number[];
+    current: number[];
+    probeMetadata?: CurrentProbeMetadata;
+}
+type SimulationGraph = VoltageGraph | CurrentGraph;
+
+declare const eecircuitResultToSimulationGraphs: (result: ResultType, spiceString: string) => SimulationGraph[];
 declare const eecircuitResultToVGraphs: (result: ResultType, spiceString: string) => VoltageGraph[];
+
+declare const simulationGraphsToCircuitJson: (graphs: SimulationGraph[], spiceString: string) => Array<SimulationTransientVoltageGraph | SimulationTransientCurrentGraph>;
+
 declare const createNgspiceSpiceEngine: () => Promise<SpiceEngine>;
 
-export { type TranParams, createNgspiceSpiceEngine, createNgspiceSpiceEngine as default, eecircuitResultToVGraphs, parseTranParams, rewritePspiceCompatibilitySyntax };
+export { type TranParams, createNgspiceSpiceEngine, createNgspiceSpiceEngine as default, eecircuitResultToSimulationGraphs, eecircuitResultToVGraphs, parseTranParams, rewritePspiceCompatibilitySyntax, simulationGraphsToCircuitJson };

package/dist/index.js

@@ -1,26 +1,22 @@
-// lib/linear-interpolate.ts
-var linearInterpolate = (targetX, xPoints, yPoints) => {
-  if (xPoints.length === 0) {
-    return 0;
-  }
-  if (targetX <= xPoints[0]) {
-    return yPoints[0];
-  }
-  if (targetX >= xPoints[xPoints.length - 1]) {
-    return yPoints[yPoints.length - 1];
-  }
-  let i = 1;
-  while (i < xPoints.length && xPoints[i] < targetX) {
-    i++;
-  }
-  const x1 = xPoints[i - 1];
-  const y1 = yPoints[i - 1];
-  const x2 = xPoints[i];
-  const y2 = yPoints[i];
-  if (x2 === x1) {
-    return y1;
+// lib/import-eecircuit-engine.ts
+var EECIRCUIT_ENGINE_URL = "https://jscdn.tscircuit.com/@tscircuit/eecircuit-engine/1.7.4/+esm";
+var modulePromise = null;
+var importEecircuitEngine = async () => {
+  if (!modulePromise) {
+    modulePromise = fetch(EECIRCUIT_ENGINE_URL).then(async (response) => {
+      if (!response.ok) {
+        throw new Error(
+          `Failed to load @tscircuit/eecircuit-engine from ${EECIRCUIT_ENGINE_URL}: ${response.status} ${response.statusText}`
+        );
+      }
+      const source = await response.text();
+      const moduleUrl = URL.createObjectURL(
+        new Blob([source], { type: "text/javascript" })
+      );
+      return import(moduleUrl);
+    });
   }
-  return y1 + (y2 - y1) * (targetX - x1) / (x2 - x1);
+  return modulePromise;
 };
 
 // lib/parse-tran-params.ts
@@ -173,43 +169,84 @@ var rewritePspiceValueBooleanCarets = (spiceString) => {
 };
 var rewritePspiceCompatibilitySyntax = (spiceString) => rewritePspiceValueBooleanCarets(rewritePspiceResistorTcPairs(spiceString));
 
-// lib/index.ts
-var ensureSimulation = async () => {
-  const { Simulation: SimulationCtor } = await import("@tscircuit/eecircuit-engine");
-  const instance = new SimulationCtor({ ngBehavior: "psa" });
-  await instance.start();
-  return instance;
-};
-var simulationPromise = null;
-var getSimulation = async () => {
-  if (!simulationPromise) {
-    simulationPromise = ensureSimulation().catch((error) => {
-      simulationPromise = null;
-      throw error;
-    });
+// lib/create-graph-from-requested-plot.ts
+var getNetName = (rawName) => {
+  const diffMatch = rawName.match(/^v\(([^,]+),\s*([^)]+)\)$/i);
+  if (diffMatch?.[1] && diffMatch?.[2]) {
+    return `${diffMatch[1].trim()}-${diffMatch[2].trim()}`;
   }
-  return simulationPromise;
-};
-var extractRequestedPlots = (spiceString) => {
-  const match = spiceString.match(/\.print\s+tran\s+(.*)/i);
-  if (!match?.[1]) {
-    return null;
+  const match = rawName.match(/^v\((.*)\)$/i);
+  if (!match) {
+    return rawName;
   }
-  const tokens = match[1].match(/[VI]\s*\([^)]+\)/gi);
-  if (!tokens) {
-    return null;
+  return match[1] ?? rawName;
+};
+var getCurrentName = (rawName) => {
+  const match = rawName.match(/^i\((.*)\)$/i);
+  if (!match) {
+    return rawName;
   }
-  const plotMap = /* @__PURE__ */ new Map();
-  for (const token of tokens) {
-    const lowerCaseToken = token.toLowerCase().replace(/\s/g, "");
-    if (!plotMap.has(lowerCaseToken)) {
-      plotMap.set(lowerCaseToken, token);
+  return match[1] ?? rawName;
+};
+var createVoltageGraphFromRequestedPlot = ({
+  lowerCaseToken,
+  originalToken,
+  timeValues,
+  voltageDataMap,
+  voltageProbeMetadata
+}) => {
+  if (!lowerCaseToken.startsWith("v(")) return null;
+  const diffMatch = originalToken.match(/^v\(([^,]+),\s*([^)]+)\)$/i);
+  let voltage;
+  if (diffMatch?.[1] && diffMatch?.[2]) {
+    voltage = voltageDataMap.get(lowerCaseToken);
+    if (!voltage) {
+      const node1 = diffMatch[1].trim();
+      const node2 = diffMatch[2].trim();
+      const node1Data = voltageDataMap.get(`v(${node1.toLowerCase()})`);
+      const node2Data = voltageDataMap.get(`v(${node2.toLowerCase()})`);
+      if (node1Data && node2Data) {
+        voltage = node1Data.map((v, i) => v - (node2Data[i] ?? 0));
+      }
     }
+  } else {
+    voltage = voltageDataMap.get(lowerCaseToken);
   }
-  return plotMap;
+  if (!voltage) return null;
+  const metadata = voltageProbeMetadata.get(lowerCaseToken);
+  const voltageGraph = {
+    graphType: "voltage",
+    netName: metadata?.name ?? getNetName(originalToken),
+    time: timeValues,
+    voltage,
+    probeMetadata: metadata
+  };
+  return voltageGraph;
 };
+var createCurrentGraphFromRequestedPlot = ({
+  lowerCaseToken,
+  originalToken,
+  timeValues,
+  currentDataMap,
+  currentProbeMetadata
+}) => {
+  if (!lowerCaseToken.startsWith("i(")) return null;
+  const current = currentDataMap.get(lowerCaseToken);
+  if (!current) return null;
+  const metadata = currentProbeMetadata.get(lowerCaseToken);
+  const currentGraph = {
+    graphType: "current",
+    currentName: metadata?.name ?? getCurrentName(originalToken),
+    time: timeValues,
+    current,
+    probeMetadata: metadata
+  };
+  return currentGraph;
+};
+
+// lib/extract-probe-metadata.ts
 var normalizeSpiceVector = (value) => value.toLowerCase().replace(/\s/g, "");
-var extractProbeMetadata = (spiceString) => {
+var extractVoltageProbeMetadata = (spiceString) => {
   const metadata = /* @__PURE__ */ new Map();
   for (const line of spiceString.split(/\r?\n/)) {
     const match = line.match(/^\s*\*\s*tscircuit_probe\s+(.+)\s*$/);
@@ -219,30 +256,92 @@ var extractProbeMetadata = (spiceString) => {
       if (typeof parsed.simulation_voltage_probe_id !== "string" || typeof parsed.spice_vector !== "string" || typeof parsed.source_node_name !== "string") {
         continue;
       }
-      metadata.set(normalizeSpiceVector(parsed.spice_vector), {
+      const normalizedSpiceVector = normalizeSpiceVector(parsed.spice_vector);
+      const voltageProbeMetadata = {
         simulation_voltage_probe_id: parsed.simulation_voltage_probe_id,
         name: typeof parsed.name === "string" ? parsed.name : void 0,
         spice_vector: parsed.spice_vector,
         source_node_name: parsed.source_node_name,
         reference_node_name: typeof parsed.reference_node_name === "string" ? parsed.reference_node_name : void 0
-      });
+      };
+      metadata.set(normalizedSpiceVector, voltageProbeMetadata);
     } catch {
     }
   }
   return metadata;
 };
-var getNetName = (rawName) => {
-  const diffMatch = rawName.match(/^v\(([^,]+),\s*([^)]+)\)$/i);
-  if (diffMatch?.[1] && diffMatch?.[2]) {
-    return `${diffMatch[1].trim()}-${diffMatch[2].trim()}`;
+var extractCurrentProbeMetadata = (spiceString) => {
+  const metadata = /* @__PURE__ */ new Map();
+  for (const line of spiceString.split(/\r?\n/)) {
+    const match = line.match(/^\s*\*\s*tscircuit_current_probe\s+(.+)\s*$/);
+    if (!match?.[1]) continue;
+    try {
+      const parsed = JSON.parse(match[1]);
+      if (typeof parsed.simulation_current_probe_id !== "string" || typeof parsed.spice_vector !== "string") {
+        continue;
+      }
+      const normalizedSpiceVector = normalizeSpiceVector(parsed.spice_vector);
+      const currentProbeMetadata = {
+        simulation_current_probe_id: parsed.simulation_current_probe_id,
+        name: typeof parsed.name === "string" ? parsed.name : void 0,
+        spice_vector: parsed.spice_vector,
+        source_component_id: typeof parsed.source_component_id === "string" ? parsed.source_component_id : void 0,
+        source_trace_id: typeof parsed.source_trace_id === "string" ? parsed.source_trace_id : void 0
+      };
+      metadata.set(normalizedSpiceVector, currentProbeMetadata);
+    } catch {
+    }
   }
-  const match = rawName.match(/^v\((.*)\)$/i);
-  if (!match) {
-    return rawName;
+  return metadata;
+};
+
+// lib/extract-requested-plots.ts
+var extractRequestedPlots = (spiceString) => {
+  const match = spiceString.match(/\.print\s+tran\s+(.*)/i);
+  if (!match?.[1]) {
+    return null;
   }
-  return match[1] ?? rawName;
+  const tokens = match[1].match(/[VI]\s*\([^)]+\)/gi);
+  if (!tokens) {
+    return null;
+  }
+  const plotMap = /* @__PURE__ */ new Map();
+  for (const token of tokens) {
+    const lowerCaseToken = token.toLowerCase().replace(/\s/g, "");
+    if (!plotMap.has(lowerCaseToken)) {
+      plotMap.set(lowerCaseToken, token);
+    }
+  }
+  return plotMap;
 };
-var eecircuitResultToVGraphs = (result, spiceString) => {
+
+// lib/linear-interpolate.ts
+var linearInterpolate = (targetX, xPoints, yPoints) => {
+  if (xPoints.length === 0) {
+    return 0;
+  }
+  if (targetX <= xPoints[0]) {
+    return yPoints[0];
+  }
+  if (targetX >= xPoints[xPoints.length - 1]) {
+    return yPoints[yPoints.length - 1];
+  }
+  let i = 1;
+  while (i < xPoints.length && xPoints[i] < targetX) {
+    i++;
+  }
+  const x1 = xPoints[i - 1];
+  const y1 = yPoints[i - 1];
+  const x2 = xPoints[i];
+  const y2 = yPoints[i];
+  if (x2 === x1) {
+    return y1;
+  }
+  return y1 + (y2 - y1) * (targetX - x1) / (x2 - x1);
+};
+
+// lib/eecircuit-result-to-simulation-graphs.ts
+var eecircuitResultToSimulationGraphs = (result, spiceString) => {
   if (!result?.data || result.dataType !== "real") {
     return [];
   }
@@ -258,46 +357,62 @@ var eecircuitResultToVGraphs = (result, spiceString) => {
   for (const item of voltageDataItems) {
     voltageDataMap.set(item.name.toLowerCase(), item.values);
   }
+  const currentDataItems = result.data.filter(
+    (item) => item.type === "current" && Array.isArray(item.values)
+  );
+  const currentDataMap = /* @__PURE__ */ new Map();
+  for (const item of currentDataItems) {
+    currentDataMap.set(normalizeSpiceVector(item.name), item.values);
+  }
   const requestedPlots = extractRequestedPlots(spiceString);
-  const probeMetadata = extractProbeMetadata(spiceString);
+  const voltageProbeMetadata = extractVoltageProbeMetadata(spiceString);
+  const currentProbeMetadata = extractCurrentProbeMetadata(spiceString);
   if (!requestedPlots) {
-    return voltageDataItems.map((item) => {
-      const metadata = probeMetadata.get(normalizeSpiceVector(item.name));
-      return {
-        netName: metadata?.name ?? getNetName(item.name),
-        time: timeValues,
-        voltage: item.values,
-        probeMetadata: metadata
-      };
-    });
+    return [
+      ...voltageDataItems.map((item) => {
+        const metadata = voltageProbeMetadata.get(
+          normalizeSpiceVector(item.name)
+        );
+        const voltageGraph = {
+          graphType: "voltage",
+          netName: metadata?.name ?? getNetName(item.name),
+          time: timeValues,
+          voltage: item.values,
+          probeMetadata: metadata
+        };
+        return voltageGraph;
+      }),
+      ...currentDataItems.map((item) => {
+        const metadata = currentProbeMetadata.get(
+          normalizeSpiceVector(item.name)
+        );
+        const currentGraph = {
+          graphType: "current",
+          currentName: metadata?.name ?? getCurrentName(item.name),
+          time: timeValues,
+          current: item.values,
+          probeMetadata: metadata
+        };
+        return currentGraph;
+      })
+    ];
   }
   const graphs = [];
   for (const [lowerCaseToken, originalToken] of requestedPlots.entries()) {
-    const diffMatch = originalToken.match(/^v\(([^,]+),\s*([^)]+)\)$/i);
-    let voltage;
-    if (diffMatch?.[1] && diffMatch?.[2]) {
-      voltage = voltageDataMap.get(lowerCaseToken);
-      if (!voltage) {
-        const node1 = diffMatch[1].trim();
-        const node2 = diffMatch[2].trim();
-        const node1Data = voltageDataMap.get(`v(${node1.toLowerCase()})`);
-        const node2Data = voltageDataMap.get(`v(${node2.toLowerCase()})`);
-        if (node1Data && node2Data) {
-          voltage = node1Data.map((v, i) => v - (node2Data[i] ?? 0));
-        }
-      }
-    } else {
-      voltage = voltageDataMap.get(lowerCaseToken);
-    }
-    if (voltage) {
-      const metadata = probeMetadata.get(lowerCaseToken);
-      graphs.push({
-        netName: metadata?.name ?? getNetName(originalToken),
-        time: timeValues,
-        voltage,
-        probeMetadata: metadata
-      });
-    }
+    const graph = createVoltageGraphFromRequestedPlot({
+      lowerCaseToken,
+      originalToken,
+      timeValues,
+      voltageDataMap,
+      voltageProbeMetadata
+    }) ?? createCurrentGraphFromRequestedPlot({
+      lowerCaseToken,
+      originalToken,
+      timeValues,
+      currentDataMap,
+      currentProbeMetadata
+    });
+    if (graph) graphs.push(graph);
   }
   const tranParams = parseTranParams(spiceString);
   if (tranParams?.tstep && tranParams.tstep > 0 && tranParams.tstop && graphs.length > 0) {
@@ -310,39 +425,94 @@ var eecircuitResultToVGraphs = (result, spiceString) => {
         (_, i) => tstart + i * tstep
       );
       const oldTimeValues = graphs[0].time;
-      return graphs.map((graph) => ({
-        ...graph,
-        time: newTimeValues,
-        voltage: newTimeValues.map(
-          (t) => linearInterpolate(t, oldTimeValues, graph.voltage)
-        )
-      }));
+      return graphs.map((graph) => {
+        if (graph.graphType === "voltage") {
+          return {
+            ...graph,
+            time: newTimeValues,
+            voltage: newTimeValues.map(
+              (t) => linearInterpolate(t, oldTimeValues, graph.voltage)
+            )
+          };
+        }
+        return {
+          ...graph,
+          time: newTimeValues,
+          current: newTimeValues.map(
+            (t) => linearInterpolate(t, oldTimeValues, graph.current)
+          )
+        };
+      });
     }
   }
   return graphs;
 };
-var voltageGraphsToCircuitJson = (graphs, spiceString) => {
+var eecircuitResultToVGraphs = (result, spiceString) => {
+  return eecircuitResultToSimulationGraphs(result, spiceString).filter(
+    (graph) => graph.graphType === "voltage"
+  );
+};
+
+// lib/simulation-graphs-to-circuit-json.ts
+var simulationGraphsToCircuitJson = (graphs, spiceString) => {
   const tranParams = parseTranParams(spiceString);
   return graphs.map((graph, index) => {
-    const graphIdSource = graph.probeMetadata?.simulation_voltage_probe_id ?? `${index}_${graph.netName}`;
+    if (graph.graphType === "voltage") {
+      const graphIdSource2 = graph.probeMetadata?.simulation_voltage_probe_id ?? `${index}_${graph.netName}`;
+      const graphElement2 = {
+        type: "simulation_transient_voltage_graph",
+        simulation_experiment_id: "placeholder_simulation_experiment_id",
+        simulation_transient_voltage_graph_id: `simulation_graph_${graphIdSource2}`,
+        name: graph.netName,
+        voltage_levels: graph.voltage,
+        timestamps_ms: graph.time.map((timePoint) => timePoint * 1e3),
+        start_time_ms: (tranParams?.tstart ?? 0) * 1e3,
+        time_per_step: (tranParams?.tstep ?? 0) * 1e3,
+        end_time_ms: (tranParams?.tstop ?? 0) * 1e3,
+        source_probe_id: graph.probeMetadata?.simulation_voltage_probe_id,
+        source_probe_name: graph.probeMetadata?.name,
+        source_node_name: graph.probeMetadata?.source_node_name,
+        reference_node_name: graph.probeMetadata?.reference_node_name
+      };
+      return graphElement2;
+    }
+    const graphIdSource = graph.probeMetadata?.simulation_current_probe_id ?? `${index}_${graph.currentName}`;
     const graphElement = {
-      type: "simulation_transient_voltage_graph",
+      type: "simulation_transient_current_graph",
       simulation_experiment_id: "placeholder_simulation_experiment_id",
-      simulation_transient_voltage_graph_id: `simulation_graph_${graphIdSource}`,
-      name: graph.netName,
-      voltage_levels: graph.voltage,
+      simulation_transient_current_graph_id: `simulation_graph_${graphIdSource}`,
+      name: graph.currentName,
+      current_levels: graph.current,
       timestamps_ms: graph.time.map((timePoint) => timePoint * 1e3),
       start_time_ms: (tranParams?.tstart ?? 0) * 1e3,
       time_per_step: (tranParams?.tstep ?? 0) * 1e3,
       end_time_ms: (tranParams?.tstop ?? 0) * 1e3,
-      source_probe_id: graph.probeMetadata?.simulation_voltage_probe_id,
+      source_probe_id: graph.probeMetadata?.simulation_current_probe_id,
       source_probe_name: graph.probeMetadata?.name,
-      source_node_name: graph.probeMetadata?.source_node_name,
-      reference_node_name: graph.probeMetadata?.reference_node_name
+      source_component_id: graph.probeMetadata?.source_component_id,
+      source_trace_id: graph.probeMetadata?.source_trace_id
     };
     return graphElement;
   });
 };
+
+// lib/index.ts
+var ensureSimulation = async () => {
+  const { Simulation: SimulationCtor } = await importEecircuitEngine();
+  const instance = new SimulationCtor({ ngBehavior: "psa" });
+  await instance.start();
+  return instance;
+};
+var simulationPromise = null;
+var getSimulation = async () => {
+  if (!simulationPromise) {
+    simulationPromise = ensureSimulation().catch((error) => {
+      simulationPromise = null;
+      throw error;
+    });
+  }
+  return simulationPromise;
+};
 var simulate = async (spiceString) => {
   const simulation = await getSimulation();
   const simulationSpiceString = rewritePspiceCompatibilitySyntax(spiceString);
@@ -357,9 +527,12 @@ var simulate = async (spiceString) => {
   if (!result) {
     return { simulationResultCircuitJson: [] };
   }
-  const graphs = eecircuitResultToVGraphs(result, simulationSpiceString);
+  const graphs = eecircuitResultToSimulationGraphs(
+    result,
+    simulationSpiceString
+  );
   return {
-    simulationResultCircuitJson: voltageGraphsToCircuitJson(
+    simulationResultCircuitJson: simulationGraphsToCircuitJson(
       graphs,
       simulationSpiceString
     )
@@ -374,7 +547,9 @@ var index_default = createNgspiceSpiceEngine;
 export {
   createNgspiceSpiceEngine,
   index_default as default,
+  eecircuitResultToSimulationGraphs,
   eecircuitResultToVGraphs,
   parseTranParams,
-  rewritePspiceCompatibilitySyntax
+  rewritePspiceCompatibilitySyntax,
+  simulationGraphsToCircuitJson
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/ngspice-spice-engine",
-  "version": "0.0.16",
+  "version": "0.0.18",
   "description": "A tscircuit-compatible SPICE engine using ngspice.",
   "type": "module",
   "main": "./dist/index.js",
@@ -17,11 +17,10 @@
     "typecheck": "tsc --noEmit"
   },
   "devDependencies": {
-    "@tscircuit/eecircuit-engine": "https://jscdn.tscircuit.com/@tscircuit/eecircuit-engine/1.7.4.tgz",
-    "@tscircuit/props": "^0.0.374",
+    "@tscircuit/props": "^0.0.551",
     "bun-match-svg": "^0.0.14",
-    "circuit-json": "^0.0.435",
-    "circuit-to-svg": "^0.0.217",
+    "circuit-json": "^0.0.437",
+    "circuit-to-svg": "^0.0.357",
     "format-si-unit": "^0.0.7",
     "@biomejs/biome": "^2.2.7",
     "@types/bun": "latest",