clarity-pattern-parser 4.0.2 → 5.0.0

package/src/ast/Node.ts

@@ -1,39 +1,187 @@
-export default class Node {
-  public type: string;
-  public name: string;
-  public startIndex: number;
-  public endIndex: number;
-  public children: Node[];
-  public value: string;
+export interface CycleFreeNode {
+  type: string;
+  name: string;
+  firstIndex: number;
+  lastIndex: number;
+  startIndex: number;
+  endIndex: number;
+  value: string;
+  children: CycleFreeNode[];
+}
+
+export class Node {
+  private _type: string;
+  private _name: string;
+  private _firstIndex: number;
+  private _lastIndex: number;
+  private _parent: Node | null;
+  private _children: Node[];
+  private _value: string;
+
+  get type() {
+    return this._type;
+  }
+
+  get name() {
+    return this._name;
+  }
+
+  get firstIndex() {
+    return this._firstIndex;
+  }
+
+  get lastIndex() {
+    return this._lastIndex;
+  }
+
+  get startIndex() {
+    return this._firstIndex;
+  }
+
+  get endIndex() {
+    return this._lastIndex + 1;
+  }
+
+  get parent() {
+    return this._parent;
+  }
+
+  get children(): readonly Node[] {
+    return this._children;
+  }
+
+  get value() {
+    return this.toString();
+  }
 
   constructor(
     type: string,
     name: string,
-    startIndex: number,
-    endIndex: number,
+    firstIndex: number,
+    lastIndex: number,
     children: Node[] = [],
     value: string = ""
   ) {
-    this.type = type;
-    this.name = name;
-    this.startIndex = startIndex;
-    this.endIndex = endIndex;
-    this.children = children;
-    this.value = value;
+    this._type = type;
+    this._name = name;
+    this._firstIndex = firstIndex;
+    this._lastIndex = lastIndex;
+    this._parent = null;
+    this._children = children;
+    this._value = value;
+
+    this._children.forEach(c => c._parent = this)
+  }
+
+  removeChild(node: Node) {
+    const index = this._children.indexOf(node);
+
+    if (index > -1) {
+      this._children.splice(index, 1);
+      node._parent = null;
+    }
+  }
+
+  removeAllChildren() {
+    this._children.forEach(c => c._parent = null);
+    this._children.length = 0;
+  }
+
+  replaceChild(newNode: Node, referenceNode: Node) {
+    const index = this._children.indexOf(referenceNode);
+
+    if (index > -1) {
+      this._children.splice(index, 1, newNode);
+      newNode._parent = this;
+      referenceNode._parent = null;
+    }
+  }
+
+  insertBefore(newNode: Node, referenceNode: Node | null) {
+    newNode._parent = this;
+
+    if (referenceNode == null) {
+      this._children.push(newNode);
+      return;
+    }
+
+    const index = this._children.indexOf(referenceNode);
+
+    if (index > -1) {
+      this._children.splice(index, 0, newNode);
+    }
+  }
+
+  appendChild(newNode: Node) {
+    newNode._parent = this;
+    this._children.push(newNode);
+  }
+
+  spliceChildren(index: number, deleteCount: number, ...items: Node[]) {
+    const removedItems = this._children.splice(index, deleteCount, ...items);
+
+    items.forEach(i => i._parent = this);
+    removedItems.forEach(i => i._parent = null);
+
+    return removedItems;
+  }
+
+  find(isMatch: (node: Node) => boolean): Node | null {
+    return this.findAll(isMatch)[0] || null
+  }
+
+  findAll(isMatch: (node: Node) => boolean): Node[] {
+    const matches: Node[] = [];
+    this.walkUp(n => {
+      if (isMatch(n)) { matches.push(n); }
+    })
+
+    return matches;
+  }
+
+  walkUp(callback: (node: Node) => void) {
+    this.children.forEach(c => c.walkUp(callback))
+    callback(this);
+  }
+
+  walkDown(callback: (node: Node) => void) {
+    callback(this);
+    this.children.forEach(c => c.walkDown(callback))
   }
 
   clone(): Node {
     return new Node(
-      this.type,
-      this.name,
-      this.startIndex,
-      this.endIndex,
-      this.children.map((c) => c.clone()),
-      this.value
+      this._type,
+      this._name,
+      this._firstIndex,
+      this._lastIndex,
+      this._children.map((c) => c.clone()),
+      this._value
     );
   }
 
-  toString() {
-    return this.value;
+  toString(): string {
+    if (this._children.length === 0) {
+      return this._value;
+    }
+
+    return this._children.map(c => c.toString()).join("")
+  }
+
+  toCycleFreeObject(): CycleFreeNode {
+    return {
+      type: this._type,
+      name: this._name,
+      value: this.toString(),
+      firstIndex: this._firstIndex,
+      lastIndex: this._lastIndex,
+      startIndex: this.startIndex,
+      endIndex: this.endIndex,
+      children: this._children.map(c => c.toCycleFreeObject()),
+    }
+  }
+
+  toJson(space?: number): string {
+    return JSON.stringify(this.toCycleFreeObject(), null, space)
   }
 }

package/src/index.ts

@@ -1,18 +1,14 @@
-import Node from "./ast/Node";
-import Cursor from "./Cursor";
-import Regex from "./patterns/Regex";
-import And from "./patterns/And";
-import Literal from "./patterns/Literal";
-import LookAhead from "./patterns/LookAhead";
-import Not from "./patterns/Not";
-import Or from "./patterns/Or";
-import Repeat from "./patterns/Repeat";
-import ParseError from "./patterns/ParseError";
-import Pattern from "./patterns/Pattern";
-import Recursive from "./patterns/Recursive";
-import Reference from "./patterns/Reference";
-import TextSuggester from "./TextSuggester";
-import Visitor from "./ast/Visitor";
+import { Node } from "./ast/Node";
+import { Cursor } from "./patterns/Cursor";
+import { Regex } from "./patterns/Regex";
+import { And } from "./patterns/And";
+import { Literal } from "./patterns/Literal";
+import { Not } from "./patterns/Not";
+import { Or } from "./patterns/Or";
+import { Repeat } from "./patterns/Repeat";
+import { ParseError } from "./patterns/ParseError";
+import { Pattern } from "./patterns/Pattern";
+import { Reference } from "./patterns/Reference";
 
 export {
   Node,
@@ -25,9 +21,5 @@ export {
   Repeat,
   ParseError,
   Pattern,
-  Recursive,
   Reference,
-  TextSuggester,
-  Visitor,
-  LookAhead,
 };

package/src/intellisense/AutoComplete.test.ts

@@ -0,0 +1,72 @@
+import { And } from "../patterns/And";
+import { findPattern } from "../patterns/findPattern";
+import { Literal } from "../patterns/Literal";
+import { Or } from "../patterns/Or";
+import { AutoComplete } from "./AutoComplete";
+
+describe("AutoComplete", () => {
+    test("No Text", () => {
+        const name = new Literal("name", "Name");
+        const autoComplete = new AutoComplete(name);
+        let result = autoComplete.suggest("");
+
+        expect(result.options[0].text).toBe("Name");
+        expect(result.options[0].startIndex).toBe(0);
+        expect(result.nextPattern).toBe(name);
+        expect(result.isComplete).toBeFalsy();
+    });
+
+    test("Full Pattern Match", () => {
+        const john = new Literal("john", "John");
+        const space = new Literal("space", " ");
+        const doe = new Literal("doe", "Doe");
+        const smith = new Literal("smith", "Smith");
+
+        space.enableContextualTokenAggregation();
+
+        const name = new And("name", [john, space, new Or("last-name", [smith, doe])]);
+
+        const autoComplete = new AutoComplete(name);
+        let result = autoComplete.suggest("John");
+
+        expect(result.options.length).toBe(2);
+        expect(result.nextPattern).toBe(findPattern(name, p=>p.name === "space"));
+        expect(result.options[0].text).toBe(" Doe");
+        expect(result.options[0].startIndex).toBe(4);
+        expect(result.options[1].text).toBe(" Smith");
+        expect(result.options[1].startIndex).toBe(4);
+        expect(result.isComplete).toBeFalsy();
+    });
+
+    test("Partial", () => {
+        const name = new Literal("name", "Name");
+        const autoComplete = new AutoComplete(name);
+        let result = autoComplete.suggest("Na");
+
+        expect(result.options[0].text).toBe("me");
+        expect(result.options[0].startIndex).toBe(2);
+        expect(result.nextPattern).toBe(name);
+        expect(result.isComplete).toBeFalsy();
+    });
+
+    test("Partial Match With Bad Characters", () => {
+        const name = new Literal("name", "Name");
+        const autoComplete = new AutoComplete(name);
+        let result = autoComplete.suggest("Ni");
+
+        expect(result.options[0].text).toBe("ame");
+        expect(result.options[0].startIndex).toBe(1);
+        expect(result.nextPattern).toBe(name);
+        expect(result.isComplete).toBeFalsy();
+    });
+
+    test("Complete", () => {
+        const name = new Literal("name", "Name");
+        const autoComplete = new AutoComplete(name);
+        let result = autoComplete.suggest("Name");
+
+        expect(result.options.length).toBe(0);
+        expect(result.nextPattern).toBe(null);
+        expect(result.isComplete).toBeTruthy();
+    });
+});

package/src/intellisense/AutoComplete.ts

@@ -0,0 +1,146 @@
+import { Cursor } from "../patterns/Cursor";
+import { ParseError } from "../patterns/ParseError";
+import { Pattern } from "../patterns/Pattern";
+import { Suggestion } from "./Suggestion";
+import { SuggestionOption } from "./SuggestionOption";
+
+export class AutoComplete {
+  private _pattern: Pattern;
+  private _cursor!: Cursor;
+  private _text: string;
+
+  constructor(pattern: Pattern) {
+    this._pattern = pattern;
+    this._text = "";
+  }
+
+  suggest(text: string): Suggestion {
+    if (text.length === 0) {
+      return {
+        isComplete: false,
+        options: this.createSuggestionsFromRoot(),
+        nextPattern: this._pattern,
+        cursor: null,
+        error: new ParseError(0, this._pattern),
+      }
+    }
+
+    this._text = text;
+    this._cursor = new Cursor(text);
+    this._pattern.parse(this._cursor);
+
+    const leafPattern = this._cursor.leafMatch.pattern;
+    const rootMatch = this._cursor.rootMatch.pattern;
+    const isComplete = this._cursor.isOnLast && rootMatch === this._pattern;
+    const options = this.createSuggestionsFromTokens();
+    const nextPattern = isComplete ? null : leafPattern?.getNextPattern() || this._pattern;
+
+    return {
+      isComplete: isComplete,
+      options: options,
+      nextPattern,
+      cursor: this._cursor,
+      error: this._cursor.furthestError
+    }
+  }
+
+  private createSuggestionsFromRoot(): SuggestionOption[] {
+    const suggestions: SuggestionOption[] = [];
+    const tokens = this._pattern.getTokens();
+
+    for (const token of tokens) {
+      suggestions.push(this.createSuggestion("", token));
+    }
+
+    return suggestions;
+  }
+
+  private createSuggestionsFromTokens(): SuggestionOption[] {
+    const leafMatch = this._cursor.leafMatch;
+
+    if (!leafMatch.pattern) {
+      return this.createSuggestions(-1, this._pattern.getTokens());
+    }
+
+    const leafPattern = leafMatch.pattern;
+    const parent = leafMatch.pattern.parent;
+
+    if (parent !== null && leafMatch.node != null) {
+      const tokens = parent.getNextTokens(leafPattern);
+      return this.createSuggestions(leafMatch.node.lastIndex, tokens);
+    } else {
+      return [];
+    }
+  }
+
+  private createSuggestions(lastIndex: number, tokens: string[]): SuggestionOption[] {
+    let substring = lastIndex === -1 ? "" : this._cursor.getChars(0, lastIndex);
+    const suggestionStrings: string[] = [];
+    const options: SuggestionOption[] = [];
+
+    for (const token of tokens) {
+      const suggestion = substring + token;
+      const startsWith = suggestion.startsWith(substring);
+      const alreadyExist = suggestionStrings.includes(suggestion);
+      const isSameAsText = suggestion === this._text;
+
+      if (startsWith && !alreadyExist && !isSameAsText) {
+        suggestionStrings.push(suggestion);
+        options.push(this.createSuggestion(this._cursor.text, suggestion));
+      }
+    }
+
+    const reducedOptions = getFurthestOptions(options);
+    reducedOptions.sort((a, b) => a.text.localeCompare(b.text));
+
+    return reducedOptions;
+  }
+
+  private createSuggestion(fullText: string, suggestion: string): SuggestionOption {
+    const furthestMatch = findMatchIndex(suggestion, fullText);
+    const text = suggestion.slice(furthestMatch);
+
+    return {
+      text: text,
+      startIndex: furthestMatch,
+    }
+  }
+}
+
+function findMatchIndex(str1: string, str2: string): number {
+  let matchCount = 0;
+  let minLength = str1.length;
+
+  if (str2.length < minLength) {
+    minLength = str2.length;
+  }
+
+  for (let i = 0; i < minLength; i++) {
+    if (str1[i] === str2[i]) {
+      matchCount++;
+    } else {
+      break;
+    }
+  }
+
+  return matchCount;
+}
+
+function getFurthestOptions(options: SuggestionOption[]): SuggestionOption[] {
+  let furthestOptions: SuggestionOption[] = [];
+  let furthestIndex = -1;
+
+  for (const option of options) {
+    if (option.startIndex > furthestIndex) {
+      furthestIndex = option.startIndex;
+      furthestOptions = [];
+    }
+
+    if (option.startIndex === furthestIndex) {
+      furthestOptions.push(option);
+    }
+  }
+
+  return furthestOptions;
+}
+

package/src/intellisense/Suggestion.ts

@@ -0,0 +1,13 @@
+import { Cursor } from "../patterns/Cursor";
+import { Match } from "../patterns/CursorHistory";
+import { ParseError } from "../patterns/ParseError";
+import { Pattern } from "../patterns/Pattern";
+import { SuggestionOption } from "./SuggestionOption";
+
+export interface Suggestion {
+  isComplete: boolean;
+  options: SuggestionOption[];
+  nextPattern: Pattern | null;
+  cursor: Cursor | null;
+  error: ParseError | null;
+}

package/src/intellisense/SuggestionOption.ts

@@ -0,0 +1,4 @@
+export interface SuggestionOption {
+  text: string;
+  startIndex: number;
+}

package/src/{tests/cssPatterns → intellisense/css}/cssValue.ts

@@ -1,4 +1,4 @@
-import { Repeat } from "../../index";
+import { Repeat } from "../../patterns/Repeat";
 import divider from "./divider";
 import values from "./values";
 

package/src/{tests/cssPatterns → intellisense/css}/divider.ts

@@ -1,5 +1,6 @@
-import { Regex } from "../../index";
+import { Regex } from "../../patterns/Regex";
 
 const divider = new Regex(",", "\\s*[,]\\s*");
+divider.setTokens([", "]);
 
 export default divider;

package/src/intellisense/css/hex.ts

@@ -0,0 +1,6 @@
+import { Regex } from "../../patterns/Regex";
+
+const hex = new Regex("hex", "#[0-9a-fA-F]{6}|#[0-9a-fA-F]{3}");
+hex.setTokens(["#000", "#FFF"]);
+
+export default hex;

package/src/{tests/cssPatterns → intellisense/css}/method.ts

@@ -1,21 +1,20 @@
-import {
-  Literal,
-  And,
-  Repeat,
-  Recursive,
-} from "../../index";
-
+import { Reference } from "../../patterns/Reference";
+import { Literal } from "../../patterns/Literal";
+import { Repeat } from "../../patterns/Repeat";
+import { And } from "../../patterns/And";
 import name from "./name";
 import optionalSpaces from "./optionalSpaces";
 import divider from "./divider";
 
 const openParen = new Literal("open-paren", "(");
 const closeParen = new Literal("close-paren", ")");
-const values = new Recursive("values");
+const values = new Reference("values");
 const args = new Repeat("arguments", values, divider, true);
+const methodName = name.clone("method-name");
+methodName.setTokens(["rgba", "radial-gradient", "linear-gradient"]);
 
 const method = new And("method", [
-  name.clone("[Method Name]"),
+  methodName,
   openParen,
   optionalSpaces,
   args,

package/src/intellisense/css/name.ts

@@ -0,0 +1,5 @@
+import { Regex } from "../../patterns/Regex";
+
+const name = new Regex("name", "[a-zA-Z]+[a-zA-Z0-9_-]+");
+
+export default name;

package/src/{tests/javascriptPatterns → intellisense/css}/number.ts

@@ -1,10 +1,10 @@
-import {
-  Regex
-} from "../../index";
+import { Regex } from "../../patterns/Regex";
 
 const number = new Regex(
   "number",
   "[-+]?[0-9]*[.]?[0-9]+([eE][-+]?[0-9]+)?"
 );
 
+number.setTokens(["0"]);
+
 export default number;

package/src/intellisense/css/spaces.ts

@@ -0,0 +1,6 @@
+import { Regex } from "../../patterns/Regex";
+
+const spaces = new Regex("spaces", "\\s+");
+spaces.setTokens([" "])
+
+export default spaces;

package/src/intellisense/css/unit.ts

@@ -0,0 +1,10 @@
+import { And } from "../../patterns/And";
+import { Regex } from "../../patterns/Regex";
+import number from "./number";
+
+const unitType = new Regex("unit-type", "[a-zA-Z%]+");
+unitType.setTokens(["px", "%", "em", "rem", "vh", "vw"]);
+
+const unit = new And("unit", [number, unitType]);
+
+export default unit;

package/src/{tests/cssPatterns → intellisense/css}/value.ts

@@ -1,9 +1,9 @@
-import { Or } from "../../index";
 import unit from "./unit";
 import hex from "./hex";
 import number from "./number";
 import method from "./method";
 import name from "./name"
+import { Or } from "../../patterns/Or";
 
 const value = new Or("value", [hex, method, unit, number, name]);
 

package/src/{tests/cssPatterns → intellisense/css}/values.ts

@@ -1,4 +1,4 @@
-import { Repeat } from "../../index";
+import { Repeat } from "../../patterns/Repeat";
 import value from "./value";
 import spaces from "./spaces";