circuitscript 0.0.38 → 0.1.2

package/dist/esm/sizing.mjs

@@ -1,5 +1,5 @@
 import { SVG, registerWindow } from '@svgdotjs/svg.js';
-import { HorizontalAlign, VerticalAlign } from './geometry.mjs';
+import { HorizontalAlign, HorizontalAlignProp, VerticalAlign, VerticalAlignProp } from './geometry.mjs';
 import { defaultFont } from './globals.mjs';
 import { JSModuleType, detectJSModuleType } from './helpers.mjs';
 let MainCanvas = null;
@@ -38,27 +38,53 @@ export function measureTextSize2(text, fontFamily, fontSize, fontWeight = 'regul
     }
     const key = `${text}-${fontFamily}-${fontSize}-${fontWeight}-${anchor}-${vanchor}`;
     if (measureTextSizeCache[key] === undefined) {
-        let dominantBaseline = 'hanging';
+        let dominantBaseline = VerticalAlignProp.Hanging;
         switch (vanchor) {
             case VerticalAlign.Top:
-                dominantBaseline = 'hanging';
+                dominantBaseline = VerticalAlignProp.Hanging;
                 break;
             case VerticalAlign.Middle:
-                dominantBaseline = 'middle';
+                dominantBaseline = VerticalAlignProp.Central;
                 break;
             case VerticalAlign.Bottom:
-                dominantBaseline = 'text-top';
+                dominantBaseline = VerticalAlignProp.TextTop;
+                break;
+        }
+        let useAnchor = HorizontalAlignProp.Start;
+        switch (anchor) {
+            case HorizontalAlign.Left:
+                useAnchor = HorizontalAlignProp.Start;
+                break;
+            case HorizontalAlign.Middle:
+                useAnchor = HorizontalAlignProp.Middle;
+                break;
+            case HorizontalAlign.Right:
+                useAnchor = HorizontalAlignProp.End;
                 break;
         }
         fontFamily = defaultFont;
         const tmpTextElement = MainCanvas.text(text).font({
             family: fontFamily,
             size: fontSize,
-            anchor: anchor,
+            anchor: useAnchor,
             'dominant-baseline': dominantBaseline,
             weight: fontWeight,
-        }).fill('#333');
-        const textbox = tmpTextElement.bbox();
+        })
+            .attr("xml:space", "preserve")
+            .fill('#333');
+        let textbox = tmpTextElement.bbox();
+        const tmpTextBox = { ...textbox };
+        if (dominantBaseline === VerticalAlignProp.Hanging) {
+            tmpTextBox.y = textbox.cy - textbox.height;
+            tmpTextBox.y2 = tmpTextBox.y + textbox.height;
+            textbox = tmpTextBox;
+        }
+        else if (dominantBaseline === VerticalAlignProp.Central) {
+            tmpTextBox.y -= textbox.cy;
+            tmpTextBox.y2 -= textbox.cy;
+            tmpTextBox.cy = 0;
+            textbox = tmpTextBox;
+        }
         const { width, height } = textbox;
         tmpTextElement.remove();
         measureTextSizeCache[key] = {

package/dist/esm/utils.mjs

@@ -1,3 +1,5 @@
+import { Big } from 'big.js';
+import { NumericValue } from "./objects/ParamDefinition";
 export class SimpleStopwatch {
     startTime;
     constructor() {
@@ -64,5 +66,88 @@ export function getPortType(component) {
     return foundPinType;
 }
 export function roundValue(value) {
-    return +value.toFixed(7);
+    return resolveToNumericValue(new Big(value.toBigNumber().toFixed(7)));
+}
+export function throwWithContext(context, message) {
+    const startLine = context.start?.line;
+    const startColumn = context.start?.column;
+    const startString = startLine + ":" + startColumn;
+    const stopLine = context.stop?.line;
+    const stopColumn = context.stop?.column;
+    let stopString = "";
+    if (startLine === stopLine) {
+        stopString = stopColumn?.toString();
+    }
+    else {
+        stopString = stopLine + ":" + stopString;
+    }
+    throw `Parse exception at [${startString} - ${stopString}] : ${message}`;
+}
+export function combineMaps(map1, map2) {
+    const newMap = new Map(map1);
+    map2.forEach((value, key) => {
+        newMap.set(key, value);
+    });
+    return newMap;
+}
+export function getNumberExponential(value) {
+    value = value.trim();
+    switch (value) {
+        case 'G':
+            return 9;
+        case 'M':
+            return 6;
+        case 'k':
+        case 'K':
+            return 3;
+        case 'm':
+            return -3;
+        case 'u':
+            return -6;
+        case 'n':
+            return -9;
+        case 'p':
+            return -12;
+        case 'f':
+            return -15;
+        default:
+            return 0;
+    }
+}
+export function getNumberExponentialText(value) {
+    switch (value) {
+        case -15:
+            return 'f';
+        case -12:
+            return 'p';
+        case -9:
+            return 'n';
+        case -6:
+            return 'u';
+        case -3:
+            return 'm';
+        case 3:
+            return 'k';
+        case 6:
+            return 'M';
+        case 9:
+            return 'G';
+        case 0:
+        default:
+            return '';
+    }
+}
+export function resolveToNumericValue(value) {
+    if (value.toNumber() === 0) {
+        return new NumericValue(0);
+    }
+    const isNeg = value.lt(0);
+    const positiveValue = isNeg ? value.neg() : value;
+    const prefixPart = Math.floor(Math.log10(positiveValue.toNumber()) / 3);
+    let useValue = value;
+    if (prefixPart !== 0) {
+        const tmpValue1 = positiveValue.div(Math.pow(10, prefixPart * 3));
+        useValue = isNeg ? tmpValue1.neg() : tmpValue1;
+    }
+    return new NumericValue(useValue, prefixPart * 3);
 }