circuitscript 0.0.22 → 0.0.25

package/dist/cjs/helpers.js

@@ -0,0 +1,269 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPackageVersion = exports.getDefaultLibsPath = exports.getFontsPath = exports.getCurrentPath = exports.detectJSModuleType = exports.renderScript = exports.validateScript = exports.ParseErrorStrategy = exports.getSemanticTokens = exports.getScriptText = exports.prepareFile = exports.JSModuleType = void 0;
+const fs_1 = require("fs");
+const export_js_1 = require("./export.js");
+const layout_js_1 = require("./layout.js");
+const ExecutionScope_js_1 = require("./objects/ExecutionScope.js");
+const parser_js_1 = require("./parser.js");
+const render_js_1 = require("./render.js");
+const utils_js_1 = require("./utils.js");
+const visitor_js_1 = require("./visitor.js");
+const this_file_1 = require("this-file");
+const SymbolValidatorVisitor_js_1 = require("./SymbolValidatorVisitor.js");
+const antlr4ng_1 = require("antlr4ng");
+const lexer_js_1 = require("./lexer.js");
+const CircuitScriptParser_js_1 = require("./antlr/CircuitScriptParser.js");
+const SemanticTokenVisitor_js_1 = require("./SemanticTokenVisitor.js");
+const path_1 = __importDefault(require("path"));
+var JSModuleType;
+(function (JSModuleType) {
+    JSModuleType["CommonJs"] = "cjs";
+    JSModuleType["ESM"] = "mjs";
+})(JSModuleType || (exports.JSModuleType = JSModuleType = {}));
+function prepareFile(textData) {
+    const chars = antlr4ng_1.CharStream.fromString(textData);
+    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 parser = new CircuitScriptParser_js_1.CircuitScriptParser(tokens);
+    return {
+        parser,
+        lexer,
+        lexerTimeTaken,
+        tokens
+    };
+}
+exports.prepareFile = prepareFile;
+function getScriptText(filePath) {
+    try {
+        return (0, fs_1.readFileSync)(filePath, { encoding: 'utf-8' });
+    }
+    catch (err) {
+        return null;
+    }
+}
+exports.getScriptText = getScriptText;
+function getSemanticTokens(scriptData, options) {
+    const { parser, lexer, tokens } = prepareFile(scriptData);
+    const tree = parser.script();
+    const { currentDirectory = null, defaultLibsPath, } = options;
+    const visitor = new SemanticTokenVisitor_js_1.SemanticTokensVisitor(true, null, currentDirectory, defaultLibsPath, lexer, scriptData);
+    parser.removeErrorListeners();
+    visitor.onImportFile = (visitor, textData) => {
+        let hasError = false;
+        let hasParseError = false;
+        if (textData !== null) {
+            const { parser } = prepareFile(textData);
+            const tree = parser.script();
+            try {
+                visitor.visit(tree);
+            }
+            catch (err) {
+                console.log('Error while parsing: ', err);
+                hasParseError = true;
+                hasError = true;
+            }
+        }
+        else {
+            console.log('File does not exist');
+            hasError = true;
+        }
+        return {
+            hasError, hasParseError
+        };
+    };
+    visitor.visit(tree);
+    const semanticTokens = visitor.getTokens();
+    const parsedTokens = (0, SemanticTokenVisitor_js_1.prepareTokens)(tokens.getTokens(), lexer, scriptData);
+    const finalParsedTokens = [];
+    parsedTokens.forEach(token => {
+        const location = `${token.line}_${token.column}`;
+        if (semanticTokens.has(location)) {
+            finalParsedTokens.push(semanticTokens.get(location));
+        }
+        else {
+            finalParsedTokens.push(token);
+        }
+    });
+    return {
+        visitor,
+        parsedTokens: finalParsedTokens
+    };
+}
+exports.getSemanticTokens = getSemanticTokens;
+class TokenErrorListener extends antlr4ng_1.BaseErrorListener {
+    syntaxError(recognizer, offendingSymbol, line, column, msg, e) {
+        console.log(msg);
+    }
+}
+class ParseErrorStrategy extends antlr4ng_1.DefaultErrorStrategy {
+    reportUnwantedToken(recognizer) {
+        if (this.inErrorRecoveryMode(recognizer)) {
+            return;
+        }
+        this.beginErrorCondition(recognizer);
+        const t = recognizer.getCurrentToken();
+        const tokenName = this.getTokenErrorDisplay(t);
+        const msg = "extraneous input " + tokenName;
+        recognizer.notifyErrorListeners(msg, t, null);
+        this.endErrorCondition(recognizer);
+    }
+}
+exports.ParseErrorStrategy = ParseErrorStrategy;
+function validateScript(scriptData, options) {
+    const { parser } = prepareFile(scriptData);
+    parser.removeErrorListeners();
+    parser.errorHandler = new ParseErrorStrategy();
+    parser.addErrorListener(new TokenErrorListener());
+    const tree = parser.script();
+    const { currentDirectory = null, defaultLibsPath, } = options;
+    const visitor = new SymbolValidatorVisitor_js_1.SymbolValidatorVisitor(true, null, currentDirectory, defaultLibsPath);
+    visitor.onImportFile = (visitor, textData) => {
+        let hasError = false;
+        let hasParseError = false;
+        if (textData !== null) {
+            const { parser } = prepareFile(textData);
+            const tree = parser.script();
+            try {
+                visitor.visit(tree);
+            }
+            catch (err) {
+                console.log('got an error while parsing tree: ', err);
+                hasParseError = true;
+                hasError = true;
+            }
+        }
+        else {
+            console.log('file does not exist!');
+            hasError = true;
+        }
+        return {
+            hasError, hasParseError
+        };
+    };
+    visitor.visit(tree);
+    const symbolTable = visitor.getSymbols();
+    symbolTable.clearUndefined();
+    const visitorResolver = new SymbolValidatorVisitor_js_1.SymbolValidatorResolveVisitor(true, null, currentDirectory, defaultLibsPath);
+    visitorResolver.setSymbols(visitor.getSymbols());
+    visitorResolver.onImportFile = visitor.onImportFile;
+    visitorResolver.visit(tree);
+    return visitorResolver;
+}
+exports.validateScript = validateScript;
+function renderScript(scriptData, outputPath, options) {
+    const { currentDirectory = null, defaultLibsPath, dumpNets = false, dumpData = false, kicadNetlistPath = null, showStats = false } = options;
+    const onErrorHandler = (line, column, message, error) => {
+        if (error instanceof visitor_js_1.VisitorExecutionException) {
+            console.log('Error', line, column, message, error.errorMessage);
+        }
+    };
+    const visitor = new visitor_js_1.ParserVisitor(true, onErrorHandler, currentDirectory, defaultLibsPath);
+    visitor.onImportFile = (visitor, fileData) => {
+        const { hasError, hasParseError } = (0, parser_js_1.parseFileWithVisitor)(visitor, fileData);
+        return { hasError, hasParseError };
+    };
+    visitor.log('reading file');
+    visitor.log('done reading file');
+    const { tree, parser, hasParseError, hasError, parserTimeTaken, lexerTimeTaken } = (0, parser_js_1.parseFileWithVisitor)(visitor, scriptData);
+    showStats && console.log('Lexing took:', lexerTimeTaken);
+    showStats && console.log('Parsing took:', parserTimeTaken);
+    dumpNets && console.log(visitor.dumpNets());
+    dumpData && (0, fs_1.writeFileSync)('dump/tree.lisp', tree.toStringTree(null, parser));
+    dumpData && (0, fs_1.writeFileSync)('dump/raw-parser.txt', visitor.logger.dump());
+    if (hasError || hasParseError) {
+        console.log('Error while parsing');
+        return null;
+    }
+    try {
+        visitor.annotateComponents();
+    }
+    catch (err) {
+        console.log('Error during annotation: ', err);
+    }
+    if (kicadNetlistPath) {
+        const kicadNetList = (0, export_js_1.generateKiCADNetList)(visitor.getNetList());
+        (0, fs_1.writeFileSync)(kicadNetlistPath, kicadNetList);
+        console.log('Generated KiCad netlist file');
+    }
+    const { sequence, nets } = visitor.getGraph();
+    const tmpSequence = sequence.map(item => {
+        const tmp = [...item];
+        const action = tmp[0];
+        if (action === ExecutionScope_js_1.SequenceAction.Wire) {
+            tmp[2] = tmp[2].map(item2 => {
+                return [item2.direction, item2.value].join(",");
+            }).join(" ");
+        }
+        else if (action === ExecutionScope_js_1.SequenceAction.Frame) {
+            tmp[1] = item[1].frameId;
+        }
+        else if (action !== ExecutionScope_js_1.SequenceAction.WireJump) {
+            tmp[1] = item[1].instanceName;
+        }
+        return tmp.join(" | ");
+    });
+    dumpData && (0, fs_1.writeFileSync)('dump/raw-sequence.txt', tmpSequence.join('\n'));
+    let svgOutput = null;
+    try {
+        const layoutEngine = new layout_js_1.LayoutEngine();
+        const layoutTimer = new utils_js_1.SimpleStopwatch();
+        const graph = layoutEngine.runLayout(sequence, nets);
+        layoutEngine.printWarnings();
+        showStats && console.log('Layout took:', layoutTimer.lap());
+        dumpData && (0, fs_1.writeFileSync)('dump/raw-layout.txt', layoutEngine.logger.dump());
+        const generateSvgTimer = new utils_js_1.SimpleStopwatch();
+        svgOutput = (0, render_js_1.generateSVG2)(graph);
+        showStats && console.log('Render took:', generateSvgTimer.lap());
+        if (outputPath) {
+            (0, fs_1.writeFileSync)(outputPath, svgOutput);
+        }
+    }
+    catch (err) {
+        console.log('Error during render: ', err);
+    }
+    return svgOutput;
+}
+exports.renderScript = renderScript;
+function detectJSModuleType() {
+    if (typeof __filename === 'undefined' &&
+        typeof __dirname === 'undefined') {
+        return JSModuleType.ESM;
+    }
+    else {
+        return JSModuleType.CommonJs;
+    }
+}
+exports.detectJSModuleType = detectJSModuleType;
+const context = (0, this_file_1.createContext)();
+function getCurrentPath() {
+    const filename = context.filename;
+    return { filePath: filename };
+}
+exports.getCurrentPath = getCurrentPath;
+function getToolsPath() {
+    const { filePath } = getCurrentPath();
+    return path_1.default.normalize(path_1.default.dirname(filePath) + '/../../');
+}
+function getFontsPath() {
+    const toolsPath = getToolsPath();
+    return path_1.default.normalize(toolsPath + "fonts");
+}
+exports.getFontsPath = getFontsPath;
+function getDefaultLibsPath() {
+    const toolsPath = getToolsPath();
+    return path_1.default.normalize(toolsPath + "libs");
+}
+exports.getDefaultLibsPath = getDefaultLibsPath;
+function getPackageVersion() {
+    const packageJson = JSON.parse((0, fs_1.readFileSync)(getToolsPath() + 'package.json').toString());
+    const { version } = packageJson;
+    return version;
+}
+exports.getPackageVersion = getPackageVersion;

package/dist/cjs/index.js

@@ -0,0 +1,31 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./draw_symbols.js"), exports);
+__exportStar(require("./execute.js"), exports);
+__exportStar(require("./export.js"), exports);
+__exportStar(require("./geometry.js"), exports);
+__exportStar(require("./globals.js"), exports);
+__exportStar(require("./helpers.js"), exports);
+__exportStar(require("./layout.js"), exports);
+__exportStar(require("./lexer.js"), exports);
+__exportStar(require("./logger.js"), exports);
+__exportStar(require("./parser.js"), exports);
+__exportStar(require("./render.js"), exports);
+__exportStar(require("./utils.js"), exports);
+__exportStar(require("./visitor.js"), exports);
+__exportStar(require("./sizing.js"), exports);
+__exportStar(require("./objects/types.js"), exports);