circuitscript 0.0.22 → 0.0.25

package/dist/cjs/draw_symbols.js

@@ -0,0 +1,819 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SymbolDrawingCommands = exports.SymbolDrawing = exports.SymbolCustom = exports.PlaceHolderCommands = exports.SymbolPlaceholder = exports.SymbolText = exports.SymbolPointHidden = exports.SymbolFactory = exports.SymbolGraphic = void 0;
+const globals_js_1 = require("./globals.js");
+const geometry_js_1 = require("./geometry.js");
+const defaultSymbolLineWidth = 2;
+class SymbolGraphic {
+    constructor() {
+        this.drawPortsName = true;
+        this.displayBounds = true;
+        this._angle = 0;
+        this._flipX = 0;
+        this._flipY = 0;
+        this.labelTexts = new Map();
+    }
+    get angle() {
+        return (this._angle % 360);
+    }
+    set angle(value) {
+        this._angle = value;
+    }
+    get flipX() {
+        return this._flipX;
+    }
+    set flipX(value) {
+        this._flipX = value;
+    }
+    get flipY() {
+        return this._flipY;
+    }
+    set flipY(value) {
+        this._flipY = value;
+    }
+    refreshDrawing(calculateSize = true) {
+        this.generateDrawing();
+        calculateSize && this.calculateSize();
+    }
+    calculateSize() {
+        const { width, height } = this.drawing.getBoundingBox();
+        this.width = width;
+        this.height = height;
+    }
+    size() {
+        return {
+            width: this.width,
+            height: this.height
+        };
+    }
+    draw(group, extra) {
+        const innerGroup = group.group();
+        this.drawBody(innerGroup);
+        this.drawPins(innerGroup);
+        this.drawLabels(innerGroup);
+        this.drawPlaceRemove(innerGroup, extra);
+    }
+    drawPlaceRemove(group, extra) {
+        if (extra && extra.place === false) {
+            const { start, end } = this.drawing.getBoundingBox(true);
+            const path = geometry_js_1.Geometry.roundPathValues([
+                "M", start[0], start[1], "L", end[0], end[1],
+                "M", end[0], start[1], "L", start[0], end[1]
+            ]);
+            group.path(path)
+                .stroke({
+                width: defaultSymbolLineWidth,
+                color: 'red'
+            });
+        }
+    }
+    pinPosition(id) {
+        const pin = this.drawing.getPinPosition(id);
+        const [x, y] = pin.start;
+        const useX = Math.round(x * 10000) / 10000;
+        const useY = Math.round(y * 10000 / 10000);
+        return {
+            x: useX,
+            y: useY,
+            angle: pin.angle,
+        };
+    }
+    drawBounds(group) {
+        const bbox = this.drawing.getBoundingBox();
+        group.circle(3)
+            .translate(-3 / 2, -3 / 2)
+            .fill('red')
+            .stroke('none');
+        group.rect(bbox.width, bbox.height)
+            .translate(bbox.start[0], bbox.start[1])
+            .fill('none')
+            .stroke({
+            width: 1,
+            color: '#ccc',
+        });
+    }
+    drawBody(group) {
+        const paths = this.drawing.getPaths();
+        paths.forEach(pathInfo => {
+            const { path, lineColor, fillColor, lineWidth } = pathInfo;
+            group.path(path)
+                .stroke({
+                width: lineWidth,
+                color: lineColor,
+            })
+                .fill(fillColor);
+        });
+    }
+    drawPins(group) {
+        group.path(this.drawing.getPinsPath())
+            .stroke({
+            width: defaultSymbolLineWidth,
+            color: '#333',
+        });
+    }
+    drawLabels(group) {
+        const labels = this.drawing.getLabels();
+        labels.forEach(label => {
+            const tmpLabel = label;
+            const { fontSize = 10, anchor = geometry_js_1.HorizontalAlign.Left, vanchor = geometry_js_1.VerticalAlign.Bottom, fontWeight = 'regular', angle: labelAngle = 0, } = tmpLabel.style ?? {};
+            let anchorStyle = 'start';
+            let dominantBaseline = 'auto';
+            let useAnchor = anchor;
+            let useDominantBaseline = vanchor;
+            const isRotation180 = Math.abs(this.angle) === 180;
+            if (isRotation180) {
+                useAnchor = this.flipTextAnchor(anchor);
+                useDominantBaseline = this.flipDominantBaseline(vanchor);
+            }
+            switch (useAnchor) {
+                case geometry_js_1.HorizontalAlign.Left:
+                    anchorStyle = (this.flipX === 0) ? 'start' : 'end';
+                    break;
+                case geometry_js_1.HorizontalAlign.Middle:
+                    anchorStyle = 'middle';
+                    break;
+                case geometry_js_1.HorizontalAlign.Right:
+                    anchorStyle = (this.flipX === 0) ? 'end' : 'start';
+                    break;
+            }
+            switch (useDominantBaseline) {
+                case geometry_js_1.VerticalAlign.Top:
+                    dominantBaseline = (this.flipY === 0) ? 'hanging' : 'text-top';
+                    break;
+                case geometry_js_1.VerticalAlign.Middle:
+                    dominantBaseline = 'middle';
+                    break;
+                case geometry_js_1.VerticalAlign.Bottom:
+                    dominantBaseline = (this.flipY === 0) ? 'text-top' : 'hanging';
+                    break;
+            }
+            const position = tmpLabel.getLabelPosition();
+            if (this.flipX !== 0) {
+                position[0] *= -1;
+            }
+            if (this.flipY !== 0) {
+                position[1] *= -1;
+            }
+            const useFont = globals_js_1.defaultFont;
+            const textContainer = group.group();
+            const text = textContainer.text(tmpLabel.text)
+                .fill('#333')
+                .font({
+                family: useFont,
+                size: fontSize,
+                anchor: anchorStyle,
+                'dominant-baseline': dominantBaseline,
+                weight: fontWeight,
+            });
+            let translateX, translateY;
+            let useRotateAngle = 0;
+            if (isRotation180) {
+                translateX = -position[0];
+                translateY = -position[1];
+                useRotateAngle = 0;
+            }
+            else {
+                translateX = position[0];
+                translateY = position[1];
+                useRotateAngle = this.angle;
+            }
+            translateX = this.roundValues(translateX);
+            translateY = this.roundValues(translateY);
+            text.rotate(labelAngle);
+            textContainer.translate(translateX, translateY)
+                .rotate(useRotateAngle, -translateX, -translateY);
+            const { a, b, c, d, e, f } = textContainer.matrix();
+            const newMatrix = {
+                a: this.roundValues(a),
+                b: this.roundValues(b),
+                c: this.roundValues(c),
+                d: this.roundValues(d),
+                e: this.roundValues(e),
+                f: this.roundValues(f),
+            };
+            textContainer.transform(newMatrix);
+        });
+    }
+    roundValues(value) {
+        return +value.toFixed(7);
+    }
+    flipTextAnchor(value) {
+        if (value === geometry_js_1.HorizontalAlign.Left) {
+            return geometry_js_1.HorizontalAlign.Right;
+        }
+        else if (value === geometry_js_1.HorizontalAlign.Right) {
+            return geometry_js_1.HorizontalAlign.Left;
+        }
+        else {
+            return geometry_js_1.HorizontalAlign.Middle;
+        }
+    }
+    flipDominantBaseline(value) {
+        if (value === geometry_js_1.VerticalAlign.Top) {
+            return geometry_js_1.VerticalAlign.Bottom;
+        }
+        else if (value === geometry_js_1.VerticalAlign.Bottom) {
+            return geometry_js_1.VerticalAlign.Top;
+        }
+        else {
+            return geometry_js_1.VerticalAlign.Middle;
+        }
+    }
+    setLabelValue(labelId, labelValue) {
+        this.labelTexts.set(labelId, labelValue);
+    }
+    getLabelValue(labelId) {
+        if (this.labelTexts.has(labelId)) {
+            return this.labelTexts.get(labelId);
+        }
+        return undefined;
+    }
+}
+exports.SymbolGraphic = SymbolGraphic;
+function SymbolFactory(name) {
+    switch (name) {
+        case 'point':
+            return new SymbolPointHidden();
+    }
+    return null;
+}
+exports.SymbolFactory = SymbolFactory;
+class SymbolPointHidden extends SymbolGraphic {
+    generateDrawing() {
+        const drawing = new SymbolDrawing();
+        drawing.addPin(1, 0, 0, 0, 0);
+        this.drawing = drawing;
+    }
+}
+exports.SymbolPointHidden = SymbolPointHidden;
+class SymbolText extends SymbolGraphic {
+    constructor(text) {
+        super();
+        this.fontSize = 10;
+        this.fontWeight = 'regular';
+        this.text = text;
+    }
+    generateDrawing() {
+        const drawing = new SymbolDrawing();
+        drawing.addLabel(0, 0, this.text, {
+            fontSize: this.fontSize,
+            anchor: geometry_js_1.HorizontalAlign.Middle,
+            fontWeight: this.fontWeight,
+        });
+        this.drawing = drawing;
+    }
+}
+exports.SymbolText = SymbolText;
+class SymbolPlaceholder extends SymbolGraphic {
+    generateDrawing() {
+        const drawing = this.drawing;
+        drawing.log("=== start generate drawing ===");
+        drawing.clear();
+        drawing.angle = this._angle;
+        drawing.flipX = this._flipX;
+        drawing.flipY = this._flipY;
+        const commands = drawing.getCommands();
+        drawing.log('id: ', drawing.id, 'angle: ', this._angle, "commands:", commands.length);
+        commands.forEach(([commandName, positionParams, keywordParams]) => {
+            switch (commandName) {
+                case PlaceHolderCommands.rect:
+                    drawing.log('add rect', ...positionParams);
+                    drawing.addRect(...positionParams);
+                    break;
+                case PlaceHolderCommands.hline:
+                    drawing.log('add hline', ...positionParams);
+                    drawing.addHLine(...positionParams);
+                    break;
+                case PlaceHolderCommands.vline:
+                    drawing.log('add vline', ...positionParams);
+                    drawing.addVLine(...positionParams);
+                    break;
+                case PlaceHolderCommands.line:
+                    drawing.log('add line', ...positionParams);
+                    drawing.addLine(...positionParams);
+                    break;
+                case PlaceHolderCommands.path:
+                    drawing.addPath(...positionParams);
+                    break;
+                case PlaceHolderCommands.lineWidth:
+                    drawing.addSetLineWidth(...positionParams);
+                    break;
+                case PlaceHolderCommands.fill:
+                    drawing.addSetFillColor(...positionParams);
+                    break;
+                case PlaceHolderCommands.lineColor:
+                    drawing.addSetLineColor(...positionParams);
+                    break;
+                case PlaceHolderCommands.arc:
+                    drawing.addArc(...positionParams);
+                    break;
+                case PlaceHolderCommands.circle:
+                    drawing.addArc(...positionParams, 0, 360);
+                    break;
+                case PlaceHolderCommands.triangle:
+                    drawing.addTriangle(...positionParams);
+                    break;
+                case PlaceHolderCommands.pin:
+                case PlaceHolderCommands.hpin:
+                case PlaceHolderCommands.vpin:
+                    {
+                        this.drawPinParams(drawing, commandName, keywordParams, positionParams);
+                        break;
+                    }
+                case PlaceHolderCommands.label: {
+                    const keywords = ['fontSize', 'anchor', 'vanchor', 'angle'];
+                    const style = {};
+                    keywords.forEach(item => {
+                        if (keywordParams.has(item)) {
+                            style[item] = keywordParams.get(item);
+                        }
+                    });
+                    positionParams = [...positionParams];
+                    positionParams.push(style);
+                    const labelId = positionParams[0];
+                    const tmpPositionParams = [...positionParams];
+                    const tmpLabelValue = this.getLabelValue(labelId);
+                    if (tmpLabelValue !== undefined) {
+                        tmpPositionParams[3] = tmpLabelValue;
+                    }
+                    drawing.log('add label', JSON.stringify(tmpPositionParams));
+                    drawing.addLabelId(...tmpPositionParams);
+                    break;
+                }
+            }
+        });
+        drawing.log("=== end generate drawing ===");
+    }
+    drawPinParams(drawing, commandName, keywordParams, positionParams) {
+        drawing.log('add pin', ...positionParams);
+        const keywordDisplayPinId = 'display_pin_id';
+        let displayPinId = true;
+        if (keywordParams.has(keywordDisplayPinId)
+            && keywordParams.get(keywordDisplayPinId) === 0) {
+            displayPinId = false;
+        }
+        let pinNameParam = null;
+        if (typeof positionParams[1] === 'string') {
+            pinNameParam = positionParams[1];
+            positionParams = [positionParams[0], ...positionParams.slice(2)];
+        }
+        const startX = positionParams[1];
+        const startY = positionParams[2];
+        if (commandName === PlaceHolderCommands.vpin) {
+            const magnitude = positionParams[3];
+            positionParams = [
+                positionParams[0],
+                startX,
+                startY,
+                startX,
+                startY + magnitude
+            ];
+        }
+        else if (commandName === PlaceHolderCommands.hpin) {
+            const magnitude = positionParams[3];
+            positionParams = [
+                positionParams[0],
+                startX,
+                startY,
+                startX + magnitude,
+                startY
+            ];
+        }
+        drawing.addPin(...positionParams);
+        const lastAddedPin = this.drawing.pins[this.drawing.pins.length - 1];
+        const [pinId, , angle] = lastAddedPin;
+        const [, , , endX, endY] = positionParams;
+        let pinNameAlignment = geometry_js_1.HorizontalAlign.Left;
+        let pinNameOffsetX = 4;
+        let pinIdOffsetX = 0;
+        let pinIdAlignment = geometry_js_1.HorizontalAlign.Left;
+        let pinIdVAlignment = geometry_js_1.VerticalAlign.Bottom;
+        let pinIdOffsetY = -2;
+        switch (angle) {
+            case 0:
+                pinNameAlignment = geometry_js_1.HorizontalAlign.Left;
+                pinNameOffsetX = 4;
+                pinIdAlignment = geometry_js_1.HorizontalAlign.Right;
+                pinIdOffsetX = -2;
+                break;
+            case 90:
+            case 180:
+                pinNameAlignment = geometry_js_1.HorizontalAlign.Right;
+                pinNameOffsetX = -4;
+                pinIdAlignment = geometry_js_1.HorizontalAlign.Left;
+                pinIdOffsetX = 2;
+                break;
+            case 270:
+                pinNameAlignment = geometry_js_1.HorizontalAlign.Left;
+                pinNameOffsetX = 4;
+                pinIdAlignment = geometry_js_1.HorizontalAlign.Left;
+                pinIdOffsetX = 2;
+                pinIdOffsetY = 2;
+                pinIdVAlignment = geometry_js_1.VerticalAlign.Top;
+                break;
+        }
+        if (angle === 0 || angle === 90 || angle === 180 || angle === 270) {
+            const usePinName = pinNameParam ?? "";
+            usePinName !== "" && drawing.addLabel(endX + pinNameOffsetX, endY, usePinName, {
+                fontSize: 10,
+                anchor: pinNameAlignment,
+                vanchor: geometry_js_1.VerticalAlign.Middle,
+            });
+            displayPinId && drawing.addLabel(endX + pinIdOffsetX, endY + pinIdOffsetY, pinId.toString(), {
+                fontSize: 8,
+                anchor: pinIdAlignment,
+                vanchor: pinIdVAlignment,
+            });
+        }
+    }
+    constructor(drawing) {
+        super();
+        this.drawing = drawing;
+    }
+}
+exports.SymbolPlaceholder = SymbolPlaceholder;
+var PlaceHolderCommands;
+(function (PlaceHolderCommands) {
+    PlaceHolderCommands["arc"] = "arc";
+    PlaceHolderCommands["circle"] = "circle";
+    PlaceHolderCommands["rect"] = "rect";
+    PlaceHolderCommands["triangle"] = "triangle";
+    PlaceHolderCommands["pin"] = "pin";
+    PlaceHolderCommands["hpin"] = "hpin";
+    PlaceHolderCommands["vpin"] = "vpin";
+    PlaceHolderCommands["hline"] = "hline";
+    PlaceHolderCommands["vline"] = "vline";
+    PlaceHolderCommands["line"] = "line";
+    PlaceHolderCommands["label"] = "label";
+    PlaceHolderCommands["path"] = "path";
+    PlaceHolderCommands["lineWidth"] = "lineWidth";
+    PlaceHolderCommands["fill"] = "fill";
+    PlaceHolderCommands["lineColor"] = "lineColor";
+})(PlaceHolderCommands || (exports.PlaceHolderCommands = PlaceHolderCommands = {}));
+class SymbolCustom extends SymbolGraphic {
+    constructor(pinDefinition) {
+        super();
+        this.pinDefinition = [];
+        this.bodyWidth = 100;
+        this.pinLength = 20;
+        this.width = 100;
+        this.height = 100;
+        this.pinSpacing = 20;
+        this.pinTextPadding = 5;
+        this.pins = [];
+        this.pinDefinition = pinDefinition;
+    }
+    generateDrawing() {
+        const leftPins = this.pinDefinition.filter(item => {
+            return item.side === globals_js_1.SymbolPinSide.Left;
+        });
+        const rightPins = this.pinDefinition.filter(item => {
+            return item.side === globals_js_1.SymbolPinSide.Right;
+        });
+        const maxLeftPins = Math.max(...leftPins.map(item => item.position)) + 1;
+        const maxRightPins = Math.max(...rightPins.map(item => item.position)) + 1;
+        const drawing = new SymbolDrawing();
+        drawing.angle = this._angle;
+        drawing.flipX = this._flipX;
+        drawing.flipY = this._flipY;
+        const bodyWidth = this.bodyWidth;
+        const bodyHeight = (1 + Math.max(maxLeftPins, maxRightPins)) * this.pinSpacing;
+        drawing.addRect(0, 0, bodyWidth, bodyHeight);
+        const leftPinStart = -bodyWidth / 2;
+        const rightPinStart = bodyWidth / 2;
+        const pinStartY = -bodyHeight / 2;
+        leftPins.forEach(pin => {
+            const position = pin.position;
+            const pinY = pinStartY + (position + 1) * this.pinSpacing;
+            drawing.addPin(pin.pinId, leftPinStart - this.pinLength, pinY, leftPinStart, pinY);
+            drawing.addLabel(leftPinStart + 4, pinY, pin.text, {
+                fontSize: 10,
+                anchor: geometry_js_1.HorizontalAlign.Left,
+                vanchor: geometry_js_1.VerticalAlign.Middle,
+            });
+            drawing.addLabel(leftPinStart - 2, pinY - 2, pin.pinId.toString(), {
+                fontSize: 8,
+                anchor: geometry_js_1.HorizontalAlign.Right,
+                vanchor: geometry_js_1.VerticalAlign.Bottom,
+            });
+        });
+        rightPins.forEach(pin => {
+            const position = pin.position;
+            const pinY = pinStartY + (position + 1) * this.pinSpacing;
+            drawing.addPin(pin.pinId, rightPinStart + this.pinLength, pinY, rightPinStart, pinY);
+            drawing.addLabel(rightPinStart - 4, pinY, pin.text, {
+                fontSize: 10,
+                anchor: geometry_js_1.HorizontalAlign.Right,
+                vanchor: geometry_js_1.VerticalAlign.Middle,
+            });
+            drawing.addLabel(rightPinStart + 2, pinY - 2, pin.pinId.toString(), {
+                fontSize: 8,
+                anchor: geometry_js_1.HorizontalAlign.Left,
+                vanchor: geometry_js_1.VerticalAlign.Bottom,
+            });
+        });
+        const instanceName = this.getLabelValue("refdes");
+        instanceName && drawing.addLabel(-bodyWidth / 2, -bodyHeight / 2 - 4, instanceName, {
+            fontSize: 10,
+            anchor: geometry_js_1.HorizontalAlign.Left,
+        });
+        const acceptedMPNKeys = ['MPN', 'mpn', 'manufacturer_pn'];
+        acceptedMPNKeys.some(key => {
+            const labelValue = this.getLabelValue(key);
+            if (labelValue !== undefined) {
+                drawing.addLabel(-bodyWidth / 2, bodyHeight / 2 + 4, labelValue, {
+                    fontSize: 10,
+                    anchor: geometry_js_1.HorizontalAlign.Left,
+                    vanchor: geometry_js_1.VerticalAlign.Top,
+                });
+            }
+        });
+        this.drawing = drawing;
+        this._cacheLeftPins = leftPins;
+        this._cacheRightPins = rightPins;
+    }
+    calculateSize() {
+        this.width = this.bodyWidth + 2 * this.pinLength;
+        this.height = (1 + Math.max(this._cacheLeftPins.length, this._cacheRightPins.length)) * this.pinSpacing;
+    }
+}
+exports.SymbolCustom = SymbolCustom;
+class SymbolDrawing {
+    constructor() {
+        this.items = [];
+        this.pins = [];
+        this.angle = 0;
+        this.flipX = 0;
+        this.flipY = 0;
+        this.mainOrigin = [0, 0];
+        this.logger = null;
+    }
+    clear() {
+        this.items = [];
+        this.pins = [];
+    }
+    log(...params) {
+        this.logger && this.logger.add(params.join(' '));
+    }
+    addLine(startX, startY, endX, endY) {
+        this.items.push(geometry_js_1.Geometry.segment([startX, startY], [endX, endY]));
+        return this;
+    }
+    addPin(pinId, startX, startY, endX, endY) {
+        let angle = 0;
+        if (startX === endX) {
+            if (startY > endY) {
+                angle = 270;
+            }
+            else if (startY < endY) {
+                angle = 90;
+            }
+        }
+        else {
+            if (startX < endX) {
+                angle = 0;
+            }
+            else if (startX > endX) {
+                angle = 180;
+            }
+        }
+        this.pins.push([
+            pinId,
+            geometry_js_1.Geometry.segment([startX, startY], [endX, endY]),
+            angle
+        ]);
+        return this;
+    }
+    addVLine(startX, startY, value) {
+        this.items.push(geometry_js_1.Geometry.segment([startX, startY], [startX, startY + value]));
+        return this;
+    }
+    addHLine(startX, startY, value) {
+        this.items.push(geometry_js_1.Geometry.segment([startX, startY], [startX + value, startY]));
+        return this;
+    }
+    addRect(centerX, centerY, width, height) {
+        const width2 = width / 2;
+        const height2 = height / 2;
+        this.items.push(geometry_js_1.Geometry.polygon([
+            [centerX - width2, centerY - height2],
+            [centerX + width2, centerY - height2],
+            [centerX + width2, centerY + height2],
+            [centerX - width2, centerY + height2],
+            [centerX - width2, centerY - height2]
+        ]));
+        return this;
+    }
+    addTriangle(startX, startY, endX, endY, width) {
+        const line = geometry_js_1.Geometry.line(startX, startY, endX, endY);
+        const normLine = line.norm;
+        const dx1 = normLine.x * width / 2;
+        const dy1 = normLine.y * width / 2;
+        const dx2 = normLine.x * -width / 2;
+        const dy2 = normLine.y * -width / 2;
+        this.items.push(geometry_js_1.Geometry.polygon([
+            [dx1 + startX, dy1 + startY],
+            [dx2 + startX, dy2 + startY],
+            [endX, endY],
+            [dx1 + startX, dy1 + startY],
+        ]));
+        return this;
+    }
+    addRect2(x, y, x2, y2) {
+        this.items.push(geometry_js_1.Geometry.polygon([
+            [x, y],
+            [x2, y],
+            [x2, y2],
+            [x, y2],
+            [x, y]
+        ]));
+        return this;
+    }
+    addLabel(x, y, textValue, style) {
+        this.items.push(geometry_js_1.Geometry.label(null, x, y, textValue, style));
+        return this;
+    }
+    addLabelId(id, x, y, textValue, style) {
+        this.items.push(geometry_js_1.Geometry.label(id, x, y, textValue, style));
+        return this;
+    }
+    addPath(...pathParts) {
+        const parts = pathParts.reduce((accum, tmp) => {
+            if (typeof tmp === "string") {
+                accum = accum.concat(tmp.split(" "));
+            }
+            else if (typeof tmp === "number") {
+                accum.push(tmp);
+            }
+            return accum;
+        }, []);
+        const geomObjects = [];
+        let currentObj = null;
+        for (let i = 0; i < parts.length; i++) {
+            const command = parts[i];
+            if (command === 'M') {
+                if (currentObj !== null) {
+                    geomObjects.push(currentObj);
+                }
+                const x = Number(parts[i + 1]);
+                const y = Number(parts[i + 2]);
+                currentObj = [[x, y]];
+                i += 2;
+            }
+            else if (command === 'L') {
+                const x = Number(parts[i + 1]);
+                const y = Number(parts[i + 2]);
+                currentObj.push([x, y]);
+                i += 2;
+            }
+            else if (command === 'Z') {
+                const firstPoint = currentObj[0];
+                currentObj.push(firstPoint);
+            }
+        }
+        if (currentObj !== null) {
+            geomObjects.push(currentObj);
+            currentObj = null;
+        }
+        geomObjects.forEach(coords => {
+            const [first] = coords;
+            const last = coords[coords.length - 1];
+            if (first[0] === last[0] && first[1] === last[1]) {
+                this.items.push(geometry_js_1.Geometry.polygon(coords));
+            }
+            else {
+                this.items.push(geometry_js_1.Geometry.multiline(coords));
+            }
+        });
+        return this;
+    }
+    addSetLineWidth(value) {
+        this.items.push(new geometry_js_1.GeometryProp('lineWidth', value));
+        return this;
+    }
+    addSetLineColor(value) {
+        this.items.push(new geometry_js_1.GeometryProp('lineColor', value));
+        return this;
+    }
+    addSetFillColor(value) {
+        this.items.push(new geometry_js_1.GeometryProp('fillColor', value));
+        return this;
+    }
+    addArc(x, y, radius, startAngle, endAngle) {
+        startAngle = startAngle * Math.PI / 180;
+        endAngle = endAngle * Math.PI / 180;
+        this.items.push(geometry_js_1.Geometry.arc([x, y], radius, startAngle, endAngle, true));
+        return this;
+    }
+    getPaths() {
+        let currentFill = "#fff";
+        let currentLineWidth = 1;
+        let currentLineColor = '#333';
+        const pathItems = [];
+        this.items.forEach(item => {
+            if (!(item instanceof geometry_js_1.Label)) {
+                if (item instanceof geometry_js_1.GeometryProp) {
+                    if (item.name === 'lineWidth') {
+                        currentLineWidth = item.value;
+                    }
+                    else if (item.name === 'lineColor') {
+                        currentLineColor = item.value;
+                    }
+                    else if (item.name === 'fillColor') {
+                        currentFill = item.value;
+                    }
+                }
+                else {
+                    let tmpResult = geometry_js_1.Geometry.groupFlip([item], this.flipX, this.flipY);
+                    tmpResult = geometry_js_1.Geometry.groupRotate(tmpResult, this.angle, this.mainOrigin);
+                    const { path, isClosedPolygon } = this.featuresToPath(tmpResult);
+                    pathItems.push({
+                        path: path,
+                        lineWidth: currentLineWidth,
+                        lineColor: currentLineColor,
+                        fillColor: isClosedPolygon ? currentFill : 'none',
+                    });
+                }
+            }
+        });
+        return pathItems;
+    }
+    getPinsPath() {
+        let features = this.pins.map(item => item[1]);
+        features = geometry_js_1.Geometry.groupFlip(features, this.flipX, this.flipY);
+        features = geometry_js_1.Geometry.groupRotate(features, this.angle, this.mainOrigin);
+        const { path } = this.featuresToPath(features);
+        return path;
+    }
+    getLabels() {
+        return this.items.filter(item => item instanceof geometry_js_1.Label);
+    }
+    featuresToPath(items) {
+        return geometry_js_1.Geometry.featuresToPath(items);
+    }
+    getBoundingBox(excludeLabels = false) {
+        const pinFeatures = this.pins.map(pin => {
+            return pin[1];
+        });
+        const drawingFeatures = this.items.reduce((accum, item) => {
+            if (!excludeLabels || (excludeLabels && !(item instanceof geometry_js_1.Label))) {
+                if (!(item instanceof geometry_js_1.GeometryProp)) {
+                    accum.push(item);
+                }
+            }
+            return accum;
+        }, []);
+        let features = [...drawingFeatures, ...pinFeatures];
+        features = geometry_js_1.Geometry.groupFlip(features, this.flipX, this.flipY);
+        features = geometry_js_1.Geometry.groupRotate(features, this.angle, this.mainOrigin);
+        return geometry_js_1.Geometry.groupBounds(features);
+    }
+    getPinPosition(pinId) {
+        const pin = this.pins.find(item => {
+            return item[0] === pinId;
+        });
+        if (pin) {
+            const [, feature, angle] = pin;
+            let tmpFeature = geometry_js_1.Geometry.flip(feature, this.flipX, this.flipY);
+            tmpFeature = geometry_js_1.Geometry.rotateDegs(tmpFeature, this.angle, this.mainOrigin);
+            const coords = geometry_js_1.Geometry.getCoords(tmpFeature);
+            return {
+                start: coords[0],
+                end: coords[1],
+                angle,
+            };
+        }
+        return null;
+    }
+}
+exports.SymbolDrawing = SymbolDrawing;
+class SymbolDrawingCommands extends SymbolDrawing {
+    constructor(commands) {
+        super();
+        this.id = "";
+        this.commands = commands;
+        this.id = Math.random().toString().slice(2);
+    }
+    getCommands() {
+        return this.commands;
+    }
+    clone() {
+        const tmpCommands = this.commands.map(item => {
+            if (item[0] === PlaceHolderCommands.label) {
+                const commandName = item[0];
+                const positionParams = item[1];
+                const keywordParams = item[2];
+                const newMap = new Map();
+                for (const [key, value] of keywordParams) {
+                    newMap.set(key, value);
+                }
+                return [commandName, positionParams, newMap];
+            }
+            else {
+                return [...item];
+            }
+        });
+        return new SymbolDrawingCommands(tmpCommands);
+    }
+}
+exports.SymbolDrawingCommands = SymbolDrawingCommands;