Revert "add missing jsdocs"

This reverts commit 817f6d7.

.babelrc

@@ -1,3 +1,3 @@
 {
-  "presets": []
-}
+  "presets": ["@babel/preset-env"]
+}

src/rendering/getLut.js

@@ -10,7 +10,6 @@ import generateLut from '../internal/generateLut.js';
  * @param {Boolean} invalidated Whether or not the LUT data has been invalidated
  * (e.g. by a change to the windowWidth, windowCenter, or invert viewport parameters).
  * @return {Uint8ClampedArray} LUT Array
- * @memberof rendering
  */
 export default function (image, viewport, invalidated) {
   // If we have a cached lut and it has the right values, return it immediately

src/rendering/initializeRenderCanvas.js

@@ -1,11 +1,3 @@
-/**
- * Sets size and clears canvas
- * 
- * @param {Object} enabledElement Cornerstone Enabled Element 
- * @param {Object} image Image to be rendered
- * @returns {void}
- * @memberof rendering
- */
 export default function (enabledElement, image) {
   const renderCanvas = enabledElement.renderingTools.renderCanvas;
 

src/rendering/renderColorImage.js

@@ -8,21 +8,12 @@ import doesImageNeedToBeRendered from './doesImageNeedToBeRendered.js';
 import initializeRenderCanvas from './initializeRenderCanvas.js';
 import saveLastRendered from './saveLastRendered.js';
 
-/**
- * Generates an appropriate Look Up Table to render the given image with the given window width and level (specified in the viewport)
- * Uses an internal cache for performance
- * 
- * @param {Object} image  The image to be rendered
- * @param {Object} viewport The viewport values used for rendering
- * @returns {Uint8ClampedArray} Look Up Table array.
- * @memberof rendering
- */
-function getLut(image, viewport) {
+function getLut (image, viewport) {
   // If we have a cached lut and it has the right values, return it immediately
   if (image.cachedLut !== undefined &&
-    image.cachedLut.windowCenter === viewport.voi.windowCenter &&
-    image.cachedLut.windowWidth === viewport.voi.windowWidth &&
-    image.cachedLut.invert === viewport.invert) {
+        image.cachedLut.windowCenter === viewport.voi.windowCenter &&
+        image.cachedLut.windowWidth === viewport.voi.windowWidth &&
+        image.cachedLut.invert === viewport.invert) {
     return image.cachedLut.lutArray;
   }
 
@@ -34,17 +25,8 @@ function getLut(image, viewport) {
 
   return image.cachedLut.lutArray;
 }
-/**
- * Returns an appropriate canvas to render the Image. If the canvas available in the cache is appropriate
- * it is returned, otherwise adjustments are made. It also sets the color transfer functions.
- * 
- * @param {Object} enabledElement The cornerstone enabled element
- * @param {Object} image The image to be rendered
- * @param {Boolean} invalidated Is pixel data valid
- * @returns {HTMLCanvasElement} An appropriate canvas for rendering the image
- * @memberof rendering
- */
-function getRenderCanvas(enabledElement, image, invalidated) {
+
+function getRenderCanvas (enabledElement, image, invalidated) {
   const canvasWasColor = enabledElement.renderingTools.lastRenderedIsColor === true;
 
   if (!enabledElement.renderingTools.renderCanvas || !canvasWasColor) {
@@ -56,10 +38,10 @@ function getRenderCanvas(enabledElement, image, invalidated) {
   // The ww/wc is identity and not inverted - get a canvas with the image rendered into it for
   // Fast drawing
   if (enabledElement.viewport.voi.windowWidth === 255 &&
-    enabledElement.viewport.voi.windowCenter === 128 &&
-    enabledElement.viewport.invert === false &&
-    image.getCanvas &&
-    image.getCanvas()
+        enabledElement.viewport.voi.windowCenter === 128 &&
+        enabledElement.viewport.invert === false &&
+        image.getCanvas &&
+        image.getCanvas()
   ) {
     return image.getCanvas();
   }
@@ -109,7 +91,7 @@ function getRenderCanvas(enabledElement, image, invalidated) {
  * @returns {void}
  * @memberof rendering
  */
-export function renderColorImage(enabledElement, invalidated) {
+export function renderColorImage (enabledElement, invalidated) {
   if (enabledElement === undefined) {
     throw new Error('renderColorImage: enabledElement parameter must not be undefined');
   }
@@ -159,7 +141,7 @@ export function renderColorImage(enabledElement, invalidated) {
   enabledElement.renderingTools = saveLastRendered(enabledElement);
 }
 
-export function addColorLayer(layer, invalidated) {
+export function addColorLayer (layer, invalidated) {
   if (layer === undefined) {
     throw new Error('addColorLayer: layer parameter must not be undefined');
   }

src/rendering/renderGrayscaleImage.js

@@ -8,18 +8,7 @@ import doesImageNeedToBeRendered from './doesImageNeedToBeRendered.js';
 import initializeRenderCanvas from './initializeRenderCanvas.js';
 import saveLastRendered from './saveLastRendered.js';
 
-/**
- * Returns an appropriate canvas to render the Image. If the canvas available in the cache is appropriate
- * it is returned, otherwise adjustments are made. It also sets the color transfer functions.
- * 
- * @param {Object} enabledElement The cornerstone enabled element
- * @param {Object} image The image to be rendered
- * @param {Boolean} invalidated Is pixel data valid
- * @param {Boolean} [useAlphaChannel = true] Will an alpha channel be used
- * @returns {HTMLCanvasElement} An appropriate canvas for rendering the image
- * @memberof rendering
- */
-function getRenderCanvas(enabledElement, image, invalidated, useAlphaChannel = true) {
+function getRenderCanvas (enabledElement, image, invalidated, useAlphaChannel = true) {
   const canvasWasColor = enabledElement.renderingTools.lastRenderedIsColor === true;
 
   if (!enabledElement.renderingTools.renderCanvas || canvasWasColor) {
@@ -72,7 +61,7 @@ function getRenderCanvas(enabledElement, image, invalidated, useAlphaChannel = t
  * @returns {void}
  * @memberof rendering
  */
-export function renderGrayscaleImage(enabledElement, invalidated) {
+export function renderGrayscaleImage (enabledElement, invalidated) {
   if (enabledElement === undefined) {
     throw new Error('drawImage: enabledElement parameter must not be undefined');
   }
@@ -131,7 +120,7 @@ export function renderGrayscaleImage(enabledElement, invalidated) {
                                         This does not work if this layer is not the first layer in the enabledElement.
  * @returns {void}
  */
-export function addGrayscaleLayer(layer, invalidated, useAlphaChannel = false) {
+export function addGrayscaleLayer (layer, invalidated, useAlphaChannel = false) {
   if (layer === undefined) {
     throw new Error('addGrayscaleLayer: layer parameter must not be undefined');
   }

src/rendering/renderLabelMapImage.js

@@ -6,17 +6,7 @@ import doesImageNeedToBeRendered from './doesImageNeedToBeRendered.js';
 import storedPixelDataToCanvasImageDataColorLUT from '../internal/storedPixelDataToCanvasImageDataColorLUT.js';
 import colors from '../colors/index.js';
 
-/**
- * Returns an appropriate canvas to render the Image. If the canvas available in the cache is appropriate
- * it is returned, otherwise adjustments are made. It also sets the color transfer functions.
- * 
- * @param {Object} enabledElement The cornerstone enabled element
- * @param {Object} image The image to be rendered
- * @param {Boolean} invalidated Is pixel data valid
- * @returns {HTMLCanvasElement} An appropriate canvas for rendering the image
- * @memberof rendering
- */
-function getRenderCanvas(enabledElement, image, invalidated) {
+function getRenderCanvas (enabledElement, image, invalidated) {
   if (!enabledElement.renderingTools.renderCanvas) {
     enabledElement.renderingTools.renderCanvas = document.createElement('canvas');
   }
@@ -81,7 +71,7 @@ function getRenderCanvas(enabledElement, image, invalidated) {
  * @returns {void}
  * @memberof rendering
  */
-export function renderLabelMapImage(enabledElement, invalidated) {
+export function renderLabelMapImage (enabledElement, invalidated) {
   if (enabledElement === undefined) {
     throw new Error('renderLabelMapImage: enabledElement parameter must not be undefined');
   }
@@ -130,7 +120,7 @@ export function renderLabelMapImage(enabledElement, invalidated) {
  * @param {Boolean} invalidated - true if pixel data has been invalidated and cached rendering should not be used
  * @returns {void}
  */
-export function addLabelMapLayer(layer, invalidated) {
+export function addLabelMapLayer (layer, invalidated) {
   if (layer === undefined) {
     throw new Error('addLabelMapLayer: layer parameter must not be undefined');
   }

src/rendering/renderPseudoColorImage.js

@@ -7,17 +7,7 @@ import doesImageNeedToBeRendered from './doesImageNeedToBeRendered.js';
 import storedPixelDataToCanvasImageDataPseudocolorLUT from '../internal/storedPixelDataToCanvasImageDataPseudocolorLUT.js';
 import colors from '../colors/index.js';
 
-/**
- * Returns an appropriate canvas to render the Image. If the canvas available in the cache is appropriate
- * it is returned, otherwise adjustments are made. It also sets the color transfer functions.
- * 
- * @param {Object} enabledElement The cornerstone enabled element
- * @param {Object} image The image to be rendered
- * @param {Boolean} invalidated Is pixel data valid
- * @returns {HTMLCanvasElement} An appropriate canvas for rendering the image
- * @memberof rendering
- */
-function getRenderCanvas(enabledElement, image, invalidated) {
+function getRenderCanvas (enabledElement, image, invalidated) {
   if (!enabledElement.renderingTools.renderCanvas) {
     enabledElement.renderingTools.renderCanvas = document.createElement('canvas');
   }
@@ -53,7 +43,7 @@ function getRenderCanvas(enabledElement, image, invalidated) {
   let start = now();
 
   if (!enabledElement.renderingTools.colorLut || invalidated ||
-    enabledElement.renderingTools.colormapId !== colormapId) {
+       enabledElement.renderingTools.colormapId !== colormapId) {
     colormap.setNumberOfColors(256);
     enabledElement.renderingTools.colorLut = colormap.createLookupTable();
     enabledElement.renderingTools.colormapId = colormapId;
@@ -85,7 +75,7 @@ function getRenderCanvas(enabledElement, image, invalidated) {
  * @returns {void}
  * @memberof rendering
  */
-export function renderPseudoColorImage(enabledElement, invalidated) {
+export function renderPseudoColorImage (enabledElement, invalidated) {
   if (enabledElement === undefined) {
     throw new Error('drawImage: enabledElement parameter must not be undefined');
   }
@@ -135,7 +125,7 @@ export function renderPseudoColorImage(enabledElement, invalidated) {
  * @param {Boolean} invalidated - true if pixel data has been invalidated and cached rendering should not be used
  * @returns {void}
  */
-export function addPseudoColorLayer(layer, invalidated) {
+export function addPseudoColorLayer (layer, invalidated) {
   if (layer === undefined) {
     throw new Error('addPseudoColorLayer: layer parameter must not be undefined');
   }

src/rendering/renderToCanvas.js

@@ -4,32 +4,18 @@ import drawImageSync from '../internal/drawImageSync.js';
 import getDefaultViewport from '../internal/getDefaultViewport.js';
 import tryEnableWebgl from '../internal/tryEnableWebgl.js';
 
-/**
- * @typedef {Object} EnabledElementStub
- * @property {HTMLElement} element  The enabled element
- * @property {HTMLCanvasElement} canvas The current canvas
- * @property {Object} image Currently displayed image
- * @property {Boolean} invalid Whether or not the image pixel data has been changed
- * @property {Boolean} needsRedraw  A flag for triggering a redraw of the canvas without re-retrieving the pixel data, since it remains valid
- * @property {Object} options Layer drawing options
- * @property {Object[]} layers Layers added to the EnabledElement
- * @property {Object} data
- * @property {Object} renderingTools
- * @property {Object} viewport The current viewport
- * @memberof rendering
- */
 
 /**
  * creates a dummy enabled element
  *
- * @param {HTMLCanvasElement} canvas the canvas that will be assigned to the enabled element.
+ * @param {any} canvas the canvas that will be assigned to the enabled element.
  * @param {any} image An Image loaded by a Cornerstone Image Loader
  * @param { any } options Options for rendering the image (e.g.enable webgl by {renderer: 'webgl' })
  * @param { any } viewport A set of Cornerstone viewport parameters
- * @returns {EnabledElementStub} a dummy enabled element
+ * @returns { element, canvas,image, invalid: Boolean, needsRedraw: Booleans, options, layers: [], data, renderingTools, viewport} a dummy enabled element
  * @memberof rendering
  */
-function createEnabledElementStub(canvas, image, options, viewport) {
+function createEnabledElementStub (canvas, image, options, viewport) {
   return {
     element: canvas,
     canvas,
@@ -48,8 +34,8 @@ function createEnabledElementStub(canvas, image, options, viewport) {
  * Render the image to the provided canvas immediately.
  * @param {any} canvas The HTML canvas where the image will be rendered.
  * @param {any} image An Image loaded by a Cornerstone Image Loader
- * @param {any} [viewport = null] A set of Cornerstone viewport parameters
- * @param {any} [options = null] Options for rendering the image (e.g. enable webgl by {renderer: 'webgl'})
+ * @param {any} viewport A set of Cornerstone viewport parameters
+ * @param {any} options Options for rendering the image (e.g. enable webgl by {renderer: 'webgl'})
  * @returns {void}
  * @memberof rendering
  */

src/rendering/saveLastRendered.js

@@ -1,11 +1,3 @@
-/**
- * Saves the parameters of the last render into renderingTools, used later to decide if data can be reused.
- * 
- * @param {Object} enabledElement Cornerstone EnabledElement 
- * @returns {Object} enabledElement.renderingTools
- * @memberof rendering
- */
-
 export default function (enabledElement) {
   const imageId = enabledElement.image.imageId;
   const viewport = enabledElement.viewport;