clarity-pattern-parser 11.3.3 → 11.3.5

package/dist/patterns/Expression.d.ts

@@ -23,6 +23,7 @@ export declare class Expression implements Pattern {
     private _shouldStopParsing;
     private _precedenceTree;
     private _hasOrganized;
+    private _atomsIdToAncestorsMap;
     get id(): string;
     get type(): string;
     get name(): string;
@@ -37,6 +38,7 @@ export declare class Expression implements Pattern {
     get startedOnIndex(): number;
     constructor(name: string, patterns: Pattern[]);
     private _organizePatterns;
+    private _cacheAncestors;
     private _extractName;
     private _isPrefix;
     private _extractPrefix;
@@ -53,6 +55,7 @@ export declare class Expression implements Pattern {
     private _tryToParse;
     private _tryToMatchPrefix;
     private _tryToMatchAtom;
+    private _isBeyondRecursiveAllowance;
     private _tryToMatchPostfix;
     private _tryToMatchBinary;
     test(text: string, record?: boolean): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clarity-pattern-parser",
-  "version": "11.3.3",
+  "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[] {

package/src/patterns/Expression.ts

@@ -32,6 +32,7 @@ export class Expression implements Pattern {
     private _shouldStopParsing: boolean;
     private _precedenceTree: PrecedenceTree;
     private _hasOrganized: boolean;
+    private _atomsIdToAncestorsMap: Record<string, Pattern[]>
 
     get id(): string {
         return this._id;
@@ -106,6 +107,7 @@ export class Expression implements Pattern {
         this._hasOrganized = false;
         this._patterns = [];
         this._precedenceTree = new PrecedenceTree({}, {});
+        this._atomsIdToAncestorsMap = {};
     }
 
     private _organizePatterns(patterns: Pattern[]) {
@@ -163,6 +165,21 @@ export class Expression implements Pattern {
         return finalPatterns;
     }
 
+    private _cacheAncestors() {
+        for (let atom of this._atomPatterns) {
+            const id = atom.id;
+            const ancestors: Pattern[] = this._atomsIdToAncestorsMap[id] = [];
+
+            let pattern: Pattern | null = this.parent;
+            while (pattern != null) {
+                if (pattern.id === id) {
+                    ancestors.push(pattern);
+                }
+                pattern = pattern.parent;
+            }
+        }
+    }
+
     private _extractName(pattern: Pattern) {
         if (pattern.type === "right-associated") {
             return pattern.children[0].name;
@@ -262,6 +279,7 @@ export class Expression implements Pattern {
         if (!this._hasOrganized) {
             this._hasOrganized = true;
             this._organizePatterns(this._originalPatterns);
+            this._cacheAncestors();
         }
     }
 
@@ -367,6 +385,11 @@ export class Expression implements Pattern {
             cursor.moveTo(onIndex);
 
             const pattern = this._atomPatterns[i];
+
+            if (this._isBeyondRecursiveAllowance(pattern, onIndex)) {
+                continue;
+            }
+
             const node = pattern.parse(cursor);
 
             if (node != null) {
@@ -386,6 +409,11 @@ export class Expression implements Pattern {
         }
     }
 
+    private _isBeyondRecursiveAllowance(atom: Pattern, onIndex: number) {
+        const ancestors = this._atomsIdToAncestorsMap[atom.id];
+        return ancestors.some(a => a.startedOnIndex === onIndex);
+    }
+
     private _tryToMatchPostfix(cursor: Cursor) {
         let onIndex = cursor.index;
 

package/src/patterns/Reference.ts

@@ -108,7 +108,7 @@ export class Reference implements Pattern {
       if (pattern.startedOnIndex === this.startedOnIndex) {
         depth++;
 
-        if (depth > 0) {
+        if (depth > 1) {
           return true;
         }
       }