circuitscript 0.1.5 → 0.1.8

package/dist/esm/{builtinMethods.mjs → builtinMethods.js}

@@ -1,6 +1,16 @@
 import Big from "big.js";
-import { numeric, NumericValue } from "./objects/ParamDefinition";
-import { resolveToNumericValue } from "./utils";
+import { numeric, NumericValue } from "./objects/ParamDefinition.js";
+import { resolveToNumericValue } from "./utils.js";
+const builtInMethods = [
+    ['enumerate', enumerate],
+    ['toMils', toMils],
+    ['range', range],
+    ['len', objectLength],
+    ['arrayPush', arrayPush],
+    ['arrayGet', arrayGet],
+    ['print', null],
+];
+export const buildInMethodNamesList = builtInMethods.map(item => item[0]);
 export function linkBuiltInMethods(context, visitor) {
     context.createFunction('print', (params) => {
         const args = getPositionParams(params);
@@ -12,20 +22,14 @@ export function linkBuiltInMethods(context, visitor) {
         visitor.printStream.push(printedValue);
         return [visitor, printedValue];
     });
-    const builtIns = [
-        ['enumerate', enumerate],
-        ['toMils', toMils],
-        ['range', range],
-        ['len', objectLength],
-        ['arrayPush', arrayPush],
-        ['arrayGet', arrayGet],
-    ];
-    builtIns.forEach(([functionName, functionImpl]) => {
-        context.createFunction(functionName, params => {
-            const args = getPositionParams(params);
-            const functionReturn = functionImpl(...args);
-            return [visitor, functionReturn];
-        });
+    builtInMethods.forEach(([functionName, functionImpl]) => {
+        if (functionImpl !== null) {
+            context.createFunction(functionName, params => {
+                const args = getPositionParams(params);
+                const functionReturn = functionImpl(...args);
+                return [visitor, functionReturn];
+            });
+        }
     });
 }
 function range(...args) {

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

@@ -1,10 +1,10 @@
-import { milsToMM } from "./helpers.mjs";
-import { ColorScheme, CustomSymbolParamTextSize, CustomSymbolPinIdSize, CustomSymbolPinTextSize, CustomSymbolRefDesSize, PortArrowSize, PortPaddingHorizontal, PortPaddingVertical, ReferenceTypes, RenderFlags, SymbolPinSide, defaultFont, defaultPinIdTextSize, defaultPinNameTextSize, defaultSymbolLineWidth, fontDisplayScale } from "./globals.mjs";
-import { Geometry, GeometryProp, HorizontalAlign, HorizontalAlignProp, Textbox, VerticalAlign, VerticalAlignProp } from "./geometry.mjs";
-import { PinTypes } from "./objects/PinTypes.mjs";
-import { roundValue, throwWithContext } from "./utils.mjs";
-import { DeclaredReference, UndeclaredReference } from "./objects/types.mjs";
-import { numeric, NumericValue } from "./objects/ParamDefinition.mjs";
+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 { Geometry, GeometryProp, HorizontalAlign, HorizontalAlignProp, Textbox, VerticalAlign, VerticalAlignProp } from "./geometry.js";
+import { PinTypes } from "./objects/PinTypes.js";
+import { roundValue, throwWithContext } from "./utils.js";
+import { DeclaredReference, UndeclaredReference } from "./objects/types.js";
+import { numeric, NumericValue } from "./objects/ParamDefinition.js";
 export class SymbolGraphic {
     drawPortsName = true;
     displayBounds = false;

package/dist/esm/environment.js

@@ -0,0 +1,110 @@
+import { registerWindow, SVG } from "@svgdotjs/svg.js";
+import fs from 'fs';
+import path from "path";
+import { TOOL_VERSION } from "./globals.js";
+import { RuntimeExecutionError } from "./utils.js";
+export class NodeScriptEnvironment {
+    static _instance = null;
+    static setInstance(instance) {
+        NodeScriptEnvironment._instance = instance;
+    }
+    static getInstance() {
+        return NodeScriptEnvironment._instance;
+    }
+    useModuleDirectoryPath = null;
+    useDefaultLibsPath = null;
+    globalCreateSVGWindow = null;
+    supportedFonts = {
+        'Arial': 'Arial.ttf',
+    };
+    setModuleDirectory(path) {
+        this.useModuleDirectoryPath = path;
+    }
+    setDefaultLibsPath(path) {
+        this.useDefaultLibsPath = path;
+    }
+    getPackageVersion() {
+        return TOOL_VERSION;
+    }
+    getModuleDirectory() {
+        if (this.useModuleDirectoryPath !== null) {
+            return this.useModuleDirectoryPath;
+        }
+        if (typeof __dirname !== 'undefined') {
+            return __dirname;
+        }
+        const stackLine = new Error().stack?.split('\n')[1];
+        if (stackLine) {
+            const fileMatch = stackLine.match(/\((.+)\:[\d]+\:[\d]+\)/);
+            if (fileMatch) {
+                const filePath = fileMatch[1].replace('file://', '');
+                return path.dirname(filePath);
+            }
+        }
+        throw new RuntimeExecutionError("Failed to get current module directory");
+    }
+    getRelativeToModule(filePath) {
+        return path.join(this.getModuleDirectory(), filePath);
+    }
+    getRelativeToDefaultLibs(filePath) {
+        return path.join(this.getDefaultLibsPath(), filePath);
+    }
+    getToolsPath() {
+        return path.normalize(this.getModuleDirectory() + '/../');
+    }
+    getFontsPath() {
+        return path.normalize(this.getToolsPath() + "fonts");
+    }
+    getDefaultLibsPath() {
+        if (this.useDefaultLibsPath !== null) {
+            return this.useDefaultLibsPath;
+        }
+        return path.normalize(this.getToolsPath() + "libs");
+    }
+    async prepareSVGEnvironmentInternal(fontsPath) {
+        try {
+            const dynamicImport = new Function('specifier', 'return import(specifier)');
+            const { config, createSVGWindow } = await dynamicImport('svgdom');
+            this.globalCreateSVGWindow = createSVGWindow;
+            if (fontsPath !== null) {
+                await config.setFontDir(fontsPath)
+                    .setFontFamilyMappings(this.supportedFonts)
+                    .preloadFonts();
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to load svgdom ESM module: ${error}`);
+        }
+    }
+    createSVGWindow() {
+        if (this.globalCreateSVGWindow === null) {
+            throw new Error("SVG environment is not set up yet. Call prepareSVGEnvironment() first.");
+        }
+        return this.globalCreateSVGWindow();
+    }
+    textMeasurementCanvas;
+    getCanvasWindow() {
+        if (this.textMeasurementCanvas === undefined) {
+            const window = this.createSVGWindow();
+            const { document } = window;
+            registerWindow(window, document);
+            this.textMeasurementCanvas = SVG(document.documentElement);
+        }
+        return this.textMeasurementCanvas;
+    }
+    prepareSVGEnvironment() {
+        return this.prepareSVGEnvironmentInternal(this.getFontsPath());
+    }
+    async readFile(path, options) {
+        return fs.promises.readFile(path, options);
+    }
+    async exists(path) {
+        try {
+            fs.promises.access(path, fs.constants.F_OK);
+            return true;
+        }
+        catch (err) {
+            return false;
+        }
+    }
+}

package/dist/esm/{execute.mjs → execute.js}

@@ -1,16 +1,16 @@
-import { BlockTypes, ComponentTypes, Delimiter1, GlobalNames, NoNetText, ParamKeys, ReferenceTypes, SymbolPinSide } from './globals.mjs';
-import { ClassComponent, ModuleComponent } from './objects/ClassComponent.mjs';
-import { ActiveObject, ExecutionScope, FrameAction, SequenceAction } from './objects/ExecutionScope.mjs';
-import { Net } from './objects/Net.mjs';
-import { numeric } from './objects/ParamDefinition.mjs';
-import { PortSide } from './objects/PinDefinition.mjs';
-import { DeclaredReference, Direction } from './objects/types.mjs';
-import { Wire } from './objects/Wire.mjs';
-import { Frame } from './objects/Frame.mjs';
-import { CalculatePinPositions } from './layout.mjs';
-import { UnitDimension } from './helpers.mjs';
-import { PlaceHolderCommands, SymbolDrawingCommands } from './draw_symbols.mjs';
-import { getBlockTypeString } from './utils.mjs';
+import { BlockTypes, ComponentTypes, Delimiter1, GlobalNames, NoNetText, ParamKeys, ReferenceTypes, SymbolPinSide } from './globals.js';
+import { ClassComponent, ModuleComponent } from './objects/ClassComponent.js';
+import { ActiveObject, ExecutionScope, FrameAction, SequenceAction } from './objects/ExecutionScope.js';
+import { Net } from './objects/Net.js';
+import { numeric } from './objects/ParamDefinition.js';
+import { PortSide } from './objects/PinDefinition.js';
+import { DeclaredReference, Direction } from './objects/types.js';
+import { Wire } from './objects/Wire.js';
+import { Frame } from './objects/Frame.js';
+import { CalculatePinPositions } from './layout.js';
+import { UnitDimension } from './helpers.js';
+import { PlaceHolderCommands, SymbolDrawingCommands } from './draw_symbols.js';
+import { getBlockTypeString, RuntimeExecutionError } from './utils.js';
 export class ExecutionContext {
     name;
     namespace;
@@ -211,7 +211,7 @@ export class ExecutionContext {
         this.log('to component');
         const { addSequence = false } = options ?? {};
         if (!(component instanceof ClassComponent)) {
-            throw "Not a valid component!";
+            throw new RuntimeExecutionError("Not a valid component!");
         }
         if (pinId === null) {
             pinId = component.getDefaultPin();
@@ -222,7 +222,7 @@ export class ExecutionContext {
             }
             else {
                 console.trace();
-                throw ('Invalid pin number ' +
+                throw new RuntimeExecutionError('Invalid pin number ' +
                     pinId +
                     ' in ' +
                     component.instanceName);
@@ -347,6 +347,7 @@ export class ExecutionContext {
         const stackRef = this.scope.blockStack.get(this.scope.indentLevel);
         stackRef['block_index'] = blockIndex;
         const { type: blockType } = stackRef;
+        const blockTypeName = getBlockTypeString(blockType);
         stackRef['inner_blocks'].set(blockIndex, {
             last_net: null,
             ignore_last_net: false,
@@ -359,7 +360,7 @@ export class ExecutionContext {
             const { entered_at: [component, pin,] } = stackRef;
             this.atComponent(component, pin, { addSequence: true });
         }
-        this.log(`enter inner block of type (${blockType}) >>>`);
+        this.log(`enter inner block of type (${blockTypeName}) >>>`);
         this.scope.indentLevel += 1;
     }
     exitBlock(blockIndex) {
@@ -660,24 +661,64 @@ export class ExecutionContext {
         }
         const useName = userDefined ? 'point.' + pointId : pointId;
         const componentPoint = ClassComponent.simple(useName, 1);
-        componentPoint.displayProp = this.getPointSymbol();
+        componentPoint.displayProp = this.getPointSymbol(useName);
         componentPoint.typeProp = ComponentTypes.net;
+        let usePointLinkComponent = null;
+        if (this.scope.currentComponent._pointLinkComponent) {
+            usePointLinkComponent = this.scope.currentComponent._pointLinkComponent;
+        }
+        else {
+            usePointLinkComponent = this.scope.currentComponent;
+        }
+        componentPoint._pointLinkComponent = usePointLinkComponent;
         this.scope.instances.set(pointId, componentPoint);
         this.toComponent(componentPoint, 1, { addSequence: true });
         return this.getCurrentPoint();
     }
-    getPointSymbol() {
-        return new SymbolDrawingCommands(() => {
-            return [
-                [PlaceHolderCommands.pin,
-                    [numeric(1), numeric(0), numeric(0),
-                        numeric(0), numeric(0)],
+    getPointSymbol(name = "") {
+        const commands = [
+            [PlaceHolderCommands.pin,
+                [numeric(1), numeric(0), numeric(0),
+                    numeric(0), numeric(0)],
+                new Map([
+                    ["display_pin_id", false]
+                ]),
+                null
+            ]
+        ];
+        if (false) {
+            commands.push(...[
+                [PlaceHolderCommands.lineColor,
+                    ["red"],
+                    new Map(), null
+                ],
+                [PlaceHolderCommands.hline,
+                    [numeric(-25), numeric(0), numeric(50)],
+                    new Map(),
+                    null
+                ],
+                [PlaceHolderCommands.vline,
+                    [numeric(0), numeric(-25), numeric(50)],
+                    new Map(),
+                    null
+                ],
+                [PlaceHolderCommands.hline,
+                    [numeric(0), numeric(0),
+                        numeric(10)],
+                    new Map([]), null
+                ],
+                [PlaceHolderCommands.text,
+                    [],
                     new Map([
-                        ["display_pin_id", false]
+                        ["content", name],
+                        ["fontSize", numeric(10)],
                     ]),
                     null
                 ]
-            ];
+            ]);
+        }
+        return new SymbolDrawingCommands(() => {
+            return commands;
         });
     }
     setProperty(nameWithProp, value) {

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

@@ -1,5 +1,5 @@
-import { ComponentTypes, NoNetText } from "./globals.mjs";
-import { NumericValue } from "./objects/ParamDefinition.mjs";
+import { NoNetText } from "./globals.js";
+import { NumericValue } from "./objects/ParamDefinition.js";
 export function generateKiCADNetList(netlist) {
     const componentsList = [];
     const nets = {};
@@ -47,11 +47,6 @@ export function generateKiCADNetList(netlist) {
             }
         }
         else {
-            if (instance.typeProp !== ComponentTypes.net &&
-                instance.typeProp !== ComponentTypes.graphic &&
-                instance.typeProp !== null) {
-                console.log('Skipping', instance.instanceName);
-            }
         }
     });
     const netItems = [];

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

@@ -1,9 +1,9 @@
 import Flatten from '@flatten-js/core';
-import { measureTextSize2 } from './sizing.mjs';
-import { defaultFont, fontDisplayScale, PortArrowSize, PortPaddingHorizontal, PortPaddingVertical } from './globals.mjs';
-import { numeric, NumericValue } from './objects/ParamDefinition.mjs';
-import { AllPinTypes, PinTypes } from './objects/PinTypes.mjs';
-import { roundValue } from './utils.mjs';
+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;
@@ -384,6 +384,7 @@ export class Geometry {
                             replaceSegments(existingSegments, j, splitCurrentSegments);
                             replaceSegments(newSegments, k, splitNewSegments);
                             j = Math.max(0, j - 1);
+                            break;
                         }
                     }
                 }

package/dist/esm/{globals.mjs → globals.js}

@@ -1,4 +1,5 @@
-import { numeric } from "./objects/ParamDefinition";
+import { numeric } from "./objects/ParamDefinition.js";
+export const TOOL_VERSION = '0.1.5';
 export const Delimiter1 = '-';
 export const DoubleDelimiter1 = `${Delimiter1}${Delimiter1}`;
 export var GlobalNames;
@@ -28,6 +29,9 @@ export var SymbolPinSide;
     SymbolPinSide["Top"] = "top";
     SymbolPinSide["Bottom"] = "bottom";
 })(SymbolPinSide || (SymbolPinSide = {}));
+export const ValidPinSides = [
+    SymbolPinSide.Left, SymbolPinSide.Right, SymbolPinSide.Top, SymbolPinSide.Bottom
+];
 export var LengthUnit;
 (function (LengthUnit) {
     LengthUnit["mm"] = "mm";
@@ -110,3 +114,4 @@ export const RenderFlags = {
     ShowLabelBoxBounds: false,
     ShowLabelOrigin: false,
 };
+export const SymbolValidatorContext = '_sym';