clarity-pattern-parser 11.4.2 → 11.5.1

package/dist/patterns/Expression.d.ts

@@ -8,6 +8,7 @@ export declare class Expression implements Pattern {
     private _name;
     private _originalName;
     private _parent;
+    private _cachedParent;
     private _firstIndex;
     private _originalPatterns;
     private _patterns;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clarity-pattern-parser",
-  "version": "11.4.2",
+  "version": "11.5.1",
   "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>) {

package/src/patterns/Expression.ts

@@ -17,6 +17,7 @@ export class Expression implements Pattern {
     private _name: string;
     private _originalName: string;
     private _parent: Pattern | null;
+    private _cachedParent: Pattern | null;
     private _firstIndex: number;
     private _originalPatterns: Pattern[];
     private _patterns: Pattern[];
@@ -92,6 +93,7 @@ export class Expression implements Pattern {
         this._name = name;
         this._originalName = name;
         this._parent = null;
+        this._cachedParent = null;
         this._firstIndex = 0;
         this._atomPatterns = [];
         this._prefixPatterns = [];
@@ -278,7 +280,8 @@ export class Expression implements Pattern {
     }
 
     build() {
-        if (!this._hasOrganized) {
+        if (!this._hasOrganized || this._cachedParent !== this.parent) {
+            this._cachedParent = this.parent;
             this._hasOrganized = true;
             this._organizePatterns(this._originalPatterns);
             this._cacheAncestors();
@@ -491,6 +494,7 @@ export class Expression implements Pattern {
     }
 
     getTokens(): string[] {
+        this.build();
         const atomTokens = this._atomPatterns.map(p => p.getTokens()).flat();
         const prefixTokens = this.prefixPatterns.map(p => p.getTokens()).flat();
 
@@ -498,6 +502,7 @@ export class Expression implements Pattern {
     }
 
     getTokensAfter(childReference: Pattern): string[] {
+        this.build();
         if (this._prefixPatterns.includes(childReference) || this._binaryPatterns.includes(childReference)) {
             const atomTokens = this._atomPatterns.map(p => p.getTokens()).flat();
             const prefixTokens = this.prefixPatterns.map(p => p.getTokens()).flat();
@@ -534,6 +539,7 @@ export class Expression implements Pattern {
     }
 
     getPatterns(): Pattern[] {
+        this.build();
         const atomPatterns = this._atomPatterns.map(p => p.getPatterns()).flat();
         const prefixPatterns = this.prefixPatterns.map(p => p.getPatterns()).flat();
 
@@ -541,6 +547,7 @@ export class Expression implements Pattern {
     }
 
     getPatternsAfter(childReference: Pattern): Pattern[] {
+        this.build();
         if (this._prefixPatterns.includes(childReference) || this._binaryPatterns.includes(childReference)) {
             const atomPatterns = this._atomPatterns.map(p => p.getPatterns()).flat();
             const prefixPatterns = this.prefixPatterns.map(p => p.getPatterns()).flat();