circuitscript 0.0.7 → 0.0.13

package/src/main.ts

@@ -2,9 +2,9 @@
 
 import { program } from 'commander';
 import figlet from 'figlet';
-
-import fs from 'fs';
 import path from 'path';
+import { fileURLToPath } from 'url';
+import { readFileSync, watch, writeFileSync } from 'fs';
 
 import { MainVisitor } from './visitor.js';
 import { prepareSizing } from './sizing.js';
@@ -16,10 +16,18 @@ import { generateKiCADNetList } from './export.js';
 import { SimpleStopwatch } from './utils.js';
 
 export default async function main(): Promise<void> {
+    const toolSrcPath = fileURLToPath(import.meta.url);
+
+    const toolDirectory = path.dirname(toolSrcPath) + '/../../';
+    const fontsPath = toolDirectory + '/fonts';
+    const defaultLibsPath = toolDirectory + '/libs'; 
+    
+    const packageJson = JSON.parse(readFileSync(toolDirectory + 'package.json').toString());;
+    const {version} = packageJson;
 
     program
         .description('generate graphical output from circuitscript files')
-        .version('0.0.6')
+        .version(version)
         .option('-i, --input text <input text>', 'Input text directly')
         .option('-f, --input-file <path>', 'Input file')
         .option('-o, --output <path>', 'Output path')
@@ -55,7 +63,7 @@ export default async function main(): Promise<void> {
         console.log('watching for file changes...');
     }
 
-    await prepareSizing();
+    await prepareSizing(fontsPath);
 
     let inputFilePath: string = null;
 
@@ -64,7 +72,7 @@ export default async function main(): Promise<void> {
         scriptData = options.input;
     } else {
         inputFilePath = options.inputFile; // this should be provided
-        scriptData = fs.readFileSync(inputFilePath, { encoding: 'utf-8' });
+        scriptData = readFileSync(inputFilePath, { encoding: 'utf-8' });
 
         if (currentDirectory === null) {
             currentDirectory = path.dirname(inputFilePath);
@@ -73,6 +81,7 @@ export default async function main(): Promise<void> {
 
     const renderOptions = {
         currentDirectory,
+        defaultLibsPath,
         dumpNets, 
         dumpData,
         kicadNetlistPath: kicadNetlist,
@@ -87,9 +96,9 @@ export default async function main(): Promise<void> {
     }
 
     if (watchFileChanges) {
-        fs.watch(inputFilePath, (event, targetFile) => {
+        watch(inputFilePath, event => {
             if (event === 'change') {
-                const scriptData = fs.readFileSync(inputFilePath, 
+                const scriptData = readFileSync(inputFilePath, 
                     {encoding: 'utf-8'});
 
                 renderScript(scriptData, outputPath, renderOptions);
@@ -104,6 +113,7 @@ export function renderScript(scriptData: string, outputPath: string, options): s
 
     const {
         currentDirectory = null, 
+        defaultLibsPath,
         dumpNets = false,
         dumpData = false,
         kicadNetlistPath = null,
@@ -111,7 +121,7 @@ export function renderScript(scriptData: string, outputPath: string, options): s
 
     const visitor = new MainVisitor(true);
 
-    visitor.onImportFile = visitor.createImportFileHandler(currentDirectory);
+    visitor.onImportFile = visitor.createImportFileHandler(currentDirectory, defaultLibsPath);
 
     visitor.print('reading file');
     visitor.print('done reading file');
@@ -123,25 +133,21 @@ export function renderScript(scriptData: string, outputPath: string, options): s
 
     showStats && console.log('Lexing took:', lexerTimeTaken);
     showStats && console.log('Parsing took:', parserTimeTaken);
-    
-    if (dumpNets){
-        console.log(visitor.dumpNets());
-    }
-    // console.log(visitor.dumpUniqueNets());
+    dumpNets && console.log(visitor.dumpNets());
 
-    dumpData && fs.writeFileSync('dump/tree.lisp', tree.toStringTree(null, parser));
-    dumpData && fs.writeFileSync('dump/raw-parser.txt', visitor.logger.dump());
+    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;
+        return null;
     }
 
     visitor.annotateComponents();
 
-    if(kicadNetlistPath){
+    if (kicadNetlistPath) {
         const kicadNetList = generateKiCADNetList(visitor.getNetList());
-        fs.writeFileSync(kicadNetlistPath, kicadNetList);
+        writeFileSync(kicadNetlistPath, kicadNetList);
         console.log('Generated KiCad netlist file');
     }
     
@@ -176,7 +182,7 @@ export function renderScript(scriptData: string, outputPath: string, options): s
         return tmp.join(" | ");
     });
 
-    dumpData && fs.writeFileSync('dump/raw-sequence.txt', tmpSequence.join('\n'));
+    dumpData && writeFileSync('dump/raw-sequence.txt', tmpSequence.join('\n'));
     let svgOutput: string = null;
 
     try {
@@ -189,14 +195,14 @@ export function renderScript(scriptData: string, outputPath: string, options): s
 
         showStats && console.log('Layout took:', layoutTimer.lap());
 
-        dumpData && fs.writeFileSync('dump/raw-layout.txt', layoutEngine.logger.dump());
+        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){
-            fs.writeFileSync(outputPath, svgOutput);
+            writeFileSync(outputPath, svgOutput);
         } 
     } catch (err) {
         console.log('Failed to render:');

package/src/parser.ts

@@ -91,14 +91,14 @@ export class CircuitscriptParserErrorListener extends ErrorListener {
         this.syntaxErrorCounter++;
     }
 
-    reportAmbiguity(recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs) {
-    }
+    // reportAmbiguity(recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs) {
+    // }
 
-    reportAttemptingFullContext(recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs) {
-    }
+    // reportAttemptingFullContext(recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs) {
+    // }
 
-    reportContextSensitivity(recognizer, dfa, startIndex, stopIndex, prediction, configs) {
-    }
+    // reportContextSensitivity(recognizer, dfa, startIndex, stopIndex, prediction, configs) {
+    // }
 
     hasParseErrors(): boolean {
         return (this.syntaxErrorCounter > 0);

package/src/sizing.ts

@@ -10,8 +10,8 @@ const supportedFonts = {
     'Inter-Bold': 'Inter-Bold.ttf',
 }
 
-export async function prepareSizing(): Promise<void> {
-    await config.setFontDir('./fonts')
+export async function prepareSizing(fontsPath): Promise<void> {
+    await config.setFontDir(fontsPath)
         .setFontFamilyMappings(supportedFonts)
         .preloadFonts()
 }

package/src/visitor.ts

@@ -1,7 +1,7 @@
 import { ParseTreeVisitor, ParserRuleContext } from 'antlr4';
 
-import fs from 'fs';
-import path from 'path';
+import { readFileSync } from 'fs';
+import { join } from 'path';
 
 import {
     Add_component_exprContext,
@@ -1093,31 +1093,60 @@ export class MainVisitor extends ParseTreeVisitor<any> {
         PinTypes.Power,
     ];
 
-    createImportFileHandler(directory: string):
+    createImportFileHandler(directory: string, defaultLibsPath: string):
         ((visitor: MainVisitor, importPath: string) =>
-            { hasError: boolean, hasParseError: boolean }) {
+            { hasError: boolean, hasParseError: boolean, pathExists: boolean }) {
+
         return (visitor: MainVisitor, importPath: string) => {
             // Check if different files exist first
-            const tmpFilePath = path.join(directory, importPath + ".cst");
-            visitor.print('importing path:', tmpFilePath);
+            let importResult: {
+                hasError: boolean,
+                hasParseError: boolean,
+                pathExists: boolean,
+            };
 
-            try {
-                const fileData = fs.readFileSync(tmpFilePath, { encoding: 'utf8' });
+            importResult = this.importLib(visitor, directory, importPath);
+
+            if (!importResult.pathExists && importPath == 'lib') {
+                // Load default path
+                importResult = this.importLib(visitor, defaultLibsPath, importPath);
+            }
+
+            return importResult;
+        }
+    }
+
+    private importLib(visitor: MainVisitor, directory: string, filename: string): {hasError: boolean, hasParseError: boolean, pathExists: boolean} {
+        const tmpFilePath = join(directory, filename + ".cst");
+        visitor.print('importing path:', tmpFilePath);
+        let pathExists = false;
+
+        let fileData: string = null;
+
+        try {
+            fileData = readFileSync(tmpFilePath, { encoding: 'utf8' });
+            pathExists = true;
+        } catch (err) {
+            pathExists = false;
+        }
+
+        try {
+            if (pathExists){
                 visitor.print('done reading imported file data');
 
                 const { hasError, hasParseError } =
                     parseFileWithVisitor(visitor, fileData);
 
-                return { hasError, hasParseError }
-
-            } catch (err) {
-                console.log('Failed to import file: ', err.message);
+                return { hasError, hasParseError, pathExists }
             }
+        } catch (err) {
+            visitor.print('Failed to import file: ', err.message);
+        }
 
-            return {
-                hasError: true,
-                hasParseError: true
-            }
+        return {
+            hasError: true,
+            hasParseError: true,
+            pathExists,
         }
     }
 

package/tsconfig.json

@@ -17,7 +17,10 @@
       "noUnusedParameters": true,
       "noImplicitAny": false,
       "noImplicitThis": false,
-      "strictNullChecks": false
+      "strictNullChecks": false,
+      "resolveJsonModule": true,
+      "skipLibCheck": true,
+      "esModuleInterop":true,
     },
     "include": ["src/**/*", "__tests__/**/*"]
   }