circuitscript 0.0.31 → 0.0.34

package/dist/esm/antlr/CircuitScriptVisitor.mjs

@@ -24,11 +24,14 @@ export class CircuitScriptVisitor extends AbstractParseTreeVisitor {
     visitAt_block_pin_expression_simple;
     visitAt_block_pin_expression_complex;
     visitBreak_keyword;
+    visitContinue_keyword;
     visitAssignment_expr;
+    visitOperator_assignment_expr;
     visitKeyword_assignment_expr;
     visitParameters;
     visitProperty_set_expr;
     visitDouble_dot_property_set_expr;
+    visitArrayExpr;
     visitFunctionCallExpr;
     visitAdditionExpr;
     visitMultiplyExpr;
@@ -51,22 +54,26 @@ export class CircuitScriptVisitor extends AbstractParseTreeVisitor {
     visitFunction_return_expr;
     visitProperty_block_expr;
     visitCreate_component_expr;
+    visitGraphic_expressions_block;
     visitCreate_graphic_expr;
     visitCreate_module_expr;
     visitNested_properties_inner;
-    visitGraphic_expr;
+    visitGraphicCommandExpr;
+    visitGraphicForExpr;
     visitProperty_expr;
     visitProperty_key_expr;
     visitNested_properties;
     visitSingle_line_property;
-    visitBlank_expr;
     visitWire_expr_direction_value;
     visitWire_expr_direction_only;
     visitWire_expr;
+    visitArray_expr;
     visitPoint_expr;
     visitImport_expr;
     visitFrame_expr;
     visitIf_expr;
     visitIf_inner_expr;
     visitElse_expr;
+    visitWhile_expr;
+    visitFor_expr;
 }

package/dist/esm/draw_symbols.mjs

@@ -599,6 +599,7 @@ export var PlaceHolderCommands;
     PlaceHolderCommands["textColor"] = "textColor";
     PlaceHolderCommands["text"] = "text";
     PlaceHolderCommands["units"] = "units";
+    PlaceHolderCommands["for"] = "for";
 })(PlaceHolderCommands || (PlaceHolderCommands = {}));
 export class SymbolCustom extends SymbolGraphic {
     pinDefinition = [];

package/dist/esm/execute.mjs

@@ -443,12 +443,16 @@ export class ExecutionContext {
         this.log('did not find block point');
         return null;
     }
-    breakBranch() {
-        this.log('break branch');
-        const branchesInfo = this.scope.blockStack.get(this.scope.indentLevel - 1);
-        const branchIndex = branchesInfo['block_index'];
-        const branchIndexRef = branchesInfo['inner_blocks'].get(branchIndex);
-        branchIndexRef['ignore_last_net'] = true;
+    addBreakContext(ctx) {
+        this.log('add break context');
+        this.scope.breakStack.push(ctx);
+    }
+    popBreakContext() {
+        this.log('pop break context');
+        return this.scope.breakStack.pop();
+    }
+    getBreakContext() {
+        return this.scope.breakStack[this.scope.breakStack.length - 1];
     }
     createFunction(functionName, __runFunc) {
         this.scope.functions.set(functionName, __runFunc);
@@ -780,9 +784,10 @@ export class ExecutionContext {
             }
         }
     }
-    enterFrame() {
+    enterFrame(frameType) {
         const frameId = this.scope.frames.length + 1;
-        const frameObject = new Frame(frameId);
+        const frameObject = new Frame(frameId, frameType);
+        this.log('Enter frame', frameId);
         this.scope.frames.push(frameObject);
         this.scope.sequence.push([SequenceAction.Frame,
             frameObject, FrameAction.Enter]);
@@ -794,6 +799,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) {
@@ -844,10 +850,8 @@ export function getPortSide(pins, arrangeProps) {
             }
             let position = 0;
             useItems.forEach(item => {
-                if (typeof item === 'object') {
-                    if (item.blank) {
-                        position += item.blank;
-                    }
+                if (typeof item === 'object' && Array.isArray(item)) {
+                    position += item[0];
                 }
                 if (existingPinIds.indexOf(item) !== -1) {
                     result.push({

package/dist/esm/globals.mjs

@@ -36,6 +36,7 @@ export var WireAutoDirection;
 })(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;
@@ -46,6 +47,8 @@ export const defaultSymbolLineWidth = MilsToMM * 6;
 export const defaultWireLineWidth = MilsToMM * 6;
 export const defaultPinNameTextSize = 40;
 export const defaultPinIdTextSize = 30;
+export const defaultPageMarginMM = 10;
+export const defaultPageSpacingMM = 10;
 export const CustomSymbolPinTextSize = defaultPinNameTextSize;
 export const CustomSymbolPinIdSize = defaultPinIdTextSize;
 export const CustomSymbolRefDesSize = 50;
@@ -61,7 +64,7 @@ export const PortPaddingHorizontal = MilsToMM * 10;
 export const PortPaddingVertical = MilsToMM * 10;
 export const ColorScheme = {
     BodyColor: 'rgb(255, 255, 194)',
-    JunctionColor: 'rgba(0, 132, 0)',
+    JunctionColor: 'rgb(0, 132, 0)',
     WireColor: 'rgb(0, 132, 0)',
     PinLineColor: '#333',
     PinNameColor: '#333',
@@ -88,3 +91,13 @@ export var BlockTypes;
     BlockTypes[BlockTypes["Parallel"] = 3] = "Parallel";
     BlockTypes[BlockTypes["Point"] = 4] = "Point";
 })(BlockTypes || (BlockTypes = {}));
+export var FrameType;
+(function (FrameType) {
+    FrameType[FrameType["Frame"] = 1] = "Frame";
+    FrameType[FrameType["Sheet"] = 2] = "Sheet";
+})(FrameType || (FrameType = {}));
+export const GlobalDocumentName = 'document';
+export const RenderFlags = {
+    ShowElementFrames: false,
+    ShowOrigin: false,
+};

package/dist/esm/helpers.mjs

@@ -1,9 +1,11 @@
-import { readFileSync, writeFileSync } from "fs";
+import { readFileSync, writeFileSync, createWriteStream } from "fs";
+import path from "path";
+import PDFDocument from "pdfkit";
 import { generateKiCADNetList, printTree } from "./export.mjs";
 import { LayoutEngine } from "./layout.mjs";
 import { SequenceAction } from "./objects/ExecutionScope.mjs";
 import { parseFileWithVisitor } from "./parser.mjs";
-import { generateSVG2 } from "./render.mjs";
+import { generatePdfOutput, generateSvgOutput, renderSheetsToSVG } from "./render.mjs";
 import { SimpleStopwatch } from "./utils.mjs";
 import { ParserVisitor, VisitorExecutionException } from "./visitor.mjs";
 import { createContext } from "this-file";
@@ -12,8 +14,8 @@ import { BaseErrorListener, CharStream, CommonTokenStream, DefaultErrorStrategy
 import { MainLexer } from "./lexer.mjs";
 import { CircuitScriptParser } from "./antlr/CircuitScriptParser.mjs";
 import { prepareTokens, SemanticTokensVisitor } from "./SemanticTokenVisitor.mjs";
-import path from "path";
-import { LengthUnit, MilsToMM, PxToMM } from "./globals.mjs";
+import { defaultPageMarginMM, defaultZoomScale, LengthUnit, MilsToMM, PxToMM } from "./globals.mjs";
+import { FrameParamKeys } from "./objects/Frame.mjs";
 export var JSModuleType;
 (function (JSModuleType) {
     JSModuleType["CommonJs"] = "cjs";
@@ -174,6 +176,7 @@ export function renderScript(scriptData, outputPath, options) {
         console.log('Error while parsing');
         return null;
     }
+    const { frameComponent } = visitor.applySheetFrameComponent();
     try {
         visitor.annotateComponents();
     }
@@ -206,19 +209,49 @@ export function renderScript(scriptData, outputPath, options) {
         return tmp.join(" | ");
     });
     dumpData && writeFileSync('dump/raw-sequence.txt', tmpSequence.join('\n'));
-    let svgOutput = null;
+    let svgOutput = "";
     try {
+        let fileExtension = null;
+        let outputDefaultZoom = defaultZoomScale;
+        if (outputPath) {
+            fileExtension = path.extname(outputPath).substring(1);
+            if (fileExtension === "pdf") {
+                outputDefaultZoom = 1;
+            }
+        }
         const layoutEngine = new LayoutEngine();
         const layoutTimer = new SimpleStopwatch();
-        const graph = layoutEngine.runLayout(sequence, nets);
+        const sheetFrames = 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 svgCanvas = renderSheetsToSVG(sheetFrames);
         showStats && console.log('Render took:', generateSvgTimer.lap());
+        svgOutput = generateSvgOutput(svgCanvas, outputDefaultZoom);
         if (outputPath) {
-            writeFileSync(outputPath, svgOutput);
+            if (fileExtension === 'svg') {
+                writeFileSync(outputPath, svgOutput);
+            }
+            else if (fileExtension === 'pdf') {
+                let sheetSize = "A4";
+                let sheetSizeDefined = false;
+                if (frameComponent) {
+                    sheetSize = frameComponent.getParam(FrameParamKeys.PaperSize);
+                    sheetSizeDefined = true;
+                }
+                const doc = new PDFDocument({
+                    layout: 'landscape',
+                    size: sheetSize
+                });
+                const outputStream = createWriteStream(outputPath);
+                generatePdfOutput(doc, svgCanvas, sheetSize, sheetSizeDefined, outputDefaultZoom);
+                doc.pipe(outputStream);
+                doc.end();
+            }
+            else {
+                throw "Invalid output format";
+            }
             console.log('Generated file', outputPath);
         }
     }
@@ -291,3 +324,43 @@ export function milsToMM(value) {
 export function pxToMM(value) {
     return value * PxToMM;
 }
+const PaperSizes = {
+    'A0': [1189, 841],
+    'A1': [841, 594],
+    'A2': [594, 420],
+    'A3': [420, 297],
+    'A4': [297, 210],
+    'A5': [210, 148],
+    'A6': [148, 105],
+};
+export const PaperGridReferences = {
+    'A0': [16, 24],
+    'A1': [12, 16],
+    'A2': [8, 12],
+    'A3': [6, 8],
+    'A4': [4, 6],
+};
+export function isSupportedPaperSize(type) {
+    if (PaperSizes[type]) {
+        return true;
+    }
+    return false;
+}
+export function getPaperSize(type, margin = defaultPageMarginMM) {
+    if (PaperSizes[type]) {
+        const [width, height] = PaperSizes[type];
+        const useWidth = width - margin * 2;
+        const useHeight = height - margin * 2;
+        return {
+            width: Math.floor(useWidth * (1 / MilsToMM)),
+            height: Math.floor(useHeight * (1 / MilsToMM)),
+            widthMM: useWidth,
+            heightMM: useHeight,
+            originalWidthMM: width,
+            originalHeightMM: height,
+        };
+    }
+    else {
+        return getPaperSize('A4');
+    }
+}

package/dist/esm/layout.mjs

@@ -1,7 +1,7 @@
 import { Graph, alg } from '@dagrejs/graphlib';
-import { SymbolCustom, SymbolDrawing, SymbolFactory, SymbolCustomModule, SymbolPlaceholder, SymbolText } from "./draw_symbols.mjs";
+import { SymbolCustom, SymbolDrawing, SymbolFactory, SymbolCustomModule, SymbolPlaceholder, SymbolText, PlaceHolderCommands } from "./draw_symbols.mjs";
 import { FrameAction, SequenceAction } from "./objects/ExecutionScope.mjs";
-import { defaultFrameTitleTextSize, defaultGridSizeUnits, GlobalNames, ParamKeys, WireAutoDirection } from './globals.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';
@@ -13,8 +13,11 @@ export class LayoutEngine {
     logger;
     placeSubgraphVersion = 2;
     layoutWarnings = [];
-    constructor() {
+    showBaseFrame = false;
+    constructor(options = { showBaseFrame: false }) {
         this.logger = new Logger();
+        const { showBaseFrame = false } = options ?? {};
+        this.showBaseFrame = showBaseFrame;
     }
     print(...params) {
         this.logger.add(params.join(' '));
@@ -58,38 +61,51 @@ export class LayoutEngine {
                 this.print('-- items:', item.components);
             });
         }
-        const { textObjects, elementFrames } = this.placeFrames(graph, subgraphInfo, containerFrames);
+        const { elementFrames } = this.placeFrames(graph, subgraphInfo, containerFrames);
         const frameObjects = [...elementFrames, ...containerFrames];
-        const placedComponents = [];
-        const placedWires = [];
-        const tmpNodes = graph.nodes();
-        tmpNodes.forEach(item => {
-            const nodeValue = graph.node(item);
-            const [nodeType, nodeItem] = nodeValue;
-            if (nodeType === RenderItemType.Component) {
-                placedComponents.push(nodeItem);
-            }
-            else if (nodeType === RenderItemType.Wire) {
-                placedWires.push(nodeItem);
-            }
+        const sheetFrames = frameObjects.filter(item => {
+            return item.frame.frameType === FrameType.Sheet;
+        });
+        if (sheetFrames.length === 0) {
+            sheetFrames.push(containerFrames[0]);
+        }
+        const sheetFrameObjects = sheetFrames.map(sheet => {
+            const items = this.flattenFrameItems(sheet);
+            const components = items.filter(item => item instanceof RenderComponent);
+            const wires = items.filter(item => item instanceof RenderWire);
+            const textObjects = items.filter(item => item instanceof RenderText);
+            const frames = items.filter(item => item instanceof RenderFrame);
+            const wireGroups = new Map();
+            wires.forEach(wire => {
+                const { netName } = wire;
+                if (!wireGroups.has(netName)) {
+                    wireGroups.set(netName, []);
+                }
+                wireGroups.get(netName).push(wire);
+            });
+            const { junctions, mergedWires } = this.findJunctions(wireGroups);
+            return {
+                frame: sheet,
+                frames,
+                components,
+                wires,
+                textObjects,
+                junctions,
+                mergedWires,
+            };
         });
-        const wireGroups = new Map();
-        placedWires.forEach(wire => {
-            const { netName } = wire;
-            if (!wireGroups.has(netName)) {
-                wireGroups.set(netName, []);
+        return sheetFrameObjects;
+    }
+    flattenFrameItems(frame) {
+        const items = [];
+        frame.innerItems.forEach(item => {
+            items.push(item);
+            if (item instanceof RenderFrame) {
+                const inner = this.flattenFrameItems(item);
+                items.push(...inner);
             }
-            wireGroups.get(netName).push(wire);
         });
-        const { junctions, mergedWires } = this.findJunctions(wireGroups);
-        return {
-            components: placedComponents,
-            wires: placedWires,
-            mergedWires,
-            junctions,
-            frameObjects,
-            textObjects,
-        };
+        return items;
     }
     findJunctions(wireGroups) {
         const junctions = [];
@@ -122,6 +138,11 @@ export class LayoutEngine {
         const baseFrame = frameObjects[0];
         baseFrame.padding = 0;
         baseFrame.borderWidth = 0;
+        if (this.showBaseFrame) {
+            baseFrame.borderWidth = 5;
+            baseFrame.width = 11692 - 400 * 2;
+            baseFrame.height = 8267 - 400 * 2;
+        }
         baseFrame.x = 0;
         baseFrame.y = 0;
         let textObjects = [];
@@ -134,7 +155,7 @@ export class LayoutEngine {
             const result = this.prepareFrames(graph, subgraphInfo, baseFrame);
             textObjects = result.textObjects;
             elementFrames = result.elementFrames;
-            const logFrames = false;
+            const logFrames = true;
             if (logFrames) {
                 this.print('===== dump frames =====');
                 this.dumpFrame(baseFrame);
@@ -168,8 +189,14 @@ export class LayoutEngine {
         this.print(level, "".padStart(level * 4), 'frame', frame.x, frame.y);
         const innerItems = frame.innerItems;
         innerItems.forEach(innerFrame => {
-            innerFrame.x += frame.x;
-            innerFrame.y += frame.y;
+            if (innerFrame.frame.frameType === FrameType.Sheet) {
+                innerFrame.x = 0;
+                innerFrame.y = 0;
+            }
+            else {
+                innerFrame.x += frame.x;
+                innerFrame.y += frame.y;
+            }
             if (innerFrame.type === RenderFrameType.Elements) {
                 this.print(level, "".padStart(level * 4), 'element frame', innerFrame.x, innerFrame.y);
                 innerFrame.innerItems.forEach(item2 => {
@@ -257,7 +284,34 @@ export class LayoutEngine {
             }
             boundPoints.push([innerFrame.x, innerFrame.y], [innerFrame.x + frameWidth, innerFrame.y + frameHeight]);
         });
-        frame.bounds = resizeBounds(getBoundsFromPoints(boundPoints), frame.padding);
+        const contentsBounds = resizeBounds(getBoundsFromPoints(boundPoints), frame.padding);
+        if (frame.frame.parameters.has(FrameParamKeys.SheetFrame)) {
+            const frameComponent = frame.frame.parameters.get(FrameParamKeys.SheetFrame);
+            const rects = ExtractDrawingRects(frameComponent.displayProp);
+            let frameWidth = 0;
+            let frameHeight = 0;
+            if (rects[1]) {
+                frameWidth = milsToMM(rects[1].width);
+                frameHeight = milsToMM(rects[1].height);
+            }
+            const contentsWidth = contentsBounds.xmax - contentsBounds.xmin;
+            const contentsHeight = contentsBounds.ymax - contentsBounds.ymin;
+            const frameOffsetX = toNearestGrid((frameWidth - contentsWidth) / 2, gridSize);
+            const frameOffsetY = toNearestGrid((frameHeight - contentsHeight) / 2, gridSize);
+            innerFrames.forEach(innerFrame => {
+                innerFrame.x += frameOffsetX;
+                innerFrame.y += frameOffsetY;
+            });
+            frame.bounds = {
+                xmin: 0,
+                ymin: 0,
+                xmax: frameWidth,
+                ymax: frameHeight
+            };
+        }
+        else {
+            frame.bounds = contentsBounds;
+        }
     }
     dumpFrame(frame, level = 0) {
         this.print(level, "".padStart(level * 4), 'frame, items:', frame.innerItems.length);
@@ -495,6 +549,14 @@ export class LayoutEngine {
                         newFrame.borderWidth =
                             frameObject.parameters.get(FrameParamKeys.Border);
                     }
+                    if (frameObject.parameters.has(FrameParamKeys.Width)) {
+                        newFrame.width =
+                            frameObject.parameters.get(FrameParamKeys.Width);
+                    }
+                    if (frameObject.parameters.has(FrameParamKeys.Height)) {
+                        newFrame.height =
+                            frameObject.parameters.get(FrameParamKeys.Height);
+                    }
                     containerFrames.push(newFrame);
                     frameStack.push(newFrame);
                     prevFrame && prevFrame.innerItems.push(newFrame);
@@ -656,14 +718,20 @@ export class LayoutEngine {
                 floatingNode.isFloating = false;
                 this.print('set node as not floating:', floatingNode);
                 const originNode = findOriginNode(fixedNode);
-                originNodeGroups.get(originNode).push(floatingNode);
-                this.print('linking node', floatingNode, 'to origin node', originNode);
+                const itemsArray = originNodeGroups.get(originNode);
+                if (itemsArray.indexOf(floatingNode) === -1) {
+                    itemsArray.push(floatingNode);
+                    this.print('linking node', floatingNode, 'to origin node', originNode);
+                }
+                else {
+                    this.print('node is alread linked', floatingNode, 'to origin node', originNode);
+                }
             }
             [node1, node2].forEach(item => {
                 if (item instanceof RenderWire && item.isEndAutoLength()) {
                     const [instance, pin] = item.getEndAuto();
                     const [, targetNode] = graph.node(instance.instanceName);
-                    this.print('wire auto length to target:', instance, pin);
+                    this.print('wire', item, 'auto length to target:', instance, pin);
                     if (targetNode.isFloating) {
                         throw "Cannot create auto wire with floating node! Wire id: " + item.id + " to node " + instance + " pin " + pin;
                     }
@@ -674,6 +742,7 @@ export class LayoutEngine {
                     }
                     const [untilX, untilY] = getNodePositionAtPin(targetNode, pin);
                     item.setEndAuto(untilX, untilY);
+                    this.print(`set wire auto end at: ${untilX} ${untilY}`);
                 }
             });
         });
@@ -1226,6 +1295,9 @@ export class RenderFrame extends RenderObject {
     gap = milsToMM(100);
     direction = FramePlotDirection.Column;
     borderWidth = 5;
+    width = null;
+    height = null;
+    size = null;
     subgraphId = "";
     type;
     containsTitle = false;
@@ -1276,6 +1348,16 @@ export function CalculatePinPositions(component) {
     });
     return pinPositionMapping;
 }
+export function ExtractDrawingRects(drawing) {
+    return drawing.getCommands().filter(item => {
+        return (item[0] === PlaceHolderCommands.rect);
+    }).map(item => {
+        return {
+            width: item[1][2],
+            height: item[1][3],
+        };
+    });
+}
 function isPointOverlap(x, y, other) {
     return (x >= other.x && y >= other.y && x <= (other.x + other.width) && y <= (other.y + other.height));
 }

package/dist/esm/objects/ClassComponent.mjs

@@ -85,6 +85,9 @@ export class ClassComponent {
         this.parameters.set(key, value);
         this.refreshParamCache();
     }
+    hasParam(key) {
+        return this.parameters.has(key);
+    }
     refreshParamCache() {
         this._cachedParams =
             JSON.stringify(Object.fromEntries(this.parameters));

package/dist/esm/objects/ExecutionScope.mjs

@@ -6,6 +6,7 @@ export class ExecutionScope {
     variables = new Map();
     symbols = new Map();
     blockStack = new Map();
+    breakStack = [];
     wires = [];
     frames = [];
     indentLevel = 0;

package/dist/esm/objects/Frame.mjs

@@ -1,8 +1,10 @@
 export class Frame {
     parameters = new Map();
     frameId;
-    constructor(frameId) {
+    frameType;
+    constructor(frameId, frameType) {
         this.frameId = frameId;
+        this.frameType = frameType;
     }
 }
 export var FrameParamKeys;
@@ -11,6 +13,10 @@ export var FrameParamKeys;
     FrameParamKeys["Direction"] = "direction";
     FrameParamKeys["Padding"] = "padding";
     FrameParamKeys["Border"] = "border";
+    FrameParamKeys["Width"] = "width";
+    FrameParamKeys["Height"] = "height";
+    FrameParamKeys["PaperSize"] = "paper_size";
+    FrameParamKeys["SheetFrame"] = "sheet_frame";
 })(FrameParamKeys || (FrameParamKeys = {}));
 export var FramePlotDirection;
 (function (FramePlotDirection) {

package/dist/esm/objects/ParamDefinition.mjs

@@ -32,9 +32,3 @@ export class PercentageValue {
         return this.value.toString();
     }
 }
-export class PinBlankValue {
-    blank;
-    constructor(value) {
-        this.blank = value;
-    }
-}

package/dist/esm/objects/types.mjs

@@ -3,6 +3,9 @@ export class UndeclaredReference {
     constructor(reference) {
         this.reference = reference;
     }
+    throwMessage() {
+        return `Unknown symbol: ${this.reference.name}`;
+    }
 }
 export class DeclaredReference {
     found;
@@ -17,6 +20,9 @@ export class DeclaredReference {
         this.type = refType.type;
         this.value = refType.value;
     }
+    toString() {
+        return `[DeclaredReference name: ${this.name} trailers:${this.trailers} found: ${this.found}]`;
+    }
 }
 export var ParseSymbolType;
 (function (ParseSymbolType) {

package/dist/esm/regenerate-tests.mjs

@@ -26,7 +26,8 @@ async function regenerateTests(extra = "") {
     return cstFiles;
 }
 (async () => {
-    const generateDiff = false;
+    const generateDiff = (process.argv.indexOf('-diff') !== -1);
+    console.log('diff flag: ', generateDiff);
     const nextExtra = generateDiff ? '.next' : '';
     const cstFiles = await regenerateTests(nextExtra);
     const allFiles = [];