circuitscript 0.0.29 → 0.0.32

package/dist/esm/execute.mjs

@@ -3,7 +3,7 @@ import { ClassComponent } from './objects/ClassComponent.mjs';
 import { ActiveObject, ExecutionScope, FrameAction, SequenceAction } from './objects/ExecutionScope.mjs';
 import { Net } from './objects/Net.mjs';
 import { PortSide } from './objects/PinDefinition.mjs';
-import { Direction } from './objects/types.mjs';
+import { DeclaredReference, Direction } from './objects/types.mjs';
 import { Wire } from './objects/Wire.mjs';
 import { Frame } from './objects/Frame.mjs';
 import { CalculatePinPositions } from './layout.mjs';
@@ -199,20 +199,20 @@ export class ExecutionContext {
         return component;
     }
     printPoint(extra = '') {
-        let netName = NoNetText;
+        let netString = NoNetText;
         if (this.scope.currentComponent === null || this.scope.currentPin === null) {
             this.log((extra !== '' ? (extra + ' ') : '') + 'point is null');
             return;
         }
         if (this.scope.hasNet(this.scope.currentComponent, this.scope.currentPin)) {
-            netName = this.scope
+            netString = this.scope
                 .getNet(this.scope.currentComponent, this.scope.currentPin)
                 .toString();
         }
         this.log((extra !== '' ? (extra + ' ') : '') + 'point: ' +
             this.scope.currentComponent.instanceName +
             ' ' +
-            this.scope.currentPin + ' ' + netName);
+            this.scope.currentPin + ' ' + netString);
     }
     addComponentExisting(component, pin) {
         const startPin = pin;
@@ -466,34 +466,34 @@ export class ExecutionContext {
         for (let i = 0; i < reversed.length; i++) {
             const context = reversed[i];
             if (context.hasFunction(idName)) {
-                return {
+                return new DeclaredReference({
                     found: true,
                     value: context.getFunction(idName),
                     type: ReferenceTypes.function,
                     name: idName,
-                };
+                });
             }
             else if (context.scope.variables.has(idName)) {
-                return {
+                return new DeclaredReference({
                     found: true,
                     value: context.scope.variables.get(idName),
                     type: ReferenceTypes.variable,
                     name: idName,
-                };
+                });
             }
             else if (context.scope.instances.has(idName)) {
-                return {
+                return new DeclaredReference({
                     found: true,
                     value: context.scope.instances.get(idName),
                     type: ReferenceTypes.instance,
                     name: idName,
-                };
+                });
             }
         }
-        return {
+        return new DeclaredReference({
             found: false,
             name: idName,
-        };
+        });
     }
     callFunction(functionName, functionParams, executionStack, netNamespace) {
         let __runFunc = null;
@@ -520,6 +520,7 @@ export class ExecutionContext {
         }
         if (__runFunc !== null) {
             this.log(`call function '${functionName}'`);
+            this.log(`net namespace: ${netNamespace}`);
             const functionResult = __runFunc(functionParams, { netNamespace });
             this.log(`done call function '${functionName}'`);
             return functionResult;
@@ -652,6 +653,10 @@ export class ExecutionContext {
         this.scope.setActive(ActiveObject.Wire, wireId);
         this.scope.sequence.push([SequenceAction.Wire, wireId, tmp]);
         this.scope.currentComponent.pinWires.set(this.scope.currentPin, tmp);
+        if (!this.scope.currentComponent.didSetWireOrientationAngle) {
+            this.applyComponentAngleFromWire(this.scope.currentComponent, this.scope.currentPin, true);
+            this.scope.currentComponent.didSetWireOrientationAngle = true;
+        }
     }
     addPoint(pointId, userDefined = true) {
         if (this.scope.instances.has(pointId)) {
@@ -702,18 +707,37 @@ export class ExecutionContext {
             this.scope.currentComponent.styles[key] = styles[key];
         }
     }
-    applyComponentAngleFromWire(component, pin) {
+    applyComponentAngleFromWire(component, pin, opposite = false) {
         if (this.componentAngleFollowsWire
             && component.followWireOrientationProp
             && component.useWireOrientationAngle
+            && !component.didSetWireOrientationAngle
             && this.scope.currentWireId !== -1) {
             const currentWire = this.scope.wires[this.scope.currentWireId];
-            const lastSegment = currentWire.path[currentWire.path.length - 1];
+            let useSegment = currentWire.path[currentWire.path.length - 1];
+            if (opposite) {
+                useSegment = currentWire.path[0];
+            }
             const pinPositions = CalculatePinPositions(component);
             if (pinPositions.has(pin)) {
                 const connectedPinPos = pinPositions.get(pin);
                 let targetAngle = null;
-                switch (lastSegment.direction) {
+                let useDirection = useSegment.direction;
+                if (opposite) {
+                    if (useDirection === Direction.Down) {
+                        useDirection = Direction.Up;
+                    }
+                    else if (useDirection === Direction.Up) {
+                        useDirection = Direction.Down;
+                    }
+                    else if (useDirection === Direction.Right) {
+                        useDirection = Direction.Left;
+                    }
+                    else if (useDirection === Direction.Left) {
+                        useDirection = Direction.Right;
+                    }
+                }
+                switch (useDirection) {
                     case Direction.Down:
                         targetAngle = 90;
                         break;
@@ -752,12 +776,14 @@ export class ExecutionContext {
                     component.setParam('angle', 270);
                 }
                 component.wireOrientationAngle = useAngle;
+                component.didSetWireOrientationAngle = true;
             }
         }
     }
     enterFrame() {
         const frameId = this.scope.frames.length + 1;
         const frameObject = new Frame(frameId);
+        this.log('Enter frame', frameId);
         this.scope.frames.push(frameObject);
         this.scope.sequence.push([SequenceAction.Frame,
             frameObject, FrameAction.Enter]);
@@ -769,6 +795,7 @@ export class ExecutionContext {
         const frame = this.scope.frames[frameId - 1];
         this.scope.sequence.push([SequenceAction.Frame,
             frame, FrameAction.Exit]);
+        this.log('Leave frame', frameId);
     }
 }
 function isWireSegmentsEndAuto(segments) {

package/dist/esm/geometry.mjs

@@ -1,7 +1,9 @@
 import Flatten from '@flatten-js/core';
 import { measureTextSize2 } from './sizing.mjs';
-import { defaultFont } from './globals.mjs';
+import { defaultFont, fontDisplayScale, PortArrowSize, PortPaddingHorizontal, PortPaddingVertical } from './globals.mjs';
 import { NumericValue } from './objects/ParamDefinition.mjs';
+import { AllPinTypes, PinTypes } from './objects/PinTypes.mjs';
+import { roundValue } from './utils.mjs';
 export class Textbox extends Flatten.Polygon {
     id;
     text;
@@ -41,32 +43,90 @@ export class Textbox extends Flatten.Polygon {
         else {
             throw 'Invalid string passed into textbox';
         }
-        const { fontSize = 10, anchor = HorizontalAlign.Left, vanchor = VerticalAlign.Bottom, fontWeight = 'regular', } = style ?? {};
-        const { width, height, box } = measureTextSize2(useText, defaultFont, fontSize, fontWeight, anchor, vanchor);
-        const polygonCoords = [
-            [box.x, box.y],
-            [box.x2, box.y],
-            [box.x2, box.y2],
-            [box.x, box.y2],
-            [box.x, box.y],
-        ];
+        const { fontSize = 10, anchor = HorizontalAlign.Left, vanchor = VerticalAlign.Bottom, fontWeight = 'regular', portType = null, } = style ?? {};
+        const { width, height, box } = measureTextSize2(useText, defaultFont, fontSize * fontDisplayScale, fontWeight, anchor, vanchor);
+        let polygonCoords = [];
+        let anchorOffsetX = 0;
+        let anchorOffsetY = 0;
+        if (portType === null) {
+            polygonCoords = [
+                [box.x, box.y],
+                [box.x2, box.y],
+                [box.x2, box.y2],
+                [box.x, box.y2],
+                [box.x, box.y],
+            ];
+        }
+        else if (AllPinTypes.indexOf(portType) !== -1) {
+            const paddingHorizontal = PortPaddingHorizontal;
+            const paddingVert = PortPaddingVertical;
+            if (portType === PinTypes.Input) {
+                polygonCoords = [
+                    [box.x - paddingHorizontal - PortArrowSize, box.y - paddingVert],
+                    [box.x2 + paddingHorizontal, box.y - paddingVert],
+                    [box.x2 + paddingHorizontal, box.y2 + paddingVert],
+                    [box.x - paddingHorizontal - PortArrowSize, box.y2 + paddingVert],
+                    [box.x - paddingHorizontal - PortArrowSize, box.y - paddingVert],
+                ];
+                anchorOffsetX += (PortArrowSize + paddingHorizontal);
+            }
+            else if (portType === PinTypes.Output) {
+                polygonCoords = [
+                    [box.x - paddingHorizontal, box.y - paddingVert],
+                    [box.x2 + paddingHorizontal + PortArrowSize, box.y - paddingVert],
+                    [box.x2 + paddingHorizontal + PortArrowSize, box.y2 + paddingVert],
+                    [box.x - paddingHorizontal, box.y2 + paddingVert],
+                    [box.x - paddingHorizontal, box.y - paddingVert],
+                ];
+                anchorOffsetX += paddingHorizontal;
+            }
+            else if (portType === PinTypes.IO) {
+                polygonCoords = [
+                    [box.x - paddingHorizontal - PortArrowSize, box.y - paddingVert],
+                    [box.x2 + paddingHorizontal + PortArrowSize, box.y - paddingVert],
+                    [box.x2 + paddingHorizontal + PortArrowSize, box.y2 + paddingVert],
+                    [box.x - paddingHorizontal - PortArrowSize, box.y2 + paddingVert],
+                    [box.x - paddingHorizontal - PortArrowSize, box.y - paddingVert],
+                ];
+                anchorOffsetX += paddingHorizontal + PortArrowSize;
+            }
+            else if (portType === PinTypes.Any) {
+                polygonCoords = [
+                    [box.x - paddingHorizontal, box.y - paddingVert],
+                    [box.x2 + paddingHorizontal, box.y - paddingVert],
+                    [box.x2 + paddingHorizontal, box.y2 + paddingVert],
+                    [box.x - paddingHorizontal, box.y2 + paddingVert],
+                    [box.x - paddingHorizontal, box.y - paddingVert],
+                ];
+                anchorOffsetX += paddingHorizontal;
+            }
+            anchorOffsetY += paddingVert / 2;
+        }
         const polygon = new Flatten.Polygon(polygonCoords);
-        return new Textbox(id, useText, [x, y], polygon, style, box, label);
+        return new Textbox(id, useText, [x + anchorOffsetX, y + anchorOffsetY], polygon, style, box, label);
     }
     rotate(angle, origin) {
         const feature = super.rotate(angle, origin);
-        return new Textbox(this.id, this.text, this.anchorPoint, feature, this.style, this.textMeasurementBounds, this.label);
+        const newAnchorPoint = this.transformAnchorPoint(segment => segment.rotate(angle, origin));
+        return new Textbox(this.id, this.text, newAnchorPoint, feature, this.style, this.textMeasurementBounds, this.label);
     }
     transform(matrix) {
         const feature = super.transform(matrix);
-        return new Textbox(this.id, this.text, this.anchorPoint, feature, this.style, this.textMeasurementBounds, this.label);
+        const newAnchorPoint = this.transformAnchorPoint(segment => segment.transform(matrix));
+        return new Textbox(this.id, this.text, newAnchorPoint, feature, this.style, this.textMeasurementBounds, this.label);
+    }
+    transformAnchorPoint(callback) {
+        const anchorPointSegment = new Flatten.Segment(new Flatten.Point(0, 0), new Flatten.Point(this.anchorPoint));
+        const newSegment = callback(anchorPointSegment);
+        const lastPoint = newSegment.vertices[newSegment.vertices.length - 1];
+        return [
+            lastPoint.x, lastPoint.y
+        ];
     }
     getLabelPosition() {
         return this.anchorPoint;
     }
 }
-export class Label extends Textbox {
-}
 export class GeometryProp {
     name;
     value;
@@ -150,7 +210,7 @@ export class Geometry {
                 && feature.text.trim().length === 0) {
                 return;
             }
-            if (feature instanceof Textbox && !feature.label) {
+            if (feature instanceof Textbox) {
                 const [x, y] = feature.anchorPoint;
                 box = {
                     xmin: box.xmin + x,
@@ -247,7 +307,9 @@ export class Geometry {
         const existingSegments = [];
         wirePoints.forEach(points => {
             const tmpPoints = points.map(pt => {
-                return new Flatten.Point(pt.x, pt.y);
+                const roundedX = roundValue(pt.x);
+                const roundedY = roundValue(pt.y);
+                return new Flatten.Point(roundedX, roundedY);
             });
             for (let i = 0; i < tmpPoints.length - 1; i++) {
                 const pt1 = tmpPoints[i];

package/dist/esm/globals.mjs

@@ -23,18 +23,49 @@ export var SymbolPinSide;
     SymbolPinSide["Left"] = "left";
     SymbolPinSide["Right"] = "right";
 })(SymbolPinSide || (SymbolPinSide = {}));
+export var LengthUnit;
+(function (LengthUnit) {
+    LengthUnit["mm"] = "mm";
+    LengthUnit["mils"] = "mils";
+    LengthUnit["px"] = "px";
+})(LengthUnit || (LengthUnit = {}));
+export var WireAutoDirection;
+(function (WireAutoDirection) {
+    WireAutoDirection["Auto"] = "auto";
+    WireAutoDirection["Auto_"] = "auto_";
+})(WireAutoDirection || (WireAutoDirection = {}));
+export const MilsToMM = 0.0254;
+export const MMToPx = 3.779276;
+export const MMToPt = 2.8346456693;
+export const PxToMM = 0.2645833;
 export const portWidth = 20;
 export const portHeight = 2;
-export const defaultFont = 'Open Sans-Regular, Arial';
-export const defaultFontBold = 'Open Sans-Bold, Arial-Bold, Arial';
+export const defaultGridSizeUnits = MilsToMM * 100;
+export const defaultZoomScale = 2.5;
+export const fontDisplayScale = 0.032;
+export const defaultSymbolLineWidth = MilsToMM * 6;
+export const defaultWireLineWidth = MilsToMM * 6;
+export const defaultPinNameTextSize = 40;
+export const defaultPinIdTextSize = 30;
+export const CustomSymbolPinTextSize = defaultPinNameTextSize;
+export const CustomSymbolPinIdSize = defaultPinIdTextSize;
+export const CustomSymbolRefDesSize = 50;
+export const CustomSymbolParamTextSize = 40;
+export const defaultFrameTitleTextSize = 60;
+export const displayUnits = LengthUnit.mils;
+export const defaultFont = 'Arial';
+export const defaultFontBold = 'Arial';
 export const defaultFontSize = 10;
-export const junctionSize = 5;
+export const junctionSize = MilsToMM * 20;
+export const PortArrowSize = MilsToMM * 50;
+export const PortPaddingHorizontal = MilsToMM * 10;
+export const PortPaddingVertical = MilsToMM * 10;
 export const ColorScheme = {
     BodyColor: 'rgb(255, 255, 194)',
     JunctionColor: 'rgba(0, 132, 0)',
     WireColor: 'rgb(0, 132, 0)',
-    PinLineColor: 'rgb(132, 0, 0)',
-    PinNameColor: 'rgb(0, 132, 132)',
+    PinLineColor: '#333',
+    PinNameColor: '#333',
 };
 export var ComponentTypes;
 (function (ComponentTypes) {

package/dist/esm/helpers.mjs

@@ -1,4 +1,6 @@
-import { readFileSync, writeFileSync } from "fs";
+import { readFileSync, writeFileSync, createWriteStream } from "fs";
+import PDFDocument from "pdfkit";
+import SVGtoPDF from "svg-to-pdfkit";
 import { generateKiCADNetList, printTree } from "./export.mjs";
 import { LayoutEngine } from "./layout.mjs";
 import { SequenceAction } from "./objects/ExecutionScope.mjs";
@@ -13,6 +15,7 @@ import { MainLexer } from "./lexer.mjs";
 import { CircuitScriptParser } from "./antlr/CircuitScriptParser.mjs";
 import { prepareTokens, SemanticTokensVisitor } from "./SemanticTokenVisitor.mjs";
 import path from "path";
+import { LengthUnit, MilsToMM, MMToPt, PxToMM } from "./globals.mjs";
 export var JSModuleType;
 (function (JSModuleType) {
     JSModuleType["CommonJs"] = "cjs";
@@ -163,7 +166,10 @@ export function renderScript(scriptData, outputPath, options) {
     const { tree, parser, hasParseError, hasError, parserTimeTaken, lexerTimeTaken } = parseFileWithVisitor(visitor, scriptData);
     showStats && console.log('Lexing took:', lexerTimeTaken);
     showStats && console.log('Parsing took:', parserTimeTaken);
-    dumpNets && console.log(visitor.dumpNets());
+    if (dumpNets) {
+        const nets = visitor.dumpNets();
+        console.log(nets);
+    }
     dumpData && writeFileSync('dump/tree.lisp', tree.toStringTree(null, parser));
     dumpData && writeFileSync('dump/raw-parser.txt', visitor.logger.dump());
     if (hasError || hasParseError) {
@@ -204,17 +210,47 @@ export function renderScript(scriptData, outputPath, options) {
     dumpData && writeFileSync('dump/raw-sequence.txt', tmpSequence.join('\n'));
     let svgOutput = null;
     try {
-        const layoutEngine = new LayoutEngine();
+        let fileExtension = null;
+        let showBaseFrame = false;
+        if (outputPath) {
+            fileExtension = path.extname(outputPath).substring(1);
+            if (fileExtension === 'pdf') {
+                showBaseFrame = true;
+            }
+        }
+        const layoutEngine = new LayoutEngine({
+            showBaseFrame,
+        });
         const layoutTimer = new SimpleStopwatch();
         const graph = layoutEngine.runLayout(sequence, nets);
         layoutEngine.printWarnings();
         showStats && console.log('Layout took:', layoutTimer.lap());
         dumpData && writeFileSync('dump/raw-layout.txt', layoutEngine.logger.dump());
         const generateSvgTimer = new SimpleStopwatch();
-        svgOutput = generateSVG2(graph);
+        const { svg: generatedSvg, width: svgWidth, height: svgHeight } = generateSVG2(graph);
+        svgOutput = generatedSvg;
         showStats && console.log('Render took:', generateSvgTimer.lap());
         if (outputPath) {
-            writeFileSync(outputPath, svgOutput);
+            if (fileExtension === 'svg') {
+                writeFileSync(outputPath, svgOutput);
+            }
+            else if (fileExtension === 'pdf') {
+                const doc = new PDFDocument({
+                    layout: 'landscape',
+                    size: 'A4',
+                });
+                const outputStream = createWriteStream(outputPath);
+                const paperWidthMM = 297;
+                const paperHeightMM = 210;
+                const xOffset = (paperWidthMM - svgWidth) / 2;
+                const yOffset = (paperHeightMM - svgHeight) / 2;
+                SVGtoPDF(doc, svgOutput, xOffset * MMToPt, yOffset * MMToPt);
+                doc.pipe(outputStream);
+                doc.end();
+            }
+            else {
+                throw "Invalid output format";
+            }
             console.log('Generated file', outputPath);
         }
     }
@@ -254,3 +290,36 @@ export function getPackageVersion() {
     const { version } = packageJson;
     return version;
 }
+export class UnitDimension {
+    type;
+    value;
+    constructor(value, type = LengthUnit.mils) {
+        this.value = value;
+        this.type = type;
+    }
+    getMM() {
+        switch (this.type) {
+            case LengthUnit.mm:
+                return this.value;
+            case LengthUnit.mils:
+                return this.value * MilsToMM;
+            case LengthUnit.px:
+                return this.value * PxToMM;
+        }
+    }
+    static mm(value) {
+        return new UnitDimension(value, LengthUnit.mm);
+    }
+    static mils(value) {
+        return new UnitDimension(value, LengthUnit.mils);
+    }
+    static px(value) {
+        return new UnitDimension(value, LengthUnit.px);
+    }
+}
+export function milsToMM(value) {
+    return value * MilsToMM;
+}
+export function pxToMM(value) {
+    return value * PxToMM;
+}