clarity-pattern-parser 10.0.1 → 10.0.3

package/dist/patterns/Not.d.ts

@@ -14,7 +14,6 @@ export declare class Not implements Pattern {
     get parent(): Pattern | null;
     set parent(pattern: Pattern | null);
     get children(): Pattern[];
-    get isOptional(): boolean;
     constructor(name: string, pattern: Pattern);
     test(text: string): boolean;
     exec(text: string, record?: boolean): ParseResult;

package/dist/patterns/Repeat.d.ts

@@ -21,8 +21,8 @@ export declare class Repeat implements Pattern {
     get parent(): Pattern | null;
     set parent(value: Pattern | null);
     get children(): Pattern[];
-    get min(): any;
-    get max(): any;
+    get min(): number;
+    get max(): number;
     constructor(name: string, pattern: Pattern, options?: RepeatOptions);
     parse(cursor: Cursor): Node | null;
     exec(text: string): ParseResult;

package/package.json

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

package/src/ast/Node.ts

@@ -315,6 +315,10 @@ export class Node {
     return JSON.stringify(this.toCycleFreeObject(), null, space);
   }
 
+  isEqual(node: Node) {
+    return node.toJson(0) === this.toJson(0);
+  }
+
   static createValueNode(name: string, value: string) {
     return new Node("custom-value-node", name, 0, 0, [], value);
   }

package/src/grammar/Grammar.test.ts

@@ -511,4 +511,38 @@ describe("Grammar", () => {
         expect(patterns.john).not.toBeNull();
         expect(patterns.jane).not.toBeNull();
     });
+
+    test("Grammar Import", async () => {
+        const importExpression = `first-name = "John"`;
+        const spaceExpression = `
+        use params { custom-space }
+        space = custom-space
+        `;
+        const expression = `
+        use params {
+          custom-space
+        }
+        import { first-name } from "first-name.cpat"
+        import { space } from "space.cpat" with params {
+          custom-space = custom-space
+        }
+        last-name = "Doe"
+        full-name = first-name + space + last-name
+        `;
+
+        const pathMap: Record<string, string> = {
+            "space.cpat": spaceExpression,
+            "first-name.cpat": importExpression,
+            "root.cpat": expression
+        };
+
+        function resolveImport(resource: string) {
+            return Promise.resolve({ expression: pathMap[resource], resource });
+        }
+
+        const patterns = await Grammar.import("root.cpat", { resolveImport, params: [new Literal("custom-space", "  ")] });
+        const fullname = patterns["full-name"] as Pattern;
+        const result = fullname.exec("John  Doe");
+        expect(result?.ast?.value).toBe("John  Doe");
+    });
 });

package/src/grammar/Grammar.ts

@@ -462,7 +462,7 @@ export class Grammar {
                 );
 
                 const grammar = new Grammar({
-                    params: importedValues,
+                    params: [...importedValues, ...this._parseContext.paramsByName.values()],
                     originResource: this._originResource,
                     resolveImport: this._resolveImport
                 });

package/src/intellisense/AutoComplete.test.ts

@@ -118,7 +118,7 @@ describe("AutoComplete", () => {
 
         expect(result.ast).toBeNull();
         expect(result.options).toEqual(expectedOptions);
-        expect(result.errorAtIndex).toBe(text.length)
+        expect(result.errorAtIndex).toBe(text.length);
         expect(result.isComplete).toBeFalsy();
         expect(result.cursor).not.toBeNull();
     });

package/src/patterns/FiniteRepeat.test.ts

@@ -478,4 +478,10 @@ describe("BoundedRepeat", () => {
         expect(comma).toBe(numbers.children[1]);
     });
 
+    test("Trim Trailing Complex Delimiter Pattern", () => {
+        const numbers = new FiniteRepeat("numbers", new Regex("number", "\\d"), { divider: new Sequence("comma", [new Literal(",", ","), new Literal("space", " ")]), trimDivider: true, max: 3 });
+        const result = numbers.parse(new Cursor("1, 2,"));
+        expect(result?.value).toBe("1, 2");
+    });
+
 });

package/src/patterns/FiniteRepeat.ts

@@ -117,7 +117,7 @@ export class FiniteRepeat implements Pattern {
         }
 
         if (this._trimDivider && this._hasDivider) {
-            const isDividerLastMatch = cursor.leafMatch.pattern === this.children[1];
+            const isDividerLastMatch = this.children.length > 1 && nodes[nodes.length - 1].name === this.children[1].name;
             if (isDividerLastMatch) {
                 const node = nodes.pop() as Node;
                 cursor.moveTo(node.firstIndex);

package/src/patterns/InfiniteRepeat.test.ts

@@ -264,5 +264,11 @@ describe("InfiniteRepeat", () => {
         expect(result.cursor.hasError).toBeTruthy();
     });
 
+    test("Trim Trailing Complex Delimiter Pattern", () => {
+        const numbers = new InfiniteRepeat("numbers", new Regex("number", "\\d"), { divider: new Sequence("comma", [new Literal(",", ","), new Literal("space", " ")]), trimDivider: true });
+        const result = numbers.parse(new Cursor("1, 2,"));
+        expect(result?.value).toBe("1, 2");
+    });
+
 
 });

package/src/patterns/InfiniteRepeat.ts

@@ -196,7 +196,7 @@ export class InfiniteRepeat implements Pattern {
             if (dividerNode == null) {
               cursor.moveTo(dividerStartIndex);
 
-              if (dividerNode == null && repeatNode == null) {
+              if (repeatNode == null) {
                 // If neither the repeat pattern or divider pattern matched get out. 
                 passed = true;
                 break;
@@ -235,7 +235,7 @@ export class InfiniteRepeat implements Pattern {
     if (
       hasDivider &&
       this._trimDivider &&
-      cursor.leafMatch.pattern === this._divider
+      this._nodes[this._nodes.length - 1].name === this._divider?.name
     ) {
       const dividerNode = this._nodes.pop() as Node;
       cursor.moveTo(dividerNode.firstIndex);

package/src/patterns/Not.test.ts

@@ -53,7 +53,6 @@ describe("Not", () => {
         expect(notA.name).toBe("not-a");
         expect(notA.parent).toBeNull();
         expect(notA.children[0].name).toBe("a");
-        expect(notA.isOptional).toBeFalsy();
     });
 
     test("Not A Not", () => {

package/src/patterns/Not.ts

@@ -36,10 +36,6 @@ export class Not implements Pattern {
     return this._children;
   }
 
-  get isOptional(): boolean {
-    return false;
-  }
-
   constructor(name: string, pattern: Pattern) {
     this._id = `not-${idIndex++}`;
     this._type = "not";

package/src/patterns/Repeat.ts

@@ -53,11 +53,11 @@ export class Repeat implements Pattern {
     }
 
     get min() {
-        return (this.children[0] as any).min;
+        return this._options.min;
     }
 
     get max() {
-        return (this.children[0] as any).max || Infinity;
+        return this._options.max;
     }
 
     constructor(name: string, pattern: Pattern, options: RepeatOptions = {}) {

package/src/patterns/Sequence.test.ts

@@ -3,6 +3,7 @@ import { Sequence } from "./Sequence";
 import { Literal } from "./Literal";
 import { Node } from "../ast/Node";
 import { Optional } from "./Optional";
+import { Pattern } from "./Pattern";
 
 describe("Sequence", () => {
     test("No Patterns", () => {
@@ -310,9 +311,9 @@ describe("Sequence", () => {
 
         const sequenceClone = parent.find(p => p.name === "sequence");
         const nextPatterns = sequenceClone?.getNextPatterns() || [];
-        const b = parent.find(p => p.name === "b")
+        const b = parent.find(p => p.name === "b") as Pattern;
 
-        expect(nextPatterns[0]).toBe(b);
+        expect(nextPatterns[0].isEqual(b)).toBeTruthy();
     });
 
     test("Get Next Patterns With Null Parent", () => {

package/src/patterns/Sequence.ts

@@ -212,7 +212,7 @@ export class Sequence implements Pattern {
     for (const child of this._children) {
       tokens.push(...child.getTokens());
 
-      if (child.type !== "optional") {
+      if (child.type !== "optional" && child.type !== "not") {
         break;
       }
     }
@@ -243,7 +243,7 @@ export class Sequence implements Pattern {
     for (const child of this._children) {
       patterns.push(...child.getPatterns());
 
-      if (child.type !== "optional") {
+      if (child.type !== "optional" && child.type !== "not") {
         break;
       }
     }