clarity-pattern-parser 8.2.1 → 8.3.0

package/dist/index.esm.js

@@ -176,6 +176,36 @@ class Node {
     }
 }
 
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
 class ParseError {
     constructor(startIndex, endIndex, pattern) {
         this.startIndex = startIndex;
@@ -970,8 +1000,9 @@ class FiniteRepeat {
             }
         }
         if (matchCount < this._min) {
+            const lastIndex = cursor.index;
             cursor.moveTo(startIndex);
-            cursor.recordErrorAt(startIndex, startIndex, this);
+            cursor.recordErrorAt(startIndex, lastIndex, this);
             return null;
         }
         else if (nodes.length === 0) {
@@ -1088,10 +1119,10 @@ class InfiniteRepeat {
         const divider = options.divider;
         let children;
         if (divider != null) {
-            children = [pattern.clone(), divider.clone(divider.name, false)];
+            children = [pattern.clone(pattern.name, false), divider.clone(divider.name, false)];
         }
         else {
-            children = [pattern.clone()];
+            children = [pattern.clone(pattern.name, false)];
         }
         this._assignChildrenToParent(children);
         this._type = "infinite-repeat";
@@ -1211,6 +1242,10 @@ class InfiniteRepeat {
             const dividerNode = this._nodes.pop();
             cursor.moveTo(dividerNode.firstIndex);
         }
+        // if (this._nodes.length === 0) {
+        //   cursor.moveTo(this._firstIndex);
+        //   return null;
+        // }
         const lastIndex = this._nodes[this._nodes.length - 1].lastIndex;
         cursor.moveTo(lastIndex);
         return new Node(this._type, this._name, this._firstIndex, lastIndex, this._nodes);
@@ -1542,7 +1577,6 @@ class And {
     createNode(cursor) {
         const children = filterOutNull(this._nodes);
         const lastIndex = children[children.length - 1].lastIndex;
-        cursor.getChars(this._firstIndex, lastIndex);
         cursor.moveTo(lastIndex);
         return new Node("and", this._name, this._firstIndex, lastIndex, children);
     }
@@ -1584,9 +1618,6 @@ class And {
         let index = -1;
         for (let i = 0; i < this._children.length; i++) {
             if (this._children[i] === childReference) {
-                if (i + 1 < this._children.length) {
-                    this._children[i + 1];
-                }
                 nextSiblingIndex = i + 1;
                 index = i;
                 break;
@@ -1628,11 +1659,11 @@ class And {
     }
 }
 
-const name = new Regex("name", "[a-zA-Z_-]+[a-zA-Z0-9_-]*");
+const name$1 = new Regex("name", "[a-zA-Z_-]+[a-zA-Z0-9_-]*");
 
 const optionalNot = new Literal("not", "!", true);
 const optionalIsOptional$1 = new Literal("is-optional", "?", true);
-const patternName$1 = name.clone("pattern-name");
+const patternName$1 = name$1.clone("pattern-name");
 const pattern$1 = new And("pattern", [
     optionalNot,
     patternName$1,
@@ -1645,44 +1676,44 @@ const andLiteral = new Repeat("and-literal", pattern$1, { divider: divider$1, mi
 
 const divider = new Regex("or-divider", "\\s*[|]\\s*");
 divider.setTokens([" | "]);
-const orLiteral = new Repeat("or-literal", name.clone("pattern-name"), { divider, min: 2 });
+const orLiteral = new Repeat("or-literal", name$1.clone("pattern-name"), { divider, min: 2 });
 
 const regexLiteral = new Regex("regex-literal", "/(\\\\/|[^/\\n\\r])*/");
 
-const spaces = new Regex("spaces", "[ \\t]+");
-spaces.setTokens([" "]);
+const spaces$1 = new Regex("spaces", "[ \\t]+");
+spaces$1.setTokens([" "]);
 
 const optionalIsOptional = new Literal("is-optional", "?", true);
-const patternName = name.clone("pattern-name");
+const patternName = name$1.clone("pattern-name");
 const pattern = new And("pattern", [
     patternName,
     optionalIsOptional,
 ]);
-const optionalSpaces$1 = spaces.clone("optional-spaces", true);
-const dividerPattern = name.clone("divider-pattern");
-const openBracket = new Literal("open-bracket", "{");
-const closeBracket = new Literal("close-bracket", "}");
+const optionalSpaces$2 = spaces$1.clone("optional-spaces", true);
+const dividerPattern = name$1.clone("divider-pattern");
+const openBracket$1 = new Literal("open-bracket", "{");
+const closeBracket$1 = 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 bounds = new And("bounds", [
-    openBracket,
-    optionalSpaces$1,
+    openBracket$1,
+    optionalSpaces$2,
     optionalInteger.clone("min"),
-    optionalSpaces$1,
+    optionalSpaces$2,
     comma,
-    optionalSpaces$1,
+    optionalSpaces$2,
     optionalInteger.clone("max"),
-    optionalSpaces$1,
-    closeBracket
+    optionalSpaces$2,
+    closeBracket$1
 ]);
 const exactCount = new And("exact-count", [
-    openBracket,
-    optionalSpaces$1,
+    openBracket$1,
+    optionalSpaces$2,
     integer,
-    optionalSpaces$1,
-    closeBracket,
+    optionalSpaces$2,
+    closeBracket$1,
 ]);
 const quantifierShorthand = new Regex("quantifier-shorthand", "\\*|\\+");
 quantifierShorthand.setTokens(["*", "+"]);
@@ -1699,19 +1730,19 @@ const dividerComma = new Regex("divider-comma", "\\s*,\\s*");
 dividerComma.setTokens([", "]);
 const repeatLiteral = new And("repeat-literal", [
     openParen,
-    optionalSpaces$1,
+    optionalSpaces$2,
     pattern,
     optional,
     new And("optional-divider-section", [dividerComma, dividerPattern], true),
-    optionalSpaces$1,
+    optionalSpaces$2,
     closeParen,
-    new And("quantifier-section", [optionalSpaces$1, quantifier]),
-    new And("optional-trim-divider-section", [spaces, trimDivider], true)
+    new And("quantifier-section", [optionalSpaces$2, quantifier]),
+    new And("optional-trim-divider-section", [spaces$1, trimDivider], true)
 ]);
 
 const literal = new Regex("literal", "\"(?:\\\\[\"\\\\]|[^\n\"\\\\])*\"");
 
-const optionalSpaces = spaces.clone("optional-spaces", true);
+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", [
@@ -1720,30 +1751,55 @@ const statements = new Or("statements", [
     orLiteral,
     andLiteral,
     repeatLiteral,
-    name.clone("alias-literal"),
+    name$1.clone("alias-literal"),
 ]);
 const statement = new And("statement", [
-    optionalSpaces,
-    name,
-    optionalSpaces,
+    optionalSpaces$1,
+    name$1,
+    optionalSpaces$1,
     assignOperator,
-    optionalSpaces,
+    optionalSpaces$1,
     statements,
-    optionalSpaces,
+    optionalSpaces$1,
     optionalComment,
+    optionalSpaces$1,
+]);
+
+const spaces = new Regex("spaces", "\\s+", true);
+const importNameDivider = new Regex("import-name-divider", "(\\s+)?,(\\s+)?");
+const importKeyword = new Literal("import", "import");
+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,
+    optionalSpaces,
+    openBracket,
     optionalSpaces,
+    importedNames,
+    optionalSpaces,
+    closeBracket,
+    optionalSpaces,
+    fromKeyword,
+    spaces,
+    literal.clone("url"),
 ]);
 
-const whitespace = new Regex("whitespace", "[ \\t]+");
+const whitespace = new Regex("whitespace", "[ \\t]+((\\r?\\n)+)?");
 const newLine = new Regex("new-line", "(\\r?\\n)+");
 whitespace.setTokens([" "]);
 newLine.setTokens(["\n"]);
 const line = new Or("line", [
+    newLine,
+    whitespace,
     comment,
-    statement,
-    whitespace
-], true);
-const grammar = new Repeat("grammar", line, { divider: newLine });
+    importStatement,
+    statement
+]);
+const grammar = new Repeat("grammer", line);
 
 class Not {
     get type() {
@@ -2040,10 +2096,16 @@ function getFurthestOptions(options) {
 class ParseContext {
     constructor() {
         this.patternsByName = new Map();
+        this.importedPatternsByName = new Map();
     }
 }
+function defaultImportResolver(_path, _basePath) {
+    throw new Error("No import resolver supplied.");
+}
 class Grammar {
-    constructor() {
+    constructor(options = {}) {
+        this._meta = options.meta == null ? null : options.meta;
+        this._resolveImport = options.resolveImport == null ? defaultImportResolver : options.resolveImport;
         this._parseContext = new ParseContext();
         this._autoComplete = new AutoComplete(grammar, {
             greedyPatternNames: ["spaces", "optional-spaces", "whitespace", "new-line"],
@@ -2055,9 +2117,31 @@ class Grammar {
             }
         });
     }
+    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 } });
+            return grammar.parse(grammarFile.expression);
+        });
+    }
     parse(expression) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._parseContext = new ParseContext();
+            const ast = this._tryToParse(expression);
+            yield this._resolveImports(ast);
+            this._buildPatterns(ast);
+            this._cleanAst(ast);
+            return this._parseContext.patternsByName;
+        });
+    }
+    parseString(expression) {
         this._parseContext = new ParseContext();
-        this._tryToParse(expression);
+        const ast = this._tryToParse(expression);
+        if (this._hasImports(ast)) {
+            throw new Error("Cannot use imports on parseString, use parse instead.");
+        }
+        this._buildPatterns(ast);
+        this._cleanAst(ast);
         return this._parseContext.patternsByName;
     }
     _tryToParse(expression) {
@@ -2074,8 +2158,14 @@ class Grammar {
             throw new Error(message);
         }
         // If it is complete it will always have a node. So we have to cast it.
-        this._cleanAst(ast);
-        this._buildPatterns(ast);
+        return ast;
+    }
+    _hasImports(ast) {
+        const importBlock = ast.find(n => n.name === "import-block");
+        if (importBlock == null) {
+            return false;
+        }
+        return importBlock && importBlock.children.length > 0;
     }
     _cleanAst(ast) {
         ast.findAll(n => n.name === "spaces" ||
@@ -2116,6 +2206,36 @@ class Grammar {
             }
         });
     }
+    _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");
+            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 } });
+                try {
+                    const patterns = yield grammar.parse(grammarFile.expression);
+                    const importNames = importStatement.findAll(n => n.name === "import-name").map(n => n.value);
+                    importNames.forEach((importName) => {
+                        if (parseContext.importedPatternsByName.has(importName)) {
+                            throw new Error(`'${importName}' was already used within another import.`);
+                        }
+                        const pattern = patterns.get(importName);
+                        if (pattern == null) {
+                            throw new Error(`Couldn't find pattern with name: ${importName}, from import: ${url}.`);
+                        }
+                        parseContext.importedPatternsByName.set(importName, pattern);
+                    });
+                }
+                catch (e) {
+                    throw new Error(`Failed loading expression from: "${url}". Error details: "${e.message}"`);
+                }
+            }
+        });
+    }
     _buildLiteral(statementNode) {
         const nameNode = statementNode.find(n => n.name === "name");
         const literalNode = statementNode.find(n => n.name === "literal");
@@ -2142,7 +2262,10 @@ class Grammar {
         this._parseContext.patternsByName.set(name, or);
     }
     _getPattern(name) {
-        const pattern = this._parseContext.patternsByName.get(name);
+        let pattern = this._parseContext.patternsByName.get(name);
+        if (pattern == null) {
+            pattern = this._parseContext.importedPatternsByName.get(name);
+        }
         if (pattern == null) {
             return new Reference(name);
         }
@@ -2227,10 +2350,18 @@ class Grammar {
         const alias = pattern.clone(name);
         this._parseContext.patternsByName.set(name, alias);
     }
-    static parse(expression) {
-        const grammar = new Grammar();
+    static parse(expression, options) {
+        const grammar = new Grammar(options);
         return grammar.parse(expression);
     }
+    static import(path, options) {
+        const grammar = new Grammar(options);
+        return grammar.import(path);
+    }
+    static parseString(expression) {
+        const grammar = new Grammar();
+        return grammar.parseString(expression);
+    }
 }
 
 export { And, AutoComplete, Cursor, CursorHistory, Grammar, Literal, Node, Not, Or, ParseError, Reference, Regex, Repeat };