@shapediver/viewer.shared.services 2.12.7 → 3.0.0

package/src/settings-engine/SettingsEngine.ts

@@ -1,29 +1,37 @@
-import { convert, validate, Defaults, ISettings, versions, latestVersion } from '@shapediver/viewer.settings';
-
-import { EventEngine } from '../event-engine/EventEngine'
-import { Logger } from '../logger/Logger';
+import {
+    convert,
+    Defaults,
+    ISettings,
+    latestVersion,
+    previousVersion,
+    validate
+} from '@shapediver/viewer.settings';
 import { ShapeDiverViewerSettingsError } from '../logger/ShapeDiverViewerErrors';
 
-type IARSettings = ISettings["ar"];
-type ICameraSettings = ISettings["camera"];
-type IEnvironmentSettings = ISettings["environment"];
-type IEnvironmentGeometrySettings = ISettings["environmentGeometry"];
-type IGeneralSettings = ISettings["general"];
-type ILightSettings = ISettings["light"];
-type IRenderingSettings = ISettings["rendering"];
-type ISessionSettings = ISettings["session"];
+// #region Type aliases (8)
+
+type IARSettings = ISettings['ar'];
+type ICameraSettings = ISettings['camera'];
+type IEnvironmentGeometrySettings = ISettings['environmentGeometry'];
+type IEnvironmentSettings = ISettings['environment'];
+type IGeneralSettings = ISettings['general'];
+type ILightSettings = ISettings['light'];
+type IRenderingSettings = ISettings['rendering'];
+type ISessionSettings = ISettings['session'];
+
+// #endregion Type aliases (8)
+
+// #region Classes (1)
 
 export class SettingsEngine {
-    // #region Properties (8)
+    // #region Properties (4)
 
-    private readonly _eventEngine: EventEngine = EventEngine.instance;
-    private readonly _logger: Logger = Logger.instance;
-    private readonly _settings: ISettings = Defaults();
-    private _settingsJson: any;
+    private _settings: ISettings = Defaults();
+    private _settingsJson: unknown;
 
-    // #endregion Properties (8)
+    // #endregion Properties (4)
 
-    // #region Public Accessors (10)
+    // #region Public Getters And Setters (11)
 
     public get ar(): IARSettings {
         return this._settings.ar;
@@ -64,98 +72,111 @@ export class SettingsEngine {
     public get settings(): ISettings {
         return this._settings;
     }
-    
-    public get settingsJson(): any {
+
+    public get settingsJson(): unknown {
         return this._settingsJson;
     }
 
-    // #endregion Public Accessors (10)
-
-    // #region Public Methods (4)
-
-    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);
-    }
+    // #endregion Public Getters And Setters (11)
+
+    // #region Public Methods (2)
 
-    public loadSettings(json: any) {
+    public loadSettings(json: unknown) {
         this._settingsJson = json;
         if (JSON.stringify(json) !== JSON.stringify({})) {
+            for (let i = 0; i < previousVersion.length; i++) {
+                const v = previousVersion[i];
 
-            const prevVersions = ['1.0', '2.0', '3.0', '3.1', '3.2', '3.3', '3.4', '4.0'];
-            for(let i = 0; i < prevVersions.length; i++) {
-                const v = prevVersions[i];
-
-                try { 
-                    validate(json, v as versions);             
-                    (<any>this._settings) = convert(json, latestVersion);
+                try {
+                    validate(json, v);
+                    this._settings = convert(json, latestVersion) as ISettings;
                     this.cleanSettings(this._settings);
                     return;
-                } catch (e) {}
+                } catch (e) {
+                    // it's ok, we just try the next version
+                    // only the latest version is expected to be valid
+                }
             }
 
-            try { 
-                validate(json, latestVersion);             
-                (<any>this._settings) = convert(json, latestVersion);
+            try {
+                validate(json, latestVersion);
+                this._settings = convert(json, latestVersion) as ISettings;
                 this.cleanSettings(this._settings);
                 return;
             } catch (e) {
                 throw new ShapeDiverViewerSettingsError('SettingsEngine.loadSettings: Settings could not be validated. ' + (<Error>e).message, <Error>e);
             }
         } else {
-            (<any>this._settings) = Defaults();
+            this._settings = Defaults();
             return;
         }
     }
 
     public reset() {
-        (<any>this._settings) = Defaults();
+        this._settings = Defaults();
     }
 
-    // #endregion Public Methods (4)
+    // #endregion Public Methods (2)
 
     // #region Private Methods (1)
 
     private cleanSettings(json: ISettings) {
-        for(let c in json.camera.cameras) {
+        for (const 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;
+            if (camera.type === 'perspective') {
+                const restrictions = 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)
-}
+}
+
+// #endregion Classes (1)
+
+// #region Enums (1)
+
+/**
+ * Session settings to be used by a viewport.
+ * 
+ * The {@link https://help.shapediver.com/doc/Geometry-Backend.1863942173.html|ShapeDiver Geometry Backend} 
+ * allows to persist settings of the viewer, individually for each model that it hosts. Persisting the settings
+ * of the viewer requires permissions which are typically only granted to the owner of the model. Editing
+ * of the settings typically happens on the model edit page of the ShapeDiver Platform.
+ * 
+ * Whenever an instance of the viewer creates a session with a model, the settings are made available to the viewer.
+ * It is possible to use multiple sessions with different models from a single instance of the viewer. 
+ * Therefore the viewer offers a choice on which settings to use.
+ */
+export enum SESSION_SETTINGS_MODE {
+    /** No settings of a session will be used for the viewport. */
+    NONE = 'none',
+    /** 
+     * The settings of the very first session created will be used for the viewport. 
+     */
+    FIRST = 'first',
+    /** 
+     * Use this mode in case you want to assign a specific session identifier 
+     * to the viewport, whose settings will be used.
+     */
+    MANUAL = 'manual',
+}
+
+// #endregion Enums (1)

package/src/state-engine/ISessionGlobalAccessObjectDefinition.ts

@@ -0,0 +1,25 @@
+import { SettingsEngine } from '../settings-engine/SettingsEngine';
+import { ShapeDiverRequestGltfUploadQueryConversion, ShapeDiverResponseDto } from '@shapediver/sdk.geometry-api-sdk-v2';
+import { StatePromise } from './StatePromise';
+
+/**
+ * Interface for the global access definition of a session.
+ * This interface is used to define the properties and methods that are available via the state engine for a session.
+ * This means that they can be called without having a direct reference to the session engine.
+ */
+export interface ISessionGlobalAccessObjectDefinition {
+    // #region Properties (9)
+
+    readonly canUploadGLTF: boolean,
+    readonly id: string,
+    readonly initialOutputsLoaded: StatePromise<boolean>,
+    readonly initialized: StatePromise<boolean>,
+    readonly modelViewUrl: string,
+    readonly settingsEngine: SettingsEngine,
+    readonly settingsRegistered: StatePromise<boolean>,
+
+    isFirstSession: boolean,
+    uploadGLTF: (gltf: Blob, name: ShapeDiverRequestGltfUploadQueryConversion | undefined) => Promise<ShapeDiverResponseDto>,
+
+    // #endregion Properties (9)
+}

package/src/state-engine/IViewportGlobalAccessObjectDefinition.ts

@@ -0,0 +1,29 @@
+import { SESSION_SETTINGS_MODE, SettingsEngine } from '../settings-engine/SettingsEngine';
+import { StatePromise } from './StatePromise';
+
+/**
+ * Interface for the global access definition of a viewport.
+ * This interface is used to define the properties and methods that are available via the state engine for a viewport.
+ * This means that they can be called without having a direct reference to the viewport engine.
+ */
+export interface IViewportGlobalAccessObjectDefinition {
+    // #region Properties (14)
+
+    readonly boundingBoxCreated: StatePromise<boolean>,
+    readonly busy: string[],
+    readonly id: string,
+    readonly initialized: StatePromise<boolean>,
+    readonly sessionSettingsId?: string,
+    readonly sessionSettingsMode: SESSION_SETTINGS_MODE,
+    readonly settingsAssigned: StatePromise<boolean>,
+
+    applySettings: (sections?: { ar?: boolean, scene?: boolean, camera?: boolean, light?: boolean, environment?: boolean, general?: boolean, postprocessing?: boolean }, settingsEngine?: SettingsEngine, updateViewport?: boolean) => Promise<void>,
+    assignSettingsEngine: (settingsEngine: SettingsEngine) => void,
+    displayErrorMessage: (message: string) => void,
+    environmentMapLoaded: StatePromise<boolean>,
+    reset: () => void,
+    saveSettings: (settingsEngine?: SettingsEngine) => void,
+    update: (id: string) => void,
+
+    // #endregion Properties (14)
+}

package/src/state-engine/StateEngine.ts

@@ -1,32 +1,17 @@
-import { StatePromise } from './StatePromise'
+import { ISessionGlobalAccessObjectDefinition } from './ISessionGlobalAccessObjectDefinition';
+import { IViewportGlobalAccessObjectDefinition } from './IViewportGlobalAccessObjectDefinition';
+import { StatePromise } from './StatePromise';
 
 export class StateEngine {
-    // #region Properties (6)
+    // #region Properties (4)
 
     private readonly _fontLoaded: StatePromise<boolean> = new StatePromise();
-    private readonly _renderingEngines: {
-        [key: string]: {
-            id: string,
-            initialized: StatePromise<boolean>,
-            settingsAssigned: StatePromise<boolean>,
-            environmentMapLoaded: StatePromise<boolean>,
-            boundingBoxCreated: StatePromise<boolean>,
-            busy: string[],
-            update: (id: string) => void
-        }
-    } = {};
-    private readonly _sessionEngines: {
-        [key: string]: {
-            id: string,
-            initialized: StatePromise<boolean>,
-            initialOutputsLoaded: StatePromise<boolean>,
-            settingsRegistered: StatePromise<boolean>,
-        }
-    } = {};
+    private readonly _sessionEngines: { [key: string]: ISessionGlobalAccessObjectDefinition } = {};
+    private readonly _viewportEngines: { [key: string]: IViewportGlobalAccessObjectDefinition } = {};
 
     private static _instance: StateEngine;
 
-    // #endregion Properties (6)
+    // #endregion Properties (4)
 
     // #region Constructors (1)
 
@@ -36,44 +21,27 @@ export class StateEngine {
 
     // #endregion Constructors (1)
 
-    // #region Public Static Accessors (1)
+    // #region Public Static Getters And Setters (1)
 
     public static get instance() {
         return this._instance || (this._instance = new this());
     }
 
-    // #endregion Public Static Accessors (1)
+    // #endregion Public Static Getters And Setters (1)
 
-    // #region Public Accessors (3)
+    // #region Public Getters And Setters (3)
 
     public get fontLoaded(): StatePromise<boolean> {
         return this._fontLoaded;
     }
 
-    public get renderingEngines(): {
-        [key: string]: {
-            id: string,
-            initialized: StatePromise<boolean>,
-            settingsAssigned: StatePromise<boolean>,
-            environmentMapLoaded: StatePromise<boolean>,
-            boundingBoxCreated: StatePromise<boolean>,
-            busy: string[],
-            update: (id: string) => void
-        }
-    } {
-        return this._renderingEngines;
+    public get sessionEngines(): { [key: string]: ISessionGlobalAccessObjectDefinition } {
+        return this._sessionEngines;
     }
 
-    public get sessionEngines(): {
-        [key: string]: {
-            id: string,
-            initialized: StatePromise<boolean>,
-            initialOutputsLoaded: StatePromise<boolean>,
-            settingsRegistered: StatePromise<boolean>,
-        }
-    } {
-        return this._sessionEngines;
+    public get viewportEngines(): { [key: string]: IViewportGlobalAccessObjectDefinition } {
+        return this._viewportEngines;
     }
 
-    // #endregion Public Accessors (3)
-}
+    // #endregion Public Getters And Setters (3)
+}

package/src/system-info/SystemInfo.ts

@@ -91,7 +91,7 @@ export class SystemInfo {
     public get isIOS(): boolean {
         const osName = this._parser.getOS().name;
         return osName === 'iOS' || 
-        (window.navigator && window.navigator.maxTouchPoints === 5 && window.navigator.platform === 'MacIntel');
+        (typeof window !== undefined && window.navigator && window.navigator.maxTouchPoints === 5 && window.navigator.platform === 'MacIntel');
     }
 
     /**

package/src/utilities/base64.ts

@@ -0,0 +1,15 @@
+export const atobCustom = (str: string): string => {
+    if(typeof window !== 'undefined' && window.atob) {
+        return window.atob(str);
+    } else {
+        return Buffer.from(str, 'base64').toString();
+    }
+};
+
+export const btoaCustom = (str: string): string => {
+    if(typeof window !== 'undefined' && window.btoa) {
+        return window.btoa(str);
+    } else {
+        return Buffer.from(str).toString('base64');
+    }
+};