clarity-pattern-parser 8.4.8 → 8.4.10

package/dist/grammar/Grammar.d.ts

@@ -1,17 +1,16 @@
 import { Pattern } from "../patterns/Pattern";
-export interface GrammarMeta {
-    originPath?: string;
-}
 export interface GrammarFile {
-    path: string;
+    resource: string;
     expression: string;
 }
 export interface GrammarOptions {
-    resolveImport?: (path: string, originPath: string | null) => Promise<GrammarFile>;
-    meta?: GrammarMeta | null;
+    resolveImport?: (resource: string, originResource: string | null) => Promise<GrammarFile>;
+    originResource?: string | null;
+    params?: Pattern[];
 }
 export declare class Grammar {
-    private _meta;
+    private _params;
+    private _originResource?;
     private _resolveImport;
     private _parseContext;
     private _autoComplete;
@@ -23,6 +22,7 @@ export declare class Grammar {
     private _hasImports;
     private _buildPatterns;
     private _resolveImports;
+    private _getParams;
     private _buildLiteral;
     private _buildRegex;
     private _buildOr;
@@ -32,5 +32,5 @@ export declare class Grammar {
     private _buildAlias;
     static parse(expression: string, options?: GrammarOptions): Promise<Map<string, Pattern>>;
     static import(path: string, options?: GrammarOptions): Promise<Map<string, Pattern>>;
-    static parseString(expression: string): Map<string, Pattern>;
+    static parseString(expression: string, options?: GrammarOptions): Map<string, Pattern>;
 }

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

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

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

@@ -1,2 +1,2 @@
-import { Repeat } from "../../patterns/Repeat";
-export declare const grammar: Repeat;
+import { And } from "../../patterns/And";
+export declare const grammar: And;

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

@@ -1,2 +1,2 @@
-import { And } from "../../patterns/And";
-export declare const importStatement: And;
+import { Or } from "../../patterns/Or";
+export declare const importStatement: Or;

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

@@ -1,2 +1,7 @@
 import { Regex } from "../../patterns/Regex";
+import { Repeat } from "../../patterns/Repeat";
+export declare const tabs: Regex;
 export declare const spaces: Regex;
+export declare const newLine: Regex;
+export declare const lineSpaces: Repeat;
+export declare const allSpaces: Regex;

package/dist/index.browser.js

@@ -1690,6 +1690,17 @@
         }
     }
 
+    const literal = new Regex("literal", "\"(?:\\\\[\"\\\\]|[^\n\"\\\\])*\"");
+
+    const tabs$1 = new Regex("tabs", "\\t+");
+    const spaces$1 = new Regex("spaces", "[ ]+");
+    const newLine$1 = new Regex("new-line", "(\\r?\\n)+");
+    spaces$1.setTokens([" "]);
+    tabs$1.setTokens(["\t"]);
+    newLine$1.setTokens(["\n"]);
+    const lineSpaces$1 = new Repeat("line-spaces", new Or("line-space", [tabs$1, spaces$1]));
+    const allSpaces = new Regex("all-spaces", "\\s+", true);
+
     const name$1 = new Regex("name", "[a-zA-Z_-]+[a-zA-Z0-9_-]*");
 
     const optionalNot = new Literal("not", "!", true);
@@ -1703,17 +1714,14 @@
 
     const divider$1 = new Regex("and-divider", "\\s*[&]\\s*");
     divider$1.setTokens([" & "]);
-    const andLiteral = new Repeat("and-literal", pattern, { divider: divider$1, min: 2 });
+    const andLiteral = new Repeat("and-literal", pattern, { divider: divider$1, min: 2, trimDivider: true });
 
     const divider = new Regex("or-divider", "\\s*[|]\\s*");
     divider.setTokens([" | "]);
-    const orLiteral = new Repeat("or-literal", name$1.clone("pattern-name"), { divider, min: 2 });
+    const orLiteral = new Repeat("or-literal", name$1.clone("pattern-name"), { divider, min: 2, trimDivider: true });
 
     const regexLiteral = new Regex("regex-literal", "/(\\\\/|[^/\\n\\r])*/");
 
-    const spaces$1 = new Regex("spaces", "[ \\t]+");
-    spaces$1.setTokens([" "]);
-
     const patternName = name$1.clone("pattern-name");
     const optionalSpaces$2 = spaces$1.clone("optional-spaces", true);
     const dividerPattern = name$1.clone("divider-pattern");
@@ -1766,11 +1774,8 @@
         new And("optional-trim-divider-section", [spaces$1, trimDivider], true)
     ]);
 
-    const literal = new Regex("literal", "\"(?:\\\\[\"\\\\]|[^\n\"\\\\])*\"");
-
     const optionalSpaces$1 = spaces$1.clone("optional-spaces", true);
     const assignOperator = new Literal("assign-operator", "=");
-    const optionalComment = comment.clone("inline-comment", true);
     const statements = new Or("statements", [
         literal,
         regexLiteral,
@@ -1785,47 +1790,96 @@
         optionalSpaces$1,
         assignOperator,
         optionalSpaces$1,
-        statements,
-        optionalSpaces$1,
-        optionalComment,
-        optionalSpaces$1,
+        statements
     ]);
 
-    const spaces = new Regex("spaces", "\\s+", true);
+    const bodyLineContent = new Or("body-line-content", [
+        comment,
+        statement
+    ]);
+    const bodyLine = new And("body-line", [
+        lineSpaces$1.clone("line-spaces", true),
+        bodyLineContent,
+        lineSpaces$1.clone("line-spaces", true),
+    ]);
+    const body = new Repeat("body", bodyLine, { divider: newLine$1, min: 0 });
+
     const importNameDivider = new Regex("import-name-divider", "(\\s+)?,(\\s+)?");
     const importKeyword = new Literal("import", "import");
+    const useParamsKeyword = new Literal("use-params", "use params");
     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 importedNames = new Repeat("imported-names", name, { divider: importNameDivider });
-    const optionalSpaces = spaces.clone("optional-spaces", true);
-    const importStatement = new And("import-statement", [
-        importKeyword,
+    const paramName = name.clone("param-name");
+    const paramNames = new Repeat("param-names", paramName, { divider: importNameDivider });
+    const optionalSpaces = allSpaces.clone("optional-spaces", true);
+    const optionalLineSpaces = lineSpaces$1.clone("options-line-spaces", true);
+    const resource = literal.clone("resource");
+    const useParams = new And("import-params", [
+        useParamsKeyword,
+        optionalLineSpaces,
+        openBracket,
+        optionalSpaces,
+        paramNames,
         optionalSpaces,
+        closeBracket
+    ]);
+    const withParamsKeyword = new Literal("with-params", "with params");
+    const withParamsStatement = new And("with-params-statement", [
+        withParamsKeyword,
+        optionalLineSpaces,
+        openBracket,
+        optionalSpaces,
+        body,
+        optionalSpaces,
+        closeBracket
+    ], true);
+    const importFromStatement = new And("import-from", [
+        importKeyword,
+        optionalLineSpaces,
         openBracket,
         optionalSpaces,
         importedNames,
         optionalSpaces,
         closeBracket,
-        optionalSpaces,
+        optionalLineSpaces,
         fromKeyword,
-        spaces,
-        literal.clone("url"),
+        optionalLineSpaces,
+        resource,
+        optionalLineSpaces,
+        withParamsStatement
+    ]);
+    const importStatement = new Or("import-statement", [
+        useParams,
+        importFromStatement
     ]);
 
-    const whitespace = new Regex("whitespace", "[ \\t]+((\\r?\\n)+)?");
+    const tabs = new Regex("tabs", "\\t+");
+    const spaces = new Regex("spaces", "[ ]+");
     const newLine = new Regex("new-line", "(\\r?\\n)+");
-    whitespace.setTokens([" "]);
+    spaces.setTokens([" "]);
+    tabs.setTokens(["\t"]);
     newLine.setTokens(["\n"]);
-    const line = new Or("line", [
-        newLine,
-        whitespace,
+    const lineSpaces = new Repeat("line-spaces", new Or("line-space", [tabs, spaces]));
+    const headLineContent = new Or("head-line-content", [
         comment,
-        importStatement,
-        statement
+        importStatement
+    ]);
+    const headLine = new And("head-line-content", [
+        lineSpaces.clone("line-spaces", true),
+        headLineContent,
+        lineSpaces.clone("line-spaces", true),
+    ]);
+    const head = new Repeat("head", headLine, { divider: newLine, min: 0 });
+    const grammar = new And("grammar", [
+        allSpaces,
+        head,
+        allSpaces,
+        body,
+        allSpaces
     ]);
-    const grammar = new Repeat("grammer", line);
 
     class Not {
         get type() {
@@ -2128,9 +2182,11 @@
     }
 
     class ParseContext {
-        constructor() {
+        constructor(params) {
             this.patternsByName = new Map();
             this.importedPatternsByName = new Map();
+            this.paramsByName = new Map();
+            params.forEach(p => this.paramsByName.set(p.name, p));
         }
     }
     function defaultImportResolver(_path, _basePath) {
@@ -2138,9 +2194,10 @@
     }
     class Grammar {
         constructor(options = {}) {
-            this._meta = options.meta == null ? null : options.meta;
+            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._parseContext = new ParseContext(this._params);
             this._autoComplete = new AutoComplete(grammar, {
                 greedyPatternNames: ["spaces", "optional-spaces", "whitespace", "new-line"],
                 customTokens: {
@@ -2154,13 +2211,17 @@
         import(path) {
             return __awaiter(this, void 0, void 0, function* () {
                 const grammarFile = yield this._resolveImport(path, null);
-                const grammar = new Grammar({ resolveImport: this._resolveImport, meta: { originPath: grammarFile.path } });
+                const grammar = new Grammar({
+                    resolveImport: this._resolveImport,
+                    originResource: grammarFile.resource,
+                    params: this._params
+                });
                 return grammar.parse(grammarFile.expression);
             });
         }
         parse(expression) {
             return __awaiter(this, void 0, void 0, function* () {
-                this._parseContext = new ParseContext();
+                this._parseContext = new ParseContext(this._params);
                 const ast = this._tryToParse(expression);
                 yield this._resolveImports(ast);
                 this._buildPatterns(ast);
@@ -2168,7 +2229,7 @@
             });
         }
         parseString(expression) {
-            this._parseContext = new ParseContext();
+            this._parseContext = new ParseContext(this._params);
             const ast = this._tryToParse(expression);
             if (this._hasImports(ast)) {
                 throw new Error("Cannot use imports on parseString, use parse instead.");
@@ -2200,7 +2261,7 @@
             return importBlock && importBlock.children.length > 0;
         }
         _buildPatterns(ast) {
-            ast.children.forEach((n) => {
+            ast.findAll(n => n.name === "statement").forEach((n) => {
                 const typeNode = n.find(n => n.name.includes("literal"));
                 const type = (typeNode === null || typeNode === void 0 ? void 0 : typeNode.name) || "unknown";
                 switch (type) {
@@ -2232,15 +2293,19 @@
             });
         }
         _resolveImports(ast) {
-            var _a;
             return __awaiter(this, void 0, void 0, function* () {
                 const parseContext = this._parseContext;
-                const importStatements = ast.findAll(n => n.name === "import-statement");
+                const importStatements = ast.findAll(n => n.name === "import-from");
                 for (const importStatement of importStatements) {
-                    const urlNode = importStatement.find(n => n.name === "url");
-                    const url = urlNode.value.slice(1, -1);
-                    const grammarFile = yield this._resolveImport(url, ((_a = this._meta) === null || _a === void 0 ? void 0 : _a.originPath) || null);
-                    const grammar = new Grammar({ resolveImport: this._resolveImport, meta: { originPath: grammarFile.path } });
+                    const resourceNode = importStatement.find(n => n.name === "resource");
+                    const params = this._getParams(importStatement);
+                    const resource = resourceNode.value.slice(1, -1);
+                    const grammarFile = yield this._resolveImport(resource, this._originResource || null);
+                    const grammar = new Grammar({
+                        resolveImport: this._resolveImport,
+                        originResource: grammarFile.resource,
+                        params
+                    });
                     try {
                         const patterns = yield grammar.parse(grammarFile.expression);
                         const importNames = importStatement.findAll(n => n.name === "import-name").map(n => n.value);
@@ -2250,17 +2315,39 @@
                             }
                             const pattern = patterns.get(importName);
                             if (pattern == null) {
-                                throw new Error(`Couldn't find pattern with name: ${importName}, from import: ${url}.`);
+                                throw new Error(`Couldn't find pattern with name: ${importName}, from import: ${resource}.`);
                             }
                             parseContext.importedPatternsByName.set(importName, pattern);
                         });
                     }
                     catch (e) {
-                        throw new Error(`Failed loading expression from: "${url}". Error details: "${e.message}"`);
+                        throw new Error(`Failed loading expression from: "${resource}". Error details: "${e.message}"`);
                     }
                 }
             });
         }
+        _getParams(importStatement) {
+            let params = [];
+            const paramsStatement = importStatement.find(n => n.name === "with-params-statement");
+            if (paramsStatement != null) {
+                const statements = paramsStatement.find(n => n.name === "body");
+                if (statements != null) {
+                    const expression = statements.toString();
+                    const importedValues = Array.from(this
+                        ._parseContext
+                        .importedPatternsByName
+                        .values());
+                    const grammar = new Grammar({
+                        params: importedValues,
+                        originResource: this._originResource,
+                        resolveImport: this._resolveImport
+                    });
+                    const patterns = grammar.parseString(expression);
+                    params = Array.from(patterns.values());
+                }
+            }
+            return params;
+        }
         _buildLiteral(statementNode) {
             const nameNode = statementNode.find(n => n.name === "name");
             const literalNode = statementNode.find(n => n.name === "literal");
@@ -2291,6 +2378,9 @@
             if (pattern == null) {
                 pattern = this._parseContext.importedPatternsByName.get(name);
             }
+            if (pattern == null) {
+                pattern = this._parseContext.paramsByName.get(name);
+            }
             if (pattern == null) {
                 return new Reference(name);
             }
@@ -2382,8 +2472,8 @@
             const grammar = new Grammar(options);
             return grammar.import(path);
         }
-        static parseString(expression) {
-            const grammar = new Grammar();
+        static parseString(expression, options) {
+            const grammar = new Grammar(options);
             return grammar.parseString(expression);
         }
     }