circuitscript 0.6.0 → 0.6.1

package/dist/cjs/errors.js

@@ -131,9 +131,12 @@ function collectErrorChain(error) {
 }
 exports.collectErrorChain = collectErrorChain;
 function printErrorChain(error) {
-    const errors = collectErrorChain(error);
-    errors.reverse();
-    for (const err of errors) {
+    let useErrors = collectErrorChain(error);
+    if (useErrors.length === 0) {
+        useErrors = [error];
+    }
+    useErrors.reverse();
+    for (const err of useErrors) {
         console.log("  " + err.toString());
     }
 }

package/dist/cjs/execute.js

@@ -1023,7 +1023,8 @@ class ExecutionContext {
         });
     }
     applyComponentAngleFromWire(component, pin, opposite = false) {
-        const targetUnit = component.getUnitForPin(pin);
+        const usePin = component.getPin(pin);
+        const targetUnit = component.getUnitForPin(usePin);
         if (this.componentAngleFollowsWire
             && targetUnit.followWireOrientationProp
             && targetUnit.useWireOrientationAngle
@@ -1035,8 +1036,8 @@ class ExecutionContext {
                 useSegment = currentWire.path[0];
             }
             const pinPositions = (0, layout_js_1.CalculatePinPositions)(targetUnit);
-            if (pinPositions.has(pin)) {
-                const connectedPinPos = pinPositions.get(pin);
+            if (pinPositions.has(usePin)) {
+                const connectedPinPos = pinPositions.get(usePin);
                 let targetAngle = null;
                 let useDirection = useSegment.direction;
                 if (opposite) {

package/dist/cjs/objects/ClassComponent.js

@@ -192,10 +192,10 @@ class ClassComponent {
         }
         throw new errors_js_1.RuntimeExecutionError(`Could not find pin '${pinId}' on component '${this.instanceName}'`);
     }
-    getNextPinAfter(pinIndex) {
+    getNextPinAfter(pinId) {
         const pins = Array.from(this.pins.keys());
-        pins.sort();
-        const index = pins.findIndex(tmp => tmp.equals(pinIndex));
+        const foundPin = this.getPin(pinId);
+        const index = pins.findIndex(tmp => tmp.equals(foundPin));
         if (index + 1 < pins.length) {
             return pins[index + 1];
         }

package/dist/cjs/regenerate-tests.js

@@ -27,13 +27,16 @@ async function regenerateTests(extra = "", fileList = []) {
         const outputPath = mainDir + 'svgs/' + file + extra + '.svg';
         env.setModuleDirectory(mainDir);
         env.setDefaultLibsPath(mainDir + '../../../libs/');
-        await (0, pipeline_js_1.renderScript)(scriptData, outputPath, {
+        const { errors } = await (0, pipeline_js_1.renderScript)(scriptData, outputPath, {
             inputPath,
             dumpNets: false,
             dumpData: false,
             showStats: false,
             environment: env,
         });
+        if (errors.length > 0) {
+            console.log(errors);
+        }
     }
     return cstFiles;
 }

package/dist/cjs/render/draw_symbols.js

@@ -456,6 +456,9 @@ class SymbolPlaceholder extends SymbolGraphic {
                 case PlaceHolderCommands.triangle:
                     drawing.addTriangle(...positionParams);
                     break;
+                case PlaceHolderCommands.arrow:
+                    drawing.addArrow(...positionParams);
+                    break;
                 case PlaceHolderCommands.pin:
                 case PlaceHolderCommands.hpin:
                 case PlaceHolderCommands.vpin:
@@ -683,6 +686,7 @@ var PlaceHolderCommands;
     PlaceHolderCommands["rect"] = "rect";
     PlaceHolderCommands["crect"] = "crect";
     PlaceHolderCommands["triangle"] = "triangle";
+    PlaceHolderCommands["arrow"] = "arrow";
     PlaceHolderCommands["pin"] = "pin";
     PlaceHolderCommands["hpin"] = "hpin";
     PlaceHolderCommands["vpin"] = "vpin";
@@ -1056,6 +1060,35 @@ class SymbolDrawing {
         ]));
         return this;
     }
+    addArrow(startX, startY, endX, endY, arrowLength = (0, NumericValue_js_1.numeric)(25), arrowWidth = (0, NumericValue_js_1.numeric)(25)) {
+        startX = (0, helpers_js_1.milsToMM)(startX);
+        startY = (0, helpers_js_1.milsToMM)(startY);
+        endX = (0, helpers_js_1.milsToMM)(endX);
+        endY = (0, helpers_js_1.milsToMM)(endY);
+        arrowLength = (0, helpers_js_1.milsToMM)(arrowLength);
+        arrowWidth = (0, helpers_js_1.milsToMM)(arrowWidth);
+        const dxNum = endX.sub(startX).toNumber();
+        const dyNum = endY.sub(startY).toNumber();
+        const len = Math.sqrt(dxNum * dxNum + dyNum * dyNum);
+        const unitDx = (0, NumericValue_js_1.numeric)(dxNum / len);
+        const unitDy = (0, NumericValue_js_1.numeric)(dyNum / len);
+        const arrowBaseX = endX.sub(unitDx.mul(arrowLength));
+        const arrowBaseY = endY.sub(unitDy.mul(arrowLength));
+        this.items.push(geometry_js_1.Geometry.segment([startX, startY], [arrowBaseX, arrowBaseY]));
+        const perpX = (0, NumericValue_js_1.numeric)(-unitDy.toNumber());
+        const perpY = (0, NumericValue_js_1.numeric)(unitDx.toNumber());
+        const dx1 = perpX.mul(arrowWidth).half();
+        const dy1 = perpY.mul(arrowWidth).half();
+        const dx2 = perpX.mul(arrowWidth.neg()).half();
+        const dy2 = perpY.mul(arrowWidth.neg()).half();
+        this.items.push(geometry_js_1.Geometry.polygon([
+            [dx1.add(arrowBaseX), dy1.add(arrowBaseY)],
+            [dx2.add(arrowBaseX), dy2.add(arrowBaseY)],
+            [endX, endY],
+            [dx1.add(arrowBaseX), dy1.add(arrowBaseY)],
+        ]));
+        return this;
+    }
     addLabel(x, y, textValue, style) {
         this.items.push(geometry_js_1.Geometry.label(null, x, y, textValue, style));
         return this;

package/dist/cjs/visitor.js

@@ -509,14 +509,17 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
                     let shouldIgnoreWireOrientation = false;
                     if (modifierText === globals_js_1.ParamKeys.flip) {
                         const flipValue = result.name;
+                        let didSetX = false;
+                        let didSetY = false;
                         if (flipValue.indexOf('x') !== -1) {
                             defaultUnit.setParam(globals_js_1.ParamKeys.flipX, (0, NumericValue_js_2.numeric)(1));
-                            shouldIgnoreWireOrientation = true;
+                            didSetX = true;
                         }
                         if (flipValue.indexOf('y') !== -1) {
                             defaultUnit.setParam(globals_js_1.ParamKeys.flipY, (0, NumericValue_js_2.numeric)(1));
-                            shouldIgnoreWireOrientation = true;
+                            didSetY = true;
                         }
+                        shouldIgnoreWireOrientation = didSetX && didSetY;
                     }
                     else if (modifierText === globals_js_1.ParamKeys.angle) {
                         defaultUnit.setParam(globals_js_1.ParamKeys.angle, result);
@@ -525,6 +528,9 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
                     else if (modifierText === 'anchor') {
                         dataResult.setParam('anchor', result.name);
                     }
+                    else {
+                        dataResult.setParam(modifierText, result);
+                    }
                     if (shouldIgnoreWireOrientation) {
                         defaultUnit.useWireOrientationAngle = false;
                     }
@@ -830,18 +836,36 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
         this.visitWire_expr = (ctx) => {
             const segments = [];
             ctx.ID().forEach((ctxId, index) => {
-                const value = ctxId.getText();
+                const valueText = ctxId.getText();
                 const ctxDataExpr = ctx.data_expr(index);
-                if ((value === globals_js_1.WireAutoDirection.Auto || value === globals_js_1.WireAutoDirection.Auto_) && ctxDataExpr === null) {
-                    segments.push([value]);
+                let value = null;
+                switch (valueText) {
+                    case 'right':
+                    case 'rg':
+                    case 'r':
+                        value = types_js_1.Direction.Right;
+                        break;
+                    case 'left':
+                    case 'lf':
+                    case 'l':
+                        value = types_js_1.Direction.Left;
+                        break;
+                    case 'up':
+                    case 'u':
+                        value = types_js_1.Direction.Up;
+                        break;
+                    case 'down':
+                    case 'dw':
+                    case 'd':
+                        value = types_js_1.Direction.Down;
+                        break;
+                }
+                if ((valueText === globals_js_1.WireAutoDirection.Auto || valueText === globals_js_1.WireAutoDirection.Auto_) && ctxDataExpr === null) {
+                    segments.push([valueText]);
                 }
                 else if (this.acceptedDirections.indexOf(value) !== -1 && ctxDataExpr) {
-                    let useValue = null;
-                    useValue = this.visitResult(ctxDataExpr);
-                    if (useValue instanceof NumericValue_js_1.NumericValue) {
-                        useValue = useValue.toNumber();
-                    }
-                    segments.push([value, new helpers_js_1.UnitDimension(useValue)]);
+                    const useValue = this.visitResult(ctxDataExpr);
+                    segments.push([value, new helpers_js_1.UnitDimension(useValue.toNumber())]);
                 }
                 else {
                     this.throwWithContext(ctx, "Invalid wire expression");
@@ -1175,6 +1199,7 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
         const suffix = properties.get('suffix') ?? null;
         let pins = [];
         if (display !== null && arrange === null && typeProp !== globals_js_1.ComponentTypes.graphic) {
+            display.variables = properties.get('params') ?? new Map();
             const drawCommands = display.getCommands();
             drawCommands.forEach(command => {
                 const [commandValue,] = command;
@@ -1182,9 +1207,11 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
                     || commandValue === draw_symbols_js_1.PlaceHolderCommands.hpin
                     || commandValue === draw_symbols_js_1.PlaceHolderCommands.pin) {
                     const id = PinDefinition_js_1.PinId.from(command[1][0]);
-                    const pinType = id.getType();
-                    const pinName = id.toString();
-                    pins.push(new PinDefinition_js_1.PinDefinition(id, pinType, pinName, PinTypes_js_1.PinTypes.Any));
+                    let pinName = id.toString();
+                    if (typeof command[1][1] === 'string') {
+                        pinName = command[1][1];
+                    }
+                    pins.push(new PinDefinition_js_1.PinDefinition(id, id.getType(), pinName, PinTypes_js_1.PinTypes.Any));
                 }
             });
         }

package/dist/esm/annotate/ComponentAnnotater.js

@@ -23,21 +23,15 @@ export class ComponentAnnotater {
         else {
             const type = instance.typeProp ?? 'conn';
             if (this.counter[type] === undefined && type.length <= 2) {
-                for (const [, value] of Object.entries(ComponentRefDesPrefixes)) {
-                    if (value === type) {
-                        throw "Refdes prefix is already in use!";
-                    }
-                }
-                if (ComponentRefDesPrefixes[type] === undefined) {
-                    ComponentRefDesPrefixes[type] = type;
-                    this.counter[type] = 1;
-                }
+                ComponentRefDesPrefixes[type] = type;
+                this.counter[type] = 1;
             }
+            let useType = type;
             if (ComponentRefDesPrefixes[type] === undefined) {
-                return null;
+                useType = 'conn';
             }
-            usePrefix = ComponentRefDesPrefixes[type];
-            useCounterKey = type;
+            usePrefix = ComponentRefDesPrefixes[useType];
+            useCounterKey = useType;
         }
         let prefix = '';
         let resultRefdes = '';