clarity-pattern-parser 11.4.2 → 11.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clarity-pattern-parser",
-  "version": "11.4.2",
+  "version": "11.5.0",
   "description": "Parsing Library for Typescript and Javascript.",
   "main": "./dist/index.js",
   "module": "./dist/index.esm.js",

package/src/ast/Node.test.ts

@@ -477,4 +477,42 @@ describe("Node", () => {
         expect(result.isEqual(expected)).toBeTruthy();
     });
 
+    test("Find All", () => {
+        const a = new Node("a", "a", 0, 0, [], "A");
+        const b = new Node("b", "b", 0, 0, [], "B");
+        const a2 = a.clone();
+        const parent = new Node("parent", "parent", 0, 0, [a, b, a2]);
+
+        const result = parent.findAll(n => n.name === "a");
+        expect(result).toEqual([a, a2]);
+    });
+
+    test("Breadth First Early Exit", () => {
+        const a = new Node("a", "a", 0, 0, [], "A");
+        const b = new Node("b", "b", 0, 0, [], "B");
+        const a2 = a.clone();
+        const parent = new Node("parent", "parent", 0, 0, [a, b, a2]);
+
+        let count = 0;
+        parent.walkBreadthFirst(n => {
+            count++;
+            if (n.name === "a") {
+                return false;
+            }
+            return true;
+        });
+
+        expect(count).toBe(2);
+    });
+
+    test("Find All (Breadth First)", () => {
+        const a = new Node("a", "a", 0, 0, [], "A");
+        const b = new Node("b", "b", 0, 0, [], "B");
+        const a2 = a.clone();
+        const parent = new Node("parent", "parent", 0, 0, [a, b, a2]);
+
+        const result = parent.findAll(n => n.name === "a", true);
+        expect(result).toEqual([a, a2]);
+    });
+
 });

package/src/ast/Node.ts

@@ -190,16 +190,40 @@ export class Node {
     return null;
   }
 
-  find(predicate: (node: Node) => boolean): Node | null {
-    return this.findAll(predicate)[0] || null;
+  find(predicate: (node: Node) => boolean, breadthFirst = false): Node | null {
+    let match: Node | null = null;
+
+    if (breadthFirst) {
+      this.walkBreadthFirst(n => {
+        if (predicate(n)) {
+          match = n;
+          return false;
+        }
+      });
+    } else {
+      this.walkUp(n => {
+        if (predicate(n)) {
+          match = n;
+          return false;
+        }
+      });
+    }
+
+    return match;
   }
 
-  findAll(predicate: (node: Node) => boolean): Node[] {
+  findAll(predicate: (node: Node) => boolean, breadthFirst = false): Node[] {
     const matches: Node[] = [];
 
-    this.walkUp(n => {
-      if (predicate(n)) { matches.push(n); }
-    });
+    if (breadthFirst) {
+      this.walkBreadthFirst(n => {
+        if (predicate(n)) { matches.push(n); }
+      });
+    } else {
+      this.walkUp(n => {
+        if (predicate(n)) { matches.push(n);}
+      });
+    }
 
     return matches;
   }
@@ -229,28 +253,31 @@ export class Node {
     return null;
   }
 
-  walkUp(callback: (node: Node) => void) {
+  walkUp(callback: (node: Node) => boolean | void): boolean {
     const childrenCopy = this._children.slice();
 
-    childrenCopy.forEach(c => c.walkUp(callback));
-    callback(this);
+    const result = childrenCopy.every(c => c.walkUp(callback));
+    return (callback(this) ?? true) && result;
   }
 
-  walkDown(callback: (node: Node) => void) {
+  walkDown(callback: (node: Node) => boolean | void): boolean {
     const childrenCopy = this._children.slice();
 
-    callback(this);
-    childrenCopy.forEach(c => c.walkDown(callback));
+    return (callback(this) ?? true) && childrenCopy.every(c => c.walkDown(callback));
   }
 
-  walkBreadthFirst(callback: (node: Node) => void): void {
+  walkBreadthFirst(callback: (node: Node) => boolean | void): boolean {
     const queue: Node[] = [this];
 
     while (queue.length > 0) {
       const current = queue.shift() as Node;
-      callback(current);
+      if (callback(current) === false) {
+        return false;
+      }
       queue.push(...current.children);
     }
+
+    return true;
   }
 
   transform(visitors: Record<string, (node: Node) => Node>) {