clarity-pattern-parser 3.0.16 → 4.0.1

package/src/tests/{NodeVisitor.test.ts → Visitor.test.ts}

@@ -1,16 +1,14 @@
 /** @jest-environment node */
-import CompositeNode from "../ast/CompositeNode";
-import Visitor from "../ast/Visitor";
-import ValueNode from "../ast/ValueNode";
+import { Visitor, Node } from "../index";
 import cssValue from "./cssPatterns/cssValue";
 
 function createContext(amount: number = 10) {
-  const grandParent = new CompositeNode("grand-parent", "grand-parent");
-  const parent = new CompositeNode("parent", "parent");
-  const children: ValueNode[] = [];
+  const grandParent = new Node("grand-parent", "grand-parent", 0, 0);
+  const parent = new Node("parent", "parent", 0, 0);
+  const children: Node[] = [];
 
   for (let x = 0; x < amount; x++) {
-    const child = new ValueNode("child", "child", x.toString());
+    const child = new Node("child", "child", 0, 0, [], x.toString());
     children.push(child);
   }
 
@@ -35,7 +33,9 @@ describe("Visitor", () => {
   });
 
   test("remove", () => {
-    const node = cssValue.exec("linear-gradient(to left, #333, #333 50%, #eee 75%, #333 75%), linear-gradient(to bottom, #555, #555 50%, #eee 75%, #555 75%)");
+    const node = cssValue.exec(
+      "linear-gradient(to left, #333, #333 50%, #eee 75%, #333 75%), linear-gradient(to bottom, #555, #555 50%, #eee 75%, #555 75%)"
+    );
 
     if (node != null) {
       const visitor = new Visitor(node);
@@ -59,15 +59,19 @@ describe("Visitor", () => {
       const stringResult = visitor
         .select((n) => n.name === "child")
         .wrap((node) => {
-          const wrapper = new CompositeNode("wrapper", "wrapper");
+          const wrapper = new Node("wrapper", "wrapper", 0, 0);
           wrapper.children.push(node);
           return wrapper;
         });
 
-      let wrappers = Visitor.select(node, (n) => n.type === "wrapper")
-        .selectedNodes;
-      let children = Visitor.select(node, (n) => n.type === "child")
-        .selectedNodes;
+      let wrappers = Visitor.select(
+        node,
+        (n) => n.type === "wrapper"
+      ).selectedNodes;
+      let children = Visitor.select(
+        node,
+        (n) => n.type === "child"
+      ).selectedNodes;
 
       expect(wrappers.length).toBe(10);
       expect(children.length).toBe(10);
@@ -90,13 +94,21 @@ describe("Visitor", () => {
       visitor
         .select((n) => n.type === "child")
         .prepend((n) => {
-          const sibling = new ValueNode("sibling", "sibling", n.value || "");
+          const sibling = new Node(
+            "sibling",
+            "sibling",
+            0,
+            0,
+            [],
+            n.value || ""
+          );
 
           return sibling;
         });
 
-      const siblings = visitor.select((n) => n.type === "sibling")
-        .selectedNodes;
+      const siblings = visitor.select(
+        (n) => n.type === "sibling"
+      ).selectedNodes;
       const parent = visitor.select((n) => n.type === "parent")
         .selectedNodes[0];
 
@@ -174,13 +186,21 @@ describe("Visitor", () => {
       visitor
         .select((n) => n.type === "child")
         .append((n) => {
-          const sibling = new ValueNode("sibling", "sibling", n.value || "");
+          const sibling = new Node(
+            "sibling",
+            "sibling",
+            0,
+            0,
+            [],
+            n.value || ""
+          );
 
           return sibling;
         });
 
-      const siblings = visitor.select((n) => n.type === "sibling")
-        .selectedNodes;
+      const siblings = visitor.select(
+        (n) => n.type === "sibling"
+      ).selectedNodes;
       const parent = visitor.select((n) => n.type === "parent")
         .selectedNodes[0];
 
@@ -288,8 +308,9 @@ describe("Visitor", () => {
 
     if (node != null) {
       const visitor = new Visitor(node);
-      const selected = visitor.selectNode(node).deselectNode(node)
-        .selectedNodes;
+      const selected = visitor
+        .selectNode(node)
+        .deselectNode(node).selectedNodes;
 
       expect(selected.length).toBe(0);
     }

package/src/tests/cssPatterns/cssValue.ts

@@ -1,7 +1,7 @@
-import { RepeatComposite } from "../../index";
+import { Repeat } from "../../index";
 import divider from "./divider";
 import values from "./values";
 
-const cssValue = new RepeatComposite("css-value", values, divider);
+const cssValue = new Repeat("css-value", values, divider);
 
 export default cssValue;

package/src/tests/cssPatterns/divider.ts

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

package/src/tests/cssPatterns/hex.ts

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

package/src/tests/cssPatterns/method.ts

@@ -1,9 +1,8 @@
 import {
   Literal,
-  AndComposite,
-  RepeatComposite,
-  RecursivePattern,
-  OptionalComposite
+  And,
+  Repeat,
+  Recursive,
 } from "../../index";
 
 import name from "./name";
@@ -12,15 +11,14 @@ import divider from "./divider";
 
 const openParen = new Literal("open-paren", "(");
 const closeParen = new Literal("close-paren", ")");
-const values = new RecursivePattern("values");
-const args = new RepeatComposite("arguments", values, divider);
-const optionalArgs = new OptionalComposite(args);
+const values = new Recursive("values");
+const args = new Repeat("arguments", values, divider, true);
 
-const method = new AndComposite("method", [
+const method = new And("method", [
   name.clone("[Method Name]"),
   openParen,
   optionalSpaces,
-  optionalArgs,
+  args,
   optionalSpaces,
   closeParen
 ]);

package/src/tests/cssPatterns/name.ts

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

package/src/tests/cssPatterns/number.ts

@@ -1,6 +1,6 @@
-import { RegexValue } from "../../index";
+import { Regex } from "../../index";
 
-const number = new RegexValue(
+const number = new Regex(
   "[Number]",
   "[-+]?[0-9]*[.]?[0-9]+([eE][-+]?[0-9]+)?"
 );

package/src/tests/cssPatterns/optionalSpaces.ts

@@ -1,6 +1,5 @@
-import { OptionalValue } from "../../index";
 import spaces from "./spaces";
 
-const optionalSpaces = new OptionalValue(spaces);
+const optionalSpaces = spaces.clone(spaces.name, true);
 
 export default optionalSpaces;

package/src/tests/cssPatterns/spaces.ts

@@ -1,5 +1,5 @@
-import { RegexValue } from "../../index";
+import { Regex } from "../../index";
 
-const spaces = new RegexValue(" ", "\\s+");
+const spaces = new Regex(" ", "\\s+");
 
 export default spaces;

package/src/tests/cssPatterns/unit.ts

@@ -1,8 +1,8 @@
-import { AndComposite, RegexValue } from "../../index";
+import { And, Regex } from "../../index";
 
 import number from "./number";
 
-const unitType = new RegexValue("[unit]", "[a-zA-Z%]+");
-const unit = new AndComposite("unit", [number, unitType]);
+const unitType = new Regex("[unit]", "[a-zA-Z%]+");
+const unit = new And("unit", [number, unitType]);
 
 export default unit;

package/src/tests/cssPatterns/value.ts

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

package/src/tests/cssPatterns/values.ts

@@ -1,7 +1,7 @@
-import { RepeatComposite } from "../../index";
+import { Repeat } from "../../index";
 import value from "./value";
 import spaces from "./spaces";
 
-const values = new RepeatComposite("values", value, spaces);
+const values = new Repeat("values", value, spaces);
 
 export default values;

package/src/tests/htmlPatterns/element.ts

@@ -1,64 +1,49 @@
-import {
-  Literal,
-  OptionalValue,
-  AndValue,
-  OrValue,
-  AndComposite,
-  OrComposite,
-  RegexValue,
-  NotValue,
-  RepeatComposite,
-  RecursivePattern,
-  OptionalComposite
-} from "../../index";
+import { Literal, And, Or, Regex, Repeat, Recursive } from "../../index";
 
-const attributeName = new RegexValue(
-  "attribute-name",
-  "[a-zA-Z_:]+[a-zA-Z0-9_]*"
-);
+const attributeName = new Regex("attribute-name", "[a-zA-Z_:]+[a-zA-Z0-9_]*");
 
 const doubleQuote = new Literal("double-quote", '"');
 const greaterThan = new Literal("greater-than", ">");
 const lessThan = new Literal("less-than", "<");
 const forwardSlash = new Literal("forward-slash", "/");
 const equal = new Literal("equal", "=");
-const spaces = new RegexValue(" ", "\\s+");
-const optionalSpaces = new OptionalValue(spaces);
-
-const value = new RegexValue("value", '[^"]+');
+const spaces = new Regex(" ", "\\s+", true);
+const optionalSpaces = spaces.clone("optional-spaces", true);
+const value = new Regex("value", '[^"]+');
 
-export const attribute = new AndComposite("attribute", [
+export const attribute = new And("attribute", [
   attributeName,
   equal,
   doubleQuote,
   value,
-  doubleQuote
+  doubleQuote,
 ]);
-const attributes = new RepeatComposite("attributes", attribute, spaces);
-const optionalAttributes = new OptionalComposite(attributes);
+const optionalAttributes = new Repeat("attributes", attribute, spaces, true);
 
-const elementName = new RegexValue("element-name", "[a-zA-Z]+[a-zA-Z-]*");
-const text = new RegexValue("text", "[^<>]+");
-const recursiveElement = new RecursivePattern("element");
+const elementName = new Regex("element-name", "[a-zA-Z]+[a-zA-Z-]*");
+const text = new Regex("text", "[^<>]+");
+const recursiveElement = new Recursive("element");
 
-const elementContent = new RepeatComposite(
+const elementContent = new Repeat(
   "children",
-  new OrComposite("content", [text, recursiveElement])
+  new Or("content", [text, recursiveElement]),
+  undefined,
+  true
 );
 
-const element = new AndComposite("element", [
+const element = new And("element", [
   lessThan,
   elementName.clone("open-element-name"),
   optionalSpaces,
   optionalAttributes,
   optionalSpaces,
   greaterThan,
-  new OptionalComposite(elementContent),
+  elementContent,
   lessThan,
   forwardSlash,
   elementName.clone("close-element-name"),
   optionalSpaces,
-  greaterThan
+  greaterThan,
 ]);
 
 export default element;

package/src/tests/javascriptPatterns/boolean.ts

@@ -1,9 +1,8 @@
-import Literal from "../../patterns/value/Literal";
-import OrValue from "../../patterns/value/OrValue";
+import {Literal, Or} from "../../index";
 
 const trueLiteral = new Literal("true", "true");
 const falseLiteral = new Literal("false", "false");
-const boolean = new OrValue("boolean", [
+const boolean = new Or("boolean", [
     trueLiteral,
     falseLiteral
 ]);

package/src/tests/javascriptPatterns/json.ts

@@ -1,14 +1,4 @@
-import RecursivePattern from "../../patterns/RecursivePattern";
-import {
-  Literal,
-  AndComposite,
-  RepeatValue,
-  OptionalValue,
-  RepeatComposite,
-  OptionalComposite,
-  OrComposite,
-  AndValue,
-} from "../../index";
+import { Literal, And, Repeat, Or, Recursive } from "../../index";
 
 import string from "./string";
 import number from "./number";
@@ -20,25 +10,25 @@ const openSquareBracket = new Literal("open-square-bracket", "[");
 const closeSquareBracket = new Literal("close-square-bracket", "]");
 const colon = new Literal(":", ":");
 const space = new Literal("space", " ");
-const spaces = new RepeatValue("spaces", space);
-const optionalSpaces = new OptionalValue(spaces);
+const spaces = new Repeat("spaces", space);
+const optionalSpaces = spaces.clone("optional-spaces", true);
 const nullLiteral = new Literal("null", "null");
 const comma = new Literal(",", ",");
 
-const divider = new AndValue("divider", [
+const divider = new And("divider", [
   optionalSpaces,
   comma,
   optionalSpaces,
 ]);
 
-const arrayValues = new RepeatComposite(
+const arrayValues = new Repeat(
   "values",
-  new RecursivePattern("literals"),
+  new Recursive("literals"),
   divider
 );
-const optionalArrayValues = new OptionalComposite(arrayValues);
+const optionalArrayValues = arrayValues.clone("optional-values", true);
 
-const arrayLiteral = new AndComposite("array-literal", [
+const arrayLiteral = new And("array-literal", [
   openSquareBracket,
   optionalSpaces,
   optionalArrayValues,
@@ -46,18 +36,18 @@ const arrayLiteral = new AndComposite("array-literal", [
   closeSquareBracket,
 ]);
 
-const keyValue = new AndComposite("key-value", [
+const keyValue = new And("key-value", [
   string,
   optionalSpaces,
   colon,
   optionalSpaces,
-  new RecursivePattern("literals"),
+  new Recursive("literals"),
 ]);
 
-const keyValues = new RepeatComposite("key-values", keyValue, divider);
-const optionalKeyValues = new OptionalComposite(keyValues);
+const keyValues = new Repeat("key-values", keyValue, divider);
+const optionalKeyValues = keyValues.clone("optional-key-values", true);
 
-const objectLiteral = new AndComposite("object-literal", [
+const objectLiteral = new And("object-literal", [
   openCurlyBracket,
   optionalSpaces,
   optionalKeyValues,
@@ -65,7 +55,7 @@ const objectLiteral = new AndComposite("object-literal", [
   closeCurlyBracket,
 ]);
 
-const json = new OrComposite("literals", [
+const json = new Or("literals", [
   number,
   string,
   boolean,
@@ -75,5 +65,3 @@ const json = new OrComposite("literals", [
 ]);
 
 export default json;
-
-

package/src/tests/javascriptPatterns/name.ts

@@ -1,22 +1,5 @@
-import RegexValue from "../../patterns/value/RegexValue";
+import { Regex } from "../../index";
 
-// const letter = new AnyOfThese("letter", "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
-// const digit = new AnyOfThese("digit", "0987654321");
-// const underbar = new Literal("underbar", "_");
-// const character = new OrValue("character", [
-//     letter,
-//     digit,
-//     underbar
-// ]);
+const name = new Regex("name", "[a-zA-Z]+[a-zA-Z0-9_]*");
 
-// const characterSequence = new RepeatValue("character-sequence", character);
-// const optionalCharacter = new OptionalValue(characterSequence);
-
-// const name = new AndValue("name", [
-//     letter,
-//     optionalCharacter
-// ]);
-
-const name = new RegexValue("name", "[a-zA-Z]+[a-zA-Z0-9_]*");
-
-export default name;
+export default name;

package/src/tests/javascriptPatterns/number.ts

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

package/src/tests/javascriptPatterns/objectLiteral.ts

@@ -1,29 +1,22 @@
-import Literal from "../../patterns/value/Literal";
-import AndComposite from "../../patterns/composite/AndComposite";
-import RepeatComposite from "../../patterns/composite/RepeatComposite";
-import OptionalComposite from "../../patterns/composite/OptionalComposite";
-import OrValue from "../../patterns/value/OrValue";
-import OptionalValue from "../../patterns/value/OptionalValue";
-import RecursivePattern from "../../patterns/RecursivePattern";
+import {Literal, And, Repeat, Or, Recursive} from "../../index";
 import name from "./name";
 import string from "./string";
 import whitespace from "./whitespace";
-import AndValue from "../../patterns/value/AndValue";
 
-const expression = new RecursivePattern("expression");
-const optionalWhitespace = new OptionalValue(whitespace);
+const expression = new Recursive("expression");
+const optionalWhitespace = whitespace.clone("optional-whitespaces", true);
 const comma = new Literal(",", ",");
 const colon = new Literal(":", ":");
 
-const separator = new AndValue("separator", [
+const separator = new And("separator", [
   optionalWhitespace,
   comma,
   optionalWhitespace,
 ]);
 
-const property = new OrValue("property", [name, string]);
+const property = new Or("property", [name, string]);
 
-const keyValue = new AndComposite("key-value", [
+const keyValue = new And("key-value", [
   property,
   optionalWhitespace,
   colon,
@@ -31,12 +24,12 @@ const keyValue = new AndComposite("key-value", [
   expression,
 ]);
 
-const keyValues = new RepeatComposite("key-values", keyValue, separator);
-const optionalKeyValues = new OptionalComposite(keyValues);
+const keyValues = new Repeat("key-values", keyValue, separator);
+const optionalKeyValues = keyValues.clone("optional-key-values", true);
 const openBracket = new Literal("{", "}");
 const closeBracket = new Literal("}", "}");
 
-const objectLiteral = new AndComposite("object-literal", [
+const objectLiteral = new And("object-literal", [
   openBracket,
   optionalWhitespace,
   optionalKeyValues,

package/src/tests/javascriptPatterns/string.ts

@@ -1,30 +1,26 @@
-import Literal from "../../patterns/value/Literal";
-import NotValue from "../../patterns/value/NotValue";
-import OrValue from "../../patterns/value/OrValue";
-import RepeatValue from "../../patterns/value/RepeatValue";
-import AndValue from "../../patterns/value/AndValue";
+import { Literal, Not, Or, Repeat, And, Regex } from "../../index";
 
 const singleQuote = new Literal("single-quote", "'");
 const doubleQuote = new Literal("double-quote", '"');
 const backslash = new Literal("double-quote", "\\");
 
-const singleQuoteOrBackslash = new OrValue("single-quote-or-backslash", [
+const singleQuoteOrBackslash = new Or("single-quote-or-backslash", [
   singleQuote,
-  backslash
+  backslash,
 ]);
 
-const doubleQuoteOrBackslash = new OrValue("single-quote-or-backslash", [
+const doubleQuoteOrBackslash = new Or("single-quote-or-backslash", [
   doubleQuote,
-  backslash
+  backslash,
 ]);
 
-const unescapedSingleCharacter = new NotValue(
+const unescapedSingleCharacter = new Regex(
   "unescaped-single-character",
-  singleQuoteOrBackslash
+  "[^'\\\\]"
 );
-const unescapedDoubleCharacter = new NotValue(
+const unescapedDoubleCharacter = new Regex(
   "unescaped-double-character",
-  doubleQuoteOrBackslash
+  `[^"\\\\]`
 );
 const escapedSingleQuote = new Literal("escaped-single-quote", "\\'");
 const escapedDoubleQuote = new Literal("escaped-double-quote", '\\"');
@@ -36,7 +32,7 @@ const escapedNewLine = new Literal("escaped-new-line", "\\n");
 const escapedCarriageReturn = new Literal("escaped-carriage-return", "\\r");
 const escapedTab = new Literal("escaped-tab", "\\t");
 
-const singleQuoteCharacter = new OrValue("character", [
+const singleQuoteCharacter = new Or("character", [
   escapedSingleQuote,
   escapedDoubleQuote,
   escapedBackslash,
@@ -46,10 +42,10 @@ const singleQuoteCharacter = new OrValue("character", [
   escapedNewLine,
   escapedCarriageReturn,
   escapedTab,
-  unescapedSingleCharacter
+  unescapedSingleCharacter,
 ]);
 
-const doubleQuoteCharacter = new OrValue("character", [
+const doubleQuoteCharacter = new Or("character", [
   escapedSingleQuote,
   escapedDoubleQuote,
   escapedBackslash,
@@ -59,24 +55,30 @@ const doubleQuoteCharacter = new OrValue("character", [
   escapedNewLine,
   escapedCarriageReturn,
   escapedTab,
-  unescapedDoubleCharacter
+  unescapedDoubleCharacter,
 ]);
 
-const singleCharacterSequence = new RepeatValue("string-content", singleQuoteCharacter);
-const doubleCharacterSequence = new RepeatValue("string-content", doubleQuoteCharacter);
+const singleCharacterSequence = new Repeat(
+  "string-content",
+  singleQuoteCharacter
+);
+const doubleCharacterSequence = new Repeat(
+  "string-content",
+  doubleQuoteCharacter
+);
 
-const singleQuoteString = new AndValue("single-quote-string", [
+const singleQuoteString = new And("single-quote-string", [
   singleQuote,
   singleCharacterSequence,
-  singleQuote
+  singleQuote,
 ]);
 
-const doubleQuoteString = new AndValue("double-quote-string", [
+const doubleQuoteString = new And("double-quote-string", [
   doubleQuote,
   doubleCharacterSequence,
-  doubleQuote
+  doubleQuote,
 ]);
 
-const string = new OrValue("string", [singleQuoteString, doubleQuoteString]);
+const string = new Or("string", [singleQuoteString, doubleQuoteString]);
 
 export default string;

package/src/tests/javascriptPatterns/unit.ts

@@ -1,11 +1,8 @@
-import {
-  AndComposite,
-  RegexValue
-} from "../../index";
+import { And, Regex } from "../../index";
 
 import number from "./number";
 
-const unitType = new RegexValue("unit-type","[a-zA-Z]+|%");
-const unit = new AndComposite("unit", [number, unitType]);
+const unitType = new Regex("unit-type", "[a-zA-Z]+|%");
+const unit = new And("unit", [number, unitType]);
 
 export default unit;