clarity-pattern-parser 11.3.4 → 11.3.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clarity-pattern-parser",
-  "version": "11.3.4",
+  "version": "11.3.5",
   "description": "Parsing Library for Typescript and Javascript.",
   "main": "./dist/index.js",
   "module": "./dist/index.esm.js",

package/src/generator/generator.ts

@@ -1,9 +1,4 @@
-import { Context } from "../patterns/Context";
-import { Expression } from "../patterns/Expression";
-import { Literal } from "../patterns/Literal";
 import { Pattern } from "../patterns/Pattern";
-import { Regex } from "../patterns/Regex";
-import { Repeat } from "../patterns/Repeat";
 import { IVisitor } from "./ivisitor";
 
 export class Generator {

package/src/intellisense/AutoComplete.test.ts

@@ -236,6 +236,39 @@ describe("AutoComplete", () => {
 
     });
 
+
+    test("Options AutoComplete on Root Pattern", () => {
+
+        const jack = new Literal("first-name", "Jack");
+        const john = new Literal("first-name", "John");
+
+        const names = new Options('names', [jack,john]);
+        const divider = new Literal('divider', ', ');
+        const repeat = new Repeat('name-list', names, { divider, trimDivider: true });
+
+        const text = ''
+
+        const autoCompleteOptions: AutoCompleteOptions = {
+            customTokens: {
+                'first-name': ["James"]
+            }
+        };
+        const autoComplete = new AutoComplete(repeat,autoCompleteOptions);
+
+        const suggestion = autoComplete.suggestFor(text)
+
+        console.log('suggestion: ',suggestion)
+
+        const expectedOptions = [
+            { text: "Jack", startIndex: 0 },
+            { text: "John", startIndex: 0 },
+            { text: "James", startIndex: 0 },
+        ];
+
+        expect(suggestion.options).toEqual(expectedOptions)
+    
+    })
+
     test("Options AutoComplete On Leaf Pattern", () => {
         const autoCompleteOptions: AutoCompleteOptions = {
             greedyPatternNames: ["space"],
@@ -648,4 +681,33 @@ describe("AutoComplete", () => {
         }
     ]);
     });
-});
+
+
+    test("Calling AutoComplete -> _getAllOptions Does not mutate customTokensMap", () => {
+
+        const jediLuke = new Literal(`jedi`, 'luke');
+        const names = new Options('names', [jediLuke]);
+        const divider = new Literal('divider', ', ');
+        const pattern = new Repeat('name-list', names, { divider, trimDivider: true });
+        
+        const customTokensMap:Record<string, string[]> = {
+            'jedi': ["leia"]
+        }
+        
+        const copiedCustomTokensMap:Record<string, string[]>  = JSON.parse(JSON.stringify(customTokensMap));
+        
+        const autoCompleteOptions: AutoCompleteOptions = {
+            greedyPatternNames:['jedi'],
+            customTokens: customTokensMap
+        };
+        const autoComplete = new AutoComplete(pattern,autoCompleteOptions);
+        
+        // provide a non-empty input to trigger the logic flow that hits _getAllOptions
+        autoComplete.suggestFor('l')
+        
+        expect(customTokensMap).toEqual(copiedCustomTokensMap)
+    })
+
+});
+
+  

package/src/intellisense/AutoComplete.ts

@@ -159,7 +159,7 @@ export class AutoComplete {
 
   private _createSuggestionsFromRoot(): SuggestionOption[] {
     const suggestions: SuggestionOption[] = [];
-    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) {
@@ -197,21 +197,21 @@ export class AutoComplete {
 
     if (this._options.greedyPatternNames != null && this._options.greedyPatternNames.includes(pattern.name)) {
       const nextPatterns = pattern.getNextPatterns();
-      const tokens: string[] = [];
-
       const nextPatternTokens = nextPatterns.reduce((acc: string[], 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<string>();
+      
+      for (const token of augmentedTokens) {
+        for (const nextPatternToken of nextPatternTokens) {    
+          tokens.add(token + nextPatternToken);
         }
       }
 
-      return tokens;
-    } else {
+      return [...tokens]
+        } else {
       return augmentedTokens;
     }
   }
@@ -219,14 +219,22 @@ export class AutoComplete {
   private _getAugmentedTokens(pattern: Pattern) {
     const customTokensMap: any = this._options.customTokens || {};
     const leafPatterns = pattern.getPatterns();
-    const tokens: string[] = customTokensMap[pattern.name] || [];
 
-    leafPatterns.forEach(p => {
-      const augmentedTokens = customTokensMap[p.name] || [];
-      tokens.push(...p.getTokens(), ...augmentedTokens);
-    });
+  /** Using Set to
+   * - prevent duplicates
+   * - prevent mutation of original customTokensMap
+   */
+  const customTokensForPattern = new Set<string>(customTokensMap[pattern.name] ?? []);
+
+  for (const lp of leafPatterns) {
+    const augmentedTokens = customTokensMap[lp.name] ?? [];
+    const lpsCombinedTokens = [...lp.getTokens(), ...augmentedTokens];
 
-    return tokens;
+  for (const token of lpsCombinedTokens) {    
+    customTokensForPattern.add(token);
+  }
+  }
+    return [...customTokensForPattern];
   }
 
   private _createSuggestions(lastIndex: number, tokens: string[]): SuggestionOption[] {