use generator fn instead of an iterator class

Author: theSherwood

README.md

@@ -171,21 +171,27 @@ Clear tree
 tree.clear()
 ```
 
-### Iterator([interval, outputMapperFn])
-Returns a stateful iterator. <br/>
+### Iterate([interval, outputMapperFn])
+Returns an iterator (and iterable). <br/>
 Call `next` on the iterator to navigate to successor tree nodes and return the corresponding values. <br/>
-In the absence of a starting interval, the iterator will start with a `null` state. <br/>
-If there is no successor node when `next` is called, the iterator will have a `null` state and return `null`. <br/>
-If the iterator has a `null` state, calling `next` will take the iterator to the minimum node in the tree. 
+In the absence of a starting interval, the iterator will start with the lowest interval. <br/>
 ```javascript
-let iterator = tree.iterator();
-let next = iterator.next();
+let iterator = tree.iterate();
+let next = iterator.next().value;
 ```
 Optional *outputMapperFn(value, key)* enables to map search results into custom defined output. <br/>
 Example:
 ```javascript
-let iterator = tree.iterator([5,5], (value, key) => key);
-let next_key = iterator.next();
+let iterator = tree.iterate([5,5], (value, key) => key);
+let next_key = iterator.next().value;
+```
+Supports `for .. of` syntax. <br/>
+Example:
+```javascript
+for (let key of tree.iterate([5,5], (value, key) => key)) {
+    if (key[0] > 8) break;
+    console.log(key);
+}
 ```
 
 ## Documentation

package.json

@@ -11,7 +11,8 @@
   "types": "index.d.ts",
   "nyc": {
     "require": [
-      "@babel/register"
+      "@babel/register",
+      "@babel/polyfill"
     ],
     "sourceMap": false,
     "instrument": false

src/classes/intervalTree.js

@@ -3,7 +3,6 @@
  */
 'use strict';
 
-import Iterator from './iterator.js';
 import Node from './node.js';
 import {RB_TREE_COLOR_RED, RB_TREE_COLOR_BLACK} from '../utils/constants.js';
 
@@ -169,12 +168,21 @@ class IntervalTree {
     }
 
     /**
-     * @param {Interval} interval - may be null if the iterator is intended to start from the beginning or end
+     * @param {Interval} interval - optional if the iterator is intended to start from the beginning or end
      * @param outputMapperFn(value,key) - optional function that maps (value, key) to custom output
      * @returns {Iterator}
      */
-    iterator(interval, outputMapperFn = (value, key) => value === key ? key.output() : value) {
-        return new Iterator(this, interval, outputMapperFn);
+    *iterate(interval, outputMapperFn = (value, key) => value === key ? key.output() : value) {
+        let node;
+        if (interval) {
+            node = this.tree_search_nearest_forward(this.root, new Node(interval));
+        } else if (this.root) {
+            node = this.local_minimum(this.root);
+        }
+        while (node) {
+            yield outputMapperFn(node.item.value, node.item.key);
+            node = this.tree_successor(node);
+        }
     }
 
     recalc_max(node) {

src/classes/iterator.js

@@ -310,4 +310,69 @@ describe('#IntervalTree', function() {
         const resp2 = tree.search([4,11]);
         expect(resp2).to.deep.equal([[5,7],[7,8]]);
     })
+    describe('##Iterator', function() {
+        it('May find first intersecting interval', function () {
+            let tree = new IntervalTree();
+            let ints = [[6,8],[1,3],[5,12],[1,1],[5,7]];
+            for (let int of ints) tree.insert(int);
+            let iterator = tree.iterate([3,8]);
+            expect(iterator.next().value).to.deep.equal([1,3]);
+        });
+        it('May find first forward interval when there is no intersection', function () {
+            let tree = new IntervalTree();
+            let ints = [[6,8],[1,3],[5,12],[1,1],[5,7]];
+            for (let int of ints) tree.insert(int);
+            let iterator = tree.iterate([4,4]);
+            expect(iterator.next().value).to.deep.equal([5,7]);
+        });
+        it('May find first interval when no interval is passed', function () {
+            let tree = new IntervalTree();
+            let ints = [[6,8],[1,3],[5,12],[1,1],[5,7]];
+            for (let int of ints) tree.insert(int);
+            let iterator = tree.iterate();
+            expect(iterator.next().value).to.deep.equal([1,1]);
+        });
+        it('Supports iteration with `for .. of` syntax', function () {
+            let tree = new IntervalTree();
+            let ints = [[6,8],[1,3],[5,12],[1,1],[5,7]];
+            for (let int of ints) tree.insert(int);
+            let results = [];
+            for (let val of tree.iterate([4,4])) {
+                results.push(val);
+            }
+            expect(results).to.deep.equal([[5,7],[5,12],[6,8]]);
+        });
+        it('Returns `{done: true}` when it reaches the end', function () {
+            let tree = new IntervalTree();
+            let ints = [[6,8],[1,3],[5,12],[1,1],[5,7]];
+            for (let int of ints) tree.insert(int);
+            let iterator = tree.iterate([8,8]);
+            expect(iterator.next().value).to.deep.equal([5,12]);
+            expect(iterator.next().value).to.deep.equal([6,8]);
+            let res = iterator.next();
+            expect(res.value).to.equal(undefined);
+            expect(res.done).to.equal(true);
+        });
+        it('Supports custom transformed objects', function () {
+            const composers = [
+                {name: "Ludwig van Beethoven", period: [1770,1827]},
+                {name: "Johann Sebastian Bach", period: [1685, 1750]},
+                {name: "Wolfgang Amadeus Mozart", period: [1756, 1791]},
+                {name: "Johannes Brahms", period: [1833, 1897]},
+                {name: "Richard Wagner", period: [1813, 1883]},
+                {name: "Claude Debussy", period: [1862, 1918]},
+                {name: "Pyotr Ilyich Tchaikovsky", period: [1840, 1893]},
+                {name: "Frédéric Chopin", period: [1810, 1849]},
+                {name: "Joseph Haydn", period: [1732, 1809]},
+                {name: "Antonio Vivaldi", period: [1678, 1741]}
+            ];
+            const tree = new IntervalTree();
+            for (let composer of composers)
+                tree.insert(composer.period, composer.name);
+            let iterator = tree.iterate([1600, 1700],
+                (name, period) => {return `${name} (${period.low}-${period.high})`});
+            expect(iterator.next().value).to.equal("Antonio Vivaldi (1678-1741)");
+            expect(iterator.next().value).to.equal("Johann Sebastian Bach (1685-1750)");
+        });
+    });
 });