circuitscript 0.1.23 → 0.1.24

package/dist/esm/antlr/CircuitScriptVisitor.js

@@ -79,5 +79,12 @@ export class CircuitScriptVisitor extends AbstractParseTreeVisitor {
     visitElse_expr;
     visitWhile_expr;
     visitFor_expr;
+    visitPart_set_expr;
+    visitPart_set_key;
+    visitPart_match_block;
+    visitPart_sub_expr;
+    visitPart_condition_expr;
+    visitPart_condition_key_only_expr;
+    visitPart_value_expr;
     visitAnnotation_comment_expr;
 }

package/dist/esm/builtinMethods.js

@@ -159,7 +159,12 @@ function toString(obj) {
             return obj.toDisplayString();
         }
         else if (obj.toString) {
-            return obj.toString();
+            if (typeof obj === 'object') {
+                return JSON.stringify(obj);
+            }
+            else {
+                return obj.toString();
+            }
         }
         else {
             throw "Could not create string from object: " + obj;

package/dist/esm/execute.js

@@ -378,9 +378,9 @@ export class ExecutionContext {
                 + pinId + ' in ' + component);
         }
         this.scope.setCurrent(component, usePinId);
-        if (!this.scope.hasNet(component, pinId)) {
+        if (!this.scope.hasNet(component, usePinId)) {
             const tmpNet = new Net(this.netNamespace, this.getUniqueNetName());
-            this.scope.setNet(component, pinId, tmpNet);
+            this.scope.setNet(component, usePinId, tmpNet);
         }
         this.scope.clearActive();
         if (addSequence) {
@@ -502,7 +502,9 @@ export class ExecutionContext {
             const { start_point: [component, pin, wireId] } = stackRef;
             this.atComponent(component, pin, { addSequence: true });
             if (wireId !== -1) {
-                this.scope.sequence.push([SequenceAction.WireJump, wireId, 1]);
+                const wireObject = this.scope.wires[wireId];
+                this.scope.sequence.push([SequenceAction.WireJump,
+                    wireId, PinId.from(1), wireObject]);
             }
         }
         else if (blockType === BlockTypes.Join || blockType === BlockTypes.Parallel) {
@@ -628,7 +630,7 @@ export class ExecutionContext {
                         type: isVariable ? ReferenceTypes.variable
                             : ReferenceTypes.instance,
                         found: (tmpReference.value !== undefined),
-                        parentValue: tmpReference.parentValue,
+                        rootValue: tmpReference.rootValue,
                         value: tmpReference.value,
                         name: idName,
                         trailers,
@@ -642,16 +644,19 @@ export class ExecutionContext {
         });
     }
     resolveTrailers(type, item, trailers = []) {
-        let parentValue;
+        let rootValue;
         let useValue = item;
         if (trailers.length > 0) {
-            parentValue = useValue;
+            rootValue = useValue;
             const trailersPath = trailers.join(".");
             if (type === ReferenceTypes.variable) {
-                useValue = parentValue[trailersPath];
+                useValue = rootValue;
+                trailers.forEach(trailerPath => {
+                    useValue = useValue[trailerPath];
+                });
             }
             else if (type === ReferenceTypes.instance) {
-                const tmpComponent = parentValue;
+                const tmpComponent = rootValue;
                 if (tmpComponent.typeProp === ComponentTypes.net) {
                     const usedNet = this.scope.getNet(tmpComponent, new PinId(1));
                     if (usedNet) {
@@ -660,20 +665,21 @@ export class ExecutionContext {
                     }
                 }
                 else {
-                    useValue = parentValue
+                    useValue = rootValue
                         .parameters.get(trailersPath);
                 }
             }
         }
         let found = false;
-        if (parentValue !== undefined && useValue !== undefined) {
+        if (rootValue !== undefined && useValue !== undefined) {
             found = true;
         }
         return new AnyReference({
             found,
             type: type,
-            parentValue,
+            rootValue,
             trailers,
+            trailerIndex: trailers.length,
             value: useValue,
         });
     }
@@ -774,13 +780,16 @@ export class ExecutionContext {
         childScope.sequence.forEach(sequenceAction => {
             const [action] = sequenceAction;
             if (action === SequenceAction.Wire) {
-                const [, innerWireId, segments] = sequenceAction;
-                this.scope.sequence.push([SequenceAction.Wire, wireIdOffset + innerWireId, segments]);
+                const [, innerWireId, segments, wire] = sequenceAction;
+                this.scope.sequence.push([SequenceAction.Wire, wireIdOffset + innerWireId,
+                    segments, wire]);
                 this.scope.wires.push(new Wire(segments));
             }
             else if (action === SequenceAction.WireJump) {
                 const jumpWireId = wireIdOffset + sequenceAction[1];
-                this.scope.sequence.push([SequenceAction.WireJump, jumpWireId, 1]);
+                const wireObject = this.scope.wires[jumpWireId];
+                this.scope.sequence.push([SequenceAction.WireJump, jumpWireId,
+                    PinId.from(1), wireObject]);
             }
             else if (action === SequenceAction.At || action === SequenceAction.To) {
                 this.scope.sequence.push(sequenceAction);
@@ -828,7 +837,8 @@ export class ExecutionContext {
             };
         });
         const wireId = this.scope.wires.length;
-        this.scope.wires.push(new Wire(tmp));
+        const newWire = new Wire(tmp);
+        this.scope.wires.push(newWire);
         const output = [];
         segments.forEach(item => {
             const tmpArray = item.map(item2 => {
@@ -843,12 +853,13 @@ export class ExecutionContext {
         });
         this.log('add wire: ', output.join("|"));
         this.scope.setActive(ActiveObject.Wire, wireId);
-        this.scope.sequence.push([SequenceAction.Wire, wireId, tmp]);
+        this.scope.sequence.push([SequenceAction.Wire, wireId, tmp, newWire]);
         this.scope.currentComponent.pinWires.set(this.scope.currentPin, tmp);
         if (!this.scope.currentComponent.didSetWireOrientationAngle) {
             this.applyComponentAngleFromWire(this.scope.currentComponent, this.scope.currentPin, true);
             this.scope.currentComponent.didSetWireOrientationAngle = true;
         }
+        return newWire;
     }
     addPoint(pointId, userDefined = true) {
         if (this.scope.instances.has(pointId)) {

package/dist/esm/graph.js

@@ -8,7 +8,7 @@ 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";
+import { getPinDefinition, PinId } from "./objects/PinDefinition.js";
 export class NetGraph {
     logger;
     constructor(logger) {
@@ -81,8 +81,9 @@ export class NetGraph {
                     break;
                 }
                 case SequenceAction.Wire: {
-                    const [, wireId, wireSegments] = sequenceStep;
+                    const [, wireId, , wire] = sequenceStep;
                     let useNet;
+                    const wireSegments = wire.path;
                     if (previousNode !== null) {
                         const [prevNodeType, prevNodeItem] = graph.node(previousNode);
                         if (prevNodeType === RenderItemType.Component) {
@@ -98,15 +99,15 @@ export class NetGraph {
                             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]);
+                    const renderWire = new RenderWire(useNet, numeric(0), numeric(0), wireSegments, wire);
+                    renderWire.id = wireId;
+                    renderWire.netName = useNet.toString();
+                    const wireName = getWireName(renderWire.id);
+                    graph.setNode(wireName, [RenderItemType.Wire, renderWire, index]);
                     let tmpPreviousNode = previousNode;
-                    this.setGraphEdge(graph, previousNode, wireName, makeEdgeValue(previousNode, previousPin, wireName, 0, index));
+                    this.setGraphEdge(graph, previousNode, wireName, makeEdgeValue(previousNode, previousPin, wireName, PinId.from(0), index));
                     previousNode = wireName;
-                    previousPin = 1;
+                    previousPin = PinId.from(1);
                     const wireSegmentsInfo = wireSegments.map(item => {
                         const tmp = {
                             direction: item.direction,
@@ -140,7 +141,7 @@ export class NetGraph {
                         wirePin = sequenceStep[2];
                     }
                     previousNode = wireName;
-                    previousPin = wirePin;
+                    previousPin = PinId.from(wirePin);
                     break;
                 }
                 case SequenceAction.Frame: {

package/dist/esm/helpers.js

@@ -19,6 +19,8 @@ import Big from "big.js";
 import { Logger } from "./logger.js";
 import { NetGraph } from "./graph.js";
 import { RefdesAnnotationVisitor } from "./RefdesAnnotationVisitor.js";
+import { EvaluateERCRules } from "./rules-check/rules.js";
+import { generateBom, generateBomCSV, saveBomOutputCsv } from "./BomGeneration.js";
 export var JSModuleType;
 (function (JSModuleType) {
     JSModuleType["CommonJs"] = "cjs";
@@ -155,7 +157,7 @@ export async function renderScript(scriptData, outputPath, options) {
     return renderScriptCustom(scriptData, outputPath, options, parseHandlers);
 }
 export async function renderScriptCustom(scriptData, outputPath, options, parseHandlers) {
-    const { dumpNets = false, dumpData = false, showStats = false, environment, inputPath = null, updateSource = false, saveAnnotatedCopy = undefined, } = options;
+    const { dumpNets = false, dumpData = false, showStats = false, enableErc = false, enableBom = false, bomOutputPath = undefined, environment, inputPath = null, updateSource = false, saveAnnotatedCopy = undefined, } = options;
     const errors = [];
     const onErrorHandler = (message, context, error) => {
         if (error && error instanceof RuntimeExecutionError) {
@@ -209,10 +211,10 @@ export async function renderScriptCustom(scriptData, outputPath, options, parseH
     catch (err) {
         throw new RenderError(`Error during component annotation: ${err}`, 'annotation');
     }
-    const componentLinks = visitor.getComponentCtxLinks();
-    const refdesVisitor = new RefdesAnnotationVisitor(true, scriptData, tokens, componentLinks);
-    await refdesVisitor.visitAsync(tree);
     if (inputPath && (updateSource || saveAnnotatedCopy !== undefined)) {
+        const componentLinks = visitor.getComponentCtxLinks();
+        const refdesVisitor = new RefdesAnnotationVisitor(true, scriptData, tokens, componentLinks);
+        await refdesVisitor.visitAsync(tree);
         let usePath = inputPath;
         if (saveAnnotatedCopy === true) {
             const dir = path.dirname(inputPath);
@@ -239,6 +241,14 @@ export async function renderScriptCustom(scriptData, outputPath, options, parseH
     if (errors.length === 0) {
         const { frameComponent } = visitor.applySheetFrameComponent();
         const { sequence, nets } = visitor.getGraph();
+        if (enableBom && bomOutputPath) {
+            const documentVariable = visitor.getScope().variables.get('document');
+            const bomConfig = documentVariable.bom;
+            const bomData = generateBom(bomConfig, visitor.getScope().getInstances());
+            const bomCsvOutput = generateBomCSV(bomData);
+            await saveBomOutputCsv(bomCsvOutput, bomOutputPath);
+            console.log('Generated BOM file', bomOutputPath);
+        }
         const tmpSequence = generateDebugSequenceAction(sequence).map(item => sequenceActionString(item));
         dumpData && writeFileSync(dumpDirectory + 'raw-sequence.txt', tmpSequence.join('\n'));
         try {
@@ -267,6 +277,15 @@ export async function renderScriptCustom(scriptData, outputPath, options, parseH
             try {
                 const { graph, containerFrames } = graphEngine.generateLayoutGraph(sequence, nets);
                 sheetFrames = layoutEngine.runLayout(graph, containerFrames, nets);
+                if (enableErc) {
+                    const ercResults = EvaluateERCRules(visitor, graph, nets);
+                    if (ercResults.length > 0) {
+                        console.log(`ERC found ${ercResults.length} items:`);
+                        ercResults.forEach((item, index) => {
+                            console.log(`${(index + 1).toString().padStart(3)}. line ${item.start.line}, column ${item.start.column}: ${item.type} - ${item.message}`);
+                        });
+                    }
+                }
             }
             catch (err) {
                 throw new RenderError(`Error during layout generation: ${err}`, 'layout');

package/dist/esm/layout.js

@@ -51,23 +51,23 @@ export class LayoutEngine {
         const sheetFrameObjects = sheetFrames.map(sheet => {
             const items = this.flattenFrameItems(sheet);
             const components = items.filter(item => item instanceof RenderComponent);
-            const wires = items.filter(item => item instanceof RenderWire);
+            const renderWires = items.filter(item => item instanceof RenderWire);
             const textObjects = items.filter(item => item instanceof RenderText);
             const frames = items.filter(item => item instanceof RenderFrame);
-            const wireGroups = new Map();
-            wires.forEach(wire => {
+            const renderWireGroups = new Map();
+            renderWires.forEach(wire => {
                 const { netName } = wire;
-                if (!wireGroups.has(netName)) {
-                    wireGroups.set(netName, []);
+                if (!renderWireGroups.has(netName)) {
+                    renderWireGroups.set(netName, []);
                 }
-                wireGroups.get(netName).push(wire);
+                renderWireGroups.get(netName).push(wire);
             });
-            const { junctions, mergedWires } = this.findJunctions(wireGroups, renderNets);
+            const { junctions, mergedWires } = this.findJunctions(renderWireGroups, renderNets);
             return {
                 frame: sheet,
                 frames,
                 components,
-                wires,
+                wires: renderWires,
                 textObjects,
                 junctions,
                 mergedWires
@@ -119,12 +119,12 @@ export class LayoutEngine {
         });
         return items;
     }
-    findJunctions(wireGroups, nets) {
+    findJunctions(renderWireGroups, nets) {
         const junctions = [];
         const mergedWires = [];
         const debugSegments = false;
-        for (const [netName, wires] of wireGroups) {
-            const allLines = wires.map(wire => {
+        for (const [netName, renderWires] of renderWireGroups) {
+            const allLines = renderWires.map(wire => {
                 return wire.points.map(pt => {
                     return {
                         x: wire.x.add(pt.x),
@@ -843,7 +843,7 @@ export class LayoutEngine {
             item.y = fromY.sub(pinPosition.y);
         }
         else if (item instanceof RenderWire) {
-            if (pin === 0) {
+            if (pin.getValue() === 0) {
                 item.x = fromX;
                 item.y = fromY;
             }
@@ -1017,12 +1017,14 @@ export class RenderWire extends RenderObject {
     points = [];
     netName;
     net;
-    constructor(net, x, y, segments) {
+    wire;
+    constructor(net, x, y, segments, wire) {
         super();
         this.net = net;
         this.x = x;
         this.y = y;
         this.segments = segments;
+        this.wire = wire;
         this.refreshPoints();
     }
     refreshPoints() {

package/dist/esm/main.js

@@ -21,7 +21,9 @@ export default async function main() {
         .option('-n, --dump-nets', 'Dump out net information')
         .option('-d, --dump-data', 'Dump data during parsing')
         .option('-s, --stats', 'Show stats during generation')
-        .option('-x, --skip-output', 'Skip output generation');
+        .option('-x, --skip-output', 'Skip output generation')
+        .option('-e, --erc', 'Enable ERC output')
+        .option('-b, --bom [output-path]', 'Generate Bill of Materials in csv format');
     program.addHelpText('before', figlet.textSync('circuitscript', {
         font: 'Small Slant'
     }));
@@ -34,6 +36,9 @@ export default async function main() {
     const watchFileChanges = options.watch;
     const dumpNets = options.dumpNets;
     const dumpData = options.dumpData;
+    const enableErc = options.erc;
+    const enableBom = options.bom !== undefined;
+    let bomOutputPath = options.bom;
     if (options.currentDirectory) {
         throw "Parameter not supported yet";
     }
@@ -72,10 +77,21 @@ export default async function main() {
     if (options.annotatedPath !== undefined) {
         saveAnnotatedCopyPath = options.annotatedPath;
     }
+    if (enableBom && (bomOutputPath === true || bomOutputPath === undefined)) {
+        if (inputFilePath) {
+            bomOutputPath = inputFilePath + '.bom.csv';
+        }
+        else {
+            bomOutputPath = 'output.bom.csv';
+        }
+    }
     const scriptOptions = {
         dumpNets,
         dumpData,
         showStats: options.stats,
+        enableErc,
+        enableBom,
+        bomOutputPath,
         environment: env,
         inputPath: inputFilePath,
         updateSource,

package/dist/esm/objects/ExecutionScope.js

@@ -165,6 +165,9 @@ export class ExecutionScope {
         const propertyTree = this.findPropertyKeyTree(visitor);
         lastHandler && lastHandler(propertyTree, value, valueCtx);
     }
+    getInstances() {
+        return Array.from(this.instances.values());
+    }
 }
 export var SequenceAction;
 (function (SequenceAction) {

package/dist/esm/objects/PinDefinition.js

@@ -28,10 +28,20 @@ export class PinId {
     }
     equals(other) {
         if (other instanceof PinId) {
-            return this.value === other.value;
+            return this.value === other.value
+                && this.getType() === other.getType();
         }
         return this.value === other;
     }
+    getHashValue() {
+        if (this.type === PinIdType.Int) {
+            return 'int-' + this.value;
+        }
+        else if (this.type === PinIdType.Str) {
+            return 'str-' + this.value;
+        }
+        return '';
+    }
     static from(value) {
         if (value instanceof NumericValue) {
             return new PinId(value.toNumber());

package/dist/esm/objects/types.js

@@ -20,9 +20,10 @@ export class AnyReference {
     found = false;
     name;
     trailers = [];
+    trailerIndex = -1;
     type;
     value;
-    parentValue;
+    rootValue;
     referenceName = 'AnyReference';
     constructor(refType) {
         if (refType.value instanceof AnyReference
@@ -32,9 +33,10 @@ export class AnyReference {
         this.found = refType.found;
         this.name = refType.name;
         this.trailers = refType.trailers;
+        this.trailerIndex = refType.trailerIndex;
         this.type = refType.type ?? ReferenceTypes.unknown;
         this.value = refType.value;
-        this.parentValue = refType.parentValue;
+        this.rootValue = refType.rootValue;
     }
     toString() {
         return `[${this.referenceName} name: ${this.name} trailers:${this.trailers} found: ${this.found}]`;
@@ -65,13 +67,13 @@ export class DeclaredReference extends AnyReference {
     referenceName = 'DeclaredReference';
     toDisplayString() {
         let returnValue = undefined;
-        if (this.parentValue) {
+        if (this.rootValue) {
             const trailersString = this.trailers.join(".");
             if (this.type === 'instance') {
-                returnValue = this.parentValue.parameters.get(trailersString);
+                returnValue = this.rootValue.parameters.get(trailersString);
             }
             else if (this.type === 'variable') {
-                returnValue = this.parentValue[trailersString];
+                returnValue = this.rootValue[trailersString];
             }
         }
         else {

package/dist/esm/rules-check/no-connect-on-connected-pin.js

@@ -0,0 +1,77 @@
+import { RenderItemType } from "../graph.js";
+import { ERC_Rules } from "./rules.js";
+export function RuleCheck_NoConnectOnConnectedPin(graph, nets) {
+    const allNodes = graph.nodes();
+    const items = [];
+    const netComponentPins = new Map();
+    const pinMapping = new Map();
+    const makeComponentPinHash = (instanceName, pin) => {
+        return instanceName + '-' + pin.getHashValue();
+    };
+    nets.forEach(item => {
+        const [component, pin, net] = item;
+        if (!netComponentPins.has(net)) {
+            netComponentPins.set(net, []);
+        }
+        const items = netComponentPins.get(net);
+        items.push([
+            component.instanceName,
+            pin
+        ]);
+        netComponentPins.set(net, items);
+        pinMapping.set(makeComponentPinHash(component.instanceName, pin), net);
+    });
+    allNodes.forEach(node => {
+        const nodeInfo = graph.node(node);
+        if (nodeInfo[0] === RenderItemType.Component) {
+            const { component } = nodeInfo[1];
+            if (component.hasParam('no_connect')) {
+                const instanceName = component.instanceName;
+                const edges = graph.nodeEdges(node);
+                const otherNodes = [];
+                edges.forEach(edge => {
+                    const edgeInfo = graph.edge(edge.v, edge.w);
+                    let targetComponentName;
+                    let targetPin;
+                    if (edge.v === instanceName) {
+                        otherNodes.push(edge.w);
+                        targetComponentName = edge.w;
+                        targetPin = edgeInfo[3];
+                    }
+                    else {
+                        targetComponentName = edge.v;
+                        targetPin = edgeInfo[1];
+                    }
+                    const componentPinHash = makeComponentPinHash(targetComponentName, targetPin);
+                    if (pinMapping.has(componentPinHash)) {
+                        const net = pinMapping.get(componentPinHash);
+                        const tmpNetComponentPins = netComponentPins.get(net);
+                        const remainingItems = tmpNetComponentPins.filter(item => {
+                            if (item[0] === instanceName) {
+                                return false;
+                            }
+                            else if (item[0] === targetComponentName
+                                && item[1].getHashValue() === targetPin.getHashValue()) {
+                                return false;
+                            }
+                            return true;
+                        });
+                        if (remainingItems.length > 0) {
+                            const targetInfo = graph.node(targetComponentName);
+                            const tmpComponent = targetInfo[1];
+                            items.push({
+                                type: ERC_Rules.NoConnectOnConnectedPin,
+                                instance: component,
+                                target: {
+                                    instance: tmpComponent.component,
+                                    pin: targetPin
+                                }
+                            });
+                        }
+                    }
+                });
+            }
+        }
+    });
+    return items;
+}

package/dist/esm/rules-check/rules.js

@@ -0,0 +1,70 @@
+import { RuleCheck_UnconnectedPinsWires } from "./unconnected-pins.js";
+import { RuleCheck_NoConnectOnConnectedPin } from "./no-connect-on-connected-pin.js";
+export var ERC_Rules;
+(function (ERC_Rules) {
+    ERC_Rules["UnconnectedPin"] = "UNCONNECTED-PIN";
+    ERC_Rules["UnconnectedWire"] = "UNCONNECTED-WIRE";
+    ERC_Rules["NoConnectOnConnectedPin"] = "NO-CONNECT-ON-CONNECTED-PIN";
+})(ERC_Rules || (ERC_Rules = {}));
+export function EvaluateERCRules(visitor, graph, nets) {
+    const ruleCheckItems = [];
+    const creationCtx = visitor.creationCtx;
+    ruleCheckItems.push(...RuleCheck_UnconnectedPinsWires(graph), ...RuleCheck_NoConnectOnConnectedPin(graph, nets));
+    const reportItems = [];
+    ruleCheckItems.forEach(item => {
+        const { type } = item;
+        switch (type) {
+            case ERC_Rules.UnconnectedPin:
+                {
+                    const instance = item.instance;
+                    const token = getComponentFirstCtxToken(instance);
+                    if (token) {
+                        reportItems.push({
+                            type,
+                            start: token,
+                            message: `Unconnected pin ${item.pin} for component`
+                        });
+                    }
+                }
+                break;
+            case ERC_Rules.UnconnectedWire:
+                {
+                    const wire = item.wire;
+                    if (creationCtx.has(wire)) {
+                        const tmpCtx = creationCtx.get(wire);
+                        const startToken = tmpCtx.start;
+                        reportItems.push({
+                            type,
+                            start: startToken,
+                            message: `Unconnected wire end`
+                        });
+                    }
+                }
+                break;
+            case ERC_Rules.NoConnectOnConnectedPin:
+                {
+                    const instance = item.instance;
+                    const token = getComponentFirstCtxToken(instance);
+                    if (token) {
+                        reportItems.push({
+                            type,
+                            start: token,
+                            message: `No connect on connected pin`
+                        });
+                    }
+                }
+                break;
+        }
+    });
+    const sortedReport = reportItems.toSorted((a, b) => {
+        return a.start.start - b.start.start;
+    });
+    return sortedReport;
+}
+function getComponentFirstCtxToken(instance) {
+    if (instance.ctxReferences.length > 0) {
+        const { ctx } = instance.ctxReferences[0];
+        return ctx.start;
+    }
+    return null;
+}

package/dist/esm/rules-check/unconnected-pins.js

@@ -0,0 +1,48 @@
+import { RenderItemType } from "../graph.js";
+import { ERC_Rules } from "./rules.js";
+export function RuleCheck_UnconnectedPinsWires(graph) {
+    const items = [];
+    const allNodes = graph.nodes();
+    allNodes.forEach(node => {
+        const nodeInfo = graph.node(node);
+        if (nodeInfo[0] === RenderItemType.Component) {
+            const { component } = nodeInfo[1];
+            const edges = graph.nodeEdges(node);
+            const instanceName = component.instanceName;
+            const connectedPins = [];
+            edges.forEach(edge => {
+                const edgeInfo = graph.edge(edge.v, edge.w);
+                let pin;
+                if (edge.v === instanceName) {
+                    pin = edgeInfo[1];
+                }
+                else if (edge.w === instanceName) {
+                    pin = edgeInfo[3];
+                }
+                connectedPins.push(pin.getHashValue());
+            });
+            const pinIds = Array.from(component.pins.keys());
+            pinIds.forEach(pinId => {
+                const hashValue = pinId.getHashValue();
+                if (connectedPins.indexOf(hashValue) === -1) {
+                    items.push({
+                        type: ERC_Rules.UnconnectedPin,
+                        instance: component,
+                        pin: pinId,
+                    });
+                }
+            });
+        }
+        else if (nodeInfo[0] === RenderItemType.Wire) {
+            const renderWire = nodeInfo[1];
+            const edges = graph.nodeEdges(node);
+            if (edges.length < 2) {
+                items.push({
+                    type: ERC_Rules.UnconnectedWire,
+                    wire: renderWire.wire,
+                });
+            }
+        }
+    });
+    return items;
+}