circuitscript 0.3.1 → 0.4.0

package/dist/esm/lexer.js

@@ -1,31 +1,46 @@
 import { CommonToken } from "antlr4ng";
 import { CircuitScriptParser } from "./antlr/CircuitScriptParser.js";
 import { CircuitScriptLexer } from "./antlr/CircuitScriptLexer.js";
+import { LexerDiagnosticCollector } from "./LexerDiagnosticListener.js";
 export class MainLexer extends CircuitScriptLexer {
     tokens;
+    tokensHead;
     indents;
     opened;
-    constructor(input) {
+    diagnosticCollector;
+    lineOffset;
+    constructor(input, enableDiagnostics = false) {
         super(input);
         this.tokens = [];
+        this.tokensHead = 0;
         this.indents = [];
         this.opened = 0;
+        this.lineOffset = 0;
+        this.diagnosticCollector = new 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.EOF && this.indents.length) {
-            this.tokens = this.tokens.filter(function (val) {
-                return val.type !== CircuitScriptParser.EOF;
-            });
+            let writeIdx = this.tokensHead;
+            for (let i = this.tokensHead; i < this.tokens.length; i++) {
+                if (this.tokens[i].type !== CircuitScriptParser.EOF) {
+                    this.tokens[writeIdx++] = this.tokens[i];
+                }
+            }
+            this.tokens.length = writeIdx;
             const fillerNewLine = this.commonToken(CircuitScriptParser.NEWLINE, "");
             this.emitToken(fillerNewLine);
             fillerNewLine.__skip = true;
@@ -36,7 +51,19 @@ export class MainLexer extends CircuitScriptLexer {
             this.emitToken(this.commonToken(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.DEDENT, "");
@@ -80,9 +107,6 @@ export class MainLexer extends CircuitScriptLexer {
         }
         return count;
     }
-    atStartOfInput() {
-        return this.getCharIndex() === 0;
-    }
     openBrace() {
         this.opened++;
     }
@@ -90,8 +114,19 @@ export class MainLexer extends 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 +134,9 @@ export class MainLexer extends 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.NEWLINE, newLine, start, start));
             const indent = this.getIndentationCount(spaces);
             const previous = this.indents.length ? this.indents[this.indents.length - 1] : 0;
@@ -119,4 +155,7 @@ export class MainLexer extends CircuitScriptLexer {
             }
         }
     }
+    setLineOffset(offset) {
+        this.lineOffset = offset;
+    }
 }

package/dist/esm/main.js

@@ -2,8 +2,8 @@
 import { program } from 'commander';
 import figlet from 'figlet';
 import { watch } from 'fs';
-import { renderScript } from './helpers.js';
-import { NodeScriptEnvironment } from "./environment.js";
+import { renderScript } from "./pipeline.js";
+import { NodeScriptEnvironment } from "./environment/environment.js";
 export default async function main() {
     const env = new NodeScriptEnvironment();
     NodeScriptEnvironment.setInstance(env);
@@ -22,7 +22,12 @@ export default 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)');
     program.addHelpText('before', figlet.textSync('circuitscript', {
         font: 'Small Slant'
     }));
@@ -87,6 +92,11 @@ export default 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,

package/dist/esm/objects/ClassComponent.js

@@ -1,4 +1,4 @@
-import { SymbolDrawingCommands } from '../draw_symbols.js';
+import { SymbolDrawingCommands } from '../render/draw_symbols.js';
 import { PinDefinition, PinId, PinIdType } from './PinDefinition.js';
 import { PinTypes } from './PinTypes.js';
 import { DefaultComponentUnit, ParamKeys } from '../globals.js';

package/dist/esm/objects/ExecutionScope.js

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

package/dist/esm/objects/types.js

@@ -7,6 +7,10 @@ export class CFunctionEntry {
     execute;
     uniqueId;
     source;
+    lazyLoaded = false;
+    lazyLoader = null;
+    tokens;
+    tree;
     constructor(namespace, name, execute, source, uniqueId) {
         this.name = name;
         this.namespace = namespace;
@@ -18,6 +22,9 @@ export class CFunctionEntry {
     toString() {
         return `[Function: ${this.name}]`;
     }
+    getFunctionPath() {
+        return `${this.namespace}${this.name}`;
+    }
 }
 ;
 export class AnyReference {
@@ -128,7 +135,13 @@ export class ImportedLibrary {
     enableRefdesAnnotationFile = false;
     tree;
     tokens;
-    constructor(libraryName, libraryNamespace, libraryFilePath, tree, tokens, context, flag, specifiedImports) {
+    referencedTokens = [];
+    fileHash;
+    writeToCache = false;
+    refdesAnnotations = new Map;
+    parseError = false;
+    importStatement;
+    constructor(libraryName, libraryNamespace, libraryFilePath, tree, tokens, context, flag, specifiedImports, fileHash, importStatement) {
         this.libraryName = libraryName;
         this.libraryNamespace = libraryNamespace;
         this.libraryFilePath = libraryFilePath;
@@ -137,6 +150,13 @@ export 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);
+        }
     }
 }
 export var ImportFunctionHandling;

package/dist/esm/parser.js

@@ -1,28 +1,41 @@
 import { CircuitScriptParser } from './antlr/CircuitScriptParser.js';
 import { MainLexer } from './lexer.js';
 import { ParseSyntaxError, RuntimeExecutionError, SimpleStopwatch } from './utils.js';
-import { CharStream, CommonTokenStream } from 'antlr4ng';
-export async function parseFileWithVisitor(visitor, data) {
+import { CharStream, CommonTokenStream, PredictionMode } from 'antlr4ng';
+export function parseFileWithVisitor(visitor, data, options) {
     const lexerErrorListener = new CircuitscriptParserErrorListener(visitor.onErrorHandler);
     const parserErrorListener = new CircuitscriptParserErrorListener(visitor.onErrorHandler);
     const chars = CharStream.fromString(data);
-    const lexer = new 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 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 SimpleStopwatch();
     const tokens = new CommonTokenStream(lexer);
     tokens.fill();
     const lexerTimeTaken = lexerTimer.lap();
-    const parserTimer = new SimpleStopwatch();
     const parser = new CircuitScriptParser(tokens);
+    parser.interpreter.predictionMode = PredictionMode.SLL;
     parser.removeErrorListeners();
     parser.addErrorListener(parserErrorListener);
+    const parserTimer = new 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) {
@@ -40,6 +53,7 @@ export async function parseFileWithVisitor(visitor, data) {
     return {
         tree, parser,
         tokens,
+        lexer,
         hasParseError,
         hasError,
         parserTimeTaken,

package/dist/esm/pipeline.js

@@ -0,0 +1,276 @@
+import path from "path";
+import PDFDocument from "pdfkit";
+import { RecognitionException } from "antlr4ng";
+import { DefaultPostAnnotationCallback } from "./annotate/DefaultPostAnnotationCallback.js";
+import { generateBom, generateBomCSV, saveBomOutputCsv } from "./BomGeneration.js";
+import { defaultZoomScale } from "./globals.js";
+import { NetGraph } from "./render/graph.js";
+import { LayoutEngine } from "./render/layout.js";
+import { Logger } from "./logger.js";
+import { FrameParamKeys } from "./objects/Frame.js";
+import { parseFileWithVisitor } from "./parser.js";
+import { KiCadNetListOutputHandler } from "./render/KiCadNetListOutputHandler.js";
+import { renderSheetsToSVG, generateSvgOutput, generatePdfOutput } from "./render/render.js";
+import { EvaluateERCRules } from "./rules-check/rules.js";
+import { RuntimeExecutionError, ParseSyntaxError, ParseError, printWarnings, RenderError, generateDebugSequenceAction, sequenceActionString, SimpleStopwatch } from "./utils.js";
+import { ParserVisitor } from "./visitor.js";
+export async function renderScript(scriptData, outputPath, options) {
+    const parseHandlers = [
+        new KiCadNetListOutputHandler(),
+    ];
+    return renderScriptCustom(scriptData, outputPath, options, parseHandlers, [DefaultPostAnnotationCallback]);
+}
+export 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 RuntimeExecutionError) {
+            errors.push(error);
+        }
+        else if (error && error instanceof RecognitionException) {
+            if (context !== null) {
+                errors.push(new ParseSyntaxError(message, context.start, context.stop));
+            }
+            else {
+                if (error.recognizer) {
+                    const recognizer = error.recognizer;
+                    errors.push(new ParseSyntaxError(message, {
+                        line: recognizer.currentTokenStartLine,
+                        column: recognizer.currentTokenColumn
+                    }));
+                }
+                else {
+                    errors.push(new ParseSyntaxError(message));
+                }
+            }
+        }
+        else {
+            errors.push(new ParseError(message, context.start, context.stop));
+        }
+    };
+    const visitor = new 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 = 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 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 parseFileWithVisitor(visitor, scriptData, {
+        enableLexerDiagnostics: lexerDiagnostics,
+        enableLexerVerbose: lexerVerbose,
+        enableLexerTokenStream: lexerTokens !== false || lexerMapping !== false,
+    });
+    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 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 = generateBom(bomConfig, visitor.getScope().getInstances());
+            const bomCsvOutput = generateBomCSV(bomData);
+            await saveBomOutputCsv(environment, bomCsvOutput, bomOutputPath);
+            console.log('Generated BOM file', bomOutputPath);
+        }
+        const tmpSequence = generateDebugSequenceAction(sequence).map(item => sequenceActionString(item));
+        dumpData && environment.writeFileSync(dumpDirectory + 'raw-sequence.txt', tmpSequence.join('\n'));
+        try {
+            let fileExtension = null;
+            let outputDefaultZoom = defaultZoomScale;
+            if (outputPath) {
+                fileExtension = path.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();
+            const graphEngine = new NetGraph(logger);
+            const layoutEngine = new LayoutEngine(logger);
+            const layoutTimer = new SimpleStopwatch();
+            let sheetFrames;
+            try {
+                const { graph, containerFrames } = graphEngine.generateLayoutGraph(sequence, nets);
+                sheetFrames = layoutEngine.runLayout(graph, containerFrames, nets);
+                if (enableErc) {
+                    const ercResults = 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 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 SimpleStopwatch();
+            const renderLogger = new Logger();
+            let svgCanvas;
+            try {
+                svgCanvas = renderSheetsToSVG(sheetFrames, renderLogger);
+            }
+            catch (err) {
+                throw new 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 = generateSvgOutput(svgCanvas, outputDefaultZoom);
+            }
+            catch (err) {
+                throw new RenderError(`Error generating SVG output: ${err}`, 'svg_output');
+            }
+            if (outputPath) {
+                if (fileExtension === 'svg') {
+                    try {
+                        environment.writeFileSync(outputPath, svgOutput);
+                    }
+                    catch (err) {
+                        throw new RenderError(`Error writing SVG file: ${err}`, 'file_output');
+                    }
+                }
+                else if (fileExtension === 'pdf') {
+                    let sheetSize = "A4";
+                    let sheetSizeDefined = false;
+                    if (frameComponent) {
+                        sheetSize = frameComponent.getParam(FrameParamKeys.PaperSize);
+                        sheetSizeDefined = true;
+                    }
+                    try {
+                        const doc = new PDFDocument({
+                            layout: 'landscape',
+                            size: sheetSize
+                        });
+                        const outputStream = environment.createWriteStream(outputPath);
+                        generatePdfOutput(doc, svgCanvas, sheetSize, sheetSizeDefined, outputDefaultZoom);
+                        doc.pipe(outputStream);
+                        doc.end();
+                    }
+                    catch (err) {
+                        throw new RenderError(`Error generating PDF file: ${err}`, 'pdf_output');
+                    }
+                }
+                else {
+                    throw new RenderError(`Invalid output format: ${fileExtension}`, 'file_output');
+                }
+                console.log('Generated file', outputPath);
+            }
+        }
+        catch (err) {
+            throw new RenderError(`Error during rendering: ${err}`, 'output_generation');
+        }
+    }
+    return {
+        svgOutput,
+        errors
+    };
+}

package/dist/esm/regenerate-tests.js

@@ -1,6 +1,6 @@
 import fs from 'fs';
-import { renderScript } from './helpers.js';
-import { NodeScriptEnvironment } from "./environment.js";
+import { renderScript } from "./pipeline.js";
+import { NodeScriptEnvironment } from "./environment/environment.js";
 const mainDir = './__tests__/testData/renderData/';
 const env = new NodeScriptEnvironment();
 NodeScriptEnvironment.setInstance(env);
@@ -21,6 +21,7 @@ async function regenerateTests(extra = "") {
         env.setModuleDirectory(mainDir);
         env.setDefaultLibsPath(mainDir + '../../../libs/');
         await renderScript(scriptData, outputPath, {
+            inputPath,
             dumpNets: false,
             dumpData: false,
             showStats: false,

package/dist/esm/render/KiCadNetListOutputHandler.js

@@ -0,0 +1,20 @@
+import { generateKiCadNetList, printTree } from "./export.js";
+export class ParseOutputHandler {
+    beforeRender = false;
+    afterRender = false;
+}
+export class KiCadNetListOutputHandler extends ParseOutputHandler {
+    beforeRender = true;
+    parse(visitor, outputPath, fileExtension) {
+        if (outputPath !== null && fileExtension === "net") {
+            const { tree: kiCadNetList, missingFootprints } = generateKiCadNetList(visitor.getNetList());
+            missingFootprints.forEach(entry => {
+                console.log(`${entry.refdes} (${entry.instanceName}) does not have footprint`);
+            });
+            visitor.environment.writeFileSync(outputPath, printTree(kiCadNetList));
+            console.log('Generated file', outputPath);
+            return false;
+        }
+        return true;
+    }
+}

package/dist/esm/render/PaperSizes.js

@@ -0,0 +1,41 @@
+import { defaultPageMarginMM, MilsToMM } from "../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],
+};
+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');
+    }
+}