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

package/src/api/classes/variantInstance.ts

@@ -9,19 +9,22 @@ import { Variant } from './variant';
  * Class VariantInstance.
  */
 export class VariantInstance extends EventBroadcaster {
+  /**
+   * Constructor
+   */
+  public constructor(public variant: Variant, public name: string) {
+    super();
+  }
 
-	/**
-	 * Constructor
-	 */
-	public constructor( public variant: Variant, public name: string ) {
-		super();
-	}
-
-	/**
-	 * WORK IN PROGRESS
-	 */
-	public translate( joint: DottedPathArgument, variantInstance: VariantInstance, variantInstanceJoint: DottedPathArgument ): VariantInstance {
-		/*
+  /**
+   * WORK IN PROGRESS
+   */
+  public translate(
+    joint: DottedPathArgument,
+    variantInstance: VariantInstance,
+    variantInstanceJoint: DottedPathArgument
+  ): VariantInstance {
+    /*
 		joint = DottedPath.create( joint );
 		variantInstanceJoint = DottedPath.create( variantInstanceJoint );
 		const jointNode = variantInstance.variant.getNode( joint.path );
@@ -41,49 +44,54 @@ export class VariantInstance extends EventBroadcaster {
 			// node.rotate(Axis.Z, differenceVectorRotation.z, Space.WORLD );
 		} );
 		*/
-		return this;
-	}
-
-	/**
-	 * A proxy for {@link Variant.getElement}.
-	 */
-	public async getElement( dottedPath: DottedPathArgument ): Promise<Element> {
-		return this.variant.getElement( dottedPath );
-	}
+    return this;
+  }
 
-	/**
-	 * A proxy for {@link Variant.getViewerLight}.
-	 */
-	public async getViewerLight( dottedPath: DottedPathArgument ): Promise<ViewerLight> {
-		return this.variant.getViewerLight( dottedPath );
-	}
+  /**
+   * A proxy for {@link Variant.getElement}.
+   */
+  public async getElement(dottedPath: DottedPathArgument): Promise<Element> {
+    return this.variant.getElement(dottedPath);
+  }
 
-	/**
-	 * A proxy for {@link Variant.getNode}.
-	 */
-	public async getNode( elementDottedPath: DottedPathArgument, nodeDottedPath: DottedPathArgument ): Promise<TransformNode> {
-		return this.variant.getNode( elementDottedPath, nodeDottedPath );
-	}
+  /**
+   * A proxy for {@link Variant.getViewerLight}.
+   */
+  public async getViewerLight(dottedPath: DottedPathArgument): Promise<ViewerLight> {
+    return this.variant.getViewerLight(dottedPath);
+  }
 
-	/**
-	 * A proxy for {@link Variant.getMesh}.
-	 */
-	public async getMesh( elementDottedPath: DottedPathArgument, meshDottedPath: DottedPathArgument ): Promise<Mesh|null> {
-		return this.variant.getMesh( elementDottedPath, meshDottedPath );
-	}
+  /**
+   * A proxy for {@link Variant.getNode}.
+   */
+  public async getNode(
+    elementDottedPath: DottedPathArgument,
+    nodeDottedPath: DottedPathArgument
+  ): Promise<TransformNode> {
+    return this.variant.getNode(elementDottedPath, nodeDottedPath);
+  }
 
-	/**
-	 * A proxy for {@link Variant.commitParameters}.
-	 */
-	public async commitParameters( parameters?: ParameterBag ): Promise<Variant> {
-		return this.variant.commitParameters( parameters );
-	}
+  /**
+   * A proxy for {@link Variant.getMesh}.
+   */
+  public async getMesh(
+    elementDottedPath: DottedPathArgument,
+    meshDottedPath: DottedPathArgument
+  ): Promise<Mesh | null> {
+    return this.variant.getMesh(elementDottedPath, meshDottedPath);
+  }
 
-	/**
-	 * A proxy for {@link ParameterObservable.commitParameter}.
-	 */
-	public async commitParameter( parameter: string, value: ParameterValue ): Promise<ParameterObservable> {
-		return this.variant.commitParameter( parameter, value );
-	}
+  /**
+   * A proxy for {@link Variant.commitParameters}.
+   */
+  public async commitParameters(parameters?: ParameterBag): Promise<Variant> {
+    return this.variant.commitParameters(parameters);
+  }
 
-}
+  /**
+   * A proxy for {@link ParameterObservable.commitParameter}.
+   */
+  public async commitParameter(parameter: string, value: ParameterValue): Promise<ParameterObservable> {
+    return this.variant.commitParameter(parameter, value);
+  }
+}

package/src/api/classes/variantParameterizable.ts

@@ -7,74 +7,79 @@ import { mergeMaps } from './../util/resourceHelper';
 import { camelToSnakeCase } from './../util/stringHelper';
 
 export abstract class VariantParameterizable extends Parameterizable {
+  protected readonly _parameterObservers: Map<string, ParameterObserver[]> = new Map();
 
-	protected readonly _parameterObservers: Map<string, ParameterObserver[]> = new Map();
+  protected constructor(public readonly variant: Variant, public readonly name: string) {
+    super();
+  }
 
-	protected constructor( public readonly variant: Variant,
-	                       public readonly name: string ) {
-		super();
-	}
-
-	/**
-	 * Gets the inherited parameters from the {@link Variant} with cleaned {@link Parameterizable} prefix.
-	 */
-	get inheritedParameters(): ParameterBag {
-		const parameterBag: ParameterBag = {};
-		for( const parameter in this.variant.inheritedParameters ) {
-			const dpp = DottedPath.create( parameter );
-			if( dpp.parts.length !== 1 ) {
-				continue;
-			}
-			parameterBag[parameter] = this.variant.inheritedParameters[parameter];
-		}
-		for( const parameter in this.variant.inheritedParameters ) {
-			const dpp = DottedPath.create( parameter );
-			if( dpp.firstPart !== this.name ) {
-				continue;
-			}
-			dpp.shiftPart();
-			parameterBag[dpp.path] = this.variant.inheritedParameters[parameter];
-		}
-		return parameterBag;
-	}
-
-	/**
-	 * Places the given {@link ParameterBag} in the {@link VariantParameterizable}'s parameters, replaces all patterns in the
-	 * {@link StructureJson} and broadcasts all {@link ParameterObserver}s.
-	 */
-	public async commitParameters( parameters?: ParameterBag ): Promise<VariantParameterizable> {
-		if( !parameters ) {
-			parameters = {};
-		}
-		const oldParameters = cloneDeep( this.parameters );
-		merge( this.parameters, parameters );
-		// handle parameter observers
-		let observerPromises: Promise<void | ParameterObserver>[] = [];
-		for( const parameter in this.parameters ) {
-			const oldParameterValue = oldParameters[parameter];
-			const newParameterValue = this.parameters[parameter];
-			this.variant.assertParameter( this.variant.inheritedParameterDeclaration, parameter, newParameterValue );
-			if( oldParameterValue === newParameterValue ) {
-				continue;
-			}
-			// parameter changed
-			const parameterObservers = mergeMaps( this._parameterObservers, this.parameterObservers );
-			if( parameterObservers.has( parameter ) ) {
-				const observers = parameterObservers.get( parameter )!;
-				observerPromises = concat( observerPromises, observers.map( observer => {
-					const observerResult = observer( this, oldParameterValue, newParameterValue );
-					const observerPromise = Promise.resolve( observerResult );
-					observerPromise.then( () => {
-						const clsName = camelToSnakeCase( this.constructor.name ).toUpperCase();
-						this.broadcastEvent( get( Event, clsName + '_PARAMETER_COMMITTED' ),
-							this, parameter, oldParameterValue, newParameterValue );
-					} );
-					return observerPromise;
-				} ) );
-			}
-		}
-		await Promise.all( observerPromises );
-		return this;
-	}
+  /**
+   * Gets the inherited parameters from the {@link Variant} with cleaned {@link Parameterizable} prefix.
+   */
+  get inheritedParameters(): ParameterBag {
+    const parameterBag: ParameterBag = {};
+    for (const parameter in this.variant.inheritedParameters) {
+      const dpp = DottedPath.create(parameter);
+      if (dpp.parts.length !== 1) {
+        continue;
+      }
+      parameterBag[parameter] = this.variant.inheritedParameters[parameter];
+    }
+    for (const parameter in this.variant.inheritedParameters) {
+      const dpp = DottedPath.create(parameter);
+      if (dpp.firstPart !== this.name) {
+        continue;
+      }
+      dpp.shiftPart();
+      parameterBag[dpp.path] = this.variant.inheritedParameters[parameter];
+    }
+    return parameterBag;
+  }
 
+  /**
+   * Places the given {@link ParameterBag} in the {@link VariantParameterizable}'s parameters, replaces all patterns in the
+   * {@link StructureJson} and broadcasts all {@link ParameterObserver}s.
+   */
+  public async commitParameters(parameters?: ParameterBag): Promise<VariantParameterizable> {
+    if (!parameters) {
+      parameters = {};
+    }
+    const oldParameters = cloneDeep(this.parameters);
+    merge(this.parameters, parameters);
+    // handle parameter observers
+    let observerPromises: Promise<void | ParameterObserver>[] = [];
+    for (const parameter in this.parameters) {
+      const oldParameterValue = oldParameters[parameter];
+      const newParameterValue = this.parameters[parameter];
+      this.variant.assertParameter(this.variant.inheritedParameterDeclaration, parameter, newParameterValue);
+      if (oldParameterValue === newParameterValue) {
+        continue;
+      }
+      // parameter changed
+      const parameterObservers = mergeMaps(this._parameterObservers, this.parameterObservers);
+      if (parameterObservers.has(parameter)) {
+        const observers = parameterObservers.get(parameter)!;
+        observerPromises = concat(
+          observerPromises,
+          observers.map(observer => {
+            const observerResult = observer(this, oldParameterValue, newParameterValue);
+            const observerPromise = Promise.resolve(observerResult);
+            observerPromise.then(() => {
+              const clsName = camelToSnakeCase(this.constructor.name).toUpperCase();
+              this.broadcastEvent(
+                get(Event, clsName + '_PARAMETER_COMMITTED'),
+                this,
+                parameter,
+                oldParameterValue,
+                newParameterValue
+              );
+            });
+            return observerPromise;
+          })
+        );
+      }
+    }
+    await Promise.all(observerPromises);
+    return this;
+  }
 }