@shapediver/viewer.shared.services 1.15.7 → 2.0.2

package/src/settings-engine/SettingsEngine.ts

@@ -0,0 +1,176 @@
+import { convert, validate, DefaultsV3_1, ISettingsV3_1 } from '@shapediver/viewer.settings';
+import { container, singleton } from 'tsyringe'
+
+import { EventEngine } from '../event-engine/EventEngine'
+import { Logger, LOGGING_TOPIC } from '../logger/Logger';
+import { ShapeDiverViewerSettingsError } from '../logger/ShapeDiverViewerErrors';
+
+type IARSettings = ISettingsV3_1["ar"];
+type ICameraSettings = ISettingsV3_1["camera"];
+type IEnvironmentSettings = ISettingsV3_1["environment"];
+type IEnvironmentGeometrySettings = ISettingsV3_1["environmentGeometry"];
+type IGeneralSettings = ISettingsV3_1["general"];
+type ILightSettings = ISettingsV3_1["light"];
+type IRenderingSettings = ISettingsV3_1["rendering"];
+type ISessionSettings = ISettingsV3_1["session"];
+
+export class SettingsEngine {
+    // #region Properties (8)
+
+    private readonly _eventEngine: EventEngine = <EventEngine>container.resolve(EventEngine);
+    private readonly _logger: Logger = <Logger>container.resolve(Logger);
+    private readonly _settings: ISettingsV3_1 = DefaultsV3_1();
+    private _settings_version: '1.0' | '2.0' | '3.0' | '3.1' = '3.1';
+
+    // #endregion Properties (8)
+
+    // #region Public Accessors (10)
+
+    public get ar(): IARSettings {
+        return this._settings.ar;
+    }
+
+    public get camera(): ICameraSettings {
+        return this._settings.camera;
+    }
+
+    public get environment(): IEnvironmentSettings {
+        return this._settings.environment;
+    }
+
+    public get environmentGeometry(): IEnvironmentGeometrySettings {
+        return this._settings.environmentGeometry;
+    }
+
+    public get general(): IGeneralSettings {
+        return this._settings.general;
+    }
+
+    public get light(): ILightSettings {
+        return this._settings.light;
+    }
+
+    public get rendering(): IRenderingSettings {
+        return this._settings.rendering;
+    }
+
+    public get session(): ISessionSettings {
+        return this._settings.session;
+    }
+
+    public set session(value: ISessionSettings) {
+        this._settings.session = value;
+    }
+
+    public get settings(): ISettingsV3_1 {
+        return this._settings;
+    }
+
+    // #endregion Public Accessors (10)
+
+    // #region Public Methods (4)
+
+    public convertToTargetVersion(): any {
+        return convert(this._settings, this._settings_version);
+    }
+
+    public flatten() {
+        const flattenObject = (ob: any) => {
+            const toReturn: { [key: string]: any } = {};
+            for (let i in ob) {
+                if (!ob.hasOwnProperty(i)) continue;
+                if ((typeof ob[i]) == 'object') {
+                    const flatObject = flattenObject(ob[i]);
+                    for (var x in flatObject) {
+                        if (!flatObject.hasOwnProperty(x)) continue;
+                        toReturn[i + '.' + x] = flatObject[x];
+                    }
+                } else {
+                    toReturn[i] = ob[i];
+                }
+            }
+            return toReturn;
+        };
+        return flattenObject(this.settings);
+    }
+
+    public loadSettings(json: any) {
+        if (JSON.stringify(json) !== JSON.stringify({})) {
+            try { 
+                validate(json, '1.0');             
+                this._settings_version = '1.0';       
+                (<any>this._settings) = convert(json, '3.1');
+                this.cleanSettings(this._settings);
+                return;
+            } catch (e) {}
+            
+            try { 
+                validate(json, '2.0');             
+                this._settings_version = '2.0';       
+                (<any>this._settings) = convert(json, '3.1');
+                this.cleanSettings(this._settings);
+                return;
+            } catch (e) {}
+
+            try { 
+                validate(json, '3.0');             
+                this._settings_version = '3.0';       
+                (<any>this._settings) = convert(json, '3.1');
+                this.cleanSettings(this._settings);
+                return;
+            } catch (e) {}
+
+            try { 
+                validate(json, '3.1');             
+                this._settings_version = '3.1';       
+                (<any>this._settings) = convert(json, '3.1');
+                this.cleanSettings(this._settings);
+                return;
+            } catch (e) {
+                const error = new ShapeDiverViewerSettingsError('SettingsEngine.loadSettings: Settings could not be validated.', <Error>e);
+                throw this._logger.handleError(LOGGING_TOPIC.SETTINGS, `SettingsEngine.loadSettings`, error);
+            }
+        } else {
+            this._settings_version = '3.1';       
+            (<any>this._settings) = DefaultsV3_1();
+            return;
+        }
+    }
+
+    public reset() {
+        this._settings_version = '3.1';       
+        (<any>this._settings) = DefaultsV3_1();
+    }
+
+    // #endregion Public Methods (4)
+
+    // #region Private Methods (1)
+
+    private cleanSettings(json: ISettingsV3_1) {
+        for(let c in json.camera.cameras) {
+            const camera = json.camera.cameras[c];
+            if(camera.type === 'perspective') {
+                const restrictions = (<any>camera.controls).restrictions;
+                if(restrictions.position.cube.min.x === null) restrictions.position.cube.min.x = -Infinity;
+                if(restrictions.position.cube.min.y === null) restrictions.position.cube.min.y = -Infinity;
+                if(restrictions.position.cube.min.z === null) restrictions.position.cube.min.z = -Infinity;
+                if(restrictions.position.cube.max.x === null) restrictions.position.cube.max.x = Infinity;
+                if(restrictions.position.cube.max.y === null) restrictions.position.cube.max.y = Infinity;
+                if(restrictions.position.cube.max.z === null) restrictions.position.cube.max.z = Infinity;
+                if(restrictions.position.sphere.radius === null) restrictions.position.sphere.radius = Infinity;
+                if(restrictions.target.cube.min.x === null) restrictions.target.cube.min.x = -Infinity;
+                if(restrictions.target.cube.min.y === null) restrictions.target.cube.min.y = -Infinity;
+                if(restrictions.target.cube.min.z === null) restrictions.target.cube.min.z = -Infinity;
+                if(restrictions.target.cube.max.x === null) restrictions.target.cube.max.x = Infinity;
+                if(restrictions.target.cube.max.y === null) restrictions.target.cube.max.y = Infinity;
+                if(restrictions.target.cube.max.z === null) restrictions.target.cube.max.z = Infinity;
+                if(restrictions.target.sphere.radius === null) restrictions.target.sphere.radius = Infinity;
+                if(restrictions.rotation.minAzimuthAngle === null) restrictions.rotation.minAzimuthAngle = -Infinity;
+                if(restrictions.rotation.maxAzimuthAngle === null) restrictions.rotation.maxAzimuthAngle = Infinity;
+                if(restrictions.zoom.maxDistance === null) restrictions.zoom.maxDistance = Infinity;
+            }
+        }
+    }
+
+    // #endregion Private Methods (1)
+}

package/src/state-engine/StateEngine.ts

@@ -0,0 +1,73 @@
+import { container, singleton } from 'tsyringe'
+
+import { EventEngine } from '../index'
+import { StatePromise } from './StatePromise'
+
+@singleton()
+export class StateEngine {
+    // #region Properties (8)
+
+    private readonly _customStates: {
+        [key: string]: StatePromise<boolean>
+    } = {};
+    private readonly _eventEngine: EventEngine = <EventEngine>container.resolve(EventEngine);
+    private readonly _fontLoaded: StatePromise<boolean>;
+    private readonly _sessionEngines: {
+        [key: string]: {
+            id: string,
+            initialized: StatePromise<boolean>,
+            settingsRegistered: StatePromise<boolean>,
+        }
+    } = {};
+    private readonly _renderingEngines: {
+        [key: string]: {
+            id: string,
+            initialized: StatePromise<boolean>,
+            settingsAssigned: StatePromise<boolean>,
+            environmentMapLoaded: StatePromise<boolean>,
+            boundingBoxCreated: StatePromise<boolean>,
+            busy: string[]
+        }
+    } = {};
+
+    // #endregion Properties (8)
+
+    // #region Constructors (1)
+
+    constructor() {
+        this._fontLoaded = new StatePromise();
+    }
+
+    // #endregion Constructors (1)
+
+    // #region Public Accessors (7)
+
+    public get fontLoaded(): StatePromise<boolean> {
+        return this._fontLoaded;
+    }
+
+    public get sessionEngines(): {
+        [key: string]: {
+            id: string,
+            initialized: StatePromise<boolean>,
+            settingsRegistered: StatePromise<boolean>,
+        }
+    } {
+        return this._sessionEngines;
+    }
+
+    public get renderingEngines(): {
+        [key: string]: {
+            id: string,
+            initialized: StatePromise<boolean>,
+            settingsAssigned: StatePromise<boolean>,
+            environmentMapLoaded: StatePromise<boolean>,
+            boundingBoxCreated: StatePromise<boolean>,
+            busy: string[]
+        }
+    } {
+        return this._renderingEngines;
+    }
+
+    // #endregion Public Accessors (7)
+}

package/src/state-engine/StatePromise.ts

@@ -0,0 +1,54 @@
+export class StatePromise<T> {
+    private _resolved: boolean = false;
+    private _resolve!: (value: T | PromiseLike<T>) => void;
+    private _reject!: (value: T | PromiseLike<T>) => void;
+
+    private _promise: Promise<T>;
+    private _callbacks: (() => void)[] = [];
+
+    constructor() {
+        this._promise = new Promise((resolve, reject) => {
+            this._resolve = resolve;
+            this._reject = reject;
+        });
+        
+        this._promise.finally(() => {
+            this._resolved = true;
+        });
+    }
+
+    public get resolved(): boolean {
+        return this._resolved;
+    }
+
+    public get resolve(): (value: T | PromiseLike<T>) => void {
+        return this._resolve;
+    }
+
+    public get reject(): (value: T | PromiseLike<T>) => void {
+        return this._reject;
+    }
+
+    public async then(callback: () => void ) {
+        this._callbacks.push(callback);
+        this.resolved === true ? callback() : this._promise.then(callback);
+    }
+
+    public reset() {
+        this._resolved = false;
+        
+        this._promise = new Promise((resolve, reject) => {
+            this._resolve = resolve;
+            this._reject = reject;
+        });
+        
+        this._promise.finally(() => {
+            this._resolved = true;
+        });
+
+        const callbackCopy = [...this._callbacks];
+        this._callbacks = [];
+        for(let i = 0; i < callbackCopy.length; i++)
+            this.then(callbackCopy[i])
+    }
+}

package/src/system-info/SystemInfo.ts

@@ -0,0 +1,117 @@
+import { singleton } from 'tsyringe'
+import UAParser from 'ua-parser-js';
+
+@singleton()
+export class SystemInfo {
+
+    private readonly _isBrowser: boolean;
+    private readonly _isIframe: boolean;
+    private readonly _origin: string;
+    private readonly _parser: UAParser;
+
+    constructor() {
+        this._parser = new UAParser();
+        const isInternetExplorer = typeof window !== 'undefined' && window.navigator && window.navigator.userAgent.indexOf('Trident') > -1;
+        this._isBrowser = isInternetExplorer ||
+            (typeof document !== 'undefined'
+                && typeof document.getElementById === 'function'
+                && window
+                && typeof window.Event === 'function'
+            );
+        this._isIframe = false;
+        if (this._isBrowser) {
+            // in case we are running in an iframe, parent and window are different, in
+            // that case we use the referrer
+            this._isIframe = parent !== window;
+            this._origin = this._isIframe ? document.referrer : window.location.origin;
+        } else {
+            this._origin = 'direct';
+        }
+    }
+
+    /**
+     * Check if we are on a Mac OS device
+     */
+    public get isMacOS(): boolean {
+        const osName = this._parser.getOS().name;
+        return osName === 'Mac OS';
+    };
+
+    /**
+     * Check if we are on an IOS device
+     */
+    public get isIOS(): boolean {
+        const osName = this._parser.getOS().name;
+        return osName === 'iOS' || 
+        (window.navigator && window.navigator.maxTouchPoints === 5 && window.navigator.platform === 'MacIntel');
+    };
+
+    /**
+     * Check if we are on an Android device
+     */
+    public get isAndroid(): boolean {
+        const osName = this._parser.getOS().name;
+        return osName === 'Android';
+    };
+
+    /**
+     * Check if we are on a mobile device
+     */
+    public get isMobile(): boolean {
+        const type = this._parser.getDevice().type;
+        return type === 'mobile' || type === 'tablet';
+    };
+
+    /**
+     * Check if we are running in internet explorer (arrrggghhhh!!!!)
+     */
+    public get isIE(): boolean {
+        const browserName = this._parser.getBrowser().name;
+        return !!(browserName && browserName.includes('IE'));
+    };
+
+    /**
+     * Check if we are running in Safari
+     */
+    public get isChrome(): boolean {
+        const browserName = this._parser.getBrowser().name;
+        return !!(browserName && browserName.includes('Chrome'));
+    };
+
+    /**
+     * Check if we are running in Safari
+     */
+    public get isSafari(): boolean {
+        const browserName = this._parser.getBrowser().name;
+        return !!(browserName && browserName.includes('Safari'));
+    };
+
+    /**
+     * Check if we are running in Firefox
+     */
+    public get isFirefox(): boolean {
+        const browserName = this._parser.getBrowser().name;
+        return !!(browserName && browserName.includes('Firefox'));
+    };
+
+    /**
+     * Check if we are running in a browser
+     */
+    public get isBrowser(): boolean {
+        return this._isBrowser;
+    };
+
+    /**
+     * Check if we are running in an iframe
+     */
+    public get isIframe(): boolean {
+        return this._isIframe;
+    };
+
+    /**
+     * Get guessed origin of embedding website
+     */
+    public get origin(): string {
+        return this._origin + '';
+    };
+}

package/src/type-check/TypeChecker.ts

@@ -0,0 +1,13 @@
+import { singleton } from 'tsyringe'
+
+@singleton()
+export class TypeChecker {
+
+    public isTypeOf(value: any, type: string): boolean {
+        return typeof value === type;
+    }
+
+    public isHTMLCanvasElement(value: any): boolean {
+        return value instanceof HTMLCanvasElement;
+    }
+}

package/src/uuid-generator/UuidGenerator.ts

@@ -0,0 +1,41 @@
+import { singleton } from 'tsyringe'
+import { parse as parseUUID, stringify as stringifyUUID, v4, validate as validateUUID } from 'uuid'
+
+@singleton()
+export class UuidGenerator {
+    /**
+     * Creates a new uuid v4.
+     */
+    public create(): string {
+        return v4();
+    };
+
+    /**
+     * Checks if the provided string is a valid uuid.
+     * 
+     * @param uuid the uuid to check
+     */
+    public validate(uuid: string): boolean {
+        return validateUUID(uuid);
+    };
+
+    /**
+     * Parse the uuid to array of bytes
+     * 
+     * @param uuid the uuid to convert
+     * @returns ArrayLike collection of 16 values
+     */
+    public parse(uuid: string): ArrayLike<number> {
+        return parseUUID(uuid);
+    };
+
+    /**
+     * Stringify an array of bytes to an uuid
+     * 
+     * @param uuid the array of bytes
+     * @returns the converted uuid
+     */
+    public stringify(uuid: ArrayLike<number>): string {
+        return stringifyUUID(uuid);
+    };
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+    "extends": "../../tsconfig.json",
+    "include": [
+        "./**/*.ts"
+    ],
+    "compilerOptions": {
+        "rootDir": "src",
+        "outDir": "dist"
+    },
+    "exclude": [
+        "__tests__",
+        "node_modules",
+        "dist",
+        "dist-dev",
+        "dist-prod"
+    ]
+}