circuitscript 0.1.16 → 0.1.18

package/dist/esm/objects/PinDefinition.js

@@ -1,4 +1,47 @@
+import { RuntimeExecutionError } from '../utils.js';
+import { NumericValue } from './ParamDefinition.js';
 import { PinTypes } from './PinTypes.js';
+export class PinId {
+    value;
+    type;
+    constructor(value) {
+        if (typeof value !== 'string' && typeof value !== 'number') {
+            throw new RuntimeExecutionError("Invalid value for PinId: " + value);
+        }
+        this.value = value;
+        this.type = typeof value === 'number' ? PinIdType.Int : PinIdType.Str;
+    }
+    getValue() {
+        return this.value;
+    }
+    getType() {
+        return this.type;
+    }
+    isNumeric() {
+        return this.type === PinIdType.Int;
+    }
+    isString() {
+        return this.type === PinIdType.Str;
+    }
+    toString() {
+        return this.value.toString();
+    }
+    equals(other) {
+        if (other instanceof PinId) {
+            return this.value === other.value;
+        }
+        return this.value === other;
+    }
+    static from(value) {
+        if (value instanceof NumericValue) {
+            return new PinId(value.toNumber());
+        }
+        return new PinId(value);
+    }
+    static isPinIdType(value) {
+        return (typeof value === 'number' || typeof value === 'string');
+    }
+}
 export class PinDefinition {
     id;
     idType;
@@ -8,8 +51,8 @@ export class PinDefinition {
     side = PortSide.EAST;
     position = -1;
     constructor(id, idType, name, pinType = PinTypes.Any, altNames = []) {
-        this.id = id;
-        this.idType = idType;
+        this.id = id instanceof PinId ? id : new PinId(id);
+        this.idType = this.id.getType();
         this.pinType = pinType;
         this.name = name;
         this.altNames = altNames;
@@ -27,3 +70,11 @@ export var PortSide;
     PortSide["SOUTH"] = "SOUTH";
     PortSide["NORTH"] = "NORTH";
 })(PortSide || (PortSide = {}));
+export function isPinId(item) {
+    return item instanceof PinId || (typeof item === 'number' || typeof item === 'string');
+}
+export function getPinDefinition(map, id) {
+    const keys = Array.from(map.keys());
+    const tmpKey = keys.find(item => item.equals(id));
+    return map.get(tmpKey);
+}

package/dist/esm/objects/types.js

@@ -106,3 +106,19 @@ export var Direction;
     Direction["Down"] = "down";
     Direction["Up"] = "up";
 })(Direction || (Direction = {}));
+export var TypeProps;
+(function (TypeProps) {
+    TypeProps["Net"] = "net";
+    TypeProps["Port"] = "port";
+    TypeProps["Graphic"] = "graphic";
+    TypeProps["Module"] = "module";
+    TypeProps["Resistor"] = "res";
+    TypeProps["Capacitor"] = "cap";
+    TypeProps["Inductor"] = "ind";
+    TypeProps["Diode"] = "diode";
+})(TypeProps || (TypeProps = {}));
+export var NetTypes;
+(function (NetTypes) {
+    NetTypes["Any"] = "any";
+    NetTypes["Source"] = "source";
+})(NetTypes || (NetTypes = {}));

package/dist/esm/visitor.js

@@ -1,8 +1,8 @@
 import { ClassComponent } from './objects/ClassComponent.js';
 import { NumberOperator, numeric, NumericValue, ParamDefinition } from './objects/ParamDefinition.js';
-import { PinDefinition, PinIdType } from './objects/PinDefinition.js';
+import { PinDefinition, PinId, PinIdType } from './objects/PinDefinition.js';
 import { PinTypes } from './objects/PinTypes.js';
-import { AnyReference, DeclaredReference, UndeclaredReference } from './objects/types.js';
+import { AnyReference, DeclaredReference, TypeProps, UndeclaredReference } from './objects/types.js';
 import { BlockTypes, ComponentTypes, Delimiter1, FrameType, GlobalDocumentName, ModuleContainsKeyword, NoNetText, ParamKeys, ReferenceTypes, SymbolPinSide, ValidPinSides, WireAutoDirection } from './globals.js';
 import { unwrapValue } from "./utils.js";
 import { PlaceHolderCommands, SymbolDrawingCommands } from './draw_symbols.js';
@@ -17,19 +17,23 @@ export class ParserVisitor extends BaseVisitor {
         this.setResult(ctx, [id, value]);
     };
     visitPin_select_expr = (ctx) => {
-        let value = null;
+        let pinId = null;
         const ctxData = ctx.data_expr();
         const result = this.visitResult(ctxData);
+        let pinValue;
         if (result instanceof NumericValue) {
-            value = result.toNumber();
+            pinValue = result.toNumber();
         }
         else if (typeof result === 'string') {
-            value = result;
+            pinValue = result;
         }
         else {
-            throw new RuntimeExecutionError("Invalid value for pin", ctx);
+            throw new RuntimeExecutionError("Invalid select pin: " + result, ctx);
         }
-        this.setResult(ctx, value);
+        if (pinValue !== undefined) {
+            pinId = new PinId(pinValue);
+        }
+        this.setResult(ctx, pinId);
     };
     visitAdd_component_expr = (ctx) => {
         const [component, pinValue] = this.visitResult(ctx.data_expr_with_assignment());
@@ -216,11 +220,18 @@ export class ParserVisitor extends BaseVisitor {
                                 }
                             }
                             else {
-                                if (!(value instanceof NumericValue)) {
+                                if (!(value instanceof NumericValue) && !(typeof value === 'string')) {
                                     throw new RuntimeExecutionError(`Invalid numeric value for arrange.${sideKeyName}`, ctx);
                                 }
                                 else {
-                                    checkPinExistsAndNotDuplicated(value.toNumber(), ctx);
+                                    let useValue;
+                                    if (value instanceof NumericValue) {
+                                        useValue = value.toNumber();
+                                    }
+                                    else if (typeof value === 'string') {
+                                        useValue = value;
+                                    }
+                                    value && checkPinExistsAndNotDuplicated(useValue, ctx);
                                 }
                             }
                         }
@@ -260,7 +271,6 @@ export class ParserVisitor extends BaseVisitor {
         scope.exitContext();
         scope.popOnPropertyHandler();
         const properties = this.getPropertyExprList(ctx.property_expr());
-        const pins = this.parseCreateComponentPins(properties.get('pins'));
         let instanceName = this.getExecutor().getUniqueInstanceName();
         const propParams = properties.get('params');
         const params = this.parseCreateComponentParams(propParams);
@@ -273,11 +283,11 @@ export class ParserVisitor extends BaseVisitor {
             }
             instanceName += `${Delimiter1}${appendValue}`;
         }
-        const arrange = properties.has('arrange') ?
+        const arrangeProp = properties.has('arrange') ?
             properties.get('arrange') : null;
-        const display = properties.has('display') ?
+        const displayProp = properties.has('display') ?
             properties.get('display') : null;
-        const type = properties.has('type') ?
+        const typeProp = properties.has('type') ?
             properties.get('type') : null;
         const copy = properties.has('copy') ?
             properties.get('copy') : false;
@@ -289,8 +299,29 @@ export class ParserVisitor extends BaseVisitor {
             properties.get(ParamKeys.angle) : null;
         const followWireOrientation = properties.has('followWireOrientation') ?
             properties.get('followWireOrientation') : true;
+        let pins = [];
+        if (displayProp !== null && arrangeProp === null
+            && typeProp !== TypeProps.Graphic) {
+            const drawCommands = displayProp.getCommands();
+            drawCommands.forEach(command => {
+                const [commandValue,] = command;
+                if (commandValue === PlaceHolderCommands.vpin
+                    || commandValue === PlaceHolderCommands.hpin
+                    || commandValue === PlaceHolderCommands.pin) {
+                    const id = PinId.from(command[1][0]);
+                    const pinType = id.getType();
+                    const pinName = id.toString();
+                    pins.push(new PinDefinition(id, pinType, pinName, PinTypes.Any));
+                }
+            });
+        }
+        else {
+            pins = this.parseCreateComponentPins(properties.get('pins'));
+        }
         const props = {
-            arrange, display, type, width, height, copy,
+            arrange: arrangeProp,
+            display: displayProp,
+            type: typeProp, width, height, copy,
             angle, followWireOrientation
         };
         try {
@@ -852,14 +883,21 @@ export class ParserVisitor extends BaseVisitor {
     visitPin_select_expr2 = (ctx) => {
         const ctxStringValue = ctx.STRING_VALUE();
         const ctxIntegerValue = ctx.INTEGER_VALUE();
-        let result = null;
+        let pinIdValue;
+        let pinId = null;
         if (ctxStringValue) {
-            result = this.prepareStringValue(ctxStringValue.getText());
+            pinIdValue = this.prepareStringValue(ctxStringValue.getText());
         }
         else if (ctxIntegerValue) {
-            result = Number(ctxIntegerValue.getText());
+            pinIdValue = Number(ctxIntegerValue.getText());
         }
-        this.setResult(ctx, result);
+        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();
@@ -1200,7 +1238,7 @@ export class ParserVisitor extends BaseVisitor {
                         return item;
                     }
                     else {
-                        return numeric(nameToPinId.get(item));
+                        return new PinId(nameToPinId.get(item));
                     }
                 });
                 if (items.length > 0) {
@@ -1291,7 +1329,7 @@ export class ParserVisitor extends BaseVisitor {
     getGraph() {
         const executor = this.getExecutor();
         const fullSequence = executor.scope.sequence;
-        const tmpNet = executor.scope.getNet(executor.scope.componentRoot, 1);
+        const tmpNet = executor.scope.getNet(executor.scope.componentRoot, new PinId(1));
         const sequence = (tmpNet === null)
             ? fullSequence.slice(1) : fullSequence;
         const nets = executor.scope.getNets();
@@ -1336,8 +1374,28 @@ export class ParserVisitor extends BaseVisitor {
                 this.log('Failed to annotate:', instance.instanceName);
             }
         });
-        this.log('===== annotate done =====');
-        this.log('');
+        this.log('===== annotate components done =====');
+        this.log('===== rename nets =====');
+        this.renameNetsWithRefdes();
+        this.log('===== rename nets done =====');
+    }
+    renameNetsWithRefdes() {
+        const nets = this.getScope().getNets();
+        const seenNets = [];
+        const uniqueNets = new Set(nets.map(([, , net]) => net));
+        const fullNetNames = Array.from(uniqueNets).map(item => item.toString());
+        nets.forEach(([component, pin, net]) => {
+            if (net.priority === 0 && seenNets.indexOf(net) === -1
+                && component.typeProp !== TypeProps.Module
+                && component.typeProp !== TypeProps.Net) {
+                net.name = net.baseName =
+                    `NET-(${component.assignedRefDes}-${pin.toString()})`;
+                if (fullNetNames.indexOf(net.toString()) !== -1) {
+                    throw new RuntimeExecutionError('Net renaming failed due to clash: ' + net);
+                }
+                seenNets.push(net);
+            }
+        });
     }
     applySheetFrameComponent() {
         const baseScope = this.getScope();

package/dist/libs/std.cst

@@ -1,6 +1,6 @@
 # Circuitscript default lib
 
-def net(net_name):
+def net(net_name, net_type = "any"):
     return create component:
         pins: 1
         copy: true
@@ -13,9 +13,10 @@ def net(net_name):
         params:
             net_name: net_name
             priority: 10
+            net_type: net_type
 
 def supply(net_name):
-    net_obj = net(net_name)
+    net_obj = net(net_name, "source")
     return net_obj
 
 def label(value, anchor="left"):

package/dist/types/BaseVisitor.d.ts

@@ -10,6 +10,7 @@ import { ExecutionWarning } from "./utils.js";
 import { BaseError } from './utils.js';
 import { ExecutionScope } from './objects/ExecutionScope.js';
 import { NodeScriptEnvironment } from "./environment.js";
+import { PinId } from './objects/PinDefinition.js';
 export declare class BaseVisitor extends CircuitScriptVisitor<ComplexType | AnyReference | any> {
     indentLevel: number;
     startingContext: ExecutionContext;
@@ -38,7 +39,7 @@ export declare class BaseVisitor extends CircuitScriptVisitor<ComplexType | AnyR
         found: boolean;
         net?: Net;
     };
-    createComponentPinNetResolver(executionStack: ExecutionContext[]): (component: ClassComponent, pin: number) => Net | null;
+    createComponentPinNetResolver(executionStack: ExecutionContext[]): (component: ClassComponent, pin: PinId) => Net | null;
     log(...params: any[]): void;
     log2(message: string): void;
     visitAsync(ctx: ParserRuleContext): Promise<void>;

package/dist/types/draw_symbols.d.ts

@@ -4,6 +4,7 @@ import { Logger } from "./logger.js";
 import { PinTypes } from "./objects/PinTypes.js";
 import { ParserRuleContext } from "antlr4ng";
 import { NumericValue } from "./objects/ParamDefinition.js";
+import { PinId } from "./objects/PinDefinition.js";
 export declare abstract class SymbolGraphic {
     drawPortsName: boolean;
     displayBounds: boolean;
@@ -37,7 +38,7 @@ export declare abstract class SymbolGraphic {
     drawPlaceRemove(group: G, extra?: {
         place?: boolean;
     }): void;
-    pinPosition(id: number): {
+    pinPosition(id: PinId): {
         x: NumericValue;
         y: NumericValue;
         angle: NumericValue;
@@ -131,7 +132,7 @@ export declare class SymbolCustomModule extends SymbolCustom {
 }
 export declare class SymbolDrawing {
     items: (Feature | GeometryProp)[];
-    pins: [NumericValue, Feature, angle: NumericValue, lineColor: string][];
+    pins: PinRenderInfo[];
     angle: number;
     flipX: number;
     flipY: number;
@@ -141,8 +142,7 @@ export declare class SymbolDrawing {
     clear(): void;
     log(...params: any[]): void;
     addLine(startX: NumericValue, startY: NumericValue, endX: NumericValue, endY: NumericValue): SymbolDrawing;
-    addPin(pinId: NumericValue, startX: NumericValue, startY: NumericValue, endX: NumericValue, endY: NumericValue, lineColor: string): SymbolDrawing;
-    addPinMM(pinId: NumericValue, startXMM: NumericValue, startYMM: NumericValue, endXMM: NumericValue, endYMM: NumericValue, lineColor: string): SymbolDrawing;
+    addPinMM(pinId: PinId, startXMM: NumericValue, startYMM: NumericValue, endXMM: NumericValue, endYMM: NumericValue, lineColor: string): SymbolDrawing;
     addVLine(startX: NumericValue, startY: NumericValue, value: NumericValue): SymbolDrawing;
     addHLine(startX: NumericValue, startY: NumericValue, value: NumericValue): SymbolDrawing;
     addRect(x: NumericValue, y: NumericValue, width: NumericValue, height: NumericValue): SymbolDrawing;
@@ -177,7 +177,7 @@ export declare class SymbolDrawing {
         start: SimplePoint;
         end: SimplePoint;
     };
-    getPinPosition(pinId: number): {
+    getPinPosition(pinId: PinId): {
         start: [x: NumericValue, y: NumericValue];
         end: [x: NumericValue, y: NumericValue];
         angle: NumericValue;
@@ -191,7 +191,7 @@ export type GraphicExprCommand = [
 ];
 export declare class SymbolDrawingCommands extends SymbolDrawing {
     id: string;
-    private commands;
+    protected commands: GraphicExprCommand[];
     paramIds: string[];
     callback: (variables: Map<string, any>) => GraphicExprCommand[];
     constructor(callback: (variables: Map<string, any>) => GraphicExprCommand[]);
@@ -216,9 +216,15 @@ type SymbolPinLayout = {
 };
 export type SymbolPinDefintion = {
     side: string;
-    pinId: number;
+    pinId: PinId;
     text: string;
     position: number;
     pinType: PinTypes;
 };
+export type PinRenderInfo = [
+    PinId,
+    Feature,
+    angle: NumericValue,
+    lineColor: string
+];
 export {};

package/dist/types/execute.d.ts

@@ -4,7 +4,7 @@ import { ClassComponent } from './objects/ClassComponent.js';
 import { ExecutionScope } from './objects/ExecutionScope.js';
 import { Net } from './objects/Net.js';
 import { NumericValue, ParamDefinition } from './objects/ParamDefinition.js';
-import { PinDefinition } from './objects/PinDefinition.js';
+import { PinDefinition, PinId } from './objects/PinDefinition.js';
 import { AnyReference, CFunction, CFunctionEntry, CFunctionResult, CallableParameter, ComponentPin } from './objects/types.js';
 import { Logger } from './logger.js';
 import { UnitDimension } from './helpers.js';
@@ -21,7 +21,7 @@ export declare class ExecutionContext {
         found: boolean;
         net?: Net;
     });
-    resolveComponentPinNet: (component: ClassComponent, pin: number) => Net | null;
+    resolveComponentPinNet: (component: ClassComponent, pin: PinId) => Net | null;
     stopFurtherExpressions: boolean;
     returnValue: null;
     silent: boolean;
@@ -40,7 +40,7 @@ export declare class ExecutionContext {
     private linkComponentPinNet;
     private mergeNets;
     createComponent(instanceName: string, pins: PinDefinition[], params: ParamDefinition[], props: {
-        arrange?: Map<string, number[]>;
+        arrange?: Map<string, PinId[]>;
         display?: SymbolDrawingCommands;
         type?: string;
         width?: number;
@@ -52,11 +52,11 @@ export declare class ExecutionContext {
     private removeArrangePropDuplicates;
     private getArrangePropPins;
     printPoint(extra?: string): void;
-    addComponentExisting(component: ClassComponent, pin: number): ComponentPin;
+    addComponentExisting(component: ClassComponent, pin: PinId): ComponentPin;
     toComponent(component: ClassComponent, pinId: number | null, options?: {
         addSequence?: boolean;
     }): ComponentPin;
-    atComponent(component: ClassComponent, pinId: number | null, options?: {
+    atComponent(component: ClassComponent, pinId: PinId | null, options?: {
         addSequence?: boolean;
     }): ComponentPin;
     copyComponent(component: ClassComponent): ClassComponent;
@@ -86,12 +86,12 @@ export declare class ExecutionContext {
     enterFrame(frameType: FrameType): number;
     exitFrame(frameId: number): void;
 }
-export declare function getPortSide(pins: Map<number, PinDefinition>, arrangeProps: null | Map<string, number[]>): {
+export declare function getPortSide(pins: Map<PinId, PinDefinition>, arrangeProps: null | Map<string, number[]>): {
     pins: PortSideItem[];
     maxPositions: Map<string, number>;
 };
 type PortSideItem = {
-    pinId: number;
+    pinId: PinId;
     side: string;
     order: number;
     position: number;

package/dist/types/export.d.ts

@@ -1,12 +1,12 @@
 import { NetListItem } from "./visitor.js";
-export declare function generateKiCADNetList(netlist: NetListItem[]): {
+export declare function generateKiCadNetList(netlist: NetListItem[]): {
     tree: SExp;
     missingFootprints: {
         refdes: string;
         instanceName: string;
     }[];
 };
-export declare function printTree(tree: (IdObject | string)[] | string, level?: number): string;
+export declare function printTree(tree: any, level?: number): string;
 export declare class IdObject {
     keyName: string;
     constructor(keyName: string);

package/dist/types/globals.d.ts

@@ -9,6 +9,7 @@ export declare const NoNetText = "NO_NET";
 export declare enum ParamKeys {
     priority = "priority",
     net_name = "net_name",
+    net_type = "net_type",
     flip = "flip",
     flipX = "flipX",
     flipY = "flipY",

package/dist/types/graph.d.ts

@@ -6,10 +6,11 @@ import { SequenceItem } from "./objects/ExecutionScope.js";
 import { Net } from "./objects/Net.js";
 import { Logger } from "./logger.js";
 import { ComponentPinNetPair } from "./objects/types.js";
+import { PinId } from "./objects/PinDefinition.js";
 export declare class NetGraph {
     logger: Logger;
     constructor(logger: Logger);
-    generateLayoutGraph(sequence: SequenceItem[], nets: [ClassComponent, pin: number, net: Net][]): {
+    generateLayoutGraph(sequence: SequenceItem[], nets: [ClassComponent, pin: PinId, net: Net][]): {
         graph: Graph;
         containerFrames: RenderFrame[];
     };

package/dist/types/helpers.d.ts

@@ -1,4 +1,5 @@
 import { BaseError } from "./utils.js";
+import { ParserVisitor } from "./visitor.js";
 import { SymbolValidatorVisitor } from "./validate/SymbolValidatorVisitor.js";
 import { CommonTokenStream, DefaultErrorStrategy, Parser } from "antlr4ng";
 import { CircuitScriptParser } from "./antlr/CircuitScriptParser.js";
@@ -32,10 +33,21 @@ export declare class ParseErrorStrategy extends DefaultErrorStrategy {
     reportUnwantedToken(recognizer: Parser): void;
 }
 export declare function validateScript(filePath: string, scriptData: string, options: ScriptOptions): Promise<SymbolValidatorVisitor>;
-export declare function renderScript(scriptData: string, outputPath: string | null, options: ScriptOptions): Promise<{
+type RenderScriptReturn = {
     svgOutput: string | null;
     errors: BaseError[];
-}>;
+};
+export declare function renderScript(scriptData: string, outputPath: string | null, options: ScriptOptions): Promise<RenderScriptReturn>;
+export declare function renderScriptCustom(scriptData: string, outputPath: string | null, options: ScriptOptions, parseHandlers: ParseOutputHandler[]): Promise<RenderScriptReturn>;
+export declare abstract class ParseOutputHandler {
+    beforeRender: boolean;
+    afterRender: boolean;
+    abstract parse(visitor: ParserVisitor, outputPath: string | null, fileExtension: string | null): boolean;
+}
+export declare class KiCadNetListOutputHandler extends ParseOutputHandler {
+    beforeRender: boolean;
+    parse(visitor: ParserVisitor, outputPath: string | null, fileExtension: string | null): boolean;
+}
 export declare function detectJSModuleType(): JSModuleType;
 export declare class UnitDimension {
     type: LengthUnit;
@@ -60,3 +72,4 @@ export declare function getPaperSize(type: string, margin?: number): {
     originalWidthMM: number;
     originalHeightMM: number;
 };
+export {};

package/dist/types/layout.d.ts

@@ -8,6 +8,7 @@ import { Logger } from './logger.js';
 import { Frame, FramePlotDirection } from './objects/Frame.js';
 import { BoundBox } from './utils.js';
 import { ComponentPinNetPair } from './objects/types.js';
+import { PinId } from './objects/PinDefinition.js';
 import { NumericValue } from './objects/ParamDefinition.js';
 export declare class LayoutEngine {
     logger: Logger;
@@ -35,7 +36,7 @@ export declare class LayoutEngine {
     private placeSubgraphV2;
     mergeOriginNodes(node1: RenderItem, pin1: number, node2: RenderItem, pin2: number, originNode1: string, originNode2: string, originNodes: RenderItem[], originNodeGroups: Map<string, RenderItem[]>): void;
     translateNodeBy(offsetX: number, offsetY: number, item: RenderItem): void;
-    placeNodeAtPosition(fromX: NumericValue, fromY: NumericValue, item: RenderItem, pin: number, depth?: number): void;
+    placeNodeAtPosition(fromX: NumericValue, fromY: NumericValue, item: RenderItem, pin: PinId, depth?: number): void;
     placeFloatingItems(graph: Graph, item: RenderItem, depth?: number): void;
     printWarnings(): void;
 }

package/dist/types/objects/ClassComponent.d.ts

@@ -9,8 +9,8 @@ export declare class ClassComponent {
     instanceName: string;
     numPins: number;
     parameters: Map<string, number | string | NumericValue>;
-    pins: Map<number, PinDefinition>;
-    pinNets: Map<number, Net>;
+    pins: Map<PinId, PinDefinition>;
+    pinNets: Map<PinId, Net>;
     pinWires: Map<number, WireSegment[]>;
     pinsMaxPositions: Map<string, number>;
     _cachedPins: string;
@@ -18,8 +18,8 @@ export declare class ClassComponent {
     _copyID?: number;
     _copyFrom?: ClassComponent;
     _pointLinkComponent?: ClassComponent;
-    _unplacedPins: number[];
-    arrangeProps: Map<string, NumericValue[]> | null;
+    _unplacedPins: PinId[];
+    arrangeProps: Map<string, PinId[]> | null;
     displayProp: SymbolDrawingCommands | null;
     widthProp: number | null;
     heightProp: number | null;
@@ -33,10 +33,10 @@ export declare class ClassComponent {
     assignedRefDes: string | null;
     constructor(instanceName: string, numPins: number);
     setupPins(): void;
-    getDefaultPin(): number;
-    hasPin(pinId: number | string): boolean;
-    getPin(pinId: number | string): PinId;
-    getNextPinAfter(pinIndex: number): number;
+    getDefaultPin(): PinId;
+    hasPin(pinId: PinId): boolean;
+    getPin(pinId: PinId): PinId;
+    getNextPinAfter(pinIndex: PinId): PinId;
     setParam(key: string, value: number | string | NumericValue): void;
     hasParam(key: string): boolean;
     private refreshParamCache;

package/dist/types/objects/ExecutionScope.d.ts

@@ -6,6 +6,7 @@ import { Wire, WireSegment } from './Wire.js';
 import { Frame } from './Frame.js';
 import { ParserRuleContext } from 'antlr4ng';
 import { BaseVisitor } from 'src/BaseVisitor.js';
+import { PinId } from './PinDefinition.js';
 type OnPropertyHandler = (path: PropertyTreeKey[], value: any, valueContext: ParserRuleContext) => void;
 export type PropertyTreeKey = [ctx: ParserRuleContext, value: any] | ['index', number];
 export declare class ExecutionScope {
@@ -27,7 +28,7 @@ export declare class ExecutionScope {
     netCounter: number;
     unnamedCounter: number;
     currentComponent: ClassComponent | null;
-    currentPin: number | null;
+    currentPin: PinId | null;
     currentWireId: number;
     currentFrameId: number;
     componentRoot: ClassComponent | null;
@@ -39,17 +40,17 @@ export declare class ExecutionScope {
     private findNet;
     getNetWithName(name: string): Net;
     getNetWithNamespacePath(namespace: string, name: string): Net | null;
-    hasNet(component: ClassComponent, pin: number): boolean;
-    getNet(component: ClassComponent, pin: number): Net | null;
-    setNet(component: ClassComponent, pin: number, net: Net): void;
-    removeNet(component: ClassComponent, pin: number): void;
+    hasNet(component: ClassComponent, pin: PinId): boolean;
+    getNet(component: ClassComponent, pin: PinId): Net | null;
+    setNet(component: ClassComponent, pin: PinId, net: Net): void;
+    removeNet(component: ClassComponent, pin: PinId): void;
     getNets(): ComponentPinNetPair[];
     dumpNets(): ComponentPinNet[];
     printNets(): void;
     setVariable(name: string, value: any): void;
     setActive(type: ActiveObject, item: any): void;
     clearActive(): void;
-    setCurrent(component: ClassComponent | null, pin?: number | null): void;
+    setCurrent(component: ClassComponent | null, pin?: PinId | null): void;
     enterContext(context: ParserRuleContext): void;
     exitContext(): ParserRuleContext;
     private findPropertyKeyTree;

package/dist/types/objects/Net.d.ts

@@ -1,11 +1,12 @@
+import { NetTypes } from "./types.js";
 export declare class Net {
     name: string;
     baseName: string;
     namespace: string;
     priority: number;
-    type: any;
+    type: NetTypes;
     params: Map<string, any>;
-    constructor(namespace: string, name: string, priority?: number, type?: any);
+    constructor(namespace: string, name: string, priority?: number, type?: NetTypes);
     toString(): string;
     static isSame(netA: Net, netB: Net): boolean;
 }

package/dist/types/objects/PinDefinition.d.ts

@@ -1,5 +1,18 @@
+import { NumericValue } from './ParamDefinition.js';
 import { PinTypes } from './PinTypes.js';
-export type PinId = number | string;
+export declare class PinId {
+    private value;
+    private type;
+    constructor(value: number | string);
+    getValue(): number | string;
+    getType(): PinIdType;
+    isNumeric(): boolean;
+    isString(): boolean;
+    toString(): string;
+    equals(other: PinId | number | string): boolean;
+    static from(value: number | string | NumericValue): PinId;
+    static isPinIdType(value: number | string): boolean;
+}
 export declare class PinDefinition {
     id: PinId;
     idType: PinIdType;
@@ -8,7 +21,7 @@ export declare class PinDefinition {
     altNames: string[];
     side: string;
     position: number;
-    constructor(id: PinId, idType: PinIdType, name: string, pinType?: PinTypes, altNames?: never[]);
+    constructor(id: PinId | number | string, idType: PinIdType, name: string, pinType?: PinTypes, altNames?: never[]);
 }
 export declare enum PinIdType {
     Int = "int",
@@ -20,3 +33,5 @@ export declare enum PortSide {
     SOUTH = "SOUTH",
     NORTH = "NORTH"
 }
+export declare function isPinId(item: any): boolean;
+export declare function getPinDefinition(map: Map<PinId, PinDefinition>, id: PinId): PinDefinition;