clarity-pattern-parser 10.1.21 → 10.1.23

package/dist/patterns/Reference.d.ts

@@ -20,7 +20,7 @@ export declare class Reference implements Pattern {
     test(text: string): boolean;
     exec(text: string, record?: boolean): ParseResult;
     parse(cursor: Cursor): Node | null;
-    private _getPatternSafely;
+    getReferencePatternSafely(): Pattern;
     private _findPattern;
     private _isValidPattern;
     private _getRoot;

package/dist/patterns/isRecursivePattern.d.ts

@@ -0,0 +1,2 @@
+import { Pattern } from "./Pattern";
+export declare function isRecursivePattern(pattern: Pattern): boolean;

package/package.json

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

package/src/patterns/Context.ts

@@ -84,6 +84,9 @@ export class Context implements Pattern {
     }
 
     getTokensAfter(childReference: Pattern): string[] {
+        if (this.parent == null) {
+            return [];
+        }
         return this._pattern.getTokensAfter(childReference);
     }
 
@@ -96,7 +99,11 @@ export class Context implements Pattern {
     }
 
     getPatternsAfter(childReference: Pattern): Pattern[] {
-        return this._pattern.getPatternsAfter(childReference);
+        if (this.parent == null) {
+            return [];
+        }
+
+        return this.parent.getPatternsAfter(childReference);
     }
 
     getNextPatterns(): Pattern[] {

package/src/patterns/ExpressionPattern.ts

@@ -41,17 +41,23 @@ export class ExpressionPattern implements Pattern {
     }
 
     get children(): Pattern[] {
-        return [];
+        return this._patterns;
     }
 
-    constructor(name: string, patterns: []) {
+    constructor(name: string, patterns: Pattern[]) {
         this._id = `expression-${indexId++}`;
         this._type = "expression";
+        this._name = name;
         this._unaryPatterns = [];
         this._binaryPatterns = [];
+
+        this._patterns.forEach(p => p.parent = this);
+        this._patterns = this._organizePatterns(patterns);
+
     }
 
-    private _organizePatterns() {
+    private _organizePatterns(patterns: Pattern[]) {
+        const finalPatterns = [];
         this._patterns.forEach((pattern) => {
             if (this._isBinary(pattern)) {
                 this._binaryPatterns.push(pattern);
@@ -59,6 +65,8 @@ export class ExpressionPattern implements Pattern {
                 this._unaryPatterns.push();
             }
         });
+
+        return finalPatterns;
     }
 
     private _isBinary(pattern: Pattern) {

package/src/patterns/Options.ts

@@ -5,6 +5,7 @@ import { clonePatterns } from "./clonePatterns";
 import { findPattern } from "./findPattern";
 import { ParseResult } from "./ParseResult";
 import { DepthCache } from './DepthCache';
+import { isRecursivePattern } from "./isRecursivePattern";
 
 /*
   The following is created to reduce the overhead of recursion check. 
@@ -143,7 +144,7 @@ export class Options implements Pattern {
     const tokens: string[] = [];
 
     for (const pattern of this._children) {
-      if (pattern.type === "reference" && pattern.name === this.name) {
+      if (isRecursivePattern(pattern)) {
         continue;
       }
       tokens.push(...pattern.getTokens());
@@ -172,7 +173,7 @@ export class Options implements Pattern {
     const patterns: Pattern[] = [];
 
     for (const pattern of this._children) {
-      if (pattern.type === "reference" && pattern.name === this.name) {
+      if (isRecursivePattern(pattern)) {
         continue;
       }
       patterns.push(...pattern.getPatterns());

package/src/patterns/Reference.ts

@@ -70,10 +70,10 @@ export class Reference implements Pattern {
   }
 
   parse(cursor: Cursor): Node | null {
-    return this._getPatternSafely().parse(cursor);
+    return this.getReferencePatternSafely().parse(cursor);
   }
 
-  private _getPatternSafely(): Pattern {
+  getReferencePatternSafely(): Pattern {
     if (this._pattern === null) {
       let pattern: Pattern | null = null;
 
@@ -150,7 +150,7 @@ export class Reference implements Pattern {
   }
 
   getTokens(): string[] {
-    return this._getPatternSafely().getTokens();
+    return this.getReferencePatternSafely().getTokens();
   }
 
   getTokensAfter(_lastMatched: Pattern): string[] {
@@ -170,7 +170,7 @@ export class Reference implements Pattern {
   }
 
   getPatterns(): Pattern[] {
-    return this._getPatternSafely().getPatterns();
+    return this.getReferencePatternSafely().getPatterns();
   }
 
   getPatternsAfter(_childReference: Pattern): Pattern[] {

package/src/patterns/Sequence.ts

@@ -5,6 +5,7 @@ import { clonePatterns } from "./clonePatterns";
 import { filterOutNull } from "./filterOutNull";
 import { findPattern } from "./findPattern";
 import { DepthCache } from "./DepthCache";
+import { isRecursivePattern } from "./isRecursivePattern";
 
 const depthCache = new DepthCache();
 let idIndex = 0;
@@ -217,7 +218,7 @@ export class Sequence implements Pattern {
     const tokens: string[] = [];
 
     for (const pattern of this._children) {
-      if (pattern.type === "reference" && pattern.name === this.name && pattern === this.children[0]) {
+      if (isRecursivePattern(pattern) && pattern === this._children[0]) {
         return tokens;
       }
 
@@ -251,8 +252,7 @@ export class Sequence implements Pattern {
     const patterns: Pattern[] = [];
 
     for (const pattern of this._children) {
-
-      if (pattern.type === "reference" && pattern.name === this.name && pattern === this.children[0]) {
+      if (isRecursivePattern(pattern) && pattern === this._children[0]) {
         return patterns;
       }
 

package/src/patterns/isRecursivePattern.ts

@@ -0,0 +1,21 @@
+import { Pattern } from "./Pattern";
+import { Reference } from "./Reference";
+
+export function isRecursivePattern(pattern: Pattern) {
+    let onPattern = pattern.parent;
+    let depth = 0;
+
+    while (onPattern != null) {
+        if (onPattern.id === pattern.id) {
+            depth++;
+        }
+
+        onPattern = onPattern.parent;
+
+        if (depth > 1){
+            return true;
+        }
+    }
+
+    return false;
+}