ofs-dxf-ts 1.0.0

package/dist/parser/entities/3dface.d.ts

@@ -0,0 +1,5 @@
+import { DxfEntity, DxfGroup, IEntityParser, IScanner } from '../types.js';
+export default class Face implements IEntityParser {
+    static ForEntityName: string;
+    parseEntity(scanner: IScanner, curr: DxfGroup): DxfEntity;
+}

package/dist/parser/entities/3dface.js

@@ -0,0 +1,76 @@
+import * as helpers from '../parse-helpers.js';
+export default class Face {
+    static ForEntityName = '3DFACE';
+    parseEntity(scanner, curr) {
+        const entity = { type: curr.value, vertices: [] };
+        curr = scanner.next();
+        while (true) {
+            if (curr.code === 0)
+                break;
+            switch (curr.code) {
+                case 70: // 1 = Closed shape, 128 = plinegen?, 0 = default
+                    entity.shape = ((curr.value & 1) === 1);
+                    entity.hasContinuousLinetypePattern = ((curr.value & 128) === 128);
+                    break;
+                case 10: // X coordinate of point
+                    entity.vertices = parse3dFaceVertices(scanner, curr);
+                    curr = scanner.lastReadGroup;
+                    break;
+                default:
+                    helpers.checkCommonEntityProperties(entity, curr, scanner);
+                    break;
+            }
+            curr = scanner.next();
+        }
+        return entity;
+    }
+}
+function parse3dFaceVertices(scanner, curr) {
+    const vertices = [];
+    let vertexIsStarted = false;
+    let vertexIsFinished = false;
+    const verticesPer3dFace = 4; // there can be up to four vertices per face, although 3 is most used for TIN
+    for (let i = 0; i <= verticesPer3dFace; i++) {
+        const vertex = {};
+        while (true) {
+            if (curr.code === 0 || vertexIsFinished)
+                break;
+            switch (curr.code) {
+                case 10: // X0
+                case 11: // X1
+                case 12: // X2
+                case 13: // X3
+                    if (vertexIsStarted) {
+                        vertexIsFinished = true;
+                        continue;
+                    }
+                    vertex.x = curr.value;
+                    vertexIsStarted = true;
+                    break;
+                case 20: // Y
+                case 21:
+                case 22:
+                case 23:
+                    vertex.y = curr.value;
+                    break;
+                case 30: // Z
+                case 31:
+                case 32:
+                case 33:
+                    vertex.z = curr.value;
+                    break;
+                default:
+                    // it is possible to have entity codes after the vertices.
+                    // So if code is not accounted for return to entity parser where it might be accounted for
+                    return vertices;
+            }
+            curr = scanner.next();
+        }
+        // See https://groups.google.com/forum/#!topic/comp.cad.autocad/9gn8s5O_w6E
+        vertices.push(vertex);
+        vertexIsStarted = false;
+        vertexIsFinished = false;
+    }
+    scanner.rewind();
+    return vertices;
+}

package/dist/parser/entities/arc.d.ts

@@ -0,0 +1,5 @@
+import { DxfEntity, DxfGroup, IEntityParser, IScanner } from '../types.js';
+export default class Arc implements IEntityParser {
+    static ForEntityName: string;
+    parseEntity(scanner: IScanner, curr: DxfGroup): DxfEntity;
+}

package/dist/parser/entities/arc.js

@@ -0,0 +1,34 @@
+import * as helpers from '../parse-helpers.js';
+export default class Arc {
+    static ForEntityName = 'ARC';
+    parseEntity(scanner, curr) {
+        const entity = { type: curr.value };
+        curr = scanner.next();
+        while (true) {
+            if (curr.code === 0)
+                break;
+            switch (curr.code) {
+                case 10: // X coordinate of point
+                    entity.center = helpers.parsePoint(scanner);
+                    break;
+                case 40: // radius
+                    entity.radius = curr.value;
+                    break;
+                case 50: // start angle
+                    entity.startAngle = Math.PI / 180 * curr.value;
+                    break;
+                case 51: // end angle
+                    entity.endAngle = Math.PI / 180 * curr.value;
+                    break;
+                case 210:
+                    entity.extrusionDirection = helpers.parsePoint(scanner);
+                    break;
+                default: // ignored attribute
+                    helpers.checkCommonEntityProperties(entity, curr, scanner);
+                    break;
+            }
+            curr = scanner.next();
+        }
+        return entity;
+    }
+}

package/dist/parser/entities/attdef.d.ts

@@ -0,0 +1,5 @@
+import { DxfEntity, DxfGroup, IEntityParser, IScanner } from '../types.js';
+export default class AttDef implements IEntityParser {
+    static ForEntityName: string;
+    parseEntity(scanner: IScanner, curr: DxfGroup): DxfEntity;
+}

package/dist/parser/entities/attdef.js

@@ -0,0 +1,86 @@
+import * as helpers from '../parse-helpers.js';
+export default class AttDef {
+    static ForEntityName = 'ATTDEF';
+    parseEntity(scanner, curr) {
+        const entity = {
+            type: curr.value,
+            scale: 1,
+            textStyle: 'STANDARD',
+        };
+        curr = scanner.next();
+        while (true) {
+            if (curr.code === 0) {
+                break;
+            }
+            switch (curr.code) {
+                case 1:
+                    entity.text = curr.value;
+                    break;
+                case 2:
+                    entity.tag = curr.value;
+                    break;
+                case 3:
+                    entity.prompt = curr.value;
+                    break;
+                case 7:
+                    entity.textStyle = curr.value;
+                    break;
+                case 10: // X coordinate of 'first alignment point'
+                    entity.startPoint = helpers.parsePoint(scanner);
+                    break;
+                case 11: // X coordinate of 'second alignment point'
+                    entity.endPoint = helpers.parsePoint(scanner);
+                    break;
+                case 39:
+                    entity.thickness = curr.value;
+                    break;
+                case 40:
+                    entity.textHeight = curr.value;
+                    break;
+                case 41:
+                    entity.scale = curr.value;
+                    break;
+                case 50:
+                    entity.rotation = curr.value;
+                    break;
+                case 51:
+                    entity.obliqueAngle = curr.value;
+                    break;
+                case 70:
+                    entity.hidden = !!(curr.value & 0x01);
+                    entity.constant = !!(curr.value & 0x02);
+                    entity.verificationRequired = !!(curr.value & 0x04);
+                    entity.preset = !!(curr.value & 0x08);
+                    break;
+                case 71:
+                    entity.backwards = !!(curr.value & 0x02);
+                    entity.mirrored = !!(curr.value & 0x04);
+                    break;
+                case 72:
+                    // TODO: enum values?
+                    entity.horizontalJustification = curr.value;
+                    break;
+                case 73:
+                    entity.fieldLength = curr.value;
+                    break;
+                case 74:
+                    // TODO: enum values?
+                    entity.verticalJustification = curr.value;
+                    break;
+                case 100:
+                    break;
+                case 101:
+                    helpers.skipEmbeddedObject(scanner);
+                    break;
+                case 210:
+                    entity.extrusionDirection = helpers.parsePoint(scanner);
+                    break;
+                default:
+                    helpers.checkCommonEntityProperties(entity, curr, scanner);
+                    break;
+            }
+            curr = scanner.next();
+        }
+        return entity;
+    }
+}

package/dist/parser/entities/attribute.d.ts

@@ -0,0 +1,5 @@
+import { DxfEntity, DxfGroup, IEntityParser, IScanner } from '../types.js';
+export default class Attribute implements IEntityParser {
+    static ForEntityName: string;
+    parseEntity(scanner: IScanner, curr: DxfGroup): DxfEntity;
+}

package/dist/parser/entities/attribute.js

@@ -0,0 +1,106 @@
+import * as helpers from '../parse-helpers.js';
+export default class Attribute {
+    static ForEntityName = 'ATTRIB';
+    parseEntity(scanner, curr) {
+        const entity = {
+            type: curr.value,
+            scale: 1,
+            textStyle: 'STANDARD',
+        };
+        curr = scanner.next();
+        while (true) {
+            if (curr.code === 0) {
+                break;
+            }
+            switch (curr.code) {
+                case 1:
+                    entity.text = curr.value;
+                    break;
+                case 2:
+                    entity.tag = curr.value;
+                    break;
+                case 3:
+                    entity.prompt = curr.value;
+                    break;
+                case 7:
+                    entity.textStyle = curr.value;
+                    break;
+                case 10: // X coordinate of 'first alignment point'
+                    entity.startPoint = helpers.parsePoint(scanner);
+                    break;
+                case 11: // X coordinate of 'second alignment point'
+                    entity.endPoint = helpers.parsePoint(scanner);
+                    break;
+                case 39:
+                    entity.thickness = curr.value;
+                    break;
+                case 40:
+                    entity.textHeight = curr.value;
+                    break;
+                case 41:
+                    entity.scale = curr.value;
+                    break;
+                case 44:
+                    entity.lineSpacingFactor = curr.value;
+                    break;
+                case 45:
+                    entity.fillBoxScale = curr.value;
+                    break;
+                case 46:
+                    entity.annotationHeight = curr.value;
+                    break;
+                case 50:
+                    entity.rotation = curr.value;
+                    break;
+                case 51:
+                    entity.obliqueAngle = curr.value;
+                    break;
+                case 63:
+                    entity.backgroundFillColor = curr.value;
+                    break;
+                case 70:
+                    entity.hidden = !!(curr.value & 0x01);
+                    entity.constant = !!(curr.value & 0x02);
+                    entity.verificationRequired = !!(curr.value & 0x04);
+                    entity.preset = !!(curr.value & 0x08);
+                    break;
+                case 71:
+                    entity.attachmentPoint = curr.value;
+                    break;
+                case 72:
+                    entity.horizontalJustification = curr.value;
+                    break;
+                case 73:
+                    entity.lineSpacing = curr.value;
+                    break;
+                case 74:
+                    entity.verticalJustification = curr.value;
+                    break;
+                case 90:
+                    // TODO:: enum
+                    // 0 = Background fill off
+                    // 1 = Use background fill color
+                    // 2 = Use drawing window color as background fill color
+                    // and 420 ~ 439 background color check
+                    entity.backgroundFillSetting = curr.value;
+                    break;
+                case 100:
+                    break;
+                case 210:
+                    entity.extrusionDirection = helpers.parsePoint(scanner);
+                    break;
+                case 280:
+                    entity.lockPositionFlag = curr.value;
+                    break;
+                case 340:
+                    entity.hardPointerId = curr.value;
+                    break;
+                default:
+                    helpers.checkCommonEntityProperties(entity, curr, scanner);
+                    break;
+            }
+            curr = scanner.next();
+        }
+        return entity;
+    }
+}

package/dist/parser/entities/circle.d.ts

@@ -0,0 +1,5 @@
+import { DxfEntity, DxfGroup, IEntityParser, IScanner } from '../types.js';
+export default class Circle implements IEntityParser {
+    static ForEntityName: string;
+    parseEntity(scanner: IScanner, curr: DxfGroup): DxfEntity;
+}

package/dist/parser/entities/circle.js

@@ -0,0 +1,40 @@
+import * as helpers from '../parse-helpers.js';
+export default class Circle {
+    static ForEntityName = 'CIRCLE';
+    parseEntity(scanner, curr) {
+        const entity = { type: curr.value };
+        let endAngle;
+        curr = scanner.next();
+        while (true) {
+            if (curr.code === 0)
+                break;
+            switch (curr.code) {
+                case 10: // X coordinate of point
+                    entity.center = helpers.parsePoint(scanner);
+                    break;
+                case 40: // radius
+                    entity.radius = curr.value;
+                    break;
+                case 50: // start angle
+                    entity.startAngle = Math.PI / 180 * curr.value;
+                    break;
+                case 51: // end angle
+                    endAngle = Math.PI / 180 * curr.value;
+                    if (endAngle < entity.startAngle)
+                        entity.angleLength = endAngle + 2 * Math.PI - entity.startAngle;
+                    else
+                        entity.angleLength = endAngle - entity.startAngle;
+                    entity.endAngle = endAngle;
+                    break;
+                case 210:
+                    entity.extrusionDirection = helpers.parsePoint(scanner);
+                    break;
+                default: // ignored attribute
+                    helpers.checkCommonEntityProperties(entity, curr, scanner);
+                    break;
+            }
+            curr = scanner.next();
+        }
+        return entity;
+    }
+}

package/dist/parser/entities/dimension.d.ts

@@ -0,0 +1,5 @@
+import { DxfEntity, DxfGroup, IEntityParser, IScanner } from '../types.js';
+export default class Dimension implements IEntityParser {
+    static ForEntityName: string;
+    parseEntity(scanner: IScanner, curr: DxfGroup): DxfEntity;
+}

package/dist/parser/entities/dimension.js

@@ -0,0 +1,65 @@
+import * as helpers from '../parse-helpers.js';
+export default class Dimension {
+    static ForEntityName = 'DIMENSION';
+    parseEntity(scanner, curr) {
+        const entity = { type: curr.value };
+        curr = scanner.next();
+        while (true) {
+            if (curr.code === 0)
+                break;
+            switch (curr.code) {
+                case 2: // Referenced block name
+                    entity.block = curr.value;
+                    break;
+                case 3: // Dimension style name
+                    entity.styleName = curr.value;
+                    break;
+                case 10: // X coordinate of 'first alignment point'
+                    entity.anchorPoint = helpers.parsePoint(scanner);
+                    break;
+                case 11:
+                    entity.middleOfText = helpers.parsePoint(scanner);
+                    break;
+                case 12: // Insertion point for clones of a dimension
+                    entity.insertionPoint = helpers.parsePoint(scanner);
+                    break;
+                case 13: // Definition point for linear and angular dimensions
+                    entity.linearOrAngularPoint1 = helpers.parsePoint(scanner);
+                    break;
+                case 14: // Definition point for linear and angular dimensions
+                    entity.linearOrAngularPoint2 = helpers.parsePoint(scanner);
+                    break;
+                case 15: // Definition point for diameter, radius, and angular dimensions
+                    entity.diameterOrRadiusPoint = helpers.parsePoint(scanner);
+                    break;
+                case 16: // Point defining dimension arc for angular dimensions
+                    entity.arcPoint = helpers.parsePoint(scanner);
+                    break;
+                case 70: // Dimension type
+                    entity.dimensionType = curr.value;
+                    break;
+                case 71: // 5 = Middle center
+                    entity.attachmentPoint = curr.value;
+                    break;
+                case 42: // Actual measurement
+                    entity.actualMeasurement = curr.value;
+                    break;
+                case 1: // Text entered by user explicitly
+                    entity.text = curr.value;
+                    break;
+                case 50: // Angle of rotated, horizontal, or vertical dimensions
+                    entity.angle = curr.value;
+                    break;
+                case 53: // Rotation angle of the dimension text away from its default orientation (the
+                    //direction of the dimension line)
+                    entity.textRotation = curr.value;
+                    break;
+                default: // check common entity attributes
+                    helpers.checkCommonEntityProperties(entity, curr, scanner);
+                    break;
+            }
+            curr = scanner.next();
+        }
+        return entity;
+    }
+}

package/dist/parser/entities/ellipse.d.ts

@@ -0,0 +1,5 @@
+import { DxfEntity, DxfGroup, IEntityParser, IScanner } from '../types.js';
+export default class Ellipse implements IEntityParser {
+    static ForEntityName: string;
+    parseEntity(scanner: IScanner, curr: DxfGroup): DxfEntity;
+}

package/dist/parser/entities/ellipse.js

@@ -0,0 +1,42 @@
+import * as helpers from '../parse-helpers.js';
+export default class Ellipse {
+    static ForEntityName = 'ELLIPSE';
+    parseEntity(scanner, curr) {
+        const entity = { type: curr.value };
+        curr = scanner.next();
+        while (true) {
+            if (curr.code === 0)
+                break;
+            switch (curr.code) {
+                case 10:
+                    entity.center = helpers.parsePoint(scanner);
+                    break;
+                case 11:
+                    entity.majorAxisEndPoint = helpers.parsePoint(scanner);
+                    break;
+                case 40:
+                    entity.axisRatio = curr.value;
+                    break;
+                case 41:
+                    /* Already in radians. */
+                    entity.startAngle = curr.value;
+                    break;
+                case 42:
+                    /* Already in radians. */
+                    entity.endAngle = curr.value;
+                    break;
+                case 2:
+                    entity.name = curr.value;
+                    break;
+                case 210:
+                    entity.extrusionDirection = helpers.parsePoint(scanner);
+                    break;
+                default: // check common entity attributes
+                    helpers.checkCommonEntityProperties(entity, curr, scanner);
+                    break;
+            }
+            curr = scanner.next();
+        }
+        return entity;
+    }
+}

package/dist/parser/entities/hatch.d.ts

@@ -0,0 +1,5 @@
+import { DxfEntity, DxfGroup, IEntityParser, IScanner } from '../types.js';
+export default class Hatch implements IEntityParser {
+    static ForEntityName: string;
+    parseEntity(scanner: IScanner, curr: DxfGroup): DxfEntity;
+}