@combeenation/3d-viewer 6.1.0 → 6.2.0

package/src/api/classes/variantInstance.ts

@@ -1,97 +1,97 @@
-import { Element } from './element';
-import { EventBroadcaster } from './eventBroadcaster';
-import { ParameterObservable } from './parameterObservable';
-import { Variant } from './variant';
-import { ViewerLight } from './viewerLight';
-import { Mesh } from '@babylonjs/core/Meshes/mesh';
-
-/**
- * Class VariantInstance.
- */
-export class VariantInstance extends EventBroadcaster {
-  /**
-   * Constructor
-   */
-  public constructor(public variant: Variant, public name: string) {
-    super();
-  }
-
-  /**
-   * 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 );
-  const variantInstanceJointNode = variantInstance.variant.getNode( variantInstanceJoint.path );
-  const differenceVector = variantInstanceJointNode.getAbsolutePosition().subtract( jointNode.getAbsolutePosition() );
-  const differenceVectorRotation = variantInstanceJointNode.rotation.subtract( jointNode.rotation );
-
-  console.log( variantInstanceJointNode.rotationQuaternion, 'ROTATION' );
-
-  this.variant.nodes.forEach( node => {
-    node.translate( Axis.X, differenceVector.x, Space.WORLD );
-    node.translate( Axis.Y, differenceVector.y, Space.WORLD );
-    node.translate( Axis.Z, differenceVector.z, Space.WORLD );
-
-    node.rotateAround( Axis.Y, differenceVectorRotation, 20 );
-    // node.rotate(Axis.Y, differenceVectorRotation.y, Space.WORLD );
-    // 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);
-  }
-
-  /**
-   * A proxy for {@link Variant.getViewerLight}.
-   */
-  public async getViewerLight(dottedPath: DottedPathArgument): Promise<ViewerLight> {
-    return this.variant.getViewerLight(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.getMesh}.
-   */
-  public async getMesh(
-    elementDottedPath: DottedPathArgument,
-    meshDottedPath: DottedPathArgument
-  ): Promise<Mesh | null> {
-    return this.variant.getMesh(elementDottedPath, meshDottedPath);
-  }
-
-  /**
-   * 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);
-  }
-}
+import { Element } from './element';
+import { EventBroadcaster } from './eventBroadcaster';
+import { ParameterObservable } from './parameterObservable';
+import { Variant } from './variant';
+import { ViewerLight } from './viewerLight';
+import { Mesh } from '@babylonjs/core/Meshes/mesh';
+
+/**
+ * Class VariantInstance.
+ */
+export class VariantInstance extends EventBroadcaster {
+  /**
+   * Constructor
+   */
+  public constructor(public variant: Variant, public name: string) {
+    super();
+  }
+
+  /**
+   * 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 );
+  const variantInstanceJointNode = variantInstance.variant.getNode( variantInstanceJoint.path );
+  const differenceVector = variantInstanceJointNode.getAbsolutePosition().subtract( jointNode.getAbsolutePosition() );
+  const differenceVectorRotation = variantInstanceJointNode.rotation.subtract( jointNode.rotation );
+
+  console.log( variantInstanceJointNode.rotationQuaternion, 'ROTATION' );
+
+  this.variant.nodes.forEach( node => {
+    node.translate( Axis.X, differenceVector.x, Space.WORLD );
+    node.translate( Axis.Y, differenceVector.y, Space.WORLD );
+    node.translate( Axis.Z, differenceVector.z, Space.WORLD );
+
+    node.rotateAround( Axis.Y, differenceVectorRotation, 20 );
+    // node.rotate(Axis.Y, differenceVectorRotation.y, Space.WORLD );
+    // 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);
+  }
+
+  /**
+   * A proxy for {@link Variant.getViewerLight}.
+   */
+  public async getViewerLight(dottedPath: DottedPathArgument): Promise<ViewerLight> {
+    return this.variant.getViewerLight(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.getMesh}.
+   */
+  public async getMesh(
+    elementDottedPath: DottedPathArgument,
+    meshDottedPath: DottedPathArgument
+  ): Promise<Mesh | null> {
+    return this.variant.getMesh(elementDottedPath, meshDottedPath);
+  }
+
+  /**
+   * 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

@@ -1,85 +1,85 @@
-import { DottedPath } from './../classes/dottedPath';
-import { Event } from './../classes/event';
-import { Parameterizable } from './../classes/parameterizable';
-import { Variant } from './../classes/variant';
-import { mergeMaps } from './../util/resourceHelper';
-import { camelToSnakeCase } from './../util/stringHelper';
-import { cloneDeep, concat, get, merge } from 'lodash-es';
-
-export abstract class VariantParameterizable extends Parameterizable {
-  protected readonly _parameterObservers: Map<string, ParameterObserver[]> = new Map();
-
-  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;
-  }
-}
+import { DottedPath } from './../classes/dottedPath';
+import { Event } from './../classes/event';
+import { Parameterizable } from './../classes/parameterizable';
+import { Variant } from './../classes/variant';
+import { mergeMaps } from './../util/resourceHelper';
+import { camelToSnakeCase } from './../util/stringHelper';
+import { cloneDeep, concat, get, merge } from 'lodash-es';
+
+export abstract class VariantParameterizable extends Parameterizable {
+  protected readonly _parameterObservers: Map<string, ParameterObserver[]> = new Map();
+
+  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;
+  }
+}