circuitscript 0.0.13 → 0.0.15

package/src/layout.ts

@@ -604,10 +604,6 @@ export class LayoutEngine {
                     if (tmpSymbol instanceof SymbolCustom && widthProp){
                         tmpSymbol.bodyWidth = widthProp;
                     }
-
-                    if (component.assignedRefDes !== null){
-                        tmpSymbol.setLabelValue("refdes", component.assignedRefDes);
-                    }
     
                     if (!didSetAngle && component.parameters.has('_addDirection')){
                         // If there is an _addDirection specified, then the angle
@@ -683,8 +679,31 @@ export class LayoutEngine {
     
                 previousNode = wireName;
                 previousPin = 1;
-   
-                this.print(SequenceAction.Wire, wireId, JSON.stringify(wireSegments));
+                
+                const wireSegmentsInfo = wireSegments.map(item => {
+                    const tmp: {
+                        direction: string,
+                        value: number,
+                        valueXY?: [x: number, y: number],
+                        until?: [instanceName: string, pin: number]
+                    } = {
+                        direction: item.direction,
+                        value: item.value,
+                    };
+
+                    if (item.valueXY) {
+                        tmp.valueXY = item.valueXY;
+                    }
+
+                    if (item.until) {
+                        tmp.until = [item.until[0].toString(), item.until[1]];
+                    }
+
+                    return tmp;
+                });
+
+                this.print(SequenceAction.Wire, wireId, 
+                    JSON.stringify(wireSegmentsInfo));
                 
             } else if (action === SequenceAction.WireJump) {
                 this.print(...sequence[i]);
@@ -1338,26 +1357,28 @@ function applyComponentParamsToSymbol(typeProp: string,
     component: ClassComponent, symbol: SymbolGraphic): void {
     
     if (typeProp === 'net') {
-        symbol.setLabelValue("net_name", component.parameters.get(ParamKeys.net_name) as string);
+        symbol.setLabelValue("net_name", 
+            component.parameters.get(ParamKeys.net_name) as string);
     }
 
-    if (component.parameters.has('value')) {
-
-        let displayString = "";
-        const tmpValue = component.parameters.get('value');
-        if (typeof tmpValue == 'object' && (tmpValue instanceof NumericValue)) {
-            displayString = (tmpValue as NumericValue).toDisplayString();
-        } else {
-            displayString = tmpValue;
-        }
-
-        symbol.setLabelValue('value', displayString);
+    if (component.assignedRefDes !== null){
+        symbol.setLabelValue("refdes", component.assignedRefDes);
     }
 
-    symbol.setLabelValue('refdes', component.instanceName);
+    for (const [key, value] of component.parameters) {
+        if (key !== 'refdes' && key !== 'net_name') {
+            let useValue: string;
+
+            if (typeof value == 'object' && (value instanceof NumericValue)) {
+                useValue = (value as NumericValue).toDisplayString();
+            } else if (typeof value === 'number') {
+                useValue = value.toString();
+            } else if (typeof value === 'string'){
+                useValue = value;
+            }
 
-    if (component.parameters.has('MPN')) {
-        symbol.setLabelValue('MPN', component.parameters.get('MPN') as string);
+            symbol.setLabelValue(key, useValue);
+        }
     }
 }
 

package/src/main.ts

@@ -4,16 +4,10 @@ import { program } from 'commander';
 import figlet from 'figlet';
 import path from 'path';
 import { fileURLToPath } from 'url';
-import { readFileSync, watch, writeFileSync } from 'fs';
+import { readFileSync, watch } from 'fs';
 
-import { MainVisitor } from './visitor.js';
 import { prepareSizing } from './sizing.js';
-import { LayoutEngine } from './layout.js';
-import { generateSVG2 } from './render.js';
-import { SequenceAction } from './objects/ExecutionScope.js';
-import { parseFileWithVisitor } from './parser.js';
-import { generateKiCADNetList } from './export.js';
-import { SimpleStopwatch } from './utils.js';
+import { renderScript } from './helpers.js';
 
 export default async function main(): Promise<void> {
     const toolSrcPath = fileURLToPath(import.meta.url);
@@ -108,108 +102,4 @@ export default async function main(): Promise<void> {
     }
 }
 
-
-export function renderScript(scriptData: string, outputPath: string, options): string {
-
-    const {
-        currentDirectory = null, 
-        defaultLibsPath,
-        dumpNets = false,
-        dumpData = false,
-        kicadNetlistPath = null,
-        showStats = false} = options;
-
-    const visitor = new MainVisitor(true);
-
-    visitor.onImportFile = visitor.createImportFileHandler(currentDirectory, defaultLibsPath);
-
-    visitor.print('reading file');
-    visitor.print('done reading file');
-
-    const { tree, parser,
-        hasParseError, hasError, 
-        parserTimeTaken, 
-        lexerTimeTaken } = parseFileWithVisitor(visitor, scriptData);
-
-    showStats && console.log('Lexing took:', lexerTimeTaken);
-    showStats && console.log('Parsing took:', parserTimeTaken);
-    dumpNets && console.log(visitor.dumpNets());
-
-    dumpData && writeFileSync('dump/tree.lisp', tree.toStringTree(null, parser));
-    dumpData && writeFileSync('dump/raw-parser.txt', visitor.logger.dump());
-    
-    if (hasError || hasParseError) {
-        console.log('Error while parsing');
-        return null;
-    }
-
-    visitor.annotateComponents();
-
-    if (kicadNetlistPath) {
-        const kicadNetList = generateKiCADNetList(visitor.getNetList());
-        writeFileSync(kicadNetlistPath, kicadNetList);
-        console.log('Generated KiCad netlist file');
-    }
-    
-
-    // await writeFile('dump/raw-netlist.json', JSON.stringify(visitor.dump2(), null, 2));
-
-    const { sequence, nets } = visitor.getGraph();
-
-    // const tmpInstances = visitor.getExecutor().scope.instances;
-    // for (const [instanceName, instance] of tmpInstances){
-    //     console.log(instanceName);
-    //     console.log(instance.pinNets);
-    // }
-
-
-    const tmpSequence = sequence.map(item => {
-        const tmp = [...item];
-
-        const action = tmp[0];
-
-        if (action === SequenceAction.Wire) {
-            tmp[2] = tmp[2].map(item2 => {
-                return [item2.direction, item2.value].join(",");
-            }).join(" ");
-        } else if (action === SequenceAction.Frame) {
-            tmp[1] = item[1].frameId;
-            
-        } else if (action !== SequenceAction.WireJump) {
-            tmp[1] = item[1].instanceName;
-        }
-
-        return tmp.join(" | ");
-    });
-
-    dumpData && writeFileSync('dump/raw-sequence.txt', tmpSequence.join('\n'));
-    let svgOutput: string = null;
-
-    try {
-        const layoutEngine = new LayoutEngine();
-        const layoutTimer = new SimpleStopwatch();
-
-        const graph = layoutEngine.runLayout(sequence, nets);
-
-        layoutEngine.printWarnings();
-
-        showStats && console.log('Layout took:', layoutTimer.lap());
-
-        dumpData && writeFileSync('dump/raw-layout.txt', layoutEngine.logger.dump());
-
-        const generateSvgTimer = new SimpleStopwatch();
-        svgOutput = generateSVG2(graph);
-        showStats && console.log('Render took:', generateSvgTimer.lap());
-
-        if (outputPath){
-            writeFileSync(outputPath, svgOutput);
-        } 
-    } catch (err) {
-        console.log('Failed to render:');
-        console.log(err)
-    }
-
-    return svgOutput;
-}
-
 main();

package/src/regenerate-tests.ts

@@ -1,5 +1,5 @@
 import fs from 'fs';
-import { renderScript } from './main.js';
+import { renderScript } from './helpers.js';
 
 const mainDir = './__tests__/renderData/';
 
@@ -21,5 +21,5 @@ cstFiles.forEach(file => {
     const outputPath = inputPath + '.svg';
     renderScript(scriptData, outputPath, { currentDirectory: useCurrentDir });
 
-    console.log('generated ', inputPath);
+    console.log('generated ', outputPath);
 });

package/src/sizing.ts

@@ -1,13 +1,14 @@
 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',
+    // 'Inter': 'Inter-Regular.ttf', 
+    // 'Inter-Bold': 'Inter-Bold.ttf',
 }
 
 export async function prepareSizing(fontsPath): Promise<void> {
@@ -68,18 +69,14 @@ export function measureTextSize2(text: string, fontFamily: string,
                 break;
         }
 
-        if (fontWeight === 'bold'){
-            fontFamily = 'Inter-Bold';
-        } else {
-            fontFamily = 'Inter-Regular';
-        }
+        fontFamily = defaultFont;
         
         const tmpTextElement = MainCanvas.text(text).font({
             family: fontFamily,
             size: fontSize,
             anchor: anchor,
             'dominant-baseline': dominantBaseline,
-            // weight: fontWeight,
+            weight: fontWeight,
         }).fill('#333');
 
         const textbox = tmpTextElement.bbox();

package/src/visitor.ts

@@ -1352,8 +1352,8 @@ export class MainVisitor extends ParseTreeVisitor<any> {
                 }
 
                 if (instance.typeProp === null){
-                    this.print('Instance has no type:', instance.instanceName);
-                    continue;
+                    this.print('Instance has no type:', instance.instanceName, ' assuming connector');
+                    instance.typeProp = 'conn';
                 }
 
                 if (instance.parameters.has('refdes')) {
@@ -1569,8 +1569,20 @@ class ComponentAnnotater {
     }
 
     getAnnotation(type: string): string | null {
-        if (this.counter[type] === undefined) {
-            return null;
+
+        // If type is unknown, then allow it to define a new range
+        if (this.counter[type] === undefined && type.length <= 2) {
+            for (const [, value] of Object.entries(ComponentRefDesPrefixes)) {
+                if (value === type) {
+                    throw "Refdes prefix is already in use!";
+                }
+            }
+
+            if (ComponentRefDesPrefixes[type] === undefined) {
+                // Define new type and start counting
+                ComponentRefDesPrefixes[type] = type;
+                this.counter[type] = 1;
+            }
         }
 
         let attempts = 100;