👕 refactor: Initial lint.

Author: make-github-pseudonymous-again

doc/scripts/header.js

@@ -1,34 +1,31 @@
-var domReady = function(callback) {
-	var state = document.readyState ;
-    if ( state === 'interactive' || state === 'complete' ) {
-		callback() ;
-	}
-	else {
+const domReady = function (callback) {
+	const state = document.readyState;
+	if (state === 'interactive' || state === 'complete') {
+		callback();
+	} else {
 		document.addEventListener('DOMContentLoaded', callback);
 	}
-} ;
-
+};
 
-domReady(function(){
-
-	var projectname = document.createElement('a');
+domReady(() => {
+	const projectname = document.createElement('a');
 	projectname.classList.add('project-name');
 	projectname.text = 'data-structures-and-algorithms/heapq';
-	projectname.href = './index.html' ;
+	projectname.href = './index.html';
 
-	var header = document.getElementsByTagName('header')[0] ;
-	header.insertBefore(projectname,header.firstChild);
+	const header = document.querySelectorAll('header')[0];
+	header.insertBefore(projectname, header.firstChild);
 
-	var testlink = document.querySelector('header > a[data-ice="testLink"]') ;
-	testlink.href = 'https://coveralls.io/github/data-structures-and-algorithms/heapq' ;
-	testlink.target = '_BLANK' ;
+	const testlink = document.querySelector('header > a[data-ice="testLink"]');
+	testlink.href =
+		'https://coveralls.io/github/data-structures-and-algorithms/heapq';
+	testlink.target = '_BLANK';
 
-	var searchBox = document.querySelector('.search-box');
-	var input = document.querySelector('.search-input');
+	const searchBox = document.querySelector('.search-box');
+	const input = document.querySelector('.search-input');
 
-	// active search box when focus on searchBox.
-	input.addEventListener('focus', function(){
+	// Active search box when focus on searchBox.
+	input.addEventListener('focus', () => {
 		searchBox.classList.add('active');
 	});
-
 });

package.json

@@ -198,6 +198,7 @@
       "unicorn"
     ],
     "rules": {
+      "unicorn/prefer-node-protocol": "off",
       "unicorn/filename-case": "off",
       "camelcase": "off",
       "unicorn/prevent-abbreviations": "off",

src/core/Heap.js

@@ -1,7 +1,4 @@
-
-export default function Heap ( compare , data ) {
-
-	this.compare = compare ;
-	this.data = data ;
-
+export default function Heap(compare, data) {
+	this.compare = compare;
+	this.data = data;
 }

src/core/index.js

@@ -1,21 +1,7 @@
-import Heap from './Heap.js' ;
-import keeporder from './keeporder.js' ;
-import nextchild from './nextchild.js' ;
-import siftdown from './siftdown.js' ;
-import siftup from './siftup.js' ;
+import Heap from './Heap.js';
+import keeporder from './keeporder.js';
+import nextchild from './nextchild.js';
+import siftdown from './siftdown.js';
+import siftup from './siftup.js';
 
-export default {
-	Heap ,
-	keeporder ,
-	nextchild ,
-	siftdown ,
-	siftup ,
-} ;
-
-export {
-	Heap ,
-	keeporder ,
-	nextchild ,
-	siftdown ,
-	siftup ,
-} ;
+export {Heap, keeporder, nextchild, siftdown, siftup};

src/core/keeporder.js

@@ -1,5 +1,6 @@
-import { increasing } from '@total-order/primitive' ;
+import {increasing} from '@total-order/primitive';
 
-const keeporder = compare => ( a , b ) => compare( a[0] , b[0] ) || increasing( a[1] , b[1] ) ;
+const keeporder = (compare) => (a, b) =>
+	compare(a[0], b[0]) || increasing(a[1], b[1]);
 
-export default keeporder ;
+export default keeporder;

src/core/nextchild.js

@@ -1,4 +1,4 @@
-
+import assert from 'assert';
 
 /**
  * Computes which child is the smallest according
@@ -8,16 +8,15 @@
  *
  * @param {function} compare the comparison function
  * @param {array} a the array where the heap is stored
- * @param {int} i is the first child
- * @param {int} j - 1 is the last leaf
+ * @param {number} i is the first child
+ * @param {number} j - 1 is the last leaf
+ *
+ * @return {number}
  */
+export default function nextchild(compare, a, i, j) {
+	assert(i < j);
+	if (j - i === 1) return i;
 
-export default function nextchild ( compare , a , i , j ) {
-
-	if ( j - i < 2 ) return i ;
-
-	if ( compare( a[i] , a[i+1] ) <= 0 ) return i ;
-
-	return i + 1 ;
-
+	assert(j - i >= 2);
+	return compare(a[i], a[i + 1]) <= 0 ? i : i + 1;
 }

src/core/siftdown.js

@@ -1,49 +1,45 @@
-import nextchild from './nextchild.js' ;
+import nextchild from './nextchild.js';
 
 /**
  * Sifts down a node.
  *
  * @param {function} compare the comparison function
  * @param {array} a the array where the heap is stored
- * @param {int} i is the root element
- * @param {int} j - 1 is the last leaf
- * @param {int} k is the target node
+ * @param {number} i is the root element
+ * @param {number} j - 1 is the last leaf
+ * @param {number} k is the target node
  */
 
-export default function siftdown ( compare, a, i, j, k ) {
-
+export default function siftdown(compare, a, i, j, k) {
 	let current = k - i;
 
-	while ( true ) {
-
-		// address of the first child in a zero-based
+	while (true) {
+		// Address of the first child in a zero-based
 		// binary heap
 
 		const firstchild = 2 * current + 1;
 
-		// if current node has no children
+		// If current node has no children
 		// then we are done
 
-		if ( firstchild >= j - i ) break ;
+		if (firstchild >= j - i) break;
 
-		// if current value is smaller than its smallest
+		// If current value is smaller than its smallest
 		// child then we are done
 
-		const candidate = nextchild( compare, a, i + firstchild, j );
+		const candidate = nextchild(compare, a, i + firstchild, j);
 
-		if ( compare( a[i + current], a[candidate] ) <= 0 ) break ;
+		if (compare(a[i + current], a[candidate]) <= 0) break;
 
-		// otherwise
+		// Otherwise
 		// swap with smallest child
 
-		const tmp = a[i+current] ;
-		a[i+current] = a[candidate] ;
-		a[candidate] = tmp ;
+		const tmp = a[i + current];
+		a[i + current] = a[candidate];
+		a[candidate] = tmp;
 
 		current = candidate - i;
-
 	}
 
 	return i + current;
-
 }

src/core/siftup.js

@@ -1,43 +1,38 @@
-
 /**
  * Sifts up a node.
  *
  * @param {function} compare the comparison function
  * @param {array} a the array where the heap is stored
- * @param {int} i is the root element
- * @param {int} j - 1 is the last leaf
- * @param {int} k is the target node
+ * @param {number} i is the root element
+ * @param {number} j - 1 is the last leaf
+ * @param {number} k is the target node
  */
 
-export default function siftup ( compare , a , i , j , k ) {
-
-	let current = k - i ;
-
-	// while we are not the root
+export default function siftup(compare, a, i, j, k) {
+	let current = k - i;
 
-	while ( current !== 0 ) {
+	// While we are not the root
 
-		// address of the parent in a zero-based
+	while (current !== 0) {
+		// Address of the parent in a zero-based
 		// d-ary heap
 
-		const parent = i + ( ( current - 1 ) >>> 1 ) ;
+		const parent = i + ((current - 1) >>> 1);
 
-		// if current value is greater than its parent
+		// If current value is greater than its parent
 		// then we are done
 
-		if ( compare( a[i + current], a[parent] ) >= 0 ) return i + current ;
+		if (compare(a[i + current], a[parent]) >= 0) return i + current;
 
-		// otherwise
+		// Otherwise
 		// swap with parent
 
-		const tmp = a[i+current] ;
-		a[i+current] = a[parent] ;
-		a[parent] = tmp ;
-
-		current = parent - i ;
+		const tmp = a[i + current];
+		a[i + current] = a[parent];
+		a[parent] = tmp;
 
+		current = parent - i;
 	}
 
-	return i + current ;
-
+	return i + current;
 }

src/heapify.js

@@ -1,4 +1,4 @@
-import { siftdown , Heap } from './core/index.js' ;
+import {siftdown, Heap} from './core/index.js';
 
 /**
  * Builds a heap in O(n) operations.
@@ -8,16 +8,12 @@ import { siftdown , Heap } from './core/index.js' ;
  *
  */
 
-export default function heapify ( compare , x ) {
-
-	const n = x.length ;
-
-	for ( let k = n / 2 | 0 ; k ; ) {
-
-		siftdown( compare , x , 0 , n , --k ) ;
+export default function heapify(compare, x) {
+	const n = x.length;
 
+	for (let k = (n / 2) | 0; k; ) {
+		siftdown(compare, x, 0, n, --k);
 	}
 
-	return new Heap( compare , x ) ;
-
+	return new Heap(compare, x);
 }

src/heappop.js

@@ -1,27 +1,25 @@
-import { IndexError } from '@failure-abstraction/error' ;
-import { siftdown } from './core/index.js' ;
+import {IndexError} from '@failure-abstraction/error';
+import {siftdown} from './core/index.js';
 
-export default function heappop ( heap ) {
+export default function heappop(heap) {
+	const x = heap.data;
+	const n = x.length;
 
-	const x = heap.data ;
-	const n = x.length ;
+	if (n === 0) throw new IndexError('heappop');
 
-	if ( n === 0 ) throw new IndexError( "heappop" ) ;
+	const last = n - 1;
 
-	const last = n - 1 ;
+	// Swap last leaf and root
 
-	// swap last leaf and root
+	const tmp = x[0];
+	x[0] = x[last];
+	x[last] = tmp;
 
-	const tmp = x[0] ;
-	x[0] = x[last] ;
-	x[last] = tmp ;
+	// Sift down the new root
 
-	// sift down the new root
+	siftdown(heap.compare, x, 0, last, 0);
 
-	siftdown( heap.compare , x , 0 , last , 0 ) ;
-
-	// return old root
-
-	return x.pop( ) ;
+	// Return old root
 
+	return x.pop();
 }

src/heappush.js

@@ -1,14 +1,12 @@
-import { siftup } from './core/index.js' ;
+import {siftup} from './core/index.js';
 
- export default function heappush ( heap , item ) {
+export default function heappush(heap, item) {
+	const x = heap.data;
+	const n = x.length;
 
-	const x = heap.data ;
-	const n = x.length ;
+	x.push(item);
 
-	x.push( item ) ;
-
-	// sift up the new leaf
-
-	siftup( heap.compare , x , 0 , n + 1 , n ) ;
+	// Sift up the new leaf
 
+	siftup(heap.compare, x, 0, n + 1, n);
 }

src/heappushpop.js

@@ -1,24 +1,22 @@
-import { siftdown } from './core/index.js' ;
+import {siftdown} from './core/index.js';
 
-export default function heappushpop ( heap , item ) {
+export default function heappushpop(heap, item) {
+	const x = heap.data;
+	const n = x.length;
 
-	const x = heap.data ;
-	const n = x.length ;
+	if (n === 0) return item;
 
-	if ( n === 0 ) return item ;
+	const compare = heap.compare;
 
-	const compare = heap.compare ;
+	if (compare(item, x[0]) <= 0) return item;
 
-	if ( compare( item , x[0] ) <= 0 ) return item ;
+	const smallest = x[0];
 
-	const smallest = x[0] ;
+	x[0] = item;
 
-	x[0] = item ;
+	// Sift down the new root
 
-	// sift down the new root
-
-	siftdown( compare , x , 0 , n , 0 ) ;
-
-	return smallest ;
+	siftdown(compare, x, 0, n, 0);
 
+	return smallest;
 }