circuitscript 0.1.23 → 0.1.25

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;

package/dist/cjs/visitor.js

@@ -14,10 +14,12 @@ const utils_js_2 = require("./utils.js");
 const helpers_js_1 = require("./helpers.js");
 const Frame_js_1 = require("./objects/Frame.js");
 const ComponentAnnotater_js_1 = require("./ComponentAnnotater.js");
+const ComponentMatchConditions_js_1 = require("./ComponentMatchConditions.js");
 class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
     constructor() {
         super(...arguments);
         this.componentCreationIndex = 0;
+        this.creationCtx = new Map();
         this.visitKeyword_assignment_expr = (ctx) => {
             const id = ctx.ID().getText();
             const value = this.visitResult(ctx.data_expr());
@@ -542,7 +544,7 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             scope.triggerPropertyHandler(this, value, ctxValue);
             this.getScope().exitContext();
             this.getScope().exitContext();
-            if (value instanceof types_js_1.UndeclaredReference && (value.reference.parentValue === undefined
+            if (value instanceof types_js_1.UndeclaredReference && (value.reference.rootValue === undefined
                 && value.reference.value === undefined)) {
                 throw value.throwMessage();
             }
@@ -611,11 +613,11 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
                 componentCtx = ctxAssignmentExpr;
             }
             if (dataResult instanceof types_js_1.AnyReference) {
-                const { trailers = [], parentValue = null } = dataResult;
-                if (parentValue instanceof ClassComponent_js_1.ClassComponent
+                const { trailers = [], rootValue = null } = dataResult;
+                if (rootValue instanceof ClassComponent_js_1.ClassComponent
                     && trailers.length > 0
                     && trailers[0] === globals_js_1.ModuleContainsKeyword) {
-                    dataResult = parentValue;
+                    dataResult = rootValue;
                     this.placeModuleContains(dataResult);
                 }
             }
@@ -1011,7 +1013,8 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             const segments = wireAtomExpr.map(wireSegment => {
                 return this.visitResult(wireSegment);
             });
-            this.getExecutor().addWire(segments);
+            const newWire = this.getExecutor().addWire(segments);
+            this.creationCtx.set(newWire, ctx);
         };
         this.visitPoint_expr = (ctx) => {
             const ID = ctx.ID();
@@ -1199,6 +1202,119 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
                 }
             }
         };
+        this.visitPart_set_expr = (ctx) => {
+            const paramKeys = ctx.data_expr().map(ctx => {
+                return this.visitResult(ctx);
+            });
+            const partConditionTree = this.visitResult(ctx.part_match_block());
+            const flattenedTree = (0, ComponentMatchConditions_js_1.flattenConditionNodes)(partConditionTree);
+            const partConditions = (0, ComponentMatchConditions_js_1.extractPartConditions)(flattenedTree);
+            const instances = this.getScope().getInstances();
+            (0, ComponentMatchConditions_js_1.applyPartConditions)(instances, paramKeys, partConditions);
+        };
+        this.visitPart_match_block = (ctx) => {
+            const results = ctx.part_sub_expr().map(ctxExpr => {
+                return this.visitResult(ctxExpr);
+            });
+            this.setResult(ctx, results);
+        };
+        this.visitPart_sub_expr = (ctx) => {
+            const ctxForm1 = ctx.part_condition_expr();
+            const ctxForm2 = ctx.part_condition_key_only_expr();
+            const ctxForm3 = ctx.part_value_expr();
+            let result;
+            if (ctxForm1) {
+                result = this.visitResult(ctxForm1);
+            }
+            else if (ctxForm2) {
+                result = this.visitResult(ctxForm2);
+            }
+            else if (ctxForm3) {
+                result = this.visitResult(ctxForm3);
+            }
+            this.setResult(ctx, result);
+        };
+        this.visitPart_set_key = (ctx) => {
+            const ctxID = ctx.ID();
+            const ctxIntegerValue = ctx.INTEGER_VALUE();
+            const ctxNumericValue = ctx.NUMERIC_VALUE();
+            const ctxStringValue = ctx.STRING_VALUE();
+            let useType = '';
+            let useValue;
+            if (ctxID) {
+                useType = 'ID';
+                useValue = ctxID.getText();
+            }
+            else if (ctxIntegerValue) {
+                useType = 'number',
+                    useValue = Number(ctxIntegerValue.getText());
+            }
+            else if (ctxNumericValue) {
+                useType = 'NUMERIC_VALUE';
+                useValue = (0, ParamDefinition_js_1.numeric)(ctxNumericValue.getText());
+            }
+            else if (ctxStringValue) {
+                useType = 'STRING_VALUE';
+                useValue = this.prepareStringValue(ctxStringValue.getText());
+            }
+            this.setResult(ctx, {
+                type: useType,
+                value: useValue
+            });
+        };
+        this.visitPart_value_expr = (ctx) => {
+            const key = this.visitResult(ctx.part_set_key());
+            const values = ctx.data_expr().map(ctxData => {
+                return this.visitResult(ctxData);
+            });
+            this.setResult(ctx, { key, endValue: values });
+        };
+        this.visitPart_condition_expr = (ctx) => {
+            const allKeys = ctx._key_id.map(ctx => {
+                return this.visitResult(ctx);
+            });
+            const allValues = ctx._values.map(ctx => {
+                return this.visitResult(ctx);
+            });
+            let deepestChildren = [];
+            const ctxPartMatchBlock = ctx.part_match_block();
+            if (ctxPartMatchBlock) {
+                deepestChildren = this.visitResult(ctxPartMatchBlock);
+            }
+            let lastValue = undefined;
+            if (ctx._last_data.length > 0) {
+                lastValue = ctx._last_data.map(ctxData => {
+                    return this.visitResult(ctxData);
+                });
+            }
+            if (ctx._id_only) {
+                allKeys.push(this.visitResult(ctx._id_only));
+                allValues.push(undefined);
+            }
+            const reversedKeys = [...allKeys].reverse();
+            const reversedValues = [...allValues].reverse();
+            let tmpKeyValues;
+            reversedKeys.forEach((key, index) => {
+                const node = {
+                    key,
+                    values: (reversedValues[index] !== undefined) ? [reversedValues[index]] : undefined,
+                    children: (index === 0) ? deepestChildren : [tmpKeyValues],
+                };
+                if (index === 0 && lastValue !== undefined) {
+                    node.endValue = lastValue;
+                }
+                tmpKeyValues = node;
+            });
+            this.setResult(ctx, tmpKeyValues);
+        };
+        this.visitPart_condition_key_only_expr = (ctx) => {
+            const key = this.visitResult(ctx.part_set_key());
+            const children = this.visitResult(ctx.part_match_block());
+            this.setResult(ctx, {
+                key,
+                children,
+            });
+        };
         this.pinTypes = [
             PinTypes_js_1.PinTypes.Any,
             PinTypes_js_1.PinTypes.IO,

package/dist/esm/BaseVisitor.js

@@ -48,7 +48,9 @@ export class BaseVisitor extends CircuitScriptVisitor {
         scope.sequence.push([
             SequenceAction.At, scope.componentRoot, scope.currentPin
         ]);
-        scope.setVariable(GlobalDocumentName, {});
+        scope.setVariable(GlobalDocumentName, {
+            'bom': {},
+        });
         this.setupBuiltInFunctions(this.startingContext);
         this.executionStack = [this.startingContext];
         this.startingContext.resolveNet =
@@ -168,34 +170,39 @@ export class BaseVisitor extends CircuitScriptVisitor {
             sequenceParts.push(...[itemType, leftSideReference.name, rhsValue]);
         }
         else {
-            if (leftSideReference.parentValue instanceof ClassComponent) {
-                this.setInstanceParam(leftSideReference.parentValue, trailers, rhsValue);
-                this.log2(`assigned component param ${leftSideReference.parentValue} trailers: ${trailers} value: ${rhsValue}`);
-                sequenceParts.push(...['instance', [leftSideReference.parentValue, trailers], rhsValue]);
-                if (leftSideReference.parentValue.typeProp === ComponentTypes.net) {
-                    const net = this.getScope().getNet(leftSideReference.parentValue, new PinId(1));
+            if (leftSideReference.rootValue instanceof ClassComponent) {
+                this.setInstanceParam(leftSideReference.rootValue, trailers, rhsValue);
+                this.log2(`assigned component param ${leftSideReference.rootValue} trailers: ${trailers} value: ${rhsValue}`);
+                sequenceParts.push(...['instance', [leftSideReference.rootValue, trailers], rhsValue]);
+                if (leftSideReference.rootValue.typeProp === ComponentTypes.net) {
+                    const net = this.getScope().getNet(leftSideReference.rootValue, new PinId(1));
                     if (net) {
                         const trailerValue = trailers.join(".");
                         net.params.set(trailerValue, rhsValue);
                     }
                 }
             }
-            else if (leftSideReference.parentValue instanceof Object) {
+            else if (leftSideReference.rootValue instanceof Object) {
                 if (Array.isArray(trailers[0]) && trailers[0][0] === TrailerArrayIndex) {
-                    if (Array.isArray(leftSideReference.parentValue)) {
+                    if (Array.isArray(leftSideReference.rootValue)) {
                         const arrayIndexValue = trailers[0][1];
-                        leftSideReference.parentValue[arrayIndexValue] = rhsValue;
-                        this.log2(`assigned array index ${leftSideReference.parentValue} index: ${arrayIndexValue} value: ${rhsValue}`);
+                        leftSideReference.rootValue[arrayIndexValue] = rhsValue;
+                        this.log2(`assigned array index ${leftSideReference.rootValue} index: ${arrayIndexValue} value: ${rhsValue}`);
                     }
                     else {
                         this.throwWithContext(lhsCtx, "Invalid array");
                     }
                 }
                 else {
-                    leftSideReference.parentValue[trailers.join('.')] = rhsValue;
-                    this.log2(`assigned object ${leftSideReference.parentValue} trailers: ${trailers} value: ${rhsValue}`);
+                    let expandedValue = leftSideReference.rootValue;
+                    trailers.slice(0, -1).forEach(trailer => {
+                        expandedValue = expandedValue[trailer];
+                    });
+                    const lastTrailer = trailers.slice(-1)[0];
+                    expandedValue[lastTrailer] = rhsValue;
+                    this.log2(`assigned object ${leftSideReference.rootValue} trailers: ${trailers} value: ${rhsValue}`);
                 }
-                sequenceParts.push(...['variable', [leftSideReference.parentValue, trailers], rhsValue]);
+                sequenceParts.push(...['variable', [leftSideReference.rootValue, trailers], rhsValue]);
             }
         }
         if (sequenceParts.length > 0) {
@@ -268,7 +275,7 @@ export class BaseVisitor extends CircuitScriptVisitor {
         const reference = this.visitResult(ctx);
         const { trailers = [] } = reference;
         const undefinedParentWithTrailers = trailers.length > 0
-            && reference.parentValue === undefined;
+            && reference.rootValue === undefined;
         if (undefinedParentWithTrailers) {
             this.throwWithContext(ctx, 'Undefined reference: ' + reference.name + '.' + trailers.join('.'));
         }
@@ -282,7 +289,12 @@ export class BaseVisitor extends CircuitScriptVisitor {
         let nextReference;
         if (ctxID) {
             reference.trailers.push(ctxID.getText());
-            nextReference = this.getExecutor().resolveTrailers(reference.type, useValue, reference.trailers);
+            const useRootValue = reference.rootValue ?? reference.value;
+            const useTrailerIndex = reference.trailerIndex ?? 0;
+            nextReference = this.getExecutor().resolveTrailers(reference.type, useRootValue, reference.trailers);
+            nextReference.name =
+                [reference.name,
+                    ...reference.trailers.slice(useTrailerIndex)].join('.');
         }
         else if (ctxDataExpr) {
             const arrayIndex = this.visitResult(ctxDataExpr);
@@ -296,7 +308,7 @@ export class BaseVisitor extends CircuitScriptVisitor {
                     type: refType,
                     value: foundValue,
                     trailers: [[TrailerArrayIndex, arrayIndexValue]],
-                    parentValue: useValue
+                    rootValue: useValue
                 });
             }
         }
@@ -315,15 +327,15 @@ export class BaseVisitor extends CircuitScriptVisitor {
             });
         }
         else {
+            this.log('resolve variable ctx: ' + ctx.getText(), 'atomId', atomId);
             currentReference = executor.resolveVariable(this.executionStack, atomId);
+            this.log('reference:', currentReference.name, 'found:', currentReference.found);
         }
         if (currentReference !== undefined && currentReference.found) {
-            const trailersLength = ctx.trailer_expr2().length;
-            for (let i = 0; i < trailersLength; i++) {
-                const trailerCtx = ctx.trailer_expr2(i);
-                this.setResult(trailerCtx, currentReference);
-                currentReference = this.visitResult(trailerCtx);
-            }
+            ctx.trailer_expr2().forEach(ctxTrailer => {
+                this.setResult(ctxTrailer, currentReference);
+                currentReference = this.visitResult(ctxTrailer);
+            });
         }
         this.setResult(ctx, currentReference);
         this.log2('atom resolved: ' + ctx.getText() + ' -> ' + currentReference);

package/dist/esm/BomGeneration.js

@@ -0,0 +1,137 @@
+import * as csv from '@fast-csv/format';
+import * as fs from 'fs';
+import { NumericValue } from "./objects/ParamDefinition.js";
+const TypeSortOrder = {
+    "res": 1,
+    "cap": 2,
+    "ind": 3,
+    "diode": 9,
+    "ic": 10,
+    "conn": 20,
+};
+export function generateBom(bomConfig, instances) {
+    const bomComponents = extractComponentValuesForBom(bomConfig, instances);
+    const tmpGroupedComponents = groupComponents(bomConfig, bomComponents);
+    const groupedBom = [];
+    tmpGroupedComponents.forEach(value => {
+        groupedBom.push({
+            ...value.items[0],
+            refdes: value.allRefdes.join(', ')
+        });
+    });
+    const sortedGroupedBom = groupedBom.toSorted((a, b) => {
+        const typeSortA = TypeSortOrder[a['.type']] ?? 100;
+        const typeSortB = TypeSortOrder[b['.type']] ?? 100;
+        return typeSortA - typeSortB;
+    });
+    return sortedGroupedBom;
+}
+export function groupComponents(bomConfig, bomComponents) {
+    const { group_by } = bomConfig;
+    const grouped = new Map();
+    bomComponents.forEach(row => {
+        const groupKeyParts = {};
+        group_by.forEach(paramKey => {
+            groupKeyParts[paramKey] = row[paramKey];
+        });
+        const groupKey = JSON.stringify(groupKeyParts);
+        if (!grouped.has(groupKey)) {
+            grouped.set(groupKey, {
+                allRefdes: [],
+                items: [],
+            });
+        }
+        const entry = grouped.get(groupKey);
+        entry.items.push(row);
+        entry.allRefdes.push(row.refdes);
+        grouped.set(groupKey, entry);
+    });
+    return grouped;
+}
+function extractComponentValuesForBom(bomConfig, instances) {
+    const { columns = [] } = bomConfig;
+    const resultRows = [];
+    instances.forEach(instance => {
+        if (instance.assignedRefDes !== null) {
+            const row = {
+                '.type': instance.typeProp,
+            };
+            columns.forEach(paramKey => {
+                let useValue = '';
+                if (paramKey === 'refdes') {
+                    useValue = instance.assignedRefDes;
+                }
+                else {
+                    if (instance.hasParam(paramKey)) {
+                        useValue = instance.getParam(paramKey);
+                        if (typeof useValue === 'string') {
+                            useValue = resolveValuesInTemplate(instance, useValue);
+                        }
+                        else if (useValue instanceof NumericValue) {
+                            useValue = useValue.toDisplayString();
+                        }
+                    }
+                }
+                row[paramKey] = useValue;
+            });
+            resultRows.push(row);
+        }
+    });
+    return resultRows;
+}
+function resolveValuesInTemplate(instance, templateString) {
+    return templateString.replace(/\{(\w+)\}/g, (match, paramName) => {
+        if (instance.hasParam(paramName)) {
+            const paramValue = instance.getParam(paramName);
+            if (paramValue instanceof NumericValue) {
+                return paramValue.toDisplayString();
+            }
+            return instance.getParam(paramName);
+        }
+        return match;
+    });
+}
+export function generateBomCSV(bomData) {
+    const useHeaders = [];
+    const rows = [];
+    if (bomData.length > 0) {
+        const [firstRow] = bomData;
+        for (const key in firstRow) {
+            if (key.startsWith('.')) {
+                continue;
+            }
+            const useKey = key[0].toUpperCase() + key.substring(1);
+            useHeaders.push(useKey);
+        }
+    }
+    rows.push(useHeaders);
+    const keys = [];
+    if (bomData.length > 0) {
+        for (const key in bomData[0]) {
+            if (key.startsWith('.')) {
+                continue;
+            }
+            keys.push(key);
+        }
+    }
+    bomData.forEach(row => {
+        const result = keys.map(key => {
+            return row[key];
+        });
+        rows.push(result);
+    });
+    return rows;
+}
+export async function saveBomOutputCsv(bomCsvOutput, filePath) {
+    return new Promise(resolve => {
+        const outputStream = fs.createWriteStream(filePath);
+        const csvStream = csv.format();
+        csvStream.pipe(outputStream).on("finish", () => {
+            resolve();
+        });
+        bomCsvOutput.forEach(row => {
+            csvStream.write(row);
+        });
+        csvStream.end();
+    });
+}

package/dist/esm/ComponentMatchConditions.js

@@ -0,0 +1,109 @@
+import { NumericValue } from "./objects/ParamDefinition.js";
+import { TypeProps } from "./objects/types.js";
+export function flattenConditionNodes(conditionNodes, level = 0) {
+    const conditionBranches = [];
+    conditionNodes.forEach(node => {
+        const { key, values, children = [], endValue = [] } = node;
+        const firstCondition = {
+            key, values, endValue
+        };
+        if (children.length > 0) {
+            const nestedBranches = flattenConditionNodes(children, level + 1);
+            nestedBranches.forEach(tmpCondition => {
+                if (values === undefined) {
+                    const modifiedCondition = {
+                        ...firstCondition,
+                        values: [tmpCondition[0].key.value],
+                        endValue: tmpCondition[0].endValue
+                    };
+                    conditionBranches.push([
+                        modifiedCondition,
+                        ...tmpCondition.slice(1)
+                    ]);
+                }
+                else {
+                    conditionBranches.push([
+                        firstCondition,
+                        ...tmpCondition
+                    ]);
+                }
+            });
+        }
+        else {
+            conditionBranches.push([firstCondition]);
+        }
+    });
+    return conditionBranches;
+}
+export function extractPartConditions(conditionBranches) {
+    const partConditions = conditionBranches.map(branch => {
+        const lastNode = branch[branch.length - 1];
+        const { endValue } = lastNode;
+        const conditions = [];
+        branch.forEach((node, index) => {
+            conditions.push({
+                key: node.key,
+                values: node.values
+            });
+        });
+        return {
+            endValue,
+            conditions
+        };
+    });
+    return partConditions;
+}
+export function partMatchesConditions(instance, partConditions) {
+    for (let i = 0; i < partConditions.length; i++) {
+        const { endValue, conditions } = partConditions[i];
+        const didNotMatch = conditions.some(condition => {
+            const { key, values } = condition;
+            let useKey = '';
+            if (key.type === 'ID') {
+                useKey = key.value;
+            }
+            else {
+                console.log('key type not supported', key);
+                return true;
+            }
+            if (useKey === 'type') {
+                return (instance.typeProp !== values[0]);
+            }
+            else {
+                if (!instance.hasParam(useKey)) {
+                    return true;
+                }
+                else {
+                    const paramValue = instance.getParam(useKey);
+                    const compareValue = values[0];
+                    if (typeof compareValue === "string") {
+                        return (compareValue !== paramValue);
+                    }
+                    else if (compareValue instanceof NumericValue) {
+                        return !compareValue.eq(paramValue);
+                    }
+                    else if (typeof compareValue === 'number') {
+                        return compareValue !== paramValue;
+                    }
+                }
+            }
+        });
+        if (didNotMatch === false) {
+            return endValue;
+        }
+    }
+}
+export function applyPartConditions(instances, paramKeys, partConditions) {
+    instances.forEach(item => {
+        if (item.typeProp !== TypeProps.Graphic) {
+            const matchedResult = partMatchesConditions(item, partConditions);
+            if (matchedResult !== undefined) {
+                paramKeys.forEach((paramKey, index) => {
+                    if (matchedResult[index] !== undefined) {
+                        item.setParam(paramKey, matchedResult[index]);
+                    }
+                });
+            }
+        }
+    });
+}