clarity-pattern-parser 8.4.14 → 9.0.0

package/src/grammar/patterns/import.ts

@@ -1,31 +1,37 @@
-import { And } from "../../patterns/And";
+import { Sequence } from "../../patterns/Sequence";
 import { Repeat } from "../../patterns/Repeat";
 import { Literal } from "../../patterns/Literal";
 import { Regex } from "../../patterns/Regex";
 import { literal } from "./literal";
-import { Or } from "../../patterns/Or";
+import { Options } from "../../patterns/Options";
 import { body } from "./body";
 import { allSpaces, lineSpaces } from "./spaces";
+import { Optional } from "../../patterns/Optional";
 
-const optionalSpaces = allSpaces.clone("optional-spaces", true);
-const optionalLineSpaces = lineSpaces.clone("options-line-spaces", true);
+const optionalSpaces = new Optional("optional-spaces", allSpaces);
+const optionalLineSpaces = new Optional("options-line-spaces", lineSpaces);
 
 const importNameDivider = new Regex("import-name-divider", "(\\s+)?,(\\s+)?");
+importNameDivider.setTokens([", "]);
+
+const name = new Regex("import-name", "[^}\\s,]+");
+name.setTokens(["[IMPORT_NAME]"]);
+
 const importKeyword = new Literal("import", "import");
 const useParamsKeyword = new Literal("use-params", "use params");
 const asKeyword = new Literal("as", "as");
 const fromKeyword = new Literal("from", "from");
 const openBracket = new Literal("open-bracket", "{");
 const closeBracket = new Literal("close-bracket", "}");
-const name = new Regex("import-name", "[^}\\s,]+");
+
 const importNameAlias = name.clone("import-name-alias");
-const importAlias = new And("import-alias", [name, lineSpaces, asKeyword, lineSpaces, importNameAlias]);
-const importedNames = new Repeat("imported-names", new Or("import-names", [importAlias, name]), { divider: importNameDivider });
+const importAlias = new Sequence("import-alias", [name, lineSpaces, asKeyword, lineSpaces, importNameAlias]);
+const importedNames = new Repeat("imported-names", new Options("import-names", [importAlias, name]), { divider: importNameDivider });
 const paramName = name.clone("param-name");
 const paramNames = new Repeat("param-names", paramName, { divider: importNameDivider });
 const resource = literal.clone("resource");
 
-const useParams = new And("import-params", [
+const useParams = new Sequence("import-params", [
     useParamsKeyword,
     optionalLineSpaces,
     openBracket,
@@ -36,7 +42,7 @@ const useParams = new And("import-params", [
 ]);
 
 const withParamsKeyword = new Literal("with-params", "with params");
-const withParamsStatement = new And("with-params-statement", [
+const withParamsStatement = new Optional("optional-with-params-statement", new Sequence("with-params-statement", [
     withParamsKeyword,
     optionalLineSpaces,
     openBracket,
@@ -44,9 +50,9 @@ const withParamsStatement = new And("with-params-statement", [
     body.clone("with-params-body"),
     optionalSpaces,
     closeBracket
-], true);
+]));
 
-const importFromStatement = new And("import-from", [
+const importFromStatement = new Sequence("import-from", [
     importKeyword,
     optionalLineSpaces,
     openBracket,
@@ -62,7 +68,7 @@ const importFromStatement = new And("import-from", [
     withParamsStatement
 ]);
 
-export const importStatement = new Or("import-statement", [
+export const importStatement = new Options("import-statement", [
     useParams,
     importFromStatement
 ]);

package/src/grammar/patterns/literal.ts

@@ -1,5 +1,4 @@
 import { Regex } from "../../patterns/Regex";
 
-export const literal = new Regex("literal", '"((?:\\\\.|[^"\\\\])*)"');
-
-
+export const literal = new Regex("literal", '"(?:\\\\.|[^"\\\\])*"');
+literal.setTokens(["[LITERAL]"]);

package/src/grammar/patterns/literals.ts

@@ -0,0 +1,20 @@
+import { Options } from "../../patterns/Options";
+import { Reference } from "../../patterns/Reference";
+import { literal } from "./literal";
+import { name } from "./name";
+import { regexLiteral } from "./regexLiteral";
+
+const patternName = name.clone("pattern-name");
+
+export const anonymousLiterals = new Options("anonymous-literals", [
+    literal,
+    regexLiteral,
+    patternName,
+    new Reference("repeat-literal"),
+]);
+
+export const anonymousWrappedLiterals = new Options("anonymous-wrapped-literals", [
+    new Reference("options-literal"),
+    new Reference("sequence-literal"),
+    new Reference("complex-anonymous-pattern")
+]);

package/src/grammar/patterns/optionsLiteral.ts

@@ -0,0 +1,19 @@
+import { Repeat } from "../../patterns/Repeat";
+import { Regex } from "../../patterns/Regex";
+import { name } from "./name";
+import { anonymousPattern } from "./anonymousPattern";
+import { Options } from "../../patterns/Options";
+
+const patternName = name.clone("pattern-name");
+patternName.setTokens(["[PATTERN_NAME]"]);
+
+const patterns = new Options("or-patterns", [patternName, anonymousPattern]);
+const defaultDivider = new Regex("default-divider", "\\s*[|]\\s*");
+defaultDivider.setTokens(["|"]);
+
+const greedyDivider = new Regex("greedy-divider", "\\s*[<][|][>]\\s*");
+greedyDivider.setTokens(["<|>"]);
+
+const divider = new Options("options-divider", [defaultDivider, greedyDivider]);
+
+export const optionsLiteral = new Repeat("options-literal", patterns, { divider, min: 2, trimDivider: true });

package/src/grammar/patterns/pattern.ts

@@ -1,13 +1,27 @@
-import { And } from "../../patterns/And";
+import { Options } from "../../patterns/Options";
+import { literal } from "./literal";
+import { regexLiteral } from "./regexLiteral";
+import { repeatLiteral } from "./repeatLiteral";
+import { sequenceLiteral } from "./sequenceLiteral";
+import { optionsLiteral } from "./optionsLiteral";
+import { anonymousPattern } from "./anonymousPattern";
+import { Sequence } from "../../patterns/Sequence";
 import { Literal } from "../../patterns/Literal";
 import { name } from "./name";
+import { Optional } from "../../patterns/Optional";
 
-const optionalNot = new Literal("not", "!", true);
-const optionalIsOptional = new Literal("is-optional", "?", true);
-const patternName = name.clone("pattern-name");
+const aliasLiteral = name.clone("alias-literal");
+aliasLiteral.setTokens(["[ALIAS_LITERAL]"]);
 
-export const pattern = new And("pattern", [
-    optionalNot,
-    patternName,
-    optionalIsOptional,
-]);
+const optionalIsOptional = new Optional("optional-flag", new Literal("is-optional", "?"));
+const configurableAnonymousPattern = new Sequence("configurable-anonymous-pattern", [anonymousPattern, optionalIsOptional]);
+
+export const pattern = new Options("pattern", [
+    literal,
+    regexLiteral,
+    repeatLiteral,
+    aliasLiteral,
+    optionsLiteral,
+    sequenceLiteral,
+    configurableAnonymousPattern,
+],  true);

package/src/grammar/patterns/regexLiteral.ts

@@ -1,4 +1,5 @@
 import { Regex } from "../../patterns/Regex";
 
 export const regexLiteral = new Regex("regex-literal", "/(\\\\/|[^/\\n\\r])*/");
+regexLiteral.setTokens(["[REGEX_EXPRESSION]"]);
 

package/src/grammar/patterns/repeatLiteral.ts

@@ -1,36 +1,37 @@
-import { And } from "../../patterns/And";
+import { Sequence } from "../../patterns/Sequence";
 import { Literal } from "../../patterns/Literal";
-import { Or } from "../../patterns/Or";
+import { Options } from "../../patterns/Options";
 import { Regex } from "../../patterns/Regex";
+import { anonymousPattern } from "./anonymousPattern";
 import { name } from "./name";
-import { spaces } from "./spaces";
-
-const patternName = name.clone("pattern-name");
-
-const optionalSpaces = spaces.clone("optional-spaces", true);
-const dividerPattern = name.clone("divider-pattern");
+import { lineSpaces, spaces } from "./spaces";
+import { Optional } from "../../patterns/Optional";
 
+const optionalSpaces = new Optional("optional-spaces", spaces);
 const openBracket = new Literal("open-bracket", "{");
 const closeBracket = new Literal("close-bracket", "}");
 const comma = new Literal("comma", ",");
+
 const integer = new Regex("integer", "([1-9][0-9]*)|0");
 integer.setTokens(["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]);
 
-const optionalInteger = integer.clone("integer", true)
+const min = new Optional("optional-min", integer.clone("min"));
+const max = new Optional("optional-max", integer.clone("max"));
+const trimKeyword = new Literal("trim-keyword", "trim");
+const trimFlag = new Optional("optional-trim-flag", new Sequence("trim-flag", [lineSpaces, trimKeyword]));
 
-const bounds = new And("bounds", [
+const bounds = new Sequence("bounds", [
     openBracket,
     optionalSpaces,
-    optionalInteger.clone("min"),
+    min,
     optionalSpaces,
     comma,
     optionalSpaces,
-    optionalInteger.clone("max"),
-    optionalSpaces,
+    max,
     closeBracket
 ]);
 
-const exactCount = new And("exact-count", [
+const exactCount = new Sequence("exact-count", [
     openBracket,
     optionalSpaces,
     integer,
@@ -40,27 +41,31 @@ const exactCount = new And("exact-count", [
 
 const quantifierShorthand = new Regex("quantifier-shorthand", "\\*|\\+");
 quantifierShorthand.setTokens(["*", "+"]);
-const quantifier = new Or("quantifier", [
+
+const quantifier = new Options("quantifier", [
     quantifierShorthand,
     exactCount,
     bounds
 ]);
 
-const optional = new Literal("is-optional", "?", true);
-const trimDivider = new Literal("trim-divider", "-t");
-const openParen = new Literal("open-paren", "(");
-const closeParen = new Literal("close-paren", ")");
+const openParen = new Literal("repeat-open-paren", "(");
+const closeParen = new Literal("repeat-close-paren", ")");
 const dividerComma = new Regex("divider-comma", "\\s*,\\s*");
 dividerComma.setTokens([", "]);
 
-export const repeatLiteral = new And("repeat-literal", [
+
+const patternName = name.clone("pattern-name");
+const patterns = new Options("or-patterns", [patternName, anonymousPattern]);
+const dividerPattern = patterns.clone("divider-pattern");
+const dividerSection = new Sequence("divider-section", [dividerComma, dividerPattern, trimFlag]);
+const optionalDividerSection = new Optional("optional-divider-section", dividerSection);
+
+export const repeatLiteral = new Sequence("repeat-literal", [
     openParen,
     optionalSpaces,
-    patternName,
-    optional,
-    new And("optional-divider-section", [dividerComma, dividerPattern], true),
+    patterns,
+    optionalDividerSection,
     optionalSpaces,
     closeParen,
-    new And("quantifier-section", [optionalSpaces, quantifier]),
-    new And("optional-trim-divider-section", [spaces, trimDivider], true)
+    new Sequence("quantifier-section", [quantifier]),
 ]);

package/src/grammar/patterns/sequenceLiteral.ts

@@ -0,0 +1,24 @@
+import { Repeat } from "../../patterns/Repeat";
+import { Regex } from "../../patterns/Regex";
+import { name } from "./name";
+import { anonymousPattern } from "./anonymousPattern";
+import { Options } from "../../patterns/Options";
+import { Sequence } from "../../patterns/Sequence";
+import { Literal } from "../../patterns/Literal";
+import { Optional } from "../../patterns/Optional";
+
+const optionalNot = new Optional("optional-not", new Literal("not", "!"));
+const optionalIsOptional = new Optional("optional-is-optional", new Literal("is-optional", "?"));
+const patternName = name.clone("pattern-name");
+const patterns = new Options("and-patterns", [patternName, anonymousPattern]);
+
+export const pattern = new Sequence("and-child-pattern", [
+    optionalNot,
+    patterns,
+    optionalIsOptional,
+]);
+
+const divider = new Regex("and-divider", "\\s*[+]\\s*");
+divider.setTokens([" + "]);
+
+export const sequenceLiteral = new Repeat("sequence-literal", pattern, { divider, min: 2, trimDivider: true });

package/src/grammar/patterns/spaces.ts

@@ -1,14 +1,16 @@
-import { Or } from "../../patterns/Or";
+import { Options } from "../../patterns/Options";
 import { Regex } from "../../patterns/Regex";
 import { Repeat } from "../../patterns/Repeat";
 
 export const tabs = new Regex("tabs", "\\t+");
-export const spaces = new Regex("spaces", "[ ]+");
-export const newLine = new Regex("new-line", "(\\r?\\n)+");
+tabs.setTokens(["\t"]);
 
+export const spaces = new Regex("spaces", "[ ]+");
 spaces.setTokens([" "]);
-tabs.setTokens(["\t"]);
+
+export const newLine = new Regex("new-line", "(\\r?\\n)+");
 newLine.setTokens(["\n"]);
 
-export const lineSpaces = new Repeat("line-spaces", new Or("line-space", [tabs, spaces]));
-export const allSpaces = new Regex("all-spaces", "\\s+", true);
+export const lineSpaces = new Repeat("line-spaces", new Options("line-space", [tabs, spaces]));
+export const allSpaces = new Regex("all-spaces", "\\s+");
+allSpaces.setTokens([" "]);

package/src/grammar/patterns/statement.ts

@@ -1,33 +1,21 @@
-import { And } from "../../patterns/And";
+import { Sequence } from "../../patterns/Sequence";
 import { Literal } from "../../patterns/Literal";
-import { Or } from "../../patterns/Or";
-import { andLiteral } from "./andLiteral";
+import { Options } from "../../patterns/Options";
 import { name } from "./name";
-import { orLiteral } from "./orLiteral";
-import { regexLiteral } from "./regexLiteral";
-import { repeatLiteral } from "./repeatLiteral";
 import { spaces } from "./spaces";
-import { literal } from "./literal";
+import { pattern } from "./pattern";
+import { Optional } from "../../patterns/Optional";
 
-const optionalSpaces = spaces.clone("optional-spaces", true);
+const optionalSpaces = new Optional("optional-spaces", spaces);
 const assignOperator = new Literal("assign-operator", "=");
 
-const statements = new Or("statements", [
-    literal,
-    regexLiteral,
-    orLiteral,
-    andLiteral,
-    repeatLiteral,
-    name.clone("alias-literal"),
-]);
-
-const assignStatement = new And("assign-statement", [
+const assignStatement = new Sequence("assign-statement", [
     optionalSpaces,
     name,
     optionalSpaces,
     assignOperator,
     optionalSpaces,
-    statements
+    pattern
 ]);
 
-export const statement = new Or("statement", [assignStatement, name.clone("export-name")]);
+export const statement = new Options("statement", [assignStatement, name.clone("export-name")]);

package/src/grammar/patterns.test.ts

@@ -0,0 +1,38 @@
+import { patterns } from "./patterns";
+
+describe("Patterns String Template Literal", ()=>{
+    test("Baseline", ()=>{
+        const {fullName} = patterns`
+        first-name = "John"
+        last-name = "Doe"
+        space = /\\s+/
+        full-name = first-name + space + last-name
+        `;
+
+        const result = fullName.exec("John Doe");
+        expect(result?.ast?.value).toBe("John Doe");
+    });
+
+    test("Simple Markup", ()=>{
+        const {body} = patterns`
+        tag-name = /[a-zA-Z_-]+[a-zA-Z0-9_-]*/
+        space = /\\s+/
+        opening-tag = "<" + tag-name + space? + ">"
+        closing-tag = "</" + tag-name + space? + ">"
+        child = space? + element + space?
+        children = (child)*
+        element = opening-tag + children + closing-tag
+        body = space? + element + space?
+        `;
+
+        debugger;
+        const result = body.exec(`
+        <div>
+            <div></div>
+            <div></div>    
+        </div>
+        `, true);
+        result && result.ast && result.ast.findAll(n=>n.name.includes("space")).forEach(n=>n.remove());
+        expect(result?.ast?.value).toBe("<div><div></div><div></div></div>");
+    });
+});

package/src/grammar/patterns.ts

@@ -0,0 +1,24 @@
+import { Pattern } from "../patterns/Pattern";
+import { Grammar } from "./Grammar";
+
+const kebabRegex = /-([a-z])/g; // Define the regex once
+
+function kebabToCamelCase(str: string) {
+    return str.replace(kebabRegex, (_, char) => char.toUpperCase());
+}
+
+export function patterns(strings: TemplateStringsArray, ...values: any) {
+    const combinedString = strings.reduce(
+        (result, str, i) => result + str + (values[i] || ''),
+        ''
+    );
+
+    const result: Record<string, Pattern> = {};
+    const patterns = Grammar.parseString(combinedString);
+
+    Object.keys(patterns).forEach(k => {
+        result[kebabToCamelCase(k)] = patterns[k];
+    });
+
+    return result;
+}

package/src/grammar/spec.md

@@ -79,7 +79,7 @@ digits = (digit, comma)*
 ```
 digit = /\d/
 comma = ","
-digits = (digit, comma)* -t
+digits = (digit, comma){t}
 ```
 
 This is a useful feature if you don't want the divider to be the last pattern found. Let's look at the example below to understand.
@@ -88,7 +88,7 @@ This is a useful feature if you don't want the divider to be the last pattern fo
 const expression = `
     digit = /\d/
     comma = ","
-    digits = (digit, comma)* -t
+    digits = (digit, comma){t}
 `;
 
 const { digits } = Gammar.parse(expression);
@@ -100,20 +100,12 @@ result = digits.exec("1,2,");
 expect(result.ast).toBeNull();
 ```
 
-### Zero Or More With Optional Repeated Pattern
+### Zero Or More
 
 ```
 digit = /\d/
 comma = ","
-digits = (digit?, comma)*
-```
-
-### One Or More With Optional Repeated Pattern
-
-```
-digit = /\d/
-comma = ","
-digits = (digit?, comma)+
+digits = (digit, comma)*
 ```
 
 ### Upper Limit

package/src/index.ts

@@ -5,10 +5,11 @@ import { SuggestionOption } from "./intellisense/SuggestionOption";
 import { AutoComplete, AutoCompleteOptions } from './intellisense/AutoComplete';
 import { Cursor } from "./patterns/Cursor";
 import { Regex } from "./patterns/Regex";
-import { And } from "./patterns/And";
+import { Sequence } from "./patterns/Sequence";
 import { Literal } from "./patterns/Literal";
 import { Not } from "./patterns/Not";
-import { Or } from "./patterns/Or";
+import { Options } from "./patterns/Options";
+import { Optional } from "./patterns/Optional";
 import { Repeat } from "./patterns/Repeat";
 import { ParseError } from "./patterns/ParseError";
 import { Pattern } from "./patterns/Pattern";
@@ -16,6 +17,8 @@ import { Reference } from "./patterns/Reference";
 import { CursorHistory, Match } from "./patterns/CursorHistory";
 import { ParseResult } from "./patterns/ParseResult";
 import { grammar } from "./grammar/patterns/grammar";
+import { arePatternsEqual } from "./patterns/arePatternsEqual";
+import { patterns } from "./grammar/patterns";
 
 export {
   Node,
@@ -24,18 +27,21 @@ export {
   AutoCompleteOptions,
   Suggestion,
   SuggestionOption,
-  And,
+  Sequence,
   Cursor,
   CursorHistory,
   Match,
   Literal,
   Not,
-  Or,
+  Options,
+  Optional,
   ParseError,
   ParseResult,
   Pattern,
   Reference,
   Regex,
   Repeat,
-  grammar
+  grammar,
+  arePatternsEqual,
+  patterns,
 };