@shapediver/viewer.shared.services 2.12.8 → 3.0.0

package/src/event-engine/EventTypes.ts

@@ -1,75 +1,265 @@
+/**
+ * Event types for all camera events
+ * The camera events are used to notify about camera changes, like start, move and end of camera movement.
+ * The events that are sent with the camera events are of type {@link ICameraEvent}. The {@link EventResponseMapping} can used to map the event type to the corresponding event interface.
+ * 
+ * @enum {string}
+ */
 export enum EVENTTYPE_CAMERA {
-    CAMERA_START = "camera.start",
-    CAMERA_MOVE = "camera.move",
-    CAMERA_END = "camera.end",
+    /**
+     * The CAMERA_START-event is sent when the camera starts moving.
+     */
+    CAMERA_START = 'camera.start',
+    /**
+     * The CAMERA_MOVE-event is sent when the camera moves.
+     */
+    CAMERA_MOVE = 'camera.move',
+    /**
+     * The CAMERA_END-event is sent when the camera stops moving.
+     */
+    CAMERA_END = 'camera.end',
 }
 
+/**
+ * Event types for all rendering events
+ * The rendering events are used to notify about specific rendering events, like the finishing of the beauty rendering.
+ * The events that are sent with the rendering events are of type {@link IRenderingEvent}. The {@link EventResponseMapping} can used to map the event type to the corresponding event interface.
+ */
 export enum EVENTTYPE_RENDERING {
-    BEAUTY_RENDERING_FINISHED = "rendering.beautyRenderingFinished"
+    /**
+     * The BEAUTY_RENDERING_FINISHED-event is sent when the beauty rendering has finished.
+     */
+    BEAUTY_RENDERING_FINISHED = 'rendering.beautyRenderingFinished'
 }
 
+/**
+ * Event types for all scene events
+ * The scene events are used to notify about scene changes, like bounding box changes or empty bounding boxes.
+ * The events that are sent with the scene events are of type {@link ISceneEvent}. The {@link EventResponseMapping} can used to map the event type to the corresponding event interface.
+ */
 export enum EVENTTYPE_SCENE {
-    SCENE_BOUNDING_BOX_CHANGE = "scene.boundingBoxChange",
-    SCENE_BOUNDING_BOX_EMPTY = "scene.boundingBoxEmpty"
+    /**
+     * The SCENE_BOUNDING_BOX_CHANGE-event is sent when the bounding box of the scene has changed.
+     */
+    SCENE_BOUNDING_BOX_CHANGE = 'scene.boundingBoxChange',
+    /**
+     * TheSCENE_BOUNDING_BOX_EMPTY-event is sent when the bounding box of the scene is empty.
+     */
+    SCENE_BOUNDING_BOX_EMPTY = 'scene.boundingBoxEmpty'
 }
 
-// VIEWPORT
-//     FRAMERATE
-//     RENDER_INFO
-//     RENDER_BEAUTY_START
-//     RENDER_BEAUTY_CANCEL
-//     RENDER_BEAUTY_END
-//     VISIBILITY_ON
-//     VISIBILITY_OFF
-
+/**
+ * Event types for all viewport events
+ * The viewport events are used to notify about viewport changes, like creation, update, closing, visibility changes or loading of settings.
+ * The events that are sent with the viewport events are of type {@link IViewportEvent}. The {@link EventResponseMapping} can used to map the event type to the corresponding event interface.
+ */
 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",
-    VIEWPORT_SETTINGS_LOADED = "viewport.settingsLoaded",
-    VIEWPORT_VISIBLE = "viewport.visible",
-    VIEWPORT_HIDDEN = "viewport.hidden",
+    /**
+     * The BUSY_MODE_ON-event is sent when the busy mode of the viewport has started.
+     */
+    BUSY_MODE_ON = 'viewport.busy.on',
+    /**
+     * The BUSY_MODE_OFF-event is sent when the busy mode of the viewport has ended.
+     */
+    BUSY_MODE_OFF = 'viewport.busy.off',
+    /**
+     * The VIEWPORT_CREATED-event is sent when the viewport has been created.
+     */
+    VIEWPORT_CREATED = 'viewport.created',
+    /**
+     * The VIEWPORT_UPDATED-event is sent when the viewport has been updated.
+     */
+    VIEWPORT_UPDATED = 'viewport.updated',
+    /**
+     * The VIEWPORT_CLOSED-event is sent when the viewport has been closed.
+     */
+    VIEWPORT_CLOSED = 'viewport.closed',
+    /**
+     * The VIEWPORT_SETTINGS_LOADED-event is sent when the settings of the viewport have been loaded.
+     */
+    VIEWPORT_SETTINGS_LOADED = 'viewport.settingsLoaded',
+    /**
+     * The VIEWPORT_VISIBLE-event is sent when the viewport has become visible.
+     */
+    VIEWPORT_VISIBLE = 'viewport.visible',
+    /**
+     * The VIEWPORT_HIDDEN-event is sent when the viewport has become hidden.
+     */
+    VIEWPORT_HIDDEN = 'viewport.hidden',
 }
 
+/**
+ * Event types for all session events
+ * The session events are used to notify about session changes, like creation, customization, closing, loading of initial outputs or delayed loading of SDTF.
+ * The events that are sent with the session events are of type {@link ISessionEvent}. The {@link EventResponseMapping} can used to map the event type to the corresponding event interface.
+ */
 export enum EVENTTYPE_SESSION {
-    SESSION_CREATED = "session.created",
-    SESSION_CUSTOMIZED = "session.customized",
-    SESSION_CLOSED = "session.closed",
-    SESSION_INITIAL_OUTPUTS_LOADED = 'session.initialOutputsLoaded'
+    /**
+     * The SESSION_CREATED-event is sent when the session has been created.
+     */
+    SESSION_CREATED = 'session.created',
+    /**
+     * The SESSION_CUSTOMIZED-event is sent when the session has been customized.
+     */
+    SESSION_CUSTOMIZED = 'session.customized',
+    /**
+     * The SESSION_CLOSED-event is sent when the session has been closed.
+     */
+    SESSION_CLOSED = 'session.closed',
+    /**
+     * The SESSION_INITIAL_OUTPUTS_LOADED-event is sent when the initial outputs of the session have been loaded.
+     */
+    SESSION_INITIAL_OUTPUTS_LOADED = 'session.initialOutputsLoaded',
+    /**
+     * The SESSION_SDTF_DELAYED_LOADED-event is sent when the SDTF of the session has been delayed loaded.
+     */
+    SESSION_SDTF_DELAYED_LOADED = 'session.sdtfDelayedLoaded',
+}
+
+/**
+ * Event types for all parameter events
+ * The parameter events are used to notify about parameter changes, like value changes or session value changes.
+ * The events that are sent with the parameter events are of type {@link IParameterEvent}. The {@link EventResponseMapping} can used to map the event type to the corresponding event interface.
+ */
+export enum EVENTTYPE_PARAMETER {
+    /**
+     * The PARAMETER_VALUE_CHANGED-event is sent when the value of a parameter has changed.
+     */
+    PARAMETER_VALUE_CHANGED = 'parameter.valueChanged',
+    /**
+     * The PARAMETER_SESSION_VALUE_CHANGED-event is sent when the session value of a parameter has changed.
+     */
+    PARAMETER_SESSION_VALUE_CHANGED = 'parameter.sessionValueChanged'
 }
 
+/**
+ * Event types for all output events
+ * The output events are used to notify about output changes, like updated outputs.
+ * The events that are sent with the output events are of type {@link IOutputEvent}. The {@link EventResponseMapping} can used to map the event type to the corresponding event interface.
+ */
 export enum EVENTTYPE_OUTPUT {
-    OUTPUT_UPDATED = "output.updated"
+    /**
+     * The OUTPUT_UPDATED-event is sent when an output has been updated.
+     */
+    OUTPUT_UPDATED = 'output.updated'
 }
 
+/**
+ * Event types for all task events
+ * The task events are used to notify about task changes, like start, process, end or cancel of a task.
+ * The events that are sent with the task events are of type {@link ITaskEvent}. The {@link EventResponseMapping} can used to map the event type to the corresponding event interface.
+ */
 export enum EVENTTYPE_TASK {
-    TASK_START = "task.start",
-    TASK_PROCESS = "task.process",
-    TASK_END = "task.end",
-    TASK_CANCEL = "task.cancel",
+    /**
+     * The TASK_START-event is sent when a task has started.
+     */
+    TASK_START = 'task.start',
+    /**
+     * The TASK_PROCESS-event is sent when the process of a task has been updated.
+     */
+    TASK_PROCESS = 'task.process',
+    /**
+     * The TASK_END-event is sent when a task has ended.
+     */
+    TASK_END = 'task.end',
+    /**
+     * The TASK_CANCEL-event is sent when a task has been canceled.
+     */
+    TASK_CANCEL = 'task.cancel',
 }
 
+/**
+ * Event types for all interaction events
+ * The interaction events are used to notify about interaction changes, like drag start, move and end, hover on and off, select on and off.
+ * The events that are sent with the interaction events are of type {@link IInteractionEvent}. The {@link EventResponseMapping} can used to map the event type to the corresponding event interface.
+ */
 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",
+    /**
+     * The DRAG_START-event is sent when the dragging of an object has started.
+     */
+    DRAG_START = 'interaction.drag.start',
+    /**
+     * The DRAG_MOVE-event is sent when an object is being dragged.
+     */
+    DRAG_MOVE = 'interaction.drag.move',
+    /**
+     * The DRAG_END-event is sent when the dragging of an object has ended.
+     */
+    DRAG_END = 'interaction.drag.end',
+    /**
+     * The HOVER_ON-event is sent when an object has been hovered.
+     */
+    HOVER_ON = 'interaction.hover.on',
+    /**
+     * The HOVER_OFF-event is sent when an object has been unhovered.
+     */
+    HOVER_OFF = 'interaction.hover.off',	
+    /**
+     * The SELECT_ON-event is sent when an object has been selected.
+     */
+    SELECT_ON = 'interaction.select.on',
+    /**
+     * The SELECT_OFF-event is sent when an object has been deselected.
+     */
+    SELECT_OFF = 'interaction.select.off',
+}
+
+/**
+ * Event types for all drawing tools events
+ * The drawing tools events are used to notify about drawing tools changes, like cancel, finish, update, inserted, removed, drag start, move and end.
+ * The events that are sent with the drawing tools events are of type {@link IDrawingToolsEvent}. The {@link EventResponseMapping} can used to map the event type to the corresponding event interface.
+ */
+export enum EVENTTYPE_DRAWING_TOOLS {
+    /**
+     * The CANCEL-event is sent when the drawing process has been canceled.
+     */
+    CANCEL = 'drawing_tools.cancel',
+    /**
+     * The FINISH-event is sent when the drawing process has been finished.
+     */
+    FINISH = 'drawing_tools.finish',
+    /**
+     * The UPDATE-event is sent when the drawing process has been updated.
+     */
+    UPDATE = 'drawing_tools.update',
+    /**
+     * The INSERTED-event is sent when a point has been inserted.
+     */
+    INSERTED = 'drawing_tools.inserted',
+    /**
+     * The REMOVED-event is sent when a point has been removed.
+     */
+    REMOVED = 'drawing_tools.removed',
+    /**
+     * The DRAG_START-event is sent when the dragging of a point has started.
+     */
+    DRAG_START = 'drawing_tools.drag.start',
+    /**
+     * The DRAG_MOVE-event is sent when a point is being dragged.
+     */
+    DRAG_MOVE = 'drawing_tools.drag.move',
+    /**
+     * The DRAG_END-event is sent when the dragging of a point has ended.
+     */
+    DRAG_END = 'drawing_tools.drag.end',
 }
 
+/**
+ * Definition of the event types.
+ * These types are used to identify the type of an event in an event object {@link IEvent}.
+ * The {@link EventResponseMapping} is used to map the event type to the corresponding event interface.
+ */
 export const EVENTTYPE = { 
     CAMERA: EVENTTYPE_CAMERA, 
     OUTPUT: EVENTTYPE_OUTPUT,
     RENDERING: EVENTTYPE_RENDERING, 
     SCENE: EVENTTYPE_SCENE, 
     SESSION: EVENTTYPE_SESSION,
+    PARAMETER: EVENTTYPE_PARAMETER,
     VIEWPORT: EVENTTYPE_VIEWPORT,
     INTERACTION: EVENTTYPE_INTERACTION,
-    TASK: EVENTTYPE_TASK
+    TASK: EVENTTYPE_TASK,
+    DRAWING_TOOLS: EVENTTYPE_DRAWING_TOOLS
 };
 
-export type MainEventTypes = typeof EVENTTYPE_CAMERA | typeof EVENTTYPE_OUTPUT | typeof EVENTTYPE_RENDERING | typeof EVENTTYPE_SCENE | typeof EVENTTYPE_SESSION | typeof EVENTTYPE_VIEWPORT | typeof EVENTTYPE_INTERACTION | typeof EVENTTYPE_TASK;
+export type MainEventTypes = typeof EVENTTYPE_CAMERA | typeof EVENTTYPE_OUTPUT | typeof EVENTTYPE_RENDERING | typeof EVENTTYPE_SCENE | typeof EVENTTYPE_SESSION | typeof EVENTTYPE_PARAMETER | typeof EVENTTYPE_VIEWPORT | typeof EVENTTYPE_INTERACTION | typeof EVENTTYPE_DRAWING_TOOLS | typeof EVENTTYPE_TASK;

package/src/http-client/HttpClient.ts

@@ -3,6 +3,7 @@ import { ShapeDiverError as ShapeDiverBackendError, isGBResponseError, isGBReque
 import { ShapeDiverGeometryBackendError, ShapeDiverGeometryBackendRequestError, ShapeDiverGeometryBackendResponseError } from '../logger/ShapeDiverBackendErrors';
 import { HttpResponse } from './HttpResponse';
 import { Converter } from '../converter/Converter';
+import { btoaCustom } from '../utilities/base64';
 
 export class HttpClient {
     // #region Properties (7)
@@ -104,6 +105,8 @@ export class HttpClient {
             throw new ShapeDiverGeometryBackendRequestError(e.message, e.desc);
         } else if (isGBError(e)) {
             throw new ShapeDiverGeometryBackendError(e.message);
+        } else {
+            throw e;
         }
     }
 
@@ -205,14 +208,14 @@ export class HttpClient {
      * @param href 
      * @returns 
      */
-    public async loadTexture(href: string): Promise<HttpResponse<{ image: HTMLImageElement, blob: Blob }>> {
+    public async loadTexture(href: string): Promise<HttpResponse<{ buffer: ArrayBuffer, blob: Blob }>> {
         const response = await (this.get(href, undefined, true) as Promise<HttpResponse<ArrayBuffer>>);
+        const buffer = response.data;
         const arrayBufferView = new Uint8Array( response.data );
         const blob = new Blob([ arrayBufferView ], { type: response.headers['content-type'] } );
-        const image = await Converter.instance.responseToImage(response, blob);
         return {
             data: {
-                image,
+                buffer,
                 blob
             },
             size: response.data.byteLength,
@@ -326,7 +329,7 @@ export class HttpClient {
         url.search = params.toString();
 
         const hrefAsKey = url.toString();
-        return window.btoa(hrefAsKey);
+        return btoaCustom(hrefAsKey);
     }
 
     // #endregion Private Methods (5)

package/src/index.ts

@@ -1,88 +1,139 @@
-import { EventEngine } from './event-engine/EventEngine'
-import { EVENTTYPE, EVENTTYPE_CAMERA, EVENTTYPE_INTERACTION, EVENTTYPE_OUTPUT, 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 } from './logger/Logger'
-import { StatePromise } from './state-engine/StatePromise'
-import { ShapeDiverViewerArError, ShapeDiverViewerCameraError, ShapeDiverViewerDataProcessingError, ShapeDiverViewerEnvironmentMapError, ShapeDiverViewerLightError, ShapeDiverViewerSessionError, ShapeDiverViewerSettingsError, ShapeDiverViewerUnknownError, ShapeDiverViewerValidationError, ShapeDiverViewerWebGLError, ShapeDiverViewerInteractionError, ShapeDiverViewerViewportError } from './logger/ShapeDiverViewerErrors'
-import { ShapeDiverViewerError, ShapeDiverViewerErrorType } from './logger/ShapeDiverError'
-import { HttpResponse } from './http-client/HttpResponse'
-import { ShapeDiverGeometryBackendError, ShapeDiverGeometryBackendRequestError, ShapeDiverGeometryBackendResponseError } from './logger/ShapeDiverBackendErrors'
-import { ShapeDiverResponseErrorType as ShapeDiverGeometryBackendResponseErrorType } from "@shapediver/sdk.geometry-api-sdk-v2";
-import { isViewerError, isViewerUnknownError, isViewerDataProcessingError, isViewerEnvironmentMapError, isViewerWebGLError, isViewerSettingsError, isViewerSessionError, isViewerViewportError, isViewerLightError, isViewerCameraError, isARError, isViewerValidationError, isViewerInteractionError, isViewerGeometryBackendError, isViewerGeometryBackendGenericError, isViewerGeometryBackendRequestError, isViewerGeometryBackendResponseError } from './logger/ErrorTypeGuards'
+import { Converter } from './converter/Converter';
+import { DomEventEngine } from './dom-event-engine/DomEventEngine';
+import { EventEngine } from './event-engine/EventEngine';
+import {
+    EVENTTYPE,
+    EVENTTYPE_CAMERA,
+    EVENTTYPE_DRAWING_TOOLS,
+    EVENTTYPE_INTERACTION,
+    EVENTTYPE_OUTPUT,
+    EVENTTYPE_PARAMETER,
+    EVENTTYPE_RENDERING,
+    EVENTTYPE_SCENE,
+    EVENTTYPE_SESSION,
+    EVENTTYPE_TASK,
+    EVENTTYPE_VIEWPORT,
+    MainEventTypes
+} from './event-engine/EventTypes';
+import { HttpClient } from './http-client/HttpClient';
+import { HttpResponse } from './http-client/HttpResponse';
+import { IDomEventListener } from './dom-event-engine/IDomEventListener';
+import { IEvent } from './event-engine/interfaces/IEvent';
+import { InputValidator } from './input-validator/InputValidator';
+import {
+    isARError,
+    isViewerCameraError,
+    isViewerDataProcessingError,
+    isViewerDrawingToolsError,
+    isViewerEnvironmentMapError,
+    isViewerError,
+    isViewerGeometryBackendError,
+    isViewerGeometryBackendGenericError,
+    isViewerGeometryBackendRequestError,
+    isViewerGeometryBackendResponseError,
+    isViewerInteractionError,
+    isViewerLightError,
+    isViewerSessionError,
+    isViewerSettingsError,
+    isViewerUnknownError,
+    isViewerValidationError,
+    isViewerViewportError,
+    isViewerWebGLError
+} from './logger/ErrorTypeGuards';
+import { ISessionGlobalAccessObjectDefinition } from './state-engine/ISessionGlobalAccessObjectDefinition';
+import { IViewportGlobalAccessObjectDefinition } from './state-engine/IViewportGlobalAccessObjectDefinition';
+import { Logger, LOGGING_LEVEL } from './logger/Logger';
+import { PerformanceEvaluator } from './performance-evaluator/PerformanceEvaluator';
+import { SESSION_SETTINGS_MODE, SettingsEngine } from './settings-engine/SettingsEngine';
+import { ShapeDiverGeometryBackendError, ShapeDiverGeometryBackendRequestError, ShapeDiverGeometryBackendResponseError } from './logger/ShapeDiverBackendErrors';
+import { ShapeDiverResponseErrorType as ShapeDiverGeometryBackendResponseErrorType } from '@shapediver/sdk.geometry-api-sdk-v2';
+import {
+    ShapeDiverViewerArError,
+    ShapeDiverViewerCameraError,
+    ShapeDiverViewerDataProcessingError,
+    ShapeDiverViewerDrawingToolsError,
+    ShapeDiverViewerEnvironmentMapError,
+    ShapeDiverViewerInteractionError,
+    ShapeDiverViewerLightError,
+    ShapeDiverViewerSessionError,
+    ShapeDiverViewerSettingsError,
+    ShapeDiverViewerUnknownError,
+    ShapeDiverViewerValidationError,
+    ShapeDiverViewerViewportError,
+    ShapeDiverViewerWebGLError
+} from './logger/ShapeDiverViewerErrors';
+import { ShapeDiverViewerError, ShapeDiverViewerErrorType } from './logger/ShapeDiverError';
+import { StateEngine } from './state-engine/StateEngine';
+import { StatePromise } from './state-engine/StatePromise';
+import { SystemInfo } from './system-info/SystemInfo';
+import { TypeChecker } from './type-check/TypeChecker';
+import { UuidGenerator } from './uuid-generator/UuidGenerator';
+import { atobCustom, btoaCustom } from './utilities/base64';
 
 export {
-  EventEngine, EVENTTYPE, MainEventTypes, IEvent,
-  EVENTTYPE_CAMERA, EVENTTYPE_OUTPUT, EVENTTYPE_RENDERING, EVENTTYPE_SCENE, EVENTTYPE_SESSION, EVENTTYPE_VIEWPORT, EVENTTYPE_INTERACTION, EVENTTYPE_TASK
-}
+    EventEngine, EVENTTYPE, MainEventTypes, IEvent,
+    EVENTTYPE_CAMERA, EVENTTYPE_OUTPUT, EVENTTYPE_PARAMETER, EVENTTYPE_RENDERING, EVENTTYPE_SCENE, EVENTTYPE_SESSION, EVENTTYPE_VIEWPORT, EVENTTYPE_INTERACTION, EVENTTYPE_DRAWING_TOOLS, EVENTTYPE_TASK
+};
 
 export {
-    SettingsEngine
-}
+    SettingsEngine, SESSION_SETTINGS_MODE
+};
 
 export {
-    StateEngine, StatePromise
-}
+    StateEngine, StatePromise,
+    IViewportGlobalAccessObjectDefinition, ISessionGlobalAccessObjectDefinition
+};
 
 export {
     SystemInfo
-}
+};
 
 export {
     IDomEventListener, DomEventEngine
-}
+};
 
 export {
     HttpClient, HttpResponse
-}
+};
 
 export {
     UuidGenerator
-}
+};
 
 export {
     Converter
-}
+};
 
 export {
     TypeChecker
-}
+};
 
 export {
     InputValidator
-}
+};
 
 export {
-    Logger, LOGGING_LEVEL, 
+    Logger, LOGGING_LEVEL,
     ShapeDiverViewerErrorType,
-    ShapeDiverViewerError, 
-    ShapeDiverViewerDataProcessingError, 
+    ShapeDiverViewerError,
+    ShapeDiverViewerDataProcessingError,
     ShapeDiverViewerEnvironmentMapError,
     ShapeDiverViewerWebGLError,
     ShapeDiverViewerSettingsError,
     ShapeDiverViewerSessionError,
     ShapeDiverViewerViewportError,
-    ShapeDiverViewerUnknownError, 
+    ShapeDiverViewerUnknownError,
     ShapeDiverViewerArError,
     ShapeDiverViewerLightError,
     ShapeDiverViewerCameraError,
     ShapeDiverViewerValidationError,
     ShapeDiverViewerInteractionError,
+    ShapeDiverViewerDrawingToolsError,
     ShapeDiverGeometryBackendError,
     ShapeDiverGeometryBackendRequestError,
     ShapeDiverGeometryBackendResponseError,
     ShapeDiverGeometryBackendResponseErrorType
-}
+};
 
 export {
     isViewerError,
@@ -98,12 +149,17 @@ export {
     isARError,
     isViewerValidationError,
     isViewerInteractionError,
+    isViewerDrawingToolsError,
     isViewerGeometryBackendError,
     isViewerGeometryBackendGenericError,
     isViewerGeometryBackendRequestError,
     isViewerGeometryBackendResponseError
-}
+};
 
 export {
     PerformanceEvaluator
-}
+};
+
+export {
+    atobCustom, btoaCustom
+};

package/src/logger/ErrorTypeGuards.ts

@@ -1,6 +1,6 @@
 import { ShapeDiverGeometryBackendError, ShapeDiverGeometryBackendRequestError, ShapeDiverGeometryBackendResponseError } from "./ShapeDiverBackendErrors"
 import { ShapeDiverViewerError, ShapeDiverViewerErrorType } from "./ShapeDiverError"
-import { ShapeDiverViewerArError, ShapeDiverViewerCameraError, ShapeDiverViewerDataProcessingError, ShapeDiverViewerEnvironmentMapError, ShapeDiverViewerInteractionError, ShapeDiverViewerLightError, ShapeDiverViewerSessionError, ShapeDiverViewerSettingsError, ShapeDiverViewerUnknownError, ShapeDiverViewerValidationError, ShapeDiverViewerViewportError, ShapeDiverViewerWebGLError } from "./ShapeDiverViewerErrors"
+import { ShapeDiverViewerArError, ShapeDiverViewerCameraError, ShapeDiverViewerDataProcessingError, ShapeDiverViewerDrawingToolsError, ShapeDiverViewerEnvironmentMapError, ShapeDiverViewerInteractionError, ShapeDiverViewerLightError, ShapeDiverViewerSessionError, ShapeDiverViewerSettingsError, ShapeDiverViewerUnknownError, ShapeDiverViewerValidationError, ShapeDiverViewerViewportError, ShapeDiverViewerWebGLError } from "./ShapeDiverViewerErrors"
 
 /** Type guard for all error types of the viewer package. */
 export function isViewerError(e: any): e is ShapeDiverViewerError {
@@ -93,6 +93,13 @@ export function isViewerInteractionError(e: any): e is ShapeDiverViewerInteracti
         (<ShapeDiverViewerError>e).errorType === ShapeDiverViewerErrorType.INTERACTION_ERROR
 }
 
+/** Type guard for a drawing tools viewer error. */
+export function isViewerDrawingToolsError(e: any): e is ShapeDiverViewerDrawingToolsError {
+    return e instanceof Error &&
+        "errorType" in e &&
+        (<ShapeDiverViewerError>e).errorType === ShapeDiverViewerErrorType.DRAWING_TOOLS_ERROR
+}
+
 /** Type guard for all error types of the Geometry Backend SDK package that are mapped to viewer errors. */
 export function isViewerGeometryBackendError(e: any): e is
     (ShapeDiverGeometryBackendError & ShapeDiverGeometryBackendRequestError & ShapeDiverGeometryBackendResponseError) {

package/src/logger/ShapeDiverError.ts

@@ -6,6 +6,7 @@ export enum ShapeDiverViewerErrorType {
     CAMERA_ERROR = 'SdCameraError',
     CONNECTION_ERROR = 'SdConnectionError',
     DATA_PROCESSING_ERROR = 'SdDataProcessingError',
+    DRAWING_TOOLS_ERROR = 'SdDrawingToolsError',
     ENVIRONMENT_MAP_ERROR = 'SdEnvironmentMapError',
     INTERACTION_ERROR = 'SdInteractionError',
     LIGHT_ERROR = 'SdLightError',

package/src/logger/ShapeDiverViewerErrors.ts

@@ -110,4 +110,12 @@ export class ShapeDiverViewerInteractionError extends ShapeDiverViewerError {
     ) {
         super(ShapeDiverViewerErrorType.INTERACTION_ERROR, 'An error occurred with interactions.', message);
     }
+}
+
+export class ShapeDiverViewerDrawingToolsError extends ShapeDiverViewerError {
+    constructor(
+        public readonly message: string
+    ) {
+        super(ShapeDiverViewerErrorType.INTERACTION_ERROR, 'An error occurred with drawing tools.', message);
+    }
 }