circuitscript 0.1.31 → 0.1.33

package/dist/esm/helpers.js

@@ -13,7 +13,7 @@ import { BaseErrorListener, CharStream, CommonTokenStream, DefaultErrorStrategy,
 import { MainLexer } from "./lexer.js";
 import { CircuitScriptParser } from "./antlr/CircuitScriptParser.js";
 import { prepareTokens, SemanticTokensVisitor } from "./SemanticTokenVisitor.js";
-import { defaultPageMarginMM, defaultZoomScale, LengthUnit, MilsToMM, PxToMM } from "./globals.js";
+import { defaultPageMarginMM, defaultZoomScale, LengthUnit, MilsToMM, PxToMM, RefdesFileSuffix } from "./globals.js";
 import { FrameParamKeys } from "./objects/Frame.js";
 import Big from "big.js";
 import { Logger } from "./logger.js";
@@ -150,25 +150,85 @@ export async function validateScript(filePath, scriptData, options) {
     await visitorResolver.visitAsync(tree);
     return visitorResolver;
 }
-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(true, scriptData, tokens, componentLinks);
-        await refdesVisitor.visitAsync(tree);
-        let usePath = inputPath;
-        if (saveAnnotatedCopy === true) {
-            const dir = path.dirname(inputPath);
-            const ext = path.extname(inputPath);
-            const basename = path.basename(inputPath, ext);
-            usePath = path.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(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}${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);
-        writeFileSync(usePath, refdesVisitor.getOutput());
     }
 }
+var RefdesOutputType;
+(function (RefdesOutputType) {
+    RefdesOutputType["None"] = "none";
+    RefdesOutputType["WithSource"] = "with-source";
+    RefdesOutputType["CreateExternalFile"] = "create-external-file";
+})(RefdesOutputType || (RefdesOutputType = {}));
 export async function renderScript(scriptData, outputPath, options) {
     const parseHandlers = [
         new KiCadNetListOutputHandler(),
@@ -206,7 +266,9 @@ export async function renderScriptCustom(scriptData, outputPath, options, parseH
     environment.setCurrentFile(inputPath);
     const visitor = new ParserVisitor(true, onErrorHandler, environment);
     visitor.onImportFile = async (visitor, filePath, fileData) => {
-        const { hasError, hasParseError, throwError } = await parseFileWithVisitor(visitor, fileData);
+        visitor.enterFile(filePath);
+        const { hasError, hasParseError, throwError, tree, tokens } = await parseFileWithVisitor(visitor, fileData);
+        visitor.exitFile();
         if (hasError || hasParseError) {
             let importErrorMsg = "";
             if (throwError) {
@@ -214,7 +276,7 @@ export async function renderScriptCustom(scriptData, outputPath, options, parseH
             }
             throw new 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');
@@ -225,6 +287,9 @@ export async function renderScriptCustom(scriptData, outputPath, options, parseH
             mkdirSync(dumpDirectory);
         }
     }
+    if (inputPath !== '') {
+        visitor.enterFile(inputPath);
+    }
     const { tree, parser, tokens, parserTimeTaken, lexerTimeTaken, throwError } = await parseFileWithVisitor(visitor, scriptData);
     printWarnings(visitor.getWarnings());
     showStats && console.log('Lexing took:', lexerTimeTaken);
@@ -236,8 +301,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());
     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();
@@ -296,6 +362,9 @@ export async function renderScriptCustom(scriptData, outputPath, options, parseH
                             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/esm/layout.js

@@ -1,7 +1,7 @@
 import graphlib from '@dagrejs/graphlib';
 const { alg } = graphlib;
 import { SymbolCustom, SymbolDrawing, SymbolPlaceholder, SymbolText, PlaceHolderCommands } from "./draw_symbols.js";
-import { defaultFrameTitleTextSize, defaultGridSizeUnits, FrameType, NetGraphicsParams, ParamKeys, WireAutoDirection } from './globals.js';
+import { DefaultComponentUnit, defaultFrameTitleTextSize, defaultGridSizeUnits, FrameType, NetGraphicsParams, ParamKeys, WireAutoDirection } from './globals.js';
 import { Geometry, HorizontalAlign, VerticalAlign } from './geometry.js';
 import { FixedFrameIds, Frame, FrameParamKeys, FramePlotDirection } from './objects/Frame.js';
 import { areasOverlap, combineMaps, getBoundsSize, printBounds, resizeBounds, resizeToNearestGrid, roundValue, toNearestGrid } from './utils.js';
@@ -301,7 +301,8 @@ export class LayoutEngine {
         const avoidAreas = [];
         if (frameParams.has(FrameParamKeys.SheetType)) {
             const frameComponent = frameParams.get(FrameParamKeys.SheetType);
-            const frameDrawing = frameComponent.displayProp;
+            const frameComponentUnit = frameComponent.getUnit();
+            const frameDrawing = frameComponentUnit.displayProp;
             frameDrawing.variables = combineMaps(frameComponent.parameters, frameParams);
             const rects = ExtractDrawingRects(frameDrawing);
             const drawableRect = rects.find(rect => rect.className === 'plot-area');
@@ -560,7 +561,7 @@ export 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;
@@ -692,7 +693,9 @@ export class LayoutEngine {
             const [, node1] = graph.node(firstNodeId);
             let defaultPin = new 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(numeric(0), numeric(0), node1, defaultPin);
             return;
@@ -766,7 +769,8 @@ export 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) {
@@ -922,24 +926,43 @@ function getNeighbours(graph, nodeIds) {
         return accum;
     }, []);
 }
-export 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 ?? "?");
+export function applyComponentParamsToSymbol(componentUnit, symbol) {
+    const { widthProp = null, heightProp = null } = componentUnit;
+    const newMap = new Map(componentUnit.parameters);
+    const ignoreParams = [
+        ParamKeys.angle,
+        ParamKeys.flip,
+        ParamKeys.flipX,
+        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(ParamKeys.angle)) {
-        const value = component.parameters.get(ParamKeys.angle).toNumber();
+    if (componentUnit.parameters.has(ParamKeys.angle)) {
+        const value = componentUnit.parameters.get(ParamKeys.angle).toNumber();
         symbol.angle = value;
     }
-    if (component.parameters.has(ParamKeys.flipX)) {
+    if (componentUnit.parameters.has(ParamKeys.flipX)) {
         symbol.flipX =
-            component.parameters.get(ParamKeys.flipX);
+            componentUnit.parameters.get(ParamKeys.flipX)
+                .toNumber();
     }
-    if (component.parameters.has(ParamKeys.flipY)) {
+    if (componentUnit.parameters.has(ParamKeys.flipY)) {
         symbol.flipY =
-            component.parameters.get(ParamKeys.flipY);
+            componentUnit.parameters.get(ParamKeys.flipY)
+                .toNumber();
     }
     if (symbol instanceof SymbolCustom) {
         if (widthProp) {
@@ -1176,13 +1199,15 @@ export class RenderWire extends RenderObject {
 }
 export class RenderComponent extends RenderObject {
     component;
+    unitId = DefaultComponentUnit;
     symbol;
     width;
     height;
     displaySymbol = null;
-    constructor(component, width, height) {
+    constructor(component, unitId, width, height) {
         super();
         this.component = component;
+        this.unitId = unitId;
         this.width = width;
         this.height = height;
     }
@@ -1271,22 +1296,22 @@ export class RenderJunction {
         this.net = net;
     }
 }
-export function CalculatePinPositions(component) {
+export function CalculatePinPositions(unit) {
     const pinPositionMapping = new Map();
     let tmpSymbol;
-    if (component.displayProp !== null
-        && component.displayProp instanceof SymbolDrawing) {
-        tmpSymbol = new SymbolPlaceholder(component.displayProp);
+    if (unit.displayProp !== null
+        && unit.displayProp instanceof SymbolDrawing) {
+        tmpSymbol = new SymbolPlaceholder(unit.displayProp);
     }
     else {
-        const symbolPinDefinitions = generateLayoutPinDefinition(component);
-        tmpSymbol = new SymbolCustom(symbolPinDefinitions, component.pinsMaxPositions);
+        const symbolPinDefinitions = generateLayoutPinDefinition(unit);
+        tmpSymbol = new 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/esm/main.js

@@ -14,7 +14,6 @@ export default 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')
@@ -39,9 +38,6 @@ export default 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...');
     }
@@ -52,22 +48,20 @@ export default 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) {
@@ -98,7 +92,10 @@ export default 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);
@@ -127,6 +124,7 @@ async function parseFile(scriptData, outputPath, scriptOptions) {
     }
     catch (error) {
         console.error(`Unexpected Error: ${error}`);
+        console.log(error.stack);
     }
     return null;
 }

package/dist/esm/objects/ClassComponent.js

@@ -1,8 +1,133 @@
 import { SymbolDrawingCommands } from '../draw_symbols.js';
 import { PinDefinition, PinId, PinIdType } from './PinDefinition.js';
 import { PinTypes } from './PinTypes.js';
-import { ParamKeys } from '../globals.js';
+import { DefaultComponentUnit, ParamKeys } from '../globals.js';
 import { RuntimeExecutionError } from '../utils.js';
+export class ComponentUnit {
+    parent;
+    unitId;
+    refdesSuffix = "A";
+    suffix = null;
+    get instanceName() {
+        return `${this.parent.instanceName},${this.unitId}`;
+    }
+    parameters = new Map();
+    numPins;
+    pins = new Map();
+    pinsFlat = [];
+    pinsMaxPositions = new Map();
+    arrangeProps = null;
+    displayProp = null;
+    widthProp = null;
+    heightProp = null;
+    angleProp = 0;
+    followWireOrientationProp = true;
+    wireOrientationAngle = 0;
+    useWireOrientationAngle = true;
+    didSetWireOrientationAngle = false;
+    _unplacedPins = [];
+    constructor(unitId, parent) {
+        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 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;
+    }
+}
 export class ClassComponent {
     instanceName;
     numPins;
@@ -11,27 +136,21 @@ export class ClassComponent {
     pinNets = new Map();
     pinWires = new Map();
     pinsMaxPositions = new Map();
+    units = [];
     _cachedPins;
     _cachedParams;
     _copyID = null;
     _copyFrom = null;
     _pointLinkComponent;
     _unplacedPins = [];
-    arrangeProps = null;
-    displayProp = null;
-    widthProp = null;
-    heightProp = null;
     typeProp = null;
     copyProp = false;
-    angleProp = 0;
-    followWireOrientationProp = true;
-    wireOrientationAngle = 0;
-    useWireOrientationAngle = true;
-    didSetWireOrientationAngle = false;
     assignedRefDes = null;
     placeHolderRefDes = null;
+    forceSaveRefdesAnnotation = false;
     ctxReferences = [];
     _creationIndex = -1;
+    pinUnitMap = new Map();
     constructor(instanceName, numPins) {
         this.instanceName = instanceName;
         this.numPins = numPins;
@@ -123,31 +242,32 @@ export 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 SymbolDrawingCommands) {
-            component.displayProp =
-                this.displayProp.clone();
-        }
         for (const [key, value] of this.parameters) {
             if (key === ParamKeys.flipX || key === ParamKeys.flipY || key === ParamKeys.angle) {
                 continue;
@@ -160,9 +280,60 @@ export 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(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 RuntimeExecutionError("Invalid pin id");
+        }
+        for (const [tmpPin, componentUnit] of this.pinUnitMap) {
+            if (tmpPin.equals(pinId)) {
+                return componentUnit;
+            }
+        }
+        throw new RuntimeExecutionError("Could not find unit for pin: " + pinId);
+    }
 }
 export class ModuleComponent extends ClassComponent {
     moduleContainsExpressions;

package/dist/esm/objects/types.js

@@ -135,10 +135,16 @@ export class ImportedModule {
     specifiedImports;
     moduleNamespace;
     moduleFilePath;
-    constructor(moduleName, moduleNamespace, moduleFilePath, context, flag, specifiedImports) {
+    enableRefdesAnnotation = false;
+    enableRefdesAnnotationFile = false;
+    tree;
+    tokens;
+    constructor(moduleName, moduleNamespace, moduleFilePath, tree, tokens, context, flag, specifiedImports) {
         this.moduleName = moduleName;
         this.moduleNamespace = moduleNamespace;
         this.moduleFilePath = moduleFilePath;
+        this.tree = tree;
+        this.tokens = tokens;
         this.context = context;
         this.importHandlingFlag = flag;
         this.specifiedImports = specifiedImports;