circuitscript 0.2.0 → 0.3.0

package/dist/esm/BaseVisitor.js

@@ -6,7 +6,7 @@ import { Logger } from "./logger.js";
 import { ClassComponent } from "./objects/ClassComponent.js";
 import { NumberOperator, NumericValue, PercentageValue } from "./objects/ParamDefinition.js";
 import { PinTypes } from "./objects/PinTypes.js";
-import { Direction, AnyReference, UndeclaredReference, ImportedModule, ImportFunctionHandling as ImportFunctionHandling } from "./objects/types.js";
+import { Direction, AnyReference, UndeclaredReference, ImportedLibrary, ImportFunctionHandling as ImportFunctionHandling } from "./objects/types.js";
 import { BaseNamespace, ComponentTypes, DoubleDelimiter1, GlobalDocumentName, ReferenceTypes, TrailerArrayIndex } from './globals.js';
 import { isReference, unwrapValue as unwrapValue } from "./utils.js";
 import { linkBuiltInMethods } from './builtinMethods.js';
@@ -145,17 +145,17 @@ export class BaseVisitor extends 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;
             }
         }
     }
@@ -417,23 +417,23 @@ export class BaseVisitor extends CircuitScriptVisitor {
                     }
                     const useNetNamespace = this.getNetNamespace(executor.netNamespace, passedNetNamespace);
                     try {
-                        const isModuleFunction = currentReference.rootValue
-                            && currentReference.rootValue instanceof 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 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();
                         }
@@ -712,8 +712,8 @@ export class BaseVisitor extends 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 === ImportFunctionHandling.AllMergeIntoNamespace
                 || alreadyImportedFlag === ImportFunctionHandling.SpecificMergeIntoNamespace;
             const invalidImportCondition1 = alreadyImportedFlag === ImportFunctionHandling.AllWithNamespace &&
@@ -727,11 +727,11 @@ export class BaseVisitor extends CircuitScriptVisitor {
                 if (alreadyImportedFlag === ImportFunctionHandling.AllMergeIntoNamespace) {
                 }
                 else if (alreadyImportedFlag === ImportFunctionHandling.SpecificMergeIntoNamespace && importHandling === ImportFunctionHandling.AllMergeIntoNamespace) {
-                    tmpImportedModule.specifiedImports = [];
-                    tmpImportedModule.importHandlingFlag = ImportFunctionHandling.AllMergeIntoNamespace;
+                    tmpImportedLibrary.specifiedImports = [];
+                    tmpImportedLibrary.importHandlingFlag = ImportFunctionHandling.AllMergeIntoNamespace;
                 }
                 else if (alreadyImportedFlag === ImportFunctionHandling.SpecificMergeIntoNamespace && importHandling === ImportFunctionHandling.SpecificMergeIntoNamespace) {
-                    tmpImportedModule.specifiedImports.push(...specificImports);
+                    tmpImportedLibrary.specifiedImports.push(...specificImports);
                 }
             }
             return importAlready;
@@ -752,7 +752,7 @@ export class BaseVisitor extends CircuitScriptVisitor {
             this.log('failed to read file');
             pathExists = false;
         }
-        let importedModule;
+        let importedLibrary;
         if (!pathExists) {
             try {
                 const tmpFilePath2 = this.environment.getRelativeToDefaultLibs(name + ".cst");
@@ -773,26 +773,26 @@ export class BaseVisitor extends CircuitScriptVisitor {
                 const executor = this.getExecutor();
                 const executionContextName = name;
                 const netNamespace = executor.netNamespace;
-                const moduleNamespace = `${BaseNamespace}${name}.`;
+                const libraryNamespace = `${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 ImportedModule(name, moduleNamespace, filePathUsed, importResult.tree, importResult.tokens, importContext, importHandling, specificImports);
+                importedLibrary = new 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) {
@@ -820,12 +820,12 @@ export class BaseVisitor extends 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/esm/ComponentMatchConditions.js

@@ -1,5 +1,5 @@
+import { ComponentTypes } from "./globals.js";
 import { NumericValue } from "./objects/ParamDefinition.js";
-import { TypeProps } from "./objects/types.js";
 export function flattenConditionNodes(conditionNodes, level = 0) {
     const conditionBranches = [];
     conditionNodes.forEach(node => {
@@ -95,7 +95,7 @@ export function partMatchesConditions(instance, partConditions) {
 }
 export function applyPartConditions(instances, paramKeys, partConditions) {
     instances.forEach(item => {
-        if (item.typeProp !== TypeProps.Graphic) {
+        if (item.typeProp !== ComponentTypes.graphic) {
             const matchedResult = partMatchesConditions(item, partConditions);
             if (matchedResult !== undefined) {
                 paramKeys.forEach((paramKey, index) => {

package/dist/esm/antlr/CircuitScriptParser.js

@@ -3572,7 +3572,7 @@ export 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)) {
@@ -3592,7 +3592,7 @@ export 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;
@@ -3616,7 +3616,7 @@ export 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;
@@ -6760,7 +6760,7 @@ export class Import_exprContext extends antlr.ParserRuleContext {
     }
 }
 export class Import_specificContext extends Import_exprContext {
-    _moduleName;
+    _libraryName;
     _ID;
     _funcNames = [];
     constructor(ctx) {
@@ -6794,7 +6794,7 @@ export class Import_specificContext extends Import_exprContext {
     }
 }
 export class Import_all_simpleContext extends Import_exprContext {
-    _moduleName;
+    _libraryName;
     constructor(ctx) {
         super(ctx.parent, ctx.invokingState);
         super.copyFrom(ctx);
@@ -6824,7 +6824,7 @@ export class Import_all_simpleContext extends Import_exprContext {
     }
 }
 export class Import_simpleContext extends Import_exprContext {
-    _moduleName;
+    _libraryName;
     constructor(ctx) {
         super(ctx.parent, ctx.invokingState);
         super.copyFrom(ctx);

package/dist/esm/builtinMethods.js

@@ -1,6 +1,6 @@
 import Big from "big.js";
 import { numeric, NumericValue } from "./objects/ParamDefinition.js";
-import { CFunctionEntry, ImportedModule } from "./objects/types.js";
+import { CFunctionEntry, ImportedLibrary } from "./objects/types.js";
 import { unwrapValue, resolveToNumericValue, RuntimeExecutionError } from "./utils.js";
 import { BaseNamespace } from "./globals.js";
 const builtInMethods = [
@@ -149,8 +149,8 @@ function toString(obj) {
     else if (obj instanceof CFunctionEntry) {
         return obj.toString();
     }
-    else if (obj instanceof ImportedModule) {
-        return `[module: ${obj.moduleName}]`;
+    else if (obj instanceof ImportedLibrary) {
+        return `[library: ${obj.libraryName}]`;
     }
     else {
         if (obj === undefined) {

package/dist/esm/execute.js

@@ -646,19 +646,18 @@ export 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 === ImportFunctionHandling.AllMergeIntoNamespace ||
-                        (module.importHandlingFlag === 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 === ImportFunctionHandling.AllMergeIntoNamespace ||
+                        (library.importHandlingFlag === ImportFunctionHandling.SpecificMergeIntoNamespace
+                            && library.specifiedImports.indexOf(idName) !== -1)) {
+                        const { context: libraryContext } = library;
+                        const functionPath = `${libraryContext.namespace}${idName}`;
+                        if (library.context.hasFunction(functionPath)) {
                             return new DeclaredReference({
                                 found: true,
-                                rootValue: module,
-                                value: module.context.getFunction(functionPath),
+                                rootValue: library,
+                                value: library.context.getFunction(functionPath),
                                 type: ReferenceTypes.function,
                                 name: idName,
                                 trailerIndex: 1,
@@ -667,24 +666,24 @@ export class ExecutionContext {
                         }
                     }
                 }
-                let isModule = false;
-                if (context.scope.modules.has(idName)) {
-                    const module = context.scope.modules.get(idName);
-                    if (module.importHandlingFlag === ImportFunctionHandling.AllWithNamespace) {
-                        isModule = true;
+                let isLibrary = false;
+                if (context.scope.libraries.has(idName)) {
+                    const library = context.scope.libraries.get(idName);
+                    if (library.importHandlingFlag === 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)) {
                         isComponentInstance = true;
                         isVariable = false;
                     }
-                    const referenceType = isModule ? ReferenceTypes.module :
+                    const referenceType = isLibrary ? ReferenceTypes.library :
                         (isVariable ? ReferenceTypes.variable : ReferenceTypes.instance);
                     const tmpReference = this.resolveTrailers(referenceType, useValue, trailers);
                     return new DeclaredReference({
@@ -731,12 +730,12 @@ export class ExecutionContext {
                     }
                     break;
                 }
-                case ReferenceTypes.module: {
+                case 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 AnyReference({
                             found: true,
                             type: ReferenceTypes.function,

package/dist/esm/globals.js

@@ -87,6 +87,7 @@ export var ComponentTypes;
     ComponentTypes["graphic"] = "graphic";
     ComponentTypes["port"] = "port";
     ComponentTypes["module"] = "module";
+    ComponentTypes["resistor"] = "res";
 })(ComponentTypes || (ComponentTypes = {}));
 export var ReferenceTypes;
 (function (ReferenceTypes) {
@@ -95,7 +96,7 @@ export var ReferenceTypes;
     ReferenceTypes["variable"] = "variable";
     ReferenceTypes["instance"] = "instance";
     ReferenceTypes["pinType"] = "pinType";
-    ReferenceTypes["module"] = "module";
+    ReferenceTypes["library"] = "library";
     ReferenceTypes["unknown"] = "unknown";
 })(ReferenceTypes || (ReferenceTypes = {}));
 export var BlockTypes;

package/dist/esm/graph.js

@@ -6,7 +6,7 @@ import { RenderFrame, RenderComponent, applyComponentParamsToSymbol, RenderWire
 import { SequenceAction, FrameAction } from "./objects/ExecutionScope.js";
 import { Frame, FixedFrameIds, FrameParamKeys } from "./objects/Frame.js";
 import { numeric } from "./objects/ParamDefinition.js";
-import { NetTypes, TypeProps } from "./objects/types.js";
+import { NetTypes } from "./objects/types.js";
 import Matrix, { solve } from "ml-matrix";
 import { getPinDefinition, PinId } from "./objects/PinDefinition.js";
 export class NetGraph {
@@ -232,7 +232,7 @@ export class NetGraph {
         const netsLength = netsIndexed.length;
         const conductanceMatrix = Matrix.zeros(netsLength, netsLength);
         components.forEach(item => {
-            if (item.typeProp === TypeProps.Resistor) {
+            if (item.typeProp === ComponentTypes.resistor) {
                 const net1 = item.pinNets.get(1);
                 const net2 = item.pinNets.get(2);
                 const net1Index = netsIndexed.indexOf(net1);

package/dist/esm/helpers.js

@@ -149,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 = [{
@@ -160,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;
@@ -208,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}`);
         }
@@ -300,9 +300,9 @@ 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();

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;