clarity-pattern-parser 10.0.8 → 10.1.1

package/dist/index.d.ts

@@ -18,4 +18,5 @@ import { CursorHistory, Match } from "./patterns/CursorHistory";
 import { ParseResult } from "./patterns/ParseResult";
 import { grammar } from "./grammar/patterns/grammar";
 import { patterns } from "./grammar/patterns";
-export { Node, Grammar, AutoComplete, AutoCompleteOptions, Suggestion, SuggestionOption, Sequence, Cursor, CursorHistory, Match, Literal, Not, Options, Optional, ParseError, ParseResult, Pattern, Reference, Regex, Repeat, grammar, patterns, };
+import { Context } from "./patterns/Context";
+export { Node, Grammar, AutoComplete, AutoCompleteOptions, Suggestion, SuggestionOption, Sequence, Cursor, CursorHistory, Match, Context, Literal, Not, Options, Optional, ParseError, ParseResult, Pattern, Reference, Regex, Repeat, grammar, patterns, };

package/dist/index.esm.js

@@ -279,6 +279,7 @@ class CursorHistory {
         this._patterns = [];
         this._nodes = [];
         this._errors = [];
+        this._records = [];
     }
     get isRecording() {
         return this._isRecording;
@@ -301,6 +302,9 @@ class CursorHistory {
     get error() {
         return this._currentError;
     }
+    get records() {
+        return this._records;
+    }
     get nodes() {
         return this._nodes;
     }
@@ -311,6 +315,11 @@ class CursorHistory {
         if (this._isRecording) {
             this._patterns.push(pattern);
             this._nodes.push(node);
+            this._records.push({
+                pattern,
+                ast: node,
+                error: null
+            });
         }
         this._rootMatch.pattern = pattern;
         this._rootMatch.node = node;
@@ -350,6 +359,11 @@ class CursorHistory {
         }
         if (this._isRecording) {
             this._errors.push(error);
+            this.records.push({
+                pattern,
+                ast: null,
+                error
+            });
         }
     }
     startRecording() {
@@ -400,6 +414,9 @@ class Cursor {
     get errors() {
         return this._history.errors;
     }
+    get records() {
+        return this._history.records;
+    }
     get index() {
         return this._index;
     }
@@ -818,9 +835,23 @@ class Reference {
         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() {
@@ -2485,6 +2516,77 @@ function getFurthestOptions(options) {
     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,
@@ -2539,9 +2641,17 @@ class Grammar {
             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);
@@ -2549,7 +2659,7 @@ class Grammar {
             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);
@@ -2909,5 +3019,5 @@ function patterns(strings, ...values) {
     return result;
 }
 
-export { AutoComplete, Cursor, CursorHistory, Grammar, Literal, Node, Not, Optional, Options, ParseError, Reference, Regex, Repeat, Sequence, grammar, patterns };
+export { AutoComplete, Context, Cursor, CursorHistory, Grammar, Literal, Node, Not, Optional, Options, ParseError, Reference, Regex, Repeat, Sequence, grammar, patterns };
 //# sourceMappingURL=index.esm.js.map