clarity-pattern-parser 10.1.23 → 10.1.25

package/dist/index.esm.js

@@ -262,9 +262,11 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
 };
 
 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;
     }
 }
@@ -354,7 +356,7 @@ class CursorHistory {
     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) {
@@ -989,7 +991,7 @@ class Options {
     }
     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);
@@ -2379,14 +2381,14 @@ class AutoComplete {
             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) {
@@ -2406,18 +2408,18 @@ class AutoComplete {
         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;
     }
@@ -2438,11 +2440,24 @@ class AutoComplete {
     }
     _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();
     }
@@ -2617,31 +2632,38 @@ class Context {
     }
     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);