circuitscript 0.3.1 → 0.4.0

package/dist/cjs/helpers.js

@@ -3,29 +3,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPaperSize = exports.isSupportedPaperSize = exports.PaperGridReferences = exports.pxToMM = exports.milsToMM = exports.UnitDimension = exports.detectJSModuleType = exports.KiCadNetListOutputHandler = exports.ParseOutputHandler = exports.renderScriptCustom = exports.renderScript = exports.validateScript = exports.ParseErrorStrategy = exports.getSemanticTokens = exports.prepareFile = exports.JSModuleType = void 0;
-const path_1 = __importDefault(require("path"));
-const pdfkit_1 = __importDefault(require("pdfkit"));
-const export_js_1 = require("./export.js");
-const layout_js_1 = require("./layout.js");
-const parser_js_1 = require("./parser.js");
-const render_js_1 = require("./render.js");
+exports.milsToMM = exports.UnitDimension = exports.detectJSModuleType = exports.RefdesOutputType = exports.ParseErrorStrategy = exports.TokenErrorListener = exports.prepareFile = exports.JSModuleType = void 0;
 const utils_js_1 = require("./utils.js");
-const visitor_js_1 = require("./visitor.js");
-const SymbolValidatorVisitor_js_1 = require("./validate/SymbolValidatorVisitor.js");
-const SymbolValidatorResolveVisitor_js_1 = require("./validate/SymbolValidatorResolveVisitor.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 globals_js_1 = require("./globals.js");
-const Frame_js_1 = require("./objects/Frame.js");
 const big_js_1 = __importDefault(require("big.js"));
-const logger_js_1 = require("./logger.js");
-const graph_js_1 = require("./graph.js");
-const RefdesAnnotationVisitor_js_1 = require("./RefdesAnnotationVisitor.js");
-const rules_js_1 = require("./rules-check/rules.js");
-const BomGeneration_js_1 = require("./BomGeneration.js");
 var JSModuleType;
 (function (JSModuleType) {
     JSModuleType["CommonJs"] = "cjs";
@@ -47,59 +31,12 @@ function prepareFile(textData) {
     };
 }
 exports.prepareFile = prepareFile;
-async function getSemanticTokens(scriptData, options) {
-    const { parser, lexer, tokens } = prepareFile(scriptData);
-    const tree = parser.script();
-    const visitor = new SemanticTokenVisitor_js_1.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 utils_js_1.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 = (0, SemanticTokenVisitor_js_1.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
-    };
-}
-exports.getSemanticTokens = getSemanticTokens;
 class TokenErrorListener extends antlr4ng_1.BaseErrorListener {
     syntaxError(recognizer, offendingSymbol, line, column, msg, e) {
         console.log(msg);
     }
 }
+exports.TokenErrorListener = TokenErrorListener;
 class ParseErrorStrategy extends antlr4ng_1.DefaultErrorStrategy {
     reportUnwantedToken(recognizer) {
         if (this.inErrorRecoveryMode(recognizer)) {
@@ -114,367 +51,12 @@ class ParseErrorStrategy extends antlr4ng_1.DefaultErrorStrategy {
     }
 }
 exports.ParseErrorStrategy = ParseErrorStrategy;
-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_js_1.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 utils_js_1.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_js_1.SymbolValidatorResolveVisitor(true, null, options.environment);
-    visitorResolver.enterFile(filePath);
-    visitorResolver.setSymbols(visitor.getSymbols());
-    visitorResolver.onImportFile = visitor.onImportFile;
-    await visitorResolver.visitAsync(tree);
-    return visitorResolver;
-}
-exports.validateScript = validateScript;
-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_js_1.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}${globals_js_1.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;
 (function (RefdesOutputType) {
     RefdesOutputType["None"] = "none";
     RefdesOutputType["WithSource"] = "with-source";
     RefdesOutputType["CreateExternalFile"] = "create-external-file";
-})(RefdesOutputType || (RefdesOutputType = {}));
-async function renderScript(scriptData, outputPath, options) {
-    const parseHandlers = [
-        new KiCadNetListOutputHandler(),
-    ];
-    return renderScriptCustom(scriptData, outputPath, options, parseHandlers, [DefaultPostAnnotationCallback]);
-}
-exports.renderScript = renderScript;
-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 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));
-        }
-    };
-    environment.setCurrentFile(inputPath);
-    const visitor = new visitor_js_1.ParserVisitor(true, onErrorHandler, environment);
-    visitor.onImportFile = async (visitor, filePath, fileData) => {
-        visitor.enterFile(filePath);
-        const { hasError, hasParseError, throwError, tree, tokens } = await (0, parser_js_1.parseFileWithVisitor)(visitor, fileData);
-        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 };
-    };
-    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 (0, parser_js_1.parseFileWithVisitor)(visitor, scriptData);
-    (0, utils_js_1.printWarnings)(visitor.getWarnings());
-    showStats && console.log('Lexing took:', lexerTimeTaken);
-    showStats && console.log('Parsing took:', parserTimeTaken);
-    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);
-    }
-    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 = (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;
-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;
+})(RefdesOutputType || (exports.RefdesOutputType = RefdesOutputType = {}));
 function detectJSModuleType() {
     if (typeof __filename === 'undefined' &&
         typeof __dirname === 'undefined') {
@@ -518,49 +100,3 @@ function milsToMM(value) {
     return (0, utils_js_1.resolveToNumericValue)(value.toBigNumber().mul(new big_js_1.default(globals_js_1.MilsToMM)).round(6));
 }
 exports.milsToMM = milsToMM;
-function pxToMM(value) {
-    return value * globals_js_1.PxToMM;
-}
-exports.pxToMM = pxToMM;
-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;

package/dist/cjs/importResolver.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadImportsIntoMemoryStore = exports.resolveAllImportFilepaths = exports.extractImportNames = void 0;
+const IMPORT_SIMPLE_RE = /^import\s+"([^"]+)"/;
+const IMPORT_FROM_RE = /^from\s+"([^"]*)"\s+import\b/;
+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;
+}
+exports.extractImportNames = extractImportNames;
+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;
+}
+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);
+}
+exports.resolveAllImportFilepaths = resolveAllImportFilepaths;
+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;
+}
+exports.loadImportsIntoMemoryStore = loadImportsIntoMemoryStore;

package/dist/cjs/index.js

@@ -14,17 +14,18 @@ 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("./render/draw_symbols.js"), exports);
 __exportStar(require("./execute.js"), exports);
 __exportStar(require("./export.js"), exports);
-__exportStar(require("./geometry.js"), exports);
+__exportStar(require("./render/geometry.js"), exports);
 __exportStar(require("./globals.js"), exports);
 __exportStar(require("./helpers.js"), exports);
-__exportStar(require("./layout.js"), exports);
+__exportStar(require("./render/layout.js"), exports);
 __exportStar(require("./lexer.js"), exports);
+__exportStar(require("./LexerDiagnosticListener.js"), exports);
 __exportStar(require("./logger.js"), exports);
 __exportStar(require("./parser.js"), exports);
-__exportStar(require("./render.js"), exports);
+__exportStar(require("./render/render.js"), exports);
 __exportStar(require("./utils.js"), exports);
 __exportStar(require("./visitor.js"), exports);
 __exportStar(require("./sizing.js"), exports);
@@ -33,5 +34,5 @@ __exportStar(require("./builtinMethods.js"), exports);
 __exportStar(require("./validate/SymbolTable.js"), exports);
 __exportStar(require("./validate/SymbolValidatorResolveVisitor.js"), exports);
 __exportStar(require("./validate/SymbolValidatorVisitor.js"), exports);
-__exportStar(require("./environment.js"), exports);
-__exportStar(require("./RefdesAnnotationVisitor.js"), exports);
+__exportStar(require("./environment/environment.js"), exports);
+__exportStar(require("./annotate/RefdesAnnotationVisitor.js"), exports);