@kitware/vtk.js 26.3.1 → 26.4.0

package/Rendering/Core/InteractorStyle.d.ts

@@ -0,0 +1,229 @@
+import { EventHandler, vtkSubscription } from './../../interfaces';
+import vtkInteractorObserver from './InteractorObserver';
+
+export interface vtkInteractorStyle extends vtkInteractorObserver {
+  /**
+   * Start a Rotate event.
+   */
+  startRotate(): void;
+
+  /**
+   * Invoke a StartRotate event.
+   */
+  invokeStartRotateEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback on a StartRotate event.
+   */
+  onStartRotateEvent(cb: EventHandler, priority?: number): vtkSubscription;
+
+  /**
+   * Ends a Rotate event.
+   */
+  endRotate(): void;
+
+  /**
+   * Invoke an EndRotate event.
+   */
+  invokeEndRotateEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback on an EndRotate event.
+   */
+  onEndRotateEvent(cb: EventHandler, priority?: number): vtkSubscription;
+  /**
+   * Start a Pan event.
+   */
+  startPan(): void;
+
+  /**
+   * Invoke a StartPan event.
+   */
+  invokeStartPanEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback on a StartPan event.
+   */
+  onStartPanEvent(cb: EventHandler, priority?: number): vtkSubscription;
+
+  /**
+   * Ends a Pan event.
+   */
+  endPan(): void;
+
+  /**
+   * Invoke an EndPan event.
+   */
+  invokeEndPanEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback on an EndPan event.
+   */
+  onEndPanEvent(cb: EventHandler, priority?: number): vtkSubscription;
+  /**
+   * Start a Spin event.
+   */
+  startSpin(): void;
+
+  /**
+   * Invoke a StartSpin event.
+   */
+  invokeStartSpinEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback on a StartSpin event.
+   */
+  onStartSpinEvent(cb: EventHandler, priority?: number): vtkSubscription;
+
+  /**
+   * Ends a Spin event.
+   */
+  endSpin(): void;
+
+  /**
+   * Invoke an EndSpin event.
+   */
+  invokeEndSpinEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback on an EndSpin event.
+   */
+  onEndSpinEvent(cb: EventHandler, priority?: number): vtkSubscription;
+  /**
+   * Start a Dolly event.
+   */
+  startDolly(): void;
+
+  /**
+   * Invoke a StartDolly event.
+   */
+  invokeStartDollyEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback on a StartDolly event.
+   */
+  onStartDollyEvent(cb: EventHandler, priority?: number): vtkSubscription;
+
+  /**
+   * Ends a Dolly event.
+   */
+  endDolly(): void;
+
+  /**
+   * Invoke an EndDolly event.
+   */
+  invokeEndDollyEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback on an EndDolly event.
+   */
+  onEndDollyEvent(cb: EventHandler, priority?: number): vtkSubscription;
+  /**
+   * Start a CameraPose event.
+   */
+  startCameraPose(): void;
+
+  /**
+   * Invoke a StartCameraPose event.
+   */
+  invokeStartCameraPoseEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback on a StartCameraPose event.
+   */
+  onStartCameraPoseEvent(cb: EventHandler, priority?: number): vtkSubscription;
+
+  /**
+   * Ends a CameraPose event.
+   */
+  endCameraPose(): void;
+
+  /**
+   * Invoke an EndCameraPose event.
+   */
+  invokeEndCameraPoseEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback on an EndCameraPose event.
+   */
+  onEndCameraPoseEvent(cb: EventHandler, priority?: number): vtkSubscription;
+  /**
+   * Start a WindowLevel event.
+   */
+  startWindowLevel(): void;
+
+  /**
+   * Invoke a StartWindowLevel event.
+   */
+  invokeStartWindowLevelEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback on a StartWindowLevel event.
+   */
+  onStartWindowLevelEvent(cb: EventHandler, priority?: number): vtkSubscription;
+
+  /**
+   * Ends a WindowLevel event.
+   */
+  endWindowLevel(): void;
+
+  /**
+   * Invoke an EndWindowLevel event.
+   */
+  invokeEndWindowLevelEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback on an EndWindowLevel event.
+   */
+  onEndWindowLevelEvent(cb: EventHandler, priority?: number): vtkSubscription;
+  /**
+   * Start a Slice event.
+   */
+  startSlice(): void;
+
+  /**
+   * Invoke a StartSlice event.
+   */
+  invokeStartSliceEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback on a StartSlice event.
+   */
+  onStartSliceEvent(cb: EventHandler, priority?: number): vtkSubscription;
+
+  /**
+   * Ends a Slice event.
+   */
+  endSlice(): void;
+
+  /**
+   * Invoke an EndSlice event.
+   */
+  invokeEndSliceEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback on an EndSlice event.
+   */
+  onEndSliceEvent(cb: EventHandler, priority?: number): vtkSubscription;
+
+  /**
+   * Handles a keypress.
+   */
+  handleKeyPress(callData: unknown): void;
+}
+
+export interface IInteractorStyleInitialValues {
+  autoAdjustCameraClippingRange?: boolean;
+}
+
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IInteractorStyleInitialValues
+): void;
+
+export const vtkInteractorStyle: {
+  extend: typeof extend;
+};
+
+export default vtkInteractorStyle;

package/Rendering/Core/PointPicker.js

@@ -13,7 +13,7 @@ function vtkPointPicker(publicAPI, model) {
   publicAPI.intersectWithLine = function (p1, p2, tol, mapper) {
     var tMin = Number.MAX_VALUE;
 
-    if (mapper.isA('vtkImageMapper')) {
+    if (mapper.isA('vtkImageMapper') || mapper.isA('vtkImageArrayMapper')) {
       var pickData = mapper.intersectWithLineForPointPicking(p1, p2);
 
       if (pickData) {

package/Rendering/OpenGL/CellArrayBufferObject.js

@@ -288,7 +288,7 @@ function vtkOpenGLCellArrayBufferObject(publicAPI, model) {
       // Keep track of original point and cell ids, for selection
       if (selectionMaps) {
         selectionMaps.points[pointCount] = i;
-        selectionMaps.cells[pointCount] = cellCount;
+        selectionMaps.cells[pointCount] = cellCount + options.cellOffset;
       }
 
       ++pointCount; // Vertices

package/Rendering/OpenGL/ImageMapper.js

@@ -55,7 +55,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
 
       model.openGLCamera = model._openGLRenderer.getViewNodeFor(ren.getActiveCamera()); // is slice set by the camera
 
-      if (model.renderable.getSliceAtFocalPoint()) {
+      if (model.renderable.isA('vtkImageMapper') && model.renderable.getSliceAtFocalPoint()) {
         model.renderable.setSliceFromCamera(ren.getActiveCamera());
       }
     }
@@ -495,7 +495,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
       type: 'StartEvent'
     });
     model.renderable.update();
-    model.currentInput = model.renderable.getInputData();
+    model.currentInput = model.renderable.getCurrentImage();
     publicAPI.invokeEvent({
       type: 'EndEvent'
     });
@@ -548,6 +548,11 @@ function vtkOpenGLImageMapper(publicAPI, model) {
       return;
     }
 
+    var dataType = imgScalars.getDataType();
+    var numComp = imgScalars.getNumberOfComponents(); // Re-allocate the texture because vtkOpenGLTexture uses texStorage2D
+    // which makes the texture immutable.
+
+    model.openGLTexture.releaseGraphicsResources(model._openGLRenderWindow);
     var actorProperty = actor.getProperty(); // set interpolation on the texture based on property setting
 
     var iType = actorProperty.getInterpolationType();
@@ -564,8 +569,6 @@ function vtkOpenGLImageMapper(publicAPI, model) {
       model.pwfTexture.setMagnificationFilter(Filter.LINEAR);
     }
 
-    var dataType = imgScalars.getDataType();
-    var numComp = imgScalars.getNumberOfComponents();
     var iComps = actorProperty.getIndependentComponents();
     var numIComps = iComps ? numComp : 1;
     var textureHeight = iComps ? 2 * numIComps : 1;
@@ -672,9 +675,12 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     if (ijkMode !== model.renderable.getSlicingMode()) {
       // If not IJK slicing, get the IJK slice from the XYZ position/slice
       slice = model.renderable.getSliceAtPosition(slice);
-    }
+    } // Use sub-Slice number/offset if mapper being used is vtkImageArrayMapper,
+    // since this mapper uses a collection of vtkImageData (and not just a single vtkImageData).
+
 
-    var nSlice = Math.round(slice); // Find sliceOffset
+    var nSlice = model.renderable.isA('vtkImageArrayMapper') ? model.renderable.getSubSlice() // get subSlice of the current (possibly multi-frame) image
+    : Math.round(slice); // Find sliceOffset
 
     var ext = image.getExtent();
     var sliceOffset;
@@ -889,6 +895,6 @@ var vtkImageMapper = {
   extend: extend
 }; // Register ourself to OpenGL backend if imported
 
-registerOverride('vtkImageMapper', newInstance);
+registerOverride('vtkAbstractImageMapper', newInstance);
 
 export { vtkImageMapper as default, extend, newInstance };

package/Rendering/OpenGL/PolyDataMapper.js

@@ -1070,9 +1070,9 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
 
       if (cabo.getElementCount()) {
         // are we drawing edges
-        model.drawingEdges = drawSurfaceWithEdges && (i === primTypes.TrisEdges || i === primTypes.TriStripsEdges);
+        model.drawingEdges = drawSurfaceWithEdges && (i === primTypes.TrisEdges || i === primTypes.TriStripsEdges); // don't draw edges when rendering depth or rendering for picking
 
-        if (!model.drawingEdges || !model.renderDepth) {
+        if (!model.drawingEdges || !(model.renderDepth || model.lastSelectionState >= 0)) {
           model.lastBoundBO = model.primitives[i];
           model.primitiveIDOffset += model.primitives[i].drawArrays(ren, actor, representation, publicAPI);
           model.vertexIDOffset += model.primitives[i].getCABO().getElementCount();
@@ -1274,8 +1274,7 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
         inRep: 'strips',
         cells: poly.getStrips()
       }];
-      var drawSurfaceWithEdges = // TODO: false if picking
-      actor.getProperty().getEdgeVisibility() && representation === Representation.SURFACE;
+      var drawSurfaceWithEdges = actor.getProperty().getEdgeVisibility() && representation === Representation.SURFACE;
 
       for (var i = primTypes.Start; i < primTypes.End; i++) {
         if (i !== primTypes.TrisEdges && i !== primTypes.TriStripsEdges) {
@@ -1284,13 +1283,15 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
         } else {
           // if we have edge visibility build the edge VBOs
           if (drawSurfaceWithEdges) {
-            options.cellOffset += model.primitives[i].getCABO().createVBO(primitives[i].cells, primitives[i].inRep, Representation.WIREFRAME, _objectSpread(_objectSpread({}, options), {}, {
+            // VBOs for edges in "surface with edges" are the last to be built,
+            // they are not used when picking with a hardware selector so they
+            // don't need selectionWebGLIdsToVTKIds and don't update cellOffset and vertexOffset
+            model.primitives[i].getCABO().createVBO(primitives[i].cells, primitives[i].inRep, Representation.WIREFRAME, _objectSpread(_objectSpread({}, options), {}, {
               tcoords: null,
               colors: null,
               haveCellScalars: false,
               haveCellNormals: false
-            }), model.selectionWebGLIdsToVTKIds);
-            options.vertexOffset += model.primitives[i].getCABO().getElementCount();
+            }));
           } else {
             // otherwise free them
             model.primitives[i].releaseGraphicsResources();

package/Rendering/OpenGL/RenderWindow.d.ts

@@ -96,6 +96,11 @@ export interface vtkOpenGLRenderWindow extends vtkOpenGLRenderWindowBase {
 	 */
 	getFramebufferSize(): Vector2;
 
+	/**
+	 * Get the webgl canvas.
+	 */
+	getCanvas(): Nullable<HTMLCanvasElement>;
+
 	/**
 	 * Check if a point is in the viewport.
 	 * @param {Number} x The x coordinate.
@@ -269,8 +274,10 @@ export interface vtkOpenGLRenderWindow extends vtkOpenGLRenderWindowBase {
 	 * @param {VtkDataTypes} vtktype 
 	 * @param {Number} numComps 
 	 * @param {Boolean} useFloat 
+	 * @param {unknown} oglNorm16Ext The WebGL EXT_texture_norm16 extension context
+	 * @param {Boolean} useHalfFloat
 	 */
-	getDefaultTextureInternalFormat(vtktype: VtkDataTypes, numComps: number, oglNorm16Ext?: unknown): void;
+	getDefaultTextureInternalFormat(vtktype: VtkDataTypes, numComps: number, oglNorm16Ext?: unknown, useHalfFloat?: boolean): void;
 
 	/**
 	 * 

package/Rendering/OpenGL/RenderWindow.js

@@ -541,6 +541,7 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
 
   publicAPI.getDefaultTextureInternalFormat = function (vtktype, numComps) {
     var oglNorm16Ext = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+    var useHalfFloat = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
 
     if (model.webgl2) {
       switch (vtktype) {
@@ -560,7 +561,7 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
               return model.context.RGBA8;
           }
 
-        case oglNorm16Ext && VtkDataTypes.UNSIGNED_SHORT:
+        case oglNorm16Ext && !useHalfFloat && VtkDataTypes.UNSIGNED_SHORT:
           switch (numComps) {
             case 1:
               return oglNorm16Ext.R16_EXT;
@@ -578,7 +579,7 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
 
         // prioritize norm16 over float
 
-        case oglNorm16Ext && VtkDataTypes.SHORT:
+        case oglNorm16Ext && !useHalfFloat && VtkDataTypes.SHORT:
           switch (numComps) {
             case 1:
               return oglNorm16Ext.R16_SNORM_EXT;

package/Rendering/OpenGL/Texture.js

@@ -311,7 +311,7 @@ function vtkOpenGLTexture(publicAPI, model) {
   publicAPI.getDefaultInternalFormat = function (vtktype, numComps) {
     var result = 0; // try default next
 
-    result = model._openGLRenderWindow.getDefaultTextureInternalFormat(vtktype, numComps, model.oglNorm16Ext);
+    result = model._openGLRenderWindow.getDefaultTextureInternalFormat(vtktype, numComps, model.oglNorm16Ext, model.useHalfFloat);
 
     if (result) {
       return result;
@@ -401,10 +401,10 @@ function vtkOpenGLTexture(publicAPI, model) {
         // prefer norm16 since that is accurate compared to
         // half float which is not
 
-        case model.oglNorm16Ext && VtkDataTypes.SHORT:
+        case model.oglNorm16Ext && !model.useHalfFloat && VtkDataTypes.SHORT:
           return model.context.SHORT;
 
-        case model.oglNorm16Ext && VtkDataTypes.UNSIGNED_SHORT:
+        case model.oglNorm16Ext && !model.useHalfFloat && VtkDataTypes.UNSIGNED_SHORT:
           return model.context.UNSIGNED_SHORT;
         // use half float type
 
@@ -728,7 +728,7 @@ function vtkOpenGLTexture(publicAPI, model) {
   publicAPI.create2DFromRaw = function (width, height, numComps, dataType, data) {
     var flip = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : false;
     // Now determine the texture parameters using the arguments.
-    publicAPI.getOpenGLDataType(dataType);
+    publicAPI.getOpenGLDataType(dataType, true);
     publicAPI.getInternalFormat(dataType, numComps);
     publicAPI.getFormat(dataType, numComps);
 
@@ -1148,9 +1148,10 @@ function vtkOpenGLTexture(publicAPI, model) {
         computedScale = _computeScaleOffsets.scale;
 
     model.volumeInfo.dataComputedScale = computedScale;
-    model.volumeInfo.dataComputedOffset = computedOffset; // if we can use norm16, there is no need to use halfFloat then
+    model.volumeInfo.dataComputedOffset = computedOffset; // preferSizeOverAccuracy will override norm16 due to bug with norm16 implementation
+    // https://bugs.chromium.org/p/chromium/issues/detail?id=1408247
 
-    model.useHalfFloat = model.oglNorm16Ext ? false : checkUseHalfFloat(dataType, computedOffset, computedScale, preferSizeOverAccuracy); // since our default is to use half float, in case that we can't use it
+    model.useHalfFloat = checkUseHalfFloat(dataType, computedOffset, computedScale, preferSizeOverAccuracy); // since our default is to use half float, in case that we can't use it
     // we need to use another type
 
     if (!model.useHalfFloat) {
@@ -1159,11 +1160,7 @@ function vtkOpenGLTexture(publicAPI, model) {
 
 
     if (model._openGLRenderWindow.getWebgl2()) {
-      if (dataType === VtkDataTypes.FLOAT || model.useHalfFloat && (dataType === VtkDataTypes.SHORT || dataType === VtkDataTypes.UNSIGNED_SHORT)) {
-        return publicAPI.create3DFromRaw(width, height, depth, numComps, dataType, data);
-      }
-
-      if (model.oglNorm16Ext && dataType === VtkDataTypes.SHORT) {
+      if (model.oglNorm16Ext && !model.useHalfFloat && dataType === VtkDataTypes.SHORT) {
         for (var _c3 = 0; _c3 < numComps; ++_c3) {
           model.volumeInfo.scale[_c3] = 32767.0;
         }
@@ -1171,7 +1168,7 @@ function vtkOpenGLTexture(publicAPI, model) {
         return publicAPI.create3DFromRaw(width, height, depth, numComps, dataType, data);
       }
 
-      if (model.oglNorm16Ext && dataType === VtkDataTypes.UNSIGNED_SHORT) {
+      if (model.oglNorm16Ext && !model.useHalfFloat && dataType === VtkDataTypes.UNSIGNED_SHORT) {
         for (var _c4 = 0; _c4 < numComps; ++_c4) {
           model.volumeInfo.scale[_c4] = 65535.0;
         }
@@ -1179,6 +1176,10 @@ function vtkOpenGLTexture(publicAPI, model) {
         return publicAPI.create3DFromRaw(width, height, depth, numComps, dataType, data);
       }
 
+      if (dataType === VtkDataTypes.FLOAT || model.useHalfFloat && (dataType === VtkDataTypes.SHORT || dataType === VtkDataTypes.UNSIGNED_SHORT)) {
+        return publicAPI.create3DFromRaw(width, height, depth, numComps, dataType, data);
+      }
+
       if (dataType === VtkDataTypes.UNSIGNED_CHAR) {
         for (var _c5 = 0; _c5 < numComps; ++_c5) {
           model.volumeInfo.scale[_c5] = 255.0;

package/Widgets/Core/StateBuilder.d.ts

@@ -0,0 +1,29 @@
+import vtkWidgetState from './WidgetState';
+
+export interface StateBuilder {
+  addDynamicMixinState(buildInfo: {
+    labels: string[];
+    mixins: string[];
+    name: string;
+    initialValues?: object;
+  }): StateBuilder;
+  addStateFromMixin(buildInfo: {
+    labels: string[];
+    mixins: string[];
+    name: string;
+    initialValues?: object;
+  }): StateBuilder;
+  addStateFromInstance(stateInfo: {
+    labels: string[];
+    name: string;
+    instance: vtkWidgetState;
+  });
+  addField(field: { name: string; initialValue: any });
+  build(...mixins: string[]): vtkWidgetState;
+}
+
+export function createBuilder(): StateBuilder;
+
+export declare const vtkStateBuilder: {
+  createBuilder: typeof createBuilder;
+};

package/index.d.ts

@@ -20,6 +20,7 @@
 /// <reference path="./Common/DataModel/Box.d.ts" />
 /// <reference path="./Common/DataModel/CardinalSpline1D.d.ts" />
 /// <reference path="./Common/DataModel/Cell.d.ts" />
+/// <reference path="./Common/DataModel/Collection.d.ts" />
 /// <reference path="./Common/DataModel/Cone.d.ts" />
 /// <reference path="./Common/DataModel/Cylinder.d.ts" />
 /// <reference path="./Common/DataModel/DataSet/Constants.d.ts" />
@@ -100,8 +101,33 @@
 /// <reference path="./IO/XML/XMLImageDataReader.d.ts" />
 /// <reference path="./IO/XML/XMLPolyDataReader.d.ts" />
 /// <reference path="./IO/XML/XMLReader.d.ts" />
+/// <reference path="./Interaction/Manipulators/CompositeCameraManipulator.d.ts" />
+/// <reference path="./Interaction/Manipulators/CompositeGestureManipulator.d.ts" />
+/// <reference path="./Interaction/Manipulators/CompositeKeyboardManipulator.d.ts" />
+/// <reference path="./Interaction/Manipulators/CompositeMouseManipulator.d.ts" />
+/// <reference path="./Interaction/Manipulators/CompositeVRManipulator.d.ts" />
+/// <reference path="./Interaction/Manipulators/GestureCameraManipulator.d.ts" />
+/// <reference path="./Interaction/Manipulators/MouseBoxSelectorManipulator.d.ts" />
+/// <reference path="./Interaction/Manipulators/MouseCameraTrackballMultiRotateManipulator.d.ts" />
+/// <reference path="./Interaction/Manipulators/MouseCameraTrackballPanManipulator.d.ts" />
+/// <reference path="./Interaction/Manipulators/MouseCameraTrackballRollManipulator.d.ts" />
+/// <reference path="./Interaction/Manipulators/MouseCameraTrackballRotateManipulator.d.ts" />
+/// <reference path="./Interaction/Manipulators/MouseCameraTrackballZoomManipulator.d.ts" />
+/// <reference path="./Interaction/Manipulators/MouseCameraTrackballZoomToMouseManipulator.d.ts" />
+/// <reference path="./Interaction/Manipulators/MouseRangeManipulator.d.ts" />
+/// <reference path="./Interaction/Style/InteractorStyleManipulator.d.ts" />
 /// <reference path="./Interaction/Widgets/OrientationMarkerWidget/Constants.d.ts" />
 /// <reference path="./Interaction/Widgets/OrientationMarkerWidget.d.ts" />
+/// <reference path="./Proxy/Core/AbstractRepresentationProxy.d.ts" />
+/// <reference path="./Proxy/Core/LookupTableProxy.d.ts" />
+/// <reference path="./Proxy/Core/PiecewiseFunctionProxy.d.ts" />
+/// <reference path="./Proxy/Core/ProxyManager.d.ts" />
+/// <reference path="./Proxy/Core/SourceProxy.d.ts" />
+/// <reference path="./Proxy/Core/View2DProxy.d.ts" />
+/// <reference path="./Proxy/Core/ViewProxy.d.ts" />
+/// <reference path="./Proxy/Representations/SliceRepresentationProxy.d.ts" />
+/// <reference path="./Proxy/Representations/VolumeRepresentationProxy.d.ts" />
+/// <reference path="./Rendering/Core/AbstractImageMapper.d.ts" />
 /// <reference path="./Rendering/Core/AbstractMapper.d.ts" />
 /// <reference path="./Rendering/Core/AbstractMapper3D.d.ts" />
 /// <reference path="./Rendering/Core/AbstractPicker.d.ts" />
@@ -119,12 +145,15 @@
 /// <reference path="./Rendering/Core/Follower.d.ts" />
 /// <reference path="./Rendering/Core/Glyph3DMapper/Constants.d.ts" />
 /// <reference path="./Rendering/Core/Glyph3DMapper.d.ts" />
+/// <reference path="./Rendering/Core/ImageArrayMapper.d.ts" />
 /// <reference path="./Rendering/Core/ImageMapper/Constants.d.ts" />
 /// <reference path="./Rendering/Core/ImageMapper.d.ts" />
 /// <reference path="./Rendering/Core/ImageProperty/Constants.d.ts" />
 /// <reference path="./Rendering/Core/ImageProperty.d.ts" />
 /// <reference path="./Rendering/Core/ImageSlice.d.ts" />
 /// <reference path="./Rendering/Core/InteractorObserver.d.ts" />
+/// <reference path="./Rendering/Core/InteractorStyle/Constants.d.ts" />
+/// <reference path="./Rendering/Core/InteractorStyle.d.ts" />
 /// <reference path="./Rendering/Core/Light.d.ts" />
 /// <reference path="./Rendering/Core/Mapper/Constants.d.ts" />
 /// <reference path="./Rendering/Core/Mapper.d.ts" />
@@ -168,6 +197,7 @@
 /// <reference path="./Rendering/SceneGraph/ViewNodeFactory.d.ts" />
 /// <reference path="./Widgets/Core/AbstractWidget.d.ts" />
 /// <reference path="./Widgets/Core/AbstractWidgetFactory.d.ts" />
+/// <reference path="./Widgets/Core/StateBuilder.d.ts" />
 /// <reference path="./Widgets/Core/WidgetManager/Constants.d.ts" />
 /// <reference path="./Widgets/Core/WidgetManager.d.ts" />
 /// <reference path="./Widgets/Core/WidgetState.d.ts" />

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitware/vtk.js",
-  "version": "26.3.1",
+  "version": "26.4.0",
   "description": "Visualization Toolkit for the Web",
   "keywords": [
     "3d",