circuitscript 0.0.22 → 0.0.25

package/dist/cjs/lexer.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MainLexer = void 0;
+const antlr4ng_1 = require("antlr4ng");
+const CircuitScriptParser_js_1 = require("./antlr/CircuitScriptParser.js");
+const CircuitScriptLexer_js_1 = require("./antlr/CircuitScriptLexer.js");
+class MainLexer extends CircuitScriptLexer_js_1.CircuitScriptLexer {
+    constructor(input) {
+        super(input);
+        this.tokens = [];
+        this.indents = [];
+        this.opened = 0;
+    }
+    reset() {
+        this.tokens = [];
+        this.indents = [];
+        this.opened = 0;
+        super.reset();
+    }
+    emitToken(token) {
+        super.emitToken(token);
+        this.tokens.push(token);
+    }
+    nextToken() {
+        if (this.inputStream.LA(1) === CircuitScriptParser_js_1.CircuitScriptParser.EOF && this.indents.length) {
+            this.tokens = this.tokens.filter(function (val) {
+                return val.type !== CircuitScriptParser_js_1.CircuitScriptParser.EOF;
+            });
+            this.emitToken(this.commonToken(CircuitScriptParser_js_1.CircuitScriptParser.NEWLINE, "\n"));
+            while (this.indents.length) {
+                this.emitToken(this.createDedent());
+                this.indents.pop();
+            }
+            this.emitToken(this.commonToken(CircuitScriptParser_js_1.CircuitScriptParser.EOF, "<EOF>"));
+        }
+        const next = super.nextToken();
+        return this.tokens.length ? this.tokens.shift() : next;
+    }
+    createDedent() {
+        return this.commonToken(CircuitScriptParser_js_1.CircuitScriptParser.DEDENT, "");
+    }
+    getCharIndex() {
+        return this.inputStream.index;
+    }
+    commonToken(type, text) {
+        const stop = this.getCharIndex() - 1;
+        const start = text.length ? stop - text.length + 1 : stop;
+        const token = antlr4ng_1.CommonToken.fromSource([this, this.inputStream], type, 0, start, stop);
+        let tokenTypeString = null;
+        if (type === CircuitScriptParser_js_1.CircuitScriptParser.INDENT) {
+            tokenTypeString = "indent";
+        }
+        else if (type === CircuitScriptParser_js_1.CircuitScriptParser.DEDENT) {
+            tokenTypeString = "dedent";
+        }
+        if (tokenTypeString !== null) {
+            token.text = tokenTypeString;
+        }
+        return token;
+    }
+    getIndentationCount(whitespace) {
+        let count = 0;
+        for (let i = 0; i < whitespace.length; i++) {
+            if (whitespace[i] === '\t') {
+                count += 8 - count % 8;
+            }
+            else {
+                count++;
+            }
+        }
+        return count;
+    }
+    atStartOfInput() {
+        return this.getCharIndex() === 0;
+    }
+    openBrace() {
+        this.opened++;
+    }
+    closeBrace() {
+        this.opened--;
+    }
+    onNewLine() {
+        const newLine = this.text.replace(/[^\r\n]+/g, '');
+        const spaces = this.text.replace(/[\r\n]+/g, '');
+        const next = this.inputStream.LA(1);
+        const nextnext = this.inputStream.LA(2);
+        if (this.opened > 0 || (nextnext != -1 &&
+            (next === 13 || next === 10 || next === 35))) {
+            this.skip();
+        }
+        else {
+            this.emitToken(this.commonToken(CircuitScriptParser_js_1.CircuitScriptParser.NEWLINE, newLine));
+            const indent = this.getIndentationCount(spaces);
+            const previous = this.indents.length ? this.indents[this.indents.length - 1] : 0;
+            if (indent === previous) {
+                this.skip();
+            }
+            else if (indent > previous) {
+                this.indents.push(indent);
+                this.emitToken(this.commonToken(CircuitScriptParser_js_1.CircuitScriptParser.INDENT, spaces));
+            }
+            else {
+                while (this.indents.length && this.indents[this.indents.length - 1] > indent) {
+                    this.emitToken(this.createDedent());
+                    this.indents.pop();
+                }
+            }
+        }
+    }
+}
+exports.MainLexer = MainLexer;

package/dist/cjs/logger.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+class Logger {
+    constructor() {
+        this.logs = [];
+        this.add((new Date()).toISOString());
+        this.add('starting logger...');
+    }
+    add(message) {
+        this.logs.push((new Date()).toISOString() + " | " + message);
+    }
+    dump() {
+        return this.logs.join('\n');
+    }
+}
+exports.Logger = Logger;

package/dist/cjs/main.js

@@ -0,0 +1,82 @@
+#! /usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const figlet_1 = __importDefault(require("figlet"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = require("fs");
+const sizing_js_1 = require("./sizing.js");
+const helpers_js_1 = require("./helpers.js");
+async function main() {
+    const fontsPath = (0, helpers_js_1.getFontsPath)();
+    const defaultLibsPath = (0, helpers_js_1.getDefaultLibsPath)();
+    const version = (0, helpers_js_1.getPackageVersion)();
+    commander_1.program
+        .description('generate graphical output from circuitscript files')
+        .version(version)
+        .option('-i, --input text <input text>', 'Input text directly')
+        .option('-f, --input-file <path>', 'Input file')
+        .option('-o, --output <path>', 'Output path')
+        .option('-c, --current-directory <path>', 'Set current directory')
+        .option('-k, --kicad-netlist <filename>', 'Create KiCad netlist')
+        .option('-w, --watch', 'Watch for file changes')
+        .option('-n, --dump-nets', 'Dump out net information')
+        .option('-d, --dump-data', 'Dump data during parsing')
+        .option('-s, --stats', 'Show stats during generation');
+    commander_1.program.addHelpText('before', figlet_1.default.textSync('circuitscript', {
+        font: 'Small Slant'
+    }));
+    if (process.argv.length < 3) {
+        commander_1.program.help();
+    }
+    commander_1.program.parse();
+    const options = commander_1.program.opts();
+    const watchFileChanges = options.watch;
+    const outputPath = options.output ?? null;
+    const dumpNets = options.dumpNets;
+    const dumpData = options.dumpData;
+    const kicadNetlist = options.kicadNetlist;
+    let currentDirectory = options.currentDirectory ?? null;
+    if (watchFileChanges) {
+        console.log('watching for file changes...');
+    }
+    await (0, sizing_js_1.prepareSVGEnvironment)(fontsPath);
+    let inputFilePath = null;
+    let scriptData;
+    if (options.input) {
+        scriptData = options.input;
+    }
+    else {
+        inputFilePath = options.inputFile;
+        scriptData = (0, fs_1.readFileSync)(inputFilePath, { encoding: 'utf-8' });
+        if (currentDirectory === null) {
+            currentDirectory = path_1.default.dirname(inputFilePath);
+        }
+    }
+    const scriptOptions = {
+        currentDirectory,
+        defaultLibsPath,
+        dumpNets,
+        dumpData,
+        kicadNetlistPath: kicadNetlist,
+        showStats: options.stats,
+    };
+    const output = (0, helpers_js_1.renderScript)(scriptData, outputPath, scriptOptions);
+    if (outputPath === null && output) {
+        console.log(output);
+    }
+    if (watchFileChanges) {
+        (0, fs_1.watch)(inputFilePath, event => {
+            if (event === 'change') {
+                const scriptData = (0, fs_1.readFileSync)(inputFilePath, { encoding: 'utf-8' });
+                (0, helpers_js_1.renderScript)(scriptData, outputPath, scriptOptions);
+                console.log('done');
+            }
+        });
+    }
+}
+exports.default = main;
+main();

package/dist/cjs/objects/ClassComponent.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClassComponent = void 0;
+const draw_symbols_js_1 = require("../draw_symbols.js");
+const PinDefinition_js_1 = require("./PinDefinition.js");
+const PinTypes_js_1 = require("./PinTypes.js");
+class ClassComponent {
+    constructor(instanceName, numPins, className) {
+        this.parameters = new Map();
+        this.pins = new Map();
+        this.pinNets = new Map();
+        this.pinWires = new Map();
+        this._copyID = null;
+        this._copyFrom = null;
+        this.arrangeProps = null;
+        this.displayProp = null;
+        this.widthProp = null;
+        this.typeProp = null;
+        this.styles = {};
+        this.assignedRefDes = null;
+        this.instanceName = instanceName;
+        this.numPins = numPins;
+        this.className = className;
+    }
+    setupPins() {
+        for (let i = 1; i < this.numPins + 1; i++) {
+            const pinIndex = i;
+            this.pins.set(pinIndex, new PinDefinition_js_1.PinDefinition(pinIndex, PinDefinition_js_1.PinIdType.Int, pinIndex.toString(), PinTypes_js_1.PinTypes.Any));
+        }
+        this.refreshPinsCache();
+    }
+    getDefaultPin() {
+        return 1;
+    }
+    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;
+                }
+            }
+        }
+        return false;
+    }
+    getPin(pinId) {
+        if (typeof pinId === 'number') {
+            return pinId;
+        }
+        else {
+            for (const [pin, pinDef] of this.pins) {
+                if (pinDef.name === pinId ||
+                    pinDef.altNames.indexOf(pinId) !== -1) {
+                    return pin;
+                }
+            }
+            return -1;
+        }
+    }
+    getNextPinAfter(pinIndex) {
+        if (pinIndex + 1 <= this.numPins) {
+            return pinIndex + 1;
+        }
+        else {
+            return 1;
+        }
+    }
+    setParam(key, value) {
+        this.parameters.set(key, value);
+        this.refreshParamCache();
+    }
+    refreshParamCache() {
+        this._cachedParams =
+            JSON.stringify(Object.fromEntries(this.parameters));
+    }
+    refreshPinsCache() {
+        this._cachedPins = JSON.stringify(Object.fromEntries(this.pins));
+    }
+    refreshCache() {
+        this.refreshParamCache();
+        this.refreshPinsCache();
+    }
+    getParam(key) {
+        if (this.parameters.has(key)) {
+            return this.parameters.get(key);
+        }
+        else {
+            throw 'Invalid parameter key';
+        }
+    }
+    toString() {
+        return this.instanceName;
+    }
+    static simple(instanceName, numPins, className) {
+        const component = new ClassComponent(instanceName, numPins, className);
+        component.setupPins();
+        return component;
+    }
+    isEqual(other) {
+        return this.instanceName === other.instanceName
+            && this.numPins === other.numPins
+            && this.className === other.className
+            && this._copyID === other._copyID
+            && this.arrangeProps === other.arrangeProps
+            && this.displayProp === other.displayProp
+            && this.widthProp === other.widthProp
+            && this.typeProp === other.typeProp
+            && this._cachedPins === other._cachedPins
+            && this._cachedParams === other._cachedParams;
+    }
+    clone() {
+        const component = new ClassComponent(this.instanceName, this.numPins, this.className);
+        component._copyID = this._copyID;
+        component.arrangeProps = this.arrangeProps;
+        component.widthProp = this.widthProp;
+        component.typeProp = this.typeProp;
+        if (this.displayProp) {
+            if (typeof this.displayProp === "string") {
+                component.displayProp = this.displayProp;
+            }
+            else if (this.displayProp instanceof draw_symbols_js_1.SymbolDrawingCommands) {
+                component.displayProp =
+                    this.displayProp.clone();
+            }
+        }
+        for (const [key, value] of this.parameters) {
+            if (key === 'flipX' || key === 'flipY' || key === 'angle') {
+                continue;
+            }
+            component.parameters.set(key, value);
+        }
+        for (const [key, value] of this.pins) {
+            component.pins.set(key, value);
+        }
+        for (const key in this.styles) {
+            component.styles[key] = this.styles[key];
+        }
+        component.refreshCache();
+        return component;
+    }
+}
+exports.ClassComponent = ClassComponent;

package/dist/cjs/objects/ExecutionScope.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActiveObject = exports.FrameAction = exports.SequenceAction = exports.ExecutionScope = void 0;
+class ExecutionScope {
+    constructor(scopeId) {
+        this.nets = [];
+        this.instances = new Map();
+        this.functions = new Map();
+        this.variables = new Map();
+        this.symbols = new Map();
+        this.blockStack = new Map();
+        this.wires = [];
+        this.frames = [];
+        this.indentLevel = 0;
+        this.netCounter = 1;
+        this.unnamedCounter = 1;
+        this.currentComponent = null;
+        this.currentPin = null;
+        this.currentWireId = -1;
+        this.currentFrameId = -1;
+        this.netGnd = null;
+        this.componentGnd = null;
+        this.componentRoot = null;
+        this.copyIDs = new Map();
+        this.sequence = [];
+        this.scopeId = scopeId;
+    }
+    static create() {
+        const scope = new ExecutionScope(ExecutionScope.scopeId);
+        ExecutionScope.scopeId += 1;
+        return scope;
+    }
+    findNet(component, pin) {
+        return this.nets.find(([tmpComponent, tmpPin]) => {
+            return tmpComponent.isEqual(component) && tmpPin === pin;
+        });
+    }
+    getNetWithName(name) {
+        const found = this.nets.find(([, , net]) => {
+            return net.name === name;
+        });
+        return found ? found[2] : null;
+    }
+    hasNet(component, pin) {
+        return this.findNet(component, pin) !== undefined;
+    }
+    getNet(component, pin) {
+        const result = this.findNet(component, pin);
+        if (result) {
+            return result[2];
+        }
+        return null;
+    }
+    setNet(component, pin, net) {
+        const pair = this.findNet(component, pin);
+        const result = this.nets.indexOf(pair);
+        if (result === -1) {
+            this.nets.push([component, pin, net]);
+        }
+        else {
+            this.nets[result][2] = net;
+        }
+        component.pinNets.set(pin, net);
+    }
+    removeNet(component, pin) {
+        const pair = this.findNet(component, pin);
+        const result = this.nets.indexOf(pair);
+        if (result !== -1) {
+            this.nets.splice(result, 1);
+        }
+        component.pinNets.delete(pin);
+    }
+    getNets() {
+        return this.nets;
+    }
+    dumpNets() {
+        const sortedNet = [...this.nets].sort((a, b) => {
+            const netA = a[2];
+            const netB = b[2];
+            const netAId = netA.namespace + netA.name;
+            const netBId = netB.namespace + b[2].name;
+            if (netAId > netBId) {
+                return 1;
+            }
+            else if (netAId < netBId) {
+                return -1;
+            }
+            else {
+                return 0;
+            }
+        });
+        return sortedNet.map(([component, pin, net]) => {
+            return [net.namespace + net.name, component.instanceName, pin];
+        });
+    }
+    printNets() {
+        this.dumpNets().forEach(item => {
+            const [netName, instanceName, pin] = item;
+            console.log(netName.padEnd(10), '=>', instanceName, pin);
+        });
+    }
+    setActive(type, item) {
+        this.clearActive();
+        if (type === ActiveObject.Wire) {
+            this.currentWireId = item;
+        }
+        else if (type === ActiveObject.Frame) {
+            this.currentFrameId = item;
+        }
+    }
+    clearActive() {
+        this.currentWireId = -1;
+        this.currentFrameId = -1;
+    }
+}
+exports.ExecutionScope = ExecutionScope;
+ExecutionScope.scopeId = 0;
+var SequenceAction;
+(function (SequenceAction) {
+    SequenceAction["To"] = "to";
+    SequenceAction["At"] = "at";
+    SequenceAction["Wire"] = "wire";
+    SequenceAction["WireJump"] = "wire-jump";
+    SequenceAction["Frame"] = "frame";
+})(SequenceAction || (exports.SequenceAction = SequenceAction = {}));
+var FrameAction;
+(function (FrameAction) {
+    FrameAction["Enter"] = "enter";
+    FrameAction["Exit"] = "exit";
+})(FrameAction || (exports.FrameAction = FrameAction = {}));
+var ActiveObject;
+(function (ActiveObject) {
+    ActiveObject["Frame"] = "frame";
+    ActiveObject["Wire"] = "wire";
+})(ActiveObject || (exports.ActiveObject = ActiveObject = {}));

package/dist/cjs/objects/Frame.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FramePlotDirection = exports.FrameParamKeys = exports.Frame = void 0;
+class Frame {
+    constructor(frameId) {
+        this.parameters = new Map();
+        this.frameId = frameId;
+    }
+}
+exports.Frame = Frame;
+var FrameParamKeys;
+(function (FrameParamKeys) {
+    FrameParamKeys["Title"] = "title";
+    FrameParamKeys["Direction"] = "direction";
+    FrameParamKeys["Padding"] = "padding";
+    FrameParamKeys["Border"] = "border";
+})(FrameParamKeys || (exports.FrameParamKeys = FrameParamKeys = {}));
+var FramePlotDirection;
+(function (FramePlotDirection) {
+    FramePlotDirection["Row"] = "row";
+    FramePlotDirection["Column"] = "column";
+})(FramePlotDirection || (exports.FramePlotDirection = FramePlotDirection = {}));

package/{src/objects/Net.ts → dist/cjs/objects/Net.js}

@@ -1,43 +1,28 @@
-export class Net {
-
-    name: string;
-    
-    // Name that is specified when the net was defined. 
-    baseName: string;
-
-    // Defines where the net was created. This is important for determining
-    // the 'location' of global nets.
-    namespace: string;
-
-    priority: number;
-    type: any;
-
-    constructor(namespace: string, name: string, priority = 0, type: any = null) {
-        if (namespace.indexOf(' ') !== -1){
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Net = void 0;
+class Net {
+    constructor(namespace, name, priority = 0, type = null) {
+        if (namespace.indexOf(' ') !== -1) {
             throw "Invalid net namespace provided";
         }
-
         if (name.indexOf(' ') !== -1) {
             throw "Invalid net name provided!";
         }
-
         this.namespace = namespace;
         this.name = name;
-        
         this.priority = priority;
         this.type = type;
-
         this.baseName = name;
     }
-
-    toString(): string {
+    toString() {
         return this.name;
     }
-
-    static isSame(netA: Net, netB: Net): boolean {
+    static isSame(netA, netB) {
         return netA.name === netB.name &&
             netA.baseName === netB.baseName &&
             netA.priority === netB.priority &&
             netA.type === netB.type;
     }
 }
+exports.Net = Net;

package/dist/cjs/objects/ParamDefinition.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PinBlankValue = exports.PercentageValue = exports.NumericValue = exports.ParamDefinition = void 0;
+class ParamDefinition {
+    constructor(paramName, paramValue) {
+        this.paramName = paramName;
+        this.paramValue = paramValue;
+    }
+}
+exports.ParamDefinition = ParamDefinition;
+class NumericValue {
+    constructor(value) {
+        this.value = value;
+    }
+    toString() {
+        return 'numeric:' + this.value;
+    }
+    toDisplayString() {
+        if (typeof this.value === 'number') {
+            return this.value.toString();
+        }
+        else if (typeof this.value === 'string') {
+            return this.value;
+        }
+    }
+}
+exports.NumericValue = NumericValue;
+class PercentageValue {
+    constructor(value) {
+        this.value = value;
+    }
+    toString() {
+        return this.value.toString();
+    }
+}
+exports.PercentageValue = PercentageValue;
+class PinBlankValue {
+    constructor(value) {
+        this.blank = value;
+    }
+}
+exports.PinBlankValue = PinBlankValue;

package/dist/cjs/objects/PinDefinition.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PinReference = exports.PortSide = exports.PinIdType = exports.PinDefinition = void 0;
+const PinTypes_js_1 = require("./PinTypes.js");
+class PinDefinition {
+    constructor(id, idType, name, pinType = PinTypes_js_1.PinTypes.Any, altNames = []) {
+        this.side = PortSide.EAST;
+        this.position = -1;
+        this.id = id;
+        this.idType = idType;
+        this.pinType = pinType;
+        this.name = name;
+        this.altNames = altNames;
+    }
+}
+exports.PinDefinition = PinDefinition;
+var PinIdType;
+(function (PinIdType) {
+    PinIdType["Int"] = "int";
+    PinIdType["Str"] = "str";
+})(PinIdType || (exports.PinIdType = PinIdType = {}));
+var PortSide;
+(function (PortSide) {
+    PortSide["WEST"] = "WEST";
+    PortSide["EAST"] = "EAST";
+    PortSide["SOUTH"] = "SOUTH";
+    PortSide["NORTH"] = "NORTH";
+})(PortSide || (exports.PortSide = PortSide = {}));
+class PinReference {
+}
+exports.PinReference = PinReference;

package/dist/cjs/objects/PinTypes.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PinTypes = void 0;
+var PinTypes;
+(function (PinTypes) {
+    PinTypes["Any"] = "any";
+    PinTypes["Input"] = "input";
+    PinTypes["Output"] = "output";
+    PinTypes["IO"] = "io";
+    PinTypes["Power"] = "power";
+})(PinTypes || (exports.PinTypes = PinTypes = {}));

package/dist/cjs/objects/Wire.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Wire = void 0;
+class Wire {
+    constructor(path) {
+        this.path = path;
+    }
+}
+exports.Wire = Wire;

package/dist/cjs/objects/types.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParseSymbolType = exports.UndeclaredReference = void 0;
+class UndeclaredReference {
+    constructor(reference) {
+        this.reference = reference;
+    }
+}
+exports.UndeclaredReference = UndeclaredReference;
+var ParseSymbolType;
+(function (ParseSymbolType) {
+    ParseSymbolType["Variable"] = "variable";
+    ParseSymbolType["Function"] = "function";
+    ParseSymbolType["Undefined"] = "undefined";
+})(ParseSymbolType || (exports.ParseSymbolType = ParseSymbolType = {}));