clarity-pattern-parser 10.0.6 → 10.0.7

package/dist/patterns/DepthCache.d.ts

@@ -0,0 +1,6 @@
+export declare class DepthCache {
+    private _depthMap;
+    getDepth(name: string, cursorIndex: number): number;
+    incrementDepth(name: string, cursorIndex: number): void;
+    decrementDepth(name: string, cursorIndex: number): void;
+}

package/dist/patterns/Options.d.ts

@@ -22,7 +22,6 @@ export declare class Options implements Pattern {
     exec(text: string, record?: boolean): ParseResult;
     parse(cursor: Cursor): Node | null;
     private _tryToParse;
-    private _isBeyondRecursiveLimit;
     getTokens(): string[];
     getTokensAfter(_childReference: Pattern): string[];
     getNextTokens(): string[];

package/dist/patterns/Sequence.d.ts

@@ -24,7 +24,6 @@ export declare class Sequence implements Pattern {
     };
     parse(cursor: Cursor): Node | null;
     private tryToParse;
-    private _isBeyondRecursiveLimit;
     private getLastValidNode;
     private areRemainingPatternsOptional;
     private createNode;

package/package.json

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

package/src/patterns/DepthCache.ts

@@ -0,0 +1,26 @@
+export class DepthCache {
+    private _depthMap: Record<string, Record<number, number>> = {};
+
+    getDepth(name: string, cursorIndex: number) {
+        if (this._depthMap[name] == null) {
+            this._depthMap[name] = {};
+        }
+
+        if (this._depthMap[name][cursorIndex] == null) {
+            this._depthMap[name][cursorIndex] = 0;
+        }
+
+
+        return this._depthMap[name][cursorIndex];
+    }
+
+    incrementDepth(name: string, cursorIndex: number) {
+        const depth = this.getDepth(name, cursorIndex);
+        this._depthMap[name][cursorIndex] = depth + 1;
+    }
+
+    decrementDepth(name: string, cursorIndex: number) {
+        const depth = this.getDepth(name, cursorIndex);
+        this._depthMap[name][cursorIndex] = depth - 1;
+    }
+}

package/src/patterns/Options.ts

@@ -4,7 +4,13 @@ import { Pattern } from "./Pattern";
 import { clonePatterns } from "./clonePatterns";
 import { findPattern } from "./findPattern";
 import { ParseResult } from "./ParseResult";
+import { DepthCache } from './DepthCache';
 
+/*
+  The following is created to reduce the overhead of recursion check. 
+*/
+
+const depthCache = new DepthCache();
 let idIndex = 0;
 
 export class Options implements Pattern {
@@ -83,13 +89,18 @@ export class Options implements Pattern {
   }
 
   parse(cursor: Cursor): Node | null {
+    // This is a cache to help with speed
+    this._firstIndex = cursor.index;
+    depthCache.incrementDepth(this._id, this._firstIndex);
+
     this._firstIndex = cursor.index;
     const node = this._tryToParse(cursor);
 
+    depthCache.decrementDepth(this._id, this._firstIndex);
+
     if (node != null) {
       cursor.moveTo(node.lastIndex);
       cursor.resolveError();
-
       return node;
     }
 
@@ -100,8 +111,8 @@ export class Options implements Pattern {
 
 
   private _tryToParse(cursor: Cursor): Node | null {
-    if (this._isBeyondRecursiveLimit()){
-      cursor.recordErrorAt(cursor.index, cursor.index, this);
+    if (depthCache.getDepth(this._id, this._firstIndex) > 2) {
+      cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
       return null;
     }
 
@@ -130,32 +141,6 @@ export class Options implements Pattern {
     return nonNullResults[0] || null;
   }
 
-  private _isBeyondRecursiveLimit(){
-    let pattern: Pattern = this;
-    const matches: Pattern[] = [];
-
-    while(pattern.parent != null){
-      if (pattern.type !== "options"){
-        pattern = pattern.parent;
-        continue;
-      }
-
-      const optionsPattern = pattern as Options;
-
-      if (pattern.id === this.id && optionsPattern._firstIndex === this._firstIndex){
-         matches.push(pattern);
-         
-         if (matches.length > 2){
-            return true;
-         }
-      }
-
-      pattern = pattern.parent;
-    }
-
-    return false;
-  }
-
   getTokens(): string[] {
     const tokens: string[] = [];
 

package/src/patterns/Sequence.ts

@@ -4,7 +4,9 @@ import { Node } from "../ast/Node";
 import { clonePatterns } from "./clonePatterns";
 import { filterOutNull } from "./filterOutNull";
 import { findPattern } from "./findPattern";
+import { DepthCache } from "./DepthCache";
 
+const depthCache = new DepthCache();
 let idIndex = 0;
 
 export class Sequence implements Pattern {
@@ -83,15 +85,14 @@ export class Sequence implements Pattern {
   }
 
   parse(cursor: Cursor): Node | null {
+    // This is a cache to help with speed
     this._firstIndex = cursor.index;
-    this._nodes = [];
+    depthCache.incrementDepth(this._id, this._firstIndex);
 
-    if (this._isBeyondRecursiveLimit()) {
-      cursor.recordErrorAt(cursor.index, cursor.index, this);
-      return null;
-    }
+    this._nodes = [];
 
     const passed = this.tryToParse(cursor);
+    depthCache.decrementDepth(this._id, this._firstIndex);
 
     if (passed) {
       const node = this.createNode(cursor);
@@ -107,7 +108,10 @@ export class Sequence implements Pattern {
   }
 
   private tryToParse(cursor: Cursor): boolean {
-
+    if (depthCache.getDepth(this._id, this._firstIndex) > 1) {
+      cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
+      return false;
+    }
 
     let passed = false;
 
@@ -169,32 +173,6 @@ export class Sequence implements Pattern {
     return passed;
   }
 
-  private _isBeyondRecursiveLimit() {
-    let pattern: Pattern = this;
-    const matches: Pattern[] = [];
-
-    while (pattern.parent != null) {
-      if (pattern.type !== "sequence") {
-        pattern = pattern.parent;
-        continue;
-      }
-
-      const sequencePattern = pattern as Sequence;
-
-      if (pattern.id === this.id && sequencePattern._firstIndex === this._firstIndex) {
-        matches.push(pattern);
-
-        if (matches.length > 1) {
-          return true;
-        }
-      }
-
-      pattern = pattern.parent;
-    }
-
-    return false;
-  }
-
   private getLastValidNode(): Node | null {
     const nodes = filterOutNull(this._nodes);