clarity-pattern-parser 7.0.2 → 8.0.0

package/src/patterns/Cursor.ts

@@ -45,6 +45,10 @@ export class Cursor {
     return this._history.error;
   }
 
+  get errors() {
+    return this._history.errors;
+  }
+
   get index(): number {
     return this._index;
   }
@@ -118,8 +122,8 @@ export class Cursor {
     this._history.recordMatch(pattern, node);
   }
 
-  recordErrorAt(index: number, onPattern: Pattern): void {
-    this._history.recordErrorAt(index, onPattern);
+  recordErrorAt(firstIndex: number, lastIndex: number, onPattern: Pattern): void {
+    this._history.recordErrorAt(firstIndex, lastIndex, onPattern);
   }
 
   resolveError(): void {

package/src/patterns/CursorHistory.test.ts

@@ -30,13 +30,15 @@ describe("CursorHistory", () => {
     test("Add Error At", () => {
         const history = new CursorHistory();
         const pattern = new Literal("a", "A");
-        
+
         history.startRecording();
-        history.recordErrorAt(0, pattern);
+        history.recordErrorAt(0, 0, pattern);
 
-        expect(history.error?.index).toBe(0);
+        expect(history.error?.startIndex).toBe(0);
+        expect(history.error?.endIndex).toBe(0);
         expect(history.error?.pattern).toBe(pattern);
-        expect(history.errors[0]?.index).toBe(0);
+        expect(history.errors[0]?.startIndex).toBe(0);
+        expect(history.errors[0]?.endIndex).toBe(0);
         expect(history.errors[0]?.pattern).toBe(pattern);
 
         history.stopRecording()
@@ -44,11 +46,13 @@ describe("CursorHistory", () => {
 
         expect(history.isRecording).toBeFalsy();
         expect(history.error).toBeNull();
-        
-        expect(history.errors[0]?.index).toBe(0);
+
+        expect(history.errors[0]?.startIndex).toBe(0);
+        expect(history.errors[0]?.endIndex).toBe(0);
         expect(history.errors[0]?.pattern).toBe(pattern);
 
-        expect(history.furthestError?.index).toBe(0);
+        expect(history.furthestError?.startIndex).toBe(0);
+        expect(history.furthestError?.endIndex).toBe(0);
         expect(history.furthestError?.pattern).toBe(pattern);
     });
 });

package/src/patterns/CursorHistory.ts

@@ -8,7 +8,7 @@ export interface Match {
 }
 
 export class CursorHistory {
-  private _isRecording: boolean = false;
+  private _isRecording = false;
   private _leafMatches: Match[] = [{ pattern: null, node: null }];
   private _furthestError: ParseError | null = null;
   private _currentError: ParseError | null = null;
@@ -82,7 +82,7 @@ export class CursorHistory {
         let parent = m.pattern?.parent;
 
         while (parent != null) {
-          if (parent == pattern.parent) {
+          if (parent === pattern.parent) {
             return true;
           }
           parent = parent.parent
@@ -96,11 +96,11 @@ export class CursorHistory {
     }
   }
 
-  recordErrorAt(index: number, pattern: Pattern): void {
-    const error = new ParseError(index, pattern);
+  recordErrorAt(firstIndex: number, lastIndex: number, pattern: Pattern): void {
+    const error = new ParseError(firstIndex, lastIndex, pattern);
     this._currentError = error;
 
-    if (this._furthestError === null || index > this._furthestError.index) {
+    if (this._furthestError === null || lastIndex > this._furthestError.endIndex) {
       this._furthestError = error;
     }
 

package/src/patterns/FiniteRepeat.ts

@@ -112,7 +112,7 @@ export class FiniteRepeat implements Pattern {
 
         if (matchCount < this._min) {
             cursor.moveTo(startIndex);
-            cursor.recordErrorAt(startIndex, this);
+            cursor.recordErrorAt(startIndex, startIndex, this);
             return null;
         } else if (nodes.length === 0) {
             cursor.resolveError();
@@ -197,7 +197,7 @@ export class FiniteRepeat implements Pattern {
         const childIndex = this._children.indexOf(childReference);
 
         // If Reference Pattern isn't a child.
-        if (childIndex == -1) {
+        if (childIndex === -1) {
             return [];
         }
 

package/src/patterns/InfiniteRepeat.ts

@@ -132,6 +132,7 @@ export class InfiniteRepeat implements Pattern {
   }
 
   private _tryToParse(cursor: Cursor): boolean {
+    const firstIndex = cursor.index;
     let passed = false;
 
     while (true) {
@@ -145,7 +146,7 @@ export class InfiniteRepeat implements Pattern {
           passed = true;
         } else {
           cursor.moveTo(runningCursorIndex);
-          cursor.recordErrorAt(runningCursorIndex, this._pattern);
+          cursor.recordErrorAt(firstIndex, runningCursorIndex, this._pattern);
           passed = false;
         }
 
@@ -187,7 +188,7 @@ export class InfiniteRepeat implements Pattern {
     if (hasMinimum) {
       return passed;
     } else if (!hasMinimum && passed) {
-      cursor.recordErrorAt(cursor.index, this);
+      cursor.recordErrorAt(firstIndex, cursor.index, this);
       cursor.moveTo(this._firstIndex);
       return false;
     }

package/src/patterns/Literal.test.ts

@@ -34,7 +34,8 @@ describe("Literal", () => {
 
         expect(result).toEqual(null);
         expect(cursor.index).toBe(6);
-        expect(cursor.error?.index).toBe(6);
+        expect(cursor.error?.startIndex).toBe(0);
+        expect(cursor.error?.endIndex).toBe(6);
         expect(cursor.error?.pattern).toBe(literal)
     });
 
@@ -46,7 +47,8 @@ describe("Literal", () => {
 
         expect(result).toEqual(null);
         expect(cursor.index).toBe(10);
-        expect(cursor.error?.index).toBe(10);
+        expect(cursor.error?.startIndex).toBe(0);
+        expect(cursor.error?.endIndex).toBe(11);
         expect(cursor.error?.pattern).toBe(literal)
     });
 

package/src/patterns/Literal.ts

@@ -11,6 +11,7 @@ export class Literal implements Pattern {
   private _runes: string[];
   private _firstIndex: number;
   private _lastIndex: number;
+  private _endIndex: number;
 
   get type(): string {
     return this._type;
@@ -49,6 +50,7 @@ export class Literal implements Pattern {
     this._parent = null;
     this._firstIndex = 0;
     this._lastIndex = 0;
+    this._endIndex = 0;
   }
 
   test(text: string) {
@@ -82,7 +84,7 @@ export class Literal implements Pattern {
     }
 
     if (!this._isOptional) {
-      cursor.recordErrorAt(cursor.index, this)
+      cursor.recordErrorAt(this._firstIndex, this._endIndex, this)
       return null;
     }
 
@@ -100,6 +102,7 @@ export class Literal implements Pattern {
       const cursorRune = cursor.currentChar;
 
       if (literalRune !== cursorRune) {
+        this._endIndex = cursor.index;
         break
       }
 
@@ -110,6 +113,7 @@ export class Literal implements Pattern {
       }
 
       if (!cursor.hasNext()) {
+        this._endIndex = cursor.index + 1;
         break;
       }
 

package/src/patterns/Not.ts

@@ -67,7 +67,7 @@ export class Not implements Pattern {
     } else {
       cursor.moveTo(firstIndex);
       cursor.resolveError();
-      cursor.recordErrorAt(firstIndex, this);
+      cursor.recordErrorAt(firstIndex, firstIndex, this);
     }
 
     return null;

package/src/patterns/Or.ts

@@ -86,7 +86,7 @@ export class Or implements Pattern {
     }
 
     if (!this._isOptional) {
-      cursor.recordErrorAt(this._firstIndex, this)
+      cursor.recordErrorAt(this._firstIndex, this._firstIndex, this)
       return null;
     }
 

package/src/patterns/ParseError.ts

@@ -1,11 +1,13 @@
 import { Pattern } from "./Pattern";
 
 export class ParseError {
-  public index: number;
+  public startIndex: number
+  public endIndex: number;
   public pattern: Pattern;
 
-  constructor(index: number, pattern: Pattern) {
-    this.index = index;
+  constructor(startIndex: number, endIndex: number, pattern: Pattern) {
+    this.startIndex = startIndex;
+    this.endIndex = endIndex;
     this.pattern = pattern;
   }
 }

package/src/patterns/Reference.ts

@@ -35,7 +35,7 @@ export class Reference implements Pattern {
     return this._isOptional;
   }
 
-  constructor(name: string, isOptional: boolean = false) {
+  constructor(name: string, isOptional = false) {
     this._type = "reference";
     this._name = name;
     this._parent = null;

package/src/patterns/Regex.ts

@@ -11,7 +11,8 @@ export class Regex implements Pattern {
   private _regex: RegExp;
   private _node: Node | null = null;
   private _cursor: Cursor | null = null;
-  private _substring: string = "";
+  private _firstIndex = -1;
+  private _substring = "";
   private _tokens: string[] = [];
 
   get type(): string {
@@ -86,6 +87,7 @@ export class Regex implements Pattern {
   }
 
   parse(cursor: Cursor) {
+    this._firstIndex = cursor.index;
     this.resetState(cursor);
     this.tryToParse(cursor);
 
@@ -128,7 +130,7 @@ export class Regex implements Pattern {
 
   private processError(cursor: Cursor) {
     if (!this._isOptional) {
-      cursor.recordErrorAt(cursor.index, this);
+      cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
     }
 
     this._node = null;

package/src/patterns/Repeat.ts

@@ -58,7 +58,7 @@ export class Repeat implements Pattern {
             max: options.max == null ? Infinity : options.max
         };
 
-        if (this._options.max != Infinity) {
+        if (this._options.max !== Infinity) {
             this._repeatPattern = new FiniteRepeat(name, pattern, this._options.max, this._options);
         } else {
             this._repeatPattern = new InfiniteRepeat(name, pattern, this._options)