clarity-pattern-parser 10.2.13 → 10.3.0

package/dist/patterns/Context.d.ts

@@ -10,6 +10,7 @@ export declare class Context implements Pattern {
     private _children;
     private _pattern;
     private _patterns;
+    shouldCompactAst: boolean;
     get id(): string;
     get type(): string;
     get name(): string;

package/dist/patterns/ExpressionPattern.d.ts

@@ -18,6 +18,8 @@ export declare class ExpressionPattern implements Pattern {
     private _binaryAssociation;
     private _precedenceMap;
     private _binaryNames;
+    private _shouldCompactPatternsMap;
+    shouldCompactAst: boolean;
     get id(): string;
     get type(): string;
     get name(): string;
@@ -38,6 +40,7 @@ export declare class ExpressionPattern implements Pattern {
     private _extractRecursiveTail;
     private _endsWithRecursion;
     parse(cursor: Cursor): Node | null;
+    private _compactResult;
     private _tryToParse;
     test(text: string): boolean;
     exec(text: string, record?: boolean): ParseResult;

package/dist/patterns/FiniteRepeat.d.ts

@@ -18,6 +18,7 @@ export declare class FiniteRepeat implements Pattern {
     private _min;
     private _max;
     private _trimDivider;
+    shouldCompactAst: boolean;
     get id(): string;
     get type(): string;
     get name(): string;

package/dist/patterns/InfiniteRepeat.d.ts

@@ -19,6 +19,7 @@ export declare class InfiniteRepeat implements Pattern {
     private _firstIndex;
     private _min;
     private _trimDivider;
+    shouldCompactAst: boolean;
     get id(): string;
     get type(): string;
     get name(): string;

package/dist/patterns/Literal.d.ts

@@ -12,6 +12,7 @@ export declare class Literal implements Pattern {
     private _firstIndex;
     private _lastIndex;
     private _endIndex;
+    shouldCompactAst: boolean;
     get id(): string;
     get type(): string;
     get name(): string;

package/dist/patterns/Not.d.ts

@@ -8,6 +8,7 @@ export declare class Not implements Pattern {
     private _name;
     private _parent;
     private _children;
+    shouldCompactAst: boolean;
     get id(): string;
     get type(): string;
     get name(): string;

package/dist/patterns/Optional.d.ts

@@ -8,6 +8,7 @@ export declare class Optional implements Pattern {
     private _name;
     private _parent;
     private _children;
+    shouldCompactAst: boolean;
     get id(): string;
     get type(): string;
     get name(): string;

package/dist/patterns/Options.d.ts

@@ -10,6 +10,7 @@ export declare class Options implements Pattern {
     private _children;
     private _isGreedy;
     private _firstIndex;
+    shouldCompactAst: boolean;
     get id(): string;
     get type(): string;
     get name(): string;

package/dist/patterns/Pattern.d.ts

@@ -5,6 +5,7 @@ export interface Pattern {
     id: string;
     type: string;
     name: string;
+    shouldCompactAst: boolean;
     parent: Pattern | null;
     children: Pattern[];
     parse(cursor: Cursor): Node | null;

package/dist/patterns/Reference.d.ts

@@ -10,6 +10,7 @@ export declare class Reference implements Pattern {
     private _cachedPattern;
     private _pattern;
     private _children;
+    shouldCompactAst: boolean;
     get id(): string;
     get type(): string;
     get name(): string;

package/dist/patterns/Regex.d.ts

@@ -14,6 +14,7 @@ export declare class Regex implements Pattern {
     private _firstIndex;
     private _substring;
     private _tokens;
+    shouldCompactAst: boolean;
     get id(): string;
     get type(): string;
     get name(): string;

package/dist/patterns/Repeat.d.ts

@@ -15,6 +15,9 @@ export declare class Repeat implements Pattern {
     private _pattern;
     private _options;
     private _children;
+    private _shouldCompactAst;
+    get shouldCompactAst(): boolean;
+    set shouldCompactAst(value: boolean);
     get id(): string;
     get type(): string;
     get name(): string;

package/dist/patterns/Sequence.d.ts

@@ -9,6 +9,7 @@ export declare class Sequence implements Pattern {
     private _children;
     private _nodes;
     private _firstIndex;
+    shouldCompactAst: boolean;
     get id(): string;
     get type(): string;
     get name(): string;

package/package.json

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

package/src/ast/Node.ts

@@ -236,8 +236,7 @@ export class Node {
     const queue: Node[] = [this];
 
     while (queue.length > 0) {
-      // biome-ignore lint/style/noNonNullAssertion: This will never be undefined.
-      const current = queue.shift()!;
+      const current = queue.shift() as Node;
       callback(current);
       queue.push(...current.children);
     }
@@ -309,6 +308,11 @@ export class Node {
     return length;
   }
 
+  compact(){
+    this._value = this.toString();
+    this._children.length = 0;
+  }
+
   toString(): string {
     if (this._children.length === 0) {
       return this._value;

package/src/grammar/Grammar.test.ts

@@ -571,8 +571,8 @@ describe("Grammar", () => {
         expect(result?.ast?.value).toBe("John  Doe");
     });
 
-    test("Expression Pattern", ()=>{
-        const {variables, expression} = patterns`
+    test("Expression Pattern", () => {
+        const { expression } = patterns`
             variables = "a" | "b" | "c"
             ternary = expression + " ? " + expression + " : " + expression
             expression = ternary | variables
@@ -581,7 +581,57 @@ describe("Grammar", () => {
             bad-expression = bad-ternary | bad-ternary
         `;
         let result = expression.exec("a ? b : c");
-        debugger;
         expect(result).toBe(result);
     });
+
+    test("Compacted Recursive Sequence", () => {
+        const { expression } = patterns`
+        variables = "a" | "b" | "c"
+        ternary = expression + " ? " + expression + " : " + expression compact
+        expression = ternary | variables 
+    `;
+        const result = expression.exec("a ? b : c");
+        expect(result.ast?.children.length).toBe(0);
+        expect(result.ast?.value).toBe("a ? b : c");
+    });
+
+    test("Compacted Repeat", () => {
+        const { variables } = patterns`
+        variable = "a" | "b" | "c"
+        variables = (variable, /\s*,\s*/)+ compact
+    `;
+        const result = variables.exec("a,b,c");
+        expect(result.ast?.children.length).toBe(0);
+        expect(result.ast?.value).toBe("a,b,c");
+    });
+
+    test("Compacted Binary Expression", () => {
+        const { expression } = patterns`
+        variable = "a" | "b" | "c"
+        mult-div-operator = " * " | " / "
+        add-sub-operator = " + " | " - "
+        
+        mult-div-expression = expression + mult-div-operator + expression compact
+        add-sub-expression = expression + add-sub-operator + expression compact
+        expression = mult-div-expression | add-sub-expression | variable 
+    `;
+        const result = expression.exec("a * b + c");
+        expect(result.ast?.children.length).toBe(0);
+        expect(result.ast?.value).toBe("a * b + c");
+    });
+
+    test("Compacted Expression", () => {
+        const { expression } = patterns`
+        variable = "a" | "b" | "c"
+        mult-div-operator = " * " | " / "
+        add-sub-operator = " + " | " - "
+        
+        mult-div-expression = expression + mult-div-operator + expression 
+        add-sub-expression = expression + add-sub-operator + expression 
+        expression = mult-div-expression | add-sub-expression | variable compact
+    `;
+        const result = expression.exec("a * b + c");
+        expect(result.ast?.children.length).toBe(0);
+        expect(result.ast?.value).toBe("a * b + c");
+    });
 });

package/src/grammar/Grammar.ts

@@ -238,10 +238,15 @@ export class Grammar {
 
     private _saveOptions(statementNode: Node) {
         const nameNode = statementNode.find(n => n.name === "name") as Node;
+        const shouldCompactAst = statementNode.find(n=>n.name === "compact");
         const name = nameNode.value;
         const optionsNode = statementNode.find(n => n.name === "options-literal") as Node;
         const options = this._buildOptions(name, optionsNode);
 
+        if (shouldCompactAst != null){
+            options.shouldCompactAst = true;
+        }
+
         this._parseContext.patternsByName.set(name, options);
     }
 
@@ -310,10 +315,15 @@ export class Grammar {
 
     private _saveSequence(statementNode: Node) {
         const nameNode = statementNode.find(n => n.name === "name") as Node;
+        const shouldCompactAst = statementNode.find(n=>n.name === "compact");
         const name = nameNode.value;
         const sequenceNode = statementNode.find(n => n.name === "sequence-literal") as Node;
         const sequence = this._buildSequence(name, sequenceNode);
 
+        if (shouldCompactAst != null){
+            sequence.shouldCompactAst = true;
+        }
+
         this._parseContext.patternsByName.set(name, sequence);
     }
 
@@ -339,10 +349,15 @@ export class Grammar {
 
     private _saveRepeat(statementNode: Node) {
         const nameNode = statementNode.find(n => n.name === "name") as Node;
+        const shouldCompactAst = statementNode.find(n=>n.name === "compact");
         const name = nameNode.value;
         const repeatNode = statementNode.find(n => n.name === "repeat-literal") as Node;
         const repeat = this._buildRepeat(name, repeatNode);
 
+        if (shouldCompactAst != null){
+            repeat.shouldCompactAst = true;
+        }
+
         this._parseContext.patternsByName.set(name, repeat);
     }
 
@@ -527,11 +542,16 @@ export class Grammar {
 
     private _saveAlias(statementNode: Node) {
         const nameNode = statementNode.find(n => n.name === "name") as Node;
+        const shouldCompactAst = statementNode.find(n=>n.name === "compact");
         const aliasNode = statementNode.find(n => n.name === "alias-literal") as Node;
         const aliasName = aliasNode.value;
         const name = nameNode.value;
         const alias = this._getPattern(aliasName).clone(name);
 
+        if (shouldCompactAst != null){
+            alias.shouldCompactAst = true;
+        }
+
         this._parseContext.patternsByName.set(name, alias);
     }
 

package/src/grammar/patterns/statement.ts

@@ -2,20 +2,25 @@ import { Sequence } from "../../patterns/Sequence";
 import { Literal } from "../../patterns/Literal";
 import { Options } from "../../patterns/Options";
 import { name } from "./name";
-import { spaces } from "./spaces";
+import { lineSpaces, spaces } from "./spaces";
 import { pattern } from "./pattern";
 import { Optional } from "../../patterns/Optional";
 
 const optionalSpaces = new Optional("optional-spaces", spaces);
 const assignOperator = new Literal("assign-operator", "=");
 
+const compact = new Literal("compact", "compact");
+const compactModifier = new Sequence("compact-modifier", [lineSpaces, compact]);
+const optionalCompactModifier = new Optional("optional-compact-modifier", compactModifier);
+
 const assignStatement = new Sequence("assign-statement", [
     optionalSpaces,
     name,
     optionalSpaces,
     assignOperator,
     optionalSpaces,
-    pattern
+    pattern,
+    optionalCompactModifier
 ]);
 
 export const statement = new Options("statement", [assignStatement, name.clone("export-name")]);

package/src/patterns/Context.ts

@@ -14,6 +14,8 @@ export class Context implements Pattern {
     private _pattern: Pattern;
     private _patterns: Record<string, Pattern>;
 
+    shouldCompactAst = false;
+
     get id(): string {
         return this._id;
     }
@@ -76,6 +78,7 @@ export class Context implements Pattern {
     clone(name = this._name): Pattern {
         const clone = new Context(name, this._pattern, Object.values(this._patterns));
         clone._id = this._id;
+        clone.shouldCompactAst = this.shouldCompactAst;
         return clone;
     }
 

package/src/patterns/ExpressionPattern.ts

@@ -34,6 +34,9 @@ export class ExpressionPattern implements Pattern {
     private _binaryAssociation: Association[];
     private _precedenceMap: Record<string, number>;
     private _binaryNames: string[];
+    private _shouldCompactPatternsMap: Record<string, boolean>;
+
+    shouldCompactAst = false;
 
     get id(): string {
         return this._id;
@@ -90,6 +93,7 @@ export class ExpressionPattern implements Pattern {
         this._binaryAssociation = [];
         this._precedenceMap = {};
         this._originalPatterns = patterns;
+        this._shouldCompactPatternsMap = {};
         this._patterns = this._organizePatterns(patterns);
 
         if (this._unaryPatterns.length === 0) {
@@ -100,6 +104,8 @@ export class ExpressionPattern implements Pattern {
     private _organizePatterns(patterns: Pattern[]) {
         const finalPatterns: Pattern[] = [];
         patterns.forEach((pattern) => {
+            this._shouldCompactPatternsMap[pattern.name] = pattern.shouldCompactAst;
+
             if (this._isBinary(pattern)) {
                 const binaryName = this._extractName(pattern);
                 const clone = this._extractDelimiter(pattern).clone();
@@ -119,6 +125,7 @@ export class ExpressionPattern implements Pattern {
             } else if (this._isRecursive(pattern)) {
                 const name = this._extractName(pattern);
                 const tail = this._extractRecursiveTail(pattern);
+
                 tail.parent = this;
 
                 this._recursivePatterns.push(tail);
@@ -216,6 +223,7 @@ export class ExpressionPattern implements Pattern {
         if (node != null) {
             cursor.moveTo(node.lastIndex);
             cursor.resolveError();
+            this._compactResult(node);
             return node;
         }
 
@@ -223,6 +231,28 @@ export class ExpressionPattern implements Pattern {
         return null;
     }
 
+    private _compactResult(node: Node | null) {
+        if (node == null) {
+            return;
+        }
+
+        if (this.shouldCompactAst) {
+            node.compact();
+            return;
+        }
+
+        // This could be really expensive with large trees. So we optimize with these checks,
+        // as well as use breadth first as to not recompact nodes over and over again. 
+        const isCompactingNeeded = Object.values(this._shouldCompactPatternsMap).some(p => p);
+        if (isCompactingNeeded) {
+            node.walkBreadthFirst(n => {
+                if (this._shouldCompactPatternsMap[n.name]) {
+                    n.compact();
+                }
+            });
+        }
+    }
+
     private _tryToParse(cursor: Cursor): Node | null {
         if (depthCache.getDepth(this._id, this._firstIndex) > 2) {
             cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
@@ -246,6 +276,7 @@ export class ExpressionPattern implements Pattern {
 
                 if (node != null) {
                     lastUnaryNode = node;
+
                     break;
                 } else {
                     lastUnaryNode = null;
@@ -338,12 +369,14 @@ export class ExpressionPattern implements Pattern {
                     if (precedence === lastPrecendece && association === Association.right) {
                         const node = createNode(name, [lastUnaryNode, delimiterNode]);
                         lastBinaryNode.appendChild(node);
+
                         lastBinaryNode = node;
                     } else if (precedence === lastPrecendece) {
                         const node = createNode(name, []);
 
                         lastBinaryNode.replaceWith(node);
                         lastBinaryNode.appendChild(lastUnaryNode);
+
                         node.append(lastBinaryNode, delimiterNode);
                         lastBinaryNode = node;
                     } else if (precedence > lastPrecendece) {
@@ -376,6 +409,7 @@ export class ExpressionPattern implements Pattern {
                     } else {
                         const node = createNode(name, [lastUnaryNode, delimiterNode]);
                         lastBinaryNode.appendChild(node);
+
                         lastBinaryNode = node;
                     }
 
@@ -514,6 +548,7 @@ export class ExpressionPattern implements Pattern {
     clone(name = this._name): Pattern {
         const clone = new ExpressionPattern(name, this._originalPatterns);
         clone._id = this._id;
+        clone.shouldCompactAst = this.shouldCompactAst;
         return clone;
     }
 

package/src/patterns/FiniteRepeat.ts

@@ -24,6 +24,8 @@ export class FiniteRepeat implements Pattern {
     private _max: number;
     private _trimDivider: boolean;
 
+    shouldCompactAst = false;
+
     get id() {
         return this._id;
     }
@@ -140,7 +142,13 @@ export class FiniteRepeat implements Pattern {
         cursor.resolveError();
         cursor.moveTo(lastIndex);
 
-        return new Node(this._type, this.name, firstIndex, lastIndex, nodes);
+        const node = new Node(this._type, this.name, firstIndex, lastIndex, nodes);
+
+        if (this.shouldCompactAst) {
+            node.compact();
+        }
+
+        return node;
     }
 
     test(text: string): boolean {
@@ -178,6 +186,7 @@ export class FiniteRepeat implements Pattern {
         );
 
         clone._id = this._id;
+        clone.shouldCompactAst = this.shouldCompactAst;
 
         return clone;
     }

package/src/patterns/InfiniteRepeat.ts

@@ -26,6 +26,8 @@ export class InfiniteRepeat implements Pattern {
   private _min: number;
   private _trimDivider: boolean;
 
+  shouldCompactAst = false;
+
   get id(): string {
     return this._id;
   }
@@ -118,6 +120,10 @@ export class InfiniteRepeat implements Pattern {
       if (node != null) {
         cursor.moveTo(node.lastIndex);
         cursor.recordMatch(this, node);
+
+        if (this.shouldCompactAst) {
+          node.compact();
+        }
       }
 
       return node;
@@ -352,6 +358,7 @@ export class InfiniteRepeat implements Pattern {
     );
 
     clone._id = this._id;
+    clone.shouldCompactAst = this.shouldCompactAst;
 
     return clone;
   }

package/src/patterns/Literal.ts

@@ -16,6 +16,8 @@ export class Literal implements Pattern {
   private _lastIndex: number;
   private _endIndex: number;
 
+  shouldCompactAst = false;
+
   get id(): string {
     return this._id;
   }
@@ -141,6 +143,7 @@ export class Literal implements Pattern {
   clone(name = this._name): Pattern {
     const clone = new Literal(name, this._token);
     clone._id = this._id;
+    clone.shouldCompactAst = this.shouldCompactAst;
     return clone;
   }
 

package/src/patterns/Not.ts

@@ -12,6 +12,8 @@ export class Not implements Pattern {
   private _parent: Pattern | null;
   private _children: Pattern[];
 
+  shouldCompactAst = false;
+
   get id(): string {
     return this._id;
   }

package/src/patterns/Optional.ts

@@ -12,6 +12,8 @@ export class Optional implements Pattern {
   private _parent: Pattern | null;
   private _children: Pattern[];
 
+  shouldCompactAst = false;
+
   get id(): string {
     return this._id;
   }
@@ -74,15 +76,20 @@ export class Optional implements Pattern {
 
       return null;
     } else {
+      if (node != null && this.shouldCompactAst) {
+        node.compact();
+      }
+
       return node;
     }
 
   }
 
   clone(name = this._name): Pattern {
-    const optional = new Optional(name, this._children[0]);
-    optional._id = this._id;
-    return optional;
+    const clone = new Optional(name, this._children[0]);
+    clone._id = this._id;
+    clone.shouldCompactAst = this.shouldCompactAst;
+    return clone;
   }
 
   getTokens(): string[] {

package/src/patterns/Options.ts

@@ -23,6 +23,8 @@ export class Options implements Pattern {
   private _isGreedy: boolean;
   private _firstIndex: number;
 
+  shouldCompactAst = false;
+
   get id(): string {
     return this._id;
   }
@@ -102,6 +104,11 @@ export class Options implements Pattern {
     if (node != null) {
       cursor.moveTo(node.lastIndex);
       cursor.resolveError();
+
+      if (this.shouldCompactAst) {
+        node.compact();
+      }
+
       return node;
     }
 
@@ -202,9 +209,10 @@ export class Options implements Pattern {
   }
 
   clone(name = this._name): Pattern {
-    const or = new Options(name, this._children, this._isGreedy);
-    or._id = this._id;
-    return or;
+    const clone = new Options(name, this._children, this._isGreedy);
+    clone._id = this._id;
+    clone.shouldCompactAst = this.shouldCompactAst;
+    return clone;
   }
 
   isEqual(pattern: Options): boolean {

package/src/patterns/Pattern.ts

@@ -6,6 +6,7 @@ export interface Pattern {
   id: string;
   type: string;
   name: string;
+  shouldCompactAst: boolean;
   parent: Pattern | null;
   children: Pattern[];
 

package/src/patterns/Reference.ts

@@ -16,6 +16,8 @@ export class Reference implements Pattern {
   private _pattern: Pattern | null;
   private _children: Pattern[];
 
+  shouldCompactAst = false;
+
   get id(): string {
     return this._id;
   }
@@ -196,6 +198,7 @@ export class Reference implements Pattern {
   clone(name = this._name): Pattern {
     const clone = new Reference(name);
     clone._id = this._id;
+    clone.shouldCompactAst = this.shouldCompactAst;
 
     // Optimize future clones, by caching the pattern we already found.
     if (this._pattern != null) {

package/src/patterns/Regex.ts

@@ -18,6 +18,8 @@ export class Regex implements Pattern {
   private _substring = "";
   private _tokens: string[] = [];
 
+  shouldCompactAst = false;
+
   get id(): string {
     return this._id;
   }
@@ -30,7 +32,7 @@ export class Regex implements Pattern {
     return this._name;
   }
 
-  get regex(): string{
+  get regex(): string {
     return this._originalRegexString;
   }
 
@@ -145,8 +147,9 @@ export class Regex implements Pattern {
   clone(name = this._name) {
     const clone = new Regex(name, this._originalRegexString);
     clone._tokens = this._tokens.slice();
-
     clone._id = this._id;
+    clone.shouldCompactAst = this.shouldCompactAst;
+    
     return clone;
   }