@tscircuit/core 0.0.23 → 0.0.24

package/dist/index.js

@@ -37,6 +37,7 @@ import "react";
 var orderedRenderPhases = [
   "ReactSubtreesRender",
   // probably going to be removed b/c subtrees should render instantly
+  "CreateNetsFromProps",
   "CreateTracesFromProps",
   "SourceRender",
   "SourceParentAttachment",
@@ -54,6 +55,7 @@ var orderedRenderPhases = [
   "PcbParentAttachment",
   "PcbLayout",
   "PcbTraceRender",
+  "PcbRouteNetIslands",
   "CadModelRender",
   "PcbAnalysis"
 ];
@@ -174,13 +176,13 @@ var PrimitiveComponent = class extends Renderable {
   lowercaseComponentName = "";
   externallyAddedAliases;
   /**
-   * An opaque group is a self-contained subcircuit. All the selectors inside
-   * an opaque group are relative to the group. You can have multiple opaque
-   * groups and their selectors will not interact with each other (even if the
+   * An subcircuit is self-contained. All the selectors inside
+   * a subcircuit are relative to the subcircuit group. You can have multiple
+   * subcircuits and their selectors will not interact with each other (even if the
    * components share the same names) unless you explicitly break out some ports
    */
-  get isOpaqueGroup() {
-    return Boolean(this.props.opaque) || // Implied opaque group for top-level group
+  get isSubcircuit() {
+    return Boolean(this.props.subcircuit) || // Implied opaque group for top-level group
     this.lowercaseComponentName === "group" && this?.parent?.props?.name === "$root";
   }
   source_group_id = null;
@@ -305,12 +307,12 @@ var PrimitiveComponent = class extends Renderable {
     this.childrenPendingRemoval.push(component);
     component.shouldBeRemoved = true;
   }
-  getOpaqueGroupSelector() {
+  getSubcircuitSelector() {
     const name = this._parsedProps.name;
     const endPart = name ? `${this.lowercaseComponentName}.${name}` : this.lowercaseComponentName;
     if (!this.parent) return endPart;
-    if (this.parent.isOpaqueGroup) return endPart;
-    return `${this.parent.getOpaqueGroupSelector()} > ${endPart}`;
+    if (this.parent.isSubcircuit) return endPart;
+    return `${this.parent.getSubcircuitSelector()} > ${endPart}`;
   }
   getFullPathSelector() {
     const name = this._parsedProps.name;
@@ -347,9 +349,9 @@ var PrimitiveComponent = class extends Renderable {
       return true;
     return false;
   }
-  getOpaqueGroup() {
-    if (this.isOpaqueGroup) return this;
-    const group = this.parent?.getOpaqueGroup();
+  getSubcircuit() {
+    if (this.isSubcircuit) return this;
+    const group = this.parent?.getSubcircuit();
     if (!group)
       throw new Error("Component is not inside an opaque group (no board?)");
     return group;
@@ -409,6 +411,9 @@ var PrimitiveComponent = class extends Renderable {
     if (parent?.props?.name && props?.name) {
       return `<${cname}#${this._renderId}(.${parent?.props.name}>.${props?.name}) />`;
     }
+    if (props?.from && props?.to) {
+      return `<${cname}#${this._renderId}(from:${props.from} to:${props?.to}) />`;
+    }
     if (props?.name) {
       return `<${cname}#${this._renderId} name=".${props?.name}" />`;
     }
@@ -525,6 +530,18 @@ var Port = class extends PrimitiveComponent {
       new Set(this.matchedComponents.flatMap((c) => c.getAvailablePcbLayers()))
     );
   }
+  /**
+   * Return traces that are explicitly connected to this port (not via a net)
+   */
+  _getDirectlyConnectedTraces() {
+    const allSubcircuitTraces = this.getSubcircuit().selectAll(
+      "trace"
+    );
+    const connectedTraces = allSubcircuitTraces.filter(
+      (trace) => trace._isExplicitlyConnectedToPort(this)
+    );
+    return connectedTraces;
+  }
   doInitialSourceRender() {
     const { db } = this.project;
     const { _parsedProps: props } = this;
@@ -983,6 +1000,149 @@ var createComponentsFromSoup = (soup) => {
   return components;
 };
 
+// lib/components/primitive-components/Net.ts
+import { z as z3 } from "zod";
+
+// lib/utils/pairs.ts
+function pairs(arr) {
+  const result = [];
+  for (let i = 0; i < arr.length - 1; i++) {
+    result.push([arr[i], arr[i + 1]]);
+  }
+  return result;
+}
+
+// lib/components/primitive-components/Net.ts
+import { autoroute } from "@tscircuit/infgrid-ijump-astar";
+var netProps = z3.object({
+  name: z3.string()
+});
+var Net = class extends PrimitiveComponent {
+  source_net_id;
+  getPortSelector() {
+    return `net.${this.props.name}`;
+  }
+  doInitialSourceComponentRender() {
+    const { db } = this.project;
+    const { _parsedProps: props } = this;
+    const net = db.source_net.insert({
+      name: props.name,
+      member_source_group_ids: []
+    });
+    this.source_net_id = net.source_net_id;
+  }
+  /**
+   * Get all ports connected to this net.
+   *
+   * TODO currently we're not checking for indirect connections (traces that are
+   * connected to other traces that are in turn connected to the net)
+   */
+  getAllConnectedPorts() {
+    const allPorts = this.getSubcircuit().selectAll("port");
+    const connectedPorts = [];
+    for (const port of allPorts) {
+      const traces = port._getDirectlyConnectedTraces();
+      for (const trace of traces) {
+        if (trace._isExplicitlyConnectedToNet(this)) {
+          connectedPorts.push(port);
+          break;
+        }
+      }
+    }
+    return connectedPorts;
+  }
+  /**
+   * Get all traces that are directly connected to this net, i.e. they list
+   * this net in their path, from, or to props
+   */
+  _getAllDirectlyConnectedTraces() {
+    const allTraces = this.getSubcircuit().selectAll("trace");
+    const connectedTraces = [];
+    for (const trace of allTraces) {
+      if (trace._isExplicitlyConnectedToNet(this)) {
+        connectedTraces.push(trace);
+      }
+    }
+    return connectedTraces;
+  }
+  /**
+   * Add PCB Traces to connect net islands together. A net island is a set of
+   * ports that are connected to each other. If a there are multiple net islands
+   * that means that the net is not fully connected and we need to add traces
+   * such that the nets are fully connected
+   */
+  doInitialPcbRouteNetIslands() {
+    const { db } = this.project;
+    const { _parsedProps: props } = this;
+    const traces = this._getAllDirectlyConnectedTraces().filter(
+      (trace) => (trace._portsRoutedOnPcb?.length ?? 0) > 0
+    );
+    const islands = [];
+    for (const trace of traces) {
+      const tracePorts = trace._portsRoutedOnPcb;
+      const traceIsland = islands.find(
+        (island) => tracePorts.some((port) => island.ports.includes(port))
+      );
+      if (!traceIsland) {
+        islands.push({ ports: [...tracePorts], traces: [trace] });
+        continue;
+      }
+      traceIsland.traces.push(trace);
+      traceIsland.ports.push(...tracePorts);
+    }
+    if (islands.length === 0) {
+      return;
+    }
+    const islandPairs = pairs(islands);
+    for (const [A, B] of islandPairs) {
+      const Apositions = A.ports.map(
+        (port) => port.getGlobalPcbPosition()
+      );
+      const Bpositions = B.ports.map(
+        (port) => port.getGlobalPcbPosition()
+      );
+      let closestDist = Infinity;
+      let closestPair = [-1, -1];
+      for (let i = 0; i < Apositions.length; i++) {
+        const Apos = Apositions[i];
+        for (let j = 0; j < Bpositions.length; j++) {
+          const Bpos = Bpositions[j];
+          const dist = Math.sqrt(
+            (Apos.x - Bpos.x) ** 2 + (Apos.y - Bpos.y) ** 2
+          );
+          if (dist < closestDist) {
+            closestDist = dist;
+            closestPair = [i, j];
+          }
+        }
+      }
+      const Aport = A.ports[closestPair[0]];
+      const Bport = B.ports[closestPair[1]];
+      const pcbElements = db.toArray().filter(
+        (elm) => elm.type === "pcb_smtpad" || elm.type === "pcb_trace" || elm.type === "pcb_plated_hole" || elm.type === "pcb_hole" || elm.type === "source_port" || elm.type === "pcb_port"
+      );
+      const { solution } = autoroute(
+        pcbElements.concat([
+          {
+            type: "source_trace",
+            source_trace_id: "__net_trace_tmp",
+            connected_source_port_ids: [
+              Aport.source_port_id,
+              Bport.source_port_id
+            ]
+          }
+        ])
+      );
+      const trace = solution[0];
+      if (!trace) {
+        this.renderError("Failed to route net islands");
+        return;
+      }
+      db.pcb_trace.insert(trace);
+    }
+  }
+};
+
 // lib/components/base-components/NormalComponent.ts
 var NormalComponent = class extends PrimitiveComponent {
   reactSubtrees = [];
@@ -1204,6 +1364,19 @@ var NormalComponent = class extends PrimitiveComponent {
     }
     return newPorts;
   }
+  _createNetsFromProps(propsWithConnections) {
+    for (const prop of propsWithConnections) {
+      if (typeof prop === "string" && prop.startsWith("net.")) {
+        if (!this.getSubcircuit().selectOne(prop)) {
+          this.getSubcircuit().add(
+            new Net({
+              name: prop.split(".")[1]
+            })
+          );
+        }
+      }
+    }
+  }
   /**
    * Use data from our props to create ports for this component.
    *
@@ -1239,10 +1412,24 @@ var NormalComponent = class extends PrimitiveComponent {
 
 // lib/components/normal-components/Board.ts
 import { boardProps } from "@tscircuit/props";
-import { identity as identity3 } from "transformation-matrix";
-var Board = class extends NormalComponent {
+import { identity as identity4 } from "transformation-matrix";
+
+// lib/components/primitive-components/Group.ts
+import { groupProps } from "@tscircuit/props";
+import "transformation-matrix";
+import "zod";
+var Group = class extends NormalComponent {
+  get config() {
+    return {
+      zodProps: groupProps
+    };
+  }
+};
+
+// lib/components/normal-components/Board.ts
+var Board = class extends Group {
   pcb_board_id = null;
-  get isOpaqueGroup() {
+  get isSubcircuit() {
     return true;
   }
   get config() {
@@ -1270,7 +1457,7 @@ var Board = class extends NormalComponent {
     this.pcb_board_id = null;
   }
   computePcbGlobalTransform() {
-    return identity3();
+    return identity4();
   }
 };
 
@@ -1282,7 +1469,7 @@ import "zod";
 import { traceProps } from "@tscircuit/props";
 import {
   IJumpAutorouter,
-  autoroute,
+  autoroute as autoroute2,
   getObstaclesFromSoup,
   markObstaclesAsConnected
 } from "@tscircuit/infgrid-ijump-astar";
@@ -1366,15 +1553,6 @@ var findPossibleTraceLayerCombinations = (hints, layer_path = []) => {
   return candidates;
 };
 
-// lib/utils/pairs.ts
-function pairs(arr) {
-  const result = [];
-  for (let i = 0; i < arr.length - 1; i++) {
-    result.push([arr[i], arr[i + 1]]);
-  }
-  return result;
-}
-
 // lib/utils/autorouting/mergeRoutes.ts
 function pdist(a, b) {
   return Math.hypot(a.x - b.x, a.y - b.y);
@@ -1417,7 +1595,29 @@ var mergeRoutes = (routes) => {
   return merged;
 };
 
+// lib/utils/getClosest.ts
+var getDistance = (a, b) => {
+  const aPos = "getGlobalPcbPosition" in a ? a.getGlobalPcbPosition() : a;
+  const bPos = "getGlobalPcbPosition" in b ? b.getGlobalPcbPosition() : b;
+  return Math.sqrt((aPos.x - bPos.x) ** 2 + (aPos.y - bPos.y) ** 2);
+};
+function getClosest(point, candidates) {
+  if (candidates.length === 0)
+    throw new Error("No candidates given to getClosest method");
+  let closest = candidates[0];
+  let closestDist = Infinity;
+  for (const candidate of candidates) {
+    const dist = getDistance(point, candidate);
+    if (dist < closestDist) {
+      closest = candidate;
+      closestDist = dist;
+    }
+  }
+  return closest;
+}
+
 // lib/components/primitive-components/Trace.ts
+import "zod";
 var portToObjective = (port) => {
   const portPosition = port.getGlobalPcbPosition();
   return {
@@ -1429,12 +1629,17 @@ var Trace = class extends PrimitiveComponent {
   source_trace_id = null;
   pcb_trace_id = null;
   schematic_trace_id = null;
+  _portsRoutedOnPcb;
+  constructor(props) {
+    super(props);
+    this._portsRoutedOnPcb = [];
+  }
   get config() {
     return {
       zodProps: traceProps
     };
   }
-  getTracePortPathSelectors() {
+  _getTracePortOrNetSelectorListFromProps() {
     if ("from" in this.props && "to" in this.props) {
       return [
         typeof this.props.from === "string" ? this.props.from : this.props.from.getPortSelector(),
@@ -1448,19 +1653,29 @@ var Trace = class extends PrimitiveComponent {
     }
     return [];
   }
+  getTracePortPathSelectors() {
+    return this._getTracePortOrNetSelectorListFromProps().filter(
+      (selector) => !selector.includes("net.")
+    );
+  }
+  getTracePathNetSelectors() {
+    return this._getTracePortOrNetSelectorListFromProps().filter(
+      (selector) => selector.includes("net.")
+    );
+  }
   _findConnectedPorts() {
     const { db } = this.project;
     const { _parsedProps: props, parent } = this;
     if (!parent) throw new Error("Trace has no parent");
     const portSelectors = this.getTracePortPathSelectors();
-    const ports = portSelectors.map((selector) => ({
+    const portsWithSelectors = portSelectors.map((selector) => ({
       selector,
-      port: this.getOpaqueGroup().selectOne(selector, { type: "port" }) ?? null
+      port: this.getSubcircuit().selectOne(selector, { type: "port" }) ?? null
     }));
-    for (const { selector, port } of ports) {
+    for (const { selector, port } of portsWithSelectors) {
       if (!port) {
         const parentSelector = selector.replace(/\>.*$/, "");
-        const targetComponent = this.getOpaqueGroup().selectOne(parentSelector);
+        const targetComponent = this.getSubcircuit().selectOne(parentSelector);
         if (!targetComponent) {
           this.renderError(`Could not find port for selector "${selector}"`);
         } else {
@@ -1473,10 +1688,43 @@ searched component ${targetComponent.getString()}, which has ports: ${targetComp
         }
       }
     }
-    if (ports.some((p) => !p.port)) {
+    if (portsWithSelectors.some((p) => !p.port)) {
       return { allPortsFound: false };
     }
-    return { allPortsFound: true, ports };
+    return {
+      allPortsFound: true,
+      portsWithSelectors,
+      ports: portsWithSelectors.map(({ port }) => port)
+    };
+  }
+  _findConnectedNets() {
+    const nets = this.getTracePathNetSelectors().map((selector) => ({
+      selector,
+      net: this.getSubcircuit().selectOne(selector, { type: "net" })
+    }));
+    const undefinedNets = nets.filter((n) => !n.net);
+    if (undefinedNets.length > 0) {
+      this.renderError(
+        `Could not find net for selector "${undefinedNets[0].selector}" inside ${this}`
+      );
+    }
+    return nets;
+  }
+  /**
+   * Determine if a trace is explicitly connected to a port (not via a net)
+   */
+  _isExplicitlyConnectedToPort(port) {
+    const { allPortsFound, portsWithSelectors: portsWithMetadata } = this._findConnectedPorts();
+    if (!allPortsFound) return false;
+    const ports = portsWithMetadata.map((p) => p.port);
+    return ports.includes(port);
+  }
+  /**
+   * Determine if a trace is explicitly connected to a net (not via a port)
+   */
+  _isExplicitlyConnectedToNet(net) {
+    const nets = this._findConnectedNets().map((n) => n.net);
+    return nets.includes(net);
   }
   doInitialSourceTraceRender() {
     const { db } = this.project;
@@ -1485,11 +1733,12 @@ searched component ${targetComponent.getString()}, which has ports: ${targetComp
       this.renderError("Trace has no parent");
       return;
     }
-    const { allPortsFound, ports } = this._findConnectedPorts();
+    const { allPortsFound, portsWithSelectors: ports } = this._findConnectedPorts();
     if (!allPortsFound) return;
+    const nets = this._findConnectedNets();
     const trace = db.source_trace.insert({
       connected_source_port_ids: ports.map((p) => p.port.source_port_id),
-      connected_source_net_ids: []
+      connected_source_net_ids: nets.map((n) => n.net.source_net_id)
     });
     this.source_trace_id = trace.source_trace_id;
   }
@@ -1498,42 +1747,90 @@ searched component ${targetComponent.getString()}, which has ports: ${targetComp
     const { _parsedProps: props, parent } = this;
     if (!parent) throw new Error("Trace has no parent");
     const { allPortsFound, ports } = this._findConnectedPorts();
+    const portsConnectedOnPcbViaNet = [];
     if (!allPortsFound) return;
+    const nets = this._findConnectedNets();
+    if (ports.length === 0 && nets.length === 2) {
+      this.renderError(
+        `Trace connects two nets, we haven't implemented a way to route this yet`
+      );
+      return;
+    } else if (ports.length === 1 && nets.length === 1) {
+      const port = ports[0];
+      const portsInNet = nets[0].net.getAllConnectedPorts();
+      const otherPortsInNet = portsInNet.filter((p) => p !== port);
+      if (otherPortsInNet.length === 0) {
+        console.log(
+          "Nothing to connect this port to, the net is empty. TODO should emit a warning!"
+        );
+        return;
+      }
+      const closestPortInNet = getClosest(port, otherPortsInNet);
+      portsConnectedOnPcbViaNet.push(closestPortInNet);
+      ports.push(closestPortInNet);
+    } else if (ports.length > 1 && nets.length >= 1) {
+      this.renderError(
+        `Trace has more than one port and one or more nets, we don't currently support this type of complex trace routing`
+      );
+      return;
+    }
     const pcbElements = db.toArray().filter(
       (elm) => elm.type === "pcb_smtpad" || elm.type === "pcb_trace" || elm.type === "pcb_plated_hole" || elm.type === "pcb_hole" || elm.type === "source_port" || elm.type === "pcb_port"
     );
     const source_trace = db.source_trace.get(this.source_trace_id);
     const hints = ports.flatMap(
-      ({ port }) => port.matchedComponents.filter((c) => c.componentName === "TraceHint")
+      (port) => port.matchedComponents.filter((c) => c.componentName === "TraceHint")
     );
     const pcbRouteHints = (this._parsedProps.pcbRouteHints ?? []).concat(
       hints.flatMap((h) => h.getPcbRouteHints())
     );
     if (ports.length > 2) {
       this.renderError(
-        `Trace has more than two ports (${ports.map((p) => p.port.getString()).join(
+        `Trace has more than two ports (${ports.map((p) => p.getString()).join(
           ", "
         )}), routing between more than two ports for a single trace is not implemented`
       );
       return;
     }
+    const alreadyRoutedTraces = this.getSubcircuit().selectAll("trace").filter(
+      (trace) => trace.renderPhaseStates.PcbTraceRender.initialized
+    );
+    const isAlreadyRouted = alreadyRoutedTraces.some(
+      (trace) => trace._portsRoutedOnPcb.length === ports.length && trace._portsRoutedOnPcb.every(
+        (portRoutedByOtherTrace) => ports.includes(portRoutedByOtherTrace)
+      )
+    );
+    if (isAlreadyRouted) {
+      return;
+    }
     if (pcbRouteHints.length === 0) {
-      const { solution } = autoroute(pcbElements.concat([source_trace]));
+      const { solution } = autoroute2(
+        pcbElements.concat([
+          {
+            ...source_trace,
+            // manually override b/c some of the ports may be connected via nets
+            // so they don't appear properly in the source_trace, we don't need
+            // to do this if the algorithm correctly looks at connected_source_net_ids
+            connected_source_port_ids: ports.map((p) => p.source_port_id)
+          }
+        ])
+      );
       const inputPcbTrace = solution[0];
       if (!inputPcbTrace) {
         console.log(
-          `Failed to find route ffrom ${ports[0].port} to ${ports[1].port} render error!`
+          `Failed to find route from ${ports[0]} to ${ports[1]} (TODO render error!)`
         );
         return;
       }
       const pcb_trace2 = db.pcb_trace.insert(inputPcbTrace);
       this.pcb_trace_id = pcb_trace2.pcb_trace_id;
+      this._portsRoutedOnPcb = ports;
       return;
     }
     const orderedRouteObjectives = [
-      portToObjective(ports[0].port),
+      portToObjective(ports[0]),
       ...pcbRouteHints,
-      portToObjective(ports[1].port)
+      portToObjective(ports[1])
     ];
     const candidateLayerCombinations = findPossibleTraceLayerCombinations(
       orderedRouteObjectives
@@ -1600,7 +1897,7 @@ searched component ${targetComponent.getString()}, which has ports: ${targetComp
     const { db } = this.project;
     const { _parsedProps: props, parent } = this;
     if (!parent) throw new Error("Trace has no parent");
-    const { allPortsFound, ports } = this._findConnectedPorts();
+    const { allPortsFound, portsWithSelectors: ports } = this._findConnectedPorts();
     if (!allPortsFound) return;
     const obstacles = [];
     const connection = {
@@ -1671,17 +1968,20 @@ var Resistor = class extends NormalComponent {
   }
   pin1 = this.portMap.pin1;
   pin2 = this.portMap.pin2;
+  doInitialCreateNetsFromProps() {
+    this._createNetsFromProps([this.props.pullupFor, this.props.pullupTo]);
+  }
   doInitialCreateTracesFromProps() {
     if (this.props.pullupFor && this.props.pullupTo) {
       this.add(
         new Trace({
-          from: `${this.getOpaqueGroupSelector()} > port.1`,
+          from: `${this.getSubcircuitSelector()} > port.1`,
           to: this.props.pullupFor
         })
       );
       this.add(
         new Trace({
-          from: `${this.getOpaqueGroupSelector()} > port.2`,
+          from: `${this.getSubcircuitSelector()} > port.2`,
           to: this.props.pullupTo
         })
       );
@@ -1743,17 +2043,23 @@ var Capacitor = class extends NormalComponent {
   }
   pin1 = this.portMap.pin1;
   pin2 = this.portMap.pin2;
+  doInitialCreateNetsFromProps() {
+    this._createNetsFromProps([
+      this.props.decouplingFor,
+      this.props.decouplingTo
+    ]);
+  }
   doInitialCreateTracesFromProps() {
     if (this.props.decouplingFor && this.props.decouplingTo) {
       this.add(
         new Trace({
-          from: `${this.getOpaqueGroupSelector()} > port.1`,
+          from: `${this.getSubcircuitSelector()} > port.1`,
           to: this.props.decouplingFor
         })
       );
       this.add(
         new Trace({
-          from: `${this.getOpaqueGroupSelector()} > port.2`,
+          from: `${this.getSubcircuitSelector()} > port.2`,
           to: this.props.decouplingTo
         })
       );
@@ -1774,17 +2080,6 @@ var Capacitor = class extends NormalComponent {
   }
 };
 
-// lib/components/primitive-components/Net.ts
-import { z as z5 } from "zod";
-var netProps = z5.object({
-  name: z5.string()
-});
-var Net = class extends PrimitiveComponent {
-  getPortSelector() {
-    return `net.${this.props.name}`;
-  }
-};
-
 // lib/components/primitive-components/TraceHint.ts
 import "@tscircuit/props";
 import { applyToPoint as applyToPoint4 } from "transformation-matrix";
@@ -1830,17 +2125,6 @@ var TraceHint = class extends PrimitiveComponent {
   }
 };
 
-// lib/components/primitive-components/Group.ts
-import { groupProps } from "@tscircuit/props";
-import "transformation-matrix";
-var Group = class extends PrimitiveComponent {
-  get config() {
-    return {
-      zodProps: groupProps
-    };
-  }
-};
-
 // lib/components/normal-components/Chip.ts
 import { chipProps } from "@tscircuit/props";
 

package/lib/Project.ts

@@ -117,7 +117,7 @@ export class Circuit {
 
   selectOne(
     selector: string,
-    opts: { type?: "component" | "port" },
+    opts?: { type?: "component" | "port" },
   ): PrimitiveComponent | null {
     return this.rootComponent?.selectOne(selector, opts) ?? null
   }

package/lib/components/base-components/NormalComponent.ts

@@ -16,6 +16,7 @@ import {
 } from "lib/fiber/create-instance-from-react-element"
 import { getPortFromHints } from "lib/utils/getPortFromHints"
 import { createComponentsFromSoup } from "lib/utils/createComponentsFromSoup"
+import { Net } from "../primitive-components/Net"
 
 export type PortMap<T extends string> = {
   [K in T]: Port
@@ -307,6 +308,20 @@ export class NormalComponent<
     return newPorts
   }
 
+  _createNetsFromProps(propsWithConnections: (string | undefined | null)[]) {
+    for (const prop of propsWithConnections) {
+      if (typeof prop === "string" && prop.startsWith("net.")) {
+        if (!this.getSubcircuit().selectOne(prop)) {
+          this.getSubcircuit().add(
+            new Net({
+              name: prop.split(".")[1],
+            }),
+          )
+        }
+      }
+    }
+  }
+
   /**
    * Use data from our props to create ports for this component.
    *