clarity-pattern-parser 3.0.9 → 3.0.11

package/src/TextSuggester.ts

@@ -172,15 +172,17 @@ export default class TextSuggester {
   }
 
   private saveNextToken() {
-    if (
+    const isCompleteMatch =
       this.patternMatch?.pattern === this.rootPattern &&
-      this.cursor?.didSuccessfullyParse()
-    ) {
+      this.cursor?.didSuccessfullyParse();
+    const noMatch = this.patternMatch?.astNode == null;
+
+    if (isCompleteMatch) {
       this.tokens = null;
       return;
     }
 
-    if (this.patternMatch?.astNode == null) {
+    if (noMatch) {
       let options = this.rootPattern?.getTokens();
 
       options = options?.filter((option: any) => {
@@ -209,7 +211,7 @@ export default class TextSuggester {
         endIndex: this.text.length - 1,
       };
       this.error = null;
-      
+
       return;
     }
 

package/src/patterns/composite/RepeatComposite.ts

@@ -73,6 +73,12 @@ export default class RepeatComposite extends CompositePattern {
             break;
           } else {
             this.nodes.push(node);
+
+            if (node.endIndex === this.cursor.lastIndex()) {
+              this._processMatch();
+              break;
+            }
+            
             this.cursor.next();
           }
         }

package/src/patterns/value/RepeatValue.ts

@@ -74,6 +74,12 @@ export default class RepeatValue extends ValuePattern {
             break;
           } else {
             this.nodes.push(node);
+
+            if (node.endIndex === this.cursor.lastIndex()) {
+              this._processMatch();
+              break;
+            }
+
             this.cursor.next();
           }
         }

package/src/tests/RepeatComposite.test.ts

@@ -3,6 +3,8 @@ import RepeatComposite from "../patterns/composite/RepeatComposite";
 import AndComposite from "../patterns/composite/AndComposite";
 import OptionalComposite from "../patterns/composite/OptionalComposite";
 import Literal from "../patterns/value/Literal";
+import Cursor from "../Cursor";
+import OrComposite from "../patterns/composite/OrComposite";
 
 describe("RepeatComposite", () => {
   test("Cannot use optional patterns.", () => {
@@ -24,4 +26,21 @@ describe("RepeatComposite", () => {
 
     expect(clone.name).toBe("full-names-2");
   });
+
+  test("parse.", () => {
+    const a = new Literal("a", "A");
+    const b = new Literal("b", "B");
+    const space = new Literal("space", " ");
+    const or = new OrComposite("names", [a, b]);
+
+    const repeat = new RepeatComposite("repeat", or, space);
+    const result = repeat.parse(new Cursor("A B"));
+
+    expect(result?.children[0].value).toBe("A");
+    expect(result?.children[0].name).toBe("a");
+    expect(result?.children[1].value).toBe(" ");
+    expect(result?.children[1].name).toBe("space");
+    expect(result?.children[2].value).toBe("B");
+    expect(result?.children[2].name).toBe("b");
+  });
 });