clarity-pattern-parser 10.2.14 → 10.3.1

package/dist/patterns/ExpressionPattern.d.ts

@@ -18,6 +18,7 @@ export declare class ExpressionPattern implements Pattern {
     private _binaryAssociation;
     private _precedenceMap;
     private _binaryNames;
+    private _shouldCompactPatternsMap;
     shouldCompactAst: boolean;
     get id(): string;
     get type(): string;
@@ -39,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/Repeat.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clarity-pattern-parser",
-  "version": "10.2.14",
+  "version": "10.3.1",
   "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);
     }

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/ExpressionPattern.test.ts

@@ -96,6 +96,34 @@ function createOptionsExpression() {
     return expressionPattern;
 }
 
+function createTailExpression() {
+    const a = new Literal("a", "a");
+    const b = new Literal("b", "b");
+    const c = new Literal("c", "c");
+    const variable = new Options("variable", [a, b, c]);
+    const period = new Literal(".", ".");
+
+    const refinement = new Sequence("refinement", [period, variable]);
+    const refinementExpression = new Sequence("refinement-expression", [
+        new Reference("expression"),
+        refinement
+    ]);
+
+    const invocation = new Literal("invocation", "()");
+    const invocationExpression = new Sequence("invocation-expression", [
+        new Reference("expression"),
+        invocation
+    ]);
+
+    const expression = new ExpressionPattern("expression", [
+        refinementExpression,
+        invocationExpression,
+        variable
+    ]);
+
+    return expression;
+}
+
 describe("Expression Pattern", () => {
     test("Single Expression", () => {
         const expression = createExpressionPattern();
@@ -113,6 +141,16 @@ describe("Expression Pattern", () => {
         expect(result).toBe(result);
     });
 
+    test("Tail", () => {
+        const expression = createTailExpression();
+        let result = expression.exec("a");
+        result = expression.exec("a.b");
+        result = expression.exec("a.b.c");
+        result = expression.exec("a.b.c()()()");
+
+        expect(result).toBe(result);
+    });
+
     test("Options like", () => {
         const expression = createOptionsExpression();
         const autoComplete = new AutoComplete(expression);

package/src/patterns/ExpressionPattern.ts

@@ -34,6 +34,7 @@ export class ExpressionPattern implements Pattern {
     private _binaryAssociation: Association[];
     private _precedenceMap: Record<string, number>;
     private _binaryNames: string[];
+    private _shouldCompactPatternsMap: Record<string, boolean>;
 
     shouldCompactAst = false;
 
@@ -92,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) {
@@ -102,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();
@@ -121,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);
@@ -206,7 +211,6 @@ export class ExpressionPattern implements Pattern {
     }
 
     parse(cursor: Cursor): Node | null {
-        // This is a cache to help with speed
         this._firstIndex = cursor.index;
         depthCache.incrementDepth(this._id, this._firstIndex);
 
@@ -218,6 +222,7 @@ export class ExpressionPattern implements Pattern {
         if (node != null) {
             cursor.moveTo(node.lastIndex);
             cursor.resolveError();
+            this._compactResult(node);
             return node;
         }
 
@@ -225,6 +230,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);
@@ -248,6 +275,7 @@ export class ExpressionPattern implements Pattern {
 
                 if (node != null) {
                     lastUnaryNode = node;
+
                     break;
                 } else {
                     lastUnaryNode = null;
@@ -301,7 +329,9 @@ export class ExpressionPattern implements Pattern {
                             }
                             break outer;
                         }
-                        break;
+                        onIndex = cursor.index;
+                        i = -1;
+                        continue;
                     }
                 }
 
@@ -340,12 +370,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) {
@@ -378,6 +410,7 @@ export class ExpressionPattern implements Pattern {
                     } else {
                         const node = createNode(name, [lastUnaryNode, delimiterNode]);
                         lastBinaryNode.appendChild(node);
+
                         lastBinaryNode = node;
                     }
 

package/src/patterns/Repeat.ts

@@ -27,8 +27,16 @@ export class Repeat implements Pattern {
     private _pattern: Pattern;
     private _options: InternalRepeatOptions;
     private _children: Pattern[];
+    private _shouldCompactAst: boolean;
 
-    shouldCompactAst = false;
+    get shouldCompactAst() {
+        return this._shouldCompactAst;
+    }
+
+    set shouldCompactAst(value: boolean) {
+        this._shouldCompactAst = value;
+        this._repeatPattern.shouldCompactAst = value;
+    }
 
     get id() {
         return this._id;
@@ -66,6 +74,7 @@ export class Repeat implements Pattern {
         this._id = `repeat-${idIndex++}`;
         this._pattern = pattern;
         this._parent = null;
+        this._shouldCompactAst = false;
         this._options = {
             ...options,
             min: options.min == null ? 1 : options.min,
@@ -78,7 +87,6 @@ export class Repeat implements Pattern {
             this._repeatPattern = new InfiniteRepeat(name, pattern, this._options);
         }
 
-        this._repeatPattern.shouldCompactAst = this.shouldCompactAst;
         this._children = [this._repeatPattern];
         this._repeatPattern.parent = this;
     }