@kitware/vtk.js 24.18.6 → 24.18.7

package/Common/DataModel/DataSet/Constants.d.ts

@@ -0,0 +1,27 @@
+export declare enum FieldAssociations {
+	FIELD_ASSOCIATION_POINTS = 0,
+	FIELD_ASSOCIATION_CELLS = 1,
+	FIELD_ASSOCIATION_NONE = 2,
+	FIELD_ASSOCIATION_POINTS_THEN_CELLS = 3,
+	FIELD_ASSOCIATION_VERTICES = 4,
+	FIELD_ASSOCIATION_EDGES = 5,
+	FIELD_ASSOCIATION_ROWS = 6,
+	NUMBER_OF_ASSOCIATIONS = 7,
+}
+
+export declare enum FieldDataTypes {
+  UNIFORM = 0,
+  DATA_OBJECT_FIELD = 0,
+  COORDINATE = 1,
+  POINT_DATA = 1,
+  POINT = 2,
+  POINT_FIELD_DATA = 2, 
+  CELL = 3,
+  CELL_FIELD_DATA = 3,
+  VERTEX = 4,
+  VERTEX_FIELD_DATA = 4,
+  EDGE = 5,
+  EDGE_FIELD_DATA = 5,
+  ROW = 6,
+  ROW_DATA = 6,
+}

package/Common/DataModel/DataSet.d.ts

@@ -1,33 +1,6 @@
-import { vtkObject } from './../../interfaces' ;
 import vtkDataSetAttributes from './DataSetAttributes';
-
-export enum FieldDataTypes {
-	UNIFORM,
-	DATA_OBJECT_FIELD,
-	COORDINATE,
-	POINT_DATA,
-	POINT,
-	POINT_FIELD_DATA,
-	CELL,
-	CELL_FIELD_DATA,
-	VERTEX,
-	VERTEX_FIELD_DATA,
-	EDGE,
-	EDGE_FIELD_DATA,
-	ROW,
-	ROW_DATA,
-}
-
-export enum FieldAssociations {
-	FIELD_ASSOCIATION_POINTS,
-	FIELD_ASSOCIATION_CELLS,
-	FIELD_ASSOCIATION_NONE,
-	FIELD_ASSOCIATION_POINTS_THEN_CELLS,
-	FIELD_ASSOCIATION_VERTICES,
-	FIELD_ASSOCIATION_EDGES,
-	FIELD_ASSOCIATION_ROWS,
-	NUMBER_OF_ASSOCIATIONS,
-}
+import { vtkObject } from './../../interfaces' ;
+import { FieldAssociations, FieldDataTypes } from './DataSet/Constants';
 
 /**
  *
@@ -102,7 +75,9 @@ export function newInstance(initialValues? : IDataSetInitialValues): vtkDataSet;
  * operate on cell data, both cell and point data, either one, or none.
  */
 export declare const vtkDataSet: {
-	newInstance: typeof newInstance,
-	extend: typeof extend,
+	newInstance: typeof newInstance;
+	extend: typeof extend;
+	FieldAssociation: typeof FieldAssociations;
+	FieldDataTypes: typeof FieldDataTypes;
 };
 export default vtkDataSet;

package/Interaction/Widgets/OrientationMarkerWidget.d.ts

@@ -165,7 +165,6 @@ export function extend(publicAPI: object, model: object, initialValues?: IOrient
  */
 export function newInstance(initialValues?: IOrientationMarkerWidgetInitialValues): vtkOrientationMarkerWidget;
 
-
 /**
  * vtkOrientationMarkerWidget is a 2D widget for manipulating a marker prop
  */
@@ -174,4 +173,5 @@ export declare const vtkOrientationMarkerWidget: {
 	extend: typeof extend;
 	Corners: typeof Corners;
 }
+
 export default vtkOrientationMarkerWidget;

package/Rendering/Core/InteractorObserver.d.ts

@@ -0,0 +1,132 @@
+import vtkRenderer from './Renderer';
+import vtkRenderWindowInteractor from './RenderWindowInteractor';
+import { vtkObject, EventHandler, vtkSubscription } from './../../interfaces';
+import { Vector3 } from './../../types';
+
+export interface vtkInteractorObserver extends vtkObject {
+  /**
+   * Invoke an interaction event.
+   * 
+   * @param args Event payload.
+   */
+  invokeInteractionEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback to be invoked when an interaction event occurs.
+   * 
+   * @param {EventHandler} cb The callback to be called.
+   * @param {Number} [priority] The priority of the event.
+   */
+  onInteractionEvent(cb: EventHandler, priority?: number): Readonly<vtkSubscription>;
+
+  /**
+   * Invoke a start interaction event.
+   * 
+   * @param args Event payload. 
+   */
+  invokeStartInteractionEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback to be invoked when a start interaction event occurs.
+   * 
+   * @param {EventHandler} cb The callback to be called. 
+   * @param {Number} [priority] The callback to be called
+   */
+  onStartInteractionEvent(cb: EventHandler, priority?: number): Readonly<vtkSubscription>;
+
+  /**
+   * Invoke an end interaction event.
+   * 
+   * @param args Event payload. 
+   */
+  invokeEndInteractionEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback to be invoked when an end interaction event occurs.
+   * 
+   * @param {EventHandler} cb The callback to be called. 
+   * @param {Number?} [priority] The callback to be called
+   */
+  onEndInteractionEvent(cb: EventHandler, priority?: number): Readonly<vtkSubscription>;
+
+  /** 
+   * Retrieve the render window interactor instance. 
+   */
+  getInteractor(): vtkRenderWindowInteractor;
+
+  /** 
+   * Get wether or not this InteractorObserver instance is enabled. 
+   */
+  getEnabled(): boolean;
+  
+  /**
+   * Enable/disable the interactor observer. Note that if you are enabling the interactor observer, an interactor instance must exists on the model.
+   * Typically you can call `setInteractor`
+   * 
+   * @param {Boolean} enable 
+   */
+  setEnabled(enable: boolean): void;
+
+  /**
+   * Set the priority.
+   * 
+   * @param {Number} priority The priority level.
+   */
+  setPriority(priority: number): void;
+
+  /**
+   * Get the priority.
+   */
+  getPriority(): number;
+
+  /**
+   * Set whether or not the interactor observer instance should process events.
+   * 
+   * @param {Boolean} processEvents 
+   */
+  setProcessEvents(processEvents: boolean): boolean;
+
+  /**
+   * Get whether or not the interactor observer instance should process events.
+   */
+  getProcessEvents(): boolean;
+
+  /**
+   * Set the interactor instance.
+   * 
+   * @param {vtkRenderWindowInteractor} interactor 
+   */
+  setInteractor(interactor: vtkRenderWindowInteractor): void;
+
+  /**
+   * Transform from world to display coordinates.
+   * 
+   * @param {vtkRenderer} renderer 
+   * @param {Number} x 
+   * @param {Number} y 
+   * @param {Number} z 
+   */
+  computeWorldToDisplay(
+    renderer: vtkRenderer,
+    x: number,
+    y: number,
+    z: number
+  ): Vector3;
+
+  /**
+   * Transform from display to world coordinates.
+   *
+   * @param {vtkRenderer} renderer 
+   * @param {Number} x 
+   * @param {Number} y 
+   * @param {Number} z 
+   */
+  computeDisplayToWorld(
+    renderer: vtkRenderer,
+    x: number,
+    y: number,
+    z: number
+  ): Vector3;
+}
+
+export default vtkInteractorObserver;

package/Rendering/Misc/SynchronizableRenderWindow/ObjectManager.d.ts

@@ -0,0 +1,80 @@
+import { vtkObject } from './../../../interfaces' ;
+import { Nullable } from './../../../types' ;
+import { ISynchronizerContext, IViewState } from "..";
+
+export type BuilderFunction = <T extends vtkObject>(type: string, initialProps?: Record<string, unknown>) => Nullable<T>;
+export type UpdaterFunction = (instance: vtkObject, state: IViewState, context: ISynchronizerContext) => void;
+
+export interface IObjectManager {
+  /**
+   * Build a vtkObject.
+   */
+  build: BuilderFunction;
+
+  /**
+   * @param {String} type The type to update 
+   * @param {vtkObject} instance The specific instance 
+   * @param {IViewState} props 
+   * @param {ISynchronizerContext} context 
+   */
+  update(type: string, instance: vtkObject, props: IViewState, context: ISynchronizerContext): Promise<Error | void>;
+
+  /**
+   * Defines a new type handler with the specified builder and updater functions
+   * 
+   * @param {String} type The type you wish to register
+   * @param {BuilderFunction} [buildFn] The builder function to associate with the type 
+   * @param {UpdaterFunction} [updateFn] The updater function to associate with the type 
+   */
+  setTypeMapping(type: string, buildFn?: BuilderFunction, updateFn?: UpdaterFunction): void;
+  
+  /**
+   * Clear all type mappings
+   */
+  clearTypeMapping(): void;
+ 
+  /**
+   * Get a list of all supported types
+   * 
+   * @returns {string[]}
+   */
+  getSupportedTypes(): string[];
+ 
+  /**
+   * Clear all one time updaters
+   */
+  clearOneTimeUpdaters(): void;
+ 
+  /**
+   * Update the associated render window
+   */
+  updateRenderWindow(): void;
+ 
+  /**
+   * Register a new type to exclude
+   * 
+   * @param {string} type The type to exclude 
+   * @param {string} propertyName The property name to exclude
+   * @param {unknown} propertyValue The property value to exclude 
+   */
+  excludeInstance(type: string, propertyName: string, propertyValue: unknown): void;
+ 
+  /**
+   * Set the default types mapping
+   * 
+   * @param {boolean} [reset] Clear all existing type mappings, defaults to true 
+   */
+  setDefaultMapping(reset?: boolean): void;
+ 
+  /**
+   * Apply the default aliases
+   */
+  applyDefaultAliases(): void;
+ 
+  /**
+   * Always update the camera
+   */
+  alwaysUpdateCamera(): void;
+}
+
+export default IObjectManager;

package/Rendering/Misc/SynchronizableRenderWindow.js

@@ -2,7 +2,7 @@ import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { newInstance as newInstance$1, event, get, chain, newTypedArray, traverseInstanceTree } from '../../macros.js';
 import Base64 from '../../Common/Core/Base64.js';
 import vtkRenderWindow from '../Core/RenderWindow.js';
-import vtkObjectManager from './SynchronizableRenderWindow/vtkObjectManager.js';
+import vtkObjectManager from './SynchronizableRenderWindow/ObjectManager.js';
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 

package/Rendering/OpenGL/ImageMapper.js

@@ -202,6 +202,10 @@ function vtkOpenGLImageMapper(publicAPI, model) {
           FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::TCoord::Impl', ['vec4 tcolor = texture2D(texture1, tcoordVCVSOutput);', 'float intensity = tcolor.r*cscale0 + cshift0;', 'gl_FragData[0] = vec4(texture2D(colorTexture1, vec2(intensity, 0.5)).rgb, pwfscale0*tcolor.g + pwfshift0);']).result;
           break;
 
+        case 3:
+          FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::TCoord::Impl', ['vec4 tcolor = cscale0*texture2D(texture1, tcoordVCVSOutput.st) + cshift0;', 'gl_FragData[0] = vec4(texture2D(colorTexture1, vec2(tcolor.r,0.5)).r,', '  texture2D(colorTexture1, vec2(tcolor.g,0.5)).r,', '  texture2D(colorTexture1, vec2(tcolor.b,0.5)).r, opacity);']).result;
+          break;
+
         default:
           FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::TCoord::Impl', ['vec4 tcolor = cscale0*texture2D(texture1, tcoordVCVSOutput.st) + cshift0;', 'gl_FragData[0] = vec4(texture2D(colorTexture1, vec2(tcolor.r,0.5)).r,', '  texture2D(colorTexture1, vec2(tcolor.g,0.5)).r,', '  texture2D(colorTexture1, vec2(tcolor.b,0.5)).r, tcolor.a);']).result;
       }

package/Widgets/Core/AbstractWidget.d.ts

@@ -0,0 +1,187 @@
+import vtkInteractorObserver from './../../Rendering/Core/InteractorObserver';
+import vtkProp from './../../Rendering/Core/Prop';
+import vtkRenderer from './../../Rendering/Core/Renderer';
+import vtkWidgetManager from './WidgetManager';
+import vtkWidgetRepresentation from './../Representations/WidgetRepresentation';
+import vtkWidgetState from './WidgetState';
+import { Bounds } from './../../types';
+import { RenderingTypes } from './WidgetManager/Constants';
+import { EventHandler, vtkSubscription } from './../../interfaces';
+
+export interface vtkAbstractWidget extends vtkProp, vtkInteractorObserver {
+  /**
+   * Get the bounds of the widget
+   */
+  getBounds(): Bounds;
+
+  /**
+   * Get all representations of the widget.
+   */
+  getNestedProps(): vtkWidgetRepresentation[];
+
+  /**
+   * Activate a handle, identified by both a state and a representation.
+   * Will also invoke appropriate events.
+   * 
+   * @param locator An object describing the handle to activate.
+   */
+  activateHandle(locator: { 
+    selectedState: vtkWidgetState; 
+    representation: vtkWidgetRepresentation; 
+  }): void;
+
+  /**
+   * Deactivate all the handles on the widget instance.
+   */
+  deactivateAllHandles(): void;
+
+  /**
+   * Returns true if the widget instance holds the given actor, false otherwise.
+   * 
+   * @param {vtkProp} actor
+   */
+  hasActor(actor: vtkProp): boolean;
+
+  /**
+   * Make the widget instance grab the focus.
+   * Should not be called directly or this will lead to unexpected behavior.
+   * To grab the focus on a widget, one should call `vtkWidgetManager.grabFocus(widgetInstanceToGiveFocusTo)`
+   */
+  grabFocus(): void;
+
+  /**
+   * Make the widget instance release the focus.
+   */
+  loseFocus(): void;
+
+  /**
+   * Returns true if the widget instance holds the focus, false otherwise.
+   */
+  hasFocus(): boolean;
+
+  /**
+   * Place a widget at the given bounds.
+   * 
+   * @param {Bounds} bounds
+   */
+  placeWidget(bounds: Bounds): void;
+
+  /**
+   * Get the place factor.
+   */
+  getPlaceFactor(): number;
+
+  /**
+   * Set the place factor.
+   * 
+   * @param {Number} factor The place factor.
+   */
+  setPlaceFactor(factor: number): void;
+
+  /**
+   * Get the `vtkWidgetRepresentation` instance associated with the given `vtkActor` instance.
+   * 
+   * @param {vtkProp} actor 
+   */
+  getRepresentationFromActor(actor: vtkProp): vtkWidgetRepresentation;
+
+  /**
+   * Update all the widget representations for render.
+   * 
+   * @param {RenderingTypes} renderingType Default value if `RenderingTypes.FRONT_BUFFER` 
+   */
+  updateRepresentationForRender(renderingType: RenderingTypes): void;
+
+  /**
+   * Get all the underlyings view widgets.
+   */
+  getViewWidgets(): vtkAbstractWidget[];
+
+
+  /**
+   * Set the context visibility.
+   * 
+   * @param {Boolean} visible 
+   */
+  setContextVisibility(visible: boolean): void;
+
+  /**
+   * Get the context visibility.
+   */
+  getContextVisibility(): boolean;
+
+  /**
+   * Defines if the handles should be visible or not.
+   * 
+   * @param {Boolean} visible 
+   */
+  setHandleVisibility(visible: boolean): void;
+
+  /**
+   * Returns true if the handles are visible, false otherwise.
+   */
+  getHandleVisibility(): boolean;
+
+  /**
+   * Set the widget manager associated with the widget instance.
+   * 
+   * @param {vtkWidgetManager} wm The widget manager instance
+   */
+  setWidgetManager(wm: vtkWidgetManager): void;
+
+  /**
+   * Get the widget manager associated with the widget instance.
+   */
+  getWidgetManager(): vtkWidgetManager;
+
+  /**
+   * Get all the representations of the widget instance.
+   */
+  getRepresentations(): vtkWidgetRepresentation[];
+
+  /**
+   * Get the the state of the widget instance.
+   */
+  getWidgetState(): vtkWidgetState;
+
+  /**
+   * Register a callback to be invoked when the `ActivateHandle` event occurs.
+   * 
+   * @param {EventHandler} cb The callback to register
+   * @param {Number} [priority] Priority of this subscription
+   */
+  onActivateHandle(cb: EventHandler, priority?: number): Readonly<vtkSubscription>;
+
+  /**
+   * Invoke the `ActivateHandle` event with the given payload.
+   * 
+   * @param args The event payload
+   */
+  invokeActivateHandle(...args: unknown[]): void;
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkAbstractWidget characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param initialValues (default: {})
+ */
+export function extend(publicAPI: object, model: object, initialValues? : object): void;
+
+/**
+ * Method used to create a new instance of vtkAbstractWidget
+ * 
+ * @param initialValues For pre-setting some of its content
+ */
+export function newInstance(initialValues?: object): vtkAbstractWidget;
+
+/**
+ * vtkAbstractWidget is an abstract class to construct a widget.
+ */
+export declare const vtkAbstractWidget: {
+	newInstance: typeof newInstance,
+	extend: typeof extend,
+};
+
+export default vtkAbstractWidget;

package/Widgets/Core/AbstractWidgetFactory.d.ts

@@ -0,0 +1,126 @@
+import vtkAbstractWidget from './AbstractWidget';
+import vtkRenderer from './../../Rendering/Core/Renderer';
+import vtkWidgetState from './WidgetState';
+import { ViewTypes } from './WidgetManager/Constants';
+import { Bounds, Nullable } from './../../types';
+import { EventHandler, vtkSubscription } from './../../interfaces';
+
+export interface IGetWidgetForViewParams {
+  viewId: number;
+  renderer?: vtkRenderer;
+  viewType?: ViewTypes;
+  initialValues?: object;
+}
+
+export interface vtkAbstractWidgetFactory {
+  /**
+   * Will return the widget associated with the view with Id id `locator.viewId`. 
+   * If there is no widget associated with the view, a new widget will be constructed, provided
+   * that the renderer, viewType, and optionally initialValues are also provided.
+   * 
+   * @param {IGetWidgetForViewParams} locator
+   */
+  getWidgetForView(locator: IGetWidgetForViewParams): Nullable<vtkAbstractWidget>;
+
+  /**
+   * Get a list of all the view ids.
+   */
+  getViewIds(): string[];
+
+  /**
+   * Set the visiblity on each underlying view widget.
+   * 
+   * @param {Boolean} visible
+   */
+  setVisibility(visible: boolean): void 
+
+  /**
+   * Set the pickable flag for each underlying view widget.
+   * 
+   * @param {Boolean} pickable 
+   */
+  setPickable(pickable: boolean): void
+
+  /**
+   * Set the dragable flag for each underlying view widget.
+   * 
+   * @param {Boolean} dragable 
+   */
+  setDragable(dragable: boolean): void
+
+  /**
+   * Set the context visibility for each associated view widget.
+   * 
+   * @param {Boolean} visible 
+   */
+  setContextVisibility(visible: boolean): void
+
+  /**
+   * Set the handles visibility for each underlying view widget.
+   * 
+   * @param {Boolean} visible 
+   */
+  setHandleVisiblity(visible: boolean): void
+
+  /**
+   * Place a new widget at the given bounds.
+   * 
+   * @param {Bounds} bounds 
+   */
+  placeWidget(bounds: Bounds);
+
+  /**
+   * Get the place factor.
+   */
+  getPlaceFactor(): number;
+
+  /**
+   * Set the place factor.
+   * 
+   * @param {Number} factor 
+   */
+  setPlaceFactor(factor: number): void;
+
+  /**
+   * Get the `vtkWidgetState` instance
+   */
+  getWidgetState(): vtkWidgetState;
+
+  /**
+   * Register a callback to be called when the WidgetChange event arise.
+   * 
+   * @param {EventHandler} cb The callback to be invoked.
+   * @param {Number} [priority] The priority of this subscription
+   */
+  onWidgetChangeEvent(cb: EventHandler, priority?: number): Readonly<vtkSubscription>;
+
+  /**
+   * Invoke the WidgetChange event
+   * 
+   * @param args The event payload
+   */
+  invokeWidgetChangeEvent(...args: unknown[]): void;
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkAbstractWidgetFactory characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param initialValues (default: {})
+ */
+export function extend(publicAPI: object, model: object, initialValues? : object): void;
+
+/**
+ * Method used to create a new instance of vtkAbstractWidgetFactory
+ * 
+ * @param initialValues for pre-setting some of its content
+ */
+export function newInstance(initialValues?: object): vtkAbstractWidgetFactory;
+
+export declare const vtkAbstractWidgetFactory: {
+	newInstance: typeof newInstance,
+	extend: typeof extend,
+};
+
+export default vtkAbstractWidgetFactory;

package/Widgets/Core/WidgetManager/Constants.d.ts

@@ -0,0 +1,27 @@
+export declare enum ViewTypes {
+  DEFAULT = 0,
+  GEOMETRY = 1,
+  SLICE = 2,
+  VOLUME = 3,
+  YZ_PLANE = 4,
+  XZ_PLANE = 5,
+  XY_PLANE = 6
+}
+
+export declare enum RenderingTypes {
+  PICKING_BUFFER = 0,
+  FRONT_BUFFER = 1
+}
+
+export declare enum CaptureOn {
+  MOUSE_MOVE = 0,
+  MOUSE_RELEASE = 1
+}
+
+declare const _default: {
+  ViewTypes: typeof ViewTypes;
+  RenderingTypes: typeof RenderingTypes;
+  CaptureOn: typeof CaptureOn;
+}
+
+export default _default;

package/Widgets/Core/WidgetManager.d.ts

@@ -0,0 +1,216 @@
+import vtkAbstractWidget from './AbstractWidget';
+import vtkAbstractWidgetFactory from './AbstractWidgetFactory';
+import vtkCamera from './../../Rendering/Core/Camera';
+import vtkProp from './../../Rendering/Core/Prop';
+import vtkRenderer from './../../Rendering/Core/Renderer';
+import vtkRenderWindow from './../../Rendering/Core/RenderWindow';
+import vtkRenderWindowInteractor from './../../Rendering/Core/RenderWindowInteractor';
+import vtkSelectionNode from './../../Common/DataModel/SelectionNode';
+import vtkWidgetRepresentation from './../Representations/WidgetRepresentation';
+import vtkWidgetState from './WidgetState';
+import { vtkObject } from './../../interfaces';
+import { CaptureOn, ViewTypes } from './WidgetManager/Constants';
+import { Nullable } from './../../types';
+
+export interface ISelectedData {
+  requestCount: number;
+  propID: number;
+  compositeID: number;
+  prop: vtkProp;
+  widget: vtkAbstractWidget;
+  representation: vtkWidgetRepresentation;
+  selectedState: vtkWidgetState;
+}
+
+export interface IRenderingComponents {
+  renderer: vtkRenderer;
+  renderWindow: vtkRenderWindow;
+  interactor: vtkRenderWindowInteractor;
+  apiSpecificRenderWindow: vtkRenderWindow;
+  camera: vtkCamera;
+}
+
+/**
+ * Extract the rendering components from the given renderer.
+ * 
+ * @param renderer
+ */
+export function extractRenderingComponents(renderer: vtkRenderer): IRenderingComponents;
+
+export interface vtkWidgetManager extends vtkObject {
+  /**
+   * The the captureOn value. 
+   * `CaptureOn.MOUSE_MOVE`: captures small region when moving mouse
+   * `CaptureOn.MOUSE_RELEASE`: captures entire region when mouse button is released
+   * 
+   * @param {CaptureOn} captureOn
+   */
+  setCaptureOn(captureOn: CaptureOn): boolean;
+
+  /**
+   * Get the captureOn value.
+   */
+  getCaptureOn(): CaptureOn;
+
+  /**
+   * The the view type.
+   * 
+   * @param {ViewTypes} type
+   */
+  setViewType(type: ViewTypes): boolean;
+
+  /**
+   * Get the view type.
+   */
+  getViewType(): ViewTypes;
+
+  /**
+   * Get the current selection.
+   */
+  getSelections(): vtkSelectionNode[];
+
+  /**
+   * Get all the underlying widgets.
+   */
+  getWidgets(): vtkAbstractWidget[];
+
+  /**
+   * Get the view id.
+   */
+  getViewId(): string;
+
+  /**
+   * Returns true if picking is enabled, false otherwise.
+   */
+  getPickingEnabled(): boolean;
+
+  /**
+   * @deprecated
+   */
+  getUseSvgLayer(): boolean;
+
+  /**
+   * @deprecated
+   */
+  setUseSvgLayer(use: boolean): boolean;
+
+  /**
+   * Enable the picking.
+   */
+  enablePicking(): void;
+
+  /**
+   * Renders all the widgets.
+   */
+  renderWidgets(): void;
+
+  /**
+   * Disable the picking.
+   */
+  disablePicking(): void;
+
+  /**
+   * Set the renderer.
+   * 
+   * @param {vtkRenderer} renderer
+   */
+  setRenderer(renderer: vtkRenderer): void;
+
+  /**
+   * Register a widget on the widget manager instance. 
+   * Please note that one should link the widget manager to a view before calling this method. 
+   * 
+   * @param {vtkAbstractWidgetFactory} widget The abstract widget factory.
+   * @param {ViewTypes} [viewType]
+   * @param {Object} [initialValues]
+   */
+  addWidget(
+    widget: vtkAbstractWidgetFactory,
+    viewType?: ViewTypes,
+    initialValues?: object
+  ): Nullable<vtkAbstractWidget>;
+
+  /**
+   * Unregister all widgets from the widget manager.
+   */
+  removeWidgets(): void;
+
+  /**
+   * Remove a widget from the widget manager.
+   * 
+   * @param {vtkAbstractWidget | vtkAbstractWidgetFactory} widget The widget to remove
+   */
+  removeWidget(widget: vtkAbstractWidget | vtkAbstractWidgetFactory): void;
+
+  /**
+   * Given x and y parameter, get selected data.
+   * 
+   * @param {Number} x
+   * @param {Number} y
+   */
+  getSelectedDataForXY(x: number, y: number): Promise<ISelectedData>;
+
+  /**
+   * @deprecated
+   */
+  updateSelectionFromXY(x: number, y: number): void;
+
+  /**
+   * @deprecated
+   */
+  updateSelectionFromMouseEvent(event: MouseEvent): void;
+
+  /**
+   * The all currently selected data.
+   */
+  getSelectedData(): ISelectedData | {};
+
+  /**
+   * Given the focus to the given widget instance.
+   * 
+   * @param {vtkAbstractWidget | vtkAbstractWidgetFactory} widget The widget instance which should get the focus.
+   */
+  grabFocus(widget: vtkAbstractWidget | vtkAbstractWidgetFactory): void;
+
+  /**
+   * Release the focus.
+   */
+  releaseFocus(): void;
+}
+
+export interface IWidgetManagerInitialValues {
+  captureOn?: CaptureOn;
+  viewType?: ViewTypes;
+  pickingEnabled?: boolean;
+  /**
+   * @deprecated
+   */
+  useSvgLayer?: boolean;
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkWidgetManager characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param initialValues (default: {})
+ */
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IWidgetManagerInitialValues
+): vtkWidgetManager;
+
+/**
+ * Method used to create a new instance of vtkCellArray
+ * 
+ * @param initialValues for pre-setting some of its content
+ */
+export function newInstance(initialValues?: IWidgetManagerInitialValues): vtkWidgetManager;
+
+export declare const vtkWidgetManager: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
+
+export default vtkWidgetManager;

package/Widgets/Core/WidgetState.d.ts

@@ -0,0 +1,81 @@
+import { vtkObject } from './../../interfaces';
+
+export interface vtkWidgetState extends vtkObject {
+  /**
+   * Set the active flag of the widget state instance
+   * 
+   * @param active The active flag
+   */
+  setActive(active: boolean): boolean;
+
+  /**
+   * Get the active flag of the widget state instance
+   */
+  getActive(): boolean;
+
+  /**
+   * Bind a state to one or more labels. If no label is provided, the default one will be used.
+   * 
+   * @param {vtkWidgetState} subState The state to bound.
+   * @param {String | String[]} [labels] The labels to which the state should be bound.
+   */
+  bindState(subState: vtkWidgetState, labels?: string | string[]): void;
+
+  /**
+   * Unbind a specific state from the widget state instance
+   * 
+   * @param {vtkWidgetState} subState The state to be unbound.
+   */
+  unbindState(subState: vtkWidgetState): void;
+
+  /**
+   * Unbind all states from the widget state instance
+   */
+  unbindAll(): void;
+
+  /**
+   * Activate the widget state instance. Same as calling `vtkWidgetState.setActive(true)`
+   */
+  activate(): void;
+
+  /**
+   * Deactivate thie widget state instance and all its sub states, except the `excludingState` argument.
+   * 
+   * @param {vtkWidgetState} [excludingState] A sub-state instance that should not be deactivated.
+   */
+  deactivate(excludingState?: vtkWidgetState): void;
+
+  /**
+   * Activate only the passed in sub state. Every other sub states will be deactivated.
+   * 
+   * @param {vtkWidgetState} subState The sub-state that should be activated.
+   */
+  activateOnly(subState: vtkWidgetState): void;
+
+  /**
+   * Get every states that are associated with the given label.
+   * 
+   * @param {String} label The label from which to retrieve the states.
+   */
+  getStatesWithLabel(label: string): vtkWidgetState[];
+
+  /**
+   * Get all the nested states on the widget state instance.
+   */
+  getAllNestedStates(): vtkWidgetState[];
+}
+
+/**
+ * Method use to decorate a given object (publicAPI+model) with vtkWidgetState characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {object} [initialValues] (default: {})
+ */
+export function extend(publicAPI: object, model: object, initialValues?: object): vtkWidgetState;
+
+export declare const vtkWidgetState: {
+  extend: typeof extend;
+};
+
+export default vtkWidgetState;

package/Widgets/Widgets3D/InteractiveOrientationWidget.d.ts

@@ -0,0 +1,40 @@
+import vtkAbstractWidgetFactory from './../Core/AbstractWidgetFactory';
+import { Bounds } from './../../types';
+import { ViewTypes } from './../Core/WidgetManager/Constants';
+
+export interface vtkInteractiveOrientationWidget extends vtkAbstractWidgetFactory {
+  /**
+   * Set the widget bounds
+   * 
+   * @param {Bounds} bounds The widget bounds
+   */
+  setBounds(bounds: Bounds): void;
+
+  /**
+   * @param {ViewTypes} viewType
+   */
+  getRepresentationForViewType(viewType: ViewTypes): unknown;
+}
+
+/**
+ * Method use to decorate a given object (publicAPI+model) with vtkInteractiveOrientationWidget characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {object} [initialValues] (default: {})
+ */
+export function extend(publicAPI: object, model: object, initialValues? : Record<string, unknown>): void;
+
+/**
+ * Creates a new instance of vtkInteractiveOrientationWidget
+ * 
+ * @param {object} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(initialValues? : Record<string, unknown>): vtkInteractiveOrientationWidget;
+
+export declare const vtkInteractiveOrientationWidget: {
+	newInstance: typeof newInstance,
+	extend: typeof extend,
+};
+
+export default vtkInteractiveOrientationWidget;

package/index.d.ts

@@ -21,6 +21,7 @@
 /// <reference path="./Common/DataModel/Cell.d.ts" />
 /// <reference path="./Common/DataModel/Cone.d.ts" />
 /// <reference path="./Common/DataModel/Cylinder.d.ts" />
+/// <reference path="./Common/DataModel/DataSet/Constants.d.ts" />
 /// <reference path="./Common/DataModel/DataSet.d.ts" />
 /// <reference path="./Common/DataModel/DataSetAttributes/FieldData.d.ts" />
 /// <reference path="./Common/DataModel/DataSetAttributes.d.ts" />
@@ -114,6 +115,7 @@
 /// <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/Light.d.ts" />
 /// <reference path="./Rendering/Core/Mapper/Constants.d.ts" />
 /// <reference path="./Rendering/Core/Mapper.d.ts" />
@@ -147,18 +149,25 @@
 /// <reference path="./Rendering/Misc/GenericRenderWindow.d.ts" />
 /// <reference path="./Rendering/Misc/RemoteView.d.ts" />
 /// <reference path="./Rendering/Misc/RenderWindowWithControlBar.d.ts" />
+/// <reference path="./Rendering/Misc/SynchronizableRenderWindow/ObjectManager.d.ts" />
 /// <reference path="./Rendering/Misc/SynchronizableRenderWindow.d.ts" />
 /// <reference path="./Rendering/Misc/TextureLODsDownloader.d.ts" />
 /// <reference path="./Rendering/OpenGL/RenderWindow.d.ts" />
 /// <reference path="./Rendering/SceneGraph/RenderPass.d.ts" />
 /// <reference path="./Rendering/SceneGraph/ViewNode.d.ts" />
 /// <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/WidgetManager/Constants.d.ts" />
+/// <reference path="./Widgets/Core/WidgetManager.d.ts" />
+/// <reference path="./Widgets/Core/WidgetState.d.ts" />
 /// <reference path="./Widgets/Manipulators/AbstractManipulator.d.ts" />
 /// <reference path="./Widgets/Manipulators/LineManipulator.d.ts" />
 /// <reference path="./Widgets/Manipulators/PlaneManipulator.d.ts" />
 /// <reference path="./Widgets/Manipulators/TrackballManipulator.d.ts" />
 /// <reference path="./Widgets/Representations/ResliceCursorContextRepresentation.d.ts" />
 /// <reference path="./Widgets/Representations/WidgetRepresentation.d.ts" />
+/// <reference path="./Widgets/Widgets3D/InteractiveOrientationWidget.d.ts" />
 /// <reference path="./Widgets/Widgets3D/SphereWidget.d.ts" />
 /// <reference path="./macros.d.ts" />
 /// <reference path="./vtk.d.ts" />

package/interfaces.d.ts

@@ -1,5 +1,6 @@
 import vtkDataArray from './Common/Core/DataArray';
 import { vtkPipelineConnection } from './types';
+import { EVENT_ABORT, VOID } from './macros';
 
 /**
  * Object returned on any subscription call
@@ -278,3 +279,5 @@ export interface vtkProperty {
 }
 
 export interface vtkPropertyDomain {}
+
+export type EventHandler = (...args: unknown[]) => typeof EVENT_ABORT | typeof VOID | void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitware/vtk.js",
-  "version": "24.18.6",
+  "version": "24.18.7",
   "description": "Visualization Toolkit for the Web",
   "keywords": [
     "3d",
@@ -112,7 +112,7 @@
     "rollup-plugin-string": "3.0.0",
     "rollup-plugin-svgo": "1.1.0",
     "rollup-plugin-web-worker-loader": "1.6.1",
-    "semantic-release": "19.0.2",
+    "semantic-release": "19.0.3",
     "string-replace-loader": "3.1.0",
     "style-loader": "3.3.1",
     "tape": "5.5.3",