clarity-pattern-parser 9.2.5 → 10.0.0

package/dist/index.d.ts

@@ -17,6 +17,5 @@ import { Reference } from "./patterns/Reference";
 import { CursorHistory, Match } from "./patterns/CursorHistory";
 import { ParseResult } from "./patterns/ParseResult";
 import { grammar } from "./grammar/patterns/grammar";
-import { arePatternsEqual } from "./patterns/arePatternsEqual";
 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, arePatternsEqual, patterns, };
+export { Node, Grammar, AutoComplete, AutoCompleteOptions, Suggestion, SuggestionOption, Sequence, Cursor, CursorHistory, Match, Literal, Not, Options, Optional, ParseError, ParseResult, Pattern, Reference, Regex, Repeat, grammar, patterns, };

package/dist/index.esm.js

@@ -1,3 +1,6 @@
+function defaultVisitor(node) {
+    return node;
+}
 class Node {
     get type() {
         return this._type;
@@ -26,6 +29,9 @@ class Node {
     get hasChildren() {
         return this._children.length > 0;
     }
+    get isLeaf() {
+        return !this.hasChildren;
+    }
     get value() {
         return this.toString();
     }
@@ -46,16 +52,22 @@ class Node {
             node._parent = null;
         }
     }
+    findChildIndex(node) {
+        return this._children.indexOf(node);
+    }
+    spliceChildren(index, deleteCount, ...items) {
+        const removedItems = this._children.splice(index, deleteCount, ...items);
+        removedItems.forEach(i => i._parent = null);
+        items.forEach(i => i._parent = this);
+        return removedItems;
+    }
     removeAllChildren() {
-        this._children.forEach(c => c._parent = null);
-        this._children.length = 0;
+        this.spliceChildren(0, this._children.length);
     }
     replaceChild(newNode, referenceNode) {
-        const index = this._children.indexOf(referenceNode);
+        const index = this.findChildIndex(referenceNode);
         if (index > -1) {
-            this._children.splice(index, 1, newNode);
-            newNode._parent = this;
-            referenceNode._parent = null;
+            this.spliceChildren(index, 1, newNode);
         }
     }
     replaceWith(newNode) {
@@ -69,20 +81,19 @@ class Node {
             this._children.push(newNode);
             return;
         }
-        const index = this._children.indexOf(referenceNode);
+        const index = this.findChildIndex(referenceNode);
         if (index > -1) {
             this._children.splice(index, 0, newNode);
         }
     }
     appendChild(newNode) {
-        newNode._parent = this;
-        this._children.push(newNode);
+        this.append(newNode);
     }
-    spliceChildren(index, deleteCount, ...items) {
-        const removedItems = this._children.splice(index, deleteCount, ...items);
-        removedItems.forEach(i => i._parent = null);
-        items.forEach(i => i._parent = this);
-        return removedItems;
+    append(...nodes) {
+        nodes.forEach((newNode) => {
+            newNode._parent = this;
+            this._children.push(newNode);
+        });
     }
     nextSibling() {
         if (this._parent == null) {
@@ -118,7 +129,7 @@ class Node {
         });
         return matches;
     }
-    findAncester(predicate) {
+    findAncestor(predicate) {
         let parent = this._parent;
         while (parent != null) {
             if (predicate(parent)) {
@@ -138,6 +149,23 @@ class Node {
         callback(this);
         childrenCopy.forEach(c => c.walkDown(callback));
     }
+    walkBreadthFirst(callback) {
+        const queue = [this];
+        while (queue.length > 0) {
+            // biome-ignore lint/style/noNonNullAssertion: This will never be undefined.
+            const current = queue.shift();
+            callback(current);
+            queue.push(...current.children);
+        }
+    }
+    transform(visitors) {
+        const childrenCopy = this._children.slice();
+        const visitor = visitors[this.name] == null ? defaultVisitor : visitors[this.name];
+        const children = childrenCopy.map(c => c.transform(visitors));
+        this.removeAllChildren();
+        this.append(...children);
+        return visitor(this);
+    }
     flatten() {
         const nodes = [];
         this.walkDown((node) => {
@@ -191,6 +219,13 @@ class Node {
     toJson(space) {
         return JSON.stringify(this.toCycleFreeObject(), null, space);
     }
+    static createValueNode(name, value) {
+        return new Node("custom-value-node", name, 0, 0, [], value);
+    }
+    static createNode(name, children) {
+        const value = children.map(c => c.toString()).join("");
+        return new Node("custom-node", name, 0, 0, children, value);
+    }
 }
 
 /******************************************************************************
@@ -308,10 +343,10 @@ class CursorHistory {
             }
         }
     }
-    recordErrorAt(firstIndex, lastIndex, pattern) {
-        const error = new ParseError(firstIndex, lastIndex, pattern);
+    recordErrorAt(startIndex, endIndex, pattern) {
+        const error = new ParseError(startIndex, endIndex, pattern);
         this._currentError = error;
-        if (this._furthestError === null || lastIndex > this._furthestError.endIndex) {
+        if (this._furthestError === null || endIndex > this._furthestError.endIndex) {
             this._furthestError = error;
         }
         if (this._isRecording) {
@@ -386,7 +421,7 @@ class Cursor {
     constructor(text) {
         this._text = text;
         this._index = 0;
-        this._length = text.length;
+        this._length = [...text].length;
         this._history = new CursorHistory();
         this._stackTrace = [];
     }
@@ -426,8 +461,8 @@ class Cursor {
     recordMatch(pattern, node) {
         this._history.recordMatch(pattern, node);
     }
-    recordErrorAt(firstIndex, lastIndex, onPattern) {
-        this._history.recordErrorAt(firstIndex, lastIndex, onPattern);
+    recordErrorAt(startIndex, endIndex, onPattern) {
+        this._history.recordErrorAt(startIndex, endIndex, onPattern);
     }
     resolveError() {
         this._history.resolveError();
@@ -444,7 +479,8 @@ class Cursor {
             pattern,
             cursorIndex: this.index
         };
-        if (this._stackTrace.find(t => t.pattern.id === pattern.id && this.index === t.cursorIndex)) {
+        const hasCycle = this._stackTrace.find(t => t.pattern.id === pattern.id && this.index === t.cursorIndex);
+        if (hasCycle) {
             throw new Error(`Cyclical Pattern: ${this._stackTrace.map(t => `${t.pattern.name}#${t.pattern.id}{${t.cursorIndex}}`).join(" -> ")} -> ${patternName}#${pattern.id}{${this.index}}.`);
         }
         this._history.pushStackTrace(trace);
@@ -480,8 +516,8 @@ class Literal {
     get name() {
         return this._name;
     }
-    get value() {
-        return this._text;
+    get token() {
+        return this._token;
     }
     get parent() {
         return this._parent;
@@ -499,15 +535,16 @@ class Literal {
         this._id = `literal-${idIndex$9++}`;
         this._type = "literal";
         this._name = name;
-        this._text = value;
+        this._token = value;
         this._runes = Array.from(value);
         this._parent = null;
         this._firstIndex = 0;
         this._lastIndex = 0;
         this._endIndex = 0;
     }
-    test(text) {
+    test(text, record = false) {
         const cursor = new Cursor(text);
+        record && cursor.startRecording();
         const ast = this.parse(cursor);
         return (ast === null || ast === void 0 ? void 0 : ast.value) === text;
     }
@@ -546,7 +583,7 @@ class Literal {
                 break;
             }
             if (i + 1 === literalRuneLength) {
-                this._lastIndex = this._firstIndex + this._text.length - 1;
+                this._lastIndex = this._firstIndex + this._token.length - 1;
                 passed = true;
                 break;
             }
@@ -559,15 +596,15 @@ class Literal {
         return passed;
     }
     _createNode() {
-        return new Node("literal", this._name, this._firstIndex, this._lastIndex, undefined, this._text);
+        return new Node("literal", this._name, this._firstIndex, this._lastIndex, undefined, this._token);
     }
     clone(name = this._name) {
-        const clone = new Literal(name, this._text);
+        const clone = new Literal(name, this._token);
         clone._id = this._id;
         return clone;
     }
     getTokens() {
-        return [this._text];
+        return [this._token];
     }
     getTokensAfter(_lastMatched) {
         return [];
@@ -594,7 +631,7 @@ class Literal {
         return null;
     }
     isEqual(pattern) {
-        return pattern.type === this.type && pattern._text === this._text;
+        return pattern.type === this.type && pattern._token === this._token;
     }
 }
 
@@ -2546,7 +2583,7 @@ class Grammar {
         return importBlock && importBlock.children.length > 0;
     }
     _buildPatterns(ast) {
-        const body = ast.find(n => n.name === "body" && n.findAncester(n => n.name === "head") == null);
+        const body = ast.find(n => n.name === "body" && n.findAncestor(n => n.name === "head") == null);
         if (body == null) {
             return;
         }
@@ -2866,16 +2903,6 @@ class Grammar {
     }
 }
 
-function arePatternsEqual(a, b) {
-    if (a === b) {
-        return true;
-    }
-    else if (a == null || b == null) {
-        return false;
-    }
-    return a.isEqual(b);
-}
-
 const kebabRegex = /-([a-z])/g; // Define the regex once
 function kebabToCamelCase(str) {
     return str.replace(kebabRegex, (_, char) => char.toUpperCase());
@@ -2890,5 +2917,5 @@ function patterns(strings, ...values) {
     return result;
 }
 
-export { AutoComplete, Cursor, CursorHistory, Grammar, Literal, Node, Not, Optional, Options, ParseError, Reference, Regex, Repeat, Sequence, arePatternsEqual, grammar, patterns };
+export { AutoComplete, Cursor, CursorHistory, Grammar, Literal, Node, Not, Optional, Options, ParseError, Reference, Regex, Repeat, Sequence, grammar, patterns };
 //# sourceMappingURL=index.esm.js.map