circuitscript 0.1.15 → 0.1.17

package/dist/esm/graph.js

@@ -0,0 +1,344 @@
+import { Graph } from "@dagrejs/graphlib";
+import { SymbolDrawing, SymbolPlaceholder, SymbolCustomModule, SymbolCustom } from "./draw_symbols.js";
+import { ComponentTypes } from "./globals.js";
+import { milsToMM } from "./helpers.js";
+import { RenderFrame, RenderComponent, applyComponentParamsToSymbol, RenderWire } from "./layout.js";
+import { SequenceAction, FrameAction } from "./objects/ExecutionScope.js";
+import { Frame, FixedFrameIds, FrameParamKeys } from "./objects/Frame.js";
+import { numeric } from "./objects/ParamDefinition.js";
+import { NetTypes, TypeProps } from "./objects/types.js";
+import Matrix, { solve } from "ml-matrix";
+import { getPinDefinition } from "./objects/PinDefinition.js";
+export class NetGraph {
+    logger;
+    constructor(logger) {
+        this.logger = logger;
+    }
+    generateLayoutGraph(sequence, nets) {
+        this.print('===== creating graph and populating with nodes =====');
+        let previousNode = null;
+        let previousPin = null;
+        const graph = new Graph({
+            directed: true,
+            compound: true,
+        });
+        this.print('sequence length:', sequence.length);
+        const baseFrame = new RenderFrame(new Frame(FixedFrameIds.BaseFrame));
+        const frameStack = [baseFrame];
+        const containerFrames = [baseFrame];
+        sequence.forEach((sequenceStep, index) => {
+            const action = sequenceStep[0];
+            let tmpComponent;
+            switch (action) {
+                case SequenceAction.To:
+                case SequenceAction.At: {
+                    this.print(...sequenceStep);
+                    const [, component, pin] = sequenceStep;
+                    const tmpInstanceName = component.instanceName;
+                    if (!graph.hasNode(tmpInstanceName)) {
+                        this.print('create instance', tmpInstanceName);
+                        const { displayProp = null } = component;
+                        let tmpSymbol;
+                        if (displayProp instanceof SymbolDrawing) {
+                            tmpSymbol = new SymbolPlaceholder(displayProp);
+                            tmpSymbol.drawing.logger = this.logger;
+                        }
+                        else {
+                            const symbolPinDefinitions = generateLayoutPinDefinition(component);
+                            if (component.typeProp === ComponentTypes.module) {
+                                tmpSymbol = new SymbolCustomModule(symbolPinDefinitions, component.pinsMaxPositions);
+                            }
+                            else {
+                                tmpSymbol = new SymbolCustom(symbolPinDefinitions, component.pinsMaxPositions);
+                            }
+                        }
+                        applyComponentParamsToSymbol(component, tmpSymbol);
+                        tmpSymbol.refreshDrawing();
+                        const { width: useWidth, height: useHeight } = tmpSymbol.size();
+                        tmpComponent = new RenderComponent(component, useWidth, useHeight);
+                        tmpComponent.symbol = tmpSymbol;
+                        graph.setNode(tmpInstanceName, [RenderItemType.Component, tmpComponent, index]);
+                        const currentFrame = frameStack[frameStack.length - 1];
+                        currentFrame && currentFrame.innerItems.push(tmpComponent);
+                    }
+                    if (action === SequenceAction.To && previousNode && previousPin) {
+                        this.setGraphEdge(graph, previousNode, tmpInstanceName, makeEdgeValue(previousNode, previousPin, tmpInstanceName, pin, index));
+                    }
+                    previousNode = tmpInstanceName;
+                    previousPin = pin;
+                    break;
+                }
+                case SequenceAction.Wire: {
+                    const [, wireId, wireSegments] = sequenceStep;
+                    let useNet;
+                    if (previousNode !== null) {
+                        const [prevNodeType, prevNodeItem] = graph.node(previousNode);
+                        if (prevNodeType === RenderItemType.Component) {
+                            const matchingItem = nets.find(([comp, pin]) => {
+                                return comp.instanceName === previousNode
+                                    && pin.equals(previousPin);
+                            });
+                            if (matchingItem !== undefined) {
+                                useNet = matchingItem[2];
+                            }
+                        }
+                        else if (prevNodeType === RenderItemType.Wire) {
+                            useNet = prevNodeItem.net;
+                        }
+                    }
+                    const wire = new RenderWire(useNet, numeric(0), numeric(0), wireSegments);
+                    wire.id = wireId;
+                    wire.netName = useNet.toString();
+                    const wireName = getWireName(wire.id);
+                    graph.setNode(wireName, [RenderItemType.Wire, wire, index]);
+                    this.setGraphEdge(graph, previousNode, wireName, makeEdgeValue(previousNode, previousPin, wireName, 0, index));
+                    previousNode = wireName;
+                    previousPin = 1;
+                    const wireSegmentsInfo = wireSegments.map(item => {
+                        const tmp = {
+                            direction: item.direction,
+                            value: item.value,
+                        };
+                        if (item.valueXY) {
+                            tmp.valueXY = item.valueXY;
+                        }
+                        if (item.until) {
+                            tmp.until = [item.until[0].toString(), item.until[1]];
+                        }
+                        return tmp;
+                    });
+                    this.print(SequenceAction.Wire, wireId, JSON.stringify(wireSegmentsInfo));
+                    break;
+                }
+                case SequenceAction.WireJump: {
+                    this.print(...sequenceStep);
+                    const wireId = sequenceStep[1];
+                    const wireName = getWireName(wireId);
+                    let wirePin = 1;
+                    if (sequenceStep.length === 3) {
+                        wirePin = sequenceStep[2];
+                    }
+                    previousNode = wireName;
+                    previousPin = wirePin;
+                    break;
+                }
+                case SequenceAction.Frame: {
+                    const [, frameObject, frameAction] = sequenceStep;
+                    if (frameAction === FrameAction.Enter) {
+                        const prevFrame = frameStack[frameStack.length - 1];
+                        const newFrame = new RenderFrame(frameObject);
+                        if (frameObject.parameters.has(FrameParamKeys.Direction)) {
+                            newFrame.direction =
+                                frameObject.parameters.get(FrameParamKeys.Direction);
+                        }
+                        if (frameObject.parameters.has(FrameParamKeys.Padding)) {
+                            newFrame.padding = milsToMM(frameObject.parameters.get(FrameParamKeys.Padding));
+                        }
+                        if (frameObject.parameters.has(FrameParamKeys.Border)) {
+                            newFrame.borderWidth =
+                                frameObject.parameters.get(FrameParamKeys.Border);
+                        }
+                        if (frameObject.parameters.has(FrameParamKeys.Width)) {
+                            newFrame.width = milsToMM(frameObject.parameters.get(FrameParamKeys.Width));
+                        }
+                        if (frameObject.parameters.has(FrameParamKeys.Height)) {
+                            newFrame.height = milsToMM(frameObject.parameters.get(FrameParamKeys.Height));
+                        }
+                        containerFrames.push(newFrame);
+                        frameStack.push(newFrame);
+                        prevFrame && prevFrame.innerItems.push(newFrame);
+                    }
+                    else if (frameAction === FrameAction.Exit) {
+                        frameStack.pop();
+                    }
+                    break;
+                }
+            }
+        });
+        this.print('===== done populating graph =====');
+        this.print('');
+        const logNodesAndEdges = true;
+        if (logNodesAndEdges) {
+            this.print('===== graph edges =====');
+            const allEdges = graph.edges();
+            allEdges.forEach(edge => {
+                const [nodeId1, pin1, nodeId2, pin2] = graph.edge(edge);
+                this.print(nodeId1, 'pin', pin1, '-----', nodeId2, 'pin', pin2);
+            });
+            this.print('===== end edges =====');
+            this.print();
+            this.print('===== graph nodes =====');
+            const nodes = graph.nodes();
+            nodes.forEach(node => {
+                this.print(`name:${node}, value:${graph.node(node)}`);
+            });
+            this.print('===== end nodes =====');
+            this.print('');
+        }
+        return {
+            graph,
+            containerFrames,
+        };
+    }
+    setGraphEdge(graph, node1, node2, edgeValue) {
+        if (!graph.isDirected && graph.hasEdge(node1, node2)) {
+            this.print(`Warning: edge already exists ${node1} ${node2}`);
+        }
+        graph.setEdge(node1, node2, edgeValue);
+        this.print(`created edge: node1:${node1} node2:${node2} edgeValue:${edgeValue}`);
+    }
+    print(...params) {
+        this.logger.add(params.join(' '));
+    }
+    generateNetGraph(nets) {
+        const uniqueNets = new Set(nets.map(([, , net]) => net));
+        const components = new Set(nets.map(([component, ,]) => component));
+        const tmpNets = Array.from(uniqueNets);
+        const gndNet = tmpNets.find(item => {
+            return item.toString() === '/GND';
+        });
+        const otherNets = tmpNets.filter(item => {
+            return item !== gndNet;
+        });
+        const netsIndexed = [];
+        if (gndNet) {
+            netsIndexed.push(gndNet);
+        }
+        netsIndexed.push(...otherNets);
+        const netsLength = netsIndexed.length;
+        const conductanceMatrix = Matrix.zeros(netsLength, netsLength);
+        components.forEach(item => {
+            if (item.typeProp === TypeProps.Resistor) {
+                const net1 = item.pinNets.get(1);
+                const net2 = item.pinNets.get(2);
+                const net1Index = netsIndexed.indexOf(net1);
+                const net2Index = netsIndexed.indexOf(net2);
+                const resistance = item.parameters.get('value');
+                const resistanceValue = resistance.toNumber();
+                const conductanceValue = 1 / resistanceValue;
+                const currentValue1 = conductanceMatrix.get(net1Index, net1Index);
+                const currentValue2 = conductanceMatrix.get(net2Index, net2Index);
+                const currentValue3 = conductanceMatrix.get(net1Index, net2Index);
+                const currentValue4 = conductanceMatrix.get(net2Index, net1Index);
+                conductanceMatrix.set(net1Index, net1Index, currentValue1 + conductanceValue);
+                conductanceMatrix.set(net2Index, net2Index, currentValue2 + conductanceValue);
+                conductanceMatrix.set(net1Index, net2Index, currentValue3 - conductanceValue);
+                conductanceMatrix.set(net2Index, net1Index, currentValue4 - conductanceValue);
+            }
+        });
+        if (gndNet) {
+            conductanceMatrix.removeColumn(0);
+            conductanceMatrix.removeRow(0);
+        }
+        const netsWithoutGnd = netsIndexed.filter(net => {
+            return (net !== gndNet);
+        });
+        const netResistances = new Map();
+        try {
+            netsWithoutGnd.forEach((net, index) => {
+                if (net.type === NetTypes.Source) {
+                    const currentVector = Matrix.zeros(netsWithoutGnd.length, 1);
+                    currentVector.set(index, 0, 1);
+                    const solution = solve(conductanceMatrix, currentVector);
+                    for (let i = 0; i < solution.rows; i++) {
+                        const resValue = solution.get(i, 0);
+                        if (resValue > 0) {
+                            const targetNet = netsIndexed[i];
+                            netResistances.set(targetNet, resValue);
+                        }
+                    }
+                }
+            });
+        }
+        catch (err) {
+        }
+        return {
+            nets,
+            netResistances,
+        };
+    }
+    findNodePaths(graph, startNode, endNode, seenNodes = []) {
+        const edges = graph.nodeEdges(startNode);
+        const paths = [];
+        for (let i = 0; i < edges.length; i++) {
+            const edge = edges[i];
+            const node1 = edge.v;
+            const node2 = edge.w;
+            let nextNode = "";
+            if (node1 === startNode) {
+                nextNode = node2;
+            }
+            else {
+                nextNode = node1;
+            }
+            if (nextNode === endNode) {
+                paths.push([startNode, endNode]);
+                continue;
+            }
+            else if (seenNodes.indexOf(nextNode) !== -1) {
+                continue;
+            }
+            seenNodes.push(startNode);
+            const routes = this.findNodePaths(graph, nextNode, endNode, seenNodes);
+            for (let j = 0; j < routes.length; j++) {
+                paths.push([startNode, ...routes[j]]);
+            }
+        }
+        return paths;
+    }
+    getNetNodeName(net) {
+        return 'net:' + net.toString();
+    }
+    getComponentName(component) {
+        return 'component:' + component.instanceName;
+    }
+}
+function makeEdgeValue(instanceName1, instancePin1, instanceName2, instancePin2, priority) {
+    return [instanceName1, instancePin1, instanceName2, instancePin2, priority];
+}
+export function getWireName(wireId) {
+    return 'wire:' + wireId;
+}
+export function generateLayoutPinDefinition(component) {
+    const pins = component.pins;
+    const symbolPinDefinitions = [];
+    const existingPinIds = Array.from(pins.keys());
+    const arrangeProps = component.arrangeProps ?? [];
+    const addedPins = [];
+    for (const [key, items] of arrangeProps) {
+        let useItems;
+        if (!Array.isArray(items)) {
+            useItems = [items];
+        }
+        else {
+            useItems = [...items];
+        }
+        useItems.forEach(pinId => {
+            const existingPin = existingPinIds.find(pin => pin.equals(pinId));
+            if (existingPin) {
+                const pin = getPinDefinition(pins, existingPin);
+                symbolPinDefinitions.push({
+                    side: key,
+                    pinId: pinId,
+                    text: pin.name,
+                    position: pin.position,
+                    pinType: pin.pinType,
+                });
+                addedPins.push(pinId);
+            }
+        });
+    }
+    const unplacedPins = existingPinIds.filter(pinId => {
+        return addedPins.find(id => id.equals(pinId)) === undefined;
+    });
+    if (unplacedPins.length > 0) {
+        component._unplacedPins = unplacedPins;
+        console.warn("Warning: There are unplaced pins: " + unplacedPins);
+    }
+    return symbolPinDefinitions;
+}
+export var RenderItemType;
+(function (RenderItemType) {
+    RenderItemType["Wire"] = "wire";
+    RenderItemType["Component"] = "component";
+})(RenderItemType || (RenderItemType = {}));

package/dist/esm/helpers.js

@@ -17,6 +17,7 @@ import { defaultPageMarginMM, defaultZoomScale, LengthUnit, MilsToMM, PxToMM } f
 import { FrameParamKeys } from "./objects/Frame.js";
 import Big from "big.js";
 import { Logger } from "./logger.js";
+import { NetGraph } from "./graph.js";
 export var JSModuleType;
 (function (JSModuleType) {
     JSModuleType["CommonJs"] = "cjs";
@@ -237,11 +238,14 @@ export async function renderScript(scriptData, outputPath, options) {
                     errors,
                 };
             }
-            const layoutEngine = new LayoutEngine();
+            const logger = new Logger();
+            const graphEngine = new NetGraph(logger);
+            const layoutEngine = new LayoutEngine(logger);
             const layoutTimer = new SimpleStopwatch();
             let sheetFrames;
             try {
-                sheetFrames = layoutEngine.runLayout(sequence, nets);
+                const { graph, containerFrames } = graphEngine.generateLayoutGraph(sequence, nets);
+                sheetFrames = layoutEngine.runLayout(graph, containerFrames, nets);
             }
             catch (err) {
                 throw new RenderError(`Error during layout generation: ${err}`, 'layout');

package/dist/esm/layout.js

@@ -1,21 +1,21 @@
-import graphlib, { Graph } from '@dagrejs/graphlib';
+import graphlib from '@dagrejs/graphlib';
 const { alg } = graphlib;
-import { SymbolCustom, SymbolDrawing, SymbolCustomModule, SymbolPlaceholder, SymbolText, PlaceHolderCommands } from "./draw_symbols.js";
-import { FrameAction, SequenceAction } from "./objects/ExecutionScope.js";
-import { ComponentTypes, defaultFrameTitleTextSize, defaultGridSizeUnits, FrameType, NetGraphicsParams, ParamKeys, WireAutoDirection } from './globals.js';
+import { SymbolCustom, SymbolDrawing, SymbolPlaceholder, SymbolText, PlaceHolderCommands } from "./draw_symbols.js";
+import { defaultFrameTitleTextSize, defaultGridSizeUnits, FrameType, NetGraphicsParams, ParamKeys, WireAutoDirection } from './globals.js';
 import { Geometry, HorizontalAlign, VerticalAlign } from './geometry.js';
-import { Logger } from './logger.js';
 import { FixedFrameIds, Frame, FrameParamKeys, FramePlotDirection } from './objects/Frame.js';
 import { areasOverlap, combineMaps, getBoundsSize, printBounds, resizeBounds, resizeToNearestGrid, roundValue, toNearestGrid } from './utils.js';
 import { Direction } from './objects/types.js';
+import { PinId } from './objects/PinDefinition.js';
 import { milsToMM, UnitDimension } from './helpers.js';
-import { numeric, NumericValue } from './objects/ParamDefinition.js';
+import { numeric } from './objects/ParamDefinition.js';
+import { generateLayoutPinDefinition, getWireName, RenderItemType } from './graph.js';
 export class LayoutEngine {
     logger;
     layoutWarnings = [];
     showBaseFrame = false;
-    constructor(options = { showBaseFrame: false }) {
-        this.logger = new Logger();
+    constructor(logger, options = { showBaseFrame: false }) {
+        this.logger = logger;
         const { showBaseFrame = false } = options ?? {};
         this.showBaseFrame = showBaseFrame;
     }
@@ -29,30 +29,8 @@ export class LayoutEngine {
         const padding = ''.padStart(value * 4, ' ');
         return "[" + value + "]" + padding;
     }
-    runLayout(sequence, nets) {
-        const logNodesAndEdges = true;
+    runLayout(graph, containerFrames, nets) {
         const renderNets = this.collectRenderNets(nets);
-        this.print('===== creating graph and populating with nodes =====');
-        const { graph, containerFrames } = this.generateLayoutGraph(sequence, nets);
-        this.print('===== done populating graph =====');
-        this.print('');
-        if (logNodesAndEdges) {
-            this.print('===== graph edges =====');
-            const allEdges = graph.edges();
-            allEdges.forEach(edge => {
-                const [nodeId1, pin1, nodeId2, pin2] = graph.edge(edge);
-                this.print(nodeId1, 'pin', pin1, '-----', nodeId2, 'pin', pin2);
-            });
-            this.print('===== end edges =====');
-            this.print();
-            this.print('===== graph nodes =====');
-            const nodes = graph.nodes();
-            nodes.forEach(node => {
-                this.print(`name:${node}, value:${graph.node(node)}`);
-            });
-            this.print('===== end nodes =====');
-            this.print('');
-        }
         const subgraphInfo = this.sizeSubGraphs(graph);
         const dumpSubgraphInfo = true;
         if (dumpSubgraphInfo) {
@@ -643,158 +621,6 @@ export class LayoutEngine {
             }
         }
     }
-    generateLayoutGraph(sequence, nets) {
-        let previousNode = null;
-        let previousPin = null;
-        const graph = new Graph({
-            directed: true,
-            compound: true,
-        });
-        this.print('sequence length:', sequence.length);
-        const baseFrame = new RenderFrame(new Frame(FixedFrameIds.BaseFrame));
-        const frameStack = [baseFrame];
-        const containerFrames = [baseFrame];
-        sequence.forEach((sequenceStep, index) => {
-            const action = sequenceStep[0];
-            let tmpComponent;
-            switch (action) {
-                case SequenceAction.To:
-                case SequenceAction.At: {
-                    this.print(...sequenceStep);
-                    const [, component, pin] = sequenceStep;
-                    const tmpInstanceName = component.instanceName;
-                    if (!graph.hasNode(tmpInstanceName)) {
-                        this.print('create instance', tmpInstanceName);
-                        const { displayProp = null } = component;
-                        let tmpSymbol;
-                        if (displayProp instanceof SymbolDrawing) {
-                            tmpSymbol = new SymbolPlaceholder(displayProp);
-                            tmpSymbol.drawing.logger = this.logger;
-                        }
-                        else {
-                            const symbolPinDefinitions = generateLayoutPinDefinition(component);
-                            if (component.typeProp === ComponentTypes.module) {
-                                tmpSymbol = new SymbolCustomModule(symbolPinDefinitions, component.pinsMaxPositions);
-                            }
-                            else {
-                                tmpSymbol = new SymbolCustom(symbolPinDefinitions, component.pinsMaxPositions);
-                            }
-                        }
-                        applyComponentParamsToSymbol(component, tmpSymbol);
-                        tmpSymbol.refreshDrawing();
-                        const { width: useWidth, height: useHeight } = tmpSymbol.size();
-                        tmpComponent = new RenderComponent(component, useWidth, useHeight);
-                        tmpComponent.symbol = tmpSymbol;
-                        graph.setNode(tmpInstanceName, [RenderItemType.Component, tmpComponent, index]);
-                        const currentFrame = frameStack[frameStack.length - 1];
-                        currentFrame && currentFrame.innerItems.push(tmpComponent);
-                    }
-                    if (action === SequenceAction.To && previousNode && previousPin) {
-                        this.setGraphEdge(graph, previousNode, tmpInstanceName, makeEdgeValue(previousNode, previousPin, tmpInstanceName, pin, index));
-                    }
-                    previousNode = tmpInstanceName;
-                    previousPin = pin;
-                    break;
-                }
-                case SequenceAction.Wire: {
-                    const [, wireId, wireSegments] = sequenceStep;
-                    let useNet;
-                    if (previousNode !== null) {
-                        const [prevNodeType, prevNodeItem] = graph.node(previousNode);
-                        if (prevNodeType === RenderItemType.Component) {
-                            const matchingItem = nets.find(([comp, pin]) => {
-                                return comp.instanceName === previousNode
-                                    && pin === previousPin;
-                            });
-                            if (matchingItem !== undefined) {
-                                useNet = matchingItem[2];
-                            }
-                        }
-                        else if (prevNodeType === RenderItemType.Wire) {
-                            useNet = prevNodeItem.net;
-                        }
-                    }
-                    const wire = new RenderWire(useNet, numeric(0), numeric(0), wireSegments);
-                    wire.id = wireId;
-                    wire.netName = useNet.toString();
-                    const wireName = getWireName(wire.id);
-                    graph.setNode(wireName, [RenderItemType.Wire, wire, index]);
-                    this.setGraphEdge(graph, previousNode, wireName, makeEdgeValue(previousNode, previousPin, wireName, 0, index));
-                    previousNode = wireName;
-                    previousPin = 1;
-                    const wireSegmentsInfo = wireSegments.map(item => {
-                        const tmp = {
-                            direction: item.direction,
-                            value: item.value,
-                        };
-                        if (item.valueXY) {
-                            tmp.valueXY = item.valueXY;
-                        }
-                        if (item.until) {
-                            tmp.until = [item.until[0].toString(), item.until[1]];
-                        }
-                        return tmp;
-                    });
-                    this.print(SequenceAction.Wire, wireId, JSON.stringify(wireSegmentsInfo));
-                    break;
-                }
-                case SequenceAction.WireJump: {
-                    this.print(...sequenceStep);
-                    const wireId = sequenceStep[1];
-                    const wireName = getWireName(wireId);
-                    let wirePin = 1;
-                    if (sequenceStep.length === 3) {
-                        wirePin = sequenceStep[2];
-                    }
-                    previousNode = wireName;
-                    previousPin = wirePin;
-                    break;
-                }
-                case SequenceAction.Frame: {
-                    const [, frameObject, frameAction] = sequenceStep;
-                    if (frameAction === FrameAction.Enter) {
-                        const prevFrame = frameStack[frameStack.length - 1];
-                        const newFrame = new RenderFrame(frameObject);
-                        if (frameObject.parameters.has(FrameParamKeys.Direction)) {
-                            newFrame.direction =
-                                frameObject.parameters.get(FrameParamKeys.Direction);
-                        }
-                        if (frameObject.parameters.has(FrameParamKeys.Padding)) {
-                            newFrame.padding = milsToMM(frameObject.parameters.get(FrameParamKeys.Padding));
-                        }
-                        if (frameObject.parameters.has(FrameParamKeys.Border)) {
-                            newFrame.borderWidth =
-                                frameObject.parameters.get(FrameParamKeys.Border);
-                        }
-                        if (frameObject.parameters.has(FrameParamKeys.Width)) {
-                            newFrame.width = milsToMM(frameObject.parameters.get(FrameParamKeys.Width));
-                        }
-                        if (frameObject.parameters.has(FrameParamKeys.Height)) {
-                            newFrame.height = milsToMM(frameObject.parameters.get(FrameParamKeys.Height));
-                        }
-                        containerFrames.push(newFrame);
-                        frameStack.push(newFrame);
-                        prevFrame && prevFrame.innerItems.push(newFrame);
-                    }
-                    else if (frameAction === FrameAction.Exit) {
-                        frameStack.pop();
-                    }
-                    break;
-                }
-            }
-        });
-        return {
-            graph,
-            containerFrames,
-        };
-    }
-    setGraphEdge(graph, node1, node2, edgeValue) {
-        if (!graph.isDirected && graph.hasEdge(node1, node2)) {
-            this.print(`Warning: edge already exists ${node1} ${node2}`);
-        }
-        graph.setEdge(node1, node2, edgeValue);
-        this.print(`created edge: node1:${node1} node2:${node2} edgeValue:${edgeValue}`);
-    }
     sizeSubGraphs(graph) {
         const subGraphs = alg.components(graph);
         const subGraphsStarts = [];
@@ -864,7 +690,11 @@ export class LayoutEngine {
         }
         if (subgraphEdges.length === 0) {
             const [, node1] = graph.node(firstNodeId);
-            this.placeNodeAtPosition(numeric(0), numeric(0), node1, 1);
+            let defaultPin = new PinId(1);
+            if (node1 instanceof RenderComponent) {
+                defaultPin = node1.component.getDefaultPin();
+            }
+            this.placeNodeAtPosition(numeric(0), numeric(0), node1, defaultPin);
             return;
         }
         let fixedNode;
@@ -1092,52 +922,6 @@ function getNeighbours(graph, nodeIds) {
         return accum;
     }, []);
 }
-function makeEdgeValue(instanceName1, instancePin1, instanceName2, instancePin2, priority) {
-    return [instanceName1, instancePin1, instanceName2, instancePin2, priority];
-}
-function getWireName(wireId) {
-    return 'wire:' + wireId;
-}
-function generateLayoutPinDefinition(component) {
-    const pins = component.pins;
-    const symbolPinDefinitions = [];
-    const existingPinIds = Array.from(pins.keys());
-    const arrangeProps = component.arrangeProps ?? [];
-    const addedPins = [];
-    for (const [key, items] of arrangeProps) {
-        let useItems;
-        if (!Array.isArray(items)) {
-            useItems = [items];
-        }
-        else {
-            useItems = [...items];
-        }
-        useItems.forEach(pinId => {
-            if (pinId instanceof NumericValue) {
-                const pinIdValue = pinId.toNumber();
-                if (existingPinIds.indexOf(pinIdValue) !== -1) {
-                    const pin = pins.get(pinIdValue);
-                    symbolPinDefinitions.push({
-                        side: key,
-                        pinId: pinIdValue,
-                        text: pin.name,
-                        position: pin.position,
-                        pinType: pin.pinType,
-                    });
-                    addedPins.push(pinIdValue);
-                }
-            }
-        });
-    }
-    const unplacedPins = existingPinIds.filter(pinId => {
-        return addedPins.indexOf(pinId) === -1;
-    });
-    if (unplacedPins.length > 0) {
-        component._unplacedPins = unplacedPins;
-        console.warn("Warning: There are unplaced pins: " + unplacedPins);
-    }
-    return symbolPinDefinitions;
-}
 export function applyComponentParamsToSymbol(component, symbol) {
     const { widthProp = null, heightProp = null } = component;
     const newMap = new Map(component.parameters);
@@ -1523,8 +1307,3 @@ export function ExtractDrawingRects(drawing) {
 function isPointOverlap(x, y, other) {
     return (x >= other.x && y >= other.y && x <= (other.x + other.width) && y <= (other.y + other.height));
 }
-var RenderItemType;
-(function (RenderItemType) {
-    RenderItemType["Wire"] = "wire";
-    RenderItemType["Component"] = "component";
-})(RenderItemType || (RenderItemType = {}));