circuitscript 0.0.21 → 0.0.22

package/build/src/antlr/CircuitScriptVisitor.d.ts

@@ -0,0 +1,115 @@
+import { ParseTreeVisitor } from 'antlr4';
+import { ScriptContext } from "./CircuitScriptParser";
+import { ExpressionContext } from "./CircuitScriptParser";
+import { Path_blocksContext } from "./CircuitScriptParser";
+import { Path_block_innerContext } from "./CircuitScriptParser";
+import { Property_set_expr2Context } from "./CircuitScriptParser";
+import { Assignment_expr2Context } from "./CircuitScriptParser";
+import { Data_expr_with_assignmentContext } from "./CircuitScriptParser";
+import { Add_component_exprContext } from "./CircuitScriptParser";
+import { Component_select_exprContext } from "./CircuitScriptParser";
+import { Pin_select_exprContext } from "./CircuitScriptParser";
+import { Pin_select_expr2Context } from "./CircuitScriptParser";
+import { At_component_exprContext } from "./CircuitScriptParser";
+import { To_component_exprContext } from "./CircuitScriptParser";
+import { At_to_multiple_exprContext } from "./CircuitScriptParser";
+import { At_to_multiple_line_exprContext } from "./CircuitScriptParser";
+import { At_to_multiple_line_expr_to_pinContext } from "./CircuitScriptParser";
+import { At_blockContext } from "./CircuitScriptParser";
+import { At_block_expressionsContext } from "./CircuitScriptParser";
+import { At_block_pin_exprContext } from "./CircuitScriptParser";
+import { At_block_pin_expression_simpleContext } from "./CircuitScriptParser";
+import { At_block_pin_expression_complexContext } from "./CircuitScriptParser";
+import { Break_keywordContext } from "./CircuitScriptParser";
+import { Assignment_exprContext } from "./CircuitScriptParser";
+import { Keyword_assignment_exprContext } from "./CircuitScriptParser";
+import { ParametersContext } from "./CircuitScriptParser";
+import { Property_set_exprContext } from "./CircuitScriptParser";
+import { Double_dot_property_set_exprContext } from "./CircuitScriptParser";
+import { AdditionExprContext } from "./CircuitScriptParser";
+import { MultiplyExprContext } from "./CircuitScriptParser";
+import { DataExprContext } from "./CircuitScriptParser";
+import { UnaryOperatorExprContext } from "./CircuitScriptParser";
+import { ValueAtomExprContext } from "./CircuitScriptParser";
+import { BinaryOperatorExprContext } from "./CircuitScriptParser";
+import { RoundedBracketsExprContext } from "./CircuitScriptParser";
+import { Binary_operatorContext } from "./CircuitScriptParser";
+import { Unary_operatorContext } from "./CircuitScriptParser";
+import { Value_exprContext } from "./CircuitScriptParser";
+import { Function_def_exprContext } from "./CircuitScriptParser";
+import { Function_exprContext } from "./CircuitScriptParser";
+import { Function_args_exprContext } from "./CircuitScriptParser";
+import { Atom_exprContext } from "./CircuitScriptParser";
+import { Trailer_exprContext } from "./CircuitScriptParser";
+import { Net_namespace_exprContext } from "./CircuitScriptParser";
+import { Function_return_exprContext } from "./CircuitScriptParser";
+import { Create_component_exprContext } from "./CircuitScriptParser";
+import { Create_graphic_exprContext } from "./CircuitScriptParser";
+import { Sub_exprContext } from "./CircuitScriptParser";
+import { Property_exprContext } from "./CircuitScriptParser";
+import { Property_key_exprContext } from "./CircuitScriptParser";
+import { Nested_propertiesContext } from "./CircuitScriptParser";
+import { Single_line_propertyContext } from "./CircuitScriptParser";
+import { Blank_exprContext } from "./CircuitScriptParser";
+import { Wire_exprContext } from "./CircuitScriptParser";
+import { Point_exprContext } from "./CircuitScriptParser";
+import { Import_exprContext } from "./CircuitScriptParser";
+import { Frame_exprContext } from "./CircuitScriptParser";
+export default class CircuitScriptVisitor<Result> extends ParseTreeVisitor<Result> {
+    visitScript?: (ctx: ScriptContext) => Result;
+    visitExpression?: (ctx: ExpressionContext) => Result;
+    visitPath_blocks?: (ctx: Path_blocksContext) => Result;
+    visitPath_block_inner?: (ctx: Path_block_innerContext) => Result;
+    visitProperty_set_expr2?: (ctx: Property_set_expr2Context) => Result;
+    visitAssignment_expr2?: (ctx: Assignment_expr2Context) => Result;
+    visitData_expr_with_assignment?: (ctx: Data_expr_with_assignmentContext) => Result;
+    visitAdd_component_expr?: (ctx: Add_component_exprContext) => Result;
+    visitComponent_select_expr?: (ctx: Component_select_exprContext) => Result;
+    visitPin_select_expr?: (ctx: Pin_select_exprContext) => Result;
+    visitPin_select_expr2?: (ctx: Pin_select_expr2Context) => Result;
+    visitAt_component_expr?: (ctx: At_component_exprContext) => Result;
+    visitTo_component_expr?: (ctx: To_component_exprContext) => Result;
+    visitAt_to_multiple_expr?: (ctx: At_to_multiple_exprContext) => Result;
+    visitAt_to_multiple_line_expr?: (ctx: At_to_multiple_line_exprContext) => Result;
+    visitAt_to_multiple_line_expr_to_pin?: (ctx: At_to_multiple_line_expr_to_pinContext) => Result;
+    visitAt_block?: (ctx: At_blockContext) => Result;
+    visitAt_block_expressions?: (ctx: At_block_expressionsContext) => Result;
+    visitAt_block_pin_expr?: (ctx: At_block_pin_exprContext) => Result;
+    visitAt_block_pin_expression_simple?: (ctx: At_block_pin_expression_simpleContext) => Result;
+    visitAt_block_pin_expression_complex?: (ctx: At_block_pin_expression_complexContext) => Result;
+    visitBreak_keyword?: (ctx: Break_keywordContext) => Result;
+    visitAssignment_expr?: (ctx: Assignment_exprContext) => Result;
+    visitKeyword_assignment_expr?: (ctx: Keyword_assignment_exprContext) => Result;
+    visitParameters?: (ctx: ParametersContext) => Result;
+    visitProperty_set_expr?: (ctx: Property_set_exprContext) => Result;
+    visitDouble_dot_property_set_expr?: (ctx: Double_dot_property_set_exprContext) => Result;
+    visitAdditionExpr?: (ctx: AdditionExprContext) => Result;
+    visitMultiplyExpr?: (ctx: MultiplyExprContext) => Result;
+    visitDataExpr?: (ctx: DataExprContext) => Result;
+    visitUnaryOperatorExpr?: (ctx: UnaryOperatorExprContext) => Result;
+    visitValueAtomExpr?: (ctx: ValueAtomExprContext) => Result;
+    visitBinaryOperatorExpr?: (ctx: BinaryOperatorExprContext) => Result;
+    visitRoundedBracketsExpr?: (ctx: RoundedBracketsExprContext) => Result;
+    visitBinary_operator?: (ctx: Binary_operatorContext) => Result;
+    visitUnary_operator?: (ctx: Unary_operatorContext) => Result;
+    visitValue_expr?: (ctx: Value_exprContext) => Result;
+    visitFunction_def_expr?: (ctx: Function_def_exprContext) => Result;
+    visitFunction_expr?: (ctx: Function_exprContext) => Result;
+    visitFunction_args_expr?: (ctx: Function_args_exprContext) => Result;
+    visitAtom_expr?: (ctx: Atom_exprContext) => Result;
+    visitTrailer_expr?: (ctx: Trailer_exprContext) => Result;
+    visitNet_namespace_expr?: (ctx: Net_namespace_exprContext) => Result;
+    visitFunction_return_expr?: (ctx: Function_return_exprContext) => Result;
+    visitCreate_component_expr?: (ctx: Create_component_exprContext) => Result;
+    visitCreate_graphic_expr?: (ctx: Create_graphic_exprContext) => Result;
+    visitSub_expr?: (ctx: Sub_exprContext) => Result;
+    visitProperty_expr?: (ctx: Property_exprContext) => Result;
+    visitProperty_key_expr?: (ctx: Property_key_exprContext) => Result;
+    visitNested_properties?: (ctx: Nested_propertiesContext) => Result;
+    visitSingle_line_property?: (ctx: Single_line_propertyContext) => Result;
+    visitBlank_expr?: (ctx: Blank_exprContext) => Result;
+    visitWire_expr?: (ctx: Wire_exprContext) => Result;
+    visitPoint_expr?: (ctx: Point_exprContext) => Result;
+    visitImport_expr?: (ctx: Import_exprContext) => Result;
+    visitFrame_expr?: (ctx: Frame_exprContext) => Result;
+}

package/build/src/draw_symbols.d.ts

@@ -0,0 +1,162 @@
+import { G } from "@svgdotjs/svg.js";
+import { Feature, GeometryProp, HorizontalAlign, Label, LabelStyle, VerticalAlign } from "./geometry.js";
+import { Logger } from "./logger.js";
+export declare abstract class SymbolGraphic {
+    drawPortsName: boolean;
+    displayBounds: boolean;
+    drawing: SymbolDrawing;
+    _angle: number;
+    width: number;
+    height: number;
+    labelTexts: Map<string, string>;
+    get angle(): number;
+    set angle(value: number);
+    refreshDrawing(calculateSize?: boolean): void;
+    calculateSize(): void;
+    abstract generateDrawing(): void;
+    size(): {
+        width: number;
+        height: number;
+    };
+    draw(group: G, extra?: {}): void;
+    drawPlaceRemove(group: G, extra?: {
+        place?: boolean;
+    }): void;
+    pinPosition(id: number): {
+        x: number;
+        y: number;
+        angle: number;
+    };
+    protected drawBounds(group: G): void;
+    protected drawBody(group: G): void;
+    protected drawPins(group: G): void;
+    protected drawLabels(group: G): void;
+    flipTextAnchor(value: HorizontalAlign): HorizontalAlign;
+    flipDominantBaseline(value: VerticalAlign): VerticalAlign;
+    setLabelValue(labelId: string, labelValue: string): void;
+    getLabelValue(labelId: string): string;
+}
+export declare function SymbolFactory(name: string): SymbolGraphic | null;
+export declare class SymbolPointHidden extends SymbolGraphic {
+    generateDrawing(): void;
+}
+export declare class SymbolText extends SymbolGraphic {
+    text: string;
+    fontSize: number;
+    fontWeight: string;
+    constructor(text: string);
+    generateDrawing(): void;
+}
+export declare class SymbolPlaceholder extends SymbolGraphic {
+    generateDrawing(): void;
+    drawPinParams(drawing: SymbolDrawingCommands, commandName: string, keywordParams: Map<string, any>, positionParams: any[]): void;
+    constructor(drawing: SymbolDrawing);
+}
+export declare enum PlaceHolderCommands {
+    arc = "arc",
+    circle = "circle",
+    rect = "rect",
+    triangle = "triangle",
+    pin = "pin",
+    hpin = "hpin",
+    vpin = "vpin",
+    hline = "hline",
+    vline = "vline",
+    line = "line",
+    label = "label",
+    path = "path",
+    lineWidth = "lineWidth",
+    fill = "fill",
+    lineColor = "lineColor"
+}
+export declare class SymbolCustom extends SymbolGraphic {
+    pinDefinition: SymbolPinDefintion[];
+    bodyWidth: number;
+    pinLength: number;
+    width: number;
+    height: number;
+    pinSpacing: number;
+    pinTextPadding: number;
+    pins: SymbolPinLayout[];
+    _cacheLeftPins: SymbolPinDefintion[];
+    _cacheRightPins: SymbolPinDefintion[];
+    constructor(pinDefinition: SymbolPinDefintion[]);
+    generateDrawing(): void;
+    calculateSize(): void;
+}
+export declare class SymbolDrawing {
+    items: (Feature | GeometryProp)[];
+    pins: [number, Feature, number][];
+    angle: number;
+    mainOrigin: [number, number];
+    logger: Logger;
+    clear(): void;
+    log(...params: any[]): void;
+    addLine(startX: number, startY: number, endX: number, endY: number): SymbolDrawing;
+    addPin(pinId: number, startX: number, startY: number, endX: number, endY: number): SymbolDrawing;
+    addVLine(startX: number, startY: number, value: number): SymbolDrawing;
+    addHLine(startX: number, startY: number, value: number): SymbolDrawing;
+    addRect(centerX: number, centerY: number, width: number, height: number): SymbolDrawing;
+    addTriangle(startX: number, startY: number, endX: number, endY: number, width: number): SymbolDrawing;
+    addRect2(x: number, y: number, x2: number, y2: number): SymbolDrawing;
+    addLabel(x: number, y: number, textValue: string, style: LabelStyle): SymbolDrawing;
+    addLabelId(id: string, x: number, y: number, textValue: string, style: LabelStyle): SymbolDrawing;
+    addPath(...pathParts: any): SymbolDrawing;
+    addSetLineWidth(value: number): SymbolDrawing;
+    addSetLineColor(value: string): SymbolDrawing;
+    addSetFillColor(value: string): SymbolDrawing;
+    addArc(x: number, y: number, radius: number, startAngle: number, endAngle: number): SymbolDrawing;
+    getPaths(): {
+        path: string;
+        fillColor: string;
+        lineColor: string;
+        lineWidth: number;
+    }[];
+    getPinsPath(): string;
+    getLabels(): Label[];
+    private featuresToPath;
+    getBoundingBox(excludeLabels?: boolean): {
+        width: number;
+        height: number;
+        start: SimplePoint;
+        end: SimplePoint;
+    };
+    getPinPosition(pinId: number): {
+        start: [number, number];
+        end: [number, number];
+        angle: number;
+    };
+}
+export type SubExpressionCommand = [
+    commandName: string,
+    positionParams: any[],
+    keywordParams: Map<string, any>
+];
+export declare class SymbolDrawingCommands extends SymbolDrawing {
+    id: string;
+    private commands;
+    constructor(commands: SubExpressionCommand[]);
+    getCommands(): SubExpressionCommand[];
+    clone(): SymbolDrawingCommands;
+}
+type SimplePoint = [x: number, y: number];
+type SymbolPinLayout = {
+    pinId: number;
+    angle: number;
+    text: string;
+    start: {
+        x: number;
+        y: number;
+    };
+    end: {
+        x: number;
+        y: number;
+    };
+};
+export type SymbolPinDefintion = {
+    side: string;
+    pinId: number;
+    text: string;
+    position: number;
+};
+export {};

package/build/src/execute.d.ts

@@ -0,0 +1,85 @@
+import { BlockTypes } from './globals.js';
+import { ClassComponent } from './objects/ClassComponent.js';
+import { ExecutionScope } from './objects/ExecutionScope.js';
+import { Net } from './objects/Net.js';
+import { ParamDefinition } from './objects/ParamDefinition.js';
+import { PinDefinition } from './objects/PinDefinition.js';
+import { CFunction, CFunctionResult, CallableParameter, ComponentPin, ReferenceType } from './objects/types.js';
+import { Logger } from './logger.js';
+export declare class ExecutionContext {
+    name: string;
+    namespace: string;
+    netNamespace: string;
+    executionLevel: number;
+    scope: ExecutionScope;
+    tmpPointId: number;
+    resolveNet: (name: string, netNamespace: string) => ({
+        found: boolean;
+        net?: Net;
+    });
+    stopFurtherExpressions: boolean;
+    returnValue: any;
+    silent: boolean;
+    logger: Logger;
+    __functionCache: {};
+    constructor(name: string, namespace: string, netNamespace: string, executionLevel: number, indentLevel: number, silent: boolean, logger: Logger);
+    print(...params: any[]): void;
+    private setupRoot;
+    instanceExists(instanceName: string): boolean;
+    getComponent(instanceName: string): ClassComponent;
+    getUniqueInstanceName(className: string): string;
+    getUniqueNetName(): string;
+    getCurrentPoint(): ComponentPin;
+    private linkComponentPinNet;
+    private mergeNets;
+    createComponent(instanceName: string, pins: PinDefinition[], params: ParamDefinition[], props: {
+        arrange?: Map<string, number[]>;
+        display?: string;
+        type?: string;
+        width?: number;
+    }): ClassComponent;
+    printPoint(extra?: string): void;
+    addComponentExisting(component: ClassComponent, pin: number): ComponentPin;
+    toComponent(component: ClassComponent, pinId: number | null, options?: {
+        addSequence?: boolean;
+        cloneNetComponent?: boolean;
+    }): ComponentPin;
+    atComponent(component: ClassComponent, pinId: number | null, options?: {
+        addSequence?: boolean;
+        cloneNetComponent?: boolean;
+    }): ComponentPin;
+    private isNetOnlyComponent;
+    private cloneComponent;
+    enterBlocks(blockType: BlockTypes): void;
+    exitBlocks(): void;
+    enterBlock(blockIndex: number): void;
+    exitBlock(blockIndex: number): void;
+    atPointBlock(): void;
+    toPointBlock(): void;
+    getPointBlockLocation(): [component: ClassComponent, pin: number, wireId: number];
+    breakBranch(): void;
+    createFunction(functionName: string, __runFunc: CFunction): void;
+    hasFunction(functionName: string): boolean;
+    getFunction(functionName: string): CFunction;
+    resolveVariable(executionStack: ExecutionContext[], idName: string): ReferenceType;
+    callFunction(functionName: string, functionParams: CallableParameter[], executionStack: ExecutionContext[], netNamespace: string): CFunctionResult;
+    mergeScope(childScope: ExecutionScope, namespace: string): void;
+    addWire(segments: [string, number?][]): void;
+    addPoint(pointId: string, userDefined?: boolean): ComponentPin;
+    setProperty(nameWithProp: string, value: any): void;
+    setCurrentComponentStyle(styles: {
+        [key: string]: number | string;
+    }): void;
+    enterFrame(): number;
+    exitFrame(frameId: number): void;
+}
+export declare function isNetComponent(component: ClassComponent): boolean;
+export declare function isLabelComponent(component: ClassComponent): boolean;
+export declare function getPortSide(pins: Map<number, PinDefinition>, arrangeProps: null | Map<string, number[]>): PortSideItem[];
+type PortSideItem = {
+    pinId: number;
+    side: string;
+    order: number;
+    position: number;
+};
+export {};

package/build/src/export.d.ts

@@ -0,0 +1,2 @@
+import { NetListItem } from "./visitor.js";
+export declare function generateKiCADNetList(netlist: NetListItem[]): string;