circuitscript 0.3.1 → 0.4.0

package/dist/esm/validate.js

@@ -1,8 +1,9 @@
 #! /usr/bin/env node
 import { program } from 'commander';
 import { readFileSync, existsSync } from 'fs';
-import { getSemanticTokens, validateScript } from './helpers.js';
-import { NodeScriptEnvironment } from "./environment.js";
+import { getSemanticTokens } from "./semantic-tokens/getSemanticTokens.js";
+import { validateScript } from "./validate/validateScript.js";
+import { NodeScriptEnvironment } from "./environment/environment.js";
 import { ParseSymbolType } from './objects/types.js';
 export default async function validate() {
     const env = new NodeScriptEnvironment();
@@ -83,7 +84,7 @@ export default async function validate() {
         }
     });
     console.log('----- tokens -----');
-    const { parsedTokens } = await getSemanticTokens(scriptData, scriptOptions);
+    const { parsedTokens } = await getSemanticTokens(inputFilePath, scriptData, scriptOptions);
     console.log('----- dump tokens -----');
     parsedTokens.forEach(item => {
         const { line, column, tokenType, tokenModifiers, textValue } = item;

package/dist/esm/visitor.js

@@ -2,15 +2,15 @@ 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, UndeclaredReference } from './objects/types.js';
+import { 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';
+import { PlaceHolderCommands, SymbolDrawingCommands } from './render/draw_symbols.js';
 import { BaseVisitor } from './BaseVisitor.js';
 import { getPortType, RuntimeExecutionError } from './utils.js';
 import { UnitDimension } from './helpers.js';
 import { FrameParamKeys } from './objects/Frame.js';
-import { ComponentAnnotater } from './ComponentAnnotater.js';
+import { ComponentAnnotater } from './annotate/ComponentAnnotater.js';
 import { applyPartConditions, extractPartConditions, flattenConditionNodes } from './ComponentMatchConditions.js';
 export class ParserVisitor extends BaseVisitor {
     constructor(silent = false, onErrorHandler = null, environment) {
@@ -25,11 +25,6 @@ export class ParserVisitor extends BaseVisitor {
     }
     componentCreationIndex = 0;
     creationCtx = new Map();
-    visitKeyword_assignment_expr = (ctx) => {
-        const id = ctx.ID().getText();
-        const value = this.visitResult(ctx.data_expr());
-        this.setResult(ctx, [id, value]);
-    };
     visitPin_select_expr = (ctx) => {
         let pinId = null;
         const ctxData = ctx.data_expr();
@@ -164,22 +159,19 @@ export class ParserVisitor extends BaseVisitor {
         if (ctx.path_block() === null) {
             this.getExecutor().closeOpenPathBlocks();
         }
-        const ctxPathBlock = ctx.path_block();
-        const ctxNotPathBlock = ctx.graph_linear_expression();
-        if (ctxPathBlock) {
-            this.visit(ctxPathBlock);
-        }
-        if (ctxNotPathBlock) {
-            this.visit(ctxNotPathBlock);
-        }
+        this.visitChildren(ctx);
         if (ctx.start && ctx.stop) {
             const startToken = ctx.start;
             const stopToken = ctx.stop;
-            const annotationKey = this.getRefdesFileAnnotation(this.getCurrentFile(), startToken.line, startToken.column, stopToken.line, stopToken.column);
-            if (this.refdesFileAnnotations.has(annotationKey)) {
-                let refdesValue = this.refdesFileAnnotations.get(annotationKey);
-                refdesValue = refdesValue.split(',')[0];
-                this.setCurrentComponentRefdes(refdesValue, true);
+            if (this.filePathStack.length > 0) {
+                const useFilePath = this.getCurrentFile();
+                const annotationKey = this.getRefdesFileAnnotationKey(useFilePath, startToken.line, startToken.column, stopToken.line, stopToken.column);
+                if (this.refdesFileAnnotations.has(annotationKey)) {
+                    this.log(`refdes annotation key matched: ${annotationKey}`);
+                    let refdesValue = this.refdesFileAnnotations.get(annotationKey);
+                    refdesValue = refdesValue.split(',')[0];
+                    this.setCurrentComponentRefdes(refdesValue, true);
+                }
             }
         }
     };
@@ -187,12 +179,10 @@ export class ParserVisitor extends BaseVisitor {
         const scope = this.getScope();
         scope.setOnPropertyHandler(this.createComponentPropertyValidator());
         scope.enterContext(ctx);
-        ctx.property_expr().forEach(item => {
-            this.visitResult(item);
-        });
+        const ctxPropertiesBlock = ctx.properties_block();
+        const properties = this.visitResult(ctxPropertiesBlock);
         scope.exitContext();
         scope.popOnPropertyHandler();
-        const properties = this.getPropertyExprList(ctx.property_expr());
         let instanceName = this.getExecutor().getUniqueInstanceName();
         const propParams = properties.get('params');
         const params = this.parseCreateComponentParams(propParams);
@@ -479,9 +469,9 @@ export class ParserVisitor extends BaseVisitor {
             throw "Invalid command!";
         }
         let parameters = [];
-        const ctxNestedProperties = ctx.nested_properties_inner();
-        if (ctxNestedProperties) {
-            const nestedKeyValues = this.visitResult(ctxNestedProperties);
+        const ctxPropertiesBlock = ctx.properties_block();
+        if (ctxPropertiesBlock) {
+            const nestedKeyValues = this.visitResult(ctxPropertiesBlock);
             nestedKeyValues.forEach((value, key) => {
                 parameters.push(['keyword', key, unwrapValue(value)]);
             });
@@ -576,10 +566,6 @@ export class ParserVisitor extends BaseVisitor {
     visitProperty_expr = (ctx) => {
         const ctxKey = ctx.property_key_expr();
         const ctxValue = ctx.property_value_expr();
-        const extraValue = ctx._extra;
-        if (extraValue) {
-            console.log('extra', extraValue.text);
-        }
         const scope = this.getScope();
         this.getScope().enterContext(ctxKey);
         this.getScope().enterContext(ctxValue);
@@ -614,18 +600,25 @@ export class ParserVisitor extends BaseVisitor {
         this.getScope().exitContext();
         this.setResult(ctx, value);
     };
-    visitNested_properties_inner = (ctx) => {
+    visitProperties_block = (ctx) => {
         const result = new Map();
-        ctx.property_expr().forEach((item) => {
+        const keyCounter = new Map();
+        ctx.property_expr().forEach(item => {
             const property = this.visitResult(item);
             for (const [key, value] of property) {
-                result.set(key, value);
+                let useKey = key;
+                const counterValue = keyCounter.get(key) ?? 0;
+                keyCounter.set(key, counterValue + 1);
+                if (counterValue > 0) {
+                    useKey = key + ':' + counterValue;
+                }
+                result.set(useKey, value);
             }
         });
         this.setResult(ctx, result);
     };
     visitNested_properties = (ctx) => {
-        this.setResult(ctx, this.visitResult(ctx.nested_properties_inner()));
+        this.passResult(ctx, ctx.children[0]);
     };
     visitProperty_key_expr = (ctx) => {
         const ctxID = ctx.ID();
@@ -649,22 +642,25 @@ export class ParserVisitor extends BaseVisitor {
         const ctxDataExpr = ctx.data_expr();
         const ctxAssignmentExpr = ctx.assignment_expr();
         if (ctxDataExpr) {
-            dataResult = this.visitResult(ctxDataExpr);
             componentCtx = ctxDataExpr;
+            this.setResult(ctxDataExpr, { keepReference: true });
+            const reference = this.visitResult(ctxDataExpr);
+            if (reference.found) {
+                dataResult = unwrapValue(reference);
+            }
+            else {
+                const { trailers = [], rootValue = null } = reference;
+                if (rootValue instanceof ClassComponent && trailers.length > 0
+                    && trailers[0] === ModuleContainsKeyword) {
+                    dataResult = rootValue;
+                    this.placeModuleContains(dataResult);
+                }
+            }
         }
         else if (ctxAssignmentExpr) {
             dataResult = this.visitResult(ctxAssignmentExpr);
             componentCtx = ctxAssignmentExpr;
         }
-        if (dataResult instanceof AnyReference) {
-            const { trailers = [], rootValue = null } = dataResult;
-            if (rootValue instanceof ClassComponent
-                && trailers.length > 0
-                && trailers[0] === ModuleContainsKeyword) {
-                dataResult = rootValue;
-                this.placeModuleContains(dataResult);
-            }
-        }
         dataResult = unwrapValue(dataResult);
         if (dataResult === null || dataResult === undefined) {
             this.throwWithContext(componentCtx, "Could not find component: " + componentCtx.getText());
@@ -678,18 +674,12 @@ export class ParserVisitor extends BaseVisitor {
             const modifiers = ctx.component_modifier_expr();
             modifiers.forEach(modifier => {
                 const modifierText = modifier.ID(0).getText();
-                const ctxValueExpr = modifier.value_expr();
-                const ctxID2 = modifier.ID(1);
-                let result = null;
-                if (ctxValueExpr) {
-                    result = this.visitResult(ctxValueExpr);
-                }
-                else if (ctxID2) {
-                    result = ctxID2.getText();
-                }
+                const ctxDataExpr = modifier.data_expr();
+                this.setResult(ctxDataExpr, { keepReference: true });
+                const result = this.visitResult(ctxDataExpr);
                 let shouldIgnoreWireOrientation = false;
                 if (modifierText === ParamKeys.flip) {
-                    const flipValue = result;
+                    const flipValue = result.name;
                     if (flipValue.indexOf('x') !== -1) {
                         defaultUnit.setParam(ParamKeys.flipX, numeric(1));
                         shouldIgnoreWireOrientation = true;
@@ -704,7 +694,7 @@ export class ParserVisitor extends BaseVisitor {
                     shouldIgnoreWireOrientation = true;
                 }
                 else if (modifierText === 'anchor') {
-                    dataResult.setParam('anchor', result);
+                    dataResult.setParam('anchor', result.name);
                 }
                 if (shouldIgnoreWireOrientation) {
                     defaultUnit.useWireOrientationAngle = false;
@@ -777,31 +767,28 @@ export class ParserVisitor extends BaseVisitor {
     }
     visitUnaryOperatorExpr = (ctx) => {
         let value = this.visitResult(ctx.data_expr());
-        const unaryOp = ctx.unary_operator();
-        if (unaryOp) {
-            if (unaryOp.Not()) {
-                if (typeof value === "boolean") {
-                    value = !value;
-                }
-                else if (value instanceof NumericValue) {
-                    value = (value.toNumber() === 0) ? true : false;
-                }
-                else {
-                    throw "Failed to do Not operator";
-                }
+        if (ctx.Not()) {
+            if (typeof value === "boolean") {
+                value = !value;
             }
-            else if (unaryOp.Minus()) {
-                if (value instanceof NumericValue) {
-                    value = value.neg();
-                }
-                else {
-                    throw "Failed to do Negation operator";
-                }
+            else if (value instanceof NumericValue) {
+                value = (value.toNumber() === 0) ? true : false;
+            }
+            else {
+                throw "Failed to do Not operator";
+            }
+        }
+        else if (ctx.Minus()) {
+            if (value instanceof NumericValue) {
+                value = value.neg();
+            }
+            else {
+                throw "Failed to do Negation operator";
             }
         }
         this.setResult(ctx, value);
     };
-    visitDataExpr = (ctx) => {
+    visitCreate_expr = (ctx) => {
         let value;
         const ctxCreateComponentExpr = ctx.create_component_expr();
         const ctxCreateGraphicExpr = ctx.create_graphic_expr();
@@ -820,6 +807,10 @@ export class ParserVisitor extends BaseVisitor {
         }
         this.setResult(ctx, value);
     };
+    visitCreateExpr = (ctx) => {
+        const result = this.visitResult(ctx.create_expr());
+        this.setResult(ctx, result);
+    };
     visitBinaryOperatorExpr = (ctx) => {
         const ctx0 = ctx.data_expr(0);
         const ctx1 = ctx.data_expr(1);
@@ -831,24 +822,23 @@ export class ParserVisitor extends BaseVisitor {
         if (value2 instanceof NumericValue) {
             value2 = value2.toNumber();
         }
-        const binaryOperatorType = ctx.binary_operator();
         let result = null;
-        if (binaryOperatorType.Equals()) {
+        if (ctx.Equals()) {
             result = value1 == value2;
         }
-        else if (binaryOperatorType.NotEquals()) {
+        else if (ctx.NotEquals()) {
             result = value1 != value2;
         }
-        else if (binaryOperatorType.GreaterThan()) {
+        else if (ctx.GreaterThan()) {
             result = value1 > value2;
         }
-        else if (binaryOperatorType.GreatOrEqualThan()) {
+        else if (ctx.GreatOrEqualThan()) {
             result = value1 >= value2;
         }
-        else if (binaryOperatorType.LessThan()) {
+        else if (ctx.LessThan()) {
             result = value1 < value2;
         }
-        else if (binaryOperatorType.LessOrEqualThan()) {
+        else if (ctx.LessOrEqualThan()) {
             result = value1 <= value2;
         }
         this.setResult(ctx, result);
@@ -942,8 +932,8 @@ export class ParserVisitor extends BaseVisitor {
         }
         const executionStack = this.executionStack;
         const functionCounter = { counter: 0 };
-        const resolveNet = this.createNetResolver(this.executionStack);
-        const resolveComponentPinNet = this.createComponentPinNetResolver(this.executionStack);
+        const resolveNet = this.createNetResolver(executionStack);
+        const resolveComponentPinNet = this.createComponentPinNetResolver(executionStack);
         const __runFunc = (passedInParameters, options) => {
             const executor = this.getExecutor();
             const functionCounterIndex = functionCounter['counter'];
@@ -958,41 +948,23 @@ export class ParserVisitor extends BaseVisitor {
         };
         this.getExecutor().createFunction(this.getExecutor().namespace, functionName, __runFunc, ctx, uniqueFunctionID);
     };
-    visitPin_select_expr2 = (ctx) => {
-        const ctxStringValue = ctx.STRING_VALUE();
-        const ctxIntegerValue = ctx.INTEGER_VALUE();
-        let pinIdValue;
-        let pinId = null;
-        if (ctxStringValue) {
-            pinIdValue = this.prepareStringValue(ctxStringValue.getText());
-        }
-        else if (ctxIntegerValue) {
-            pinIdValue = Number(ctxIntegerValue.getText());
-        }
-        if (pinIdValue !== undefined) {
-            pinId = new PinId(pinIdValue);
-        }
-        else {
-            throw new RuntimeExecutionError("Invalid select pin", ctx);
-        }
-        this.setResult(ctx, pinId);
-    };
     visitAt_block_pin_expr = (ctx) => {
         const executor = this.getExecutor();
         const [currentComponent, currentPin] = executor.getCurrentPoint();
         executor.closeOpenPathBlocks();
-        const atPin = this.visitResult(ctx.pin_select_expr2());
+        const propKey = this.visitResult(ctx.property_key_expr());
+        const atPin = new PinId(propKey);
         executor.atComponent(currentComponent, atPin, {
             addSequence: true
         });
         executor.log('at block pin expressions');
-        const ctxAtBlockSimple = ctx.at_block_pin_expression_simple();
-        const ctxAtBlockComplex = ctx.at_block_pin_expression_complex();
-        if (ctxAtBlockSimple) {
-            this.visit(ctxAtBlockSimple);
+        const ctxExpression = ctx.expression();
+        const ctxExpressionsBlock = ctx.expressions_block();
+        if (ctxExpression) {
+            this.visit(ctxExpression);
         }
-        else if (ctxAtBlockComplex) {
-            this.visit(ctxAtBlockComplex);
+        else if (ctxExpressionsBlock) {
+            this.visit(ctxExpressionsBlock);
         }
         executor.log('end at block pin expressions');
         executor.atComponent(currentComponent, currentPin);
@@ -1021,63 +993,33 @@ export class ParserVisitor extends BaseVisitor {
         executor.scope.setCurrent(currentComponent, currentPin);
         executor.log('leaving at block');
     };
-    visitAt_block_pin_expression_simple = (ctx) => {
-        const ctxExpression = ctx.expression();
-        if (ctxExpression) {
-            this.visit(ctxExpression);
-        }
-        else if (ctx.NOT_CONNECTED()) {
-            return;
-        }
-    };
-    visitAt_block_pin_expression_complex = (ctx) => {
-        this.visit(ctx.expressions_block());
-    };
-    visitWire_expr_direction_only = (ctx) => {
-        const value = ctx.ID().getText();
-        if (value === WireAutoDirection.Auto || value === WireAutoDirection.Auto_) {
-            this.setResult(ctx, [value]);
-        }
-        else {
-            throw 'Invalid direction for wire';
-        }
-    };
-    visitWire_expr_direction_value = (ctx) => {
-        const direction = ctx.ID().getText();
-        if (this.acceptedDirections.indexOf(direction) !== -1) {
-            let useValue = null;
-            const ctxIntegerValue = ctx.INTEGER_VALUE();
-            const ctxDataExpr = ctx.data_expr();
-            if (ctxIntegerValue) {
-                useValue = Number(ctxIntegerValue);
-            }
-            else if (ctxDataExpr) {
+    visitWire_expr = (ctx) => {
+        const segments = [];
+        ctx.ID().forEach((ctxId, index) => {
+            const value = ctxId.getText();
+            const ctxDataExpr = ctx.data_expr(index);
+            if ((value === WireAutoDirection.Auto || value === WireAutoDirection.Auto_) && ctxDataExpr === null) {
+                segments.push([value]);
+            }
+            else if (this.acceptedDirections.indexOf(value) !== -1 && ctxDataExpr) {
+                let useValue = null;
                 useValue = this.visitResult(ctxDataExpr);
                 if (useValue instanceof NumericValue) {
                     useValue = useValue.toNumber();
                 }
+                segments.push([value, new UnitDimension(useValue)]);
             }
-            if (useValue !== null) {
-                this.setResult(ctx, [direction, new UnitDimension(useValue)]);
-                return;
-            }
-        }
-        throw "Invalid direction or value for wire";
-    };
-    visitWire_expr = (ctx) => {
-        const wireAtomExpr = ctx.wire_atom_expr();
-        const segments = wireAtomExpr.map(wireSegment => {
-            return this.visitResult(wireSegment);
         });
         const newWire = this.getExecutor().addWire(segments);
         this.creationCtx.set(newWire, ctx);
     };
     visitPoint_expr = (ctx) => {
-        const ID = ctx.ID();
-        const ctxData = ctx.data_expr();
+        const ctxDataExpr = ctx.data_expr();
+        this.setResult(ctxDataExpr, { keepReference: true });
+        const result = this.visitResult(ctxDataExpr);
         let pointValue;
-        if (ctxData) {
-            const resultValue = this.visitResult(ctxData);
+        if (result.found) {
+            const resultValue = unwrapValue(result);
             if (typeof resultValue === 'string') {
                 pointValue = resultValue;
             }
@@ -1085,16 +1027,11 @@ export class ParserVisitor extends BaseVisitor {
                 throw new RuntimeExecutionError('Invalid value for point');
             }
         }
-        else if (ID) {
-            pointValue = ID.getText();
+        else {
+            pointValue = result.name;
         }
         return this.getExecutor().addPoint(pointValue);
     };
-    visitProperty_set_expr = (ctx) => {
-        const result = this.visitResult(ctx.data_expr());
-        const resolvedProperty = this.visitResult(ctx.atom_expr());
-        this.getExecutor().setProperty(resolvedProperty, result);
-    };
     visitDouble_dot_property_set_expr = (ctx) => {
         const result = this.visitResult(ctx.data_expr());
         const propertyName = ctx.ID().getText();
@@ -1113,14 +1050,15 @@ export class ParserVisitor extends BaseVisitor {
         this.getExecutor().exitFrame(frameId);
     };
     visitNet_namespace_expr = (ctx) => {
-        let dataValue = null;
+        let dataValue;
         let netNamespace = null;
         const hasPlus = ctx.Addition();
         const ctxDataExpr = ctx.data_expr();
         if (ctxDataExpr) {
+            this.setResult(ctxDataExpr, { keepReference: true });
             dataValue = this.visitResult(ctxDataExpr);
-            if (dataValue instanceof UndeclaredReference) {
-                netNamespace = "/" + dataValue.reference.name;
+            if (!dataValue.found) {
+                netNamespace = "/" + dataValue.name;
             }
             else if (typeof dataValue === "string") {
                 netNamespace = "/" + dataValue;
@@ -1259,7 +1197,7 @@ export class ParserVisitor extends BaseVisitor {
         }
     }
     visitAnnotation_comment_expr = (ctx) => {
-        const refdesID = ctx.ID().getText();
+        const refdesID = ctx.getText().replace('#=', '').trim();
         this.setCurrentComponentRefdes(refdesID);
     };
     visitPart_set_expr = (ctx) => {
@@ -1273,26 +1211,21 @@ export class ParserVisitor extends BaseVisitor {
         applyPartConditions(instances, paramKeys, partConditions);
     };
     visitPart_match_block = (ctx) => {
-        const results = ctx.part_sub_expr().map(ctxExpr => {
-            return this.visitResult(ctxExpr);
-        });
+        const results = ctx.part_sub_expr().reduce((accum, ctxExpr) => {
+            const result = this.visitResult(ctxExpr);
+            if (result !== undefined) {
+                accum.push(result);
+            }
+            return accum;
+        }, []);
         this.setResult(ctx, results);
     };
     visitPart_sub_expr = (ctx) => {
-        const ctxForm1 = ctx.part_condition_expr();
-        const ctxForm2 = ctx.part_condition_key_only_expr();
-        const ctxForm3 = ctx.part_value_expr();
-        let result;
-        if (ctxForm1) {
-            result = this.visitResult(ctxForm1);
-        }
-        else if (ctxForm2) {
-            result = this.visitResult(ctxForm2);
-        }
-        else if (ctxForm3) {
-            result = this.visitResult(ctxForm3);
+        this.visitChildren(ctx);
+        const result = this.getResult(ctx.children[0]);
+        if (result !== undefined) {
+            this.setResult(ctx, result);
         }
-        this.setResult(ctx, result);
     };
     visitPart_set_key = (ctx) => {
         const ctxID = ctx.ID();
@@ -1324,10 +1257,17 @@ export class ParserVisitor extends BaseVisitor {
     };
     visitPart_value_expr = (ctx) => {
         const key = this.visitResult(ctx.part_set_key());
-        const values = ctx.data_expr().map(ctxData => {
-            return this.visitResult(ctxData);
-        });
-        this.setResult(ctx, { key, endValue: values });
+        const ctxPartMatchBlock = ctx.part_match_block();
+        if (ctxPartMatchBlock) {
+            const children = this.visitResult(ctxPartMatchBlock);
+            this.setResult(ctx, { key, children });
+        }
+        else {
+            const values = ctx.data_expr().map(ctxData => {
+                return this.visitResult(ctxData);
+            });
+            this.setResult(ctx, { key, endValue: values });
+        }
     };
     visitPart_condition_expr = (ctx) => {
         const allKeys = ctx._key_id.map(ctx => {
@@ -1367,33 +1307,39 @@ export class ParserVisitor extends BaseVisitor {
         });
         this.setResult(ctx, tmpKeyValues);
     };
-    visitPart_condition_key_only_expr = (ctx) => {
-        const key = this.visitResult(ctx.part_set_key());
-        const children = this.visitResult(ctx.part_match_block());
-        this.setResult(ctx, {
-            key,
-            children,
-        });
-    };
-    async checkLibraryHasRefdesFile(filePath) {
-        const dir = this.environment.dirname(filePath);
-        const ext = this.environment.extname(filePath);
-        const basename = this.environment.basename(filePath, ext);
-        const annotatedFilePath = this.environment.join(dir, `${basename}${RefdesFileSuffix}`);
-        const exists = await this.environment.exists(annotatedFilePath);
+    getPathRefdesFile(filePath) {
+        const mainDir = this.environment.dirname(filePath);
+        const mainExt = this.environment.extname(filePath);
+        const mainBasename = this.environment.basename(filePath, mainExt);
+        return this.environment.join(mainDir, `${mainBasename}${RefdesFileSuffix}`);
+    }
+    checkLibraryInRefdesFile(filePath) {
+        if (this.filePathStack.length === 0) {
+            return;
+        }
+        const [baseFile] = this.filePathStack;
+        const mainDir = this.environment.dirname(baseFile);
+        const refdesFilePath = this.getPathRefdesFile(baseFile);
+        const exists = this.loadedFiles.has(refdesFilePath);
         if (exists) {
-            this.log(`Import has refdes file: ${annotatedFilePath}`);
-            const fileData = await this.environment.readFile(annotatedFilePath);
+            this.log(`Main schematic has refdes file: ${refdesFilePath}`);
+            const fileData = this.loadedFiles.get(refdesFilePath);
             const jsonData = JSON.parse(fileData);
-            const baseFilePath = this.environment.getAbsolutePath(this.filePathStack[0]);
-            const basePathDirectory = this.environment.dirname(baseFilePath);
-            const { file, items } = jsonData;
-            for (const item of items) {
-                const parts = item.split(':');
-                const refdes = parts[4];
-                const useFilePath = this.environment.join(basePathDirectory, file);
-                const key = this.getRefdesFileAnnotation(useFilePath, Number(parts[0]), Number(parts[1]), Number(parts[2]), Number(parts[3]));
-                this.refdesFileAnnotations.set(key, refdes);
+            const relativeLibraryPath = this.environment.relative(mainDir, filePath);
+            const { libraries = [] } = jsonData;
+            for (const library of libraries) {
+                const { path: libraryPath, items } = library;
+                if (libraryPath === relativeLibraryPath) {
+                    this.log(`Found refdes annotations for library at: ${libraryPath}`);
+                    const useFilePath = this.environment.join(mainDir, libraryPath);
+                    for (const refdes in items) {
+                        const val = items[refdes];
+                        const parts = val.split(':');
+                        const key = this.getRefdesFileAnnotationKey(useFilePath, Number(parts[0]), Number(parts[1]), Number(parts[2]), Number(parts[3]));
+                        this.refdesFileAnnotations.set(key, refdes);
+                    }
+                    break;
+                }
             }
         }
     }