circuitscript 0.1.33 → 0.3.0

package/dist/esm/helpers.js

@@ -1,4 +1,3 @@
-import { writeFileSync, createWriteStream, existsSync, mkdirSync } from "fs";
 import path from "path";
 import PDFDocument from "pdfkit";
 import { generateKiCadNetList, printTree } from "./export.js";
@@ -150,7 +149,7 @@ export async function validateScript(filePath, scriptData, options) {
     await visitorResolver.visitAsync(tree);
     return visitorResolver;
 }
-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 = [{
@@ -161,29 +160,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(true, scriptData, tokens, componentLinks);
             await tmpVisitor.visit(tree);
             let usePath = filePath;
@@ -209,15 +208,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}`);
         }
@@ -283,8 +282,8 @@ export async function renderScriptCustom(scriptData, outputPath, options, parseH
     const dumpDirectory = environment.getRelativeToModule('/dump/');
     if (dumpData) {
         console.log('Dump data to:', dumpDirectory);
-        if (!existsSync(dumpDirectory)) {
-            mkdirSync(dumpDirectory);
+        if (!environment.existsSync(dumpDirectory)) {
+            environment.mkdirSync(dumpDirectory);
         }
     }
     if (inputPath !== '') {
@@ -301,16 +300,16 @@ export async function renderScriptCustom(scriptData, outputPath, options, parseH
         throw new 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 && writeFileSync(dumpDirectory + 'tree.lisp', tree.toStringTree(null, parser));
-    dumpData && 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;
     }
@@ -323,11 +322,11 @@ export async function renderScriptCustom(scriptData, outputPath, options, parseH
             const bomConfig = documentVariable.bom;
             const bomData = generateBom(bomConfig, visitor.getScope().getInstances());
             const bomCsvOutput = generateBomCSV(bomData);
-            await saveBomOutputCsv(bomCsvOutput, bomOutputPath);
+            await saveBomOutputCsv(environment, bomCsvOutput, bomOutputPath);
             console.log('Generated BOM file', bomOutputPath);
         }
         const tmpSequence = generateDebugSequenceAction(sequence).map(item => sequenceActionString(item));
-        dumpData && writeFileSync(dumpDirectory + 'raw-sequence.txt', tmpSequence.join('\n'));
+        dumpData && environment.writeFileSync(dumpDirectory + 'raw-sequence.txt', tmpSequence.join('\n'));
         try {
             let fileExtension = null;
             let outputDefaultZoom = defaultZoomScale;
@@ -372,7 +371,7 @@ export async function renderScriptCustom(scriptData, outputPath, options, parseH
             }
             layoutEngine.printWarnings();
             showStats && console.log('Layout took:', layoutTimer.lap());
-            dumpData && writeFileSync(dumpDirectory + 'raw-layout.txt', layoutEngine.logger.dump());
+            dumpData && environment.writeFileSync(dumpDirectory + 'raw-layout.txt', layoutEngine.logger.dump());
             const generateSvgTimer = new SimpleStopwatch();
             const renderLogger = new Logger();
             let svgCanvas;
@@ -383,7 +382,7 @@ export async function renderScriptCustom(scriptData, outputPath, options, parseH
                 throw new RenderError(`Error during SVG generation: ${err}`, 'svg_generation');
             }
             showStats && console.log('Render took:', generateSvgTimer.lap());
-            dumpData && writeFileSync(dumpDirectory + 'raw-render.txt', renderLogger.dump());
+            dumpData && environment.writeFileSync(dumpDirectory + 'raw-render.txt', renderLogger.dump());
             try {
                 if (fileExtension === "pdf") {
                     outputDefaultZoom = 1;
@@ -396,7 +395,7 @@ export async function renderScriptCustom(scriptData, outputPath, options, parseH
             if (outputPath) {
                 if (fileExtension === 'svg') {
                     try {
-                        writeFileSync(outputPath, svgOutput);
+                        environment.writeFileSync(outputPath, svgOutput);
                     }
                     catch (err) {
                         throw new RenderError(`Error writing SVG file: ${err}`, 'file_output');
@@ -414,7 +413,7 @@ export async function renderScriptCustom(scriptData, outputPath, options, parseH
                             layout: 'landscape',
                             size: sheetSize
                         });
-                        const outputStream = createWriteStream(outputPath);
+                        const outputStream = environment.createWriteStream(outputPath);
                         generatePdfOutput(doc, svgCanvas, sheetSize, sheetSizeDefined, outputDefaultZoom);
                         doc.pipe(outputStream);
                         doc.end();
@@ -450,7 +449,7 @@ export class KiCadNetListOutputHandler extends ParseOutputHandler {
             missingFootprints.forEach(entry => {
                 console.log(`${entry.refdes} (${entry.instanceName}) does not have footprint`);
             });
-            writeFileSync(outputPath, printTree(kiCadNetList));
+            visitor.environment.writeFileSync(outputPath, printTree(kiCadNetList));
             console.log('Generated file', outputPath);
             return false;
         }

package/dist/esm/objects/ExecutionScope.js

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

package/dist/esm/objects/types.js

@@ -112,37 +112,26 @@ export var Direction;
     Direction["Down"] = "down";
     Direction["Up"] = "up";
 })(Direction || (Direction = {}));
-export var TypeProps;
-(function (TypeProps) {
-    TypeProps["Net"] = "net";
-    TypeProps["Port"] = "port";
-    TypeProps["Graphic"] = "graphic";
-    TypeProps["Module"] = "module";
-    TypeProps["Resistor"] = "res";
-    TypeProps["Capacitor"] = "cap";
-    TypeProps["Inductor"] = "ind";
-    TypeProps["Diode"] = "diode";
-})(TypeProps || (TypeProps = {}));
 export var NetTypes;
 (function (NetTypes) {
     NetTypes["Any"] = "any";
     NetTypes["Source"] = "source";
 })(NetTypes || (NetTypes = {}));
-export class ImportedModule {
-    moduleName;
+export class ImportedLibrary {
+    libraryName;
     context;
     importHandlingFlag;
     specifiedImports;
-    moduleNamespace;
-    moduleFilePath;
+    libraryNamespace;
+    libraryFilePath;
     enableRefdesAnnotation = false;
     enableRefdesAnnotationFile = false;
     tree;
     tokens;
-    constructor(moduleName, moduleNamespace, moduleFilePath, tree, tokens, context, flag, specifiedImports) {
-        this.moduleName = moduleName;
-        this.moduleNamespace = moduleNamespace;
-        this.moduleFilePath = moduleFilePath;
+    constructor(libraryName, libraryNamespace, libraryFilePath, tree, tokens, context, flag, specifiedImports) {
+        this.libraryName = libraryName;
+        this.libraryNamespace = libraryNamespace;
+        this.libraryFilePath = libraryFilePath;
         this.tree = tree;
         this.tokens = tokens;
         this.context = context;

package/dist/esm/validate/SymbolValidatorVisitor.js

@@ -62,13 +62,13 @@ export class SymbolValidatorVisitor extends BaseVisitor {
             });
             specifiedImports.push(...tmpImports);
         }
-        const id = ctx._moduleName.text;
-        const { pathExists, importedModule } = await this.handleImportFile(id, handling, true, ctx, specifiedImports);
+        const id = ctx._libraryName.text;
+        const { pathExists, importedLibrary } = await this.handleImportFile(id, handling, true, ctx, specifiedImports);
         if (!pathExists) {
-            this.symbolTable.addUndefined(this.getCurrentFile(), this.getExecutor(), id, ctx._moduleName);
+            this.symbolTable.addUndefined(this.getCurrentFile(), this.getExecutor(), id, ctx._libraryName);
         }
         else {
-            this.applyModuleImports(importedModule);
+            this.applyLibraryImports(importedLibrary);
         }
     }
     visitImport_simple = async (ctx) => {
@@ -80,15 +80,15 @@ export class SymbolValidatorVisitor extends BaseVisitor {
     visitImport_specific = async (ctx) => {
         await this.importCommon(ctx, ImportFunctionHandling.SpecificMergeIntoNamespace);
     };
-    applyModuleImports(module) {
-        const { importHandlingFlag: importHandling, specifiedImports } = module;
+    applyLibraryImports(library) {
+        const { importHandlingFlag: importHandling, specifiedImports } = library;
         const addedSymbols = [];
         const executor = this.getExecutor();
         const symbolTable = this.symbolTable.getSymbols();
         symbolTable.forEach((value, key) => {
             if (value.type === ParseSymbolType.Function) {
                 const definedSymbol = value;
-                if (definedSymbol.fileName === module.moduleFilePath) {
+                if (definedSymbol.fileName === library.libraryFilePath) {
                     const addSymbolToNamespace = importHandling === ImportFunctionHandling.AllMergeIntoNamespace
                         || (importHandling === ImportFunctionHandling.SpecificMergeIntoNamespace
                             && specifiedImports.indexOf(definedSymbol.id) !== -1);

package/dist/esm/visitor.js

@@ -2,7 +2,7 @@ import { ClassComponent } from './objects/ClassComponent.js';
 import { NumberOperator, numeric, NumericValue, ParamDefinition } from './objects/ParamDefinition.js';
 import { PinDefinition, PinId, PinIdType } from './objects/PinDefinition.js';
 import { PinTypes } from './objects/PinTypes.js';
-import { AnyReference, DeclaredReference, TypeProps, UndeclaredReference } from './objects/types.js';
+import { AnyReference, DeclaredReference, UndeclaredReference } from './objects/types.js';
 import { BlockTypes, ComponentTypes, Delimiter1, FrameType, GlobalDocumentName, ModuleContainsKeyword, NoNetText, ParamKeys, RefdesFileSuffix, ReferenceTypes, SymbolPinSide, ValidPinSides, WireAutoDirection } from './globals.js';
 import { unwrapValue } from "./utils.js";
 import { PlaceHolderCommands, SymbolDrawingCommands } from './draw_symbols.js';
@@ -231,7 +231,7 @@ export class ParserVisitor extends BaseVisitor {
         const display = properties.get('display') ?? null;
         const suffix = properties.get('suffix') ?? null;
         let pins = [];
-        if (display !== null && arrange === null && typeProp !== TypeProps.Graphic) {
+        if (display !== null && arrange === null && typeProp !== ComponentTypes.graphic) {
             const drawCommands = display.getCommands();
             drawCommands.forEach(command => {
                 const [commandValue,] = command;
@@ -542,7 +542,7 @@ export class ParserVisitor extends BaseVisitor {
             return new PinDefinition(index + 1, PinIdType.Int, portName, PinTypes.Any);
         });
         const arrange = this.getArrangePropFromModulePorts(modulePorts, nameToPinId);
-        const unitProperties = this.extractComponentUnitProperties(properties, TypeProps.Module);
+        const unitProperties = this.extractComponentUnitProperties(properties, ComponentTypes.module);
         const firstUnitDef = unitProperties[0][1];
         firstUnitDef.pins = tmpPorts;
         firstUnitDef.arrange = arrange;
@@ -553,7 +553,7 @@ export class ParserVisitor extends BaseVisitor {
         };
         const moduleInstanceName = this.getExecutor().getUniqueInstanceName();
         const moduleComponent = this.getExecutor().createComponent(moduleInstanceName, tmpPorts, blankParams, props, true);
-        moduleComponent.typeProp = TypeProps.Module;
+        moduleComponent.typeProp = ComponentTypes.module;
         const ctxPropertyBlock = ctx.property_block_expr();
         if (ctxPropertyBlock) {
             const [firstBlock] = ctxPropertyBlock;
@@ -1375,7 +1375,7 @@ export class ParserVisitor extends BaseVisitor {
             children,
         });
     };
-    async checkModuleHasRefdesFile(filePath) {
+    async checkLibraryHasRefdesFile(filePath) {
         const dir = this.environment.dirname(filePath);
         const ext = this.environment.extname(filePath);
         const basename = this.environment.basename(filePath, ext);
@@ -1652,8 +1652,8 @@ export class ParserVisitor extends BaseVisitor {
         const fullNetNames = Array.from(uniqueNets).map(item => item.toString());
         nets.forEach(([component, pin, net]) => {
             if (net.priority === 0 && seenNets.indexOf(net) === -1
-                && component.typeProp !== TypeProps.Module
-                && component.typeProp !== TypeProps.Net) {
+                && component.typeProp !== ComponentTypes.module
+                && component.typeProp !== ComponentTypes.net) {
                 net.name = net.baseName =
                     `NET-(${component.assignedRefDes}-${pin.toString()})`;
                 if (fullNetNames.indexOf(net.toString()) !== -1) {

package/dist/types/BaseVisitor.d.ts

@@ -4,7 +4,7 @@ import { ExecutionContext } from "./execute.js";
 import { Logger } from "./logger.js";
 import { ClassComponent } from "./objects/ClassComponent.js";
 import { Net } from "./objects/Net.js";
-import { CallableParameter, ComplexType, Direction, FunctionDefinedParameter, AnyReference, ImportedModule, NewContextOptions, ImportFunctionHandling as ImportFunctionHandling } from "./objects/types.js";
+import { CallableParameter, ComplexType, Direction, FunctionDefinedParameter, AnyReference, ImportedLibrary, NewContextOptions, ImportFunctionHandling as ImportFunctionHandling } from "./objects/types.js";
 import { CommonTokenStream, ParserRuleContext } from 'antlr4ng';
 import { ExecutionWarning } from "./utils.js";
 import { BaseError } from './utils.js';
@@ -26,7 +26,7 @@ export declare class BaseVisitor extends CircuitScriptVisitor<ComplexType | AnyR
     pinTypesList: string[];
     onErrorHandler: OnErrorHandler | null;
     environment: NodeScriptEnvironment;
-    protected importedFiles: ImportFile[];
+    protected importedFiles: ImportLibraryFile[];
     protected warnings: ExecutionWarning[];
     onImportFile: (visitor: BaseVisitor, filePath: string, fileData: string, onErrorHandler: OnErrorHandler) => Promise<ImportFileResult>;
     refdesFileAnnotations: Map<string, string>;
@@ -73,8 +73,8 @@ export declare class BaseVisitor extends CircuitScriptVisitor<ComplexType | AnyR
     protected linkComponentToCtx(ctx: ParserRuleContext, instance: ClassComponent, creationFlag?: boolean): void;
     getComponentCtxLinks(): Map<ParserRuleContext, ClassComponent>;
     visitResult(ctx: ParserRuleContext): any;
-    protected handleImportFile(name: string, importHandling: ImportFunctionHandling, throwErrors?: boolean, ctx?: ParserRuleContext | null, specificImports?: string[]): Promise<ImportFile>;
-    checkModuleHasRefdesFile(filePath: string): Promise<void>;
+    protected handleImportFile(name: string, importHandling: ImportFunctionHandling, throwErrors?: boolean, ctx?: ParserRuleContext | null, specificImports?: string[]): Promise<ImportLibraryFile>;
+    checkLibraryHasRefdesFile(filePath: string): Promise<void>;
     getRefdesFileAnnotation(filePath: string, startLine: number, startColumn: number, stopLine: number, stopColumn: number): string;
     visitRoundedBracketsExpr: (ctx: RoundedBracketsExprContext) => void;
     protected setupDefinedParameters(funcDefinedParameters: FunctionDefinedParameter[], passedInParameters: CallableParameter[], executor: ExecutionContext): void;
@@ -94,12 +94,12 @@ export declare class BaseVisitor extends CircuitScriptVisitor<ComplexType | AnyR
     getCurrentFile(): string;
 }
 export type OnErrorHandler = (message: string, context: ParserRuleContext, e?: any) => void;
-type ImportFile = {
+type ImportLibraryFile = {
     id: string;
     hasError: boolean;
     hasParseError: boolean;
     pathExists: boolean;
-    importedModule: ImportedModule;
+    importedLibrary: ImportedLibrary;
 };
 export type ImportFileResult = {
     hasError: boolean;

package/dist/types/BomGeneration.d.ts

@@ -1,4 +1,5 @@
 import { ClassComponent } from "./objects/ClassComponent.js";
+import { NodeScriptEnvironment } from './environment.js';
 export type BomConfig = {
     columns: string[];
 };
@@ -9,5 +10,5 @@ type GroupEntry = {
 };
 export declare function groupComponents(bomConfig: BomConfig, bomComponents: Record<string, unknown>[]): Map<string, GroupEntry>;
 export declare function generateBomCSV(bomData: Record<string, GroupEntry>[]): string[][];
-export declare function saveBomOutputCsv(bomCsvOutput: string[][], filePath: string): Promise<void>;
+export declare function saveBomOutputCsv(environment: NodeScriptEnvironment, bomCsvOutput: string[][], filePath: string): Promise<void>;
 export {};

package/dist/types/antlr/CircuitScriptParser.d.ts

@@ -895,7 +895,7 @@ export declare class Import_exprContext extends antlr.ParserRuleContext {
     copyFrom(ctx: Import_exprContext): void;
 }
 export declare class Import_specificContext extends Import_exprContext {
-    _moduleName?: Token | null;
+    _libraryName?: Token | null;
     _ID?: Token | null;
     _funcNames: antlr.Token[];
     constructor(ctx: Import_exprContext);
@@ -907,7 +907,7 @@ export declare class Import_specificContext extends Import_exprContext {
     accept<Result>(visitor: CircuitScriptVisitor<Result>): Result | null;
 }
 export declare class Import_all_simpleContext extends Import_exprContext {
-    _moduleName?: Token | null;
+    _libraryName?: Token | null;
     constructor(ctx: Import_exprContext);
     From(): antlr.TerminalNode;
     Import(): antlr.TerminalNode;
@@ -917,7 +917,7 @@ export declare class Import_all_simpleContext extends Import_exprContext {
     accept<Result>(visitor: CircuitScriptVisitor<Result>): Result | null;
 }
 export declare class Import_simpleContext extends Import_exprContext {
-    _moduleName?: Token | null;
+    _libraryName?: Token | null;
     constructor(ctx: Import_exprContext);
     Import(): antlr.TerminalNode;
     ID(): antlr.TerminalNode;

package/dist/types/environment.d.ts

@@ -1,8 +1,10 @@
 /// <reference types="node" resolution-mode="require"/>
 import { Dom } from "@svgdotjs/svg.js";
-import { PathOrFileDescriptor, PathLike } from "fs";
+import fs from 'fs';
 import { SVGWindow } from "./helpers.js";
 export declare class NodeScriptEnvironment {
+    existsSync(pathLike: string): boolean;
+    mkdirSync(pathLike: string): void;
     static _instance: NodeScriptEnvironment | null;
     static setInstance(instance: NodeScriptEnvironment): void;
     static getInstance(): NodeScriptEnvironment;
@@ -28,18 +30,19 @@ export declare class NodeScriptEnvironment {
     textMeasurementCanvas: Dom | undefined;
     getCanvasWindow(): Dom;
     prepareSVGEnvironment(): Promise<void>;
-    readFile(path: PathOrFileDescriptor, options?: any): Promise<string>;
-    writeFileSync(path: PathOrFileDescriptor, data: string): void;
+    readFile(path: fs.PathOrFileDescriptor, options?: any): Promise<string>;
+    writeFileSync(path: fs.PathOrFileDescriptor, data: string): void;
     getAbsolutePath(filePath: string): string;
     getDirPath(filePath: string): string;
     setCurrentFile(filePath: string): string;
     getCurrentFile(): string;
     getRelativeToCurrentFolder(filePath: string): string;
-    exists(path: PathLike): Promise<boolean>;
+    exists(path: fs.PathLike): Promise<boolean>;
     hashStringSHA256(value: string): string;
     dirname(filePath: string): string;
     extname(filePath: string): string;
     basename(filePath: string, ext: string): string;
     join(...paths: string[]): string;
     relative(from: string, to: string): string;
+    createWriteStream(filePath: string): fs.WriteStream;
 }

package/dist/types/globals.d.ts

@@ -76,7 +76,8 @@ export declare enum ComponentTypes {
     net = "net",
     graphic = "graphic",
     port = "port",
-    module = "module"
+    module = "module",
+    resistor = "res"
 }
 export declare enum ReferenceTypes {
     function = "function",
@@ -84,7 +85,7 @@ export declare enum ReferenceTypes {
     variable = "variable",
     instance = "instance",
     pinType = "pinType",
-    module = "module",
+    library = "library",
     unknown = "unknown"
 }
 export declare enum BlockTypes {

package/dist/types/helpers.d.ts

@@ -11,7 +11,7 @@ export type SVGWindow = any;
 import { NumericValue } from "./objects/ParamDefinition.js";
 import { NodeScriptEnvironment } from "./environment.js";
 import { ClassComponent } from "./objects/ClassComponent.js";
-import { ImportedModule } from "./objects/types.js";
+import { ImportedLibrary } from "./objects/types.js";
 export declare enum JSModuleType {
     CommonJs = "cjs",
     ESM = "mjs"
@@ -47,7 +47,7 @@ type RenderScriptReturn = {
     errors: BaseError[];
 };
 export declare function renderScript(scriptData: string, outputPath: string | null, options: ScriptOptions): Promise<RenderScriptReturn>;
-export declare function renderScriptCustom(scriptData: string, outputPath: string | null, options: ScriptOptions, parseHandlers: ParseOutputHandler[], postAnnotationCallbacks: ((options: ScriptOptions, scriptData: string, tree: ScriptContext, tokens: CommonTokenStream, componentLinks: Map<ParserRuleContext, ClassComponent>, importedModule: ImportedModule[], environment: NodeScriptEnvironment) => void)[]): Promise<RenderScriptReturn>;
+export declare function renderScriptCustom(scriptData: string, outputPath: string | null, options: ScriptOptions, parseHandlers: ParseOutputHandler[], postAnnotationCallbacks: ((options: ScriptOptions, scriptData: string, tree: ScriptContext, tokens: CommonTokenStream, componentLinks: Map<ParserRuleContext, ClassComponent>, importedLibraries: ImportedLibrary[], environment: NodeScriptEnvironment) => void)[]): Promise<RenderScriptReturn>;
 export declare abstract class ParseOutputHandler {
     beforeRender: boolean;
     afterRender: boolean;

package/dist/types/objects/ExecutionScope.d.ts

@@ -1,6 +1,6 @@
 import { ClassComponent } from './ClassComponent.js';
 import { Net } from './Net.js';
-import { CFunction, CFunctionEntry, ComponentPinNet, ComponentPinNetPair, ComponentPinWireId, ImportedModule, ParseSymbolType, ValueType } from './types.js';
+import { CFunction, CFunctionEntry, ComponentPinNet, ComponentPinNetPair, ComponentPinWireId, ImportedLibrary, ParseSymbolType, ValueType } from './types.js';
 import { BlockTypes, LayoutDirection } from '../globals.js';
 import { Wire, WireSegment } from './Wire.js';
 import { Frame } from './Frame.js';
@@ -19,7 +19,7 @@ export declare class ExecutionScope {
     symbols: Map<string, {
         type: ParseSymbolType;
     }>;
-    modules: Map<string, ImportedModule>;
+    libraries: Map<string, ImportedLibrary>;
     blockStack: Map<number, BlockStackEntry>;
     contextStack: ParserRuleContext[];
     onPropertyHandler: OnPropertyHandler[];

package/dist/types/objects/types.d.ts

@@ -108,32 +108,22 @@ export declare enum Direction {
     Down = "down",
     Up = "up"
 }
-export declare enum TypeProps {
-    Net = "net",
-    Port = "port",
-    Graphic = "graphic",
-    Module = "module",
-    Resistor = "res",
-    Capacitor = "cap",
-    Inductor = "ind",
-    Diode = "diode"
-}
 export declare enum NetTypes {
     Any = "any",
     Source = "source"
 }
-export declare class ImportedModule {
-    moduleName: string;
+export declare class ImportedLibrary {
+    libraryName: string;
     context: ExecutionContext;
     importHandlingFlag: ImportFunctionHandling;
     specifiedImports: string[];
-    moduleNamespace: string;
-    moduleFilePath: string;
+    libraryNamespace: string;
+    libraryFilePath: string;
     enableRefdesAnnotation: boolean;
     enableRefdesAnnotationFile: boolean;
     tree: ScriptContext;
     tokens: CommonTokenStream;
-    constructor(moduleName: string, moduleNamespace: string, moduleFilePath: string, tree: ScriptContext, tokens: CommonTokenStream, context: ExecutionContext, flag: ImportFunctionHandling, specifiedImports: string[]);
+    constructor(libraryName: string, libraryNamespace: string, libraryFilePath: string, tree: ScriptContext, tokens: CommonTokenStream, context: ExecutionContext, flag: ImportFunctionHandling, specifiedImports: string[]);
 }
 export declare enum ImportFunctionHandling {
     AllWithNamespace = "all-with-namespace",

package/dist/types/validate/SymbolValidatorVisitor.d.ts

@@ -16,7 +16,7 @@ export declare class SymbolValidatorVisitor extends BaseVisitor {
     visitImport_simple: (ctx: Import_simpleContext) => Promise<void>;
     visitImport_all_simple: (ctx: Import_all_simpleContext) => Promise<void>;
     visitImport_specific: (ctx: Import_specificContext) => Promise<void>;
-    private applyModuleImports;
+    private applyLibraryImports;
     visitAssignment_expr: (ctx: Assignment_exprContext) => ComplexType;
     visitAtom_expr: (ctx: Atom_exprContext) => void;
     visitFunction_call_expr: (ctx: Function_call_exprContext) => void;

package/dist/types/visitor.d.ts

@@ -75,7 +75,7 @@ export declare class ParserVisitor extends BaseVisitor {
     visitPart_value_expr: (ctx: Part_value_exprContext) => void;
     visitPart_condition_expr: (ctx: Part_condition_exprContext) => void;
     visitPart_condition_key_only_expr: (ctx: Part_condition_key_only_exprContext) => void;
-    checkModuleHasRefdesFile(filePath: string): Promise<void>;
+    checkLibraryHasRefdesFile(filePath: string): Promise<void>;
     private resolveDataExpr;
     private resolveDataValue;
     pinTypes: PinTypes[];

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "circuitscript",
-    "version": "0.1.33",
+    "version": "0.3.0",
     "description": "Interpreter for the circuitscript language",
     "homepage": "https://circuitscript.net",
     "engines": {