@shapediver/viewer.shared.services 1.15.5 → 2.0.0

package/src/event-engine/EventEngine.ts

@@ -0,0 +1,116 @@
+import { container, singleton } from 'tsyringe'
+
+import { EVENTTYPE, MainEventTypes } from './EventTypes'
+import { IListener } from './interfaces/IListener'
+import { ICallback } from './interfaces/ICallback'
+import { IEvent } from './interfaces/IEvent'
+import { UuidGenerator } from '../uuid-generator/UuidGenerator'
+import { Logger, LOGGING_TOPIC } from '../logger/Logger'
+
+@singleton()
+export class EventEngine {
+    // #region Properties (2)
+
+    protected readonly _uuidGenerator: UuidGenerator = <UuidGenerator>container.resolve(UuidGenerator);
+    protected readonly _logger: Logger = <Logger>container.resolve(Logger);
+    private _eventListeners: {
+        [key: string]: IListener[]
+    };
+
+    // #endregion Properties (2)
+
+    // #region Constructors (1)
+
+    constructor() {
+        this._eventListeners = {};
+        for (const type in EVENTTYPE) {
+            const subEventType = EVENTTYPE[type as keyof typeof EVENTTYPE];
+            this._eventListeners[type.toLowerCase()] = [];
+            for (const subtype in subEventType) {
+                this._eventListeners[subEventType[subtype as keyof typeof subEventType]] = [];
+            }
+        }
+    }
+
+    // #endregion Constructors (1)
+
+    private convertTypeToString(type: string | MainEventTypes): string {
+        let typeString: string = '';
+        if(typeof type === 'string') typeString = type;
+
+        for (const mainType in EVENTTYPE)
+            if(type === EVENTTYPE[mainType as keyof typeof EVENTTYPE])
+                typeString = mainType.toLowerCase();
+        
+        if(!typeString || !this._eventListeners[typeString]) {
+            this._logger.warn(LOGGING_TOPIC.GENERAL, 'EventEngine.convertTypeToString: No valid type provided.');
+            return '';
+        }
+        
+        return typeString;
+    }
+
+    // #region Public Methods (3)
+
+    /**
+     * Adds a listener that listenes to the provided type. If no valid type is specified, an error is thrown.
+     * 
+     * @param type the type of the event
+     * @param cb the callback that should be called
+     * @returns an unique token to be able to remove the listener
+     */
+    public addListener(type: string | MainEventTypes, cb: ICallback): string {
+        const typeString: string = this.convertTypeToString(type);
+        if(!typeString) return '';
+        const token = this._uuidGenerator.create();
+        this._eventListeners[typeString]?.push({ token, cb });
+        return token;
+    }
+
+    /**
+     * Emits the event to all callbacks that listen to the type.
+     * 
+     * @param type the type of the event
+     * @param event the event to emit
+     */
+    public emitEvent(type: string | MainEventTypes, event: IEvent): void {
+        const typeString: string = this.convertTypeToString(type);
+
+        if (this._eventListeners[typeString] && this._eventListeners[typeString].length !== 0) 
+            for (let i = 0; i < this._eventListeners[typeString]!.length; i++)
+                this._eventListeners[typeString]![i].cb(event);
+
+        if(typeString.includes('.')) 
+            this.emitEvent(typeString.substr(0, typeString.indexOf('.')), event);
+    }
+
+    /**
+     * Removes a listener with the specified token.
+     * 
+     * @param token the token of the listener 
+     * @returns result of the targeted operation
+     */
+    public removeListener(token: string): boolean {
+        for (const type in EVENTTYPE) {
+            const subEventType = EVENTTYPE[type as keyof typeof EVENTTYPE];
+            const typeLowerCase = type.toLowerCase();
+            for (let i = 0; i < this._eventListeners[typeLowerCase]!.length; i++) {
+                if (this._eventListeners[typeLowerCase]![i].token === token) {
+                    this._eventListeners[typeLowerCase]!.splice(i, 1);
+                    return true;
+                }
+            }
+            for (const subtype in subEventType) {
+                for (let i = 0; i < this._eventListeners[subEventType[subtype as keyof typeof subEventType]]!.length; i++) {
+                    if (this._eventListeners[subEventType[subtype as keyof typeof subEventType]]![i].token === token) {
+                        this._eventListeners[subEventType[subtype as keyof typeof subEventType]]!.splice(i, 1);
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+
+    // #endregion Public Methods (3)
+}

package/src/event-engine/EventTypes.ts

@@ -0,0 +1,66 @@
+export enum EVENTTYPE_CAMERA {
+    CAMERA_START = "camera.start",
+    CAMERA_MOVE = "camera.move",
+    CAMERA_END = "camera.end",
+}
+
+export enum EVENTTYPE_RENDERING {
+    BEAUTY_RENDERING_FINISHED = "rendering.beautyRenderingFinished"
+}
+
+export enum EVENTTYPE_SCENE {
+    SCENE_BOUNDING_BOX_CHANGE = "scene.boundingBoxChange"
+}
+
+// VIEWPORT
+//     FRAMERATE
+//     RENDER_INFO
+//     RENDER_BEAUTY_START
+//     RENDER_BEAUTY_CANCEL
+//     RENDER_BEAUTY_END
+//     VISIBILITY_ON
+//     VISIBILITY_OFF
+
+export enum EVENTTYPE_VIEWPORT {
+    BUSY_MODE_ON = "viewport.busy.on",
+    BUSY_MODE_OFF = "viewport.busy.off",
+    VIEWPORT_CREATED = "viewport.created",
+    VIEWPORT_UPDATED = "viewport.updated",
+    VIEWPORT_CLOSED = "viewport.closed"
+}
+
+export enum EVENTTYPE_SESSION {
+    SESSION_CREATED = "session.created",
+    SESSION_CUSTOMIZED = "session.customized",
+    SESSION_CLOSED = "session.closed",
+    SESSION_INITIAL_OUTPUTS_LOADED = 'session.initialOutputsLoaded'
+}
+
+export enum EVENTTYPE_TASK {
+    TASK_START = "task.start",
+    TASK_PROCESS = "task.process",
+    TASK_END = "task.end",
+    TASK_CANCEL = "task.cancel",
+}
+
+export enum EVENTTYPE_INTERACTION {
+    DRAG_START = "interaction.drag.start",
+    DRAG_MOVE = "interaction.drag.move",
+    DRAG_END = "interaction.drag.end",
+    HOVER_ON = "interaction.hover.on",
+    HOVER_OFF = "interaction.hover.off",	
+    SELECT_ON = "interaction.select.on",
+    SELECT_OFF = "interaction.select.off",
+}
+
+export const EVENTTYPE = { 
+    CAMERA: EVENTTYPE_CAMERA, 
+    RENDERING: EVENTTYPE_RENDERING, 
+    SCENE: EVENTTYPE_SCENE, 
+    SESSION: EVENTTYPE_SESSION,
+    VIEWPORT: EVENTTYPE_VIEWPORT,
+    INTERACTION: EVENTTYPE_INTERACTION,
+    TASK: EVENTTYPE_TASK
+};
+
+export type MainEventTypes = typeof EVENTTYPE_CAMERA | typeof EVENTTYPE_RENDERING | typeof EVENTTYPE_SCENE | typeof EVENTTYPE_SESSION | typeof EVENTTYPE_VIEWPORT | typeof EVENTTYPE_INTERACTION | typeof EVENTTYPE_TASK;

package/src/event-engine/interfaces/ICallback.ts

@@ -0,0 +1,5 @@
+import { IEvent } from './IEvent'
+
+export interface ICallback {
+    (event: IEvent): void;
+}

package/src/event-engine/interfaces/IEvent.ts

@@ -0,0 +1 @@
+export interface IEvent {};

package/src/event-engine/interfaces/IListener.ts

@@ -0,0 +1,8 @@
+import { ICallback } from './ICallback'
+
+export interface IListener {
+    // #region Properties (2)
+    cb: ICallback;
+    token: string;
+    // #endregion Properties (2)
+}

package/src/http-client/HttpClient.ts

@@ -0,0 +1,177 @@
+import axios, { AxiosRequestConfig } from 'axios'
+import { singleton } from 'tsyringe'
+import { ShapeDiverViewerConnectionError } from '../logger/ShapeDiverViewerErrors';
+import { HttpResponse } from './HttpResponse';
+
+@singleton()
+export class HttpClient {
+    // #region Properties (2)
+
+    private _dataCache: {
+        [key: string]: Promise<HttpResponse<any>>
+    } = {};
+
+    private _sessionLoading: {
+        [key: string]: {
+            getOutput: (sessionId: string, assetData: string) => Promise<[ArrayBuffer, string]>,
+            getTexture: (sessionId: string, assetData: string) => Promise<[ArrayBuffer, string]>,
+            getExport: (sessionId: string, assetData: string) => Promise<[ArrayBuffer, string]>,
+            downloadTexture: (sessionId: string, url: string) => Promise<[ArrayBuffer, string]>,
+        }
+    } = {};
+
+    // #endregion Properties (2)
+
+    // #region Constructors (1)
+
+    constructor() {
+        axios.interceptors.response.use(
+            response => {
+                return response;
+            },
+            error => {
+                throw new ShapeDiverViewerConnectionError(error.message, error.response.status, error);
+            });
+        axios.interceptors.request.use(
+            response => {
+                return response;
+            },
+            error => {
+                throw new ShapeDiverViewerConnectionError(error.message, undefined, error);
+            });
+    }
+
+    // #endregion Constructors (1)
+
+    // #region Public Methods (7)
+
+    private loadingCriterion(href: string): { sessionId: string, assetData: string, type: 'output' | 'export' | 'texture' } | undefined {
+        // searching for "/session/SESSION_ID/{'output' | 'export' | 'texture'}/ASSET_DATA"
+        const parts = href.split('/');
+        const sessionPartIndex = parts.indexOf('session');
+
+        // There have to be at exactly 4 parts, including the session
+        if (sessionPartIndex !== -1 && parts.length === sessionPartIndex + 4) {
+            const sessionId = parts[sessionPartIndex + 1];
+            // no such session has been registered, should never happen
+            if (!this._sessionLoading[sessionId]) return;
+
+            const type = parts[sessionPartIndex + 2];
+            // the type is not supported
+            if (type !== 'output' && type !== 'export' && type !== 'texture') return;
+
+            const assetData = parts[sessionPartIndex + 3];
+
+            return { sessionId, assetData, type };
+        }
+
+        return;
+    }
+
+    public addDataLoading(sessionId: string, callbacks: {
+        getOutput: (sessionId: string, assetData: string) => Promise<[ArrayBuffer, string]>,
+        getTexture: (sessionId: string, assetData: string) => Promise<[ArrayBuffer, string]>,
+        getExport: (sessionId: string, assetData: string) => Promise<[ArrayBuffer, string]>,
+        downloadTexture: (sessionId: string, url: string) => Promise<[ArrayBuffer, string]>,
+    }) {
+        this._sessionLoading[sessionId] = callbacks;
+    }
+
+    public async get(href: string, config: AxiosRequestConfig = { responseType: 'arraybuffer' }, textureLoading: boolean = false): Promise<HttpResponse<any>> {
+        const dataKey = btoa(href);
+        if (dataKey in this._dataCache) return await this._dataCache[dataKey];
+
+        const loadingInfo = this.loadingCriterion(href);
+        if (loadingInfo) {
+            switch (loadingInfo.type) {
+                case 'output':
+                    this._dataCache[dataKey] = new Promise<HttpResponse<ArrayBuffer>>(resolve => {
+                        this._sessionLoading[loadingInfo.sessionId]
+                            .getOutput(loadingInfo.sessionId, loadingInfo.assetData)
+                            .then(result => {
+                                resolve({
+                                    data: result[0],
+                                    headers: {
+                                        'content-type': result[1]
+                                    }
+                                })
+                            })
+
+                    });
+                    break;
+
+                case 'export':
+                    this._dataCache[dataKey] = new Promise<HttpResponse<ArrayBuffer>>(resolve => {
+                        this._sessionLoading[loadingInfo.sessionId]
+                            .getExport(loadingInfo.sessionId, loadingInfo.assetData)
+                            .then(result => {
+                                resolve({
+                                    data: result[0],
+                                    headers: {
+                                        'content-type': result[1]
+                                    }
+                                })
+                            })
+
+                    });
+                    break;
+
+                case 'texture':
+                    this._dataCache[dataKey] = new Promise<HttpResponse<ArrayBuffer>>(resolve => {
+                        this._sessionLoading[loadingInfo.sessionId]
+                            .getTexture(loadingInfo.sessionId, loadingInfo.assetData)
+                            .then(result => {
+                                resolve({
+                                    data: result[0],
+                                    headers: {
+                                        'content-type': result[1]
+                                    }
+                                })
+                            })
+
+                    });
+                    break;
+
+                default:
+                    this._dataCache[dataKey] = axios(href, Object.assign({ method: 'get' }, config));
+            }
+        } else {
+            // separation texture vs something else...
+            if(textureLoading) {
+                // we can load blobs and data urls directly
+                // if no session is registered, we have to load the texture directly
+                if(href.startsWith('blob:') || href.startsWith('data:') ||  Object.values(this._sessionLoading).length === 0) {
+                    this._dataCache[dataKey] = axios(href, Object.assign({ method: 'get' }, config));
+                } else {
+                    // take first session to load a texture that is not session related
+                    const sessionId = Object.keys(this._sessionLoading)[0];
+
+                    this._dataCache[dataKey] = new Promise<HttpResponse<any>>(resolve => {
+                        this._sessionLoading[sessionId].downloadTexture(sessionId, href).then((result) => {
+                            resolve({
+                                data: result[0],
+                                headers: {
+                                    'content-type': result[1]
+                                }
+                            })
+                        });
+                    });
+                }
+            } else {
+                this._dataCache[dataKey] = axios(href, Object.assign({ method: 'get' }, config));
+            }
+        }
+
+        return this._dataCache[dataKey];
+    }
+
+    public async loadTexture(href: string): Promise<HttpResponse<ArrayBuffer>> {
+        return this.get(href, undefined, true);
+    }
+
+    public removeDataLoading(sessionId: string) {
+        delete this._sessionLoading[sessionId];
+    }
+
+    // #endregion Public Methods (7)
+}

package/src/http-client/HttpResponse.ts

@@ -0,0 +1,4 @@
+export interface HttpResponse<T = any> {
+    data: T;
+    headers: any
+}

package/src/index.ts

@@ -0,0 +1,82 @@
+import { EventEngine } from './event-engine/EventEngine'
+import { EVENTTYPE, EVENTTYPE_CAMERA, EVENTTYPE_INTERACTION, EVENTTYPE_RENDERING, EVENTTYPE_SCENE, EVENTTYPE_SESSION, EVENTTYPE_TASK, EVENTTYPE_VIEWPORT, MainEventTypes } from './event-engine/EventTypes'
+import { SettingsEngine } from './settings-engine/SettingsEngine'
+import { StateEngine } from './state-engine/StateEngine'
+import { SystemInfo } from './system-info/SystemInfo'
+import { DomEventEngine } from './dom-event-engine/DomEventEngine'
+import { IDomEventListener } from './dom-event-engine/IDomEventListener'
+import { IEvent } from './event-engine/interfaces/IEvent'
+import { Converter } from './converter/Converter'
+import { HttpClient } from './http-client/HttpClient'
+import { InputValidator } from './input-validator/InputValidator'
+import { TypeChecker } from './type-check/TypeChecker'
+import { UuidGenerator } from './uuid-generator/UuidGenerator'
+import { PerformanceEvaluator } from './performance-evaluator/PerformanceEvaluator'
+import { Logger, LOGGING_LEVEL, LOGGING_TOPIC } from './logger/Logger'
+import { StatePromise } from './state-engine/StatePromise'
+import { ShapeDiverViewerArError, ShapeDiverViewerCameraError, ShapeDiverViewerDataProcessingError, ShapeDiverViewerEnvironmentMapError, ShapeDiverViewerLightError, ShapeDiverViewerSessionError, ShapeDiverViewerSettingsError, ShapeDiverViewerUnknownError, ShapeDiverViewerValidationError, ShapeDiverViewerGeneralError, ShapeDiverViewerWebGLError } from './logger/ShapeDiverViewerErrors'
+import { ShapeDiverError as ShapeDiverBackendError } from '@shapediver/sdk.geometry-api-sdk-v2'
+import { ShapeDiverViewerError } from './logger/ShapeDiverError'
+import { HttpResponse } from './http-client/HttpResponse'
+
+export {
+  EventEngine, EVENTTYPE, MainEventTypes, IEvent,
+  EVENTTYPE_CAMERA, EVENTTYPE_RENDERING, EVENTTYPE_SCENE, EVENTTYPE_SESSION, EVENTTYPE_VIEWPORT, EVENTTYPE_INTERACTION, EVENTTYPE_TASK
+}
+
+export {
+    SettingsEngine
+}
+
+export {
+    StateEngine, StatePromise
+}
+
+export {
+    SystemInfo
+}
+
+export {
+    IDomEventListener, DomEventEngine
+}
+
+export {
+    HttpClient, HttpResponse
+}
+
+export {
+    UuidGenerator
+}
+
+export {
+    Converter
+}
+
+export {
+    TypeChecker
+}
+
+export {
+    InputValidator
+}
+
+export {
+    Logger, LOGGING_LEVEL, LOGGING_TOPIC, 
+    ShapeDiverViewerError, 
+    ShapeDiverViewerDataProcessingError, 
+    ShapeDiverViewerEnvironmentMapError,
+    ShapeDiverViewerWebGLError,
+    ShapeDiverViewerSettingsError,
+    ShapeDiverViewerSessionError,
+    ShapeDiverViewerGeneralError,
+    ShapeDiverViewerUnknownError, 
+    ShapeDiverViewerArError,
+    ShapeDiverViewerLightError,
+    ShapeDiverViewerCameraError,
+    ShapeDiverViewerValidationError,
+    ShapeDiverBackendError
+}
+
+export {
+    PerformanceEvaluator
+}

package/src/input-validator/InputValidator.ts

@@ -0,0 +1,100 @@
+import { container, singleton } from 'tsyringe'
+import DOMPurify from 'dompurify';
+import { Logger, LOGGING_TOPIC } from '../logger/Logger'
+import { ShapeDiverViewerValidationError } from '../logger/ShapeDiverViewerErrors';
+import { TypeChecker } from '../type-check/TypeChecker'
+
+export type Types = 'string' | 'boolean' | 'function' |
+                    'HTMLCanvasElement' | 'enum' | 
+                    'number' | 'factor' | 'positive' |
+                    'vec3' | 'mat4' | 'cubeMap' | 'array' | 'stringArray' | 'object' | 'file' | 'color';
+
+@singleton()
+export class InputValidator {
+
+    private readonly _logger: Logger = <Logger>container.resolve(Logger);
+    private readonly _typeChecker: TypeChecker = <TypeChecker>container.resolve(TypeChecker);
+
+    public validateAndError(topic: LOGGING_TOPIC, scope: string, value: any, type: Types, defined: boolean = true, enumValues: string[] = []) {
+        const res = this.validate(value, type, defined, enumValues);
+        if(res) return;
+
+        const error = new ShapeDiverViewerValidationError(`${scope}: Input could not be validated. ${value} is not of type ${type}.${defined === false ? ' (Can also be undefined)' : ''}`, value, type);
+        throw this._logger.handleError(LOGGING_TOPIC.GENERAL, 'InputValidator.validateAndError', error, false);
+    }
+
+    private validate(value: any, stringLiteral: Types, defined: boolean = true, enumValues: string[] = []): boolean {
+        if (defined === false && typeof value === 'undefined') return true;
+
+        switch (stringLiteral) {
+            case 'array':
+                if(Array.isArray(value)) return true;
+                break;
+            case 'string':
+                if(this._typeChecker.isTypeOf(value, 'string')) return true;
+                break;
+            case 'boolean':
+                if(this._typeChecker.isTypeOf(value, 'boolean')) return true;
+                break;
+            case 'function':
+                if(this._typeChecker.isTypeOf(value, 'function')) return true;
+                break;
+            case 'number':
+                if(this._typeChecker.isTypeOf(value, 'number') && !isNaN(value)) return true;
+                break;
+            case 'factor':
+                if(this._typeChecker.isTypeOf(value, 'number') && value >= 0 && value <= 1) return true;
+                break;
+            case 'positive':
+                if(this._typeChecker.isTypeOf(value, 'number') && value >= 0) return true;
+                break;
+            case 'HTMLCanvasElement':
+                if(this._typeChecker.isHTMLCanvasElement(value)) return true;
+                break;
+            case 'enum':
+                if(this._typeChecker.isTypeOf(value, 'string') && enumValues.includes(value)) return true;
+                break;
+            case 'vec3':
+                if (value.constructor === Float32Array)
+                    value = Array.from(value);
+                if(Array.isArray(value) && this._typeChecker.isTypeOf(value[0], 'number') && this._typeChecker.isTypeOf(value[1], 'number') && this._typeChecker.isTypeOf(value[2], 'number')) return true;
+                break;
+            case 'cubeMap':
+                if(Array.isArray(value) && value.length === 6 && this._typeChecker.isTypeOf(value[0], 'string') && this._typeChecker.isTypeOf(value[1], 'string') && this._typeChecker.isTypeOf(value[2], 'string') && this._typeChecker.isTypeOf(value[3], 'string') && this._typeChecker.isTypeOf(value[4], 'string') && this._typeChecker.isTypeOf(value[5], 'string')) return true;
+                if(this._typeChecker.isTypeOf(value, 'string')) return true;
+                break;
+            case 'stringArray':
+                if(Array.isArray(value)) {
+                    let check = true;
+                    for(let i = 0; i < value.length; i++)
+                        if(typeof value[i] !== 'string') check = false;
+                    if (check === true) return true;
+                }
+                break;
+            case 'object':
+                if(this._typeChecker.isTypeOf(value, 'object')) return true;
+                break;
+            case 'file':
+                if(this._typeChecker.isTypeOf(value, 'string') || value instanceof File || value instanceof Blob) return true;
+                break;
+            case 'color':
+                if(this._typeChecker.isTypeOf(value, 'string') || (Array.isArray(value) && this._typeChecker.isTypeOf(value[0], 'number') && this._typeChecker.isTypeOf(value[1], 'number') && this._typeChecker.isTypeOf(value[2], 'number')) || this._typeChecker.isTypeOf(value, 'number')) return true;
+                break;
+            case 'mat4':
+                if (value.constructor === Float32Array)
+                    value = Array.from(value);
+                if(Array.isArray(value) && this._typeChecker.isTypeOf(value[0], 'number') && this._typeChecker.isTypeOf(value[1], 'number') && this._typeChecker.isTypeOf(value[2], 'number') && this._typeChecker.isTypeOf(value[3], 'number')
+                    && this._typeChecker.isTypeOf(value[4], 'number') && this._typeChecker.isTypeOf(value[5], 'number') && this._typeChecker.isTypeOf(value[6], 'number') && this._typeChecker.isTypeOf(value[7], 'number')
+                    && this._typeChecker.isTypeOf(value[8], 'number') && this._typeChecker.isTypeOf(value[9], 'number') && this._typeChecker.isTypeOf(value[10], 'number') && this._typeChecker.isTypeOf(value[11], 'number')
+                    && this._typeChecker.isTypeOf(value[12], 'number') && this._typeChecker.isTypeOf(value[13], 'number') && this._typeChecker.isTypeOf(value[14], 'number') && this._typeChecker.isTypeOf(value[15], 'number')) return true;
+                break;
+            default:
+                return false;
+        }
+        return false;
+    }
+
+    public sanitize(input: string): string {
+        return DOMPurify.sanitize(input);
+    }
+}