clarity-pattern-parser 8.2.1 → 8.3.1

package/.vscode/settings.json

@@ -1,3 +1,7 @@
 {
-  "typescript.tsdk": "node_modules/typescript/lib"
+  "typescript.tsdk": "node_modules/typescript/lib",
+  "typescript.preferences.importModuleSpecifierEnding": "minimal",
+  "javascript.preferences.importModuleSpecifierEnding": "minimal",
+  "typescript.preferences.importModuleSpecifier": "relative",
+  "javascript.preferences.importModuleSpecifier": "relative"
 }

package/README.md

@@ -129,14 +129,14 @@ ast.toJson(2); // Look Below for output
 ```
 
 ## Or
-The `Or` pattern mathes any of the patterns given to the constructor. 
+The `Or` pattern matches any of the patterns given to the constructor. 
 ```ts
 import { Or, Literal } from "clarity-pattern-parser";
 
 const jane = new Literal("jane", "Jane");
 const john = new Literal("john", "John");
 const firstName = new Or("first-name", [jane, john]);
-const { ast }= firstName.exec("Jane");
+const { ast } = firstName.exec("Jane");
 
 ast.toJson(2)
 ```

package/dist/grammar/Grammar.d.ts

@@ -1,12 +1,29 @@
 import { Pattern } from "../patterns/Pattern";
+export interface GrammarMeta {
+    originPath?: string;
+}
+export interface GrammarFile {
+    path: string;
+    expression: string;
+}
+export interface GrammarOptions {
+    resolveImport?: (path: string, originPath: string | null) => Promise<GrammarFile>;
+    meta?: GrammarMeta | null;
+}
 export declare class Grammar {
+    private _meta;
+    private _resolveImport;
     private _parseContext;
     private _autoComplete;
-    constructor();
-    parse(expression: string): Map<string, Pattern>;
+    constructor(options?: GrammarOptions);
+    import(path: string): Promise<Map<string, Pattern>>;
+    parse(expression: string): Promise<Map<string, Pattern>>;
+    parseString(expression: string): Map<string, Pattern>;
     private _tryToParse;
+    private _hasImports;
     private _cleanAst;
     private _buildPatterns;
+    private _resolveImports;
     private _buildLiteral;
     private _buildRegex;
     private _buildOr;
@@ -14,5 +31,7 @@ export declare class Grammar {
     private _buildAnd;
     private _buildRepeat;
     private _buildAlias;
-    static parse(expression: string): Map<string, Pattern>;
+    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>;
 }

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

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

package/dist/index.browser.js

@@ -182,6 +182,36 @@
         }
     }
 
+    /******************************************************************************
+    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;
@@ -976,8 +1006,9 @@
                 }
             }
             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) {
@@ -1094,10 +1125,10 @@
             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";
@@ -1217,6 +1248,10 @@
                 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);
@@ -1548,7 +1583,6 @@
         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);
         }
@@ -1590,9 +1624,6 @@
             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;
@@ -1634,11 +1665,11 @@
         }
     }
 
-    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,
@@ -1651,44 +1682,44 @@
 
     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(["*", "+"]);
@@ -1705,19 +1736,19 @@
     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", [
@@ -1726,30 +1757,55 @@
         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() {
@@ -2046,10 +2102,16 @@
     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"],
@@ -2061,9 +2123,31 @@
                 }
             });
         }
+        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) {
@@ -2080,8 +2164,14 @@
                 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" ||
@@ -2122,6 +2212,36 @@
                 }
             });
         }
+        _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");
@@ -2148,7 +2268,10 @@
             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);
             }
@@ -2233,10 +2356,18 @@
             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);
+        }
     }
 
     exports.And = And;
@@ -2252,6 +2383,7 @@
     exports.Reference = Reference;
     exports.Regex = Regex;
     exports.Repeat = Repeat;
+    exports.grammar = grammar;
 
     Object.defineProperty(exports, '__esModule', { value: true });