circuitscript 0.1.14 → 0.1.16

package/dist/cjs/builtinMethods.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.linkBuiltInMethods = exports.buildInMethodNamesList = void 0;
 const big_js_1 = __importDefault(require("big.js"));
 const ParamDefinition_js_1 = require("./objects/ParamDefinition.js");
+const types_js_1 = require("./objects/types.js");
 const utils_js_1 = require("./utils.js");
 const builtInMethods = [
     ['enumerate', enumerate],
@@ -151,8 +152,17 @@ function toString(obj) {
     else if (obj instanceof ParamDefinition_js_1.NumericValue) {
         return obj.toBigNumber().toString();
     }
+    else if (obj instanceof types_js_1.CFunctionEntry) {
+        return obj.toString();
+    }
     else {
-        if (obj.toDisplayString) {
+        if (obj === undefined) {
+            return 'undefined';
+        }
+        else if (obj === null) {
+            return 'null';
+        }
+        else if (obj.toDisplayString) {
             return obj.toDisplayString();
         }
         else if (obj.toString) {

package/dist/cjs/execute.js

@@ -21,7 +21,7 @@ class ExecutionContext {
         this.stopFurtherExpressions = false;
         this.returnValue = null;
         this.silent = false;
-        this.__functionCache = {};
+        this.__functionCache = new Map();
         this.componentAngleFollowsWire = true;
         this.warnings = [];
         this.name = name;
@@ -533,9 +533,9 @@ class ExecutionContext {
     getBreakContext() {
         return this.scope.breakStack[this.scope.breakStack.length - 1];
     }
-    createFunction(functionName, __runFunc) {
-        this.scope.functions.set(functionName, __runFunc);
-        this.__functionCache[functionName] = __runFunc;
+    createFunction(functionName, __runFunc, source, uniqueId) {
+        this.scope.functions.set(functionName, new types_js_1.CFunctionEntry(functionName, __runFunc, source, uniqueId));
+        this.__functionCache.set(functionName, __runFunc);
         this.log(`defined new function '${functionName}'`);
     }
     hasFunction(functionName) {
@@ -604,12 +604,17 @@ class ExecutionContext {
                     }
                 }
                 else {
-                    useValue = parentValue.parameters.get(trailersPath);
+                    useValue = parentValue
+                        .parameters.get(trailersPath);
                 }
             }
         }
+        let found = false;
+        if (parentValue !== undefined && useValue !== undefined) {
+            found = true;
+        }
         return new types_js_1.AnyReference({
-            found: true,
+            found,
             type: type,
             parentValue,
             trailers,
@@ -618,26 +623,28 @@ class ExecutionContext {
     }
     callFunction(functionName, functionParams, executionStack, netNamespace) {
         let __runFunc = null;
-        if (this.__functionCache[functionName] === undefined) {
+        if (!this.__functionCache.has(functionName)) {
             if (this.hasFunction(functionName)) {
-                __runFunc = this.getFunction(functionName);
+                const entry = this.getFunction(functionName);
+                __runFunc = entry.execute;
             }
             if (__runFunc === null) {
                 this.log(`searching for function ${functionName} in upper context`);
                 const tmpResolveResult = this.resolveVariable(executionStack, functionName);
                 if (tmpResolveResult.found) {
-                    __runFunc = tmpResolveResult.value;
+                    const entry = tmpResolveResult.value;
+                    __runFunc = entry.execute;
                 }
                 else {
                     throw `Invalid function ${functionName}`;
                 }
             }
             this.log('save function to cache:', functionName);
-            this.__functionCache[functionName] = __runFunc;
+            this.__functionCache.set(functionName, __runFunc);
         }
         else {
             this.log('found function in cache:', functionName);
-            __runFunc = this.__functionCache[functionName];
+            __runFunc = this.__functionCache.get(functionName);
         }
         if (__runFunc !== null) {
             this.log(`call function '${functionName}'`);

package/dist/cjs/geometry.js

@@ -416,9 +416,28 @@ class Geometry {
                 [segment.end.x, segment.end.y]
             ];
         });
+        const lines = [];
+        let prevPoint;
+        let currentLine = [];
+        segments.forEach((segment, index) => {
+            const [pt1, pt2] = segment;
+            if (index === 0 || (prevPoint[0] !== pt1[0] || prevPoint[1] !== pt1[1])) {
+                if (currentLine.length > 0) {
+                    lines.push(currentLine);
+                    currentLine = [];
+                }
+                currentLine.push([pt1[0], pt1[1]]);
+            }
+            currentLine.push(pt2);
+            prevPoint = pt2;
+        });
+        if (currentLine.length > 0) {
+            lines.push(currentLine);
+        }
         return {
             intersectPoints,
             segments,
+            lines,
         };
     }
 }

package/dist/cjs/globals.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SymbolValidatorContext = exports.RenderFlags = exports.GlobalDocumentName = exports.ModuleContainsKeyword = exports.FrameType = exports.NetGraphicsParams = exports.BlockTypes = exports.ReferenceTypes = exports.ComponentTypes = exports.ColorScheme = exports.PortPaddingVertical = exports.PortPaddingHorizontal = exports.PortArrowSize = exports.junctionSize = exports.defaultFontSize = exports.defaultFontBold = exports.defaultFont = exports.displayUnits = exports.defaultFrameTitleTextSize = exports.CustomSymbolParamTextSize = exports.CustomSymbolRefDesSize = exports.CustomSymbolPinIdSize = exports.CustomSymbolPinTextSize = exports.defaultPageSpacingMM = exports.defaultPageMarginMM = exports.defaultPinIdTextSize = exports.defaultPinNameTextSize = exports.defaultWireLineWidth = exports.defaultSymbolLineWidth = exports.fontDisplayScale = exports.defaultZoomScale = exports.defaultGridSizeUnits = exports.portHeight = exports.portWidth = exports.PxToMM = exports.MMToPt = exports.MMToPx = exports.MilsToMM = exports.WireAutoDirection = exports.LengthUnit = exports.ValidPinSides = exports.SymbolPinSide = exports.LayoutDirection = exports.ParamKeys = exports.NoNetText = exports.GlobalNames = exports.DoubleDelimiter1 = exports.Delimiter1 = exports.TOOL_VERSION = void 0;
+exports.TrailerArrayIndex = exports.SymbolValidatorContext = exports.RenderFlags = exports.GlobalDocumentName = exports.ModuleContainsKeyword = exports.FrameType = exports.NetGraphicsParams = exports.BlockTypes = exports.ReferenceTypes = exports.ComponentTypes = exports.ColorScheme = exports.PortPaddingVertical = exports.PortPaddingHorizontal = exports.PortArrowSize = exports.junctionSize = exports.defaultFontSize = exports.defaultFontBold = exports.defaultFont = exports.displayUnits = exports.defaultFrameTitleTextSize = exports.CustomSymbolParamTextSize = exports.CustomSymbolRefDesSize = exports.CustomSymbolPinIdSize = exports.CustomSymbolPinTextSize = exports.defaultPageSpacingMM = exports.defaultPageMarginMM = exports.defaultPinIdTextSize = exports.defaultPinNameTextSize = exports.defaultWireLineWidth = exports.defaultSymbolLineWidth = exports.fontDisplayScale = exports.defaultZoomScale = exports.defaultGridSizeUnits = exports.portHeight = exports.portWidth = exports.PxToMM = exports.MMToPt = exports.MMToPx = exports.MilsToMM = exports.WireAutoDirection = exports.LengthUnit = exports.ValidPinSides = exports.SymbolPinSide = exports.LayoutDirection = exports.ParamKeys = exports.NoNetText = exports.GlobalNames = exports.DoubleDelimiter1 = exports.Delimiter1 = exports.TOOL_VERSION = void 0;
 const ParamDefinition_js_1 = require("./objects/ParamDefinition.js");
 exports.TOOL_VERSION = '0.1.5';
 exports.Delimiter1 = '-';
@@ -95,6 +95,7 @@ var ReferenceTypes;
     ReferenceTypes["variable"] = "variable";
     ReferenceTypes["instance"] = "instance";
     ReferenceTypes["pinType"] = "pinType";
+    ReferenceTypes["unknown"] = "unknown";
 })(ReferenceTypes || (exports.ReferenceTypes = ReferenceTypes = {}));
 var BlockTypes;
 (function (BlockTypes) {
@@ -106,8 +107,10 @@ var BlockTypes;
 var NetGraphicsParams;
 (function (NetGraphicsParams) {
     NetGraphicsParams["Color"] = "color";
-    NetGraphicsParams["Highight"] = "highlight";
     NetGraphicsParams["LineWidth"] = "lineWidth";
+    NetGraphicsParams["Highlight"] = "highlight";
+    NetGraphicsParams["HighlightWidth"] = "highlightWidth";
+    NetGraphicsParams["HighlightOpacity"] = "highlightOpacity";
 })(NetGraphicsParams || (exports.NetGraphicsParams = NetGraphicsParams = {}));
 var FrameType;
 (function (FrameType) {
@@ -124,3 +127,4 @@ exports.RenderFlags = {
     ShowLabelOrigin: false,
 };
 exports.SymbolValidatorContext = '_sym';
+exports.TrailerArrayIndex = 'index';

package/dist/cjs/graph.js

@@ -0,0 +1,298 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RenderItemType = exports.generateLayoutPinDefinition = exports.getWireName = exports.NetGraph = void 0;
+const graphlib_1 = require("@dagrejs/graphlib");
+const draw_symbols_js_1 = require("./draw_symbols.js");
+const globals_js_1 = require("./globals.js");
+const helpers_js_1 = require("./helpers.js");
+const layout_js_1 = require("./layout.js");
+const ExecutionScope_js_1 = require("./objects/ExecutionScope.js");
+const Frame_js_1 = require("./objects/Frame.js");
+const ParamDefinition_js_1 = require("./objects/ParamDefinition.js");
+class NetGraph {
+    constructor(logger) {
+        this.logger = logger;
+    }
+    generateLayoutGraph(sequence, nets) {
+        this.print('===== creating graph and populating with nodes =====');
+        let previousNode = null;
+        let previousPin = null;
+        const graph = new graphlib_1.Graph({
+            directed: true,
+            compound: true,
+        });
+        this.print('sequence length:', sequence.length);
+        const baseFrame = new layout_js_1.RenderFrame(new Frame_js_1.Frame(Frame_js_1.FixedFrameIds.BaseFrame));
+        const frameStack = [baseFrame];
+        const containerFrames = [baseFrame];
+        sequence.forEach((sequenceStep, index) => {
+            const action = sequenceStep[0];
+            let tmpComponent;
+            switch (action) {
+                case ExecutionScope_js_1.SequenceAction.To:
+                case ExecutionScope_js_1.SequenceAction.At: {
+                    this.print(...sequenceStep);
+                    const [, component, pin] = sequenceStep;
+                    const tmpInstanceName = component.instanceName;
+                    if (!graph.hasNode(tmpInstanceName)) {
+                        this.print('create instance', tmpInstanceName);
+                        const { displayProp = null } = component;
+                        let tmpSymbol;
+                        if (displayProp instanceof draw_symbols_js_1.SymbolDrawing) {
+                            tmpSymbol = new draw_symbols_js_1.SymbolPlaceholder(displayProp);
+                            tmpSymbol.drawing.logger = this.logger;
+                        }
+                        else {
+                            const symbolPinDefinitions = generateLayoutPinDefinition(component);
+                            if (component.typeProp === globals_js_1.ComponentTypes.module) {
+                                tmpSymbol = new draw_symbols_js_1.SymbolCustomModule(symbolPinDefinitions, component.pinsMaxPositions);
+                            }
+                            else {
+                                tmpSymbol = new draw_symbols_js_1.SymbolCustom(symbolPinDefinitions, component.pinsMaxPositions);
+                            }
+                        }
+                        (0, layout_js_1.applyComponentParamsToSymbol)(component, tmpSymbol);
+                        tmpSymbol.refreshDrawing();
+                        const { width: useWidth, height: useHeight } = tmpSymbol.size();
+                        tmpComponent = new layout_js_1.RenderComponent(component, useWidth, useHeight);
+                        tmpComponent.symbol = tmpSymbol;
+                        graph.setNode(tmpInstanceName, [RenderItemType.Component, tmpComponent, index]);
+                        const currentFrame = frameStack[frameStack.length - 1];
+                        currentFrame && currentFrame.innerItems.push(tmpComponent);
+                    }
+                    if (action === ExecutionScope_js_1.SequenceAction.To && previousNode && previousPin) {
+                        this.setGraphEdge(graph, previousNode, tmpInstanceName, makeEdgeValue(previousNode, previousPin, tmpInstanceName, pin, index));
+                    }
+                    previousNode = tmpInstanceName;
+                    previousPin = pin;
+                    break;
+                }
+                case ExecutionScope_js_1.SequenceAction.Wire: {
+                    const [, wireId, wireSegments] = sequenceStep;
+                    let useNet;
+                    if (previousNode !== null) {
+                        const [prevNodeType, prevNodeItem] = graph.node(previousNode);
+                        if (prevNodeType === RenderItemType.Component) {
+                            const matchingItem = nets.find(([comp, pin]) => {
+                                return comp.instanceName === previousNode
+                                    && pin === previousPin;
+                            });
+                            if (matchingItem !== undefined) {
+                                useNet = matchingItem[2];
+                            }
+                        }
+                        else if (prevNodeType === RenderItemType.Wire) {
+                            useNet = prevNodeItem.net;
+                        }
+                    }
+                    const wire = new 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]);
+                    this.setGraphEdge(graph, previousNode, wireName, makeEdgeValue(previousNode, previousPin, wireName, 0, index));
+                    previousNode = wireName;
+                    previousPin = 1;
+                    const wireSegmentsInfo = wireSegments.map(item => {
+                        const tmp = {
+                            direction: item.direction,
+                            value: item.value,
+                        };
+                        if (item.valueXY) {
+                            tmp.valueXY = item.valueXY;
+                        }
+                        if (item.until) {
+                            tmp.until = [item.until[0].toString(), item.until[1]];
+                        }
+                        return tmp;
+                    });
+                    this.print(ExecutionScope_js_1.SequenceAction.Wire, wireId, JSON.stringify(wireSegmentsInfo));
+                    break;
+                }
+                case ExecutionScope_js_1.SequenceAction.WireJump: {
+                    this.print(...sequenceStep);
+                    const wireId = sequenceStep[1];
+                    const wireName = getWireName(wireId);
+                    let wirePin = 1;
+                    if (sequenceStep.length === 3) {
+                        wirePin = sequenceStep[2];
+                    }
+                    previousNode = wireName;
+                    previousPin = wirePin;
+                    break;
+                }
+                case ExecutionScope_js_1.SequenceAction.Frame: {
+                    const [, frameObject, frameAction] = sequenceStep;
+                    if (frameAction === ExecutionScope_js_1.FrameAction.Enter) {
+                        const prevFrame = frameStack[frameStack.length - 1];
+                        const newFrame = new layout_js_1.RenderFrame(frameObject);
+                        if (frameObject.parameters.has(Frame_js_1.FrameParamKeys.Direction)) {
+                            newFrame.direction =
+                                frameObject.parameters.get(Frame_js_1.FrameParamKeys.Direction);
+                        }
+                        if (frameObject.parameters.has(Frame_js_1.FrameParamKeys.Padding)) {
+                            newFrame.padding = (0, helpers_js_1.milsToMM)(frameObject.parameters.get(Frame_js_1.FrameParamKeys.Padding));
+                        }
+                        if (frameObject.parameters.has(Frame_js_1.FrameParamKeys.Border)) {
+                            newFrame.borderWidth =
+                                frameObject.parameters.get(Frame_js_1.FrameParamKeys.Border);
+                        }
+                        if (frameObject.parameters.has(Frame_js_1.FrameParamKeys.Width)) {
+                            newFrame.width = (0, helpers_js_1.milsToMM)(frameObject.parameters.get(Frame_js_1.FrameParamKeys.Width));
+                        }
+                        if (frameObject.parameters.has(Frame_js_1.FrameParamKeys.Height)) {
+                            newFrame.height = (0, helpers_js_1.milsToMM)(frameObject.parameters.get(Frame_js_1.FrameParamKeys.Height));
+                        }
+                        containerFrames.push(newFrame);
+                        frameStack.push(newFrame);
+                        prevFrame && prevFrame.innerItems.push(newFrame);
+                    }
+                    else if (frameAction === ExecutionScope_js_1.FrameAction.Exit) {
+                        frameStack.pop();
+                    }
+                    break;
+                }
+            }
+        });
+        this.print('===== done populating graph =====');
+        this.print('');
+        const logNodesAndEdges = true;
+        if (logNodesAndEdges) {
+            this.print('===== graph edges =====');
+            const allEdges = graph.edges();
+            allEdges.forEach(edge => {
+                const [nodeId1, pin1, nodeId2, pin2] = graph.edge(edge);
+                this.print(nodeId1, 'pin', pin1, '-----', nodeId2, 'pin', pin2);
+            });
+            this.print('===== end edges =====');
+            this.print();
+            this.print('===== graph nodes =====');
+            const nodes = graph.nodes();
+            nodes.forEach(node => {
+                this.print(`name:${node}, value:${graph.node(node)}`);
+            });
+            this.print('===== end nodes =====');
+            this.print('');
+        }
+        return {
+            graph,
+            containerFrames,
+        };
+    }
+    setGraphEdge(graph, node1, node2, edgeValue) {
+        if (!graph.isDirected && graph.hasEdge(node1, node2)) {
+            this.print(`Warning: edge already exists ${node1} ${node2}`);
+        }
+        graph.setEdge(node1, node2, edgeValue);
+        this.print(`created edge: node1:${node1} node2:${node2} edgeValue:${edgeValue}`);
+    }
+    print(...params) {
+        this.logger.add(params.join(' '));
+    }
+    generateNetGraph(nets) {
+        const graph = new graphlib_1.Graph({
+            directed: false
+        });
+        nets.forEach(item => {
+            const [component, pin, net] = item;
+            const netNodeName = this.getNetNodeName(net);
+            if (!graph.hasNode(netNodeName)) {
+                graph.setNode(netNodeName, net);
+            }
+            const componentNodeName = this.getComponentName(component);
+            if (!graph.hasNode(componentNodeName)) {
+                graph.setNode(componentNodeName, component);
+            }
+            graph.setEdge(netNodeName, componentNodeName, [component, pin, net]);
+        });
+    }
+    findNodePaths(graph, startNode, endNode, seenNodes = []) {
+        const edges = graph.nodeEdges(startNode);
+        const paths = [];
+        for (let i = 0; i < edges.length; i++) {
+            const edge = edges[i];
+            const node1 = edge.v;
+            const node2 = edge.w;
+            let nextNode = "";
+            if (node1 === startNode) {
+                nextNode = node2;
+            }
+            else {
+                nextNode = node1;
+            }
+            if (nextNode === endNode) {
+                paths.push([startNode, endNode]);
+                continue;
+            }
+            else if (seenNodes.indexOf(nextNode) !== -1) {
+                continue;
+            }
+            seenNodes.push(startNode);
+            const routes = this.findNodePaths(graph, nextNode, endNode, seenNodes);
+            for (let j = 0; j < routes.length; j++) {
+                paths.push([startNode, ...routes[j]]);
+            }
+        }
+        return paths;
+    }
+    getNetNodeName(net) {
+        return 'net:' + net.toString();
+    }
+    getComponentName(component) {
+        return 'component:' + component.instanceName;
+    }
+}
+exports.NetGraph = NetGraph;
+function makeEdgeValue(instanceName1, instancePin1, instanceName2, instancePin2, priority) {
+    return [instanceName1, instancePin1, instanceName2, instancePin2, priority];
+}
+function getWireName(wireId) {
+    return 'wire:' + wireId;
+}
+exports.getWireName = getWireName;
+function generateLayoutPinDefinition(component) {
+    const pins = component.pins;
+    const symbolPinDefinitions = [];
+    const existingPinIds = Array.from(pins.keys());
+    const arrangeProps = component.arrangeProps ?? [];
+    const addedPins = [];
+    for (const [key, items] of arrangeProps) {
+        let useItems;
+        if (!Array.isArray(items)) {
+            useItems = [items];
+        }
+        else {
+            useItems = [...items];
+        }
+        useItems.forEach(pinId => {
+            if (pinId instanceof ParamDefinition_js_1.NumericValue) {
+                const pinIdValue = pinId.toNumber();
+                if (existingPinIds.indexOf(pinIdValue) !== -1) {
+                    const pin = pins.get(pinIdValue);
+                    symbolPinDefinitions.push({
+                        side: key,
+                        pinId: pinIdValue,
+                        text: pin.name,
+                        position: pin.position,
+                        pinType: pin.pinType,
+                    });
+                    addedPins.push(pinIdValue);
+                }
+            }
+        });
+    }
+    const unplacedPins = existingPinIds.filter(pinId => {
+        return addedPins.indexOf(pinId) === -1;
+    });
+    if (unplacedPins.length > 0) {
+        component._unplacedPins = unplacedPins;
+        console.warn("Warning: There are unplaced pins: " + unplacedPins);
+    }
+    return symbolPinDefinitions;
+}
+exports.generateLayoutPinDefinition = generateLayoutPinDefinition;
+var RenderItemType;
+(function (RenderItemType) {
+    RenderItemType["Wire"] = "wire";
+    RenderItemType["Component"] = "component";
+})(RenderItemType || (exports.RenderItemType = RenderItemType = {}));

package/dist/cjs/helpers.js

@@ -23,6 +23,7 @@ const globals_js_1 = require("./globals.js");
 const Frame_js_1 = require("./objects/Frame.js");
 const big_js_1 = __importDefault(require("big.js"));
 const logger_js_1 = require("./logger.js");
+const graph_js_1 = require("./graph.js");
 var JSModuleType;
 (function (JSModuleType) {
     JSModuleType["CommonJs"] = "cjs";
@@ -247,11 +248,14 @@ async function renderScript(scriptData, outputPath, options) {
                     errors,
                 };
             }
-            const layoutEngine = new layout_js_1.LayoutEngine();
+            const logger = new logger_js_1.Logger();
+            const graphEngine = new graph_js_1.NetGraph(logger);
+            const layoutEngine = new layout_js_1.LayoutEngine(logger);
             const layoutTimer = new utils_js_1.SimpleStopwatch();
             let sheetFrames;
             try {
-                sheetFrames = layoutEngine.runLayout(sequence, nets);
+                const { graph, containerFrames } = graphEngine.generateLayoutGraph(sequence, nets);
+                sheetFrames = layoutEngine.runLayout(graph, containerFrames, nets);
             }
             catch (err) {
                 throw new utils_js_1.RenderError(`Error during layout generation: ${err}`, 'layout');