clarity-pattern-parser 10.1.0 → 10.1.1

package/TODO.md

@@ -1,9 +1,9 @@
-* Anonymous patterns within cpat files.
-```
-pattern = ("Name" | "Name") & "Blah" & /foo/
-```
-* Aliasing imports.
-* Send through params 
+* Add a Context Pattern
+This will allow you to store a list of patterns and the pattern you want to start a parse from. This will hold the context of many patterns
+that perhaps are references but are by way of the context. This will be helpful with cpat files.
+
+* Optimizations We can add a map to the cursor where we can search through previous matches and if the match for this pattern with this id has already matched in other bracnhes of the parse it can just use the node and clone it and skip the full parse and speed up things tremendously
+
 
 * Generate typescript files from cpat
 

package/dist/grammar/Grammar.d.ts

@@ -17,6 +17,7 @@ export declare class Grammar {
     constructor(options?: GrammarOptions);
     import(path: string): Promise<Record<string, Pattern>>;
     parse(expression: string): Promise<Record<string, Pattern>>;
+    private _buildPatternRecord;
     parseString(expression: string): Record<string, Pattern>;
     private _tryToParse;
     private _hasImports;

package/dist/index.browser.js

@@ -841,9 +841,23 @@
             return this._pattern;
         }
         _findPattern() {
+            let pattern = this._parent;
+            while (pattern != null) {
+                if (pattern.type !== "context") {
+                    pattern = pattern.parent;
+                    continue;
+                }
+                const foundPattern = findPattern(pattern, (pattern) => {
+                    return pattern.name === this._name && pattern.type !== "reference" && pattern.type !== "context";
+                });
+                if (foundPattern != null) {
+                    return foundPattern;
+                }
+                pattern = pattern.parent;
+            }
             const root = this._getRoot();
             return findPattern(root, (pattern) => {
-                return pattern.name === this._name && pattern.type !== "reference";
+                return pattern.name === this._name && pattern.type !== "reference" && pattern.type !== "context";
             });
         }
         _getRoot() {
@@ -2508,6 +2522,77 @@
         return furthestOptions;
     }
 
+    let contextId = 0;
+    class Context {
+        get id() {
+            return this._id;
+        }
+        get type() {
+            return this._type;
+        }
+        get name() {
+            return this._name;
+        }
+        get parent() {
+            return this._parent;
+        }
+        set parent(pattern) {
+            this._parent = pattern;
+        }
+        get children() {
+            return this._children;
+        }
+        constructor(name, pattern, context = []) {
+            this._id = `context-${contextId++}`;
+            this._type = "context";
+            this._name = name;
+            this._parent = null;
+            const clonedContext = context.map(p => p.clone());
+            const clonedPattern = pattern.clone();
+            clonedContext.forEach(p => p.parent = this);
+            clonedPattern.parent = this;
+            this._pattern = clonedPattern;
+            this._children = [...clonedContext, clonedPattern];
+        }
+        parse(cursor) {
+            return this._pattern.parse(cursor);
+        }
+        exec(text, record) {
+            return this._pattern.exec(text, record);
+        }
+        test(text, record) {
+            return this._pattern.test(text, record);
+        }
+        clone(name = this._name) {
+            const clone = new Context(name, this._pattern, this._children.slice(-1));
+            return clone;
+        }
+        getTokens() {
+            return this._pattern.getTokens();
+        }
+        getTokensAfter(childReference) {
+            return this._pattern.getTokensAfter(childReference);
+        }
+        getNextTokens() {
+            return this._pattern.getNextTokens();
+        }
+        getPatterns() {
+            return this._pattern.getPatterns();
+        }
+        getPatternsAfter(childReference) {
+            return this._pattern.getPatternsAfter(childReference);
+        }
+        getNextPatterns() {
+            return this._pattern.getNextPatterns();
+        }
+        find(predicate) {
+            return this._pattern.find(predicate);
+        }
+        isEqual(pattern) {
+            return pattern.type === this.type && this.children.every((c, index) => c.isEqual(pattern.children[index]));
+        }
+    }
+
     let anonymousIndexId = 0;
     const patternNodes = {
         "literal": true,
@@ -2562,9 +2647,17 @@
                 const ast = this._tryToParse(expression);
                 yield this._resolveImports(ast);
                 this._buildPatterns(ast);
-                return Object.fromEntries(this._parseContext.patternsByName);
+                return this._buildPatternRecord();
             });
         }
+        _buildPatternRecord() {
+            const patterns = {};
+            const allPatterns = Array.from(this._parseContext.patternsByName.values());
+            allPatterns.forEach(p => {
+                patterns[p.name] = new Context(p.name, p, allPatterns.filter(o => o !== p));
+            });
+            return patterns;
+        }
         parseString(expression) {
             this._parseContext = new ParseContext(this._params);
             const ast = this._tryToParse(expression);
@@ -2572,7 +2665,7 @@
                 throw new Error("Cannot use imports on parseString, use parse instead.");
             }
             this._buildPatterns(ast);
-            return Object.fromEntries(this._parseContext.patternsByName);
+            return this._buildPatternRecord();
         }
         _tryToParse(expression) {
             const { ast, cursor, options, isComplete } = this._autoComplete.suggestFor(expression);
@@ -2933,6 +3026,7 @@
     }
 
     exports.AutoComplete = AutoComplete;
+    exports.Context = Context;
     exports.Cursor = Cursor;
     exports.CursorHistory = CursorHistory;
     exports.Grammar = Grammar;