@kitware/vtk.js 22.1.8 → 22.2.0

package/IO/Core/ImageStream/DefaultProtocol.d.ts

@@ -3,23 +3,23 @@ import { Size, Vector3 } from '@kitware/vtk.js/types';
 declare function createMethods(session: any): {
 	subscribeToImageStream: (callback: any) => any;
 	unsubscribeToImageStream: (subscription: any) => any;
-	registerView: (viewId: number) => any;
-	unregisterView: (viewId: number) => any;
-	enableView: (viewId: number, enabled: boolean) => any;
+	registerView: (viewId: string) => any;
+	unregisterView: (viewId: string) => any;
+	enableView: (viewId: string, enabled: boolean) => any;
 	render: (options?: {
 			size: Size;
 			view: number;
 	}) => any;
 	resetCamera: (view?: number) => any;
-	invalidateCache: (viewId: number) => any;
-	setQuality: (viewId: number, quality: number, ratio?: number) => any;
-	setSize: (viewId: number, width?: number, height?: number) => any;
+	invalidateCache: (viewId: string) => any;
+	setQuality: (viewId: string, quality: number, ratio?: number) => any;
+	setSize: (viewId: string, width?: number, height?: number) => any;
 	setServerAnimationFPS: (fps?: number) => any;
 	getServerAnimationFPS: () => number;
 	startAnimation: (viewId?: number) => any;
 	stopAnimation: (viewId?: number) => any;
-	updateCamera: (viewId: number, focalPoint: Vector3, viewUp: Vector3, position: Vector3, forceUpdate?: boolean) => any;
+	updateCamera: (viewId: string, focalPoint: Vector3, viewUp: Vector3, position: Vector3, forceUpdate?: boolean) => any;
 	updateCameraParameters: (viewId?: number, parameters?: {}, forceUpdate?: boolean) => any;
 }
 
-export default createMethods;
+export default createMethods;

package/IO/Core/ImageStream.d.ts

@@ -1,6 +1,6 @@
 import { vtkObject } from '@kitware/vtk.js/interfaces';
 import { Size } from '@kitware/vtk.js/types';
-
+import vtkViewStream from '@kitware/vtk.js/IO/Core/ImageStream/ViewStream';
 
 /**
  *
@@ -10,54 +10,56 @@ export interface IImageStreamInitialValues {
 	serverAnimationFPS?: number,
 }
 
+// Return type of wslink/src/WebsocketConnection, getSession() method.
+type WebsocketSession = any;
 
 export interface vtkImageStream extends vtkObject {
 
 	/**
-	 * 
+	 *
 	 */
-	connect(): void;
+	connect(session: WebsocketSession): void;
 
 	/**
-	 * 
-	 * @param {Number} [viewId] The ID of the view.
-	 * @param {Size} [size] The size of the view. 
+	 *
+	 * @param {String} [viewId] The ID of the view.
+	 * @param {Size} [size] The size of the view.
 	 */
-	createViewStream(viewId?: number, size?: Size): any;
+	createViewStream(viewId?: string, size?: Size): vtkViewStream;
 
 	/**
-	 * 
+	 *
 	 */
 	delete(): void;
 
 	/**
-	 * 
+	 *
 	 */
 	disconnect(): void;
 
 	/**
-	 * 
+	 *
 	 */
 	getProtocol(): any;
 
 	/**
-	 * 
+	 *
 	 */
 	getServerAnimationFPS(): number;
 
 	/**
-	 * 
+	 *
 	 */
 	registerViewStream(): void;
 
 	/**
-	 * 
-	 * @param serverAnimationFPS 
+	 *
+	 * @param serverAnimationFPS
 	 */
 	setServerAnimationFPS(serverAnimationFPS: number): boolean;
 
 	/**
-	 * 
+	 *
 	 */
 	unregisterViewStream(): void;
 }

package/Rendering/Core/ScalarBarActor.d.ts

@@ -38,7 +38,10 @@ export interface IScalarBarActorInitialValues extends IActorInitialValues {
 	axisTitlePixelOffset?: number,
 	axisTextStyle?: IStyle,
 	tickLabelPixelOffset?: number,
-	tickTextStyle?: IStyle
+	tickTextStyle?: IStyle,
+	drawNanAnnotation?: boolean,
+	drawBelowRangeSwatch?: boolean,
+	drawAboveRangeSwatch?: boolean,
 }
 
 export interface vtkScalarBarActor extends vtkActor {
@@ -135,6 +138,21 @@ export interface vtkScalarBarActor extends vtkActor {
 	 */
 	getScalarsToColors(): vtkScalarsToColors;
 
+	/**
+	 *
+	 */
+	getDrawNanAnnotation(): boolean
+
+	/**
+	 *
+	 */
+	getDrawBelowRangeSwatch(): boolean
+
+	/**
+	 *
+	 */
+	getDrawAboveRangeSwatch(): boolean
+
 	/**
 	 * 
 	 */
@@ -212,8 +230,26 @@ export interface vtkScalarBarActor extends vtkActor {
 	setScalarsToColors(scalarsToColors: vtkScalarsToColors): boolean;
 
 	/**
-	 * 
-	 * @param tickLabelPixelOffset 
+	 * Set whether the NaN annotation should be rendered or not.
+	 * @param {Boolean} drawNanAnnotation
+	 */
+	 setDrawNanAnnotation(drawNanAnnotation: boolean): boolean;
+
+	/**
+	 * Set whether the Below range swatch should be rendered or not
+	 * @param {Boolean} drawBelowRangeSwatch
+	 */
+	setDrawBelowRangeSwatch(drawBelowRangeSwatch: boolean): boolean;
+
+	/**
+	 * Set whether the Above range swatch should be rendered or not
+	 * @param {Boolean} drawAboveRangeSwatch
+	 */
+	setDrawAboveRangeSwatch(drawAboveRangeSwatch: boolean): boolean;
+
+	/**
+	 *
+	 * @param tickLabelPixelOffset
 	 */
 	setTickLabelPixelOffset(tickLabelPixelOffset: number): boolean;
 

package/Rendering/Core/ScalarBarActor.js

@@ -319,6 +319,8 @@ function vtkScalarBarActor(publicAPI, model) {
 
 
   publicAPI.recomputeBarSegments = function (textSizes) {
+    var _model$scalarsToColor, _model$scalarsToColor2, _model$scalarsToColor3, _model$scalarsToColor4;
+
     // first compute the barSize/Position
     var segSize = publicAPI.computeBarSize(textSizes);
     model.barSegments = [];
@@ -337,22 +339,22 @@ function vtkScalarBarActor(publicAPI, model) {
       startPos[barAxis] += segSize[barAxis] + segSpace;
     }
 
-    if (typeof model.scalarsToColors.getNanColor === 'function') {
+    if (model.drawNanAnnotation && model.scalarsToColors.getNanColor) {
       pushSeg('NaN', [NaN, NaN, NaN, NaN]);
     }
 
-    if (typeof model.scalarsToColors.getUseBelowRangeColor === 'function' && model.scalarsToColors.getUseBelowRangeColor()) {
+    if (model.drawBelowRangeSwatch && (_model$scalarsToColor = (_model$scalarsToColor2 = model.scalarsToColors).getUseBelowRangeColor) !== null && _model$scalarsToColor !== void 0 && _model$scalarsToColor.call(_model$scalarsToColor2)) {
       pushSeg('Below', [-0.1, -0.1, -0.1, -0.1]);
     }
 
-    var haveAbove = typeof model.scalarsToColors.getUseAboveRangeColor === 'function' && model.scalarsToColors.getUseAboveRangeColor(); // extra space around the ticks section
+    var haveAbove = (_model$scalarsToColor3 = (_model$scalarsToColor4 = model.scalarsToColors).getUseAboveRangeColor) === null || _model$scalarsToColor3 === void 0 ? void 0 : _model$scalarsToColor3.call(_model$scalarsToColor4); // extra space around the ticks section
 
     startPos[barAxis] += segSpace;
     var oldSegSize = segSize[barAxis];
     segSize[barAxis] = haveAbove ? 1.0 - 2.0 * segSpace - segSize[barAxis] - startPos[barAxis] : 1.0 - segSpace - startPos[barAxis];
     pushSeg('ticks', model.vertical ? [0, 0, 0.995, 0.995] : [0, 0.995, 0.995, 0]);
 
-    if (haveAbove) {
+    if (model.drawAboveRangeSwatch && haveAbove) {
       segSize[barAxis] = oldSegSize;
       startPos[barAxis] += segSpace;
       pushSeg('Above', [1.1, 1.1, 1.1, 1.1]);
@@ -551,11 +553,26 @@ function vtkScalarBarActor(publicAPI, model) {
   };
 
   publicAPI.updatePolyDataForBarSegments = function () {
+    var _model$scalarsToColor5, _model$scalarsToColor6, _model$scalarsToColor7, _model$scalarsToColor8;
+
     var cmat = model.camera.getCompositeProjectionMatrix(model.lastAspectRatio, -1, 1);
     mat4.transpose(cmat, cmat);
     mat4.invert(invmat, cmat);
-    var haveExtraColors = typeof model.scalarsToColors.getNanColor === 'function' && typeof model.scalarsToColors.getAboveRangeColor === 'function' && typeof model.scalarsToColors.getBelowRangeColor === 'function';
-    var numPts = 4 + (haveExtraColors ? 12 : 0);
+    var numberOfExtraColors = 0;
+
+    if (model.drawNanAnnotation && model.scalarsToColors.getNanColor) {
+      numberOfExtraColors += 1;
+    }
+
+    if (model.drawBelowRangeSwatch && (_model$scalarsToColor5 = (_model$scalarsToColor6 = model.scalarsToColors).getUseBelowRangeColor) !== null && _model$scalarsToColor5 !== void 0 && _model$scalarsToColor5.call(_model$scalarsToColor6)) {
+      numberOfExtraColors += 1;
+    }
+
+    if (model.drawAboveRangeSwatch && (_model$scalarsToColor7 = (_model$scalarsToColor8 = model.scalarsToColors).getUseAboveRangeColor) !== null && _model$scalarsToColor7 !== void 0 && _model$scalarsToColor7.call(_model$scalarsToColor8)) {
+      numberOfExtraColors += 1;
+    }
+
+    var numPts = 4 * (1 + numberOfExtraColors);
     var numQuads = numPts; // handle vector component mode
 
     var numComps = 1;
@@ -667,7 +684,10 @@ function defaultValues(initialValues) {
       fontStyle: 'normal',
       fontSize: 14,
       fontFamily: 'serif'
-    }
+    },
+    drawNanAnnotation: true,
+    drawBelowRangeSwatch: true,
+    drawAboveRangeSwatch: true
   }, initialValues);
 } // ----------------------------------------------------------------------------
 
@@ -738,7 +758,7 @@ function extend(publicAPI, model) {
 
     publicAPI.update();
   });
-  macro.setGet(publicAPI, model, ['automated', 'autoLayout', 'axisTitlePixelOffset', 'axisLabel', 'scalarsToColors', 'tickLabelPixelOffset']);
+  macro.setGet(publicAPI, model, ['automated', 'autoLayout', 'axisTitlePixelOffset', 'axisLabel', 'scalarsToColors', 'tickLabelPixelOffset', 'drawNanAnnotation', 'drawBelowRangeSwatch', 'drawAboveRangeSwatch']);
   macro.get(publicAPI, model, ['axisTextStyle', 'tickTextStyle']);
   macro.getArray(publicAPI, model, ['boxPosition', 'boxSize']);
   macro.setArray(publicAPI, model, ['boxPosition', 'boxSize'], 2); // Object methods

package/Rendering/Misc/SynchronizableRenderWindow.d.ts

@@ -0,0 +1,73 @@
+import { vtkRenderWindow, IRenderWindowInitialValues } from '@kitware/vtk.js/Rendering/Rendering/Core/RenderWindow';
+
+// Keeps state for client / server scene synchronization.
+export interface SynchContext {
+    // Set a function that fetches the data array for the given object.
+    setFetchArrayFunction(fetcher: (hash: string, dataType: any) => Promise<ArrayBuffer>): void;
+    // Invokes the fetcher registered by setFetchArrayFunction.
+    getArray(sha: string, dataType: any, context: SynchContext): Promise<ArrayBuffer>;
+    emptyCachedArrays(): void;
+    freeOldArrays(threshold: number, context: SynchContext): void;
+
+    // instanceMap
+    getInstance(id: any): any;
+    getInstanceId(instance: any): any | null;
+    registerInstance(id: any, instance: any): void;
+    unregister(id: any): void;
+    emptyCachedInstances(): void;
+
+    // sceneMtimeHandler
+    getMtime(): number;
+    incrementMtime(viewId: string): number;
+    setActiveViewId(viewId: string): void;
+    getActiveViewId(): string;
+
+    // TODO: fill progresshandler
+}
+
+export interface IInitialValues extends IRenderWindowInitialValues {
+  synchronizerContextName?: string; // default: 'default':
+  synchronizerContext?: SynchContext | null;
+  synchronizedViewId?: string | null;
+}
+
+// Server-side view state.
+export interface ViewState {
+  id: ViewId;
+  // vtk object type.
+  type: string;
+  // vtk object mtime.
+  mtime: number;
+  // ID of the parent. Null for the root.
+  parent?: string | null;
+  properties?: {[key: string]: any};
+  // Child objects.
+  dependencies?: ViewState[];
+  extra?: any;
+  // List of [methodName, args] to be invoked on the object.
+  calls?: [string, string[]][];
+  // ViewState may contain other arbitrary key / value pairs.
+  [key: string]: any;
+}
+
+export interface vtkSynchronizableRenderWindowInstance extends vtkRenderWindow {
+  getSynchronizerContext(): SynchContext;
+
+  // methods added by createSyncFunction
+  synchronize(state: ViewState): Promise<boolean>;
+  setSynchronizedViewId(viewId: string): void;
+  getSynchronizedViewId(): string;
+  updateGarbageCollectorThreshold(v: number): void;
+  getManagedInstanceIds(): Array<string>;
+  clearOneTimeUpdaters(): void;
+}
+
+export function newInstance(props: IInitialValues): vtkSynchronizableRenderWindowInstance;
+export function getSynchronizerContext(name?: string): SynchContext;
+
+export const vtkSynchronizableRenderWindow: {
+  newInstance: typeof newInstance;
+  getSynchronizerContext: typeof getSynchronizerContext;
+};
+
+export default vtkSynchronizableRenderWindow;

package/Rendering/OpenGL/RenderWindow.d.ts

@@ -3,6 +3,7 @@ import { Size, Vector2, Vector3 } from '@kitware/vtk.js/types';
 import { vtkRenderer } from '@kitware/vtk.js/Rendering/Core/Renderer';
 import { VtkDataTypes } from '@kitware/vtk.js/Common/Core/DataArray';
 import vtkTexture from '@kitware/vtk.js/Rendering/Core/Texture';
+import vtkViewStream from '@kitware/vtk.js/IO/Core/ImageStream/ViewStream';
 
 /**
  *
@@ -18,7 +19,7 @@ export interface IOptions {
 	resetCamera: boolean,
 	size: Size,
 	scale: number
-} 
+}
 
 type vtkOpenGLRenderWindowBase = vtkObject & Omit<vtkAlgorithm,
 	| 'getInputData'
@@ -32,7 +33,7 @@ export interface vtkOpenGLRenderWindow extends vtkOpenGLRenderWindowBase {
 
 	/**
 	 * Builds myself.
-	 * @param {Boolean} prepass 
+	 * @param {Boolean} prepass
 	 */
 	buildPass(prepass: boolean): void;
 
@@ -45,12 +46,12 @@ export interface vtkOpenGLRenderWindow extends vtkOpenGLRenderWindowBase {
 	initialize(): void;
 
 	/**
-	 * 
+	 *
 	 */
 	makeCurrent(): void;
 
 	/**
-	 * 
+	 *
 	 * @param {HTMLElement} el The container element.
 	 */
 	setContainer(el: HTMLElement): void;
@@ -91,170 +92,170 @@ export interface vtkOpenGLRenderWindow extends vtkOpenGLRenderWindowBase {
 	getViewportCenter(viewport: vtkRenderer): Vector2;
 
 	/**
-	 * 
-	 * @param {Number} x 
-	 * @param {Number} y 
-	 * @param {Number} z 
+	 *
+	 * @param {Number} x
+	 * @param {Number} y
+	 * @param {Number} z
 	 */
 	displayToNormalizedDisplay(x: number, y: number, z: number): Vector3;
 
 	/**
-	 * 
-	 * @param {Number} x 
-	 * @param {Number} y 
-	 * @param {Number} z 
+	 *
+	 * @param {Number} x
+	 * @param {Number} y
+	 * @param {Number} z
 	 */
 	normalizedDisplayToDisplay(x: number, y: number, z: number): Vector3;
 
 	/**
-	 * 
-	 * @param {Number} x 
-	 * @param {Number} y 
-	 * @param {Number} z 
-	 * @param {vtkRenderer} renderer 
+	 *
+	 * @param {Number} x
+	 * @param {Number} y
+	 * @param {Number} z
+	 * @param {vtkRenderer} renderer
 	 */
 	worldToView(x: number, y: number, z: number, renderer: vtkRenderer): Vector3;
 
 	/**
-	 * 
-	 * @param {Number} x 
-	 * @param {Number} y 
-	 * @param {Number} z 
-	 * @param {vtkRenderer} renderer 
+	 *
+	 * @param {Number} x
+	 * @param {Number} y
+	 * @param {Number} z
+	 * @param {vtkRenderer} renderer
 	 */
 	viewToWorld(x: number, y: number, z: number, renderer: vtkRenderer): Vector3;
 
 	/**
-	 * 
-	 * @param {Number} x 
-	 * @param {Number} y 
-	 * @param {Number} z 
-	 * @param {vtkRenderer} renderer 
+	 *
+	 * @param {Number} x
+	 * @param {Number} y
+	 * @param {Number} z
+	 * @param {vtkRenderer} renderer
 	 */
 	worldToDisplay(x: number, y: number, z: number, renderer: vtkRenderer): Vector3;
 
 	/**
-	 * 
-	 * @param {Number} x 
-	 * @param {Number} y 
-	 * @param {Number} z 
-	 * @param {vtkRenderer} renderer 
+	 *
+	 * @param {Number} x
+	 * @param {Number} y
+	 * @param {Number} z
+	 * @param {vtkRenderer} renderer
 	 */
 	displayToWorld(x: number, y: number, z: number, renderer: vtkRenderer): Vector3;
 
 	/**
-	 * 
-	 * @param {Number} x 
-	 * @param {Number} y 
-	 * @param {Number} z 
-	 * @param {vtkRenderer} renderer 
+	 *
+	 * @param {Number} x
+	 * @param {Number} y
+	 * @param {Number} z
+	 * @param {vtkRenderer} renderer
 	 */
 	normalizedDisplayToViewport(x: number, y: number, z: number, renderer: vtkRenderer): Vector3;
 
 	/**
-	 * 
-	 * @param {Number} x 
-	 * @param {Number} y 
-	 * @param {Number} z 
-	 * @param {vtkRenderer} renderer 
+	 *
+	 * @param {Number} x
+	 * @param {Number} y
+	 * @param {Number} z
+	 * @param {vtkRenderer} renderer
 	 */
 	viewportToNormalizedViewport(x: number, y: number, z: number, renderer: vtkRenderer): Vector3;
 
 	/**
-	 * 
-	 * @param {Number} x 
-	 * @param {Number} y 
-	 * @param {Number} z 
+	 *
+	 * @param {Number} x
+	 * @param {Number} y
+	 * @param {Number} z
 	 */
 	normalizedViewportToViewport(x: number, y: number, z: number): Vector3;
 
 	/**
-	 * 
-	 * @param {Number} x 
-	 * @param {Number} y 
-	 * @param {Number} z 
+	 *
+	 * @param {Number} x
+	 * @param {Number} y
+	 * @param {Number} z
 	 */
 	displayToLocalDisplay(x: number, y: number, z: number): Vector3;
 
 	/**
-	 * 
-	 * @param {Number} x 
-	 * @param {Number} y 
-	 * @param {Number} z 
-	 * @param {vtkRenderer} renderer 
+	 *
+	 * @param {Number} x
+	 * @param {Number} y
+	 * @param {Number} z
+	 * @param {vtkRenderer} renderer
 	 */
 	viewportToNormalizedDisplay(x: number, y: number, z: number, renderer: vtkRenderer): Vector3;
 
 	/**
-	 * 
-	 * @param {Number} x1 
-	 * @param {Number} y1 
-	 * @param {Number} x2 
-	 * @param {Number} y2 
+	 *
+	 * @param {Number} x1
+	 * @param {Number} y1
+	 * @param {Number} x2
+	 * @param {Number} y2
 	 */
 	getPixelData(x1: number, y1: number, x2: number, y2: number): Uint8Array;
 
 	/**
-	 * 
-	 * @param options 
+	 *
+	 * @param options
 	 */
 	get3DContext(options: object): WebGLRenderingContext | null;
 
 	/**
-	 * 
+	 *
 	 */
 	startVR(): void;
 
 	/**
-	 * 
+	 *
 	 */
 	stopVR(): void;
 
 	/**
-	 * 
+	 *
 	 */
 	vrRender(): void;
 
 	/**
-	 * 
+	 *
 	 */
 	restoreContext(): void;
 
 	/**
-	 * 
-	 * @param {vtkTexture} texture 
+	 *
+	 * @param {vtkTexture} texture
 	 */
 	activateTexture(texture: vtkTexture): void;
 
 	/**
-	 * 
-	 * @param {vtkTexture} texture 
+	 *
+	 * @param {vtkTexture} texture
 	 */
 	deactivateTexture(texture: vtkTexture): void;
 
 	/**
-	 * 
-	 * @param {vtkTexture} texture 
+	 *
+	 * @param {vtkTexture} texture
 	 */
 	getTextureUnitForTexture(texture: vtkTexture): number;
 
 	/**
-	 * 
-	 * @param vtktype 
-	 * @param numComps 
-	 * @param useFloat 
+	 *
+	 * @param vtktype
+	 * @param numComps
+	 * @param useFloat
 	 */
 	getDefaultTextureInternalFormat(vtktype: VtkDataTypes, numComps: number, useFloat: boolean): void;
 
 	/**
-	 * 
-	 * @param {HTMLImageElement} img 
+	 *
+	 * @param {HTMLImageElement} img
 	 */
 	setBackgroundImage(img: HTMLImageElement): void;
 
 	/**
-	 * 
-	 * @param {Boolean} value 
+	 *
+	 * @param {Boolean} value
 	 */
 	setUseBackgroundImage(value: boolean): void;
 
@@ -269,70 +270,70 @@ export interface vtkOpenGLRenderWindow extends vtkOpenGLRenderWindowBase {
 	 * size.  If no `size` or `scale` are provided, the current renderwindow
 	 * size is assumed.  The default format is "image/png". Returns a promise
 	 * that resolves to the captured screenshot.
-	 * @param {String} format 
-	 * @param {IOptions} options 
+	 * @param {String} format
+	 * @param {IOptions} options
 	 */
 	captureNextImage(format: string, options: IOptions): Promise<string> | null;
 
 	/**
-	 * 
+	 *
 	 */
 	getGLInformations(): object;
 
 	/**
-	 * 
+	 *
 	 */
 	traverseAllPasses(): void;
 
 	/**
-	 * 
+	 *
 	 */
 	disableCullFace(): void;
 
 	/**
-	 * 
+	 *
 	 */
 	enableCullFace(): void;
 
 	/**
-	 * 
-	 * @param stream 
+	 *
+	 * @param stream
 	 */
-	setViewStream(stream: any): boolean;
+	setViewStream(stream: vtkViewStream): boolean;
 
 	/**
-	 * 
-	 * @param {Vector2} size 
+	 *
+	 * @param {Vector2} size
 	 */
 	setSize(size: Vector2): void;
 
 	/**
-	 * 
-	 * @param {Number} x 
-	 * @param {Number} y 
+	 *
+	 * @param {Number} x
+	 * @param {Number} y
 	 */
 	setSize(x: number, y: number): void;
 
 	/**
-	 * 
+	 *
 	 */
 	getSize(): Vector2;
 
 	/**
-	 * 
-	 * @param {Vector2} size 
+	 *
+	 * @param {Vector2} size
 	 */
 	setVrResolution(size: Vector2): void;
 
 	/**
-	 * 
-	 * @param {Number} x 
-	 * @param {Number} y  
+	 *
+	 * @param {Number} x
+	 * @param {Number} y
 	 */
 	setVrResolution(x: number, y: number): void;
 
 	/**
-	 * 
+	 *
 	 */
 	getVrResolution(): Vector2;
 }
@@ -353,20 +354,20 @@ export function extend(publicAPI: object, model: object, initialValues?: IOpenGL
 export function newInstance(initialValues?: IOpenGLRenderWindowInitialValues): vtkOpenGLRenderWindow;
 
 /**
- * 
- * @param cb 
+ *
+ * @param cb
  */
 export function pushMonitorGLContextCount(cb: any): void;
 
 /**
- * 
- * @param cb 
+ *
+ * @param cb
  */
 export function popMonitorGLContextCount(cb: any): void;
 
 /**
  * WebGL rendering window
- * 
+ *
  * vtkOpenGLRenderWindow is designed to view/render a vtkRenderWindow.
  */
 export declare const vtkOpenGLRenderWindow: {

package/package.json

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