@vitrosoftware/common-ui-ts 1.1.121 → 1.1.123

package/lib/dxf-viewer/index.js

@@ -0,0 +1,42 @@
+
+//export * from "./DxfViewer.js"
+
+
+//import * as three from "./dep/three.module.js";
+//import * as THREE from "./dep/three.module.js"
+//import "./DxfViewer.js";
+//import {Matrix3, Vector2, ShapePath, ShapeUtils} from "./dep/three.js"
+//import  "./dep/opentype.js"
+
+//import { DxfFetcher } from "./DxfFetcher.js";
+//import { DxfViewer } from "./DxfViewer.js";
+//import { Block } from "./DxfScene.js";
+
+
+//export { DxfFetcher, DxfViewer, Block }
+
+//import { }
+
+//export { DxfFetcher } from "./DxfFetcher.js";
+//export { DxfViewer } from "./DxfViewer.js";
+//export { DxfWorker } from "./DxfWorker.js";
+//export { ParseSpecialChars } from "./TextRenderer.js";
+//export { Block, DxfScene, RenderBatch } from "./DxfScene.js"
+
+
+
+export { Batch, DxfViewer, Layer } from "./DxfViewer.js";
+export { Block as SceneBlock } from "./DxfScene.js";
+export { Block } from "./DxfViewer.js";
+export { DxfScene, Entity, ColorCode } from "./DxfScene.js";
+export { TextRenderer, ParseSpecialChars, HAlign, VAlign } from "./TextRenderer.js";
+export { DxfWorker } from "./DxfWorker.js";
+export { DxfFetcher } from "./DxfFetcher.js";
+export { DxfParser } from "./parser/DxfParser.js";
+export { RenderBatch } from "./DxfScene.js";
+export { DynamicBuffer, NativeType } from "./DynamicBuffer.js";
+export { OrbitControls } from "./OrbitControls.js";
+
+//export default Block;
+
+

package/lib/dxf-viewer/math/Matrix2.js

@@ -0,0 +1,77 @@
+import { Vector2 } from "../dep/three/three.module.js"
+
+export class Matrix2 {
+    /**
+     *
+     * @param {number} a00
+     * @param {number} a01
+     * @param {number} a10
+     * @param {number} a11
+     */
+    constructor(a00, a01, a10, a11) {
+        this.a00 = a00
+        this.a01 = a01
+        this.a10 = a10
+        this.a11 = a11
+    }
+
+    /**
+     * Multiply Vector2 to this matrix as Av
+     * @param {Vector2} v
+     * @returns {Vector2} transformed v
+     */
+    multiply(v) {
+        return new Vector2(
+            this.a00 * v.x + this.a01 * v.y,
+            this.a10 * v.x + this.a11 * v.y,
+        )
+    }
+
+    /**
+     * Return determinant of this matrix
+     * @returns {number}
+     */
+    det() {
+        return this.a00 * this.a11 - this.a01 * this.a10
+    }
+
+    /**
+     * Return inverse of this matrix. If inverse is not exists i.e.
+     * this.det() === 0, return `undefined`.
+     * @param {number | undefined} - in case of pre computed determinant, you may pass it to parameter
+     * @returns {Matrix2 | undefined} inverse of this matrix
+     */
+    inverse(determinant = det()) {
+        if (determinant === 0) return undefined
+
+        return new Matrix2(
+            this.a11 / determinant, -this.a01 / determinant,
+            -this.a10 / determinant, this.a00 / determinant,
+        )
+    }
+
+    /**
+     * Solve linear equation Ax = b using Gauss-Jordan reduction
+     * where A is `this`. If it's singular, return `undefined`
+     * @param {Vector2} b 
+     * @returns {Vector2 | undefined}
+     */
+    solve(b) {
+        if (this.a00 * this.a11 === this.a10 * this.a01) return undefined
+
+        if (Math.abs(this.a00) >= Math.abs(this.a10)) {
+            const alpha = this.a10 / this.a00
+            const beta = this.a11 - this.a01 * alpha
+            const gamma = b.y - b.x * alpha
+            const y = gamma / beta
+            const x = (b.x - this.a01 * y) / this.a00
+            return new Vector2(x, y)
+        }
+        const alpha = this.a00 / this.a10
+        const beta = this.a01 - this.a11 * alpha
+        const gamma = b.x - b.y * alpha
+        const y = gamma / beta
+        const x = (b.y - this.a11 * y) / this.a10
+        return new Vector2(x, y)
+    }
+}

package/lib/dxf-viewer/math/utils.js

@@ -0,0 +1,59 @@
+import { Vector2 } from "../dep/three/three.module.js"
+
+
+/** Find intersection points of two segments in a parametric form.
+ * @param {Vector2} a1 First segment start point.
+ * @param {Vector2} a2 First segment end point.
+ * @param {Vector2} b1 Second segment start point.
+ * @param {Vector2} b2 Second segment end point.
+ * @param {boolean} force Force intersection calculation even if intersection point is out of
+ *  segment range.
+ * @return {?number[3]} Parameters for the first and second segment in the intersection point
+ *  (parameter value 0 corresponds to a start point, 1 - to an end point). Third number is segments
+ *  direction vectors pseudo-cross-product. Null if there is no intersection.
+ */
+export function IntersectSegmentsParametric(a1, a2, b1, b2, force = false) {
+    const a = a2.clone().sub(a1)
+    const b = b2.clone().sub(b1)
+
+    if (a.lengthSq() == 0 || b.lengthSq() == 0) {
+        return null
+    }
+
+    const S = a.cross(b)
+    if (Math.abs(S) <= Number.EPSILON) {
+        /* Consider parallel. */
+        return null
+    }
+
+    const c = b1.clone().sub(a1)
+
+    const t = c.cross(b) / S
+    if (!force && (t < 0 || t > 1)) {
+        /* Intersection point is out the first segment endpoints. */
+        return null
+    }
+
+    const u = c.cross(a) / S
+    if (!force && (u < 0 || u > 1)) {
+        /* Intersection point is out the second segment endpoints. */
+        return null
+    }
+
+    return [t, u, S]
+}
+
+/**  Find intersection points of two segments.
+ * @param {Vector2} a1 First segment start point.
+ * @param {Vector2} a2 First segment end point.
+ * @param {Vector2} b1 Second segment start point.
+ * @param {Vector2} b2 Second segment end point.
+ * @return {?Vector2} Intersection point coordinate, null if no intersection.
+ */
+export function IntersectSegments(a1, a2, b1, b2) {
+    const params = IntersectSegmentsParametric(a1, a2, b1, b2)
+    if (!params) {
+        return null
+    }
+    return a2.clone().sub(a1).multiplyScalar(params[0]).add(a1)
+}

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

@@ -0,0 +1,265 @@
+/**
+ * AutoCad files sometimes use an indexed color value between 1 and 255 inclusive.
+ * Each value corresponds to a color. index 1 is red, that is 16711680 or 0xFF0000.
+ * index 0 and 256, while included in this array, are actually reserved for inheritance
+ * values in AutoCad so they should not be used for index color lookups.
+ */
+
+export default [
+ 0,
+ 16711680,
+ 16776960,
+ 65280,
+ 65535,
+ 255,
+ 16711935,
+ 16777215,
+ 8421504,
+ 12632256,
+ 16711680,
+ 16744319,
+ 13369344,
+ 13395558,
+ 10027008,
+ 10046540,
+ 8323072,
+ 8339263,
+ 4980736,
+ 4990502,
+ 16727808,
+ 16752511,
+ 13382400,
+ 13401958,
+ 10036736,
+ 10051404,
+ 8331008,
+ 8343359,
+ 4985600,
+ 4992806,
+ 16744192,
+ 16760703,
+ 13395456,
+ 13408614,
+ 10046464,
+ 10056268,
+ 8339200,
+ 8347455,
+ 4990464,
+ 4995366,
+ 16760576,
+ 16768895,
+ 13408512,
+ 13415014,
+ 10056192,
+ 10061132,
+ 8347392,
+ 8351551,
+ 4995328,
+ 4997670,
+ 16776960,
+ 16777087,
+ 13421568,
+ 13421670,
+ 10000384,
+ 10000460,
+ 8355584,
+ 8355647,
+ 5000192,
+ 5000230,
+ 12582656,
+ 14679935,
+ 10079232,
+ 11717734,
+ 7510016,
+ 8755276,
+ 6258432,
+ 7307071,
+ 3755008,
+ 4344870,
+ 8388352,
+ 12582783,
+ 6736896,
+ 10079334,
+ 5019648,
+ 7510092,
+ 4161280,
+ 6258495,
+ 2509824,
+ 3755046,
+ 4194048,
+ 10485631,
+ 3394560,
+ 8375398,
+ 2529280,
+ 6264908,
+ 2064128,
+ 5209919,
+ 1264640,
+ 3099686,
+ 65280,
+ 8388479,
+ 52224,
+ 6736998,
+ 38912,
+ 5019724,
+ 32512,
+ 4161343,
+ 19456,
+ 2509862,
+ 65343,
+ 8388511,
+ 52275,
+ 6737023,
+ 38950,
+ 5019743,
+ 32543,
+ 4161359,
+ 19475,
+ 2509871,
+ 65407,
+ 8388543,
+ 52326,
+ 6737049,
+ 38988,
+ 5019762,
+ 32575,
+ 4161375,
+ 19494,
+ 2509881,
+ 65471,
+ 8388575,
+ 52377,
+ 6737074,
+ 39026,
+ 5019781,
+ 32607,
+ 4161391,
+ 19513,
+ 2509890,
+ 65535,
+ 8388607,
+ 52428,
+ 6737100,
+ 39064,
+ 5019800,
+ 32639,
+ 4161407,
+ 19532,
+ 2509900,
+ 49151,
+ 8380415,
+ 39372,
+ 6730444,
+ 29336,
+ 5014936,
+ 24447,
+ 4157311,
+ 14668,
+ 2507340,
+ 32767,
+ 8372223,
+ 26316,
+ 6724044,
+ 19608,
+ 5010072,
+ 16255,
+ 4153215,
+ 9804,
+ 2505036,
+ 16383,
+ 8364031,
+ 13260,
+ 6717388,
+ 9880,
+ 5005208,
+ 8063,
+ 4149119,
+ 4940,
+ 2502476,
+ 255,
+ 8355839,
+ 204,
+ 6710988,
+ 152,
+ 5000344,
+ 127,
+ 4145023,
+ 76,
+ 2500172,
+ 4129023,
+ 10452991,
+ 3342540,
+ 8349388,
+ 2490520,
+ 6245528,
+ 2031743,
+ 5193599,
+ 1245260,
+ 3089996,
+ 8323327,
+ 12550143,
+ 6684876,
+ 10053324,
+ 4980888,
+ 7490712,
+ 4128895,
+ 6242175,
+ 2490444,
+ 3745356,
+ 12517631,
+ 14647295,
+ 10027212,
+ 11691724,
+ 7471256,
+ 8735896,
+ 6226047,
+ 7290751,
+ 3735628,
+ 4335180,
+ 16711935,
+ 16744447,
+ 13369548,
+ 13395660,
+ 9961624,
+ 9981080,
+ 8323199,
+ 8339327,
+ 4980812,
+ 4990540,
+ 16711871,
+ 16744415,
+ 13369497,
+ 13395634,
+ 9961586,
+ 9981061,
+ 8323167,
+ 8339311,
+ 4980793,
+ 4990530,
+ 16711807,
+ 16744383,
+ 13369446,
+ 13395609,
+ 9961548,
+ 9981042,
+ 8323135,
+ 8339295,
+ 4980774,
+ 4990521,
+ 16711743,
+ 16744351,
+ 13369395,
+ 13395583,
+ 9961510,
+ 9981023,
+ 8323103,
+ 8339279,
+ 4980755,
+ 4990511,
+ 3355443,
+ 5987163,
+ 8684676,
+ 11382189,
+ 14079702,
+ 16777215
+];

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

@@ -0,0 +1,33 @@
+/** Dimension style variables are used either in DIMSTYLE table or in DIMENSION entity style
+ * override in XDATA.
+ */
+const codes = new Map([
+    [140, "DIMTXT"],
+    [142, "DIMTSZ"],
+    [144, "DIMLFAC"],
+    [147, "DIMGAP"],
+    [173, "DIMSAH"],
+    [175, "DIMSOXD"],
+    [176, "DIMCLRD"],
+    [177, "DIMCLRE"],
+    [178, "DIMCLRT"],
+    [271, "DIMDEC"],
+    [278, "DIMDSEP"],
+    [281, "DIMSD1"],
+    [282, "DIMSD2"],
+    [3, "DIMPOST"],
+    [40, "DIMSCALE"],
+    [41, "DIMASZ"],
+    [42, "DIMEXO"],
+    [44, "DIMEXE"],
+    [45, "DIMRND"],
+    [46, "DIMDLE"],
+    [5, "DIMBLK"],
+    [6, "DIMBLK1"],
+    [7, "DIMBLK2"],
+    [75, "DIMSE1"],
+    [76, "DIMSE2"],
+    [78, "DIMZIN"],
+])
+
+export default codes

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

@@ -0,0 +1,143 @@
+/**
+ * DxfArrayScanner
+ *
+ * Based off the AutoCad 2012 DXF Reference
+ * http://images.autodesk.com/adsk/files/autocad_2012_pdf_dxf-reference_enu.pdf
+ *
+ * Reads through an array representing lines of a dxf file. Takes an array and
+ * provides an easy interface to extract group code and value pairs.
+ * @param data - an array where each element represents a line in the dxf file
+ * @constructor
+ */
+export default function DxfArrayScanner(data) {
+    this._pointer = 0;
+    this._data = data;
+    this._eof = false;
+}
+
+/**
+ * Gets the next group (code, value) from the array. A group is two consecutive elements
+ * in the array. The first is the code, the second is the value.
+ * @returns {{code: Number}|*}
+ */
+DxfArrayScanner.prototype.next = function() {
+    var group;
+    if(!this.hasNext()) {
+        if(!this._eof)
+            throw new Error('Unexpected end of input: EOF group not read before end of file. Ended on code ' + this._data[this._pointer]);
+        else
+            throw new Error('Cannot call \'next\' after EOF group has been read');
+    }
+
+    group = {
+        code: parseInt(this._data[this._pointer])
+    };
+
+    this._pointer++;
+
+    group.value = parseGroupValue(group.code, this._data[this._pointer]);
+    
+    this._pointer++;
+
+    if(group.code === 0 && group.value === 'EOF') this._eof = true;
+
+    this.lastReadGroup = group;
+
+    return group;
+};
+
+DxfArrayScanner.prototype.peek = function() {
+    if(!this.hasNext()) {
+        if(!this._eof)
+            throw new Error('Unexpected end of input: EOF group not read before end of file. Ended on code ' + this._data[this._pointer]);
+        else
+            throw new Error('Cannot call \'next\' after EOF group has been read');
+    }
+    
+    var group = {
+        code: parseInt(this._data[this._pointer])
+    };
+
+    group.value = parseGroupValue(group.code, this._data[this._pointer + 1]);
+
+    return group;
+};
+
+
+DxfArrayScanner.prototype.rewind = function(numberOfGroups) {
+    numberOfGroups = numberOfGroups || 1;
+    this._pointer = this._pointer - numberOfGroups * 2;
+};
+
+/**
+ * Returns true if there is another code/value pair (2 elements in the array).
+ * @returns {boolean}
+ */
+DxfArrayScanner.prototype.hasNext = function() {
+    // Check if we have read EOF group code
+    if(this._eof) {
+        return false;
+    }
+    
+    // We need to be sure there are two lines available
+    if(this._pointer > this._data.length - 2) {
+        return false;
+    }
+    return true;
+};
+
+/**
+ * Returns true if the scanner is at the end of the array
+ * @returns {boolean}
+ */
+DxfArrayScanner.prototype.isEOF = function() {
+    return this._eof;
+};
+
+/**
+ * Parse a value to its proper type.
+ * See pages 3 - 10 of the AutoCad DXF 2012 reference given at the top of this file
+ *
+ * @param code
+ * @param value
+ * @returns {*}
+ */
+function parseGroupValue(code, value) {
+    if(code <= 9) return value;
+    if(code >= 10 && code <= 59) return parseFloat(value.trim());
+    if(code >= 60 && code <= 99) return parseInt(value.trim());
+    if(code >= 100 && code <= 109) return value;
+    if(code >= 110 && code <= 149) return parseFloat(value.trim());
+    if(code >= 160 && code <= 179) return parseInt(value.trim());
+    if(code >= 210 && code <= 239) return parseFloat(value.trim());
+    if(code >= 270 && code <= 289) return parseInt(value.trim());
+    if(code >= 290 && code <= 299) return parseBoolean(value.trim());
+    if(code >= 300 && code <= 369) return value;
+    if(code >= 370 && code <= 389) return parseInt(value.trim());
+    if(code >= 390 && code <= 399) return value;
+    if(code >= 400 && code <= 409) return parseInt(value.trim());
+    if(code >= 410 && code <= 419) return value;
+    if(code >= 420 && code <= 429) return parseInt(value.trim());
+    if(code >= 430 && code <= 439) return value;
+    if(code >= 440 && code <= 459) return parseInt(value.trim());
+    if(code >= 460 && code <= 469) return parseFloat(value.trim());
+    if(code >= 470 && code <= 481) return value;
+    if(code === 999) return value;
+    if(code >= 1000 && code <= 1009) return value;
+    if(code >= 1010 && code <= 1059) return parseFloat(value.trim());
+    if(code >= 1060 && code <= 1071) return parseInt(value.trim());
+
+    console.log('WARNING: Group code does not have a defined type: %j', { code: code, value: value });
+    return value;
+}
+
+/**
+ * Parse a boolean according to a 1 or 0 value
+ * @param str
+ * @returns {boolean}
+ */
+function parseBoolean(str) {
+    if(str === '0') return false;
+    if(str === '1') return true;
+    throw TypeError('String \'' + str + '\' cannot be cast to Boolean type');
+}