circuitscript 0.1.16 → 0.1.17

package/dist/esm/graph.js

@@ -5,7 +5,10 @@ import { milsToMM } from "./helpers.js";
 import { RenderFrame, RenderComponent, applyComponentParamsToSymbol, RenderWire } from "./layout.js";
 import { SequenceAction, FrameAction } from "./objects/ExecutionScope.js";
 import { Frame, FixedFrameIds, FrameParamKeys } from "./objects/Frame.js";
-import { numeric, NumericValue } from "./objects/ParamDefinition.js";
+import { numeric } from "./objects/ParamDefinition.js";
+import { NetTypes, TypeProps } from "./objects/types.js";
+import Matrix, { solve } from "ml-matrix";
+import { getPinDefinition } from "./objects/PinDefinition.js";
 export class NetGraph {
     logger;
     constructor(logger) {
@@ -73,7 +76,7 @@ export class NetGraph {
                         if (prevNodeType === RenderItemType.Component) {
                             const matchingItem = nets.find(([comp, pin]) => {
                                 return comp.instanceName === previousNode
-                                    && pin === previousPin;
+                                    && pin.equals(previousPin);
                             });
                             if (matchingItem !== undefined) {
                                 useNet = matchingItem[2];
@@ -188,21 +191,71 @@ export class NetGraph {
         this.logger.add(params.join(' '));
     }
     generateNetGraph(nets) {
-        const graph = new Graph({
-            directed: false
+        const uniqueNets = new Set(nets.map(([, , net]) => net));
+        const components = new Set(nets.map(([component, ,]) => component));
+        const tmpNets = Array.from(uniqueNets);
+        const gndNet = tmpNets.find(item => {
+            return item.toString() === '/GND';
         });
-        nets.forEach(item => {
-            const [component, pin, net] = item;
-            const netNodeName = this.getNetNodeName(net);
-            if (!graph.hasNode(netNodeName)) {
-                graph.setNode(netNodeName, net);
-            }
-            const componentNodeName = this.getComponentName(component);
-            if (!graph.hasNode(componentNodeName)) {
-                graph.setNode(componentNodeName, component);
+        const otherNets = tmpNets.filter(item => {
+            return item !== gndNet;
+        });
+        const netsIndexed = [];
+        if (gndNet) {
+            netsIndexed.push(gndNet);
+        }
+        netsIndexed.push(...otherNets);
+        const netsLength = netsIndexed.length;
+        const conductanceMatrix = Matrix.zeros(netsLength, netsLength);
+        components.forEach(item => {
+            if (item.typeProp === TypeProps.Resistor) {
+                const net1 = item.pinNets.get(1);
+                const net2 = item.pinNets.get(2);
+                const net1Index = netsIndexed.indexOf(net1);
+                const net2Index = netsIndexed.indexOf(net2);
+                const resistance = item.parameters.get('value');
+                const resistanceValue = resistance.toNumber();
+                const conductanceValue = 1 / resistanceValue;
+                const currentValue1 = conductanceMatrix.get(net1Index, net1Index);
+                const currentValue2 = conductanceMatrix.get(net2Index, net2Index);
+                const currentValue3 = conductanceMatrix.get(net1Index, net2Index);
+                const currentValue4 = conductanceMatrix.get(net2Index, net1Index);
+                conductanceMatrix.set(net1Index, net1Index, currentValue1 + conductanceValue);
+                conductanceMatrix.set(net2Index, net2Index, currentValue2 + conductanceValue);
+                conductanceMatrix.set(net1Index, net2Index, currentValue3 - conductanceValue);
+                conductanceMatrix.set(net2Index, net1Index, currentValue4 - conductanceValue);
             }
-            graph.setEdge(netNodeName, componentNodeName, [component, pin, net]);
         });
+        if (gndNet) {
+            conductanceMatrix.removeColumn(0);
+            conductanceMatrix.removeRow(0);
+        }
+        const netsWithoutGnd = netsIndexed.filter(net => {
+            return (net !== gndNet);
+        });
+        const netResistances = new Map();
+        try {
+            netsWithoutGnd.forEach((net, index) => {
+                if (net.type === NetTypes.Source) {
+                    const currentVector = Matrix.zeros(netsWithoutGnd.length, 1);
+                    currentVector.set(index, 0, 1);
+                    const solution = solve(conductanceMatrix, currentVector);
+                    for (let i = 0; i < solution.rows; i++) {
+                        const resValue = solution.get(i, 0);
+                        if (resValue > 0) {
+                            const targetNet = netsIndexed[i];
+                            netResistances.set(targetNet, resValue);
+                        }
+                    }
+                }
+            });
+        }
+        catch (err) {
+        }
+        return {
+            nets,
+            netResistances,
+        };
     }
     findNodePaths(graph, startNode, endNode, seenNodes = []) {
         const edges = graph.nodeEdges(startNode);
@@ -261,24 +314,22 @@ export function generateLayoutPinDefinition(component) {
             useItems = [...items];
         }
         useItems.forEach(pinId => {
-            if (pinId instanceof NumericValue) {
-                const pinIdValue = pinId.toNumber();
-                if (existingPinIds.indexOf(pinIdValue) !== -1) {
-                    const pin = pins.get(pinIdValue);
-                    symbolPinDefinitions.push({
-                        side: key,
-                        pinId: pinIdValue,
-                        text: pin.name,
-                        position: pin.position,
-                        pinType: pin.pinType,
-                    });
-                    addedPins.push(pinIdValue);
-                }
+            const existingPin = existingPinIds.find(pin => pin.equals(pinId));
+            if (existingPin) {
+                const pin = getPinDefinition(pins, existingPin);
+                symbolPinDefinitions.push({
+                    side: key,
+                    pinId: pinId,
+                    text: pin.name,
+                    position: pin.position,
+                    pinType: pin.pinType,
+                });
+                addedPins.push(pinId);
             }
         });
     }
     const unplacedPins = existingPinIds.filter(pinId => {
-        return addedPins.indexOf(pinId) === -1;
+        return addedPins.find(id => id.equals(pinId)) === undefined;
     });
     if (unplacedPins.length > 0) {
         component._unplacedPins = unplacedPins;

package/dist/esm/layout.js

@@ -6,6 +6,7 @@ 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';
 import { Direction } from './objects/types.js';
+import { PinId } from './objects/PinDefinition.js';
 import { milsToMM, UnitDimension } from './helpers.js';
 import { numeric } from './objects/ParamDefinition.js';
 import { generateLayoutPinDefinition, getWireName, RenderItemType } from './graph.js';
@@ -689,7 +690,11 @@ export class LayoutEngine {
         }
         if (subgraphEdges.length === 0) {
             const [, node1] = graph.node(firstNodeId);
-            this.placeNodeAtPosition(numeric(0), numeric(0), node1, 1);
+            let defaultPin = new PinId(1);
+            if (node1 instanceof RenderComponent) {
+                defaultPin = node1.component.getDefaultPin();
+            }
+            this.placeNodeAtPosition(numeric(0), numeric(0), node1, defaultPin);
             return;
         }
         let fixedNode;

package/dist/esm/objects/ClassComponent.js

@@ -1,7 +1,8 @@
 import { SymbolDrawingCommands } from '../draw_symbols.js';
-import { PinDefinition, PinIdType } from './PinDefinition.js';
+import { PinDefinition, PinId, PinIdType } from './PinDefinition.js';
 import { PinTypes } from './PinTypes.js';
 import { ParamKeys } from '../globals.js';
+import { RuntimeExecutionError } from '../utils.js';
 export class ClassComponent {
     instanceName;
     numPins;
@@ -35,47 +36,53 @@ export class ClassComponent {
     setupPins() {
         for (let i = 1; i < this.numPins + 1; i++) {
             const pinIndex = i;
-            this.pins.set(pinIndex, new PinDefinition(pinIndex, PinIdType.Int, pinIndex.toString(), PinTypes.Any));
+            this.pins.set(new PinId(pinIndex), new PinDefinition(pinIndex, PinIdType.Int, pinIndex.toString(), PinTypes.Any));
         }
         this.refreshPinsCache();
     }
     getDefaultPin() {
-        return 1;
+        const pins = Array.from(this.pins.keys());
+        pins.sort();
+        return pins[0];
     }
     hasPin(pinId) {
-        if (typeof pinId === 'number') {
-            return this.pins.has(pinId);
-        }
-        else {
-            for (const [, pinDef] of this.pins) {
-                if (pinDef.name === pinId ||
-                    pinDef.altNames.indexOf(pinId) !== -1) {
-                    return true;
-                }
+        for (const [pin, pinDef] of this.pins) {
+            if (pin.equals(pinId)) {
+                return true;
+            }
+            if (pinId.getType() === PinIdType.Str && (pinDef.name === pinId.getValue() ||
+                pinDef.altNames.indexOf(pinId.getValue()) !== -1)) {
+                return true;
             }
         }
         return false;
     }
     getPin(pinId) {
-        if (typeof pinId === 'number') {
-            return pinId;
+        for (const [pin,] of this.pins) {
+            if (pin.equals(pinId)) {
+                return pin;
+            }
         }
-        else {
+        if (pinId.getType() === PinIdType.Str) {
+            const pinIdStringValue = pinId.getValue();
             for (const [pin, pinDef] of this.pins) {
-                if (pinDef.name === pinId ||
-                    pinDef.altNames.indexOf(pinId) !== -1) {
+                if (pinDef.name === pinIdStringValue ||
+                    pinDef.altNames.indexOf(pinIdStringValue) !== -1) {
                     return pin;
                 }
             }
-            return -1;
         }
+        throw new RuntimeExecutionError(`Could not find pin '${pinId}' on component '${this.instanceName}'`);
     }
     getNextPinAfter(pinIndex) {
-        if (pinIndex + 1 <= this.numPins) {
-            return pinIndex + 1;
+        const pins = Array.from(this.pins.keys());
+        pins.sort();
+        const index = pins.findIndex(tmp => tmp.equals(pinIndex));
+        if (index + 1 < pins.length) {
+            return pins[index + 1];
         }
         else {
-            return 1;
+            return this.getDefaultPin();
         }
     }
     setParam(key, value) {

package/dist/esm/objects/ExecutionScope.js

@@ -1,4 +1,6 @@
 import { Property_key_exprContext } from '../antlr/CircuitScriptParser.js';
+import { PinId } from './PinDefinition.js';
+import { RuntimeExecutionError } from '../utils.js';
 export class ExecutionScope {
     scopeId;
     nets = [];
@@ -32,8 +34,11 @@ export class ExecutionScope {
         return scope;
     }
     findNet(component, pin) {
+        if (!(pin instanceof PinId)) {
+            throw new RuntimeExecutionError('Invalid value for PinId: ' + pin);
+        }
         return this.nets.find(([tmpComponent, tmpPin]) => {
-            return tmpComponent.isEqual(component) && tmpPin === pin;
+            return tmpComponent.isEqual(component) && tmpPin.equals(pin);
         });
     }
     getNetWithName(name) {
@@ -94,7 +99,7 @@ export class ExecutionScope {
             }
         });
         return sortedNet.map(([component, pin, net]) => {
-            return [net.toString(), component.instanceName, pin];
+            return [net.toString(), component.instanceName, pin.value];
         });
     }
     printNets() {

package/dist/esm/objects/Net.js

@@ -5,7 +5,7 @@ export class Net {
     priority;
     type;
     params = new Map();
-    constructor(namespace, name, priority = 0, type = null) {
+    constructor(namespace, name, priority = 0, type = 'any') {
         if (namespace.indexOf(' ') !== -1) {
             throw "Invalid net namespace provided";
         }

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,18 @@ 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["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();

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 {};