clarity-pattern-parser 11.3.8 → 11.3.10

package/dist/index.esm.js

@@ -1251,12 +1251,10 @@ class FiniteRepeat {
                 }
             }
         }
-        if (this._trimDivider && this._hasDivider) {
-            const isDividerLastMatch = this.children.length > 1 && nodes.length > 1 && nodes[nodes.length - 1].name === this.children[1].name;
-            if (isDividerLastMatch) {
-                const node = nodes.pop();
-                cursor.moveTo(node.firstIndex);
-            }
+        const endedOnDivider = this._hasDivider && nodes.length % modulo === 0;
+        if (this._trimDivider && endedOnDivider) {
+            const node = nodes.pop();
+            cursor.moveTo(node.firstIndex);
         }
         if (matchCount < this._min) {
             const lastIndex = cursor.index;
@@ -1392,6 +1390,7 @@ class InfiniteRepeat {
         this._firstIndex = 0;
         this._nodes = [];
         this._trimDivider = options.trimDivider == null ? false : options.trimDivider;
+        this._patterns = [];
     }
     _assignChildrenToParent(children) {
         for (const child of children) {
@@ -1407,6 +1406,7 @@ class InfiniteRepeat {
     parse(cursor) {
         this._firstIndex = cursor.index;
         this._nodes = [];
+        this._patterns = [];
         const passed = this._tryToParse(cursor);
         if (passed) {
             cursor.resolveError();
@@ -1458,6 +1458,7 @@ class InfiniteRepeat {
                 }
                 if (repeatNode != null) {
                     this._nodes.push(repeatNode);
+                    this._patterns.push(this._pattern);
                     if (!cursor.hasNext()) {
                         passed = true;
                         break;
@@ -1482,6 +1483,7 @@ class InfiniteRepeat {
                         }
                         else {
                             this._nodes.push(dividerNode);
+                            this._patterns.push(this._divider);
                             if (!cursor.hasNext()) {
                                 passed = true;
                                 break;
@@ -1504,11 +1506,11 @@ class InfiniteRepeat {
         return passed;
     }
     _createNode(cursor) {
-        var _a;
         const hasDivider = this._divider != null;
+        const lastPattern = this._patterns[this._patterns.length - 1];
         if (hasDivider &&
             this._trimDivider &&
-            this._nodes[this._nodes.length - 1].name === ((_a = this._divider) === null || _a === void 0 ? void 0 : _a.name)) {
+            lastPattern === this._divider) {
             const dividerNode = this._nodes.pop();
             cursor.moveTo(dividerNode.firstIndex);
         }
@@ -4056,7 +4058,7 @@ class AutoComplete {
         const furthestError = cursor.furthestError;
         const furthestMatch = cursor.allMatchedNodes[cursor.allMatchedNodes.length - 1];
         if (furthestError && furthestMatch) {
-            if (furthestError.lastIndex > furthestMatch.endIndex) {
+            if (furthestMatch.endIndex > furthestError.lastIndex) {
                 return furthestMatch.endIndex;
             }
             else {
@@ -4111,7 +4113,7 @@ class AutoComplete {
     }
     _createSuggestionsFromRoot() {
         const suggestions = [];
-        const tokens = this._pattern.getTokens();
+        const tokens = [...this._pattern.getTokens(), ...this._getTokensForPattern(this._pattern)];
         for (const token of tokens) {
             if (suggestions.findIndex(s => s.text === token) === -1) {
                 suggestions.push(this._createSuggestion("", token));
@@ -4123,15 +4125,29 @@ class AutoComplete {
         if (match.pattern == null) {
             return this._createSuggestions(-1, this._getTokensForPattern(this._pattern));
         }
-        const leafPattern = match.pattern;
-        const parent = match.pattern.parent;
-        if (parent !== null && match.node != null) {
-            const patterns = leafPattern.getNextPatterns();
-            const tokens = patterns.reduce((acc, pattern) => {
-                acc.push(...this._getTokensForPattern(pattern));
+        if (match.node != null) {
+            const textStartingMatch = this._text.slice(match.node.startIndex, match.node.endIndex);
+            const currentPatternsTokens = this._getTokensForPattern(match.pattern);
+            /**
+             * Compares tokens to current text and extracts remainder tokens
+             * - IE. **currentText:** *abc*, **baseToken:** *abcdef*, **trailingToken:** *def*
+             */
+            const trailingTokens = currentPatternsTokens.reduce((acc, token) => {
+                if (token.startsWith(textStartingMatch)) {
+                    const sliced = token.slice(textStartingMatch.length);
+                    if (sliced !== '') {
+                        acc.push(sliced);
+                    }
+                }
                 return acc;
             }, []);
-            return this._createSuggestions(match.node.lastIndex, tokens);
+            const leafPatterns = match.pattern.getNextPatterns();
+            const leafTokens = leafPatterns.reduce((acc, leafPattern) => {
+                acc.push(...this._getTokensForPattern(leafPattern));
+                return acc;
+            }, []);
+            const allTokens = [...trailingTokens, ...leafTokens];
+            return this._createSuggestions(match.node.lastIndex, allTokens);
         }
         else {
             return [];
@@ -4141,44 +4157,54 @@ class AutoComplete {
         const augmentedTokens = this._getAugmentedTokens(pattern);
         if (this._options.greedyPatternNames != null && this._options.greedyPatternNames.includes(pattern.name)) {
             const nextPatterns = pattern.getNextPatterns();
-            const tokens = [];
             const nextPatternTokens = nextPatterns.reduce((acc, pattern) => {
                 acc.push(...this._getTokensForPattern(pattern));
                 return acc;
             }, []);
-            for (let token of augmentedTokens) {
-                for (let nextPatternToken of nextPatternTokens) {
-                    tokens.push(token + nextPatternToken);
+            // using set to prevent duplicates
+            const tokens = new Set();
+            for (const token of augmentedTokens) {
+                for (const nextPatternToken of nextPatternTokens) {
+                    tokens.add(token + nextPatternToken);
                 }
             }
-            return tokens;
+            return [...tokens];
         }
         else {
             return augmentedTokens;
         }
     }
     _getAugmentedTokens(pattern) {
+        var _a, _b;
         const customTokensMap = this._options.customTokens || {};
         const leafPatterns = pattern.getPatterns();
-        const tokens = customTokensMap[pattern.name] || [];
-        leafPatterns.forEach(p => {
-            const augmentedTokens = customTokensMap[p.name] || [];
-            tokens.push(...p.getTokens(), ...augmentedTokens);
-        });
-        return tokens;
+        /** Using Set to
+         * - prevent duplicates
+         * - prevent mutation of original customTokensMap
+         */
+        const customTokensForPattern = new Set((_a = customTokensMap[pattern.name]) !== null && _a !== void 0 ? _a : []);
+        for (const lp of leafPatterns) {
+            const augmentedTokens = (_b = customTokensMap[lp.name]) !== null && _b !== void 0 ? _b : [];
+            const lpsCombinedTokens = [...lp.getTokens(), ...augmentedTokens];
+            for (const token of lpsCombinedTokens) {
+                customTokensForPattern.add(token);
+            }
+        }
+        return [...customTokensForPattern];
     }
     _createSuggestions(lastIndex, tokens) {
-        let substring = lastIndex === -1 ? "" : this._cursor.getChars(0, lastIndex);
+        let textToIndex = lastIndex === -1 ? "" : this._cursor.getChars(0, lastIndex);
         const suggestionStrings = [];
         const options = [];
         for (const token of tokens) {
-            const suggestion = substring + token;
-            const startsWith = suggestion.startsWith(substring);
+            // concatenated for start index identification inside createSuggestion
+            const suggestion = textToIndex + token;
             const alreadyExist = suggestionStrings.includes(suggestion);
             const isSameAsText = suggestion === this._text;
-            if (startsWith && !alreadyExist && !isSameAsText) {
+            if (!alreadyExist && !isSameAsText) {
                 suggestionStrings.push(suggestion);
-                options.push(this._createSuggestion(this._cursor.text, suggestion));
+                const suggestionOption = this._createSuggestion(this._cursor.text, suggestion);
+                options.push(suggestionOption);
             }
         }
         const reducedOptions = getFurthestOptions(options);
@@ -4188,10 +4214,11 @@ class AutoComplete {
     _createSuggestion(fullText, suggestion) {
         const furthestMatch = findMatchIndex(suggestion, fullText);
         const text = suggestion.slice(furthestMatch);
-        return {
+        const option = {
             text: text,
             startIndex: furthestMatch,
         };
+        return option;
     }
     static suggestFor(text, pattern, options) {
         return new AutoComplete(pattern, options).suggestFor(text);