circuitscript 0.0.22 → 0.0.25

package/src/objects/Frame.ts

@@ -1,20 +0,0 @@
-export class Frame {
-    parameters: Map<string, any> = new Map();
-    frameId: number;
-
-    constructor(frameId: number) {
-        this.frameId = frameId;
-    }
-}
-
-export enum FrameParamKeys {
-    Title = 'title',
-    Direction = 'direction',
-    Padding = 'padding',
-    Border = 'border',
-}
-
-export enum FramePlotDirection {
-    Row = 'row',
-    Column = 'column',
-}

package/src/objects/ParamDefinition.ts

@@ -1,49 +0,0 @@
-export class ParamDefinition {
-    paramName: string;
-    paramValue: string | number | any;
-
-    constructor(paramName: string, paramValue: any) {
-        this.paramName = paramName;
-        this.paramValue = paramValue;
-    }
-}
-
-export class NumericValue {
-    value: string | number;
-
-    constructor(value: string | number) {
-        this.value = value;
-    }
-
-    toString(): string {
-        return 'numeric:' + this.value;
-    }
-
-    toDisplayString(): string {
-        if (typeof this.value  === 'number'){
-            return this.value.toString();
-            
-        } else if (typeof this.value === 'string'){
-            return this.value;
-        }
-    }
-}
-export class PercentageValue {
-    value: string | number;
-
-    constructor(value: string | number) {
-        this.value = value;
-    }
-
-    toString(): string {
-        return this.value.toString();
-    }
-}
-
-export class PinBlankValue {
-    blank: number;
-
-    constructor(value: number) {
-        this.blank = value;
-    }
-}

package/src/objects/PinDefinition.ts

@@ -1,49 +0,0 @@
-import { PinTypes } from './PinTypes.js';
-
-export type PinId = number | string;
-
-export class PinDefinition {
-    id: PinId;
-
-    idType: PinIdType;
-
-    pinType: PinTypes;
-
-    name: string;
-    altNames: string[];
-
-    side: string = PortSide.EAST;
-
-    position = -1;
-
-    constructor(
-        id: PinId,
-        idType: PinIdType,
-        name: string,
-        pinType = PinTypes.Any,
-        altNames = [],
-    ) {
-        this.id = id;
-        this.idType = idType;
-
-        this.pinType = pinType;
-
-        this.name = name;
-        this.altNames = altNames;
-    }
-}
-
-export enum PinIdType {
-    Int = 'int',
-    Str = 'str',
-}
-
-export enum PortSide {
-    WEST = 'WEST',
-    EAST = 'EAST',
-    SOUTH = 'SOUTH',
-    NORTH = 'NORTH'
-}
-
-
-export class PinReference {}

package/src/objects/PinTypes.ts

@@ -1,7 +0,0 @@
-export enum PinTypes {
-    Any = 'any',
-    Input = 'input',
-    Output = 'output',
-    IO = 'io',
-    Power = 'power',
-}

package/src/objects/Wire.ts

@@ -1,19 +0,0 @@
-import { ClassComponent } from "./ClassComponent.js";
-
-export class Wire {
-
-    // Should have some net info too 
-
-    path: WireSegment[]
-
-    constructor(path: WireSegment[]) {
-        this.path = path;
-    }
-}
-
-export type WireSegment = {
-    direction: 'up' | 'down' | 'left' | 'right' | 'auto' | 'auto_';
-    value: number,
-    valueXY?: [x: number, y: number],
-    until?: [instance: ClassComponent, pin: number],
-}

package/src/objects/types.ts

@@ -1,66 +0,0 @@
-import { ExecutionContext } from '../execute.js';
-import { ClassComponent } from './ClassComponent.js';
-import { Net } from './Net.js';
-import { NumericValue, PercentageValue, PinBlankValue } from './ParamDefinition.js';
-
-export type CFunction = (args: CallableParameter[],
-    options?: CFunctionOptions) => CFunctionResult;
-
-export type CFunctionOptions = {
-    netNamespace?: string
-}
-
-export type CFunctionResult = [
-    executionContext: ExecutionContext, 
-    result: ValueType | ClassComponent | null
-];
-
-// export type NetMap = Map<ComponentPin, Net>;
-
-export type ComponentPinNet = [
-    netName: string, instanceName: string, pin: number];
-
-    // Need to improve name...
-export type ComponentPinNetPair = [
-    component: ClassComponent,
-    pin: number,
-    net: Net
-];
-
-export type ComponentPin = [
-    component: ClassComponent,
-    pinId: number|string
-];
-
-export type ComplexType = ValueType 
-                        | ClassComponent 
-                        | UndeclaredReference 
-                        | null;
-
-export type ValueType = boolean | number | string | 
-    NumericValue | PercentageValue | PinBlankValue;
-
-export type CallableParameter = 
-    ['keyword', key: string, value: ValueType] | 
-    ['position', key: number, value: ValueType];
-
-export type FunctionDefinedParameter = [name: string, defaultValue: ValueType] 
-    | [name: string];
-
-
-export class UndeclaredReference {
-    reference: ReferenceType;
-
-    constructor(reference: ReferenceType) {
-        this.reference = reference;
-    }
-}
-
-export type ReferenceType =
-    {
-        found: boolean,
-        name?: string,
-        trailers?: string[],
-        type?: string,
-        value?: any
-    };

package/src/parser.ts

@@ -1,106 +0,0 @@
-import { CharStream, CommonTokenStream, ErrorListener, Token } from 'antlr4';
-
-import CircuitScriptLexer from './antlr/CircuitScriptLexer.js';
-import CircuitScriptParser from './antlr/CircuitScriptParser.js';
-
-import { MainVisitor } from './visitor.js';
-import { MainLexer } from './lexer.js';
-import { SimpleStopwatch } from './utils.js';
-
-export function parseFileWithVisitor(visitor: MainVisitor, data: string) {
-    const chars = new CharStream(data);
-    const lexer = new MainLexer(chars);
-
-    const lexerTimer = new SimpleStopwatch();
-
-    const tokens = new CommonTokenStream(lexer);
-    tokens.fill();
-
-    const lexerTimeTaken = lexerTimer.lap();
-
-    const parserTimer = new SimpleStopwatch();
-    const parser = new CircuitScriptParser(tokens);
-    // Clear any existing error listeners and use the custom one only
-    parser.removeErrorListeners();
-
-    const errorListener = new CircuitscriptParserErrorListener();
-    parser.addErrorListener(errorListener);
-
-    const tree = parser.script();
-
-    let hasError = false;
-
-    try {
-        visitor.visit(tree);
-    } catch (err){
-        // Error should be internally handled in visitor
-        err.print(data);
-        hasError = true;
-    }
-
-    const parserTimeTaken = parserTimer.lap();
-
-    // dumpTokens(tokens.tokens, lexer, data);
-    
-    return {
-        tree, parser,
-        hasParseError: errorListener.hasParseErrors(),
-        hasError,
-        parserTimeTaken,
-        lexerTimeTaken,
-    };
-}
-
-function dumpTokens(tokens:Token[], lexer: CircuitScriptLexer, scriptData: string): void {
-    tokens.forEach(item => {
-        if (item.type !== -1) {
-            let stringValue = "";
-            let textPart = "";
-
-            if (lexer.symbolicNames[item.type] !== null && lexer.symbolicNames[item.type] !== undefined) {
-                stringValue = lexer.symbolicNames[item.type];
-                if (stringValue !== "NEWLINE") {
-                    textPart = scriptData.substring(item.start, item.stop + 1);
-                } else {
-                    textPart = item.text.length-1;
-                }
-            } else if (lexer.literalNames[item.type] !== null && lexer.literalNames[item.type] !== undefined) {
-                stringValue = lexer.literalNames[item.type];
-                textPart = scriptData.substring(item.start, item.stop + 1);
-            } else {
-                stringValue = item._text;
-            }
-
-            console.log('line', item.line + ':' + item.column, `\t${stringValue} (${item.type})`.padEnd(30), textPart);
-        }
-    });
-}
-
-export class CircuitscriptParserErrorListener extends ErrorListener {
-
-    syntaxErrorCounter = 0;
-
-    syntaxError(recognizer: Recognizer<TSymbol>,
-        offendingSymbol: TSymbol,
-        line: number,
-        column: number,
-        msg: string,
-        e: RecognitionException | undefined) {
-        console.log("Syntax error at line", line, ':', column, ' - ', msg);
-
-        this.syntaxErrorCounter++;
-    }
-
-    // reportAmbiguity(recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs) {
-    // }
-
-    // reportAttemptingFullContext(recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs) {
-    // }
-
-    // reportContextSensitivity(recognizer, dfa, startIndex, stopIndex, prediction, configs) {
-    // }
-
-    hasParseErrors(): boolean {
-        return (this.syntaxErrorCounter > 0);
-    }
-}

package/src/regenerate-tests.ts

@@ -1,25 +0,0 @@
-import fs from 'fs';
-import { renderScript } from './helpers.js';
-
-const mainDir = './__tests__/renderData/';
-
-const cstFiles = [];
-
-const files = fs.readdirSync(mainDir);
-files.forEach(file => {
-    if (file.endsWith('.cst')){
-        cstFiles.push(file);
-    }
-});
-
-const useCurrentDir = './examples/';
-
-cstFiles.forEach(file => {
-    const inputPath = mainDir + file;
-    const scriptData = fs.readFileSync(inputPath, { encoding: 'utf-8' });
-
-    const outputPath = inputPath + '.svg';
-    renderScript(scriptData, outputPath, { currentDirectory: useCurrentDir });
-
-    console.log('generated ', outputPath);
-});

package/src/render.ts

@@ -1,260 +0,0 @@
-import { createSVGWindow } from 'svgdom';
-import { SVG, SVGTypeMapping, registerWindow } from '@svgdotjs/svg.js';
-
-import { BoundBox, MergedWire, RenderComponent, RenderFrame, 
-    RenderFrameType, RenderJunction, RenderText, RenderWire, getBounds } from "./layout.js";
-import { applyFontsToSVG } from './sizing.js';
-import { ParamKeys, bodyColor, junctionColor, junctionSize, wireColor } from './globals.js';
-import { NumericValue } from './objects/ParamDefinition.js';
-import { getBoundsSize } from './utils.js';
-
-export function generateSVG2(graph: {
-    components: RenderComponent[],
-    wires: RenderWire[], junctions: RenderJunction[],
-    mergedWires: MergedWire[], debugRects: BoundBox[],
-    frameObjects: RenderFrame[],
-    textObjects: RenderText[],
-    }): string {
-
-    const window = createSVGWindow();
-    const document = window.document;
-
-    registerWindow(window, document);
-
-    const canvas = SVG(document.documentElement);
-    applyFontsToSVG(canvas);
-
-    generateSVGChild(canvas, 
-        graph.components, graph.wires, graph.junctions, graph.mergedWires,
-        graph.frameObjects, graph.textObjects,
-        );
-    const {x, y, width, height} = canvas.bbox();
-
-    const margin = 5;
-    const widthAndMargin = width + margin * 2;
-    const heightAndMargin = height + margin * 2;
-
-    const scale = 1;
-
-    canvas.size(widthAndMargin * scale, heightAndMargin * scale);
-    canvas.viewbox(x - margin, y - margin, widthAndMargin, heightAndMargin);
-
-    return canvas.svg();
-}
-
-function generateSVGChild(canvas: SVGTypeMapping<SVGAElement>, 
-    components: RenderComponent[], wires: RenderWire[], 
-    junctions: RenderJunction[], mergedWires:MergedWire[],
-    frameObjects:RenderFrame[], textObjects: RenderText[] ): void {
-
-    const displayWireId = false;
-
-    // Draw the display grid
-    const bounds = getBounds(components, wires, junctions, frameObjects);
-
-    drawGrid(
-        canvas.group().translate(0, 0),
-        {
-            x: bounds.xmin,
-            y: bounds.ymin,
-            x2: bounds.xmax,
-            y2: bounds.ymax
-        });
-
-    components.forEach(item => {
-        const { x, y, width, height } = item;
-        const symbolGroup = canvas.group();
-        symbolGroup.translate(x, y);
-
-        const { symbol = null } = item;
-
-        if (symbol !== null && symbol) {
-            let extra = {};
-            if (item.component.parameters.has('__is_net')) {
-                extra.net_name = item.component.parameters.get(ParamKeys.net_name);
-
-            } else if (item.component.parameters.has('value')) {
-                let tmpValue = item.component.parameters.get('value');
-                if (tmpValue instanceof NumericValue){
-                    // Prepare value for display
-                    tmpValue = (tmpValue as NumericValue).value;
-                }
-                
-                extra.value = tmpValue;
-            }
-
-            extra.instance_name = item.component.instanceName;
-            
-            if (item.component.parameters.has('place')){
-                extra.place = item.component.parameters.get('place');
-            } else {
-                extra.place = true; // Default is to place the item
-            }
-
-            symbol.draw(symbolGroup, extra);
-
-        } else {
-            // draw default shape
-            symbolGroup.rect(width, height)
-                .fill(bodyColor)
-                .stroke({ width: 1, color: '#333' });
-        }
-    });
-
-    if (displayWireId){
-        // Debugging method to draw the wire id next to the wires.
-        const wiresGroup = canvas.group().translate(0, 0);
-        
-        wires.forEach(wire => {
-            // Draw the wire id at the start of the wire
-            wiresGroup.text(wire.id.toString())
-                .font({
-                    family: 'Inter',
-                    size: 10,
-                })
-                .translate(wire.x+5, wire.y+5)
-        });
-    }
-
-    const mergedWireGroup = canvas.group();
-
-    // draw the merged wires
-    mergedWires.forEach(tmpItem => {
-        const { segments, intersectPoints } = tmpItem;
-
-        segments.forEach(segment => {
-            const pt1 = segment[0];
-            const pt2 = segment[1];
-            mergedWireGroup.line([pt1, pt2])
-                .stroke({ width: 1, color: wireColor, linecap: 'square' })
-                .fill('none');
-        });
-
-        intersectPoints.forEach(point => {
-            const [x, y, count] = point;
-            mergedWireGroup.circle(junctionSize)
-                            .translate(x - junctionSize/2, y - junctionSize/2)
-                            .fill(junctionColor)
-                            .stroke('none');
-                            
-            // mergedWireGroup.text(count.toString())
-            //                 .translate(x + 2, y + 2)
-            //                 .font({
-            //                     family: 'Inter',
-            //                     size: 10,
-            //                 })
-        });
-    });
-
-    // const debugRectsGroup = canvas.group();
-    // debugRects.forEach(box => {
-    //     // Draw a rect
-    //     const width = box.xmax - box.xmin;
-    //     const height = box.ymax - box.ymin;
-    //     const tmpRect = debugRectsGroup.rect(width, height)
-    //                         .fill('none')
-    //                         .stroke({ width: 1, color: '#000'});
-    //     tmpRect.translate(box.xmin, box.ymin);
-    // });
-
-    const frameGroup = canvas.group();
-    const showElementFrames = false;
-
-    frameObjects.forEach(item => {
-        const { bounds, borderWidth } = item;
-        if (borderWidth > 0){
-            const { width, height } = getBoundsSize(bounds);
-
-            let strokeColor = '#111';
-            if (item.type === RenderFrameType.Container) {
-                strokeColor = '#111';
-            } else if (item.type === RenderFrameType.Elements){
-                strokeColor = '#aaa';
-                if (!showElementFrames){
-                    return;
-                }
-            }
-
-            const tmpRect = frameGroup.rect(width, height)
-                .fill('none')
-                .stroke({ width: borderWidth, color: strokeColor });
-
-            tmpRect.translate(item.x, item.y);
-        }
-    });
-
-    textObjects.forEach(item => {
-        const {x, y, symbol} = item;
-        const innerGroup = canvas.group();
-        innerGroup.translate(x, y);
-        symbol.draw(innerGroup);
-    });
-
-    const drawOrigin = false;
-
-    // Draw origin
-    drawOrigin && canvas.group().translate(0,0)
-        .circle(5)
-        .translate(-5/2, -5/2)
-        .stroke('none').fill('red');
-}
-
-function drawGrid(group: G, canvasSize: { x: number, y: number, x2: number, y2: number }): void {
-    const gridSize = 20;
-    const { x, y, x2, y2 } = canvasSize;
-
-    const gridStartX = (Math.floor(x / gridSize) - 1) * gridSize;
-    const gridStartY = (Math.floor(y / gridSize) - 1) * gridSize;
-
-    const gridEndX = (Math.ceil(x2 / gridSize) + 1) * gridSize;
-    const gridEndY = (Math.ceil(y2 / gridSize) + 1) * gridSize;
-
-    const numCols = Math.ceil((gridEndX - gridStartX) / gridSize);
-    // const numRows = Math.ceil((gridEndY - gridStartY) / gridSize);
-
-    // Draws (0, 0) point
-    // group.circle(5)
-    //     .translate(-5 / 2, -5 / 2)
-    //     .fill('red')
-    //     .stroke('none');
-
-    const lines = [];
-
-    for (let i = 0; i <= numCols; i++) {
-        const startX = gridStartX + i * gridSize;
-        const startY = gridStartY-0.5;
-        const endY = gridEndY;
-        lines.push(`M ${startX} ${startY} L ${startX} ${endY}`);
-    }
-
-    group.path(lines.join(" "))
-        .fill('none')
-        .attr({
-            'stroke-dasharray': '1,' + (gridSize-1),
-        })
-        .stroke({
-            width: 1,
-            color: '#aaa'
-        })
-}
-
-function calculateBoundingBox(components: RenderComponent[]): { width: number, height: number } {
-    let maxX = Number.NEGATIVE_INFINITY;
-    let minX = Number.POSITIVE_INFINITY;
-
-    let maxY = Number.NEGATIVE_INFINITY;
-    let minY = Number.POSITIVE_INFINITY;
-
-    components.forEach(item => {
-        minX = Math.min(item.x, minX);
-        maxX = Math.max(item.x + item.width, maxX);
-
-        minY = Math.min(item.y, minY);
-        maxY = Math.max(item.y + item.height, maxY);
-    });
-
-    return {
-        width: (maxX - minX),
-        height: (maxY - minY)
-    }
-}

package/src/sizing.ts

@@ -1,96 +0,0 @@
-import { Box, SVG, SVGTypeMapping, registerWindow } from '@svgdotjs/svg.js';
-import { config, createSVGWindow } from 'svgdom';
-import { HorizontalAlign, VerticalAlign } from './geometry.js';
-import { defaultFont } from './globals.js';
-
-let MainCanvas = null;
-
-const supportedFonts = { 
-    // 'Roboto': 'Roboto-Regular.ttf',
-    // 'Inter': 'Inter-Regular.ttf', 
-    // 'Inter-Bold': 'Inter-Bold.ttf',
-}
-
-export async function prepareSizing(fontsPath): Promise<void> {
-    await config.setFontDir(fontsPath)
-        .setFontFamilyMappings(supportedFonts)
-        .preloadFonts()
-}
-
-export function applyFontsToSVG(canvas: SVGTypeMapping): void {
-    // for (const fontName in supportedFonts) {
-    //     canvas.fontface(fontName, "url('" + InterFontEncoded + "')");
-    // }
-}
-
-export async function measureTextSize(text: string, fontFamily: string, fontSize: number): Promise<{ width: number, height: number }> {
-    // Async version, in case measuring text sizes need more time
-    return measureTextSize2(text, fontFamily, fontSize);
-}
-
-// Cache measurements to avoid recalculations
-const measureTextSizeCache: {
-    [key: string]: {
-        width: number,
-        height: number, box: Box
-    }
-} = {};
-const measureTextSizeCacheHits: { [key: string]: number } = {};
-
-export function measureTextSize2(text: string, fontFamily: string,
-    fontSize: number, fontWeight = 'regular',
-    anchor = HorizontalAlign.Left,
-    vanchor = VerticalAlign.Bottom): { width: number, height: number, box: Box } {
-
-    // Reuse the canvas, so no need to keep creating
-    if (MainCanvas === null) {
-        const window = createSVGWindow();
-        const { document } = window;
-        registerWindow(window, document);
-        MainCanvas = SVG(document.documentElement);
-    }
-
-    // Check if entry already exists in the cache
-    const key = `${text}-${fontFamily}-${fontSize}-${fontWeight}-${anchor}-${vanchor}`;
-
-    if (measureTextSizeCache[key] === undefined) {
-        let dominantBaseline = 'hanging';
-        switch(vanchor){
-            case VerticalAlign.Top:
-                dominantBaseline = 'hanging';
-                break;
-
-            case VerticalAlign.Middle:
-                dominantBaseline = 'middle';
-                break;
-
-            case VerticalAlign.Bottom:
-                dominantBaseline = 'text-top';
-                break;
-        }
-
-        fontFamily = defaultFont;
-        
-        const tmpTextElement = MainCanvas.text(text).font({
-            family: fontFamily,
-            size: fontSize,
-            anchor: anchor,
-            'dominant-baseline': dominantBaseline,
-            weight: fontWeight,
-        }).fill('#333');
-
-        const textbox = tmpTextElement.bbox();
-        const { width, height } = textbox;
-        tmpTextElement.remove();
-
-        measureTextSizeCache[key] = {
-            width: Math.round(width * 100) / 100,
-            height: Math.round(height * 100) / 100,
-            box: textbox,
-        }
-        measureTextSizeCacheHits[key] = 0;
-    }
-
-    measureTextSizeCacheHits[key]++;
-    return measureTextSizeCache[key];
-}