circuitscript 0.1.7 → 0.1.9

package/dist/types/BaseVisitor.d.ts

@@ -6,6 +6,7 @@ import { ClassComponent } from "./objects/ClassComponent.js";
 import { Net } from "./objects/Net.js";
 import { CallableParameter, CFunctionOptions, ComplexType, Direction, FunctionDefinedParameter, ReferenceType } from "./objects/types.js";
 import { ParserRuleContext } from 'antlr4ng';
+import { ExecutionWarning } from "./utils.js";
 import { BaseError } from './utils.js';
 import { ExecutionScope } from './objects/ExecutionScope.js';
 import { NodeScriptEnvironment } from "./environment.js";
@@ -24,6 +25,7 @@ export declare class BaseVisitor extends CircuitScriptVisitor<ComplexType | Refe
     onErrorHandler: OnErrorHandler | null;
     environment: NodeScriptEnvironment;
     protected importedFiles: ImportFile[];
+    protected warnings: ExecutionWarning[];
     onImportFile: (visitor: BaseVisitor, filePath: string, fileData: string, onErrorHandler: OnErrorHandler) => Promise<{
         hasError: boolean;
         hasParseError: boolean;
@@ -60,7 +62,7 @@ export declare class BaseVisitor extends CircuitScriptVisitor<ComplexType | Refe
     visitArrayExpr: (ctx: ArrayExprContext) => void;
     protected setResult(ctx: ParserRuleContext, value: any): void;
     protected getResult(ctx: ParserRuleContext): any;
-    protected visitResult(ctx: ParserRuleContext): any;
+    visitResult(ctx: ParserRuleContext): any;
     protected handleImportFile(name: string, throwErrors?: boolean, ctx?: ParserRuleContext | null): Promise<ImportFile>;
     visitRoundedBracketsExpr: (ctx: RoundedBracketsExprContext) => void;
     protected setupDefinedParameters(funcDefinedParameters: FunctionDefinedParameter[], passedInParameters: CallableParameter[], executor: ExecutionContext): void;

package/dist/types/execute.d.ts

@@ -1,4 +1,5 @@
 import { BlockTypes, FrameType } from './globals.js';
+import { ExecutionWarning } from "./utils.js";
 import { ClassComponent } from './objects/ClassComponent.js';
 import { ExecutionScope } from './objects/ExecutionScope.js';
 import { Net } from './objects/Net.js';
@@ -28,7 +29,9 @@ export declare class ExecutionContext {
     __functionCache: {};
     parentContext: ExecutionContext;
     componentAngleFollowsWire: boolean;
-    constructor(name: string, namespace: string, netNamespace: string, executionLevel: number | undefined, indentLevel: number | undefined, silent: boolean | undefined, logger: Logger, parent: ExecutionContext);
+    warnings: ExecutionWarning[];
+    constructor(name: string, namespace: string, netNamespace: string, executionLevel: number | undefined, indentLevel: number | undefined, silent: boolean | undefined, logger: Logger, warnings: ExecutionWarning[], parent: ExecutionContext);
+    logWarning(message: string, context?: ParserRuleContext, fileName?: string): void;
     log(...params: any[]): void;
     private setupRoot;
     getUniqueInstanceName(): string;
@@ -46,6 +49,8 @@ export declare class ExecutionContext {
         angle?: NumericValue;
         followWireOrientation: boolean;
     }, isModule?: boolean): ClassComponent;
+    private removeArrangePropDuplicates;
+    private getArrangePropPins;
     printPoint(extra?: string): void;
     addComponentExisting(component: ClassComponent, pin: number): ComponentPin;
     toComponent(component: ClassComponent, pinId: number | null, options?: {

package/dist/types/layout.d.ts

@@ -0,0 +1,148 @@
+import { Graph } from '@dagrejs/graphlib';
+import { SymbolGraphic, SymbolText, SymbolDrawingCommands } from "./draw_symbols.js";
+import { ClassComponent } from "./objects/ClassComponent.js";
+import { SequenceItem } from "./objects/ExecutionScope.js";
+import { WireAutoDirection } from './globals.js';
+import { WireSegment } from './objects/Wire.js';
+import { Net } from './objects/Net.js';
+import { Logger } from './logger.js';
+import { Frame, FramePlotDirection } from './objects/Frame.js';
+import { BoundBox } from './utils.js';
+import { NumericValue } from './objects/ParamDefinition.js';
+export declare class LayoutEngine {
+    logger: Logger;
+    layoutWarnings: string[];
+    showBaseFrame: boolean;
+    constructor(options?: {
+        showBaseFrame: boolean;
+    });
+    protected print(...params: any[]): void;
+    protected printLevel(level: number, ...params: any[]): void;
+    protected padLevel(value: number): string;
+    runLayout(sequence: SequenceItem[], nets: [ClassComponent, pin: number, net: Net][]): SheetFrame[];
+    private flattenFrameItems;
+    private findJunctions;
+    private placeFrames;
+    collectElementFrames(frame: RenderFrame, level?: number): RenderFrame[];
+    applyFrameOffset(frame: RenderFrame, level?: number): void;
+    private placeAndSizeFrame;
+    dumpFrame(frame: RenderFrame, level?: number): void;
+    private prepareFrames;
+    private checkAddFrameTitle;
+    generateLayoutGraph(sequence: SequenceItem[], nets: [ClassComponent, pin: number, net: Net][]): {
+        graph: Graph;
+        containerFrames: RenderFrame[];
+    };
+    private setGraphEdge;
+    private sizeSubGraphs;
+    private walkAndPlaceGraph;
+    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;
+    placeFloatingItems(graph: Graph, item: RenderItem, depth?: number): void;
+    printWarnings(): void;
+}
+type RenderItem = RenderComponent | RenderWire | RenderText;
+export declare function applyComponentParamsToSymbol(component: ClassComponent, symbol: SymbolGraphic): void;
+export declare function getBounds(components: (RenderComponent | RenderText)[], wires: RenderWire[], junctions: RenderJunction[], frames: RenderFrame[]): BoundBox;
+export declare class RenderObject {
+    x: NumericValue;
+    y: NumericValue;
+    isFloating: boolean;
+    floatingRelativeTo: [selfPin: number, nodeId: string, pin: number][];
+}
+export declare class RenderWire extends RenderObject {
+    id: number;
+    segments: WireSegment[];
+    points: {
+        x: number;
+        y: number;
+    }[];
+    netName: string;
+    constructor(x: NumericValue, y: NumericValue, segments: WireSegment[]);
+    refreshPoints(): void;
+    getAutoPoints(value: [x: NumericValue, y: NumericValue], direction: WireAutoDirection): [dx: number, dy: number][];
+    getWireEnd(): {
+        x: number;
+        y: number;
+    };
+    isEndAutoLength(): boolean;
+    getEndAuto(): [instance: ClassComponent, pin: number];
+    setEndAuto(untilX: NumericValue, untilY: NumericValue): void;
+    toString(): string;
+}
+export type MergedWire = {
+    netName: string;
+    segments: [x: number, y: number][][];
+    intersectPoints: [x: number, y: number, count: number][];
+};
+export declare class RenderComponent extends RenderObject {
+    component: ClassComponent;
+    symbol: SymbolGraphic;
+    width: number;
+    height: number;
+    displaySymbol: string | null;
+    constructor(component: ClassComponent, width: number, height: number);
+    doesOverlap(other: RenderComponent): boolean;
+    toString(): string;
+}
+export declare class RenderText extends RenderObject {
+    symbol: SymbolText;
+    _fontSize: NumericValue;
+    _fontWeight: string;
+    get fontSize(): NumericValue;
+    set fontSize(value: NumericValue);
+    get fontWeight(): string;
+    set fontWeight(value: string);
+    constructor(text: string);
+}
+export declare class RenderFrame extends RenderObject {
+    bounds: BoundBox | null;
+    frame: Frame;
+    innerItems: (RenderComponent | RenderFrame | RenderText)[];
+    translateX: number;
+    translateY: number;
+    padding: NumericValue;
+    gap: NumericValue;
+    borderWidth: NumericValue;
+    direction: FramePlotDirection;
+    width: NumericValue | null;
+    height: NumericValue | null;
+    subgraphId: string;
+    renderType: RenderFrameType;
+    containsTitle: boolean;
+    constructor(frame: Frame, type?: RenderFrameType);
+    toString(): string;
+}
+export declare enum RenderFrameType {
+    Container = 1,
+    Elements = 2
+}
+export declare class RenderJunction {
+    x: NumericValue;
+    y: NumericValue;
+    constructor(x: NumericValue, y: NumericValue);
+}
+export type SheetFrame = {
+    frame: RenderFrame;
+    frames: RenderFrame[];
+    components: RenderComponent[];
+    wires: RenderWire[];
+    textObjects: RenderText[];
+    junctions: RenderJunction[];
+    mergedWires: MergedWire[];
+};
+export declare function CalculatePinPositions(component: ClassComponent): Map<number, {
+    x: NumericValue;
+    y: NumericValue;
+    angle: NumericValue;
+}>;
+export declare function ExtractDrawingRects(drawing: SymbolDrawingCommands): {
+    x: NumericValue;
+    y: NumericValue;
+    width: NumericValue;
+    height: NumericValue;
+    className: string | undefined;
+}[];
+export { BoundBox };

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

@@ -18,6 +18,7 @@ export declare class ClassComponent {
     _copyID?: number;
     _copyFrom?: ClassComponent;
     _pointLinkComponent?: ClassComponent;
+    _unplacedPins: number[];
     arrangeProps: Map<string, NumericValue[]> | null;
     displayProp: SymbolDrawingCommands | null;
     widthProp: number | null;

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

@@ -5,6 +5,7 @@ import { LayoutDirection } from '../globals.js';
 import { Wire, WireSegment } from './Wire.js';
 import { Frame } from './Frame.js';
 import { ParserRuleContext } from 'antlr4ng';
+import { BaseVisitor } from 'src/BaseVisitor.js';
 type OnPropertyHandler = (path: PropertyTreeKey[], value: any, valueContext: ParserRuleContext) => void;
 export type PropertyTreeKey = [ctx: ParserRuleContext, value: any] | ['index', number];
 export declare class ExecutionScope {
@@ -50,10 +51,10 @@ export declare class ExecutionScope {
     setCurrent(component: ClassComponent | null, pin?: number | null): void;
     enterContext(context: ParserRuleContext): void;
     exitContext(): ParserRuleContext;
-    findPropertyKeyTree(): PropertyTreeKey[];
+    private findPropertyKeyTree;
     setOnPropertyHandler(handler: OnPropertyHandler): void;
     popOnPropertyHandler(): OnPropertyHandler;
-    triggerPropertyHandler(value: any, valueCtx: ParserRuleContext): void;
+    triggerPropertyHandler(visitor: BaseVisitor, value: any, valueCtx: ParserRuleContext): void;
 }
 export declare enum SequenceAction {
     To = "to",

package/dist/types/utils.d.ts

@@ -4,6 +4,7 @@ import { ClassComponent } from "./objects/ClassComponent.js";
 import { NumericValue } from "./objects/ParamDefinition.js";
 import { SequenceAction, SequenceItem } from './objects/ExecutionScope.js';
 import { BlockTypes } from './globals.js';
+import { ExecutionWarning } from './utils.js';
 export declare class SimpleStopwatch {
     startTime: Date;
     constructor();
@@ -49,9 +50,10 @@ export declare class BaseError extends Error {
     startToken?: Token;
     endToken?: Token;
     filePath?: string;
-    constructor(message: string, startToken?: Token, endToken?: Token, filePath?: string);
+    constructor(message: string, startTokenOrCtx?: Token | ParserRuleContext, endToken?: Token, filePath?: string);
     toString(): string;
 }
+export declare function getLinePositionAsString(ctx: ParserRuleContext): string | null;
 export declare class ParseSyntaxError extends BaseError {
     name: string;
 }
@@ -65,3 +67,9 @@ export declare class RenderError extends Error {
     stage?: string;
     constructor(message: string, stage?: string);
 }
+export type ExecutionWarning = {
+    message: string;
+    fileName?: string;
+    ctx?: ParserRuleContext;
+};
+export declare function printWarnings(warnings: ExecutionWarning[]): void;

package/dist/types/visitor.d.ts

@@ -2,6 +2,7 @@ import { Add_component_exprContext, AdditionExprContext, At_blockContext, At_blo
 import { ClassComponent } from './objects/ClassComponent.js';
 import { PinTypes } from './objects/PinTypes.js';
 import { ComponentPin, ComponentPinNet, ComponentPinNetPair } from './objects/types.js';
+import { ExecutionWarning } from "./utils.js";
 import { Net } from './objects/Net.js';
 import { BaseVisitor } from './BaseVisitor.js';
 import { ParserRuleContext } from 'antlr4ng';
@@ -83,6 +84,7 @@ export declare class ParserVisitor extends BaseVisitor {
     };
     private resolveNets;
     private getPropertyExprList;
+    getWarnings(): ExecutionWarning[];
 }
 export type NetListItem = {
     instanceName: string;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "circuitscript",
-    "version": "0.1.7",
+    "version": "0.1.9",
     "description": "Interpreter for the circuitscript language",
     "homepage": "https://circuitscript.net",
     "engines": {
@@ -78,7 +78,7 @@
     "boilerplate_author": "Jakub Synowiec <jsynowiec@users.noreply.github.com>",
     "license": "MIT",
     "dependencies": {
-        "@dagrejs/graphlib": "2.1.13",
+        "@dagrejs/graphlib": "^2.2.4",
         "@flatten-js/core": "1.5.5",
         "@svgdotjs/svg.js": "3.2.0",
         "antlr4ng": "^3.0.4",