circuitscript 0.0.37 → 0.1.0

package/dist/esm/builtinMethods.mjs

@@ -41,7 +41,7 @@ function range(...args) {
 }
 function enumerate(array) {
     if (!Array.isArray(array)) {
-        throw "Invalid parameter for enumerate function!";
+        throw "Invalid parameter for enumerate function";
     }
     const output = array.map((item, index) => {
         return [index, item];
@@ -82,7 +82,10 @@ function toString(obj) {
         return "[" + inner + "]";
     }
     else {
-        if (obj.toString) {
+        if (obj.toDisplayString) {
+            return obj.toDisplayString();
+        }
+        else if (obj.toString) {
             return obj.toString();
         }
         else {

package/dist/esm/draw_symbols.mjs

@@ -2,7 +2,8 @@ import { milsToMM } from "./helpers.mjs";
 import { ColorScheme, CustomSymbolParamTextSize, CustomSymbolPinIdSize, CustomSymbolPinTextSize, CustomSymbolRefDesSize, PortArrowSize, PortPaddingHorizontal, PortPaddingVertical, ReferenceTypes, SymbolPinSide, defaultFont, defaultPinIdTextSize, defaultPinNameTextSize, defaultSymbolLineWidth, fontDisplayScale } from "./globals.mjs";
 import { Geometry, GeometryProp, HorizontalAlign, Textbox, VerticalAlign } from "./geometry.mjs";
 import { PinTypes } from "./objects/PinTypes.mjs";
-import { roundValue } from "./utils.mjs";
+import { roundValue, throwWithContext } from "./utils.mjs";
+import { DeclaredReference, UndeclaredReference } from "./objects/types.mjs";
 export class SymbolGraphic {
     drawPortsName = true;
     displayBounds = false;
@@ -13,6 +14,9 @@ export class SymbolGraphic {
     width;
     height;
     labelTexts = new Map();
+    constructor() {
+        this.drawing = new SymbolDrawing();
+    }
     get angle() {
         return (this._angle % 360);
     }
@@ -310,15 +314,6 @@ export class SymbolGraphic {
             return VerticalAlign.Middle;
         }
     }
-    setLabelValue(labelId, labelValue) {
-        this.labelTexts.set(labelId, labelValue);
-    }
-    getLabelValue(labelId) {
-        if (this.labelTexts.has(labelId)) {
-            return this.labelTexts.get(labelId);
-        }
-        return undefined;
-    }
 }
 export function SymbolFactory(name) {
     switch (name) {
@@ -329,7 +324,8 @@ export function SymbolFactory(name) {
 }
 export class SymbolPointHidden extends SymbolGraphic {
     generateDrawing() {
-        const drawing = new SymbolDrawing();
+        const drawing = this.drawing;
+        drawing.clear();
         drawing.addPin(1, 0, 0, 0, 0);
         this.drawing = drawing;
     }
@@ -343,7 +339,8 @@ export class SymbolText extends SymbolGraphic {
         this.text = text;
     }
     generateDrawing() {
-        const drawing = new SymbolDrawing();
+        const drawing = this.drawing;
+        drawing.clear();
         drawing.addTextbox(0, 0, this.text, {
             fontSize: this.fontSize,
             anchor: HorizontalAlign.Middle,
@@ -370,7 +367,17 @@ export class SymbolPlaceholder extends SymbolGraphic {
         drawing.log('id: ', drawing.id, 'angle: ', this._angle, "commands:", commands.length);
         let lineColor = "#333";
         let textColor = "#333";
-        commands.forEach(([commandName, positionParams, keywordParams]) => {
+        commands.forEach(([commandName, positionParams, keywordParams, ctx]) => {
+            positionParams = positionParams.map(param => {
+                return this.resolveReference(param);
+            });
+            if (keywordParams instanceof Map) {
+                const tmpKeywordParams = new Map(keywordParams);
+                tmpKeywordParams.forEach((value, key) => {
+                    tmpKeywordParams.set(key, this.resolveReference(value));
+                });
+                keywordParams = tmpKeywordParams;
+            }
             switch (commandName) {
                 case PlaceHolderCommands.rect:
                     drawing.log('add rect', ...positionParams);
@@ -426,16 +433,17 @@ export class SymbolPlaceholder extends SymbolGraphic {
                     if (style['textColor'] === undefined) {
                         style['textColor'] = textColor;
                     }
-                    positionParams = [...positionParams];
-                    positionParams.push(style);
-                    const labelId = positionParams[0];
-                    const tmpPositionParams = [...positionParams];
-                    const tmpLabelValue = this.getLabelValue(labelId);
-                    if (tmpLabelValue !== undefined) {
-                        tmpPositionParams[3] = tmpLabelValue;
-                    }
+                    const tmpPositionParams = [
+                        positionParams[1], positionParams[2],
+                        positionParams[0], style
+                    ];
                     drawing.log('add label', JSON.stringify(tmpPositionParams));
-                    drawing.addLabelId(...tmpPositionParams);
+                    try {
+                        drawing.addLabelMils(...tmpPositionParams);
+                    }
+                    catch (err) {
+                        throwWithContext(ctx, err);
+                    }
                     break;
                 }
                 case PlaceHolderCommands.text: {
@@ -459,13 +467,30 @@ export class SymbolPlaceholder extends SymbolGraphic {
         });
         drawing.log("=== end generate drawing ===");
     }
+    resolveReference(param) {
+        if (param instanceof DeclaredReference) {
+            return param.value;
+        }
+        else if (param instanceof UndeclaredReference) {
+            throw "Undefined symbol: " + param.nameString();
+        }
+        return param;
+    }
     parseLabelStyle(keywordParams) {
         const keywords = ['fontSize', 'anchor', 'vanchor',
-            'angle', 'textColor', 'portType'];
+            'angle', 'textColor', 'portType', 'bold'];
         const style = {};
         keywords.forEach(item => {
             if (keywordParams.has(item)) {
                 style[item] = keywordParams.get(item);
+                if (item === 'bold') {
+                    if (keywordParams.get(item) === true) {
+                        style['fontWeight'] = 'bold';
+                    }
+                    else {
+                        style['fontWeight'] = 'normal';
+                    }
+                }
             }
         });
         return style;
@@ -625,7 +650,8 @@ export class SymbolCustom extends SymbolGraphic {
         });
         const maxLeftPins = Math.max(...leftPins.map(item => item.position)) + 1;
         const maxRightPins = Math.max(...rightPins.map(item => item.position)) + 1;
-        const drawing = new SymbolDrawing();
+        this.drawing.clear();
+        const drawing = this.drawing;
         drawing.angle = this._angle;
         drawing.flipX = this._flipX;
         drawing.flipY = this._flipY;
@@ -678,14 +704,14 @@ export class SymbolCustom extends SymbolGraphic {
                 textColor: defaultLineColor
             });
         });
-        const instanceName = this.getLabelValue("refdes");
+        const instanceName = drawing.variables.get('refdes');
         instanceName && drawing.addLabel(-bodyWidthMM / 2, -bodyHeightMM / 2 - milsToMM(20), instanceName, {
             fontSize: CustomSymbolRefDesSize,
             anchor: HorizontalAlign.Left,
         });
         const acceptedMPNKeys = ['MPN', 'mpn', 'manufacturer_pn'];
         acceptedMPNKeys.some(key => {
-            const labelValue = this.getLabelValue(key);
+            const labelValue = drawing.variables.get(key);
             if (labelValue !== undefined) {
                 drawing.addLabel(-bodyWidthMM / 2, bodyHeightMM / 2 + milsToMM(20), labelValue, {
                     fontSize: CustomSymbolParamTextSize,
@@ -742,6 +768,7 @@ export class SymbolDrawing {
     flipY = 0;
     mainOrigin = [0, 0];
     logger = null;
+    variables = new Map();
     clear() {
         this.items = [];
         this.pins = [];
@@ -857,10 +884,10 @@ export class SymbolDrawing {
         this.items.push(Geometry.label(null, x, y, textValue, style));
         return this;
     }
-    addLabelId(id, x, y, textValue, style) {
+    addLabelMils(x, y, textValue, style) {
         x = milsToMM(x);
         y = milsToMM(y);
-        this.items.push(Geometry.label(id, x, y, textValue, style));
+        this.items.push(Geometry.label(null, x, y, textValue, style));
         return this;
     }
     addTextbox(x, y, textValue, style) {
@@ -1086,31 +1113,24 @@ export class SymbolDrawing {
 }
 export class SymbolDrawingCommands extends SymbolDrawing {
     id = "";
-    commands;
-    constructor(commands) {
+    commands = [];
+    paramIds = [];
+    callback;
+    constructor(callback) {
         super();
-        this.commands = commands;
+        this.callback = callback;
         this.id = Math.random().toString().slice(2);
     }
+    runCommands() {
+        this.commands = this.callback(this.variables);
+    }
     getCommands() {
+        this.runCommands();
         return this.commands;
     }
     clone() {
-        const tmpCommands = this.commands.map(item => {
-            if (item[0] === PlaceHolderCommands.label) {
-                const commandName = item[0];
-                const positionParams = item[1];
-                const keywordParams = item[2];
-                const newMap = new Map();
-                for (const [key, value] of keywordParams) {
-                    newMap.set(key, value);
-                }
-                return [commandName, positionParams, newMap];
-            }
-            else {
-                return [...item];
-            }
-        });
-        return new SymbolDrawingCommands(tmpCommands);
+        const cloned = new SymbolDrawingCommands(this.callback);
+        cloned.variables = this.variables;
+        return cloned;
     }
 }

package/dist/esm/execute.mjs

@@ -465,7 +465,7 @@ export class ExecutionContext {
     getFunction(functionName) {
         return this.scope.functions.get(functionName);
     }
-    resolveVariable(executionStack, idName) {
+    resolveVariable(executionStack, idName, trailers = []) {
         const reversed = [...executionStack].reverse();
         for (let i = 0; i < reversed.length; i++) {
             const context = reversed[i];
@@ -477,21 +477,34 @@ export class ExecutionContext {
                     name: idName,
                 });
             }
-            else if (context.scope.variables.has(idName)) {
-                return new DeclaredReference({
-                    found: true,
-                    value: context.scope.variables.get(idName),
-                    type: ReferenceTypes.variable,
-                    name: idName,
-                });
-            }
-            else if (context.scope.instances.has(idName)) {
-                return new DeclaredReference({
-                    found: true,
-                    value: context.scope.instances.get(idName),
-                    type: ReferenceTypes.instance,
-                    name: idName,
-                });
+            else {
+                const isVariable = context.scope.variables.has(idName);
+                const isComponentInstance = context.scope.instances.has(idName);
+                if (isVariable || isComponentInstance) {
+                    const scopeList = isVariable ? context.scope.variables
+                        : context.scope.instances;
+                    let parentValue = undefined;
+                    let useValue = scopeList.get(idName);
+                    if (trailers.length > 0) {
+                        parentValue = useValue;
+                        const trailersPath = trailers.join(".");
+                        if (isVariable) {
+                            useValue = parentValue[trailersPath];
+                        }
+                        else if (isComponentInstance) {
+                            useValue = parentValue.parameters.get(trailersPath);
+                        }
+                    }
+                    return new DeclaredReference({
+                        type: isVariable ? ReferenceTypes.variable
+                            : ReferenceTypes.instance,
+                        found: (useValue !== undefined),
+                        parentValue,
+                        value: useValue,
+                        name: idName,
+                        trailers,
+                    });
+                }
             }
         }
         return new DeclaredReference({

package/dist/esm/globals.mjs

@@ -97,6 +97,7 @@ export var FrameType;
     FrameType[FrameType["Frame"] = 1] = "Frame";
     FrameType[FrameType["Sheet"] = 2] = "Sheet";
 })(FrameType || (FrameType = {}));
+export const ModuleContainsKeyword = 'contains';
 export const GlobalDocumentName = 'document';
 export const RenderFlags = {
     ShowElementFrames: false,

package/dist/esm/layout.mjs

@@ -2,11 +2,10 @@ import { Graph, alg } from '@dagrejs/graphlib';
 import { SymbolCustom, SymbolDrawing, SymbolFactory, 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 { 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';
 export class LayoutEngine {
@@ -287,7 +286,9 @@ export class LayoutEngine {
         const contentsBounds = resizeBounds(getBoundsFromPoints(boundPoints), frame.padding);
         if (frame.frame.parameters.has(FrameParamKeys.SheetType)) {
             const frameComponent = frame.frame.parameters.get(FrameParamKeys.SheetType);
-            const rects = ExtractDrawingRects(frameComponent.displayProp);
+            const frameDrawing = frameComponent.displayProp;
+            frameDrawing.variables = combineMaps(frameComponent.parameters, frame.frame.parameters);
+            const rects = ExtractDrawingRects(frameDrawing);
             let frameWidth = 0;
             let frameHeight = 0;
             if (rects[1]) {
@@ -373,7 +374,8 @@ 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;
@@ -448,7 +450,7 @@ export class LayoutEngine {
                             tmpSymbol = new SymbolCustom(symbolPinDefinitions);
                         }
                     }
-                    applyComponentParamsToSymbol(typeProp, component, tmpSymbol);
+                    applyComponentParamsToSymbol(component, tmpSymbol);
                     let didSetAngle = false;
                     if (component.parameters.has('angle')) {
                         didSetAngle = true;
@@ -996,28 +998,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;
@@ -1341,6 +1327,7 @@ export function CalculatePinPositions(component) {
         const symbolPinDefinitions = generateLayoutPinDefinition(component);
         tmpSymbol = new SymbolCustom(symbolPinDefinitions);
     }
+    applyComponentParamsToSymbol(component, tmpSymbol);
     tmpSymbol.refreshDrawing();
     const pins = component.pins;
     pins.forEach((value, key) => {

package/dist/esm/objects/Frame.mjs

@@ -17,6 +17,8 @@ export var FrameParamKeys;
     FrameParamKeys["Height"] = "height";
     FrameParamKeys["PaperSize"] = "paper_size";
     FrameParamKeys["SheetType"] = "sheet_type";
+    FrameParamKeys["SheetNumber"] = "sheet_number";
+    FrameParamKeys["SheetTotal"] = "sheet_total";
 })(FrameParamKeys || (FrameParamKeys = {}));
 export var FramePlotDirection;
 (function (FramePlotDirection) {

package/dist/esm/objects/types.mjs

@@ -6,6 +6,17 @@ export class UndeclaredReference {
     throwMessage() {
         return `Unknown symbol: ${this.reference.name}`;
     }
+    toString() {
+        return 'undefined';
+    }
+    nameString() {
+        const { name, trailers = [] } = this.reference;
+        let extra = '';
+        if (trailers.length > 0) {
+            extra = '.' + trailers.join('.');
+        }
+        return name + extra;
+    }
 }
 export class DeclaredReference {
     found;
@@ -13,16 +24,47 @@ export class DeclaredReference {
     trailers;
     type;
     value;
+    parentValue;
     constructor(refType) {
         this.found = refType.found;
         this.name = refType.name;
         this.trailers = refType.trailers;
         this.type = refType.type;
         this.value = refType.value;
+        this.parentValue = refType.parentValue;
     }
     toString() {
         return `[DeclaredReference name: ${this.name} trailers:${this.trailers} found: ${this.found}]`;
     }
+    toDisplayString() {
+        let returnValue = undefined;
+        if (this.parentValue) {
+            const trailersString = this.trailers.join(".");
+            if (this.type === 'instance') {
+                returnValue = this.parentValue.parameters.get(trailersString);
+            }
+            else if (this.type === 'variable') {
+                returnValue = this.parentValue[trailersString];
+            }
+        }
+        else {
+            returnValue = this.value;
+        }
+        if (returnValue !== undefined) {
+            if (returnValue !== null) {
+                if (returnValue.toDisplayString) {
+                    return returnValue.toDisplayString();
+                }
+                else {
+                    return returnValue.toString();
+                }
+            }
+            else {
+                return 'null';
+            }
+        }
+        throw 'Could not find string value: ' + this;
+    }
 }
 export var ParseSymbolType;
 (function (ParseSymbolType) {

package/dist/esm/render.mjs

@@ -3,7 +3,7 @@ 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 { getBoundsSize } from './utils.mjs';
+import { combineMaps, getBoundsSize } from './utils.mjs';
 import { getPaperSize, milsToMM, PaperGridReferences } from './helpers.mjs';
 import SVGtoPDF from 'svg-to-pdfkit';
 import { FrameParamKeys } from './objects/Frame.mjs';
@@ -254,6 +254,7 @@ function drawSheetFrameBorder(frameGroup, frame) {
         if (displayProp) {
             const sheetFrameGroup = frameGroup.group();
             const symbol = new SymbolPlaceholder(displayProp);
+            symbol.drawing.variables = combineMaps(frameComponent.parameters, frameParams);
             symbol.refreshDrawing();
             symbol.draw(sheetFrameGroup);
             const offsetX = milsToMM(frameComponent.getParam('offset_x'));

package/dist/esm/utils.mjs

@@ -66,3 +66,25 @@ export function getPortType(component) {
 export function roundValue(value) {
     return +value.toFixed(7);
 }
+export function throwWithContext(context, message) {
+    const startLine = context.start?.line;
+    const startColumn = context.start?.column;
+    const startString = startLine + ":" + startColumn;
+    const stopLine = context.stop?.line;
+    const stopColumn = context.stop?.column;
+    let stopString = "";
+    if (startLine === stopLine) {
+        stopString = stopColumn?.toString();
+    }
+    else {
+        stopString = stopLine + ":" + stopString;
+    }
+    throw `Parse exception at [${startString} - ${stopString}] : ${message}`;
+}
+export function combineMaps(map1, map2) {
+    const newMap = new Map(map1);
+    map2.forEach((value, key) => {
+        newMap.set(key, value);
+    });
+    return newMap;
+}