circuitscript 0.1.2 → 0.1.4

package/dist/esm/objects/Frame.mjs

@@ -8,6 +8,11 @@ export class Frame {
         this.frameType = frameType;
     }
 }
+export var FixedFrameIds;
+(function (FixedFrameIds) {
+    FixedFrameIds[FixedFrameIds["BaseFrame"] = -1] = "BaseFrame";
+    FixedFrameIds[FixedFrameIds["FrameIdNotUsed"] = -2] = "FrameIdNotUsed";
+})(FixedFrameIds || (FixedFrameIds = {}));
 export var FrameParamKeys;
 (function (FrameParamKeys) {
     FrameParamKeys["Title"] = "title";
@@ -18,6 +23,9 @@ export var FrameParamKeys;
     FrameParamKeys["Height"] = "height";
     FrameParamKeys["PaperSize"] = "paper_size";
     FrameParamKeys["SheetType"] = "sheet_type";
+    FrameParamKeys["TitleAlign"] = "title_align";
+    FrameParamKeys["HorizontalAlign"] = "align";
+    FrameParamKeys["VerticalAlign"] = "valign";
     FrameParamKeys["SheetNumber"] = "sheet_number";
     FrameParamKeys["SheetTotal"] = "sheet_total";
 })(FrameParamKeys || (FrameParamKeys = {}));

package/dist/esm/objects/ParamDefinition.mjs

@@ -55,6 +55,9 @@ export class NumericValue {
         }
         return resolveToNumericValue(this.toBigNumber().div(value.toBigNumber()));
     }
+    half() {
+        return this.div(2);
+    }
     mul(value) {
         if (typeof value === 'number') {
             value = numeric(value);

package/dist/esm/render.mjs

@@ -2,7 +2,7 @@ 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, defaultGridSizeUnits, defaultPageSpacingMM, defaultWireLineWidth, fontDisplayScale, junctionSize } from './globals.mjs';
-import { NumericValue } from './objects/ParamDefinition.mjs';
+import { numeric, NumericValue } from './objects/ParamDefinition.mjs';
 import { combineMaps, getBoundsSize } from './utils.mjs';
 import { getPaperSize, milsToMM } from './helpers.mjs';
 import SVGtoPDF from 'svg-to-pdfkit';
@@ -28,7 +28,7 @@ export function renderSheetsToSVG(sheetFrames, logger) {
         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
@@ -38,29 +38,33 @@ export function renderSheetsToSVG(sheetFrames, logger) {
                     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).toNumber();
-                    originalHeightMM = milsToMM(frameRects[0].height).toNumber();
-                    logger.add('first frame size: ' + originalWidthMM + ' ' + originalHeightMM);
+                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).toNumber();
-                    heightMM = milsToMM(frameRects[1].height).toNumber();
-                    logger.add('second frame size: ' + widthMM + ' ' + heightMM);
+                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;
+                xOffset = (originalWidthMM.sub(widthMM)).half().toNumber();
+                yOffset = (originalHeightMM.sub(heightMM)).half().toNumber();
                 logger.add('offset', xOffset, yOffset);
-                sheetYOffset = index * (originalHeightMM + defaultPageSpacingMM);
+                sheetYOffset = originalHeightMM.add(defaultPageSpacingMM).mul(index);
                 gridBounds = {
                     xmin: 0,
                     ymin: 0,
-                    xmax: widthMM,
-                    ymax: heightMM
+                    xmax: widthMM.toNumber(),
+                    ymax: heightMM.toNumber()
                 };
                 extendGrid = false;
             }
@@ -70,7 +74,7 @@ export function renderSheetsToSVG(sheetFrames, logger) {
         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;
 }
@@ -177,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');
         });
@@ -195,10 +202,10 @@ function generateSVGChild(canvas, components, wires, junctions, mergedWires, fra
         }
         else {
             if (borderWidth.toNumber() > 0) {
-                if (item.type === RenderFrameType.Container) {
+                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;
@@ -230,33 +237,34 @@ 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).toNumber();
-    const startY = gridStartY - smallOffset / 2;
-    const endY = gridEndY + smallOffset;
+    const smallOffset = milsToMM(3);
+    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.addClass('grid')
         .path(lines.join(" "))
         .attr({
-        'stroke-dasharray': `${strokeSize.toNumber()},${gridSize - strokeSize.toNumber()}`,
+        'stroke-dasharray': `${strokeSize.toNumber()},${numericGridSize.sub(strokeSize).toNumber()}`,
     })
         .stroke({
         width: strokeSize.toNumber(),

package/dist/esm/utils.mjs

@@ -151,3 +151,19 @@ export function resolveToNumericValue(value) {
     }
     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);
+}

package/dist/esm/visitor.mjs

@@ -189,7 +189,16 @@ export class ParserVisitor extends BaseVisitor {
                     }
                     return accum;
                 }, []);
-                accum.push([commandName, positionParams, keywordParams, item]);
+                let useCommandName = commandName;
+                let usePositionParams = positionParams;
+                if (commandName === PlaceHolderCommands.crect) {
+                    useCommandName = PlaceHolderCommands.rect;
+                    const [centerX, centerY, width, height] = positionParams;
+                    const newX = centerX.sub(width.half());
+                    const newY = centerY.sub(height.half());
+                    usePositionParams = [newX, newY, width, height];
+                }
+                accum.push([useCommandName, usePositionParams, keywordParams, item]);
             }
             return accum;
         }, []);

package/dist/types/draw_symbols.d.ts

@@ -69,6 +69,7 @@ export declare enum PlaceHolderCommands {
     arc = "arc",
     circle = "circle",
     rect = "rect",
+    crect = "crect",
     triangle = "triangle",
     pin = "pin",
     hpin = "hpin",
@@ -148,8 +149,8 @@ export declare class SymbolDrawing {
     addPinMM(pinId: NumericValue, startXMM: NumericValue, startYMM: NumericValue, endXMM: NumericValue, endYMM: NumericValue, lineColor: string): SymbolDrawing;
     addVLine(startX: NumericValue, startY: NumericValue, value: NumericValue): SymbolDrawing;
     addHLine(startX: NumericValue, startY: NumericValue, value: NumericValue): SymbolDrawing;
-    addRect(centerX: NumericValue, centerY: NumericValue, width: NumericValue, height: NumericValue): SymbolDrawing;
-    addRectMM(centerX: NumericValue, centerY: NumericValue, width: NumericValue, height: NumericValue): SymbolDrawing;
+    addRect(x: NumericValue, y: NumericValue, width: NumericValue, height: NumericValue): SymbolDrawing;
+    addRectMM(x: NumericValue, y: NumericValue, width: NumericValue, height: NumericValue): SymbolDrawing;
     addTriangle(startX: NumericValue, startY: NumericValue, endX: NumericValue, endY: NumericValue, width: NumericValue): SymbolDrawing;
     addLabel(x: NumericValue, y: NumericValue, textValue: string, style: LabelStyle): SymbolDrawing;
     addLabelMils(x: NumericValue, y: NumericValue, textValue: string, style: LabelStyle): SymbolDrawing;

package/dist/types/globals.d.ts

@@ -54,7 +54,7 @@ export declare const displayUnits = LengthUnit.mils;
 export declare const defaultFont = "Arial";
 export declare const defaultFontBold = "Arial";
 export declare const defaultFontSize = 10;
-export declare const junctionSize: number;
+export declare const junctionSize: import("./objects/ParamDefinition").NumericValue;
 export declare const PortArrowSize: number;
 export declare const PortPaddingHorizontal: number;
 export declare const PortPaddingVertical: number;

package/dist/types/layout.d.ts

@@ -11,7 +11,6 @@ import { BoundBox } from './utils.js';
 import { NumericValue } from './objects/ParamDefinition.js';
 export declare class LayoutEngine {
     logger: Logger;
-    placeSubgraphVersion: number;
     layoutWarnings: string[];
     showBaseFrame: boolean;
     constructor(options?: {
@@ -22,44 +21,28 @@ export declare class LayoutEngine {
     protected padLevel(value: number): string;
     runLayout(sequence: SequenceItem[], nets: [ClassComponent, pin: number, net: Net][]): SheetFrame[];
     private flattenFrameItems;
-    findJunctions(wireGroups: Map<string, RenderWire[]>): {
-        junctions: RenderJunction[];
-        mergedWires: MergedWire[];
-    };
-    placeFrames(graph: Graph, subgraphInfo: SubGraphInfo[], frameObjects: RenderFrame[]): {
-        elementFrames: RenderFrame[];
-        textObjects: RenderText[];
-    };
+    private findJunctions;
+    private placeFrames;
     collectElementFrames(frame: RenderFrame, level?: number): RenderFrame[];
     applyFrameOffset(frame: RenderFrame, level?: number): void;
-    placeAndSizeFrame(frame: RenderFrame, level?: number): void;
+    private placeAndSizeFrame;
     dumpFrame(frame: RenderFrame, level?: number): void;
-    prepareFrames(graph: Graph, subgraphInfo: SubGraphInfo[], frame: RenderFrame, level?: number): {
-        elementFrames: RenderFrame[];
-        textObjects: RenderText[];
-    };
+    private prepareFrames;
+    private checkAddFrameTitle;
     generateLayoutGraph(sequence: SequenceItem[], nets: [ClassComponent, pin: number, net: Net][]): {
         graph: Graph;
         containerFrames: RenderFrame[];
     };
-    setGraphEdge(graph: Graph, node1: string, node2: string, edgeValue: EdgeValue): void;
-    sizeSubGraphs(graph: Graph): SubGraphInfo[];
-    walkAndPlaceGraph(graph: Graph, firstNodeId: string, subgraphNodes: string[]): void;
+    private setGraphEdge;
+    private sizeSubGraphs;
+    private walkAndPlaceGraph;
     placeSubgraphV2(graph: Graph, firstNodeId: string, subgraphEdges: Edge[]): void;
     mergeOriginNodes(node1: RenderItem, pin1: number, node2: RenderItem, pin2: number, originNode1: string, originNode2: string, originNodes: RenderItem[], originNodeGroups: Map<string, RenderItem[]>): void;
-    placeSubgraph(graph: Graph, firstNodeId: string, subgraphEdges: Edge[]): void;
     translateNodeBy(offsetX: number, offsetY: number, item: RenderItem): void;
     placeNodeAtPosition(fromX: NumericValue, fromY: NumericValue, item: RenderItem, pin: number, depth?: number): void;
     placeFloatingItems(graph: Graph, item: RenderItem, depth?: number): void;
     printWarnings(): void;
 }
-type EdgeValue = [
-    instance1: string,
-    instancePin1: number,
-    instance2: string,
-    instancePin2: number,
-    priority: number
-];
 type RenderItem = RenderComponent | RenderWire | RenderText;
 export declare function applyComponentParamsToSymbol(component: ClassComponent, symbol: SymbolGraphic): void;
 export declare function getBounds(components: (RenderComponent | RenderText)[], wires: RenderWire[], junctions: RenderJunction[], frames: RenderFrame[]): BoundBox;
@@ -124,10 +107,10 @@ export declare class RenderFrame extends RenderObject {
     gap: NumericValue;
     borderWidth: NumericValue;
     direction: FramePlotDirection;
-    width: number | null;
-    height: number | null;
+    width: NumericValue | null;
+    height: NumericValue | null;
     subgraphId: string;
-    type: RenderFrameType;
+    renderType: RenderFrameType;
     containsTitle: boolean;
     constructor(frame: Frame, type?: RenderFrameType);
     toString(): string;
@@ -156,12 +139,10 @@ export declare function CalculatePinPositions(component: ClassComponent): Map<nu
     angle: NumericValue;
 }>;
 export declare function ExtractDrawingRects(drawing: SymbolDrawingCommands): {
+    x: NumericValue;
+    y: NumericValue;
     width: NumericValue;
     height: NumericValue;
+    className: string | undefined;
 }[];
-type SubGraphInfo = {
-    firstNodeId: string;
-    components: string[];
-    bounds: BoundBox;
-};
 export { BoundBox };

package/dist/types/objects/ExecutionScope.d.ts

@@ -29,7 +29,7 @@ export declare class ExecutionScope {
     componentGnd: ClassComponent | null;
     componentRoot: ClassComponent | null;
     copyIDs: Map<string, number>;
-    sequence: any[];
+    sequence: SequenceItem[];
     constructor(scopeId: number);
     static scopeId: number;
     static create(): ExecutionScope;

package/dist/types/objects/Frame.d.ts

@@ -5,6 +5,10 @@ export declare class Frame {
     frameType: FrameType;
     constructor(frameId: number, frameType?: FrameType);
 }
+export declare enum FixedFrameIds {
+    BaseFrame = -1,
+    FrameIdNotUsed = -2
+}
 export declare enum FrameParamKeys {
     Title = "title",
     Direction = "direction",
@@ -14,6 +18,9 @@ export declare enum FrameParamKeys {
     Height = "height",
     PaperSize = "paper_size",
     SheetType = "sheet_type",
+    TitleAlign = "title_align",
+    HorizontalAlign = "align",
+    VerticalAlign = "valign",
     SheetNumber = "sheet_number",
     SheetTotal = "sheet_total"
 }

package/dist/types/objects/ParamDefinition.d.ts

@@ -14,6 +14,7 @@ export declare class NumericValue {
     toNumber(): number;
     toBigNumber(): Big;
     div(value: NumericValue | number): NumericValue;
+    half(): NumericValue;
     mul(value: NumericValue | number): NumericValue;
     add(value: NumericValue | number): NumericValue;
     sub(value: NumericValue | number): NumericValue;

package/dist/types/utils.d.ts

@@ -13,6 +13,12 @@ export type BoundBox = {
     xmax: number;
     ymax: number;
 };
+export type BoundBox2 = [
+    xmin: number,
+    ymin: number,
+    xmax: number,
+    ymax: number
+];
 export declare function resizeBounds(bounds: BoundBox, value: number): BoundBox;
 export declare function printBounds(bounds: BoundBox): string;
 export declare function resizeToNearestGrid(bounds: BoundBox, gridSize?: number): BoundBox;
@@ -28,3 +34,5 @@ export declare function combineMaps(map1: Map<string, any>, map2: Map<string, an
 export declare function getNumberExponential(value: string): number;
 export declare function getNumberExponentialText(value: number): string;
 export declare function resolveToNumericValue(value: Big): NumericValue;
+export declare function isPointWithinArea(point: [x: number, y: number], bounds: BoundBox2): boolean;
+export declare function areasOverlap(area1: BoundBox2, area2: BoundBox2): boolean;

package/libs/lib.cst

@@ -64,7 +64,7 @@ def res(value):
     return create component:
         pins: 2
         display: create graphic (params):
-            rect: 0, 0, width, height
+            crect: 0, 0, width, height
             hpin: 1, -width/2 - 30, 0, 30
             hpin: 2, width/2 + 30, 0, -30
             label: params.refdes, -width/2, -height/2 - 20, fontSize=50, anchor="left"
@@ -277,13 +277,15 @@ def sheet_generator(paper_size_name, paper_width, paper_height, margin_x, margin
 
             # outer rect 
             lineColor: "#cccccc"
-            rect: paper_width/2, paper_height/2, paper_width, paper_height
+            crect: (paper_width/2, paper_height/2, 
+                paper_width, paper_height, class="paper-area")
 
             # inner rect
             lineColor: "#111111"
-            rect: paper_width/2, paper_height/2, inner_width, inner_height
+            crect: (paper_width/2, paper_height/2, 
+                    inner_width, inner_height, class="plot-area")
 
-            rect: (paper_width/2, paper_height/2, 
+            crect: (paper_width/2, paper_height/2, 
                     paper_width - 2 * margin_x + inner_frame_margin * 2, 
                     paper_height - 2 * margin_y  + inner_frame_margin * 2)
 
@@ -358,7 +360,10 @@ def sheet_generator(paper_size_name, paper_width, paper_height, margin_x, margin
                 anchor: "left"
                 vanchor: "bottom"
 
-            rect: title_block_x + title_block_width / 2, title_block_y + title_block_height / 2, title_block_width, title_block_height
+            crect: (title_block_x + title_block_width / 2, 
+                    title_block_y + title_block_height / 2, 
+                    title_block_width, title_block_height,
+                    class="keepout-area")
 
         params:
             title: "Sheet title"

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "circuitscript",
-    "version": "0.1.2",
+    "version": "0.1.4",
     "description": "Interpreter for the circuitscript language",
     "homepage": "https://circuitscript.net",
     "engines": {