@kitware/vtk.js 26.0.0-beta.1 → 26.0.0-beta.2

package/Widgets/Core/WidgetManager.js

@@ -4,19 +4,14 @@ import _regeneratorRuntime from '@babel/runtime/regenerator';
 import { r as radiansFromDegrees } from '../../Common/Core/Math/index.js';
 import { FieldAssociations } from '../../Common/DataModel/DataSet/Constants.js';
 import macro from '../../macros.js';
-import vtkSelectionNode from '../../Common/DataModel/SelectionNode.js';
 import WidgetManagerConst from './WidgetManager/Constants.js';
-import vtkSVGRepresentation from '../SVG/SVGRepresentation.js';
 import { WIDGET_PRIORITY } from './AbstractWidget/Constants.js';
-import { diff } from './WidgetManager/vdom.js';
 
 var ViewTypes = WidgetManagerConst.ViewTypes,
     RenderingTypes = WidgetManagerConst.RenderingTypes,
     CaptureOn = WidgetManagerConst.CaptureOn;
 var vtkErrorMacro = macro.vtkErrorMacro,
     vtkWarningMacro = macro.vtkWarningMacro;
-var createSvgElement = vtkSVGRepresentation.createSvgElement,
-    createSvgDomElement = vtkSVGRepresentation.createSvgDomElement;
 var viewIdCount = 1; // ----------------------------------------------------------------------------
 // Helper
 // ----------------------------------------------------------------------------
@@ -34,17 +29,9 @@ function extractRenderingComponents(renderer) {
     camera: camera
   };
 } // ----------------------------------------------------------------------------
-
-function createSvgRoot(id) {
-  var svgRoot = createSvgDomElement('svg');
-  svgRoot.setAttribute('version', '1.1');
-  svgRoot.setAttribute('baseProfile', 'full');
-  return svgRoot;
-} // ----------------------------------------------------------------------------
 // vtkWidgetManager methods
 // ----------------------------------------------------------------------------
 
-
 function vtkWidgetManager(publicAPI, model) {
   if (!model.viewId) {
     model.viewId = "view-".concat(viewIdCount++);
@@ -52,13 +39,7 @@ function vtkWidgetManager(publicAPI, model) {
 
   model.classHierarchy.push('vtkWidgetManager');
   var propsWeakMap = new WeakMap();
-  var widgetToSvgMap = new WeakMap();
-  var svgVTrees = new WeakMap();
   var subscriptions = []; // --------------------------------------------------------------------------
-  // Internal variable
-  // --------------------------------------------------------------------------
-
-  model.svgRoot = createSvgRoot(model.viewId); // --------------------------------------------------------------------------
   // API internal
   // --------------------------------------------------------------------------
 
@@ -85,142 +66,6 @@ function vtkWidgetManager(publicAPI, model) {
       viewId: model.viewId
     }));
   } // --------------------------------------------------------------------------
-  // internal SVG API
-  // --------------------------------------------------------------------------
-
-
-  var pendingSvgRenders = new WeakMap();
-
-  function enableSvgLayer() {
-    var container = model._apiSpecificRenderWindow.getReferenceByName('el');
-
-    var canvas = model._apiSpecificRenderWindow.getCanvas();
-
-    container.insertBefore(model.svgRoot, canvas.nextSibling);
-    var containerStyles = window.getComputedStyle(container);
-
-    if (containerStyles.position === 'static') {
-      container.style.position = 'relative';
-    }
-  }
-
-  function disableSvgLayer() {
-    var container = model._apiSpecificRenderWindow.getReferenceByName('el');
-
-    container.removeChild(model.svgRoot);
-  }
-
-  function removeFromSvgLayer(viewWidget) {
-    var group = widgetToSvgMap.get(viewWidget);
-
-    if (group) {
-      widgetToSvgMap.delete(viewWidget);
-      svgVTrees.delete(viewWidget);
-      model.svgRoot.removeChild(group);
-    }
-  }
-
-  function setSvgSize() {
-    var _model$_apiSpecificRe = model._apiSpecificRenderWindow.getViewportSize(model._renderer),
-        _model$_apiSpecificRe2 = _slicedToArray(_model$_apiSpecificRe, 2),
-        cwidth = _model$_apiSpecificRe2[0],
-        cheight = _model$_apiSpecificRe2[1];
-
-    var ratio = window.devicePixelRatio || 1;
-    var bwidth = String(cwidth / ratio);
-    var bheight = String(cheight / ratio);
-    var viewBox = "0 0 ".concat(cwidth, " ").concat(cheight);
-    var origWidth = model.svgRoot.getAttribute('width');
-    var origHeight = model.svgRoot.getAttribute('height');
-    var origViewBox = model.svgRoot.getAttribute('viewBox');
-
-    if (origWidth !== bwidth) {
-      model.svgRoot.setAttribute('width', bwidth);
-    }
-
-    if (origHeight !== bheight) {
-      model.svgRoot.setAttribute('height', bheight);
-    }
-
-    if (origViewBox !== viewBox) {
-      model.svgRoot.setAttribute('viewBox', viewBox);
-    }
-  }
-
-  function setSvgRootStyle() {
-    var viewport = model._renderer.getViewport().map(function (v) {
-      return v * 100;
-    });
-
-    model.svgRoot.setAttribute('style', "position: absolute; left: ".concat(viewport[0], "%; top: ").concat(100 - viewport[3], "%; width: ").concat(viewport[2] - viewport[0], "%; height: ").concat(viewport[3] - viewport[1], "%;"));
-  }
-
-  function updateSvg() {
-    if (model.useSvgLayer) {
-      var _loop = function _loop(i) {
-        var widget = model.widgets[i];
-        var svgReps = widget.getRepresentations().filter(function (r) {
-          return r.isA('vtkSVGRepresentation');
-        });
-        var pendingContent = [];
-
-        if (widget.getVisibility()) {
-          pendingContent = svgReps.filter(function (r) {
-            return r.getVisibility();
-          }).map(function (r) {
-            return r.render();
-          });
-        }
-
-        var promise = Promise.all(pendingContent);
-        var renders = pendingSvgRenders.get(widget) || [];
-        renders.push(promise);
-        pendingSvgRenders.set(widget, renders);
-        promise.then(function (vnodes) {
-          var pendingRenders = pendingSvgRenders.get(widget) || [];
-          var idx = pendingRenders.indexOf(promise);
-
-          if (model.deleted || widget.isDeleted() || idx === -1) {
-            return;
-          } // throw away previous renders
-
-
-          pendingRenders = pendingRenders.slice(idx + 1);
-          pendingSvgRenders.set(widget, pendingRenders);
-          var oldVTree = svgVTrees.get(widget);
-          var newVTree = createSvgElement('g');
-
-          for (var ni = 0; ni < vnodes.length; ni++) {
-            newVTree.appendChild(vnodes[ni]);
-          }
-
-          var widgetGroup = widgetToSvgMap.get(widget);
-          var node = widgetGroup;
-          var patchFns = diff(oldVTree, newVTree);
-
-          for (var j = 0; j < patchFns.length; j++) {
-            node = patchFns[j](node);
-          }
-
-          if (!widgetGroup && node) {
-            // add
-            model.svgRoot.appendChild(node);
-            widgetToSvgMap.set(widget, node);
-          } else if (widgetGroup && !node) {
-            // delete
-            widgetGroup.remove();
-            widgetToSvgMap.delete(widget);
-          }
-
-          svgVTrees.set(widget, newVTree);
-        });
-      };
-
-      for (var i = 0; i < model.widgets.length; i++) {
-        _loop(i);
-      }
-    }
-  } // --------------------------------------------------------------------------
   // Widget scaling
   // --------------------------------------------------------------------------
 
@@ -451,10 +296,10 @@ function vtkWidgetManager(publicAPI, model) {
 
   publicAPI.renderWidgets = function () {
     if (model.pickingEnabled && model.captureOn === CaptureOn.MOUSE_RELEASE) {
-      var _model$_apiSpecificRe3 = model._apiSpecificRenderWindow.getSize(),
-          _model$_apiSpecificRe4 = _slicedToArray(_model$_apiSpecificRe3, 2),
-          w = _model$_apiSpecificRe4[0],
-          h = _model$_apiSpecificRe4[1];
+      var _model$_apiSpecificRe = model._apiSpecificRenderWindow.getSize(),
+          _model$_apiSpecificRe2 = _slicedToArray(_model$_apiSpecificRe, 2),
+          w = _model$_apiSpecificRe2[0],
+          h = _model$_apiSpecificRe2[1];
 
       captureBuffers(0, 0, w, h);
     }
@@ -480,11 +325,6 @@ function vtkWidgetManager(publicAPI, model) {
 
     model._selector.setFieldAssociation(FieldAssociations.FIELD_ASSOCIATION_POINTS);
 
-    subscriptions.push(model._interactor.onRenderEvent(updateSvg));
-    subscriptions.push(renderer.onModified(setSvgRootStyle));
-    setSvgRootStyle();
-    subscriptions.push(model._apiSpecificRenderWindow.onModified(setSvgSize));
-    setSvgSize();
     subscriptions.push(model._apiSpecificRenderWindow.onModified(updateDisplayScaleParams));
     subscriptions.push(model._camera.onModified(updateDisplayScaleParams));
     updateDisplayScaleParams();
@@ -515,10 +355,6 @@ function vtkWidgetManager(publicAPI, model) {
     if (model.pickingEnabled) {
       publicAPI.enablePicking();
     }
-
-    if (model.useSvgLayer) {
-      enableSvgLayer();
-    }
   };
 
   function addWidgetInternal(viewWidget) {
@@ -556,7 +392,6 @@ function vtkWidgetManager(publicAPI, model) {
   function removeWidgetInternal(viewWidget) {
     model._renderer.removeActor(viewWidget);
 
-    removeFromSvgLayer(viewWidget);
     viewWidget.delete();
   }
 
@@ -592,7 +427,7 @@ function vtkWidgetManager(publicAPI, model) {
 
   publicAPI.getSelectedDataForXY = /*#__PURE__*/function () {
     var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(x, y) {
-      var i, widget, hoveredSVGReps, selection, capturedRegion;
+      var capturedRegion;
       return _regeneratorRuntime.wrap(function _callee2$(_context2) {
         while (1) {
           switch (_context2.prev = _context2.next) {
@@ -600,68 +435,37 @@ function vtkWidgetManager(publicAPI, model) {
               model.selections = null;
 
               if (!model.pickingEnabled) {
-                _context2.next = 24;
-                break;
-              }
-
-              i = 0;
-
-            case 3:
-              if (!(i < model.widgets.length)) {
-                _context2.next = 16;
+                _context2.next = 10;
                 break;
               }
 
-              widget = model.widgets[i];
-              hoveredSVGReps = widget.getRepresentations().filter(function (r) {
-                return r.isA('vtkSVGRepresentation') && r.getHover() != null;
-              });
-
-              if (!hoveredSVGReps.length) {
-                _context2.next = 13;
-                break;
-              }
-
-              selection = vtkSelectionNode.newInstance();
-              selection.getProperties().compositeID = hoveredSVGReps[0].getHover();
-              selection.getProperties().widget = widget;
-              selection.getProperties().representation = hoveredSVGReps[0];
-              model.selections = [selection];
-              return _context2.abrupt("return", publicAPI.getSelectedData());
-
-            case 13:
-              ++i;
-              _context2.next = 3;
-              break;
-
-            case 16:
               if (!(!model._capturedBuffers || model.captureOn === CaptureOn.MOUSE_MOVE)) {
-                _context2.next = 19;
+                _context2.next = 5;
                 break;
               }
 
-              _context2.next = 19;
+              _context2.next = 5;
               return captureBuffers(x, y, x, y);
 
-            case 19:
+            case 5:
               // or do we need a pixel that is outside the last capture?
               capturedRegion = model._capturedBuffers.area;
 
               if (!(x < capturedRegion[0] || x > capturedRegion[2] || y < capturedRegion[1] || y > capturedRegion[3])) {
-                _context2.next = 23;
+                _context2.next = 9;
                 break;
               }
 
-              _context2.next = 23;
+              _context2.next = 9;
               return captureBuffers(x, y, x, y);
 
-            case 23:
+            case 9:
               model.selections = model._capturedBuffers.generateSelection(x, y, x, y);
 
-            case 24:
+            case 10:
               return _context2.abrupt("return", publicAPI.getSelectedData());
 
-            case 25:
+            case 11:
             case "end":
               return _context2.stop();
           }
@@ -678,24 +482,7 @@ function vtkWidgetManager(publicAPI, model) {
     vtkWarningMacro('updateSelectionFromXY is deprecated, please use getSelectedDataForXY');
 
     if (model.pickingEnabled) {
-      // First pick SVG representation
-      for (var i = 0; i < model.widgets.length; ++i) {
-        var widget = model.widgets[i];
-        var hoveredSVGReps = widget.getRepresentations().filter(function (r) {
-          return r.isA('vtkSVGRepresentation') && r.getHover() != null;
-        });
-
-        if (hoveredSVGReps.length) {
-          var selection = vtkSelectionNode.newInstance();
-          selection.getProperties().compositeID = hoveredSVGReps[0].getHover();
-          selection.getProperties().widget = widget;
-          selection.getProperties().representation = hoveredSVGReps[0];
-          model.selections = [selection];
-          return;
-        }
-      } // Then pick regular representations.
-
-
+      // Then pick regular representations.
       if (model.captureOn === CaptureOn.MOUSE_MOVE) {
         captureBuffers(x, y, x, y);
       }
@@ -707,10 +494,10 @@ function vtkWidgetManager(publicAPI, model) {
     var pageX = event.pageX,
         pageY = event.pageY;
 
-    var _model$_apiSpecificRe5 = model._apiSpecificRenderWindow.getCanvas().getBoundingClientRect(),
-        top = _model$_apiSpecificRe5.top,
-        left = _model$_apiSpecificRe5.left,
-        height = _model$_apiSpecificRe5.height;
+    var _model$_apiSpecificRe3 = model._apiSpecificRenderWindow.getCanvas().getBoundingClientRect(),
+        top = _model$_apiSpecificRe3.top,
+        left = _model$_apiSpecificRe3.left,
+        height = _model$_apiSpecificRe3.height;
 
     var x = pageX - left;
     var y = height - (pageY - top);
@@ -730,8 +517,7 @@ function vtkWidgetManager(publicAPI, model) {
 
     var _model$selections$0$g2 = model.selections[0].getProperties(),
         widget = _model$selections$0$g2.widget,
-        representation = _model$selections$0$g2.representation; // prop is undefined for SVG representation, widget is undefined for handle
-    // representation.
+        representation = _model$selections$0$g2.representation; // widget is undefined for handle representation.
 
 
     if (model.previousSelectedData && model.previousSelectedData.prop === prop && model.previousSelectedData.widget === widget && model.previousSelectedData.compositeID === compositeID) {
@@ -781,26 +567,6 @@ function vtkWidgetManager(publicAPI, model) {
     return publicAPI.grabFocus(null);
   };
 
-  publicAPI.setUseSvgLayer = function (useSvgLayer) {
-    if (useSvgLayer !== model.useSvgLayer) {
-      model.useSvgLayer = useSvgLayer;
-
-      if (model._renderer) {
-        if (useSvgLayer) {
-          enableSvgLayer(); // force a render so svg widgets can be drawn
-
-          updateSvg();
-        } else {
-          disableSvgLayer();
-        }
-      }
-
-      return true;
-    }
-
-    return false;
-  };
-
   var superDelete = publicAPI.delete;
 
   publicAPI.delete = function () {
@@ -828,7 +594,6 @@ var DEFAULT_VALUES = {
   selections: null,
   previousSelectedData: null,
   widgetInFocus: null,
-  useSvgLayer: true,
   captureOn: CaptureOn.MOUSE_MOVE
 }; // ----------------------------------------------------------------------------
 
@@ -841,7 +606,7 @@ function extend(publicAPI, model) {
     name: 'viewType',
     enum: ViewTypes
   }]);
-  macro.get(publicAPI, model, ['selections', 'widgets', 'viewId', 'pickingEnabled', 'useSvgLayer']); // Object specific methods
+  macro.get(publicAPI, model, ['selections', 'widgets', 'viewId', 'pickingEnabled']); // Object specific methods
 
   vtkWidgetManager(publicAPI, model);
 } // ----------------------------------------------------------------------------

package/Widgets/Widgets3D/EllipseWidget.js

@@ -5,7 +5,6 @@ import vtkCircleContextRepresentation from '../Representations/CircleContextRepr
 import vtkPlanePointManipulator from '../Manipulators/PlaneManipulator.js';
 import vtkShapeWidget from './ShapeWidget.js';
 import vtkSphereHandleRepresentation from '../Representations/SphereHandleRepresentation.js';
-import vtkSVGLandmarkRepresentation from '../SVG/SVGLandmarkRepresentation.js';
 import widgetBehavior from './EllipseWidget/behavior.js';
 import generateState from './EllipseWidget/state.js';
 import { BehaviorCategory, ShapeBehavior } from './ShapeWidget/Constants.js';
@@ -35,12 +34,6 @@ function vtkEllipseWidget(publicAPI, model) {
         }, {
           builder: vtkCircleContextRepresentation,
           labels: ['ellipseHandle']
-        }, {
-          builder: vtkSVGLandmarkRepresentation,
-          initialValues: {
-            text: ''
-          },
-          labels: ['SVGtext']
         }];
     }
   }; // --------------------------------------------------------------------------

package/Widgets/Widgets3D/LabelWidget/behavior.js

@@ -1,9 +1,5 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import macro from '../../../macros.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; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 function widgetBehavior(publicAPI, model) {
   model.classHierarchy.push('vtkLabelWidgetProp');
   model._isDragging = false; // --------------------------------------------------------------------------
@@ -12,9 +8,6 @@ function widgetBehavior(publicAPI, model) {
 
   publicAPI.setText = function (text) {
     model.widgetState.getText().setText(text);
-    model.representations[1].setCircleProps(_objectSpread(_objectSpread({}, model.representations[1].getCircleProps()), {}, {
-      visible: !text
-    }));
 
     model._interactor.render();
   };

package/Widgets/Widgets3D/LabelWidget.js

@@ -2,11 +2,9 @@ import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import macro from '../../macros.js';
 import vtkAbstractWidgetFactory from '../Core/AbstractWidgetFactory.js';
 import vtkSphereHandleRepresentation from '../Representations/SphereHandleRepresentation.js';
-import vtkSVGLandmarkRepresentation from '../SVG/SVGLandmarkRepresentation.js';
 import vtkPlanePointManipulator from '../Manipulators/PlaneManipulator.js';
 import widgetBehavior from './LabelWidget/behavior.js';
 import generateState from './LabelWidget/state.js';
-import { VerticalTextAlignment } from '../SVG/SVGLandmarkRepresentation/Constants.js';
 import { ViewTypes } from '../Core/WidgetManager/Constants.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; }
@@ -21,7 +19,7 @@ function vtkLabelWidget(publicAPI, model) {
   var superClass = _objectSpread({}, publicAPI); // --- Widget Requirement ---------------------------------------------------
 
 
-  model.methodsToLink = ['textProps', 'fontProperties', 'strokeFontProperties', 'scaleInPixels'];
+  model.methodsToLink = ['scaleInPixels'];
 
   publicAPI.getRepresentationsForViewType = function (viewType) {
     switch (viewType) {
@@ -33,21 +31,6 @@ function vtkLabelWidget(publicAPI, model) {
         return [{
           builder: vtkSphereHandleRepresentation,
           labels: ['moveHandle']
-        }, {
-          builder: vtkSVGLandmarkRepresentation,
-          initialValues: {
-            circleProps: {
-              visible: true
-            },
-            textProps: {
-              'text-anchor': 'middle',
-              verticalAlign: VerticalTextAlignment.MIDDLE
-            },
-            strokeFontProperties: {
-              fontStyle: 'bold'
-            }
-          },
-          labels: ['SVGtext']
         }];
     }
   }; // --- Public methods -------------------------------------------------------

package/Widgets/Widgets3D/LineWidget/behavior.js

@@ -1,13 +1,9 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import Constants from './Constants.js';
 import macro from '../../../macros.js';
 import { s as subtract, l as add, m as normalize } from '../../../Common/Core/Math/index.js';
 import { getNumberOfPlacedHandles, isHandlePlaced, calculateTextPosition, updateTextPosition, getPoint } from './helpers.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; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 var ShapeType = Constants.ShapeType; // Total number of points to place
 
 var MAX_POINTS = 2;
@@ -70,44 +66,6 @@ function widgetBehavior(publicAPI, model) {
   // Text methods
   // --------------------------------------------------------------------------
 
-  /**
-   * check for handle 2 position in comparison to handle 1 position
-   * and sets text offset to not overlap on the line representation
-   */
-
-
-  function getOffsetDirectionForTextPosition() {
-    var pos1 = publicAPI.getHandle(0).getOrigin();
-    var pos2 = publicAPI.getHandle(1).getOrigin();
-    var dySign = 1;
-
-    if (pos1 && pos2) {
-      if (pos1[0] <= pos2[0]) {
-        dySign = pos1[1] <= pos2[1] ? 1 : -1;
-      } else {
-        dySign = pos1[1] <= pos2[1] ? -1 : 1;
-      }
-    }
-
-    return dySign;
-  }
-  /**
-   * place SVGText on line according to both handle positions
-   * which purpose is to never have text representation overlapping
-   * on PolyLine representation
-   * */
-
-
-  publicAPI.placeText = function () {
-    var dySign = getOffsetDirectionForTextPosition();
-
-    var textPropsCp = _objectSpread({}, model.representations[3].getTextProps());
-
-    textPropsCp.dy = dySign * Math.abs(textPropsCp.dy);
-    model.representations[3].setTextProps(textPropsCp);
-
-    model._interactor.render();
-  };
 
   publicAPI.setText = function (text) {
     model.widgetState.getText().setText(text);
@@ -211,7 +169,6 @@ function widgetBehavior(publicAPI, model) {
     }
 
     if (handleIndex === 1) {
-      publicAPI.placeText();
       publicAPI.loseFocus();
     }
   }; // --------------------------------------------------------------------------
@@ -289,7 +246,6 @@ function widgetBehavior(publicAPI, model) {
     if (model._isDragging && publicAPI.isPlaced()) {
       var wasTextActive = model.widgetState.getText().getActive(); // Recompute offsets
 
-      publicAPI.placeText();
       model.widgetState.deactivate();
       model.activeState = null;
 

package/Widgets/Widgets3D/LineWidget.js

@@ -5,7 +5,6 @@ import generateState from './LineWidget/state.js';
 import vtkAbstractWidgetFactory from '../Core/AbstractWidgetFactory.js';
 import vtkArrowHandleRepresentation from '../Representations/ArrowHandleRepresentation.js';
 import vtkPlanePointManipulator from '../Manipulators/PlaneManipulator.js';
-import vtkSVGLandmarkRepresentation from '../SVG/SVGLandmarkRepresentation.js';
 import vtkPolyLineRepresentation from '../Representations/PolyLineRepresentation.js';
 import widgetBehavior from './LineWidget/behavior.js';
 import { Behavior } from '../Representations/WidgetRepresentation/Constants.js';
@@ -107,16 +106,6 @@ function vtkLineWidget(publicAPI, model) {
               }
             }
           }
-        }, {
-          builder: vtkSVGLandmarkRepresentation,
-          initialValues: {
-            text: '',
-            textProps: {
-              dx: 12,
-              dy: -12
-            }
-          },
-          labels: ['SVGtext']
         }, {
           builder: vtkPolyLineRepresentation,
           labels: ['handle1', 'handle2', 'moveHandle'],

package/Widgets/Widgets3D/PolyLineWidget.js

@@ -4,7 +4,6 @@ import vtkAbstractWidgetFactory from '../Core/AbstractWidgetFactory.js';
 import vtkPlanePointManipulator from '../Manipulators/PlaneManipulator.js';
 import vtkPolyLineRepresentation from '../Representations/PolyLineRepresentation.js';
 import vtkSphereHandleRepresentation from '../Representations/SphereHandleRepresentation.js';
-import vtkSVGLandmarkRepresentation from '../SVG/SVGLandmarkRepresentation.js';
 import widgetBehavior from './PolyLineWidget/behavior.js';
 import generateState from './PolyLineWidget/state.js';
 import { ViewTypes } from '../Core/WidgetManager/Constants.js';
@@ -36,15 +35,6 @@ function vtkPolyLineWidget(publicAPI, model) {
         }, {
           builder: vtkSphereHandleRepresentation,
           labels: ['moveHandle']
-        }, {
-          builder: vtkSVGLandmarkRepresentation,
-          initialValues: {
-            textProps: {
-              dx: 12,
-              dy: -12
-            }
-          },
-          labels: ['handles']
         }, {
           builder: vtkPolyLineRepresentation,
           labels: ['handles', 'moveHandle']

package/Widgets/Widgets3D/RectangleWidget.js

@@ -5,7 +5,6 @@ import vtkPlanePointManipulator from '../Manipulators/PlaneManipulator.js';
 import vtkShapeWidget from './ShapeWidget.js';
 import vtkSphereHandleRepresentation from '../Representations/SphereHandleRepresentation.js';
 import vtkRectangleContextRepresentation from '../Representations/RectangleContextRepresentation.js';
-import vtkSVGLandmarkRepresentation from '../SVG/SVGLandmarkRepresentation.js';
 import widgetBehavior from './RectangleWidget/behavior.js';
 import generateState from './RectangleWidget/state.js';
 import { BehaviorCategory, ShapeBehavior } from './ShapeWidget/Constants.js';
@@ -34,12 +33,6 @@ function vtkRectangleWidget(publicAPI, model) {
         }, {
           builder: vtkRectangleContextRepresentation,
           labels: ['rectangleHandle']
-        }, {
-          builder: vtkSVGLandmarkRepresentation,
-          initialValues: {
-            text: ''
-          },
-          labels: ['SVGtext']
         }];
     }
   }; // --------------------------------------------------------------------------

package/Widgets/Widgets3D/ShapeWidget.js

@@ -12,7 +12,7 @@ function vtkShapeWidget(publicAPI, model) {
 
   var superClass = _objectSpread({}, publicAPI);
 
-  model.methodsToLink = ['scaleInPixels', 'textProps', 'fontProperties'];
+  model.methodsToLink = ['scaleInPixels'];
 
   publicAPI.setManipulator = function (manipulator) {
     superClass.setManipulator(manipulator);

package/package.json

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

package/Widgets/Core/WidgetManager/vdom.js

@@ -1,172 +0,0 @@
-import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
-
-var SVG_XMLNS = 'http://www.w3.org/2000/svg';
-
-function attrDelta(oldObj, newObj) {
-  var set = [];
-  var remove = [];
-  var oldKeysArray = Object.keys(oldObj);
-  var newKeysArray = Object.keys(newObj);
-  var oldKeys = new Set(oldKeysArray);
-  var newKeys = new Set(newKeysArray);
-
-  for (var i = 0; i < oldKeysArray.length; i++) {
-    var key = oldKeysArray[i];
-
-    if (newKeys.has(key)) {
-      if (oldObj[key] !== newObj[key]) {
-        set.push([key, newObj[key]]);
-      }
-    } else {
-      remove.push(key);
-    }
-  }
-
-  for (var _i = 0; _i < newKeysArray.length; _i++) {
-    var _key = newKeysArray[_i];
-
-    if (!oldKeys.has(_key)) {
-      set.push([_key, newObj[_key]]);
-    }
-  }
-
-  return [set, remove];
-}
-
-function render(vnode) {
-  var node = document.createElementNS(SVG_XMLNS, vnode.name);
-  var keys = Object.keys(vnode.attrs);
-
-  for (var i = 0; i < keys.length; i++) {
-    var key = keys[i];
-    node.setAttribute(key, vnode.attrs[key]);
-  } // TODO: support removing event listener (e.g. use snabbdom)
-
-
-  Object.keys(vnode.eventListeners).forEach(function (key) {
-    node.addEventListener(key, vnode.eventListeners[key]);
-  });
-
-  if (vnode.textContent) {
-    node.textContent = vnode.textContent;
-  } else {
-    for (var _i2 = 0; _i2 < vnode.children.length; _i2++) {
-      node.appendChild(render(vnode.children[_i2]));
-    }
-  }
-
-  return node;
-}
-/**
- * Returns a set of patch functions to be applied to a document node.
- *
- * Patch functions must return the effective result node.
- */
-
-function diff(oldVTree, newVTree) {
-  if (newVTree.textContent !== null && newVTree.children.length) {
-    throw new Error('Tree cannot have both children and textContent!');
-  }
-
-  if (!oldVTree) {
-    return [function () {
-      return render(newVTree);
-    }];
-  }
-
-  if (!newVTree) {
-    return [function (node) {
-      return node.remove();
-    }];
-  }
-
-  if (oldVTree.name !== newVTree.name) {
-    return [function (node) {
-      var newNode = render(newVTree);
-      node.replaceWith(newNode);
-      return newNode;
-    }];
-  }
-
-  var patchFns = [];
-
-  var _attrDelta = attrDelta(oldVTree.attrs, newVTree.attrs),
-      _attrDelta2 = _slicedToArray(_attrDelta, 2),
-      attrsSet = _attrDelta2[0],
-      attrsRemove = _attrDelta2[1];
-
-  if (attrsSet.length || attrsRemove.length) {
-    patchFns.push(function (node) {
-      for (var i = 0; i < attrsSet.length; i++) {
-        var _attrsSet$i = _slicedToArray(attrsSet[i], 2),
-            name = _attrsSet$i[0],
-            value = _attrsSet$i[1];
-
-        node.setAttribute(name, value);
-      }
-
-      for (var _i3 = 0; _i3 < attrsRemove.length; _i3++) {
-        var _name = attrsRemove[_i3];
-        node.removeAttribute(_name);
-      }
-
-      return node;
-    });
-  }
-
-  if (oldVTree.textContent !== newVTree.textContent && newVTree.textContent !== null) {
-    patchFns.push(function (node) {
-      node.textContent = newVTree.textContent;
-      return node;
-    });
-  }
-
-  if (newVTree.textContent === null) {
-    var min = Math.min(oldVTree.children.length, newVTree.children.length);
-
-    var _loop = function _loop(i) {
-      var childPatches = diff(oldVTree.children[i], newVTree.children[i]);
-      patchFns.push(function (node) {
-        for (var p = 0; p < childPatches.length; p++) {
-          childPatches[p](node.children[i]);
-        }
-
-        return node;
-      });
-    };
-
-    for (var i = 0; i < min; i++) {
-      _loop(i);
-    }
-
-    if (oldVTree.children.length < newVTree.children.length) {
-      var _loop2 = function _loop2(_i4) {
-        patchFns.push(function (node) {
-          node.appendChild(render(newVTree.children[_i4]));
-          return node;
-        });
-      };
-
-      for (var _i4 = min; _i4 < newVTree.children.length; _i4++) {
-        _loop2(_i4);
-      }
-    } else {
-      var _loop3 = function _loop3(_i5) {
-        patchFns.push(function (node) {
-          node.children[_i5].remove();
-
-          return node;
-        });
-      };
-
-      // always delete nodes in reverse
-      for (var _i5 = oldVTree.children.length - 1; _i5 >= min; _i5--) {
-        _loop3(_i5);
-      }
-    }
-  }
-
-  return patchFns;
-}
-
-export { diff, render };

package/Widgets/SVG/SVGLandmarkRepresentation/Constants.js

@@ -1,28 +0,0 @@
-var VerticalTextAlignment = {
-  TOP: 'TOP',
-  BOTTOM: 'BOTTOM',
-  MIDDLE: 'MIDDLE'
-};
-/**
- * fontSize can be a number or a string representing a size in px
- * @param {Number|String} fontSize
- * @returns Number representing the fontSize in pixels
- */
-
-function fontSizeToPixels(fontProperties) {
-  var defaultFontSize = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 16;
-
-  if (fontProperties != null && fontProperties.fontSize) {
-    if (typeof fontProperties.fontSize === 'string') {
-      if (fontProperties.fontSize.slice(-2) === 'px') {
-        return window.devicePixelRatio * parseInt(fontProperties.fontSize, 10);
-      }
-    }
-
-    return window.devicePixelRatio * fontProperties.fontSize;
-  }
-
-  return window.devicePixelRatio * defaultFontSize;
-}
-
-export { VerticalTextAlignment, VerticalTextAlignment as default, fontSizeToPixels };

package/Widgets/SVG/SVGLandmarkRepresentation.js

@@ -1,167 +0,0 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../macros.js';
-import vtkSVGRepresentation from './SVGRepresentation.js';
-import { fontSizeToPixels, VerticalTextAlignment } from './SVGLandmarkRepresentation/Constants.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; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-var createSvgElement = vtkSVGRepresentation.createSvgElement; // ----------------------------------------------------------------------------
-// vtkSVGLandmarkRepresentation
-// ----------------------------------------------------------------------------
-
-function vtkSVGLandmarkRepresentation(publicAPI, model) {
-  // Set our className
-  model.classHierarchy.push('vtkSVGLandmarkRepresentation');
-
-  publicAPI.render = function () {
-    var list = publicAPI.getRepresentationStates();
-
-    if (!list.length) {
-      return createSvgElement('g');
-    }
-
-    var coords = [];
-    var texts = [];
-    list.forEach(function (state, index) {
-      if (state.getOrigin && state.getOrigin() && state.getVisible && state.getVisible()) {
-        coords.push(state.getOrigin());
-        texts.push(state.getText ? state.getText() : "L".concat(index));
-      }
-    });
-    var state = list[0];
-    var isActive = state.getActive();
-    return publicAPI.worldPointsToPixelSpace(coords).then(function (pixelSpace) {
-      var points2d = pixelSpace.coords;
-      var winHeight = pixelSpace.windowSize[1];
-      var root = createSvgElement('g');
-
-      var _loop = function _loop(i) {
-        var xy = points2d[i];
-
-        if (Number.isNaN(xy[0]) || Number.isNaN(xy[1])) {
-          return "continue"; // eslint-disable-line
-        }
-
-        var x = xy[0];
-        var y = winHeight - xy[1];
-
-        if (model.circleProps && model.circleProps.visible) {
-          var circle = publicAPI.createListenableSvgElement('circle', i);
-          Object.keys(model.circleProps || {}).forEach(function (prop) {
-            return circle.setAttribute(prop, model.circleProps[prop]);
-          });
-          circle.setAttribute('cx', x);
-          circle.setAttribute('cy', y);
-          root.appendChild(circle);
-        }
-
-        if (!texts[i]) {
-          texts[i] = '';
-        }
-
-        var splitText = texts[i].split('\n');
-        var fontSize = fontSizeToPixels(model.fontProperties);
-        splitText.forEach(function (subText, j) {
-          var _model$textProps, _model$textProps2;
-
-          var text = publicAPI.createListenableSvgElement('text', i);
-          Object.keys(model.textProps || {}).forEach(function (prop) {
-            text.setAttribute(prop, model.textProps[prop]);
-          });
-          text.setAttribute('x', x);
-          text.setAttribute('y', y); // Vertical offset (dy) calculation based on VerticalTextAlignment
-
-          var dy = ((_model$textProps = model.textProps) === null || _model$textProps === void 0 ? void 0 : _model$textProps.dy) || 0;
-
-          switch ((_model$textProps2 = model.textProps) === null || _model$textProps2 === void 0 ? void 0 : _model$textProps2.verticalAlign) {
-            case VerticalTextAlignment.MIDDLE:
-              dy -= fontSize * (0.5 * splitText.length - j - 1);
-              break;
-
-            case VerticalTextAlignment.TOP:
-              dy += fontSize * (j + 1);
-              break;
-
-            case VerticalTextAlignment.BOTTOM:
-            default:
-              dy -= fontSize * (splitText.length - j - 1);
-              break;
-          }
-
-          text.setAttribute('dy', dy);
-          text.setAttribute('font-size', fontSize);
-
-          if (model.fontProperties && model.fontProperties.fontFamily) {
-            text.setAttribute('font-family', model.fontProperties.fontFamily);
-          } else if (isActive && model.strokeFontProperties && model.strokeFontProperties.fontFamily) {
-            text.setAttribute('font-family', model.strokeFontProperties.fontFamily);
-          }
-
-          if (model.fontProperties && model.fontProperties.fontStyle) {
-            text.setAttribute('font-weight', model.fontProperties.fontStyle);
-          } else if (isActive && model.strokeFontProperties && model.strokeFontProperties.fontStyle) {
-            text.setAttribute('font-weight', model.strokeFontProperties.fontStyle);
-          }
-
-          if (model.fontProperties && model.fontProperties.fontColor) {
-            text.setAttribute('fill', model.fontProperties.fontColor);
-          } else if (isActive && model.strokeFontProperties && model.strokeFontProperties.fontColor) {
-            text.setAttribute('fill', model.strokeFontProperties.fontColor);
-          }
-
-          text.textContent = subText;
-          root.appendChild(text);
-        });
-      };
-
-      for (var i = 0; i < points2d.length; i++) {
-        var _ret = _loop(i);
-
-        if (_ret === "continue") continue;
-      }
-
-      return root;
-    });
-  };
-} // ----------------------------------------------------------------------------
-// Object factory
-// ----------------------------------------------------------------------------
-
-/**
- * textProps can contain any "svg" attribute (e.g. text-anchor, text-align,
- * alignment-baseline...)
- */
-
-
-function defaultValues(initialValues) {
-  return _objectSpread(_objectSpread({}, initialValues), {}, {
-    circleProps: _objectSpread({
-      visible: false,
-      r: 5,
-      stroke: 'red',
-      fill: 'red'
-    }, initialValues.circleProps),
-    fontProperties: _objectSpread({
-      fontColor: 'white'
-    }, initialValues.fontProperties)
-  });
-} // ----------------------------------------------------------------------------
-
-
-function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  vtkSVGRepresentation.extend(publicAPI, model, defaultValues(initialValues));
-  macro.setGet(publicAPI, model, ['circleProps', 'fontProperties', 'strokeFontProperties', 'textProps']); // Object specific methods
-
-  vtkSVGLandmarkRepresentation(publicAPI, model);
-} // ----------------------------------------------------------------------------
-
-var newInstance = macro.newInstance(extend, 'vtkSVGLandmarkRepresentation'); // ----------------------------------------------------------------------------
-
-var vtkSVGLandmarkRepresentation$1 = {
-  extend: extend,
-  newInstance: newInstance
-};
-
-export { vtkSVGLandmarkRepresentation$1 as default, extend, newInstance };

package/Widgets/SVG/SVGRepresentation.js

@@ -1,163 +0,0 @@
-import macro from '../../macros.js';
-import vtkPolyData from '../../Common/DataModel/PolyData.js';
-import vtkActor from '../../Rendering/Core/Actor.js';
-import vtkPixelSpaceCallbackMapper from '../../Rendering/Core/PixelSpaceCallbackMapper.js';
-import vtkWidgetRepresentation from '../Representations/WidgetRepresentation.js';
-import { Behavior } from '../Representations/WidgetRepresentation/Constants.js';
-import { RenderingTypes } from '../Core/WidgetManager/Constants.js';
-
-var SVG_XMLNS = 'http://www.w3.org/2000/svg'; // ----------------------------------------------------------------------------
-
-function createSvgElement(tag) {
-  return {
-    name: tag,
-    attrs: {},
-    eventListeners: {},
-    // implies no children if set
-    textContent: null,
-    children: [],
-    setAttribute: function setAttribute(attr, val) {
-      this.attrs[attr] = val;
-    },
-    removeAttribute: function removeAttribute(attr) {
-      delete this.attrs[attr];
-    },
-    appendChild: function appendChild(n) {
-      this.children.push(n);
-    },
-    addEventListeners: function addEventListeners(event, callback) {
-      this.eventListeners[event] = callback;
-    }
-  };
-} // ----------------------------------------------------------------------------
-
-
-function createSvgDomElement(tag) {
-  return document.createElementNS(SVG_XMLNS, tag);
-} // ----------------------------------------------------------------------------
-
-
-function defer() {
-  var resolve;
-  var reject;
-  var promise = new Promise(function (res, rej) {
-    resolve = res;
-    reject = rej;
-  });
-  return {
-    promise: promise,
-    resolve: resolve,
-    reject: reject
-  };
-} // ----------------------------------------------------------------------------
-// vtkSVGRepresentation
-// ----------------------------------------------------------------------------
-
-
-function vtkSVGRepresentation(publicAPI, model) {
-  // Set our className
-  model.classHierarchy.push('vtkSVGRepresentation');
-  var deferred = null;
-  model.psActor = vtkActor.newInstance({
-    pickable: false,
-    _parentProp: publicAPI
-  });
-  model.psMapper = vtkPixelSpaceCallbackMapper.newInstance();
-  model.points = vtkPolyData.newInstance();
-  model.psMapper.setInputData(model.points);
-  model.psActor.setMapper(model.psMapper);
-  model.psMapper.setCallback(function () {
-    if (deferred) {
-      var d = deferred;
-      deferred = null;
-      d.resolve({
-        coords: arguments.length <= 0 ? undefined : arguments[0],
-        camera: arguments.length <= 1 ? undefined : arguments[1],
-        aspect: arguments.length <= 2 ? undefined : arguments[2],
-        depthValues: arguments.length <= 3 ? undefined : arguments[3],
-        windowSize: arguments.length <= 4 ? undefined : arguments[4]
-      });
-    }
-  });
-  publicAPI.addActor(model.psActor); // --------------------------------------------------------------------------
-
-  publicAPI.worldPointsToPixelSpace = function (points3d) {
-    var pts = new Float32Array(points3d.length * 3);
-
-    for (var i = 0; i < points3d.length; i++) {
-      pts[i * 3 + 0] = points3d[i][0];
-      pts[i * 3 + 1] = points3d[i][1];
-      pts[i * 3 + 2] = points3d[i][2];
-    }
-
-    model.points.getPoints().setData(pts);
-    model.points.modified();
-    deferred = defer();
-    return deferred.promise;
-  };
-
-  publicAPI.createListenableSvgElement = function (tag, id) {
-    var element = createSvgElement(tag);
-
-    if (model.pickable) {
-      element.addEventListeners('mouseenter', function () {
-        publicAPI.setHover(id);
-      });
-      element.addEventListeners('mouseleave', function () {
-        if (publicAPI.getHover() === id) {
-          publicAPI.setHover(null);
-        }
-      });
-    }
-
-    return element;
-  }; // --------------------------------------------------------------------------
-
-
-  publicAPI.updateActorVisibility = function () {
-    arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : RenderingTypes.FRONT_BUFFER;
-    var ctxVisible = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-    var handleVisible = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
-
-    if (model.behavior === Behavior.CONTEXT) {
-      publicAPI.setVisibility(ctxVisible);
-    } else if (model.behavior === Behavior.HANDLE) {
-      publicAPI.setVisibility(handleVisible);
-    }
-  }; // --------------------------------------------------------------------------
-  // Subclasses must implement this method
-
-
-  publicAPI.render = function () {
-    throw new Error('Not implemented');
-  };
-} // ----------------------------------------------------------------------------
-// Object factory
-// ----------------------------------------------------------------------------
-
-/**
- * 'hover' is not null when a pickable SVG element is mouse hovered.
- */
-
-
-var DEFAULT_VALUES = {
-  visibility: true
-}; // ----------------------------------------------------------------------------
-
-function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Extend methods
-
-  vtkWidgetRepresentation.extend(publicAPI, model, initialValues);
-  macro.setGet(publicAPI, model, ['visibility', 'hover']); // Object specific methods
-
-  vtkSVGRepresentation(publicAPI, model);
-} // ----------------------------------------------------------------------------
-
-var vtkSVGRepresentation$1 = {
-  extend: extend,
-  createSvgElement: createSvgElement,
-  createSvgDomElement: createSvgDomElement
-};
-
-export { vtkSVGRepresentation$1 as default, extend };