clarity-pattern-parser 10.1.23 → 10.1.25

package/dist/index.browser.js

@@ -268,9 +268,11 @@
     };
 
     class ParseError {
-        constructor(startIndex, endIndex, pattern) {
+        constructor(startIndex, lastIndex, pattern) {
+            this.firstIndex = startIndex;
             this.startIndex = startIndex;
-            this.endIndex = endIndex;
+            this.lastIndex = lastIndex;
+            this.endIndex = lastIndex + 1;
             this.pattern = pattern;
         }
     }
@@ -360,7 +362,7 @@
         recordErrorAt(startIndex, endIndex, pattern) {
             const error = new ParseError(startIndex, endIndex, pattern);
             this._currentError = error;
-            if (this._furthestError === null || endIndex > this._furthestError.endIndex) {
+            if (this._furthestError === null || endIndex > this._furthestError.lastIndex) {
                 this._furthestError = error;
             }
             if (this._isRecording) {
@@ -995,7 +997,7 @@
         }
         constructor(name, options, isGreedy = false) {
             if (options.length === 0) {
-                throw new Error("Need at least one pattern with an 'or' pattern.");
+                throw new Error("Need at least one pattern with an 'options' pattern.");
             }
             const children = clonePatterns(options);
             this._assignChildrenToParent(children);
@@ -2385,14 +2387,14 @@
                 const startIndex = options.reduce((lowestIndex, o) => {
                     return Math.min(lowestIndex, o.startIndex);
                 }, Infinity);
-                const endIndex = cursor.getLastIndex() + 1;
-                error = new ParseError(startIndex, endIndex, this._pattern);
+                const lastIndex = cursor.getLastIndex() + 1;
+                error = new ParseError(startIndex, lastIndex, this._pattern);
                 errorAtIndex = startIndex;
             }
             else if (!isComplete && options.length === 0 && ast != null) {
                 const startIndex = ast.endIndex;
-                const endIndex = cursor.getLastIndex() + 1;
-                error = new ParseError(startIndex, endIndex, this._pattern);
+                const lastIndex = cursor.getLastIndex() + 1;
+                error = new ParseError(startIndex, lastIndex, this._pattern);
                 errorAtIndex = startIndex;
             }
             else if (!isComplete && this._cursor.hasError && this._cursor.furthestError != null) {
@@ -2412,18 +2414,18 @@
             const furthestError = cursor.furthestError;
             const furthestMatch = cursor.allMatchedNodes[cursor.allMatchedNodes.length - 1];
             if (furthestError && furthestMatch) {
-                if (furthestError.endIndex > furthestMatch.endIndex) {
+                if (furthestError.lastIndex > furthestMatch.endIndex) {
                     return furthestMatch.endIndex;
                 }
                 else {
-                    return furthestError.endIndex;
+                    return furthestError.lastIndex;
                 }
             }
             if (furthestError == null && furthestMatch != null) {
                 return furthestMatch.endIndex;
             }
             if (furthestMatch == null && furthestError != null) {
-                return furthestError.endIndex;
+                return furthestError.lastIndex;
             }
             return 0;
         }
@@ -2444,11 +2446,24 @@
         }
         _getOptionsFromErrors() {
             // These errored because the length of the string.
-            const errors = this._cursor.errors.filter(e => e.endIndex === this._cursor.length);
+            const errors = this._cursor.errors.filter(e => e.lastIndex === this._cursor.length);
             const suggestions = errors.map(e => {
                 const tokens = this._getTokensForPattern(e.pattern);
-                const adjustedTokens = tokens.map(t => t.slice(e.endIndex - e.startIndex));
-                return this._createSuggestions(e.endIndex, adjustedTokens);
+                const adjustedTokens = new Set();
+                const currentText = this._cursor.getChars(e.startIndex, e.lastIndex);
+                tokens.forEach((token) => {
+                    if (token.startsWith(currentText) && token.length > currentText.length) {
+                        const difference = token.length - currentText.length;
+                        const suggestedText = token.slice(-difference);
+                        adjustedTokens.add(suggestedText);
+                    }
+                });
+                return Array.from(adjustedTokens).map(t => {
+                    return {
+                        text: t,
+                        startIndex: e.lastIndex,
+                    };
+                });
             });
             return suggestions.flat();
         }
@@ -2623,31 +2638,38 @@
         }
         clone(name = this._name) {
             const clone = new Context(name, this._pattern, Object.values(this._patterns));
+            clone._id = this._id;
             return clone;
         }
         getTokens() {
             return this._pattern.getTokens();
         }
-        getTokensAfter(childReference) {
-            if (this.parent == null) {
+        getTokensAfter(_childReference) {
+            if (this._parent == null) {
                 return [];
             }
-            return this._pattern.getTokensAfter(childReference);
+            return this._parent.getTokensAfter(this);
         }
         getNextTokens() {
-            return this._pattern.getNextTokens();
+            if (this._parent == null) {
+                return [];
+            }
+            return this._parent.getTokensAfter(this);
         }
         getPatterns() {
             return this._pattern.getPatterns();
         }
-        getPatternsAfter(childReference) {
-            if (this.parent == null) {
+        getPatternsAfter(_childReference) {
+            if (this._parent == null) {
                 return [];
             }
-            return this.parent.getPatternsAfter(childReference);
+            return this._parent.getPatternsAfter(this);
         }
         getNextPatterns() {
-            return this._pattern.getNextPatterns();
+            if (this._parent == null) {
+                return [];
+            }
+            return this._parent.getPatternsAfter(this);
         }
         find(predicate) {
             return this._pattern.find(predicate);