clarity-pattern-parser 11.1.0 → 11.1.2

package/dist/patterns/Expression.d.ts

@@ -6,6 +6,7 @@ export declare class Expression implements Pattern {
     private _id;
     private _type;
     private _name;
+    private _originalName;
     private _parent;
     private _firstIndex;
     private _originalPatterns;

package/package.json

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

package/src/grammar/Grammar.test.ts

@@ -682,4 +682,18 @@ describe("Grammar", () => {
         expect(allRecordedPatterns).toEqual(["spaces", "digits"]);
     });
 
+    test("Decorator With Empty Object Literal", () => {
+        patterns`
+            @method({})
+            spaces = /\\s+/
+        `;
+    });
+
+    test("Decorator With Object Literal", () => {
+        patterns`
+            @method({"prop": 2})
+            spaces = /\\s+/
+        `;
+    });
+
 });

package/src/grammar/patterns/decoratorStatement.ts

@@ -17,13 +17,13 @@ const closeSquareBracket = new Literal("close-square-bracket", "]");
 const optionalAllSpaces = new Optional("optional-all-spaces", allSpaces);
 
 const stringLiteral = new Regex("string-literal", '"(?:\\\\.|[^"\\\\])*"');
-const numberLiteral = new Regex("number-literal", '[+-]?\\d+(\\\\.\\d+)?([eE][+-]?\\d+)?');
+const numberLiteral = new Regex("number-literal", '[+-]?\\d+(\\.\\d+)?([eE][+-]?\\d+)?');
 const nullLiteral = new Literal("null-literal", "null");
 const trueLiteral = new Literal("true-literal", "true");
 const falseLiteral = new Literal("false-literal", "false");
 const booleanLiteral = new Options("", [trueLiteral, falseLiteral]);
 
-const objectKey = name.clone("object-key");
+const objectKey = stringLiteral.clone("object-key");
 const objectProperty = new Sequence("object-property", [
     objectKey,
     optionalAllSpaces,
@@ -44,7 +44,7 @@ const arrayItems = new Repeat("array-items", new Reference("literal"), { divider
 const arrayLiteral = new Sequence("array-literal", [
     openSquareBracket,
     optionalAllSpaces,
-    arrayItems,
+    new Optional("optional-array-items", arrayItems),
     optionalAllSpaces,
     closeSquareBracket,
 ]);

package/src/patterns/Expression.test.ts

@@ -166,4 +166,12 @@ describe("Expression Pattern", () => {
         const suggestion = autoComplete.suggestFor("a ? b ");
         expect(suggestion).toBe(suggestion);
     });
+
+    test("Clone With New Name", ()=>{
+        const expression = createTailExpression();
+        const clone = expression.clone("new-expression");
+
+        const result = clone.exec("a.b");
+        expect(result).toBe(result);
+    });
 });

package/src/patterns/Expression.ts

@@ -15,6 +15,7 @@ export class Expression implements Pattern {
     private _id: string;
     private _type: string;
     private _name: string;
+    private _originalName: string;
     private _parent: Pattern | null;
     private _firstIndex: number;
     private _originalPatterns: Pattern[];
@@ -88,6 +89,7 @@ export class Expression implements Pattern {
         this._id = `expression-${indexId++}`;
         this._type = "expression";
         this._name = name;
+        this._originalName = name;
         this._parent = null;
         this._firstIndex = 0;
         this._atomPatterns = [];
@@ -253,7 +255,7 @@ export class Expression implements Pattern {
         if (pattern == null) {
             return false;
         }
-        return pattern.name === this.name;
+        return pattern.name === this._originalName;
     }
 
     build() {
@@ -550,6 +552,7 @@ export class Expression implements Pattern {
 
     clone(name = this._name): Pattern {
         const clone = new Expression(name, this._originalPatterns);
+        clone._originalName = this.name;
         clone._id = this._id;
         return clone;
     }