clarity-pattern-parser 8.3.1 → 8.4.0

package/TODO.md

@@ -1 +1,15 @@
-* Need to Rename Repeat.ts to InfiniteRepeat and them make a new class that is Repeat.ts that is a fascade to FiniteRepeat and InfiniteRepeat, so its easier to use. 
+* We should make a Block, Delimiter Pattern. These will be breadth first patterns. It look something like this.
+
+```ts
+new Block(startPattern,contentPattern,endPattern);
+```
+
+```
+block = [start-pattern content-pattern end-pattern];
+```
+
+It will count the startPattern and only be done when its ends equal to end Pattern. It will store the internal pattern needed for its content. This is what is lazily done at some point in the future.
+
+```ts
+new Delimiter(pattern, segmentPattern);
+```

package/package.json

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

package/src/ast/Node.test.ts

@@ -188,7 +188,7 @@ describe("Node", () => {
         const b = new Node("b", "b", 0, 0, [], "B");
         const parent = new Node("parent", "parent", 0, 0, [a, b]);
 
-        parent.find(p=>p.name === "b")?.remove();
+        parent.find(p => p.name === "b")?.remove();
 
         expect(parent.children.length).toBe(1);
         expect(parent.value).toBe("A")
@@ -382,4 +382,30 @@ describe("Node", () => {
         expect(result).toBeNull()
     });
 
+    test("Normalize values and index", () => {
+        const firstChild = new Node("literal", "first", 0, 0, [], "first");
+        const secondChild = new Node("literal", "second", 0, 0, [], "second");
+        const parent = new Node("literal", "parent", 0, 0);
+
+        parent.appendChild(firstChild);
+        parent.appendChild(secondChild);
+
+        parent.normalize();
+
+        expect(parent.startIndex).toBe(0);
+        expect(parent.firstIndex).toBe(0);
+        expect(parent.lastIndex).toBe(10);
+        expect(parent.endIndex).toBe(11);
+    });
+
+    test("Normalize values with no values", () => {
+        const node = new Node("literal", "node", 0, 0, [], "");
+        node.normalize();
+
+        expect(node.startIndex).toBe(0);
+        expect(node.firstIndex).toBe(0);
+        expect(node.lastIndex).toBe(0);
+        expect(node.endIndex).toBe(1);
+    });
+
 });

package/src/ast/Node.ts

@@ -232,6 +232,20 @@ export class Node {
     );
   }
 
+  normalize(startIndex = this._firstIndex): number {
+    let length = 0;
+
+    if (this.children.length === 0) {
+      length = this._value.length;
+    } else {
+      length = this.children.reduce((acc, c) => acc + c.normalize(acc+startIndex), startIndex);
+    }
+
+    this._firstIndex = startIndex;
+    this._lastIndex = Math.max(startIndex + length - 1, 0);
+    return length;
+  }
+
   toString(): string {
     if (this._children.length === 0) {
       return this._value;