@vitrosoftware/common-ui-ts 1.1.122 → 1.1.124

package/lib/dxf-viewer/parser/ExtendedDataParse-My.js

@@ -0,0 +1,91 @@
+//import log from "loglevel"
+
+
+export default class ExtendedDataParser {
+
+    constructor() {
+        this.appName = null
+        this.appNameWarningShown = false
+        this.lastString = null
+        this.sectionStack = []
+        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
+                //vitrolog.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
+        }
+
+        const curSection = this._currentSection
+
+        if (curr.code == 1002) {
+            if (curr.value == "{") {
+                const newSection = this._CreateSection()
+                this.sectionStack.push(newSection)
+                return false
+            }
+            if (curr.value == "}") {
+                return false
+            }
+            //vitrolog.warn("Bad XDATA section control string encountered: " + curr.value)
+            this.failure = true
+            return false
+        }
+
+        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
+        }
+    }
+
+    get _currentSection() {
+        return this.sectionStack[this.sectionStack.length - 1]
+    }
+
+    _CreateSection() {
+        return {
+            values: []
+        }
+    }
+
+    _CreateValue(code, value) {
+        return { code, value }
+    }
+}

package/lib/dxf-viewer/parser/ExtendedDataParser.js

@@ -0,0 +1,123 @@
+//import log from "loglevel"
+
+
+export default class ExtendedDataParser {
+
+    constructor() {
+        this.appName = null
+        this.appNameWarningShown = false
+        this.lastString = null
+        this.lastIndex = 1
+        this.sectionFinished = true
+        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
+                //vitrolog.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 (this.sectionFinished) {
+            if (curr.code == 1000) {
+                if (this.lastString) {
+                    //vitrolog.warn("XDATA section unused string: " + this.lastString)
+                }
+                this.lastString = curr.value
+                return false
+            }
+        }
+ 
+        const curSection = this._currentSection
+
+        if (curr.code == 1002) {
+            if (curr.value == "{") {
+                this.sectionFinished = false
+                if (!this.lastString) {
+                    //vitrolog.warn("Unnamed XDATA section encountered")
+                    this.lastString = this.lastIndex
+                }
+                const newSection = this._CreateSection()
+                curSection[this.lastString] = newSection
+                this.lastString = null
+                this.sectionStack.push(newSection)
+                return false
+            }
+            if (curr.value == "}") {
+                this.sectionFinished = true
+                if (this.sectionStack.length < 2) {
+                    //vitrolog.warn("Unmatched XDATA section closing")
+                    this.failure = true
+                    return false
+                }
+                this.sectionStack.length = this.sectionStack.length - 1
+                this.lastIndex++
+                return false
+            }
+            //vitrolog.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/lib/dxf-viewer/parser/ParseHelpers.js

@@ -0,0 +1,142 @@
+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) {
+    if (!scanner) {
+        return;
+    }
+    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.visible = curr.value === 0;
+            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/lib/dxf-viewer/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/lib/dxf-viewer/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/lib/dxf-viewer/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.invisible = !!(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/lib/dxf-viewer/parser/entities/attrib.js

@@ -0,0 +1,34 @@
+
+import * as attdef  from './attdef.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 72: // Horizontal alignment
+            entity.halign = curr.value;
+            break;
+        case 74: // Vertical alignment
+            entity.valign = curr.value;
+            break;
+        default:
+            attdef.checkAttProperties(entity, scanner, curr);
+            break;
+        }
+        curr = scanner.next();
+    }
+
+    return entity;
+};