ofs-dxf-ts 1.0.0

package/dist/parser/entities/hatch.js

@@ -0,0 +1,321 @@
+import * as helpers from '../parse-helpers.js';
+export default class Hatch {
+    static ForEntityName = 'HATCH';
+    parseEntity(scanner, curr) {
+        const entity = { type: curr.value };
+        let numBoundaryLoops = 0;
+        let numDefinitionLines = 0;
+        let numSeedPoints = 0;
+        curr = scanner.next();
+        while (true) {
+            if (curr.code === 0)
+                break;
+            while (numBoundaryLoops > 0) {
+                const loop = ParseBoundaryLoop(curr, scanner);
+                if (loop) {
+                    entity.boundaryLoops.push(loop);
+                    numBoundaryLoops--;
+                    curr = scanner.next();
+                }
+                else {
+                    numBoundaryLoops = 0;
+                }
+            }
+            while (numDefinitionLines > 0) {
+                const line = ParseDefinitionLine(curr, scanner);
+                if (line) {
+                    entity.definitionLines.push(line);
+                    numDefinitionLines--;
+                    curr = scanner.next();
+                }
+                else {
+                    numDefinitionLines = 0;
+                }
+            }
+            while (numSeedPoints > 0) {
+                const pt = ParseSeedPoint(curr, scanner);
+                if (pt) {
+                    entity.seedPoints.push(pt);
+                    numSeedPoints--;
+                    curr = scanner.next();
+                }
+                else {
+                    numSeedPoints = 0;
+                }
+            }
+            if (curr.code === 0)
+                break;
+            switch (curr.code) {
+                case 2: // Hatch pattern name
+                    entity.patternName = curr.value;
+                    break;
+                case 70: //Solid fill flag (solid fill = 1; pattern fill = 0)
+                    entity.isSolid = curr.value != 0;
+                    break;
+                case 91: // Number of boundary paths (loops)
+                    numBoundaryLoops = curr.value;
+                    if (numBoundaryLoops > 0) {
+                        entity.boundaryLoops = [];
+                    }
+                    break;
+                // Hatch style:
+                // 0 = Hatch "odd parity" area (Normal style)
+                // 1 = Hatch outermost area only (Outer style)
+                // 2 = Hatch through entire area (Ignore style)
+                case 75:
+                    entity.hatchStyle = curr.value;
+                    break;
+                //Hatch pattern type:
+                // 0 = User-defined; 1 = Predefined; 2 = Custom
+                case 76:
+                    entity.patternType = curr.value;
+                    break;
+                case 52: // Hatch pattern angle (pattern fill only)
+                    entity.patternAngle = curr.value * Math.PI / 180;
+                    break;
+                case 41: // Hatch pattern scale or spacing (pattern fill only)
+                    entity.patternScale = curr.value;
+                    break;
+                case 78: // Number of pattern definition lines
+                    numDefinitionLines = curr.value;
+                    if (numDefinitionLines > 0) {
+                        entity.definitionLines = [];
+                    }
+                    break;
+                case 98: // Number of seed points
+                    numSeedPoints = curr.value;
+                    if (numSeedPoints > 0) {
+                        entity.seedPoints = [];
+                    }
+                    break;
+                default: // check common entity attributes
+                    helpers.checkCommonEntityProperties(entity, curr, scanner);
+                    break;
+            }
+            curr = scanner.next();
+        }
+        return entity;
+    }
+}
+function ParseBoundaryLoop(curr, scanner) {
+    let entity = null;
+    const ParsePolyline = () => {
+        const pl = { vertices: [], isClosed: false };
+        let hasBulge = false;
+        let numVertices = 0;
+        while (true) {
+            if (numVertices > 0) {
+                for (let i = 0; i < numVertices; i++) {
+                    if (curr.code != 10) {
+                        break;
+                    }
+                    const p = helpers.parsePoint(scanner);
+                    curr = scanner.next();
+                    if (curr.code == 42) {
+                        p.bulge = curr.value;
+                        curr = scanner.next();
+                    }
+                    pl.vertices.push(p);
+                }
+                return pl;
+            }
+            switch (curr.code) {
+                case 72:
+                    hasBulge = curr.value;
+                    break;
+                case 73:
+                    pl.isClosed = curr.value;
+                    break;
+                case 93:
+                    numVertices = curr.value;
+                    break;
+                default:
+                    return pl;
+            }
+            curr = scanner.next();
+        }
+    };
+    const ParseEdge = () => {
+        if (curr.code != 72) {
+            return null;
+        }
+        const e = { type: curr.value };
+        curr = scanner.next();
+        const isSpline = e.type == 4;
+        while (true) {
+            switch (curr.code) {
+                case 10:
+                    if (isSpline) {
+                        if (!e.controlPoints) {
+                            e.controlPoints = [];
+                        }
+                        e.controlPoints.push(helpers.parsePoint(scanner));
+                    }
+                    else {
+                        e.start = helpers.parsePoint(scanner);
+                    }
+                    break;
+                case 11:
+                    if (isSpline) {
+                        if (!e.fitPoints) {
+                            e.fitPoints = [];
+                        }
+                        e.fitPoints.push(helpers.parsePoint(scanner));
+                    }
+                    else {
+                        e.end = helpers.parsePoint(scanner);
+                    }
+                    break;
+                case 40:
+                    if (isSpline) {
+                        if (!e.knotValues) {
+                            e.knotValues = [];
+                        }
+                        e.knotValues.push(curr.value);
+                    }
+                    else {
+                        e.radius = curr.value;
+                    }
+                    break;
+                case 50:
+                    e.startAngle = curr.value * Math.PI / 180;
+                    break;
+                case 51:
+                    e.endAngle = curr.value * Math.PI / 180;
+                    break;
+                case 73:
+                    if (isSpline) {
+                        e.rational = curr.value;
+                    }
+                    else {
+                        e.isCcw = curr.value;
+                    }
+                    break;
+                case 74:
+                    e.periodic = curr.value;
+                    break;
+                case 94:
+                    e.degreeOfSplineCurve = curr.value;
+                    break;
+                //XXX ignore some groups for now, mostly spline
+                case 95:
+                case 96:
+                case 42:
+                case 97:
+                    break;
+                default:
+                    return e;
+            }
+            curr = scanner.next();
+        }
+    };
+    let polylineParsed = false;
+    let numEdges = 0;
+    let numSourceRefs = 0;
+    while (true) {
+        if (!entity) {
+            if (curr.code != 92) {
+                return null;
+            }
+            entity = {
+                type: curr.value,
+                isExternal: (curr.value & 1) != 0,
+                isOutermost: (curr.value & 16) != 0,
+            };
+            curr = scanner.next();
+        }
+        if ((entity.type & 2) && !polylineParsed) {
+            entity.polyline = ParsePolyline();
+            polylineParsed = true;
+        }
+        while (numEdges) {
+            const edge = ParseEdge();
+            if (edge) {
+                entity.edges.push(edge);
+                numEdges--;
+            }
+            else {
+                numEdges = 0;
+            }
+        }
+        while (numSourceRefs) {
+            if (curr.code == 330) {
+                entity.sourceRefs.push(curr.value);
+                numSourceRefs--;
+                curr = scanner.next();
+            }
+            else {
+                numSourceRefs = 0;
+            }
+        }
+        switch (curr.code) {
+            case 93:
+                numEdges = curr.value;
+                if (numEdges > 0) {
+                    entity.edges = [];
+                }
+                break;
+            case 97:
+                numSourceRefs = curr.value;
+                if (numSourceRefs > 0) {
+                    entity.sourceRefs = [];
+                }
+                break;
+            default:
+                scanner.rewind();
+                return entity;
+        }
+        curr = scanner.next();
+    }
+}
+function ParseDefinitionLine(curr, scanner) {
+    /* Assuming always starts from group 53. */
+    if (curr.code != 53) {
+        return null;
+    }
+    const entity = {
+        angle: curr.value * Math.PI / 180,
+        base: { x: 0, y: 0 },
+        offset: { x: 0, y: 0 },
+    };
+    curr = scanner.next();
+    let numDashes = 0;
+    while (true) {
+        switch (curr.code) {
+            case 43:
+                entity.base.x = curr.value;
+                break;
+            case 44:
+                entity.base.y = curr.value;
+                break;
+            case 45:
+                entity.offset.x = curr.value;
+                break;
+            case 46:
+                entity.offset.y = curr.value;
+                break;
+            case 49:
+                if (numDashes > 0) {
+                    entity.dashes.push(curr.value);
+                    numDashes--;
+                }
+                break;
+            case 79:
+                numDashes = curr.value;
+                if (curr.value) {
+                    entity.dashes = [];
+                }
+                break;
+            default:
+                scanner.rewind();
+                return entity;
+        }
+        curr = scanner.next();
+    }
+}
+function ParseSeedPoint(curr, scanner) {
+    if (curr.code != 10) {
+        return null;
+    }
+    return helpers.parsePoint(scanner);
+}

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

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

package/dist/parser/entities/insert.js

@@ -0,0 +1,52 @@
+import * as helpers from '../parse-helpers.js';
+export default class Insert {
+    static ForEntityName = 'INSERT';
+    parseEntity(scanner, curr) {
+        const entity = { type: curr.value };
+        curr = scanner.next();
+        while (true) {
+            if (curr.code === 0)
+                break;
+            switch (curr.code) {
+                case 2:
+                    entity.name = curr.value;
+                    break;
+                case 41:
+                    entity.xScale = curr.value;
+                    break;
+                case 42:
+                    entity.yScale = curr.value;
+                    break;
+                case 43:
+                    entity.zScale = curr.value;
+                    break;
+                case 10:
+                    entity.position = helpers.parsePoint(scanner);
+                    break;
+                case 50:
+                    entity.rotation = curr.value;
+                    break;
+                case 70:
+                    entity.columnCount = curr.value;
+                    break;
+                case 71:
+                    entity.rowCount = curr.value;
+                    break;
+                case 44:
+                    entity.columnSpacing = curr.value;
+                    break;
+                case 45:
+                    entity.rowSpacing = 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/line.d.ts

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

package/dist/parser/entities/line.js

@@ -0,0 +1,30 @@
+import * as helpers from '../parse-helpers.js';
+export default class Line {
+    static ForEntityName = 'LINE';
+    parseEntity(scanner, curr) {
+        const entity = { type: curr.value, vertices: [] };
+        curr = scanner.next();
+        while (true) {
+            if (curr.code === 0)
+                break;
+            switch (curr.code) {
+                case 10: // X coordinate of point
+                    entity.vertices.unshift(helpers.parsePoint(scanner));
+                    break;
+                case 11:
+                    entity.vertices.push(helpers.parsePoint(scanner));
+                    break;
+                case 210:
+                    entity.extrusionDirection = helpers.parsePoint(scanner);
+                    break;
+                case 100:
+                    break;
+                default:
+                    helpers.checkCommonEntityProperties(entity, curr, scanner);
+                    break;
+            }
+            curr = scanner.next();
+        }
+        return entity;
+    }
+}

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

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

package/dist/parser/entities/lwpolyline.js

@@ -0,0 +1,101 @@
+import * as helpers from '../parse-helpers.js';
+export default class LWPolyline {
+    static ForEntityName = 'LWPOLYLINE';
+    parseEntity(scanner, curr) {
+        const entity = { type: curr.value, vertices: [] };
+        let numberOfVertices = 0;
+        curr = scanner.next();
+        while (true) {
+            if (curr.code === 0)
+                break;
+            switch (curr.code) {
+                case 38:
+                    entity.elevation = curr.value;
+                    break;
+                case 39:
+                    entity.depth = curr.value;
+                    break;
+                case 70: // 1 = Closed shape, 128 = plinegen?, 0 = default
+                    entity.shape = ((curr.value & 1) === 1);
+                    entity.hasContinuousLinetypePattern = ((curr.value & 128) === 128);
+                    break;
+                case 90:
+                    numberOfVertices = curr.value;
+                    break;
+                case 10: // X coordinate of point
+                    entity.vertices = parseLWPolylineVertices(numberOfVertices, scanner);
+                    break;
+                case 43:
+                    if (curr.value !== 0)
+                        entity.width = curr.value;
+                    break;
+                case 210:
+                    entity.extrusionDirection = helpers.parsePoint(scanner);
+                    break;
+                default:
+                    helpers.checkCommonEntityProperties(entity, curr, scanner);
+                    break;
+            }
+            curr = scanner.next();
+        }
+        return entity;
+    }
+}
+function parseLWPolylineVertices(n, scanner) {
+    if (!n || n <= 0)
+        throw Error('n must be greater than 0 vertices');
+    const vertices = [];
+    let vertexIsStarted = false;
+    let vertexIsFinished = false;
+    let curr = scanner.lastReadGroup;
+    for (let i = 0; i < n; i++) {
+        const vertex = {};
+        while (true) {
+            if (curr.code === 0 || vertexIsFinished)
+                break;
+            switch (curr.code) {
+                case 10: // X
+                    if (vertexIsStarted) {
+                        vertexIsFinished = true;
+                        continue;
+                    }
+                    vertex.x = curr.value;
+                    vertexIsStarted = true;
+                    break;
+                case 20: // Y
+                    vertex.y = curr.value;
+                    break;
+                case 30: // Z
+                    vertex.z = curr.value;
+                    break;
+                case 40: // start width
+                    vertex.startWidth = curr.value;
+                    break;
+                case 41: // end width
+                    vertex.endWidth = curr.value;
+                    break;
+                case 42: // bulge
+                    if (curr.value != 0)
+                        vertex.bulge = curr.value;
+                    break;
+                case 91: // vertex identifier
+                    vertex.id = curr.value;
+                    break;
+                default:
+                    // if we do not hit known code return vertices.  Code might belong to entity
+                    if (vertexIsStarted) {
+                        vertices.push(vertex);
+                    }
+                    scanner.rewind();
+                    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/mtext.d.ts

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

package/dist/parser/entities/mtext.js

@@ -0,0 +1,54 @@
+import * as helpers from '../parse-helpers.js';
+export default class MText {
+    static ForEntityName = 'MTEXT';
+    parseEntity(scanner, curr) {
+        const entity = { type: curr.value };
+        curr = scanner.next();
+        while (true) {
+            if (curr.code === 0)
+                break;
+            switch (curr.code) {
+                case 3:
+                case 1:
+                    entity.text ? entity.text += curr.value : entity.text = curr.value;
+                    break;
+                case 10:
+                    entity.position = helpers.parsePoint(scanner);
+                    break;
+                case 11:
+                    entity.direction = helpers.parsePoint(scanner);
+                    break;
+                case 40:
+                    //Note: this is the text height
+                    entity.height = curr.value;
+                    break;
+                case 41:
+                    entity.width = curr.value;
+                    break;
+                case 44:
+                    entity.lineSpacing = curr.value;
+                    break;
+                case 50:
+                    entity.rotation = curr.value;
+                    break;
+                case 7: // Text style name
+                    entity.styleName = curr.value;
+                    break;
+                case 71:
+                    entity.attachmentPoint = curr.value;
+                    break;
+                case 72:
+                    entity.drawingDirection = curr.value;
+                    break;
+                case 101:
+                    helpers.skipEmbeddedObject(scanner);
+                    break;
+                default:
+                    helpers.checkCommonEntityProperties(entity, curr, scanner);
+                    break;
+            }
+            curr = scanner.next();
+        }
+        return entity;
+    }
+}

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

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

package/dist/parser/entities/point.js

@@ -0,0 +1,30 @@
+import * as helpers from '../parse-helpers.js';
+export default class Point {
+    static ForEntityName = 'POINT';
+    parseEntity(scanner, curr) {
+        const entity = { type: curr.value };
+        curr = scanner.next();
+        while (true) {
+            if (curr.code === 0)
+                break;
+            switch (curr.code) {
+                case 10:
+                    entity.position = helpers.parsePoint(scanner);
+                    break;
+                case 39:
+                    entity.thickness = curr.value;
+                    break;
+                case 210:
+                    entity.extrusionDirection = helpers.parsePoint(scanner);
+                    break;
+                case 100:
+                    break;
+                default: // check common entity attributes
+                    helpers.checkCommonEntityProperties(entity, curr, scanner);
+                    break;
+            }
+            curr = scanner.next();
+        }
+        return entity;
+    }
+}

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

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