circuitscript 0.1.5 → 0.1.8

package/dist/cjs/main.js

@@ -6,14 +6,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 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");
+const environment_js_1 = require("./environment.js");
 async function main() {
-    const fontsPath = (0, helpers_js_1.getFontsPath)();
-    const defaultLibsPath = (0, helpers_js_1.getDefaultLibsPath)();
-    const version = (0, helpers_js_1.getPackageVersion)();
+    const env = new environment_js_1.NodeScriptEnvironment();
+    environment_js_1.NodeScriptEnvironment.setInstance(env);
+    const version = env.getPackageVersion();
     commander_1.program
         .description('generate graphical output from circuitscript files')
         .version(version)
@@ -38,11 +37,13 @@ async function main() {
     const watchFileChanges = options.watch;
     const dumpNets = options.dumpNets;
     const dumpData = options.dumpData;
-    let currentDirectory = options.currentDirectory ?? null;
+    if (options.currentDirectory) {
+        throw "Parameter not supported yet";
+    }
     if (watchFileChanges) {
         console.log('watching for file changes...');
     }
-    await (0, sizing_js_1.prepareSVGEnvironment)(fontsPath);
+    await env.prepareSVGEnvironment();
     let inputFilePath = "";
     if (args.length > 2) {
         console.log("Error: Extra arguments passed");
@@ -51,11 +52,8 @@ async function main() {
     let scriptData;
     if (args.length > 0 && args[0]) {
         inputFilePath = args[0];
-        if ((0, fs_1.existsSync)(inputFilePath)) {
-            scriptData = (0, fs_1.readFileSync)(inputFilePath, { encoding: 'utf-8' });
-            if (currentDirectory === null) {
-                currentDirectory = path_1.default.dirname(inputFilePath);
-            }
+        if ((await env.exists(inputFilePath))) {
+            scriptData = await env.readFile(inputFilePath, { encoding: 'utf-8' });
         }
         else {
             console.error("Error: File could not be found");
@@ -70,29 +68,43 @@ async function main() {
         return;
     }
     const scriptOptions = {
-        currentDirectory,
-        defaultLibsPath,
         dumpNets,
         dumpData,
         showStats: options.stats,
+        environment: env,
     };
     let outputPath = null;
     if (args.length > 0 && args[1]) {
         outputPath = args[1];
     }
-    const output = (0, helpers_js_1.renderScript)(scriptData, outputPath, scriptOptions);
+    const output = await parseFile(scriptData, outputPath, scriptOptions);
     if (outputPath === null && output && (options.skipOutput === undefined)) {
         console.log(output);
     }
     if (watchFileChanges) {
-        (0, fs_1.watch)(inputFilePath, event => {
+        (0, fs_1.watch)(inputFilePath, async (event) => {
             if (event === 'change') {
-                const scriptData = (0, fs_1.readFileSync)(inputFilePath, { encoding: 'utf-8' });
-                (0, helpers_js_1.renderScript)(scriptData, outputPath, scriptOptions);
-                console.log('done');
+                const scriptData = await env.readFile(inputFilePath, { encoding: 'utf-8' });
+                parseFile(scriptData, outputPath, scriptOptions);
             }
         });
     }
 }
 exports.default = main;
+async function parseFile(scriptData, outputPath, scriptOptions) {
+    try {
+        const { svgOutput: output, errors } = await (0, helpers_js_1.renderScript)(scriptData, outputPath, scriptOptions);
+        errors.forEach((err, index) => {
+            console.log(`[${index}] ${err}`);
+        });
+        if (errors.length > 0) {
+            console.log('Render failed due to syntax or parsing errors');
+        }
+        return output;
+    }
+    catch (error) {
+        console.error(`Unexpected Error: ${error}`);
+    }
+    return null;
+}
 main();

package/dist/cjs/objects/ExecutionScope.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ActiveObject = exports.FrameAction = exports.SequenceAction = exports.ExecutionScope = void 0;
+const CircuitScriptParser_js_1 = require("../antlr/CircuitScriptParser.js");
 class ExecutionScope {
     constructor(scopeId) {
         this.nets = [];
@@ -9,6 +10,8 @@ class ExecutionScope {
         this.variables = new Map();
         this.symbols = new Map();
         this.blockStack = new Map();
+        this.contextStack = [];
+        this.onPropertyHandler = [];
         this.breakStack = [];
         this.wires = [];
         this.frames = [];
@@ -123,6 +126,36 @@ class ExecutionScope {
             this.currentPin = null;
         }
     }
+    enterContext(context) {
+        this.contextStack.push(context);
+    }
+    exitContext() {
+        return this.contextStack.pop();
+    }
+    findPropertyKeyTree() {
+        const keyNames = [];
+        for (let i = this.contextStack.length - 1; i >= 0; i--) {
+            const ctx = this.contextStack[i];
+            if (ctx instanceof CircuitScriptParser_js_1.Property_key_exprContext) {
+                keyNames.push([ctx, ctx.getText()]);
+            }
+            else if (typeof ctx === 'number') {
+                keyNames.push(['index', ctx]);
+            }
+        }
+        return keyNames.reverse();
+    }
+    setOnPropertyHandler(handler) {
+        this.onPropertyHandler.push(handler);
+    }
+    popOnPropertyHandler() {
+        return this.onPropertyHandler.pop();
+    }
+    triggerPropertyHandler(value, valueCtx) {
+        const lastHandler = this.onPropertyHandler[this.onPropertyHandler.length - 1];
+        const propertyTree = this.findPropertyKeyTree();
+        lastHandler && lastHandler(propertyTree, value, valueCtx);
+    }
 }
 exports.ExecutionScope = ExecutionScope;
 ExecutionScope.scopeId = 0;

package/dist/cjs/objects/ParamDefinition.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NumberOperator = exports.WrappedNumber = exports.PercentageValue = exports.numeric = exports.NumericValue = exports.ParamDefinition = void 0;
-const utils_1 = require("../utils");
+const utils_js_1 = require("../utils.js");
 const big_js_1 = require("big.js");
 class ParamDefinition {
     constructor(paramName, paramValue) {
@@ -17,7 +17,7 @@ class NumericValue {
             const matches = value.match(/^([\d]+(?:.[\d]+)?)([\w]*)$/);
             if (matches) {
                 this.valuePart = new big_js_1.Big(matches[1]);
-                this.prefixPart = (0, utils_1.getNumberExponential)(matches[2]);
+                this.prefixPart = (0, utils_js_1.getNumberExponential)(matches[2]);
             }
             else {
                 throw new Error("Invalid numeric value: " + value);
@@ -27,7 +27,7 @@ class NumericValue {
             this.valuePart = new big_js_1.Big(value);
             this.prefixPart = prefix;
             this.value = this.valuePart.toString()
-                + (0, utils_1.getNumberExponentialText)(prefix);
+                + (0, utils_js_1.getNumberExponentialText)(prefix);
         }
     }
     toString() {
@@ -39,7 +39,7 @@ class NumericValue {
         }
         else {
             return this.valuePart.toString()
-                + (0, utils_1.getNumberExponentialText)(this.prefixPart);
+                + (0, utils_js_1.getNumberExponentialText)(this.prefixPart);
         }
     }
     toNumber() {
@@ -52,7 +52,7 @@ class NumericValue {
         if (typeof value === 'number') {
             value = numeric(value);
         }
-        return (0, utils_1.resolveToNumericValue)(this.toBigNumber().div(value.toBigNumber()));
+        return (0, utils_js_1.resolveToNumericValue)(this.toBigNumber().div(value.toBigNumber()));
     }
     half() {
         return this.div(2);
@@ -61,28 +61,28 @@ class NumericValue {
         if (typeof value === 'number') {
             value = numeric(value);
         }
-        return (0, utils_1.resolveToNumericValue)(this.toBigNumber().mul(value.toBigNumber()));
+        return (0, utils_js_1.resolveToNumericValue)(this.toBigNumber().mul(value.toBigNumber()));
     }
     add(value) {
         if (typeof value === 'number') {
             value = numeric(value);
         }
-        return (0, utils_1.resolveToNumericValue)(this.toBigNumber().add(value.toBigNumber()));
+        return (0, utils_js_1.resolveToNumericValue)(this.toBigNumber().add(value.toBigNumber()));
     }
     sub(value) {
         if (typeof value === 'number') {
             value = numeric(value);
         }
-        return (0, utils_1.resolveToNumericValue)(this.toBigNumber().sub(value.toBigNumber()));
+        return (0, utils_js_1.resolveToNumericValue)(this.toBigNumber().sub(value.toBigNumber()));
     }
     mod(value) {
         if (typeof value === 'number') {
             value = numeric(value);
         }
-        return (0, utils_1.resolveToNumericValue)(this.toBigNumber().mod(value.toBigNumber()));
+        return (0, utils_js_1.resolveToNumericValue)(this.toBigNumber().mod(value.toBigNumber()));
     }
     neg() {
-        return (0, utils_1.resolveToNumericValue)(this.toBigNumber().neg());
+        return (0, utils_js_1.resolveToNumericValue)(this.toBigNumber().neg());
     }
     eq(value) {
         return this.toBigNumber().eq(value.toBigNumber());
@@ -129,27 +129,27 @@ class NumberOperator {
     multiply(value1, value2) {
         const big1 = new big_js_1.Big(value1.toNumber());
         const big2 = new big_js_1.Big(value2.toNumber());
-        return (0, utils_1.resolveToNumericValue)(big1.mul(big2));
+        return (0, utils_js_1.resolveToNumericValue)(big1.mul(big2));
     }
     divide(value1, value2) {
         const big1 = new big_js_1.Big(value1.toNumber());
         const big2 = new big_js_1.Big(value2.toNumber());
-        return (0, utils_1.resolveToNumericValue)(big1.div(big2));
+        return (0, utils_js_1.resolveToNumericValue)(big1.div(big2));
     }
     addition(value1, value2) {
         const big1 = new big_js_1.Big(value1.toNumber());
         const big2 = new big_js_1.Big(value2.toNumber());
-        return (0, utils_1.resolveToNumericValue)(big1.add(big2));
+        return (0, utils_js_1.resolveToNumericValue)(big1.add(big2));
     }
     subtraction(value1, value2) {
         const big1 = new big_js_1.Big(value1.toNumber());
         const big2 = new big_js_1.Big(value2.toNumber());
-        return (0, utils_1.resolveToNumericValue)(big1.sub(big2));
+        return (0, utils_js_1.resolveToNumericValue)(big1.sub(big2));
     }
     modulus(value1, value2) {
         const big1 = new big_js_1.Big(value1.toNumber());
         const big2 = new big_js_1.Big(value2.toNumber());
-        return (0, utils_1.resolveToNumericValue)(big1.mod(big2));
+        return (0, utils_js_1.resolveToNumericValue)(big1.mod(big2));
     }
 }
 exports.NumberOperator = NumberOperator;

package/dist/cjs/parser.js

@@ -1,59 +1,65 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CircuitscriptParserErrorListener = exports.TempErrorStrategy = exports.parseFileWithVisitor = void 0;
+exports.CircuitscriptParserErrorListener = 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) {
+async function parseFileWithVisitor(visitor, data) {
+    const lexerErrorListener = new CircuitscriptParserErrorListener(visitor.onErrorHandler);
+    const parserErrorListener = new CircuitscriptParserErrorListener(visitor.onErrorHandler);
     const chars = antlr4ng_1.CharStream.fromString(data);
     const lexer = new lexer_js_1.MainLexer(chars);
+    lexer.removeErrorListeners();
+    lexer.addErrorListener(lexerErrorListener);
     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);
+    parser.removeErrorListeners();
+    parser.addErrorListener(parserErrorListener);
     const tree = parser.script();
-    let hasError = false;
     try {
-        visitor.visit(tree);
+        await visitor.visitAsync(tree);
     }
-    catch (err) {
-        console.log(err);
-        hasError = true;
+    catch (error) {
+        if (visitor.onErrorHandler) {
+            if (error instanceof utils_js_1.RuntimeExecutionError) {
+                visitor.onErrorHandler(error.message, null, error);
+            }
+            else {
+                throw error;
+            }
+        }
     }
     const parserTimeTaken = parserTimer.lap();
     return {
         tree, parser,
         hasParseError: false,
-        hasError,
+        hasError: false,
         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);
+    syntaxError(recognizer, offendingSymbol, line, column, msg, e) {
+        if (this.onErrorHandler && e) {
+            this.onErrorHandler(msg, e.ctx, e);
         }
         else {
-            console.log("Syntax error at line", line, ':', charPositionInLine, ' - ', msg);
+            if (offendingSymbol && msg.match("extraneous input 'import' expecting")) {
+                msg = "Invalid import statement";
+                throw new utils_js_1.ParseSyntaxError("Invalid import statement", offendingSymbol);
+            }
+            console.log("Syntax error at line", line, ':', column, ' - ', msg);
         }
         this.syntaxErrorCounter++;
     }

package/dist/cjs/regenerate-tests.js

@@ -5,12 +5,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const fs_1 = __importDefault(require("fs"));
 const helpers_js_1 = require("./helpers.js");
-const sizing_js_1 = require("./sizing.js");
+const environment_js_1 = require("./environment.js");
 const mainDir = './__tests__/renderData/';
-const fontsPath = (0, helpers_js_1.getFontsPath)();
-const defaultLibsPath = (0, helpers_js_1.getDefaultLibsPath)();
+const env = new environment_js_1.NodeScriptEnvironment();
+environment_js_1.NodeScriptEnvironment.setInstance(env);
 async function regenerateTests(extra = "") {
-    await (0, sizing_js_1.prepareSVGEnvironment)(fontsPath);
+    await env.prepareSVGEnvironment();
     const cstFiles = [];
     const files = fs_1.default.readdirSync(mainDir);
     files.forEach(file => {
@@ -18,16 +18,20 @@ async function regenerateTests(extra = "") {
             cstFiles.push(file);
         }
     });
-    cstFiles.forEach(file => {
+    for (let i = 0; i < cstFiles.length; i++) {
+        const file = cstFiles[i];
         const inputPath = mainDir + file;
         const scriptData = fs_1.default.readFileSync(inputPath, { encoding: 'utf-8' });
         const outputPath = mainDir + 'svgs/' + file + extra + '.svg';
-        (0, helpers_js_1.renderScript)(scriptData, outputPath, {
-            currentDirectory: mainDir,
-            defaultLibsPath,
+        env.setModuleDirectory(mainDir);
+        env.setDefaultLibsPath(mainDir + '../../libs/');
+        await (0, helpers_js_1.renderScript)(scriptData, outputPath, {
+            dumpNets: false,
+            dumpData: false,
+            showStats: false,
+            environment: env,
         });
-        console.log('generated ', outputPath);
-    });
+    }
     return cstFiles;
 }
 (async () => {

package/dist/cjs/render.js

@@ -11,11 +11,13 @@ const globals_js_1 = require("./globals.js");
 const ParamDefinition_js_1 = require("./objects/ParamDefinition.js");
 const utils_js_1 = require("./utils.js");
 const helpers_js_1 = require("./helpers.js");
+const environment_js_1 = require("./environment.js");
 const svg_to_pdfkit_1 = __importDefault(require("svg-to-pdfkit"));
 const Frame_js_1 = require("./objects/Frame.js");
 const draw_symbols_js_1 = require("./draw_symbols.js");
 function createSvgCanvas() {
-    const window = (0, sizing_js_1.getCreateSVGWindow)()();
+    const env = environment_js_1.NodeScriptEnvironment.getInstance();
+    const window = env.createSVGWindow();
     const document = window.document;
     (0, svg_js_1.registerWindow)(window, document);
     const canvas = (0, svg_js_1.SVG)(document.documentElement);

package/dist/cjs/sizing.js

@@ -1,71 +1,18 @@
 "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.applyFontsToSVG = exports.getCreateSVGWindow = exports.prepareSVGEnvironment = void 0;
-const svg_js_1 = require("@svgdotjs/svg.js");
+exports.measureTextSize2 = exports.applyFontsToSVG = void 0;
 const big_js_1 = require("big.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 = {
-    'Arial': 'Arial.ttf',
-};
-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;
+const environment_js_1 = require("./environment.js");
 function applyFontsToSVG(canvas) {
 }
 exports.applyFontsToSVG = applyFontsToSVG;
 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 environment = environment_js_1.NodeScriptEnvironment.getInstance();
+    const mainCanvas = environment.getCanvasWindow();
     const key = `${text}-${fontFamily}-${fontSize}-${fontWeight}-${anchor}-${vanchor}`;
     if (measureTextSizeCache[key] === undefined) {
         let dominantBaseline = geometry_js_1.VerticalAlignProp.Hanging;
@@ -93,7 +40,7 @@ function measureTextSize2(text, fontFamily, fontSize, fontWeight = 'regular', an
                 break;
         }
         fontFamily = globals_js_1.defaultFont;
-        const tmpTextElement = MainCanvas.text(text).font({
+        const tmpTextElement = mainCanvas.text(text).font({
             family: fontFamily,
             size: fontSize,
             anchor: useAnchor,