@vertexvis/viewer 0.15.2-testing.4 → 0.15.2

package/dist/esm/{scene-970f5000.js → scene-2543b3bd.js}

@@ -1,10 +1,12 @@
 /**!
- * Copyright (c) 2022 Vertex Software LLC. All rights reserved.
+ * Copyright (c) 2023 Vertex Software LLC. All rights reserved.
  */
-import { c as color, u as uri, a as async, b as uuid } from './browser.esm-ae4ca1f1.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-24bd7b3a.js';
+import { c as color, u as uri, a as async, b as uuid } from './browser.esm-07e7db8f.js';
+import { I as InvalidResourceUrnError, a as InvalidCameraError, b as InvalidArgumentError } from './errors-a4cc9caa.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-92e615bf.js';
+import { v as vertexvis, t as toProtobuf, e as FramePerspectiveCamera, g as constrainViewVector, d as FrameOrthographicCamera, w as withPositionAndViewVector, h as fromBoundingBoxAndLookAtCamera } from './streamAttributes-23270e27.js';
 import './entities-ce81dd7f.js';
+import { t as toProtoDuration } from './bundle.esm-91404853.js';
 
 const defaultColor = {
   opacity: 255,
@@ -96,115 +98,54 @@ 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$1 = uri.parse(urn);
   if (uri$1.scheme !== 'urn' || uri$1.path == null) {
     throw new Error('Invalid URN. Expected URN scheme.');
   }
-  const [nid, resourceType, resourceId] = uri$1.path.split(':');
+  const [nid, resourceType, resourceId, ...subResourcePath] = uri$1.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$1.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$1.query),
+        subResource,
+        queries: queries.filter((q) => q.type !== 'scene-view-state'),
       };
     default:
       throw new 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) {
   if (query != null) {
     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');
       }
     });
   }
@@ -218,6 +159,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.
  *
@@ -368,79 +316,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,
+          },
         },
-        operationTypes,
       };
     case 'volume-intersection':
       return {
-        volume: {
-          frustumByRectangle: {
-            rectangle: query.rectangle,
+        operand: {
+          volume: {
+            frustumByRectangle: {
+              rectangle: query.rectangle,
+            },
+            exclusive: query.exclusive,
+            viewport: context.dimensions,
           },
-          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':
@@ -560,6 +543,33 @@ function buildOperationTypes(operations) {
     }
   });
 }
+function toPbSceneViewStateFeatures(features) {
+  return features.map((feature) => {
+    switch (feature) {
+      case 'camera':
+        return vertexvis.protobuf.stream.SceneViewStateFeature
+          .SCENE_VIEW_STATE_FEATURE_CAMERA;
+      case 'material_overrides':
+        return vertexvis.protobuf.stream.SceneViewStateFeature
+          .SCENE_VIEW_STATE_FEATURE_MATERIAL_OVERRIDE;
+      case 'selection':
+        return vertexvis.protobuf.stream.SceneViewStateFeature
+          .SCENE_VIEW_STATE_FEATURE_SELECTION;
+      case 'visibility':
+        return vertexvis.protobuf.stream.SceneViewStateFeature
+          .SCENE_VIEW_STATE_FEATURE_VISIBILITY;
+      case 'transforms':
+        return vertexvis.protobuf.stream.SceneViewStateFeature
+          .SCENE_VIEW_STATE_FEATURE_TRANSFORM;
+      case 'cross_section':
+        return vertexvis.protobuf.stream.SceneViewStateFeature
+          .SCENE_VIEW_STATE_FEATURE_CROSS_SECTION;
+      default:
+        return vertexvis.protobuf.stream.SceneViewStateFeature
+          .SCENE_VIEW_STATE_FEATURE_INVALID;
+    }
+  });
+}
 
 const PI_OVER_360 = 0.008726646259972;
 class TerminalFlyToExecutor {
@@ -819,7 +829,9 @@ class PerspectiveCamera extends Camera {
     return super.fitCameraToBoundingBox(boundingBox$1, 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;
@@ -1052,61 +1064,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, 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,
@@ -1115,30 +1163,35 @@ 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 VolumeIntersectionQuery {
-  constructor(rectangle, exclusive) {
+class VolumeIntersectionQuery extends TerminalQuery {
+  constructor(rectangle, inverted, exclusive) {
+    super(inverted);
     this.rectangle = rectangle;
     this.exclusive = exclusive;
   }
-  build() {
+  queryExpressionBuilder() {
     return {
       type: 'volume-intersection',
       rectangle: this.rectangle,
@@ -1146,12 +1199,13 @@ class VolumeIntersectionQuery {
     };
   }
 }
-class BulkQuery {
-  constructor(ids, type) {
+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) => {
@@ -1163,55 +1217,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;
@@ -1359,12 +1410,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.
@@ -1444,4 +1503,4 @@ class Scene {
   }
 }
 
-export { CustomError as C, ImageLoadError as I, Scene as S, ViewerInitializationError as V, WebsocketConnectionError as W, SynchronizedClock as a, SceneRenderError as b, colorMaterial as c, defaultSelectionMaterial as d, InteractionHandlerError as e, fromUrn as f, ComponentInitializationError as g, IllegalStateError as h, fromHex as i, loadableResource as l };
+export { Scene as S, SynchronizedClock as a, fromHex as b, colorMaterial as c, defaultSelectionMaterial as d, fromUrn as f, loadableResource as l };

package/dist/esm/shadow-css-51dd7708.js

@@ -1,5 +1,5 @@
 /**!
- * Copyright (c) 2022 Vertex Software LLC. All rights reserved.
+ * Copyright (c) 2023 Vertex Software LLC. All rights reserved.
  */
 /*
  Stencil Client Platform v2.16.1 | MIT Licensed | https://stenciljs.com

package/dist/esm/stencil-bfbf099f.js

@@ -1,5 +1,5 @@
 /**!
- * Copyright (c) 2022 Vertex Software LLC. All rights reserved.
+ * Copyright (c) 2023 Vertex Software LLC. All rights reserved.
  */
 import { a as readTask, e as writeTask } from './index-26dfb2d0.js';