clarity-pattern-parser 11.0.30 → 11.1.0

package/dist/grammar/Grammar.d.ts

@@ -1,4 +1,5 @@
 import { Pattern } from "../patterns/Pattern";
+export type Decorator = (pattern: Pattern, arg?: string | boolean | number | null | Record<string, any> | any[]) => void;
 export interface GrammarFile {
     resource: string;
     expression: string;
@@ -7,6 +8,7 @@ export interface GrammarOptions {
     resolveImport?: (resource: string, originResource: string | null) => Promise<GrammarFile>;
     originResource?: string | null;
     params?: Pattern[];
+    decorators?: Record<string, Decorator>;
 }
 export declare class Grammar {
     private _params;
@@ -38,6 +40,7 @@ export declare class Grammar {
     private _saveConfigurableAnonymous;
     private _buildComplexAnonymousPattern;
     private _resolveImports;
+    private _applyDecorators;
     private _getParams;
     private _getPattern;
     private _saveAlias;

package/dist/grammar/decorators/tokens.d.ts

@@ -0,0 +1,2 @@
+import { Decorator } from "../Grammar";
+export declare const tokens: Decorator;

package/dist/grammar/patterns/decoratorStatement.d.ts

@@ -0,0 +1,2 @@
+import { Options } from "../../patterns/Options";
+export declare const decoratorStatement: Options;

package/dist/grammar/patterns.d.ts

@@ -1,2 +1,4 @@
 import { Pattern } from "../patterns/Pattern";
+import { GrammarOptions } from "./Grammar";
 export declare function patterns(strings: TemplateStringsArray, ...values: any): Record<string, Pattern>;
+export declare function createPatternsTemplate(options: GrammarOptions): (strings: TemplateStringsArray, ...values: any) => Record<string, Pattern>;

package/dist/index.browser.js

@@ -1945,8 +1945,8 @@
         }
     }
 
-    const literal = new Regex("literal", '"(?:\\\\.|[^"\\\\])*"');
-    literal.setTokens(["[LITERAL]"]);
+    const literal$1 = new Regex("literal", '"(?:\\\\.|[^"\\\\])*"');
+    literal$1.setTokens(["[LITERAL]"]);
 
     const tabs$1 = new Regex("tabs", "\\t+");
     tabs$1.setTokens(["\t"]);
@@ -1965,7 +1965,7 @@
 
     const patternName$3 = name$1.clone("pattern-name");
     const anonymousLiterals = new Options("anonymous-literals", [
-        literal,
+        literal$1,
         regexLiteral,
         patternName$3,
         new Reference("repeat-literal"),
@@ -2086,9 +2086,9 @@
     ]);
 
     const optionalSpaces$3 = new Optional("optional-spaces", spaces$1);
-    const openBracket$1 = new Literal("repeat-open-bracket", "{");
-    const closeBracket$1 = new Literal("repeat-close-bracket", "}");
-    const comma = new Literal("comma", ",");
+    const openBracket$2 = new Literal("repeat-open-bracket", "{");
+    const closeBracket$2 = new Literal("repeat-close-bracket", "}");
+    const comma$1 = 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 min = new Optional("optional-min", integer.clone("min"));
@@ -2096,21 +2096,21 @@
     const trimKeyword = new Literal("trim-keyword", "trim");
     const trimFlag = new Optional("optional-trim-flag", new Sequence("trim-flag", [lineSpaces$1, trimKeyword]));
     const bounds = new Sequence("bounds", [
-        openBracket$1,
+        openBracket$2,
         optionalSpaces$3,
         min,
         optionalSpaces$3,
-        comma,
+        comma$1,
         optionalSpaces$3,
         max,
-        closeBracket$1
+        closeBracket$2
     ]);
     const exactCount = new Sequence("exact-count", [
-        openBracket$1,
+        openBracket$2,
         optionalSpaces$3,
         integer,
         optionalSpaces$3,
-        closeBracket$1,
+        closeBracket$2,
     ]);
     const quantifierShorthand = new Regex("quantifier-shorthand", "\\*|\\+");
     quantifierShorthand.setTokens(["*", "+"]);
@@ -2119,8 +2119,8 @@
         exactCount,
         bounds
     ]);
-    const openParen = new Literal("repeat-open-paren", "(");
-    const closeParen = new Literal("repeat-close-paren", ")");
+    const openParen$1 = new Literal("repeat-open-paren", "(");
+    const closeParen$1 = new Literal("repeat-close-paren", ")");
     const dividerComma = new Regex("divider-comma", "\\s*,\\s*");
     dividerComma.setTokens([", "]);
     const patternName$2 = name$1.clone("pattern-name");
@@ -2129,12 +2129,12 @@
     const repeatDividerSection = new Sequence("repeat-divider-section", [dividerComma, repeatDividerPattern, trimFlag]);
     const repeatOptionalDividerSection = new Optional("repeat-optional-divider-section", repeatDividerSection);
     const repeatLiteral = new Sequence("repeat-literal", [
-        openParen,
+        openParen$1,
         optionalSpaces$3,
         repeatPattern,
         repeatOptionalDividerSection,
         optionalSpaces$3,
-        closeParen,
+        closeParen$1,
         new Sequence("quantifier-section", [quantifier]),
     ]);
 
@@ -2169,7 +2169,7 @@
     const optionalIsOptional = new Optional("optional-flag", new Literal("is-optional", "?"));
     const configurableAnonymousPattern = new Sequence("configurable-anonymous-pattern", [anonymousPattern, optionalIsOptional]);
     const pattern = new Options("pattern", [
-        literal,
+        literal$1,
         regexLiteral,
         repeatLiteral,
         aliasLiteral,
@@ -2178,6 +2178,74 @@
         configurableAnonymousPattern,
     ], true);
 
+    const colon = new Literal("colon", ":");
+    const comma = new Regex("comma", "\\s*,\\s*");
+    const openBracket$1 = new Literal("open-bracket", "{");
+    const closeBracket$1 = new Literal("close-bracket", "}");
+    const openSquareBracket = new Literal("open-square-bracket", "[");
+    const closeSquareBracket = new Literal("close-square-bracket", "]");
+    const optionalAllSpaces = new Optional("optional-all-spaces", allSpaces);
+    const stringLiteral = new Regex("string-literal", '"(?:\\\\.|[^"\\\\])*"');
+    const numberLiteral = new Regex("number-literal", '[+-]?\\d+(\\\\.\\d+)?([eE][+-]?\\d+)?');
+    const nullLiteral = new Literal("null-literal", "null");
+    const trueLiteral = new Literal("true-literal", "true");
+    const falseLiteral = new Literal("false-literal", "false");
+    const booleanLiteral = new Options("", [trueLiteral, falseLiteral]);
+    const objectKey = name$1.clone("object-key");
+    const objectProperty = new Sequence("object-property", [
+        objectKey,
+        optionalAllSpaces,
+        colon,
+        optionalAllSpaces,
+        new Reference("literal"),
+    ]);
+    const objectProperies = new Repeat("object-properties", objectProperty, { divider: comma });
+    const objectLiteral = new Sequence("object-literal", [
+        openBracket$1,
+        optionalAllSpaces,
+        new Optional("optional-object-properties", objectProperies),
+        optionalAllSpaces,
+        closeBracket$1
+    ]);
+    const arrayItems = new Repeat("array-items", new Reference("literal"), { divider: comma });
+    const arrayLiteral = new Sequence("array-literal", [
+        openSquareBracket,
+        optionalAllSpaces,
+        arrayItems,
+        optionalAllSpaces,
+        closeSquareBracket,
+    ]);
+    const literal = new Options("literal", [
+        objectLiteral,
+        arrayLiteral,
+        stringLiteral,
+        booleanLiteral,
+        nullLiteral,
+        numberLiteral,
+    ]);
+    const decoratorPrefix = new Literal("decorator-prefix", "@");
+    const decoratorName = name$1.clone("decorator-name");
+    const openParen = new Literal("open-paren", "(");
+    const closeParen = new Literal("close-paren", ")");
+    const methodDecoration = new Sequence("method-decorator", [
+        decoratorPrefix,
+        decoratorName,
+        optionalAllSpaces,
+        openParen,
+        optionalAllSpaces,
+        new Optional("optional-args", literal),
+        optionalAllSpaces,
+        closeParen
+    ]);
+    const nameDecoration = new Sequence("name-decorator", [
+        decoratorPrefix,
+        decoratorName,
+    ]);
+    const decoratorStatement = new Options("decorator-statement", [
+        methodDecoration,
+        nameDecoration,
+    ]);
+
     const optionalSpaces$2 = new Optional("optional-spaces", spaces$1);
     const assignOperator = new Literal("assign-operator", "=");
     const assignStatement = new Sequence("assign-statement", [
@@ -2188,7 +2256,7 @@
         optionalSpaces$2,
         pattern,
     ]);
-    const statement = new Options("statement", [assignStatement, name$1.clone("export-name")]);
+    const statement = new Options("statement", [decoratorStatement, assignStatement, name$1.clone("export-name")]);
 
     const bodyLineContent = new Options("body-line-content", [
         comment,
@@ -2219,7 +2287,7 @@
     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 resource = literal$1.clone("resource");
     const useParams = new Sequence("import-params", [
         useParamsKeyword,
         optionalLineSpaces$1,
@@ -3178,7 +3246,23 @@
         return suggestions.map(s => s.trim()).filter(s => s.length > 0);
     }
 
+    const tokens = (pattern, arg) => {
+        if (pattern.type === "regex" && Array.isArray(arg)) {
+            const regex = pattern;
+            const tokens = [];
+            arg.forEach(token => {
+                if (typeof token === "string") {
+                    tokens.push(token);
+                }
+            });
+            regex.setTokens(tokens);
+        }
+    };
+
     let anonymousIndexId = 0;
+    const defaultDecorators = {
+        tokens: tokens
+    };
     const patternNodes = {
         "literal": true,
         "regex-literal": true,
@@ -3189,11 +3273,12 @@
         "configurable-anonymous-pattern": true
     };
     class ParseContext {
-        constructor(params) {
+        constructor(params, decorators = {}) {
             this.patternsByName = new Map();
             this.importedPatternsByName = new Map();
             this.paramsByName = new Map();
             params.forEach(p => this.paramsByName.set(p.name, p));
+            this.decorators = Object.assign(Object.assign({}, decorators), defaultDecorators);
         }
     }
     function defaultImportResolver(_path, _basePath) {
@@ -3204,7 +3289,7 @@
             this._params = (options === null || options === void 0 ? void 0 : options.params) == null ? [] : options.params;
             this._originResource = (options === null || options === void 0 ? void 0 : options.originResource) == null ? null : options.originResource;
             this._resolveImport = options.resolveImport == null ? defaultImportResolver : options.resolveImport;
-            this._parseContext = new ParseContext(this._params);
+            this._parseContext = new ParseContext(this._params, options.decorators || {});
         }
         import(path) {
             return __awaiter(this, void 0, void 0, function* () {
@@ -3212,14 +3297,15 @@
                 const grammar = new Grammar({
                     resolveImport: this._resolveImport,
                     originResource: grammarFile.resource,
-                    params: this._params
+                    params: this._params,
+                    decorators: this._parseContext.decorators
                 });
                 return grammar.parse(grammarFile.expression);
             });
         }
         parse(expression) {
             return __awaiter(this, void 0, void 0, function* () {
-                this._parseContext = new ParseContext(this._params);
+                this._parseContext = new ParseContext(this._params, this._parseContext.decorators);
                 const ast = this._tryToParse(expression);
                 yield this._resolveImports(ast);
                 this._buildPatterns(ast);
@@ -3227,7 +3313,7 @@
             });
         }
         parseString(expression) {
-            this._parseContext = new ParseContext(this._params);
+            this._parseContext = new ParseContext(this._params, this._parseContext.decorators);
             const ast = this._tryToParse(expression);
             if (this._hasImports(ast)) {
                 throw new Error("Cannot use imports on parseString, use parse instead.");
@@ -3310,6 +3396,7 @@
             const literalNode = statementNode.find(n => n.name === "literal");
             const name = nameNode.value;
             const literal = this._buildLiteral(name, literalNode);
+            this._applyDecorators(statementNode, literal);
             this._parseContext.patternsByName.set(name, literal);
         }
         _buildLiteral(name, node) {
@@ -3332,6 +3419,7 @@
             const regexNode = statementNode.find(n => n.name === "regex-literal");
             const name = nameNode.value;
             const regex = this._buildRegex(name, regexNode);
+            this._applyDecorators(statementNode, regex);
             this._parseContext.patternsByName.set(name, regex);
         }
         _buildRegex(name, node) {
@@ -3343,6 +3431,7 @@
             const name = nameNode.value;
             const optionsNode = statementNode.find(n => n.name === "options-literal");
             const options = this._buildOptions(name, optionsNode);
+            this._applyDecorators(statementNode, options);
             this._parseContext.patternsByName.set(name, options);
         }
         _buildOptions(name, node) {
@@ -3421,6 +3510,7 @@
             const name = nameNode.value;
             const sequenceNode = statementNode.find(n => n.name === "sequence-literal");
             const sequence = this._buildSequence(name, sequenceNode);
+            this._applyDecorators(statementNode, sequence);
             this._parseContext.patternsByName.set(name, sequence);
         }
         _buildSequence(name, node) {
@@ -3443,6 +3533,7 @@
             const name = nameNode.value;
             const repeatNode = statementNode.find(n => n.name === "repeat-literal");
             const repeat = this._buildRepeat(name, repeatNode);
+            this._applyDecorators(statementNode, repeat);
             this._parseContext.patternsByName.set(name, repeat);
         }
         _buildRepeat(name, repeatNode) {
@@ -3497,6 +3588,7 @@
             const anonymousNode = node.find(n => n.name === "configurable-anonymous-pattern");
             const isOptional = node.children[1] != null;
             const anonymous = isOptional ? new Optional(name, this._buildPattern(anonymousNode.children[0])) : this._buildPattern(anonymousNode.children[0]);
+            this._applyDecorators(node, anonymous);
             this._parseContext.patternsByName.set(name, anonymous);
         }
         _buildComplexAnonymousPattern(node) {
@@ -3515,7 +3607,8 @@
                     const grammar = new Grammar({
                         resolveImport: this._resolveImport,
                         originResource: grammarFile.resource,
-                        params
+                        params,
+                        decorators: this._parseContext.decorators
                     });
                     try {
                         const patterns = yield grammar.parse(grammarFile.expression);
@@ -3558,6 +3651,46 @@
                 }
             });
         }
+        _applyDecorators(statementNode, pattern) {
+            const decorators = this._parseContext.decorators;
+            const bodyLine = statementNode.parent;
+            if (bodyLine == null) {
+                return;
+            }
+            let prevSibling = bodyLine.previousSibling();
+            let decoratorNodes = [];
+            while (prevSibling != null) {
+                if (prevSibling.find(n => n.name === "assign-statement")) {
+                    break;
+                }
+                decoratorNodes.push(prevSibling);
+                prevSibling = prevSibling.previousSibling();
+            }
+            decoratorNodes = decoratorNodes.filter(n => n.find(n => n.name.includes("decorator")) != null);
+            decoratorNodes.forEach((d) => {
+                const nameNode = d.find(n => n.name === "decorator-name");
+                if (nameNode == null || decorators[nameNode.value] == null) {
+                    return;
+                }
+                const nameDocorator = d.find(n => n.name === "name-decorator");
+                if (nameDocorator != null) {
+                    decorators[nameNode.value](pattern);
+                    return;
+                }
+                const methodDecorator = d.find(n => n.name === "method-decorator");
+                if (methodDecorator == null) {
+                    return;
+                }
+                methodDecorator.findAll(n => n.name.includes("space")).forEach(n => n.remove());
+                const argsNode = methodDecorator.children[3];
+                if (argsNode == null || argsNode.name === "close-paren") {
+                    decorators[nameNode.value](pattern);
+                }
+                else {
+                    decorators[nameNode.value](pattern, JSON.parse(argsNode.value));
+                }
+            });
+        }
         _getParams(importStatement) {
             let params = [];
             const paramsStatement = importStatement.find(n => n.name === "with-params-statement");
@@ -3572,7 +3705,8 @@
                     const grammar = new Grammar({
                         params: [...importedValues, ...this._parseContext.paramsByName.values()],
                         originResource: this._originResource,
-                        resolveImport: this._resolveImport
+                        resolveImport: this._resolveImport,
+                        decorators: this._parseContext.decorators
                     });
                     const patterns = grammar.parseString(expression);
                     params = Array.from(Object.values(patterns));
@@ -3602,10 +3736,12 @@
             // This solves the problem for an alias pointing to a reference.
             if (aliasPattern.type === "reference") {
                 const reference = new Reference(name, aliasName);
+                this._applyDecorators(statementNode, reference);
                 this._parseContext.patternsByName.set(name, reference);
             }
             else {
                 const alias = aliasPattern.clone(name);
+                this._applyDecorators(statementNode, alias);
                 this._parseContext.patternsByName.set(name, alias);
             }
         }