Build some dark magics with replaceAll

Author: crutchcorn

all.js

@@ -0,0 +1,56 @@
+'use strict';
+
+const is = require('unist-util-is');
+
+function replaceAllBetween(parent, start, end, func) {
+  if (!parent || !parent.type || !parent.children) {
+    throw new Error('Expected parent node');
+  }
+
+  const {children} = parent;
+
+  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];
+    if (isStart(children[i])) {
+      if (lastPrev && !lastPrev.end) {
+        console.error('Attempted to start a second replacement before the first one was cleaned up');
+        return prev;
+      }
+      prev.push({
+        start: i
+      });
+      return prev;
+    }
+    if (isEnd(children[i])) {
+      lastPrev.end = i;
+    }
+    return prev;
+  }, []);
+
+  // The function will return a different length than the original
+  // This offset is used to correct
+  let offset = 0;
+
+  return ranges.map(({start, end}) => {
+    const offsetStart = start + offset;
+    const offsetEnd = end + offset;
+
+    const replaced = children.slice(offsetStart, offsetEnd + 1);
+
+    const changedArray = func(replaced);
+
+    const diff = children.splice(offsetStart, offsetEnd - offsetStart + 1, ...changedArray);
+
+    offset -= diff.length - changedArray.length;
+
+    return changedArray;
+  });
+}
+
+module.exports = replaceAllBetween;

example/example.js

@@ -1,6 +1,6 @@
 import {remark} from 'remark'
 import {is} from 'unist-util-is';
-import replaceBetween from '../index.js';
+import replaceAllBetween from '../all.js';
 
 const markdown = `
 # Hello World!
@@ -26,8 +26,50 @@ Ciao!
 Testing
 
 # Test
+
+
+<!-- tabs:start -->
+
+#### **English**
+
+Hello!
+
+#### **French**
+
+Bonjour!
+
+Telakjdsf
+
+asdf
+
+<!-- tabs:end -->
+
+# Testing
+
+![](asdf)
 `;
 
+/**
+ * @typedef {Object} Section
+ * @prop {string} header
+ * @prop {any[]} range
+ */
+
+/**
+ * @returns {Section[]}
+ */
+const getSections = (allChildren, headerIndexes) =>
+  headerIndexes.map((_, i, arr) => {
+    let [startIndex, endIndex] = [arr[i], arr[i + 1]];
+    const header = allChildren[startIndex];
+    startIndex += 1;
+
+    return {
+      header,
+      range: allChildren.slice(startIndex, endIndex)
+    };
+  });
+
 // Create a plugin for remark
 const plugin = () => (tree) => {
   // `start` and `end` nodes to look for, and find between.
@@ -42,19 +84,36 @@ const plugin = () => (tree) => {
   };
 
   // Get lists between `start` and `end`
-  replaceBetween(tree, start, end, list => {
+  replaceAllBetween(tree, start, end, list => {
     // Remove both `tabs` mention
-    list.shift();
-    list.pop()
+    // list.shift();
+    // list.pop()
+
+    console.log({list});
 
     const headerIndexes = list
       .map((node, i) => is(node, {type: 'heading'}) && i)
       .filter(Number.isInteger)
 
     return [{
       type: 'html',
-      value: headerIndexes
+      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
+    // }]
   });
 
   // Return new tree
@@ -65,19 +124,3 @@ remark()
   .use(plugin)
   .process(markdown)
   .then((result) => console.log(result.toString()), console.error);
-
-/**
- * Outputs:
- *
- * **List one:**
- *
- * - 1
- * - 2
- *
- * **List two:**
- *
- * - 3
- * - 4
- * - 5
- *
- */

test.js

@@ -4,87 +4,6 @@ const {test} = require('tap');
 const findAllBetween = require('.');
 
 test('unist-util-find-all-between', (test) => {
-  test.throws(() => {
-    findAllBetween();
-  }, 'Should fail without parent node');
-
-  test.throws(() => {
-    findAllBetween({type: 'foo'});
-  }, 'Should fail without parent node');
-
-  test.doesNotThrow(() => {
-    test.throws(() => {
-      findAllBetween({type: 'foo', children: []});
-    }, 'Expected positive finite index or child node');
-
-    test.throws(() => {
-      findAllBetween({type: 'foo', children: []}, -1);
-    }, 'Expected positive finite index or child node');
-
-    test.throws(() => {
-      findAllBetween({type: 'foo', children: []}, {type: 'bar'});
-    }, 'Expected positive finite index or child node');
-
-    test.throws(() => {
-      findAllBetween({type: 'foo', children: []}, 1, {type: 'bar'});
-    }, 'Expected positive finite index or child node');
-  }, 'Should fail without index');
-
-  test.doesNotThrow(() => {
-    test.ok(
-      findAllBetween(
-        {
-          type: 'foo',
-          children: [
-            {
-              type: 'foo'
-            },
-            {
-              type: 'bar'
-            }
-          ]
-        },
-        0,
-        1,
-        (v) => v
-      )
-    );
-  }, 'Should not throw with `unist-util-is` >= 4.0.0');
-
-  test.doesNotThrow(() => {
-    test.deepEqual(
-      findAllBetween(
-        {
-          type: 'foo',
-          children: [
-            {
-              type: 'foo'
-            },
-            {
-              type: 'bar'
-            },
-            {
-              type: 'baz'
-            }
-          ]
-        },
-        0,
-        2,
-        (v) => v
-      ),
-      [
-        {
-          type: 'foo'
-        },
-        {
-          type: 'bar'
-        },
-        {
-          type: 'baz'
-        }
-      ]
-    );
-  }, 'Expects identity function to return the same');
 
   test.doesNotThrow(() => {
     test.deepEqual(