Fix linting

Author: crutchcorn

example/example.js

@@ -1,6 +1,6 @@
-import {remark} from 'remark'
+import {remark} from 'remark';
 import {is} from 'unist-util-is';
-import replaceAllBetween from '../all.js';
+import replaceAllBetween from '..';
 
 const markdown = `
 # Hello World!
@@ -59,8 +59,8 @@ asdf
  * @returns {Section[]}
  */
 const getSections = (allChildren, headerIndexes) =>
-  headerIndexes.map((_, i, arr) => {
-    let [startIndex, endIndex] = [arr[i], arr[i + 1]];
+  headerIndexes.map((_, i, array) => {
+    let [startIndex, endIndex] = [array[i], array[i + 1]];
     const header = allChildren[startIndex];
     startIndex += 1;
 
@@ -84,36 +84,30 @@ const plugin = () => (tree) => {
   };
 
   // Get lists between `start` and `end`
-  replaceAllBetween(tree, start, end, list => {
+  replaceAllBetween(tree, start, end, (list) => {
     // Remove both `tabs` mention
-    // list.shift();
-    // list.pop()
-
-    console.log({list});
+    list.shift();
+    list.pop();
 
     const headerIndexes = list
       .map((node, i) => is(node, {type: 'heading'}) && i)
-      .filter(Number.isInteger)
-
-    return [{
-      type: 'html',
-      value: headerIndexes.toString()
-    }]
-
-    // const sections = getSections(list, headerIndexes);
-    //
-    // const tabNodes = sections.map(section => {
-    //   return {
-    //     type: 'tab',
-    //     heading: section.heading,
-    //     children: section.range
-    //   }
-    // })
-    //
-    // return [{
-    //   type: 'tabList',
-    //   children: tabNodes
-    // }]
+      .filter(Number.isInteger);
+
+    const sections = getSections(list, headerIndexes);
+
+    const tabNodes = sections.map((section) => {
+      return {
+        type: 'html',
+        value: section.range
+      };
+    });
+
+    return [
+      {
+        type: 'element',
+        children: tabNodes
+      }
+    ];
   });
 
   // Return new tree

index.js

@@ -9,36 +9,50 @@ function replaceAllBetween(parent, start, end, func) {
 
   const {children} = parent;
 
-  const isStart = node => is(node, start);
-  const isEnd = node => is(node, end);
+  const isStart = (node) => is(node, start);
+  const isEnd = (node) => is(node, end);
 
   /**
    * @type {Array<{start: number, end: number}>}
    */
-  const ranges = children.reduce((prev, child, i) => {
-    const lastPrev = prev[prev.length - 1];
+  const ranges = children.reduce((previous, child, i) => {
+    const lastPrevious = previous[previous.length - 1];
     if (isStart(children[i])) {
-      if (lastPrev && lastPrev.end === undefined) {
-        console.error('Attempted to start a replacement before the first one was cleaned up')
-        throw new Error('Attempted to start a replacement before the first one was cleaned up');
+      if (lastPrevious && lastPrevious.end === undefined) {
+        console.error(
+          'Attempted to start a replacement before the first one was cleaned up'
+        );
+        throw new Error(
+          'Attempted to start a replacement before the first one was cleaned up'
+        );
       }
-      prev.push({
+
+      previous.push({
         start: i
       });
-      return prev;
+      return previous;
     }
+
     if (isEnd(children[i])) {
-      if (!lastPrev || (lastPrev && lastPrev.start === undefined)) {
-        console.error('Attempted to end a replacement before finding the start', i, lastPrev)
-        throw new Error('Attempted to end a replacement before finding the start');
+      if (!lastPrevious || (lastPrevious && lastPrevious.start === undefined)) {
+        console.error(
+          'Attempted to end a replacement before finding the start',
+          i,
+          lastPrevious
+        );
+        throw new Error(
+          'Attempted to end a replacement before finding the start'
+        );
       }
-      lastPrev.end = i;
+
+      lastPrevious.end = i;
     }
-    return prev;
+
+    return previous;
   }, []);
 
   if (!ranges[ranges.length - 1].end) {
-    console.error('No ending value was found')
+    console.error('No ending value was found');
     throw new Error('No ending value was found');
   }
 
@@ -54,7 +68,11 @@ function replaceAllBetween(parent, start, end, func) {
 
     const changedArray = func(replaced);
 
-    const diff = children.splice(offsetStart, offsetEnd - offsetStart + 1, ...changedArray);
+    const diff = children.splice(
+      offsetStart,
+      offsetEnd - offsetStart + 1,
+      ...changedArray
+    );
 
     offset -= diff.length - changedArray.length;
 

package.json

@@ -52,7 +52,9 @@
   "xo": {
     "prettier": true,
     "rules": {
-      "unicorn/prefer-number-properties": "off"
+      "unicorn/prefer-number-properties": "off",
+      "unicorn/no-reduce": "off",
+      "unicorn/no-fn-reference-in-iterator": "off"
     }
   },
   "prettier": {

test.js

@@ -13,33 +13,38 @@ test('unist-util-find-all-between', (test) => {
   }, 'Should fail without parent node');
 
   test.throws(() => {
-    findAllBetween({type: 'foo', children: [
-        {type: 'start'},
-        {type: 'start'}
-      ]}, {type: 'start'}, {type: 'end'});
+    findAllBetween(
+      {type: 'foo', children: [{type: 'start'}, {type: 'start'}]},
+      {type: 'start'},
+      {type: 'end'}
+    );
   }, 'Tried getting a new start instead of ending');
 
   test.throws(() => {
-    findAllBetween({type: 'foo', children: [
-        {type: 'start'},
-        {type: 'end'},
-        {type: 'start'}
-      ]}, {type: 'start'}, {type: 'end'});
+    findAllBetween(
+      {
+        type: 'foo',
+        children: [{type: 'start'}, {type: 'end'}, {type: 'start'}]
+      },
+      {type: 'start'},
+      {type: 'end'}
+    );
   }, 'No ending value was found');
 
   test.throws(() => {
-    findAllBetween({type: 'foo', children: [
-        {type: 'end'},
-        {type: 'start'}
-      ]}, {type: 'start'}, {type: 'end'});
+    findAllBetween(
+      {type: 'foo', children: [{type: 'end'}, {type: 'start'}]},
+      {type: 'start'},
+      {type: 'end'}
+    );
   }, 'Attempted to end a replacement before finding the start');
 
   test.throws(() => {
-    findAllBetween({type: 'foo', children: [
-        {type: 'start'},
-        {type: 'end'},
-        {type: 'end'},
-      ]}, {type: 'start'}, {type: 'end'});
+    findAllBetween(
+      {type: 'foo', children: [{type: 'start'}, {type: 'end'}, {type: 'end'}]},
+      {type: 'start'},
+      {type: 'end'}
+    );
   }, 'Attempted to end a replacement before finding the start');
 
   test.doesNotThrow(() => {
@@ -102,7 +107,7 @@ test('unist-util-find-all-between', (test) => {
             },
             {
               type: 'baz'
-            },
+            }
           ]
         },
         {type: 'foo'},
@@ -125,6 +130,5 @@ test('unist-util-find-all-between', (test) => {
     );
   }, 'Replaces two matches with new output');
 
-
   test.end();
 });