clarity-pattern-parser 10.3.7 → 11.0.1

package/dist/patterns/ExpressionPattern.d.ts

@@ -11,52 +11,54 @@ export declare class ExpressionPattern implements Pattern {
     private _originalPatterns;
     private _patterns;
     private _atomPatterns;
-    private _unaryPrefixPatterns;
-    private _unaryPrefixNames;
+    private _prefixPatterns;
+    private _prefixNames;
+    private _postfixPatterns;
+    private _postfixNames;
     private _binaryPatterns;
-    private _recursivePatterns;
-    private _recursiveNames;
-    private _endsInRecursion;
-    private _binaryAssociation;
-    private _precedenceMap;
     private _binaryNames;
-    private _shouldCompactPatternsMap;
-    shouldCompactAst: boolean;
+    private associationMap;
+    private _precedenceMap;
+    private _shouldStopParsing;
+    private _precedenceTree;
     get id(): string;
     get type(): string;
     get name(): string;
     get parent(): Pattern | null;
     set parent(pattern: Pattern | null);
     get children(): Pattern[];
-    get unaryPrefixPatterns(): readonly Pattern[];
+    get prefixPatterns(): readonly Pattern[];
     get atomPatterns(): readonly Pattern[];
+    get postfixPatterns(): readonly Pattern[];
     get binaryPatterns(): readonly Pattern[];
-    get recursivePatterns(): readonly Pattern[];
     get startedOnIndex(): number;
     constructor(name: string, patterns: Pattern[]);
     private _organizePatterns;
-    private _isBinary;
-    private _isBinaryPattern;
-    private _extractDelimiter;
     private _extractName;
-    private _isUnary;
-    private _isUnaryPattern;
-    private _extractUnaryPrefixPattern;
-    private _isRecursive;
-    private _isRecursivePattern;
-    private _extractRecursiveTail;
-    private _endsWithRecursion;
+    private _isPrefix;
+    private _extractPrefix;
+    private _isAtom;
+    private _isPostfix;
+    private _extractPostfix;
+    private _isBinary;
+    private _extractBinary;
+    private _unwrapAssociationIfNecessary;
+    private _referenceCount;
+    private _isRecursiveReference;
     parse(cursor: Cursor): Node | null;
-    private _compactResult;
     private _tryToParse;
+    private _tryToMatchPrefix;
+    private _tryToMatchAtom;
+    private _tryToMatchPostfix;
+    private _tryToMatchBinary;
     private _isBeyondRecursiveAllowance;
-    test(text: string): boolean;
+    test(text: string, record?: boolean): boolean;
     exec(text: string, record?: boolean): ParseResult;
     getTokens(): string[];
-    getTokensAfter(childReference: Pattern): string[];
+    getTokensAfter(_childReference: Pattern): string[];
     getNextTokens(): string[];
     getPatterns(): Pattern[];
-    getPatternsAfter(childReference: Pattern): Pattern[];
+    getPatternsAfter(_childReference: Pattern): Pattern[];
     getNextPatterns(): Pattern[];
     find(predicate: (p: Pattern) => boolean): Pattern | null;
     clone(name?: string): Pattern;

package/dist/patterns/FiniteRepeat.d.ts

@@ -19,7 +19,6 @@ export declare class FiniteRepeat implements Pattern {
     private _max;
     private _trimDivider;
     private _firstIndex;
-    shouldCompactAst: boolean;
     get id(): string;
     get type(): string;
     get name(): string;
@@ -31,7 +30,7 @@ export declare class FiniteRepeat implements Pattern {
     get startedOnIndex(): number;
     constructor(name: string, pattern: Pattern, options?: FiniteRepeatOptions);
     parse(cursor: Cursor): Node | null;
-    test(text: string): boolean;
+    test(text: string, record?: boolean): boolean;
     exec(text: string, record?: boolean): ParseResult;
     clone(name?: string): Pattern;
     getTokens(): string[];

package/dist/patterns/InfiniteRepeat.d.ts

@@ -19,7 +19,6 @@ export declare class InfiniteRepeat implements Pattern {
     private _firstIndex;
     private _min;
     private _trimDivider;
-    shouldCompactAst: boolean;
     get id(): string;
     get type(): string;
     get name(): string;
@@ -30,7 +29,7 @@ export declare class InfiniteRepeat implements Pattern {
     get startedOnIndex(): number;
     constructor(name: string, pattern: Pattern, options?: InfiniteRepeatOptions);
     private _assignChildrenToParent;
-    test(text: string): boolean;
+    test(text: string, record?: boolean): boolean;
     exec(text: string, record?: boolean): ParseResult;
     parse(cursor: Cursor): Node | null;
     private _meetsMin;

package/dist/patterns/Literal.d.ts

@@ -12,7 +12,6 @@ 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,7 +8,6 @@ export declare class Not implements Pattern {
     private _name;
     private _parent;
     private _children;
-    shouldCompactAst: boolean;
     get id(): string;
     get type(): string;
     get name(): string;
@@ -17,7 +16,7 @@ export declare class Not implements Pattern {
     get children(): Pattern[];
     get startedOnIndex(): number;
     constructor(name: string, pattern: Pattern);
-    test(text: string): boolean;
+    test(text: string, record?: boolean): boolean;
     exec(text: string, record?: boolean): ParseResult;
     parse(cursor: Cursor): Node | null;
     clone(name?: string): Pattern;

package/dist/patterns/Optional.d.ts

@@ -8,7 +8,6 @@ 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,7 +10,6 @@ export declare class Options implements Pattern {
     private _children;
     private _isGreedy;
     private _firstIndex;
-    shouldCompactAst: boolean;
     get id(): string;
     get type(): string;
     get name(): string;
@@ -20,7 +19,7 @@ export declare class Options implements Pattern {
     get startedOnIndex(): number;
     constructor(name: string, options: Pattern[], isGreedy?: boolean);
     private _assignChildrenToParent;
-    test(text: string): boolean;
+    test(text: string, record?: boolean): boolean;
     exec(text: string, record?: boolean): ParseResult;
     parse(cursor: Cursor): Node | null;
     private _tryToParse;

package/dist/patterns/Pattern.d.ts

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

package/dist/patterns/PrecedenceTree.d.ts

@@ -0,0 +1,28 @@
+import { Node } from "../ast/Node";
+export declare enum Association {
+    left = 0,
+    right = 1
+}
+export declare class PrecedenceTree {
+    private _prefixPlaceholder;
+    private _prefixNode;
+    private _postfixPlaceholder;
+    private _postfixNode;
+    private _binaryPlaceholder;
+    private _binaryNode;
+    private _atomNode;
+    private _orphanedAtom;
+    private _precedenceMap;
+    private _associationMap;
+    constructor(precedenceMap?: Record<string, number>, associationMap?: Record<string, Association>);
+    addPrefix(name: string, ...prefix: Node[]): void;
+    addPostfix(name: string, ...postfix: Node[]): void;
+    addBinary(name: string, ...delimiterNode: Node[]): void;
+    private _getPrecedenceFromNode;
+    private _getPrecedence;
+    private _compileAtomNode;
+    addAtom(node: Node): void;
+    hasAtom(): boolean;
+    commit(): Node | null;
+    private reset;
+}

package/dist/patterns/Reference.d.ts

@@ -11,7 +11,6 @@ export declare class Reference implements Pattern {
     private _pattern;
     private _children;
     private _firstIndex;
-    shouldCompactAst: boolean;
     get id(): string;
     get type(): string;
     get name(): string;
@@ -20,7 +19,7 @@ export declare class Reference implements Pattern {
     get children(): Pattern[];
     get startedOnIndex(): number;
     constructor(name: string);
-    test(text: string): boolean;
+    test(text: string, record?: boolean): boolean;
     exec(text: string, record?: boolean): ParseResult;
     parse(cursor: Cursor): Node | null;
     getReferencePatternSafely(): Pattern;

package/dist/patterns/Regex.d.ts

@@ -14,7 +14,6 @@ export declare class Regex implements Pattern {
     private _firstIndex;
     private _substring;
     private _tokens;
-    shouldCompactAst: boolean;
     get id(): string;
     get type(): string;
     get name(): string;
@@ -25,7 +24,7 @@ export declare class Regex implements Pattern {
     get startedOnIndex(): number;
     constructor(name: string, regex: string);
     private assertArguments;
-    test(text: string): boolean;
+    test(text: string, record?: boolean): boolean;
     exec(text: string, record?: boolean): ParseResult;
     parse(cursor: Cursor): Node | null;
     private resetState;

package/dist/patterns/Repeat.d.ts

@@ -15,9 +15,6 @@ 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

@@ -1,6 +1,7 @@
 import { Cursor } from "./Cursor";
 import { Pattern } from "./Pattern";
 import { Node } from "../ast/Node";
+import { ParseResult } from "./ParseResult";
 export declare class Sequence implements Pattern {
     private _id;
     private _type;
@@ -9,7 +10,6 @@ export declare class Sequence implements Pattern {
     private _children;
     private _nodes;
     private _firstIndex;
-    shouldCompactAst: boolean;
     get id(): string;
     get type(): string;
     get name(): string;
@@ -19,11 +19,8 @@ export declare class Sequence implements Pattern {
     get startedOnIndex(): number;
     constructor(name: string, sequence: Pattern[]);
     private _assignChildrenToParent;
-    test(text: string): boolean;
-    exec(text: string, record?: boolean): {
-        ast: Node | null;
-        cursor: Cursor;
-    };
+    test(text: string, record?: boolean): boolean;
+    exec(text: string, record?: boolean): ParseResult;
     parse(cursor: Cursor): Node | null;
     private tryToParse;
     private getLastValidNode;

package/dist/patterns/execPattern.d.ts

@@ -0,0 +1,3 @@
+import { ParseResult } from "./ParseResult";
+import { Pattern } from "./Pattern";
+export declare function execPattern(pattern: Pattern, text: string, record?: boolean): ParseResult;

package/dist/patterns/testPattern.d.ts

@@ -0,0 +1,2 @@
+import { Pattern } from "./Pattern";
+export declare function testPattern(pattern: Pattern, text: string, record?: boolean): boolean;

package/package.json

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

package/src/ast/Node.test.ts

@@ -441,34 +441,34 @@ describe("Node", () => {
     });
 
     test("Transform", () => {
-        const node = Node.createNode("grandparent", [
-            Node.createNode("parent", [
-                Node.createValueNode("child", "John"),
-                Node.createValueNode("child", "Jane"),
-                Node.createValueNode("child", "Jack")
+        const node = Node.createNode("family", "grandparent", [
+            Node.createNode("family", "parent", [
+                Node.createValueNode("family", "child", "John"),
+                Node.createValueNode("family", "child", "Jane"),
+                Node.createValueNode("family", "child", "Jack")
             ]),
-            Node.createValueNode("aunt", "aunt")
+            Node.createValueNode("family", "aunt", "aunt")
         ]);
 
         const result = node.transform({
             "child": (node: Node) => {
-                return Node.createValueNode("adopted-child", node.value);
+                return Node.createValueNode("family", "adopted-child", node.value);
             },
-            "parent": (node)=>{
-                return Node.createNode("adopted-parent", node.children.slice());
+            "parent": (node) => {
+                return Node.createNode("family", "adopted-parent", node.children.slice());
             },
-            "grandparent": (node)=>{
-                return Node.createNode("adopted-grandparent", node.children.slice());
+            "grandparent": (node) => {
+                return Node.createNode("family", "adopted-grandparent", node.children.slice());
             }
         });
 
-        const expected = Node.createNode("adopted-grandparent", [
-            Node.createNode("adopted-parent", [
-                Node.createValueNode("adopted-child", "John"),
-                Node.createValueNode("adopted-child", "Jane"),
-                Node.createValueNode("adopted-child", "Jack")
+        const expected = Node.createNode("family", "adopted-grandparent", [
+            Node.createNode("family", "adopted-parent", [
+                Node.createValueNode("family", "adopted-child", "John"),
+                Node.createValueNode("family", "adopted-child", "Jane"),
+                Node.createValueNode("family", "adopted-child", "Jack")
             ]),
-            Node.createValueNode("aunt", "aunt")
+            Node.createValueNode("family", "aunt", "aunt")
         ]);
 
         expect(result.toJson()).toBe(expected.toJson());

package/src/ast/Node.ts

@@ -114,6 +114,8 @@ export class Node {
 
     if (index > -1) {
       this.spliceChildren(index, 1, newNode);
+      newNode._parent = this;
+      referenceNode._parent = null;
     }
   }
 
@@ -308,7 +310,7 @@ export class Node {
     return length;
   }
 
-  compact(){
+  compact() {
     this._value = this.toString();
     this._children.length = 0;
   }
@@ -340,12 +342,12 @@ export class Node {
     return node.toJson(0) === this.toJson(0);
   }
 
-  static createValueNode(name: string, value: string) {
-    return new Node("custom-value-node", name, 0, 0, [], value);
+  static createValueNode(type: string, name: string, value = "") {
+    return new Node(type, name, 0, 0, [], value);
   }
 
-  static createNode(name: string, children: Node[]) {
+  static createNode(type: string, name: string, children: Node[] = []) {
     const value = children.map(c => c.toString()).join("");
-    return new Node("custom-node", name, 0, 0, children, value);
+    return new Node(type, name, 0, 0, children, value);
   }
 }

package/src/ast/compact.ts

@@ -0,0 +1,11 @@
+import { Node } from "./Node";
+
+export function compact(node: Node, nodeMap: Record<string, boolean>) {
+    node.walkBreadthFirst(n=>{
+        if (nodeMap[n.name]){
+            n.compact();
+        }
+    });
+
+    return node;
+}

package/src/ast/remove.ts

@@ -0,0 +1,11 @@
+import { Node } from "./Node";
+
+export function remove(node: Node, nodeMap: Record<string, boolean>) {
+    node.walkBreadthFirst(n=>{
+        if (nodeMap[n.name]){
+            n.remove();
+        }
+    });
+
+    return node;
+}

package/src/grammar/Grammar.test.ts

@@ -584,54 +584,4 @@ describe("Grammar", () => {
         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,15 +238,10 @@ 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);
     }
 
@@ -315,15 +310,10 @@ 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);
     }
 
@@ -349,15 +339,10 @@ 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);
     }
 
@@ -542,16 +527,11 @@ 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,17 +2,13 @@ import { Sequence } from "../../patterns/Sequence";
 import { Literal } from "../../patterns/Literal";
 import { Options } from "../../patterns/Options";
 import { name } from "./name";
-import { lineSpaces, spaces } from "./spaces";
+import { 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,
@@ -20,7 +16,6 @@ const assignStatement = new Sequence("assign-statement", [
     assignOperator,
     optionalSpaces,
     pattern,
-    optionalCompactModifier
 ]);
 
 export const statement = new Options("statement", [assignStatement, name.clone("export-name")]);

package/src/index.ts

@@ -1,4 +1,6 @@
 import { Node } from "./ast/Node";
+import { compact } from './ast/compact';
+import { remove } from './ast/remove';
 import { Grammar } from "./grammar/Grammar";
 import { Suggestion } from "./intellisense/Suggestion";
 import { SuggestionOption } from "./intellisense/SuggestionOption";
@@ -46,4 +48,6 @@ export {
   Repeat,
   grammar,
   patterns,
+  compact,
+  remove
 };

package/src/patterns/ExpressionPattern.test.ts

@@ -79,7 +79,7 @@ function createExpressionPattern() {
         new RightAssociatedPattern(multDivExpression),
         addSubExpression,
         boolExpression,
-        ternary,
+        new RightAssociatedPattern(ternary),
         group,
         variables,
     ]);