adds isDecendantOfType util

Author: Daniel Del Core

.changeset/five-llamas-clap.md

@@ -0,0 +1,5 @@
+---
+'@codeshift/utils': patch
+---
+
+Adds isDecendantOfType as a way to ensure a node has a specific parent

packages/utils/src/nodes.spec.ts

@@ -0,0 +1,58 @@
+import { API, FileInfo } from 'jscodeshift';
+import { applyTransform } from '@codeshift/test-utils';
+import { isDecendantOfType } from '@codeshift/utils';
+
+describe('nodes', () => {
+  describe('isDecendantOfType', () => {
+    it('detects decendant callExpression', async () => {
+      let result = 0;
+      const transform = (file: FileInfo, api: API) => {
+        const j = api.jscodeshift;
+
+        result = j(file.source)
+          .find(j.Literal)
+          .filter(literal =>
+            isDecendantOfType(j, literal, j.CallExpression),
+          ).length;
+      };
+
+      await applyTransform(transform, 'console.log("bar");');
+
+      expect(result).toEqual(1);
+    });
+
+    it('correctly reports missing decendant', async () => {
+      let result = 0;
+      const transform = (file: FileInfo, api: API) => {
+        const j = api.jscodeshift;
+
+        result = j(file.source)
+          .find(j.Literal)
+          .filter(literal =>
+            isDecendantOfType(j, literal, j.CallExpression),
+          ).length;
+      };
+
+      await applyTransform(transform, 'const foo = "bar";');
+
+      expect(result).toEqual(0);
+    });
+
+    it('correctly reports deeply nested decendant', async () => {
+      let result = 0;
+      const transform = (file: FileInfo, api: API) => {
+        const j = api.jscodeshift;
+
+        result = j(file.source)
+          .find(j.Literal)
+          .filter(literal =>
+            isDecendantOfType(j, literal, j.CallExpression),
+          ).length;
+      };
+
+      await applyTransform(transform, 'console.log(console.log("bar"));');
+
+      expect(result).toEqual(1);
+    });
+  });
+});

packages/utils/src/nodes.ts

@@ -1,4 +1,4 @@
-import { ASTNode } from 'jscodeshift';
+import core, { ASTNode, ASTPath } from 'jscodeshift';
 
 /**
  * The isNodeOfType function uses generics to check if a node of type ASTNode is of a specified type.
@@ -14,3 +14,22 @@ export const isNodeOfType = <Expected extends ASTNode>(
   node: ASTNode,
   type: Expected['type'],
 ): node is Expected => node.type === type;
+
+/**
+ * Determines if the current node is a decendant of a parent node of specific type
+ *
+ * Example:
+ *
+ * ```ts
+ * const isDecendantOfImportSpecifier = isDecendantOfType(node, j.ImportSpecifier);
+ * ```
+ */
+export const isDecendantOfType = (
+  j: core.JSCodeshift,
+  source: ASTPath<any>,
+  type: any,
+): boolean => {
+  const closestNodes = j(source).closest(type);
+  const count: number = closestNodes.length;
+  return count > 0;
+};

website/docs/api/codeshift-utils.mdx

@@ -34,6 +34,22 @@ If the check passes, the type of node is narrowed to the expected type, ensuring
 const isImportSpecifier = isNodeOfType(node, 'ImportSpecifier');
 ```
 
+### `isDecendantOfType`
+
+`isDecendantOfType(j, path, type)`
+
+The `isDecendantOfType` function traverses the AST to determind if the given path is a child of a node of the specified type.
+
+**Returns**
+
+`boolean`
+
+**Example**
+
+```jsx
+const isChildOfImportSpecifier = isDecendantOfType(j, path, j.ImportSpecifier);
+```
+
 ## Imports
 
 ### `hasImportDeclaration`