feat: create pathsIntersectingRange

Author: jedwards1211

README.md

@@ -42,3 +42,19 @@ j(editor.getText())
   )
   .forEach(path => console.log(path.node))
 ```
+
+### `pathsIntersectingRange(start: number, end: number = start)`
+
+The only difference between this and `pathsInRange` is it will include nodes that
+extend beyond `start` or `end`.
+
+```js
+import pathsIntersectingRange from 'jscodeshift-paths-in-range'
+```
+
+Returns a predicate for `Collection.filter`.
+
+#### Arguments
+
+- `start` - the index of the start of the range within the source code
+- `end` - the index of the end of the range within the source code (defaults to `start`)

src/index.spec.ts

@@ -5,6 +5,8 @@ import { expect } from 'chai'
 import pathsToTransformFilter from './index'
 import jscodeshift from 'jscodeshift'
 
+import { pathsIntersectingRange } from './'
+
 const j = jscodeshift.withParser('babylon')
 
 describe(`pathsToTransformFilter`, function() {
@@ -108,3 +110,40 @@ var qlarmge
     )
   })
 })
+
+describe(`pathsIntersectingRange`, function() {
+  const code = `
+const Comp = () => (
+  <div>
+    This is a
+    <button>
+      Test
+    </button>
+    <span />
+  </div>
+) 
+`
+
+  it('works', () => {
+    const root = j(code)
+    const elements = root
+      .find(j.Node)
+      .filter(
+        path =>
+          path.node.type !== 'JSXOpeningElement' &&
+          path.node.type !== 'JSXClosingElement' &&
+          (path.node.type === 'JSXElement' ||
+            (path.parent && path.parent.node.type === 'JSXElement'))
+      )
+      .filter(
+        pathsIntersectingRange(code.indexOf('is a'), code.indexOf('<span'))
+      )
+      .nodes()
+    expect(elements[0].type).to.equal('JSXText')
+    expect((elements[0] as any).value).to.match(/is a/)
+    expect(elements[1].type).to.equal('JSXElement')
+    expect(elements[2].type).to.equal('JSXText')
+    expect((elements[2] as any).value).not.to.match(/\S/)
+    expect(elements).to.have.lengthOf(3)
+  })
+})

src/index.ts

@@ -36,7 +36,62 @@ export default function pathsInRange(
       )
     }
 
-    // return the bottommost paths that fully contains the range
+    // return the bottommost path that fully contains the range
+    const allFullContainers = paths.filter(
+      path =>
+        (path.value as any).start <= start && (path.value as any).end >= end
+    )
+    const fullContainersSet = new Set(allFullContainers)
+    allFullContainers.forEach(path => {
+      for (const ancestor of ancestorsOfPath(path)) {
+        fullContainersSet.delete(ancestor)
+      }
+    })
+    return fullContainersSet
+  }
+
+  return (
+    path: ASTPath<Node>,
+    index: number,
+    paths: Array<ASTPath<Node>>
+  ): boolean => {
+    if (paths !== lastPaths) {
+      lastPaths = paths
+      lastPathSet = computePathSet(paths)
+    }
+    return lastPathSet.has(path)
+  }
+}
+
+export function pathsIntersectingRange(
+  start: number,
+  end: number = start
+): (path: ASTPath<Node>, i: number, paths: Array<ASTPath<Node>>) => boolean {
+  let lastPaths: Array<ASTPath<Node>> | null = null
+  let lastPathSet: Set<ASTPath<Node>> = new Set()
+
+  function computePathSet(paths: Array<ASTPath<Node>>): Set<ASTPath<Node>> {
+    const intersected = paths.filter((path: ASTPath<Node>): boolean => {
+      const value: any = path.value
+      return (
+        value.start < end &&
+        value.end > start &&
+        (start <= value.start || end >= value.end)
+      )
+    })
+    if (intersected.length) {
+      const intersectedSet = new Set(intersected)
+      return new Set(
+        intersected.filter(path => {
+          for (const ancestor of ancestorsOfPath(path)) {
+            if (intersectedSet.has(ancestor)) return false
+          }
+          return true
+        })
+      )
+    }
+
+    // return the bottommost path that fully contains the range
     const allFullContainers = paths.filter(
       path =>
         (path.value as any).start <= start && (path.value as any).end >= end