circuitscript 0.3.2 → 0.4.1

package/dist/cjs/lexer.js

@@ -4,28 +4,40 @@ exports.MainLexer = void 0;
 const antlr4ng_1 = require("antlr4ng");
 const CircuitScriptParser_js_1 = require("./antlr/CircuitScriptParser.js");
 const CircuitScriptLexer_js_1 = require("./antlr/CircuitScriptLexer.js");
+const LexerDiagnosticListener_js_1 = require("./LexerDiagnosticListener.js");
 class MainLexer extends CircuitScriptLexer_js_1.CircuitScriptLexer {
-    constructor(input) {
+    constructor(input, enableDiagnostics = false) {
         super(input);
         this.tokens = [];
+        this.tokensHead = 0;
         this.indents = [];
         this.opened = 0;
+        this.lineOffset = 0;
+        this.diagnosticCollector = new LexerDiagnosticListener_js_1.LexerDiagnosticCollector();
+        this.diagnosticCollector.setEnabled(enableDiagnostics);
     }
     reset() {
         this.tokens = [];
+        this.tokensHead = 0;
         this.indents = [];
         this.opened = 0;
         super.reset();
     }
     emitToken(token) {
+        this.diagnosticCollector.onTokenStart();
         super.emitToken(token);
         this.tokens.push(token);
+        this.diagnosticCollector.onTokenGenerated(token, this.tokens.length - this.tokensHead);
     }
     nextToken() {
         if (this.inputStream.LA(1) === CircuitScriptParser_js_1.CircuitScriptParser.EOF && this.indents.length) {
-            this.tokens = this.tokens.filter(function (val) {
-                return val.type !== CircuitScriptParser_js_1.CircuitScriptParser.EOF;
-            });
+            let writeIdx = this.tokensHead;
+            for (let i = this.tokensHead; i < this.tokens.length; i++) {
+                if (this.tokens[i].type !== CircuitScriptParser_js_1.CircuitScriptParser.EOF) {
+                    this.tokens[writeIdx++] = this.tokens[i];
+                }
+            }
+            this.tokens.length = writeIdx;
             const fillerNewLine = this.commonToken(CircuitScriptParser_js_1.CircuitScriptParser.NEWLINE, "");
             this.emitToken(fillerNewLine);
             fillerNewLine.__skip = true;
@@ -36,7 +48,19 @@ class MainLexer extends CircuitScriptLexer_js_1.CircuitScriptLexer {
             this.emitToken(this.commonToken(CircuitScriptParser_js_1.CircuitScriptParser.EOF, ""));
         }
         const next = super.nextToken();
-        return this.tokens.length ? this.tokens.shift() : next;
+        let returnToken;
+        if (this.tokensHead < this.tokens.length) {
+            returnToken = this.tokens[this.tokensHead++];
+            if (this.tokensHead > 64) {
+                this.tokens = this.tokens.slice(this.tokensHead);
+                this.tokensHead = 0;
+            }
+        }
+        else {
+            returnToken = next;
+        }
+        returnToken.line += this.lineOffset;
+        return returnToken;
     }
     createDedent() {
         return this.commonToken(CircuitScriptParser_js_1.CircuitScriptParser.DEDENT, "");
@@ -80,9 +104,6 @@ class MainLexer extends CircuitScriptLexer_js_1.CircuitScriptLexer {
         }
         return count;
     }
-    atStartOfInput() {
-        return this.getCharIndex() === 0;
-    }
     openBrace() {
         this.opened++;
     }
@@ -90,8 +111,19 @@ class MainLexer extends CircuitScriptLexer_js_1.CircuitScriptLexer {
         this.opened--;
     }
     onNewLine() {
-        const newLine = this.text.replace(/[^\r\n]+/g, '');
-        const spaces = this.text.replace(/[\r\n]+/g, '');
+        const text = this.text;
+        let nlLen = 0;
+        while (nlLen < text.length) {
+            const c = text.charCodeAt(nlLen);
+            if (c === 13 || c === 10 || c === 12) {
+                nlLen++;
+            }
+            else {
+                break;
+            }
+        }
+        const newLine = text.substring(0, nlLen);
+        const spaces = text.substring(nlLen);
         const next = this.inputStream.LA(1);
         const nextnext = this.inputStream.LA(2);
         if (this.opened > 0 || (nextnext != -1 &&
@@ -99,8 +131,9 @@ class MainLexer extends CircuitScriptLexer_js_1.CircuitScriptLexer {
             this.skip();
         }
         else {
-            const start = this.getCharIndex() - this.text.length;
-            const stop = this.getCharIndex() - 1;
+            const charIndex = this.getCharIndex();
+            const start = charIndex - this.text.length;
+            const stop = charIndex - 1;
             this.emitToken(this.commonToken(CircuitScriptParser_js_1.CircuitScriptParser.NEWLINE, newLine, start, start));
             const indent = this.getIndentationCount(spaces);
             const previous = this.indents.length ? this.indents[this.indents.length - 1] : 0;
@@ -119,5 +152,8 @@ class MainLexer extends CircuitScriptLexer_js_1.CircuitScriptLexer {
             }
         }
     }
+    setLineOffset(offset) {
+        this.lineOffset = offset;
+    }
 }
 exports.MainLexer = MainLexer;

package/dist/cjs/main.js

@@ -7,8 +7,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
 const figlet_1 = __importDefault(require("figlet"));
 const fs_1 = require("fs");
-const helpers_js_1 = require("./helpers.js");
-const environment_js_1 = require("./environment.js");
+const pipeline_js_1 = require("./pipeline.js");
+const environment_js_1 = require("./environment/environment.js");
 async function main() {
     const env = new environment_js_1.NodeScriptEnvironment();
     environment_js_1.NodeScriptEnvironment.setInstance(env);
@@ -27,7 +27,12 @@ async function main() {
         .option('-s, --stats', 'Show stats during generation')
         .option('-x, --skip-output', 'Skip output generation')
         .option('-e, --erc', 'Enable ERC output')
-        .option('-b, --bom [output-path]', 'Generate Bill of Materials in csv format');
+        .option('-b, --bom [output-path]', 'Generate Bill of Materials in csv format')
+        .option('-l, --lexer-diagnostics', 'Enable lexer performance diagnostics')
+        .option('--lexer-verbose', 'Log each token as it is generated (requires -l)')
+        .option('--lexer-tokens [limit]', 'Print token stream (optionally limit number of tokens, requires -l)')
+        .option('--lexer-mapping [lines]', 'Print character-to-token mapping (optionally specify line range like "1-10", requires -l)')
+        .option('--lexer-summary', 'Print lexer operation summary (requires -l)');
     commander_1.program.addHelpText('before', figlet_1.default.textSync('circuitscript', {
         font: 'Small Slant'
     }));
@@ -92,6 +97,11 @@ async function main() {
         enableBom,
         bomOutputPath,
         environment: env,
+        lexerDiagnostics: options.lexerDiagnostics,
+        lexerVerbose: options.lexerVerbose,
+        lexerTokens: options.lexerTokens,
+        lexerMapping: options.lexerMapping,
+        lexerSummary: options.lexerSummary,
         inputPath: inputFilePath,
         updateSource,
         saveAnnotatedCopy: saveAnnotatedCopyPath,
@@ -119,7 +129,7 @@ async function main() {
 exports.default = main;
 async function parseFile(scriptData, outputPath, scriptOptions) {
     try {
-        const { svgOutput: output, errors } = await (0, helpers_js_1.renderScript)(scriptData, outputPath, scriptOptions);
+        const { svgOutput: output, errors } = await (0, pipeline_js_1.renderScript)(scriptData, outputPath, scriptOptions);
         errors.forEach((err, index) => {
             console.log(`[${index}] ${err}`);
         });

package/dist/cjs/objects/ClassComponent.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ModuleComponent = exports.ClassComponent = exports.ComponentUnit = void 0;
-const draw_symbols_js_1 = require("../draw_symbols.js");
+const draw_symbols_js_1 = require("../render/draw_symbols.js");
 const PinDefinition_js_1 = require("./PinDefinition.js");
 const PinTypes_js_1 = require("./PinTypes.js");
 const globals_js_1 = require("../globals.js");

package/dist/cjs/objects/ExecutionScope.js

@@ -11,7 +11,6 @@ class ExecutionScope {
         this.functions = new Map();
         this.functionCounter = new Map();
         this.variables = new Map();
-        this.symbols = new Map();
         this.libraries = new Map();
         this.blockStack = new Map();
         this.contextStack = [];

package/dist/cjs/objects/types.js

@@ -5,6 +5,8 @@ const globals_js_1 = require("../globals.js");
 const utils_js_1 = require("../utils.js");
 class CFunctionEntry {
     constructor(namespace, name, execute, source, uniqueId) {
+        this.lazyLoaded = false;
+        this.lazyLoader = null;
         this.name = name;
         this.namespace = namespace;
         this.originalNamespace = namespace;
@@ -15,6 +17,9 @@ class CFunctionEntry {
     toString() {
         return `[Function: ${this.name}]`;
     }
+    getFunctionPath() {
+        return `${this.namespace}${this.name}`;
+    }
 }
 exports.CFunctionEntry = CFunctionEntry;
 ;
@@ -117,9 +122,13 @@ var NetTypes;
     NetTypes["Source"] = "source";
 })(NetTypes || (exports.NetTypes = NetTypes = {}));
 class ImportedLibrary {
-    constructor(libraryName, libraryNamespace, libraryFilePath, tree, tokens, context, flag, specifiedImports) {
+    constructor(libraryName, libraryNamespace, libraryFilePath, tree, tokens, context, flag, specifiedImports, fileHash, importStatement) {
         this.enableRefdesAnnotation = false;
         this.enableRefdesAnnotationFile = false;
+        this.referencedTokens = [];
+        this.writeToCache = false;
+        this.refdesAnnotations = new Map;
+        this.parseError = false;
         this.libraryName = libraryName;
         this.libraryNamespace = libraryNamespace;
         this.libraryFilePath = libraryFilePath;
@@ -128,6 +137,13 @@ class ImportedLibrary {
         this.context = context;
         this.importHandlingFlag = flag;
         this.specifiedImports = specifiedImports;
+        this.fileHash = fileHash;
+        this.importStatement = importStatement;
+    }
+    addRefdesModifications(mods) {
+        for (const [ctx, modification] of mods) {
+            this.refdesAnnotations.set(ctx, modification);
+        }
     }
 }
 exports.ImportedLibrary = ImportedLibrary;

package/dist/cjs/parser.js

@@ -5,27 +5,40 @@ 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");
-async function parseFileWithVisitor(visitor, data) {
+function parseFileWithVisitor(visitor, data, options) {
     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);
+    const enableDiagnostics = options?.enableLexerDiagnostics ?? false;
+    const enableVerbose = options?.enableLexerVerbose ?? false;
+    const enableTokenStream = options?.enableLexerTokenStream ?? false;
+    const lineOffset = options?.lineOffset ?? 0;
+    const lexer = new lexer_js_1.MainLexer(chars, enableDiagnostics);
+    lexer.setLineOffset(lineOffset);
+    if (enableDiagnostics) {
+        lexer.diagnosticCollector.setSourceText(data);
+        lexer.diagnosticCollector.setVerboseLogging(enableVerbose);
+        if (enableTokenStream) {
+            lexer.diagnosticCollector.setRecordTokenStream(true);
+        }
+    }
     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.interpreter.predictionMode = antlr4ng_1.PredictionMode.SLL;
     parser.removeErrorListeners();
     parser.addErrorListener(parserErrorListener);
+    const parserTimer = new utils_js_1.SimpleStopwatch();
     const tree = parser.script();
     let throwError;
     let hasError = false;
     let hasParseError = false;
     try {
-        await visitor.visitAsync(tree);
+        visitor.visit(tree);
     }
     catch (error) {
         if (visitor.onErrorHandler) {
@@ -43,6 +56,7 @@ async function parseFileWithVisitor(visitor, data) {
     return {
         tree, parser,
         tokens,
+        lexer,
         hasParseError,
         hasError,
         parserTimeTaken,

package/dist/cjs/pipeline.js

@@ -0,0 +1,284 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderScriptCustom = exports.renderScript = void 0;
+const path_1 = __importDefault(require("path"));
+const pdfkit_1 = __importDefault(require("pdfkit"));
+const antlr4ng_1 = require("antlr4ng");
+const DefaultPostAnnotationCallback_js_1 = require("./annotate/DefaultPostAnnotationCallback.js");
+const BomGeneration_js_1 = require("./BomGeneration.js");
+const globals_js_1 = require("./globals.js");
+const graph_js_1 = require("./render/graph.js");
+const layout_js_1 = require("./render/layout.js");
+const logger_js_1 = require("./logger.js");
+const Frame_js_1 = require("./objects/Frame.js");
+const parser_js_1 = require("./parser.js");
+const KiCadNetListOutputHandler_js_1 = require("./render/KiCadNetListOutputHandler.js");
+const render_js_1 = require("./render/render.js");
+const rules_js_1 = require("./rules-check/rules.js");
+const utils_js_1 = require("./utils.js");
+const visitor_js_1 = require("./visitor.js");
+async function renderScript(scriptData, outputPath, options) {
+    const parseHandlers = [
+        new KiCadNetListOutputHandler_js_1.KiCadNetListOutputHandler(),
+    ];
+    return renderScriptCustom(scriptData, outputPath, options, parseHandlers, [DefaultPostAnnotationCallback_js_1.DefaultPostAnnotationCallback]);
+}
+exports.renderScript = renderScript;
+async function renderScriptCustom(scriptData, outputPath, options, parseHandlers, postAnnotationCallbacks) {
+    const { dumpNets = false, dumpData = false, showStats = false, enableErc = false, enableBom = false, lexerDiagnostics = false, lexerVerbose = false, lexerTokens = false, lexerMapping = false, lexerSummary = false, inputPath = '', bomOutputPath = undefined, environment } = options;
+    const errors = [];
+    const onErrorHandler = (message, context, error) => {
+        if (error && error instanceof utils_js_1.RuntimeExecutionError) {
+            errors.push(error);
+        }
+        else if (error && error instanceof antlr4ng_1.RecognitionException) {
+            if (context !== null) {
+                errors.push(new utils_js_1.ParseSyntaxError(message, context.start, context.stop));
+            }
+            else {
+                if (error.recognizer) {
+                    const recognizer = error.recognizer;
+                    errors.push(new utils_js_1.ParseSyntaxError(message, {
+                        line: recognizer.currentTokenStartLine,
+                        column: recognizer.currentTokenColumn
+                    }));
+                }
+                else {
+                    errors.push(new utils_js_1.ParseSyntaxError(message));
+                }
+            }
+        }
+        else {
+            errors.push(new utils_js_1.ParseError(message, context.start, context.stop));
+        }
+    };
+    const visitor = new visitor_js_1.ParserVisitor(true, onErrorHandler, environment);
+    environment.setCurrentFile(inputPath);
+    visitor.log(`current file: ${inputPath}`);
+    visitor.onImportFile = (visitor, filePath, fileData, errorHandler, fileLineOffset = 0) => {
+        visitor.enterFile(filePath);
+        errors.splice(0, errors.length);
+        const result = (0, parser_js_1.parseFileWithVisitor)(visitor, fileData, {
+            enableLexerDiagnostics: lexerDiagnostics,
+            enableLexerVerbose: lexerVerbose,
+            lineOffset: fileLineOffset,
+        });
+        const { throwError, tree, tokens } = result;
+        let { hasError, hasParseError } = result;
+        if (errors.length > 0) {
+            hasError = true;
+            hasParseError = true;
+        }
+        visitor.exitFile();
+        if (hasError || hasParseError) {
+            let importErrorMsg = "";
+            if (throwError) {
+                importErrorMsg = ": " + throwError.message;
+            }
+            throw new utils_js_1.ParseError(`Error parsing imported file: ${filePath}${importErrorMsg}`, undefined, undefined, filePath);
+        }
+        return { hasError, hasParseError, tree, tokens };
+    };
+    const dumpDirectory = environment.getRelativeToModule('/dump/');
+    if (dumpData) {
+        console.log('Dump data to:', dumpDirectory);
+        if (!environment.existsSync(dumpDirectory)) {
+            environment.mkdirSync(dumpDirectory);
+        }
+    }
+    if (inputPath !== '') {
+        visitor.enterFile(inputPath);
+    }
+    await visitor.resolveImportsAndLoad(inputPath, scriptData);
+    const { tree, parser, tokens, lexer, parserTimeTaken, lexerTimeTaken, throwError } = await (0, parser_js_1.parseFileWithVisitor)(visitor, scriptData, {
+        enableLexerDiagnostics: lexerDiagnostics,
+        enableLexerVerbose: lexerVerbose,
+        enableLexerTokenStream: lexerTokens !== false || lexerMapping !== false,
+    });
+    (0, utils_js_1.printWarnings)(visitor.getWarnings());
+    showStats && console.log('Lexing took:', lexerTimeTaken);
+    showStats && console.log('Parsing took:', parserTimeTaken);
+    if (lexerDiagnostics && lexer.diagnosticCollector) {
+        console.log('\n');
+        if (lexerSummary) {
+            lexer.diagnosticCollector.printLexerOperationSummary();
+        }
+        if (lexerTokens !== false) {
+            const limit = typeof lexerTokens === 'number' ? lexerTokens : undefined;
+            lexer.diagnosticCollector.printTokenStream(limit);
+        }
+        if (lexerMapping !== false) {
+            if (typeof lexerMapping === 'string') {
+                const match = lexerMapping.match(/^(\d+)-(\d+)$/);
+                if (match) {
+                    const startLine = parseInt(match[1], 10);
+                    const endLine = parseInt(match[2], 10);
+                    lexer.diagnosticCollector.printCharacterToTokenMapping(startLine, endLine);
+                }
+                else {
+                    console.log('Invalid line range format. Use format like "1-10"');
+                }
+            }
+            else {
+                lexer.diagnosticCollector.printCharacterToTokenMapping();
+            }
+        }
+        lexer.diagnosticCollector.printReport();
+        const recommendations = lexer.diagnosticCollector.getRecommendations();
+        if (recommendations.length > 0) {
+            console.log('Performance Recommendations:');
+            recommendations.forEach((rec, idx) => {
+                console.log(`  ${idx + 1}. ${rec}`);
+            });
+            console.log('');
+        }
+    }
+    try {
+        visitor.annotateComponents();
+    }
+    catch (err) {
+        throw new utils_js_1.RenderError(`Error during component annotation: ${err}`, 'annotation');
+    }
+    const componentLinks = visitor.getComponentCtxLinks();
+    const importedLibraries = Array.from(visitor.getScope().libraries.values());
+    for (let i = 0; i < postAnnotationCallbacks.length; i++) {
+        await postAnnotationCallbacks[i](options, scriptData, tree, tokens, componentLinks, importedLibraries, environment);
+    }
+    visitor.cacheLibraries();
+    if (dumpNets) {
+        const nets = visitor.dumpNets();
+        nets.forEach(item => console.log(item.join(" | ")));
+    }
+    dumpData && environment.writeFileSync(dumpDirectory + 'tree.lisp', tree.toStringTree(null, parser));
+    dumpData && environment.writeFileSync(dumpDirectory + 'raw-parser.txt', visitor.logger.dump());
+    if (throwError) {
+        errors.push(throwError);
+    }
+    let svgOutput = "";
+    if (errors.length === 0 && throwError === undefined) {
+        const { frameComponent } = visitor.applySheetFrameComponent();
+        const { sequence, nets } = visitor.getGraph();
+        if (enableBom && bomOutputPath) {
+            const documentVariable = visitor.getScope().variables.get('document');
+            const bomConfig = documentVariable.bom;
+            const bomData = (0, BomGeneration_js_1.generateBom)(bomConfig, visitor.getScope().getInstances());
+            const bomCsvOutput = (0, BomGeneration_js_1.generateBomCSV)(bomData);
+            await (0, BomGeneration_js_1.saveBomOutputCsv)(environment, bomCsvOutput, bomOutputPath);
+            console.log('Generated BOM file', bomOutputPath);
+        }
+        const tmpSequence = (0, utils_js_1.generateDebugSequenceAction)(sequence).map(item => (0, utils_js_1.sequenceActionString)(item));
+        dumpData && environment.writeFileSync(dumpDirectory + 'raw-sequence.txt', tmpSequence.join('\n'));
+        try {
+            let fileExtension = null;
+            let outputDefaultZoom = globals_js_1.defaultZoomScale;
+            if (outputPath) {
+                fileExtension = path_1.default.extname(outputPath).substring(1);
+            }
+            for (let i = 0; i < parseHandlers.length; i++) {
+                const handler = parseHandlers[i];
+                if (handler.beforeRender) {
+                    const keepParsing = handler.parse(visitor, outputPath, fileExtension);
+                    if (!keepParsing) {
+                        return {
+                            svgOutput: null,
+                            errors
+                        };
+                    }
+                }
+            }
+            const logger = new logger_js_1.Logger();
+            const graphEngine = new graph_js_1.NetGraph(logger);
+            const layoutEngine = new layout_js_1.LayoutEngine(logger);
+            const layoutTimer = new utils_js_1.SimpleStopwatch();
+            let sheetFrames;
+            try {
+                const { graph, containerFrames } = graphEngine.generateLayoutGraph(sequence, nets);
+                sheetFrames = layoutEngine.runLayout(graph, containerFrames, nets);
+                if (enableErc) {
+                    const ercResults = (0, rules_js_1.EvaluateERCRules)(visitor, graph, nets);
+                    if (ercResults.length > 0) {
+                        console.log(`ERC found ${ercResults.length} items:`);
+                        ercResults.forEach((item, index) => {
+                            console.log(`${(index + 1).toString().padStart(3)}. line ${item.start.line}, column ${item.start.column}: ${item.type} - ${item.message}`);
+                        });
+                    }
+                    else {
+                        console.log('No ERC issues found');
+                    }
+                }
+            }
+            catch (err) {
+                throw new utils_js_1.RenderError(`Error during layout generation: ${err}`, 'layout');
+            }
+            layoutEngine.printWarnings();
+            showStats && console.log('Layout took:', layoutTimer.lap());
+            dumpData && environment.writeFileSync(dumpDirectory + 'raw-layout.txt', layoutEngine.logger.dump());
+            const generateSvgTimer = new utils_js_1.SimpleStopwatch();
+            const renderLogger = new logger_js_1.Logger();
+            let svgCanvas;
+            try {
+                svgCanvas = (0, render_js_1.renderSheetsToSVG)(sheetFrames, renderLogger);
+            }
+            catch (err) {
+                throw new utils_js_1.RenderError(`Error during SVG generation: ${err}`, 'svg_generation');
+            }
+            showStats && console.log('Render took:', generateSvgTimer.lap());
+            dumpData && environment.writeFileSync(dumpDirectory + 'raw-render.txt', renderLogger.dump());
+            try {
+                if (fileExtension === "pdf") {
+                    outputDefaultZoom = 1;
+                }
+                svgOutput = (0, render_js_1.generateSvgOutput)(svgCanvas, outputDefaultZoom);
+            }
+            catch (err) {
+                throw new utils_js_1.RenderError(`Error generating SVG output: ${err}`, 'svg_output');
+            }
+            if (outputPath) {
+                if (fileExtension === 'svg') {
+                    try {
+                        environment.writeFileSync(outputPath, svgOutput);
+                    }
+                    catch (err) {
+                        throw new utils_js_1.RenderError(`Error writing SVG file: ${err}`, 'file_output');
+                    }
+                }
+                else if (fileExtension === 'pdf') {
+                    let sheetSize = "A4";
+                    let sheetSizeDefined = false;
+                    if (frameComponent) {
+                        sheetSize = frameComponent.getParam(Frame_js_1.FrameParamKeys.PaperSize);
+                        sheetSizeDefined = true;
+                    }
+                    try {
+                        const doc = new pdfkit_1.default({
+                            layout: 'landscape',
+                            size: sheetSize
+                        });
+                        const outputStream = environment.createWriteStream(outputPath);
+                        (0, render_js_1.generatePdfOutput)(doc, svgCanvas, sheetSize, sheetSizeDefined, outputDefaultZoom);
+                        doc.pipe(outputStream);
+                        doc.end();
+                    }
+                    catch (err) {
+                        throw new utils_js_1.RenderError(`Error generating PDF file: ${err}`, 'pdf_output');
+                    }
+                }
+                else {
+                    throw new utils_js_1.RenderError(`Invalid output format: ${fileExtension}`, 'file_output');
+                }
+                console.log('Generated file', outputPath);
+            }
+        }
+        catch (err) {
+            throw new utils_js_1.RenderError(`Error during rendering: ${err}`, 'output_generation');
+        }
+    }
+    return {
+        svgOutput,
+        errors
+    };
+}
+exports.renderScriptCustom = renderScriptCustom;

package/dist/cjs/regenerate-tests.js

@@ -4,8 +4,8 @@ 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 environment_js_1 = require("./environment.js");
+const pipeline_js_1 = require("./pipeline.js");
+const environment_js_1 = require("./environment/environment.js");
 const mainDir = './__tests__/testData/renderData/';
 const env = new environment_js_1.NodeScriptEnvironment();
 environment_js_1.NodeScriptEnvironment.setInstance(env);
@@ -25,7 +25,8 @@ async function regenerateTests(extra = "") {
         const outputPath = mainDir + 'svgs/' + file + extra + '.svg';
         env.setModuleDirectory(mainDir);
         env.setDefaultLibsPath(mainDir + '../../../libs/');
-        await (0, helpers_js_1.renderScript)(scriptData, outputPath, {
+        await (0, pipeline_js_1.renderScript)(scriptData, outputPath, {
+            inputPath,
             dumpNets: false,
             dumpData: false,
             showStats: false,

package/dist/cjs/render/KiCadNetListOutputHandler.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KiCadNetListOutputHandler = exports.ParseOutputHandler = void 0;
+const export_js_1 = require("./export.js");
+class ParseOutputHandler {
+    constructor() {
+        this.beforeRender = false;
+        this.afterRender = false;
+    }
+}
+exports.ParseOutputHandler = ParseOutputHandler;
+class KiCadNetListOutputHandler extends ParseOutputHandler {
+    constructor() {
+        super(...arguments);
+        this.beforeRender = true;
+    }
+    parse(visitor, outputPath, fileExtension) {
+        if (outputPath !== null && fileExtension === "net") {
+            const { tree: kiCadNetList, missingFootprints } = (0, export_js_1.generateKiCadNetList)(visitor.getNetList());
+            missingFootprints.forEach(entry => {
+                console.log(`${entry.refdes} (${entry.instanceName}) does not have footprint`);
+            });
+            visitor.environment.writeFileSync(outputPath, (0, export_js_1.printTree)(kiCadNetList));
+            console.log('Generated file', outputPath);
+            return false;
+        }
+        return true;
+    }
+}
+exports.KiCadNetListOutputHandler = KiCadNetListOutputHandler;

package/dist/cjs/render/PaperSizes.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPaperSize = exports.isSupportedPaperSize = exports.PaperGridReferences = void 0;
+const globals_js_1 = require("../globals.js");
+const PaperSizes = {
+    'A0': [1189, 841],
+    'A1': [841, 594],
+    'A2': [594, 420],
+    'A3': [420, 297],
+    'A4': [297, 210],
+    'A5': [210, 148],
+    'A6': [148, 105],
+};
+exports.PaperGridReferences = {
+    'A0': [16, 24],
+    'A1': [12, 16],
+    'A2': [8, 12],
+    'A3': [6, 8],
+    'A4': [4, 6],
+};
+function isSupportedPaperSize(type) {
+    if (PaperSizes[type]) {
+        return true;
+    }
+    return false;
+}
+exports.isSupportedPaperSize = isSupportedPaperSize;
+function getPaperSize(type, margin = globals_js_1.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 / globals_js_1.MilsToMM)),
+            height: Math.floor(useHeight * (1 / globals_js_1.MilsToMM)),
+            widthMM: useWidth,
+            heightMM: useHeight,
+            originalWidthMM: width,
+            originalHeightMM: height,
+        };
+    }
+    else {
+        return getPaperSize('A4');
+    }
+}
+exports.getPaperSize = getPaperSize;