ofs-dxf-ts 1.0.0

package/dist/parser/entities/polyline.js

@@ -0,0 +1,85 @@
+import * as helpers from '../parse-helpers.js';
+import VertexParser from './vertex.js';
+export default class Polyline {
+    static ForEntityName = 'POLYLINE';
+    parseEntity(scanner, curr) {
+        const entity = { type: curr.value, vertices: [] };
+        curr = scanner.next();
+        while (true) {
+            if (curr.code === 0)
+                break;
+            switch (curr.code) {
+                case 10: // always 0
+                    break;
+                case 20: // always 0
+                    break;
+                case 30: // elevation
+                    break;
+                case 39: // thickness
+                    entity.thickness = curr.value;
+                    break;
+                case 40: // start width
+                    break;
+                case 41: // end width
+                    break;
+                case 70:
+                    entity.shape = (curr.value & 1) !== 0;
+                    entity.includesCurveFitVertices = (curr.value & 2) !== 0;
+                    entity.includesSplineFitVertices = (curr.value & 4) !== 0;
+                    entity.is3dPolyline = (curr.value & 8) !== 0;
+                    entity.is3dPolygonMesh = (curr.value & 16) !== 0;
+                    entity.is3dPolygonMeshClosed = (curr.value & 32) !== 0; // 32 = The polygon mesh is closed in the N direction
+                    entity.isPolyfaceMesh = (curr.value & 64) !== 0;
+                    entity.hasContinuousLinetypePattern = (curr.value & 128) !== 0;
+                    break;
+                case 71: // Polygon mesh M vertex count
+                    break;
+                case 72: // Polygon mesh N vertex count
+                    break;
+                case 73: // Smooth surface M density
+                    break;
+                case 74: // Smooth surface N density
+                    break;
+                case 75: // Curves and smooth surface type
+                    break;
+                case 210:
+                    entity.extrusionDirection = helpers.parsePoint(scanner);
+                    break;
+                default:
+                    helpers.checkCommonEntityProperties(entity, curr, scanner);
+                    break;
+            }
+            curr = scanner.next();
+        }
+        entity.vertices = parsePolylineVertices(scanner, curr);
+        return entity;
+    }
+}
+function parsePolylineVertices(scanner, curr) {
+    const vertexParser = new VertexParser();
+    const vertices = [];
+    while (!scanner.isEOF()) {
+        if (curr.code === 0) {
+            if (curr.value === 'VERTEX') {
+                vertices.push(vertexParser.parseEntity(scanner, curr));
+                curr = scanner.lastReadGroup;
+            }
+            else if (curr.value === 'SEQEND') {
+                parseSeqEnd(scanner, curr);
+                break;
+            }
+        }
+    }
+    return vertices;
+}
+function parseSeqEnd(scanner, curr) {
+    const entity = { type: curr.value };
+    curr = scanner.next();
+    while (true) {
+        if (curr.code == 0)
+            break;
+        helpers.checkCommonEntityProperties(entity, curr, scanner);
+        curr = scanner.next();
+    }
+    return entity;
+}

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

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

package/dist/parser/entities/solid.js

@@ -0,0 +1,35 @@
+import * as helpers from '../parse-helpers.js';
+export default class Solid {
+    static ForEntityName = 'SOLID';
+    parseEntity(scanner, currentGroup) {
+        const entity = { type: currentGroup.value };
+        entity.points = [];
+        currentGroup = scanner.next();
+        while (true) {
+            if (currentGroup.code === 0)
+                break;
+            switch (currentGroup.code) {
+                case 10:
+                    entity.points[0] = helpers.parsePoint(scanner);
+                    break;
+                case 11:
+                    entity.points[1] = helpers.parsePoint(scanner);
+                    break;
+                case 12:
+                    entity.points[2] = helpers.parsePoint(scanner);
+                    break;
+                case 13:
+                    entity.points[3] = helpers.parsePoint(scanner);
+                    break;
+                case 210:
+                    entity.extrusionDirection = helpers.parsePoint(scanner);
+                    break;
+                default: // check common entity attributes
+                    helpers.checkCommonEntityProperties(entity, currentGroup, scanner);
+                    break;
+            }
+            currentGroup = scanner.next();
+        }
+        return entity;
+    }
+}

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

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

package/dist/parser/entities/spline.js

@@ -0,0 +1,69 @@
+import * as helpers from '../parse-helpers.js';
+export default class Spline {
+    static ForEntityName = 'SPLINE';
+    parseEntity(scanner, curr) {
+        const entity = { type: curr.value };
+        curr = scanner.next();
+        while (true) {
+            if (curr.code === 0)
+                break;
+            switch (curr.code) {
+                case 10:
+                    if (!entity.controlPoints)
+                        entity.controlPoints = [];
+                    entity.controlPoints.push(helpers.parsePoint(scanner));
+                    break;
+                case 11:
+                    if (!entity.fitPoints)
+                        entity.fitPoints = [];
+                    entity.fitPoints.push(helpers.parsePoint(scanner));
+                    break;
+                case 12:
+                    entity.startTangent = helpers.parsePoint(scanner);
+                    break;
+                case 13:
+                    entity.endTangent = helpers.parsePoint(scanner);
+                    break;
+                case 40:
+                    if (!entity.knotValues)
+                        entity.knotValues = [];
+                    entity.knotValues.push(curr.value);
+                    break;
+                case 70:
+                    if ((curr.value & 1) != 0)
+                        entity.closed = true;
+                    if ((curr.value & 2) != 0)
+                        entity.periodic = true;
+                    if ((curr.value & 4) != 0)
+                        entity.rational = true;
+                    if ((curr.value & 8) != 0)
+                        entity.planar = true;
+                    if ((curr.value & 16) != 0) {
+                        entity.planar = true;
+                        entity.linear = true;
+                    }
+                    break;
+                case 71:
+                    entity.degreeOfSplineCurve = curr.value;
+                    break;
+                case 72:
+                    entity.numberOfKnots = curr.value;
+                    break;
+                case 73:
+                    entity.numberOfControlPoints = curr.value;
+                    break;
+                case 74:
+                    entity.numberOfFitPoints = curr.value;
+                    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/text.d.ts

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

package/dist/parser/entities/text.js

@@ -0,0 +1,47 @@
+import * as helpers from '../parse-helpers.js';
+export default class Text {
+    static ForEntityName = 'TEXT';
+    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 'first alignment point'
+                    entity.startPoint = helpers.parsePoint(scanner);
+                    break;
+                case 11: // X coordinate of 'second alignment point'
+                    entity.endPoint = helpers.parsePoint(scanner);
+                    break;
+                case 40: // Text height
+                    entity.textHeight = curr.value;
+                    break;
+                case 41:
+                    entity.xScale = curr.value;
+                    break;
+                case 50: // Rotation in degrees
+                    entity.rotation = curr.value;
+                    break;
+                case 7: // Text style name
+                    entity.styleName = curr.value;
+                    break;
+                case 1: // Text
+                    entity.text = curr.value;
+                    break;
+                // NOTE: 72 and 73 are meaningless without 11 (second alignment point)
+                case 72: // Horizontal alignment
+                    entity.halign = curr.value;
+                    break;
+                case 73: // Vertical alignment
+                    entity.valign = curr.value;
+                    break;
+                default: // check common entity attributes
+                    helpers.checkCommonEntityProperties(entity, curr, scanner);
+                    break;
+            }
+            curr = scanner.next();
+        }
+        return entity;
+    }
+}

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

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

package/dist/parser/entities/vertex.js

@@ -0,0 +1,59 @@
+import * as helpers from '../parse-helpers.js';
+export default class Vertex {
+    static ForEntityName = 'VERTEX';
+    parseEntity(scanner, curr) {
+        const entity = { type: curr.value };
+        curr = scanner.next();
+        while (true) {
+            if (curr.code === 0)
+                break;
+            switch (curr.code) {
+                case 10: // X
+                    entity.x = curr.value;
+                    break;
+                case 20: // Y
+                    entity.y = curr.value;
+                    break;
+                case 30: // Z
+                    entity.z = curr.value;
+                    break;
+                case 40: // start width
+                    break;
+                case 41: // end width
+                    break;
+                case 42: // bulge
+                    if (curr.value != 0)
+                        entity.bulge = curr.value;
+                    break;
+                case 70: // flags
+                    entity.curveFittingVertex = (curr.value & 1) !== 0;
+                    entity.curveFitTangent = (curr.value & 2) !== 0;
+                    entity.splineVertex = (curr.value & 8) !== 0;
+                    entity.splineControlPoint = (curr.value & 16) !== 0;
+                    entity.threeDPolylineVertex = (curr.value & 32) !== 0;
+                    entity.threeDPolylineMesh = (curr.value & 64) !== 0;
+                    entity.polyfaceMeshVertex = (curr.value & 128) !== 0;
+                    break;
+                case 50: // curve fit tangent direction
+                    break;
+                case 71: // polyface mesh vertex index
+                    entity.faces = [curr.value];
+                    break;
+                case 72: // polyface mesh vertex index
+                    entity.faces[1] = curr.value;
+                    break;
+                case 73: // polyface mesh vertex index
+                    entity.faces[2] = curr.value;
+                    break;
+                case 74: // polyface mesh vertex index
+                    entity.faces[3] = curr.value;
+                    break;
+                default:
+                    helpers.checkCommonEntityProperties(entity, curr, scanner);
+                    break;
+            }
+            curr = scanner.next();
+        }
+        return entity;
+    }
+}

package/dist/parser/extended-data-parser.d.ts

@@ -0,0 +1,18 @@
+import { DxfEntity, DxfGroup } from './types.js';
+export default class ExtendedDataParser {
+    private appName;
+    private appNameWarningShown;
+    private lastString;
+    private sectionStack;
+    private failure;
+    /**
+     * Feed next token.
+     * @return True if new parser instance should be created for this token.
+     */
+    Feed(curr: DxfGroup): boolean;
+    /** Finalize XDATA section parsing. */
+    Finish(entity: DxfEntity): void;
+    private get _currentSection();
+    private _CreateSection;
+    private _CreateValue;
+}

package/dist/parser/extended-data-parser.js

@@ -0,0 +1,100 @@
+import log from './log.js';
+export default class ExtendedDataParser {
+    appName = null;
+    appNameWarningShown = false;
+    lastString = null;
+    sectionStack = [this._CreateSection()];
+    failure = false;
+    /**
+     * Feed next token.
+     * @return True if new parser instance should be created for this token.
+     */
+    Feed(curr) {
+        if (!this.appName) {
+            if (curr.code === 1001) {
+                this.appName = curr.value;
+                return false;
+            }
+            if (!this.appNameWarningShown) {
+                this.appNameWarningShown = true;
+                log.warn('XDATA section does not start with application name');
+            }
+            return false;
+        }
+        if (curr.code === 1001) {
+            return true;
+        }
+        if (this.failure) {
+            /* Ignore all the rest content in case of parsing failure. */
+            return false;
+        }
+        if (curr.code === 1000) {
+            if (this.lastString) {
+                log.warn('XDATA section unused string: ' + this.lastString);
+            }
+            this.lastString = curr.value;
+            return false;
+        }
+        const curSection = this._currentSection;
+        if (curr.code === 1002) {
+            if (curr.value === '{') {
+                if (!this.lastString) {
+                    log.warn('Unnamed XDATA section encountered');
+                    this.failure = true;
+                    return false;
+                }
+                const newSection = this._CreateSection();
+                curSection[this.lastString] = newSection;
+                this.lastString = null;
+                this.sectionStack.push(newSection);
+                return false;
+            }
+            if (curr.value === '}') {
+                if (this.sectionStack.length < 2) {
+                    log.warn('Unmatched XDATA section closing');
+                    this.failure = true;
+                    return false;
+                }
+                this.sectionStack.length = this.sectionStack.length - 1;
+                return false;
+            }
+            log.warn('Bad XDATA section control string encountered: ' + curr.value);
+            this.failure = true;
+            return false;
+        }
+        if (this.lastString !== null) {
+            curSection.values.push(this._CreateValue(1000, this.lastString));
+            this.lastString = null;
+        }
+        curSection.values.push(this._CreateValue(curr.code, curr.value));
+        return false;
+    }
+    /** Finalize XDATA section parsing. */
+    Finish(entity) {
+        if (this.failure) {
+            return;
+        }
+        if (this.appName) {
+            let xdata;
+            if (Object.prototype.hasOwnProperty.call(entity, 'xdata')) {
+                xdata = entity.xdata;
+            }
+            else {
+                xdata = {};
+                entity.xdata = xdata;
+            }
+            xdata[this.appName] = this.sectionStack[0];
+        }
+    }
+    get _currentSection() {
+        return this.sectionStack[this.sectionStack.length - 1];
+    }
+    _CreateSection() {
+        return {
+            values: [],
+        };
+    }
+    _CreateValue(code, value) {
+        return { code, value };
+    }
+}

package/dist/parser/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Internal DXF parser — TypeScript port of the `dxf-parser` npm package
+ * (MIT-licensed, original JS source kept in parser-raw/ for reference).
+ * Replaces the external dependency so the library stays dependency-light
+ * and fully browser-compatible.
+ */
+export { default as DxfParser } from './dxf-parser.js';
+export { default as DxfArrayScanner } from './scanner.js';
+export * as ParseHelpers from './parse-helpers.js';
+export type { DxfGroup, DxfPoint, DxfEntity, DxfBlock, ParsedDxf, GroupValue, IScanner, IEntityParser, IEntityParserType, } from './types.js';

package/dist/parser/index.js

@@ -0,0 +1,9 @@
+/**
+ * Internal DXF parser — TypeScript port of the `dxf-parser` npm package
+ * (MIT-licensed, original JS source kept in parser-raw/ for reference).
+ * Replaces the external dependency so the library stays dependency-light
+ * and fully browser-compatible.
+ */
+export { default as DxfParser } from './dxf-parser.js';
+export { default as DxfArrayScanner } from './scanner.js';
+export * as ParseHelpers from './parse-helpers.js';

package/dist/parser/log.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Minimal internal logger replacing the `loglevel` dependency of the original
+ * dxf-parser. Default level is 'error', matching the original's
+ * `log.setLevel('error')`, so debug/info/warn output stays suppressed.
+ */
+export type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'silent';
+declare const log: {
+    setLevel(level: LogLevel): void;
+    debug(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+};
+export default log;

package/dist/parser/log.js

@@ -0,0 +1,39 @@
+/**
+ * Minimal internal logger replacing the `loglevel` dependency of the original
+ * dxf-parser. Default level is 'error', matching the original's
+ * `log.setLevel('error')`, so debug/info/warn output stays suppressed.
+ */
+const LEVEL_ORDER = {
+    trace: 0,
+    debug: 1,
+    info: 2,
+    warn: 3,
+    error: 4,
+    silent: 5,
+};
+let currentLevel = 'error';
+function enabled(level) {
+    return LEVEL_ORDER[level] >= LEVEL_ORDER[currentLevel];
+}
+const log = {
+    setLevel(level) {
+        currentLevel = level;
+    },
+    debug(...args) {
+        if (enabled('debug'))
+            console.debug(...args);
+    },
+    info(...args) {
+        if (enabled('info'))
+            console.info(...args);
+    },
+    warn(...args) {
+        if (enabled('warn'))
+            console.warn(...args);
+    },
+    error(...args) {
+        if (enabled('error'))
+            console.error(...args);
+    },
+};
+export default log;

package/dist/parser/parse-helpers.d.ts

@@ -0,0 +1,23 @@
+import { DxfEntity, DxfGroup, DxfPoint, IScanner } from './types.js';
+/**
+ * Returns the truecolor value of the given AutoCad color index value
+ * @return truecolor value as a number
+ */
+export declare function getAcadColor(index: number): number;
+/**
+ * Parses the 2D or 3D coordinate, vector, or point. When complete,
+ * the scanner remains on the last group of the coordinate.
+ */
+export declare function parsePoint(scanner: IScanner): DxfPoint;
+/** Some entities may contain embedded object which is started by group 101. All the rest data until
+ * end of entity should not be interpreted as entity attributes. There is no documentation for this
+ * feature.
+ */
+export declare function skipEmbeddedObject(scanner: IScanner): void;
+/**
+ * Attempts to parse codes common to all entities. Returns true if the group
+ * was handled by this function.
+ * @param entity - the entity currently being parsed
+ * @param curr - the current group being parsed
+ */
+export declare function checkCommonEntityProperties(entity: DxfEntity, curr: DxfGroup, scanner: IScanner): boolean;

package/dist/parser/parse-helpers.js

@@ -0,0 +1,128 @@
+import AUTO_CAD_COLOR_INDEX from './auto-cad-color-index.js';
+import ExtendedDataParser from './extended-data-parser.js';
+/**
+ * Returns the truecolor value of the given AutoCad color index value
+ * @return truecolor value as a number
+ */
+export function getAcadColor(index) {
+    return AUTO_CAD_COLOR_INDEX[index];
+}
+/**
+ * Parses the 2D or 3D coordinate, vector, or point. When complete,
+ * the scanner remains on the last group of the coordinate.
+ */
+export function parsePoint(scanner) {
+    const point = {};
+    // Reread group for the first coordinate
+    scanner.rewind();
+    let curr = scanner.next();
+    let code = curr.code;
+    point.x = curr.value;
+    code += 10;
+    curr = scanner.next();
+    if (curr.code !== code)
+        throw new Error('Expected code for point value to be ' + code +
+            ' but got ' + curr.code + '.');
+    point.y = curr.value;
+    code += 10;
+    curr = scanner.next();
+    if (curr.code !== code) {
+        // Only the x and y are specified. Don't read z.
+        scanner.rewind(); // Let the calling code advance off the point
+        return point;
+    }
+    point.z = curr.value;
+    return point;
+}
+/** Some entities may contain embedded object which is started by group 101. All the rest data until
+ * end of entity should not be interpreted as entity attributes. There is no documentation for this
+ * feature.
+ */
+export function skipEmbeddedObject(scanner) {
+    /* Ensure proper start group. */
+    scanner.rewind();
+    let curr = scanner.next();
+    if (curr.code !== 101) {
+        throw new Error('Bad call for skipEmbeddedObject()');
+    }
+    do {
+        curr = scanner.next();
+    } while (curr.code !== 0);
+    scanner.rewind();
+}
+/**
+ * Attempts to parse codes common to all entities. Returns true if the group
+ * was handled by this function.
+ * @param entity - the entity currently being parsed
+ * @param curr - the current group being parsed
+ */
+export function checkCommonEntityProperties(entity, curr, scanner) {
+    let xdataParser = null;
+    while (curr.code >= 1000) {
+        if (xdataParser == null) {
+            xdataParser = new ExtendedDataParser();
+        }
+        if (xdataParser.Feed(curr)) {
+            xdataParser.Finish(entity);
+            xdataParser = null;
+        }
+        else {
+            curr = scanner.next();
+        }
+    }
+    if (xdataParser) {
+        xdataParser.Finish(entity);
+        /* Groups following XDATA should be parsed on next iteration. */
+        scanner.rewind();
+        return true;
+    }
+    switch (curr.code) {
+        case 0:
+            entity.type = curr.value;
+            break;
+        case 5:
+            entity.handle = curr.value;
+            break;
+        case 6:
+            entity.lineType = curr.value;
+            break;
+        case 8: // Layer name
+            entity.layer = curr.value;
+            break;
+        case 48:
+            entity.lineTypeScale = curr.value;
+            break;
+        case 60:
+            entity.hidden = !!curr.value;
+            break;
+        case 62: // Acad Index Color. 0 inherits ByBlock. 256 inherits ByLayer. Default is bylayer
+            entity.colorIndex = curr.value;
+            entity.color = getAcadColor(Math.abs(curr.value));
+            break;
+        case 67:
+            entity.inPaperSpace = curr.value !== 0;
+            break;
+        case 100:
+            //ignore
+            break;
+        case 330:
+            entity.ownerHandle = curr.value;
+            break;
+        case 347:
+            entity.materialObjectHandle = curr.value;
+            break;
+        case 370:
+            //From https://www.woutware.com/Forum/Topic/955/lineweight?returnUrl=%2FForum%2FUserPosts%3FuserId%3D478262319
+            // An integer representing 100th of mm, must be one of the following values:
+            // 0, 5, 9, 13, 15, 18, 20, 25, 30, 35, 40, 50, 53, 60, 70, 80, 90, 100, 106, 120, 140, 158, 200, 211.
+            // -3 = STANDARD, -2 = BYLAYER, -1 = BYBLOCK
+            entity.lineweight = curr.value;
+            break;
+        case 420: // TrueColor Color
+            entity.color = curr.value;
+            break;
+        default:
+            return false;
+    }
+    return true;
+}