clarity-pattern-parser 11.3.10 → 11.3.12

package/src/intellisense/AutoComplete.ts

@@ -3,7 +3,8 @@ import { Match } from "../patterns/CursorHistory";
 import { ParseError } from "../patterns/ParseError";
 import { Pattern } from "../patterns/Pattern";
 import { Suggestion } from "./Suggestion";
-import { SuggestionOption } from "./SuggestionOption";
+import { SuggestionSegment, SuggestionOption, CompositeSuggestion } from "./SuggestionOption";
+
 
 export interface AutoCompleteOptions {
   /**
@@ -17,6 +18,12 @@ export interface AutoCompleteOptions {
    * and the string array are the tokens suggested for that pattern.
    */
   customTokens?: Record<string, string[]>;
+  /**
+   * Suggestions may share the same text but differ in their suggestionSequence. 
+   * By default, duplicates are removed and only the first instance is kept. 
+   * Disabling deduplication allows all distinct instances to be returned together.
+   */
+  disableDedupe?: boolean;
 }
 
 const defaultOptions = { greedyPatternNames: [], customTokens: {} };
@@ -33,6 +40,10 @@ export class AutoComplete {
     this._text = "";
   }
 
+  suggestFor(text: string): Suggestion {
+    return this.suggestForWithCursor(new Cursor(text));
+  }
+
   suggestForWithCursor(cursor: Cursor): Suggestion {
     cursor.moveTo(0);
 
@@ -41,14 +52,17 @@ export class AutoComplete {
     this._cursor.startRecording();
 
     if (cursor.length === 0) {
-      return {
+
+      const suggestion: Suggestion = {
         isComplete: false,
-        options: this._createSuggestionsFromRoot(),
+        options: this._createSuggestionOptionsFromMatch(),
         error: new ParseError(0, 0, this._pattern),
         errorAtIndex: 0,
         cursor,
         ast: null
-      };
+      }
+
+      return suggestion;
     }
 
     let errorAtIndex = null;
@@ -56,7 +70,7 @@ export class AutoComplete {
 
     const ast = this._pattern.parse(this._cursor);
     const isComplete = ast?.value === this._text;
-    const options = this._getAllOptions();
+    const options = this._getAllSuggestionsOptions();
 
     if (!isComplete && options.length > 0 && !this._cursor.hasError) {
       const startIndex = options.reduce((lowestIndex, o) => {
@@ -111,161 +125,269 @@ export class AutoComplete {
     return 0;
   }
 
-  suggestFor(text: string): Suggestion {
-    return this.suggestForWithCursor(new Cursor(text));
-  }
 
-  private _getAllOptions() {
-    const errorMatches = this._getOptionsFromErrors();
-    const leafMatches = this._cursor.leafMatches.map((m) => this._createSuggestionsFromMatch(m)).flat();
-    const finalResults: SuggestionOption[] = [];
 
-    [...leafMatches, ...errorMatches].forEach(m => {
+  private _getAllSuggestionsOptions() {
+
+    const errorMatchOptions = this._createSuggestionOptionsFromErrors();
+    const leafMatchOptions = this._cursor.leafMatches.map((m) => this._createSuggestionOptionsFromMatch(m)).flat();
+    
+    const finalResults: SuggestionOption[] = [];
+    [...leafMatchOptions, ...errorMatchOptions].forEach(m => {
       const index = finalResults.findIndex(f => m.text === f.text);
       if (index === -1) {
         finalResults.push(m);
       }
     });
 
-    return finalResults;
+    return getFurthestOptions(finalResults);
   }
 
-  private _getOptionsFromErrors() {
+  private _createSuggestionOptionsFromErrors() {
     // These errored because the length of the string.
     const errors = this._cursor.errors.filter(e => e.lastIndex === this._cursor.length);
-    const suggestions = errors.map(e => {
-      const tokens = this._getTokensForPattern(e.pattern);
-      const adjustedTokens: Set<string> = new Set();
-      const currentText = this._cursor.getChars(e.startIndex, e.lastIndex);
-
-      tokens.forEach((token)=>{
-        if (token.startsWith(currentText) && token.length > currentText.length){
-          const difference = token.length - currentText.length;
-          const suggestedText = token.slice(-difference);
-          adjustedTokens.add(suggestedText);
-        }
-      });
+    
+    const errorSuggestionOptions = errors.map(parseError => {
 
-      return Array.from(adjustedTokens).map(t=>{
-        return {
-          text: t,
-          startIndex: e.lastIndex,
-        }
-      });
-    });
+      const currentText = this._cursor.getChars(parseError.startIndex, parseError.lastIndex);
+    
+      const compositeSuggestions = this._getCompositeSuggestionsForPattern(parseError.pattern);
+      const trimmedErrorCompositeSuggestions = this._trimSuggestionsByExistingText(currentText, compositeSuggestions);
+  
+      return this._createSuggestions(parseError.lastIndex, trimmedErrorCompositeSuggestions);
+    }).flat();
+
+    const dedupedErrorSuggestionOptions = this._deDupeCompositeSuggestions(errorSuggestionOptions);
 
-    return suggestions.flat();
+    return dedupedErrorSuggestionOptions
   }
 
-  private _createSuggestionsFromRoot(): SuggestionOption[] {
-    const suggestions: SuggestionOption[] = [];
-    const tokens = [...this._pattern.getTokens(),... this._getTokensForPattern(this._pattern)];
 
-    for (const token of tokens) {
-      if (suggestions.findIndex(s => s.text === token) === -1) {
-        suggestions.push(this._createSuggestion("", token));
-      }
+  private _createSuggestionOptionsFromMatch(match?: Match): SuggestionOption[] {
+
+    if (match?.pattern == null) {
+      const compositeSuggestions = this._getCompositeSuggestionsForPattern(this._pattern);
+      return this._createSuggestions(-1, compositeSuggestions);
     }
 
-    return suggestions;
-  }
+    if ( match?.node != null) {
+      const currentText = this._text.slice(match.node.startIndex,match.node.endIndex)
+      
+      
+      /**Captures suggestions for a "completed" match pattern that still has existing possible suggestions.
+       * particularly relevant when working with set/custom tokens.
+      */
+      const matchCompositeSuggestions = this._getCompositeSuggestionsForPattern(match.pattern)
+      const trimmedMatchCompositeSuggestions =  this._trimSuggestionsByExistingText(currentText, matchCompositeSuggestions) 
 
-  private _createSuggestionsFromMatch(match: Match): SuggestionOption[] {
-    if (match.pattern == null) {
-      return this._createSuggestions(-1, this._getTokensForPattern(this._pattern));
-    }
+      
+      const leafPatterns = match.pattern.getNextPatterns();
+      const leafCompositeSuggestions = leafPatterns.flatMap(leafPattern => 
+      this._getCompositeSuggestionsForPattern(leafPattern)
+    );
 
-    if ( match.node != null) {
-    const textStartingMatch = this._text.slice(match.node.startIndex,match.node.endIndex)
-    const currentPatternsTokens = this._getTokensForPattern(match.pattern);
-    /**
-     * Compares tokens to current text and extracts remainder tokens
-     * - IE. **currentText:** *abc*, **baseToken:** *abcdef*, **trailingToken:** *def*
-     */
-    const trailingTokens = currentPatternsTokens.reduce<string[]>((acc, token) => {
-      if (token.startsWith(textStartingMatch)) {
-        const sliced = token.slice(textStartingMatch.length);
-        if (sliced !== '') {
-          acc.push(sliced);
-        }
-      }
-      return acc;
-    }, []);
-    
-    const leafPatterns = match.pattern.getNextPatterns();
-    const leafTokens = leafPatterns.reduce((acc: string[], leafPattern) => {
-      acc.push(...this._getTokensForPattern(leafPattern));
-      return acc;
-    }, []);
-
-    const allTokens = [...trailingTokens,...leafTokens]
-      return this._createSuggestions(match.node.lastIndex, allTokens);
+     const allCompositeSuggestions = [...leafCompositeSuggestions,...trimmedMatchCompositeSuggestions,]
+
+     const dedupedCompositeSuggestions = this._deDupeCompositeSuggestions(allCompositeSuggestions);
+
+      return this._createSuggestions(match.node.lastIndex, dedupedCompositeSuggestions);
     } else {
       return [];
     }
   }
 
-  private _getTokensForPattern(pattern: Pattern) {
-    const augmentedTokens = this._getAugmentedTokens(pattern);
+  /**
+   * Compares suggestions with provided text and removes completed sub-sequences and preceding text
+   * - IE. **currentText:** *abc*, **sequence:** *[{ab}{cd}{ef}*
+   *   - refines to {d}{ef}
+   */
+  private _trimSuggestionsByExistingText(currentText: string, compositeSuggestions: CompositeSuggestion[]): CompositeSuggestion[] {
+    
+        const trimmedSuggestions = compositeSuggestions.reduce<CompositeSuggestion[]>((acc, compositeSuggestion) => {
+          if (compositeSuggestion.text.startsWith(currentText)) {
+    
+            const filteredSegments = this._filterCompletedSubSegments(currentText, compositeSuggestion);
+            const slicedSuggestionText = compositeSuggestion.text.slice(currentText.length);
+    
+            if (slicedSuggestionText !== '') {
+              const refinedCompositeSuggestion: CompositeSuggestion = {
+                text: slicedSuggestionText,
+                suggestionSequence: filteredSegments,
+              }
+    
+              acc.push(refinedCompositeSuggestion);
+            }
+          }
+          return acc;
+        }, []);
+
+        return trimmedSuggestions
+  }
+
+    /** Removed segments already accounted for in the existing text.
+   * ie. sequence pattern segments ≈ [{look}, {an example}, {phrase}]
+   * fullText = "look an"
+   * remove {look} segment as its already been completed by the existing text.
+ */
+    private _filterCompletedSubSegments(currentText: string, compositeSuggestion: CompositeSuggestion){
+
+      let elementsToRemove: SuggestionSegment [] = [];
+      let workingText = currentText;
+  
+      compositeSuggestion.suggestionSequence.forEach(segment => {
+        /**sub segment has been completed, remove it from the sequence */
+        if(workingText.startsWith(segment.text)){
+          workingText = workingText.slice(segment.text.length);
+          elementsToRemove.push (segment);
+        }
+      })
+  
+      const filteredSegments = compositeSuggestion.suggestionSequence.filter(segment => !elementsToRemove.includes (segment) );
+  
+      return filteredSegments
+    }
+
+  private _getCompositeSuggestionsForPattern(pattern: Pattern):CompositeSuggestion[] {
+
+    const suggestionsToReturn:CompositeSuggestion[] = [];
+    
+    const leafPatterns = pattern.getPatterns();
+    // for when pattern has no leafPatterns and only returns itself
+    if(leafPatterns.length === 1 && leafPatterns[0].id === pattern.id) { 
+
+      const currentCustomTokens = this._getCustomTokens(pattern);
+      const currentTokens = pattern.getTokens();
+      const allTokens = [...currentCustomTokens, ...currentTokens];
+
+      const leafCompositeSuggestions: CompositeSuggestion[] = allTokens.map(token => {
+
+        const segment:SuggestionSegment = {
+          text: token,
+          pattern: pattern,
+        }
+  
+        const compositeSuggestion:CompositeSuggestion = { 
+          text: token,
+          suggestionSequence: [segment],
+        }
+        return compositeSuggestion;
+      })
+      suggestionsToReturn.push(...leafCompositeSuggestions);
+
+    }else{
+
+      const currentCustomTokens = this._getCustomTokens(pattern);
+
+      const patternsSuggestionList = currentCustomTokens.map(token => {
+        const segment:SuggestionSegment = {
+          text: token,
+          pattern: pattern,
+        }
+
+        const patternSuggestion:CompositeSuggestion = {
+          text: token,
+          suggestionSequence: [segment],
+        }
+        return patternSuggestion;
+      })
+
+      const leafCompositeSuggestions = leafPatterns.map(lp => this._getCompositeSuggestionsForPattern(lp)).flat();
+
+      suggestionsToReturn.push(...patternsSuggestionList, ...leafCompositeSuggestions);
+    }
 
     if (this._options.greedyPatternNames != null && this._options.greedyPatternNames.includes(pattern.name)) {
+
       const nextPatterns = pattern.getNextPatterns();
-      const nextPatternTokens = nextPatterns.reduce((acc: string[], pattern) => {
-        acc.push(...this._getTokensForPattern(pattern));
+
+      const nextPatternedTokensList = nextPatterns.reduce<CompositeSuggestion[]>((acc, pattern) => {
+        const patternedTokensList = this._getCompositeSuggestionsForPattern(pattern);
+        acc.push(...patternedTokensList);
+
         return acc;
       }, []);
-      // using set to prevent duplicates
-      const tokens = new Set<string>();
       
-      for (const token of augmentedTokens) {
-        for (const nextPatternToken of nextPatternTokens) {    
-          tokens.add(token + nextPatternToken);
+      const compositeSuggestionList:CompositeSuggestion[] = [];
+      
+      for (const currentSuggestion of suggestionsToReturn) {
+        for (const nextSuggestionWithSubElements of nextPatternedTokensList) { 
+
+          const augmentedTokenWithPattern:CompositeSuggestion = {
+            text: currentSuggestion.text + nextSuggestionWithSubElements.text,
+            suggestionSequence: [...currentSuggestion.suggestionSequence,...nextSuggestionWithSubElements.suggestionSequence ],
+          }
+
+          compositeSuggestionList.push(augmentedTokenWithPattern);
         }
       }
 
-      return [...tokens]
-        } else {
-      return augmentedTokens;
+      return compositeSuggestionList;
+
+    } else {   
+
+      const dedupedSuggestions = this._deDupeCompositeSuggestions(suggestionsToReturn);
+      return dedupedSuggestions;
     }
   }
 
-  private _getAugmentedTokens(pattern: Pattern) {
-    const customTokensMap: any = this._options.customTokens || {};
-    const leafPatterns = pattern.getPatterns();
+  private _getCustomTokens(pattern: Pattern) {
 
-  /** Using Set to
-   * - prevent duplicates
-   * - prevent mutation of original customTokensMap
-   */
-  const customTokensForPattern = new Set<string>(customTokensMap[pattern.name] ?? []);
+   const customTokensMap: Record<string, string[]> = this._options.customTokens || {};
+   const customTokens = customTokensMap[pattern.name] ?? [];
 
-  for (const lp of leafPatterns) {
-    const augmentedTokens = customTokensMap[lp.name] ?? [];
-    const lpsCombinedTokens = [...lp.getTokens(), ...augmentedTokens];
+   const allTokens = [...customTokens];
 
-  for (const token of lpsCombinedTokens) {    
-    customTokensForPattern.add(token);
+   return allTokens;
   }
+
+
+  
+  private _deDupeCompositeSuggestions<T extends CompositeSuggestion>(suggestions: T[]): T[] {
+
+    if (this._options.disableDedupe) {
+      return suggestions;
+    }
+
+    const seen = new Set<string>();
+    const unique: T[] = [];
+
+    for (const suggestion of suggestions) {
+      // Create a unique key based on text and subElements
+      const subElementsKey = suggestion.suggestionSequence
+        .map(sub => ` ${sub.pattern.name} - ${sub.text}  `)
+        .sort()
+        .join('|');
+
+
+      const key = `${suggestion.text}|${subElementsKey}`;
+
+      if (!seen.has(key)) {
+        seen.add(key);
+        unique.push(suggestion);
+      }
+    }
+
+    return unique;
   }
-    return [...customTokensForPattern];
-  }
 
-  private _createSuggestions(lastIndex: number, tokens: string[]): SuggestionOption[] {
+  private _createSuggestions(lastIndex: number, compositeSuggestionList:CompositeSuggestion[]): SuggestionOption[] {
+
     let textToIndex = lastIndex === -1 ? "" : this._cursor.getChars(0, lastIndex);
     const suggestionStrings: string[] = [];
     const options: SuggestionOption[] = [];
 
-    for (const token of tokens) {
+    for (const compositeSuggestion of compositeSuggestionList) {
       // concatenated for start index identification inside createSuggestion
-      const suggestion = textToIndex + token;
-      const alreadyExist = suggestionStrings.includes(suggestion);
-      const isSameAsText = suggestion === this._text;
+      const existingTextWithSuggestion = textToIndex + compositeSuggestion.text;
 
-      if ( !alreadyExist && !isSameAsText) {
-        suggestionStrings.push(suggestion);
-        const suggestionOption = this._createSuggestion(this._cursor.text, suggestion)
+      const alreadyExist = suggestionStrings.includes(existingTextWithSuggestion);
+      const isSameAsText = existingTextWithSuggestion === this._text;
+
+      // if ( !alreadyExist && !isSameAsText) {
+        suggestionStrings.push(existingTextWithSuggestion);
+        const suggestionOption = this._createSuggestionOption(this._cursor.text, existingTextWithSuggestion, compositeSuggestion.suggestionSequence);
         options.push(suggestionOption);
-      }
+      // }
     }
 
     const reducedOptions = getFurthestOptions(options);
@@ -274,13 +396,14 @@ export class AutoComplete {
     return reducedOptions;
   }
 
-  private _createSuggestion(fullText: string, suggestion: string): SuggestionOption {
+  private _createSuggestionOption(fullText: string, suggestion: string, segments: SuggestionSegment[]): SuggestionOption {
     const furthestMatch = findMatchIndex(suggestion, fullText);
     const text = suggestion.slice(furthestMatch);
 
     const option:SuggestionOption = {
       text: text,
       startIndex: furthestMatch,
+      suggestionSequence: segments,
     };
     return option
   }

package/src/intellisense/SuggestionOption.ts

@@ -1,4 +1,27 @@
-export interface SuggestionOption {
-  text: string;
+import { Pattern } from "../patterns/Pattern";
+
+
+/**
+ * A CompositeSuggestion associated with a index to start at when inserting into existing text.
+ */
+export interface SuggestionOption extends CompositeSuggestion {
   startIndex: number;
 }
+
+
+/** 
+ * Represents a composed suggestion, derived from potential next tokens defined by the pattern, and configured auto complete options
+ * text: represents the full composed text of the suggestion; a concatenated string of relevant suggestion segments.
+ */
+export interface CompositeSuggestion{
+  text: string;
+  suggestionSequence: SuggestionSegment[];
+}
+
+
+/** A segment of a parent composite suggestion and a reference to the pattern that this segment token was derived from. */
+export interface SuggestionSegment {
+  text: string;
+  pattern: Pattern;
+}
+

package/src/intellisense/css/optionalSpaces.ts

@@ -1,5 +1,5 @@
 import spaces from "./spaces";
 
-const optionalSpaces = spaces.clone(spaces.name, true);
+const optionalSpaces = spaces.clone(spaces.name);
 
 export default optionalSpaces;

package/src/intellisense/css/value.ts

@@ -5,6 +5,6 @@ import method from "./method";
 import name from "./name"
 import { Options } from "../../patterns/Options";
 
-const value = new Or("value", [hex, method, unit, number, name]);
+const value = new Options("value", [hex, method, unit, number, name]);
 
 export default value;

package/src/patterns/Expression.ts

@@ -112,7 +112,7 @@ export class Expression implements Pattern {
 
     private _organizePatterns(patterns: Pattern[]) {
         const finalPatterns: Pattern[] = [];
-        patterns.forEach((pattern) => {
+        patterns.forEach((pattern, index) => {
 
             if (this._isAtom(pattern)) {
                 const atom = pattern.clone();
@@ -127,6 +127,7 @@ export class Expression implements Pattern {
 
                 prefix.parent = this;
 
+                this._precedenceMap[name] = index;
                 this._prefixPatterns.push(prefix);
                 this._prefixNames.push(name);
 
@@ -136,6 +137,7 @@ export class Expression implements Pattern {
                 const postfix = this._extractPostfix(pattern);
                 postfix.parent = this;
 
+                this._precedenceMap[name] = index;
                 this._postfixPatterns.push(postfix);
                 this._postfixNames.push(name);
 
@@ -145,7 +147,7 @@ export class Expression implements Pattern {
                 const binary = this._extractBinary(pattern);
                 binary.parent = this;
 
-                this._precedenceMap[name] = this._binaryPatterns.length;
+                this._precedenceMap[name] = index;
                 this._binaryPatterns.push(binary);
                 this._binaryNames.push(name);
 

package/src/patterns/Literal.test.ts

@@ -7,7 +7,7 @@ describe("Literal", () => {
     test("Empty Value", () => {
         expect(() => {
             new Literal("empty", "");
-        }).toThrowError();
+        }).toThrow();
     });
 
     test("Successful Parse", () => {

package/src/patterns/Options.test.ts

@@ -13,7 +13,7 @@ describe("Options", () => {
     test("Empty Options", () => {
         expect(() => {
             new Options("bad", []);
-        }).toThrowError();
+        }).toThrow();
     });
 
     test("One Option Successful", () => {

package/src/patterns/PrecedenceTree.ts

@@ -175,14 +175,38 @@ export class PrecedenceTree {
     private _compileAtomNode() {
         let node = this._atomNode;
 
-        if (this._prefixNode != null && this._atomNode != null) {
-            node = this._prefixNode.findRoot();
-            this._prefixPlaceholder.replaceWith(this._atomNode);
-        }
+        if (this._prefixNode != null && this._postfixNode != null && this._atomNode != null) {
+            let firstNode = this._prefixNode;
+            let secondNode = this._postfixNode;
+            let firstPlaceholder = this._prefixPlaceholder;
+            let secondPlaceholder = this._postfixPlaceholder;
+            const prefixName = this._prefixNode.name;
+            const postfixName = this._postfixNode.name;
+            const prefixPrecedence = this._getPrecedence(prefixName);
+            const postfixPrecedence = this._getPrecedence(postfixName);
+
+            // The Precedence is the index of the patterns, so its lower not higher :\
+            if (prefixPrecedence > postfixPrecedence) {
+                firstNode = this._postfixNode;
+                secondNode = this._prefixNode;
+                firstPlaceholder = this._postfixPlaceholder;
+                secondPlaceholder = this._prefixPlaceholder;
+            }
+
+            node = firstNode.findRoot();
+            firstPlaceholder.replaceWith(this._atomNode);
+            secondPlaceholder.replaceWith(node);
+            node = secondNode;
+        } else {
+            if (this._prefixNode != null && this._atomNode != null) {
+                node = this._prefixNode.findRoot();
+                this._prefixPlaceholder.replaceWith(this._atomNode);
+            }
 
-        if (this._postfixNode != null && node != null) {
-            this._postfixPlaceholder.replaceWith(node);
-            node = this._postfixNode;
+            if (this._postfixNode != null && node != null) {
+                this._postfixPlaceholder.replaceWith(node);
+                node = this._postfixNode;
+            }
         }
 
         this._prefixNode = null;

package/src/patterns/Reference.test.ts

@@ -50,7 +50,7 @@ describe("Reference", () => {
 
         expect(() => {
             ref.parse(new Cursor("text"));
-        }).toThrowError();
+        }).toThrow();
     });
 
     test("Get Tokens", () => {

package/src/patterns/Regex.test.ts

@@ -7,15 +7,15 @@ import { Pattern } from "./Pattern";
 
 describe("Regex", () => {
     test("Empty String", () => {
-        expect(() => new Regex("empty", "")).toThrowError();
+        expect(() => new Regex("empty", "")).toThrow();
     });
 
     test("Starts With ^", () => {
-        expect(() => new Regex("carrot", "^")).toThrowError();
+        expect(() => new Regex("carrot", "^")).toThrow();
     });
 
     test("Ends With $", () => {
-        expect(() => new Regex("money", ".$")).toThrowError();
+        expect(() => new Regex("money", ".$")).toThrow();
     });
 
     test("Successful Parse", () => {

package/src/patterns/Sequence.test.ts

@@ -9,7 +9,7 @@ describe("Sequence", () => {
     test("No Patterns", () => {
         expect(() => {
             new Sequence("empty", []);
-        }).toThrowError();
+        }).toThrow();
     });
 
     test("One Pattern Match Successful", () => {

package/tsconfig.json

@@ -17,5 +17,5 @@
     "strictNullChecks": true
   },
   "exclude": ["node_modules"],
-  "files": ["./src/index.ts"]
+  "include": ["src"]
 }