circuitscript 0.1.31 → 0.1.33

package/dist/esm/antlr/CircuitScriptVisitor.js

@@ -75,6 +75,7 @@ export class CircuitScriptVisitor extends AbstractParseTreeVisitor {
     visitImport_simple;
     visitImport_all_simple;
     visitImport_specific;
+    visitImport_annotation_expr;
     visitFrame_expr;
     visitIf_expr;
     visitIf_inner_expr;

package/dist/esm/draw_symbols.js

@@ -133,7 +133,7 @@ export class SymbolGraphic {
     }
     drawLabels(group) {
         const labels = this.drawing.getLabels();
-        labels.forEach(label => {
+        for (const label of labels) {
             const tmpLabel = label;
             const { fontSize = numeric(50), anchor = HorizontalAlign.Left, vanchor = VerticalAlign.Bottom, fontWeight = 'regular', angle: tmpLabelAngle = numeric(0), textColor = "#333", } = tmpLabel.style ?? {};
             const labelAngle = tmpLabelAngle.toNumber();
@@ -146,31 +146,35 @@ export class SymbolGraphic {
                 useAnchor = this.flipTextAnchor(anchor);
                 useDominantBaseline = this.flipDominantBaseline(vanchor);
             }
-            switch (useAnchor) {
-                case HorizontalAlign.Left:
-                    anchorStyle = (this.flipX === 0)
-                        ? HorizontalAlignProp.Start : HorizontalAlignProp.End;
-                    break;
-                case HorizontalAlign.Middle:
-                    anchorStyle = HorizontalAlignProp.Middle;
-                    break;
-                case HorizontalAlign.Right:
-                    anchorStyle = (this.flipX === 0)
-                        ? HorizontalAlignProp.End : HorizontalAlignProp.Start;
-                    break;
+            const isHorizontalLabel = labelAngle === 0 || labelAngle === 180;
+            const isVerticalLabel = labelAngle === 90 || labelAngle === -90;
+            if (useAnchor === HorizontalAlign.Middle) {
+                anchorStyle = HorizontalAlignProp.Middle;
             }
-            switch (useDominantBaseline) {
-                case VerticalAlign.Top:
-                    dominantBaseline = (this.flipY === 0)
-                        ? VerticalAlignProp.Hanging : VerticalAlignProp.TextTop;
-                    break;
-                case VerticalAlign.Middle:
-                    dominantBaseline = VerticalAlignProp.Central;
-                    break;
-                case VerticalAlign.Bottom:
-                    dominantBaseline = (this.flipY === 0)
-                        ? VerticalAlignProp.TextTop : VerticalAlignProp.Hanging;
-                    break;
+            else if (useAnchor === HorizontalAlign.Left) {
+                anchorStyle = HorizontalAlignProp.Start;
+            }
+            else if (useAnchor === HorizontalAlign.Right) {
+                anchorStyle = HorizontalAlignProp.End;
+            }
+            if (useDominantBaseline === VerticalAlign.Middle) {
+                dominantBaseline = VerticalAlignProp.Central;
+            }
+            else if (useDominantBaseline === VerticalAlign.Top) {
+                dominantBaseline = VerticalAlignProp.Hanging;
+            }
+            else if (useDominantBaseline === VerticalAlign.Bottom) {
+                dominantBaseline = VerticalAlignProp.TextTop;
+            }
+            if (anchorStyle !== HorizontalAlignProp.Middle &&
+                ((isHorizontalLabel && this.flipX === 1) || (isVerticalLabel && this.flipY === 1))) {
+                anchorStyle = (anchorStyle === HorizontalAlignProp.Start)
+                    ? HorizontalAlignProp.End : HorizontalAlignProp.Start;
+            }
+            if (dominantBaseline !== VerticalAlignProp.Central &&
+                ((isHorizontalLabel && this.flipY === 1) || (isVerticalLabel && this.flipX === 1))) {
+                dominantBaseline = (dominantBaseline === VerticalAlignProp.Hanging)
+                    ? VerticalAlignProp.TextTop : VerticalAlignProp.Hanging;
             }
             const position = tmpLabel.getLabelPosition();
             if (this.flipX !== 0) {
@@ -314,7 +318,7 @@ export class SymbolGraphic {
                     .translate(-originSize / 2, -originSize / 2)
                     .fill('green');
             }
-        });
+        }
     }
     flipTextAnchor(value) {
         if (value === HorizontalAlign.Left) {
@@ -709,7 +713,7 @@ export class SymbolCustom extends SymbolGraphic {
         const pinStartY = bodyHeightMM.neg().half();
         const pinStartX = bodyWidthMM.neg().half();
         const tmpPinSpacing = this.pinSpacing.toNumber();
-        leftPins.forEach(pin => {
+        for (const pin of leftPins) {
             const position = pin.position;
             const pinY = pinStartY.add((position + 1) * tmpPinSpacing);
             drawing.addPinMM(pin.pinId, leftPinStart.sub(this.pinLength), pinY, leftPinStart, pinY, defaultLineColor);
@@ -725,8 +729,8 @@ export class SymbolCustom extends SymbolGraphic {
                 vanchor: VerticalAlign.Bottom,
                 textColor: defaultLineColor
             });
-        });
-        rightPins.forEach(pin => {
+        }
+        for (const pin of rightPins) {
             const position = pin.position;
             const pinY = pinStartY.add((position + 1) * tmpPinSpacing);
             drawing.addPinMM(pin.pinId, rightPinStart.add(this.pinLength), pinY, rightPinStart, pinY, defaultLineColor);
@@ -742,8 +746,8 @@ export class SymbolCustom extends SymbolGraphic {
                 vanchor: VerticalAlign.Bottom,
                 textColor: defaultLineColor
             });
-        });
-        topPins.forEach(pin => {
+        }
+        for (const pin of topPins) {
             const position = pin.position;
             const pinX = pinStartX.add((position + 1) * tmpPinSpacing);
             drawing.addPinMM(pin.pinId, pinX, topPinStart.sub(this.pinLength), pinX, topPinStart, defaultLineColor);
@@ -761,8 +765,8 @@ export class SymbolCustom extends SymbolGraphic {
                 textColor: defaultLineColor,
                 angle: numeric(-90),
             });
-        });
-        bottomPins.forEach(pin => {
+        }
+        for (const pin of bottomPins) {
             const position = pin.position;
             const pinX = pinStartX.add((position + 1) * tmpPinSpacing);
             drawing.addPinMM(pin.pinId, pinX, bottomPinStart.add(this.pinLength), pinX, bottomPinStart, defaultLineColor);
@@ -780,7 +784,7 @@ export class SymbolCustom extends SymbolGraphic {
                 textColor: defaultLineColor,
                 angle: numeric(-90)
             });
-        });
+        }
         const instanceName = drawing.variables.get('refdes');
         instanceName && drawing.addLabel(bodyWidthMM.neg().half(), bodyHeightMM.neg().half().sub(milsToMM(20)), instanceName, {
             fontSize: numeric(CustomSymbolRefDesSize),

package/dist/esm/environment.js

@@ -1,4 +1,5 @@
 import { registerWindow, SVG } from "@svgdotjs/svg.js";
+import { writeFileSync } from "fs";
 import fs from 'fs';
 import path from "path";
 import CryptoJs from "crypto-js";
@@ -112,8 +113,12 @@ export class NodeScriptEnvironment {
         return this.prepareSVGEnvironmentInternal(this.getFontsPath());
     }
     async readFile(path, options) {
+        options = options ?? { encoding: 'utf8' };
         return fs.promises.readFile(path, options);
     }
+    writeFileSync(path, data) {
+        return writeFileSync(path, data);
+    }
     getAbsolutePath(filePath) {
         return path.resolve(filePath);
     }
@@ -132,7 +137,7 @@ export class NodeScriptEnvironment {
     }
     async exists(path) {
         try {
-            fs.promises.access(path, fs.constants.F_OK);
+            await fs.promises.access(path, fs.constants.F_OK);
             return true;
         }
         catch (err) {
@@ -142,4 +147,19 @@ export class NodeScriptEnvironment {
     hashStringSHA256(value) {
         return CryptoJs.SHA256(value).toString();
     }
+    dirname(filePath) {
+        return path.dirname(filePath);
+    }
+    extname(filePath) {
+        return path.extname(filePath);
+    }
+    basename(filePath, ext) {
+        return path.basename(filePath, ext);
+    }
+    join(...paths) {
+        return path.join(...paths);
+    }
+    relative(from, to) {
+        return path.relative(from, to);
+    }
 }

package/dist/esm/execute.js

@@ -1,5 +1,5 @@
 import { BlockTypes, ComponentTypes, Delimiter1, GlobalNames, NoNetText, ParamKeys, ReferenceTypes, SymbolPinSide } from './globals.js';
-import { ClassComponent, ModuleComponent } from './objects/ClassComponent.js';
+import { ClassComponent, ComponentUnit, ModuleComponent } from './objects/ClassComponent.js';
 import { ActiveObject, ExecutionScope, FrameAction, SequenceAction } from './objects/ExecutionScope.js';
 import { Net } from './objects/Net.js';
 import { numeric, NumericValue } from './objects/ParamDefinition.js';
@@ -65,7 +65,7 @@ export class ExecutionContext {
     setupRoot() {
         const componentRoot = ClassComponent.simple(GlobalNames.__root, 1);
         componentRoot.typeProp = ComponentTypes.net;
-        componentRoot.displayProp = this.getPointSymbol();
+        componentRoot.addDefaultUnit(this.getPointSymbol());
         this.scope.instances.set(GlobalNames.__root, componentRoot);
         this.scope.setCurrent(componentRoot);
         this.scope.componentRoot = componentRoot;
@@ -131,49 +131,13 @@ export class ExecutionContext {
     }
     createComponent(instanceName, pins, params, props, isModule = false) {
         const className = isModule ? ModuleComponent : ClassComponent;
+        pins = this.extractPinsFromUnits(props.units);
         const component = new className(instanceName, pins.length);
         pins.forEach((pin) => {
             component.pins.set(pin.id, pin);
         });
-        component.displayProp = props.display ?? null;
-        component.widthProp = props.width ?? null;
-        component.heightProp = props.height ?? null;
         component.typeProp = props.type ?? null;
         component.copyProp = props.copy ?? false;
-        let useAngle = null;
-        if (props.angle) {
-            useAngle = props.angle.toNumber() % 360;
-            if (useAngle < 0) {
-                useAngle += 360;
-            }
-        }
-        if (props.display === null && props.arrange === null) {
-            const tmpArrangeLeft = [];
-            const tmpArrangeRight = [];
-            pins.forEach((pin, index) => {
-                const useArray = (index % 2 === 0) ? tmpArrangeLeft : tmpArrangeRight;
-                useArray.push(pin.id);
-            });
-            const arrangeProp = new Map([
-                [SymbolPinSide.Left, tmpArrangeLeft],
-                [SymbolPinSide.Right, tmpArrangeRight]
-            ]);
-            props.arrange = arrangeProp;
-        }
-        if (props.arrange !== null) {
-            component.arrangeProps = this.removeArrangePropDuplicates(props.arrange);
-            const arrangePropPins = this.getArrangePropPins(component.arrangeProps);
-            pins.forEach(pin => {
-                if (arrangePropPins.find(id => id.equals(pin.id)) === undefined) {
-                    this.logWarning(`Pin ${pin.id} is not specified in arrange property`);
-                }
-            });
-        }
-        else {
-            component.arrangeProps = null;
-        }
-        component.angleProp = useAngle ?? 0;
-        component.followWireOrientationProp = props.followWireOrientation;
         const paramsMap = new Map();
         params.forEach((param) => {
             component.parameters.set(param.paramName, param.paramValue);
@@ -200,27 +164,91 @@ export class ExecutionContext {
             this.scope.setNet(component, defaultPin, tmpNet);
             this.log('set net', netName, 'component', component, defaultPin);
         }
-        const { pins: pinSides, maxPositions } = getPortSide(component.pins, component.arrangeProps);
-        component.pinsMaxPositions = maxPositions;
-        const pinIdKeys = Array.from(component.pins.keys());
-        pinSides.forEach(({ pinId, side, position }) => {
-            const matchedPinId = pinIdKeys.find(id => id.equals(pinId));
-            if (matchedPinId) {
-                const tmpPin = component.pins.get(matchedPinId);
-                tmpPin.side = side;
-                tmpPin.position = position;
-            }
-            else {
-                throw 'Not found!';
-            }
-        });
         this.scope.instances.set(instanceName, component);
         const pinsOutput = pins.map((pin) => {
             return pin.id + ':' + pin.name;
         });
         this.log('add symbol', instanceName, '[' + pinsOutput.join(', ') + ']');
+        component.units = this.generateComponentUnits(props.units, component);
+        component.refreshPinUnitMap();
         return component;
     }
+    extractPinsFromUnits(units) {
+        const pins = [];
+        units.forEach(([, definition]) => {
+            pins.push(...definition.pins);
+        });
+        return pins;
+    }
+    generateComponentUnits(units, parent) {
+        return units.map(([key, unitDef]) => {
+            unitDef = { ...unitDef };
+            let useAngle = null;
+            const { pins } = unitDef;
+            const pinsMap = new Map();
+            pins.forEach(pin => {
+                pinsMap.set(pin.id, pin);
+            });
+            if (unitDef.angle) {
+                useAngle = unitDef.angle.toNumber() % 360;
+                if (useAngle < 0) {
+                    useAngle += 360;
+                }
+            }
+            if (unitDef.display === null && unitDef.arrange === null) {
+                const tmpArrangeLeft = [];
+                const tmpArrangeRight = [];
+                pins.forEach((pin, index) => {
+                    const useArray = (index % 2 === 0) ? tmpArrangeLeft : tmpArrangeRight;
+                    useArray.push(pin.id);
+                });
+                const arrangeProp = new Map([
+                    [SymbolPinSide.Left, tmpArrangeLeft],
+                    [SymbolPinSide.Right, tmpArrangeRight]
+                ]);
+                unitDef.arrange = arrangeProp;
+            }
+            if (unitDef.arrange !== null) {
+                unitDef.arrange = this.removeArrangePropDuplicates(unitDef.arrange);
+                const arrangePropPins = this.getArrangePropPins(unitDef.arrange);
+                pins.forEach(pin => {
+                    if (arrangePropPins.find(id => id.equals(pin.id)) === undefined) {
+                        this.logWarning(`Pin ${pin.id} is not specified in arrange property`);
+                    }
+                });
+            }
+            else {
+                unitDef.arrange = null;
+            }
+            unitDef.angle = useAngle ?? 0;
+            const { pins: pinSides, maxPositions } = getPortSide(pinsMap, unitDef.arrange);
+            const pinIdKeys = Array.from(pinsMap.keys());
+            pinSides.forEach(({ pinId, side, position }) => {
+                const matchedPinId = pinIdKeys.find(id => id.equals(pinId));
+                if (matchedPinId) {
+                    const tmpPin = pinsMap.get(matchedPinId);
+                    tmpPin.side = side;
+                    tmpPin.position = position;
+                }
+                else {
+                    throw 'Not found!';
+                }
+            });
+            const componentUnit = new ComponentUnit(key, parent);
+            componentUnit.widthProp = unitDef.width;
+            componentUnit.heightProp = unitDef.height;
+            componentUnit.angleProp = unitDef.angle;
+            componentUnit.followWireOrientationProp = unitDef.followWireOrientation;
+            componentUnit.pins = pinsMap;
+            componentUnit.pinsFlat = pins;
+            componentUnit.numPins = unitDef.pins.length;
+            componentUnit.pinsMaxPositions = maxPositions;
+            componentUnit.displayProp = unitDef.display;
+            componentUnit.arrangeProps = unitDef.arrange;
+            componentUnit.suffix = unitDef.suffix ?? null;
+            return componentUnit;
+        });
+    }
     removeArrangePropDuplicates(arrangeProp) {
         const sides = [
             SymbolPinSide.Left,
@@ -886,9 +914,10 @@ export class ExecutionContext {
         this.scope.setActive(ActiveObject.Wire, wireId);
         this.scope.sequence.push([SequenceAction.Wire, wireId, tmp, newWire]);
         this.scope.currentComponent.pinWires.set(this.scope.currentPin, tmp);
-        if (!this.scope.currentComponent.didSetWireOrientationAngle) {
+        const currentUnit = this.scope.currentComponent.getUnitForPin(this.scope.currentPin);
+        if (!currentUnit.didSetWireOrientationAngle) {
             this.applyComponentAngleFromWire(this.scope.currentComponent, this.scope.currentPin, true);
-            this.scope.currentComponent.didSetWireOrientationAngle = true;
+            currentUnit.didSetWireOrientationAngle = true;
         }
         return newWire;
     }
@@ -898,7 +927,6 @@ export class ExecutionContext {
         }
         const useName = userDefined ? 'point.' + pointId : pointId;
         const componentPoint = ClassComponent.simple(useName, 1);
-        componentPoint.displayProp = this.getPointSymbol(useName);
         componentPoint.typeProp = ComponentTypes.net;
         let usePointLinkComponent = null;
         if (this.scope.currentComponent._pointLinkComponent) {
@@ -908,6 +936,7 @@ export class ExecutionContext {
             usePointLinkComponent = this.scope.currentComponent;
         }
         componentPoint._pointLinkComponent = usePointLinkComponent;
+        componentPoint.addDefaultUnit(this.getPointSymbol(useName));
         this.scope.instances.set(pointId, componentPoint);
         this.toComponent(componentPoint, 1, { addSequence: true });
         return this.getCurrentPoint();
@@ -981,6 +1010,15 @@ export class ExecutionContext {
             if (this.scope.instances.has(idName)) {
                 const component = this.scope.instances.get(idName);
                 component.setParam(paramName, value);
+                const unitModifiers = [
+                    ParamKeys.angle,
+                    ParamKeys.flip,
+                    ParamKeys.flipX,
+                    ParamKeys.flipY,
+                ];
+                if (unitModifiers.indexOf(paramName) !== -1) {
+                    component.getUnit().setParam(paramName, value);
+                }
             }
             else if (this.scope.variables.has(idName)) {
                 throw "Not implemented yet!";
@@ -991,17 +1029,18 @@ export class ExecutionContext {
         }
     }
     applyComponentAngleFromWire(component, pin, opposite = false) {
+        const targetUnit = component.getUnitForPin(pin);
         if (this.componentAngleFollowsWire
-            && component.followWireOrientationProp
-            && component.useWireOrientationAngle
-            && !component.didSetWireOrientationAngle
+            && targetUnit.followWireOrientationProp
+            && targetUnit.useWireOrientationAngle
+            && !targetUnit.didSetWireOrientationAngle
             && this.scope.currentWireId !== -1) {
             const currentWire = this.scope.wires[this.scope.currentWireId];
             let useSegment = currentWire.path[currentWire.path.length - 1];
             if (opposite) {
                 useSegment = currentWire.path[0];
             }
-            const pinPositions = CalculatePinPositions(component);
+            const pinPositions = CalculatePinPositions(targetUnit);
             if (pinPositions.has(pin)) {
                 const connectedPinPos = pinPositions.get(pin);
                 let targetAngle = null;
@@ -1039,27 +1078,27 @@ export class ExecutionContext {
                 if (targetAngle === null) {
                     return;
                 }
-                this.log('set component angle from wire, target angle:', targetAngle, ', component angle:', component.angleProp, 'pin angle:', connectedPinPos.angle);
+                this.log('set component unit angle from wire, target angle:', targetAngle, ', component unit angle:', targetUnit.angleProp, 'pin angle:', connectedPinPos.angle);
                 let useAngle = (targetAngle - connectedPinPos.angle.toNumber()) % 360;
                 if (useAngle < 0) {
                     useAngle += 360;
                 }
                 if (useAngle === 90) {
-                    component.setParam(ParamKeys.angle, numeric(90));
+                    targetUnit.setParam(ParamKeys.angle, numeric(90));
                 }
                 else if (useAngle === 180) {
-                    if (component.angleProp === 0 || component.angleProp === 180) {
-                        component.setParam(ParamKeys.flipX, 1);
+                    if (targetUnit.angleProp === 0 || targetUnit.angleProp === 180) {
+                        targetUnit.setParam(ParamKeys.flipX, numeric(1));
                     }
-                    else if (component.angleProp === 90 || component.angleProp === 270) {
-                        component.setParam(ParamKeys.flipY, 1);
+                    else if (targetUnit.angleProp === 90 || targetUnit.angleProp === 270) {
+                        targetUnit.setParam(ParamKeys.flipY, numeric(1));
                     }
                 }
                 else if (useAngle === 270) {
-                    component.setParam(ParamKeys.angle, numeric(270));
+                    targetUnit.setParam(ParamKeys.angle, numeric(270));
                 }
-                component.wireOrientationAngle = useAngle;
-                component.didSetWireOrientationAngle = true;
+                targetUnit.wireOrientationAngle = useAngle;
+                targetUnit.didSetWireOrientationAngle = true;
             }
         }
     }

package/dist/esm/globals.js

@@ -3,6 +3,7 @@ export const TOOL_VERSION = '0.1.5';
 export const Delimiter1 = '-';
 export const DoubleDelimiter1 = `${Delimiter1}${Delimiter1}`;
 export const BaseNamespace = `${DoubleDelimiter1}.`;
+export const RefdesFileSuffix = '.refdes.json';
 export var GlobalNames;
 (function (GlobalNames) {
     GlobalNames["__root"] = "--root";
@@ -128,3 +129,4 @@ export const RenderFlags = {
 };
 export const SymbolValidatorContext = '_sym';
 export const TrailerArrayIndex = 'index';
+export const DefaultComponentUnit = '__default';

package/dist/esm/graph.js

@@ -35,32 +35,33 @@ export class NetGraph {
                 case SequenceAction.At: {
                     this.print(...sequenceStep);
                     const [, component, pin] = sequenceStep;
-                    const tmpInstanceName = component.instanceName;
+                    const componentUnit = component.getUnitForPin(pin);
+                    const tmpInstanceName = componentUnit.instanceName;
                     if (action === SequenceAction.At) {
                         previousNode = null;
                         previousPin = null;
                     }
                     if (!graph.hasNode(tmpInstanceName)) {
                         this.print('create instance', tmpInstanceName);
-                        const { displayProp = null } = component;
+                        const { displayProp = null } = componentUnit;
                         let tmpSymbol;
                         if (displayProp instanceof SymbolDrawing) {
                             tmpSymbol = new SymbolPlaceholder(displayProp);
                             tmpSymbol.drawing.logger = this.logger;
                         }
                         else {
-                            const symbolPinDefinitions = generateLayoutPinDefinition(component);
+                            const symbolPinDefinitions = generateLayoutPinDefinition(componentUnit);
                             if (component.typeProp === ComponentTypes.module) {
-                                tmpSymbol = new SymbolCustomModule(symbolPinDefinitions, component.pinsMaxPositions);
+                                tmpSymbol = new SymbolCustomModule(symbolPinDefinitions, componentUnit.pinsMaxPositions);
                             }
                             else {
-                                tmpSymbol = new SymbolCustom(symbolPinDefinitions, component.pinsMaxPositions);
+                                tmpSymbol = new SymbolCustom(symbolPinDefinitions, componentUnit.pinsMaxPositions);
                             }
                         }
-                        applyComponentParamsToSymbol(component, tmpSymbol);
+                        applyComponentParamsToSymbol(componentUnit, tmpSymbol);
                         tmpSymbol.refreshDrawing();
                         const { width: useWidth, height: useHeight } = tmpSymbol.size();
-                        tmpComponent = new RenderComponent(component, useWidth, useHeight);
+                        tmpComponent = new RenderComponent(component, componentUnit.unitId, useWidth, useHeight);
                         tmpComponent.symbol = tmpSymbol;
                         graph.setNode(tmpInstanceName, [RenderItemType.Component, tmpComponent, index]);
                         let useFrame = frameStack[frameStack.length - 1];
@@ -88,7 +89,8 @@ export class NetGraph {
                         const [prevNodeType, prevNodeItem] = graph.node(previousNode);
                         if (prevNodeType === RenderItemType.Component) {
                             const matchingItem = nets.find(([comp, pin]) => {
-                                return comp.instanceName === previousNode
+                                const unit = comp.getUnitForPin(pin);
+                                return unit.instanceName === previousNode
                                     && pin.equals(previousPin);
                             });
                             if (matchingItem !== undefined) {
@@ -321,11 +323,11 @@ function makeEdgeValue(instanceName1, instancePin1, instanceName2, instancePin2,
 export function getWireName(wireId) {
     return 'wire:' + wireId;
 }
-export function generateLayoutPinDefinition(component) {
-    const pins = component.pins;
+export function generateLayoutPinDefinition(componentUnit) {
+    const pins = componentUnit.pins;
     const symbolPinDefinitions = [];
     const existingPinIds = Array.from(pins.keys());
-    const arrangeProps = component.arrangeProps ?? [];
+    const arrangeProps = componentUnit.arrangeProps ?? [];
     const addedPins = [];
     for (const [key, items] of arrangeProps) {
         let useItems;
@@ -354,7 +356,7 @@ export function generateLayoutPinDefinition(component) {
         return addedPins.find(id => id.equals(pinId)) === undefined;
     });
     if (unplacedPins.length > 0) {
-        component._unplacedPins = unplacedPins;
+        componentUnit._unplacedPins = unplacedPins;
         console.warn("Warning: There are unplaced pins: " + unplacedPins);
     }
     return symbolPinDefinitions;