clarity-pattern-parser 9.2.4 → 10.0.0

package/package.json

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

package/src/ast/Node.test.ts

@@ -16,7 +16,7 @@ describe("Node", () => {
     });
 
     test("Properties", () => {
-        const child = new Node("child", "child", 0, 0, undefined, "Content")
+        const child = new Node("child", "child", 0, 0, undefined, "Content");
         const parent = new Node("parent", "parent", 0, 0, [
             child,
         ]);
@@ -99,7 +99,7 @@ describe("Node", () => {
         parent.insertBefore(b, a);
 
         expect(parent.children.length).toBe(2);
-        expect(parent.value).toBe("BA")
+        expect(parent.value).toBe("BA");
         expect(parent.children[0]).toBe(b);
         expect(parent.children[1]).toBe(a);
         expect(a.parent).toBe(parent);
@@ -118,7 +118,7 @@ describe("Node", () => {
         parent.insertBefore(b, null);
 
         expect(parent.children.length).toBe(2);
-        expect(parent.value).toBe("AB")
+        expect(parent.value).toBe("AB");
         expect(parent.children[0]).toBe(a);
         expect(parent.children[1]).toBe(b);
         expect(a.parent).toBe(parent);
@@ -137,7 +137,7 @@ describe("Node", () => {
         parent.appendChild(b);
 
         expect(parent.children.length).toBe(2);
-        expect(parent.value).toBe("AB")
+        expect(parent.value).toBe("AB");
         expect(parent.children[0]).toBe(a);
         expect(parent.children[1]).toBe(b);
         expect(a.parent).toBe(parent);
@@ -156,7 +156,7 @@ describe("Node", () => {
         parent.spliceChildren(0, 0, b);
 
         expect(parent.children.length).toBe(2);
-        expect(parent.value).toBe("BA")
+        expect(parent.value).toBe("BA");
         expect(parent.children[0]).toBe(b);
         expect(parent.children[1]).toBe(a);
         expect(a.parent).toBe(parent);
@@ -175,7 +175,7 @@ describe("Node", () => {
         parent.spliceChildren(0, 1, b);
 
         expect(parent.children.length).toBe(1);
-        expect(parent.value).toBe("B")
+        expect(parent.value).toBe("B");
         expect(parent.children[0]).toBe(b);
         expect(a.parent).toBeNull();
         expect(b.parent).toBe(parent);
@@ -191,7 +191,7 @@ describe("Node", () => {
         parent.find(p => p.name === "b")?.remove();
 
         expect(parent.children.length).toBe(1);
-        expect(parent.value).toBe("A")
+        expect(parent.value).toBe("A");
         expect(parent.children[0]).toBe(a);
         expect(a.parent).toBe(parent);
         expect(b.parent).toBeNull();
@@ -203,7 +203,7 @@ describe("Node", () => {
         const b = new Node("b", "b", 0, 0, [], "B");
         new Node("parent", "parent", 0, 0, [a, b]);
 
-        const nextSibling = a.nextSibling()
+        const nextSibling = a.nextSibling();
 
         expect(nextSibling).toBe(b);
     });
@@ -211,7 +211,7 @@ describe("Node", () => {
     test("Next Sibling (No Parent)", () => {
         const a = new Node("a", "a", 0, 0, [], "A");
 
-        const nextSibling = a.nextSibling()
+        const nextSibling = a.nextSibling();
         expect(nextSibling).toBeNull;
     });
 
@@ -220,7 +220,7 @@ describe("Node", () => {
         const b = new Node("b", "b", 0, 0, [], "B");
         new Node("parent", "parent", 0, 0, [a, b]);
 
-        const nextSibling = b.nextSibling()
+        const nextSibling = b.nextSibling();
         expect(nextSibling).toBeNull;
     });
 
@@ -229,14 +229,14 @@ describe("Node", () => {
         const b = new Node("b", "b", 0, 0, [], "B");
         new Node("parent", "parent", 0, 0, [a, b]);
 
-        const previousSibling = b.previousSibling()
+        const previousSibling = b.previousSibling();
 
         expect(previousSibling).toBe(a);
     });
 
     test("Previous Sibling (No Parent)", () => {
         const a = new Node("a", "a", 0, 0, [], "A");
-        const previousSibling = a.previousSibling()
+        const previousSibling = a.previousSibling();
         expect(previousSibling).toBeNull();
     });
 
@@ -245,7 +245,7 @@ describe("Node", () => {
         const b = new Node("b", "b", 0, 0, [], "B");
         new Node("parent", "parent", 0, 0, [a, b]);
 
-        const previousSibling = a.previousSibling()
+        const previousSibling = a.previousSibling();
         expect(previousSibling).toBeNull;
     });
 
@@ -256,7 +256,7 @@ describe("Node", () => {
 
         const result = parent.find(n => n.name === "a");
 
-        expect(result).toBe(a)
+        expect(result).toBe(a);
     });
 
     test("Walk Down", () => {
@@ -266,7 +266,7 @@ describe("Node", () => {
         const parent = new Node("parent", "parent", 0, 0, [a, b]);
 
         parent.walkDown((n) => {
-            result.push(n)
+            result.push(n);
         });
 
         const expected = [parent, a, b];
@@ -281,7 +281,7 @@ describe("Node", () => {
         const parent = new Node("parent", "parent", 0, 0, [a, b]);
 
         parent.walkUp((n) => {
-            result.push(n)
+            result.push(n);
         });
 
         const expected = [a, b, parent];
@@ -295,7 +295,7 @@ describe("Node", () => {
         const parent = new Node("parent", "parent", 0, 0, [a, b]);
         const clone = parent.clone();
 
-        expect(clone).toEqual(parent)
+        expect(clone).toEqual(parent);
     });
 
     test("Turn Into JSON", () => {
@@ -307,16 +307,12 @@ describe("Node", () => {
             type: "parent",
             name: "parent",
             value: "AB",
-            firstIndex: 0,
-            lastIndex: 0,
             startIndex: 0,
             endIndex: 1,
             children: [{
                 type: "a",
                 name: "a",
                 value: "A",
-                firstIndex: 0,
-                lastIndex: 0,
                 startIndex: 0,
                 endIndex: 1,
                 children: [],
@@ -324,15 +320,13 @@ describe("Node", () => {
                 type: "b",
                 name: "b",
                 value: "B",
-                firstIndex: 0,
-                lastIndex: 0,
                 startIndex: 0,
                 endIndex: 1,
                 children: [],
             }],
         });
 
-        expect(result).toEqual(expected)
+        expect(result).toEqual(expected);
     });
 
     test("Reduce", () => {
@@ -343,7 +337,7 @@ describe("Node", () => {
         parent.reduce();
 
         expect(parent.hasChildren).toBeFalsy();
-        expect(parent.value).toBe("Content")
+        expect(parent.value).toBe("Content");
     });
 
     test("Flatten", () => {
@@ -364,22 +358,22 @@ describe("Node", () => {
         const nodes = grandParent.flatten();
         const expected = [a, b, c];
 
-        expect(nodes).toEqual(expected)
+        expect(nodes).toEqual(expected);
     });
 
     test("Find Ancester", () => {
         const child = new Node("child", "child", 0, 0, []);
         const parent = new Node("parent", "parent", 0, 0, [child]);
         const grandParent = new Node("grand-parent", "grand-parent", 0, 0, [parent]);
-        const result = child.findAncester(p => p.name === "grand-parent")
+        const result = child.findAncestor(p => p.name === "grand-parent");
 
-        expect(result).toBe(grandParent)
+        expect(result).toBe(grandParent);
     });
 
     test("Find Ancester Without Parent", () => {
         const child = new Node("child", "child", 0, 0, []);
-        const result = child.findAncester(p => p.name === "parent")
-        expect(result).toBeNull()
+        const result = child.findAncestor(p => p.name === "parent");
+        expect(result).toBeNull();
     });
 
     test("Normalize values and index", () => {
@@ -426,4 +420,40 @@ describe("Node", () => {
 
     });
 
+    test("Transform", () => {
+        const node = Node.createNode("grandparent", [
+            Node.createNode("parent", [
+                Node.createValueNode("child", "John"),
+                Node.createValueNode("child", "Jane"),
+                Node.createValueNode("child", "Jack")
+            ]),
+            Node.createValueNode("aunt", "aunt")
+        ]);
+
+        const result = node.transform({
+            "child": (node: Node) => {
+                return Node.createValueNode("adopted-child", node.value);
+            },
+            "parent": (node)=>{
+                return Node.createNode("adopted-parent", node.children.slice());
+            },
+            "grandparent": (node)=>{
+                return Node.createNode("adopted-grandparent", node.children.slice());
+            }
+        });
+
+        const expected = Node.createNode("adopted-grandparent", [
+            Node.createNode("adopted-parent", [
+                Node.createValueNode("adopted-child", "John"),
+                Node.createValueNode("adopted-child", "Jane"),
+                Node.createValueNode("adopted-child", "Jack")
+            ]),
+            Node.createValueNode("aunt", "aunt")
+        ]);
+
+        
+
+        expect(result.toJson()).toBe(expected.toJson());
+    });
+
 });

package/src/ast/Node.ts

@@ -1,8 +1,10 @@
+function defaultVisitor(node: Node) {
+  return node;
+}
+
 export interface CycleFreeNode {
   type: string;
   name: string;
-  firstIndex: number;
-  lastIndex: number;
   startIndex: number;
   endIndex: number;
   value: string;
@@ -54,6 +56,10 @@ export class Node {
     return this._children.length > 0;
   }
 
+  get isLeaf(): boolean {
+    return !this.hasChildren;
+  }
+
   get value() {
     return this.toString();
   }
@@ -74,7 +80,7 @@ export class Node {
     this._children = children;
     this._value = value;
 
-    this._children.forEach(c => c._parent = this)
+    this._children.forEach(c => c._parent = this);
   }
 
   removeChild(node: Node) {
@@ -86,18 +92,28 @@ export class Node {
     }
   }
 
+  findChildIndex(node: Node) {
+    return this._children.indexOf(node);
+  }
+
+  spliceChildren(index: number, deleteCount: number, ...items: Node[]) {
+    const removedItems = this._children.splice(index, deleteCount, ...items);
+
+    removedItems.forEach(i => i._parent = null);
+    items.forEach(i => i._parent = this);
+
+    return removedItems;
+  }
+
   removeAllChildren() {
-    this._children.forEach(c => c._parent = null);
-    this._children.length = 0;
+    this.spliceChildren(0, this._children.length);
   }
 
   replaceChild(newNode: Node, referenceNode: Node) {
-    const index = this._children.indexOf(referenceNode);
+    const index = this.findChildIndex(referenceNode);
 
     if (index > -1) {
-      this._children.splice(index, 1, newNode);
-      newNode._parent = this;
-      referenceNode._parent = null;
+      this.spliceChildren(index, 1, newNode);
     }
   }
 
@@ -115,7 +131,7 @@ export class Node {
       return;
     }
 
-    const index = this._children.indexOf(referenceNode);
+    const index = this.findChildIndex(referenceNode);
 
     if (index > -1) {
       this._children.splice(index, 0, newNode);
@@ -123,17 +139,14 @@ export class Node {
   }
 
   appendChild(newNode: Node) {
-    newNode._parent = this;
-    this._children.push(newNode);
+    this.append(newNode);
   }
 
-  spliceChildren(index: number, deleteCount: number, ...items: Node[]) {
-    const removedItems = this._children.splice(index, deleteCount, ...items);
-
-    removedItems.forEach(i => i._parent = null);
-    items.forEach(i => i._parent = this);
-
-    return removedItems;
+  append(...nodes: Node[]) {
+    nodes.forEach((newNode: Node) => {
+      newNode._parent = this;
+      this._children.push(newNode);
+    });
   }
 
   nextSibling() {
@@ -145,10 +158,10 @@ export class Node {
     const index = children.indexOf(this);
 
     if (index > -1 && index < children.length - 1) {
-      return children[index + 1]
+      return children[index + 1];
     }
 
-    return null
+    return null;
   }
 
   previousSibling() {
@@ -160,26 +173,27 @@ export class Node {
     const index = children.indexOf(this);
 
     if (index > -1 && index > 0) {
-      return children[index - 1]
+      return children[index - 1];
     }
 
-    return null
+    return null;
   }
 
   find(predicate: (node: Node) => boolean): Node | null {
-    return this.findAll(predicate)[0] || null
+    return this.findAll(predicate)[0] || null;
   }
 
   findAll(predicate: (node: Node) => boolean): Node[] {
     const matches: Node[] = [];
+
     this.walkUp(n => {
       if (predicate(n)) { matches.push(n); }
-    })
+    });
 
     return matches;
   }
 
-  findAncester(predicate: (node: Node) => boolean) {
+  findAncestor(predicate: (node: Node) => boolean) {
     let parent = this._parent;
 
     while (parent != null) {
@@ -196,7 +210,7 @@ export class Node {
   walkUp(callback: (node: Node) => void) {
     const childrenCopy = this._children.slice();
 
-    childrenCopy.forEach(c => c.walkUp(callback))
+    childrenCopy.forEach(c => c.walkUp(callback));
     callback(this);
   }
 
@@ -204,7 +218,29 @@ export class Node {
     const childrenCopy = this._children.slice();
 
     callback(this);
-    childrenCopy.forEach(c => c.walkDown(callback))
+    childrenCopy.forEach(c => c.walkDown(callback));
+  }
+
+  walkBreadthFirst(callback: (node: Node) => void): void {
+    const queue: Node[] = [this];
+
+    while (queue.length > 0) {
+      // biome-ignore lint/style/noNonNullAssertion: This will never be undefined.
+      const current = queue.shift()!;
+      callback(current);
+      queue.push(...current.children);
+    }
+  }
+
+  transform(visitors: Record<string, (node: Node) => Node>) {
+    const childrenCopy = this._children.slice();
+    const visitor = visitors[this.name] == null ? defaultVisitor : visitors[this.name];
+
+    const children = childrenCopy.map(c => c.transform(visitors));
+    this.removeAllChildren();
+    this.append(...children);
+
+    return visitor(this);
   }
 
   flatten() {
@@ -261,7 +297,7 @@ export class Node {
       return this._value;
     }
 
-    return this._children.map(c => c.toString()).join("")
+    return this._children.map(c => c.toString()).join("");
   }
 
   toCycleFreeObject(): CycleFreeNode {
@@ -269,15 +305,22 @@ export class Node {
       type: this._type,
       name: this._name,
       value: this.toString(),
-      firstIndex: this._firstIndex,
-      lastIndex: this._lastIndex,
       startIndex: this.startIndex,
       endIndex: this.endIndex,
       children: this._children.map(c => c.toCycleFreeObject()),
-    }
+    };
   }
 
   toJson(space?: number): string {
-    return JSON.stringify(this.toCycleFreeObject(), null, space)
+    return JSON.stringify(this.toCycleFreeObject(), null, space);
+  }
+
+  static createValueNode(name: string, value: string) {
+    return new Node("custom-value-node", name, 0, 0, [], value);
+  }
+
+  static createNode(name: string, children: Node[]) {
+    const value = children.map(c => c.toString()).join("");
+    return new Node("custom-node", name, 0, 0, children, value);
   }
 }

package/src/grammar/Grammar.test.ts

@@ -1,5 +1,4 @@
 import { Sequence } from "../patterns/Sequence";
-import { arePatternsEqual } from "../patterns/arePatternsEqual";
 import { Literal } from "../patterns/Literal";
 import { Not } from "../patterns/Not";
 import { Options } from "../patterns/Options";
@@ -20,7 +19,7 @@ describe("Grammar", () => {
         const namePattern = patterns["name"];
         const expected = new Literal("name", "John");
 
-        expect(arePatternsEqual(namePattern, expected)).toBeTruthy();
+        expect(namePattern.isEqual(expected)).toBeTruthy();
     });
 
     test("Literal With Escaped Characters", () => {
@@ -31,7 +30,7 @@ describe("Grammar", () => {
         const namePattern = patterns["chars"];
         const expected = new Literal("chars", "\n\r\t\b\f\v\0\x00\u0000\"\\");
 
-        expect(arePatternsEqual(namePattern, expected)).toBeTruthy();
+        expect(namePattern.isEqual(expected)).toBeTruthy();
     });
 
     test("Literal With Escaped Quotes", () => {
@@ -42,7 +41,7 @@ describe("Grammar", () => {
         const namePattern = patterns["content"];
         const expected = new Literal("content", "With Con\"tent");
 
-        expect(arePatternsEqual(namePattern, expected)).toBeTruthy();
+        expect(namePattern.isEqual(expected)).toBeTruthy();
     });
 
     test("Regex", () => {
@@ -54,7 +53,7 @@ describe("Grammar", () => {
         const pattern = patterns["name"];
         const name = new Regex("name", "\\w");
 
-        expect(arePatternsEqual(pattern, name)).toBeTruthy();
+        expect(pattern.isEqual(name)).toBeTruthy();
     });
 
     test("Or", () => {
@@ -70,7 +69,7 @@ describe("Grammar", () => {
         const jane = new Literal("jane", "Jane");
         const names = new Options("names", [john, jane], true);
 
-        expect(arePatternsEqual(pattern, names)).toBeTruthy();
+        expect(pattern.isEqual(names)).toBeTruthy();
     });
 
     test("And", () => {
@@ -88,7 +87,7 @@ describe("Grammar", () => {
         const lastName = new Regex("last-name", "\\w");
         const fullName = new Sequence("full-name", [firstName, space, lastName]);
 
-        expect(arePatternsEqual(pattern, fullName)).toBeTruthy();
+        expect(pattern.isEqual(fullName)).toBeTruthy();
     });
 
     test("And With Optional Pattern", () => {
@@ -110,7 +109,7 @@ describe("Grammar", () => {
         const middleNameWithSpace = new Optional("optional-middle-name-with-space", new Sequence("middle-name-with-space", [middleName, space]));
         const fullName = new Sequence("full-name", [firstName, space, middleNameWithSpace, lastName]);
 
-        expect(arePatternsEqual(pattern, fullName)).toBeTruthy();
+        expect(pattern.isEqual(fullName)).toBeTruthy();
     });
 
     test("And With Not Pattern", () => {
@@ -134,7 +133,8 @@ describe("Grammar", () => {
         const notJack = new Not("not-jack", jack);
         const middleNameWithSpace = new Optional("optional-middle-name-with-space", new Sequence("middle-name-with-space", [middleName, space]));
         const fullName = new Sequence("full-name", [notJack, firstName, space, middleNameWithSpace, lastName]);
-        expect(arePatternsEqual(pattern, fullName)).toBeTruthy();
+
+        expect(pattern.isEqual(fullName)).toBeTruthy();
     });
 
     test("Repeat", () => {
@@ -148,7 +148,7 @@ describe("Grammar", () => {
         const digit = new Regex("digit", "\\d");
         const digits = new Repeat("digits", digit);
 
-        expect(arePatternsEqual(pattern, digits)).toBeTruthy();
+        expect(pattern.isEqual(digits)).toBeTruthy();
     });
 
     test("Repeat Zero Or More", () => {
@@ -162,7 +162,7 @@ describe("Grammar", () => {
         const digit = new Regex("digit", "\\d");
         const digits = new Optional("digits", new Repeat("digits", digit, { min: 0 }));
 
-        expect(arePatternsEqual(pattern, digits)).toBeTruthy();
+        expect(pattern.isEqual(digits)).toBeTruthy();
     });
 
     test("Repeat Lower Limit", () => {
@@ -176,7 +176,7 @@ describe("Grammar", () => {
         const digit = new Regex("digit", "\\d+");
         const digits = new Repeat("digits", digit, { min: 1 });
 
-        expect(arePatternsEqual(pattern, digits)).toBeTruthy();
+        expect(pattern.isEqual(digits)).toBeTruthy();
     });
 
     test("Repeat Bounded", () => {
@@ -189,7 +189,8 @@ describe("Grammar", () => {
         const pattern = patterns["digits"];
         const digit = new Regex("digit", "\\d+");
         const digits = new Repeat("digits", digit, { min: 1, max: 3 });
-        expect(arePatternsEqual(pattern, digits)).toBeTruthy();
+
+        expect(pattern.isEqual(digits)).toBeTruthy();
     });
 
     test("Repeat Upper Limit", () => {
@@ -203,7 +204,7 @@ describe("Grammar", () => {
         const digit = new Regex("digit", "\\d+");
         const digits = new Repeat("digits", digit, { min: 0, max: 3 });
 
-        expect(arePatternsEqual(pattern, digits)).toBeTruthy();
+        expect(pattern.isEqual(digits)).toBeTruthy();
     });
 
     test("Repeat Exact", () => {
@@ -217,7 +218,7 @@ describe("Grammar", () => {
         const digit = new Regex("digit", "\\d+");
         const digits = new Repeat("digits", digit, { min: 3, max: 3 });
 
-        expect(arePatternsEqual(pattern, digits)).toBeTruthy();
+        expect(pattern.isEqual(digits)).toBeTruthy();
     });
 
     test("Repeat Divider", () => {
@@ -233,7 +234,7 @@ describe("Grammar", () => {
         const divider = new Literal("comma", ",");
         const digits = new Repeat("digits", digit, { divider, min: 3, max: 3 });
 
-        expect(arePatternsEqual(pattern, digits)).toBeTruthy();
+        expect(pattern.isEqual(digits)).toBeTruthy();
     });
 
     test("Repeat Divider With Trim Divider", () => {
@@ -248,8 +249,8 @@ describe("Grammar", () => {
         const digit = new Regex("digit", "\\d+");
         const divider = new Literal("comma", ",");
         const digits = new Repeat("digits", digit, { divider, min: 1, trimDivider: true });
-        debugger;
-        expect(arePatternsEqual(pattern, digits)).toBeTruthy();
+
+        expect(pattern.isEqual(digits)).toBeTruthy();
     });
 
     test("Repeat Divider With Trim Divider And Bounds", () => {
@@ -265,7 +266,7 @@ describe("Grammar", () => {
         const divider = new Literal("comma", ",");
         const digits = new Repeat("digits", digit, { divider, min: 3, max: 3, trimDivider: true });
 
-        expect(arePatternsEqual(pattern, digits)).toBeTruthy();
+        expect(pattern.isEqual(digits)).toBeTruthy();
     });
 
     test("Reference", () => {
@@ -303,8 +304,8 @@ describe("Grammar", () => {
         const alias = patterns["alias"];
         const expectedAlias = new Regex("alias", "regex");
 
-        expect(arePatternsEqual(name, expectedName)).toBeTruthy();
-        expect(arePatternsEqual(alias, expectedAlias)).toBeTruthy();
+        expect(name.isEqual(expectedName)).toBeTruthy();
+        expect(alias.isEqual(expectedAlias)).toBeTruthy();
     });
 
     test("Bad Grammar At Beginning", () => {
@@ -497,17 +498,17 @@ describe("Grammar", () => {
             ])
         ]);
 
-        expect(arePatternsEqual(patterns["complex-expression"], expected)).toBeTruthy();
+        expect(patterns["complex-expression"].isEqual(expected)).toBeTruthy();
     });
 
-    test("Grammar With Spaces", ()=>{
+    test("Grammar With Spaces", () => {
         const expression = `
         john = "John"
             
         jane = "Jane"
         `;
         const patterns = Grammar.parseString(expression);
-        expect(patterns.john).not.toBeNull(); 
-        expect(patterns.jane).not.toBeNull(); 
+        expect(patterns.john).not.toBeNull();
+        expect(patterns.jane).not.toBeNull();
     });
 });

package/src/grammar/Grammar.ts

@@ -131,7 +131,7 @@ export class Grammar {
     }
 
     private _buildPatterns(ast: Node) {
-        const body = ast.find(n => n.name === "body" && n.findAncester(n => n.name === "head") == null);
+        const body = ast.find(n => n.name === "body" && n.findAncestor(n => n.name === "head") == null);
 
         if (body == null) {
             return;