fl-web-component 2.0.19-beta.3 → 2.1.1-beta.0

package/src/utils/dxf-parser/ExtendedDataParser.js

@@ -0,0 +1,117 @@
+import log from "loglevel"
+
+
+export default class ExtendedDataParser {
+
+    constructor() {
+        this.appName = null
+        this.appNameWarningShown = false
+        this.lastString = null
+        this.sectionStack = [this._CreateSection()]
+        this.failure = false
+    }
+
+    /**
+     * Feed next token.
+     * @return {boolean} 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 (entity.hasOwnProperty("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/src/utils/dxf-parser/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 GDS Storefront Estimating
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/src/utils/dxf-parser/ParseHelpers.js

@@ -0,0 +1,140 @@
+import AUTO_CAD_COLOR_INDEX from "./AutoCadColorIndex.js";
+import ExtendedDataParser from "./ExtendedDataParser.js";
+
+/**
+ * Returns the truecolor value of the given AutoCad color index value
+ * @return {Number} 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.
+ * @param {*} scanner
+ */
+export function parsePoint(scanner) {
+    var point = {};
+
+    // Reread group for the first coordinate
+    scanner.rewind();
+    var curr = scanner.next();
+
+    var 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.
+ * @param scanner
+ */
+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;
+}

package/src/utils/dxf-parser/README.md

@@ -0,0 +1,8 @@
+It is a fork of https://github.com/gdsestimating/dxf-parser. We need it to make some improvements
+over the original code:
+ * Support additional DXF groups.
+ * Stream parsing - parse text as it is fetched without buffering. This allows parsing huge files
+   with limited memory consumption.
+ * Result filtering - do not include data which is not needed on further processing steps, filtering
+   it on-the-fly, thus minimizing memory consumption even more.
+ * Additional features support (e.g. hatching).

package/src/utils/dxf-parser/entities/3dface.js

@@ -0,0 +1,83 @@
+
+import * as helpers from "../ParseHelpers.js"
+
+export default function EntityParser() {}
+
+EntityParser.ForEntityName = '3DFACE';
+
+EntityParser.prototype.parseEntity = function(scanner, curr) {
+
+    var entity = { type: curr.value, vertices: [] };
+    curr = scanner.next();
+    while (curr !== 'EOF') {
+        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) {
+    var vertices = [],
+        i;
+    var vertexIsStarted = false;
+    var vertexIsFinished = false;
+    var verticesPer3dFace = 4; // there can be up to four vertices per face, although 3 is most used for TIN
+
+    for (i = 0; i <= verticesPer3dFace; i++) {
+        var vertex = {};
+        while (curr !== 'EOF') {
+            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;
+                continue;
+            }
+            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/src/utils/dxf-parser/entities/arc.js

@@ -0,0 +1,38 @@
+
+import * as helpers from "../ParseHelpers.js"
+
+export default function EntityParser() {}
+
+EntityParser.ForEntityName = 'ARC';
+
+EntityParser.prototype.parseEntity = function(scanner, curr) {
+    var entity, endAngle;
+    entity = { type: curr.value };
+    curr = scanner.next();
+    while(curr !== 'EOF') {
+        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/src/utils/dxf-parser/entities/attdef.js

@@ -0,0 +1,89 @@
+import * as helpers from "../ParseHelpers.js";
+
+export default function EntityParser() {}
+
+EntityParser.ForEntityName = 'ATTDEF';
+
+EntityParser.prototype.parseEntity = function (scanner, curr) {
+    var entity = {
+        type: curr.value,
+        scale: 1,
+        textStyle: 'STANDARD',
+    };
+    curr = scanner.next();
+    while (curr !== 'EOF') {
+        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/src/utils/dxf-parser/entities/attribute.js

@@ -0,0 +1,109 @@
+import * as helpers from "../ParseHelpers.js";
+
+export default function EntityParser() {}
+
+EntityParser.ForEntityName = 'ATTRIB';
+
+EntityParser.prototype.parseEntity = function (scanner, curr) {
+    var entity = {
+        type: curr.value,
+        scale: 1,
+        textStyle: 'STANDARD',
+    };
+    curr = scanner.next();
+    while (curr !== 'EOF') {
+        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/src/utils/dxf-parser/entities/circle.js

@@ -0,0 +1,43 @@
+
+import * as helpers from "../ParseHelpers.js"
+
+export default function EntityParser() {}
+
+EntityParser.ForEntityName = 'CIRCLE';
+
+EntityParser.prototype.parseEntity = function(scanner, curr) {
+    var entity, endAngle;
+    entity = { type: curr.value };
+    curr = scanner.next();
+    while(curr !== 'EOF') {
+        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;
+};