@kitware/vtk.js 28.10.2 → 28.11.1

package/Rendering/OpenGL/TextureUnitManager.js

@@ -1,119 +1,123 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 
-var vtkErrorMacro = macro.vtkErrorMacro; // ----------------------------------------------------------------------------
+const {
+  vtkErrorMacro
+} = macro;
+
+// ----------------------------------------------------------------------------
 // vtkOpenGLTextureUnitManager methods
 // ----------------------------------------------------------------------------
 
 function vtkOpenGLTextureUnitManager(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkOpenGLTextureUnitManager'); // ----------------------------------------------------------------------------
+  model.classHierarchy.push('vtkOpenGLTextureUnitManager');
+
+  // ----------------------------------------------------------------------------
   // Description:
   // Delete the allocation table and check if it is not called before
   // all the texture units have been released.
-
-  publicAPI.deleteTable = function () {
-    for (var i = 0; i < model.numberOfTextureUnits; ++i) {
+  publicAPI.deleteTable = () => {
+    for (let i = 0; i < model.numberOfTextureUnits; ++i) {
       if (model.textureUnits[i] === true) {
         vtkErrorMacro('some texture units  were not properly released');
       }
     }
-
     model.textureUnits = [];
     model.numberOfTextureUnits = 0;
-  }; // ----------------------------------------------------------------------------
-
+  };
 
-  publicAPI.setContext = function (ctx) {
+  // ----------------------------------------------------------------------------
+  publicAPI.setContext = ctx => {
     if (model.context !== ctx) {
       if (model.context !== 0) {
         publicAPI.deleteTable();
       }
-
       model.context = ctx;
-
       if (model.context) {
         model.numberOfTextureUnits = ctx.getParameter(ctx.MAX_TEXTURE_IMAGE_UNITS);
-
-        for (var i = 0; i < model.numberOfTextureUnits; ++i) {
+        for (let i = 0; i < model.numberOfTextureUnits; ++i) {
           model.textureUnits[i] = false;
         }
       }
-
       publicAPI.modified();
     }
-  }; // ----------------------------------------------------------------------------
+  };
+
+  // ----------------------------------------------------------------------------
   // Description:
   // Reserve a texture unit. It returns its number.
   // It returns -1 if the allocation failed (because there are no more
   // texture units left).
   // \post valid_result: result==-1 || result>=0 && result<this->GetNumberOfTextureUnits())
   // \post allocated: result==-1 || this->IsAllocated(result)
-
-
-  publicAPI.allocate = function () {
-    for (var i = 0; i < model.numberOfTextureUnits; i++) {
+  publicAPI.allocate = () => {
+    for (let i = 0; i < model.numberOfTextureUnits; i++) {
       if (!publicAPI.isAllocated(i)) {
         model.textureUnits[i] = true;
         return i;
       }
     }
-
     return -1;
   };
-
-  publicAPI.allocateUnit = function (unit) {
+  publicAPI.allocateUnit = unit => {
     if (publicAPI.isAllocated(unit)) {
       return -1;
     }
-
     model.textureUnits[unit] = true;
     return unit;
-  }; // ----------------------------------------------------------------------------
+  };
+
+  // ----------------------------------------------------------------------------
   // Description:
   // Tell if texture unit `textureUnitId' is already allocated.
   // \pre valid_id_range : textureUnitId>=0 && textureUnitId<this->GetNumberOfTextureUnits()
+  publicAPI.isAllocated = textureUnitId => model.textureUnits[textureUnitId];
 
-
-  publicAPI.isAllocated = function (textureUnitId) {
-    return model.textureUnits[textureUnitId];
-  }; // ----------------------------------------------------------------------------
+  // ----------------------------------------------------------------------------
   // Description:
   // Release a texture unit.
   // \pre valid_id: textureUnitId>=0 && textureUnitId<this->GetNumberOfTextureUnits()
   // \pre allocated_id: this->IsAllocated(textureUnitId)
-
-
-  publicAPI.free = function (val) {
+  publicAPI.free = val => {
     model.textureUnits[val] = false;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   context: null,
   numberOfTextureUnits: 0,
   textureUnits: 0
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   Object.assign(model, DEFAULT_VALUES, initialValues);
   macro.obj(publicAPI, model);
-  model.textureUnits = []; // Build VTK API
+  model.textureUnits = [];
 
+  // Build VTK API
   macro.get(publicAPI, model, ['numberOfTextureUnits']);
-  macro.setGet(publicAPI, model, ['context']); // Object methods
+  macro.setGet(publicAPI, model, ['context']);
 
+  // Object methods
   vtkOpenGLTextureUnitManager(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkOpenGLTextureUnitManager'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkOpenGLTextureUnitManager');
+
+// ----------------------------------------------------------------------------
 
 var vtkTextureUnitManager = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkTextureUnitManager as default, extend, newInstance };

package/Rendering/OpenGL/VertexArrayObject.js

@@ -1,30 +1,30 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import { ObjectType } from './BufferObject/Constants.js';
 
+// ----------------------------------------------------------------------------
 // vtkOpenGLVertexArrayObject methods
 // ----------------------------------------------------------------------------
 
 function vtkOpenGLVertexArrayObject(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkOpenGLVertexArrayObject'); // Public API methods
+  model.classHierarchy.push('vtkOpenGLVertexArrayObject');
 
-  publicAPI.exposedMethod = function () {// This is a publicly exposed method of this object
+  // Public API methods
+  publicAPI.exposedMethod = () => {
+    // This is a publicly exposed method of this object
   };
-
-  publicAPI.initialize = function () {
+  publicAPI.initialize = () => {
     model.instancingExtension = null;
-
     if (!model._openGLRenderWindow.getWebgl2()) {
       model.instancingExtension = model.context.getExtension('ANGLE_instanced_arrays');
     }
-
     if (!model.forceEmulation && model._openGLRenderWindow && model._openGLRenderWindow.getWebgl2()) {
       model.extension = null;
       model.supported = true;
       model.handleVAO = model.context.createVertexArray();
     } else {
-      model.extension = model.context.getExtension('OES_vertex_array_object'); // Start setting up VAO
-
+      model.extension = model.context.getExtension('OES_vertex_array_object');
+      // Start setting up VAO
       if (!model.forceEmulation && model.extension) {
         model.supported = true;
         model.handleVAO = model.extension.createVertexArrayOES();
@@ -33,20 +33,15 @@ function vtkOpenGLVertexArrayObject(publicAPI, model) {
       }
     }
   };
-
-  publicAPI.isReady = function () {
-    return (// We either probed and allocated a VAO, or are falling back as the current
-      // hardware does not support VAOs.
-      model.handleVAO !== 0 || model.supported === false
-    );
-  };
-
-  publicAPI.bind = function () {
+  publicAPI.isReady = () =>
+  // We either probed and allocated a VAO, or are falling back as the current
+  // hardware does not support VAOs.
+  model.handleVAO !== 0 || model.supported === false;
+  publicAPI.bind = () => {
     // Either simply bind the VAO, or emulate behavior by binding all attributes.
     if (!publicAPI.isReady()) {
       publicAPI.initialize();
     }
-
     if (publicAPI.isReady() && model.supported) {
       if (model.extension) {
         model.extension.bindVertexArrayOES(model.handleVAO);
@@ -54,20 +49,16 @@ function vtkOpenGLVertexArrayObject(publicAPI, model) {
         model.context.bindVertexArray(model.handleVAO);
       }
     } else if (publicAPI.isReady()) {
-      var gl = model.context;
-
-      for (var ibuff = 0; ibuff < model.buffers.length; ++ibuff) {
-        var buff = model.buffers[ibuff];
+      const gl = model.context;
+      for (let ibuff = 0; ibuff < model.buffers.length; ++ibuff) {
+        const buff = model.buffers[ibuff];
         model.context.bindBuffer(gl.ARRAY_BUFFER, buff.buffer);
-
-        for (var iatt = 0; iatt < buff.attributes.length; ++iatt) {
-          var attrIt = buff.attributes[iatt];
-          var matrixCount = attrIt.isMatrix ? attrIt.size : 1;
-
-          for (var i = 0; i < matrixCount; ++i) {
+        for (let iatt = 0; iatt < buff.attributes.length; ++iatt) {
+          const attrIt = buff.attributes[iatt];
+          const matrixCount = attrIt.isMatrix ? attrIt.size : 1;
+          for (let i = 0; i < matrixCount; ++i) {
             gl.enableVertexAttribArray(attrIt.index + i);
             gl.vertexAttribPointer(attrIt.index + i, attrIt.size, attrIt.type, attrIt.normalize, attrIt.stride, attrIt.offset + attrIt.stride * i / attrIt.size);
-
             if (attrIt.divisor > 0) {
               if (model.instancingExtension) {
                 model.instancingExtension.vertexAttribDivisorANGLE(attrIt.index + i, 1);
@@ -80,8 +71,7 @@ function vtkOpenGLVertexArrayObject(publicAPI, model) {
       }
     }
   };
-
-  publicAPI.release = function () {
+  publicAPI.release = () => {
     // Either simply release the VAO, or emulate behavior by releasing all attributes.
     if (publicAPI.isReady() && model.supported) {
       if (model.extension) {
@@ -90,20 +80,16 @@ function vtkOpenGLVertexArrayObject(publicAPI, model) {
         model.context.bindVertexArray(null);
       }
     } else if (publicAPI.isReady()) {
-      var gl = model.context;
-
-      for (var ibuff = 0; ibuff < model.buffers.length; ++ibuff) {
-        var buff = model.buffers[ibuff];
+      const gl = model.context;
+      for (let ibuff = 0; ibuff < model.buffers.length; ++ibuff) {
+        const buff = model.buffers[ibuff];
         model.context.bindBuffer(gl.ARRAY_BUFFER, buff.buffer);
-
-        for (var iatt = 0; iatt < buff.attributes.length; ++iatt) {
-          var attrIt = buff.attributes[iatt];
-          var matrixCount = attrIt.isMatrix ? attrIt.size : 1;
-
-          for (var i = 0; i < matrixCount; ++i) {
+        for (let iatt = 0; iatt < buff.attributes.length; ++iatt) {
+          const attrIt = buff.attributes[iatt];
+          const matrixCount = attrIt.isMatrix ? attrIt.size : 1;
+          for (let i = 0; i < matrixCount; ++i) {
             gl.enableVertexAttribArray(attrIt.index + i);
             gl.vertexAttribPointer(attrIt.index + i, attrIt.size, attrIt.type, attrIt.normalize, attrIt.stride, attrIt.offset + attrIt.stride * i / attrIt.size);
-
             if (attrIt.divisor > 0) {
               if (model.instancingExtension) {
                 model.instancingExtension.vertexAttribDivisorANGLE(attrIt.index + i, 0);
@@ -111,17 +97,14 @@ function vtkOpenGLVertexArrayObject(publicAPI, model) {
                 gl.vertexAttribDivisor(attrIt.index + i, 0);
               }
             }
-
             gl.disableVertexAttribArray(attrIt.index + i);
           }
         }
       }
     }
   };
-
-  publicAPI.shaderProgramChanged = function () {
+  publicAPI.shaderProgramChanged = () => {
     publicAPI.release();
-
     if (model.handleVAO) {
       if (model.extension) {
         model.extension.deleteVertexArrayOES(model.handleVAO);
@@ -129,14 +112,11 @@ function vtkOpenGLVertexArrayObject(publicAPI, model) {
         model.context.deleteVertexArray(model.handleVAO);
       }
     }
-
     model.handleVAO = 0;
     model.handleProgram = 0;
   };
-
-  publicAPI.releaseGraphicsResources = function () {
+  publicAPI.releaseGraphicsResources = () => {
     publicAPI.shaderProgramChanged();
-
     if (model.handleVAO) {
       if (model.extension) {
         model.extension.deleteVertexArrayOES(model.handleVAO);
@@ -144,41 +124,33 @@ function vtkOpenGLVertexArrayObject(publicAPI, model) {
         model.context.deleteVertexArray(model.handleVAO);
       }
     }
-
     model.handleVAO = 0;
     model.supported = true;
     model.handleProgram = 0;
   };
-
-  publicAPI.addAttributeArray = function (program, buffer, name, offset, stride, elementType, elementTupleSize, normalize) {
-    return publicAPI.addAttributeArrayWithDivisor(program, buffer, name, offset, stride, elementType, elementTupleSize, normalize, 0, false);
-  };
-
-  publicAPI.addAttributeArrayWithDivisor = function (program, buffer, name, offset, stride, elementType, elementTupleSize, normalize, divisor, isMatrix) {
+  publicAPI.addAttributeArray = (program, buffer, name, offset, stride, elementType, elementTupleSize, normalize) => publicAPI.addAttributeArrayWithDivisor(program, buffer, name, offset, stride, elementType, elementTupleSize, normalize, 0, false);
+  publicAPI.addAttributeArrayWithDivisor = (program, buffer, name, offset, stride, elementType, elementTupleSize, normalize, divisor, isMatrix) => {
     if (!program) {
       return false;
-    } // Check the program is bound, and the buffer is valid.
-
+    }
 
+    // Check the program is bound, and the buffer is valid.
     if (!program.isBound() || buffer.getHandle() === 0 || buffer.getType() !== ObjectType.ARRAY_BUFFER) {
       return false;
-    } // Perform initialization if necessary, ensure program matches VAOs.
-
+    }
 
+    // Perform initialization if necessary, ensure program matches VAOs.
     if (model.handleProgram === 0) {
       model.handleProgram = program.getHandle();
     }
-
     if (!publicAPI.isReady()) {
       publicAPI.initialize();
     }
-
     if (!publicAPI.isReady() || model.handleProgram !== program.getHandle()) {
       return false;
     }
-
-    var gl = model.context;
-    var attribs = {};
+    const gl = model.context;
+    const attribs = {};
     attribs.name = name;
     attribs.index = gl.getAttribLocation(model.handleProgram, name);
     attribs.offset = offset;
@@ -188,17 +160,15 @@ function vtkOpenGLVertexArrayObject(publicAPI, model) {
     attribs.normalize = normalize;
     attribs.isMatrix = isMatrix;
     attribs.divisor = divisor;
-
     if (attribs.Index === -1) {
       return false;
-    } // Always make the call as even the first use wants the attrib pointer setting
-    // up when we are emulating.
-
+    }
 
+    // Always make the call as even the first use wants the attrib pointer setting
+    // up when we are emulating.
     buffer.bind();
     gl.enableVertexAttribArray(attribs.index);
     gl.vertexAttribPointer(attribs.index, attribs.size, attribs.type, attribs.normalize, attribs.stride, attribs.offset);
-
     if (divisor > 0) {
       if (model.instancingExtension) {
         model.instancingExtension.vertexAttribDivisorANGLE(attribs.index, 1);
@@ -206,35 +176,29 @@ function vtkOpenGLVertexArrayObject(publicAPI, model) {
         gl.vertexAttribDivisor(attribs.index, 1);
       }
     }
+    attribs.buffer = buffer.getHandle();
 
-    attribs.buffer = buffer.getHandle(); // If vertex array objects are not supported then build up our list.
-
+    // If vertex array objects are not supported then build up our list.
     if (!model.supported) {
       // find the buffer
-      var buffFound = false;
-
-      for (var ibuff = 0; ibuff < model.buffers.length; ++ibuff) {
-        var buff = model.buffers[ibuff];
-
+      let buffFound = false;
+      for (let ibuff = 0; ibuff < model.buffers.length; ++ibuff) {
+        const buff = model.buffers[ibuff];
         if (buff.buffer === attribs.buffer) {
           buffFound = true;
-          var found = false;
-
-          for (var iatt = 0; iatt < buff.attributes.length; ++iatt) {
-            var attrIt = buff.attributes[iatt];
-
+          let found = false;
+          for (let iatt = 0; iatt < buff.attributes.length; ++iatt) {
+            const attrIt = buff.attributes[iatt];
             if (attrIt.name === name) {
               found = true;
               buff.attributes[iatt] = attribs;
             }
           }
-
           if (!found) {
             buff.attributes.push(attribs);
           }
         }
       }
-
       if (!buffFound) {
         model.buffers.push({
           buffer: attribs.buffer,
@@ -242,25 +206,19 @@ function vtkOpenGLVertexArrayObject(publicAPI, model) {
         });
       }
     }
-
     return true;
   };
-
-  publicAPI.addAttributeMatrixWithDivisor = function (program, buffer, name, offset, stride, elementType, elementTupleSize, normalize, divisor) {
+  publicAPI.addAttributeMatrixWithDivisor = (program, buffer, name, offset, stride, elementType, elementTupleSize, normalize, divisor) => {
     // bind the first row of values
-    var result = publicAPI.addAttributeArrayWithDivisor(program, buffer, name, offset, stride, elementType, elementTupleSize, normalize, divisor, true);
-
+    const result = publicAPI.addAttributeArrayWithDivisor(program, buffer, name, offset, stride, elementType, elementTupleSize, normalize, divisor, true);
     if (!result) {
       return result;
     }
-
-    var gl = model.context;
-    var index = gl.getAttribLocation(model.handleProgram, name);
-
-    for (var i = 1; i < elementTupleSize; i++) {
+    const gl = model.context;
+    const index = gl.getAttribLocation(model.handleProgram, name);
+    for (let i = 1; i < elementTupleSize; i++) {
       gl.enableVertexAttribArray(index + i);
       gl.vertexAttribPointer(index + i, elementTupleSize, elementType, normalize, stride, offset + stride * i / elementTupleSize);
-
       if (divisor > 0) {
         if (model.instancingExtension) {
           model.instancingExtension.vertexAttribDivisorANGLE(index + i, 1);
@@ -269,88 +227,91 @@ function vtkOpenGLVertexArrayObject(publicAPI, model) {
         }
       }
     }
-
     return true;
   };
-
-  publicAPI.removeAttributeArray = function (name) {
+  publicAPI.removeAttributeArray = name => {
     if (!publicAPI.isReady() || model.handleProgram === 0) {
       return false;
-    } // If we don't have real VAOs find the entry and remove it too.
-
+    }
 
+    // If we don't have real VAOs find the entry and remove it too.
     if (!model.supported) {
-      for (var ibuff = 0; ibuff < model.buffers.length; ++ibuff) {
-        var buff = model.buffers[ibuff];
-
-        for (var iatt = 0; iatt < buff.attributes.length; ++iatt) {
-          var attrIt = buff.attributes[iatt];
-
+      for (let ibuff = 0; ibuff < model.buffers.length; ++ibuff) {
+        const buff = model.buffers[ibuff];
+        for (let iatt = 0; iatt < buff.attributes.length; ++iatt) {
+          const attrIt = buff.attributes[iatt];
           if (attrIt.name === name) {
             buff.attributes.splice(iatt, 1);
-
             if (!buff.attributes.length) {
               model.buffers.splice(ibuff, 1);
             }
-
             return true;
           }
         }
       }
     }
-
     return true;
   };
-
-  publicAPI.setOpenGLRenderWindow = function (rw) {
+  publicAPI.setOpenGLRenderWindow = rw => {
     if (model._openGLRenderWindow === rw) {
       return;
     }
-
     publicAPI.releaseGraphicsResources();
     model._openGLRenderWindow = rw;
     model.context = null;
-
     if (rw) {
       model.context = model._openGLRenderWindow.getContext();
     }
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   forceEmulation: false,
   handleVAO: 0,
   handleProgram: 0,
   supported: true,
   buffers: null,
-  context: null // _openGLRenderWindow: null,
+  context: null
+  // _openGLRenderWindow: null,
+};
 
-}; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Internal objects initialization
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
-  model.buffers = []; // Object methods
+  // Internal objects initialization
+  model.buffers = [];
 
-  macro.obj(publicAPI, model); // Create get-only macros
+  // Object methods
+  macro.obj(publicAPI, model);
 
-  macro.get(publicAPI, model, ['supported']); // Create get-set macros
+  // Create get-only macros
+  macro.get(publicAPI, model, ['supported']);
 
-  macro.setGet(publicAPI, model, ['forceEmulation']); // For more macro methods, see "Sources/macros.js"
-  // Object specific methods
+  // Create get-set macros
+  macro.setGet(publicAPI, model, ['forceEmulation']);
 
+  // For more macro methods, see "Sources/macros.js"
+
+  // Object specific methods
   vtkOpenGLVertexArrayObject(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkOpenGLVertexArrayObject'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkOpenGLVertexArrayObject');
+
+// ----------------------------------------------------------------------------
 
 var vtkVertexArrayObject = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkVertexArrayObject as default, extend, newInstance };

package/Rendering/OpenGL/ViewNodeFactory.js

@@ -1,39 +1,51 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkViewNodeFactory$1 from '../SceneGraph/ViewNodeFactory.js';
 
-var CLASS_MAPPING = Object.create(null);
+const CLASS_MAPPING = Object.create(null);
 function registerOverride(className, fn) {
   CLASS_MAPPING[className] = fn;
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // vtkOpenGLViewNodeFactory methods
 // ----------------------------------------------------------------------------
 
 function vtkOpenGLViewNodeFactory(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkOpenGLViewNodeFactory');
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
+const DEFAULT_VALUES = {};
 
-var DEFAULT_VALUES = {}; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Static class mapping shared across instances
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
-  model.overrides = CLASS_MAPPING; // Inheritance
+  // Static class mapping shared across instances
+  model.overrides = CLASS_MAPPING;
 
-  vtkViewNodeFactory$1.extend(publicAPI, model, initialValues); // Object methods
+  // Inheritance
+  vtkViewNodeFactory$1.extend(publicAPI, model, initialValues);
 
+  // Object methods
   vtkOpenGLViewNodeFactory(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkOpenGLViewNodeFactory'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkOpenGLViewNodeFactory');
+
+// ----------------------------------------------------------------------------
 
 var vtkViewNodeFactory = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkViewNodeFactory as default, extend, newInstance, registerOverride };