circuitscript 0.1.31 → 0.1.33

package/dist/cjs/helpers.js

@@ -160,25 +160,85 @@ async function validateScript(filePath, scriptData, options) {
     return visitorResolver;
 }
 exports.validateScript = validateScript;
-async function DefaultPostAnnotationCallback(options, scriptData, tree, tokens, componentLinks) {
+async function DefaultPostAnnotationCallback(options, scriptData, tree, tokens, componentLinks, importedModules, environment) {
     const { inputPath = null, updateSource = false, saveAnnotatedCopy = undefined, } = options;
     if (inputPath && (updateSource || saveAnnotatedCopy !== undefined)) {
-        const refdesVisitor = new RefdesAnnotationVisitor_js_1.RefdesAnnotationVisitor(true, scriptData, tokens, componentLinks);
-        await refdesVisitor.visitAsync(tree);
-        let usePath = inputPath;
-        if (saveAnnotatedCopy === true) {
-            const dir = path_1.default.dirname(inputPath);
-            const ext = path_1.default.extname(inputPath);
-            const basename = path_1.default.basename(inputPath, ext);
-            usePath = path_1.default.join(dir, `${basename}.annotated${ext}`);
+        const annotatedFiles = [{
+                isMainFile: true,
+                scriptData,
+                tokens,
+                tree,
+                filePath: inputPath,
+                outputType: RefdesOutputType.WithSource
+            }];
+        for (const module of importedModules) {
+            let outputType = RefdesOutputType.None;
+            if (module.enableRefdesAnnotation) {
+                outputType = RefdesOutputType.WithSource;
+            }
+            else if (module.enableRefdesAnnotationFile) {
+                outputType = RefdesOutputType.CreateExternalFile;
+            }
+            if (outputType !== RefdesOutputType.None) {
+                const { moduleFilePath, moduleName, tokens: moduleTokens, tree: moduleTree } = module;
+                const moduleScriptData = await environment.readFile(moduleFilePath, { encoding: 'utf8' });
+                annotatedFiles.push({
+                    tokens: moduleTokens,
+                    tree: moduleTree,
+                    filePath: moduleFilePath,
+                    scriptData: moduleScriptData,
+                    moduleName,
+                    outputType
+                });
+            }
         }
-        else if (typeof saveAnnotatedCopy === 'string') {
-            usePath = saveAnnotatedCopy;
+        for (const item of annotatedFiles) {
+            const { scriptData, tokens, tree, filePath, moduleName, isMainFile = false } = item;
+            const tmpVisitor = new RefdesAnnotationVisitor_js_1.RefdesAnnotationVisitor(true, scriptData, tokens, componentLinks);
+            await tmpVisitor.visit(tree);
+            let usePath = filePath;
+            if (isMainFile && saveAnnotatedCopy === true) {
+                const dir = environment.dirname(filePath);
+                const ext = environment.extname(filePath);
+                const basename = environment.basename(filePath, ext);
+                usePath = environment.join(dir, `${basename}.annotated${ext}`);
+            }
+            else if (isMainFile && typeof saveAnnotatedCopy === 'string') {
+                usePath = saveAnnotatedCopy;
+            }
+            if (item.outputType === RefdesOutputType.WithSource) {
+                environment.writeFileSync(usePath, tmpVisitor.getOutput());
+            }
+            else if (item.outputType === RefdesOutputType.CreateExternalFile) {
+                const dir = environment.dirname(usePath);
+                const ext = environment.extname(usePath);
+                const basename = environment.basename(filePath, ext);
+                usePath = environment.join(dir, `${basename}${globals_js_1.RefdesFileSuffix}`);
+                const output = tmpVisitor.getOutputForExternalRefdesFile();
+                const inputDir = environment.dirname(inputPath);
+                const relativeFilePath = environment.relative(inputDir, filePath);
+                const jsonFile = {
+                    format: 'v1',
+                    module: moduleName,
+                    file: relativeFilePath,
+                    items: output,
+                };
+                environment.writeFileSync(usePath, JSON.stringify(jsonFile, null, 4));
+            }
+            let display = 'Refdes annotations';
+            if (moduleName) {
+                display += ` for module ${moduleName}`;
+            }
+            console.log(`${display} saved to ${usePath}`);
         }
-        console.log('Annotations saved to ' + usePath);
-        (0, fs_1.writeFileSync)(usePath, refdesVisitor.getOutput());
     }
 }
+var RefdesOutputType;
+(function (RefdesOutputType) {
+    RefdesOutputType["None"] = "none";
+    RefdesOutputType["WithSource"] = "with-source";
+    RefdesOutputType["CreateExternalFile"] = "create-external-file";
+})(RefdesOutputType || (RefdesOutputType = {}));
 async function renderScript(scriptData, outputPath, options) {
     const parseHandlers = [
         new KiCadNetListOutputHandler(),
@@ -217,7 +277,9 @@ async function renderScriptCustom(scriptData, outputPath, options, parseHandlers
     environment.setCurrentFile(inputPath);
     const visitor = new visitor_js_1.ParserVisitor(true, onErrorHandler, environment);
     visitor.onImportFile = async (visitor, filePath, fileData) => {
-        const { hasError, hasParseError, throwError } = await (0, parser_js_1.parseFileWithVisitor)(visitor, fileData);
+        visitor.enterFile(filePath);
+        const { hasError, hasParseError, throwError, tree, tokens } = await (0, parser_js_1.parseFileWithVisitor)(visitor, fileData);
+        visitor.exitFile();
         if (hasError || hasParseError) {
             let importErrorMsg = "";
             if (throwError) {
@@ -225,7 +287,7 @@ async function renderScriptCustom(scriptData, outputPath, options, parseHandlers
             }
             throw new utils_js_1.ParseError(`Error parsing imported file: ${filePath}${importErrorMsg}`, undefined, undefined, filePath);
         }
-        return { hasError, hasParseError };
+        return { hasError, hasParseError, tree, tokens };
     };
     visitor.log('reading file');
     visitor.log('done reading file');
@@ -236,6 +298,9 @@ async function renderScriptCustom(scriptData, outputPath, options, parseHandlers
             (0, fs_1.mkdirSync)(dumpDirectory);
         }
     }
+    if (inputPath !== '') {
+        visitor.enterFile(inputPath);
+    }
     const { tree, parser, tokens, parserTimeTaken, lexerTimeTaken, throwError } = await (0, parser_js_1.parseFileWithVisitor)(visitor, scriptData);
     (0, utils_js_1.printWarnings)(visitor.getWarnings());
     showStats && console.log('Lexing took:', lexerTimeTaken);
@@ -247,8 +312,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());
     for (let i = 0; i < postAnnotationCallbacks.length; i++) {
-        await postAnnotationCallbacks[i](options, scriptData, tree, tokens, componentLinks);
+        await postAnnotationCallbacks[i](options, scriptData, tree, tokens, componentLinks, importedModules, environment);
     }
     if (dumpNets) {
         const nets = visitor.dumpNets();
@@ -307,6 +373,9 @@ async function renderScriptCustom(scriptData, outputPath, options, parseHandlers
                             console.log(`${(index + 1).toString().padStart(3)}. line ${item.start.line}, column ${item.start.column}: ${item.type} - ${item.message}`);
                         });
                     }
+                    else {
+                        console.log('No ERC issues found');
+                    }
                 }
             }
             catch (err) {

package/dist/cjs/layout.js

@@ -306,7 +306,8 @@ class LayoutEngine {
         const avoidAreas = [];
         if (frameParams.has(Frame_js_1.FrameParamKeys.SheetType)) {
             const frameComponent = frameParams.get(Frame_js_1.FrameParamKeys.SheetType);
-            const frameDrawing = frameComponent.displayProp;
+            const frameComponentUnit = frameComponent.getUnit();
+            const frameDrawing = frameComponentUnit.displayProp;
             frameDrawing.variables = (0, utils_js_1.combineMaps)(frameComponent.parameters, frameParams);
             const rects = ExtractDrawingRects(frameDrawing);
             const drawableRect = rects.find(rect => rect.className === 'plot-area');
@@ -565,7 +566,7 @@ class LayoutEngine {
                 accum.push(item);
             }
             else if (item instanceof RenderComponent) {
-                const { instanceName } = item.component;
+                const { instanceName } = item.component.getUnit(item.unitId);
                 if (ignoreItems.indexOf(instanceName) === -1) {
                     const withinSubgraph = subgraphInfo.find(subgraphInfo => {
                         return subgraphInfo.components.indexOf(instanceName) !== -1;
@@ -697,7 +698,9 @@ class LayoutEngine {
             const [, node1] = graph.node(firstNodeId);
             let defaultPin = new PinDefinition_js_1.PinId(1);
             if (node1 instanceof RenderComponent) {
-                defaultPin = node1.component.getDefaultPin();
+                const unitId = node1.unitId;
+                const componentUnit = node1.component.getUnit(unitId);
+                defaultPin = componentUnit.pinsFlat[0].id;
             }
             this.placeNodeAtPosition((0, ParamDefinition_js_1.numeric)(0), (0, ParamDefinition_js_1.numeric)(0), node1, defaultPin);
             return;
@@ -771,7 +774,8 @@ class LayoutEngine {
             }
             [node1, node2].forEach(item => {
                 if (item instanceof RenderWire && item.isEndAutoLength()) {
-                    const [instance, pin] = item.getEndAuto();
+                    const [component, pin] = item.getEndAuto();
+                    const instance = component.getUnitForPin(pin);
                     const [, targetNode] = graph.node(instance.instanceName);
                     this.print('wire', item, 'auto length to target:', instance, pin);
                     if (targetNode.isFloating) {
@@ -928,24 +932,43 @@ function getNeighbours(graph, nodeIds) {
         return accum;
     }, []);
 }
-function applyComponentParamsToSymbol(component, symbol) {
-    const { widthProp = null, heightProp = null } = component;
-    const newMap = new Map(component.parameters);
-    if (!newMap.has('refdes')) {
-        newMap.set('refdes', component.assignedRefDes ?? "?");
+function applyComponentParamsToSymbol(componentUnit, symbol) {
+    const { widthProp = null, heightProp = null } = componentUnit;
+    const newMap = new Map(componentUnit.parameters);
+    const ignoreParams = [
+        globals_js_1.ParamKeys.angle,
+        globals_js_1.ParamKeys.flip,
+        globals_js_1.ParamKeys.flipX,
+        globals_js_1.ParamKeys.flipY,
+    ];
+    const parentParams = componentUnit.parent.parameters;
+    parentParams.forEach((value, key) => {
+        if (ignoreParams.indexOf(key) === -1) {
+            newMap.set(key, value);
+        }
+    });
+    const refdesKey = 'refdes';
+    if (!newMap.has(refdesKey)) {
+        newMap.set(refdesKey, componentUnit.parent.assignedRefDes ?? "?");
+    }
+    if (componentUnit.refdesSuffix !== "") {
+        const tmpRefdes = newMap.get(refdesKey);
+        newMap.set(refdesKey, `${tmpRefdes}${componentUnit.refdesSuffix}`);
     }
     symbol.drawing.variables = newMap;
-    if (component.parameters.has(globals_js_1.ParamKeys.angle)) {
-        const value = component.parameters.get(globals_js_1.ParamKeys.angle).toNumber();
+    if (componentUnit.parameters.has(globals_js_1.ParamKeys.angle)) {
+        const value = componentUnit.parameters.get(globals_js_1.ParamKeys.angle).toNumber();
         symbol.angle = value;
     }
-    if (component.parameters.has(globals_js_1.ParamKeys.flipX)) {
+    if (componentUnit.parameters.has(globals_js_1.ParamKeys.flipX)) {
         symbol.flipX =
-            component.parameters.get(globals_js_1.ParamKeys.flipX);
+            componentUnit.parameters.get(globals_js_1.ParamKeys.flipX)
+                .toNumber();
     }
-    if (component.parameters.has(globals_js_1.ParamKeys.flipY)) {
+    if (componentUnit.parameters.has(globals_js_1.ParamKeys.flipY)) {
         symbol.flipY =
-            component.parameters.get(globals_js_1.ParamKeys.flipY);
+            componentUnit.parameters.get(globals_js_1.ParamKeys.flipY)
+                .toNumber();
     }
     if (symbol instanceof draw_symbols_js_1.SymbolCustom) {
         if (widthProp) {
@@ -1183,10 +1206,12 @@ class RenderWire extends RenderObject {
 }
 exports.RenderWire = RenderWire;
 class RenderComponent extends RenderObject {
-    constructor(component, width, height) {
+    constructor(component, unitId, width, height) {
         super();
+        this.unitId = globals_js_1.DefaultComponentUnit;
         this.displaySymbol = null;
         this.component = component;
+        this.unitId = unitId;
         this.width = width;
         this.height = height;
     }
@@ -1272,22 +1297,22 @@ class RenderJunction {
     }
 }
 exports.RenderJunction = RenderJunction;
-function CalculatePinPositions(component) {
+function CalculatePinPositions(unit) {
     const pinPositionMapping = new Map();
     let tmpSymbol;
-    if (component.displayProp !== null
-        && component.displayProp instanceof draw_symbols_js_1.SymbolDrawing) {
-        tmpSymbol = new draw_symbols_js_1.SymbolPlaceholder(component.displayProp);
+    if (unit.displayProp !== null
+        && unit.displayProp instanceof draw_symbols_js_1.SymbolDrawing) {
+        tmpSymbol = new draw_symbols_js_1.SymbolPlaceholder(unit.displayProp);
     }
     else {
-        const symbolPinDefinitions = (0, graph_js_1.generateLayoutPinDefinition)(component);
-        tmpSymbol = new draw_symbols_js_1.SymbolCustom(symbolPinDefinitions, component.pinsMaxPositions);
+        const symbolPinDefinitions = (0, graph_js_1.generateLayoutPinDefinition)(unit);
+        tmpSymbol = new draw_symbols_js_1.SymbolCustom(symbolPinDefinitions, unit.pinsMaxPositions);
     }
-    applyComponentParamsToSymbol(component, tmpSymbol);
+    applyComponentParamsToSymbol(unit, tmpSymbol);
     tmpSymbol.refreshDrawing();
-    const pins = component.pins;
+    const pins = unit.pins;
     pins.forEach((value, key) => {
-        if (component._unplacedPins.indexOf(key) === -1) {
+        if (unit._unplacedPins.indexOf(key) === -1) {
             pinPositionMapping.set(key, tmpSymbol.pinPosition(key));
         }
     });

package/dist/cjs/main.js

@@ -19,7 +19,6 @@ async function main() {
         .argument('[input path]', 'Input path')
         .argument('[output path]', 'Output path')
         .option('-i, --input text <input text>', 'Input text directly')
-        .option('-c, --current-directory <path>', 'Set current directory')
         .option('-u, --update-source', 'Update source file with refdes annotation')
         .option('-j, --annotated-path [file-path]', 'Save annotated source file at given path')
         .option('-w, --watch', 'Watch for file changes')
@@ -44,9 +43,6 @@ async function main() {
     const enableErc = options.erc;
     const enableBom = options.bom !== undefined;
     let bomOutputPath = options.bom;
-    if (options.currentDirectory) {
-        throw "Parameter not supported yet";
-    }
     if (watchFileChanges) {
         console.log('watching for file changes...');
     }
@@ -57,22 +53,20 @@ async function main() {
         return;
     }
     let scriptData;
-    if (args.length > 0 && args[0]) {
-        inputFilePath = args[0];
-        if ((await env.exists(inputFilePath))) {
-            scriptData = await env.readFile(inputFilePath, { encoding: 'utf-8' });
-        }
-        else {
-            console.error("Error: File could not be found");
-            return;
-        }
-    }
-    else if (options.input) {
+    if (options.input) {
         scriptData = options.input;
     }
     else {
-        console.error("Error: No input provided");
-        return;
+        if (args.length > 0 && args[0]) {
+            inputFilePath = args[0];
+            if ((await env.exists(inputFilePath))) {
+                scriptData = await env.readFile(inputFilePath, { encoding: 'utf-8' });
+            }
+            else {
+                console.error("Error: File could not be found");
+                return;
+            }
+        }
     }
     let updateSource = false;
     if (options.updateSource !== undefined) {
@@ -103,7 +97,10 @@ async function main() {
         saveAnnotatedCopy: saveAnnotatedCopyPath,
     };
     let outputPath = null;
-    if (args.length > 0 && args[1]) {
+    if (options.input && args.length > 0 && args[0]) {
+        outputPath = args[0];
+    }
+    else if (args.length > 0 && args[1]) {
         outputPath = args[1];
     }
     const output = await parseFile(scriptData, outputPath, scriptOptions);
@@ -133,6 +130,7 @@ async function parseFile(scriptData, outputPath, scriptOptions) {
     }
     catch (error) {
         console.error(`Unexpected Error: ${error}`);
+        console.log(error.stack);
     }
     return null;
 }

package/dist/cjs/objects/ClassComponent.js

@@ -1,36 +1,153 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ModuleComponent = exports.ClassComponent = void 0;
+exports.ModuleComponent = exports.ClassComponent = exports.ComponentUnit = void 0;
 const draw_symbols_js_1 = require("../draw_symbols.js");
 const PinDefinition_js_1 = require("./PinDefinition.js");
 const PinTypes_js_1 = require("./PinTypes.js");
 const globals_js_1 = require("../globals.js");
 const utils_js_1 = require("../utils.js");
-class ClassComponent {
-    constructor(instanceName, numPins) {
+class ComponentUnit {
+    get instanceName() {
+        return `${this.parent.instanceName},${this.unitId}`;
+    }
+    constructor(unitId, parent) {
+        this.refdesSuffix = "A";
+        this.suffix = null;
         this.parameters = new Map();
         this.pins = new Map();
-        this.pinNets = new Map();
-        this.pinWires = new Map();
+        this.pinsFlat = [];
         this.pinsMaxPositions = new Map();
-        this._copyID = null;
-        this._copyFrom = null;
-        this._unplacedPins = [];
         this.arrangeProps = null;
         this.displayProp = null;
         this.widthProp = null;
         this.heightProp = null;
-        this.typeProp = null;
-        this.copyProp = false;
         this.angleProp = 0;
         this.followWireOrientationProp = true;
         this.wireOrientationAngle = 0;
         this.useWireOrientationAngle = true;
         this.didSetWireOrientationAngle = false;
+        this._unplacedPins = [];
+        this.unitId = unitId;
+        this.parent = parent;
+    }
+    clone() {
+        const unit = new ComponentUnit(this.unitId, this.parent);
+        unit.numPins = this.numPins;
+        unit.angleProp = this.angleProp;
+        unit.widthProp = this.widthProp;
+        unit.heightProp = this.heightProp;
+        if (this.displayProp instanceof draw_symbols_js_1.SymbolDrawingCommands) {
+            unit.displayProp = this.displayProp.clone();
+        }
+        if (this.arrangeProps !== null) {
+            unit.arrangeProps = new Map(this.arrangeProps);
+        }
+        for (const [key, value] of this.pins) {
+            unit.pins.set(key, value);
+        }
+        unit.pinsFlat = [...this.pinsFlat];
+        for (const [key, value] of this.pinsMaxPositions) {
+            unit.pinsMaxPositions.set(key, value);
+        }
+        unit._unplacedPins = [...this._unplacedPins];
+        unit.followWireOrientationProp = this.followWireOrientationProp;
+        unit.wireOrientationAngle = this.wireOrientationAngle;
+        unit.useWireOrientationAngle = this.useWireOrientationAngle;
+        unit.didSetWireOrientationAngle = this.didSetWireOrientationAngle;
+        return unit;
+    }
+    setParam(key, value) {
+        this.parameters.set(key, value);
+    }
+    isEqual(other) {
+        if (this === other)
+            return true;
+        if (this.unitId !== other.unitId)
+            return false;
+        if (this.numPins !== other.numPins)
+            return false;
+        if (this.angleProp !== other.angleProp)
+            return false;
+        if (this.widthProp !== other.widthProp)
+            return false;
+        if (this.heightProp !== other.heightProp)
+            return false;
+        if (this.followWireOrientationProp !== other.followWireOrientationProp)
+            return false;
+        if (this.wireOrientationAngle !== other.wireOrientationAngle)
+            return false;
+        if (this.useWireOrientationAngle !== other.useWireOrientationAngle)
+            return false;
+        if (this.didSetWireOrientationAngle !== other.didSetWireOrientationAngle)
+            return false;
+        if (this.displayProp === null && other.displayProp !== null)
+            return false;
+        if (this.displayProp !== null && other.displayProp === null)
+            return false;
+        if (this.displayProp !== null && other.displayProp !== null && !this.displayProp.eq(other.displayProp))
+            return false;
+        if (this.arrangeProps === null && other.arrangeProps !== null)
+            return false;
+        if (this.arrangeProps !== null && other.arrangeProps === null)
+            return false;
+        if (this.arrangeProps !== null && other.arrangeProps !== null) {
+            if (this.arrangeProps.size !== other.arrangeProps.size)
+                return false;
+            for (const [key, value] of this.arrangeProps) {
+                const otherValue = other.arrangeProps.get(key);
+                if (!otherValue || value.length !== otherValue.length)
+                    return false;
+                for (let i = 0; i < value.length; i++) {
+                    if (!value[i].equals(otherValue[i]))
+                        return false;
+                }
+            }
+        }
+        if (this.parameters.size !== other.parameters.size)
+            return false;
+        for (const [key, value] of this.parameters) {
+            if (!other.parameters.has(key) || other.parameters.get(key) !== value)
+                return false;
+        }
+        if (this.pins.size !== other.pins.size)
+            return false;
+        for (const [key, value] of this.pins) {
+            let found = false;
+            for (const [otherKey, otherValue] of other.pins) {
+                if (key.equals(otherKey) && value === otherValue) {
+                    found = true;
+                    break;
+                }
+            }
+            if (!found)
+                return false;
+        }
+        if (this.parent !== other.parent) {
+            return false;
+        }
+        return true;
+    }
+}
+exports.ComponentUnit = ComponentUnit;
+class ClassComponent {
+    constructor(instanceName, numPins) {
+        this.parameters = new Map();
+        this.pins = new Map();
+        this.pinNets = new Map();
+        this.pinWires = new Map();
+        this.pinsMaxPositions = new Map();
+        this.units = [];
+        this._copyID = null;
+        this._copyFrom = null;
+        this._unplacedPins = [];
+        this.typeProp = null;
+        this.copyProp = false;
         this.assignedRefDes = null;
         this.placeHolderRefDes = null;
+        this.forceSaveRefdesAnnotation = false;
         this.ctxReferences = [];
         this._creationIndex = -1;
+        this.pinUnitMap = new Map();
         this.instanceName = instanceName;
         this.numPins = numPins;
     }
@@ -121,31 +238,32 @@ class ClassComponent {
         return component;
     }
     isEqual(other) {
-        return this.instanceName === other.instanceName
-            && this.numPins === other.numPins
-            && this._copyID === other._copyID
-            && this.arrangeProps === other.arrangeProps
-            && ((this.displayProp === null && other.displayProp === null)
-                ||
-                    (this.displayProp !== null && other.displayProp !== null && this.displayProp.eq(other.displayProp)))
-            && this.widthProp === other.widthProp
-            && this.typeProp === other.typeProp
-            && this._cachedPins === other._cachedPins
-            && this._cachedParams === other._cachedParams;
+        if (this === other)
+            return true;
+        if (this.instanceName !== other.instanceName)
+            return false;
+        if (this._copyID !== other._copyID)
+            return false;
+        if (this.typeProp !== other.typeProp)
+            return false;
+        if (this._cachedPins !== other._cachedPins)
+            return false;
+        if (this._cachedParams !== other._cachedParams)
+            return false;
+        for (let i = 0; i < this.units.length; i++) {
+            if (other.units[i] === undefined) {
+                return false;
+            }
+            if (!other.units[i].isEqual(this.units[i])) {
+                return false;
+            }
+        }
+        return true;
     }
     clone() {
         const component = new ClassComponent(this.instanceName, this.numPins);
         component._copyID = this._copyID;
-        component.arrangeProps = this.arrangeProps;
-        component.widthProp = this.widthProp;
         component.typeProp = this.typeProp;
-        component.angleProp = this.angleProp;
-        component.followWireOrientationProp = this.followWireOrientationProp;
-        component.useWireOrientationAngle = this.useWireOrientationAngle;
-        if (this.displayProp instanceof draw_symbols_js_1.SymbolDrawingCommands) {
-            component.displayProp =
-                this.displayProp.clone();
-        }
         for (const [key, value] of this.parameters) {
             if (key === globals_js_1.ParamKeys.flipX || key === globals_js_1.ParamKeys.flipY || key === globals_js_1.ParamKeys.angle) {
                 continue;
@@ -158,9 +276,60 @@ class ClassComponent {
         for (const [key, value] of this.pinsMaxPositions) {
             component.pinsMaxPositions.set(key, value);
         }
+        component.units = this.units.map(unit => {
+            const tmpUnit = unit.clone();
+            tmpUnit.parent = component;
+            return tmpUnit;
+        });
         component.refreshCache();
+        component.refreshPinUnitMap();
         return component;
     }
+    getUnit(unitId = null) {
+        if (unitId === null) {
+            return this.units[0];
+        }
+        else {
+            return this.units.find(item => {
+                return item.unitId === unitId;
+            });
+        }
+    }
+    addDefaultUnit(displayProp) {
+        const tmpUnit = new ComponentUnit(globals_js_1.DefaultComponentUnit, this);
+        tmpUnit.pins = this.pins;
+        const pinsFlat = [];
+        this.pins.forEach(pin => {
+            pinsFlat.push(pin);
+        });
+        tmpUnit.pinsFlat = pinsFlat;
+        tmpUnit.numPins = this.numPins;
+        tmpUnit.pinsMaxPositions = new Map();
+        tmpUnit.displayProp = displayProp;
+        tmpUnit.angleProp = 0;
+        tmpUnit.followWireOrientationProp = true;
+        this.units.push(tmpUnit);
+        this.refreshPinUnitMap();
+    }
+    refreshPinUnitMap() {
+        for (const unit of this.units) {
+            const { pinsFlat } = unit;
+            for (const pin of pinsFlat) {
+                this.pinUnitMap.set(pin.id, unit);
+            }
+        }
+    }
+    getUnitForPin(pinId) {
+        if (typeof pinId === "number") {
+            throw new utils_js_1.RuntimeExecutionError("Invalid pin id");
+        }
+        for (const [tmpPin, componentUnit] of this.pinUnitMap) {
+            if (tmpPin.equals(pinId)) {
+                return componentUnit;
+            }
+        }
+        throw new utils_js_1.RuntimeExecutionError("Could not find unit for pin: " + pinId);
+    }
 }
 exports.ClassComponent = ClassComponent;
 class ModuleComponent extends ClassComponent {

package/dist/cjs/objects/types.js

@@ -128,10 +128,14 @@ var NetTypes;
     NetTypes["Source"] = "source";
 })(NetTypes || (exports.NetTypes = NetTypes = {}));
 class ImportedModule {
-    constructor(moduleName, moduleNamespace, moduleFilePath, context, flag, specifiedImports) {
+    constructor(moduleName, moduleNamespace, moduleFilePath, tree, tokens, context, flag, specifiedImports) {
+        this.enableRefdesAnnotation = false;
+        this.enableRefdesAnnotationFile = false;
         this.moduleName = moduleName;
         this.moduleNamespace = moduleNamespace;
         this.moduleFilePath = moduleFilePath;
+        this.tree = tree;
+        this.tokens = tokens;
         this.context = context;
         this.importHandlingFlag = flag;
         this.specifiedImports = specifiedImports;