@vertexvis/viewer 0.15.2-testing.3 → 0.15.2

package/dist/cjs/{scene-56438693.js → scene-a94e6fa5.js}

@@ -1,12 +1,14 @@
 /**!
- * Copyright (c) 2022 Vertex Software LLC. All rights reserved.
+ * Copyright (c) 2023 Vertex Software LLC. All rights reserved.
  */
 'use strict';
 
 const browser_esm = require('./browser.esm-5d246754.js');
-const bundle_esm = require('./bundle.esm-22b6f2d6.js');
-const streamAttributes = require('./streamAttributes-c64aee75.js');
+const errors = require('./errors-1b37642b.js');
+const bundle_esm$1 = require('./bundle.esm-22b6f2d6.js');
+const streamAttributes = require('./streamAttributes-cf0c513d.js');
 require('./entities-9eb7e608.js');
+const bundle_esm = require('./bundle.esm-b43c197a.js');
 
 const defaultColor = {
   opacity: 255,
@@ -98,104 +100,41 @@ const colorMaterial = /*#__PURE__*/Object.freeze({
   defaultSelectionMaterial: defaultSelectionMaterial
 });
 
-class CustomError extends Error {
-  constructor(message, e) {
-    super();
-    this.message = message;
-    this.stack = e === null || e === void 0 ? void 0 : e.stack;
-    this.name = this.constructor.name;
-    // Allows for `instanceof` checks.
-    Object.setPrototypeOf(this, CustomError.prototype);
-  }
-}
-class InvalidResourceUrnError extends CustomError {
-  constructor(message, e) {
-    super(message, e);
-    // Allows for `instanceof` checks.
-    Object.setPrototypeOf(this, InvalidResourceUrnError.prototype);
-  }
-}
-class ViewerInitializationError extends CustomError {
-  constructor(message, e) {
-    super(message, e);
-    // Allows for `instanceof` checks.
-    Object.setPrototypeOf(this, ViewerInitializationError.prototype);
-  }
-}
-class ComponentInitializationError extends CustomError {
-  constructor(message, e) {
-    super(message, e);
-    // Allows for `instanceof` checks.
-    Object.setPrototypeOf(this, ComponentInitializationError.prototype);
-  }
-}
-class SceneRenderError extends CustomError {
-  constructor(message, e) {
-    super(message, e);
-    // Allows for `instanceof` checks.
-    Object.setPrototypeOf(this, SceneRenderError.prototype);
-  }
-}
-class WebsocketConnectionError extends CustomError {
-  constructor(message, e) {
-    super(message, e);
-    // Allows for `instanceof` checks.
-    Object.setPrototypeOf(this, WebsocketConnectionError.prototype);
-  }
-}
-class InteractionHandlerError extends CustomError {
-  constructor(message, e) {
-    super(message, e);
-    // Allows for `instanceof` checks.
-    Object.setPrototypeOf(this, InteractionHandlerError.prototype);
-  }
-}
-class ImageLoadError extends CustomError {
-  constructor(message, e) {
-    super(message, e);
-    // Allows for `instanceof` checks.
-    Object.setPrototypeOf(this, ImageLoadError.prototype);
-  }
-}
-class IllegalStateError extends CustomError {
-  constructor(message, e) {
-    super(message, e);
-    // Allows for `instanceof` checks.
-    Object.setPrototypeOf(this, IllegalStateError.prototype);
-  }
-}
-class InvalidArgumentError extends CustomError {
-  constructor(message, e) {
-    super(message, e);
-    // Allows for `instanceof` checks.
-    Object.setPrototypeOf(this, InvalidArgumentError.prototype);
-  }
-}
-class InvalidCameraError extends CustomError {
-  constructor(message, e) {
-    super(message, e);
-    // Allows for `instanceof` checks.
-    Object.setPrototypeOf(this, InvalidCameraError.prototype);
-  }
-}
-
 function fromUrn(urn) {
+  var _a;
   const uri = browser_esm.uri.parse(urn);
   if (uri.scheme !== 'urn' || uri.path == null) {
     throw new Error('Invalid URN. Expected URN scheme.');
   }
-  const [nid, resourceType, resourceId] = uri.path.split(':');
+  const [nid, resourceType, resourceId, ...subResourcePath] = uri.path.split(/[:/]/);
   if (nid !== 'vertexvis') {
     throw new Error('Invalid URN. Expected URN to be vertexvis namespace');
   }
   switch (resourceType) {
     case 'stream-key':
+      const queries = fromQuery(uri.query);
+      const subResource = (_a = fromSubResourcePath(subResourcePath.join('/'))) !== null && _a !== void 0 ? _a : queries.find((q) => q.type === 'scene-view-state');
       return {
         resource: { type: 'stream-key', id: resourceId },
-        queries: fromQuery(uri.query),
+        subResource,
+        queries: queries.filter((q) => q.type !== 'scene-view-state'),
       };
     default:
-      throw new InvalidResourceUrnError(`Invalid URN. Unknown resource type ${resourceType}`);
+      throw new errors.InvalidResourceUrnError(`Invalid URN. Unknown resource type ${resourceType}`);
+  }
+}
+function fromSubResourcePath(path) {
+  if (path != null) {
+    const [subResourceType, subResourceId] = path.split('/');
+    switch (subResourceType) {
+      case 'scene-view-states':
+        return {
+          type: 'scene-view-state',
+          id: subResourceId,
+        };
+      default:
+        return undefined;
+    }
   }
 }
 function fromQuery(query) {
@@ -203,10 +142,12 @@ function fromQuery(query) {
     return query.split('&').map((queryFragment) => {
       const [resourceType, resourceId] = queryFragment.split('=');
       switch (resourceType) {
+        case 'supplied-id':
+          return { type: 'supplied-id', id: resourceId };
         case 'scene-view-state':
           return { type: 'scene-view-state', id: resourceId };
         default:
-          throw new Error('Invalid URN. Unknown query resource type');
+          throw new Error('Invalid URN. Unknown query value type');
       }
     });
   }
@@ -220,6 +161,13 @@ const loadableResource = /*#__PURE__*/Object.freeze({
   fromUrn: fromUrn
 });
 
+function isSceneViewStateId(identifier) {
+  return identifier.id != null;
+}
+function isSceneViewStateSuppliedId(identifier) {
+  return identifier.suppliedId != null;
+}
+
 /**
  * A `SynchronizedClock` allows for approximating the time on a remote machine.
  *
@@ -370,68 +318,114 @@ class CameraRenderResult {
   }
 }
 
-function buildSceneOperation(query, operations, context) {
-  const operationTypes = buildOperationTypes(operations);
+function buildSceneViewStateIdentifier(identifier) {
+  if (typeof identifier === 'string') {
+    return { sceneViewStateId: { hex: identifier } };
+  }
+  else if (isSceneViewStateId(identifier)) {
+    return { sceneViewStateId: { hex: identifier.id } };
+  }
+  else if (isSceneViewStateSuppliedId(identifier)) {
+    return { sceneViewStateSuppliedId: { value: identifier.suppliedId } };
+  }
+  else {
+    throw new Error('Unable to build scene view state identifier, input must be a string or `SceneViewStateIdentifier`.');
+  }
+}
+function buildQueryExpression(query, context) {
   switch (query.type) {
     case 'and':
     case 'or':
       return {
-        [query.type]: {
-          queries: query.expressions.map((exp) => ({
-            sceneItemQuery: buildSceneItemQuery(exp),
-          })),
+        operand: {
+          itemCollection: {
+            queries: query.expressions.map((exp) => ({
+              sceneItemQuery: buildSceneItemQuery(exp),
+            })),
+          },
+        },
+      };
+    case 'not':
+      return {
+        not: {
+          expression: buildQueryExpression(query.query, context),
         },
-        operationTypes,
       };
     case 'item-id':
     case 'supplied-id':
       return {
-        item: {
-          sceneItemQuery: buildSceneItemQuery(query),
+        operand: {
+          item: {
+            sceneItemQuery: buildSceneItemQuery(query),
+          },
         },
-        operationTypes,
       };
     case 'all':
       return {
-        all: {},
-        operationTypes,
+        operand: {
+          root: {},
+        },
       };
     case 'scene-tree-range':
       return {
-        sceneTreeRange: {
-          start: query.range.start,
-          end: query.range.end,
+        operand: {
+          sceneTreeRange: {
+            start: query.range.start,
+            end: query.range.end,
+          },
         },
-        operationTypes,
       };
     case 'metadata':
       return {
-        metadata: {
-          valueFilter: query.filter,
-          keys: query.keys,
-          exactMatch: query.exactMatch,
+        operand: {
+          metadata: {
+            valueFilter: query.filter,
+            keys: query.keys,
+            exactMatch: query.exactMatch,
+          },
         },
-        operationTypes,
       };
     case 'all-selected':
       return {
-        override: {
-          selection: {},
+        operand: {
+          override: {
+            selection: {},
+          },
         },
-        operationTypes,
       };
     case 'point':
       return {
-        point: {
-          point: query.point,
-          viewport: context.dimensions,
+        operand: {
+          point: {
+            point: query.point,
+            viewport: context.dimensions,
+          },
+        },
+      };
+    case 'volume-intersection':
+      return {
+        operand: {
+          volume: {
+            frustumByRectangle: {
+              rectangle: query.rectangle,
+            },
+            exclusive: query.exclusive,
+            viewport: context.dimensions,
+          },
         },
-        operationTypes,
       };
     default:
       return {};
   }
 }
+function buildSceneOperation(query, operations, context) {
+  const operationTypes = buildOperationTypes(operations);
+  const queryExpression = buildQueryExpression(query, context);
+  return {
+    queryExpression,
+    operationTypes,
+  };
+}
 function buildSceneItemQuery(item) {
   switch (item.type) {
     case 'item-id':
@@ -455,7 +449,7 @@ function buildFlyToOperation(frameCorrelationId, options, animation) {
     },
     animation: animation
       ? {
-        duration: streamAttributes.toProtoDuration(animation.milliseconds),
+        duration: bundle_esm.toProtoDuration(animation.milliseconds),
       }
       : undefined,
   };
@@ -551,6 +545,33 @@ function buildOperationTypes(operations) {
     }
   });
 }
+function toPbSceneViewStateFeatures(features) {
+  return features.map((feature) => {
+    switch (feature) {
+      case 'camera':
+        return streamAttributes.vertexvis.protobuf.stream.SceneViewStateFeature
+          .SCENE_VIEW_STATE_FEATURE_CAMERA;
+      case 'material_overrides':
+        return streamAttributes.vertexvis.protobuf.stream.SceneViewStateFeature
+          .SCENE_VIEW_STATE_FEATURE_MATERIAL_OVERRIDE;
+      case 'selection':
+        return streamAttributes.vertexvis.protobuf.stream.SceneViewStateFeature
+          .SCENE_VIEW_STATE_FEATURE_SELECTION;
+      case 'visibility':
+        return streamAttributes.vertexvis.protobuf.stream.SceneViewStateFeature
+          .SCENE_VIEW_STATE_FEATURE_VISIBILITY;
+      case 'transforms':
+        return streamAttributes.vertexvis.protobuf.stream.SceneViewStateFeature
+          .SCENE_VIEW_STATE_FEATURE_TRANSFORM;
+      case 'cross_section':
+        return streamAttributes.vertexvis.protobuf.stream.SceneViewStateFeature
+          .SCENE_VIEW_STATE_FEATURE_CROSS_SECTION;
+      default:
+        return streamAttributes.vertexvis.protobuf.stream.SceneViewStateFeature
+          .SCENE_VIEW_STATE_FEATURE_INVALID;
+    }
+  });
+}
 
 const PI_OVER_360 = 0.008726646259972;
 class TerminalFlyToExecutor {
@@ -618,9 +639,9 @@ class Camera {
     this.flyToOptions = flyToOptions;
   }
   fitCameraToBoundingBox(boundingBox, distance, viewVector) {
-    const vvec = bundle_esm.vector3.scale(distance, bundle_esm.vector3.normalize(viewVector));
-    const lookAt = bundle_esm.boundingBox.center(boundingBox);
-    const position = bundle_esm.vector3.subtract(lookAt, vvec);
+    const vvec = bundle_esm$1.vector3.scale(distance, bundle_esm$1.vector3.normalize(viewVector));
+    const lookAt = bundle_esm$1.boundingBox.center(boundingBox);
+    const position = bundle_esm$1.vector3.subtract(lookAt, vvec);
     return this.update({ lookAt, position, viewVector: vvec });
   }
   /**
@@ -631,9 +652,9 @@ class Camera {
    */
   signedDistanceToBoundingBoxCenter(boundingBox) {
     const { position, viewVector } = streamAttributes.withPositionAndViewVector(this.data);
-    const boundingBoxCenter = bundle_esm.boundingBox.center(boundingBox !== null && boundingBox !== void 0 ? boundingBox : this.boundingBox);
-    const cameraToCenter = bundle_esm.vector3.subtract(boundingBoxCenter, position);
-    return (bundle_esm.vector3.dot(viewVector, cameraToCenter) / bundle_esm.vector3.magnitude(viewVector));
+    const boundingBoxCenter = bundle_esm$1.boundingBox.center(boundingBox !== null && boundingBox !== void 0 ? boundingBox : this.boundingBox);
+    const cameraToCenter = bundle_esm$1.vector3.subtract(boundingBoxCenter, position);
+    return (bundle_esm$1.vector3.dot(viewVector, cameraToCenter) / bundle_esm$1.vector3.magnitude(viewVector));
   }
   /**
    * Specifies that the next render of the camera will be repositioned to one of
@@ -715,22 +736,22 @@ class Camera {
    * @param normal The normal of the plane to align to.
    */
   alignTo(position, normal) {
-    const worldX = bundle_esm.vector3.normalize(bundle_esm.vector3.cross(this.up, bundle_esm.vector3.normalize(this.viewVector)));
-    const positiveWorldY = bundle_esm.vector3.normalize(bundle_esm.vector3.cross(bundle_esm.vector3.normalize(this.viewVector), worldX));
+    const worldX = bundle_esm$1.vector3.normalize(bundle_esm$1.vector3.cross(this.up, bundle_esm$1.vector3.normalize(this.viewVector)));
+    const positiveWorldY = bundle_esm$1.vector3.normalize(bundle_esm$1.vector3.cross(bundle_esm$1.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 = bundle_esm.vector3.angleTo(normal, positiveWorldY) > Math.PI / 2
-      ? bundle_esm.vector3.negate(positiveWorldY)
+    const worldY = bundle_esm$1.vector3.angleTo(normal, positiveWorldY) > Math.PI / 2
+      ? bundle_esm$1.vector3.negate(positiveWorldY)
       : positiveWorldY;
-    const localX = bundle_esm.vector3.isEqual(worldY, normal)
+    const localX = bundle_esm$1.vector3.isEqual(worldY, normal)
       ? worldX
-      : bundle_esm.vector3.normalize(bundle_esm.vector3.cross(worldY, normal));
-    const transformedViewVector = bundle_esm.vector3.transformMatrix(this.viewVector, bundle_esm.matrix4.makeRotation(bundle_esm.quaternion.fromAxisAngle(localX, bundle_esm.vector3.angleTo(normal, worldY))));
-    const lookAtRay = bundle_esm.ray.create({
+      : bundle_esm$1.vector3.normalize(bundle_esm$1.vector3.cross(worldY, normal));
+    const transformedViewVector = bundle_esm$1.vector3.transformMatrix(this.viewVector, bundle_esm$1.matrix4.makeRotation(bundle_esm$1.quaternion.fromAxisAngle(localX, bundle_esm$1.vector3.angleTo(normal, worldY))));
+    const lookAtRay = bundle_esm$1.ray.create({
       origin: position,
-      direction: bundle_esm.vector3.normalize(transformedViewVector),
+      direction: bundle_esm$1.vector3.normalize(transformedViewVector),
     });
-    const lookAt = bundle_esm.ray.at(lookAtRay, bundle_esm.vector3.magnitude(this.viewVector));
+    const lookAt = bundle_esm$1.ray.at(lookAtRay, bundle_esm$1.vector3.magnitude(this.viewVector));
     return this.update({
       position,
       lookAt,
@@ -747,8 +768,8 @@ class Camera {
   standardView(standardView) {
     return this.update({
       position: standardView.position,
-      viewVector: bundle_esm.vector3.subtract(bundle_esm.vector3.origin(), standardView.position),
-      lookAt: bundle_esm.vector3.origin(),
+      viewVector: bundle_esm$1.vector3.subtract(bundle_esm$1.vector3.origin(), standardView.position),
+      lookAt: bundle_esm$1.vector3.origin(),
       up: standardView.up,
     });
   }
@@ -786,21 +807,21 @@ class PerspectiveCamera extends Camera {
    */
   moveBy(delta) {
     return this.update({
-      position: bundle_esm.vector3.add(this.position, delta),
-      lookAt: bundle_esm.vector3.add(this.lookAt, delta),
+      position: bundle_esm$1.vector3.add(this.position, delta),
+      lookAt: bundle_esm$1.vector3.add(this.lookAt, delta),
     });
   }
   rotateAroundAxisAtPoint(angleInRadians, point, axis) {
     return this.update({
-      position: bundle_esm.vector3.rotateAboutAxis(angleInRadians, this.position, axis, point),
-      lookAt: bundle_esm.vector3.rotateAboutAxis(angleInRadians, this.lookAt, axis, point),
-      up: bundle_esm.vector3.rotateAboutAxis(angleInRadians, this.up, axis, bundle_esm.vector3.origin()),
+      position: bundle_esm$1.vector3.rotateAboutAxis(angleInRadians, this.position, axis, point),
+      lookAt: bundle_esm$1.vector3.rotateAboutAxis(angleInRadians, this.lookAt, axis, point),
+      up: bundle_esm$1.vector3.rotateAboutAxis(angleInRadians, this.up, axis, bundle_esm$1.vector3.origin()),
     });
   }
   fitToBoundingBox(boundingBox) {
     var _a;
     const radius = 1.1 *
-      bundle_esm.vector3.magnitude(bundle_esm.vector3.subtract(boundingBox.max, bundle_esm.boundingBox.center(boundingBox)));
+      bundle_esm$1.vector3.magnitude(bundle_esm$1.vector3.subtract(boundingBox.max, bundle_esm$1.boundingBox.center(boundingBox)));
     // ratio of the height of the frustum to the distance along the view vector
     let hOverD = Math.tan(((_a = this.fovY) !== null && _a !== void 0 ? _a : 45) * PI_OVER_360);
     if (this.aspect < 1.0) {
@@ -810,14 +831,16 @@ class PerspectiveCamera extends Camera {
     return super.fitCameraToBoundingBox(boundingBox, distance, this.viewVector);
   }
   update(camera) {
-    return new PerspectiveCamera(this.stream, this.aspect, Object.assign(Object.assign({}, this.perspectiveData), camera), this.boundingBox, this.decodeFrame, this.flyToOptions);
+    var _a;
+    const fovY = (_a = camera.fovY) !== null && _a !== void 0 ? _a : this.fovY;
+    return new PerspectiveCamera(this.stream, this.aspect, Object.assign(Object.assign(Object.assign({}, this.perspectiveData), camera), { fovY }), this.boundingBox, this.decodeFrame, this.flyToOptions);
   }
   toFrameCamera() {
     var _a;
     return new streamAttributes.FramePerspectiveCamera(this.position, this.lookAt, this.up, this.near, this.far, this.aspectRatio, (_a = this.fovY) !== null && _a !== void 0 ? _a : 45);
   }
   get viewVector() {
-    return bundle_esm.vector3.subtract(this.lookAt, this.position);
+    return bundle_esm$1.vector3.subtract(this.lookAt, this.position);
   }
   /**
    * The position vector for the camera, in world space coordinates.
@@ -880,21 +903,21 @@ class OrthographicCamera extends Camera {
    */
   moveBy(delta) {
     return this.update({
-      lookAt: bundle_esm.vector3.add(this.lookAt, delta),
+      lookAt: bundle_esm$1.vector3.add(this.lookAt, delta),
     });
   }
   rotateAroundAxisAtPoint(angleInRadians, point, axis) {
-    const updatedLookAt = bundle_esm.vector3.rotateAboutAxis(angleInRadians, this.lookAt, axis, point);
-    const updatedPosition = bundle_esm.vector3.rotateAboutAxis(angleInRadians, this.position, axis, point);
-    const viewVector = streamAttributes.constrainViewVector(bundle_esm.vector3.subtract(updatedLookAt, updatedPosition), bundle_esm.boundingSphere.create(this.boundingBox));
+    const updatedLookAt = bundle_esm$1.vector3.rotateAboutAxis(angleInRadians, this.lookAt, axis, point);
+    const updatedPosition = bundle_esm$1.vector3.rotateAboutAxis(angleInRadians, this.position, axis, point);
+    const viewVector = streamAttributes.constrainViewVector(bundle_esm$1.vector3.subtract(updatedLookAt, updatedPosition), bundle_esm$1.boundingSphere.create(this.boundingBox));
     return this.update({
       viewVector: viewVector,
       lookAt: updatedLookAt,
-      up: bundle_esm.vector3.rotateAboutAxis(angleInRadians, this.up, axis, bundle_esm.vector3.origin()),
+      up: bundle_esm$1.vector3.rotateAboutAxis(angleInRadians, this.up, axis, bundle_esm$1.vector3.origin()),
     });
   }
   fitToBoundingBox(boundingBox) {
-    const boundingSphere = bundle_esm.boundingSphere.create(boundingBox);
+    const boundingSphere = bundle_esm$1.boundingSphere.create(boundingBox);
     const fitAll = super.fitCameraToBoundingBox(boundingBox, boundingSphere.radius, this.viewVector);
     return this.update({
       lookAt: fitAll.lookAt,
@@ -906,13 +929,13 @@ class OrthographicCamera extends Camera {
     return new OrthographicCamera(this.stream, this.aspect, Object.assign(Object.assign({}, this.orthographicData), camera), this.boundingBox, this.decodeFrame, this.flyToOptions);
   }
   toFrameCamera() {
-    return new streamAttributes.FrameOrthographicCamera(streamAttributes.constrainViewVector(this.viewVector, bundle_esm.boundingSphere.create(this.boundingBox)), this.lookAt, this.up, this.near, this.far, this.aspectRatio, this.fovHeight);
+    return new streamAttributes.FrameOrthographicCamera(streamAttributes.constrainViewVector(this.viewVector, bundle_esm$1.boundingSphere.create(this.boundingBox)), this.lookAt, this.up, this.near, this.far, this.aspectRatio, this.fovHeight);
   }
   get viewVector() {
     return Object.assign({}, this.orthographicData.viewVector);
   }
   get position() {
-    return bundle_esm.vector3.add(this.lookAt, bundle_esm.vector3.negate(this.viewVector));
+    return bundle_esm$1.vector3.add(this.lookAt, bundle_esm$1.vector3.negate(this.viewVector));
   }
   /**
    * A normalized vector representing the up direction.
@@ -974,7 +997,7 @@ class Raycaster {
   async hitItems(point, options) {
     const scale = this.imageScaleProvider();
     const res = await this.stream.hitItems({
-      point: bundle_esm.point.scale(point, (scale === null || scale === void 0 ? void 0 : scale.x) || 1, (scale === null || scale === void 0 ? void 0 : scale.y) || 1),
+      point: bundle_esm$1.point.scale(point, (scale === null || scale === void 0 ? void 0 : scale.x) || 1, (scale === null || scale === void 0 ? void 0 : scale.y) || 1),
       includeMetadata: options === null || options === void 0 ? void 0 : options.includeMetadata,
     }, true);
     return res.hitItems || undefined;
@@ -1043,58 +1066,97 @@ class SceneOperationBuilder {
   }
 }
 
+/**
+ * An interface that represents a query is "complete" and can be turned into an
+ * expression.
+ */
+class TerminalQuery {
+  constructor(inverted) {
+    this.inverted = inverted;
+  }
+  build() {
+    if (this.inverted) {
+      return {
+        type: 'not',
+        query: this.queryExpressionBuilder(),
+      };
+    }
+    else {
+      return this.queryExpressionBuilder();
+    }
+  }
+}
 class RootQuery {
+  constructor(inverted = false) {
+    this.inverted = inverted;
+  }
   all() {
     return new AllQuery();
   }
+  not() {
+    return new NotQuery(!this.inverted);
+  }
   withItemIds(ids) {
-    return new BulkQuery(ids, 'item-id');
+    return new BulkQuery(ids, 'item-id', this.inverted);
   }
   withSuppliedIds(ids) {
-    return new BulkQuery(ids, 'supplied-id');
+    return new BulkQuery(ids, 'supplied-id', this.inverted);
   }
   withItemId(id) {
-    return new SingleQuery({ type: 'item-id', value: id });
+    return new SingleQuery({ type: 'item-id', value: id }, this.inverted);
   }
   withSuppliedId(id) {
-    return new SingleQuery({ type: 'supplied-id', value: id });
+    return new SingleQuery({ type: 'supplied-id', value: id }, this.inverted);
   }
   withSceneTreeRange(range) {
-    return new SceneTreeRangeQuery(range);
+    return new SceneTreeRangeQuery(range, this.inverted);
   }
   withMetadata(filter, keys, exactMatch) {
-    return new MetadataQuery(filter, keys, exactMatch);
+    return new MetadataQuery(filter, keys, exactMatch, this.inverted);
   }
   withSelected() {
-    return new AllSelectedQuery();
+    return new AllSelectedQuery(this.inverted);
   }
   withPoint(point) {
-    return new PointQuery(point);
+    return new PointQuery(point, this.inverted);
+  }
+  withVolumeIntersection(rectangle, exclusive) {
+    return new VolumeIntersectionQuery(rectangle, this.inverted, exclusive);
   }
 }
-class AllQuery {
-  build() {
+class NotQuery extends RootQuery {
+  constructor(inverted) {
+    super(inverted);
+  }
+}
+class AllQuery extends TerminalQuery {
+  constructor(inverted = false) {
+    super(inverted);
+  }
+  queryExpressionBuilder() {
     return { type: 'all' };
   }
 }
-class SceneTreeRangeQuery {
-  constructor(range) {
+class SceneTreeRangeQuery extends TerminalQuery {
+  constructor(range, inverted) {
+    super(inverted);
     this.range = range;
   }
-  build() {
+  queryExpressionBuilder() {
     return {
       type: 'scene-tree-range',
       range: this.range,
     };
   }
 }
-class MetadataQuery {
-  constructor(filter, keys, exactMatch) {
+class MetadataQuery extends TerminalQuery {
+  constructor(filter, keys, exactMatch, inverted) {
+    super(inverted);
     this.filter = filter;
     this.keys = keys;
     this.exactMatch = exactMatch;
   }
-  build() {
+  queryExpressionBuilder() {
     return {
       type: 'metadata',
       filter: this.filter,
@@ -1103,30 +1165,49 @@ class MetadataQuery {
     };
   }
 }
-class AllSelectedQuery {
-  build() {
+class AllSelectedQuery extends TerminalQuery {
+  constructor(inverted) {
+    super(inverted);
+  }
+  queryExpressionBuilder() {
     return {
       type: 'all-selected',
     };
   }
 }
-class PointQuery {
-  constructor(point) {
+class PointQuery extends TerminalQuery {
+  constructor(point, inverted) {
+    super(inverted);
     this.point = point;
   }
-  build() {
+  queryExpressionBuilder() {
     return {
       type: 'point',
       point: this.point,
     };
   }
 }
-class BulkQuery {
-  constructor(ids, type) {
+class VolumeIntersectionQuery extends TerminalQuery {
+  constructor(rectangle, inverted, exclusive) {
+    super(inverted);
+    this.rectangle = rectangle;
+    this.exclusive = exclusive;
+  }
+  queryExpressionBuilder() {
+    return {
+      type: 'volume-intersection',
+      rectangle: this.rectangle,
+      exclusive: !!this.exclusive,
+    };
+  }
+}
+class BulkQuery extends TerminalQuery {
+  constructor(ids, type, inverted) {
+    super(inverted);
     this.ids = ids;
     this.type = type;
   }
-  build() {
+  queryExpressionBuilder() {
     return {
       type: 'or',
       expressions: this.ids.map((id) => {
@@ -1138,55 +1219,52 @@ class BulkQuery {
     };
   }
 }
-class SingleQuery {
-  constructor(query) {
+class SingleQuery extends TerminalQuery {
+  constructor(query, inverted) {
+    super(inverted);
     this.query = query;
   }
-  build() {
+  queryExpressionBuilder() {
     return Object.assign({}, this.query);
   }
   and() {
-    return new AndQuery([this.query]);
+    return new AndQuery([this.query], this.inverted);
   }
   or() {
-    return new OrQuery([this.query]);
+    return new OrQuery([this.query], this.inverted);
   }
 }
-class OrQuery {
-  constructor(expressions) {
+class OrQuery extends TerminalQuery {
+  constructor(expressions, inverted) {
+    super(inverted);
     this.expressions = expressions;
   }
-  build() {
+  queryExpressionBuilder() {
     return { type: 'or', expressions: [...this.expressions] };
   }
   withItemId(id) {
-    return new OrQuery([...this.expressions, { type: 'item-id', value: id }]);
+    return new OrQuery([...this.expressions, { type: 'item-id', value: id }], this.inverted);
   }
   withSuppliedId(id) {
-    return new OrQuery([
-      ...this.expressions,
-      { type: 'supplied-id', value: id },
-    ]);
+    return new OrQuery([...this.expressions, { type: 'supplied-id', value: id }], this.inverted);
   }
   or() {
     return this;
   }
 }
-class AndQuery {
-  constructor(expressions) {
+class AndQuery extends TerminalQuery {
+  constructor(expressions, inverted) {
+    super(inverted);
     this.expressions = expressions;
   }
-  build() {
+  queryExpressionBuilder() {
     return { type: 'and', expressions: [...this.expressions] };
   }
   withItemId(id) {
-    return new AndQuery([...this.expressions, { type: 'item-id', value: id }]);
+    return new AndQuery([...this.expressions, { type: 'item-id', value: id }], this.inverted);
   }
   withSuppliedId(id) {
-    return new AndQuery([
-      ...this.expressions,
-      { type: 'supplied-id', value: id },
-    ]);
+    return new AndQuery([...this.expressions, { type: 'supplied-id', value: id }], this.inverted);
   }
   and() {
     return this;
@@ -1245,7 +1323,7 @@ class SceneItemOperationsBuilder {
   transform(matrix) {
     if (Array.isArray(matrix)) {
       if (matrix.length !== 16) {
-        throw new InvalidArgumentError('Matrix provided must contain exactly 16 values (4x4).');
+        throw new errors.InvalidArgumentError('Matrix provided must contain exactly 16 values (4x4).');
       }
       return new SceneItemOperationsBuilder(this.query, this.defaultSelectionMaterial, this.builder.transform({
         r0: {
@@ -1334,12 +1412,20 @@ class Scene {
    * Applies the provided scene view state to the scene.
    */
   async applySceneViewState(sceneViewStateId, opts = {}) {
-    return await this.stream.loadSceneViewState({
-      sceneViewStateId: { hex: sceneViewStateId },
-      frameCorrelationId: opts.suppliedCorrelationId
+    const pbIdField = buildSceneViewStateIdentifier(sceneViewStateId);
+    return await this.stream.loadSceneViewState(Object.assign(Object.assign({}, pbIdField), { frameCorrelationId: opts.suppliedCorrelationId
         ? { value: opts.suppliedCorrelationId }
-        : undefined,
-    }, true);
+        : undefined }), true);
+  }
+  /**
+   * Applies the specified features of the provided scene view state to the scene.
+   */
+  async applyPartialSceneViewState(sceneViewStateId, featuresToApply, opts = {}) {
+    const pbIdField = buildSceneViewStateIdentifier(sceneViewStateId);
+    const pbFeatures = toPbSceneViewStateFeatures(featuresToApply);
+    return await this.stream.loadSceneViewState(Object.assign(Object.assign({}, pbIdField), { frameCorrelationId: opts.suppliedCorrelationId
+        ? { value: opts.suppliedCorrelationId }
+        : undefined, sceneViewStateFeatureSubset: pbFeatures }), true);
   }
   /**
    * Resets the view to its default state, with the ability to reset the camera to that of the base scene.
@@ -1371,7 +1457,7 @@ class Scene {
   camera() {
     const { scene } = this.frame;
     if (scene.camera.isOrthographic()) {
-      return new OrthographicCamera(this.stream, bundle_esm.dimensions.aspectRatio(this.viewport()), {
+      return new OrthographicCamera(this.stream, bundle_esm$1.dimensions.aspectRatio(this.viewport()), {
         viewVector: scene.camera.viewVector,
         lookAt: scene.camera.lookAt,
         up: scene.camera.up,
@@ -1379,7 +1465,7 @@ class Scene {
       }, this.frame.scene.boundingBox, this.decodeFrame);
     }
     else if (scene.camera.isPerspective()) {
-      return new PerspectiveCamera(this.stream, bundle_esm.dimensions.aspectRatio(this.viewport()), {
+      return new PerspectiveCamera(this.stream, bundle_esm$1.dimensions.aspectRatio(this.viewport()), {
         position: scene.camera.position,
         lookAt: scene.camera.lookAt,
         up: scene.camera.up,
@@ -1387,7 +1473,7 @@ class Scene {
       }, this.frame.scene.boundingBox, this.decodeFrame);
     }
     else {
-      throw new InvalidCameraError('Cannot retrieve camera. Scene has an unknown or invalid camera type.');
+      throw new errors.InvalidCameraError('Cannot retrieve camera. Scene has an unknown or invalid camera type.');
     }
   }
   boundingBox() {
@@ -1415,20 +1501,12 @@ class Scene {
    * The current x and y scale of the rendered image.
    */
   scale() {
-    return this.imageScaleProvider() || bundle_esm.point.create(1, 1);
+    return this.imageScaleProvider() || bundle_esm$1.point.create(1, 1);
   }
 }
 
-exports.ComponentInitializationError = ComponentInitializationError;
-exports.CustomError = CustomError;
-exports.IllegalStateError = IllegalStateError;
-exports.ImageLoadError = ImageLoadError;
-exports.InteractionHandlerError = InteractionHandlerError;
 exports.Scene = Scene;
-exports.SceneRenderError = SceneRenderError;
 exports.SynchronizedClock = SynchronizedClock;
-exports.ViewerInitializationError = ViewerInitializationError;
-exports.WebsocketConnectionError = WebsocketConnectionError;
 exports.colorMaterial = colorMaterial;
 exports.defaultSelectionMaterial = defaultSelectionMaterial;
 exports.fromHex = fromHex;