clarity-pattern-parser 6.0.0 → 7.0.0

package/src/intellisense/AutoComplete.ts

@@ -1,4 +1,5 @@
 import { Cursor } from "../patterns/Cursor";
+import { Match } from "../patterns/CursorHistory";
 import { Pattern } from "../patterns/Pattern";
 import { Suggestion } from "./Suggestion";
 import { SuggestionOption } from "./SuggestionOption";
@@ -9,12 +10,12 @@ export interface AutoCompleteOptions {
    * Be very careful, this can explode to infinity pretty quick. Usually useful 
    * for dividers and spaces.
    */
-  greedyPatternNames: string[];
+  greedyPatternNames?: string[];
   /**
    * Allows for custom suggestions for patterns. The key is the name of the pattern
    * and the string array are the tokens suggested for that pattern.
    */
-  customTokens: Record<string, string[]>;
+  customTokens?: Record<string, string[]>;
 }
 
 const defaultOptions = { greedyPatternNames: [], customTokens: {} };
@@ -31,12 +32,12 @@ export class AutoComplete {
     this._text = "";
   }
 
-  suggest(text: string): Suggestion {
+  suggestFor(text: string): Suggestion {
     if (text.length === 0) {
       return {
         isComplete: false,
-        options: this.createSuggestionsFromRoot(),
-        nextPatterns: [this._pattern],
+        options: this._createSuggestionsFromRoot(),
+        errorAtIndex: 0,
         cursor: null,
         ast: null
       }
@@ -44,50 +45,54 @@ export class AutoComplete {
 
     this._text = text;
     this._cursor = new Cursor(text);
-    const ast = this._pattern.parse(this._cursor);
 
-    const leafPattern = this._cursor.leafMatch.pattern;
+    let errorAtIndex = null;
+
+    const ast = this._pattern.parse(this._cursor);
     const isComplete = ast?.value === text;
-    const options = this.createSuggestionsFromTokens();
+    const options = this._getAllOptions();
 
-    let nextPatterns = [this._pattern];
+    if (this._cursor.hasError && this._cursor.furthestError != null) {
+      errorAtIndex = this._cursor.furthestError.index;
 
-    if (leafPattern != null) {
-      nextPatterns = leafPattern.getNextPatterns();
+      errorAtIndex = options.reduce((errorAtIndex, option) =>
+        Math.max(errorAtIndex, option.startIndex),
+        errorAtIndex);
     }
 
     return {
       isComplete: isComplete,
       options: options,
-      nextPatterns,
+      errorAtIndex,
       cursor: this._cursor,
       ast,
     }
   }
 
-  private createSuggestionsFromRoot(): SuggestionOption[] {
+  private _getAllOptions() {
+    return this._cursor.leafMatches.map((m) => this._createSuggestionsFromMatch(m)).flat();
+  }
+
+  private _createSuggestionsFromRoot(): SuggestionOption[] {
     const suggestions: SuggestionOption[] = [];
     const tokens = this._pattern.getTokens();
 
     for (const token of tokens) {
-      suggestions.push(this.createSuggestion("", token));
+      suggestions.push(this._createSuggestion("", token));
     }
 
     return suggestions;
   }
 
-  private createSuggestionsFromTokens(): SuggestionOption[] {
-    const leafMatch = this._cursor.leafMatch;
-
-    if (!leafMatch.pattern) {
-      return this.createSuggestions(-1, this._getTokensForPattern(this._pattern));
+  private _createSuggestionsFromMatch(match: Match): SuggestionOption[] {
+    if (!match.pattern) {
+      return this._createSuggestions(-1, this._getTokensForPattern(this._pattern));
     }
 
-    const leafPattern = leafMatch.pattern;
-    const leafNode = leafMatch.node;
-    const parent = leafMatch.pattern.parent;
+    const leafPattern = match.pattern;
+    const parent = match.pattern.parent;
 
-    if (parent !== null && leafMatch.node != null) {
+    if (parent !== null && match.node != null) {
       const patterns = leafPattern.getNextPatterns();
 
       const tokens = patterns.reduce((acc: string[], pattern) => {
@@ -95,39 +100,50 @@ export class AutoComplete {
         return acc;
       }, []);
 
-      return this.createSuggestions(leafMatch.node.lastIndex, tokens);
+      return this._createSuggestions(match.node.lastIndex, tokens);
     } else {
       return [];
     }
   }
 
   private _getTokensForPattern(pattern: Pattern) {
-    if (this._options.greedyPatternNames.includes(pattern.name)) {
-      const greedyTokens = pattern.getTokens();
+    const augmentedTokens = this._getAugmentedTokens(pattern)
+
+    if (this._options.greedyPatternNames != null && this._options.greedyPatternNames.includes(pattern.name)) {
       const nextPatterns = pattern.getNextPatterns();
       const tokens: string[] = [];
 
-      const nextPatternTokens = nextPatterns.reduce((acc: string[], pattern)=>{
+      const nextPatternTokens = nextPatterns.reduce((acc: string[], pattern) => {
         acc.push(...this._getTokensForPattern(pattern));
         return acc;
       }, []);
 
-      for (let token of greedyTokens){
-        for (let nextPatternToken of nextPatternTokens){
+      for (let token of augmentedTokens) {
+        for (let nextPatternToken of nextPatternTokens) {
           tokens.push(token + nextPatternToken);
         }
       }
 
       return tokens;
     } else {
-      const tokens = pattern.getTokens();
-      const customTokens = this._options.customTokens[pattern.name] || [];
-      tokens.push(...customTokens);
-      return tokens;
+      return augmentedTokens;
     }
   }
 
-  private createSuggestions(lastIndex: number, tokens: string[]): SuggestionOption[] {
+  private _getAugmentedTokens(pattern: Pattern) {
+    const customTokensMap: any = this._options.customTokens || {};
+    const leafPatterns = pattern.getPatterns();
+    const tokens: string[] = customTokensMap[pattern.name] || [];
+
+    leafPatterns.forEach(p => {
+      const augmentedTokens = customTokensMap[p.name] || [];
+      tokens.push(...p.getTokens(), ...augmentedTokens);
+    });
+
+    return tokens;
+  }
+
+  private _createSuggestions(lastIndex: number, tokens: string[]): SuggestionOption[] {
     let substring = lastIndex === -1 ? "" : this._cursor.getChars(0, lastIndex);
     const suggestionStrings: string[] = [];
     const options: SuggestionOption[] = [];
@@ -140,7 +156,7 @@ export class AutoComplete {
 
       if (startsWith && !alreadyExist && !isSameAsText) {
         suggestionStrings.push(suggestion);
-        options.push(this.createSuggestion(this._cursor.text, suggestion));
+        options.push(this._createSuggestion(this._cursor.text, suggestion));
       }
     }
 
@@ -150,7 +166,7 @@ export class AutoComplete {
     return reducedOptions;
   }
 
-  private createSuggestion(fullText: string, suggestion: string): SuggestionOption {
+  private _createSuggestion(fullText: string, suggestion: string): SuggestionOption {
     const furthestMatch = findMatchIndex(suggestion, fullText);
     const text = suggestion.slice(furthestMatch);
 

package/src/intellisense/Suggestion.ts

@@ -1,12 +1,11 @@
 import { Node } from "../ast/Node";
 import { Cursor } from "../patterns/Cursor";
-import { Pattern } from "../patterns/Pattern";
 import { SuggestionOption } from "./SuggestionOption";
 
 export interface Suggestion {
   isComplete: boolean;
   options: SuggestionOption[];
-  nextPatterns: Pattern[];
+  errorAtIndex: number | null;
   cursor: Cursor | null;
   ast: Node | null;
 }

package/src/intellisense/css/cssValue.ts

@@ -2,6 +2,6 @@ import { Repeat } from "../../patterns/Repeat";
 import divider from "./divider";
 import values from "./values";
 
-const cssValue = new Repeat("css-value", values, divider);
+const cssValue = new Repeat("css-value", values, { divider });
 
 export default cssValue;

package/src/intellisense/css/method.ts

@@ -9,7 +9,7 @@ import divider from "./divider";
 const openParen = new Literal("open-paren", "(");
 const closeParen = new Literal("close-paren", ")");
 const values = new Reference("values");
-const args = new Repeat("arguments", values, divider, true);
+const args = new Repeat("arguments", values, { divider, min: 0 });
 const methodName = name.clone("method-name");
 methodName.setTokens(["rgba", "radial-gradient", "linear-gradient"]);
 

package/src/intellisense/css/values.ts

@@ -2,6 +2,6 @@ import { Repeat } from "../../patterns/Repeat";
 import value from "./value";
 import spaces from "./spaces";
 
-const values = new Repeat("values", value, spaces);
+const values = new Repeat("values", value, { divider: spaces });
 
 export default values;

package/src/intellisense/javascript/Javascript.test.ts

@@ -1,7 +1,8 @@
+import { Cursor } from "../../patterns/Cursor";
 import { escapedCharacter } from "./escapedCharacter";
 import { exponent } from "./exponent";
 import { expression } from "./expression";
-import { expressionStatement } from "./expressionStatement";
+import { assignment } from "./assignment";
 import { infixOperator } from "./infixOperator";
 import { integer } from "./integer";
 import { name } from "./name";
@@ -173,30 +174,52 @@ describe("Ecmascript 3", () => {
         expect(result.ast?.value).toBe(`{"prop":1}`);
     });
 
-    test("Array Literal", () => {
+    test("Expression", () => {
+
         let result = expression.exec("[]")
         expect(result.ast?.value).toBe("[]");
 
         result = expression.exec("[{}, 9, 0.9e-10, [1, 2]]")
         expect(result.ast?.value).toBe("[{}, 9, 0.9e-10, [1, 2]]");
-    });
+
+        result = expression.exec(`"John"`);
+        expect(result.ast?.value).toBe(`"John"`)
+
+        result = expression.exec(`variableName.property`);
+        expect(result.ast?.value).toBe(`variableName.property`);
+
+        result = expression.exec(`{property: ""}`);
+        expect(result.ast?.value).toBe(`{property: ""}`);
+
+        const cursor = new Cursor(`name() == name.property === name2 ? {prop: name, blah: [ 0.9e-10 ]} : name`);
+        cursor.startRecording();
+        const ast = expression.parse(cursor);
+    })
 
     test("Expression Statement", () => {
-        let result = expressionStatement.exec(`name = "John"`);
+        let result = assignment.exec(`name = "John"`);
         expect(result.ast?.value).toBe(`name = "John"`);
 
-        result = expressionStatement.exec(`name = othername = "John"`)
+        result = assignment.exec(`name = othername = "John"`)
         expect(result.ast?.value).toBe(`name = othername = "John"`);
 
-        result = expressionStatement.exec(`name = othername.prop = "John"`)
+        result = assignment.exec(`name = othername.prop = "John"`)
         expect(result.ast?.value).toBe(`name = othername.prop = "John"`);
 
-        result = expressionStatement.exec(`name = othername.prop += 2`)
+        result = assignment.exec(`name = othername.prop += 2`)
         expect(result.ast?.value).toBe(`name = othername.prop += 2`);
-    
-        result = expressionStatement.exec(`name.prop().method(blah) = blah.prop()`)
-        expect(result.ast?.value).toBe(`name.prop().method(blah) = blah.prop()`);
-    
+
+        result = assignment.exec(`name.prop().method(blah) = blah.prop() == ha ? first : second`)
+        expect(result.ast?.value).toBe(`name.prop().method(blah) = blah.prop() == ha ? first : second`);
+    });
+
+
+    test("Object Access", () => {
+        let result = expression.exec("name.prop");
+        expect(result.ast?.value).toBe(`name.prop`);
+
+        result = expression.exec(`name.prop.anotherProp["Ha"][coolYo] === 1`);
+        expect(result.ast?.value).toBe(`name.prop.anotherProp["Ha"][coolYo] === 1`);
     });
 
 

package/src/intellisense/javascript/arrayLiteral.ts

@@ -7,7 +7,7 @@ import { Repeat } from "../../patterns/Repeat";
 import { optionalSpaces } from "./optionalSpaces";
 
 const divider = new Regex("array-divider", "\\s*,\\s*");
-const arrayItems = new Repeat("array-items", new Reference("expression"), divider, true);
+const arrayItems = new Repeat("array-items", new Reference("expression"), { divider, min: 0 });
 
 export const arrayLiteral = new Or("array-literal",
     [new And("empty-array-literal", [

package/src/intellisense/javascript/{expressionStatement.ts → assignment.ts}

@@ -1,7 +1,7 @@
 import { And } from "../../patterns/And";
 import { Literal } from "../../patterns/Literal";
 import { Or } from "../../patterns/Or";
-import { Repeat } from "../../patterns/Repeat";
+import { Reference } from "../../patterns/Reference";
 import { expression } from "./expression";
 import { optionalSpaces } from "./optionalSpaces";
 
@@ -16,14 +16,13 @@ const assignment = new And("assignment", [
     optionalSpaces,
     assignmentOperators,
     optionalSpaces,
+    new Or("assignment-right-operand", [
+        new Reference("assignment"),
+        expression
+    ]),
 ]);
 
-const expressionStatement = new And("expressionStatement", [
-    new Repeat("assignments",
-        assignment),
-    optionalSpaces,
-    expression
-]);
 
 
-export { expressionStatement }
+
+export { assignment }

package/src/intellisense/javascript/expression.ts

@@ -1,13 +1,15 @@
-import { Regex } from "../..";
 import { And } from "../../patterns/And";
 import { Literal } from "../../patterns/Literal";
 import { Or } from "../../patterns/Or";
 import { Reference } from "../../patterns/Reference";
+import { Regex } from "../../patterns/Regex";
 import { Repeat } from "../../patterns/Repeat";
 import { infixOperator } from "./infixOperator";
 import { invocation } from "./invocation";
+import { nullKeyword } from "./keywords";
 import { literal } from "./literal";
 import { name } from "./name";
+import { objectAccess } from "./objectAccess";
 import { optionalSpaces } from "./optionalSpaces";
 import { prefixOperator } from "./prefixOperator";
 import { propertyAccess } from "./propertyAccess";
@@ -41,46 +43,62 @@ const prefixExpression = new And("prefix-expression", [
     new Reference("expression")
 ]);
 
-const optionalInfix = new And("infix-expression", [
-    infixOperator,
-    optionalSpaces,
-    new Reference("expression"),
-], true);
-
-const optionalTernary = new And("ternary", [
-    new Literal("question-mark", "?"),
-    optionalSpaces,
-    new Reference("expression"),
-    optionalSpaces,
-    new Literal("colon", ":"),
-    optionalSpaces,
-    new Reference("expression")
-], true);
-
-const optionalMemberAccesses = new Repeat("object-member-accesses",
-    new Or("object-member-access", [
+const memberAccess = new Repeat("member-access",
+    new Or("member-access", [
         invocation,
         propertyAccess,
-    ]),
-    undefined, true
+    ])
 );
 
+
 var variableName = name.clone("variable-name");
 
 const expressions = new Or("expressions", [
     newExpression,
     deleteExpression,
-    groupExpression,
-    prefixExpression,
     literal,
+    nullKeyword,
+    objectAccess,
     variableName,
+    groupExpression,
+    prefixExpression
 ]);
 
-const expression = new And("expression", [
+const expressionBody = new And("expression-body", [
     expressions,
-    optionalInfix,
-    optionalTernary,
-    optionalMemberAccesses
+    memberAccess.clone(undefined, true),
+]);
+
+const infixExpression = new And("infix-expression", [
+    expressionBody,
+    optionalSpaces,
+    infixOperator,
+    optionalSpaces,
+    new Or("infix-right-operand", [
+        new Reference("infix-expression"),
+        expressionBody,
+    ])
+]);
+
+const ternaryExpression = new And("ternary", [
+    new Or("ternary-condition", [
+        infixExpression,
+        expressionBody
+    ]),
+    optionalSpaces,
+    new Literal("question-mark", "?"),
+    optionalSpaces,
+    new Reference("expression"),
+    optionalSpaces,
+    new Literal("colon", ":"),
+    optionalSpaces,
+    new Reference("expression")
+]);
+
+const expression = new Or("expression", [
+    ternaryExpression,
+    infixExpression,
+    expressionBody
 ]);
 
 export { expression }

package/src/intellisense/javascript/infixOperator.ts

@@ -10,8 +10,10 @@ const greaterOrEqual = new Literal("greater-or-equal", ">=");
 const lessOrEqual = new Literal("less-or-equal", "<=");
 const greater = new Literal("greater", ">");
 const less = new Literal("less", "<");
-const equal = new Literal("equal", "===");
-const notEqual = new Literal("not-equal", "!==");
+const equal = new Literal("equal", "==");
+const notEqual = new Literal("not-equal", "!=");
+const strictEqual = new Literal("strict-equal", "===");
+const strictNotEqual = new Literal("strict-not-equal", "!==");
 const logicalOr = new Literal("logical-or", "||");
 const logicalAnd = new Literal("logical-and", "&&");
 
@@ -25,6 +27,8 @@ const infixOperator = new Or("infix-operator", [
     lessOrEqual,
     greater,
     less,
+    strictEqual,
+    strictNotEqual,
     equal,
     notEqual,
     logicalOr,

package/src/intellisense/javascript/invocation.ts

@@ -11,7 +11,7 @@ const divider = new Regex("invocation-divider", "\\s*,\\s*");
 const invocationWithArguments = new And("invocation-with-arguments", [
     new Literal("open-paren", "("),
     optionalSpaces,
-    new Repeat("expressions", new Reference("expression"), divider, true),
+    new Repeat("expressions", new Reference("expression"), { divider, min: 0 }),
     optionalSpaces,
     new Literal("close-paren", ")"),
 ]);

package/src/intellisense/javascript/keywords.ts

@@ -0,0 +1,3 @@
+import { Literal } from "../../patterns/Literal";
+
+export const nullKeyword = new Literal("null", "null");

package/src/intellisense/javascript/objectAccess.ts

@@ -0,0 +1,9 @@
+import { And } from "../../patterns/And";
+import { Reference } from "../../patterns/Reference";
+import { name } from "./name";
+import { propertyAccess } from "./propertyAccess";
+
+export const objectAccess = new And("object-access", [
+    name.clone("variable-name"),
+    propertyAccess,
+]);

package/src/intellisense/javascript/objectLiteral.ts

@@ -8,7 +8,7 @@ import { name } from "./name";
 import { optionalSpaces } from "./optionalSpaces";
 import { stringLiteral } from "./stringLiteral";
 
-const propertyName = new Or("property-name", [stringLiteral, name]);
+const propertyName = new Or("property-name", [stringLiteral.clone("object-property"), name.clone("object-property")]);
 const property = new And("property", [
     propertyName,
     optionalSpaces,
@@ -17,12 +17,12 @@ const property = new And("property", [
     new Reference("expression"),
 ]);
 const divider = new Regex("property-divider", "\\s*,\\s*");
-const properties = new Repeat("properties", property, divider, true);
+const optionalProperties = new Repeat("properties", property, { divider, min: 0 });
 
 const objectLiteral = new And("object-literal", [
     new Literal("open-curly-bracket", "{"),
     optionalSpaces,
-    properties,
+    optionalProperties,
     optionalSpaces,
     new Literal("close-curly-bracket", "}"),
 ]);

package/src/intellisense/javascript/parameters.ts

@@ -12,7 +12,7 @@ const optionalSpace = new Regex("optional-space", "\\s", true)
 const parameters = new And("parameters", [
     new Literal("open-paren", "("),
     optionalSpace,
-    new Repeat("arguments", name, divider),
+    new Repeat("arguments", name, { divider, trimDivider: true }),
     optionalSpace,
     new Literal("close-paren", ")"),
 ]);

package/src/intellisense/javascript/propertyAccess.ts

@@ -6,7 +6,7 @@ import { name } from "./name";
 
 const dotPropertyAccess = new And("dot-property-access", [
     new Literal("period", "."),
-    name
+    name.clone("property-name")
 ]);
 
 const bracketPropertyAccess = new And("bracket-property-access", [
@@ -15,9 +15,14 @@ const bracketPropertyAccess = new And("bracket-property-access", [
     new Literal("close-square-bracket", "]"),
 ]);
 
-const propertyAccess = new Or("property-access", [
+const propertyAccessTypes = new Or("property-access-types", [
     dotPropertyAccess,
-    bracketPropertyAccess,
+    bracketPropertyAccess
+]);
+
+const propertyAccess = new And("property-access", [
+    propertyAccessTypes,
+    new Reference("property-access", true)
 ]);
 
 export { propertyAccess }

package/src/intellisense/javascript/stringLiteral.ts

@@ -7,19 +7,25 @@ import { escapedCharacter } from "./escapedCharacter";
 
 const doubleQuoteStringLiteral = new And("double-string-literal", [
     new Literal("double-quote", "\""),
-    new Repeat("characters", new Or("characters", [
-        new Regex("normal-characters", "[^\\\"]+"),
-        escapedCharacter
-    ])),
+    new Repeat("characters",
+        new Or("characters", [
+            new Regex("normal-characters", "[^\\\"]+"),
+            escapedCharacter
+        ]),
+        { min: 0 }
+    ),
     new Literal("double-quote", "\""),
 ]);
 
 const singleQuoteStringLiteral = new And("single-string-literal", [
     new Literal("single-quote", "'"),
-    new Repeat("characters", new Or("characters", [
-        new Regex("normal-characters", "[^\\']+"),
-        escapedCharacter
-    ])),
+    new Repeat("characters",
+        new Or("characters", [
+            new Regex("normal-characters", "[^\\']+"),
+            escapedCharacter
+        ]),
+        { min: 0 }
+    ),
     new Literal("single-quote", "'"),
 ]);
 

package/src/patterns/And.test.ts

@@ -276,7 +276,7 @@ describe("And", () => {
         const sequence = new And("sequence", [new Literal("a", "A")]);
         const parent = new And("parent", [sequence, new Literal("b", "B")]);
 
-        const sequenceClone = parent.findPattern(p => p.name === "sequence");
+        const sequenceClone = parent.find(p => p.name === "sequence");
         const tokens = sequenceClone?.getNextTokens() || [];
 
         expect(tokens[0]).toBe("B");
@@ -289,13 +289,26 @@ describe("And", () => {
         expect(tokens.length).toBe(0);
     });
 
+    test("Get Patterns", () => {
+        const sequence = new And("sequence", [
+            new Literal("a", "A", true),
+            new Literal("b", "B"),
+        ], true);
+        const tokens = sequence.getPatterns();
+        const a = sequence.find(p=>p.name === "a");
+        const b = sequence.find(p=>p.name === "b");
+        const expected = [a, b]
+
+        expect(tokens).toEqual(expected);
+    });
+
     test("Get Next Patterns", () => {
         const sequence = new And("sequence", [new Literal("a", "A")]);
         const parent = new And("parent", [sequence, new Literal("b", "B")]);
 
-        const sequenceClone = parent.findPattern(p => p.name === "sequence");
+        const sequenceClone = parent.find(p => p.name === "sequence");
         const nextPatterns = sequenceClone?.getNextPatterns() || [];
-        const b = parent.findPattern(p => p.name === "b")
+        const b = parent.find(p => p.name === "b")
 
         expect(nextPatterns[0]).toBe(b);
     });