@mlightcad/libredwg-web 0.6.5 → 0.6.7

package/lib/svg/ToSVG.js

@@ -0,0 +1,235 @@
+import { entityToPolyline } from './util/entityToPolyline';
+import { denormalise } from './util/denormalise';
+import { rotate } from './util/rotate';
+import { rgbToColorAttribute } from './util/rgbToColorAttribute';
+import { toPiecewiseBezier, multiplicity } from './util/toPiecewiseBezier';
+import { transformBoundingBoxAndElement } from './util/transformBoundingBoxAndElement';
+import { BoundingBox } from './util/boundingBox';
+import { Color } from './color';
+export class LibreDwgSVGConverter {
+    addFlipXIfApplicable(entity, { bbox, element }) {
+        if (entity.extrusionZ === -1) {
+            return {
+                bbox: new BoundingBox()
+                    .expandByPoint({ x: -bbox.min.x, y: bbox.min.y })
+                    .expandByPoint({ x: -bbox.max.x, y: bbox.max.y }),
+                element: `<g transform="matrix(-1 0 0 1 0 0)">${element}</g>`
+            };
+        }
+        else {
+            return { bbox, element };
+        }
+    }
+    polyline(entity) {
+        const vertices = entityToPolyline(entity);
+        const bbox = vertices.reduce((acc, [x, y]) => acc.expandByPoint({ x, y }), new BoundingBox());
+        const d = vertices.reduce((acc, point, i) => {
+            acc += i === 0 ? 'M' : 'L';
+            acc += point[0] + ',' + point[1];
+            return acc;
+        }, '');
+        return transformBoundingBoxAndElement(bbox, `<path d="${d}" />`, entity.transforms);
+    }
+    circle(entity) {
+        const bbox0 = new BoundingBox()
+            .expandByPoint({ x: entity.x + entity.r, y: entity.y + entity.r })
+            .expandByPoint({ x: entity.x - entity.r, y: entity.y - entity.r });
+        const element0 = `<circle cx="${entity.x}" cy="${entity.y}" r="${entity.r}" />`;
+        const { bbox, element } = this.addFlipXIfApplicable(entity, {
+            bbox: bbox0,
+            element: element0
+        });
+        return transformBoundingBoxAndElement(bbox, element, entity.transforms);
+    }
+    ellipseOrArc(cx, cy, majorX, majorY, axisRatio, startAngle, endAngle) {
+        const rx = Math.sqrt(majorX * majorX + majorY * majorY);
+        const ry = axisRatio * rx;
+        const rotationAngle = -Math.atan2(-majorY, majorX);
+        const bbox = this.bboxEllipseOrArc(cx, cy, majorX, majorY, axisRatio, startAngle, endAngle);
+        if (Math.abs(startAngle - endAngle) < 1e-9 ||
+            Math.abs(startAngle - endAngle + Math.PI * 2) < 1e-9) {
+            const element = `<g transform="rotate(${(rotationAngle / Math.PI) * 180} ${cx}, ${cy})"><ellipse cx="${cx}" cy="${cy}" rx="${rx}" ry="${ry}" /></g>`;
+            return { bbox, element };
+        }
+        else {
+            const startOffset = rotate({ x: Math.cos(startAngle) * rx, y: Math.sin(startAngle) * ry }, rotationAngle);
+            const startPoint = { x: cx + startOffset.x, y: cy + startOffset.y };
+            const endOffset = rotate({ x: Math.cos(endAngle) * rx, y: Math.sin(endAngle) * ry }, rotationAngle);
+            const endPoint = { x: cx + endOffset.x, y: cy + endOffset.y };
+            const adjustedEndAngle = endAngle < startAngle ? endAngle + Math.PI * 2 : endAngle;
+            const largeArcFlag = adjustedEndAngle - startAngle < Math.PI ? 0 : 1;
+            const d = `M ${startPoint.x} ${startPoint.y} A ${rx} ${ry} ${(rotationAngle / Math.PI) * 180} ${largeArcFlag} 1 ${endPoint.x} ${endPoint.y}`;
+            const element = `<path d="${d}" />`;
+            return { bbox, element };
+        }
+    }
+    bboxEllipseOrArc(cx, cy, majorX, majorY, axisRatio, startAngle, endAngle) {
+        while (startAngle < 0)
+            startAngle += Math.PI * 2;
+        while (endAngle <= startAngle)
+            endAngle += Math.PI * 2;
+        const angles = [];
+        if (Math.abs(majorX) < 1e-12 || Math.abs(majorY) < 1e-12) {
+            for (let i = 0; i < 4; i++) {
+                angles.push((i / 2) * Math.PI);
+            }
+        }
+        else {
+            angles[0] = Math.atan((-majorY * axisRatio) / majorX) - Math.PI;
+            angles[1] = Math.atan((majorX * axisRatio) / majorY) - Math.PI;
+            angles[2] = angles[0] - Math.PI;
+            angles[3] = angles[1] - Math.PI;
+        }
+        for (let i = 4; i >= 0; i--) {
+            while (angles[i] < startAngle)
+                angles[i] += Math.PI * 2;
+            if (angles[i] > endAngle) {
+                angles.splice(i, 1);
+            }
+        }
+        angles.push(startAngle);
+        angles.push(endAngle);
+        const pts = angles.map(a => ({ x: Math.cos(a), y: Math.sin(a) }));
+        const M = [
+            [majorX, -majorY * axisRatio],
+            [majorY, majorX * axisRatio]
+        ];
+        const rotatedPts = pts.map(p => ({
+            x: p.x * M[0][0] + p.y * M[0][1] + cx,
+            y: p.x * M[1][0] + p.y * M[1][1] + cy
+        }));
+        const bbox = rotatedPts.reduce((acc, p) => {
+            acc.expandByPoint(p);
+            return acc;
+        }, new BoundingBox());
+        return bbox;
+    }
+    ellipse(entity) {
+        const { bbox: bbox0, element: element0 } = this.ellipseOrArc(entity.x, entity.y, entity.majorX, entity.majorY, entity.axisRatio, entity.startAngle, entity.endAngle);
+        const { bbox, element } = this.addFlipXIfApplicable(entity, {
+            bbox: bbox0,
+            element: element0
+        });
+        return transformBoundingBoxAndElement(bbox, element, entity.transforms);
+    }
+    arc(entity) {
+        const { bbox: bbox0, element: element0 } = this.ellipseOrArc(entity.x, entity.y, entity.r, 0, 1, entity.startAngle, entity.endAngle);
+        const { bbox, element } = this.addFlipXIfApplicable(entity, {
+            bbox: bbox0,
+            element: element0
+        });
+        return transformBoundingBoxAndElement(bbox, element, entity.transforms);
+    }
+    piecewiseToPaths(k, knots, controlPoints) {
+        const paths = [];
+        let controlPointIndex = 0;
+        let knotIndex = k;
+        while (knotIndex < knots.length - k + 1) {
+            const m = multiplicity(knots, knotIndex);
+            const cp = controlPoints.slice(controlPointIndex, controlPointIndex + k);
+            if (k === 4) {
+                paths.push(`<path d="M ${cp[0].x} ${cp[0].y} C ${cp[1].x} ${cp[1].y} ${cp[2].x} ${cp[2].y} ${cp[3].x} ${cp[3].y}" />`);
+            }
+            else if (k === 3) {
+                paths.push(`<path d="M ${cp[0].x} ${cp[0].y} Q ${cp[1].x} ${cp[1].y} ${cp[2].x} ${cp[2].y}" />`);
+            }
+            controlPointIndex += m;
+            knotIndex += m;
+        }
+        return paths;
+    }
+    bezier(entity) {
+        let bbox = new BoundingBox();
+        entity.controlPoints.forEach((p) => {
+            bbox = bbox.expandByPoint(p);
+        });
+        const k = entity.degree + 1;
+        const piecewise = toPiecewiseBezier(k, entity.controlPoints, entity.knots);
+        const paths = this.piecewiseToPaths(k, piecewise.knots, piecewise.controlPoints);
+        const element = `<g>${paths.join('')}</g>`;
+        return transformBoundingBoxAndElement(bbox, element, entity.transforms);
+    }
+    entityToBoundsAndElement(entity) {
+        switch (entity.type) {
+            case 'CIRCLE':
+                return this.circle(entity);
+            case 'ELLIPSE':
+                return this.ellipse(entity);
+            case 'ARC':
+                return this.arc(entity);
+            case 'SPLINE': {
+                const hasWeights = entity.weights && entity.weights.some((w) => w !== 1);
+                if ((entity.degree === 2 || entity.degree === 3) && !hasWeights) {
+                    try {
+                        return this.bezier(entity);
+                    }
+                    catch (err) {
+                        return this.polyline(entity);
+                    }
+                }
+                else {
+                    return this.polyline(entity);
+                }
+            }
+            case 'LINE':
+            case 'LWPOLYLINE':
+            case 'POLYLINE':
+                return this.polyline(entity);
+            default:
+                return null;
+        }
+    }
+    getEntityColor(layers, entity) {
+        const layer = layers.find((layer) => layer.name === entity.layer);
+        if (layer) {
+            const color = new Color(layer.colorIndex);
+            return `rgb(${color.red}, ${color.green}, ${color.blue})`;
+        }
+        return "rgb(0, 0, 0)"; // Default to black if layer not found
+    }
+    convert(dwg) {
+        const entities = denormalise(dwg);
+        const { bbox, elements } = entities.reduce((acc, entity) => {
+            const rgb = this.getEntityColor(dwg.tables.LAYER.entries, entity);
+            const boundsAndElement = this.entityToBoundsAndElement(entity);
+            if (boundsAndElement) {
+                const { bbox, element } = boundsAndElement;
+                if (bbox.valid) {
+                    acc.bbox.expandByPoint(bbox.min);
+                    acc.bbox.expandByPoint(bbox.max);
+                }
+                acc.elements.push(`<g stroke="${rgbToColorAttribute(rgb)}">${element}</g>`);
+            }
+            return acc;
+        }, {
+            bbox: new BoundingBox(),
+            elements: []
+        });
+        const viewBox = bbox.valid
+            ? {
+                x: bbox.min.x,
+                y: -bbox.max.y,
+                width: bbox.max.x - bbox.min.x,
+                height: bbox.max.y - bbox.min.y
+            }
+            : {
+                x: 0,
+                y: 0,
+                width: 0,
+                height: 0
+            };
+        return `<?xml version="1.0"?>
+<svg
+  xmlns="http://www.w3.org/2000/svg"
+  xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1"
+  preserveAspectRatio="xMinYMin meet"
+  viewBox="${viewBox.x} ${viewBox.y} ${viewBox.width} ${viewBox.height}"
+  width="100%" height="100%"
+>
+  <g stroke="#000000" stroke-width="0.1%" fill="none" transform="matrix(1,0,0,-1,0,0)">
+    ${elements.join('\n')}
+  </g>
+</svg>`;
+    }
+}
+//# sourceMappingURL=ToSVG.js.map

package/lib/svg/util/boundingBox.d.ts

@@ -0,0 +1,9 @@
+import { DwgPoint2D } from "database";
+export declare class BoundingBox {
+    min: DwgPoint2D;
+    max: DwgPoint2D;
+    valid: boolean;
+    constructor();
+    expandByPoint(point: DwgPoint2D): BoundingBox;
+}
+//# sourceMappingURL=boundingBox.d.ts.map

package/lib/svg/util/boundingBox.js

@@ -0,0 +1,19 @@
+export class BoundingBox {
+    min;
+    max;
+    valid;
+    constructor() {
+        this.min = { x: Infinity, y: Infinity };
+        this.max = { x: -Infinity, y: -Infinity };
+        this.valid = false;
+    }
+    expandByPoint(point) {
+        this.min.x = Math.min(this.min.x, point.x);
+        this.min.y = Math.min(this.min.y, point.y);
+        this.max.x = Math.max(this.max.x, point.x);
+        this.max.y = Math.max(this.max.y, point.y);
+        this.valid = true;
+        return this;
+    }
+}
+//# sourceMappingURL=boundingBox.js.map

package/lib/svg/util/box2d.d.ts

@@ -0,0 +1,9 @@
+import { DwgPoint2D } from "database";
+export declare class Box2D {
+    min: DwgPoint2D;
+    max: DwgPoint2D;
+    valid: boolean;
+    constructor();
+    expandByPoint(point: DwgPoint2D): Box2D;
+}
+//# sourceMappingURL=box2d.d.ts.map

package/lib/svg/util/box2d.js

@@ -0,0 +1,19 @@
+export class Box2D {
+    min;
+    max;
+    valid;
+    constructor() {
+        this.min = { x: Infinity, y: Infinity };
+        this.max = { x: -Infinity, y: -Infinity };
+        this.valid = false;
+    }
+    expandByPoint(point) {
+        this.min.x = Math.min(this.min.x, point.x);
+        this.min.y = Math.min(this.min.y, point.y);
+        this.max.x = Math.max(this.max.x, point.x);
+        this.max.y = Math.max(this.max.y, point.y);
+        this.valid = true;
+        return this;
+    }
+}
+//# sourceMappingURL=box2d.js.map

package/lib/svg/util/denormalise.d.ts

@@ -0,0 +1,19 @@
+import { DwgDatabase } from '../../database';
+export declare const denormalise: (dwg: DwgDatabase) => {
+    type: string;
+    x: any;
+    y: any;
+    r: any;
+    majorX: any;
+    majorY: any;
+    axisRatio: any;
+    startAngle: any;
+    endAngle: any;
+    extrusionZ: any;
+    transforms: any;
+    controlPoints: any;
+    knots: any;
+    degree: any;
+    weights: any;
+}[];
+//# sourceMappingURL=denormalise.d.ts.map

package/lib/svg/util/denormalise.js

@@ -0,0 +1,24 @@
+export const denormalise = (dwg) => {
+    // Implement the logic to process the parsed DXF data
+    // This function should convert the parsed data into a format suitable for SVG conversion
+    // For example, it might involve flattening nested structures or extracting relevant properties
+    // Placeholder implementation
+    return dwg.entities.map((entity) => ({
+        type: entity.type,
+        x: entity.x,
+        y: entity.y,
+        r: entity.r,
+        majorX: entity.majorX,
+        majorY: entity.majorY,
+        axisRatio: entity.axisRatio,
+        startAngle: entity.startAngle,
+        endAngle: entity.endAngle,
+        extrusionZ: entity.extrusionZ,
+        transforms: entity.transforms,
+        controlPoints: entity.controlPoints,
+        knots: entity.knots,
+        degree: entity.degree,
+        weights: entity.weights,
+    }));
+};
+//# sourceMappingURL=denormalise.js.map

package/lib/svg/util/entityToPolyline.d.ts

@@ -0,0 +1,2 @@
+export declare const entityToPolyline: (entity: any) => any;
+//# sourceMappingURL=entityToPolyline.d.ts.map

package/lib/svg/util/entityToPolyline.js

@@ -0,0 +1,5 @@
+export const entityToPolyline = (entity) => {
+    const vertices = entity.vertices || []; // Assuming entity has a vertices property
+    return vertices.map((vertex) => [vertex.x, vertex.y]);
+};
+//# sourceMappingURL=entityToPolyline.js.map

package/lib/svg/util/getRGBForEntity.d.ts

@@ -0,0 +1,3 @@
+import { Layer } from "../types";
+export default function getRGBForEntity(layers: Layer[], entity: any): string;
+//# sourceMappingURL=getRGBForEntity.d.ts.map

package/lib/svg/util/getRGBForEntity.js

@@ -0,0 +1,9 @@
+export default function getRGBForEntity(layers, entity) {
+    const layer = layers.find((layer) => layer.name === entity.layer);
+    if (layer) {
+        const { r, g, b } = layer.color;
+        return `rgb(${r}, ${g}, ${b})`;
+    }
+    return "rgb(0, 0, 0)"; // Default to black if layer not found
+}
+//# sourceMappingURL=getRGBForEntity.js.map

package/lib/svg/util/rgbToColorAttribute.d.ts

@@ -0,0 +1,6 @@
+export declare const rgbToColorAttribute: (rgb: {
+    r: number;
+    g: number;
+    b: number;
+}) => string;
+//# sourceMappingURL=rgbToColorAttribute.d.ts.map

package/lib/svg/util/rgbToColorAttribute.js

@@ -0,0 +1,4 @@
+export const rgbToColorAttribute = (rgb) => {
+    return `rgb(${rgb.r}, ${rgb.g}, ${rgb.b})`;
+};
+//# sourceMappingURL=rgbToColorAttribute.js.map

package/lib/svg/util/rotate.d.ts

@@ -0,0 +1,6 @@
+import { DwgPoint2D } from '../../database';
+export declare const rotate: (point: DwgPoint2D, angle: number) => {
+    x: number;
+    y: number;
+};
+//# sourceMappingURL=rotate.d.ts.map

package/lib/svg/util/rotate.js

@@ -0,0 +1,9 @@
+export const rotate = (point, angle) => {
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    return {
+        x: point.x * cos - point.y * sin,
+        y: point.x * sin + point.y * cos,
+    };
+};
+//# sourceMappingURL=rotate.js.map

package/lib/svg/util/toPiecewiseBezier.d.ts

@@ -0,0 +1,9 @@
+export declare const toPiecewiseBezier: (k: number, controlPoints: {
+    x: number;
+    y: number;
+}[], knots: number[]) => {
+    knots: never[];
+    controlPoints: never[];
+};
+export declare const multiplicity: (knots: number[], index: number) => number;
+//# sourceMappingURL=toPiecewiseBezier.d.ts.map

package/lib/svg/util/toPiecewiseBezier.js

@@ -0,0 +1,24 @@
+export const toPiecewiseBezier = (k, controlPoints, knots) => {
+    const piecewise = { knots: [], controlPoints: [] };
+    let controlPointIndex = 0;
+    let knotIndex = k;
+    while (knotIndex < knots.length - k + 1) {
+        const m = multiplicity(knots, knotIndex);
+        const cp = controlPoints.slice(controlPointIndex, controlPointIndex + k);
+        piecewise.knots.push(...knots.slice(knotIndex, knotIndex + m));
+        piecewise.controlPoints.push(...cp);
+        controlPointIndex += m;
+        knotIndex += m;
+    }
+    return piecewise;
+};
+export const multiplicity = (knots, index) => {
+    let count = 0;
+    const knotValue = knots[index];
+    while (index < knots.length && knots[index] === knotValue) {
+        count++;
+        index++;
+    }
+    return count;
+};
+//# sourceMappingURL=toPiecewiseBezier.js.map

package/lib/svg/util/transformBoundingBoxAndElement.d.ts

@@ -0,0 +1,19 @@
+import { Box2D } from "../box2d";
+type Transform = {
+    type: "translate";
+    x: number;
+    y: number;
+} | {
+    type: "rotate";
+    angle: number;
+} | {
+    type: "scale";
+    x: number;
+    y: number;
+};
+export declare const transformBoundingBoxAndElement: (bbox: Box2D, element: string, transforms: Transform[] | undefined) => {
+    bbox: Box2D;
+    element: string;
+};
+export {};
+//# sourceMappingURL=transformBoundingBoxAndElement.d.ts.map

package/lib/svg/util/transformBoundingBoxAndElement.js

@@ -0,0 +1,20 @@
+export const transformBoundingBoxAndElement = (bbox, element, transforms) => {
+    if (!transforms || transforms.length === 0) {
+        return { bbox, element };
+    }
+    let transformedElement = element;
+    transforms.forEach((transform) => {
+        // Apply each transformation to the element
+        if (transform.type === "translate") {
+            transformedElement = `<g transform="translate(${transform.x}, ${transform.y})">${transformedElement}</g>`;
+        }
+        else if (transform.type === "rotate") {
+            transformedElement = `<g transform="rotate(${transform.angle})">${transformedElement}</g>`;
+        }
+        else if (transform.type === "scale") {
+            transformedElement = `<g transform="scale(${transform.x}, ${transform.y})">${transformedElement}</g>`;
+        }
+    });
+    return { bbox, element: transformedElement };
+};
+//# sourceMappingURL=transformBoundingBoxAndElement.js.map

package/lib/types/common.d.ts

@@ -1,4 +1,5 @@
 import { DwgPoint2D, DwgPoint2DWithWeight, DwgPoint3D } from '../database';
+import { Dwg_Color_Method } from './enums';
 export type Dwg_Array_Ptr = number;
 export type Dwg_Data_Ptr = number;
 export type Dwg_Object_Ptr = number;
@@ -68,7 +69,7 @@ export interface Dwg_Color {
      * - 0xc5 for foreground color
      * - 0xc8 for none (also c3 and rgb of 0x101)
      */
-    method: number;
+    method: Dwg_Color_Method;
     /**
      * DXF 430
      */

package/lib/types/database.d.ts

@@ -0,0 +1,17 @@
+import { DwgImageDefObject, DwgLayoutObject } from './objects';
+import { DwgBlockRecordTableEntry, DwgDimStyleTableEntry, DwgLayerTableEntry, DwgLTypeTableEntry, DwgStyleTableEntry, DwgTable, DwgVPortTableEntry } from './tables';
+export interface DwgDatabase {
+    tables: {
+        BLOCK_RECORD: DwgTable<DwgBlockRecordTableEntry>;
+        DIMSTYLE: DwgTable<DwgDimStyleTableEntry>;
+        LAYER: DwgTable<DwgLayerTableEntry>;
+        LTYPE: DwgTable<DwgLTypeTableEntry>;
+        STYLE: DwgTable<DwgStyleTableEntry>;
+        VPORT: DwgTable<DwgVPortTableEntry>;
+    };
+    objects: {
+        IMAGEDEF: DwgImageDefObject[];
+        LAYOUT: DwgLayoutObject[];
+    };
+}
+//# sourceMappingURL=database.d.ts.map

package/lib/types/database.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=database.js.map

package/lib/types/entities/arc.d.ts

@@ -0,0 +1,12 @@
+import { DwgPoint3D } from '../common';
+import { DwgEntity } from './entity';
+export interface DwgArcEntity extends DwgEntity {
+    type: 'ARC';
+    thickness: number;
+    center: DwgPoint3D;
+    radius: number;
+    startAngle: number;
+    endAngle: number;
+    extrusionDirection: DwgPoint3D;
+}
+//# sourceMappingURL=arc.d.ts.map

package/lib/types/entities/arc.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=arc.js.map

package/lib/types/entities/circle.d.ts

@@ -0,0 +1,10 @@
+import { DwgPoint3D } from '../common';
+import { DwgEntity } from './entity';
+export interface DwgCircleEntity extends DwgEntity {
+    type: 'CIRCLE';
+    thickness: number;
+    center: DwgPoint3D;
+    radius: number;
+    extrusionDirection: DwgPoint3D;
+}
+//# sourceMappingURL=circle.d.ts.map

package/lib/types/entities/circle.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=circle.js.map

package/lib/types/entities/dimension.d.ts

@@ -0,0 +1,108 @@
+import { DwgPoint3D } from '../common';
+import { DwgEntity } from './entity';
+export declare enum DwgDimensionType {
+    Rotated = 0,
+    Aligned = 1,
+    Angular = 2,
+    Diameter = 3,
+    Radius = 4,
+    Angular3Point = 5,
+    Ordinate = 6,
+    ReferenceIsExclusive = 32,
+    IsOrdinateXTypeFlag = 64,
+    IsCustomTextPositionFlag = 128
+}
+export declare enum DwgAttachmentPoint {
+    TopLeft = 1,
+    TopCenter = 2,
+    TopRight = 3,
+    MiddleLeft = 4,
+    MiddleCenter = 5,
+    MiddleRight = 6,
+    BottomLeft = 7,
+    BottomCenter = 8,
+    BottomRight = 9
+}
+export declare enum DwgDimensionTextLineSpacing {
+    AtLeast = 1,
+    Exact = 2
+}
+export declare enum DwgDimensionTextVertical {
+    Center = 0,
+    Above = 1,
+    Outside = 2,
+    JIS = 3,
+    Below = 4
+}
+export declare enum DwgDimensionZeroSuppression {
+    Feet = 0,
+    None = 1,
+    Inch = 2,
+    FeetAndInch = 3,
+    Leading = 4,
+    Trailing = 8,
+    LeadingAndTrailing = 12
+}
+export declare enum DwgDimensionZeroSuppressionAngular {
+    None = 0,
+    Leading = 1,
+    Trailing = 2,
+    LeadingAndTrailing = 3
+}
+export declare enum DwgDimensionTextHorizontal {
+    Center = 0,
+    Left = 1,
+    Right = 2,
+    OverFirst = 3,
+    OverSecond = 4
+}
+export declare enum DwgDimensionToleranceTextVertical {
+    Bottom = 0,
+    Center = 1,
+    Top = 2
+}
+export interface DwgDimensionEntityCommon extends DwgEntity {
+    type: 'DIMENSION';
+    subclassMarker: string;
+    version: string;
+    name: string;
+    definitionPoint: DwgPoint3D;
+    textPoint: DwgPoint3D;
+    dimensionType: DwgDimensionType;
+    attachmentPoint: DwgAttachmentPoint;
+    textLineSpacingStyle?: DwgDimensionTextLineSpacing;
+    textLineSpacingFactor?: number;
+    measurement?: number;
+    text?: string;
+    textRotation?: number;
+    ocsRotation?: number;
+    extrusionDirection?: DwgPoint3D;
+    styleName: string;
+}
+export interface DwgAlignedDimensionEntity extends DwgDimensionEntityCommon {
+    subclassMarker: 'AcDbAlignedDimension' | 'AcDbRotatedDimension';
+    insertionPoint?: DwgPoint3D;
+    subDefinitionPoint1: DwgPoint3D;
+    subDefinitionPoint2: DwgPoint3D;
+    rotationAngle: number;
+    obliqueAngle: number;
+}
+export interface DwgAngularDimensionEntity extends DwgDimensionEntityCommon {
+    subclassMarker: 'AcDb3PointAngularDimension';
+    subDefinitionPoint1: DwgPoint3D;
+    subDefinitionPoint2: DwgPoint3D;
+    centerPoint: DwgPoint3D;
+    arcPoint: DwgPoint3D;
+}
+export interface DwgOrdinateDimensionEntity extends DwgDimensionEntityCommon {
+    subclassMarker: 'AcDbOrdinateDimension';
+    subDefinitionPoint1: DwgPoint3D;
+    subDefinitionPoint2: DwgPoint3D;
+}
+export interface DwgRadialDiameterDimensionEntity extends DwgDimensionEntityCommon {
+    subclassMarker: 'AcDbRadialDimension' | 'AcDbDiametricDimension';
+    centerPoint: DwgPoint3D;
+    leaderLength: number;
+}
+export type DimensionEntity = DwgDimensionEntityCommon & (Partial<DwgAlignedDimensionEntity> | Partial<DwgAngularDimensionEntity> | Partial<DwgOrdinateDimensionEntity> | Partial<DwgRadialDiameterDimensionEntity>);
+//# sourceMappingURL=dimension.d.ts.map

package/lib/types/entities/dimension.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=dimension.js.map