clarity-pattern-parser 11.0.4 → 11.0.6

package/dist/patterns/ExpressionPattern.d.ts

@@ -17,7 +17,7 @@ export declare class ExpressionPattern implements Pattern {
     private _postfixNames;
     private _binaryPatterns;
     private _binaryNames;
-    private associationMap;
+    private _associationMap;
     private _precedenceMap;
     private _shouldStopParsing;
     private _precedenceTree;
@@ -55,10 +55,10 @@ export declare class ExpressionPattern implements Pattern {
     test(text: string, record?: boolean): boolean;
     exec(text: string, record?: boolean): ParseResult;
     getTokens(): string[];
-    getTokensAfter(_childReference: Pattern): string[];
+    getTokensAfter(childReference: Pattern): string[];
     getNextTokens(): string[];
     getPatterns(): Pattern[];
-    getPatternsAfter(_childReference: Pattern): Pattern[];
+    getPatternsAfter(childReference: Pattern): Pattern[];
     getNextPatterns(): Pattern[];
     find(predicate: (p: Pattern) => boolean): Pattern | null;
     clone(name?: string): Pattern;

package/package.json

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

package/src/intellisense/AutoComplete.test.ts

@@ -430,7 +430,7 @@ describe("AutoComplete", () => {
     test("Repeat with bad trailing content", () => {
         const flags = ["FlagA", "FlagB", "FlagC"];
         const pattern = generateExpression(flags);
-        const result = new AutoComplete(pattern).suggestFor("FlagA AND FlagAlkjhgB")
+        const result = new AutoComplete(pattern).suggestFor("FlagA AND FlagAlkjhgB");
 
         expect(result.options).toEqual([]);
         expect(result.ast?.value).toBe("FlagA AND FlagA");

package/src/patterns/ExpressionPattern.test.ts

@@ -163,8 +163,7 @@ describe("Expression Pattern", () => {
         const expression = createExpressionPattern();
 
         const autoComplete = new AutoComplete(expression);
-        const suggestion = autoComplete.suggestFor("a");
-
+        const suggestion = autoComplete.suggestFor("a ? b ");
         expect(suggestion).toBe(suggestion);
     });
 });

package/src/patterns/ExpressionPattern.ts

@@ -25,7 +25,7 @@ export class ExpressionPattern implements Pattern {
     private _postfixNames: string[];
     private _binaryPatterns: Pattern[];
     private _binaryNames: string[];
-    private associationMap: Record<string, Association>;
+    private _associationMap: Record<string, Association>;
     private _precedenceMap: Record<string, number>;
     private _shouldStopParsing: boolean;
     private _precedenceTree: PrecedenceTree;
@@ -91,12 +91,12 @@ export class ExpressionPattern implements Pattern {
         this._postfixNames = [];
         this._binaryPatterns = [];
         this._binaryNames = [];
-        this.associationMap = {};
+        this._associationMap = {};
         this._precedenceMap = {};
         this._originalPatterns = patterns;
         this._patterns = this._organizePatterns(patterns);
         this._shouldStopParsing = false;
-        this._precedenceTree = new PrecedenceTree(this._precedenceMap, this.associationMap);
+        this._precedenceTree = new PrecedenceTree(this._precedenceMap, this._associationMap);
 
         if (this._atomPatterns.length === 0) {
             throw new Error("Need at least one terminating pattern with an 'expression' pattern.");
@@ -143,9 +143,9 @@ export class ExpressionPattern implements Pattern {
                 this._binaryNames.push(name);
 
                 if (pattern.type === "right-associated") {
-                    this.associationMap[name] = Association.right;
+                    this._associationMap[name] = Association.right;
                 } else {
-                    this.associationMap[name] = Association.left;
+                    this._associationMap[name] = Association.left;
                 }
 
                 finalPatterns.push(clone);
@@ -183,7 +183,7 @@ export class ExpressionPattern implements Pattern {
         pattern = this._unwrapAssociationIfNecessary(pattern);
 
         const firstChild = pattern.children[0];
-        const lastChild = pattern.children[1];
+        const lastChild = pattern.children[pattern.children.length -1];
         const firstChildIsReference = this._isRecursiveReference(firstChild);
         const lastChildIsReference = this._isRecursiveReference(lastChild);
 
@@ -238,7 +238,7 @@ export class ExpressionPattern implements Pattern {
     }
 
     private _isRecursiveReference(pattern: Pattern) {
-        if (pattern == null){
+        if (pattern == null) {
             return false;
         }
         return pattern.type === "reference" && pattern.name === this.name;
@@ -457,7 +457,31 @@ export class ExpressionPattern implements Pattern {
         return this.atomPatterns.map(p => p.getTokens()).flat();
     }
 
-    getTokensAfter(_childReference: Pattern): string[] {
+    getTokensAfter(childReference: Pattern): string[] {
+        if (this._prefixPatterns.includes(childReference) || this._binaryPatterns.includes(childReference)) {
+            const atomTokens = this._atomPatterns.map(p => p.getTokens()).flat();
+            const prefixTokens = this.prefixPatterns.map(p => p.getTokens()).flat();
+
+            return [...prefixTokens, ...atomTokens];
+        }
+
+        if (this._atomPatterns.includes(childReference)) {
+            const postfixTokens = this.prefixPatterns.map(p => p.getTokens()).flat();
+
+            if (postfixTokens.length === 0){
+                return this._binaryPatterns.map(p => p.getTokens()).flat();
+            }
+
+            return postfixTokens;
+        }
+
+        if (this._postfixPatterns.includes(childReference)) {
+            const postfixTokens = this.postfixPatterns.map(p => p.getTokens()).flat();
+            const binaryTokens = this._binaryPatterns.map(p => p.getTokens()).flat();
+
+            return [...postfixTokens, ...binaryTokens];
+        }
+
         return [];
     }
 
@@ -473,7 +497,31 @@ export class ExpressionPattern implements Pattern {
         return this.atomPatterns.map(p => p.getPatterns()).flat();
     }
 
-    getPatternsAfter(_childReference: Pattern): Pattern[] {
+    getPatternsAfter(childReference: Pattern): Pattern[] {
+        if (this._prefixPatterns.includes(childReference) || this._binaryPatterns.includes(childReference)) {
+            const atomPatterns = this._atomPatterns.map(p => p.getPatterns()).flat();
+            const prefixPatterns = this.prefixPatterns.map(p => p.getPatterns()).flat();
+
+            return [...prefixPatterns, ...atomPatterns];
+        }
+
+        if (this._atomPatterns.includes(childReference)) {
+            const postfixPatterns = this.prefixPatterns.map(p => p.getPatterns()).flat();
+
+            if (postfixPatterns.length === 0){
+                return this._binaryPatterns.map(p => p.getPatterns()).flat();
+            }
+
+            return postfixPatterns;
+        }
+
+        if (this._postfixPatterns.includes(childReference)) {
+            const postfixPaterns = this.postfixPatterns.map(p => p.getPatterns()).flat();
+            const binaryPatterns = this._binaryPatterns.map(p => p.getPatterns()).flat();
+
+            return [...postfixPaterns, ...binaryPatterns];
+        }
+
         return [];
     }
 

package/src/patterns/PrecedenceTree.test.ts

@@ -248,7 +248,7 @@ describe("Precedence Tree", () => {
         expect(result?.toCycleFreeObject()).toEqual(expected.toCycleFreeObject());
     });
 
-    test("add Partial Binary With Greater Precedence", () => {
+    test("mul Partial Binary With Greater Precedence", () => {
         const tree = new PrecedenceTree({
             mul: 0,
             add: 1,