circuitscript 0.1.23 → 0.1.24

package/dist/cjs/builtinMethods.js

@@ -166,7 +166,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/cjs/execute.js

@@ -373,9 +373,9 @@ 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_js_1.Net(this.netNamespace, this.getUniqueNetName());
-            this.scope.setNet(component, pinId, tmpNet);
+            this.scope.setNet(component, usePinId, tmpNet);
         }
         this.scope.clearActive();
         if (addSequence) {
@@ -497,7 +497,9 @@ class ExecutionContext {
             const { start_point: [component, pin, wireId] } = stackRef;
             this.atComponent(component, pin, { addSequence: true });
             if (wireId !== -1) {
-                this.scope.sequence.push([ExecutionScope_js_1.SequenceAction.WireJump, wireId, 1]);
+                const wireObject = this.scope.wires[wireId];
+                this.scope.sequence.push([ExecutionScope_js_1.SequenceAction.WireJump,
+                    wireId, PinDefinition_js_1.PinId.from(1), wireObject]);
             }
         }
         else if (blockType === globals_js_1.BlockTypes.Join || blockType === globals_js_1.BlockTypes.Parallel) {
@@ -623,7 +625,7 @@ class ExecutionContext {
                         type: isVariable ? globals_js_1.ReferenceTypes.variable
                             : globals_js_1.ReferenceTypes.instance,
                         found: (tmpReference.value !== undefined),
-                        parentValue: tmpReference.parentValue,
+                        rootValue: tmpReference.rootValue,
                         value: tmpReference.value,
                         name: idName,
                         trailers,
@@ -637,16 +639,19 @@ 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 === globals_js_1.ReferenceTypes.variable) {
-                useValue = parentValue[trailersPath];
+                useValue = rootValue;
+                trailers.forEach(trailerPath => {
+                    useValue = useValue[trailerPath];
+                });
             }
             else if (type === globals_js_1.ReferenceTypes.instance) {
-                const tmpComponent = parentValue;
+                const tmpComponent = rootValue;
                 if (tmpComponent.typeProp === globals_js_1.ComponentTypes.net) {
                     const usedNet = this.scope.getNet(tmpComponent, new PinDefinition_js_1.PinId(1));
                     if (usedNet) {
@@ -655,20 +660,21 @@ 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 types_js_1.AnyReference({
             found,
             type: type,
-            parentValue,
+            rootValue,
             trailers,
+            trailerIndex: trailers.length,
             value: useValue,
         });
     }
@@ -769,13 +775,16 @@ class ExecutionContext {
         childScope.sequence.forEach(sequenceAction => {
             const [action] = sequenceAction;
             if (action === ExecutionScope_js_1.SequenceAction.Wire) {
-                const [, innerWireId, segments] = sequenceAction;
-                this.scope.sequence.push([ExecutionScope_js_1.SequenceAction.Wire, wireIdOffset + innerWireId, segments]);
+                const [, innerWireId, segments, wire] = sequenceAction;
+                this.scope.sequence.push([ExecutionScope_js_1.SequenceAction.Wire, wireIdOffset + innerWireId,
+                    segments, wire]);
                 this.scope.wires.push(new Wire_js_1.Wire(segments));
             }
             else if (action === ExecutionScope_js_1.SequenceAction.WireJump) {
                 const jumpWireId = wireIdOffset + sequenceAction[1];
-                this.scope.sequence.push([ExecutionScope_js_1.SequenceAction.WireJump, jumpWireId, 1]);
+                const wireObject = this.scope.wires[jumpWireId];
+                this.scope.sequence.push([ExecutionScope_js_1.SequenceAction.WireJump, jumpWireId,
+                    PinDefinition_js_1.PinId.from(1), wireObject]);
             }
             else if (action === ExecutionScope_js_1.SequenceAction.At || action === ExecutionScope_js_1.SequenceAction.To) {
                 this.scope.sequence.push(sequenceAction);
@@ -823,7 +832,8 @@ class ExecutionContext {
             };
         });
         const wireId = this.scope.wires.length;
-        this.scope.wires.push(new Wire_js_1.Wire(tmp));
+        const newWire = new Wire_js_1.Wire(tmp);
+        this.scope.wires.push(newWire);
         const output = [];
         segments.forEach(item => {
             const tmpArray = item.map(item2 => {
@@ -838,12 +848,13 @@ class ExecutionContext {
         });
         this.log('add wire: ', output.join("|"));
         this.scope.setActive(ExecutionScope_js_1.ActiveObject.Wire, wireId);
-        this.scope.sequence.push([ExecutionScope_js_1.SequenceAction.Wire, wireId, tmp]);
+        this.scope.sequence.push([ExecutionScope_js_1.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/cjs/graph.js

@@ -106,8 +106,9 @@ class NetGraph {
                     break;
                 }
                 case ExecutionScope_js_1.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) {
@@ -123,15 +124,15 @@ class NetGraph {
                             useNet = prevNodeItem.net;
                         }
                     }
-                    const wire = new layout_js_1.RenderWire(useNet, (0, ParamDefinition_js_1.numeric)(0), (0, ParamDefinition_js_1.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 layout_js_1.RenderWire(useNet, (0, ParamDefinition_js_1.numeric)(0), (0, ParamDefinition_js_1.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, PinDefinition_js_1.PinId.from(0), index));
                     previousNode = wireName;
-                    previousPin = 1;
+                    previousPin = PinDefinition_js_1.PinId.from(1);
                     const wireSegmentsInfo = wireSegments.map(item => {
                         const tmp = {
                             direction: item.direction,
@@ -165,7 +166,7 @@ class NetGraph {
                         wirePin = sequenceStep[2];
                     }
                     previousNode = wireName;
-                    previousPin = wirePin;
+                    previousPin = PinDefinition_js_1.PinId.from(wirePin);
                     break;
                 }
                 case ExecutionScope_js_1.SequenceAction.Frame: {

package/dist/cjs/helpers.js

@@ -25,6 +25,8 @@ const big_js_1 = __importDefault(require("big.js"));
 const logger_js_1 = require("./logger.js");
 const graph_js_1 = require("./graph.js");
 const RefdesAnnotationVisitor_js_1 = require("./RefdesAnnotationVisitor.js");
+const rules_js_1 = require("./rules-check/rules.js");
+const BomGeneration_js_1 = require("./BomGeneration.js");
 var JSModuleType;
 (function (JSModuleType) {
     JSModuleType["CommonJs"] = "cjs";
@@ -166,7 +168,7 @@ async function renderScript(scriptData, outputPath, options) {
 }
 exports.renderScript = renderScript;
 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 utils_js_1.RuntimeExecutionError) {
@@ -220,10 +222,10 @@ async function renderScriptCustom(scriptData, outputPath, options, parseHandlers
     catch (err) {
         throw new utils_js_1.RenderError(`Error during component annotation: ${err}`, 'annotation');
     }
-    const componentLinks = visitor.getComponentCtxLinks();
-    const refdesVisitor = new RefdesAnnotationVisitor_js_1.RefdesAnnotationVisitor(true, scriptData, tokens, componentLinks);
-    await refdesVisitor.visitAsync(tree);
     if (inputPath && (updateSource || saveAnnotatedCopy !== undefined)) {
+        const componentLinks = visitor.getComponentCtxLinks();
+        const refdesVisitor = new RefdesAnnotationVisitor_js_1.RefdesAnnotationVisitor(true, scriptData, tokens, componentLinks);
+        await refdesVisitor.visitAsync(tree);
         let usePath = inputPath;
         if (saveAnnotatedCopy === true) {
             const dir = path_1.default.dirname(inputPath);
@@ -250,6 +252,14 @@ async function renderScriptCustom(scriptData, outputPath, options, parseHandlers
     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 = (0, BomGeneration_js_1.generateBom)(bomConfig, visitor.getScope().getInstances());
+            const bomCsvOutput = (0, BomGeneration_js_1.generateBomCSV)(bomData);
+            await (0, BomGeneration_js_1.saveBomOutputCsv)(bomCsvOutput, bomOutputPath);
+            console.log('Generated BOM file', bomOutputPath);
+        }
         const tmpSequence = (0, utils_js_1.generateDebugSequenceAction)(sequence).map(item => (0, utils_js_1.sequenceActionString)(item));
         dumpData && (0, fs_1.writeFileSync)(dumpDirectory + 'raw-sequence.txt', tmpSequence.join('\n'));
         try {
@@ -278,6 +288,15 @@ async function renderScriptCustom(scriptData, outputPath, options, parseHandlers
             try {
                 const { graph, containerFrames } = graphEngine.generateLayoutGraph(sequence, nets);
                 sheetFrames = layoutEngine.runLayout(graph, containerFrames, nets);
+                if (enableErc) {
+                    const ercResults = (0, rules_js_1.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 utils_js_1.RenderError(`Error during layout generation: ${err}`, 'layout');

package/dist/cjs/layout.js

@@ -56,23 +56,23 @@ 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
@@ -124,12 +124,12 @@ 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),
@@ -848,7 +848,7 @@ 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;
             }
@@ -1023,7 +1023,7 @@ class RenderObject {
 }
 exports.RenderObject = RenderObject;
 class RenderWire extends RenderObject {
-    constructor(net, x, y, segments) {
+    constructor(net, x, y, segments, wire) {
         super();
         this.segments = [];
         this.points = [];
@@ -1031,6 +1031,7 @@ class RenderWire extends RenderObject {
         this.x = x;
         this.y = y;
         this.segments = segments;
+        this.wire = wire;
         this.refreshPoints();
     }
     refreshPoints() {

package/dist/cjs/main.js

@@ -26,7 +26,9 @@ 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');
     commander_1.program.addHelpText('before', figlet_1.default.textSync('circuitscript', {
         font: 'Small Slant'
     }));
@@ -39,6 +41,9 @@ 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";
     }
@@ -77,10 +82,21 @@ 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/cjs/objects/ExecutionScope.js

@@ -166,6 +166,9 @@ class ExecutionScope {
         const propertyTree = this.findPropertyKeyTree(visitor);
         lastHandler && lastHandler(propertyTree, value, valueCtx);
     }
+    getInstances() {
+        return Array.from(this.instances.values());
+    }
 }
 exports.ExecutionScope = ExecutionScope;
 ExecutionScope.scopeId = 0;

package/dist/cjs/objects/PinDefinition.js

@@ -29,10 +29,20 @@ 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 ParamDefinition_js_1.NumericValue) {
             return new PinId(value.toNumber());

package/dist/cjs/objects/types.js

@@ -20,6 +20,7 @@ class AnyReference {
     constructor(refType) {
         this.found = false;
         this.trailers = [];
+        this.trailerIndex = -1;
         this.referenceName = 'AnyReference';
         if (refType.value instanceof AnyReference
             && refType.value.type !== globals_js_1.ReferenceTypes.function) {
@@ -28,9 +29,10 @@ class AnyReference {
         this.found = refType.found;
         this.name = refType.name;
         this.trailers = refType.trailers;
+        this.trailerIndex = refType.trailerIndex;
         this.type = refType.type ?? globals_js_1.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 @@ class DeclaredReference extends AnyReference {
     }
     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/cjs/rules-check/no-connect-on-connected-pin.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuleCheck_NoConnectOnConnectedPin = void 0;
+const graph_js_1 = require("../graph.js");
+const rules_js_1 = require("./rules.js");
+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] === graph_js_1.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: rules_js_1.ERC_Rules.NoConnectOnConnectedPin,
+                                instance: component,
+                                target: {
+                                    instance: tmpComponent.component,
+                                    pin: targetPin
+                                }
+                            });
+                        }
+                    }
+                });
+            }
+        }
+    });
+    return items;
+}
+exports.RuleCheck_NoConnectOnConnectedPin = RuleCheck_NoConnectOnConnectedPin;

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

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvaluateERCRules = exports.ERC_Rules = void 0;
+const unconnected_pins_js_1 = require("./unconnected-pins.js");
+const no_connect_on_connected_pin_js_1 = require("./no-connect-on-connected-pin.js");
+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 || (exports.ERC_Rules = ERC_Rules = {}));
+function EvaluateERCRules(visitor, graph, nets) {
+    const ruleCheckItems = [];
+    const creationCtx = visitor.creationCtx;
+    ruleCheckItems.push(...(0, unconnected_pins_js_1.RuleCheck_UnconnectedPinsWires)(graph), ...(0, no_connect_on_connected_pin_js_1.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;
+}
+exports.EvaluateERCRules = EvaluateERCRules;
+function getComponentFirstCtxToken(instance) {
+    if (instance.ctxReferences.length > 0) {
+        const { ctx } = instance.ctxReferences[0];
+        return ctx.start;
+    }
+    return null;
+}

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

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuleCheck_UnconnectedPinsWires = void 0;
+const graph_js_1 = require("../graph.js");
+const rules_js_1 = require("./rules.js");
+function RuleCheck_UnconnectedPinsWires(graph) {
+    const items = [];
+    const allNodes = graph.nodes();
+    allNodes.forEach(node => {
+        const nodeInfo = graph.node(node);
+        if (nodeInfo[0] === graph_js_1.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: rules_js_1.ERC_Rules.UnconnectedPin,
+                        instance: component,
+                        pin: pinId,
+                    });
+                }
+            });
+        }
+        else if (nodeInfo[0] === graph_js_1.RenderItemType.Wire) {
+            const renderWire = nodeInfo[1];
+            const edges = graph.nodeEdges(node);
+            if (edges.length < 2) {
+                items.push({
+                    type: rules_js_1.ERC_Rules.UnconnectedWire,
+                    wire: renderWire.wire,
+                });
+            }
+        }
+    });
+    return items;
+}
+exports.RuleCheck_UnconnectedPinsWires = RuleCheck_UnconnectedPinsWires;