circuitscript 0.1.0 → 0.1.3

package/dist/esm/render.mjs

@@ -1,10 +1,10 @@
 import { SVG, registerWindow } from '@svgdotjs/svg.js';
 import { ExtractDrawingRects, RenderFrameType, getBounds } from "./layout.mjs";
 import { applyFontsToSVG, getCreateSVGWindow } from './sizing.mjs';
-import { ColorScheme, ComponentTypes, FrameType, MMToPt, MMToPx, ParamKeys, RenderFlags, defaultFont, defaultGridSizeUnits, defaultPageSpacingMM, defaultWireLineWidth, fontDisplayScale, junctionSize } from './globals.mjs';
-import { NumericValue } from './objects/ParamDefinition.mjs';
+import { ColorScheme, ComponentTypes, FrameType, MMToPt, MMToPx, ParamKeys, RenderFlags, defaultGridSizeUnits, defaultPageSpacingMM, defaultWireLineWidth, fontDisplayScale, junctionSize } from './globals.mjs';
+import { numeric, NumericValue } from './objects/ParamDefinition.mjs';
 import { combineMaps, getBoundsSize } from './utils.mjs';
-import { getPaperSize, milsToMM, PaperGridReferences } from './helpers.mjs';
+import { getPaperSize, milsToMM } from './helpers.mjs';
 import SVGtoPDF from 'svg-to-pdfkit';
 import { FrameParamKeys } from './objects/Frame.mjs';
 import { SymbolPlaceholder } from './draw_symbols.mjs';
@@ -16,19 +16,21 @@ function createSvgCanvas() {
     applyFontsToSVG(canvas);
     return canvas;
 }
-export function renderSheetsToSVG(sheetFrames) {
+export 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 = numeric(0);
         if (sheet.frame.frame) {
+            logger.add('drawing frame');
             const frameComponent = sheet.frame.frame.parameters
                 .get(FrameParamKeys.SheetType);
             if (frameComponent) {
@@ -36,34 +38,43 @@ export function renderSheetsToSVG(sheetFrames) {
                     throw 'Invalid graphic object for sheet frame';
                 }
                 const frameRects = ExtractDrawingRects(frameComponent.displayProp) ?? [];
-                let originalWidthMM = 0;
-                let originalHeightMM = 0;
-                let widthMM = 0;
-                let heightMM = 0;
-                if (frameRects[0]) {
-                    originalWidthMM = milsToMM(frameRects[0].width);
-                    originalHeightMM = milsToMM(frameRects[0].height);
+                let originalWidthMM = numeric(0);
+                let originalHeightMM = numeric(0);
+                let widthMM = numeric(0);
+                let heightMM = numeric(0);
+                const paperRect = frameRects.find(item => item.className === 'paper-area');
+                const plotRect = frameRects.find(item => item.className === 'plot-area');
+                if (paperRect) {
+                    originalWidthMM = milsToMM(paperRect.width);
+                    originalHeightMM = milsToMM(paperRect.height);
+                    logger.add('first frame size: ' + originalWidthMM.toNumber()
+                        + ' ' + originalHeightMM.toNumber());
                 }
-                if (frameRects[1]) {
-                    widthMM = milsToMM(frameRects[1].width);
-                    heightMM = milsToMM(frameRects[1].height);
+                if (plotRect) {
+                    widthMM = milsToMM(plotRect.width);
+                    heightMM = milsToMM(plotRect.height);
+                    logger.add('second frame size: ' + widthMM.toNumber()
+                        + ' ' + heightMM.toNumber());
                 }
-                xOffset = (originalWidthMM - widthMM) / 2;
-                yOffset = (originalHeightMM - heightMM) / 2;
-                sheetYOffset = index * (originalHeightMM + defaultPageSpacingMM);
+                xOffset = (originalWidthMM.sub(widthMM)).half().toNumber();
+                yOffset = (originalHeightMM.sub(heightMM)).half().toNumber();
+                logger.add('offset', xOffset, yOffset);
+                sheetYOffset = originalHeightMM.add(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;
 }
@@ -105,16 +116,18 @@ export function generatePdfOutput(doc, canvas, sheetSize, sheetSizeDefined, zoom
         }
     });
 }
-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 = 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 = {};
@@ -151,7 +164,7 @@ function generateSVGChild(canvas, components, wires, junctions, mergedWires, fra
                 family: 'Arial',
                 size: 50 * fontDisplayScale,
             })
-                .translate(wire.x + 5, wire.y + 5);
+                .translate(wire.x.add(5).toNumber(), wire.y.add(5).toNumber());
         });
     }
     const mergedWireGroup = canvas.group();
@@ -168,10 +181,13 @@ function generateSVGChild(canvas, components, wires, junctions, mergedWires, fra
             })
                 .fill('none');
         });
+        const halfJunctionSize = junctionSize.half();
         intersectPoints.forEach(point => {
-            const [x, y, count] = point;
-            mergedWireGroup.circle(junctionSize)
-                .translate(x - junctionSize / 2, y - junctionSize / 2)
+            const [x, y,] = point;
+            const translateX = numeric(x).sub(halfJunctionSize);
+            const translateY = numeric(y).sub(halfJunctionSize);
+            mergedWireGroup.circle(junctionSize.toNumber())
+                .translate(translateX.toNumber(), translateY.toNumber())
                 .fill(ColorScheme.JunctionColor)
                 .stroke('none');
         });
@@ -185,11 +201,11 @@ function generateSVGChild(canvas, components, wires, junctions, mergedWires, fra
             drawSheetFrameBorder(frameGroup, item);
         }
         else {
-            if (borderWidth > 0) {
-                if (item.type === RenderFrameType.Container) {
+            if (borderWidth.toNumber() > 0) {
+                if (item.renderType === RenderFrameType.Container) {
                     strokeColor = '#111';
                 }
-                else if (item.type === RenderFrameType.Elements) {
+                else if (item.renderType === RenderFrameType.Elements) {
                     strokeColor = '#aaa';
                     if (!RenderFlags.ShowElementFrames) {
                         return;
@@ -197,52 +213,61 @@ function generateSVGChild(canvas, components, wires, junctions, mergedWires, fra
                 }
                 const tmpRect = frameGroup.rect(width, height)
                     .fill('none')
-                    .stroke({ width: milsToMM(borderWidth), color: strokeColor });
-                tmpRect.translate(item.x, item.y);
+                    .stroke({
+                    width: 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 = milsToMM(10);
+    const originSize = milsToMM(10).toNumber();
     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 = 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 = (numeric(Math.floor(xmin / gridSize)).sub(extraValue)).mul(gridSize);
+    const gridStartY = (numeric(Math.floor(ymin / gridSize)).sub(extraValue)).mul(gridSize);
     const gridEndX = extendGrid
-        ? (Math.ceil(xmax / gridSize) + extraValue) * gridSize
-        : (xmax - xmin);
+        ? (numeric(Math.ceil(xmax / gridSize)).add(extraValue)).mul(gridSize)
+        : (numeric(xmax).sub(xmin));
     const gridEndY = extendGrid
-        ? (Math.ceil(ymax / gridSize) + extraValue) * gridSize
-        : (ymax - ymin);
-    const numCols = Math.floor((gridEndX - gridStartX) / gridSize)
+        ? (numeric(Math.ceil(ymax / gridSize)).add(extraValue)).mul(gridSize)
+        : (numeric(ymax).sub(ymin));
+    const numCols = Math.floor(gridEndX.sub(gridStartX).div(gridSize).toNumber())
         + (extendGrid ? 1 : 0);
+    const originSize = milsToMM(10).toNumber();
+    RenderFlags.ShowGridOrigin && group.circle(originSize)
+        .translate(-originSize / 2, -originSize / 2)
+        .stroke('none').fill('blue');
     const lines = [];
     const smallOffset = milsToMM(3);
-    const startY = gridStartY - smallOffset / 2;
-    const endY = gridEndY + smallOffset;
+    const startY = gridStartY.sub(smallOffset.half());
+    const endY = gridEndY.add(smallOffset);
+    const numericGridSize = 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 = 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'
     });
 }
@@ -259,94 +284,7 @@ function drawSheetFrameBorder(frameGroup, frame) {
             symbol.draw(sheetFrameGroup);
             const offsetX = milsToMM(frameComponent.getParam('offset_x'));
             const offsetY = milsToMM(frameComponent.getParam('offset_y'));
-            sheetFrameGroup.translate(-offsetX, -offsetY);
-        }
-    }
-}
-function drawSheetFrameBorderDirect(frameGroup, frame, borderWidth, strokeColor, width, height) {
-    const commonStroke = {
-        width: milsToMM(borderWidth),
-        color: strokeColor
-    };
-    const commonFont = {
-        family: defaultFont,
-        size: 50 * fontDisplayScale,
-        'dominant-baseline': 'middle',
-        'text-anchor': 'middle',
-    };
-    let rows = 1;
-    let columns = 1;
-    let showGridReference = true;
-    if (PaperGridReferences[frame.size]) {
-        [rows, columns] = 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 + milsToMM(10));
-        frameGroup.text(i.toString())
-            .font(commonFont)
-            .translate(lineX - gridWidth / 2, lineStartY2 + outerMargin / 2 + milsToMM(10));
-    }
-    frameGroup.path(pathPoints).stroke(commonStroke);
-    const titleWidth = milsToMM(3000);
-    const titleHeight = milsToMM(1000);
-    const rowHeight = 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/esm/sizing.mjs

@@ -1,5 +1,5 @@
 import { SVG, registerWindow } from '@svgdotjs/svg.js';
-import { HorizontalAlign, VerticalAlign } from './geometry.mjs';
+import { HorizontalAlign, HorizontalAlignProp, VerticalAlign, VerticalAlignProp } from './geometry.mjs';
 import { defaultFont } from './globals.mjs';
 import { JSModuleType, detectJSModuleType } from './helpers.mjs';
 let MainCanvas = null;
@@ -38,27 +38,53 @@ export function measureTextSize2(text, fontFamily, fontSize, fontWeight = 'regul
     }
     const key = `${text}-${fontFamily}-${fontSize}-${fontWeight}-${anchor}-${vanchor}`;
     if (measureTextSizeCache[key] === undefined) {
-        let dominantBaseline = 'hanging';
+        let dominantBaseline = VerticalAlignProp.Hanging;
         switch (vanchor) {
             case VerticalAlign.Top:
-                dominantBaseline = 'hanging';
+                dominantBaseline = VerticalAlignProp.Hanging;
                 break;
             case VerticalAlign.Middle:
-                dominantBaseline = 'middle';
+                dominantBaseline = VerticalAlignProp.Central;
                 break;
             case VerticalAlign.Bottom:
-                dominantBaseline = 'text-top';
+                dominantBaseline = VerticalAlignProp.TextTop;
+                break;
+        }
+        let useAnchor = HorizontalAlignProp.Start;
+        switch (anchor) {
+            case HorizontalAlign.Left:
+                useAnchor = HorizontalAlignProp.Start;
+                break;
+            case HorizontalAlign.Middle:
+                useAnchor = HorizontalAlignProp.Middle;
+                break;
+            case HorizontalAlign.Right:
+                useAnchor = HorizontalAlignProp.End;
                 break;
         }
         fontFamily = 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 === VerticalAlignProp.Hanging) {
+            tmpTextBox.y = textbox.cy - textbox.height;
+            tmpTextBox.y2 = tmpTextBox.y + textbox.height;
+            textbox = tmpTextBox;
+        }
+        else if (dominantBaseline === 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/esm/utils.mjs

@@ -1,3 +1,5 @@
+import { Big } from 'big.js';
+import { NumericValue } from "./objects/ParamDefinition";
 export class SimpleStopwatch {
     startTime;
     constructor() {
@@ -64,7 +66,7 @@ export function getPortType(component) {
     return foundPinType;
 }
 export function roundValue(value) {
-    return +value.toFixed(7);
+    return resolveToNumericValue(new Big(value.toBigNumber().toFixed(7)));
 }
 export function throwWithContext(context, message) {
     const startLine = context.start?.line;
@@ -88,3 +90,80 @@ export function combineMaps(map1, map2) {
     });
     return newMap;
 }
+export 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;
+    }
+}
+export 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 '';
+    }
+}
+export function resolveToNumericValue(value) {
+    if (value.toNumber() === 0) {
+        return new 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 NumericValue(useValue, prefixPart * 3);
+}
+export function isPointWithinArea(point, bounds) {
+    const [xPt, yPt] = point;
+    const [xmin, ymin, xmax, ymax] = bounds;
+    return (xPt > xmin && xPt < xmax && yPt > ymin && yPt < ymax);
+}
+export 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);
+}