circuitscript 0.0.22 → 0.0.25

package/{build/src → dist/types}/antlr/CircuitScriptVisitor.d.ts

@@ -1,71 +1,77 @@
-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> {
+import { AbstractParseTreeVisitor } from "antlr4ng";
+import { ScriptContext } from "./CircuitScriptParser.js";
+import { ExpressionContext } from "./CircuitScriptParser.js";
+import { Path_blocksContext } from "./CircuitScriptParser.js";
+import { Path_block_innerContext } from "./CircuitScriptParser.js";
+import { Property_set_expr2Context } from "./CircuitScriptParser.js";
+import { Assignment_expr2Context } from "./CircuitScriptParser.js";
+import { Pin_select_exprContext } from "./CircuitScriptParser.js";
+import { Component_modifier_exprContext } from "./CircuitScriptParser.js";
+import { Data_expr_with_assignmentContext } from "./CircuitScriptParser.js";
+import { Add_component_exprContext } from "./CircuitScriptParser.js";
+import { Component_select_exprContext } from "./CircuitScriptParser.js";
+import { Pin_select_expr2Context } from "./CircuitScriptParser.js";
+import { At_component_exprContext } from "./CircuitScriptParser.js";
+import { To_component_exprContext } from "./CircuitScriptParser.js";
+import { At_to_multiple_exprContext } from "./CircuitScriptParser.js";
+import { At_to_multiple_line_exprContext } from "./CircuitScriptParser.js";
+import { At_to_multiple_line_expr_to_pinContext } from "./CircuitScriptParser.js";
+import { At_blockContext } from "./CircuitScriptParser.js";
+import { At_block_expressionsContext } from "./CircuitScriptParser.js";
+import { At_block_pin_exprContext } from "./CircuitScriptParser.js";
+import { At_block_pin_expression_simpleContext } from "./CircuitScriptParser.js";
+import { At_block_pin_expression_complexContext } from "./CircuitScriptParser.js";
+import { Break_keywordContext } from "./CircuitScriptParser.js";
+import { Assignment_exprContext } from "./CircuitScriptParser.js";
+import { Keyword_assignment_exprContext } from "./CircuitScriptParser.js";
+import { ParametersContext } from "./CircuitScriptParser.js";
+import { Property_set_exprContext } from "./CircuitScriptParser.js";
+import { Double_dot_property_set_exprContext } from "./CircuitScriptParser.js";
+import { FunctionCallExprContext } from "./CircuitScriptParser.js";
+import { AdditionExprContext } from "./CircuitScriptParser.js";
+import { MultiplyExprContext } from "./CircuitScriptParser.js";
+import { DataExprContext } from "./CircuitScriptParser.js";
+import { UnaryOperatorExprContext } from "./CircuitScriptParser.js";
+import { ValueAtomExprContext } from "./CircuitScriptParser.js";
+import { BinaryOperatorExprContext } from "./CircuitScriptParser.js";
+import { RoundedBracketsExprContext } from "./CircuitScriptParser.js";
+import { Binary_operatorContext } from "./CircuitScriptParser.js";
+import { Unary_operatorContext } from "./CircuitScriptParser.js";
+import { Value_exprContext } from "./CircuitScriptParser.js";
+import { Function_def_exprContext } from "./CircuitScriptParser.js";
+import { Function_exprContext } from "./CircuitScriptParser.js";
+import { Function_args_exprContext } from "./CircuitScriptParser.js";
+import { Atom_exprContext } from "./CircuitScriptParser.js";
+import { Trailer_exprContext } from "./CircuitScriptParser.js";
+import { Function_call_exprContext } from "./CircuitScriptParser.js";
+import { Net_namespace_exprContext } from "./CircuitScriptParser.js";
+import { Function_return_exprContext } from "./CircuitScriptParser.js";
+import { Create_component_exprContext } from "./CircuitScriptParser.js";
+import { Create_graphic_exprContext } from "./CircuitScriptParser.js";
+import { Sub_exprContext } from "./CircuitScriptParser.js";
+import { Property_exprContext } from "./CircuitScriptParser.js";
+import { Property_key_exprContext } from "./CircuitScriptParser.js";
+import { Nested_propertiesContext } from "./CircuitScriptParser.js";
+import { Single_line_propertyContext } from "./CircuitScriptParser.js";
+import { Blank_exprContext } from "./CircuitScriptParser.js";
+import { Wire_expr_direction_valueContext } from "./CircuitScriptParser.js";
+import { Wire_expr_direction_onlyContext } from "./CircuitScriptParser.js";
+import { Wire_exprContext } from "./CircuitScriptParser.js";
+import { Point_exprContext } from "./CircuitScriptParser.js";
+import { Import_exprContext } from "./CircuitScriptParser.js";
+import { Frame_exprContext } from "./CircuitScriptParser.js";
+export declare class CircuitScriptVisitor<Result> extends AbstractParseTreeVisitor<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;
+    visitPin_select_expr?: (ctx: Pin_select_exprContext) => Result;
+    visitComponent_modifier_expr?: (ctx: Component_modifier_exprContext) => 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;
@@ -83,6 +89,7 @@ export default class CircuitScriptVisitor<Result> extends ParseTreeVisitor<Resul
     visitParameters?: (ctx: ParametersContext) => Result;
     visitProperty_set_expr?: (ctx: Property_set_exprContext) => Result;
     visitDouble_dot_property_set_expr?: (ctx: Double_dot_property_set_exprContext) => Result;
+    visitFunctionCallExpr?: (ctx: FunctionCallExprContext) => Result;
     visitAdditionExpr?: (ctx: AdditionExprContext) => Result;
     visitMultiplyExpr?: (ctx: MultiplyExprContext) => Result;
     visitDataExpr?: (ctx: DataExprContext) => Result;
@@ -98,6 +105,7 @@ export default class CircuitScriptVisitor<Result> extends ParseTreeVisitor<Resul
     visitFunction_args_expr?: (ctx: Function_args_exprContext) => Result;
     visitAtom_expr?: (ctx: Atom_exprContext) => Result;
     visitTrailer_expr?: (ctx: Trailer_exprContext) => Result;
+    visitFunction_call_expr?: (ctx: Function_call_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;
@@ -108,6 +116,8 @@ export default class CircuitScriptVisitor<Result> extends ParseTreeVisitor<Resul
     visitNested_properties?: (ctx: Nested_propertiesContext) => Result;
     visitSingle_line_property?: (ctx: Single_line_propertyContext) => Result;
     visitBlank_expr?: (ctx: Blank_exprContext) => Result;
+    visitWire_expr_direction_value?: (ctx: Wire_expr_direction_valueContext) => Result;
+    visitWire_expr_direction_only?: (ctx: Wire_expr_direction_onlyContext) => Result;
     visitWire_expr?: (ctx: Wire_exprContext) => Result;
     visitPoint_expr?: (ctx: Point_exprContext) => Result;
     visitImport_expr?: (ctx: Import_exprContext) => Result;

package/{build/src → dist/types}/draw_symbols.d.ts

@@ -6,11 +6,17 @@ export declare abstract class SymbolGraphic {
     displayBounds: boolean;
     drawing: SymbolDrawing;
     _angle: number;
+    _flipX: number;
+    _flipY: number;
     width: number;
     height: number;
     labelTexts: Map<string, string>;
     get angle(): number;
     set angle(value: number);
+    get flipX(): number;
+    set flipX(value: number);
+    get flipY(): number;
+    set flipY(value: number);
     refreshDrawing(calculateSize?: boolean): void;
     calculateSize(): void;
     abstract generateDrawing(): void;
@@ -18,7 +24,7 @@ export declare abstract class SymbolGraphic {
         width: number;
         height: number;
     };
-    draw(group: G, extra?: {}): void;
+    draw(group: G, extra?: unknown): void;
     drawPlaceRemove(group: G, extra?: {
         place?: boolean;
     }): void;
@@ -31,12 +37,13 @@ export declare abstract class SymbolGraphic {
     protected drawBody(group: G): void;
     protected drawPins(group: G): void;
     protected drawLabels(group: G): void;
+    roundValues(value: number): number;
     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 function SymbolFactory(name: string): SymbolGraphic;
 export declare class SymbolPointHidden extends SymbolGraphic {
     generateDrawing(): void;
 }
@@ -88,6 +95,8 @@ export declare class SymbolDrawing {
     items: (Feature | GeometryProp)[];
     pins: [number, Feature, number][];
     angle: number;
+    flipX: number;
+    flipY: number;
     mainOrigin: [number, number];
     logger: Logger;
     clear(): void;

package/{build/src → dist/types}/execute.d.ts

@@ -18,15 +18,14 @@ export declare class ExecutionContext {
         net?: Net;
     });
     stopFurtherExpressions: boolean;
-    returnValue: any;
+    returnValue: null;
     silent: boolean;
     logger: Logger;
     __functionCache: {};
-    constructor(name: string, namespace: string, netNamespace: string, executionLevel: number, indentLevel: number, silent: boolean, logger: Logger);
-    print(...params: any[]): void;
+    parentContext: ExecutionContext;
+    constructor(name: string, namespace: string, netNamespace: string, executionLevel: number | undefined, indentLevel: number | undefined, silent: boolean | undefined, logger: Logger, parent: ExecutionContext);
+    log(...params: any[]): void;
     private setupRoot;
-    instanceExists(instanceName: string): boolean;
-    getComponent(instanceName: string): ClassComponent;
     getUniqueInstanceName(className: string): string;
     getUniqueNetName(): string;
     getCurrentPoint(): ComponentPin;
@@ -42,14 +41,11 @@ export declare class ExecutionContext {
     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;
+    cloneComponent(component: ClassComponent): ClassComponent;
     enterBlocks(blockType: BlockTypes): void;
     exitBlocks(): void;
     enterBlock(blockIndex: number): void;
@@ -75,6 +71,7 @@ export declare class ExecutionContext {
 }
 export declare function isNetComponent(component: ClassComponent): boolean;
 export declare function isLabelComponent(component: ClassComponent): boolean;
+export declare function isNetOnlyComponent(component: ClassComponent): boolean;
 export declare function getPortSide(pins: Map<number, PinDefinition>, arrangeProps: null | Map<string, number[]>): PortSideItem[];
 type PortSideItem = {
     pinId: number;

package/{build/src → dist/types}/geometry.d.ts

@@ -26,10 +26,11 @@ export declare class Label extends Flatten.Polygon {
     font: string;
     style: LabelStyle;
     textMeasurementBounds: Box;
-    get box(): any;
+    get box(): Flatten.Box;
     constructor(id: string, text: string, anchorPoint: [number, number], polygon: Flatten.Polygon, style: LabelStyle, bounds: Box);
     static fromPoint(id: string, x: number, y: number, text: string, style: LabelStyle): Label;
     rotate(angle: number, origin: Flatten.Point): Label;
+    transform(matrix: Flatten.Matrix): Label;
     getLabelPosition(): [number, number];
 }
 export declare class GeometryProp {
@@ -47,7 +48,9 @@ export declare class Geometry {
     static arc(center: [x: number, y: number], radius: number, startAngle: number, endAngle: number, sweepDirection: boolean): Arc;
     static getCoords(item: Feature): [number, number][];
     static rotateDegs(feature: Feature, angleDegrees: number, center: [number, number]): Feature;
+    static flip(feature: Feature, flipX: number, flipY: number): Feature;
     static groupRotate(features: Feature[], angle: number, center: [number, number]): Feature[];
+    static groupFlip(features: Feature[], flipX: number, flipY: number): Feature[];
     static groupBounds(features: Feature[]): {
         start: [number, number];
         end: [number, number];
@@ -60,6 +63,7 @@ export declare class Geometry {
         path: string;
         isClosedPolygon: boolean;
     };
+    static roundPathValues(pathItems: (string | number)[]): string;
     static angle(dx: number, dy: number): number;
     static getQuadrant(dx: number, dy: number): number;
     static mergeWires(wirePoints: {

package/dist/types/helpers.d.ts

@@ -0,0 +1,40 @@
+import { SymbolValidatorVisitor } from "./SymbolValidatorVisitor.js";
+import { CommonTokenStream, DefaultErrorStrategy, Parser } from "antlr4ng";
+import { CircuitScriptParser } from "./antlr/CircuitScriptParser.js";
+import { CircuitScriptLexer } from "./antlr/CircuitScriptLexer.js";
+import { IParsedToken, SemanticTokensVisitor } from "./SemanticTokenVisitor.js";
+export declare enum JSModuleType {
+    CommonJs = "cjs",
+    ESM = "mjs"
+}
+export type ScriptOptions = {
+    currentDirectory: string | null;
+    defaultLibsPath: string;
+    dumpNets: boolean;
+    dumpData: boolean;
+    kicadNetlistPath: string | null;
+    showStats: boolean;
+};
+export declare function prepareFile(textData: string): {
+    parser: CircuitScriptParser;
+    lexer: CircuitScriptLexer;
+    lexerTimeTaken: number;
+    tokens: CommonTokenStream;
+};
+export declare function getScriptText(filePath: string): string | null;
+export declare function getSemanticTokens(scriptData: string, options: ScriptOptions): {
+    visitor: SemanticTokensVisitor;
+    parsedTokens: IParsedToken[];
+};
+export declare class ParseErrorStrategy extends DefaultErrorStrategy {
+    reportUnwantedToken(recognizer: Parser): void;
+}
+export declare function validateScript(scriptData: string, options: ScriptOptions): SymbolValidatorVisitor;
+export declare function renderScript(scriptData: string, outputPath: string, options: ScriptOptions): string | null;
+export declare function detectJSModuleType(): JSModuleType;
+export declare function getCurrentPath(): {
+    filePath: string;
+};
+export declare function getFontsPath(): string;
+export declare function getDefaultLibsPath(): string;
+export declare function getPackageVersion(): string;

package/dist/types/index.d.ts

@@ -0,0 +1,15 @@
+export * from './draw_symbols.js';
+export * from './execute.js';
+export * from './export.js';
+export * from './geometry.js';
+export * from './globals.js';
+export * from './helpers.js';
+export * from './layout.js';
+export * from './lexer.js';
+export * from './logger.js';
+export * from './parser.js';
+export * from './render.js';
+export * from './utils.js';
+export * from './visitor.js';
+export * from './sizing.js';
+export * from './objects/types.js';

package/{build/src → dist/types}/layout.d.ts

@@ -1,4 +1,4 @@
-import graphlib from '@dagrejs/graphlib';
+import { Graph, Edge } from '@dagrejs/graphlib';
 import { SymbolGraphic, SymbolText } from "./draw_symbols.js";
 import { ClassComponent } from "./objects/ClassComponent.js";
 import { SequenceItem } from "./objects/ExecutionScope.js";
@@ -27,7 +27,7 @@ export declare class LayoutEngine {
         junctions: RenderJunction[];
         mergedWires: MergedWire[];
     };
-    placeFrames(graph: graphlib.Graph, subgraphInfo: SubGraphInfo[], frameObjects: RenderFrame[]): {
+    placeFrames(graph: Graph, subgraphInfo: SubGraphInfo[], frameObjects: RenderFrame[]): {
         elementFrames: RenderFrame[];
         textObjects: RenderText[];
     };
@@ -35,23 +35,23 @@ export declare class LayoutEngine {
     applyFrameOffset(frame: RenderFrame, level?: number): void;
     placeAndSizeFrame(frame: RenderFrame, level?: number): void;
     dumpFrame(frame: RenderFrame, level?: number): void;
-    prepareFrames(graph: graphlib.Graph, subgraphInfo: SubGraphInfo[], frame: RenderFrame, level?: number): {
+    prepareFrames(graph: Graph, subgraphInfo: SubGraphInfo[], frame: RenderFrame, level?: number): {
         elementFrames: RenderFrame[];
         textObjects: RenderText[];
     };
     generateLayoutGraph(sequence: SequenceItem[], nets: [ClassComponent, pin: number, net: Net][]): {
-        graph: graphlib.Graph;
+        graph: Graph;
         containerFrames: RenderFrame[];
     };
-    setGraphEdge(graph: graphlib.Graph, node1: string, node2: string, edgeValue: EdgeValue): void;
-    sizeSubGraphs(graph: graphlib.Graph): SubGraphInfo[];
-    walkAndPlaceGraph(graph: graphlib.Graph, firstNodeId: string, subgraphNodes: string[]): void;
-    placeSubgraphV2(graph: graphlib.Graph, firstNodeId: string, subgraphEdges: graphlib.Edge[]): void;
+    setGraphEdge(graph: Graph, node1: string, node2: string, edgeValue: EdgeValue): void;
+    sizeSubGraphs(graph: Graph): SubGraphInfo[];
+    walkAndPlaceGraph(graph: Graph, firstNodeId: string, subgraphNodes: string[]): void;
+    placeSubgraphV2(graph: Graph, firstNodeId: string, subgraphEdges: Edge[]): void;
     mergeOriginNodes(node1: RenderItem, pin1: number, node2: RenderItem, pin2: number, originNode1: string, originNode2: string, originNodes: RenderItem[], originNodeGroups: Map<string, RenderItem[]>): void;
-    placeSubgraph(graph: graphlib.Graph, firstNodeId: string, subgraphEdges: graphlib.Edge[]): void;
+    placeSubgraph(graph: Graph, firstNodeId: string, subgraphEdges: Edge[]): void;
     translateNodeBy(offsetX: number, offsetY: number, item: RenderItem): void;
     placeNodeAtPosition(fromX: number, fromY: number, item: RenderItem, pin: number, depth?: number): void;
-    placeFloatingItems(graph: graphlib.Graph, item: RenderItem, depth?: number): void;
+    placeFloatingItems(graph: Graph, item: RenderItem, depth?: number): void;
     printWarnings(): void;
 }
 type EdgeValue = [

package/{build/src → dist/types}/lexer.d.ts

@@ -1,5 +1,5 @@
-import { CharStream, Token } from "antlr4";
-import CircuitScriptLexer from "./antlr/CircuitScriptLexer.js";
+import { CharStream, Token } from "antlr4ng";
+import { CircuitScriptLexer } from "./antlr/CircuitScriptLexer.js";
 export declare class MainLexer extends CircuitScriptLexer {
     tokens: any[];
     indents: any[];

package/{build/src → dist/types}/objects/ClassComponent.d.ts

@@ -1,6 +1,6 @@
 import { SymbolDrawingCommands } from '../draw_symbols.js';
 import { Net } from './Net.js';
-import { PinDefinition } from './PinDefinition.js';
+import { PinDefinition, PinId } from './PinDefinition.js';
 import { WireSegment } from './Wire.js';
 export declare class ClassComponent {
     instanceName: string;
@@ -26,7 +26,7 @@ export declare class ClassComponent {
     setupPins(): void;
     getDefaultPin(): number;
     hasPin(pinId: number | string): boolean;
-    getPin(pinId: number | string): number;
+    getPin(pinId: number | string): PinId;
     getNextPinAfter(pinIndex: number): number;
     setParam(key: string, value: number | string): void;
     private refreshParamCache;

package/{build/src → dist/types}/objects/ExecutionScope.d.ts

@@ -1,6 +1,6 @@
 import { ClassComponent } from './ClassComponent.js';
 import { Net } from './Net.js';
-import { CFunction, ComponentPinNet, ComponentPinNetPair, ValueType } from './types.js';
+import { CFunction, ComponentPinNet, ComponentPinNetPair, ParseSymbolType, ValueType } from './types.js';
 import { LayoutDirection } from '../globals.js';
 import { Wire, WireSegment } from './Wire.js';
 import { Frame } from './Frame.js';
@@ -10,6 +10,9 @@ export declare class ExecutionScope {
     instances: Map<string, ClassComponent>;
     functions: Map<string, CFunction>;
     variables: Map<string, ValueType | ClassComponent>;
+    symbols: Map<string, {
+        type: ParseSymbolType;
+    }>;
     blockStack: Map<number, any>;
     wires: Wire[];
     frames: Frame[];

package/{build/src → dist/types}/objects/PinDefinition.d.ts

@@ -8,7 +8,7 @@ export declare class PinDefinition {
     altNames: string[];
     side: string;
     position: number;
-    constructor(id: PinId, idType: PinIdType, name: string, pinType?: PinTypes, altNames?: any[]);
+    constructor(id: PinId, idType: PinIdType, name: string, pinType?: PinTypes, altNames?: never[]);
 }
 export declare enum PinIdType {
     Int = "int",

package/{build/src → dist/types}/objects/types.d.ts

@@ -47,3 +47,8 @@ export type ReferenceType = {
     type?: string;
     value?: any;
 };
+export declare enum ParseSymbolType {
+    Variable = "variable",
+    Function = "function",
+    Undefined = "undefined"
+}

package/dist/types/parser.d.ts

@@ -0,0 +1,25 @@
+import { CircuitScriptParser, ScriptContext } from './antlr/CircuitScriptParser.js';
+import { ANTLRErrorListener, ATNConfigSet, ATNSimulator, BitSet, DefaultErrorStrategy, DFA, Parser, RecognitionException, Recognizer, Token } from 'antlr4ng';
+import { BaseVisitor, OnErrorCallback } from './BaseVisitor.js';
+export declare function parseFileWithVisitor(visitor: BaseVisitor, data: string): {
+    tree: ScriptContext;
+    parser: CircuitScriptParser;
+    hasError: boolean;
+    hasParseError: boolean;
+    parserTimeTaken: number;
+    lexerTimeTaken: number;
+};
+export declare class TempErrorStrategy extends DefaultErrorStrategy {
+    recover(recognizer: Parser, e: RecognitionException): void;
+    reportError(recognizer: Parser, e: RecognitionException): void;
+}
+export declare class CircuitscriptParserErrorListener implements ANTLRErrorListener {
+    syntaxErrorCounter: number;
+    onErrorHandler: OnErrorCallback | null;
+    constructor(onErrorHandler?: OnErrorCallback | null);
+    syntaxError<S extends Token, T extends ATNSimulator>(recognizer: Recognizer<T>, offendingSymbol: S | null, line: number, charPositionInLine: number, msg: string, e: RecognitionException | null): void;
+    reportAmbiguity(recognizer: Parser, dfa: DFA, startIndex: number, stopIndex: number, exact: boolean, ambigAlts: BitSet | undefined, configs: ATNConfigSet): void;
+    reportAttemptingFullContext(recognizer: Parser, dfa: DFA, startIndex: number, stopIndex: number, conflictingAlts: BitSet | undefined, configs: ATNConfigSet): void;
+    reportContextSensitivity(recognizer: Parser, dfa: DFA, startIndex: number, stopIndex: number, prediction: number, configs: ATNConfigSet): void;
+    hasSyntaxErrors(): boolean;
+}

package/{build/src → dist/types}/render.d.ts

@@ -4,7 +4,7 @@ export declare function generateSVG2(graph: {
     wires: RenderWire[];
     junctions: RenderJunction[];
     mergedWires: MergedWire[];
-    debugRects: BoundBox[];
+    debugRects?: BoundBox[];
     frameObjects: RenderFrame[];
     textObjects: RenderText[];
 }): string;

package/{build/src → dist/types}/sizing.d.ts

@@ -1,6 +1,8 @@
 import { Box, SVGTypeMapping } from '@svgdotjs/svg.js';
 import { HorizontalAlign, VerticalAlign } from './geometry.js';
-export declare function prepareSizing(fontsPath: any): Promise<void>;
+import { SVGWindow } from 'svgdom';
+export declare function prepareSVGEnvironment(fontsPath: string | null): Promise<void>;
+export declare function getCreateSVGWindow(): () => SVGWindow;
 export declare function applyFontsToSVG(canvas: SVGTypeMapping): void;
 export declare function measureTextSize(text: string, fontFamily: string, fontSize: number): Promise<{
     width: number;

package/dist/types/validate.d.ts

@@ -0,0 +1,2 @@
+#! /usr/bin/env node
+export declare function validate(): Promise<void>;

package/dist/types/visitor.d.ts

@@ -0,0 +1,80 @@
+import { Add_component_exprContext, AdditionExprContext, At_blockContext, At_block_pin_exprContext, At_block_pin_expression_complexContext, At_block_pin_expression_simpleContext, At_component_exprContext, BinaryOperatorExprContext, Path_blocksContext, Component_select_exprContext, Create_component_exprContext, Create_graphic_exprContext, DataExprContext, Data_expr_with_assignmentContext, Double_dot_property_set_exprContext, Frame_exprContext, Function_def_exprContext, Keyword_assignment_exprContext, MultiplyExprContext, Nested_propertiesContext, Net_namespace_exprContext, Pin_select_expr2Context, Pin_select_exprContext, Point_exprContext, Property_exprContext, Property_key_exprContext, Property_set_exprContext, Single_line_propertyContext, Sub_exprContext, To_component_exprContext, Wire_exprContext, UnaryOperatorExprContext, Wire_expr_direction_onlyContext, Wire_expr_direction_valueContext } from './antlr/CircuitScriptParser.js';
+import { ClassComponent } from './objects/ClassComponent.js';
+import { PinTypes } from './objects/PinTypes.js';
+import { ComponentPin, ComponentPinNet } from './objects/types.js';
+import { Net } from './objects/Net.js';
+import { BaseVisitor } from './BaseVisitor.js';
+import { ParserRuleContext } from 'antlr4ng';
+export declare class ParserVisitor extends BaseVisitor {
+    visitKeyword_assignment_expr: (ctx: Keyword_assignment_exprContext) => void;
+    visitPin_select_expr: (ctx: Pin_select_exprContext) => void;
+    visitAdd_component_expr: (ctx: Add_component_exprContext) => ComponentPin;
+    visitAt_component_expr: (ctx: At_component_exprContext) => ComponentPin;
+    visitTo_component_expr: (ctx: To_component_exprContext) => ComponentPin;
+    visitComponent_select_expr: (ctx: Component_select_exprContext) => void;
+    visitPath_blocks: (ctx: Path_blocksContext) => ComponentPin;
+    visitCreate_component_expr: (ctx: Create_component_exprContext) => void;
+    visitCreate_graphic_expr: (ctx: Create_graphic_exprContext) => void;
+    visitSub_expr: (ctx: Sub_exprContext) => void;
+    visitProperty_expr: (ctx: Property_exprContext) => void;
+    visitSingle_line_property: (ctx: Single_line_propertyContext) => void;
+    visitNested_properties: (ctx: Nested_propertiesContext) => void;
+    visitProperty_key_expr: (ctx: Property_key_exprContext) => void;
+    visitData_expr_with_assignment: (ctx: Data_expr_with_assignmentContext) => void;
+    visitUnaryOperatorExpr: (ctx: UnaryOperatorExprContext) => void;
+    visitDataExpr: (ctx: DataExprContext) => void;
+    visitBinaryOperatorExpr: (ctx: BinaryOperatorExprContext) => void;
+    visitMultiplyExpr: (ctx: MultiplyExprContext) => void;
+    visitAdditionExpr: (ctx: AdditionExprContext) => void;
+    visitFunction_def_expr: (ctx: Function_def_exprContext) => void;
+    visitPin_select_expr2: (ctx: Pin_select_expr2Context) => void;
+    visitAt_block_pin_expr: (ctx: At_block_pin_exprContext) => void;
+    visitAt_block: (ctx: At_blockContext) => void;
+    visitAt_block_pin_expression_simple: (ctx: At_block_pin_expression_simpleContext) => void;
+    visitAt_block_pin_expression_complex: (ctx: At_block_pin_expression_complexContext) => void;
+    visitWire_expr_direction_only: (ctx: Wire_expr_direction_onlyContext) => void;
+    visitWire_expr_direction_value: (ctx: Wire_expr_direction_valueContext) => void;
+    visitWire_expr: (ctx: Wire_exprContext) => void;
+    visitPoint_expr: (ctx: Point_exprContext) => ComponentPin;
+    visitProperty_set_expr: (ctx: Property_set_exprContext) => void;
+    visitDouble_dot_property_set_expr: (ctx: Double_dot_property_set_exprContext) => void;
+    visitFrame_expr: (ctx: Frame_exprContext) => void;
+    visitNet_namespace_expr: (ctx: Net_namespace_exprContext) => void;
+    pinTypes: PinTypes[];
+    private parseCreateComponentPins;
+    private parseCreateComponentParams;
+    printNets(): void;
+    dumpNets(): ComponentPinNet[];
+    dumpUniqueNets(): Net[];
+    dumpVariables(): Map<string, any>;
+    dumpInstances(): Map<string, ClassComponent>;
+    dump2(): {
+        name: string;
+        refdes: string;
+        pins: {};
+    }[];
+    getNetList(): NetListItem[];
+    getGraph(): {
+        sequence: any[];
+        nets: import("./objects/types.js").ComponentPinNetPair[];
+        components: ClassComponent[];
+    };
+    annotateComponents(): void;
+    private resolveNets;
+    private setComponentOrientation;
+    private setComponentFlip;
+    private getPropertyExprList;
+}
+export type NetListItem = {
+    instanceName: string;
+    instance: ClassComponent;
+    pins: {
+        [key: string | number]: string;
+    };
+};
+export declare class VisitorExecutionException {
+    errorMessage: string;
+    context: ParserRuleContext;
+    constructor(context: ParserRuleContext, errorMessage: string);
+    print(scriptData: string): void;
+}

package/libs/lib.cst

@@ -1,5 +1,3 @@
-// Circuitscript default lib
-
 def net(net_name):
     return create component:
         pins: 1