@combeenation/3d-viewer 4.1.1-alpha1 → 4.3.0

package/src/api/util/globalTypes.ts

@@ -1,38 +1,39 @@
 // global accessible types imported from 3d-viewer
-type Viewer = import("../classes/viewer").Viewer;
-type Variant = import("../classes/variant").Variant;
-type VariantInstance = import("../classes/variantInstance").VariantInstance;
+type Viewer = import('../classes/viewer').Viewer;
+type Variant = import('../classes/variant').Variant;
+type VariantInstance = import('../classes/variantInstance').VariantInstance;
 /**
  * Alias for {@link Element} which can be used to prevent name clashes with the web APIs
  * [Element](https://developer.mozilla.org/en-US/docs/Web/API/Element) class
  */
-type VariantElement = import("../classes/element").Element;
-type DottedPath = import("../classes/dottedPath").DottedPath;
-type ViewerLight = import("../classes/viewerLight").ViewerLight;
+type VariantElement = import('../classes/element').Element;
+type DottedPath = import('../classes/dottedPath').DottedPath;
+type ViewerLight = import('../classes/viewerLight').ViewerLight;
 
 // global accessible types imported from BabylonJS
-type Scene = import("@babylonjs/core/scene").Scene;
-type Vector3 = import("@babylonjs/core/Maths/math.vector").Vector3;
-type Color3 = import("@babylonjs/core/Maths/math.color").Color3;
-type Color4 = import("@babylonjs/core/Maths/math.color").Color4;
-type Material = import("@babylonjs/core/Materials/material").Material;
-type PBRMaterial = import("@babylonjs/core/Materials/PBR/pbrMaterial").PBRMaterial;
-type StandardMaterial = import("@babylonjs/core/Materials/standardMaterial").StandardMaterial;
-type DynamicTexture = import("@babylonjs/core/Materials/Textures/dynamicTexture").DynamicTexture;
-type Mesh = import("@babylonjs/core/Meshes/mesh").Mesh;
-type AbstractMesh = import("@babylonjs/core/Meshes/abstractMesh").AbstractMesh;
-type InstancedMesh = import("@babylonjs/core/Meshes/instancedMesh").InstancedMesh;
-type TransformNode = import("@babylonjs/core/Meshes/transformNode").TransformNode;
-type Engine = import("@babylonjs/core/Engines/engine").Engine;
-type EngineOptions = import("@babylonjs/core/Engines/thinEngine").EngineOptions;
-type ArcRotateCamera = import("@babylonjs/core/Cameras/arcRotateCamera").ArcRotateCamera;
-type IScreenshotSize = import("@babylonjs/core/Misc/interfaces/screenshotSize").IScreenshotSize;
+type Scene = import('@babylonjs/core/scene').Scene;
+type Vector3 = import('@babylonjs/core/Maths/math.vector').Vector3;
+type Color3 = import('@babylonjs/core/Maths/math.color').Color3;
+type Color4 = import('@babylonjs/core/Maths/math.color').Color4;
+type Material = import('@babylonjs/core/Materials/material').Material;
+type PBRMaterial = import('@babylonjs/core/Materials/PBR/pbrMaterial').PBRMaterial;
+type StandardMaterial = import('@babylonjs/core/Materials/standardMaterial').StandardMaterial;
+type DynamicTexture = import('@babylonjs/core/Materials/Textures/dynamicTexture').DynamicTexture;
+type Mesh = import('@babylonjs/core/Meshes/mesh').Mesh;
+type AbstractMesh = import('@babylonjs/core/Meshes/abstractMesh').AbstractMesh;
+type InstancedMesh = import('@babylonjs/core/Meshes/instancedMesh').InstancedMesh;
+type TransformNode = import('@babylonjs/core/Meshes/transformNode').TransformNode;
+type Engine = import('@babylonjs/core/Engines/engine').Engine;
+type EngineOptions = import('@babylonjs/core/Engines/thinEngine').EngineOptions;
+type ArcRotateCamera = import('@babylonjs/core/Cameras/arcRotateCamera').ArcRotateCamera;
+type IScreenshotSize = import('@babylonjs/core/Misc/interfaces/screenshotSize').IScreenshotSize;
 type BabylonAnimation = import('@babylonjs/core/Animations/animation').Animation;
 type CubeTexture = import('@babylonjs/core/Materials/Textures/cubeTexture').CubeTexture;
 type MeshBuilder = import('@babylonjs/core/Meshes/meshBuilder').MeshBuilder;
 type Texture = import('@babylonjs/core/Materials/Textures/texture').Texture;
 type HemisphericLight = import('@babylonjs/core/Lights/hemisphericLight').HemisphericLight;
 type DirectionalLight = import('@babylonjs/core/Lights/directionalLight').DirectionalLight;
+type IInspectorOptions = import('@babylonjs/core/Debug').IInspectorOptions;
 // Node is already defined in lib.dom.d.ts, so it can't be declared that way
 // type Node = import("@babylonjs/core/node").Node;
 
@@ -40,163 +41,169 @@ type EventEmitter = import('eventemitter3');
 
 // some more global accessible types
 type PathDefinitions = {
-	include: string[],
-	exclude?: string[]
+  include: string[];
+  exclude?: string[];
 };
 
 type TraceableDefinition = {
-	path: string
+  path: string;
 };
 
 type TraceableDefinitions = {
-	[name: string]: TraceableDefinition
+  [name: string]: TraceableDefinition;
 };
 
 type PaintableDefinition = {
-	path: string,
-	textureOptions: {
-		width: number,
-		height: number,
-	} | number
+  path: string;
+  textureOptions:
+    | {
+        width: number;
+        height: number;
+      }
+    | number;
 };
 
 type PaintableDefinitions = {
-	[name: string]: PaintableDefinition
+  [name: string]: PaintableDefinition;
 };
 
 type Asset = {
-	rootUrl: string,
-	fileName: string | undefined
+  rootUrl: string;
+  fileName: string | undefined;
 };
 
 type ElementDefinitions = {
-	[name: string]: ElementDefinition | string[]
+  [name: string]: ElementDefinition | string[];
 };
 
 type ElementDefinition = {
-	paths: PathDefinitions,
-	traceables?: TraceableDefinitions,
-	paintables?: PaintableDefinitions
+  paths: PathDefinitions;
+  traceables?: TraceableDefinitions;
+  paintables?: PaintableDefinitions;
 };
 
 type TransformationDefinition = {
-	scaling: Vector3,
-	position: Vector3,
-	rotation: Vector3
+  scaling: Vector3;
+  position: Vector3;
+  rotation: Vector3;
 };
 
 type StructureJson = {
-	/**
-	 * `scene` describes the visualisation of the Babylon `scene` such as the incidence of light and camera position. If a
-	 * string is given, the {@link Viewer} will resolve the URL or path and pass the parsed JSON to this property.
-	 */
-	scene?: string | SceneJson,
-	/**
-	 * `setup` is a kind of construction plan for the {@link Viewer}. You can pass a {@link SetupJson} or a string, which
-	 * must represent a valid URL or path. If a string is given, the {@link Viewer} will resolve the URL or path and pass
-	 * the parsed JSON to this property. The {@link SetupJson} is responsible for managing a list of
-	 * {@link VariantInstanceDefinition}s. These definitions define the instances that should be instantiated during the
-	 * bootstrapping process. Each instance has a name and a reference to it's {@link Variant}.
-	 */
-	setup?: string | SetupJson,
-	file?: string
-	glTF?: Asset | string,
-	parameterDeclaration?: ParameterDeclarations,
-	parameters?: ParameterBag,
-	elements?: ElementDefinitions,
-	lights?: LightDefinitions,
-	grounds?: GroundDefinitions,
-	/**
-	 * `variants` is a declarative description of 3D-model variations in the configurator. Each variant itself is a
-	 * {@link StructureJson} which must at least define a `name` in the key of the list and the properties `glTF` and
-	 * `elements` in the value. FYI: BabylonJS's sandbox can show you the path of the 3D-model to properly define the
-	 * `paths`.
-	 *
-	 * Example Code
-	 * ```js
-	 * variants: {
-	 *     'My Pretty Variant' {
-	 *         glTF: {
-	 *             rootUrl: 'https:/my.awesome.domain/path/to/my/project/',
-	 *             fileName: 'my_3d_model_file.glb',
-	 *         },
-	 *         elements: {
-	 *             'My Little Element': {
-	 *                 paths: {
-	 *                     includes: ['__root__.MeshName']
-	 *                 }
-	 *             }
-	 *         }
-	 *     }
-	 * }
-	 * ```
-	 * `MeshName` has to be identical to the path in the glb-file of the 3D-model.
-	 */
-	variants?: {
-		[id: string]: StructureJson,
-	},
+  /**
+   * `scene` describes the visualisation of the Babylon `scene` such as the incidence of light and camera position. If a
+   * string is given, the {@link Viewer} will resolve the URL or path and pass the parsed JSON to this property.
+   */
+  scene?: string | SceneJson;
+  /**
+   * `setup` is a kind of construction plan for the {@link Viewer}. You can pass a {@link SetupJson} or a string, which
+   * must represent a valid URL or path. If a string is given, the {@link Viewer} will resolve the URL or path and pass
+   * the parsed JSON to this property. The {@link SetupJson} is responsible for managing a list of
+   * {@link VariantInstanceDefinition}s. These definitions define the instances that should be instantiated during the
+   * bootstrapping process. Each instance has a name and a reference to it's {@link Variant}.
+   */
+  setup?: string | SetupJson;
+  file?: string;
+  glTF?: Asset | string;
+  parameterDeclaration?: ParameterDeclarations;
+  parameters?: ParameterBag;
+  elements?: ElementDefinitions;
+  lights?: LightDefinitions;
+  grounds?: GroundDefinitions;
+  /**
+   * `variants` is a declarative description of 3D-model variations in the configurator. Each variant itself is a
+   * {@link StructureJson} which must at least define a `name` in the key of the list and the properties `glTF` and
+   * `elements` in the value. FYI: BabylonJS's sandbox can show you the path of the 3D-model to properly define the
+   * `paths`.
+   *
+   * Example Code
+   * ```js
+   * variants: {
+   *     'My Pretty Variant' {
+   *         glTF: {
+   *             rootUrl: 'https:/my.awesome.domain/path/to/my/project/',
+   *             fileName: 'my_3d_model_file.glb',
+   *         },
+   *         elements: {
+   *             'My Little Element': {
+   *                 paths: {
+   *                     includes: ['__root__.MeshName']
+   *                 }
+   *             }
+   *         }
+   *     }
+   * }
+   * ```
+   * `MeshName` has to be identical to the path in the glb-file of the 3D-model.
+   */
+  variants?: {
+    [id: string]: StructureJson;
+  };
 };
 
 type SceneJson = {
-	parameterDeclaration?: ParameterDeclarations,
-	parameters?: ParameterBag,
-	meshPicking?: boolean,
-	/**
-	 * Information about [EngineOptions](https://doc.babylonjs.com/typedoc/interfaces/babylon.engineoptions).
-	 */
-	engine?: {
-		antialiasing?: boolean
-		options?: EngineOptions
-	}
-	scene: SceneDefinition,
-	animations?: AnimationDefinitions,
-	placements?: PlacementDefinitions
+  parameterDeclaration?: ParameterDeclarations;
+  parameters?: ParameterBag;
+  meshPicking?: boolean;
+  /**
+   * Information about [EngineOptions](https://doc.babylonjs.com/typedoc/interfaces/babylon.engineoptions).
+   */
+  engine?: {
+    antialiasing?: boolean;
+    options?: EngineOptions;
+  };
+  scene: SceneDefinition;
+  animations?: AnimationDefinitions;
+  placements?: PlacementDefinitions;
+  /**
+   * Information about [material cloning](pages/Release%20Notes/releases/4-3-0.html#material-cloning-on-mutation)
+   */
+  cloneMaterialsOnMutation?: boolean;
 };
 
 type SceneDefinition = {
-	globals: SceneGlobals,
-	cameras?: CameraDefinitions,
+  globals: SceneGlobals;
+  cameras?: CameraDefinitions;
 };
 
 type SceneGlobals = {
-	shadows?: {
-		enabled: boolean,
-		type: 'contact',
-		settings: [],
-		generator: [],
-		receiver: []
-	},
-	/**
-	 * `aa` or anti aliasing is not needed if hard edges are desired.\
-	 * FYI: aa smooths edges and avoids stairs-effects.
-	 */
-	aa?: 'fxaa',
-	'tone-mapping'?: boolean,
-	/**
-	 * @bloom is widely known as glow. There you can define it’s size (Specifies the size of the bloom blur kernel, relative to the final output size) and threshold (The luminance threshold to find bright areas of the image to bloom).
-	 * Further Information under [BloomEffect](https://doc.babylonjs.com/typedoc/classes/babylon.bloomeffect).
-	 *
-	 * @dof short for "depth-of-field" defines the focus in the view. Parameters in settings are listed in [Depth of Field and Other Lens Effects link](https://doc.babylonjs.com/divingDeeper/postProcesses/dofLenseEffects).
-	 * @exposure specifies the intensity of the lightning of the view (not 3D-Model).
-	 * @sharpen´s parameter `settings` are listed in [Default Rendering Pipeline Sharpening link](https://doc.babylonjs.com/divingDeeper/postProcesses/defaultRenderingPipeline#sharpening).
-	 */
-	'camera-settings'?: {
-		contrast: number,
-		exposure: number,
-		bloom?: {
-			enabled: boolean,
-			size?: number,
-			threshold?: number
-		},
-		dof?: {
-			enabled: boolean,
-			settings: {}
-		},
-		sharpen?: {
-			enabled: boolean,
-			settings: {}
-		}
-	}
+  'shadows'?: {
+    enabled: boolean;
+    type: 'contact';
+    settings: [];
+    generator: [];
+    receiver: [];
+  };
+  /**
+   * `aa` or anti aliasing is not needed if hard edges are desired.\
+   * FYI: aa smooths edges and avoids stairs-effects.
+   */
+  'aa'?: 'fxaa';
+  'tone-mapping'?: boolean;
+  /**
+   * @bloom is widely known as glow. There you can define it’s size (Specifies the size of the bloom blur kernel, relative to the final output size) and threshold (The luminance threshold to find bright areas of the image to bloom).
+   * Further Information under [BloomEffect](https://doc.babylonjs.com/typedoc/classes/babylon.bloomeffect).
+   *
+   * @dof short for "depth-of-field" defines the focus in the view. Parameters in settings are listed in [Depth of Field and Other Lens Effects link](https://doc.babylonjs.com/divingDeeper/postProcesses/dofLenseEffects).
+   * @exposure specifies the intensity of the lightning of the view (not 3D-Model).
+   * @sharpen´s parameter `settings` are listed in [Default Rendering Pipeline Sharpening link](https://doc.babylonjs.com/divingDeeper/postProcesses/defaultRenderingPipeline#sharpening).
+   */
+  'camera-settings'?: {
+    contrast: number;
+    exposure: number;
+    bloom?: {
+      enabled: boolean;
+      size?: number;
+      threshold?: number;
+    };
+    dof?: {
+      enabled: boolean;
+      settings: {};
+    };
+    sharpen?: {
+      enabled: boolean;
+      settings: {};
+    };
+  };
 };
 
 /**
@@ -204,175 +211,172 @@ type SceneGlobals = {
  * See this link for additional info about the properties.
  */
 type ScreenshotSettings = {
-	/** Defaults to canvas width & height */
-	size?: IScreenshotSize,
-	/**
-	 * Default `image/png`
-	 * 
-	 * **Info regarding JPEG:** \
-	 * Use mimeType `image/jpeg` (**not** `image/jpg`) when creating jpeg's. \
-	 * Also ensure that {@link Scene.clearColor | viewer.scene.clearColor} has an alpha value of `1` as jpeg's don't support
-	 * transparency. Otherwise background will always be black for jpeg's.
-	 */
-	mimeType?: string,
-	/** Default `1` */
-	samples?: number,
-	/** Default `false` */
-	antialiasing?: boolean,
-	/** Default `screenshot.png` */
-	fileName?: string,
-	/** Default `false` */
-	renderSprites?: boolean
+  /** Defaults to canvas width & height */
+  size?: IScreenshotSize;
+  /**
+   * Default `image/png`
+   *
+   * **Info regarding JPEG:** \
+   * Use mimeType `image/jpeg` (**not** `image/jpg`) when creating jpeg's. \
+   * Also ensure that {@link Scene.clearColor | viewer.scene.clearColor} has an alpha value of `1` as jpeg's don't support
+   * transparency. Otherwise background will always be black for jpeg's.
+   */
+  mimeType?: string;
+  /** Default `1` */
+  samples?: number;
+  /** Default `false` */
+  antialiasing?: boolean;
+  /** Default `screenshot.png` */
+  fileName?: string;
+  /** Default `false` */
+  renderSprites?: boolean;
 };
 
 type AutofocusSettings = {
-	/**
-	 * Can be used to customize the margins shown around the 3d model when calling {@link autofocusActiveCamera}.\
-	 * Defaults to 1.5 when not set explicitly.
-	 */
-	radiusFactor?: number,
-	adjustWheelPrecision?: boolean,
-	adjustPanningSensibility?: boolean,
-	adjustPinchPrecision?: boolean,
-	/** Desired camera angles, these won't be overwritten by the autofocus function, only the camera radius is adjusted */
-	alpha?: number;
-	beta?: number;
-	/** Optional animation for the focusing camera movement */
-	animation?: string | AnimationDefinition
+  /**
+   * Can be used to customize the margins shown around the 3d model when calling {@link autofocusActiveCamera}.\
+   * Defaults to 1.5 when not set explicitly.
+   */
+  radiusFactor?: number;
+  adjustWheelPrecision?: boolean;
+  adjustPanningSensibility?: boolean;
+  adjustPinchPrecision?: boolean;
+  /** Desired horizontal camera angle, this won't be overwritten by the autofocus function */
+  alpha?: number;
+  /** Desired vertical camera angle, this won't be overwritten by the autofocus function */
+  beta?: number;
+  /** Optional animation for the focusing camera movement */
+  animation?: string | AnimationDefinition;
 };
 
 type LightDefinitions = {
-	[name: string]: LightDefinition | string
+  [name: string]: LightDefinition | string;
 };
 
 type LightDefinition = {
-	type: 'baked' | 'hemispheric' | 'point' | 'directional' | 'spot',
-	path?: string,
-	shadowGenerator?: ShadowGeneratorDefinition
+  type: 'baked' | 'hemispheric' | 'point' | 'directional' | 'spot';
+  path?: string;
+  shadowGenerator?: ShadowGeneratorDefinition;
 };
 
 type ShadowGeneratorDefinition = {
-	mapSize: number
-	[others: string]: any,
-	/**
-	 * Further properties like `usePoissonSampling` are set directly on the ShadowGenerator object.
-	 * [Shadows](https://doc.babylonjs.com/divingDeeper/lights/shadows)
-	 */
+  mapSize: number;
+  [others: string]: any;
+  /**
+   * Further properties like `usePoissonSampling` are set directly on the ShadowGenerator object.
+   * [Shadows](https://doc.babylonjs.com/divingDeeper/lights/shadows)
+   */
 };
 
 type GroundDefinitions = {
-	[ground: string]: GroundDefinition
+  [ground: string]: GroundDefinition;
 };
 
 type GroundDefinition = {
-	type: 'baked' | 'ground' | 'heightmap',
-	meshId?: string,
-	url?: string,
-	width?: number,
-	height?: number,
-	subdivisions?: number,
-	receiveShadows?: boolean,
-	minHeight?: number,
-	maxHeight?: number,
-	alphaFilter?: number,
-	onReady?: any
+  type: 'baked' | 'ground' | 'heightmap';
+  meshId?: string;
+  url?: string;
+  width?: number;
+  height?: number;
+  subdivisions?: number;
+  receiveShadows?: boolean;
+  minHeight?: number;
+  maxHeight?: number;
+  alphaFilter?: number;
+  onReady?: any;
 };
 
 type CameraDefinitions = {
-	[camera: string]: CameraDefinition
+  [camera: string]: CameraDefinition;
 };
 
 type CameraDefinition = {
-	/**
-	 * `fov` or "Field Of View" defines as it says the view of the scene. Further information about its [theory](https://en.wikipedia.org/wiki/Field_of_view) and [implementation](https://doc.babylonjs.com/typedoc/classes/babylon.camera#fov).
-	 */
-	fov?: number,
-	active?: boolean
-	/**
-	 * `arc` is a default camera position where the 3D-model is the center and the camera rotates around the 3D-model.
-	 * More Information about `arc` in [ArcRotateCamera](https://doc.babylonjs.com/typedoc/classes/babylon.arcrotatecamera).
-	 * 
-	 * NOTE: While "baked" camera definitions from a GLB or babylon file can currently not be instatiated within the `Specification`, it's still possible to use them in the viewer.\
-	 * For the moment all camera definitions inside these files are automatically added to the scene and can be actived using the {@link switchCamera} function.\
-	 * The `newCamera` input has to match the name of the camera node inside the GLB/babylon file.
-	 */
-	type: 'arc'
-	/**
-	 * `target` overrides `arc`´s position and repositions the camera. The string has the syntax (x?: number, y?: number, z?: number) like [Vector3](https://doc.babylonjs.com/typedoc/classes/babylon.vector3).
-	 */
-	target?: string
+  /**
+   * `fov` or "Field Of View" defines as it says the view of the scene. Further information about its [theory](https://en.wikipedia.org/wiki/Field_of_view) and [implementation](https://doc.babylonjs.com/typedoc/classes/babylon.camera#fov).
+   */
+  fov?: number;
+  active?: boolean;
+  /**
+   * `arc` is a default camera position where the 3D-model is the center and the camera rotates around the 3D-model.
+   * More Information about `arc` in [ArcRotateCamera](https://doc.babylonjs.com/typedoc/classes/babylon.arcrotatecamera).
+   *
+   * NOTE: While "baked" camera definitions from a GLB or babylon file can currently not be instatiated within the `Specification`, it's still possible to use them in the viewer.\
+   * For the moment all camera definitions inside these files are automatically added to the scene and can be actived using the {@link switchCamera} function.\
+   * The `newCamera` input has to match the name of the camera node inside the GLB/babylon file.
+   */
+  type: 'arc';
+  /**
+   * `target` overrides `arc`´s position and repositions the camera. The string has the syntax (x?: number, y?: number, z?: number) like [Vector3](https://doc.babylonjs.com/typedoc/classes/babylon.vector3).
+   */
+  target?: string;
 };
 
 type VariantInstanceDefinition = {
-	name?: string,
-	variant: DottedPathArgument,
-	parameters?: ParameterBag,
-	lazy?: boolean
+  name?: string;
+  variant: DottedPathArgument;
+  parameters?: ParameterBag;
+  lazy?: boolean;
 };
 
 type SetupJson = {
-	instances: VariantInstanceDefinition[]
+  instances: VariantInstanceDefinition[];
 };
 
 type ParameterDeclarations = {
-	[name: string]: ParameterDeclaration
+  [name: string]: ParameterDeclaration;
 };
 
 type ParameterDeclaration = {
-	type: 'string' | 'boolean' | 'number' | 'color' | 'select' | 'vector' | 'csl',
-	parser?: any,
-	options?: ParameterValue[]
+  type: 'string' | 'boolean' | 'number' | 'color' | 'select' | 'vector' | 'csl';
+  parser?: any;
+  options?: ParameterValue[];
 };
 
 type ParameterValue = string | number | boolean;
 
 type ParameterBag = {
-	[name: string]: ParameterValue
+  [name: string]: ParameterValue;
 };
 
 type ParsedParameterBag = {
-	[name: string]: any
+  [name: string]: any;
 };
 
 type DottedPathArgument = string | string[] | DottedPath;
 
-type ParameterObserver = (
-	object: any,
-	oldValue: ParameterValue,
-	newValue: ParameterValue
-) => void;
+type ParameterObserver = (object: any, oldValue: ParameterValue, newValue: ParameterValue) => void;
 
 type PlacementDefinitions = {
-	[name: string]: PlacementDefinition
+  [name: string]: PlacementDefinition;
 };
 
 type PlacementDefinition = {
-	position?: string | Vector3,
-	alpha?: number,
-	beta?: number,
-	radius?: number,
-	target?: string | Vector3
+  position?: string | Vector3;
+  alpha?: number;
+  beta?: number;
+  radius?: number;
+  target?: string | Vector3;
 };
 
 type AnimationDefinitions = {
-	[name: string]: AnimationDefinition
+  [name: string]: AnimationDefinition;
 };
 
 /**
  * See [GSAP API Docs](https://greensock.com/docs/v3/GSAP/Tween/vars) for description of `GSAPTWeenVars`.
- * 
+ *
  * You can use the [GreenSock Ease Visualizer](https://greensock.com/ease-visualizer/) to create an animation of your
  * liking and simply copy the `ease` function shown at the bottom of the visualizer into the `ease` property of your
  * {@link AnimationDefinition}.
- * 
+ *
  * The `GSAPTWeenVars` are extended by the `shortestWay` property.\
  * This property defines if the camera should move to the target position within the shortest possible distance.\
  * If `shortestWay` is `false`, the camera moves the whole difference between the current camera position and the target position
  * and that could be > 360, which can appear very unconvenient to the operator.\
  * The default value of this flag is `true`.
- * 
+ *
  * Example usage in {@link SceneJson | SceneJson.animations}:
- * 
+ *
  * ```js
  * // ...
  * scene: {
@@ -388,4 +392,4 @@ type AnimationDefinitions = {
  * // ...
  * ```
  */
-type AnimationDefinition = GSAPTweenVars & { shortestWay?: boolean }
+type AnimationDefinition = GSAPTweenVars & { shortestWay?: boolean };