circuitscript 0.2.0 → 0.3.1

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/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/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/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,

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

@@ -159,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 = [{
@@ -170,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;
@@ -218,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}`);
         }
@@ -311,9 +311,9 @@ 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();

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 = [];

package/dist/cjs/objects/types.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImportFunctionHandling = exports.ImportedModule = exports.NetTypes = exports.TypeProps = exports.Direction = exports.ParseSymbolType = exports.DeclaredReference = exports.UndeclaredReference = exports.AnyReference = exports.CFunctionEntry = void 0;
+exports.ImportFunctionHandling = exports.ImportedLibrary = exports.NetTypes = exports.Direction = exports.ParseSymbolType = exports.DeclaredReference = exports.UndeclaredReference = exports.AnyReference = exports.CFunctionEntry = void 0;
 const globals_js_1 = require("../globals.js");
 const utils_js_1 = require("../utils.js");
 class CFunctionEntry {
@@ -111,29 +111,18 @@ var Direction;
     Direction["Down"] = "down";
     Direction["Up"] = "up";
 })(Direction || (exports.Direction = Direction = {}));
-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 || (exports.TypeProps = TypeProps = {}));
 var NetTypes;
 (function (NetTypes) {
     NetTypes["Any"] = "any";
     NetTypes["Source"] = "source";
 })(NetTypes || (exports.NetTypes = NetTypes = {}));
-class ImportedModule {
-    constructor(moduleName, moduleNamespace, moduleFilePath, tree, tokens, context, flag, specifiedImports) {
+class ImportedLibrary {
+    constructor(libraryName, libraryNamespace, libraryFilePath, tree, tokens, context, flag, specifiedImports) {
         this.enableRefdesAnnotation = false;
         this.enableRefdesAnnotationFile = false;
-        this.moduleName = moduleName;
-        this.moduleNamespace = moduleNamespace;
-        this.moduleFilePath = moduleFilePath;
+        this.libraryName = libraryName;
+        this.libraryNamespace = libraryNamespace;
+        this.libraryFilePath = libraryFilePath;
         this.tree = tree;
         this.tokens = tokens;
         this.context = context;
@@ -141,7 +130,7 @@ class ImportedModule {
         this.specifiedImports = specifiedImports;
     }
 }
-exports.ImportedModule = ImportedModule;
+exports.ImportedLibrary = ImportedLibrary;
 var ImportFunctionHandling;
 (function (ImportFunctionHandling) {
     ImportFunctionHandling["AllWithNamespace"] = "all-with-namespace";

package/dist/cjs/validate/SymbolValidatorVisitor.js

@@ -167,24 +167,24 @@ class SymbolValidatorVisitor extends BaseVisitor_js_1.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);
         }
     }
-    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 === types_js_1.ParseSymbolType.Function) {
                 const definedSymbol = value;
-                if (definedSymbol.fileName === module.moduleFilePath) {
+                if (definedSymbol.fileName === library.libraryFilePath) {
                     const addSymbolToNamespace = importHandling === types_js_1.ImportFunctionHandling.AllMergeIntoNamespace
                         || (importHandling === types_js_1.ImportFunctionHandling.SpecificMergeIntoNamespace
                             && specifiedImports.indexOf(definedSymbol.id) !== -1);

package/dist/cjs/visitor.js

@@ -351,7 +351,7 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
                 return new PinDefinition_js_1.PinDefinition(index + 1, PinDefinition_js_1.PinIdType.Int, portName, PinTypes_js_1.PinTypes.Any);
             });
             const arrange = this.getArrangePropFromModulePorts(modulePorts, nameToPinId);
-            const unitProperties = this.extractComponentUnitProperties(properties, types_js_1.TypeProps.Module);
+            const unitProperties = this.extractComponentUnitProperties(properties, globals_js_1.ComponentTypes.module);
             const firstUnitDef = unitProperties[0][1];
             firstUnitDef.pins = tmpPorts;
             firstUnitDef.arrange = arrange;
@@ -362,7 +362,7 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             };
             const moduleInstanceName = this.getExecutor().getUniqueInstanceName();
             const moduleComponent = this.getExecutor().createComponent(moduleInstanceName, tmpPorts, blankParams, props, true);
-            moduleComponent.typeProp = types_js_1.TypeProps.Module;
+            moduleComponent.typeProp = globals_js_1.ComponentTypes.module;
             const ctxPropertyBlock = ctx.property_block_expr();
             if (ctxPropertyBlock) {
                 const [firstBlock] = ctxPropertyBlock;
@@ -1148,7 +1148,7 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
         const display = properties.get('display') ?? null;
         const suffix = properties.get('suffix') ?? null;
         let pins = [];
-        if (display !== null && arrange === null && typeProp !== types_js_1.TypeProps.Graphic) {
+        if (display !== null && arrange === null && typeProp !== globals_js_1.ComponentTypes.graphic) {
             const drawCommands = display.getCommands();
             drawCommands.forEach(command => {
                 const [commandValue,] = command;
@@ -1385,7 +1385,7 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             currentComponent.forceSaveRefdesAnnotation = forceSave;
         }
     }
-    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);
@@ -1655,8 +1655,8 @@ class ParserVisitor extends BaseVisitor_js_1.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 !== types_js_1.TypeProps.Module
-                && component.typeProp !== types_js_1.TypeProps.Net) {
+                && component.typeProp !== globals_js_1.ComponentTypes.module
+                && component.typeProp !== globals_js_1.ComponentTypes.net) {
                 net.name = net.baseName =
                     `NET-(${component.assignedRefDes}-${pin.toString()})`;
                 if (fullNetNames.indexOf(net.toString()) !== -1) {