@combeenation/3d-viewer 3.1.1-alpha7 → 3.1.2

package/src/api/manager/variantInstanceManager.ts

@@ -1,237 +1,237 @@
-import { merge } from 'lodash-es';
-import { DottedPath } from '../classes/dottedPath';
-import { Event } from '../classes/event';
-import { EventBroadcaster } from '../classes/eventBroadcaster';
-import { Parameter } from '../classes/parameter';
-import { Variant } from '../classes/variant';
-import { VariantInstance } from '../classes/variantInstance';
-
-/**
- * There's usually no need to instantiate a {@link VariantInstanceManager} yourself as it is provided by each
- * {@link Viewer} instance via its {@link Viewer.variantInstances}
- */
-export class VariantInstanceManager extends EventBroadcaster {
-
-	protected variantInstances: Map<string, VariantInstance> = new Map();
-
-	protected variantInstanceDefinitions: Map<string, VariantInstanceDefinition> = new Map();
-
-	protected parameters: ParameterBag = {};
-
-	protected queues: { [name: string]: Promise<VariantInstance>[] } = {};
-
-	/**
-	 * Constructor.
-	 */
-	protected constructor( protected rootVariant: Variant ) {
-		super();
-	}
-
-	/**
-	 * Creates a {@link VariantInstanceManager} based on given root Variant.
-	 */
-	public static async create( rootVariant: Variant ): Promise<VariantInstanceManager> {
-		return new VariantInstanceManager( rootVariant );
-	}
-
-	/**
-	 * Gets all instances.
-	 */
-	get all() {
-		const all: VariantInstance[] = [];
-		this.variantInstances.forEach( variantInstance => all.push( variantInstance ) );
-		return all;
-	}
-
-	/**
-	 * Gets all instance definitions.
-	 */
-	get allDefinitions() {
-		const all: VariantInstanceDefinition[] = [];
-		this.variantInstanceDefinitions.forEach( definition => all.push( definition ) );
-		return all;
-	}
-
-	/**
-	 * Checks whether a {@link VariantInstance} is either registered or created.
-	 */
-	public has( name: string ) {
-		return this.variantInstances.has( name ) || this.variantInstanceDefinitions.has( name );
-	}
-
-	/**
-	 * Retrieves a {@link VariantInstance}.
-	 * If the instance has been created, the created instance will be returned.
-	 * If the instance is registered, the instance will be created.
-	 * If none of these apply, an Error is thrown.
-	 *
-	 * @emits {@link Event.VARIANT_INSTANCE_CREATED}
-	 */
-	public async get( name: string ): Promise<VariantInstance> {
-		if( this.variantInstances.has( name ) ) {
-			return this.variantInstances.get( name )!;
-		}
-		if( this.variantInstanceDefinitions.has( name ) ) {
-			const definition = this.variantInstanceDefinitions.get( name )!;
-			return await this.createFromDefinition( definition );
-		}
-		throw Error( `VariantInstance with name "${name}" neither created nor configured.` );
-	}
-
-	/**
-	 * Creates and registers a unique {@link VariantInstance}.
-	 *
-	 * @emits {@link Event.VARIANT_INSTANCE_CREATED}
-	 */
-	public async create( dottedPath: DottedPathArgument, name?: string, parameters?: ParameterBag ): Promise<VariantInstance> {
-		const variant = DottedPath.create( dottedPath ).path;
-		const definition = {
-			name: this.ensureUniqueName( name ? name : variant ),
-			variant: variant,
-			parameters: parameters
-		};
-		return await this.createFromDefinition( definition );
-	}
-
-	/**
-	 * Registers a unique {@link VariantInstanceDefinition}.
-	 *
-	 * @emits {@link Event.VARIANT_INSTANCE_REGISTERED}
-	 */
-	public register( instanceDefinition: VariantInstanceDefinition ): VariantInstanceDefinition {
-		const name = instanceDefinition.name ? instanceDefinition.name
-																				 : DottedPath.create( instanceDefinition.variant ).path;
-		instanceDefinition.name = this.ensureUniqueName( name );
-		this.variantInstanceDefinitions.set( instanceDefinition.name, instanceDefinition );
-		this.broadcastEvent( Event.VARIANT_INSTANCE_REGISTERED, instanceDefinition );
-		return instanceDefinition;
-	}
-
-	/**
-	 * Commits the {@link ParameterBag} to all registered and created {@link VariantInstance}s.
-	 */
-	public async commitParameters( parameters: ParameterBag = {}, onlyVisible: boolean = true ): Promise<VariantInstanceManager> {
-		this.parameters = merge(this.parameters, parameters);
-		this.allDefinitions.forEach( definition => definition.parameters = merge( definition.parameters, this.parameters ) );
-		let instances = this.all;
-		if( onlyVisible ) {
-			instances = this.all.filter( instance => instance.variant.visible );
-		}
-		const promises = instances.map( instance => instance.variant.commitParameters( this.parameters ) );
-		await Promise.all( promises );
-		return this;
-	}
-
-	/**
-	 * Show one {@link VariantInstance}. If `exclusive` is set to `true` it will hide all other
-	 * instances handled by this {@link VariantInstanceManager}. If the function is called synchronously,
-	 * the calls end up in a queue according to the FIFO principle (the last one wins).
-	 */
-	public async show( name: string, exclusive: boolean = false ): Promise<VariantInstance> {
-		const promise: Promise<VariantInstance> = new Promise(async resolve => {
-			if( exclusive ) {
-				this.allDefinitions.filter( definition => definition.name !== name ).forEach( definition => {
-					const parameters: ParameterBag = {};
-					parameters[Parameter.VISIBLE] = false;
-					definition.parameters = merge( definition.parameters, parameters);
-				});
-				await Promise.all( this.all.filter( _instance => _instance.name !== name ).map( _instance => {
-					return _instance.variant.hide();
-				} ) );
-			}
-			const instance = await this.get( name );
-			await instance.variant.show();
-			resolve(instance);
-		});
-		if( ! this.queues['show'] ) {
-			this.queues['show'] = [];
-		}
-		this.queues['show'].push(promise);
-		for( let i = 0; i < this.queues['show'].length; i++) {
-			const instance = await this.queues['show'][i];
-			if( exclusive ) {
-				if( i + 1 < this.queues['show'].length ) {
-					await instance.variant.hide();
-				}
-			}
-		}
-		this.queues['show'] = [];
-		return promise;
-	}
-
-	/**
-	 * Clones and registers a new {@link VariantInstance} with a new, unique name.
-	 *
-	 * @emits {@link Event.VARIANT_INSTANCE_CLONED}
-	 */
-	public async clone( name: string, newName: string, parameters?: ParameterBag ): Promise<VariantInstance> {
-		if( !this.variantInstances.has( name ) ) {
-			throw Error( `VariantInstance with name "${name}" does not exist.` );
-		}
-		const variantInstance = this.variantInstances.get( name )!;
-		const definition = {
-			name: this.ensureUniqueName( newName ? newName : name ),
-			variant: variantInstance.variant.id,
-			parameters: parameters
-		};
-		const living = await variantInstance.variant.createLiving( definition.parameters );
-		const variantInstanceClone = new VariantInstance( living, definition.name );
-		this.variantInstances.set( definition.name, variantInstanceClone );
-		variantInstance.broadcastEvent( Event.VARIANT_INSTANCE_CLONED, variantInstanceClone );
-		return variantInstanceClone;
-	}
-
-	/**
-	 * Destroys the instance by removing the {@link Variant} and de-registering the instance.
-	 *
-	 * @emits {@link Event.VARIANT_INSTANCE_DESTROYED}
-	 */
-	public destroy( name: string ): VariantInstanceManager {
-		if( !this.variantInstances.has( name ) ) {
-			throw Error( `VariantInstance with name "${name}" does not exist.` );
-		}
-		const variantInstance = this.variantInstances.get( name )!;
-		variantInstance.variant.destroy();
-		this.variantInstances.delete( name );
-		variantInstance.broadcastEvent( Event.VARIANT_INSTANCE_DESTROYED, variantInstance );
-		return this;
-	}
-
-	/**
-	 * Creates and registers a unique {@link VariantInstance} from `definition`.
-	 *
-	 * @emits {@link Event.VARIANT_INSTANCE_CREATED}
-	 */
-	protected async createFromDefinition( definition: VariantInstanceDefinition ): Promise<VariantInstance> {
-		if( !definition.name ) {
-			throw new Error( `Given VariantInstanceDefinition ${definition.variant} is missing a name property.` );
-		}
-		if( this.variantInstances.has( definition.name ) ) {
-			throw new Error( `VariantInstance with name "${definition.name}" is already created.` );
-		}
-		if( !this.rootVariant ) {
-			throw new Error( `Viewer has not been properly bootstrapped (rootVariant missing).` );
-		}
-		const variant = await this.rootVariant.getDescendant( definition.variant );
-		const living = await variant.createLiving( definition.parameters );
-		const variantInstance = new VariantInstance( living, definition.name );
-		this.variantInstances.set( definition.name, variantInstance );
-		this.broadcastEvent( Event.VARIANT_INSTANCE_CREATED, variantInstance );
-		return variantInstance;
-	}
-
-	/**
-	 * Creates a unique instance name based on already registered instance names on the {@link VariantInstanceManager}.
-	 * Appends an `_i` to the name where `i = 0` and increments as long as the name is not registered.
-	 */
-	protected ensureUniqueName( name: string ): string {
-		let instanceName = name;
-		let i = 1;
-		while( this.has( instanceName ) ) {
-			instanceName = `${name}_${i}`;
-			i++;
-		}
-		return instanceName;
-	}
-
+import { merge } from 'lodash-es';
+import { DottedPath } from '../classes/dottedPath';
+import { Event } from '../classes/event';
+import { EventBroadcaster } from '../classes/eventBroadcaster';
+import { Parameter } from '../classes/parameter';
+import { Variant } from '../classes/variant';
+import { VariantInstance } from '../classes/variantInstance';
+
+/**
+ * There's usually no need to instantiate a {@link VariantInstanceManager} yourself as it is provided by each
+ * {@link Viewer} instance via its {@link Viewer.variantInstances}
+ */
+export class VariantInstanceManager extends EventBroadcaster {
+
+	protected variantInstances: Map<string, VariantInstance> = new Map();
+
+	protected variantInstanceDefinitions: Map<string, VariantInstanceDefinition> = new Map();
+
+	protected parameters: ParameterBag = {};
+
+	protected queues: { [name: string]: Promise<VariantInstance>[] } = {};
+
+	/**
+	 * Constructor.
+	 */
+	protected constructor( protected rootVariant: Variant ) {
+		super();
+	}
+
+	/**
+	 * Creates a {@link VariantInstanceManager} based on given root Variant.
+	 */
+	public static async create( rootVariant: Variant ): Promise<VariantInstanceManager> {
+		return new VariantInstanceManager( rootVariant );
+	}
+
+	/**
+	 * Gets all instances.
+	 */
+	get all() {
+		const all: VariantInstance[] = [];
+		this.variantInstances.forEach( variantInstance => all.push( variantInstance ) );
+		return all;
+	}
+
+	/**
+	 * Gets all instance definitions.
+	 */
+	get allDefinitions() {
+		const all: VariantInstanceDefinition[] = [];
+		this.variantInstanceDefinitions.forEach( definition => all.push( definition ) );
+		return all;
+	}
+
+	/**
+	 * Checks whether a {@link VariantInstance} is either registered or created.
+	 */
+	public has( name: string ) {
+		return this.variantInstances.has( name ) || this.variantInstanceDefinitions.has( name );
+	}
+
+	/**
+	 * Retrieves a {@link VariantInstance}.
+	 * If the instance has been created, the created instance will be returned.
+	 * If the instance is registered, the instance will be created.
+	 * If none of these apply, an Error is thrown.
+	 *
+	 * @emits {@link Event.VARIANT_INSTANCE_CREATED}
+	 */
+	public async get( name: string ): Promise<VariantInstance> {
+		if( this.variantInstances.has( name ) ) {
+			return this.variantInstances.get( name )!;
+		}
+		if( this.variantInstanceDefinitions.has( name ) ) {
+			const definition = this.variantInstanceDefinitions.get( name )!;
+			return await this.createFromDefinition( definition );
+		}
+		throw Error( `VariantInstance with name "${name}" neither created nor configured.` );
+	}
+
+	/**
+	 * Creates and registers a unique {@link VariantInstance}.
+	 *
+	 * @emits {@link Event.VARIANT_INSTANCE_CREATED}
+	 */
+	public async create( dottedPath: DottedPathArgument, name?: string, parameters?: ParameterBag ): Promise<VariantInstance> {
+		const variant = DottedPath.create( dottedPath ).path;
+		const definition = {
+			name: this.ensureUniqueName( name ? name : variant ),
+			variant: variant,
+			parameters: parameters
+		};
+		return await this.createFromDefinition( definition );
+	}
+
+	/**
+	 * Registers a unique {@link VariantInstanceDefinition}.
+	 *
+	 * @emits {@link Event.VARIANT_INSTANCE_REGISTERED}
+	 */
+	public register( instanceDefinition: VariantInstanceDefinition ): VariantInstanceDefinition {
+		const name = instanceDefinition.name ? instanceDefinition.name
+																				 : DottedPath.create( instanceDefinition.variant ).path;
+		instanceDefinition.name = this.ensureUniqueName( name );
+		this.variantInstanceDefinitions.set( instanceDefinition.name, instanceDefinition );
+		this.broadcastEvent( Event.VARIANT_INSTANCE_REGISTERED, instanceDefinition );
+		return instanceDefinition;
+	}
+
+	/**
+	 * Commits the {@link ParameterBag} to all registered and created {@link VariantInstance}s.
+	 */
+	public async commitParameters( parameters: ParameterBag = {}, onlyVisible: boolean = true ): Promise<VariantInstanceManager> {
+		this.parameters = merge(this.parameters, parameters);
+		this.allDefinitions.forEach( definition => definition.parameters = merge( definition.parameters, this.parameters ) );
+		let instances = this.all;
+		if( onlyVisible ) {
+			instances = this.all.filter( instance => instance.variant.visible );
+		}
+		const promises = instances.map( instance => instance.variant.commitParameters( this.parameters ) );
+		await Promise.all( promises );
+		return this;
+	}
+
+	/**
+	 * Show one {@link VariantInstance}. If `exclusive` is set to `true` it will hide all other
+	 * instances handled by this {@link VariantInstanceManager}. If the function is called synchronously,
+	 * the calls end up in a queue according to the FIFO principle (the last one wins).
+	 */
+	public async show( name: string, exclusive: boolean = false ): Promise<VariantInstance> {
+		const promise: Promise<VariantInstance> = new Promise(async resolve => {
+			if( exclusive ) {
+				this.allDefinitions.filter( definition => definition.name !== name ).forEach( definition => {
+					const parameters: ParameterBag = {};
+					parameters[Parameter.VISIBLE] = false;
+					definition.parameters = merge( definition.parameters, parameters);
+				});
+				await Promise.all( this.all.filter( _instance => _instance.name !== name ).map( _instance => {
+					return _instance.variant.hide();
+				} ) );
+			}
+			const instance = await this.get( name );
+			await instance.variant.show();
+			resolve(instance);
+		});
+		if( ! this.queues['show'] ) {
+			this.queues['show'] = [];
+		}
+		this.queues['show'].push(promise);
+		for( let i = 0; i < this.queues['show'].length; i++) {
+			const instance = await this.queues['show'][i];
+			if( exclusive ) {
+				if( i + 1 < this.queues['show'].length ) {
+					await instance.variant.hide();
+				}
+			}
+		}
+		this.queues['show'] = [];
+		return promise;
+	}
+
+	/**
+	 * Clones and registers a new {@link VariantInstance} with a new, unique name.
+	 *
+	 * @emits {@link Event.VARIANT_INSTANCE_CLONED}
+	 */
+	public async clone( name: string, newName: string, parameters?: ParameterBag ): Promise<VariantInstance> {
+		if( !this.variantInstances.has( name ) ) {
+			throw Error( `VariantInstance with name "${name}" does not exist.` );
+		}
+		const variantInstance = this.variantInstances.get( name )!;
+		const definition = {
+			name: this.ensureUniqueName( newName ? newName : name ),
+			variant: variantInstance.variant.id,
+			parameters: parameters
+		};
+		const living = await variantInstance.variant.createLiving( definition.parameters );
+		const variantInstanceClone = new VariantInstance( living, definition.name );
+		this.variantInstances.set( definition.name, variantInstanceClone );
+		variantInstance.broadcastEvent( Event.VARIANT_INSTANCE_CLONED, variantInstanceClone );
+		return variantInstanceClone;
+	}
+
+	/**
+	 * Destroys the instance by removing the {@link Variant} and de-registering the instance.
+	 *
+	 * @emits {@link Event.VARIANT_INSTANCE_DESTROYED}
+	 */
+	public destroy( name: string ): VariantInstanceManager {
+		if( !this.variantInstances.has( name ) ) {
+			throw Error( `VariantInstance with name "${name}" does not exist.` );
+		}
+		const variantInstance = this.variantInstances.get( name )!;
+		variantInstance.variant.destroy();
+		this.variantInstances.delete( name );
+		variantInstance.broadcastEvent( Event.VARIANT_INSTANCE_DESTROYED, variantInstance );
+		return this;
+	}
+
+	/**
+	 * Creates and registers a unique {@link VariantInstance} from `definition`.
+	 *
+	 * @emits {@link Event.VARIANT_INSTANCE_CREATED}
+	 */
+	protected async createFromDefinition( definition: VariantInstanceDefinition ): Promise<VariantInstance> {
+		if( !definition.name ) {
+			throw new Error( `Given VariantInstanceDefinition ${definition.variant} is missing a name property.` );
+		}
+		if( this.variantInstances.has( definition.name ) ) {
+			throw new Error( `VariantInstance with name "${definition.name}" is already created.` );
+		}
+		if( !this.rootVariant ) {
+			throw new Error( `Viewer has not been properly bootstrapped (rootVariant missing).` );
+		}
+		const variant = await this.rootVariant.getDescendant( definition.variant );
+		const living = await variant.createLiving( definition.parameters );
+		const variantInstance = new VariantInstance( living, definition.name );
+		this.variantInstances.set( definition.name, variantInstance );
+		this.broadcastEvent( Event.VARIANT_INSTANCE_CREATED, variantInstance );
+		return variantInstance;
+	}
+
+	/**
+	 * Creates a unique instance name based on already registered instance names on the {@link VariantInstanceManager}.
+	 * Appends an `_i` to the name where `i = 0` and increments as long as the name is not registered.
+	 */
+	protected ensureUniqueName( name: string ): string {
+		let instanceName = name;
+		let i = 1;
+		while( this.has( instanceName ) ) {
+			instanceName = `${name}_${i}`;
+			i++;
+		}
+		return instanceName;
+	}
+
 }

package/src/api/store/specStorage.ts

@@ -1,54 +1,54 @@
-import { get, set } from 'lodash-es';
-
-export class SpecStorage {
-
-	public static instance: SpecStorage|undefined;
-
-	/**
-	 * Constructor.
-	 */
-	protected constructor( protected spec: StructureJson ) {
-	}
-
-	/**
-	 * Creates {@link SpecStorage} from spec.
-	 */
-	public static createFromSpec( structureJson: StructureJson ): SpecStorage {
-		if( this.instance ) {
-			throw new Error( `SpecStorage has already been created.` );
-		}
-		return (this.instance = new this( structureJson ));
-	}
-
-	/**
-	 * Destroys the current instance to allow reinstantiating the SpecStorage.
-	 */
-	public static destroy() {
-		this.instance = undefined
-	}
-
-	/**
-	 * Gets spec from key.
-	 */
-	public static get<T>( key?: string ): T {
-		if( !this.instance || !this.instance.spec ) {
-			throw new Error( `SpecStore has not been properly created.` );
-		}
-		if( key ) {
-			return get( this.instance.spec, key ) as T;
-		}
-		return this.instance.spec as T;
-	}
-
-	/**
-	 * Sets value for spec for given key.
-	 */
-	public static set<T>( key: string, value: T ) {
-		if( !this.instance || !this.instance.spec ) {
-			throw new Error( `SpecStore has not been properly created.` );
-		}
-		set( this.instance.spec, key, value );
-		return SpecStorage;
-	}
-
+import { get, set } from 'lodash-es';
+
+export class SpecStorage {
+
+	public static instance: SpecStorage|undefined;
+
+	/**
+	 * Constructor.
+	 */
+	protected constructor( protected spec: StructureJson ) {
+	}
+
+	/**
+	 * Creates {@link SpecStorage} from spec.
+	 */
+	public static createFromSpec( structureJson: StructureJson ): SpecStorage {
+		if( this.instance ) {
+			throw new Error( `SpecStorage has already been created.` );
+		}
+		return (this.instance = new this( structureJson ));
+	}
+
+	/**
+	 * Destroys the current instance to allow reinstantiating the SpecStorage.
+	 */
+	public static destroy() {
+		this.instance = undefined
+	}
+
+	/**
+	 * Gets spec from key.
+	 */
+	public static get<T>( key?: string ): T {
+		if( !this.instance || !this.instance.spec ) {
+			throw new Error( `SpecStore has not been properly created.` );
+		}
+		if( key ) {
+			return get( this.instance.spec, key ) as T;
+		}
+		return this.instance.spec as T;
+	}
+
+	/**
+	 * Sets value for spec for given key.
+	 */
+	public static set<T>( key: string, value: T ) {
+		if( !this.instance || !this.instance.spec ) {
+			throw new Error( `SpecStore has not been properly created.` );
+		}
+		set( this.instance.spec, key, value );
+		return SpecStorage;
+	}
+
 }