circuitscript 0.1.0 → 0.1.3

package/dist/cjs/render.js

@@ -22,19 +22,21 @@ function createSvgCanvas() {
     (0, sizing_js_1.applyFontsToSVG)(canvas);
     return canvas;
 }
-function renderSheetsToSVG(sheetFrames) {
+function renderSheetsToSVG(sheetFrames, logger) {
     const canvas = createSvgCanvas();
     sheetFrames.forEach((sheet, index) => {
         const sheetGroup = canvas.group();
-        sheetGroup.id('sheet-' + index);
+        sheetGroup.id('sheet-' + index).addClass('sheet');
+        logger.add('rendering sheet: sheet-' + index);
         const { components, wires, junctions, mergedWires, frames, textObjects } = sheet;
         const allFrames = [sheet.frame, ...frames];
         let gridBounds = null;
         let extendGrid = true;
         let xOffset = 0;
         let yOffset = 0;
-        let sheetYOffset = 0;
+        let sheetYOffset = (0, ParamDefinition_js_1.numeric)(0);
         if (sheet.frame.frame) {
+            logger.add('drawing frame');
             const frameComponent = sheet.frame.frame.parameters
                 .get(Frame_js_1.FrameParamKeys.SheetType);
             if (frameComponent) {
@@ -42,34 +44,43 @@ function renderSheetsToSVG(sheetFrames) {
                     throw 'Invalid graphic object for sheet frame';
                 }
                 const frameRects = (0, layout_js_1.ExtractDrawingRects)(frameComponent.displayProp) ?? [];
-                let originalWidthMM = 0;
-                let originalHeightMM = 0;
-                let widthMM = 0;
-                let heightMM = 0;
-                if (frameRects[0]) {
-                    originalWidthMM = (0, helpers_js_1.milsToMM)(frameRects[0].width);
-                    originalHeightMM = (0, helpers_js_1.milsToMM)(frameRects[0].height);
+                let originalWidthMM = (0, ParamDefinition_js_1.numeric)(0);
+                let originalHeightMM = (0, ParamDefinition_js_1.numeric)(0);
+                let widthMM = (0, ParamDefinition_js_1.numeric)(0);
+                let heightMM = (0, ParamDefinition_js_1.numeric)(0);
+                const paperRect = frameRects.find(item => item.className === 'paper-area');
+                const plotRect = frameRects.find(item => item.className === 'plot-area');
+                if (paperRect) {
+                    originalWidthMM = (0, helpers_js_1.milsToMM)(paperRect.width);
+                    originalHeightMM = (0, helpers_js_1.milsToMM)(paperRect.height);
+                    logger.add('first frame size: ' + originalWidthMM.toNumber()
+                        + ' ' + originalHeightMM.toNumber());
                 }
-                if (frameRects[1]) {
-                    widthMM = (0, helpers_js_1.milsToMM)(frameRects[1].width);
-                    heightMM = (0, helpers_js_1.milsToMM)(frameRects[1].height);
+                if (plotRect) {
+                    widthMM = (0, helpers_js_1.milsToMM)(plotRect.width);
+                    heightMM = (0, helpers_js_1.milsToMM)(plotRect.height);
+                    logger.add('second frame size: ' + widthMM.toNumber()
+                        + ' ' + heightMM.toNumber());
                 }
-                xOffset = (originalWidthMM - widthMM) / 2;
-                yOffset = (originalHeightMM - heightMM) / 2;
-                sheetYOffset = index * (originalHeightMM + globals_js_1.defaultPageSpacingMM);
+                xOffset = (originalWidthMM.sub(widthMM)).half().toNumber();
+                yOffset = (originalHeightMM.sub(heightMM)).half().toNumber();
+                logger.add('offset', xOffset, yOffset);
+                sheetYOffset = originalHeightMM.add(globals_js_1.defaultPageSpacingMM).mul(index);
                 gridBounds = {
                     xmin: 0,
                     ymin: 0,
-                    xmax: widthMM,
-                    ymax: heightMM
+                    xmax: widthMM.toNumber(),
+                    ymax: heightMM.toNumber()
                 };
                 extendGrid = false;
             }
         }
-        const sheetElements = sheetGroup.group();
-        generateSVGChild(sheetElements, components, wires, junctions, mergedWires, allFrames, textObjects, gridBounds, extendGrid);
+        logger.add('sheet contents offset: ' + xOffset + ' ' + yOffset);
+        logger.add('generating svg children in sheet');
+        const sheetElements = sheetGroup.group().addClass('sheet-elements');
+        generateSVGChild(sheetElements, components, wires, junctions, mergedWires, allFrames, textObjects, gridBounds, extendGrid, logger);
         sheetElements.translate(xOffset, yOffset);
-        sheetGroup.translate(0, sheetYOffset);
+        sheetGroup.translate(0, sheetYOffset.toNumber());
     });
     return canvas;
 }
@@ -114,16 +125,18 @@ function generatePdfOutput(doc, canvas, sheetSize, sheetSizeDefined, zoomScale =
     });
 }
 exports.generatePdfOutput = generatePdfOutput;
-function generateSVGChild(canvas, components, wires, junctions, mergedWires, frameObjects, textObjects, gridBounds, extendGrid) {
+function generateSVGChild(canvas, components, wires, junctions, mergedWires, frameObjects, textObjects, gridBounds, extendGrid, logger) {
     const displayWireId = false;
     if (gridBounds === null) {
+        logger.add('get grid bounds');
         gridBounds = (0, layout_js_1.getBounds)(components, wires, junctions, frameObjects);
     }
-    drawGrid(canvas.group().translate(0, 0), gridBounds, extendGrid);
+    logger.add('grid bounds', gridBounds.xmin, gridBounds.ymin, gridBounds.xmax, gridBounds.ymax);
+    drawGrid(canvas.group().translate(0, 0), gridBounds, extendGrid, logger);
     components.forEach(item => {
         const { x, y, width, height } = item;
         const symbolGroup = canvas.group();
-        symbolGroup.translate(x, y);
+        symbolGroup.translate(x.toNumber(), y.toNumber());
         const { symbol = null } = item;
         if (symbol !== null && symbol) {
             const extra = {};
@@ -160,7 +173,7 @@ function generateSVGChild(canvas, components, wires, junctions, mergedWires, fra
                 family: 'Arial',
                 size: 50 * globals_js_1.fontDisplayScale,
             })
-                .translate(wire.x + 5, wire.y + 5);
+                .translate(wire.x.add(5).toNumber(), wire.y.add(5).toNumber());
         });
     }
     const mergedWireGroup = canvas.group();
@@ -177,10 +190,13 @@ function generateSVGChild(canvas, components, wires, junctions, mergedWires, fra
             })
                 .fill('none');
         });
+        const halfJunctionSize = globals_js_1.junctionSize.half();
         intersectPoints.forEach(point => {
-            const [x, y, count] = point;
-            mergedWireGroup.circle(globals_js_1.junctionSize)
-                .translate(x - globals_js_1.junctionSize / 2, y - globals_js_1.junctionSize / 2)
+            const [x, y,] = point;
+            const translateX = (0, ParamDefinition_js_1.numeric)(x).sub(halfJunctionSize);
+            const translateY = (0, ParamDefinition_js_1.numeric)(y).sub(halfJunctionSize);
+            mergedWireGroup.circle(globals_js_1.junctionSize.toNumber())
+                .translate(translateX.toNumber(), translateY.toNumber())
                 .fill(globals_js_1.ColorScheme.JunctionColor)
                 .stroke('none');
         });
@@ -194,11 +210,11 @@ function generateSVGChild(canvas, components, wires, junctions, mergedWires, fra
             drawSheetFrameBorder(frameGroup, item);
         }
         else {
-            if (borderWidth > 0) {
-                if (item.type === layout_js_1.RenderFrameType.Container) {
+            if (borderWidth.toNumber() > 0) {
+                if (item.renderType === layout_js_1.RenderFrameType.Container) {
                     strokeColor = '#111';
                 }
-                else if (item.type === layout_js_1.RenderFrameType.Elements) {
+                else if (item.renderType === layout_js_1.RenderFrameType.Elements) {
                     strokeColor = '#aaa';
                     if (!globals_js_1.RenderFlags.ShowElementFrames) {
                         return;
@@ -206,52 +222,61 @@ function generateSVGChild(canvas, components, wires, junctions, mergedWires, fra
                 }
                 const tmpRect = frameGroup.rect(width, height)
                     .fill('none')
-                    .stroke({ width: (0, helpers_js_1.milsToMM)(borderWidth), color: strokeColor });
-                tmpRect.translate(item.x, item.y);
+                    .stroke({
+                    width: (0, helpers_js_1.milsToMM)(borderWidth).toNumber(),
+                    color: strokeColor
+                });
+                tmpRect.translate(item.x.toNumber(), item.y.toNumber());
             }
         }
     });
     textObjects.forEach(item => {
         const { x, y, symbol } = item;
         const innerGroup = canvas.group();
-        innerGroup.translate(x, y);
+        innerGroup.translate(x.toNumber(), y.toNumber());
         symbol.draw(innerGroup);
     });
-    const originSize = (0, helpers_js_1.milsToMM)(10);
+    const originSize = (0, helpers_js_1.milsToMM)(10).toNumber();
     globals_js_1.RenderFlags.ShowOrigin && canvas.group().translate(0, 0)
         .circle(originSize)
         .translate(-originSize / 2, -originSize / 2)
         .stroke('none').fill('red');
 }
-function drawGrid(group, canvasSize, extendGrid) {
+function drawGrid(group, canvasSize, extendGrid, logger) {
     const gridSize = globals_js_1.defaultGridSizeUnits;
     const { xmin, ymin, xmax, ymax } = canvasSize;
     const extraValue = extendGrid ? 1 : 0;
-    const gridStartX = (Math.floor(xmin / gridSize) - extraValue) * gridSize;
-    const gridStartY = (Math.floor(ymin / gridSize) - extraValue) * gridSize;
+    const gridStartX = ((0, ParamDefinition_js_1.numeric)(Math.floor(xmin / gridSize)).sub(extraValue)).mul(gridSize);
+    const gridStartY = ((0, ParamDefinition_js_1.numeric)(Math.floor(ymin / gridSize)).sub(extraValue)).mul(gridSize);
     const gridEndX = extendGrid
-        ? (Math.ceil(xmax / gridSize) + extraValue) * gridSize
-        : (xmax - xmin);
+        ? ((0, ParamDefinition_js_1.numeric)(Math.ceil(xmax / gridSize)).add(extraValue)).mul(gridSize)
+        : ((0, ParamDefinition_js_1.numeric)(xmax).sub(xmin));
     const gridEndY = extendGrid
-        ? (Math.ceil(ymax / gridSize) + extraValue) * gridSize
-        : (ymax - ymin);
-    const numCols = Math.floor((gridEndX - gridStartX) / gridSize)
+        ? ((0, ParamDefinition_js_1.numeric)(Math.ceil(ymax / gridSize)).add(extraValue)).mul(gridSize)
+        : ((0, ParamDefinition_js_1.numeric)(ymax).sub(ymin));
+    const numCols = Math.floor(gridEndX.sub(gridStartX).div(gridSize).toNumber())
         + (extendGrid ? 1 : 0);
+    const originSize = (0, helpers_js_1.milsToMM)(10).toNumber();
+    globals_js_1.RenderFlags.ShowGridOrigin && group.circle(originSize)
+        .translate(-originSize / 2, -originSize / 2)
+        .stroke('none').fill('blue');
     const lines = [];
     const smallOffset = (0, helpers_js_1.milsToMM)(3);
-    const startY = gridStartY - smallOffset / 2;
-    const endY = gridEndY + smallOffset;
+    const startY = gridStartY.sub(smallOffset.half());
+    const endY = gridEndY.add(smallOffset);
+    const numericGridSize = (0, ParamDefinition_js_1.numeric)(gridSize);
     for (let i = 0; i < numCols; i++) {
-        const startX = gridStartX + i * gridSize;
-        lines.push(`M ${startX} ${startY} L ${startX} ${endY}`);
+        const startX = gridStartX.add(numericGridSize.mul(i)).toNumber();
+        lines.push(`M ${startX} ${startY.toNumber()} L ${startX} ${endY.toNumber()}`);
     }
     const strokeSize = (0, helpers_js_1.milsToMM)(3);
-    group.path(lines.join(" "))
+    group.addClass('grid')
+        .path(lines.join(" "))
         .attr({
-        'stroke-dasharray': `${strokeSize},${gridSize - strokeSize}`,
+        'stroke-dasharray': `${strokeSize.toNumber()},${numericGridSize.sub(strokeSize).toNumber()}`,
     })
         .stroke({
-        width: strokeSize,
+        width: strokeSize.toNumber(),
         color: '#000'
     });
 }
@@ -268,94 +293,7 @@ function drawSheetFrameBorder(frameGroup, frame) {
             symbol.draw(sheetFrameGroup);
             const offsetX = (0, helpers_js_1.milsToMM)(frameComponent.getParam('offset_x'));
             const offsetY = (0, helpers_js_1.milsToMM)(frameComponent.getParam('offset_y'));
-            sheetFrameGroup.translate(-offsetX, -offsetY);
-        }
-    }
-}
-function drawSheetFrameBorderDirect(frameGroup, frame, borderWidth, strokeColor, width, height) {
-    const commonStroke = {
-        width: (0, helpers_js_1.milsToMM)(borderWidth),
-        color: strokeColor
-    };
-    const commonFont = {
-        family: globals_js_1.defaultFont,
-        size: 50 * globals_js_1.fontDisplayScale,
-        'dominant-baseline': 'middle',
-        'text-anchor': 'middle',
-    };
-    let rows = 1;
-    let columns = 1;
-    let showGridReference = true;
-    if (helpers_js_1.PaperGridReferences[frame.size]) {
-        [rows, columns] = helpers_js_1.PaperGridReferences[frame.size];
-    }
-    else {
-        showGridReference = false;
-    }
-    if (!showGridReference) {
-        return;
-    }
-    const outerMargin = 2;
-    const outerWidth = width + outerMargin * 2;
-    const outerHeight = height + outerMargin * 2;
-    const outerRect = frameGroup.rect(outerWidth, outerHeight)
-        .fill('none')
-        .stroke(commonStroke);
-    outerRect.translate(frame.x - outerMargin, frame.y - outerMargin);
-    const gridWidth = outerWidth / columns;
-    const gridHeight = outerHeight / rows;
-    const pathPoints = [];
-    for (let i = 1; i < rows + 1; i++) {
-        const lineStartX = frame.x - outerMargin;
-        const lineStartX2 = frame.x - outerMargin + outerWidth - outerMargin;
-        const lineY = frame.y - outerMargin + (gridHeight * i);
-        if (i < rows) {
-            pathPoints.push(...[
-                "M", lineStartX, lineY, "L", lineStartX + outerMargin, lineY,
-                "M", lineStartX2, lineY, "L", lineStartX2 + outerMargin, lineY
-            ]);
+            sheetFrameGroup.translate(-offsetX.toNumber(), -offsetY.toNumber());
         }
-        const displayValue = String.fromCharCode(i + 64);
-        frameGroup.text(displayValue)
-            .font(commonFont)
-            .translate(lineStartX + outerMargin / 2, lineY - gridHeight / 2);
-        frameGroup.text(displayValue)
-            .font(commonFont)
-            .translate(lineStartX2 + outerMargin / 2, lineY - gridHeight / 2);
-    }
-    for (let i = 1; i < columns + 1; i++) {
-        const lineStartY = frame.y - outerMargin;
-        const lineStartY2 = frame.y - outerMargin + outerHeight - outerMargin;
-        const lineX = frame.x - outerMargin + (gridWidth * i);
-        if (i < columns) {
-            pathPoints.push(...[
-                "M", lineX, lineStartY, "L", lineX, lineStartY + outerMargin,
-                "M", lineX, lineStartY2, "L", lineX, lineStartY2 + outerMargin
-            ]);
-        }
-        frameGroup.text(i.toString())
-            .font(commonFont)
-            .translate(lineX - gridWidth / 2, lineStartY + outerMargin / 2 + (0, helpers_js_1.milsToMM)(10));
-        frameGroup.text(i.toString())
-            .font(commonFont)
-            .translate(lineX - gridWidth / 2, lineStartY2 + outerMargin / 2 + (0, helpers_js_1.milsToMM)(10));
-    }
-    frameGroup.path(pathPoints).stroke(commonStroke);
-    const titleWidth = (0, helpers_js_1.milsToMM)(3000);
-    const titleHeight = (0, helpers_js_1.milsToMM)(1000);
-    const rowHeight = (0, helpers_js_1.milsToMM)(200);
-    const points = [
-        "M", width - titleWidth, height,
-        "L", width - titleWidth, height - titleHeight,
-        "L", width, height - titleHeight,
-        "M", width - titleWidth, height - rowHeight,
-        "L", width, height - rowHeight,
-        "M", width - titleWidth, height - rowHeight * 2,
-        "L", width, height - rowHeight * 2,
-        "M", width - titleWidth, height - rowHeight * 3,
-        "L", width, height - rowHeight * 3
-    ];
-    frameGroup.path(points).stroke(commonStroke).fill('none');
-    if (frame.containsTitle) {
     }
 }

package/dist/cjs/sizing.js

@@ -67,27 +67,53 @@ function measureTextSize2(text, fontFamily, fontSize, fontWeight = 'regular', an
     }
     const key = `${text}-${fontFamily}-${fontSize}-${fontWeight}-${anchor}-${vanchor}`;
     if (measureTextSizeCache[key] === undefined) {
-        let dominantBaseline = 'hanging';
+        let dominantBaseline = geometry_js_1.VerticalAlignProp.Hanging;
         switch (vanchor) {
             case geometry_js_1.VerticalAlign.Top:
-                dominantBaseline = 'hanging';
+                dominantBaseline = geometry_js_1.VerticalAlignProp.Hanging;
                 break;
             case geometry_js_1.VerticalAlign.Middle:
-                dominantBaseline = 'middle';
+                dominantBaseline = geometry_js_1.VerticalAlignProp.Central;
                 break;
             case geometry_js_1.VerticalAlign.Bottom:
-                dominantBaseline = 'text-top';
+                dominantBaseline = geometry_js_1.VerticalAlignProp.TextTop;
+                break;
+        }
+        let useAnchor = geometry_js_1.HorizontalAlignProp.Start;
+        switch (anchor) {
+            case geometry_js_1.HorizontalAlign.Left:
+                useAnchor = geometry_js_1.HorizontalAlignProp.Start;
+                break;
+            case geometry_js_1.HorizontalAlign.Middle:
+                useAnchor = geometry_js_1.HorizontalAlignProp.Middle;
+                break;
+            case geometry_js_1.HorizontalAlign.Right:
+                useAnchor = geometry_js_1.HorizontalAlignProp.End;
                 break;
         }
         fontFamily = globals_js_1.defaultFont;
         const tmpTextElement = MainCanvas.text(text).font({
             family: fontFamily,
             size: fontSize,
-            anchor: anchor,
+            anchor: useAnchor,
             'dominant-baseline': dominantBaseline,
             weight: fontWeight,
-        }).fill('#333');
-        const textbox = tmpTextElement.bbox();
+        })
+            .attr("xml:space", "preserve")
+            .fill('#333');
+        let textbox = tmpTextElement.bbox();
+        const tmpTextBox = { ...textbox };
+        if (dominantBaseline === geometry_js_1.VerticalAlignProp.Hanging) {
+            tmpTextBox.y = textbox.cy - textbox.height;
+            tmpTextBox.y2 = tmpTextBox.y + textbox.height;
+            textbox = tmpTextBox;
+        }
+        else if (dominantBaseline === geometry_js_1.VerticalAlignProp.Central) {
+            tmpTextBox.y -= textbox.cy;
+            tmpTextBox.y2 -= textbox.cy;
+            tmpTextBox.cy = 0;
+            textbox = tmpTextBox;
+        }
         const { width, height } = textbox;
         tmpTextElement.remove();
         measureTextSizeCache[key] = {

package/dist/cjs/utils.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.combineMaps = exports.throwWithContext = exports.roundValue = exports.getPortType = exports.getBoundsSize = exports.toNearestGrid = exports.resizeToNearestGrid = exports.printBounds = exports.resizeBounds = exports.SimpleStopwatch = void 0;
+exports.areasOverlap = exports.isPointWithinArea = exports.resolveToNumericValue = exports.getNumberExponentialText = exports.getNumberExponential = exports.combineMaps = exports.throwWithContext = exports.roundValue = exports.getPortType = exports.getBoundsSize = exports.toNearestGrid = exports.resizeToNearestGrid = exports.printBounds = exports.resizeBounds = exports.SimpleStopwatch = void 0;
+const big_js_1 = require("big.js");
+const ParamDefinition_1 = require("./objects/ParamDefinition");
 class SimpleStopwatch {
     constructor() {
         this.startTime = new Date();
@@ -73,7 +75,7 @@ function getPortType(component) {
 }
 exports.getPortType = getPortType;
 function roundValue(value) {
-    return +value.toFixed(7);
+    return resolveToNumericValue(new big_js_1.Big(value.toBigNumber().toFixed(7)));
 }
 exports.roundValue = roundValue;
 function throwWithContext(context, message) {
@@ -100,3 +102,85 @@ function combineMaps(map1, map2) {
     return newMap;
 }
 exports.combineMaps = combineMaps;
+function getNumberExponential(value) {
+    value = value.trim();
+    switch (value) {
+        case 'G':
+            return 9;
+        case 'M':
+            return 6;
+        case 'k':
+        case 'K':
+            return 3;
+        case 'm':
+            return -3;
+        case 'u':
+            return -6;
+        case 'n':
+            return -9;
+        case 'p':
+            return -12;
+        case 'f':
+            return -15;
+        default:
+            return 0;
+    }
+}
+exports.getNumberExponential = getNumberExponential;
+function getNumberExponentialText(value) {
+    switch (value) {
+        case -15:
+            return 'f';
+        case -12:
+            return 'p';
+        case -9:
+            return 'n';
+        case -6:
+            return 'u';
+        case -3:
+            return 'm';
+        case 3:
+            return 'k';
+        case 6:
+            return 'M';
+        case 9:
+            return 'G';
+        case 0:
+        default:
+            return '';
+    }
+}
+exports.getNumberExponentialText = getNumberExponentialText;
+function resolveToNumericValue(value) {
+    if (value.toNumber() === 0) {
+        return new ParamDefinition_1.NumericValue(0);
+    }
+    const isNeg = value.lt(0);
+    const positiveValue = isNeg ? value.neg() : value;
+    const prefixPart = Math.floor(Math.log10(positiveValue.toNumber()) / 3);
+    let useValue = value;
+    if (prefixPart !== 0) {
+        const tmpValue1 = positiveValue.div(Math.pow(10, prefixPart * 3));
+        useValue = isNeg ? tmpValue1.neg() : tmpValue1;
+    }
+    return new ParamDefinition_1.NumericValue(useValue, prefixPart * 3);
+}
+exports.resolveToNumericValue = resolveToNumericValue;
+function isPointWithinArea(point, bounds) {
+    const [xPt, yPt] = point;
+    const [xmin, ymin, xmax, ymax] = bounds;
+    return (xPt > xmin && xPt < xmax && yPt > ymin && yPt < ymax);
+}
+exports.isPointWithinArea = isPointWithinArea;
+function areasOverlap(area1, area2) {
+    const [xmin, ymin, xmax, ymax] = area1;
+    const pt1 = [xmin, ymin];
+    const pt2 = [xmin, ymax];
+    const pt3 = [xmax, ymin];
+    const pt4 = [xmax, ymax];
+    return isPointWithinArea(pt1, area2)
+        || isPointWithinArea(pt2, area2)
+        || isPointWithinArea(pt3, area2)
+        || isPointWithinArea(pt4, area2);
+}
+exports.areasOverlap = areasOverlap;