@node-projects/acad-ts 1.0.0

package/dist/IO/SVG/SvgXmlWriter.js

@@ -0,0 +1,781 @@
+import { SvgConverter } from './SvgConverter.js';
+import { PlotRotation } from '../../Objects/PlotRotation.js';
+import { Entity } from '../../Entities/Entity.js';
+import { Arc } from '../../Entities/Arc.js';
+import { Circle } from '../../Entities/Circle.js';
+import { Dimension } from '../../Entities/Dimension.js';
+import { Ellipse } from '../../Entities/Ellipse.js';
+import { Hatch } from '../../Entities/Hatch.js';
+import { Insert } from '../../Entities/Insert.js';
+import { Line } from '../../Entities/Line.js';
+import { MText, AttachmentPointType } from '../../Entities/MText.js';
+import { Point } from '../../Entities/Point.js';
+import { Solid } from '../../Entities/Solid.js';
+import { TextEntity, TextHorizontalAlignment, TextVerticalAlignmentType } from '../../Entities/TextEntity.js';
+import { Polyline3D } from '../../Entities/Polyline3D.js';
+import { Color } from '../../Color.js';
+import { UnitsType } from '../../Types/Units/UnitsType.js';
+import { LineWeightType } from '../../Types/LineWeightType.js';
+import { NotificationType } from '../NotificationEventHandler.js';
+import { NotificationEventArgs } from '../NotificationEventHandler.js';
+import { UnitExtensions } from '../../Extensions/UnitExtensions.js';
+import { FontFlags } from '../../Tables/FontFlags.js';
+import { XYZ } from '../../Math/XYZ.js';
+class Transform {
+    Translation = new XYZ(0, 0, 0);
+    Scale = new XYZ(1, 1, 1);
+    EulerRotation = new XYZ(0, 0, 0);
+    Matrix = null;
+    constructor(translation, scale, rotation) {
+        if (translation)
+            this.Translation = translation;
+        if (scale)
+            this.Scale = scale;
+        if (rotation)
+            this.EulerRotation = rotation;
+    }
+    ApplyTransform(point) {
+        return new XYZ(point.x + this.Translation.x, point.y + this.Translation.y, point.z + this.Translation.z);
+    }
+}
+export class SvgXmlWriter {
+    OnNotification = null;
+    Configuration;
+    Layout = null;
+    Units = UnitsType.Unitless;
+    Formatting = 'Indented';
+    _output = '';
+    _indent = 0;
+    _elementStack = [];
+    _inAttribute = false;
+    _attrName = '';
+    _attrValue = '';
+    _currentElementOpen = false;
+    _stream;
+    _encoding;
+    constructor(stream, configOrEncoding, configuration) {
+        this._stream = stream;
+        if (configuration !== undefined) {
+            this._encoding = configOrEncoding;
+            this.Configuration = configuration;
+        }
+        else {
+            this._encoding = null;
+            this.Configuration = configOrEncoding;
+        }
+    }
+    WriteBlock(record) {
+        this.Units = record.units;
+        const box = this.getBlockBoundingBox(record);
+        this.startDocument(box, box, this.Units);
+        for (const e of record.entities) {
+            this.writeEntity(e);
+        }
+        this.endDocument();
+    }
+    WriteLayout(layout) {
+        this.Layout = layout;
+        this.Units = UnitExtensions.toUnits(layout.paperUnits);
+        let paperWidth = layout.paperWidth;
+        let paperHeight = layout.paperHeight;
+        switch (layout.paperRotation) {
+            case PlotRotation.Degrees90:
+            case PlotRotation.Degrees270:
+                paperWidth = layout.paperHeight;
+                paperHeight = layout.paperWidth;
+                break;
+        }
+        const lowerCorner = new XYZ(0, 0, 0);
+        const upperCorner = new XYZ(paperWidth, paperHeight, 0);
+        const paper = { Min: lowerCorner, Max: upperCorner, Width: paperWidth, Height: paperHeight };
+        const lowerMargin = new XYZ(layout.unprintableMargin?.bottomLeftCorner?.x ?? 0, layout.unprintableMargin?.bottomLeftCorner?.y ?? 0, 0);
+        this.startDocument(paper, null, UnitsType.Millimeters);
+        const transform = new Transform(SvgConverter.vectorToPixelSize(lowerMargin, UnitsType.Millimeters), new XYZ(layout.printScale, layout.printScale, layout.printScale), new XYZ(0, 0, 0));
+        for (const e of layout.associatedBlock.Entities) {
+            this.writeEntity(e, transform);
+        }
+        this.endDocument();
+    }
+    // ========== XML Writing Methods ==========
+    WriteStartDocument() {
+        this._output += '<?xml version="1.0" encoding="utf-8"?>\n';
+    }
+    WriteEndDocument() {
+        // no-op
+    }
+    WriteStartElement(localName) {
+        this.closeOpenElement();
+        this._output += `${this.getIndent()}<${localName}`;
+        this._elementStack.push(localName);
+        this._currentElementOpen = true;
+        this._indent++;
+    }
+    WriteEndElement() {
+        this._indent--;
+        if (this._currentElementOpen) {
+            this._output += ' />\n';
+            this._currentElementOpen = false;
+            this._elementStack.pop();
+        }
+        else {
+            this._elementStack.pop();
+            this._output += `${this.getIndent()}</${this._elementStack.length >= 0 ? '' : ''}`;
+            // Re-get the element name before it was popped
+            this._output = this._output.slice(0, this._output.lastIndexOf(`${this.getIndent()}<`));
+            // Actually let's redo this
+            const name = this._elementStack.length >= 0 ? '' : '';
+            this._output += `${this.getIndent()}</${this.getClosingTag()}>\n`;
+        }
+    }
+    WriteAttributeString(localName, value) {
+        if (typeof value === 'number') {
+            this._output += ` ${localName}="${SvgConverter.toSvgWithUnits(value, this.Units)}"`;
+        }
+        else {
+            this._output += ` ${localName}="${this.escapeXml(value)}"`;
+        }
+    }
+    WriteStartAttribute(localName) {
+        this._inAttribute = true;
+        this._attrName = localName;
+        this._attrValue = '';
+    }
+    WriteEndAttribute() {
+        this._output += ` ${this._attrName}="${this.escapeXml(this._attrValue)}"`;
+        this._inAttribute = false;
+    }
+    WriteValue(value) {
+        if (this._inAttribute) {
+            this._attrValue += typeof value === 'number' ? value.toString() : value;
+        }
+        else {
+            this.closeOpenElement();
+            this._output += this.escapeXml(typeof value === 'number' ? value.toString() : value);
+        }
+    }
+    WriteComment(comment) {
+        this.closeOpenElement();
+        this._output += `${this.getIndent()}<!-- ${comment} -->\n`;
+    }
+    WriteString(text) {
+        this.closeOpenElement();
+        this._output += this.escapeXml(text);
+    }
+    Close() {
+        // Write output to stream
+        const encoder = new TextEncoder();
+        const bytes = encoder.encode(this._output);
+        if (this._stream instanceof Uint8Array) {
+            this._stream.set(bytes);
+        }
+    }
+    getOutput() {
+        return this._output;
+    }
+    // ========== Protected methods ==========
+    notify(message, type, ex = null) {
+        if (this.OnNotification) {
+            this.OnNotification(this, new NotificationEventArgs(message, type, ex));
+        }
+    }
+    triggerNotification(sender, e) {
+        if (this.OnNotification) {
+            this.OnNotification(sender, e);
+        }
+    }
+    writeEntity(entity, transform) {
+        if (!transform) {
+            transform = new Transform();
+        }
+        this.WriteComment(`${entity.objectName} | ${entity.handle}`);
+        if (entity instanceof Arc) {
+            this.writeArc(entity, transform);
+        }
+        else if (entity instanceof Dimension) {
+            this.writeDimension(entity, transform);
+        }
+        else if (entity instanceof Line) {
+            this.writeLine(entity, transform);
+        }
+        else if (entity instanceof Point) {
+            this.writePoint(entity, transform);
+        }
+        else if (entity instanceof Circle) {
+            this.writeCircle(entity, transform);
+        }
+        else if (entity instanceof Ellipse) {
+            this.writeEllipse(entity, transform);
+        }
+        else if (entity instanceof Hatch) {
+            this.writeHatch(entity, transform);
+        }
+        else if (entity instanceof Insert) {
+            this.writeInsert(entity, transform);
+        }
+        else if ('isClosed' in entity && 'vertices' in entity) {
+            this.writePolyline(entity, transform);
+        }
+        else if ('Value' in entity && 'InsertPoint' in entity) {
+            this.writeText(entity, transform);
+        }
+        else if (entity instanceof Solid) {
+            this.writeSolid(entity, transform);
+        }
+        else {
+            this.notify(`[${entity.objectName}] Entity not implemented.`, NotificationType.NotImplemented);
+        }
+    }
+    // ========== Private helper methods ==========
+    closeOpenElement() {
+        if (this._currentElementOpen) {
+            this._output += '>\n';
+            this._currentElementOpen = false;
+        }
+    }
+    getIndent() {
+        return '  '.repeat(this._indent);
+    }
+    getClosingTag() {
+        // We need to track this differently
+        return '';
+    }
+    escapeXml(str) {
+        return str
+            .replace(/&/g, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;')
+            .replace(/'/g, '&apos;');
+    }
+    colorSvg(color) {
+        if (this.Layout !== null && color.equals(Color.Default)) {
+            color = Color.Black;
+        }
+        return `rgb(${color.r},${color.g},${color.b})`;
+    }
+    getBlockBoundingBox(record) {
+        let minX = Infinity;
+        let minY = Infinity;
+        let minZ = Infinity;
+        let maxX = -Infinity;
+        let maxY = -Infinity;
+        let maxZ = -Infinity;
+        for (const item of record.entities) {
+            if (!(item instanceof Entity)) {
+                continue;
+            }
+            const box = this.normalizeBoundingBox(item.getBoundingBox());
+            if (!box) {
+                continue;
+            }
+            minX = Math.min(minX, box.Min.x);
+            minY = Math.min(minY, box.Min.y);
+            minZ = Math.min(minZ, box.Min.z);
+            maxX = Math.max(maxX, box.Max.x);
+            maxY = Math.max(maxY, box.Max.y);
+            maxZ = Math.max(maxZ, box.Max.z);
+        }
+        if (!Number.isFinite(minX) || !Number.isFinite(maxX)) {
+            return { Min: new XYZ(0, 0, 0), Max: new XYZ(0, 0, 0), Width: 0, Height: 0 };
+        }
+        const min = new XYZ(minX, minY, minZ);
+        const max = new XYZ(maxX, maxY, maxZ);
+        return { Min: min, Max: max, Width: max.x - min.x, Height: max.y - min.y };
+    }
+    normalizeBoundingBox(box) {
+        if (!box) {
+            return null;
+        }
+        const min = box.Min ?? box.min;
+        const max = box.Max ?? box.max;
+        if (!min || !max) {
+            return null;
+        }
+        const normalizedMin = new XYZ(min.x ?? 0, min.y ?? 0, min.z ?? 0);
+        const normalizedMax = new XYZ(max.x ?? 0, max.y ?? 0, max.z ?? 0);
+        return {
+            Min: normalizedMin,
+            Max: normalizedMax,
+            Width: normalizedMax.x - normalizedMin.x,
+            Height: normalizedMax.y - normalizedMin.y,
+        };
+    }
+    getPolylinePoints(polyline) {
+        if (typeof polyline.getPoints === 'function') {
+            return polyline.getPoints(this.Configuration.ArcPoints);
+        }
+        const points = [];
+        for (const vertex of polyline.vertices ?? []) {
+            if (vertex == null || typeof vertex !== 'object') {
+                continue;
+            }
+            const location = typeof vertex.getLocation3D === 'function'
+                ? vertex.getLocation3D()
+                : vertex.location;
+            if (location) {
+                points.push(location);
+            }
+        }
+        return points;
+    }
+    createPath(...polylines) {
+        let sb = '';
+        for (const item of polylines) {
+            const pts = this.getPolylinePoints(item);
+            if (!pts || pts.length === 0) {
+                continue;
+            }
+            const pt0 = SvgConverter.vectorToPixelSize(pts[0], this.Units);
+            sb += `M ${SvgConverter.vectorToSvg(pt0)} `;
+            for (let i = 1; i < pts.length; i++) {
+                const pt = SvgConverter.vectorToPixelSize(pts[i], this.Units);
+                sb += `L ${SvgConverter.vectorToSvg(pt)} `;
+            }
+            if (item.isClosed) {
+                sb += 'Z';
+            }
+        }
+        return sb;
+    }
+    drawableLineType(lineType) {
+        return lineType.isComplex && !lineType.hasShapes;
+    }
+    getPointSize(entity) {
+        const lw = entity.getActiveLineWeightType ? entity.getActiveLineWeightType() : LineWeightType.Default;
+        return SvgConverter.toPixelSize(this.Configuration.GetLineWeightValue(lw, this.Units), this.Units);
+    }
+    startDocument(box, viewBox, units) {
+        this.WriteStartDocument();
+        this.WriteStartElement('svg');
+        this.WriteAttributeString('xmlns', 'http://www.w3.org/2000/svg');
+        this.WriteAttributeString('width', SvgConverter.toSvgWithUnits(box.Max.x - box.Min.x, units));
+        this.WriteAttributeString('height', SvgConverter.toSvgWithUnits(box.Max.y - box.Min.y, units));
+        if (viewBox) {
+            const vb = viewBox;
+            this.WriteStartAttribute('viewBox');
+            this.WriteValue(SvgConverter.toPixelSize(vb.Min.x, units));
+            this.WriteValue(' ');
+            this.WriteValue(SvgConverter.toPixelSize(vb.Min.y, units));
+            this.WriteValue(' ');
+            this.WriteValue(SvgConverter.toPixelSize(vb.Width, units));
+            this.WriteValue(' ');
+            this.WriteValue(SvgConverter.toPixelSize(vb.Height, units));
+            this.WriteEndAttribute();
+        }
+        this.WriteAttributeString('transform', 'scale(1,-1)');
+        if (this.Layout !== null) {
+            this.WriteAttributeString('style', 'background-color:white');
+        }
+    }
+    endDocument() {
+        this.WriteEndElement();
+        this.WriteEndDocument();
+        this.Close();
+    }
+    svgPoints(points, transform) {
+        if (!points || points.length === 0) {
+            return '';
+        }
+        let sb = SvgConverter.vectorToSvg(SvgConverter.vectorToPixelSize(points[0], this.Units));
+        for (let i = 1; i < points.length; i++) {
+            sb += ' ';
+            sb += SvgConverter.vectorToSvg(SvgConverter.vectorToPixelSize(points[i], this.Units));
+        }
+        return sb;
+    }
+    writeArc(arc, transform) {
+        this.WriteStartElement('path');
+        this.writeEntityHeader(arc, transform);
+        const vertices = arc.getEndVertices();
+        const start = vertices.start;
+        const end = vertices.end;
+        const sweep = arc.endAngle - arc.startAngle;
+        const largeArc = Math.abs(sweep) > Math.PI ? 1 : 0;
+        let sb = '';
+        sb += `M ${SvgConverter.vectorToSvg(SvgConverter.vectorToPixelSize(start, this.Units))}`;
+        sb += ` `;
+        sb += `A ${SvgConverter.toPixelSize(arc.radius, this.Units)} ${SvgConverter.toPixelSize(arc.radius, this.Units)}`;
+        sb += ` `;
+        sb += `${0} ${largeArc} ${1} ${SvgConverter.vectorToSvg(SvgConverter.vectorToPixelSize(end, this.Units))}`;
+        this.WriteAttributeString('d', sb);
+        this.WriteAttributeString('fill', 'none');
+        this.WriteEndElement();
+    }
+    writeDimension(dimension, transform) {
+        this.WriteStartElement('g');
+        if (dimension.block && dimension.block.entities) {
+            for (const e of dimension.block.entities) {
+                this.writeEntity(e, transform);
+            }
+        }
+        this.WriteEndElement();
+    }
+    writeCircle(circle, transform) {
+        const loc = transform.ApplyTransform(circle.center);
+        this.WriteStartElement('circle');
+        this.writeEntityHeader(circle, transform);
+        this.WriteAttributeString('r', SvgConverter.toSvgWithUnits(circle.radius, this.Units));
+        this.WriteAttributeString('cx', SvgConverter.toSvgWithUnits(loc.x, this.Units));
+        this.WriteAttributeString('cy', SvgConverter.toSvgWithUnits(loc.y, this.Units));
+        this.WriteAttributeString('fill', 'none');
+        this.WriteEndElement();
+    }
+    writeDashes(dashes) {
+        let sb = '';
+        for (const d of dashes) {
+            sb += Math.abs(SvgConverter.toPixelSize(d, this.Units)).toString();
+            sb += ' ';
+        }
+        this.WriteAttributeString('stroke-dasharray', sb.trim());
+    }
+    writeDashesFromLineType(lineType, pointSize) {
+        let sb = '';
+        for (const segment of lineType.segments) {
+            if (segment.length === 0) {
+                sb += SvgConverter.toPixelSize(pointSize, this.Units).toString();
+            }
+            else {
+                sb += Math.abs(SvgConverter.toPixelSize(segment.length, this.Units)).toString();
+            }
+            sb += ' ';
+        }
+        this.WriteAttributeString('stroke-dasharray', sb.trim());
+    }
+    writeEllipse(ellipse, transform) {
+        if (ellipse.isFullEllipse) {
+            this.WriteStartElement('path');
+            this.writeEntityHeader(ellipse, transform);
+            let sb = '';
+            const start = ellipse.polarCoordinateRelativeToCenter ? ellipse.polarCoordinateRelativeToCenter(0) : new XYZ(0, 0, 0);
+            const end = ellipse.polarCoordinateRelativeToCenter ? ellipse.polarCoordinateRelativeToCenter(Math.PI) : new XYZ(0, 0, 0);
+            sb += `M ${SvgConverter.vectorToSvg(SvgConverter.vectorToPixelSize(start, this.Units))} `;
+            sb += `A ${ellipse.majorAxis / 2} ${ellipse.minorAxis / 2} ${ellipse.rotation * 180 / Math.PI} ${0} ${1} ${SvgConverter.vectorToSvg(SvgConverter.vectorToPixelSize(end, this.Units))} `;
+            const start2 = ellipse.polarCoordinateRelativeToCenter ? ellipse.polarCoordinateRelativeToCenter(Math.PI) : new XYZ(0, 0, 0);
+            const end2 = ellipse.polarCoordinateRelativeToCenter ? ellipse.polarCoordinateRelativeToCenter(Math.PI * 2) : new XYZ(0, 0, 0);
+            sb += `A ${ellipse.majorAxis / 2} ${ellipse.minorAxis / 2} ${ellipse.rotation * 180 / Math.PI} ${0} ${1} ${SvgConverter.vectorToSvg(SvgConverter.vectorToPixelSize(end2, this.Units))}`;
+            this.WriteAttributeString('d', sb);
+            this.WriteAttributeString('fill', 'none');
+            this.WriteEndElement();
+        }
+        else {
+            this.WriteStartElement('polyline');
+            this.writeEntityHeader(ellipse, transform);
+            const vertices = ellipse.polygonalVertexes ? ellipse.polygonalVertexes(256) : [];
+            const pts = this.svgPoints(vertices, transform);
+            this.WriteAttributeString('points', pts);
+            this.WriteAttributeString('fill', 'none');
+            this.WriteEndElement();
+        }
+    }
+    writeEntityHeader(entity, transform, drawStroke = true) {
+        const color = entity.getActiveColor ? entity.getActiveColor() : entity.Color ?? Color.Default;
+        this.WriteAttributeString('vector-effect', 'non-scaling-stroke');
+        if (drawStroke) {
+            this.WriteAttributeString('stroke', this.colorSvg(color));
+        }
+        else {
+            this.WriteAttributeString('stroke', 'none');
+        }
+        const lineWeight = entity.getActiveLineWeightType ? entity.getActiveLineWeightType() : LineWeightType.Default;
+        this.WriteAttributeString('stroke-width', `${SvgConverter.toSvgWithUnits(this.Configuration.GetLineWeightValue(lineWeight, this.Units), UnitsType.Millimeters)}`);
+        this.writeTransformObj(transform);
+        const lt = entity.getActiveLineType ? entity.getActiveLineType() : null;
+        if (lt && this.drawableLineType(lt)) {
+            this.writeDashesFromLineType(lt, this.getPointSize(entity));
+        }
+    }
+    writeHatch(hatch, transform) {
+        this.WriteStartElement('g');
+        const patternId = this.writePattern(hatch);
+        const plines = [];
+        for (const path of hatch.paths) {
+            const pts = path.getPoints ? path.getPoints(this.Configuration.ArcPoints) : [];
+            const pline = new Polyline3D(pts);
+            plines.push(pline);
+        }
+        this.WriteStartElement('path');
+        this.writeEntityHeader(hatch, transform, false);
+        this.WriteAttributeString('d', this.createPath(...plines));
+        this.WriteAttributeString('fill', `url(#${patternId})`);
+        this.WriteEndElement();
+        this.WriteEndElement();
+    }
+    writePatternHeader(hatch) {
+        const id = `${hatch.pattern.name}_pattern`;
+        this.WriteStartElement('pattern');
+        this.WriteAttributeString('id', id);
+        this.WriteAttributeString('patternUnits', 'userSpaceOnUse');
+        return id;
+    }
+    writeSolidPattern(hatch) {
+        const id = this.writePatternHeader(hatch);
+        this.WriteAttributeString('width', '100%');
+        this.WriteAttributeString('height', '100%');
+        this.WriteStartElement('rect');
+        this.WriteAttributeString('width', '100%');
+        this.WriteAttributeString('height', '100%');
+        this.WriteAttributeString('fill', this.colorSvg(hatch.color));
+        // rect
+        this.WriteEndElement();
+        // pattern
+        this.WriteEndElement();
+        return id;
+    }
+    writePattern(hatch) {
+        if (hatch.isSolid) {
+            return this.writeSolidPattern(hatch);
+        }
+        const patterns = new Map();
+        for (const [index, item] of hatch.pattern.lines.entries()) {
+            const i = `${hatch.pattern.name}_${index}_line`;
+            patterns.set(i, {
+                Min: new XYZ(0, 0, 0),
+                Max: new XYZ(item.lineOffset, item.lineOffset, 0),
+                Width: item.lineOffset,
+                Height: item.lineOffset,
+            });
+            this.WriteStartElement('pattern');
+            this.WriteAttributeString('id', i);
+            this.WriteAttributeString('patternUnits', 'userSpaceOnUse');
+            this.WriteAttributeString('width', SvgConverter.toSvgWithUnits(item.lineOffset, this.Units));
+            this.WriteAttributeString('height', SvgConverter.toSvgWithUnits(item.lineOffset, this.Units));
+            this.writeTransformValues('patternTransform', SvgConverter.vectorToPixelSize(new XYZ(item.basePoint.x, item.basePoint.y, 0), this.Units));
+            this.WriteStartElement('line');
+            const x = Math.cos(item.angle) * 10;
+            const y = Math.sin(item.angle) * 10;
+            this.WriteAttributeString('x1', SvgConverter.toSvgWithUnits(0, this.Units));
+            this.WriteAttributeString('y1', SvgConverter.toSvgWithUnits(0, this.Units));
+            this.WriteAttributeString('x2', SvgConverter.toSvgWithUnits(x, this.Units));
+            this.WriteAttributeString('y2', SvgConverter.toSvgWithUnits(y, this.Units));
+            this.WriteAttributeString('stroke', this.colorSvg(hatch.color));
+            this.WriteAttributeString('stroke-width', `${SvgConverter.toSvgWithUnits(this.Configuration.GetLineWeightValue(hatch.lineWeight ?? LineWeightType.Default, this.Units), UnitsType.Millimeters)}`);
+            if (item.dashLengths && item.dashLengths.length > 0) {
+                this.writeDashes(item.dashLengths);
+            }
+            // Line
+            this.WriteEndElement();
+            // Pattern
+            this.WriteEndElement();
+        }
+        const id = this.writePatternHeader(hatch);
+        let width = 0;
+        let height = 0;
+        for (const [, box] of patterns) {
+            if (box.Width > width)
+                width = box.Width;
+            if (box.Height > height)
+                height = box.Height;
+        }
+        this.WriteAttributeString('width', SvgConverter.toSvgWithUnits(width, this.Units));
+        this.WriteAttributeString('height', SvgConverter.toSvgWithUnits(height, this.Units));
+        for (const [key, box] of patterns) {
+            this.WriteStartElement('rect');
+            this.WriteAttributeString('width', SvgConverter.toSvgWithUnits(box.Width, this.Units));
+            this.WriteAttributeString('height', SvgConverter.toSvgWithUnits(box.Height, this.Units));
+            this.WriteAttributeString('fill', `url(#${key})`);
+            this.WriteEndElement();
+        }
+        // pattern
+        this.WriteEndElement();
+        return id;
+    }
+    writeInsert(insert, transform) {
+        const insertTransform = insert.getTransform ? insert.getTransform() : new Transform();
+        // Merge transforms
+        const merged = new Transform(new XYZ(transform.Translation.x + insertTransform.Translation.x, transform.Translation.y + insertTransform.Translation.y, transform.Translation.z + insertTransform.Translation.z));
+        this.WriteStartElement('g');
+        this.writeTransformObj(merged);
+        for (const e of insert.block.entities) {
+            this.writeEntity(e);
+        }
+        this.WriteEndElement();
+    }
+    writeLine(line, transform) {
+        this.WriteStartElement('line');
+        this.writeEntityHeader(line, transform);
+        this.WriteAttributeString('x1', SvgConverter.toSvgWithUnits(line.startPoint.x, this.Units));
+        this.WriteAttributeString('y1', SvgConverter.toSvgWithUnits(line.startPoint.y, this.Units));
+        this.WriteAttributeString('x2', SvgConverter.toSvgWithUnits(line.endPoint.x, this.Units));
+        this.WriteAttributeString('y2', SvgConverter.toSvgWithUnits(line.endPoint.y, this.Units));
+        this.WriteEndElement();
+    }
+    writePoint(point, transform) {
+        this.WriteStartElement('circle');
+        this.writeEntityHeader(point, transform);
+        this.WriteAttributeString('r', SvgConverter.toSvgWithUnits(this.Configuration.PointRadius, UnitsType.Unitless));
+        this.WriteAttributeString('cx', SvgConverter.toSvgWithUnits(point.location.x, this.Units));
+        this.WriteAttributeString('cy', SvgConverter.toSvgWithUnits(point.location.y, this.Units));
+        this.WriteAttributeString('fill', this.colorSvg(point.color));
+        this.WriteEndElement();
+    }
+    writePolyline(polyline, transform) {
+        if (polyline.isClosed) {
+            this.WriteStartElement('polygon');
+        }
+        else {
+            this.WriteStartElement('polyline');
+        }
+        this.writeEntityHeader(polyline, transform);
+        const pts = this.getPolylinePoints(polyline);
+        const ptsStr = this.svgPoints(pts, transform);
+        this.WriteAttributeString('points', ptsStr);
+        this.WriteAttributeString('fill', 'none');
+        this.WriteEndElement();
+    }
+    writeText(text, transform) {
+        let insert;
+        if (text instanceof TextEntity
+            && (text.horizontalAlignment !== TextHorizontalAlignment.Left
+                || text.verticalAlignment !== TextVerticalAlignmentType.Baseline)
+            && !(text.horizontalAlignment === TextHorizontalAlignment.Fit
+                || text.horizontalAlignment === TextHorizontalAlignment.Aligned)) {
+            insert = text.alignmentPoint;
+        }
+        else {
+            insert = text.InsertPoint;
+        }
+        this.WriteStartElement('g');
+        this.writeTransformObj(transform);
+        this.WriteStartElement('text');
+        this.writeTransformValues('transform', SvgConverter.vectorToPixelSize(insert, this.Units), new XYZ(1, -1, 0), text.Rotation !== 0 ? text.Rotation : undefined);
+        this.WriteAttributeString('fill', this.colorSvg(text.Color ?? Color.Default));
+        let style = 'font:';
+        style += SvgConverter.toSvgWithUnits(text.Height, this.Units);
+        if (this.Units === UnitsType.Unitless) {
+            style += 'px';
+        }
+        if (text.Style?.TrueType !== undefined) {
+            if (text.Style.TrueType & FontFlags.Bold) {
+                style += 'bold';
+            }
+            if (text.Style.TrueType & FontFlags.Italic) {
+                style += 'italic';
+            }
+        }
+        style += ' ';
+        if (text.Style?.Filename) {
+            const filename = text.Style.Filename;
+            const nameWithoutExt = filename.replace(/\.[^/.]+$/, '');
+            style += nameWithoutExt;
+        }
+        this.WriteAttributeString('style', style);
+        if (text instanceof MText) {
+            const mtext = text;
+            switch (mtext.attachmentPoint) {
+                case AttachmentPointType.TopLeft:
+                    this.WriteAttributeString('alignment-baseline', 'hanging');
+                    this.WriteAttributeString('text-anchor', 'start');
+                    break;
+                case AttachmentPointType.TopCenter:
+                    this.WriteAttributeString('alignment-baseline', 'hanging');
+                    this.WriteAttributeString('text-anchor', 'middle');
+                    break;
+                case AttachmentPointType.TopRight:
+                    this.WriteAttributeString('alignment-baseline', 'hanging');
+                    this.WriteAttributeString('text-anchor', 'end');
+                    break;
+                case AttachmentPointType.MiddleLeft:
+                    this.WriteAttributeString('alignment-baseline', 'middle');
+                    this.WriteAttributeString('text-anchor', 'start');
+                    break;
+                case AttachmentPointType.MiddleCenter:
+                    this.WriteAttributeString('alignment-baseline', 'middle');
+                    this.WriteAttributeString('text-anchor', 'middle');
+                    break;
+                case AttachmentPointType.MiddleRight:
+                    this.WriteAttributeString('alignment-baseline', 'middle');
+                    this.WriteAttributeString('text-anchor', 'end');
+                    break;
+                case AttachmentPointType.BottomLeft:
+                    this.WriteAttributeString('alignment-baseline', 'baseline');
+                    this.WriteAttributeString('text-anchor', 'start');
+                    break;
+                case AttachmentPointType.BottomCenter:
+                    this.WriteAttributeString('alignment-baseline', 'baseline');
+                    this.WriteAttributeString('text-anchor', 'middle');
+                    break;
+                case AttachmentPointType.BottomRight:
+                    this.WriteAttributeString('alignment-baseline', 'baseline');
+                    this.WriteAttributeString('text-anchor', 'end');
+                    break;
+            }
+            const lines = mtext.getPlainTextLines ? mtext.getPlainTextLines() : [mtext.value];
+            for (const item of lines) {
+                this.WriteStartElement('tspan');
+                this.WriteAttributeString('x', '0');
+                this.WriteAttributeString('dy', '1em');
+                this.WriteString(item);
+                this.WriteEndElement();
+            }
+            // Hidden line to avoid offset
+            this.WriteStartElement('tspan');
+            this.WriteAttributeString('x', '0');
+            this.WriteAttributeString('dy', '1em');
+            this.WriteAttributeString('visibility', 'hidden');
+            this.WriteString('.');
+            this.WriteEndElement();
+        }
+        else if (text instanceof TextEntity) {
+            const textEntity = text;
+            switch (textEntity.horizontalAlignment) {
+                case TextHorizontalAlignment.Left:
+                    this.WriteAttributeString('text-anchor', 'start');
+                    break;
+                case TextHorizontalAlignment.Middle:
+                case TextHorizontalAlignment.Center:
+                    this.WriteAttributeString('text-anchor', 'middle');
+                    break;
+                case TextHorizontalAlignment.Right:
+                    this.WriteAttributeString('text-anchor', 'end');
+                    break;
+            }
+            switch (textEntity.verticalAlignment) {
+                case TextVerticalAlignmentType.Baseline:
+                case TextVerticalAlignmentType.Bottom:
+                    this.WriteAttributeString('alignment-baseline', 'baseline');
+                    break;
+                case TextVerticalAlignmentType.Middle:
+                    this.WriteAttributeString('alignment-baseline', 'middle');
+                    break;
+                case TextVerticalAlignmentType.Top:
+                    this.WriteAttributeString('alignment-baseline', 'hanging');
+                    break;
+            }
+            this.WriteString(text.value);
+        }
+        this.WriteEndElement();
+        this.WriteEndElement();
+    }
+    writeSolid(solid, transform) {
+        this.WriteStartElement('polygon');
+        this.writeEntityHeader(solid, transform);
+        const pts = this.svgPoints([solid.firstCorner, solid.secondCorner, solid.thirdCorner, solid.fourthCorner], transform);
+        this.WriteAttributeString('points', pts);
+        this.WriteAttributeString('fill', this.colorSvg(solid.color));
+        this.WriteEndElement();
+    }
+    writeTransformObj(transform) {
+        const translation = (transform.Translation.x !== 0 || transform.Translation.y !== 0 || transform.Translation.z !== 0) ? transform.Translation : undefined;
+        const scale = (transform.Scale.x !== 1 || transform.Scale.y !== 1) ? transform.Scale : undefined;
+        const rotation = transform.EulerRotation.z !== 0 ? transform.EulerRotation.z : undefined;
+        this.writeTransformValues('transform', translation, scale, rotation);
+    }
+    writeTransformValues(name = 'transform', translation, scale, rotation) {
+        let sb = '';
+        if (translation) {
+            sb += `translate(${translation.x.toString()},${translation.y.toString()})`;
+        }
+        if (scale) {
+            sb += `scale(${scale.x.toString()},${scale.y.toString()})`;
+        }
+        if (rotation !== undefined) {
+            const r = -(rotation * 180 / Math.PI);
+            sb += `rotate(${r.toString()})`;
+        }
+        if (!sb) {
+            return;
+        }
+        this.WriteAttributeString(name, sb);
+    }
+}
+//# sourceMappingURL=SvgXmlWriter.js.map