clarity-pattern-parser 11.3.8 → 11.3.10

package/dist/index.browser.js

@@ -1257,12 +1257,10 @@
                     }
                 }
             }
-            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;
@@ -1398,6 +1396,7 @@
             this._firstIndex = 0;
             this._nodes = [];
             this._trimDivider = options.trimDivider == null ? false : options.trimDivider;
+            this._patterns = [];
         }
         _assignChildrenToParent(children) {
             for (const child of children) {
@@ -1413,6 +1412,7 @@
         parse(cursor) {
             this._firstIndex = cursor.index;
             this._nodes = [];
+            this._patterns = [];
             const passed = this._tryToParse(cursor);
             if (passed) {
                 cursor.resolveError();
@@ -1464,6 +1464,7 @@
                     }
                     if (repeatNode != null) {
                         this._nodes.push(repeatNode);
+                        this._patterns.push(this._pattern);
                         if (!cursor.hasNext()) {
                             passed = true;
                             break;
@@ -1488,6 +1489,7 @@
                             }
                             else {
                                 this._nodes.push(dividerNode);
+                                this._patterns.push(this._divider);
                                 if (!cursor.hasNext()) {
                                     passed = true;
                                     break;
@@ -1510,11 +1512,11 @@
             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);
             }
@@ -4062,7 +4064,7 @@
             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 {
@@ -4117,7 +4119,7 @@
         }
         _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));
@@ -4129,15 +4131,29 @@
             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 [];
@@ -4147,44 +4163,54 @@
             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);
@@ -4194,10 +4220,11 @@
         _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);