circuitscript 0.1.23 → 0.1.24

package/dist/cjs/BaseVisitor.js

@@ -89,34 +89,39 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.CircuitScriptVisitor {
                 sequenceParts.push(...[itemType, leftSideReference.name, rhsValue]);
             }
             else {
-                if (leftSideReference.parentValue instanceof ClassComponent_js_1.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 === globals_js_1.ComponentTypes.net) {
-                        const net = this.getScope().getNet(leftSideReference.parentValue, new PinDefinition_js_1.PinId(1));
+                if (leftSideReference.rootValue instanceof ClassComponent_js_1.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 === globals_js_1.ComponentTypes.net) {
+                        const net = this.getScope().getNet(leftSideReference.rootValue, new PinDefinition_js_1.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] === globals_js_1.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) {
@@ -189,7 +194,12 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.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);
@@ -203,7 +213,7 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.CircuitScriptVisitor {
                         type: refType,
                         value: foundValue,
                         trailers: [[globals_js_1.TrailerArrayIndex, arrayIndexValue]],
-                        parentValue: useValue
+                        rootValue: useValue
                     });
                 }
             }
@@ -222,15 +232,15 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.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);
@@ -425,7 +435,9 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.CircuitScriptVisitor {
         scope.sequence.push([
             ExecutionScope_js_1.SequenceAction.At, scope.componentRoot, scope.currentPin
         ]);
-        scope.setVariable(globals_js_1.GlobalDocumentName, {});
+        scope.setVariable(globals_js_1.GlobalDocumentName, {
+            'bom': {},
+        });
         this.setupBuiltInFunctions(this.startingContext);
         this.executionStack = [this.startingContext];
         this.startingContext.resolveNet =
@@ -503,7 +515,7 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.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('.'));
         }

package/dist/cjs/BomGeneration.js

@@ -0,0 +1,167 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveBomOutputCsv = exports.generateBomCSV = exports.groupComponents = exports.generateBom = void 0;
+const csv = __importStar(require("@fast-csv/format"));
+const fs = __importStar(require("fs"));
+const ParamDefinition_js_1 = require("./objects/ParamDefinition.js");
+const TypeSortOrder = {
+    "res": 1,
+    "cap": 2,
+    "ind": 3,
+    "diode": 9,
+    "ic": 10,
+    "conn": 20,
+};
+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;
+}
+exports.generateBom = generateBom;
+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;
+}
+exports.groupComponents = groupComponents;
+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 ParamDefinition_js_1.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 ParamDefinition_js_1.NumericValue) {
+                return paramValue.toDisplayString();
+            }
+            return instance.getParam(paramName);
+        }
+        return match;
+    });
+}
+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;
+}
+exports.generateBomCSV = generateBomCSV;
+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();
+    });
+}
+exports.saveBomOutputCsv = saveBomOutputCsv;

package/dist/cjs/ComponentMatchConditions.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyPartConditions = exports.partMatchesConditions = exports.extractPartConditions = exports.flattenConditionNodes = void 0;
+const ParamDefinition_js_1 = require("./objects/ParamDefinition.js");
+const types_js_1 = require("./objects/types.js");
+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;
+}
+exports.flattenConditionNodes = flattenConditionNodes;
+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;
+}
+exports.extractPartConditions = extractPartConditions;
+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 ParamDefinition_js_1.NumericValue) {
+                        return !compareValue.eq(paramValue);
+                    }
+                    else if (typeof compareValue === 'number') {
+                        return compareValue !== paramValue;
+                    }
+                }
+            }
+        });
+        if (didNotMatch === false) {
+            return endValue;
+        }
+    }
+}
+exports.partMatchesConditions = partMatchesConditions;
+function applyPartConditions(instances, paramKeys, partConditions) {
+    instances.forEach(item => {
+        if (item.typeProp !== types_js_1.TypeProps.Graphic) {
+            const matchedResult = partMatchesConditions(item, partConditions);
+            if (matchedResult !== undefined) {
+                paramKeys.forEach((paramKey, index) => {
+                    if (matchedResult[index] !== undefined) {
+                        item.setParam(paramKey, matchedResult[index]);
+                    }
+                });
+            }
+        }
+    });
+}
+exports.applyPartConditions = applyPartConditions;