clarity-pattern-parser 11.3.9 → 11.3.10

package/dist/patterns/InfiniteRepeat.d.ts

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

package/package.json

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

package/src/intellisense/AutoComplete.test.ts

@@ -523,6 +523,29 @@ describe("AutoComplete", () => {
         expect(result.options).toEqual([{ text: 'a', startIndex: 4 }]);
     });
 
+    test("Remove options divider", () => {
+        const jediLuke = new Literal(`jedi`, 'luke');
+        const names = new Options('names', [jediLuke]);
+        const literalA = new Literal('literal-a', 'a');
+        const literalB = new Literal('literal-b', 'b');
+
+        const optionsDivider = new Options('options-divider', [literalA, literalB]);
+
+        // control to prove the pattern works without trimDivider
+        const controlPattern = new Repeat('name-list', names, { divider: optionsDivider });
+        const controlAutoComplete = new AutoComplete(controlPattern);
+        const controlResult = controlAutoComplete.suggestFor('lukea');
+        expect(controlResult.isComplete).toEqual(true);
+
+        const trimPattern = new Repeat('name-list', names, { divider: optionsDivider, trimDivider: true });
+        const trimAutoComplete = new AutoComplete(trimPattern);
+
+        const trimResult = trimAutoComplete.suggestFor('lukea');
+        expect(trimResult.isComplete).toEqual(false);
+    })
+
+
+
     test("Expect Divider", () => {
         const repeat = new Repeat("repeat", new Literal("a", "a"), { divider: new Literal("pipe", "|") });
         const autoComplete = new AutoComplete(repeat);

package/src/patterns/FiniteRepeat.ts

@@ -123,12 +123,10 @@ export class FiniteRepeat implements Pattern {
             }
         }
 
-        if (this._trimDivider && this._hasDivider) {
-            const isDividerLastMatch = this.children.length > 1 && nodes.length > 1 && nodes[nodes.length - 1].name === this.children[1].name;
-            if (isDividerLastMatch) {
-                const node = nodes.pop() as Node;
-                cursor.moveTo(node.firstIndex);
-            }
+        const endedOnDivider = this._hasDivider && nodes.length % modulo === 0;
+        if (this._trimDivider && endedOnDivider) {
+            const node = nodes.pop() as Node;
+            cursor.moveTo(node.firstIndex);
         }
 
         if (matchCount < this._min) {

package/src/patterns/InfiniteRepeat.ts

@@ -26,6 +26,7 @@ export class InfiniteRepeat implements Pattern {
   private _firstIndex: number;
   private _min: number;
   private _trimDivider: boolean;
+  private _patterns: Pattern[];
 
   get id(): string {
     return this._id;
@@ -83,6 +84,7 @@ export class InfiniteRepeat implements Pattern {
     this._firstIndex = 0;
     this._nodes = [];
     this._trimDivider = options.trimDivider == null ? false : options.trimDivider;
+    this._patterns = [];
   }
 
   private _assignChildrenToParent(children: Pattern[]): void {
@@ -102,6 +104,7 @@ export class InfiniteRepeat implements Pattern {
   parse(cursor: Cursor): Node | null {
     this._firstIndex = cursor.index;
     this._nodes = [];
+    this._patterns = [];
 
     const passed = this._tryToParse(cursor);
 
@@ -165,6 +168,7 @@ export class InfiniteRepeat implements Pattern {
 
         if (repeatNode != null) {
           this._nodes.push(repeatNode);
+          this._patterns.push(this._pattern);
 
           if (!cursor.hasNext()) {
             passed = true;
@@ -192,6 +196,7 @@ export class InfiniteRepeat implements Pattern {
               }
             } else {
               this._nodes.push(dividerNode);
+              this._patterns.push(this._divider);
 
               if (!cursor.hasNext()) {
                 passed = true;
@@ -220,11 +225,12 @@ export class InfiniteRepeat implements Pattern {
 
   private _createNode(cursor: Cursor): Node | null {
     const hasDivider = this._divider != null;
+    const lastPattern = this._patterns[this._patterns.length - 1];
 
     if (
       hasDivider &&
       this._trimDivider &&
-      this._nodes[this._nodes.length - 1].name === this._divider?.name
+      lastPattern === this._divider
     ) {
       const dividerNode = this._nodes.pop() as Node;
       cursor.moveTo(dividerNode.firstIndex);