@vertexvis/stream-api 0.24.6-canary.0 → 1.0.0-canary.0

package/dist/bundle.cjs

@@ -0,0 +1,1095 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var frameStreamingProtos = require('@vertexvis/frame-streaming-protos');
+var utils = require('@vertexvis/utils');
+
+function encode(message) {
+    return frameStreamingProtos.vertexvis.protobuf.stream.StreamMessage.encode(message).finish();
+}
+function decode(bufferOrBytes) {
+    const bytes = bufferOrBytes instanceof ArrayBuffer
+        ? new Uint8Array(bufferOrBytes)
+        : bufferOrBytes;
+    const message = frameStreamingProtos.vertexvis.protobuf.stream.StreamMessage.decode(bytes);
+    return frameStreamingProtos.vertexvis.protobuf.stream.StreamMessage.toObject(message, {
+        defaults: true,
+    });
+}
+
+class StreamRequestError extends Error {
+    constructor(requestId, requestPayload, summary, details) {
+        super(summary != null && summary.length > 0
+            ? `Stream request failed (${summary})`
+            : 'Stream request failed');
+        this.requestId = requestId;
+        this.requestPayload = requestPayload;
+        this.summary = summary;
+        this.details = details;
+        // Allows for `instanceof` checks. See https://github.com/Microsoft/TypeScript/wiki/Breaking-Changes#extending-built-ins-like-error-array-and-map-may-no-longer-work
+        Object.setPrototypeOf(this, StreamRequestError.prototype);
+    }
+}
+
+function defineParams(...definitions) {
+    return (settings) => {
+        return definitions.reduce((result, def) => ({ ...result, ...def(settings) }), {});
+    };
+}
+function defineBoolean(param, prop) {
+    return defineValue(param, prop, (v) => {
+        if (typeof v === 'boolean') {
+            return v ? 'on' : 'off';
+        }
+        else {
+            return undefined;
+        }
+    });
+}
+function defineNumber(param, prop) {
+    return defineValue(param, prop, (v) => typeof v === 'number' ? v.toString() : undefined);
+}
+function defineString(param, prop) {
+    return defineValue(param, prop, (v) => typeof v === 'string' ? v : undefined);
+}
+function defineValue(param, prop, f) {
+    return (settings) => {
+        const value = f(settings[prop]);
+        if (value != null) {
+            return { [param]: value };
+        }
+        else {
+            return {};
+        }
+    };
+}
+
+function appendSettingsToUrl(url, settings) {
+    const defaults = {
+    // Settings that you want to set on each WS connection should go here.
+    };
+    const uri = utils.Uri.parse(url);
+    const builder = defineParams(toFrameDeliverySettingsParams(defaults.EXPERIMENTAL_frameDelivery), toAdaptiveRenderingSettingsParams(defaults.EXPERIMENTAL_adaptiveRendering), toQualityOfServiceSettingsParams(defaults.EXPERIMENTAL_qualityOfService));
+    const params = builder(settings);
+    return utils.Uri.toString(utils.Uri.addQueryParams(params, uri));
+}
+function toFrameDeliverySettingsParams(defaults) {
+    return defineSettings((s) => s.EXPERIMENTAL_frameDelivery, defaults, defineParams(defineBoolean('frame-delivery.rate-limit-enabled', 'rateLimitingEnabled'), defineNumber('frame-delivery.packet-loss-threshold', 'packetLossThreshold'), defineNumber('frame-delivery.history-max-size', 'historyMaxSize'), defineString('frame-delivery.timeout', 'timeout'), defineNumber('frame-delivery.timeout-ratio-threshold', 'timeoutRatioThreshold')));
+}
+function toAdaptiveRenderingSettingsParams(defaults) {
+    return defineSettings((s) => s.EXPERIMENTAL_adaptiveRendering, defaults, defineParams(defineBoolean('adaptive-rendering.enabled', 'enabled'), defineString('adaptive-rendering.method', 'method'), defineNumber('adaptive-rendering.jpeg-quality-min', 'jpegMinQuality'), defineNumber('adaptive-rendering.jpeg-quality-max', 'jpegMaxQuality'), defineNumber('adaptive-rendering.image-scale-min', 'imageMinScale'), defineNumber('adaptive-rendering.image-scale-max', 'imageMaxScale'), defineNumber('adaptive-rendering.window-size', 'windowSize')));
+}
+function toQualityOfServiceSettingsParams(defaults) {
+    return defineSettings((s) => s.EXPERIMENTAL_qualityOfService, defaults, defineParams(defineNumber('qos.history-max-size', 'historyMaxSize')));
+}
+function defineSettings(getter, defaults, builder) {
+    return (settings) => {
+        const merged = utils.Objects.defaults(getter(settings) || {}, defaults);
+        return builder(merged);
+    };
+}
+
+/**
+ * Converts a JS date type to a `google.protobuf.Timestamp`. The returned time
+ * will be represented as UTC.
+ *
+ * @param date The date to convert.
+ */
+function toProtoTimestamp(date) {
+    const millis = date.getTime();
+    return frameStreamingProtos.google.protobuf.Timestamp.create(parseEpochMillis(millis));
+}
+/**
+ * Returns the current date and time as a `google.protobuf.Timestamp`.
+ */
+function currentDateAsProtoTimestamp() {
+    return toProtoTimestamp(new Date());
+}
+function toProtoDuration(...args) {
+    if (args.length === 2) {
+        const start = args[0];
+        const end = args[1];
+        const millis = end.getTime() - start.getTime();
+        return frameStreamingProtos.google.protobuf.Duration.create(parseEpochMillis(millis));
+    }
+    else if (args.length === 1) {
+        const millis = args[0];
+        return frameStreamingProtos.google.protobuf.Duration.create(parseEpochMillis(millis));
+    }
+    else {
+        throw new Error('Expected input to be a number or start and end date.');
+    }
+}
+function protoToDate(time) {
+    if (time.seconds != null && time.nanos != null) {
+        const seconds = typeof time.seconds === 'number' ? time.seconds : time.seconds.toNumber();
+        return new Date(seconds * 1000 + time.nanos / 1000000);
+    }
+}
+/* eslint-enable padding-line-between-statements */
+function parseEpochMillis(millis) {
+    const seconds = Math.floor(Math.abs(millis) / 1000);
+    const nanos = (millis % 1000) * 1000000;
+    return { seconds: seconds * (millis < 0 ? -1 : 1), nanos };
+}
+
+function validateBoundingBox(boundingBox) {
+    const boundingBoxXMaxValid = (boundingBox === null || boundingBox === void 0 ? void 0 : boundingBox.xmax) != null && Number.isFinite(boundingBox.xmax);
+    const boundingBoxXMinValid = (boundingBox === null || boundingBox === void 0 ? void 0 : boundingBox.xmin) != null && Number.isFinite(boundingBox.xmin);
+    const boundingBoxYMaxValid = (boundingBox === null || boundingBox === void 0 ? void 0 : boundingBox.ymax) != null && Number.isFinite(boundingBox.ymax);
+    const boundingBoxYMinValid = (boundingBox === null || boundingBox === void 0 ? void 0 : boundingBox.ymin) != null && Number.isFinite(boundingBox.ymin);
+    const boundingBoxZMaxValid = (boundingBox === null || boundingBox === void 0 ? void 0 : boundingBox.zmax) != null && Number.isFinite(boundingBox.zmax);
+    const boundingBoxZMinValid = (boundingBox === null || boundingBox === void 0 ? void 0 : boundingBox.zmin) != null && Number.isFinite(boundingBox.zmin);
+    return (boundingBoxXMaxValid &&
+        boundingBoxXMinValid &&
+        boundingBoxYMaxValid &&
+        boundingBoxYMinValid &&
+        boundingBoxZMaxValid &&
+        boundingBoxZMinValid);
+}
+function validateCamera(camera) {
+    // If a perspective camera is provided, verify it is valid
+    if (camera.perspective != null) {
+        const perspectiveCameraIsValid = validatePerspectiveCamera(camera.perspective);
+        return perspectiveCameraIsValid;
+    }
+    // If an orthographic camera is provided, verify it is valid
+    if (camera.orthographic != null) {
+        const orthographicCameraIsValid = validateOrthographicCamera(camera.orthographic);
+        return orthographicCameraIsValid;
+    }
+    return false;
+}
+function validatePerspectiveCamera(camera) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+    const lookAtXValid = ((_a = camera.lookAt) === null || _a === void 0 ? void 0 : _a.x) != null && Number.isFinite(camera.lookAt.x);
+    const lookAtYValid = ((_b = camera.lookAt) === null || _b === void 0 ? void 0 : _b.y) != null && Number.isFinite(camera.lookAt.y);
+    const lookAtZValid = ((_c = camera.lookAt) === null || _c === void 0 ? void 0 : _c.z) != null && Number.isFinite(camera.lookAt.z);
+    const positionXValid = ((_d = camera.position) === null || _d === void 0 ? void 0 : _d.x) != null && Number.isFinite(camera.position.x);
+    const positionYValid = ((_e = camera.position) === null || _e === void 0 ? void 0 : _e.y) != null && Number.isFinite(camera.position.y);
+    const positionZValid = ((_f = camera.position) === null || _f === void 0 ? void 0 : _f.z) != null && Number.isFinite(camera.position.z);
+    const upXValid = ((_g = camera.up) === null || _g === void 0 ? void 0 : _g.x) != null && Number.isFinite(camera.up.x);
+    const upYValid = ((_h = camera.up) === null || _h === void 0 ? void 0 : _h.y) != null && Number.isFinite(camera.up.y);
+    const upZValid = ((_j = camera.up) === null || _j === void 0 ? void 0 : _j.z) != null && Number.isFinite(camera.up.z);
+    // Validate up vector has non-zero length
+    const upVectorValid = validateVector({ x: (_k = camera === null || camera === void 0 ? void 0 : camera.up) === null || _k === void 0 ? void 0 : _k.x, y: (_l = camera === null || camera === void 0 ? void 0 : camera.up) === null || _l === void 0 ? void 0 : _l.y, z: (_m = camera === null || camera === void 0 ? void 0 : camera.up) === null || _m === void 0 ? void 0 : _m.z }, true);
+    return (lookAtXValid &&
+        lookAtYValid &&
+        lookAtZValid &&
+        positionXValid &&
+        positionYValid &&
+        positionZValid &&
+        upXValid &&
+        upYValid &&
+        upZValid &&
+        upVectorValid);
+}
+function validateOrthographicCamera(camera) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+    const fovHeightValid = camera.fovHeight != null && Number.isFinite(camera.fovHeight);
+    const lookAtXValid = ((_a = camera.lookAt) === null || _a === void 0 ? void 0 : _a.x) != null && Number.isFinite(camera.lookAt.x);
+    const lookAtYValid = ((_b = camera.lookAt) === null || _b === void 0 ? void 0 : _b.y) != null && Number.isFinite(camera.lookAt.y);
+    const lookAtZValid = ((_c = camera.lookAt) === null || _c === void 0 ? void 0 : _c.z) != null && Number.isFinite(camera.lookAt.z);
+    const upXValid = ((_d = camera.up) === null || _d === void 0 ? void 0 : _d.x) != null && Number.isFinite(camera.up.x);
+    const upYValid = ((_e = camera.up) === null || _e === void 0 ? void 0 : _e.y) != null && Number.isFinite(camera.up.y);
+    const upZValid = ((_f = camera.up) === null || _f === void 0 ? void 0 : _f.z) != null && Number.isFinite(camera.up.z);
+    const viewVectorXValid = ((_g = camera.viewVector) === null || _g === void 0 ? void 0 : _g.x) != null && Number.isFinite(camera.viewVector.x);
+    const viewVectorYValid = ((_h = camera.viewVector) === null || _h === void 0 ? void 0 : _h.y) != null && Number.isFinite(camera.viewVector.y);
+    const viewVectorZValid = ((_j = camera.viewVector) === null || _j === void 0 ? void 0 : _j.z) != null && Number.isFinite(camera.viewVector.z);
+    // Validate up vector has non-zero length
+    const upVectorValid = validateVector({ x: (_k = camera === null || camera === void 0 ? void 0 : camera.up) === null || _k === void 0 ? void 0 : _k.x, y: (_l = camera === null || camera === void 0 ? void 0 : camera.up) === null || _l === void 0 ? void 0 : _l.y, z: (_m = camera === null || camera === void 0 ? void 0 : camera.up) === null || _m === void 0 ? void 0 : _m.z }, true);
+    return (fovHeightValid &&
+        lookAtXValid &&
+        lookAtYValid &&
+        lookAtZValid &&
+        viewVectorXValid &&
+        viewVectorYValid &&
+        viewVectorZValid &&
+        upXValid &&
+        upYValid &&
+        upZValid &&
+        upVectorValid);
+}
+function validateDimensions(dimensions) {
+    const heightValid = (dimensions === null || dimensions === void 0 ? void 0 : dimensions.height) != null &&
+        Number.isFinite(dimensions.height) &&
+        dimensions.height > 0;
+    const widthValid = (dimensions === null || dimensions === void 0 ? void 0 : dimensions.width) != null &&
+        Number.isFinite(dimensions.width) &&
+        dimensions.width > 0;
+    return heightValid && widthValid;
+}
+function validateNumber(number) {
+    return number != null && Number.isFinite(number);
+}
+function validatePoint(point) {
+    const xValid = (point === null || point === void 0 ? void 0 : point.x) != null && Number.isFinite(point.x);
+    const yValid = (point === null || point === void 0 ? void 0 : point.y) != null && Number.isFinite(point.y);
+    return xValid && yValid;
+}
+function validateVector(vector, verifyNonZeroLength) {
+    const xValid = (vector === null || vector === void 0 ? void 0 : vector.x) != null && Number.isFinite(vector.x);
+    const yValid = (vector === null || vector === void 0 ? void 0 : vector.y) != null && Number.isFinite(vector.y);
+    const zValid = (vector === null || vector === void 0 ? void 0 : vector.z) != null && Number.isFinite(vector.z);
+    const vectorComponentsValid = xValid && yValid && zValid;
+    if (verifyNonZeroLength) {
+        if ((vector === null || vector === void 0 ? void 0 : vector.x) != null && (vector === null || vector === void 0 ? void 0 : vector.y) != null && (vector === null || vector === void 0 ? void 0 : vector.z) != null) {
+            const vectorMagnitudeSquared = vector.x * vector.x + vector.y * vector.y + vector.z * vector.z;
+            const vectorHasNonZeroLength = vectorMagnitudeSquared !== 0;
+            return vectorComponentsValid && vectorHasNonZeroLength;
+        }
+        else {
+            // If one or more components are undefined, then the vector does not have non-zero length
+            return false;
+        }
+    }
+    return vectorComponentsValid;
+}
+
+class WebSocketClientImpl {
+    constructor() {
+        this.listeners = {};
+        this.onMessageDispatcher = new utils.EventDispatcher();
+        this.onCloseDispatcher = new utils.EventDispatcher();
+        this.addWebSocketListeners = (ws, wsId, resolve, reject) => {
+            const onOpen = () => this.onOpen(resolve);
+            const onError = () => reject();
+            const onClose = (event) => this.handleClose(event, wsId);
+            ws.addEventListener('message', this.handleMessage);
+            ws.addEventListener('open', onOpen);
+            ws.addEventListener('error', onError);
+            ws.addEventListener('close', onClose);
+            return {
+                dispose: () => {
+                    ws.removeEventListener('message', this.handleMessage);
+                    ws.removeEventListener('open', onOpen);
+                    ws.removeEventListener('error', onError);
+                    ws.removeEventListener('close', onClose);
+                },
+            };
+        };
+        this.handleMessage = (event) => {
+            this.onMessageDispatcher.emit(event);
+        };
+        this.handleClose = (event, webSocketId) => {
+            this.onCloseDispatcher.emit(event);
+            this.removeWebSocketListeners(webSocketId);
+        };
+    }
+    close() {
+        if (this.webSocket != null) {
+            this.webSocket.close();
+        }
+    }
+    async connect(descriptor) {
+        const id = utils.UUID.create();
+        // Ensure that any existing websocket connection has been closed prior
+        // to opening a new one to ensure we don't leave open connections.
+        if (this.webSocket != null) {
+            this.close();
+        }
+        this.webSocket = new WebSocket(descriptor.url, descriptor.protocols);
+        this.webSocket.binaryType = 'arraybuffer';
+        return new Promise((resolve, reject) => {
+            if (this.webSocket != null) {
+                this.listeners[id] = this.addWebSocketListeners(this.webSocket, id, resolve, reject);
+            }
+        });
+    }
+    onMessage(handler) {
+        return this.onMessageDispatcher.on(handler);
+    }
+    onClose(handler) {
+        return this.onCloseDispatcher.on(handler);
+    }
+    send(data) {
+        if (this.webSocket != null) {
+            this.webSocket.send(data);
+        }
+    }
+    removeWebSocketListeners(webSocketId) {
+        var _a;
+        (_a = this.listeners[webSocketId]) === null || _a === void 0 ? void 0 : _a.dispose();
+    }
+    onOpen(resolve) {
+        resolve();
+    }
+}
+
+/**
+ * The API client to interact with Vertex's streaming API.
+ */
+class StreamApi {
+    constructor(websocket = new WebSocketClientImpl(), opts = {}) {
+        var _a;
+        this.websocket = websocket;
+        this.onResponseDispatcher = new utils.EventDispatcher();
+        this.onRequestDispatcher = new utils.EventDispatcher();
+        this.onEventDispatcher = new utils.EventDispatcher();
+        this.opts = {
+            loggingEnabled: (_a = opts.loggingEnabled) !== null && _a !== void 0 ? _a : false,
+        };
+    }
+    /**
+     * Initiates a websocket connection to Vertex's streaming API. Returns a
+     * promise that resolves once the connection is established and can begin
+     * accepting messages.
+     *
+     * @param descriptor A function that returns a description of how to establish
+     * a WS connection.
+     * @param settings A configuration to use when initializing the WS connection.
+     */
+    async connect(descriptor, settings = {}) {
+        const desc = {
+            ...descriptor,
+            url: appendSettingsToUrl(descriptor.url, settings),
+        };
+        await this.websocket.connect(desc);
+        this.messageSubscription = this.websocket.onMessage((message) => {
+            this.handleMessage(message);
+        });
+        return { dispose: () => this.dispose() };
+    }
+    /**
+     * Closes any open WS connections and disposes of resources.
+     */
+    dispose() {
+        var _a;
+        this.websocket.close();
+        (_a = this.messageSubscription) === null || _a === void 0 ? void 0 : _a.dispose();
+    }
+    /**
+     * Adds a callback that is invoked when the client receives a request from the
+     * server. Returns a `Disposable` that can be used to remove the listener.
+     *
+     * @param handler A handler function.
+     */
+    onRequest(handler) {
+        return this.onRequestDispatcher.on(handler);
+    }
+    /**
+     * Adds a callback that is invoked when the client receives an event from the
+     * server. Returns a `Disposable` that can be used to remove the listener.
+     *
+     * @param handler - A handler function.
+     */
+    onEvent(handler) {
+        return this.onEventDispatcher.on(handler);
+    }
+    /**
+     * Adds a callback that is invoked when the websocket connection is closed.
+     *
+     * @param handler A handler function.
+     */
+    onClose(handler) {
+        return this.websocket.onClose(handler);
+    }
+    /**
+     * Sends a request to initiate a streaming session.
+     *
+     * The payload accepts an optional `frameCorrelationId` that will be sent
+     * back on the frame that is associated to this request. Use `onRequest` to
+     * add a callback that'll be invoked when the server sends a request to draw
+     * the frame.
+     *
+     * Use `withResponse` to indicate if the server should reply with a response.
+     * If `false`, the returned promise will complete immediately. Otherwise,
+     * it'll complete when a response is received.
+     *
+     * @param payload The payload of the request.
+     * @param withResponse Indicates if the server should reply with a response.
+     * Defaults to `true`.
+     */
+    startStream(payload, withResponse = true) {
+        return this.sendRequest({ startStream: payload }, withResponse);
+    }
+    /**
+     * Sends a request to reconnect to an existing streaming session.
+     *
+     * The payload accepts an optional `frameCorrelationId` that will be sent
+     * back on the frame that is associated to this request. Use `onRequest` to
+     * add a callback that'll be invoked when the server sends a request to draw
+     * the frame.
+     *
+     * Use `withResponse` to indicate if the server should reply with a response.
+     * If `false`, the returned promise will complete immediately. Otherwise,
+     * it'll complete when a response is received.
+     *
+     * @param payload The payload of the request.
+     * @param withResponse Indicates if the server should reply with a response.
+     * Defaults to `true`.
+     */
+    async reconnect(payload, withResponse = true) {
+        return this.sendRequest({ reconnect: payload }, withResponse);
+    }
+    async updateStream(payload, withResponse = false) {
+        return this.sendRequest({ updateStream: payload }, withResponse);
+    }
+    /**
+     * Sends a request to signal to the rendering pipeline that an interaction has
+     * started. The rendering pipeline will use this as a hint to perform more
+     * aggressive rendering optimizations at the expense of rendering quality.
+     * Call `endInteraction` to signal to the rendering pipeline that an
+     * interaction has finished.
+     *
+     * Use `withResponse` to indicate if the server should reply with a response.
+     * If `false`, the returned promise will complete immediately. Otherwise,
+     * it'll complete when a response is received.
+     *
+     * @param data The payload of the request.
+     * @param withResponse Indicates if the server should reply with a response.
+     * Defaults to `true`.
+     */
+    beginInteraction(payload = {}, withResponse = true) {
+        return this.sendRequest({ beginInteraction: payload }, withResponse);
+    }
+    /**
+     * Sends a request to update the position of the scene's camera.
+     *
+     * The payload accepts an optional `frameCorrelationId` that will be sent
+     * back on the frame that is associated to this request. Use `onRequest` to
+     * add a callback that'll be invoked when the server sends a request to draw
+     * the frame.
+     *
+     * Use `withResponse` to indicate if the server should reply with a response.
+     * If `false`, the returned promise will complete immediately. Otherwise,
+     * it'll complete when a response is received.
+     *
+     * @param payload The payload of the request.
+     * @param withResponse Indicates if the server should reply with a response.
+     * Defaults to `true`.
+     */
+    replaceCamera(payload, withResponse = true) {
+        // If a camera is provided, verify it is valid
+        if (payload.camera != null) {
+            const cameraIsValid = validateCamera(payload.camera);
+            if (!cameraIsValid) {
+                console.warn('Invalid camera provided. Canceling replaceCamera operation.');
+                return Promise.resolve({});
+            }
+        }
+        return this.sendRequest({ updateCamera: payload }, withResponse);
+    }
+    /**
+     * Sends a request to update the position of the scene's camera as a fly operation
+     *
+     * The payload accepts an optional `frameCorrelationId` that will be sent
+     * back on the frame that is associated to this request. Use `onRequest` to
+     * add a callback that'll be invoked when the server sends a request to draw
+     * the frame.
+     *
+     * Use `withResponse` to indicate if the server should reply with a response.
+     * If `false`, the returned promise will complete immediately. Otherwise,
+     * it'll complete when a response is received.
+     *
+     * @param payload
+     * @param withResponse
+     */
+    flyTo(payload, withResponse = true) {
+        // If a bounding box is provided, verify it is valid
+        if (payload.boundingBox != null) {
+            const validBoundingBox = validateBoundingBox(payload.boundingBox);
+            if (!validBoundingBox) {
+                console.warn('Invalid bounding box provided. Canceling flyTo operation.');
+                return Promise.resolve({});
+            }
+        }
+        // If a camera is provided, verify it is valid
+        if (payload.camera != null) {
+            const cameraIsValid = validateCamera(payload.camera);
+            if (!cameraIsValid) {
+                console.warn('Invalid camera provided. Canceling flyTo operation.');
+                return Promise.resolve({});
+            }
+        }
+        // If a base camera is provided, verify it is valid
+        if (payload.baseCamera != null) {
+            const baseCameraIsValid = validateCamera(payload.baseCamera);
+            if (!baseCameraIsValid) {
+                console.warn('Invalid base camera provided. Canceling flyTo operation.');
+                return Promise.resolve({});
+            }
+        }
+        return this.sendRequest({ flyTo: payload }, withResponse);
+    }
+    /**
+     * Sends a request to update the specified interaction.
+     *
+     * Use `withResponse` to indicate if the server should reply with a response.
+     * If `false`, the returned promise will complete immediately. Otherwise,
+     * it'll complete when a response is received.
+     *
+     * @param payload The payload of the request.
+     * @param withResponse Indicates if the server should reply with a response.
+     * Defaults to `true`.
+     */
+    updateInteraction(payload, withResponse = true) {
+        return this.sendRequest({ updateInteraction: payload }, withResponse);
+    }
+    /**
+     * Sends a request to update the dimensions of the frame.
+     *
+     * The payload accepts an optional `frameCorrelationId` that will be sent
+     * back on the frame that is associated to this request. Use `onRequest` to
+     * add a callback that'll be invoked when the server sends a request to draw
+     * the frame.
+     *
+     * Use `withResponse` to indicate if the server should reply with a response.
+     * If `false`, the returned promise will complete immediately. Otherwise,
+     * it'll complete when a response is received.
+     *
+     * @param payload The payload of the request.
+     * @param withResponse Indicates if the server should reply with a response.
+     * Defaults to `true`.
+     */
+    updateDimensions(payload, withResponse = true) {
+        // Verify the provided dimensions are valid
+        if (payload.dimensions != null) {
+            const validDimensions = validateDimensions(payload.dimensions);
+            if (!validDimensions) {
+                console.warn('Invalid dimensions provided. Canceling updateDimensions operation.');
+                return Promise.resolve({});
+            }
+        }
+        return this.sendRequest({ updateDimensions: payload }, withResponse);
+    }
+    /**
+     * Sends a request to update the cross sectioning planes of the frame.
+     *
+     * The payload accepts an optional `frameCorrelationId` that will be sent
+     * back on the frame that is associated to this request. Use `onRequest` to
+     * add a callback that'll be invoked when the server sends a request to draw
+     * the frame.
+     *
+     * Use `withResponse` to indicate if the server should reply with a response.
+     * If `false`, the returned promise will complete immediately. Otherwise,
+     * it'll complete when a response is received.
+     *
+     * @param payload The payload of the request.
+     * @param withResponse Indicates if the server should reply with a response.
+     * Defaults to `true`.
+     */
+    updateCrossSectioning(payload, withResponse = true) {
+        var _a, _b;
+        // If a section plane is provided, verify it is valid
+        const invalidSectionPlane = (_b = (_a = payload.crossSectioning) === null || _a === void 0 ? void 0 : _a.sectionPlanes) === null || _b === void 0 ? void 0 : _b.some((plane) => {
+            const validNormal = plane.normal != null && validateVector(plane.normal, true);
+            const validOffset = plane.offset != null && validateNumber(plane.offset);
+            return !validNormal || !validOffset;
+        });
+        if (invalidSectionPlane) {
+            console.warn('Invalid cross section plane provided. Canceling updateCrossSectioning operation.');
+            return Promise.resolve({});
+        }
+        return this.sendRequest({ updateCrossSectioning: payload }, withResponse);
+    }
+    /**
+     * Sends a request to set or clear the model view of the frame.
+     *
+     * The payload accepts an optional `frameCorrelationId` that will be sent
+     * back on the frame that is associated to this request. Use `onRequest` to
+     * add a callback that'll be invoked when the server sends a request to draw
+     * the frame.
+     *
+     * Use `withResponse` to indicate if the server should reply with a response.
+     * If `false`, the returned promise will complete immediately. Otherwise,
+     * it'll complete when a response is received.
+     *
+     * @param payload The payload of the request.
+     * @param withResponse Indicates if the server should reply with a response.
+     * Defaults to `true`.
+     */
+    updateModelView(payload, withResponse = true) {
+        return this.sendRequest({ updateModelView: payload }, withResponse);
+    }
+    /**
+     * Sends a request to perform hit detection.
+     *
+     * Use `withResponse` to indicate if the server should reply with a response.
+     * If `false`, the returned promise will complete immediately. Otherwise,
+     * it'll complete when a response is received.
+     *
+     * @param payload The payload of the request.
+     * @param withResponse Indicates if the server should reply with a response.
+     * Defaults to `true`.
+     */
+    hitItems(payload, withResponse = true) {
+        // If a point is provided, verify it is valid
+        if (payload.point != null) {
+            const validPoint = validatePoint(payload.point);
+            if (!validPoint) {
+                console.warn('Invalid point provided. Canceling hitItems operation.');
+                return Promise.resolve({});
+            }
+        }
+        return this.sendRequest({ hitItems: payload }, withResponse);
+    }
+    /**
+     * Sends a request to perform an alteration to a scene. Alterations include
+     * changing item visibility and changing the materials of items.
+     *
+     * Use `withResponse` to indicate if the server should reply with a response.
+     * If `false`, the returned promise will complete immediately. Otherwise,
+     * it'll complete when a response is received.
+     *
+     * @param payload The payload of the request.
+     * @param withResponse Indicates if the server should reply with a response.
+     * Defaults to `true`.
+     */
+    createSceneAlteration(payload, withResponse = true) {
+        return this.sendRequest({ createSceneAlteration: payload }, withResponse);
+    }
+    /**
+     * Sends a request to reset all overrides for a given scene and optionally to
+     * reset the camera to that of the base scene.
+     *
+     * Use `withResponse` to indicate if the server should reply with a response.
+     * If `false`, the returned promise will complete immediately. Otherwise,
+     * it'll complete when a response is received.
+     *
+     * @param payload The payload of the request.
+     * @param withResponse Indicates if the server should reply with a response.
+     * Defaults to `true`.
+     */
+    resetSceneView(payload, withResponse = true) {
+        return this.sendRequest({ resetView: payload }, withResponse);
+    }
+    /**
+     * Sends a request to tell the rendering pipeline that an interaction has
+     * ended.
+     *
+     * Use `withResponse` to indicate if the server should reply with a response.
+     * If `false`, the returned promise will complete immediately. Otherwise,
+     * it'll complete when a response is received.
+     *
+     * @param withResponse Indicates if the server should reply with a response.
+     * Defaults to `true`.
+     */
+    endInteraction(payload = {}, withResponse = true) {
+        return this.sendRequest({ endInteraction: payload }, withResponse);
+    }
+    /**
+     * Sends a request to sync the clocks between the client and server.
+     *
+     * Use `withResponse` to indicate if the server should reply with a response.
+     * If `false`, the returned promise will complete immediately. Otherwise,
+     * it'll complete when a response is received.
+     *
+     * @param payload The request payload.
+     * @param withResponse Indicates if the server should reply with a response.
+     * Defaults to `true`.
+     */
+    syncTime(payload, withResponse = true) {
+        return this.sendRequest({ syncTime: payload }, withResponse);
+    }
+    /**
+     * Sends a request to record performance timings that were measured in the
+     * client. The server may use these timings as hints to optimize the rendering
+     * performance to provide a better experience.
+     *
+     * Use `withResponse` to indicate if the server should reply with a response.
+     * If `false`, the returned promise will complete immediately. Otherwise,
+     * it'll complete when a response is received.
+     *
+     * @param payload The request payload
+     * @param withResponse Indicates if the server should reply with a response.
+     * Defaults to `true`.
+     */
+    recordPerformance(payload, withResponse = true) {
+        return this.sendRequest({ recordPerformance: payload }, withResponse);
+    }
+    /**
+     * Sends a request to update the current scene view with the state present
+     * in the specified scene view state.
+     *
+     * Use `withResponse` to indicate if the server should reply with a response.
+     * If `false`, the returned promise will complete immediately. Otherwise,
+     * it'll complete when a response is received.
+     *
+     * @param payload
+     * @param withResponse
+     */
+    loadSceneViewState(payload, withResponse = true) {
+        return this.sendRequest({ loadSceneViewState: payload }, withResponse);
+    }
+    /**
+     * Sends a request to get a stencil buffer image for the current scene view.
+     */
+    getStencilBuffer(payload, withResponse = true) {
+        return this.sendRequest({ getStencilBuffer: payload }, withResponse);
+    }
+    /**
+     * Sends a request to retrieve a new token. This token can be used to
+     * authenticate with other Vertex services.
+     *
+     * @param withResponse Indicates if the server should reply with a response.
+     * @returns A promise that completes with the refreshed token.
+     */
+    refreshToken(withResponse = true) {
+        return this.sendRequest({ refreshToken: {} }, withResponse);
+    }
+    /**
+     * Acknowledges a successful request by sending a reply back to the server
+     * with an optional result body.
+     *
+     * @param reqId The ID of the received request.
+     * @param result A result to reply with.
+     */
+    replyResult(reqId, result) {
+        this.sendResponse({ requestId: { value: reqId }, ...result });
+    }
+    /**
+     * Acknowledges a failed request by sending a reply back to the server.
+     *
+     * @param reqId The ID of the received request.
+     * @param error An error to reply with.
+     */
+    replyError(reqId, error) {
+        this.sendResponse({ requestId: { value: reqId }, error });
+    }
+    handleMessage(message) {
+        const msg = decode(message.data);
+        this.log('WS message received', msg);
+        if ((msg === null || msg === void 0 ? void 0 : msg.sentAtTime) != null) {
+            if (msg.response != null) {
+                this.onResponseDispatcher.emit({
+                    sentAtTime: msg.sentAtTime,
+                    response: msg.response,
+                });
+            }
+            if (msg.request != null) {
+                this.onRequestDispatcher.emit({
+                    sentAtTime: msg.sentAtTime,
+                    request: msg.request,
+                });
+            }
+            if (msg.event != null) {
+                this.onEventDispatcher.emit({
+                    sentAtTime: msg.sentAtTime,
+                    event: msg.event,
+                });
+            }
+        }
+    }
+    onResponse(handler) {
+        return this.onResponseDispatcher.on(handler);
+    }
+    log(msg, ...other) {
+        if (this.opts.loggingEnabled) {
+            console.debug(msg, ...other);
+        }
+    }
+    sendRequest(req, withResponse) {
+        const sentAtTime = currentDateAsProtoTimestamp();
+        if (withResponse) {
+            const requestId = utils.UUID.create();
+            const request = { ...req, requestId: { value: requestId } };
+            return new Promise((resolve, reject) => {
+                const subscription = this.onResponse((msg) => {
+                    var _a;
+                    if (requestId === ((_a = msg.response.requestId) === null || _a === void 0 ? void 0 : _a.value)) {
+                        if (msg.response.error == null) {
+                            resolve(msg.response);
+                        }
+                        else {
+                            const { message: summary, details } = msg.response.error;
+                            reject(new StreamRequestError(requestId, req, summary === null || summary === void 0 ? void 0 : summary.value, details === null || details === void 0 ? void 0 : details.value));
+                        }
+                        subscription.dispose();
+                    }
+                });
+                this.sendMessage({ sentAtTime, request });
+            });
+        }
+        this.sendMessage({ sentAtTime, request: req });
+        return Promise.resolve({});
+    }
+    sendMessage(msg) {
+        this.websocket.send(encode(msg));
+        this.log('WS message sent', msg);
+    }
+    sendResponse(response) {
+        const sentAtTime = currentDateAsProtoTimestamp();
+        this.websocket.send(encode({ sentAtTime, response }));
+    }
+}
+
+function event(req, meta) {
+    return {
+        sentAtTime: currentDateAsProtoTimestamp(),
+        event: {
+            ...req,
+        },
+        ...meta,
+    };
+}
+function animationCompleted(id) {
+    const def = {
+        animationId: { hex: id },
+    };
+    return event({
+        animationCompleted: {
+            ...def,
+        },
+    });
+}
+
+var events = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  animationCompleted: animationCompleted
+});
+
+function request(req, meta) {
+    return {
+        sentAtTime: currentDateAsProtoTimestamp(),
+        ...meta,
+        request: {
+            requestId: req.requestId != null ? { value: req.requestId } : undefined,
+            ...req.payload,
+        },
+    };
+}
+function drawFrame(req = {}, meta) {
+    const def = {
+        sequenceNumber: 1,
+        sceneAttributes: {
+            camera: {
+                position: { x: 0, y: 0, z: 1 },
+                lookAt: { x: 0, y: 0, z: 0 },
+                up: { x: 0, y: 1, z: 0 },
+            },
+            visibleBoundingBox: {
+                xmin: -1,
+                ymin: -1,
+                zmin: -1,
+                xmax: 1,
+                ymax: 1,
+                zmax: 1,
+            },
+            crossSectioning: {
+                sectionPlanes: [],
+            },
+            displayListSummary: {
+                visibleSummary: {
+                    count: 100,
+                },
+                selectedVisibleSummary: {
+                    count: 0,
+                },
+            },
+        },
+        imageAttributes: {
+            frameDimensions: { width: 200, height: 150 },
+            imageRect: { x: 0, y: 0, width: 200, height: 150 },
+            scaleFactor: 1,
+        },
+        frameCorrelationIds: ['123'],
+        image: new Uint8Array(),
+    };
+    return request({
+        requestId: req.requestId,
+        payload: { drawFrame: utils.Objects.defaults(req.payload, def) },
+    }, meta);
+}
+function gracefulReconnect(req = {}, meta) {
+    const def = {
+        streamId: { hex: utils.UUID.create() },
+        timeToReconnectDuration: { seconds: 1, nanos: 0 },
+    };
+    return request({
+        requestId: req.requestId,
+        payload: { gracefulReconnection: utils.Objects.defaults(req.payload, def) },
+    }, meta);
+}
+
+var requests = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  drawFrame: drawFrame,
+  gracefulReconnect: gracefulReconnect
+});
+
+function response(res, meta) {
+    return {
+        sentAtTime: currentDateAsProtoTimestamp(),
+        ...meta,
+        response: {
+            requestId: res.requestId != null ? { value: res.requestId } : undefined,
+            ...res.result,
+        },
+    };
+}
+function startStream(res = {}, meta) {
+    const def = {
+        streamId: { hex: utils.UUID.create() },
+        sceneId: { hex: utils.UUID.create() },
+        sceneViewId: { hex: utils.UUID.create() },
+        sessionId: { hex: utils.UUID.create() },
+        jwt: 'jwt',
+        token: { token: 'token', expiresIn: new Date().getTime() + 10000 },
+        worldOrientation: {
+            front: { x: 0, y: 0, z: 1 },
+            up: { x: 0, y: 1, z: 0 },
+        },
+    };
+    return response({
+        requestId: res.requestId,
+        result: { startStream: utils.Objects.defaults(res.result, def) },
+    }, meta);
+}
+function syncTime(res = {}, meta) {
+    const def = { replyTime: { seconds: 1, nanos: 0 } };
+    return response({
+        requestId: res.requestId,
+        result: { syncTime: utils.Objects.defaults(res.result, def) },
+    });
+}
+function reconnect(res = {}, meta) {
+    const def = {
+        jwt: 'jwt',
+        token: { token: 'token', expiresIn: new Date().getTime() + 10000 },
+    };
+    return response({
+        requestId: res.requestId,
+        result: { reconnect: utils.Objects.defaults(res.result, def) },
+    }, meta);
+}
+function loadSceneViewState(res = {}, meta) {
+    const def = {};
+    return response({
+        requestId: res.requestId,
+        result: { loadSceneViewState: utils.Objects.defaults(res.result, def) },
+    }, meta);
+}
+function refreshToken(res = {}, meta) {
+    const def = {
+        token: { token: 'token', expiresIn: new Date().getTime() + 10000 },
+    };
+    return response({
+        requestId: res.requestId,
+        result: { refreshToken: utils.Objects.defaults(res.result, def) },
+    }, meta);
+}
+
+var responses = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  startStream: startStream,
+  syncTime: syncTime,
+  reconnect: reconnect,
+  loadSceneViewState: loadSceneViewState,
+  refreshToken: refreshToken
+});
+
+var index = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Events: events,
+  Requests: requests,
+  Responses: responses
+});
+
+class WebSocketClientMock {
+    constructor() {
+        this.closeHandlers = new Set();
+        this.msgHandlers = new Set();
+        this.sentMessages = new Array();
+    }
+    close() {
+        this.closeHandlers.forEach((handler) => handler(new CloseEvent('close')));
+    }
+    connect(descriptor) {
+        return Promise.resolve();
+    }
+    onClose(handler) {
+        this.closeHandlers.add(handler);
+        return { dispose: () => this.closeHandlers.delete(handler) };
+    }
+    onMessage(handler) {
+        this.msgHandlers.add(handler);
+        return { dispose: () => this.msgHandlers.delete(handler) };
+    }
+    send(data) {
+        this.sentMessages.push(data);
+    }
+    reconnect(descriptor) {
+        return Promise.resolve();
+    }
+    /**
+     * Simulates a websocket message that was sent by the server and received by
+     * the client.
+     *
+     * @param data The websocket message data.
+     */
+    receiveMessage(data) {
+        this.msgHandlers.forEach((handler) => handler(new MessageEvent('message', { data })));
+    }
+    /**
+     * Resets the internal state of the mock by clearing any accrued sent messages
+     * and removing all handlers.
+     */
+    reset() {
+        this.sentMessages = [];
+        this.msgHandlers.clear();
+        this.closeHandlers.clear();
+    }
+    /**
+     * Returns `true` if there are remaining sent messages..
+     */
+    hasNextSent() {
+        return this.sentMessages.length > 0;
+    }
+    nextSent(decoder) {
+        const next = this.sentMessages.shift();
+        if (next != null) {
+            if (decoder != null) {
+                return decoder(next);
+            }
+            else {
+                return next;
+            }
+        }
+        else {
+            throw new Error('Sent messages is empty');
+        }
+    }
+    /**
+     * Skips the next N sent messages.
+     *
+     * @example
+     * ```
+     * const ws = new WebSocketClientMock();
+     * ws.send("1");
+     * ws.send("2");
+     * ws.send("3");
+     *
+     * ws.skipSent(2);
+     * ws.nextSent(); // "3"
+     * ```
+     *
+     * @param n The number of sent messages to skip over.
+     */
+    skipSent(n = 1) {
+        if (n <= this.sentMessages.length) {
+            for (let i = 0; i < n; i++) {
+                this.nextSent();
+            }
+        }
+        else {
+            throw new Error(`Cannot skip the next ${n} messages. Sent message queue only has ${this.sentMessages.length} messages.`);
+        }
+        return this;
+    }
+}
+
+exports.Fixtures = index;
+exports.StreamApi = StreamApi;
+exports.StreamRequestError = StreamRequestError;
+exports.WebSocketClientImpl = WebSocketClientImpl;
+exports.WebSocketClientMock = WebSocketClientMock;
+exports.appendSettingsToUrl = appendSettingsToUrl;
+exports.currentDateAsProtoTimestamp = currentDateAsProtoTimestamp;
+exports.decode = decode;
+exports.encode = encode;
+exports.protoToDate = protoToDate;
+exports.toProtoDuration = toProtoDuration;
+exports.toProtoTimestamp = toProtoTimestamp;
+//# sourceMappingURL=bundle.cjs.map