circuitscript 0.3.1 → 0.4.0

package/dist/esm/helpers.js

@@ -1,25 +1,9 @@
-import path from "path";
-import PDFDocument from "pdfkit";
-import { generateKiCadNetList, printTree } from "./export.js";
-import { LayoutEngine } from "./layout.js";
-import { parseFileWithVisitor } from "./parser.js";
-import { generatePdfOutput, generateSvgOutput, renderSheetsToSVG } from "./render.js";
-import { generateDebugSequenceAction, ParseError, ParseSyntaxError, printWarnings, RenderError, resolveToNumericValue, RuntimeExecutionError, sequenceActionString, SimpleStopwatch } from "./utils.js";
-import { ParserVisitor } from "./visitor.js";
-import { SymbolValidatorVisitor } from "./validate/SymbolValidatorVisitor.js";
-import { SymbolValidatorResolveVisitor } from "./validate/SymbolValidatorResolveVisitor.js";
-import { BaseErrorListener, CharStream, CommonTokenStream, DefaultErrorStrategy, RecognitionException } from "antlr4ng";
+import { resolveToNumericValue, SimpleStopwatch } from "./utils.js";
+import { BaseErrorListener, CharStream, CommonTokenStream, DefaultErrorStrategy } from "antlr4ng";
 import { MainLexer } from "./lexer.js";
 import { CircuitScriptParser } from "./antlr/CircuitScriptParser.js";
-import { prepareTokens, SemanticTokensVisitor } from "./SemanticTokenVisitor.js";
-import { defaultPageMarginMM, defaultZoomScale, LengthUnit, MilsToMM, PxToMM, RefdesFileSuffix } from "./globals.js";
-import { FrameParamKeys } from "./objects/Frame.js";
+import { LengthUnit, MilsToMM, PxToMM } from "./globals.js";
 import Big from "big.js";
-import { Logger } from "./logger.js";
-import { NetGraph } from "./graph.js";
-import { RefdesAnnotationVisitor } from "./RefdesAnnotationVisitor.js";
-import { EvaluateERCRules } from "./rules-check/rules.js";
-import { generateBom, generateBomCSV, saveBomOutputCsv } from "./BomGeneration.js";
 export var JSModuleType;
 (function (JSModuleType) {
     JSModuleType["CommonJs"] = "cjs";
@@ -40,54 +24,7 @@ export function prepareFile(textData) {
         tokens
     };
 }
-export async function getSemanticTokens(scriptData, options) {
-    const { parser, lexer, tokens } = prepareFile(scriptData);
-    const tree = parser.script();
-    const visitor = new SemanticTokensVisitor(true, null, options.environment, lexer, scriptData);
-    parser.removeErrorListeners();
-    visitor.onImportFile = async (visitor, filePath, 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;
-                throw new ParseError(`Error parsing semantic tokens in imported file: ${err}`);
-            }
-        }
-        else {
-            console.log('File does not exist');
-            hasError = true;
-        }
-        return {
-            hasError, hasParseError
-        };
-    };
-    await visitor.visitAsync(tree);
-    const semanticTokens = visitor.getTokens();
-    const parsedTokens = prepareTokens(tokens.getTokens(), lexer, scriptData);
-    const finalParsedTokens = [];
-    parsedTokens.forEach(token => {
-        const location = `${token.line}_${token.column}_${token.length}`;
-        if (semanticTokens.has(location)) {
-            finalParsedTokens.push(semanticTokens.get(location));
-        }
-        else {
-            finalParsedTokens.push(token);
-        }
-    });
-    return {
-        visitor,
-        parsedTokens: finalParsedTokens
-    };
-}
-class TokenErrorListener extends BaseErrorListener {
+export class TokenErrorListener extends BaseErrorListener {
     syntaxError(recognizer, offendingSymbol, line, column, msg, e) {
         console.log(msg);
     }
@@ -105,357 +42,12 @@ export class ParseErrorStrategy extends DefaultErrorStrategy {
         this.endErrorCondition(recognizer);
     }
 }
-export async function validateScript(filePath, scriptData, options) {
-    const { parser } = prepareFile(scriptData);
-    parser.removeErrorListeners();
-    parser.errorHandler = new ParseErrorStrategy();
-    parser.addErrorListener(new TokenErrorListener());
-    const tree = parser.script();
-    const visitor = new SymbolValidatorVisitor(true, null, options.environment);
-    visitor.enterFile(filePath);
-    visitor.onImportFile = async (visitor, filePath, textData) => {
-        visitor.enterFile(filePath);
-        let hasError = false;
-        let hasParseError = false;
-        if (textData !== null) {
-            const { parser } = prepareFile(textData);
-            const tree = parser.script();
-            try {
-                await visitor.visitAsync(tree);
-                visitor.exitFile();
-            }
-            catch (err) {
-                console.log('got an error while parsing tree: ', err);
-                hasParseError = true;
-                hasError = true;
-                throw new ParseError(`Error parsing validation in imported file: ${err}`);
-            }
-        }
-        else {
-            console.log('file does not exist!');
-            hasError = true;
-        }
-        return {
-            hasError, hasParseError
-        };
-    };
-    await visitor.visitAsync(tree);
-    const symbolTable = visitor.getSymbols();
-    symbolTable.clearUndefined();
-    const visitorResolver = new SymbolValidatorResolveVisitor(true, null, options.environment);
-    visitorResolver.enterFile(filePath);
-    visitorResolver.setSymbols(visitor.getSymbols());
-    visitorResolver.onImportFile = visitor.onImportFile;
-    await visitorResolver.visitAsync(tree);
-    return visitorResolver;
-}
-async function DefaultPostAnnotationCallback(options, scriptData, tree, tokens, componentLinks, importedLibraries, environment) {
-    const { inputPath = null, updateSource = false, saveAnnotatedCopy = undefined, } = options;
-    if (inputPath && (updateSource || saveAnnotatedCopy !== undefined)) {
-        const annotatedFiles = [{
-                isMainFile: true,
-                scriptData,
-                tokens,
-                tree,
-                filePath: inputPath,
-                outputType: RefdesOutputType.WithSource
-            }];
-        for (const library of importedLibraries) {
-            let outputType = RefdesOutputType.None;
-            if (library.enableRefdesAnnotation) {
-                outputType = RefdesOutputType.WithSource;
-            }
-            else if (library.enableRefdesAnnotationFile) {
-                outputType = RefdesOutputType.CreateExternalFile;
-            }
-            if (outputType !== RefdesOutputType.None) {
-                const { libraryFilePath, libraryName, tokens: libTokens, tree: libTree } = library;
-                const libraryScriptData = await environment.readFile(libraryFilePath, { encoding: 'utf8' });
-                annotatedFiles.push({
-                    tokens: libTokens,
-                    tree: libTree,
-                    filePath: libraryFilePath,
-                    scriptData: libraryScriptData,
-                    libraryName,
-                    outputType
-                });
-            }
-        }
-        for (const item of annotatedFiles) {
-            const { scriptData, tokens, tree, filePath, libraryName, isMainFile = false } = item;
-            const tmpVisitor = new RefdesAnnotationVisitor(true, scriptData, tokens, componentLinks);
-            await tmpVisitor.visit(tree);
-            let usePath = filePath;
-            if (isMainFile && saveAnnotatedCopy === true) {
-                const dir = environment.dirname(filePath);
-                const ext = environment.extname(filePath);
-                const basename = environment.basename(filePath, ext);
-                usePath = environment.join(dir, `${basename}.annotated${ext}`);
-            }
-            else if (isMainFile && typeof saveAnnotatedCopy === 'string') {
-                usePath = saveAnnotatedCopy;
-            }
-            if (item.outputType === RefdesOutputType.WithSource) {
-                environment.writeFileSync(usePath, tmpVisitor.getOutput());
-            }
-            else if (item.outputType === RefdesOutputType.CreateExternalFile) {
-                const dir = environment.dirname(usePath);
-                const ext = environment.extname(usePath);
-                const basename = environment.basename(filePath, ext);
-                usePath = environment.join(dir, `${basename}${RefdesFileSuffix}`);
-                const output = tmpVisitor.getOutputForExternalRefdesFile();
-                const inputDir = environment.dirname(inputPath);
-                const relativeFilePath = environment.relative(inputDir, filePath);
-                const jsonFile = {
-                    format: 'v1',
-                    library: libraryName,
-                    file: relativeFilePath,
-                    items: output,
-                };
-                environment.writeFileSync(usePath, JSON.stringify(jsonFile, null, 4));
-            }
-            let display = 'Refdes annotations';
-            if (libraryName) {
-                display += ` for library ${libraryName}`;
-            }
-            console.log(`${display} saved to ${usePath}`);
-        }
-    }
-}
-var RefdesOutputType;
+export var RefdesOutputType;
 (function (RefdesOutputType) {
     RefdesOutputType["None"] = "none";
     RefdesOutputType["WithSource"] = "with-source";
     RefdesOutputType["CreateExternalFile"] = "create-external-file";
 })(RefdesOutputType || (RefdesOutputType = {}));
-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, 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));
-        }
-    };
-    environment.setCurrentFile(inputPath);
-    const visitor = new ParserVisitor(true, onErrorHandler, environment);
-    visitor.onImportFile = async (visitor, filePath, fileData) => {
-        visitor.enterFile(filePath);
-        const { hasError, hasParseError, throwError, tree, tokens } = await parseFileWithVisitor(visitor, fileData);
-        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 };
-    };
-    visitor.log('reading file');
-    visitor.log('done reading file');
-    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);
-    }
-    const { tree, parser, tokens, parserTimeTaken, lexerTimeTaken, throwError } = await parseFileWithVisitor(visitor, scriptData);
-    printWarnings(visitor.getWarnings());
-    showStats && console.log('Lexing took:', lexerTimeTaken);
-    showStats && console.log('Parsing took:', parserTimeTaken);
-    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);
-    }
-    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) {
-        throw throwError;
-    }
-    let svgOutput = "";
-    if (errors.length === 0) {
-        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
-    };
-}
-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;
-    }
-}
 export function detectJSModuleType() {
     if (typeof __filename === 'undefined' &&
         typeof __dirname === 'undefined') {
@@ -498,46 +90,3 @@ export function milsToMM(value) {
     }
     return resolveToNumericValue(value.toBigNumber().mul(new Big(MilsToMM)).round(6));
 }
-export function pxToMM(value) {
-    return value * PxToMM;
-}
-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');
-    }
-}

package/dist/esm/importResolver.js

@@ -0,0 +1,96 @@
+const IMPORT_SIMPLE_RE = /^import\s+"([^"]+)"/;
+const IMPORT_FROM_RE = /^from\s+"([^"]*)"\s+import\b/;
+export function extractImportNames(fileData) {
+    const names = [];
+    for (const rawLine of fileData.split('\n')) {
+        const line = rawLine.trim();
+        if (line === '' || line.startsWith('//') || line.startsWith('#'))
+            continue;
+        const simple = IMPORT_SIMPLE_RE.exec(line);
+        if (simple) {
+            names.push(simple[1]);
+            continue;
+        }
+        const from = IMPORT_FROM_RE.exec(line);
+        if (from) {
+            names.push(from[1]);
+            continue;
+        }
+        break;
+    }
+    return names;
+}
+async function resolveImportPath(name, environment) {
+    let useName = name;
+    if (!name.endsWith('.cst')) {
+        useName = name + '.cst';
+    }
+    const absPath = environment.getAbsPathRelativeToCurrentFolder(useName);
+    const executionDirectory = environment.getCurrentDirectory();
+    const relPath = environment.relative(executionDirectory, absPath);
+    if (await environment.exists(relPath)) {
+        return relPath;
+    }
+    const libPath = environment.getRelativeToDefaultLibs(useName);
+    if (await environment.exists(libPath)) {
+        return libPath;
+    }
+    return null;
+}
+export async function resolveAllImportFilepaths(rootFilePath, scriptData, environment) {
+    const visited = new Set();
+    const result = [];
+    async function walk(filePath, passedInScriptData) {
+        if (filePath !== undefined && filePath !== null && filePath !== '') {
+            if (visited.has(filePath))
+                return;
+            visited.add(filePath);
+        }
+        let fileData;
+        if (passedInScriptData === undefined || passedInScriptData === null) {
+            try {
+                fileData = await environment.readFile(filePath, { encoding: 'utf8' });
+            }
+            catch {
+                return;
+            }
+        }
+        else {
+            fileData = passedInScriptData;
+        }
+        if (fileData) {
+            const importNames = extractImportNames(fileData);
+            const savedFile = environment.getCurrentFile();
+            if (filePath) {
+                environment.setCurrentFile(filePath);
+            }
+            for (const name of importNames) {
+                const resolvedPath = await resolveImportPath(name, environment);
+                if (resolvedPath) {
+                    result.push(resolvedPath);
+                    await walk(resolvedPath);
+                }
+            }
+            if (filePath) {
+                environment.setCurrentFile(savedFile);
+            }
+        }
+    }
+    await walk(rootFilePath, scriptData);
+    const uniqueResults = new Set(result);
+    return Array.from(uniqueResults);
+}
+export async function loadImportsIntoMemoryStore(filepaths, environment) {
+    const store = new Map();
+    for (const filePath of filepaths) {
+        if (store.has(filePath))
+            continue;
+        try {
+            const content = await environment.readFile(filePath, { encoding: 'utf8' });
+            store.set(filePath, content);
+        }
+        catch {
+        }
+    }
+    return store;
+}

package/dist/esm/index.js

@@ -1,14 +1,15 @@
-export * from './draw_symbols.js';
+export * from './render/draw_symbols.js';
 export * from './execute.js';
 export * from './export.js';
-export * from './geometry.js';
+export * from './render/geometry.js';
 export * from './globals.js';
 export * from './helpers.js';
-export * from './layout.js';
+export * from './render/layout.js';
 export * from './lexer.js';
+export * from './LexerDiagnosticListener.js';
 export * from './logger.js';
 export * from './parser.js';
-export * from './render.js';
+export * from './render/render.js';
 export * from './utils.js';
 export * from './visitor.js';
 export * from './sizing.js';
@@ -17,5 +18,5 @@ export * from './builtinMethods.js';
 export * from './validate/SymbolTable.js';
 export * from './validate/SymbolValidatorResolveVisitor.js';
 export * from './validate/SymbolValidatorVisitor.js';
-export * from './environment.js';
-export * from './RefdesAnnotationVisitor.js';
+export * from './environment/environment.js';
+export * from './annotate/RefdesAnnotationVisitor.js';