circuitscript 0.0.38 → 0.1.2

package/dist/esm/layout.mjs

@@ -1,14 +1,14 @@
 import { Graph, alg } from '@dagrejs/graphlib';
-import { SymbolCustom, SymbolDrawing, SymbolFactory, SymbolCustomModule, SymbolPlaceholder, SymbolText, PlaceHolderCommands } from "./draw_symbols.mjs";
+import { SymbolCustom, SymbolDrawing, SymbolCustomModule, SymbolPlaceholder, SymbolText, PlaceHolderCommands } from "./draw_symbols.mjs";
 import { FrameAction, SequenceAction } from "./objects/ExecutionScope.mjs";
-import { defaultFrameTitleTextSize, defaultGridSizeUnits, FrameType, GlobalNames, ParamKeys, WireAutoDirection } from './globals.mjs';
-import { NumericValue } from './objects/ParamDefinition.mjs';
+import { ComponentTypes, defaultFrameTitleTextSize, defaultGridSizeUnits, FrameType, ParamKeys, SymbolPinSide, WireAutoDirection } from './globals.mjs';
 import { Geometry } from './geometry.mjs';
 import { Logger } from './logger.mjs';
 import { Frame, FrameParamKeys, FramePlotDirection } from './objects/Frame.mjs';
-import { getBoundsSize, printBounds, resizeBounds, resizeToNearestGrid, roundValue, toNearestGrid } from './utils.mjs';
+import { combineMaps, getBoundsSize, printBounds, resizeBounds, resizeToNearestGrid, roundValue, toNearestGrid } from './utils.mjs';
 import { Direction } from './objects/types.mjs';
 import { milsToMM, UnitDimension } from './helpers.mjs';
+import { numeric, NumericValue } from './objects/ParamDefinition.mjs';
 export class LayoutEngine {
     logger;
     placeSubgraphVersion = 2;
@@ -114,8 +114,8 @@ export class LayoutEngine {
             const allLines = wires.map(wire => {
                 return wire.points.map(pt => {
                     return {
-                        x: wire.x + pt.x,
-                        y: wire.y + pt.y,
+                        x: wire.x.add(pt.x),
+                        y: wire.y.add(pt.y),
                     };
                 });
             });
@@ -126,7 +126,7 @@ export class LayoutEngine {
                 intersectPoints,
             });
             intersectPoints.forEach(([x, y]) => {
-                junctions.push(new RenderJunction(x, y));
+                junctions.push(new RenderJunction(numeric(x), numeric(y)));
             });
         }
         return {
@@ -136,15 +136,15 @@ export class LayoutEngine {
     }
     placeFrames(graph, subgraphInfo, frameObjects) {
         const baseFrame = frameObjects[0];
-        baseFrame.padding = 0;
-        baseFrame.borderWidth = 0;
+        baseFrame.padding = numeric(0);
+        baseFrame.borderWidth = numeric(0);
         if (this.showBaseFrame) {
-            baseFrame.borderWidth = 5;
+            baseFrame.borderWidth = numeric(5);
             baseFrame.width = 11692 - 400 * 2;
             baseFrame.height = 8267 - 400 * 2;
         }
-        baseFrame.x = 0;
-        baseFrame.y = 0;
+        baseFrame.x = numeric(0);
+        baseFrame.y = numeric(0);
         let textObjects = [];
         let elementFrames = [];
         baseFrame.bounds = {
@@ -190,18 +190,18 @@ export class LayoutEngine {
         const innerItems = frame.innerItems;
         innerItems.forEach(innerFrame => {
             if (innerFrame.frame.frameType === FrameType.Sheet) {
-                innerFrame.x = 0;
-                innerFrame.y = 0;
+                innerFrame.x = numeric(0);
+                innerFrame.y = numeric(0);
             }
             else {
-                innerFrame.x += frame.x;
-                innerFrame.y += frame.y;
+                innerFrame.x = innerFrame.x.add(frame.x);
+                innerFrame.y = innerFrame.y.add(frame.y);
             }
             if (innerFrame.type === RenderFrameType.Elements) {
                 this.print(level, "".padStart(level * 4), 'element frame', innerFrame.x, innerFrame.y);
                 innerFrame.innerItems.forEach(item2 => {
-                    item2.x += innerFrame.x - innerFrame.translateX;
-                    item2.y += innerFrame.y - innerFrame.translateY;
+                    item2.x = item2.x.add(innerFrame.x).sub(innerFrame.translateX);
+                    item2.y = item2.y.add(innerFrame.y).sub(innerFrame.translateY);
                 });
             }
             else {
@@ -213,8 +213,8 @@ export class LayoutEngine {
     placeAndSizeFrame(frame, level = 0) {
         const innerFrames = frame.innerItems;
         const gridSize = defaultGridSizeUnits;
-        let accumX = 0;
-        let accumY = 0;
+        let accumX = numeric(0);
+        let accumY = numeric(0);
         const boundPoints = [];
         const frameSizes = innerFrames.map(innerFrame => {
             if (innerFrame.type === RenderFrameType.Elements) {
@@ -242,7 +242,7 @@ export class LayoutEngine {
                     return accum;
                 }
                 return accum + width +
-                    ((index + 1 < frameSizes.length) ? frame.gap : 0);
+                    ((index + 1 < frameSizes.length) ? frame.gap.toNumber() : 0);
             }, 0);
         }
         else {
@@ -266,47 +266,55 @@ export class LayoutEngine {
         innerFrames.forEach(innerFrame => {
             const { width: frameWidth, height: frameHeight } = getBoundsSize(innerFrame.bounds);
             if (innerFrame.containsTitle) {
-                innerFrame.x = offsetX + accumX + toNearestGrid(widthForTitle / 2 - frameWidth / 2, gridSize);
-                innerFrame.y = offsetY + accumY;
-                accumY += (frameHeight + frame.gap);
+                innerFrame.x = offsetX.add(accumX).add(toNearestGrid(widthForTitle / 2 - frameWidth / 2, gridSize));
+                innerFrame.y = offsetY.add(accumY);
+                accumY = accumY.add(frameHeight).add(frame.gap);
             }
             else {
                 if (frame.direction === FramePlotDirection.Column) {
-                    innerFrame.x = offsetX + accumX + toNearestGrid(maxWidth / 2 - frameWidth / 2, gridSize);
-                    innerFrame.y = offsetY + accumY;
-                    accumY += (frameHeight + frame.gap);
+                    innerFrame.x = offsetX.add(accumX).add(toNearestGrid(maxWidth / 2 - frameWidth / 2, gridSize));
+                    innerFrame.y = offsetY.add(accumY);
+                    accumY = accumY.add(frameHeight).add(frame.gap);
                 }
                 else if (frame.direction === FramePlotDirection.Row) {
-                    innerFrame.x = offsetX + centeredOffsetX + accumX;
-                    innerFrame.y = offsetY + accumY;
-                    accumX += (frameWidth + frame.gap);
+                    innerFrame.x = offsetX.add(centeredOffsetX).add(accumX);
+                    innerFrame.y = offsetY.add(accumY);
+                    accumX = accumX.add(frameWidth).add(frame.gap);
                 }
             }
-            boundPoints.push([innerFrame.x, innerFrame.y], [innerFrame.x + frameWidth, innerFrame.y + frameHeight]);
+            boundPoints.push([innerFrame.x, innerFrame.y], [innerFrame.x.add(frameWidth), innerFrame.y.add(frameHeight)]);
         });
-        const contentsBounds = resizeBounds(getBoundsFromPoints(boundPoints), frame.padding);
+        const tmpBoundPoints = boundPoints.map(item => {
+            return [
+                item[0].toNumber(),
+                item[1].toNumber(),
+            ];
+        });
+        const contentsBounds = resizeBounds(getBoundsFromPoints(tmpBoundPoints), frame.padding.toNumber());
         if (frame.frame.parameters.has(FrameParamKeys.SheetType)) {
             const frameComponent = frame.frame.parameters.get(FrameParamKeys.SheetType);
-            const rects = ExtractDrawingRects(frameComponent.displayProp);
-            let frameWidth = 0;
-            let frameHeight = 0;
+            const frameDrawing = frameComponent.displayProp;
+            frameDrawing.variables = combineMaps(frameComponent.parameters, frame.frame.parameters);
+            const rects = ExtractDrawingRects(frameDrawing);
+            let frameWidth = numeric(0);
+            let frameHeight = numeric(0);
             if (rects[1]) {
                 frameWidth = milsToMM(rects[1].width);
                 frameHeight = milsToMM(rects[1].height);
             }
             const contentsWidth = contentsBounds.xmax - contentsBounds.xmin;
             const contentsHeight = contentsBounds.ymax - contentsBounds.ymin;
-            const frameOffsetX = toNearestGrid((frameWidth - contentsWidth) / 2, gridSize);
-            const frameOffsetY = toNearestGrid((frameHeight - contentsHeight) / 2, gridSize);
+            const frameOffsetX = toNearestGrid((frameWidth.toNumber() - contentsWidth) / 2, gridSize);
+            const frameOffsetY = toNearestGrid((frameHeight.toNumber() - contentsHeight) / 2, gridSize);
             innerFrames.forEach(innerFrame => {
-                innerFrame.x += frameOffsetX;
-                innerFrame.y += frameOffsetY;
+                innerFrame.x = innerFrame.x.add(frameOffsetX);
+                innerFrame.y = innerFrame.y.add(frameOffsetY);
             });
             frame.bounds = {
                 xmin: 0,
                 ymin: 0,
-                xmax: frameWidth,
-                ymax: frameHeight
+                xmax: frameWidth.toNumber(),
+                ymax: frameHeight.toNumber(),
             };
         }
         else {
@@ -373,13 +381,14 @@ export class LayoutEngine {
         }, []);
         if (frame.type === RenderFrameType.Container) {
             const frameObject = frame.frame;
-            if (frameObject.parameters.has(FrameParamKeys.Title)) {
+            const isSheetFrame = frameObject.frameType === FrameType.Sheet;
+            if (frameObject.parameters.has(FrameParamKeys.Title) && !isSheetFrame) {
                 const title = frameObject.parameters.get(FrameParamKeys.Title);
                 const tmpFrame = new RenderFrame(new Frame(-2), RenderFrameType.Elements);
                 tmpFrame.containsTitle = true;
                 tmpFrame.subgraphId = title.replace(/\s/g, "_");
                 const textObject = new RenderText(title);
-                textObject.fontSize = defaultFrameTitleTextSize;
+                textObject.fontSize = numeric(defaultFrameTitleTextSize);
                 textObject.fontWeight = 'bold';
                 textObject.symbol.refreshDrawing();
                 tmpFrame.innerItems.push(textObject);
@@ -390,8 +399,8 @@ export class LayoutEngine {
                     xmax: tmpBox.start[0] + tmpBox.width,
                     ymax: tmpBox.start[1] + tmpBox.height
                 };
-                textObject.x = 0;
-                textObject.y = 0;
+                textObject.x = numeric(0);
+                textObject.y = numeric(0);
                 frame.innerItems.splice(0, 0, tmpFrame);
                 this.printLevel(level, frame, 'added text', tmpFrame);
                 textObjects.push(textObject);
@@ -424,46 +433,43 @@ export class LayoutEngine {
                 const tmpInstanceName = component.instanceName;
                 if (!graph.hasNode(tmpInstanceName)) {
                     this.print('create instance', tmpInstanceName);
-                    let { displayProp = null, widthProp = null, typeProp = null } = component;
+                    const { displayProp = null, widthProp = null, heightProp = null } = component;
                     let tmpSymbol;
-                    if (displayProp === null &&
-                        component.parameters.get(ParamKeys.net_name) === GlobalNames.gnd) {
-                        displayProp = 'gnd';
-                    }
-                    if (displayProp !== null) {
-                        if (displayProp instanceof SymbolDrawing) {
-                            tmpSymbol = new SymbolPlaceholder(displayProp);
-                            tmpSymbol.drawing.logger = this.logger;
-                        }
-                        else if (typeof displayProp === "string") {
-                            tmpSymbol = SymbolFactory(displayProp);
-                        }
+                    if (displayProp instanceof SymbolDrawing) {
+                        tmpSymbol = new SymbolPlaceholder(displayProp);
+                        tmpSymbol.drawing.logger = this.logger;
                     }
                     else {
                         const symbolPinDefinitions = generateLayoutPinDefinition(component);
-                        if (component.typeProp === 'module') {
-                            tmpSymbol = new SymbolCustomModule(symbolPinDefinitions);
+                        if (component.typeProp === ComponentTypes.module) {
+                            tmpSymbol = new SymbolCustomModule(symbolPinDefinitions, component.pinsMaxPositions);
                         }
                         else {
-                            tmpSymbol = new SymbolCustom(symbolPinDefinitions);
+                            tmpSymbol = new SymbolCustom(symbolPinDefinitions, component.pinsMaxPositions);
                         }
                     }
-                    applyComponentParamsToSymbol(typeProp, component, tmpSymbol);
+                    applyComponentParamsToSymbol(component, tmpSymbol);
                     let didSetAngle = false;
-                    if (component.parameters.has('angle')) {
+                    if (component.parameters.has(ParamKeys.angle)) {
                         didSetAngle = true;
-                        tmpSymbol.angle = component.parameters.get('angle');
+                        const value = component.parameters.get(ParamKeys.angle).toNumber();
+                        tmpSymbol.angle = value;
                     }
-                    if (component.parameters.has('flipX')) {
+                    if (component.parameters.has(ParamKeys.flipX)) {
                         tmpSymbol.flipX =
-                            component.parameters.get('flipX');
+                            component.parameters.get(ParamKeys.flipX);
                     }
-                    if (component.parameters.has('flipY')) {
+                    if (component.parameters.has(ParamKeys.flipY)) {
                         tmpSymbol.flipY =
-                            component.parameters.get('flipY');
+                            component.parameters.get(ParamKeys.flipY);
                     }
-                    if (tmpSymbol instanceof SymbolCustom && widthProp) {
-                        tmpSymbol.bodyWidth = milsToMM(widthProp);
+                    if (tmpSymbol instanceof SymbolCustom) {
+                        if (widthProp) {
+                            tmpSymbol.bodyWidth = milsToMM(widthProp);
+                        }
+                        if (heightProp) {
+                            tmpSymbol.bodyHeight = milsToMM(heightProp);
+                        }
                     }
                     if (!didSetAngle && component.parameters.has('_addDirection')) {
                         tmpSymbol.refreshDrawing(false);
@@ -485,7 +491,7 @@ export class LayoutEngine {
             }
             else if (action === SequenceAction.Wire) {
                 const [, wireId, wireSegments] = sequence[i];
-                const wire = new RenderWire(0, 0, wireSegments);
+                const wire = new RenderWire(numeric(0), numeric(0), wireSegments);
                 wire.id = wireId;
                 let useNetName = null;
                 if (previousNode !== null) {
@@ -649,7 +655,7 @@ export class LayoutEngine {
         }
         if (subgraphEdges.length === 0) {
             const [, node1] = graph.node(firstNodeId);
-            this.placeNodeAtPosition(0, 0, node1, 1);
+            this.placeNodeAtPosition(numeric(0), numeric(0), node1, 1);
             return;
         }
         let fixedNode;
@@ -662,7 +668,7 @@ export class LayoutEngine {
             const [, node2] = graph.node(nodeId2);
             if (nodeId1 === firstNodeId && !firstNodePlaced) {
                 this.print('first node placed at origin');
-                this.placeNodeAtPosition(0, 0, node1, pin1);
+                this.placeNodeAtPosition(numeric(0), numeric(0), node1, pin1);
                 firstNodePlaced = true;
                 node1.isFloating = false;
                 originNodes.push(node1);
@@ -685,7 +691,7 @@ export class LayoutEngine {
                 originNodes.push(node1);
                 originNodeGroups.set(node1.toString(), [node1]);
                 this.print('creating new origin node at', node1);
-                this.placeNodeAtPosition(0, 0, node1, pin1);
+                this.placeNodeAtPosition(numeric(0), numeric(0), node1, pin1);
                 node1.isFloating = false;
                 fixedNode = node1;
                 fixedNodePin = pin1;
@@ -702,7 +708,7 @@ export class LayoutEngine {
                 else {
                     const [x1, y1] = getNodePositionAtPin(node1, pin1);
                     const [x2, y2] = getNodePositionAtPin(node2, pin2);
-                    if (x1 !== x2 && y1 !== y2) {
+                    if (!x1.eq(x2) && !y1.eq(y2)) {
                         if (node1 instanceof RenderWire &&
                             node2 instanceof RenderComponent) {
                             const refdes = node2.component.assignedRefDes;
@@ -779,8 +785,8 @@ export class LayoutEngine {
         this.print('merging origin node groups, fixed:', keepOriginNode, ', other:', otherOriginNode);
         const [x, y] = getNodePositionAtPin(fixedNode, fixedNodePin);
         const [otherNodeOriginX, otherNodeOriginY] = getNodePositionAtPin(mergedNode, mergedNodePin);
-        const offsetX = x - otherNodeOriginX;
-        const offsetY = y - otherNodeOriginY;
+        const offsetX = x.sub(otherNodeOriginX);
+        const offsetY = y.sub(otherNodeOriginY);
         this.print('offset of other origin:', offsetX, offsetY);
         const otherItemsLinkedToOriginNode = originNodeGroups.get(otherOriginNode);
         this.print('nodes in other origin:', otherItemsLinkedToOriginNode);
@@ -802,7 +808,7 @@ export class LayoutEngine {
             const [, node2] = graph.node(nodeId2);
             if (nodeId1 === firstNodeId && !firstNodePlaced) {
                 this.print('first node placed at origin');
-                this.placeNodeAtPosition(0, 0, node1, pin1);
+                this.placeNodeAtPosition(numeric(0), numeric(0), node1, pin1);
                 firstNodePlaced = true;
                 node1.isFloating = false;
             }
@@ -848,14 +854,14 @@ export class LayoutEngine {
         });
     }
     translateNodeBy(offsetX, offsetY, item) {
-        item.x += offsetX;
-        item.y += offsetY;
+        item.x = item.x.add(offsetX);
+        item.y = item.y.add(offsetY);
     }
     placeNodeAtPosition(fromX, fromY, item, pin, depth = 0) {
         if (item instanceof RenderComponent) {
             const pinPosition = item.symbol.pinPosition(pin);
-            item.x = fromX - pinPosition.x;
-            item.y = fromY - pinPosition.y;
+            item.x = fromX.sub(pinPosition.x);
+            item.y = fromY.sub(pinPosition.y);
         }
         else if (item instanceof RenderWire) {
             if (pin === 0) {
@@ -864,8 +870,8 @@ export class LayoutEngine {
             }
             else {
                 const wireEnd = item.getWireEnd();
-                item.x = fromX - wireEnd.x;
-                item.y = fromY - wireEnd.y;
+                item.x = fromX.sub(wireEnd.x);
+                item.y = fromY.sub(wireEnd.y);
             }
         }
         this.print(this.padLevel(depth), 'place', item, 'pin', pin, 'at', item.x, item.y);
@@ -904,12 +910,12 @@ export class LayoutEngine {
     }
 }
 function getNodePositionAtPin(item, pin) {
-    let x = 0;
-    let y = 0;
+    let x = numeric(0);
+    let y = numeric(0);
     if (item instanceof RenderComponent) {
         const pinPosition = item.symbol.pinPosition(pin);
-        x = item.x + pinPosition.x;
-        y = item.y + pinPosition.y;
+        x = item.x.add(pinPosition.x);
+        y = item.y.add(pinPosition.y);
     }
     else if (item instanceof RenderWire) {
         if (pin === 0) {
@@ -918,8 +924,8 @@ function getNodePositionAtPin(item, pin) {
         }
         else {
             const wireEnd = item.getWireEnd();
-            x = item.x + wireEnd.x;
-            y = item.y + wireEnd.y;
+            x = item.x.add(wireEnd.x);
+            y = item.y.add(wireEnd.y);
         }
     }
     return [
@@ -952,7 +958,7 @@ function generateLayoutPinDefinition(component) {
             const pinPosition = Math.floor(i / 2);
             const pin = pins.get(existingPinIds[i]);
             symbolPinDefinitions.push({
-                side: (i % 2 === 0) ? "left" : "right",
+                side: (i % 2 === 0) ? SymbolPinSide.Left : SymbolPinSide.Right,
                 pinId: existingPinIds[i],
                 text: pin.name,
                 position: pinPosition,
@@ -971,24 +977,24 @@ function generateLayoutPinDefinition(component) {
                 useItems = [...items];
             }
             useItems.forEach(pinId => {
-                if (existingPinIds.indexOf(pinId) !== -1) {
-                    const pin = pins.get(pinId);
-                    symbolPinDefinitions.push({
-                        side: key,
-                        pinId: pinId,
-                        text: pin.name,
-                        position: pin.position,
-                        pinType: pin.pinType,
-                    });
-                    addedPins.push(pinId);
+                if (pinId instanceof 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.forEach(item => {
-            if (addedPins.indexOf(item) === -1) {
-                unplacedPins.push(item);
-            }
+        const unplacedPins = existingPinIds.filter(pinId => {
+            return addedPins.indexOf(pinId) === -1;
         });
         if (unplacedPins.length > 0) {
             throw "'arrange' property is defined, but not all pins are specified: " + unplacedPins.join(",");
@@ -996,28 +1002,12 @@ function generateLayoutPinDefinition(component) {
     }
     return symbolPinDefinitions;
 }
-function applyComponentParamsToSymbol(typeProp, component, symbol) {
-    if (typeProp === 'net') {
-        symbol.setLabelValue("net_name", component.parameters.get(ParamKeys.net_name));
-    }
-    if (component.assignedRefDes !== null) {
-        symbol.setLabelValue("refdes", component.assignedRefDes);
-    }
-    for (const [key, value] of component.parameters) {
-        if (key !== 'refdes' && key !== 'net_name') {
-            let useValue;
-            if (typeof value == 'object' && (value instanceof NumericValue)) {
-                useValue = value.toDisplayString();
-            }
-            else if (typeof value === 'number') {
-                useValue = value.toString();
-            }
-            else if (typeof value === 'string') {
-                useValue = value;
-            }
-            symbol.setLabelValue(key, useValue);
-        }
+export function applyComponentParamsToSymbol(component, symbol) {
+    const newMap = new Map(component.parameters);
+    if (!newMap.has('refdes')) {
+        newMap.set('refdes', component.assignedRefDes ?? "?");
     }
+    symbol.drawing.variables = newMap;
 }
 function calculateSymbolAngle(symbol, pin, direction) {
     let directionVector = 0;
@@ -1045,21 +1035,21 @@ export function getBounds(components, wires, junctions, frames) {
         const bbox = item.symbol.drawing.getBoundingBox();
         const [x1, y1] = bbox.start;
         const [x2, y2] = bbox.end;
-        points.push([x1 + item.x, y1 + item.y]);
-        points.push([x2 + item.x, y2 + item.y]);
+        points.push([x1 + item.x.toNumber(), y1 + item.y.toNumber()]);
+        points.push([x2 + item.x.toNumber(), y2 + item.y.toNumber()]);
     });
     wires.forEach(wire => {
         wire.points.forEach(point => {
-            points.push([wire.x + point.x, wire.y + point.y]);
+            points.push([wire.x.add(point.x).toNumber(), wire.y.add(point.y).toNumber()]);
         });
     });
     junctions.forEach(item => {
-        points.push([item.x, item.y]);
+        points.push([item.x.toNumber(), item.y.toNumber()]);
     });
     frames.forEach(item => {
         const { width, height } = getBoundsSize(item.bounds);
-        points.push([item.x, item.y]);
-        points.push([item.x + width, item.y + height]);
+        points.push([item.x.toNumber(), item.y.toNumber()]);
+        points.push([item.x.toNumber() + width, item.y.toNumber() + height]);
     });
     return getBoundsFromPoints(points);
 }
@@ -1075,8 +1065,8 @@ function getBoundsFromPoints(points) {
     };
 }
 export class RenderObject {
-    x = -1;
-    y = -1;
+    x = numeric(-1);
+    y = numeric(-1);
     isFloating = true;
     floatingRelativeTo = [];
 }
@@ -1119,7 +1109,7 @@ export class RenderWire extends RenderObject {
                 tmpX += useValue;
             }
             else if (direction === WireAutoDirection.Auto || direction === WireAutoDirection.Auto_) {
-                const { valueXY = [0, 0] } = segment;
+                const { valueXY = [numeric(0), numeric(0)] } = segment;
                 const tmpPoints = this.getAutoPoints(valueXY, direction);
                 tmpPoints.forEach(point => {
                     if (point[0] !== 0 || point[1] !== 0) {
@@ -1137,8 +1127,8 @@ export class RenderWire extends RenderObject {
         this.points = points;
     }
     getAutoPoints(value, direction) {
-        const valueX = roundValue(value[0]);
-        const valueY = roundValue(value[1]);
+        const valueX = roundValue(value[0]).toNumber();
+        const valueY = roundValue(value[1]).toNumber();
         const inQuadrant = Geometry.getQuadrant(valueX, valueY);
         const [dx, dy] = [valueX, valueY];
         if (direction === WireAutoDirection.Auto) {
@@ -1194,16 +1184,16 @@ export class RenderWire extends RenderObject {
                 useValue = value;
             }
             if (direction === Direction.Down) {
-                tmpY += useValue;
+                tmpY = tmpY.add(useValue);
             }
             else if (direction === Direction.Up) {
-                tmpY -= useValue;
+                tmpY = tmpY.sub(useValue);
             }
             else if (direction === Direction.Left) {
-                tmpX -= useValue;
+                tmpX = tmpX.sub(useValue);
             }
             else if (direction === Direction.Right) {
-                tmpX += useValue;
+                tmpX = tmpX.add(useValue);
             }
         });
         let useValue = null;
@@ -1211,22 +1201,22 @@ export class RenderWire extends RenderObject {
         const lastSegment = this.segments[this.segments.length - 1];
         switch (lastSegment.direction) {
             case Direction.Left:
-                useValue = tmpX - untilX;
+                useValue = tmpX.sub(untilX);
                 break;
             case Direction.Right:
-                useValue = untilX - tmpX;
+                useValue = untilX.sub(tmpX);
                 break;
             case Direction.Up:
-                useValue = untilY - tmpY;
+                useValue = untilY.sub(tmpY);
                 break;
             case Direction.Down:
-                useValue = tmpY - untilY;
+                useValue = tmpY.sub(untilY);
                 break;
             case WireAutoDirection.Auto:
             case WireAutoDirection.Auto_:
                 valueXY = [
-                    untilX - tmpX,
-                    untilY - tmpY,
+                    untilX.sub(tmpX),
+                    untilY.sub(tmpY),
                 ];
                 useValue = 0;
                 break;
@@ -1264,7 +1254,7 @@ export class RenderComponent extends RenderObject {
 }
 export class RenderText extends RenderObject {
     symbol;
-    _fontSize = 12;
+    _fontSize = numeric(12);
     _fontWeight = 'regular';
     get fontSize() {
         return this._fontSize;
@@ -1293,11 +1283,10 @@ export class RenderFrame extends RenderObject {
     translateY = 0;
     padding = milsToMM(100);
     gap = milsToMM(100);
+    borderWidth = numeric(5);
     direction = FramePlotDirection.Column;
-    borderWidth = 5;
     width = null;
     height = null;
-    size = null;
     subgraphId = "";
     type;
     containsTitle = false;
@@ -1314,7 +1303,8 @@ export class RenderFrame extends RenderObject {
         else if (this.type === RenderFrameType.Elements) {
             name = 'elements_' + this.subgraphId;
         }
-        return name + ": " + this.x + "," + this.y + " bounds:" + printBounds(this.bounds);
+        return name + ": " + this.x + "," + this.y
+            + " bounds:" + (this.bounds && printBounds(this.bounds));
     }
 }
 export var RenderFrameType;
@@ -1339,8 +1329,9 @@ export function CalculatePinPositions(component) {
     }
     else {
         const symbolPinDefinitions = generateLayoutPinDefinition(component);
-        tmpSymbol = new SymbolCustom(symbolPinDefinitions);
+        tmpSymbol = new SymbolCustom(symbolPinDefinitions, component.pinsMaxPositions);
     }
+    applyComponentParamsToSymbol(component, tmpSymbol);
     tmpSymbol.refreshDrawing();
     const pins = component.pins;
     pins.forEach((value, key) => {

package/dist/esm/logger.mjs

@@ -4,7 +4,14 @@ export class Logger {
         this.add((new Date()).toISOString());
         this.add('starting logger...');
     }
-    add(message) {
+    add(...args) {
+        let message = "";
+        if (args.length === 1) {
+            message = args[0].toString();
+        }
+        else {
+            message = args.join(" ");
+        }
         this.logs.push((new Date()).toISOString() + " | " + message);
     }
     dump() {