refactor!: return an object instead of throw error when timeout exceeded (#13)

Author: hamed-musallam

src/__tests__/conrec.test.js

@@ -9,60 +9,77 @@ const parsed = convert(data, { noContour: true }).flatten[0];
 describe('conrec basic test', () => {
   it('no result because level too far', () => {
     const conrec = new Conrec(parsed.minMax.z);
-    const basic = conrec.drawContour({
+    const { contours, timeout } = conrec.drawContour({
       contourDrawer: 'basic',
       levels: [-1000000000, 1000000000],
       timeout: 10000,
     });
-
-    expect(basic).toStrictEqual([
+    expect(timeout).toBeFalsy();
+    expect(contours).toStrictEqual([
       { lines: [], zValue: -1000000000 },
       { lines: [], zValue: 1000000000 },
     ]);
   });
 
   it('2 specified levels', () => {
     const conrec = new Conrec(parsed.minMax.z);
-    const basic = conrec.drawContour({
+    const { contours, timeout } = conrec.drawContour({
       contourDrawer: 'basic',
       levels: [-100000, 100000],
       timeout: 10000,
     });
-
-    expect(basic).toHaveLength(2);
-    expect(basic[0].lines).toHaveLength(36864);
-    expect(basic[1].lines).toHaveLength(119720);
+    expect(timeout).toBeFalsy();
+    expect(contours).toHaveLength(2);
+    expect(contours[0].lines).toHaveLength(36864);
+    expect(contours[1].lines).toHaveLength(119720);
   });
 
   it('auto select levels', () => {
     const conrec = new Conrec(parsed.minMax.z);
-    const basic = conrec.drawContour({
+    const { contours, timeout } = conrec.drawContour({
       contourDrawer: 'basic',
       nbLevels: 10,
       timeout: 10000,
     });
 
-    expect(basic).toHaveLength(10);
-    expect(basic[0].lines).toHaveLength(0);
-    expect(basic[1].lines).toHaveLength(4984);
-    expect(basic[8].lines).toHaveLength(32);
-    expect(basic[8].lines).toMatchSnapshot();
-    expect(basic[9].lines).toHaveLength(0);
+    expect(timeout).toBeFalsy();
+    expect(contours).toHaveLength(10);
+    expect(contours[0].lines).toHaveLength(0);
+    expect(contours[1].lines).toHaveLength(4984);
+    expect(contours[8].lines).toHaveLength(32);
+    expect(contours[8].lines).toMatchSnapshot();
+    expect(contours[9].lines).toHaveLength(0);
   });
 
   it('auto select levels with swapAxes', () => {
     const conrec = new Conrec(parsed.minMax.z, { swapAxes: true });
-    const basic = conrec.drawContour({
+    const { contours, timeout } = conrec.drawContour({
       contourDrawer: 'basic',
       nbLevels: 10,
       timeout: 10000,
     });
 
-    expect(basic).toHaveLength(10);
-    expect(basic[0].lines).toHaveLength(0);
-    expect(basic[1].lines).toHaveLength(4984);
-    expect(basic[8].lines).toHaveLength(32);
-    expect(basic[8].lines).toMatchSnapshot();
-    expect(basic[9].lines).toHaveLength(0);
+    expect(timeout).toBeFalsy();
+    expect(contours).toHaveLength(10);
+    expect(contours[0].lines).toHaveLength(0);
+    expect(contours[1].lines).toHaveLength(4984);
+    expect(contours[8].lines).toHaveLength(32);
+    expect(contours[8].lines).toMatchSnapshot();
+    expect(contours[9].lines).toHaveLength(0);
+  });
+
+  it('return available contours within 100ms', () => {
+    const conrec = new Conrec(parsed.minMax.z);
+    const { contours, timeout } = conrec.drawContour({
+      contourDrawer: 'basic',
+      nbLevels: 10,
+      timeout: 100,
+    });
+    expect(timeout).toBeTruthy();
+    expect(contours).toHaveLength(10);
+    expect(contours[0].lines).toHaveLength(0);
+    expect(contours[1].lines.length).toBeLessThan(2000);
+    expect(contours[8].lines).toHaveLength(0);
+    expect(contours[9].lines).toHaveLength(0);
   });
 });

src/__tests__/shape.test.js

@@ -11,11 +11,12 @@ describe('shape', () => {
     `);
 
     const conrec = new Conrec(matrix);
-    const shape = conrec.drawContour({
+    const { contours, timeout } = conrec.drawContour({
       contourDrawer: 'shape',
       levels: [0.5],
     });
-    expect(shape[0]).toHaveLength(25);
+    expect(timeout).toBeFalsy();
+    expect(contours[0]).toHaveLength(25);
   });
 
   it('2 squares', () => {
@@ -28,12 +29,13 @@ describe('shape', () => {
     `);
 
     const conrec = new Conrec(matrix);
-    const shape = conrec.drawContour({
+    const { contours, timeout } = conrec.drawContour({
       contourDrawer: 'shape',
       levels: [0.5],
     });
 
-    expect(shape[0]).toHaveLength(25);
+    expect(timeout).toBeFalsy();
+    expect(contours[0]).toHaveLength(25);
   });
 
   it('2 diagonal squares', () => {
@@ -49,12 +51,12 @@ describe('shape', () => {
     `);
 
     const conrec = new Conrec(matrix);
-    const shape = conrec.drawContour({
+    const { contours, timeout } = conrec.drawContour({
       contourDrawer: 'shape',
       levels: [0.5],
     });
-
-    expect(shape[0]).toHaveLength(49);
+    expect(timeout).toBeFalsy();
+    expect(contours[0]).toHaveLength(49);
   });
 });
 

src/calculateContour.js

@@ -99,6 +99,7 @@ const MINUSEPSILON = 0 - EPSILON;
  * @param {number} [options.iub] - index bounds of data matrix
  * @param {number} [options.jlb] - index bounds of data matrix
  * @param {number} [options.jub] - index bounds of data matrix
+ * @returns {boolean} - Whether contour generation had to stop early because it reached the timeout
  */
 export function calculateContour(matrix, x, y, z, contourDrawer, options = {}) {
   const {
@@ -117,13 +118,16 @@ export function calculateContour(matrix, x, y, z, contourDrawer, options = {}) {
   const znc1 = z[nc - 1];
 
   const start = Date.now();
+
   /** private */
   function xsect(p1, p2) {
     return (h[p2] * xh[p1] - h[p1] * xh[p2]) / (h[p2] - h[p1]);
   }
+
   function ysect(p1, p2) {
     return (h[p2] * yh[p1] - h[p1] * yh[p2]) / (h[p2] - h[p1]);
   }
+
   let m1;
   let m2;
   let m3;
@@ -160,9 +164,8 @@ export function calculateContour(matrix, x, y, z, contourDrawer, options = {}) {
   //  for (let j = jlb; j < jub; j++) {
   for (let j = jub - 1; j >= jlb; j--) {
     if (timeout && Date.now() - start > timeout) {
-      throw new Error(
-        `timeout: contour generation could not finish in less than ${timeout}ms`,
-      );
+      // `timeout: contour generation could not finish in less than ${timeout}ms`
+      return true;
     }
     for (let i = ilb; i < iub; i++) {
       let dij = matrix[i][j];
@@ -319,4 +322,5 @@ export function calculateContour(matrix, x, y, z, contourDrawer, options = {}) {
       }
     }
   }
+  return false;
 }

src/index.js

@@ -40,16 +40,22 @@ export class Conrec {
     this.hasMinMax = false;
   }
 
+  /**
+   * @typedef {Object} Output
+   * @property {any} contours
+   * @property {boolean} timeout - Whether contour generation had to stop early because it reached the timeout
+   */
+
   /**
    *
    * @param {number[]} [options.levels]
    * @param {number} [options.nbLevels=10]
    * @param {string} [options.contourDrawer='basic'] - 'basic' or 'shape'
    * @param {number} [options.timeout=0]
-   * @return {any}
+   * @return {Output}
    */
   drawContour(options) {
-    options = Object.assign({}, defaultOptions, options);
+    options = { ...defaultOptions, ...options };
 
     let levels;
     if (options.levels) {
@@ -73,11 +79,18 @@ export class Conrec {
     } else {
       throw new TypeError('contourDrawer must be a string');
     }
+    const isTimeout = calculateContour(
+      this.matrix,
+      this.xs,
+      this.ys,
+      levels,
+      contourDrawer,
+      {
+        timeout: options.timeout,
+      },
+    );
 
-    calculateContour(this.matrix, this.xs, this.ys, levels, contourDrawer, {
-      timeout: options.timeout,
-    });
-    return contourDrawer.getContour();
+    return { contours: contourDrawer.getContour(), timeout: isTimeout };
   }
 
   _computeMinMax() {