clarity-pattern-parser 10.1.0 → 10.1.2

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

@@ -835,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() {
@@ -2502,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(0, -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,
@@ -2556,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);
@@ -2566,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);
@@ -2926,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