refactor(dataarray): change setData

Rename values to data in extend function and accept null as array param
setData accept undefined, newinstance with "data" as param

Author: joannacirillo

Sources/Common/Core/CellArray/test/testCellArray.js

@@ -13,7 +13,7 @@ test('Test cell array constructor', (t) => {
   );
   t.equal(emptyCellArray.getNumberOfCells(), 0, 'empty init number of cells');
 
-  const uintCellArray = vtkCellArray.newInstance({ values: [3, 0, 1, 2] });
+  const uintCellArray = vtkCellArray.newInstance({ data: [3, 0, 1, 2] });
   t.equal(
     uintCellArray.getDataType(),
     VtkDataTypes.UNSIGNED_INT,
@@ -23,7 +23,7 @@ test('Test cell array constructor', (t) => {
 
   const charCellArray = vtkCellArray.newInstance({
     dataType: VtkDataTypes.CHAR,
-    values: [3, 0, 1, 2],
+    data: [3, 0, 1, 2],
   });
   t.equal(
     charCellArray.getDataType(),

Sources/Common/Core/DataArray/index.d.ts

@@ -118,7 +118,7 @@ export interface vtkDataArray extends vtkObject {
 	 * @param {TypedArray} typedArray
 	 * @param {Number} [numberOfComponents]
 	 */
-	setData(typedArray: TypedArray, numberOfComponents?: number): void;
+	setData(typedArray?: TypedArray, numberOfComponents?: number): void;
 
 	/**
 	 *
@@ -209,7 +209,7 @@ export function extend(publicAPI: object, model: object, initialValues?: object)
  * Method use to create a new instance of vtkDataArray
  * @param {object} [initialValues] for pre-setting some of its content
  * initialValues can have a property "empty: true" to be able to create a
- * model without giving values. This property will not be stored in the model
+ * model without giving data. This property will not be stored in the model
  */
 export function newInstance(initialValues?: object): vtkDataArray;
 

Sources/Common/Core/DataArray/index.js

@@ -2,8 +2,6 @@ import Constants from 'vtk.js/Sources/Common/Core/DataArray/Constants';
 import * as macro from 'vtk.js/Sources/macros';
 import * as vtkMath from 'vtk.js/Sources/Common/Core/Math';
 
-const { vtkErrorMacro } = macro;
-
 const { DefaultDataType } = Constants;
 const TUPLE_HOLDER = [];
 
@@ -263,24 +261,20 @@ function vtkDataArray(publicAPI, model) {
     return model.name;
   };
 
-  publicAPI.setData = (typedArray, numberOfComponents) => {
-    if (!typedArray) {
-      vtkErrorMacro(`Cannot call setData with given array : ${typedArray}`);
-      return;
-    }
-
+  publicAPI.setData = (typedArray = null, numberOfComponents = undefined) => {
     if (Array.isArray(typedArray)) {
       // eslint-disable-next-line no-param-reassign
       typedArray = macro.newTypedArrayFrom(model.dataType, typedArray);
     }
+
     model.values = typedArray;
-    model.size = typedArray.length;
-    model.dataType = getDataType(typedArray);
+    model.size = typedArray ? typedArray.length : 0;
+    model.dataType = typedArray ? getDataType(typedArray) : model.dataType;
 
     if (numberOfComponents) {
       model.numberOfComponents = numberOfComponents;
     }
-    if (model.size % model.numberOfComponents !== 0) {
+    if (model.size % model.numberOfComponents !== 0 || !typedArray) {
       model.numberOfComponents = 1;
     }
     dataChange();
@@ -341,11 +335,14 @@ function defaultValues(initialValues) {
 // ----------------------------------------------------------------------------
 
 export function extend(publicAPI, model, initialValues = {}) {
-  if (!initialValues.empty && !initialValues.values && !initialValues.size) {
+  if (!initialValues.empty && !initialValues.data && !initialValues.size) {
     throw new TypeError(
       'Cannot create vtkDataArray object without: size > 0, values'
     );
   }
+  let initialData = initialValues.data;
+  delete initialValues.empty;
+  delete initialValues.data;
   Object.assign(initialValues, defaultValues(initialValues));
 
   // Object methods
@@ -355,28 +352,17 @@ export function extend(publicAPI, model, initialValues = {}) {
   model.dataType = initialValues.dataType
     ? initialValues.dataType
     : DefaultDataType;
-  if (!initialValues.values) {
-    initialValues.values = macro.newTypedArray(
-      model.dataType,
-      initialValues.size
-    );
-  } else if (Array.isArray(initialValues.values)) {
-    initialValues.values = macro.newTypedArrayFrom(
-      model.dataType,
-      initialValues.values
-    );
+  delete initialValues.dataType;
+  if (!initialData) {
+    initialData = macro.newTypedArray(model.dataType, initialValues.size);
+  } else if (Array.isArray(initialData)) {
+    initialData = macro.newTypedArrayFrom(model.dataType, initialData);
   }
 
+  initialValues.data = initialData;
+
   // Object specific methods
   vtkDataArray(publicAPI, model);
-  // We need to call setData manually here because it is not a setter for a property
-  // in itself but calling it is still the proper way to set the datas of the model
-  publicAPI.setData(initialValues.values, initialValues.numberOfComponents);
-  delete initialValues.values;
-  delete initialValues.empty;
-  delete initialValues.numberOfComponents;
-  delete initialValues.size;
-  delete initialValues.dataType;
 }
 
 // ----------------------------------------------------------------------------

Sources/Common/Core/DataArray/test/testDataArray.js

@@ -19,24 +19,27 @@ test('Test vtkDataArray instance', (t) => {
 
   t.throws(
     () => vtkDataArray.newInstance({}),
-    'Create instance without values'
+    'Not allowed to create instance without initialValues'
   );
 
-  t.doesNotThrow(() => vtkDataArray.newInstance({ empty: true }));
+  t.doesNotThrow(
+    () => vtkDataArray.newInstance({ empty: true }),
+    'Allowed to create instance with empty true, no data'
+  );
 
   t.throws(
     () => vtkDataArray.newInstance({ empty: false }),
-    'Create instance with empty false, no values'
+    'Not allowed to create instance with empty false, no data'
   );
 
   t.doesNotThrow(
     () => vtkDataArray.newInstance({ size: 256 }),
-    'Create instance with only size'
+    'Allowed to create instance with only size'
   );
 
   const dataArray0 = vtkDataArray.newInstance({
     empty: true,
-    values: null,
+    data: null,
   });
   t.deepEqual(
     {
@@ -46,7 +49,7 @@ test('Test vtkDataArray instance', (t) => {
       values: macro.newTypedArray(DefaultDataType, 0),
     },
     getDataArrayProperties(dataArray0),
-    'initialValues.values = null'
+    'initialValues.data = null'
   );
 
   const dataArray1 = vtkDataArray.newInstance({ size: 256 });
@@ -62,7 +65,7 @@ test('Test vtkDataArray instance', (t) => {
   );
 
   const dataArray2 = vtkDataArray.newInstance({
-    values: Uint32Array.from([1, 2, 3]),
+    data: Uint32Array.from([1, 2, 3]),
   });
   t.deepEqual(
     {
@@ -72,11 +75,11 @@ test('Test vtkDataArray instance', (t) => {
       values: Uint32Array.from([1, 2, 3]),
     },
     getDataArrayProperties(dataArray2),
-    'Create instance with values (typed array)'
+    'Create instance with data (typed array)'
   );
 
   const dataArray3 = vtkDataArray.newInstance({
-    values: [1, 2, 3],
+    data: [1, 2, 3],
   });
   t.deepEqual(
     {
@@ -86,11 +89,11 @@ test('Test vtkDataArray instance', (t) => {
       values: macro.newTypedArrayFrom(DefaultDataType, [1, 2, 3]),
     },
     getDataArrayProperties(dataArray3),
-    'Create instance with values (untyped array)'
+    'Create instance with data (untyped array)'
   );
 
   const dataArray4 = vtkDataArray.newInstance({
-    values: [1, 2, 3, 4, 5, 6, 7, 8, 9],
+    data: [1, 2, 3, 4, 5, 6, 7, 8, 9],
     numberOfComponents: 3,
   });
   t.deepEqual(
@@ -108,7 +111,7 @@ test('Test vtkDataArray instance', (t) => {
   );
 
   const dataArray5 = vtkDataArray.newInstance({
-    values: [1, 2, 3],
+    data: [1, 2, 3],
     dataType: null,
   });
   t.deepEqual(
@@ -176,28 +179,29 @@ test('Test vtkDataArray setData', (t) => {
     'Empty an instance (pass [] array)'
   );
 
-  // For both of those cases, check it does not change the DataArray
-  // Not supposed to call setData with typedArray = null
+  // Fill the DataArray before so that we are sure the size and the numberOfComponents is updated
+  dataArray.setData([1, 2, 3], 3);
   dataArray.setData(null);
   t.deepEqual(
     {
       dataType: DefaultDataType,
       size: 0,
       numberOfComponents: 1,
-      values: macro.newTypedArray(DefaultDataType),
+      values: null,
     },
     getDataArrayProperties(dataArray),
     'Call setData with typedArray = null'
   );
 
-  // Not supposed to call setData without parameters
+  // Fill the DataArray before so that we are sure the size and the numberOfComponents is updated
+  dataArray.setData([1, 2, 3], 3);
   dataArray.setData();
   t.deepEqual(
     {
       dataType: DefaultDataType,
       size: 0,
       numberOfComponents: 1,
-      values: macro.newTypedArray(DefaultDataType),
+      values: null,
     },
     getDataArrayProperties(dataArray),
     'Call setData with typedArray = undefined'
@@ -227,7 +231,7 @@ test('Test vtkDataArray getRange function with single-channel data.', (t) => {
 
   const da = vtkDataArray.newInstance({
     numberOfComponents: 1,
-    values: newArray,
+    data: newArray,
   });
 
   t.ok(da.getRange(0)[0] === 0, 'getRange minimum value should be 0');
@@ -250,7 +254,7 @@ test('Test vtkDataArray getRange function with multi-channel data.', (t) => {
 
   const da = vtkDataArray.newInstance({
     numberOfComponents: 3,
-    values: newArray,
+    data: newArray,
   });
 
   t.ok(da.getRange(0)[0] === 0, 'component:0 minimum value should be 0');

Sources/Common/Core/Points/index.js

@@ -82,6 +82,8 @@ function vtkPoints(publicAPI, model) {
 
 function defaultValues(initialValues) {
   return {
+    // empty is only here to be passed to the DataArray extend function in order
+    // to create Points without giving values
     empty: true,
     numberOfComponents: 3,
     dataType: VtkDataTypes.FLOAT,

Sources/Rendering/Misc/FullScreenRenderWindow/index.d.ts

@@ -128,6 +128,7 @@ export function extend(publicAPI: object, model: object, initialValues?: IFullSc
 /**
  * Method used to create a new instance of vtkFullScreenRenderWindow
  * @param {IFullScreenRenderWindowInitialValues} [initialValues] for pre-setting some of its content
+ *  a background property can be given in the initialValues to set the background of the renderer
  */
 export function newInstance(initialValues?: IFullScreenRenderWindowInitialValues): vtkFullScreenRenderWindow;
 

Sources/Rendering/Misc/FullScreenRenderWindow/index.js

@@ -200,9 +200,6 @@ function defaultValues(initialValues) {
 // ----------------------------------------------------------------------------
 
 export function extend(publicAPI, model, initialValues = {}) {
-  // a background property can be set in the initialValues but we do not want
-  // to "store" background, only forward it to the renderer
-
   Object.assign(initialValues, defaultValues(initialValues));
 
   // Object methods