@colijnit/homedecorator 255.1.1

package/esm2015/app/core/service/view-mode.service.js

@@ -0,0 +1,61 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { ViewMode } from '../enum/view-mode.enum';
+import * as i0 from "@angular/core";
+export class ViewModeService {
+    constructor() {
+        this.viewModeChanged = new BehaviorSubject(ViewMode.FloorPlan2D);
+        this.room3DUpdated = new BehaviorSubject(false);
+        this._viewMode = ViewMode.FloorPlan2D;
+    }
+    set viewMode(value) {
+        if (this._viewMode !== value) {
+            this._viewMode = value;
+            this.viewModeChanged.next(this._viewMode);
+        }
+    }
+    get viewMode() {
+        return this._viewMode;
+    }
+    get viewCorner() {
+        return this._viewCorner;
+    }
+    set viewCorner(value) {
+        this._viewCorner = value;
+    }
+    get walkThroughCameraStartPoint() {
+        return this._walkThroughCameraStartPoint;
+    }
+    set walkThroughCameraStartPoint(value) {
+        this._walkThroughCameraStartPoint = value;
+    }
+    setViewMode(viewSize, viewCenter, mode) {
+        this.viewSize = viewSize;
+        this.viewCenter = viewCenter;
+        this.viewMode = mode;
+    }
+    is2dViewActive() {
+        return this._viewMode === ViewMode.FloorPlan2D;
+    }
+    is3dViewActive() {
+        return this._viewMode === ViewMode.RoomPlan3D;
+    }
+    isWalkThroughViewActive() {
+        return this._viewMode === ViewMode.WalkThrough;
+    }
+    isVRViewActive() {
+        return this._viewMode === ViewMode.VR;
+    }
+    isTopViewActive() {
+        return this._viewMode === ViewMode.TopView;
+    }
+}
+ViewModeService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ViewModeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ViewModeService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ViewModeService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ViewModeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/app/core/service/web-worker.service.js

@@ -0,0 +1,44 @@
+import { Injectable } from '@angular/core';
+import { WebWorkerType } from '../workers/enum/web-worker-type.enum';
+import * as i0 from "@angular/core";
+export class WebWorkerService {
+    constructor() {
+        this._webWorkers = new Map();
+        this._loadedWebWorkers = false;
+    }
+    ngOnDestroy() {
+        this._webWorkers.forEach(worker => worker.terminate());
+    }
+    webWorkersSupported() {
+        return !!window.Worker;
+    }
+    postMessage(webWorkerType, message) {
+        return new Promise((resolve, reject) => {
+            const webWorker = this._webWorkers.get(webWorkerType);
+            if (webWorker) {
+                webWorker.onmessage = (response) => {
+                    resolve(response);
+                };
+                webWorker.postMessage(message);
+            }
+            else {
+                reject();
+            }
+        });
+    }
+    initWorkers() {
+        if (this.webWorkersSupported() && !this._loadedWebWorkers) {
+            this._loadedWebWorkers = true;
+            this._webWorkers.set(WebWorkerType.IndexedDB, new Worker('/assets/workers/indexedDB-web-worker.js'));
+        }
+    }
+}
+WebWorkerService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: WebWorkerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+WebWorkerService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: WebWorkerService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: WebWorkerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/app/core/utils/clone-utils.js

@@ -0,0 +1,41 @@
+import { Mesh, Object3D } from 'three';
+export class CloneUtils {
+    static CleanCloneObject(obj) {
+        let clone;
+        if (obj.geometry && obj.material) {
+            clone = new Mesh();
+            clone.geometry = obj.geometry.clone();
+            clone.material = Array.isArray(obj.material) ? obj.material.map(m => m.clone()) : obj.material.clone();
+        }
+        else {
+            clone = new Object3D();
+        }
+        CloneUtils.CloneDefaultProps(clone, obj);
+        if (obj.children && obj.children.length > 0) {
+            for (let i = 0; i < obj.children.length; i++) {
+                const child = obj.children[i];
+                clone.add(child.clone());
+            }
+        }
+        return clone;
+    }
+    static CloneDefaultProps(clone, source) {
+        clone.name = source.name;
+        clone.up.copy(source.up);
+        clone.position.copy(source.position);
+        clone.quaternion.copy(source.quaternion);
+        clone.scale.copy(source.scale);
+        clone.matrix.copy(source.matrix);
+        clone.matrixWorld.copy(source.matrixWorld);
+        clone.matrixAutoUpdate = source.matrixAutoUpdate;
+        clone.matrixWorldNeedsUpdate = source.matrixWorldNeedsUpdate;
+        clone.layers.mask = source.layers.mask;
+        clone.visible = source.visible;
+        clone.castShadow = source.castShadow;
+        clone.receiveShadow = source.receiveShadow;
+        clone.frustumCulled = source.frustumCulled;
+        clone.renderOrder = source.renderOrder;
+        // throw new Error('foutje');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/app/core/utils/color.utils.js

@@ -0,0 +1,20 @@
+export class ColorUtils {
+    static HexToRgb(hex) {
+        // Expand shorthand form (e.g. "03F") to full form (e.g. "0033FF")
+        const clearHex = hex.replace('#', '');
+        if (clearHex.length < 6 && clearHex.length > 3) {
+            hex = '#00' + clearHex;
+        }
+        const shorthandRegex = /^#?([a-f\d])([a-f\d])([a-f\d])$/i;
+        hex = hex.replace(shorthandRegex, function (m, r, g, b) {
+            return r + r + g + g + b + b;
+        });
+        const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+        return result ? {
+            r: parseInt(result[1], 16),
+            g: parseInt(result[2], 16),
+            b: parseInt(result[3], 16)
+        } : null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/app/core/utils/file.utils.js

@@ -0,0 +1,234 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+// Static utility functions holder related to files.
+// @dynamic
+export class FileUtils {
+    // Returns the given dataUri string stripped of the mimetype part.
+    static StripMimeStringFromDataUri(dataUri) {
+        if (!dataUri) {
+            return '';
+        }
+        const mimeString = this.GetMimeStringFromDataUri(dataUri);
+        return dataUri.substr(mimeString.length + 1);
+    }
+    static GetMimeStringFromDataUri(dataUri) {
+        if (!dataUri) {
+            return '';
+        }
+        return dataUri.split(',')[0];
+    }
+    /**
+     * Deprecated
+     */
+    static FileExists(url, assetPath) {
+        if (assetPath) {
+            if (!assetPath.endsWith('/')) {
+                assetPath += '/';
+            }
+            const xhr = new XMLHttpRequest();
+            xhr.open('GET', `${assetPath}getFiles.php?assetUrl=${url}`, false);
+            xhr.send();
+            return !!xhr.responseText;
+        }
+        else {
+            try {
+                const xhr = new XMLHttpRequest();
+                xhr.open('head', url, false);
+                xhr.send();
+                return xhr.status !== 404;
+            }
+            catch (e) {
+                //
+            }
+        }
+    }
+    static CheckModelConversion(url, assetPath) {
+        const xhr = new XMLHttpRequest();
+        xhr.open('GET', `${assetPath}checkModelConversion.php?checkModelConversion=&url=${url}`, false);
+        xhr.send();
+        return JSON.parse(xhr.responseText);
+    }
+    static SaveTextureImage(metaData, fileName, assetPath) {
+        const payload = JSON.stringify(metaData);
+        if (this._cachedTextureUploads.has(payload)) {
+            return this._cachedTextureUploads.get(payload);
+        }
+        const formData = new FormData();
+        formData.append('action', 'saveTempTextureImage');
+        formData.append('fileName', fileName);
+        formData.append('data', payload);
+        const xhr = new XMLHttpRequest();
+        xhr.open('POST', `${assetPath}saveFile.php`, false);
+        xhr.send(formData);
+        if (xhr.responseText) {
+            const answer = JSON.parse(xhr.responseText);
+            this._cachedTextureUploads.set(payload, answer);
+            return answer;
+        }
+        else {
+            return false;
+        }
+    }
+    static SaveGLBFile(data, assetPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const xhr = new XMLHttpRequest();
+                xhr.open('POST', `${assetPath}saveGLBFile.php`, true);
+                xhr.onload = () => {
+                    if (xhr.responseText) {
+                        resolve(JSON.parse(xhr.responseText));
+                    }
+                    else {
+                        reject(false);
+                    }
+                };
+                xhr.send(data);
+            });
+        });
+    }
+    // Converts given string data to an ArrayBuffer.
+    static ConvertStringToArrayBuffer(stringData) {
+        if (!stringData) {
+            return undefined;
+        }
+        const arrayBuffer = new ArrayBuffer(stringData.length);
+        const bufView = new Uint8Array(arrayBuffer);
+        for (let i = 0, len = stringData.length; i < len; i++) {
+            bufView[i] = stringData.charCodeAt(i);
+        }
+        return bufView;
+    }
+    static ConvertByteArrayToString(byteArray) {
+        let str = '';
+        if (byteArray) {
+            for (let i = 0, len = byteArray.length; i < len; i++) {
+                str += String.fromCharCode(byteArray[i]);
+            }
+        }
+        return str;
+    }
+    // Returns true if given string contains a data-uri/base64.
+    static StringContainsDataUri(str) {
+        if (!str) {
+            return false;
+        }
+        const mimeString = str.split(',')[0];
+        return mimeString.indexOf('base64') > -1;
+    }
+    /**
+     * There is some discrepancy regarding locations of h3d objects
+     * Therefor we need to (temporarily?!) fix the content url
+     * Also we need to change some additionals
+     */
+    static FixUrl(assetUrl) {
+        if (!assetUrl) {
+            return '';
+        }
+        let fixedUrl = assetUrl;
+        if (!fixedUrl.endsWith('glb') && !fixedUrl.endsWith('obj') && !fixedUrl.endsWith('glb.gz') && !fixedUrl.endsWith('obj.gz')) {
+            fixedUrl = FileUtils.FixUnityUrl(fixedUrl);
+        }
+        fixedUrl = fixedUrl.replace('/content/', '/content43/');
+        return fixedUrl;
+    }
+    static FixGlbUrl(assetUrl) {
+        if (!assetUrl) {
+            return '';
+        }
+        let fixedUrl = assetUrl;
+        if (assetUrl.indexOf('_webplayer') === -1) {
+            fixedUrl = assetUrl.concat('_webplayer');
+        }
+        fixedUrl = fixedUrl.replace('/content/', '/content43/');
+        if (!fixedUrl.endsWith('.glb')) {
+            fixedUrl = fixedUrl.concat('.glb');
+        }
+        return fixedUrl;
+    }
+    // Return the mimetype of the given filename.
+    static MimeTypeFromFilename(fileName) {
+        const regEx = /(?:\.([^.]+))?$/; // regex to find extension
+        const extension = regEx.exec(fileName)[1];
+        switch (extension) {
+            case 'jpg':
+            case 'jpeg':
+                return 'image/jpeg';
+            case 'png':
+                return 'image/png';
+            case 'bmp':
+                return 'image/bmp';
+        }
+    }
+    /**
+     * Downloads the given file to the users default download location.
+     * @param fileName With or without extension
+     * @param content File content as a string
+     * @param [mimeType = 'text/plain']
+     */
+    static DownloadFile(fileName, content, mimeType = 'text/plain') {
+        const element = document.createElement('a');
+        element.setAttribute('href', 'data:' + mimeType + ';charset=utf-8,' + encodeURIComponent(content));
+        element.setAttribute('download', fileName);
+        element.style.display = 'none';
+        document.body.appendChild(element);
+        element.click();
+        document.body.removeChild(element);
+    }
+    // Returns the contents of given file as a text string.
+    static ReadAsText(file) {
+        return new Promise((resolve) => {
+            const reader = new FileReader();
+            reader.readAsText(file);
+            reader.onloadend = (event) => {
+                if (event.target.readyState === 2) {
+                    resolve(event.target.result);
+                }
+            };
+        });
+    }
+    static GetExtensionFromDataUri(dataUri) {
+        return dataUri.replace(/(data:image\/)(.*?)(;base64.*)/gi, '$2');
+    }
+    static CreateDownloadFileNameFromBase64(dataUri) {
+        const ext = this.GetExtensionFromDataUri(dataUri);
+        return 'preview.' + ext;
+    }
+    static DownloadFromDataUri(dataUri, fileName) {
+        const link = document.createElement('a');
+        link.download = fileName;
+        link.href = dataUri;
+        document.body.appendChild(link);
+        link.click();
+        document.body.removeChild(link);
+    }
+    // todo remove once Connector deals with mimetypes and this method isn't used anymore
+    static DocumentBodyToDataUri(documentBody, mimeType) {
+        if (!!documentBody) {
+            return 'data:' + mimeType + ';base64,' + documentBody;
+        }
+        else {
+            return '';
+        }
+    }
+    static FixUnityUrl(url) {
+        if (url.indexOf('_webplayer') === -1) {
+            url = url.concat('_webplayer.ione3d');
+        }
+        else {
+            url = url.replace('_webplayer', '_webplayer.ione3d');
+        }
+        if (!url.endsWith('.gz')) {
+            url = url.concat('.gz');
+        }
+        return url.replace('.unity3d', '');
+    }
+}
+FileUtils._cachedTextureUploads = new Map();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"file.utils.js","sourceRoot":"","sources":["../../../../../../src/client/app/core/utils/file.utils.ts"],"names":[],"mappings":"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","sourcesContent":["// Static utility functions holder related to files.\r\n// @dynamic\r\nexport class FileUtils {\r\n\r\n  private static _cachedTextureUploads: Map<string, Object> = new Map();\r\n\r\n  // Returns the given dataUri string stripped of the mimetype part.\r\n  public static StripMimeStringFromDataUri(dataUri: string): string {\r\n    if (!dataUri) {\r\n      return '';\r\n    }\r\n\r\n    const mimeString: string = this.GetMimeStringFromDataUri(dataUri);\r\n    return dataUri.substr(mimeString.length + 1);\r\n  }\r\n\r\n  public static GetMimeStringFromDataUri(dataUri: string): string {\r\n    if (!dataUri) {\r\n      return '';\r\n    }\r\n\r\n    return dataUri.split(',')[0];\r\n  }\r\n\r\n  /**\r\n   * Deprecated\r\n   */\r\n  public static FileExists(url: string, assetPath?: string): boolean {\r\n    if (assetPath) {\r\n      if (!assetPath.endsWith('/')) {\r\n        assetPath += '/';\r\n      }\r\n      const xhr = new XMLHttpRequest();\r\n      xhr.open('GET', `${assetPath}getFiles.php?assetUrl=${url}`, false);\r\n      xhr.send();\r\n      return !!xhr.responseText;\r\n    } else {\r\n      try {\r\n        const xhr = new XMLHttpRequest();\r\n        xhr.open('head', url, false);\r\n        xhr.send();\r\n        return xhr.status !== 404;\r\n      } catch (e) {\r\n        //\r\n      }\r\n    }\r\n  }\r\n\r\n  public static CheckModelConversion(url: string, assetPath: string): any {\r\n    const xhr = new XMLHttpRequest();\r\n    xhr.open('GET', `${assetPath}checkModelConversion.php?checkModelConversion=&url=${url}`, false);\r\n    xhr.send();\r\n    return JSON.parse(xhr.responseText);\r\n  }\r\n\r\n  public static SaveTextureImage(metaData: any, fileName: string, assetPath: string): any {\r\n    const payload = JSON.stringify(metaData);\r\n    if (this._cachedTextureUploads.has(payload)) {\r\n      return this._cachedTextureUploads.get(payload);\r\n    }\r\n\r\n    const formData = new FormData();\r\n    formData.append('action', 'saveTempTextureImage');\r\n    formData.append('fileName', fileName);\r\n    formData.append('data', payload);\r\n\r\n    const xhr = new XMLHttpRequest();\r\n    xhr.open('POST', `${assetPath}saveFile.php`, false);\r\n    xhr.send(formData);\r\n\r\n    if (xhr.responseText) {\r\n      const answer = JSON.parse(xhr.responseText);\r\n      this._cachedTextureUploads.set(payload, answer);\r\n      return answer;\r\n    } else {\r\n      return false;\r\n    }\r\n  }\r\n\r\n  public static async SaveGLBFile(data: Blob, assetPath: string): Promise<any> {\r\n    return new Promise((resolve, reject) => {\r\n      const xhr = new XMLHttpRequest();\r\n      xhr.open('POST', `${assetPath}saveGLBFile.php`, true);\r\n      xhr.onload = () => {\r\n        if (xhr.responseText) {\r\n          resolve(JSON.parse(xhr.responseText));\r\n        } else {\r\n          reject(false);\r\n        }\r\n      };\r\n      xhr.send(data);\r\n    });\r\n  }\r\n\r\n  // Converts given string data to an ArrayBuffer.\r\n  public static ConvertStringToArrayBuffer(stringData: string): Uint8Array {\r\n    if (!stringData) {\r\n      return undefined;\r\n    }\r\n    const arrayBuffer: ArrayBuffer = new ArrayBuffer(stringData.length);\r\n    const bufView: Uint8Array = new Uint8Array(arrayBuffer);\r\n    for (let i = 0, len: number = stringData.length; i < len; i++) {\r\n      bufView[i] = stringData.charCodeAt(i);\r\n    }\r\n    return bufView;\r\n  }\r\n\r\n  public static ConvertByteArrayToString(byteArray: number[]): string {\r\n    let str = '';\r\n    if (byteArray) {\r\n      for (let i = 0, len: number = byteArray.length; i < len; i++) {\r\n        str += String.fromCharCode(byteArray[i]);\r\n      }\r\n    }\r\n    return str;\r\n  }\r\n\r\n  // Returns true if given string contains a data-uri/base64.\r\n  public static StringContainsDataUri(str: string): boolean {\r\n    if (!str) {\r\n      return false;\r\n    }\r\n    const mimeString: string = str.split(',')[0];\r\n    return mimeString.indexOf('base64') > -1;\r\n  }\r\n\r\n  /**\r\n   * There is some discrepancy regarding locations of h3d objects\r\n   * Therefor we need to (temporarily?!) fix the content url\r\n   * Also we need to change some additionals\r\n   */\r\n  public static FixUrl(assetUrl: string): string {\r\n    if (!assetUrl) {\r\n      return '';\r\n    }\r\n    let fixedUrl: string = assetUrl;\r\n    if (!fixedUrl.endsWith('glb') && !fixedUrl.endsWith('obj') && !fixedUrl.endsWith('glb.gz') && !fixedUrl.endsWith('obj.gz')) {\r\n      fixedUrl = FileUtils.FixUnityUrl(fixedUrl);\r\n    }\r\n    fixedUrl = fixedUrl.replace('/content/', '/content43/');\r\n    return fixedUrl;\r\n  }\r\n\r\n  public static FixGlbUrl(assetUrl: string): string {\r\n    if (!assetUrl) {\r\n      return '';\r\n    }\r\n    let fixedUrl: string = assetUrl;\r\n    if (assetUrl.indexOf('_webplayer') === -1) {\r\n      fixedUrl = assetUrl.concat('_webplayer');\r\n    }\r\n    fixedUrl = fixedUrl.replace('/content/', '/content43/');\r\n    if (!fixedUrl.endsWith('.glb')) {\r\n      fixedUrl = fixedUrl.concat('.glb');\r\n    }\r\n    return fixedUrl;\r\n  }\r\n\r\n  // Return the mimetype of the given filename.\r\n  public static MimeTypeFromFilename(fileName: string): string {\r\n    const regEx: RegExp = /(?:\\.([^.]+))?$/; // regex to find extension\r\n    const extension: any = regEx.exec(fileName)[1];\r\n    switch (extension) {\r\n      case 'jpg':\r\n      case 'jpeg':\r\n        return 'image/jpeg';\r\n      case 'png':\r\n        return 'image/png';\r\n      case 'bmp':\r\n        return 'image/bmp';\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Downloads the given file to the users default download location.\r\n   * @param fileName With or without extension\r\n   * @param content File content as a string\r\n   * @param [mimeType = 'text/plain']\r\n   */\r\n  public static DownloadFile(\r\n    fileName: string,\r\n    content: string,\r\n    mimeType: string = 'text/plain'\r\n  ): void {\r\n    const element: HTMLAnchorElement = document.createElement('a');\r\n    element.setAttribute('href', 'data:' + mimeType + ';charset=utf-8,' + encodeURIComponent(content));\r\n    element.setAttribute('download', fileName);\r\n\r\n    element.style.display = 'none';\r\n    document.body.appendChild(element);\r\n\r\n    element.click();\r\n\r\n    document.body.removeChild(element);\r\n  }\r\n\r\n  // Returns the contents of given file as a text string.\r\n  public static ReadAsText(file: File): Promise<string> {\r\n    return new Promise<string>((resolve: Function) => {\r\n      const reader: FileReader = new FileReader();\r\n      reader.readAsText(file);\r\n      reader.onloadend = (event: any) => {\r\n        if (event.target.readyState === 2) {\r\n          resolve(event.target.result);\r\n        }\r\n      };\r\n    });\r\n  }\r\n\r\n  public static GetExtensionFromDataUri(dataUri: string): string {\r\n    return dataUri.replace(/(data:image\\/)(.*?)(;base64.*)/gi, '$2');\r\n  }\r\n\r\n  public static CreateDownloadFileNameFromBase64(dataUri: string): string {\r\n    const ext: string = this.GetExtensionFromDataUri(dataUri);\r\n    return 'preview.' + ext;\r\n  }\r\n\r\n  public static DownloadFromDataUri(dataUri: string, fileName: string): void {\r\n    const link: any = document.createElement('a');\r\n    link.download = fileName;\r\n    link.href = dataUri;\r\n    document.body.appendChild(link);\r\n    link.click();\r\n    document.body.removeChild(link);\r\n  }\r\n\r\n  // todo remove once Connector deals with mimetypes and this method isn't used anymore\r\n  public static DocumentBodyToDataUri(documentBody: string, mimeType: string): string {\r\n    if (!!documentBody) {\r\n      return 'data:' + mimeType + ';base64,' + documentBody;\r\n    } else {\r\n      return '';\r\n    }\r\n  }\r\n\r\n  private static FixUnityUrl(url): string {\r\n    if (url.indexOf('_webplayer') === -1) {\r\n      url = url.concat('_webplayer.ione3d');\r\n    } else {\r\n      url = url.replace('_webplayer', '_webplayer.ione3d');\r\n    }\r\n    if (!url.endsWith('.gz')) {\r\n      url = url.concat('.gz');\r\n    }\r\n    return url.replace('.unity3d', '');\r\n  }\r\n}\r\n"]}

package/esm2015/app/core/utils/function/is-empty.function.js

@@ -0,0 +1,5 @@
+// @returns true iff given value equals null or equals undefined or equals ''
+export function isEmpty(value) {
+    return value === null || value === undefined || value === '';
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXMtZW1wdHkuZnVuY3Rpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvY2xpZW50L2FwcC9jb3JlL3V0aWxzL2Z1bmN0aW9uL2lzLWVtcHR5LmZ1bmN0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLDZFQUE2RTtBQUM3RSxNQUFNLFVBQVUsT0FBTyxDQUFDLEtBQVU7SUFDaEMsT0FBTyxLQUFLLEtBQUssSUFBSSxJQUFJLEtBQUssS0FBSyxTQUFTLElBQUksS0FBSyxLQUFLLEVBQUUsQ0FBQztBQUMvRCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQHJldHVybnMgdHJ1ZSBpZmYgZ2l2ZW4gdmFsdWUgZXF1YWxzIG51bGwgb3IgZXF1YWxzIHVuZGVmaW5lZCBvciBlcXVhbHMgJydcclxuZXhwb3J0IGZ1bmN0aW9uIGlzRW1wdHkodmFsdWU6IGFueSk6IGJvb2xlYW4ge1xyXG4gIHJldHVybiB2YWx1ZSA9PT0gbnVsbCB8fCB2YWx1ZSA9PT0gdW5kZWZpbmVkIHx8IHZhbHVlID09PSAnJztcclxufVxyXG4iXX0=

package/esm2015/app/core/utils/function/is-nill.function.js

@@ -0,0 +1,5 @@
+// @returns true iff given value equals null or equals undefined
+export function isNill(value) {
+    return value === null || value === undefined;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXMtbmlsbC5mdW5jdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9jbGllbnQvYXBwL2NvcmUvdXRpbHMvZnVuY3Rpb24vaXMtbmlsbC5mdW5jdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxnRUFBZ0U7QUFDaEUsTUFBTSxVQUFVLE1BQU0sQ0FBQyxLQUFVO0lBQy9CLE9BQU8sS0FBSyxLQUFLLElBQUksSUFBSSxLQUFLLEtBQUssU0FBUyxDQUFDO0FBQy9DLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBAcmV0dXJucyB0cnVlIGlmZiBnaXZlbiB2YWx1ZSBlcXVhbHMgbnVsbCBvciBlcXVhbHMgdW5kZWZpbmVkXHJcbmV4cG9ydCBmdW5jdGlvbiBpc05pbGwodmFsdWU6IGFueSk6IGJvb2xlYW4ge1xyXG4gIHJldHVybiB2YWx1ZSA9PT0gbnVsbCB8fCB2YWx1ZSA9PT0gdW5kZWZpbmVkO1xyXG59XHJcbiJdfQ==