circuitscript 0.3.2 → 0.4.1

package/dist/esm/{draw_symbols.js → render/draw_symbols.js}

@@ -1,11 +1,11 @@
-import { milsToMM } from "./helpers.js";
-import { ColorScheme, CustomSymbolParamTextSize, CustomSymbolPinIdSize, CustomSymbolPinTextSize, CustomSymbolRefDesSize, PortArrowSize, PortPaddingHorizontal, PortPaddingVertical, ReferenceTypes, RenderFlags, SymbolPinSide, defaultFont, defaultPinIdTextSize, defaultPinNameTextSize, defaultSymbolLineWidth, fontDisplayScale } from "./globals.js";
+import { milsToMM } from "../helpers.js";
+import { ColorScheme, CustomSymbolParamTextSize, CustomSymbolPinIdSize, CustomSymbolPinTextSize, CustomSymbolRefDesSize, PinTypesList, PortArrowSize, PortPaddingHorizontal, PortPaddingVertical, ReferenceTypes, RenderFlags, SymbolPinSide, defaultFont, defaultPinIdTextSize, defaultPinNameTextSize, defaultSymbolLineWidth, fontDisplayScale } from "../globals.js";
 import { Geometry, GeometryProp, HorizontalAlign, HorizontalAlignProp, Textbox, VerticalAlign, VerticalAlignProp } from "./geometry.js";
-import { PinTypes } from "./objects/PinTypes.js";
-import { roundValue, RuntimeExecutionError, throwWithContext } from "./utils.js";
-import { DeclaredReference, UndeclaredReference } from "./objects/types.js";
-import { numeric, NumericValue } from "./objects/ParamDefinition.js";
-import { PinId } from "./objects/PinDefinition.js";
+import { PinTypes } from "../objects/PinTypes.js";
+import { roundValue, RuntimeExecutionError, throwWithContext } from "../utils.js";
+import { DeclaredReference, UndeclaredReference } from "../objects/types.js";
+import { numeric, NumericValue } from "../objects/ParamDefinition.js";
+import { PinId } from "../objects/PinDefinition.js";
 export class SymbolGraphic {
     drawPortsName = true;
     displayBounds = false;
@@ -136,18 +136,19 @@ export class SymbolGraphic {
         for (const label of labels) {
             const tmpLabel = label;
             const { fontSize = numeric(50), anchor = HorizontalAlign.Left, vanchor = VerticalAlign.Bottom, fontWeight = 'regular', angle: tmpLabelAngle = numeric(0), textColor = "#333", } = tmpLabel.style ?? {};
-            const labelAngle = tmpLabelAngle.toNumber();
             let anchorStyle = 'start';
             let dominantBaseline = 'auto';
             let useAnchor = anchor;
             let useDominantBaseline = vanchor;
-            const isRotation180 = Math.abs(this.angle) === 180;
+            const labelAngle = tmpLabelAngle.toNumber();
+            const finalLabelAngle = labelAngle + this.angle;
+            const isRotation180 = Math.abs(finalLabelAngle) === 180;
             if (isRotation180) {
                 useAnchor = this.flipTextAnchor(anchor);
                 useDominantBaseline = this.flipDominantBaseline(vanchor);
             }
-            const isHorizontalLabel = labelAngle === 0 || labelAngle === 180;
-            const isVerticalLabel = labelAngle === 90 || labelAngle === -90;
+            const isHorizontalLabel = finalLabelAngle === 0 || finalLabelAngle === 180;
+            const isVerticalLabel = finalLabelAngle === 90 || finalLabelAngle === -90;
             if (useAnchor === HorizontalAlign.Middle) {
                 anchorStyle = HorizontalAlignProp.Middle;
             }
@@ -187,16 +188,9 @@ export class SymbolGraphic {
             const textContainer = group.group();
             let translateX, translateY;
             let useRotateAngle = 0;
-            if (isRotation180) {
-                translateX = position[0].neg();
-                translateY = position[1].neg();
-                useRotateAngle = 0;
-            }
-            else {
-                translateX = position[0];
-                translateY = position[1];
-                useRotateAngle = this.angle;
-            }
+            translateX = position[0];
+            translateY = position[1];
+            useRotateAngle = this.angle;
             translateX = roundValue(translateX);
             translateY = roundValue(translateY);
             const { portType = null } = tmpLabel.style;
@@ -291,6 +285,10 @@ export class SymbolGraphic {
             }
             textContainer.translate(translateX.toNumber(), translateY.toNumber())
                 .rotate(useRotateAngle, -translateX.toNumber(), -translateY.toNumber());
+            let useLabelAngle = labelAngle;
+            if (isRotation180) {
+                useLabelAngle = (labelAngle + 180) % 360;
+            }
             textContainer.text(tmpLabel.text)
                 .fill(textColor)
                 .font({
@@ -301,7 +299,7 @@ export class SymbolGraphic {
                 weight: fontWeight,
             })
                 .attr("xml:space", "preserve")
-                .rotate(labelAngle, 0, 0);
+                .rotate(useLabelAngle, 0, 0);
             const { a, b, c, d, e, f } = textContainer.matrix();
             const newMatrix = {
                 a: roundValue(numeric(a)).toNumber(),
@@ -512,16 +510,21 @@ export class SymbolPlaceholder extends SymbolGraphic {
     drawPinParams(drawing, commandName, keywordParams, positionParams, lineColor, pinNameColor) {
         drawing.log('add pin', ...positionParams);
         positionParams = [...positionParams];
-        const keywordDisplayPinId = 'display_pin_id';
+        const keywordDisplayPinId = 'display_id';
+        const keywordDisplayPinName = 'display_name';
         let displayPinId = true;
+        let displayPinName = true;
         if (keywordParams.has(keywordDisplayPinId)) {
             const value = keywordParams.get(keywordDisplayPinId);
-            if (value instanceof NumericValue && value.toNumber() === 0) {
-                displayPinId = false;
-            }
-            if (value === 0 || value === false) {
-                displayPinId = false;
-            }
+            displayPinId = ((value instanceof NumericValue && value.toNumber() === 0)
+                || (value === 0)
+                || (value === false)) ? false : true;
+        }
+        if (keywordParams.has(keywordDisplayPinName)) {
+            const value = keywordParams.get(keywordDisplayPinName);
+            displayPinName = ((value instanceof NumericValue && value.toNumber() === 0)
+                || (value === 0)
+                || (value === false)) ? false : true;
         }
         let pinNameParam = null;
         let pinType = PinTypes.Any;
@@ -529,6 +532,10 @@ export class SymbolPlaceholder extends SymbolGraphic {
             pinType = positionParams[1].value;
             positionParams = [positionParams[0], ...positionParams.slice(2)];
         }
+        else if (typeof positionParams[1] === 'string' && PinTypesList.indexOf(positionParams[1]) !== -1) {
+            pinType = positionParams[1];
+            positionParams = [positionParams[0], ...positionParams.slice(2)];
+        }
         if (typeof positionParams[1] === 'string') {
             pinNameParam = positionParams[1];
             positionParams = [positionParams[0], ...positionParams.slice(2)];
@@ -578,12 +585,14 @@ export class SymbolPlaceholder extends SymbolGraphic {
         let pinNameAlignment = HorizontalAlign.Left;
         const offset1 = 15;
         const offset2 = 15;
-        let pinNameOffsetX = milsToMM(offset1);
+        let pinNameOffsetX = milsToMM(0);
+        let pinNameOffsetY = milsToMM(0);
         let pinIdOffsetX = numeric(0);
         let pinIdAlignment = HorizontalAlign.Left;
         let pinIdVAlignment = VerticalAlign.Bottom;
         let pinIdOffsetY = milsToMM(-offset2);
         const angleValue = angle.toNumber();
+        let usePinIdAngle = 0;
         switch (angleValue) {
             case 0:
                 pinNameAlignment = HorizontalAlign.Left;
@@ -592,6 +601,15 @@ export class SymbolPlaceholder extends SymbolGraphic {
                 pinIdOffsetX = milsToMM(-offset2);
                 break;
             case 90:
+                pinNameAlignment = HorizontalAlign.Right;
+                pinNameOffsetX = milsToMM(0);
+                pinNameOffsetY = milsToMM(offset1);
+                pinIdAlignment = HorizontalAlign.Left;
+                pinIdOffsetX = milsToMM(-offset2);
+                pinIdOffsetY = milsToMM(-offset2);
+                pinIdVAlignment = VerticalAlign.Bottom;
+                usePinIdAngle = -90;
+                break;
             case 180:
                 pinNameAlignment = HorizontalAlign.Right;
                 pinNameOffsetX = milsToMM(-offset1);
@@ -600,27 +618,31 @@ export class SymbolPlaceholder extends SymbolGraphic {
                 break;
             case 270:
                 pinNameAlignment = HorizontalAlign.Left;
-                pinNameOffsetX = milsToMM(offset1);
-                pinIdAlignment = HorizontalAlign.Left;
-                pinIdOffsetX = milsToMM(offset2);
+                pinNameOffsetX = milsToMM(0);
+                pinNameOffsetY = milsToMM(-offset1);
+                pinIdAlignment = HorizontalAlign.Right;
+                pinIdOffsetX = milsToMM(-offset2);
                 pinIdOffsetY = milsToMM(offset2);
-                pinIdVAlignment = VerticalAlign.Top;
+                pinIdVAlignment = VerticalAlign.Bottom;
+                usePinIdAngle = -90;
                 break;
         }
         if (angleValue === 0 || angleValue === 90 || angleValue === 180 || angleValue === 270) {
             const usePinName = pinNameParam ?? "";
-            usePinName !== "" && drawing.addLabel(endX.add(pinNameOffsetX), endY, usePinName, {
+            displayPinName && usePinName !== "" && drawing.addLabel(endX.add(pinNameOffsetX), endY.add(pinNameOffsetY), usePinName, {
                 fontSize: numeric(defaultPinNameTextSize),
                 anchor: pinNameAlignment,
                 vanchor: VerticalAlign.Middle,
                 textColor: pinNameColor,
+                angle: numeric(usePinIdAngle)
             });
             const pinDisplayText = pinId.toString();
             displayPinId && drawing.addLabel(endX.add(pinIdOffsetX), endY.add(pinIdOffsetY), pinDisplayText, {
                 fontSize: numeric(defaultPinIdTextSize),
                 anchor: pinIdAlignment,
                 vanchor: pinIdVAlignment,
-                textColor: lineColor
+                textColor: lineColor,
+                angle: numeric(usePinIdAngle)
             });
         }
     }

package/dist/esm/{export.js → render/export.js}

@@ -1,5 +1,5 @@
-import { NoNetText } from "./globals.js";
-import { NumericValue } from "./objects/ParamDefinition.js";
+import { NoNetText } from "../globals.js";
+import { NumericValue } from "../objects/ParamDefinition.js";
 export function generateKiCadNetList(netlist) {
     const componentsList = [];
     const nets = {};

package/dist/esm/{geometry.js → render/geometry.js}

@@ -1,9 +1,9 @@
 import Flatten from '@flatten-js/core';
-import { measureTextSize2 } from './sizing.js';
-import { defaultFont, fontDisplayScale, PortArrowSize, PortPaddingHorizontal, PortPaddingVertical } from './globals.js';
-import { numeric, NumericValue } from './objects/ParamDefinition.js';
-import { AllPinTypes, PinTypes } from './objects/PinTypes.js';
-import { roundValue } from './utils.js';
+import { measureTextSize2 } from '../sizing.js';
+import { defaultFont, fontDisplayScale, PortArrowSize, PortPaddingHorizontal, PortPaddingVertical } from '../globals.js';
+import { numeric, NumericValue } from '../objects/ParamDefinition.js';
+import { AllPinTypes, PinTypes } from '../objects/PinTypes.js';
+import { roundValue } from '../utils.js';
 export class Textbox extends Flatten.Polygon {
     id;
     text;

package/dist/esm/{graph.js → render/graph.js}

@@ -1,14 +1,14 @@
 import { Graph } from "@dagrejs/graphlib";
 import { SymbolDrawing, SymbolPlaceholder, SymbolCustomModule, SymbolCustom } from "./draw_symbols.js";
-import { ComponentTypes } from "./globals.js";
-import { milsToMM } from "./helpers.js";
+import { ComponentTypes } from "../globals.js";
+import { milsToMM } from "../helpers.js";
 import { RenderFrame, RenderComponent, applyComponentParamsToSymbol, RenderWire } from "./layout.js";
-import { SequenceAction, FrameAction } from "./objects/ExecutionScope.js";
-import { Frame, FixedFrameIds, FrameParamKeys } from "./objects/Frame.js";
-import { numeric } from "./objects/ParamDefinition.js";
-import { NetTypes } from "./objects/types.js";
+import { SequenceAction, FrameAction } from "../objects/ExecutionScope.js";
+import { Frame, FixedFrameIds, FrameParamKeys } from "../objects/Frame.js";
+import { numeric } from "../objects/ParamDefinition.js";
+import { NetTypes } from "../objects/types.js";
 import Matrix, { solve } from "ml-matrix";
-import { getPinDefinition, PinId } from "./objects/PinDefinition.js";
+import { getPinDefinition, PinId } from "../objects/PinDefinition.js";
 export class NetGraph {
     logger;
     constructor(logger) {

package/dist/esm/{layout.js → render/layout.js}

@@ -1,14 +1,14 @@
 import graphlib from '@dagrejs/graphlib';
 const { alg } = graphlib;
 import { SymbolCustom, SymbolDrawing, SymbolPlaceholder, SymbolText, PlaceHolderCommands } from "./draw_symbols.js";
-import { DefaultComponentUnit, defaultFrameTitleTextSize, defaultGridSizeUnits, FrameType, NetGraphicsParams, ParamKeys, WireAutoDirection } from './globals.js';
+import { DefaultComponentUnit, defaultFrameTitleTextSize, defaultGridSizeUnits, FrameType, NetGraphicsParams, ParamKeys, WireAutoDirection } from '../globals.js';
 import { Geometry, HorizontalAlign, VerticalAlign } from './geometry.js';
-import { FixedFrameIds, Frame, FrameParamKeys, FramePlotDirection } from './objects/Frame.js';
-import { areasOverlap, combineMaps, getBoundsSize, printBounds, resizeBounds, resizeToNearestGrid, roundValue, toNearestGrid } from './utils.js';
-import { Direction } from './objects/types.js';
-import { PinId } from './objects/PinDefinition.js';
-import { milsToMM, UnitDimension } from './helpers.js';
-import { numeric } from './objects/ParamDefinition.js';
+import { FixedFrameIds, Frame, FrameParamKeys, FramePlotDirection } from '../objects/Frame.js';
+import { areasOverlap, combineMaps, getBoundsSize, printBounds, resizeBounds, resizeToNearestGrid, roundValue, toNearestGrid } from '../utils.js';
+import { Direction } from '../objects/types.js';
+import { PinId } from '../objects/PinDefinition.js';
+import { milsToMM, UnitDimension } from '../helpers.js';
+import { numeric } from '../objects/ParamDefinition.js';
 import { generateLayoutPinDefinition, getWireName, RenderItemType } from './graph.js';
 export class LayoutEngine {
     logger;
@@ -1309,7 +1309,7 @@ export function CalculatePinPositions(unit) {
     }
     applyComponentParamsToSymbol(unit, tmpSymbol);
     tmpSymbol.refreshDrawing();
-    const pins = unit.pins;
+    const { pins } = unit;
     pins.forEach((value, key) => {
         if (unit._unplacedPins.indexOf(key) === -1) {
             pinPositionMapping.set(key, tmpSymbol.pinPosition(key));

package/dist/esm/{render.js → render/render.js}

@@ -1,13 +1,14 @@
 import { SVG, registerWindow } from '@svgdotjs/svg.js';
 import { ExtractDrawingRects, RenderFrameType, getBounds } from "./layout.js";
-import { applyFontsToSVG } from './sizing.js';
-import { ColorScheme, ComponentTypes, FrameType, MMToPt, MMToPx, MilsToMM, ParamKeys, RenderFlags, defaultGridSizeUnits, defaultPageSpacingMM, defaultWireLineWidth, fontDisplayScale, junctionSize } from './globals.js';
-import { numeric, NumericValue } from './objects/ParamDefinition.js';
-import { combineMaps, getBoundsSize } from './utils.js';
-import { getPaperSize, milsToMM } from './helpers.js';
-import { NodeScriptEnvironment } from "./environment.js";
+import { applyFontsToSVG } from '../sizing.js';
+import { ColorScheme, ComponentTypes, FrameType, MMToPt, MMToPx, MilsToMM, ParamKeys, RenderFlags, defaultGridSizeUnits, defaultPageSpacingMM, defaultWireLineWidth, fontDisplayScale, junctionSize } from '../globals.js';
+import { numeric, NumericValue } from '../objects/ParamDefinition.js';
+import { combineMaps, getBoundsSize } from '../utils.js';
+import { milsToMM } from '../helpers.js';
+import { getPaperSize } from "./PaperSizes.js";
+import { NodeScriptEnvironment } from "../environment/environment.js";
 import SVGtoPDF from 'svg-to-pdfkit';
-import { FrameParamKeys } from './objects/Frame.js';
+import { FrameParamKeys } from '../objects/Frame.js';
 import { SymbolPlaceholder } from './draw_symbols.js';
 function createSvgCanvas() {
     const env = NodeScriptEnvironment.getInstance();

package/dist/esm/rules-check/no-connect-on-connected-pin.js

@@ -1,4 +1,4 @@
-import { RenderItemType } from "../graph.js";
+import { RenderItemType } from "../render/graph.js";
 import { ERC_Rules } from "./rules.js";
 export function RuleCheck_NoConnectOnConnectedPin(graph, nets) {
     const allNodes = graph.nodes();

package/dist/esm/rules-check/unconnected-pins.js

@@ -1,4 +1,4 @@
-import { RenderItemType } from "../graph.js";
+import { RenderItemType } from "../render/graph.js";
 import { ERC_Rules } from "./rules.js";
 export function RuleCheck_UnconnectedPinsWires(graph) {
     const items = [];

package/dist/esm/{SemanticTokenVisitor.js → semantic-tokens/SemanticTokenVisitor.js}

@@ -1,7 +1,7 @@
-import { Assignment_exprContext } from "./antlr/CircuitScriptParser.js";
-import { BaseVisitor } from "./BaseVisitor.js";
-import { buildInMethodNamesList } from "./builtinMethods.js";
-import { SymbolValidatorContext } from "./globals.js";
+import { Assignment_exprContext } from "../antlr/CircuitScriptParser.js";
+import { BaseVisitor } from "../BaseVisitor.js";
+import { buildInMethodNamesList } from "../builtinMethods.js";
+import { SymbolValidatorContext } from "../globals.js";
 export class SemanticTokensVisitor extends BaseVisitor {
     parsedTokens = [];
     lexer;
@@ -47,14 +47,16 @@ export class SemanticTokensVisitor extends BaseVisitor {
         this.runExpressions(newExecutor, ctx.function_expr());
         this.executionStack.pop();
     };
-    visitCreate_component_expr = (ctx) => {
+    visitCreateExpr = (ctx) => {
         this.addSemanticToken(ctx.Create(), ['defaultLibrary'], 'function');
+        this.visit(ctx.create_expr());
+    };
+    visitCreate_component_expr = (ctx) => {
         ctx.property_expr().forEach(property_expr => {
             this.visit(property_expr);
         });
     };
     visitCreate_graphic_expr = (ctx) => {
-        this.addSemanticToken(ctx.Create(), ['defaultLibrary'], 'function');
         const graphicsExpressionsCtx = ctx.graphic_expressions_block();
         this.visitResult(graphicsExpressionsCtx);
     };
@@ -101,18 +103,14 @@ export class SemanticTokensVisitor extends BaseVisitor {
         }
     };
     visitAssignment_expr = (ctx) => {
-        this.visit(ctx.atom_expr());
+        this.visit(ctx.callable_expr());
         this.visit(ctx.data_expr());
     };
-    visitAtom_expr = (ctx) => {
-        if (ctx.parent instanceof Assignment_exprContext && ctx.ID(0)) {
-            this.addSemanticToken(ctx.ID(0), [], 'variable');
+    visitCallable_expr = (ctx) => {
+        if (ctx.parent instanceof Assignment_exprContext && ctx.ID()) {
+            this.addSemanticToken(ctx.ID(), [], 'variable');
         }
     };
-    visitOperator_assignment_expr = (ctx) => {
-        this.visit(ctx.atom_expr());
-        this.visit(ctx.data_expr());
-    };
     visitImport_expr = (ctx) => {
         this.addSemanticToken(ctx.ID(), [], 'namespace');
     };

package/dist/esm/semantic-tokens/getSemanticTokens.js

@@ -0,0 +1,51 @@
+import { prepareFile } from "../helpers.js";
+import { prepareTokens, SemanticTokensVisitor } from "./SemanticTokenVisitor.js";
+import { ParseError } from "../utils.js";
+export async function getSemanticTokens(filePath, scriptData, options) {
+    const { parser, lexer, tokens } = prepareFile(scriptData);
+    const tree = parser.script();
+    const visitor = new SemanticTokensVisitor(true, null, options.environment, lexer, scriptData);
+    parser.removeErrorListeners();
+    visitor.onImportFile = async (visitor, filePath, textData) => {
+        let hasError = false;
+        let hasParseError = false;
+        if (textData !== null) {
+            const { parser } = prepareFile(textData);
+            const tree = parser.script();
+            try {
+                visitor.visit(tree);
+            }
+            catch (err) {
+                console.log('Error while parsing: ', err);
+                hasParseError = true;
+                hasError = true;
+                throw new ParseError(`Error parsing semantic tokens in imported file: ${err}`);
+            }
+        }
+        else {
+            console.log('File does not exist');
+            hasError = true;
+        }
+        return {
+            hasError, hasParseError
+        };
+    };
+    await visitor.resolveImportsAndLoad(filePath, scriptData);
+    visitor.visit(tree);
+    const semanticTokens = visitor.getTokens();
+    const parsedTokens = prepareTokens(tokens.getTokens(), lexer, scriptData);
+    const finalParsedTokens = [];
+    parsedTokens.forEach(token => {
+        const location = `${token.line}_${token.column}_${token.length}`;
+        if (semanticTokens.has(location)) {
+            finalParsedTokens.push(semanticTokens.get(location));
+        }
+        else {
+            finalParsedTokens.push(token);
+        }
+    });
+    return {
+        visitor,
+        parsedTokens: finalParsedTokens
+    };
+}

package/dist/esm/sizing.js

@@ -1,7 +1,7 @@
 import { Big } from 'big.js';
-import { HorizontalAlign, HorizontalAlignProp, VerticalAlign, VerticalAlignProp } from './geometry.js';
+import { HorizontalAlign, HorizontalAlignProp, VerticalAlign, VerticalAlignProp } from './render/geometry.js';
 import { defaultFont } from './globals.js';
-import { NodeScriptEnvironment } from "./environment.js";
+import { NodeScriptEnvironment } from "./environment/environment.js";
 export function applyFontsToSVG(canvas) {
 }
 const measureTextSizeCache = {};

package/dist/esm/utils.js

@@ -8,10 +8,10 @@ import { DeclaredReference, AnyReference } from './objects/types.js';
 export class SimpleStopwatch {
     startTime;
     constructor() {
-        this.startTime = new Date();
+        this.startTime = performance.now();
     }
     lap() {
-        return (new Date()).getTime() - this.startTime.getTime();
+        return performance.now() - this.startTime;
     }
 }
 export function resizeBounds(bounds, value) {

package/dist/esm/validate/SymbolValidatorResolveVisitor.js

@@ -1,5 +1,8 @@
 import { SymbolValidatorVisitor } from "./SymbolValidatorVisitor.js";
 export class SymbolValidatorResolveVisitor extends SymbolValidatorVisitor {
+    enableCacheImports = false;
+    enableCachedImportsRead = false;
+    enableCachedImportsWrite = false;
     addSymbolVariable(token, name, value) {
     }
     addSymbolFunction(token, functionName, funcDefinedParameters) {

package/dist/esm/validate/SymbolValidatorVisitor.js

@@ -1,11 +1,14 @@
-import { Import_specificContext } from "../antlr/CircuitScriptParser.js";
+import { Import_specific_or_allContext } from "../antlr/CircuitScriptParser.js";
 import { buildInMethodNamesList } from "../builtinMethods.js";
 import { ImportFunctionHandling, ParseSymbolType } from "../objects/types.js";
 import { cloneSymbol } from "./SymbolTable.js";
 import { SymbolTable } from "./SymbolTable.js";
 import { BaseVisitor } from "../BaseVisitor.js";
-import { BaseNamespace, SymbolValidatorContext } from "../globals.js";
+import { BaseNamespace, PinTypesList, SymbolValidatorContext } from "../globals.js";
 export class SymbolValidatorVisitor extends BaseVisitor {
+    enableCacheImports = false;
+    enableCachedImportsRead = false;
+    enableCachedImportsWrite = false;
     symbolTable = new SymbolTable();
     addSymbolVariable(token, name, value, executor = null) {
         const useExecutor = executor === null ? this.getExecutor() : executor;
@@ -54,16 +57,16 @@ export class SymbolValidatorVisitor extends BaseVisitor {
     setSymbols(symbolTable) {
         this.symbolTable = symbolTable;
     }
-    async importCommon(ctx, handling) {
+    importCommon(ctx, handling) {
         const specifiedImports = [];
-        if (ctx instanceof Import_specificContext) {
+        if (ctx instanceof Import_specific_or_allContext) {
             const tmpImports = ctx._funcNames.map(item => {
                 return item.text;
             });
             specifiedImports.push(...tmpImports);
         }
-        const id = ctx._libraryName.text;
-        const { pathExists, importedLibrary } = await this.handleImportFile(id, handling, true, ctx, specifiedImports);
+        const id = ctx._libraryName.text.slice(1, -1);
+        const { pathExists, importedLibrary } = this.handleImportFile(id, handling, true, ctx, specifiedImports);
         if (!pathExists) {
             this.symbolTable.addUndefined(this.getCurrentFile(), this.getExecutor(), id, ctx._libraryName);
         }
@@ -71,14 +74,15 @@ export class SymbolValidatorVisitor extends BaseVisitor {
             this.applyLibraryImports(importedLibrary);
         }
     }
-    visitImport_simple = async (ctx) => {
-        await this.importCommon(ctx, ImportFunctionHandling.AllWithNamespace);
+    visitImport_simple = (ctx) => {
+        this.importCommon(ctx, ImportFunctionHandling.AllWithNamespace);
     };
-    visitImport_all_simple = async (ctx) => {
-        await this.importCommon(ctx, ImportFunctionHandling.AllMergeIntoNamespace);
-    };
-    visitImport_specific = async (ctx) => {
-        await this.importCommon(ctx, ImportFunctionHandling.SpecificMergeIntoNamespace);
+    visitImport_specific_or_all = (ctx) => {
+        let importType = ImportFunctionHandling.SpecificMergeIntoNamespace;
+        if (ctx._all) {
+            importType = ImportFunctionHandling.AllMergeIntoNamespace;
+        }
+        this.importCommon(ctx, importType);
     };
     applyLibraryImports(library) {
         const { importHandlingFlag: importHandling, specifiedImports } = library;
@@ -110,7 +114,7 @@ export class SymbolValidatorVisitor extends BaseVisitor {
         const ctxDataExpr = ctx.data_expr();
         this.visit(ctxDataExpr);
         const value = this.getResult(ctxDataExpr);
-        const atomId = ctx.atom_expr().ID(0);
+        const atomId = ctx.callable_expr().ID();
         const atomText = atomId.getText();
         const executor = this.getExecutor();
         if (!this.symbolTable.exists(executor, atomText)) {
@@ -122,37 +126,25 @@ export class SymbolValidatorVisitor extends BaseVisitor {
         }
         return null;
     };
-    visitAtom_expr = (ctx) => {
-        const tmpSymbol = this.handleAtomSymbol(ctx.ID(0));
-        this.setResult(ctx, tmpSymbol);
-    };
-    visitFunction_call_expr = (ctx) => {
-        this.handleAtomSymbol(ctx.ID());
-        if (ctx.trailer_expr().length > 0) {
-            ctx.trailer_expr().forEach(item => {
-                if (item.OPEN_PAREN() && item.CLOSE_PAREN()) {
-                    const params = item.parameters();
+    visitCallableExpr = (ctx) => {
+        const innerCtx = ctx.callable_expr();
+        const innerCtxID = innerCtx.ID();
+        if (PinTypesList.indexOf(innerCtxID.getText()) !== -1 && innerCtx.trailer().length === 0) {
+            return;
+        }
+        else {
+            const tmpSymbol = this.handleAtomSymbol(innerCtxID);
+            innerCtx.trailer().forEach(trailer => {
+                if (trailer.LParen() && trailer.RParen()) {
+                    const params = trailer.parameters();
                     if (params) {
                         this.visit(params);
                     }
                 }
             });
+            this.setResult(ctx, tmpSymbol);
         }
     };
-    visitValueAtomExpr = (ctx) => {
-        let value = null;
-        const ctxValueExpr = ctx.value_expr();
-        const cxtAtomExpr = ctx.atom_expr();
-        if (ctxValueExpr) {
-            this.visit(ctxValueExpr);
-            value = this.getResult(ctxValueExpr);
-        }
-        else if (cxtAtomExpr) {
-            this.visit(cxtAtomExpr);
-            value = this.getResult(cxtAtomExpr);
-        }
-        this.setResult(ctx, value);
-    };
     visitUnaryOperatorExpr = (ctx) => {
         this.visit(ctx.data_expr());
     };
@@ -168,9 +160,6 @@ export class SymbolValidatorVisitor extends BaseVisitor {
         this.visit(ctx.data_expr(0));
         this.visit(ctx.data_expr(1));
     };
-    visitDataExpr = (ctx) => {
-        return;
-    };
     visitFunction_def_expr = (ctx) => {
         const functionName = ctx.ID().getText();
         let funcDefinedParameters = [];
@@ -196,6 +185,12 @@ export class SymbolValidatorVisitor extends BaseVisitor {
             this.addSymbolVariable(item.getSymbol(), item.getText(), null);
         });
     };
+    visitCreate_graphic_expr = (ctx) => {
+        const ctxID = ctx.ID();
+        if (ctxID) {
+            this.addSymbolVariable(ctxID.getSymbol(), ctxID.getText(), null);
+        }
+    };
     getSymbols() {
         return this.symbolTable;
     }

package/dist/esm/validate/validateScript.js

@@ -0,0 +1,50 @@
+import { prepareFile, ParseErrorStrategy, TokenErrorListener } from "../helpers.js";
+import { ParseError } from "../utils.js";
+import { SymbolValidatorResolveVisitor } from "./SymbolValidatorResolveVisitor.js";
+import { SymbolValidatorVisitor } from "./SymbolValidatorVisitor.js";
+export async function validateScript(filePath, scriptData, options) {
+    const { parser } = prepareFile(scriptData);
+    parser.removeErrorListeners();
+    parser.errorHandler = new ParseErrorStrategy();
+    parser.addErrorListener(new TokenErrorListener());
+    const tree = parser.script();
+    const visitor = new SymbolValidatorVisitor(true, null, options.environment);
+    await visitor.resolveImportsAndLoad(filePath, scriptData);
+    visitor.enterFile(filePath);
+    visitor.onImportFile = (visitor, filePath, textData) => {
+        visitor.enterFile(filePath);
+        let hasError = false;
+        let hasParseError = false;
+        if (textData !== null) {
+            const { parser } = prepareFile(textData);
+            const tree = parser.script();
+            try {
+                visitor.visit(tree);
+                visitor.exitFile();
+            }
+            catch (err) {
+                console.log('got an error while parsing tree: ', err);
+                hasParseError = true;
+                hasError = true;
+                throw new ParseError(`Error parsing validation in imported file: ${err}`);
+            }
+        }
+        else {
+            console.log('file does not exist!');
+            hasError = true;
+        }
+        return {
+            hasError, hasParseError
+        };
+    };
+    visitor.visit(tree);
+    const symbolTable = visitor.getSymbols();
+    symbolTable.clearUndefined();
+    const visitorResolver = new SymbolValidatorResolveVisitor(true, null, options.environment);
+    visitorResolver.loadedFiles = visitor.loadedFiles;
+    visitorResolver.enterFile(filePath);
+    visitorResolver.setSymbols(visitor.getSymbols());
+    visitorResolver.onImportFile = visitor.onImportFile;
+    visitorResolver.visit(tree);
+    return visitorResolver;
+}