clarity-pattern-parser 11.5.2 → 11.5.4

package/dist/patterns/Expression.d.ts

@@ -17,8 +17,8 @@ export declare class Expression implements Pattern {
     private _prefixNames;
     private _postfixPatterns;
     private _postfixNames;
-    private _binaryPatterns;
-    private _binaryNames;
+    private _infixPatterns;
+    private _infixNames;
     private _associationMap;
     private _precedenceMap;
     private _shouldStopParsing;
@@ -34,6 +34,7 @@ export declare class Expression implements Pattern {
     get prefixPatterns(): readonly Pattern[];
     get atomPatterns(): readonly Pattern[];
     get postfixPatterns(): readonly Pattern[];
+    get infixPatterns(): readonly Pattern[];
     get binaryPatterns(): readonly Pattern[];
     get originalPatterns(): readonly Pattern[];
     get startedOnIndex(): number;
@@ -47,7 +48,7 @@ export declare class Expression implements Pattern {
     private _isPostfix;
     private _extractPostfix;
     private _isBinary;
-    private _extractBinary;
+    private _extractInfix;
     private _unwrapAssociationIfNecessary;
     private _referenceCount;
     private _isRecursiveReference;

package/package.json

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

package/src/patterns/Expression.ts

@@ -26,8 +26,8 @@ export class Expression implements Pattern {
     private _prefixNames: string[];
     private _postfixPatterns: Pattern[];
     private _postfixNames: string[];
-    private _binaryPatterns: Pattern[];
-    private _binaryNames: string[];
+    private _infixPatterns: Pattern[];
+    private _infixNames: string[];
     private _associationMap: Record<string, Association>;
     private _precedenceMap: Record<string, number>;
     private _shouldStopParsing: boolean;
@@ -71,8 +71,13 @@ export class Expression implements Pattern {
         return this._postfixPatterns;
     }
 
+    get infixPatterns(): readonly Pattern[] {
+        return this._infixPatterns;
+    }
+
+    // @deprecated use infixPatterns instead
     get binaryPatterns(): readonly Pattern[] {
-        return this._binaryPatterns;
+        return this._infixPatterns;
     }
 
     get originalPatterns(): readonly Pattern[] {
@@ -100,8 +105,8 @@ export class Expression implements Pattern {
         this._prefixNames = [];
         this._postfixPatterns = [];
         this._postfixNames = [];
-        this._binaryPatterns = [];
-        this._binaryNames = [];
+        this._infixPatterns = [];
+        this._infixNames = [];
         this._associationMap = {};
         this._precedenceMap = {};
         this._originalPatterns = patterns;
@@ -146,12 +151,12 @@ export class Expression implements Pattern {
                 finalPatterns.push(postfix);
             } else if (this._isBinary(pattern)) {
                 const name = this._extractName(pattern);
-                const binary = this._extractBinary(pattern);
-                binary.parent = this;
+                const infix = this._extractInfix(pattern);
+                infix.parent = this;
 
                 this._precedenceMap[name] = index;
-                this._binaryPatterns.push(binary);
-                this._binaryNames.push(name);
+                this._infixPatterns.push(infix);
+                this._infixNames.push(name);
 
                 if (pattern.type === "right-associated") {
                     this._associationMap[name] = Association.right;
@@ -159,7 +164,7 @@ export class Expression implements Pattern {
                     this._associationMap[name] = Association.left;
                 }
 
-                finalPatterns.push(binary);
+                finalPatterns.push(infix);
             }
         });
 
@@ -246,12 +251,12 @@ export class Expression implements Pattern {
         return firstChildIsReference && lastChildIsReference && pattern.children.length > 2;
     }
 
-    private _extractBinary(pattern: Pattern) {
+    private _extractInfix(pattern: Pattern) {
         pattern = this._unwrapAssociationIfNecessary(pattern);
         const children = pattern.children.slice(1, -1);
-        const binarySequence = new Sequence(`${pattern.name}-delimiter`, children);
+        const infixSequence = new Sequence(`${pattern.name}-delimiter`, children);
 
-        return binarySequence;
+        return infixSequence;
     }
 
     private _unwrapAssociationIfNecessary(pattern: Pattern) {
@@ -452,15 +457,15 @@ export class Expression implements Pattern {
         let onIndex = cursor.index;
         let foundMatch = false;
 
-        if (this.binaryPatterns.length === 0) {
+        if (this.infixPatterns.length === 0) {
             this._shouldStopParsing = true;
         }
 
-        for (let i = 0; i < this._binaryPatterns.length; i++) {
+        for (let i = 0; i < this._infixPatterns.length; i++) {
             cursor.moveTo(onIndex);
 
-            const pattern = this._binaryPatterns[i];
-            const name = this._binaryNames[i];
+            const pattern = this._infixPatterns[i];
+            const name = this._infixNames[i];
             const node = pattern.parse(cursor);
 
             if (node != null) {
@@ -503,7 +508,7 @@ export class Expression implements Pattern {
 
     getTokensAfter(childReference: Pattern): string[] {
         this.build();
-        if (this._prefixPatterns.includes(childReference) || this._binaryPatterns.includes(childReference)) {
+        if (this._prefixPatterns.includes(childReference) || this._infixPatterns.includes(childReference)) {
             const atomTokens = this._atomPatterns.map(p => p.getTokens()).flat();
             const prefixTokens = this.prefixPatterns.map(p => p.getTokens()).flat();
 
@@ -512,19 +517,29 @@ export class Expression implements Pattern {
 
         if (this._atomPatterns.includes(childReference)) {
             const postfixTokens = this.postfixPatterns.map(p => p.getTokens()).flat();
+            const infixTokens = this._infixPatterns.map(p => p.getTokens()).flat();
 
-            if (postfixTokens.length === 0) {
-                return this._binaryPatterns.map(p => p.getTokens()).flat();
+            if (this._parent != null) {
+                return [...postfixTokens, ...infixTokens, ...this._parent.getNextTokens()];
             }
 
-            return postfixTokens;
+            return [...postfixTokens, ...infixTokens];
+        }
+
+        if (this._infixPatterns.includes(childReference)) {
+            const atomTokens = this._atomPatterns.map(p => p.getTokens()).flat();
+            return atomTokens;
         }
 
         if (this._postfixPatterns.includes(childReference)) {
             const postfixTokens = this.postfixPatterns.map(p => p.getTokens()).flat();
-            const binaryTokens = this._binaryPatterns.map(p => p.getTokens()).flat();
+            const infixTokens = this._infixPatterns.map(p => p.getTokens()).flat();
+
+            if (this._parent != null) {
+                return [...postfixTokens, ...infixTokens, ...this._parent.getNextTokens()];
+            }
 
-            return [...postfixTokens, ...binaryTokens];
+            return [...postfixTokens, ...infixTokens];
         }
 
         return [];
@@ -548,7 +563,7 @@ export class Expression implements Pattern {
 
     getPatternsAfter(childReference: Pattern): Pattern[] {
         this.build();
-        if (this._prefixPatterns.includes(childReference) || this._binaryPatterns.includes(childReference)) {
+        if (this._prefixPatterns.includes(childReference) || this._infixPatterns.includes(childReference)) {
             const atomPatterns = this._atomPatterns.map(p => p.getPatterns()).flat();
             const prefixPatterns = this.prefixPatterns.map(p => p.getPatterns()).flat();
 
@@ -557,19 +572,29 @@ export class Expression implements Pattern {
 
         if (this._atomPatterns.includes(childReference)) {
             const postfixPatterns = this.postfixPatterns.map(p => p.getPatterns()).flat();
+            const infixPatterns = this._infixPatterns.map(p => p.getPatterns()).flat();
 
-            if (postfixPatterns.length === 0) {
-                return this._binaryPatterns.map(p => p.getPatterns()).flat();
+            if (this._parent != null) {
+                return [...postfixPatterns, ...infixPatterns, ...this._parent.getNextPatterns()];
             }
 
-            return postfixPatterns;
+            return [...postfixPatterns, ...infixPatterns];
+        }
+
+        if (this._infixPatterns.includes(childReference)) {
+            const atomPatterns = this._atomPatterns.map(p => p.getPatterns()).flat();
+            return atomPatterns;
         }
 
         if (this._postfixPatterns.includes(childReference)) {
             const postfixPatterns = this.postfixPatterns.map(p => p.getPatterns()).flat();
-            const binaryPatterns = this._binaryPatterns.map(p => p.getPatterns()).flat();
+            const infixPatterns = this._infixPatterns.map(p => p.getPatterns()).flat();
+
+            if (this._parent != null) {
+                return [...postfixPatterns, ...infixPatterns, ...this._parent.getNextPatterns()];
+            }
 
-            return [...postfixPatterns, ...binaryPatterns];
+            return [...postfixPatterns, ...infixPatterns];
         }
 
         return [];