circuitscript 0.0.22 → 0.0.25

package/dist/cjs/parser.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CircuitscriptParserErrorListener = exports.TempErrorStrategy = exports.parseFileWithVisitor = void 0;
+const CircuitScriptParser_js_1 = require("./antlr/CircuitScriptParser.js");
+const lexer_js_1 = require("./lexer.js");
+const utils_js_1 = require("./utils.js");
+const antlr4ng_1 = require("antlr4ng");
+function parseFileWithVisitor(visitor, data) {
+    const chars = antlr4ng_1.CharStream.fromString(data);
+    const lexer = new lexer_js_1.MainLexer(chars);
+    const lexerTimer = new utils_js_1.SimpleStopwatch();
+    const tokens = new antlr4ng_1.CommonTokenStream(lexer);
+    tokens.fill();
+    const lexerTimeTaken = lexerTimer.lap();
+    const parserTimer = new utils_js_1.SimpleStopwatch();
+    const parser = new CircuitScriptParser_js_1.CircuitScriptParser(tokens);
+    const tree = parser.script();
+    let hasError = false;
+    try {
+        visitor.visit(tree);
+    }
+    catch (err) {
+        console.log(err);
+        hasError = true;
+    }
+    const parserTimeTaken = parserTimer.lap();
+    return {
+        tree, parser,
+        hasParseError: false,
+        hasError,
+        parserTimeTaken,
+        lexerTimeTaken,
+    };
+}
+exports.parseFileWithVisitor = parseFileWithVisitor;
+class TempErrorStrategy extends antlr4ng_1.DefaultErrorStrategy {
+    recover(recognizer, e) {
+        throw new Error('Method not implemented.');
+    }
+    reportError(recognizer, e) {
+        throw new Error('Method not implemented.');
+    }
+}
+exports.TempErrorStrategy = TempErrorStrategy;
+class CircuitscriptParserErrorListener {
+    constructor(onErrorHandler = null) {
+        this.syntaxErrorCounter = 0;
+        this.onErrorHandler = null;
+        this.onErrorHandler = onErrorHandler;
+    }
+    syntaxError(recognizer, offendingSymbol, line, charPositionInLine, msg, e) {
+        if (this.onErrorHandler) {
+            this.onErrorHandler(line, charPositionInLine, msg, e);
+        }
+        else {
+            console.log("Syntax error at line", line, ':', charPositionInLine, ' - ', msg);
+        }
+        this.syntaxErrorCounter++;
+    }
+    reportAmbiguity(recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs) {
+    }
+    reportAttemptingFullContext(recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs) {
+    }
+    reportContextSensitivity(recognizer, dfa, startIndex, stopIndex, prediction, configs) {
+    }
+    hasSyntaxErrors() {
+        return (this.syntaxErrorCounter > 0);
+    }
+}
+exports.CircuitscriptParserErrorListener = CircuitscriptParserErrorListener;

package/dist/cjs/regenerate-tests.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const helpers_js_1 = require("./helpers.js");
+const mainDir = './__tests__/renderData/';
+const cstFiles = [];
+const files = fs_1.default.readdirSync(mainDir);
+files.forEach(file => {
+    if (file.endsWith('.cst')) {
+        cstFiles.push(file);
+    }
+});
+const useCurrentDir = './examples/';
+cstFiles.forEach(file => {
+    const inputPath = mainDir + file;
+    const scriptData = fs_1.default.readFileSync(inputPath, { encoding: 'utf-8' });
+    const outputPath = inputPath + '.svg';
+    (0, helpers_js_1.renderScript)(scriptData, outputPath, { currentDirectory: useCurrentDir });
+    console.log('generated ', outputPath);
+});

package/dist/cjs/render.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSVG2 = void 0;
+const svg_js_1 = require("@svgdotjs/svg.js");
+const layout_js_1 = require("./layout.js");
+const sizing_js_1 = require("./sizing.js");
+const globals_js_1 = require("./globals.js");
+const ParamDefinition_js_1 = require("./objects/ParamDefinition.js");
+const utils_js_1 = require("./utils.js");
+function generateSVG2(graph) {
+    const window = (0, sizing_js_1.getCreateSVGWindow)()();
+    const document = window.document;
+    (0, svg_js_1.registerWindow)(window, document);
+    const canvas = (0, svg_js_1.SVG)(document.documentElement);
+    (0, sizing_js_1.applyFontsToSVG)(canvas);
+    generateSVGChild(canvas, graph.components, graph.wires, graph.junctions, graph.mergedWires, graph.frameObjects, graph.textObjects);
+    const { x, y, width, height } = canvas.bbox();
+    const margin = 5;
+    const widthAndMargin = width + margin * 2;
+    const heightAndMargin = height + margin * 2;
+    const scale = 1;
+    canvas.size(widthAndMargin * scale, heightAndMargin * scale);
+    canvas.viewbox(x - margin, y - margin, widthAndMargin, heightAndMargin);
+    return canvas.svg();
+}
+exports.generateSVG2 = generateSVG2;
+function generateSVGChild(canvas, components, wires, junctions, mergedWires, frameObjects, textObjects) {
+    const displayWireId = false;
+    const bounds = (0, layout_js_1.getBounds)(components, wires, junctions, frameObjects);
+    drawGrid(canvas.group().translate(0, 0), {
+        x: bounds.xmin,
+        y: bounds.ymin,
+        x2: bounds.xmax,
+        y2: bounds.ymax
+    });
+    components.forEach(item => {
+        const { x, y, width, height } = item;
+        const symbolGroup = canvas.group();
+        symbolGroup.translate(x, y);
+        const { symbol = null } = item;
+        if (symbol !== null && symbol) {
+            const extra = {};
+            if (item.component.parameters.has('__is_net')) {
+                extra.net_name = item.component.parameters.get(globals_js_1.ParamKeys.net_name);
+            }
+            else if (item.component.parameters.has('value')) {
+                let tmpValue = item.component.parameters.get('value');
+                if (tmpValue instanceof ParamDefinition_js_1.NumericValue) {
+                    tmpValue = tmpValue.value;
+                }
+                extra.value = tmpValue;
+            }
+            extra.instance_name = item.component.instanceName;
+            if (item.component.parameters.has('place')) {
+                extra.place = item.component.parameters.get('place');
+            }
+            else {
+                extra.place = true;
+            }
+            symbol.draw(symbolGroup, extra);
+        }
+        else {
+            symbolGroup.rect(width, height)
+                .fill(globals_js_1.bodyColor)
+                .stroke({ width: 1, color: '#333' });
+        }
+    });
+    if (displayWireId) {
+        const wiresGroup = canvas.group().translate(0, 0);
+        wires.forEach(wire => {
+            wiresGroup.text(wire.id.toString())
+                .font({
+                family: 'Inter',
+                size: 10,
+            })
+                .translate(wire.x + 5, wire.y + 5);
+        });
+    }
+    const mergedWireGroup = canvas.group();
+    mergedWires.forEach(tmpItem => {
+        const { segments, intersectPoints } = tmpItem;
+        segments.forEach(segment => {
+            const pt1 = segment[0];
+            const pt2 = segment[1];
+            mergedWireGroup.line([pt1, pt2])
+                .stroke({ width: 1, color: globals_js_1.wireColor, linecap: 'square' })
+                .fill('none');
+        });
+        intersectPoints.forEach(point => {
+            const [x, y, count] = point;
+            mergedWireGroup.circle(globals_js_1.junctionSize)
+                .translate(x - globals_js_1.junctionSize / 2, y - globals_js_1.junctionSize / 2)
+                .fill(globals_js_1.junctionColor)
+                .stroke('none');
+        });
+    });
+    const frameGroup = canvas.group();
+    const showElementFrames = false;
+    frameObjects.forEach(item => {
+        const { bounds, borderWidth } = item;
+        if (borderWidth > 0) {
+            const { width, height } = (0, utils_js_1.getBoundsSize)(bounds);
+            let strokeColor = '#111';
+            if (item.type === layout_js_1.RenderFrameType.Container) {
+                strokeColor = '#111';
+            }
+            else if (item.type === layout_js_1.RenderFrameType.Elements) {
+                strokeColor = '#aaa';
+                if (!showElementFrames) {
+                    return;
+                }
+            }
+            const tmpRect = frameGroup.rect(width, height)
+                .fill('none')
+                .stroke({ width: borderWidth, color: strokeColor });
+            tmpRect.translate(item.x, item.y);
+        }
+    });
+    textObjects.forEach(item => {
+        const { x, y, symbol } = item;
+        const innerGroup = canvas.group();
+        innerGroup.translate(x, y);
+        symbol.draw(innerGroup);
+    });
+    const drawOrigin = false;
+    drawOrigin && canvas.group().translate(0, 0)
+        .circle(5)
+        .translate(-5 / 2, -5 / 2)
+        .stroke('none').fill('red');
+}
+function drawGrid(group, canvasSize) {
+    const gridSize = 20;
+    const { x, y, x2, y2 } = canvasSize;
+    const gridStartX = (Math.floor(x / gridSize) - 1) * gridSize;
+    const gridStartY = (Math.floor(y / gridSize) - 1) * gridSize;
+    const gridEndX = (Math.ceil(x2 / gridSize) + 1) * gridSize;
+    const gridEndY = (Math.ceil(y2 / gridSize) + 1) * gridSize;
+    const numCols = Math.ceil((gridEndX - gridStartX) / gridSize);
+    const lines = [];
+    for (let i = 0; i <= numCols; i++) {
+        const startX = gridStartX + i * gridSize;
+        const startY = gridStartY - 0.5;
+        const endY = gridEndY;
+        lines.push(`M ${startX} ${startY} L ${startX} ${endY}`);
+    }
+    group.path(lines.join(" "))
+        .fill('none')
+        .attr({
+        'stroke-dasharray': '1,' + (gridSize - 1),
+    })
+        .stroke({
+        width: 1,
+        color: '#aaa'
+    });
+}

package/{src/server.ts → dist/cjs/server.js}

@@ -1,16 +1,17 @@
-import express from 'express';
-import ws from 'ws';
-import fs from 'fs';
-
-const app = express()
-
-const wsServer = new ws.Server({ noServer: true });
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = __importDefault(require("express"));
+const ws_1 = __importDefault(require("ws"));
+const fs_1 = __importDefault(require("fs"));
+const app = (0, express_1.default)();
+const wsServer = new ws_1.default.Server({ noServer: true });
 wsServer.on('connection', socket => {
-
     const fileName = 'output.svg';
-
-    function emitFile(): void {
-        fs.readFile(fileName, 'utf8', (err, data) => {
+    function emitFile() {
+        fs_1.default.readFile(fileName, 'utf8', (err, data) => {
             if (err) {
                 throw err;
             }
@@ -18,33 +19,26 @@ wsServer.on('connection', socket => {
             socket.send(data);
         });
     }
-
     let emitTimeout = null;
-    fs.watch(fileName, (event, targetFile) => {
+    fs_1.default.watch(fileName, (event, targetFile) => {
         if (event === 'change') {
             console.log((new Date()).toISOString(), 'file changed!');
-
-            // emit the change
             clearInterval(emitTimeout);
             emitTimeout = setTimeout(() => {
                 emitFile();
             }, 200);
         }
     });
-
     socket.on('message', message => {
         console.log(message.toString());
         emitFile();
     });
 });
-
-app.use(express.static('./'))
-
+app.use(express_1.default.static('./'));
 const server = app.listen(3000);
 server.on('upgrade', (request, socket, head) => {
     wsServer.handleUpgrade(request, socket, head, socket => {
         wsServer.emit('connection', socket, request);
     });
 });
-
-console.log('server started at port 3000');
+console.log('server started at port 3000');

package/dist/cjs/sizing.js

@@ -0,0 +1,105 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.measureTextSize2 = exports.measureTextSize = exports.applyFontsToSVG = exports.getCreateSVGWindow = exports.prepareSVGEnvironment = void 0;
+const svg_js_1 = require("@svgdotjs/svg.js");
+const geometry_js_1 = require("./geometry.js");
+const globals_js_1 = require("./globals.js");
+const helpers_js_1 = require("./helpers.js");
+let MainCanvas = null;
+const supportedFonts = {};
+let globalCreateSVGWindow;
+async function prepareSVGEnvironment(fontsPath) {
+    const moduleType = (0, helpers_js_1.detectJSModuleType)();
+    if (moduleType === helpers_js_1.JSModuleType.CommonJs) {
+        const { config, createSVGWindow } = await Promise.resolve().then(() => __importStar(require('svgdom')));
+        globalCreateSVGWindow = createSVGWindow;
+        if (fontsPath !== null) {
+            await config.setFontDir(fontsPath)
+                .setFontFamilyMappings(supportedFonts)
+                .preloadFonts();
+        }
+    }
+}
+exports.prepareSVGEnvironment = prepareSVGEnvironment;
+function getCreateSVGWindow() {
+    if (globalCreateSVGWindow === undefined) {
+        throw "SVG environment is not set up yet";
+    }
+    return globalCreateSVGWindow;
+}
+exports.getCreateSVGWindow = getCreateSVGWindow;
+function applyFontsToSVG(canvas) {
+}
+exports.applyFontsToSVG = applyFontsToSVG;
+async function measureTextSize(text, fontFamily, fontSize) {
+    return measureTextSize2(text, fontFamily, fontSize);
+}
+exports.measureTextSize = measureTextSize;
+const measureTextSizeCache = {};
+const measureTextSizeCacheHits = {};
+function measureTextSize2(text, fontFamily, fontSize, fontWeight = 'regular', anchor = geometry_js_1.HorizontalAlign.Left, vanchor = geometry_js_1.VerticalAlign.Bottom) {
+    if (MainCanvas === null) {
+        const window = getCreateSVGWindow()();
+        const { document } = window;
+        (0, svg_js_1.registerWindow)(window, document);
+        MainCanvas = (0, svg_js_1.SVG)(document.documentElement);
+    }
+    const key = `${text}-${fontFamily}-${fontSize}-${fontWeight}-${anchor}-${vanchor}`;
+    if (measureTextSizeCache[key] === undefined) {
+        let dominantBaseline = 'hanging';
+        switch (vanchor) {
+            case geometry_js_1.VerticalAlign.Top:
+                dominantBaseline = 'hanging';
+                break;
+            case geometry_js_1.VerticalAlign.Middle:
+                dominantBaseline = 'middle';
+                break;
+            case geometry_js_1.VerticalAlign.Bottom:
+                dominantBaseline = 'text-top';
+                break;
+        }
+        fontFamily = globals_js_1.defaultFont;
+        const tmpTextElement = MainCanvas.text(text).font({
+            family: fontFamily,
+            size: fontSize,
+            anchor: anchor,
+            'dominant-baseline': dominantBaseline,
+            weight: fontWeight,
+        }).fill('#333');
+        const textbox = tmpTextElement.bbox();
+        const { width, height } = textbox;
+        tmpTextElement.remove();
+        measureTextSizeCache[key] = {
+            width: Math.round(width * 100) / 100,
+            height: Math.round(height * 100) / 100,
+            box: textbox,
+        };
+        measureTextSizeCacheHits[key] = 0;
+    }
+    measureTextSizeCacheHits[key]++;
+    return measureTextSizeCache[key];
+}
+exports.measureTextSize2 = measureTextSize2;

package/{src/utils.ts → dist/cjs/utils.js}

@@ -1,64 +1,54 @@
-
-export class SimpleStopwatch {
-    startTime: Date;
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBoundsSize = exports.toNearestGrid = exports.resizeToNearestGrid = exports.printBounds = exports.resizeBounds = exports.SimpleStopwatch = void 0;
+class SimpleStopwatch {
     constructor() {
         this.startTime = new Date();
     }
-
-    lap(): number {
+    lap() {
         return (new Date()).getTime() - this.startTime.getTime();
     }
 }
-
-export type BoundBox = {
-    xmin: number, ymin: number,
-    xmax: number, ymax: number,
-}
-
-export function resizeBounds(bounds: BoundBox, value: number): BoundBox {
+exports.SimpleStopwatch = SimpleStopwatch;
+function resizeBounds(bounds, value) {
     return {
         xmin: bounds.xmin - value,
         xmax: bounds.xmax + value,
-
         ymin: bounds.ymin - value,
         ymax: bounds.ymax + value
-    }
+    };
 }
-
-export function printBounds(bounds: BoundBox): string {
-    if (bounds !== null){
+exports.resizeBounds = resizeBounds;
+function printBounds(bounds) {
+    if (bounds !== null) {
         return `[${bounds.xmin}, ${bounds.ymin} to ${bounds.xmax}, ${bounds.ymax}]`;
-    } else {
+    }
+    else {
         return 'null';
     }
 }
-
-export function resizeToNearestGrid(bounds: BoundBox, gridSize = 20): BoundBox {
-    
-    // These extra values force the bounds to be expanded if it is already
-    // to the grid, otherwise the expanded grid might "just nice" fit.
-    const addXMin = (bounds.xmin % gridSize) === 0 ? -1: 0;
-    const addYMin = (bounds.ymin % gridSize) === 0 ? -1: 0;
+exports.printBounds = printBounds;
+function resizeToNearestGrid(bounds, gridSize = 20) {
+    const addXMin = (bounds.xmin % gridSize) === 0 ? -1 : 0;
+    const addYMin = (bounds.ymin % gridSize) === 0 ? -1 : 0;
     const addXMax = (bounds.xmax % gridSize) === 0 ? 1 : 0;
     const addYMax = (bounds.ymax % gridSize) === 0 ? 1 : 0;
-
     return {
         xmin: Math.floor((bounds.xmin + addXMin) / gridSize) * gridSize,
         ymin: Math.floor((bounds.ymin + addYMin) / gridSize) * gridSize,
-
         xmax: Math.ceil((bounds.xmax + addXMax) / gridSize) * gridSize,
         ymax: Math.ceil((bounds.ymax + addYMax) / gridSize) * gridSize,
-    }
+    };
 }
-
-export function toNearestGrid(value: number, gridSize: number): number {
+exports.resizeToNearestGrid = resizeToNearestGrid;
+function toNearestGrid(value, gridSize) {
     return Math.floor(value / gridSize) * gridSize;
 }
-
-export function getBoundsSize(bounds: BoundBox): {width: number, height: number} {
+exports.toNearestGrid = toNearestGrid;
+function getBoundsSize(bounds) {
     return {
         width: bounds.xmax - bounds.xmin,
         height: bounds.ymax - bounds.ymin,
-    }
-}
+    };
+}
+exports.getBoundsSize = getBoundsSize;

package/dist/cjs/validate.js

@@ -0,0 +1,81 @@
+#! /usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validate = void 0;
+const commander_1 = require("commander");
+const figlet_1 = __importDefault(require("figlet"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = require("fs");
+const sizing_js_1 = require("./sizing.js");
+const helpers_js_1 = require("./helpers.js");
+async function validate() {
+    const { filePath } = (0, helpers_js_1.getCurrentPath)();
+    const toolSrcPath = filePath;
+    const toolDirectory = path_1.default.dirname(toolSrcPath) + '/../../';
+    const fontsPath = toolDirectory + '/fonts';
+    const defaultLibsPath = toolDirectory + '/libs';
+    const packageJson = JSON.parse((0, fs_1.readFileSync)(toolDirectory + 'package.json').toString());
+    ;
+    const { version } = packageJson;
+    commander_1.program
+        .description('generate graphical output from circuitscript files')
+        .version(version)
+        .option('-i, --input text <input text>', 'Input text directly')
+        .option('-f, --input-file <path>', 'Input file')
+        .option('-o, --output <path>', 'Output path')
+        .option('-c, --current-directory <path>', 'Set current directory')
+        .option('-k, --kicad-netlist <filename>', 'Create KiCad netlist')
+        .option('-w, --watch', 'Watch for file changes')
+        .option('-n, --dump-nets', 'Dump out net information')
+        .option('-d, --dump-data', 'Dump data during parsing')
+        .option('-s, --stats', 'Show stats during generation');
+    commander_1.program.addHelpText('before', figlet_1.default.textSync('circuitscript', {
+        font: 'Small Slant'
+    }));
+    if (process.argv.length < 3) {
+        commander_1.program.help();
+    }
+    commander_1.program.parse();
+    const options = commander_1.program.opts();
+    const watchFileChanges = options.watch;
+    const outputPath = options.output ?? null;
+    const dumpNets = options.dumpNets;
+    const dumpData = options.dumpData;
+    const kicadNetlist = options.kicadNetlist;
+    let currentDirectory = options.currentDirectory ?? null;
+    if (watchFileChanges) {
+        console.log('watching for file changes...');
+    }
+    await (0, sizing_js_1.prepareSVGEnvironment)(fontsPath);
+    let inputFilePath = null;
+    let scriptData;
+    if (options.input) {
+        scriptData = options.input;
+    }
+    else {
+        inputFilePath = options.inputFile;
+        const tmpScriptData = (0, helpers_js_1.getScriptText)(inputFilePath);
+        if (tmpScriptData === null) {
+            throw "File does not exists";
+        }
+        scriptData = tmpScriptData;
+        if (currentDirectory === null) {
+            currentDirectory = path_1.default.dirname(inputFilePath);
+        }
+    }
+    const scriptOptions = {
+        currentDirectory,
+        defaultLibsPath,
+        dumpNets,
+        dumpData,
+        kicadNetlistPath: kicadNetlist,
+        showStats: options.stats,
+    };
+    const visitor = (0, helpers_js_1.validateScript)(scriptData, scriptOptions);
+    const semanticTokensVisitor = (0, helpers_js_1.getSemanticTokens)(scriptData, scriptOptions);
+}
+exports.validate = validate;
+validate();