circuitscript 0.0.21 → 0.0.24

package/dist/cjs/parser.js

@@ -0,0 +1,299 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CircuitscriptParserErrorListener = exports.SemanticTokensVisitor = exports.parseFileWithVisitor = void 0;
+const antlr4_1 = require("antlr4");
+const CircuitScriptParser_js_1 = __importStar(require("./antlr/CircuitScriptParser.js"));
+const lexer_js_1 = require("./lexer.js");
+const utils_js_1 = require("./utils.js");
+function parseFileWithVisitor(visitor, data) {
+    const chars = new antlr4_1.CharStream(data);
+    const lexer = new lexer_js_1.MainLexer(chars);
+    const lexerTimer = new utils_js_1.SimpleStopwatch();
+    const tokens = new antlr4_1.CommonTokenStream(lexer);
+    tokens.fill();
+    const lexerTimeTaken = lexerTimer.lap();
+    const parserTimer = new utils_js_1.SimpleStopwatch();
+    const parser = new CircuitScriptParser_js_1.default(tokens);
+    parser.removeErrorListeners();
+    const errorListener = new CircuitscriptParserErrorListener();
+    parser.addErrorListener(errorListener);
+    const tree = parser.script();
+    let hasError = false;
+    try {
+        visitor.visit(tree);
+    }
+    catch (err) {
+        err.print(data);
+        hasError = true;
+    }
+    const parserTimeTaken = parserTimer.lap();
+    const semanticTokenVisitor = new SemanticTokensVisitor(lexer, data);
+    semanticTokenVisitor.visit(tree);
+    const semanticTokens = semanticTokenVisitor.semanticTokens;
+    const parsedTokens = prepareTokens(tokens.tokens, lexer, data);
+    const finalParsedTokens = [];
+    parsedTokens.forEach(token => {
+        const location = `${token.line}_${token.column}`;
+        if (semanticTokens.has(location)) {
+            finalParsedTokens.push(semanticTokens.get(location));
+        }
+        else {
+            finalParsedTokens.push(token);
+        }
+    });
+    return {
+        tree, parser,
+        hasParseError: errorListener.hasParseErrors(),
+        hasError,
+        parserTimeTaken,
+        lexerTimeTaken,
+        tokens: finalParsedTokens,
+    };
+}
+exports.parseFileWithVisitor = parseFileWithVisitor;
+class SemanticTokensVisitor extends antlr4_1.ParseTreeVisitor {
+    constructor(lexer, script) {
+        super();
+        this.parsedTokens = [];
+        this.semanticTokens = new Map();
+        this.lexer = lexer;
+        this.script = script;
+    }
+    visit(ctx) {
+        const here = this;
+        if (Array.isArray(ctx)) {
+            return ctx.map(function (child) {
+                try {
+                    here.checkContext(child);
+                    return child.accept(this);
+                }
+                catch (err) {
+                    this.handleError(child, err);
+                }
+            }, this);
+        }
+        else {
+            try {
+                this.checkContext(ctx);
+                return ctx.accept(this);
+            }
+            catch (err) {
+                this.handleError(ctx, err);
+            }
+        }
+    }
+    handleError(ctx, err) {
+        console.log('error!', err);
+    }
+    checkContext(ctx) {
+        if (ctx instanceof CircuitScriptParser_js_1.Function_def_exprContext) {
+            this.addSemanticToken(this.parseToken(ctx.ID(), ['declaration'], 'function'));
+        }
+        else if (ctx instanceof CircuitScriptParser_js_1.Create_component_exprContext
+            || ctx instanceof CircuitScriptParser_js_1.Create_graphic_exprContext) {
+            this.addSemanticToken(this.parseToken(ctx.Create(), ['defaultLibrary'], 'function'));
+        }
+        else if (ctx instanceof CircuitScriptParser_js_1.Atom_exprContext) {
+            if (ctx.ID()) {
+                if (ctx.trailer_expr_list().length > 0) {
+                    this.addSemanticToken(this.parseToken(ctx.ID(), ['declaration'], 'function'));
+                }
+                else {
+                    this.addSemanticToken(this.parseToken(ctx.ID(), ['declaration'], 'variable'));
+                }
+            }
+        }
+        else if (ctx instanceof CircuitScriptParser_js_1.Property_key_exprContext) {
+            let useToken = null;
+            if (ctx.ID()) {
+                useToken = ctx.ID();
+            }
+            else if (ctx.INTEGER_VALUE()) {
+                useToken = ctx.INTEGER_VALUE();
+            }
+            else if (ctx.STRING_VALUE()) {
+                useToken = ctx.STRING_VALUE();
+            }
+            useToken && this.addSemanticToken(this.parseToken(useToken, ['declaration'], 'property'));
+        }
+        else if (ctx instanceof CircuitScriptParser_js_1.Sub_exprContext) {
+            let useToken = null;
+            if (ctx.ID()) {
+                useToken = ctx.ID();
+            }
+            else if (ctx.Pin()) {
+                useToken = ctx.Pin();
+            }
+            useToken && this.addSemanticToken(this.parseToken(useToken, ['defaultLibrary'], 'function'));
+        }
+    }
+    addSemanticToken(parsedToken) {
+        this.semanticTokens.set(parsedToken.line + "_" + parsedToken.column, parsedToken);
+    }
+    parseToken(node, modifiers, tokenType = null) {
+        const token = node.symbol;
+        let stringValue = "";
+        let textPart = "";
+        if (this.lexer.symbolicNames[token.type] !== null && this.lexer.symbolicNames[token.type] !== undefined) {
+            stringValue = this.lexer.symbolicNames[token.type];
+            if (stringValue !== "NEWLINE") {
+                textPart = this.script.substring(token.start, token.stop + 1);
+            }
+            else {
+                textPart = token.text.length - 1;
+            }
+        }
+        else if (this.lexer.literalNames[token.type] !== null && this.lexer.literalNames[token.type] !== undefined) {
+            stringValue = this.lexer.literalNames[token.type];
+            textPart = this.script.substring(token.start, token.stop + 1);
+        }
+        else {
+            stringValue = token._text;
+        }
+        return {
+            line: token.line,
+            column: token.column,
+            length: token.stop - token.start + 1,
+            tokenType: tokenType !== null ? tokenType : stringValue,
+            tokenModifiers: modifiers,
+            textValue: textPart,
+        };
+    }
+}
+exports.SemanticTokensVisitor = SemanticTokensVisitor;
+function prepareTokens(tokens, lexer, script) {
+    const parsedTokens = [];
+    tokens.forEach(item => {
+        if (item.type !== -1) {
+            let stringValue = "";
+            let textPart = "";
+            if (lexer.symbolicNames[item.type] !== null && lexer.symbolicNames[item.type] !== undefined) {
+                stringValue = lexer.symbolicNames[item.type];
+                if (stringValue !== "NEWLINE") {
+                    textPart = script.substring(item.start, item.stop + 1);
+                }
+                else {
+                    textPart = item.text.length - 1;
+                }
+            }
+            else if (lexer.literalNames[item.type] !== null && lexer.literalNames[item.type] !== undefined) {
+                stringValue = lexer.literalNames[item.type];
+                textPart = script.substring(item.start, item.stop + 1);
+            }
+            else {
+                stringValue = item._text;
+            }
+            if (textPart !== 0 && textPart !== '') {
+                parsedTokens.push({
+                    line: item.line,
+                    column: item.column,
+                    length: item.stop - item.start + 1,
+                    tokenType: resolveTokenType(stringValue),
+                    tokenModifiers: resolveTokenModifiers(stringValue),
+                    textValue: textPart,
+                });
+            }
+        }
+    });
+    return parsedTokens;
+}
+const languageKeywords = [
+    'break', 'branch', 'create', 'component',
+    'graphic', 'wire', 'pin', 'add', 'at', 'to',
+    'point', 'join', 'parallel', 'return', 'def', 'import',
+    'true', 'false', 'nc', 'frame',
+];
+const operatorKeywords = [
+    'at', 'to', 'wire', 'add', 'frame', 'join', 'parallel', 'point'
+];
+function resolveTokenType(tokenType) {
+    if (operatorKeywords.indexOf(tokenType.toLowerCase()) !== -1) {
+        return 'graphKeyword';
+    }
+    else if (languageKeywords.indexOf(tokenType.toLowerCase()) !== -1) {
+        return 'keyword';
+    }
+    else {
+        switch (tokenType) {
+            case 'INTEGER_VALUE':
+            case 'NUMERIC_VALUE':
+            case 'DECIMAL_VALUE':
+            case 'PERCENTAGE_VALUE':
+                return 'number';
+            case 'STRING_VALUE':
+                return 'string';
+            case 'ID':
+                return 'variable';
+            case 'Define':
+                return 'keyword';
+            case 'COMMENT':
+                return 'comment';
+        }
+        return null;
+    }
+}
+function resolveTokenModifiers(tokenType) {
+    return [];
+}
+function dumpTokens(tokens, lexer, scriptData) {
+    tokens.forEach(item => {
+        if (item.type !== -1) {
+            let stringValue = "";
+            let textPart = "";
+            if (lexer.symbolicNames[item.type] !== null && lexer.symbolicNames[item.type] !== undefined) {
+                stringValue = lexer.symbolicNames[item.type];
+                if (stringValue !== "NEWLINE") {
+                    textPart = scriptData.substring(item.start, item.stop + 1);
+                }
+                else {
+                    textPart = item.text.length - 1;
+                }
+            }
+            else if (lexer.literalNames[item.type] !== null && lexer.literalNames[item.type] !== undefined) {
+                stringValue = lexer.literalNames[item.type];
+                textPart = scriptData.substring(item.start, item.stop + 1);
+            }
+            else {
+                stringValue = item._text;
+            }
+            console.log('line', item.line + ':' + item.column, `\t${stringValue} (${item.type})`.padEnd(30), textPart);
+        }
+    });
+}
+class CircuitscriptParserErrorListener extends antlr4_1.ErrorListener {
+    constructor() {
+        super(...arguments);
+        this.syntaxErrorCounter = 0;
+    }
+    syntaxError(recognizer, offendingSymbol, line, column, msg, e) {
+        console.log("Syntax error at line", line, ':', column, ' - ', msg);
+        this.syntaxErrorCounter++;
+    }
+    hasParseErrors() {
+        return (this.syntaxErrorCounter > 0);
+    }
+}
+exports.CircuitscriptParserErrorListener = CircuitscriptParserErrorListener;

package/dist/cjs/regenerate-tests.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const helpers_js_1 = require("./helpers.js");
+const mainDir = './__tests__/renderData/';
+const cstFiles = [];
+const files = fs_1.default.readdirSync(mainDir);
+files.forEach(file => {
+    if (file.endsWith('.cst')) {
+        cstFiles.push(file);
+    }
+});
+const useCurrentDir = './examples/';
+cstFiles.forEach(file => {
+    const inputPath = mainDir + file;
+    const scriptData = fs_1.default.readFileSync(inputPath, { encoding: 'utf-8' });
+    const outputPath = inputPath + '.svg';
+    (0, helpers_js_1.renderScript)(scriptData, outputPath, { currentDirectory: useCurrentDir });
+    console.log('generated ', outputPath);
+});

package/dist/cjs/render.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSVG2 = void 0;
+const svg_js_1 = require("@svgdotjs/svg.js");
+const layout_js_1 = require("./layout.js");
+const sizing_js_1 = require("./sizing.js");
+const globals_js_1 = require("./globals.js");
+const ParamDefinition_js_1 = require("./objects/ParamDefinition.js");
+const utils_js_1 = require("./utils.js");
+function generateSVG2(graph) {
+    const window = (0, sizing_js_1.getCreateSVGWindow)()();
+    const document = window.document;
+    (0, svg_js_1.registerWindow)(window, document);
+    const canvas = (0, svg_js_1.SVG)(document.documentElement);
+    (0, sizing_js_1.applyFontsToSVG)(canvas);
+    generateSVGChild(canvas, graph.components, graph.wires, graph.junctions, graph.mergedWires, graph.frameObjects, graph.textObjects);
+    const { x, y, width, height } = canvas.bbox();
+    const margin = 5;
+    const widthAndMargin = width + margin * 2;
+    const heightAndMargin = height + margin * 2;
+    const scale = 1;
+    canvas.size(widthAndMargin * scale, heightAndMargin * scale);
+    canvas.viewbox(x - margin, y - margin, widthAndMargin, heightAndMargin);
+    return canvas.svg();
+}
+exports.generateSVG2 = generateSVG2;
+function generateSVGChild(canvas, components, wires, junctions, mergedWires, frameObjects, textObjects) {
+    const displayWireId = false;
+    const bounds = (0, layout_js_1.getBounds)(components, wires, junctions, frameObjects);
+    drawGrid(canvas.group().translate(0, 0), {
+        x: bounds.xmin,
+        y: bounds.ymin,
+        x2: bounds.xmax,
+        y2: bounds.ymax
+    });
+    components.forEach(item => {
+        const { x, y, width, height } = item;
+        const symbolGroup = canvas.group();
+        symbolGroup.translate(x, y);
+        const { symbol = null } = item;
+        if (symbol !== null && symbol) {
+            const extra = {};
+            if (item.component.parameters.has('__is_net')) {
+                extra.net_name = item.component.parameters.get(globals_js_1.ParamKeys.net_name);
+            }
+            else if (item.component.parameters.has('value')) {
+                let tmpValue = item.component.parameters.get('value');
+                if (tmpValue instanceof ParamDefinition_js_1.NumericValue) {
+                    tmpValue = tmpValue.value;
+                }
+                extra.value = tmpValue;
+            }
+            extra.instance_name = item.component.instanceName;
+            if (item.component.parameters.has('place')) {
+                extra.place = item.component.parameters.get('place');
+            }
+            else {
+                extra.place = true;
+            }
+            symbol.draw(symbolGroup, extra);
+        }
+        else {
+            symbolGroup.rect(width, height)
+                .fill(globals_js_1.bodyColor)
+                .stroke({ width: 1, color: '#333' });
+        }
+    });
+    if (displayWireId) {
+        const wiresGroup = canvas.group().translate(0, 0);
+        wires.forEach(wire => {
+            wiresGroup.text(wire.id.toString())
+                .font({
+                family: 'Inter',
+                size: 10,
+            })
+                .translate(wire.x + 5, wire.y + 5);
+        });
+    }
+    const mergedWireGroup = canvas.group();
+    mergedWires.forEach(tmpItem => {
+        const { segments, intersectPoints } = tmpItem;
+        segments.forEach(segment => {
+            const pt1 = segment[0];
+            const pt2 = segment[1];
+            mergedWireGroup.line([pt1, pt2])
+                .stroke({ width: 1, color: globals_js_1.wireColor, linecap: 'square' })
+                .fill('none');
+        });
+        intersectPoints.forEach(point => {
+            const [x, y, count] = point;
+            mergedWireGroup.circle(globals_js_1.junctionSize)
+                .translate(x - globals_js_1.junctionSize / 2, y - globals_js_1.junctionSize / 2)
+                .fill(globals_js_1.junctionColor)
+                .stroke('none');
+        });
+    });
+    const frameGroup = canvas.group();
+    const showElementFrames = false;
+    frameObjects.forEach(item => {
+        const { bounds, borderWidth } = item;
+        if (borderWidth > 0) {
+            const { width, height } = (0, utils_js_1.getBoundsSize)(bounds);
+            let strokeColor = '#111';
+            if (item.type === layout_js_1.RenderFrameType.Container) {
+                strokeColor = '#111';
+            }
+            else if (item.type === layout_js_1.RenderFrameType.Elements) {
+                strokeColor = '#aaa';
+                if (!showElementFrames) {
+                    return;
+                }
+            }
+            const tmpRect = frameGroup.rect(width, height)
+                .fill('none')
+                .stroke({ width: borderWidth, color: strokeColor });
+            tmpRect.translate(item.x, item.y);
+        }
+    });
+    textObjects.forEach(item => {
+        const { x, y, symbol } = item;
+        const innerGroup = canvas.group();
+        innerGroup.translate(x, y);
+        symbol.draw(innerGroup);
+    });
+    const drawOrigin = false;
+    drawOrigin && canvas.group().translate(0, 0)
+        .circle(5)
+        .translate(-5 / 2, -5 / 2)
+        .stroke('none').fill('red');
+}
+function drawGrid(group, canvasSize) {
+    const gridSize = 20;
+    const { x, y, x2, y2 } = canvasSize;
+    const gridStartX = (Math.floor(x / gridSize) - 1) * gridSize;
+    const gridStartY = (Math.floor(y / gridSize) - 1) * gridSize;
+    const gridEndX = (Math.ceil(x2 / gridSize) + 1) * gridSize;
+    const gridEndY = (Math.ceil(y2 / gridSize) + 1) * gridSize;
+    const numCols = Math.ceil((gridEndX - gridStartX) / gridSize);
+    const lines = [];
+    for (let i = 0; i <= numCols; i++) {
+        const startX = gridStartX + i * gridSize;
+        const startY = gridStartY - 0.5;
+        const endY = gridEndY;
+        lines.push(`M ${startX} ${startY} L ${startX} ${endY}`);
+    }
+    group.path(lines.join(" "))
+        .fill('none')
+        .attr({
+        'stroke-dasharray': '1,' + (gridSize - 1),
+    })
+        .stroke({
+        width: 1,
+        color: '#aaa'
+    });
+}

package/{src/server.ts → dist/cjs/server.js}

@@ -1,16 +1,17 @@
-import express from 'express';
-import ws from 'ws';
-import fs from 'fs';
-
-const app = express()
-
-const wsServer = new ws.Server({ noServer: true });
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = __importDefault(require("express"));
+const ws_1 = __importDefault(require("ws"));
+const fs_1 = __importDefault(require("fs"));
+const app = (0, express_1.default)();
+const wsServer = new ws_1.default.Server({ noServer: true });
 wsServer.on('connection', socket => {
-
     const fileName = 'output.svg';
-
-    function emitFile(): void {
-        fs.readFile(fileName, 'utf8', (err, data) => {
+    function emitFile() {
+        fs_1.default.readFile(fileName, 'utf8', (err, data) => {
             if (err) {
                 throw err;
             }
@@ -18,33 +19,26 @@ wsServer.on('connection', socket => {
             socket.send(data);
         });
     }
-
     let emitTimeout = null;
-    fs.watch(fileName, (event, targetFile) => {
+    fs_1.default.watch(fileName, (event, targetFile) => {
         if (event === 'change') {
             console.log((new Date()).toISOString(), 'file changed!');
-
-            // emit the change
             clearInterval(emitTimeout);
             emitTimeout = setTimeout(() => {
                 emitFile();
             }, 200);
         }
     });
-
     socket.on('message', message => {
         console.log(message.toString());
         emitFile();
     });
 });
-
-app.use(express.static('./'))
-
+app.use(express_1.default.static('./'));
 const server = app.listen(3000);
 server.on('upgrade', (request, socket, head) => {
     wsServer.handleUpgrade(request, socket, head, socket => {
         wsServer.emit('connection', socket, request);
     });
 });
-
-console.log('server started at port 3000');
+console.log('server started at port 3000');

package/dist/cjs/sizing.js

@@ -0,0 +1,105 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.measureTextSize2 = exports.measureTextSize = exports.applyFontsToSVG = exports.getCreateSVGWindow = exports.prepareSVGEnvironment = void 0;
+const svg_js_1 = require("@svgdotjs/svg.js");
+const geometry_js_1 = require("./geometry.js");
+const globals_js_1 = require("./globals.js");
+const helpers_js_1 = require("./helpers.js");
+let MainCanvas = null;
+const supportedFonts = {};
+let globalCreateSVGWindow;
+async function prepareSVGEnvironment(fontsPath) {
+    const moduleType = (0, helpers_js_1.detectJSModuleType)();
+    if (moduleType === helpers_js_1.JSModuleType.CommonJs) {
+        const { config, createSVGWindow } = await Promise.resolve().then(() => __importStar(require('svgdom')));
+        globalCreateSVGWindow = createSVGWindow;
+        if (fontsPath !== null) {
+            await config.setFontDir(fontsPath)
+                .setFontFamilyMappings(supportedFonts)
+                .preloadFonts();
+        }
+    }
+}
+exports.prepareSVGEnvironment = prepareSVGEnvironment;
+function getCreateSVGWindow() {
+    if (globalCreateSVGWindow === undefined) {
+        throw "SVG environment is not set up yet";
+    }
+    return globalCreateSVGWindow;
+}
+exports.getCreateSVGWindow = getCreateSVGWindow;
+function applyFontsToSVG(canvas) {
+}
+exports.applyFontsToSVG = applyFontsToSVG;
+async function measureTextSize(text, fontFamily, fontSize) {
+    return measureTextSize2(text, fontFamily, fontSize);
+}
+exports.measureTextSize = measureTextSize;
+const measureTextSizeCache = {};
+const measureTextSizeCacheHits = {};
+function measureTextSize2(text, fontFamily, fontSize, fontWeight = 'regular', anchor = geometry_js_1.HorizontalAlign.Left, vanchor = geometry_js_1.VerticalAlign.Bottom) {
+    if (MainCanvas === null) {
+        const window = getCreateSVGWindow()();
+        const { document } = window;
+        (0, svg_js_1.registerWindow)(window, document);
+        MainCanvas = (0, svg_js_1.SVG)(document.documentElement);
+    }
+    const key = `${text}-${fontFamily}-${fontSize}-${fontWeight}-${anchor}-${vanchor}`;
+    if (measureTextSizeCache[key] === undefined) {
+        let dominantBaseline = 'hanging';
+        switch (vanchor) {
+            case geometry_js_1.VerticalAlign.Top:
+                dominantBaseline = 'hanging';
+                break;
+            case geometry_js_1.VerticalAlign.Middle:
+                dominantBaseline = 'middle';
+                break;
+            case geometry_js_1.VerticalAlign.Bottom:
+                dominantBaseline = 'text-top';
+                break;
+        }
+        fontFamily = globals_js_1.defaultFont;
+        const tmpTextElement = MainCanvas.text(text).font({
+            family: fontFamily,
+            size: fontSize,
+            anchor: anchor,
+            'dominant-baseline': dominantBaseline,
+            weight: fontWeight,
+        }).fill('#333');
+        const textbox = tmpTextElement.bbox();
+        const { width, height } = textbox;
+        tmpTextElement.remove();
+        measureTextSizeCache[key] = {
+            width: Math.round(width * 100) / 100,
+            height: Math.round(height * 100) / 100,
+            box: textbox,
+        };
+        measureTextSizeCacheHits[key] = 0;
+    }
+    measureTextSizeCacheHits[key]++;
+    return measureTextSizeCache[key];
+}
+exports.measureTextSize2 = measureTextSize2;