Initial work on new functionality

Author: crutchcorn

.gitignore

@@ -0,0 +1,40 @@
+# Logs
+logs
+*.log
+*.swp
+npm-debug.log*
+.DS_Store
+
+# Runtime data
+pids
+*.pid
+*.seed
+
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov
+
+# Coverage directory used by tools like istanbul
+coverage.lcov
+.nyc_output
+coverage
+
+# Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
+.grunt
+
+# node-waf configuration
+.lock-wscript
+
+# Compiled binary addons (http://nodejs.org/api/addons.html)
+build/Release
+
+# Dependency directory
+# https://docs.npmjs.com/misc/faq#should-i-check-my-node-modules-folder-into-git
+node_modules
+
+# Optional npm cache directory
+.npm
+
+# Optional REPL history
+.node_repl_history
+
+.idea/

example/example.js

@@ -0,0 +1,76 @@
+const remark = require('remark');
+const between = require('..');
+
+const markdown = `
+# Example
+
+**List one:**
+- 1
+- 2
+
+**List two:**
+- 3
+- 4
+- 5
+
+# End
+
+**List three:**
+- 6
+- 7
+`;
+
+// Create a plugin for remark
+const plugin = () => (tree) => {
+  // `start` and `end` nodes to look for, and find between.
+  const start = {
+    type: 'heading',
+    children: [
+      {
+        value: 'Example'
+      }
+    ]
+  };
+
+  const end = {
+    type: 'heading',
+    children: [
+      {
+        value: 'End'
+      }
+    ]
+  };
+
+  // Test for list types and paragraph types
+  const test = (node) => node.type === 'list' || node.type === 'paragraph';
+
+  // Get lists between `start` and `end`
+  const lists = between(tree, start, end, test);
+
+  // Store lists and their labels
+  tree.children = lists;
+
+  // Return new tree
+  return tree;
+};
+
+remark()
+  .use(plugin)
+  .process(markdown)
+  .then((result) => console.log(result.toString()), console.error);
+
+/**
+ * Outputs:
+ *
+ * **List one:**
+ *
+ * - 1
+ * - 2
+ *
+ * **List two:**
+ *
+ * - 3
+ * - 4
+ * - 5
+ *
+ */

example/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "unist-util-replace-between-example",
+  "dependencies": {
+    "remark": "^11.0.1"
+  }
+}

index.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const find = require('unist-util-find');
+
+function replaceBetween(parent, start, end, func) {
+  if (!parent || !parent.type || !parent.children) {
+    throw new Error('Expected parent node');
+  }
+
+  const {children} = parent;
+
+  const index = check(start);
+  const length = check(end);
+
+  const replaced = children.splice(index, length - index + 1);
+
+  const changedArray = func(replaced);
+
+  children.splice(index, 0, ...changedArray);
+
+  return changedArray;
+
+  function check(index) {
+    if (index && index.type) {
+      const node = find(parent, index);
+      index = children.indexOf(node);
+    }
+
+    if (isNaN(index) || index < 0 || index === Infinity) {
+      throw new Error('Expected positive finite index or child node');
+    }
+
+    if (index >= children.length) {
+      index = children.length - 1;
+    }
+
+    return index;
+  }
+}
+
+module.exports = replaceBetween;

test.js

@@ -0,0 +1,120 @@
+'use strict';
+
+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(
+      findAllBetween(
+        {
+          type: 'foo',
+          children: [
+            {
+              type: 'foo'
+            },
+            {
+              type: 'bar'
+            },
+            {
+              type: 'baz'
+            }
+          ]
+        },
+        0,
+        2,
+        (v) => [{type: 'test', data: v.length}]
+      ),
+      [
+        {
+          type: 'test',
+          data: 3
+        }
+      ]
+    );
+  }, 'Replaces range with new output');
+
+  test.end();
+});

types/index.d.ts

@@ -0,0 +1,20 @@
+// TypeScript Version: 3.5
+
+import {Node, Parent} from 'unist';
+
+export = findAllBetween;
+
+/**
+ * A unist utility to get all children of a parent between two nodes or indices.
+ *
+ * @param parent Parent node to search in
+ * @param start A node or index to start search with
+ * @param end A node or index to end search with
+ * @param func The function ran to change the nodes
+ */
+declare function findAllBetween<T extends Node>(
+  parent: Parent,
+  start: Node | number,
+  end: Node | number,
+  func: (val: Node[]) => Node[]
+): Node[];

types/index.test-d.ts

@@ -0,0 +1,32 @@
+import {Node, Parent} from 'unist';
+import {expectError} from 'tsd';
+import between = require('.');
+
+const n1: Node = {type: 'a', value: 'a'};
+const n2: Node = {type: 'b', value: 'b'};
+const parent: Parent = {type: 'root', children: [n1, n2]};
+
+/**
+ * Incorrect number of arguments
+ */
+expectError(between());
+expectError(between(parent));
+expectError(between(parent, n1));
+expectError(between(parent, n1, n2));
+
+/**
+ * Incorrect types of arguments
+ */
+expectError(between((v: Node[]) => v));
+expectError(between(parent, (v: Node[]) => v));
+expectError(between(parent, n1, (v: Node[]) => v));
+
+/**
+ * Incorrect test type
+ */
+expectError(between(parent, n1, n2, true));
+
+/**
+ * Correct test type
+ */
+between(parent, n1, n2, (v) => v);