@vertexvis/viewer 0.13.2-canary.9 → 0.14.0

package/dist/esm/model-f679c493.js

@@ -0,0 +1,241 @@
+/**!
+ * Copyright (c) 2022 Vertex Software LLC. All rights reserved.
+ */
+import { E as EventDispatcher } from './browser.esm-1ddb69c9.js';
+
+/**
+ * The `PinController` is responsible for adding pin entities to the viewer canvas
+ */
+class PinController {
+  constructor(model, mode = 'view', type = 'pin') {
+    this.model = model;
+    this.mode = mode;
+    this.type = type;
+  }
+  /**
+   * Registers an entity to place on the canvas and places the pin on the associated part.
+   *
+   * @param pin The pin entity
+   * @returns A void promise
+   */
+  addPin(pin) {
+    this.model.addPin(pin);
+  }
+  /**
+   * Clears all entities and returns a promise that resolves with an empty list
+   * of pin results.
+   */
+  clearPins() {
+    this.model.clearPins();
+  }
+  /**
+   * Deregisters an entity and performs a pin if this entity was
+   * removed.
+   *
+   * @param entity The entity to remove.
+   * @returns A promise that resolves with the results after removing this
+   * entity.
+   */
+  removePin(pin) {
+    this.model.removePin(pin);
+  }
+  /**
+   * Registers a set of entities and adds a pin
+   *
+   * @param entities The pin entities to draw.
+   * @returns A promise that resolves with the results after registering these
+   * entities.
+   */
+  setPins(pins) {
+    this.model.setPins(pins);
+  }
+  /**
+   * Sets the set of entities to be placed with the model.
+   *
+   * @param pin A pin to set
+   * @returns `true` if the entity has been added.
+   */
+  setPin(pin) {
+    this.model.setPin(pin);
+  }
+  /**
+   * Updates an existing pin
+   * @param pin A pin to set
+   * @returns `true` if the entity has been updated, false otherwise
+   */
+  updatePin(pin) {
+    this.model.updatePin(pin);
+  }
+  /**
+   * Tells the controller which pin is selected in the model
+   * @param pinId
+   */
+  setSelectedPinId(pinId) {
+    this.model.setSelectedPin(pinId);
+  }
+  getToolMode() {
+    return this.mode;
+  }
+  getToolType() {
+    return this.type;
+  }
+  setToolMode(mode) {
+    this.mode = mode;
+  }
+  setToolType(type) {
+    this.type = type;
+  }
+  getDraggable() {
+    return this.draggable;
+  }
+  setDraggable(draggable) {
+    this.draggable = draggable;
+  }
+  updateDraggable(draggable, worldPosition, partId) {
+    if (this.draggable != null) {
+      this.draggable = draggable;
+    }
+    const pin = this.model.getPinById(draggable.id);
+    if (pin != null) {
+      this.updatePin(Object.assign(Object.assign({}, pin), { worldPosition,
+        partId }));
+    }
+  }
+}
+
+function isTextPin(pin) {
+  return pin != null && pin.label != null;
+}
+function isDefaultPin(pin) {
+  return pin != null && pin.label == null;
+}
+class PinModel {
+  constructor() {
+    this.entities = {};
+    this.entitiesChanged = new EventDispatcher();
+    this.selectionChanged = new EventDispatcher();
+  }
+  /**
+   * Registers an entity to be drawn in the canvas
+   *
+   * @param pin A pin entity to draw.
+   * @returns `true` if the entity has been added.
+   */
+  addPin(pin, surpressEvent = false) {
+    if (this.entities[pin.id] == null) {
+      this.entities = Object.assign(Object.assign({}, this.entities), { [pin.id]: pin });
+      if (!surpressEvent) {
+        this.entitiesChanged.emit(this.getPins());
+      }
+      return true;
+    }
+    else {
+      return false;
+    }
+  }
+  /**
+   * Clears all registered entities from the model.
+   */
+  clearPins() {
+    this.getPins().forEach((e) => this.removePin(e));
+  }
+  /**
+   * Returns all the entities registered with the model.
+   */
+  getPins() {
+    return Object.keys(this.entities).map((key) => this.entities[key]);
+  }
+  /**
+   * Returns single entity by id if present in the model.
+   */
+  getPinById(id) {
+    return this.entities[id];
+  }
+  getSelectedPinId() {
+    return this.selectedPinId;
+  }
+  /**
+   * Unregisters an entity from the model.
+   *
+   * @param entity The entity to remove.
+   * @returns `true` if the entity was removed.
+   */
+  removePin(entity) {
+    if (this.entities[entity.id] != null) {
+      delete this.entities[entity.id];
+      this.entitiesChanged.emit(this.getPins());
+      return true;
+    }
+    else {
+      return false;
+    }
+  }
+  /**
+   * Sets the set of entities to be placed with the model.
+   *
+   * @param entities A set of entities to draw.
+   * @returns `true` if the entity has been added.
+   */
+  setPins(pins) {
+    this.clearPins();
+    pins.forEach((e) => this.addPin(e, true));
+    this.entitiesChanged.emit(this.getPins());
+    return true;
+  }
+  /**
+   * Sets the set of entities to be placed with the model.
+   *
+   * @param pin A pin to set
+   * @returns `true` if the entity has been set
+   */
+  setPin(pin) {
+    this.entities = Object.assign(Object.assign({}, this.entities), { [pin.id]: pin });
+    this.entitiesChanged.emit(this.getPins());
+    return true;
+  }
+  /**
+   * Sets the set of entities to be placed with the model.
+   *
+   * @param pin A pin to set
+   * @returns `true` if the entity has been set
+   */
+  updatePin(pin) {
+    const pinById = this.getPinById(pin.id);
+    if (pinById != null) {
+      this.entities = Object.assign(Object.assign({}, this.entities), { [pin.id]: pin });
+      this.entitiesChanged.emit(this.getPins());
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Registers an event listener that will be invoked when the model's
+   * pin entities change.
+   *
+   * @param listener The listener to add.
+   * @returns A disposable that can be used to remove the listener.
+   */
+  onEntitiesChanged(listener) {
+    return this.entitiesChanged.on(listener);
+  }
+  /**
+   * Registers an event listener that will be invoked when the model's
+   * pin selection changes
+   *
+   * @param listener The listener to add.
+   * @returns A disposable that can be used to remove the listener.
+   */
+  onSelectionChange(listener) {
+    return this.selectionChanged.on(listener);
+  }
+  /**
+   * Sets the selected pin Id
+   * @param pinId
+   */
+  setSelectedPin(pinId) {
+    this.selectedPinId = pinId;
+    this.selectionChanged.emit(this.selectedPinId);
+  }
+}
+
+export { PinModel as P, PinController as a, isTextPin as b, isDefaultPin as i };

package/dist/esm/{overlays-354e275c.js → overlays-ea2d45ec.js}

@@ -1,8 +1,8 @@
 /**!
  * Copyright (c) 2022 Vertex Software LLC. All rights reserved.
  */
-import { v as vector3 } from './bundle.esm-8ceccb91.js';
-import { E as EventDispatcher, b as uuid } from './browser.esm-e72d80ad.js';
+import { v as vector3 } from './bundle.esm-ce2c7ad3.js';
+import { E as EventDispatcher, b as uuid } from './browser.esm-1ddb69c9.js';
 
 class MeasurementOverlayManager {
   constructor() {

package/dist/esm/{png-decoder-07de80d1.js → png-decoder-d4b65417.js}

@@ -1,8 +1,8 @@
 /**!
  * Copyright (c) 2022 Vertex Software LLC. All rights reserved.
  */
-import { c as __awaiter$2, e as __generator, g as __spreadArray } from './bundle.esm-8ceccb91.js';
-import { c as createCommonjsModule } from './_commonjsHelpers-9943807e.js';
+import { c as __awaiter$2, e as __generator, g as __spreadArray } from './bundle.esm-ce2c7ad3.js';
+import { c as createCommonjsModule } from './_commonjsHelpers-11ca3be1.js';
 
 const DefaultErrorSerializer = {
     deserialize(message) {

package/dist/esm/{results-4d0c3568.js → results-3b4df2cf.js}

@@ -1,7 +1,7 @@
 /**!
  * Copyright (c) 2022 Vertex Software LLC. All rights reserved.
  */
-import { v as vector3 } from './bundle.esm-8ceccb91.js';
+import { v as vector3 } from './bundle.esm-ce2c7ad3.js';
 
 /**
  * Constructs a new measurement result from the given points.

package/dist/esm/{scene-2bfcce74.js → scene-22ebacfd.js}

@@ -1,13 +1,14 @@
 /**!
  * Copyright (c) 2022 Vertex Software LLC. All rights reserved.
  */
-import { c as color, u as uri, a as async, b as uuid } from './browser.esm-e72d80ad.js';
-import { v as vector3, b as boundingBox, a as boundingSphere, p as point, d as dimensions } from './bundle.esm-8ceccb91.js';
-import { v as vertexvis, t as toProtoDuration, g as toProtobuf, e as FramePerspectiveCamera, h as constrainViewVector, d as FrameOrthographicCamera, w as withPositionAndViewVector, i as fromBoundingBoxAndLookAtCamera } from './streamAttributes-d0b384b3.js';
+import { c as color, u as uri, a as async, b as uuid } from './browser.esm-1ddb69c9.js';
+import { v as vector3, b as boundingBox, a as boundingSphere, m as matrix4, q as quaternion, r as ray, p as point, d as dimensions } from './bundle.esm-ce2c7ad3.js';
+import { v as vertexvis, t as toProtoDuration, g as toProtobuf, e as FramePerspectiveCamera, h as constrainViewVector, d as FrameOrthographicCamera, w as withPositionAndViewVector, i as fromBoundingBoxAndLookAtCamera } from './streamAttributes-72a92676.js';
+import './entities-ce81dd7f.js';
 
 const defaultColor = {
-  opacity: 100,
-  glossiness: 10,
+  opacity: 255,
+  glossiness: 4,
   diffuse: {
     r: 0,
     g: 0,
@@ -39,7 +40,7 @@ const defaultColor = {
  * @param opacity
  */
 const create = (r, g, b, opacity) => {
-  return Object.assign(Object.assign({}, defaultColor), { opacity: opacity || 100, glossiness: opacity || 10, diffuse: {
+  return Object.assign(Object.assign({}, defaultColor), { opacity: opacity !== null && opacity !== void 0 ? opacity : defaultColor.opacity, diffuse: {
       r,
       g,
       b,
@@ -53,14 +54,14 @@ const create = (r, g, b, opacity) => {
  */
 const fromHex = (hex, opacity) => {
   const color$1 = color.fromHexString(hex);
-  return Object.assign(Object.assign({}, defaultColor), { opacity: opacity || 100, glossiness: opacity || 10, diffuse: color$1 != null ? Object.assign({}, color$1) : Object.assign({}, defaultColor.diffuse) });
+  return Object.assign(Object.assign({}, defaultColor), { opacity: opacity !== null && opacity !== void 0 ? opacity : defaultColor.opacity, diffuse: color$1 != null ? Object.assign({}, color$1) : Object.assign({}, defaultColor.diffuse) });
 };
 /**
  * The default material that is used for selected items.
  */
 const defaultSelectionMaterial = {
-  opacity: 100,
-  glossiness: 4,
+  opacity: defaultColor.opacity,
+  glossiness: defaultColor.glossiness,
   diffuse: {
     r: 255,
     g: 255,
@@ -89,6 +90,7 @@ const defaultSelectionMaterial = {
 
 const colorMaterial = /*#__PURE__*/Object.freeze({
   __proto__: null,
+  defaultColor: defaultColor,
   create: create,
   fromHex: fromHex,
   defaultSelectionMaterial: defaultSelectionMaterial
@@ -405,6 +407,7 @@ function buildSceneOperation(query, operations, context) {
         metadata: {
           valueFilter: query.filter,
           keys: query.keys,
+          exactMatch: query.exactMatch,
         },
         operationTypes,
       };
@@ -694,6 +697,38 @@ class Camera {
   rotateAroundAxis(angleInRadians, axis) {
     return this.rotateAroundAxisAtPoint(angleInRadians, this.data.lookAt, axis);
   }
+  /**
+   * Aligns the camera to the plane defined by the provided position and normal.
+   * This will place the camera at the provided position, set the up vector to
+   * the provided normal, and place the lookAt on the defined plane. The point
+   * chosen for the lookAt will be determined using the current view vector.
+   *
+   * @param position The position to place the camera at.
+   * @param normal The normal of the plane to align to.
+   */
+  alignTo(position, normal) {
+    const worldX = vector3.normalize(vector3.cross(this.up, vector3.normalize(this.viewVector)));
+    const positiveWorldY = vector3.normalize(vector3.cross(vector3.normalize(this.viewVector), worldX));
+    // Invert the world y axis if the provided normal is more than 90 degrees from it
+    // to compute a proper angle to rotate the view vector by
+    const worldY = vector3.angleTo(normal, positiveWorldY) > Math.PI / 2
+      ? vector3.negate(positiveWorldY)
+      : positiveWorldY;
+    const localX = vector3.isEqual(worldY, normal)
+      ? worldX
+      : vector3.normalize(vector3.cross(worldY, normal));
+    const transformedViewVector = vector3.transformMatrix(this.viewVector, matrix4.makeRotation(quaternion.fromAxisAngle(localX, vector3.angleTo(normal, worldY))));
+    const lookAtRay = ray.create({
+      origin: position,
+      direction: vector3.normalize(transformedViewVector),
+    });
+    const lookAt = ray.at(lookAtRay, vector3.magnitude(this.viewVector));
+    return this.update({
+      position,
+      lookAt,
+      up: normal,
+    });
+  }
   /**
    * Updates the `position` and `up` vectors of the camera to the given standard
    * view.
@@ -1016,8 +1051,8 @@ class RootQuery {
   withSceneTreeRange(range) {
     return new SceneTreeRangeQuery(range);
   }
-  withMetadata(filter, keys) {
-    return new MetadataQuery(filter, keys);
+  withMetadata(filter, keys, exactMatch) {
+    return new MetadataQuery(filter, keys, exactMatch);
   }
   withSelected() {
     return new AllSelectedQuery();
@@ -1043,15 +1078,17 @@ class SceneTreeRangeQuery {
   }
 }
 class MetadataQuery {
-  constructor(filter, keys) {
+  constructor(filter, keys, exactMatch) {
     this.filter = filter;
     this.keys = keys;
+    this.exactMatch = exactMatch;
   }
   build() {
     return {
       type: 'metadata',
       filter: this.filter,
       keys: this.keys,
+      exactMatch: this.exactMatch,
     };
   }
 }

package/dist/esm/{stencil-9bf7fb9e.js → stencil-8b20e5a8.js}

@@ -1,12 +1,15 @@
 /**!
  * Copyright (c) 2022 Vertex Software LLC. All rights reserved.
  */
-import { a as readTask } from './index-10c1495a.js';
+import { a as readTask, e as writeTask } from './index-a9fb8318.js';
 
 // eslint-disable-next-line no-restricted-imports
 function readDOM(task) {
   readTask(task);
 }
+function writeDOM(task) {
+  writeTask(task);
+}
 function debounceEvent(event, wait) {
   let timer = undefined;
   function debounce(value) {
@@ -17,4 +20,4 @@ function debounceEvent(event, wait) {
   return { emit: debounce };
 }
 
-export { debounceEvent as d, readDOM as r };
+export { debounceEvent as d, readDOM as r, writeDOM as w };