circuitscript 0.1.33 → 0.3.0

package/dist/cjs/BaseVisitor.js

@@ -528,17 +528,17 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.CircuitScriptVisitor {
             });
             specificImports.push(...tmpSpecificImports);
         }
-        const id = ctx._moduleName.text;
+        const id = ctx._libraryName.text;
         const importedFile = await this.handleImportFile(id, handling, true, ctx, specificImports);
         const ctxImportAnnotation = ctx.import_annotation_expr();
         if (ctxImportAnnotation) {
             const textValue = ctxImportAnnotation.getText().replace('#=', '');
-            const { importedModule } = importedFile;
+            const { importedLibrary } = importedFile;
             if (textValue === 'annotate') {
-                importedModule.enableRefdesAnnotation = true;
+                importedLibrary.enableRefdesAnnotation = true;
             }
             else if (textValue === 'annotate-external') {
-                importedModule.enableRefdesAnnotationFile = true;
+                importedLibrary.enableRefdesAnnotationFile = true;
             }
         }
     }
@@ -585,23 +585,23 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.CircuitScriptVisitor {
                     }
                     const useNetNamespace = this.getNetNamespace(executor.netNamespace, passedNetNamespace);
                     try {
-                        const isModuleFunction = currentReference.rootValue
-                            && currentReference.rootValue instanceof types_js_1.ImportedModule;
-                        if (isModuleFunction) {
-                            this.log('create new module context');
-                            const importedModule = currentReference.rootValue;
-                            const importedModuleContext = importedModule.context;
-                            this.enterFile(importedModule.moduleFilePath);
-                            const newExecutor = this.handleEnterContext(this.getExecutor(), this.executionStack, importedModuleContext.name, ctx, {
+                        const isLibraryFunction = currentReference.rootValue
+                            && currentReference.rootValue instanceof types_js_1.ImportedLibrary;
+                        if (isLibraryFunction) {
+                            this.log('create new library context');
+                            const importedLibrary = currentReference.rootValue;
+                            const { context: importedLibraryContext } = importedLibrary;
+                            this.enterFile(importedLibrary.libraryFilePath);
+                            const newExecutor = this.handleEnterContext(this.getExecutor(), this.executionStack, importedLibraryContext.name, ctx, {
                                 netNamespace: executor.netNamespace,
-                                namespace: importedModule.moduleNamespace
+                                namespace: importedLibrary.libraryNamespace
                             }, [], [], false);
-                            this.log('copy module context scope');
-                            importedModuleContext.scope.copyTo(newExecutor.scope);
+                            this.log('copy library context scope');
+                            importedLibraryContext.scope.copyTo(newExecutor.scope);
                         }
                         const [, functionResult] = executor.callFunction(currentReference, parameters, this.executionStack, useNetNamespace);
-                        if (isModuleFunction) {
-                            this.log('pop module context scope');
+                        if (isLibraryFunction) {
+                            this.log('pop library context scope');
                             this.handlePopContext(this.getExecutor(), this.executionStack, "", false);
                             this.exitFile();
                         }
@@ -717,8 +717,8 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.CircuitScriptVisitor {
             return item.id === name;
         });
         if (importAlready) {
-            const tmpImportedModule = importAlready.importedModule;
-            const alreadyImportedFlag = tmpImportedModule.importHandlingFlag;
+            const { importedLibrary: tmpImportedLibrary } = importAlready;
+            const alreadyImportedFlag = tmpImportedLibrary.importHandlingFlag;
             const isMergedNamespace = alreadyImportedFlag === types_js_1.ImportFunctionHandling.AllMergeIntoNamespace
                 || alreadyImportedFlag === types_js_1.ImportFunctionHandling.SpecificMergeIntoNamespace;
             const invalidImportCondition1 = alreadyImportedFlag === types_js_1.ImportFunctionHandling.AllWithNamespace &&
@@ -732,11 +732,11 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.CircuitScriptVisitor {
                 if (alreadyImportedFlag === types_js_1.ImportFunctionHandling.AllMergeIntoNamespace) {
                 }
                 else if (alreadyImportedFlag === types_js_1.ImportFunctionHandling.SpecificMergeIntoNamespace && importHandling === types_js_1.ImportFunctionHandling.AllMergeIntoNamespace) {
-                    tmpImportedModule.specifiedImports = [];
-                    tmpImportedModule.importHandlingFlag = types_js_1.ImportFunctionHandling.AllMergeIntoNamespace;
+                    tmpImportedLibrary.specifiedImports = [];
+                    tmpImportedLibrary.importHandlingFlag = types_js_1.ImportFunctionHandling.AllMergeIntoNamespace;
                 }
                 else if (alreadyImportedFlag === types_js_1.ImportFunctionHandling.SpecificMergeIntoNamespace && importHandling === types_js_1.ImportFunctionHandling.SpecificMergeIntoNamespace) {
-                    tmpImportedModule.specifiedImports.push(...specificImports);
+                    tmpImportedLibrary.specifiedImports.push(...specificImports);
                 }
             }
             return importAlready;
@@ -757,7 +757,7 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.CircuitScriptVisitor {
             this.log('failed to read file');
             pathExists = false;
         }
-        let importedModule;
+        let importedLibrary;
         if (!pathExists) {
             try {
                 const tmpFilePath2 = this.environment.getRelativeToDefaultLibs(name + ".cst");
@@ -778,26 +778,26 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.CircuitScriptVisitor {
                 const executor = this.getExecutor();
                 const executionContextName = name;
                 const netNamespace = executor.netNamespace;
-                const moduleNamespace = `${globals_js_1.BaseNamespace}${name}.`;
+                const libraryNamespace = `${globals_js_1.BaseNamespace}${name}.`;
                 this.enterNewChildContext(executionStack, executor, executionContextName, {
                     netNamespace,
-                    namespace: moduleNamespace,
+                    namespace: libraryNamespace,
                 }, [], []);
                 const importResult = await this.onImportFile(this, filePathUsed, fileData, this.onErrorHandler);
                 hasError = importResult.hasError;
                 hasParseError = importResult.hasParseError;
                 const importContext = executionStack.pop();
                 this.log(`import handling flag: ${importHandling}`);
-                importedModule = new types_js_1.ImportedModule(name, moduleNamespace, filePathUsed, importResult.tree, importResult.tokens, importContext, importHandling, specificImports);
+                importedLibrary = new types_js_1.ImportedLibrary(name, libraryNamespace, filePathUsed, importResult.tree, importResult.tokens, importContext, importHandling, specificImports);
                 if (specificImports.length > 0) {
                     this.log('specific import: ' + specificImports.join(', '));
                 }
                 const scope = this.getScope();
-                scope.modules.set(name, importedModule);
-                importedModule.context.scope.modules.forEach((module, key) => {
-                    scope.modules.set(key, module);
+                scope.libraries.set(name, importedLibrary);
+                importedLibrary.context.scope.libraries.forEach((lib, key) => {
+                    scope.libraries.set(key, lib);
                 });
-                await this.checkModuleHasRefdesFile(filePathUsed);
+                await this.checkLibraryHasRefdesFile(filePathUsed);
             }
         }
         catch (err) {
@@ -825,12 +825,12 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.CircuitScriptVisitor {
             hasError,
             hasParseError,
             pathExists,
-            importedModule: importedModule
+            importedLibrary: importedLibrary
         };
         this.importedFiles.push(newImportedFile);
         return newImportedFile;
     }
-    async checkModuleHasRefdesFile(filePath) {
+    async checkLibraryHasRefdesFile(filePath) {
         return;
     }
     getRefdesFileAnnotation(filePath, startLine, startColumn, stopLine, stopColumn) {

package/dist/cjs/BomGeneration.js

@@ -25,7 +25,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.saveBomOutputCsv = exports.generateBomCSV = exports.groupComponents = exports.generateBom = void 0;
 const csv = __importStar(require("@fast-csv/format"));
-const fs = __importStar(require("fs"));
 const ParamDefinition_js_1 = require("./objects/ParamDefinition.js");
 const TypeSortOrder = {
     "res": 1,
@@ -151,9 +150,9 @@ function generateBomCSV(bomData) {
     return rows;
 }
 exports.generateBomCSV = generateBomCSV;
-async function saveBomOutputCsv(bomCsvOutput, filePath) {
+async function saveBomOutputCsv(environment, bomCsvOutput, filePath) {
     return new Promise(resolve => {
-        const outputStream = fs.createWriteStream(filePath);
+        const outputStream = environment.createWriteStream(filePath);
         const csvStream = csv.format();
         csvStream.pipe(outputStream).on("finish", () => {
             resolve();

package/dist/cjs/ComponentMatchConditions.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.applyPartConditions = exports.partMatchesConditions = exports.extractPartConditions = exports.flattenConditionNodes = void 0;
+const globals_js_1 = require("./globals.js");
 const ParamDefinition_js_1 = require("./objects/ParamDefinition.js");
-const types_js_1 = require("./objects/types.js");
 function flattenConditionNodes(conditionNodes, level = 0) {
     const conditionBranches = [];
     conditionNodes.forEach(node => {
@@ -101,7 +101,7 @@ function partMatchesConditions(instance, partConditions) {
 exports.partMatchesConditions = partMatchesConditions;
 function applyPartConditions(instances, paramKeys, partConditions) {
     instances.forEach(item => {
-        if (item.typeProp !== types_js_1.TypeProps.Graphic) {
+        if (item.typeProp !== globals_js_1.ComponentTypes.graphic) {
             const matchedResult = partMatchesConditions(item, partConditions);
             if (matchedResult !== undefined) {
                 paramKeys.forEach((paramKey, index) => {

package/dist/cjs/SemanticTokenVisitor.js

@@ -211,7 +211,7 @@ exports.prepareTokens = prepareTokens;
 const languageKeywords = [
     'break', 'branch', 'create', 'component',
     'graphic', 'wire', 'pin', 'add', 'at', 'to',
-    'point', 'join', 'parallel', 'return', 'def', 'import',
+    'point', 'join', 'parallel', 'return', 'def', 'from', 'import',
     'true', 'false', 'nc', 'sheet', 'frame', 'if', 'else', 'for', 'in',
 ];
 const operatorKeywords = [

package/dist/cjs/antlr/CircuitScriptParser.js

@@ -3406,7 +3406,7 @@ class CircuitScriptParser extends antlr.Parser {
                         this.state = 686;
                         this.match(CircuitScriptParser.Import);
                         this.state = 687;
-                        localContext._moduleName = this.match(CircuitScriptParser.ID);
+                        localContext._libraryName = this.match(CircuitScriptParser.ID);
                         this.state = 689;
                         this.errorHandler.sync(this);
                         switch (this.interpreter.adaptivePredict(this.tokenStream, 76, this.context)) {
@@ -3426,7 +3426,7 @@ class CircuitScriptParser extends antlr.Parser {
                         this.state = 691;
                         this.match(CircuitScriptParser.From);
                         this.state = 692;
-                        localContext._moduleName = this.match(CircuitScriptParser.ID);
+                        localContext._libraryName = this.match(CircuitScriptParser.ID);
                         this.state = 693;
                         this.match(CircuitScriptParser.Import);
                         this.state = 694;
@@ -3450,7 +3450,7 @@ class CircuitScriptParser extends antlr.Parser {
                         this.state = 698;
                         this.match(CircuitScriptParser.From);
                         this.state = 699;
-                        localContext._moduleName = this.match(CircuitScriptParser.ID);
+                        localContext._libraryName = this.match(CircuitScriptParser.ID);
                         this.state = 700;
                         this.match(CircuitScriptParser.Import);
                         this.state = 701;

package/dist/cjs/builtinMethods.js

@@ -156,8 +156,8 @@ function toString(obj) {
     else if (obj instanceof types_js_1.CFunctionEntry) {
         return obj.toString();
     }
-    else if (obj instanceof types_js_1.ImportedModule) {
-        return `[module: ${obj.moduleName}]`;
+    else if (obj instanceof types_js_1.ImportedLibrary) {
+        return `[library: ${obj.libraryName}]`;
     }
     else {
         if (obj === undefined) {

package/dist/cjs/environment.js

@@ -5,8 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NodeScriptEnvironment = void 0;
 const svg_js_1 = require("@svgdotjs/svg.js");
-const fs_1 = require("fs");
-const fs_2 = __importDefault(require("fs"));
+const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const crypto_js_1 = __importDefault(require("crypto-js"));
 const globals_js_1 = require("./globals.js");
@@ -22,6 +21,12 @@ class NodeScriptEnvironment {
             'Arial': 'Arial.ttf',
         };
     }
+    existsSync(pathLike) {
+        return fs_1.default.existsSync(pathLike);
+    }
+    mkdirSync(pathLike) {
+        return fs_1.default.mkdirSync(pathLike);
+    }
     static setInstance(instance) {
         NodeScriptEnvironment._instance = instance;
     }
@@ -40,7 +45,7 @@ class NodeScriptEnvironment {
         }
         try {
             const packageJsonPath = path_1.default.join(this.getToolsPath(), '../', 'package.json');
-            const packageJsonContent = fs_2.default.readFileSync(packageJsonPath, 'utf-8');
+            const packageJsonContent = fs_1.default.readFileSync(packageJsonPath, 'utf-8');
             const packageJson = JSON.parse(packageJsonContent);
             this.cachedVersion = packageJson.version || globals_js_1.TOOL_VERSION;
             return this.cachedVersion;
@@ -120,10 +125,10 @@ class NodeScriptEnvironment {
     }
     async readFile(path, options) {
         options = options ?? { encoding: 'utf8' };
-        return fs_2.default.promises.readFile(path, options);
+        return fs_1.default.promises.readFile(path, options);
     }
     writeFileSync(path, data) {
-        return (0, fs_1.writeFileSync)(path, data);
+        return fs_1.default.writeFileSync(path, data);
     }
     getAbsolutePath(filePath) {
         return path_1.default.resolve(filePath);
@@ -143,7 +148,7 @@ class NodeScriptEnvironment {
     }
     async exists(path) {
         try {
-            await fs_2.default.promises.access(path, fs_2.default.constants.F_OK);
+            await fs_1.default.promises.access(path, fs_1.default.constants.F_OK);
             return true;
         }
         catch (err) {
@@ -168,6 +173,9 @@ class NodeScriptEnvironment {
     relative(from, to) {
         return path_1.default.relative(from, to);
     }
+    createWriteStream(filePath) {
+        return fs_1.default.createWriteStream(filePath);
+    }
 }
 exports.NodeScriptEnvironment = NodeScriptEnvironment;
 NodeScriptEnvironment._instance = null;

package/dist/cjs/execute.js

@@ -641,19 +641,18 @@ class ExecutionContext {
                 });
             }
             else {
-                const modules = Array.from(context.scope.modules.values());
-                for (let j = 0; j < modules.length; j++) {
-                    const module = modules[j];
-                    if (module.importHandlingFlag === types_js_1.ImportFunctionHandling.AllMergeIntoNamespace ||
-                        (module.importHandlingFlag === types_js_1.ImportFunctionHandling.SpecificMergeIntoNamespace
-                            && module.specifiedImports.indexOf(idName) !== -1)) {
-                        const moduleContext = module.context;
-                        const functionPath = `${moduleContext.namespace}${idName}`;
-                        if (module.context.hasFunction(functionPath)) {
+                const libraries = Array.from(context.scope.libraries.values());
+                for (const library of libraries) {
+                    if (library.importHandlingFlag === types_js_1.ImportFunctionHandling.AllMergeIntoNamespace ||
+                        (library.importHandlingFlag === types_js_1.ImportFunctionHandling.SpecificMergeIntoNamespace
+                            && library.specifiedImports.indexOf(idName) !== -1)) {
+                        const { context: libraryContext } = library;
+                        const functionPath = `${libraryContext.namespace}${idName}`;
+                        if (library.context.hasFunction(functionPath)) {
                             return new types_js_1.DeclaredReference({
                                 found: true,
-                                rootValue: module,
-                                value: module.context.getFunction(functionPath),
+                                rootValue: library,
+                                value: library.context.getFunction(functionPath),
                                 type: globals_js_1.ReferenceTypes.function,
                                 name: idName,
                                 trailerIndex: 1,
@@ -662,24 +661,24 @@ class ExecutionContext {
                         }
                     }
                 }
-                let isModule = false;
-                if (context.scope.modules.has(idName)) {
-                    const module = context.scope.modules.get(idName);
-                    if (module.importHandlingFlag === types_js_1.ImportFunctionHandling.AllWithNamespace) {
-                        isModule = true;
+                let isLibrary = false;
+                if (context.scope.libraries.has(idName)) {
+                    const library = context.scope.libraries.get(idName);
+                    if (library.importHandlingFlag === types_js_1.ImportFunctionHandling.AllWithNamespace) {
+                        isLibrary = true;
                     }
                 }
                 let isVariable = context.scope.variables.has(idName);
                 let isComponentInstance = context.scope.instances.has(idName);
-                if (isModule || isVariable || isComponentInstance) {
-                    const scopeList = isModule ? context.scope.modules :
+                if (isLibrary || isVariable || isComponentInstance) {
+                    const scopeList = isLibrary ? context.scope.libraries :
                         (isVariable ? context.scope.variables : context.scope.instances);
                     const useValue = scopeList.get(idName);
                     if (!isComponentInstance && (useValue instanceof ClassComponent_js_1.ClassComponent)) {
                         isComponentInstance = true;
                         isVariable = false;
                     }
-                    const referenceType = isModule ? globals_js_1.ReferenceTypes.module :
+                    const referenceType = isLibrary ? globals_js_1.ReferenceTypes.library :
                         (isVariable ? globals_js_1.ReferenceTypes.variable : globals_js_1.ReferenceTypes.instance);
                     const tmpReference = this.resolveTrailers(referenceType, useValue, trailers);
                     return new types_js_1.DeclaredReference({
@@ -726,12 +725,12 @@ class ExecutionContext {
                     }
                     break;
                 }
-                case globals_js_1.ReferenceTypes.module: {
+                case globals_js_1.ReferenceTypes.library: {
                     const funcName = trailers[0];
-                    const module = rootValue;
-                    const functionPath = `${module.moduleNamespace}${funcName}`;
-                    if (module.context.hasFunction(functionPath)) {
-                        const foundFunc = module.context.getFunction(functionPath);
+                    const library = rootValue;
+                    const functionPath = `${library.libraryNamespace}${funcName}`;
+                    if (library.context.hasFunction(functionPath)) {
+                        const foundFunc = library.context.getFunction(functionPath);
                         return new types_js_1.AnyReference({
                             found: true,
                             type: globals_js_1.ReferenceTypes.function,
@@ -1012,6 +1011,11 @@ class ExecutionContext {
                     globals_js_1.ParamKeys.flipY,
                 ];
                 if (unitModifiers.indexOf(paramName) !== -1) {
+                    if (paramName === globals_js_1.ParamKeys.flipX || paramName == globals_js_1.ParamKeys.flipY) {
+                        if (typeof value === "boolean") {
+                            value = value ? (0, ParamDefinition_js_1.numeric)(1) : (0, ParamDefinition_js_1.numeric)(0);
+                        }
+                    }
                     component.getUnit().setParam(paramName, value);
                 }
             }

package/dist/cjs/globals.js

@@ -91,6 +91,7 @@ var ComponentTypes;
     ComponentTypes["graphic"] = "graphic";
     ComponentTypes["port"] = "port";
     ComponentTypes["module"] = "module";
+    ComponentTypes["resistor"] = "res";
 })(ComponentTypes || (exports.ComponentTypes = ComponentTypes = {}));
 var ReferenceTypes;
 (function (ReferenceTypes) {
@@ -99,7 +100,7 @@ var ReferenceTypes;
     ReferenceTypes["variable"] = "variable";
     ReferenceTypes["instance"] = "instance";
     ReferenceTypes["pinType"] = "pinType";
-    ReferenceTypes["module"] = "module";
+    ReferenceTypes["library"] = "library";
     ReferenceTypes["unknown"] = "unknown";
 })(ReferenceTypes || (exports.ReferenceTypes = ReferenceTypes = {}));
 var BlockTypes;

package/dist/cjs/graph.js

@@ -257,7 +257,7 @@ class NetGraph {
         const netsLength = netsIndexed.length;
         const conductanceMatrix = ml_matrix_1.default.zeros(netsLength, netsLength);
         components.forEach(item => {
-            if (item.typeProp === types_js_1.TypeProps.Resistor) {
+            if (item.typeProp === globals_js_1.ComponentTypes.resistor) {
                 const net1 = item.pinNets.get(1);
                 const net2 = item.pinNets.get(2);
                 const net1Index = netsIndexed.indexOf(net1);

package/dist/cjs/helpers.js

@@ -4,7 +4,6 @@ var __importDefault = (this && this.__importDefault) || function (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 fs_1 = require("fs");
 const path_1 = __importDefault(require("path"));
 const pdfkit_1 = __importDefault(require("pdfkit"));
 const export_js_1 = require("./export.js");
@@ -160,7 +159,7 @@ async function validateScript(filePath, scriptData, options) {
     return visitorResolver;
 }
 exports.validateScript = validateScript;
-async function DefaultPostAnnotationCallback(options, scriptData, tree, tokens, componentLinks, importedModules, environment) {
+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 = [{
@@ -171,29 +170,29 @@ async function DefaultPostAnnotationCallback(options, scriptData, tree, tokens,
                 filePath: inputPath,
                 outputType: RefdesOutputType.WithSource
             }];
-        for (const module of importedModules) {
+        for (const library of importedLibraries) {
             let outputType = RefdesOutputType.None;
-            if (module.enableRefdesAnnotation) {
+            if (library.enableRefdesAnnotation) {
                 outputType = RefdesOutputType.WithSource;
             }
-            else if (module.enableRefdesAnnotationFile) {
+            else if (library.enableRefdesAnnotationFile) {
                 outputType = RefdesOutputType.CreateExternalFile;
             }
             if (outputType !== RefdesOutputType.None) {
-                const { moduleFilePath, moduleName, tokens: moduleTokens, tree: moduleTree } = module;
-                const moduleScriptData = await environment.readFile(moduleFilePath, { encoding: 'utf8' });
+                const { libraryFilePath, libraryName, tokens: libTokens, tree: libTree } = library;
+                const libraryScriptData = await environment.readFile(libraryFilePath, { encoding: 'utf8' });
                 annotatedFiles.push({
-                    tokens: moduleTokens,
-                    tree: moduleTree,
-                    filePath: moduleFilePath,
-                    scriptData: moduleScriptData,
-                    moduleName,
+                    tokens: libTokens,
+                    tree: libTree,
+                    filePath: libraryFilePath,
+                    scriptData: libraryScriptData,
+                    libraryName,
                     outputType
                 });
             }
         }
         for (const item of annotatedFiles) {
-            const { scriptData, tokens, tree, filePath, moduleName, isMainFile = false } = item;
+            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;
@@ -219,15 +218,15 @@ async function DefaultPostAnnotationCallback(options, scriptData, tree, tokens,
                 const relativeFilePath = environment.relative(inputDir, filePath);
                 const jsonFile = {
                     format: 'v1',
-                    module: moduleName,
+                    library: libraryName,
                     file: relativeFilePath,
                     items: output,
                 };
                 environment.writeFileSync(usePath, JSON.stringify(jsonFile, null, 4));
             }
             let display = 'Refdes annotations';
-            if (moduleName) {
-                display += ` for module ${moduleName}`;
+            if (libraryName) {
+                display += ` for library ${libraryName}`;
             }
             console.log(`${display} saved to ${usePath}`);
         }
@@ -294,8 +293,8 @@ async function renderScriptCustom(scriptData, outputPath, options, parseHandlers
     const dumpDirectory = environment.getRelativeToModule('/dump/');
     if (dumpData) {
         console.log('Dump data to:', dumpDirectory);
-        if (!(0, fs_1.existsSync)(dumpDirectory)) {
-            (0, fs_1.mkdirSync)(dumpDirectory);
+        if (!environment.existsSync(dumpDirectory)) {
+            environment.mkdirSync(dumpDirectory);
         }
     }
     if (inputPath !== '') {
@@ -312,16 +311,16 @@ async function renderScriptCustom(scriptData, outputPath, options, parseHandlers
         throw new utils_js_1.RenderError(`Error during component annotation: ${err}`, 'annotation');
     }
     const componentLinks = visitor.getComponentCtxLinks();
-    const importedModules = Array.from(visitor.getScope().modules.values());
+    const importedLibraries = Array.from(visitor.getScope().libraries.values());
     for (let i = 0; i < postAnnotationCallbacks.length; i++) {
-        await postAnnotationCallbacks[i](options, scriptData, tree, tokens, componentLinks, importedModules, environment);
+        await postAnnotationCallbacks[i](options, scriptData, tree, tokens, componentLinks, importedLibraries, environment);
     }
     if (dumpNets) {
         const nets = visitor.dumpNets();
         nets.forEach(item => console.log(item.join(" | ")));
     }
-    dumpData && (0, fs_1.writeFileSync)(dumpDirectory + 'tree.lisp', tree.toStringTree(null, parser));
-    dumpData && (0, fs_1.writeFileSync)(dumpDirectory + 'raw-parser.txt', visitor.logger.dump());
+    dumpData && environment.writeFileSync(dumpDirectory + 'tree.lisp', tree.toStringTree(null, parser));
+    dumpData && environment.writeFileSync(dumpDirectory + 'raw-parser.txt', visitor.logger.dump());
     if (throwError) {
         throw throwError;
     }
@@ -334,11 +333,11 @@ async function renderScriptCustom(scriptData, outputPath, options, parseHandlers
             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)(bomCsvOutput, bomOutputPath);
+            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 && (0, fs_1.writeFileSync)(dumpDirectory + 'raw-sequence.txt', tmpSequence.join('\n'));
+        dumpData && environment.writeFileSync(dumpDirectory + 'raw-sequence.txt', tmpSequence.join('\n'));
         try {
             let fileExtension = null;
             let outputDefaultZoom = globals_js_1.defaultZoomScale;
@@ -383,7 +382,7 @@ async function renderScriptCustom(scriptData, outputPath, options, parseHandlers
             }
             layoutEngine.printWarnings();
             showStats && console.log('Layout took:', layoutTimer.lap());
-            dumpData && (0, fs_1.writeFileSync)(dumpDirectory + 'raw-layout.txt', layoutEngine.logger.dump());
+            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;
@@ -394,7 +393,7 @@ async function renderScriptCustom(scriptData, outputPath, options, parseHandlers
                 throw new utils_js_1.RenderError(`Error during SVG generation: ${err}`, 'svg_generation');
             }
             showStats && console.log('Render took:', generateSvgTimer.lap());
-            dumpData && (0, fs_1.writeFileSync)(dumpDirectory + 'raw-render.txt', renderLogger.dump());
+            dumpData && environment.writeFileSync(dumpDirectory + 'raw-render.txt', renderLogger.dump());
             try {
                 if (fileExtension === "pdf") {
                     outputDefaultZoom = 1;
@@ -407,7 +406,7 @@ async function renderScriptCustom(scriptData, outputPath, options, parseHandlers
             if (outputPath) {
                 if (fileExtension === 'svg') {
                     try {
-                        (0, fs_1.writeFileSync)(outputPath, svgOutput);
+                        environment.writeFileSync(outputPath, svgOutput);
                     }
                     catch (err) {
                         throw new utils_js_1.RenderError(`Error writing SVG file: ${err}`, 'file_output');
@@ -425,7 +424,7 @@ async function renderScriptCustom(scriptData, outputPath, options, parseHandlers
                             layout: 'landscape',
                             size: sheetSize
                         });
-                        const outputStream = (0, fs_1.createWriteStream)(outputPath);
+                        const outputStream = environment.createWriteStream(outputPath);
                         (0, render_js_1.generatePdfOutput)(doc, svgCanvas, sheetSize, sheetSizeDefined, outputDefaultZoom);
                         doc.pipe(outputStream);
                         doc.end();
@@ -468,7 +467,7 @@ class KiCadNetListOutputHandler extends ParseOutputHandler {
             missingFootprints.forEach(entry => {
                 console.log(`${entry.refdes} (${entry.instanceName}) does not have footprint`);
             });
-            (0, fs_1.writeFileSync)(outputPath, (0, export_js_1.printTree)(kiCadNetList));
+            visitor.environment.writeFileSync(outputPath, (0, export_js_1.printTree)(kiCadNetList));
             console.log('Generated file', outputPath);
             return false;
         }

package/dist/cjs/objects/ExecutionScope.js

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