clarity-pattern-parser 11.3.12 → 11.4.0

package/dist/index.esm.js

@@ -1653,11 +1653,11 @@ class Repeat {
     parse(cursor) {
         return this._repeatPattern.parse(cursor);
     }
-    exec(text) {
-        return this._repeatPattern.exec(text);
+    exec(text, record = false) {
+        return this._repeatPattern.exec(text, record);
     }
-    test(text) {
-        return this._repeatPattern.test(text);
+    test(text, record = false) {
+        return this._repeatPattern.test(text, record);
     }
     clone(name = this.name) {
         let min = this._options.min;
@@ -3497,11 +3497,15 @@ class ParseContext {
 function defaultImportResolver(_path, _basePath) {
     throw new Error("No import resolver supplied.");
 }
+function defaultImportResolverSync(_path, _basePath) {
+    throw new Error("No import resolver supplied.");
+}
 class Grammar {
     constructor(options = {}) {
         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._resolveImportSync = options.resolveImportSync == null ? defaultImportResolverSync : options.resolveImportSync;
         this._parseContext = new ParseContext(this._params, options.decorators || {});
     }
     import(path) {
@@ -3528,9 +3532,7 @@ class Grammar {
     parseString(expression) {
         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.");
-        }
+        this._resolveImportsSync(ast);
         this._buildPatterns(ast);
         return this._buildPatternRecord();
     }
@@ -3837,15 +3839,80 @@ class Grammar {
             });
             for (const statement of importStatements) {
                 if (statement.name === "import-from") {
-                    yield this.processImport(statement);
+                    yield this._processImport(statement);
                 }
                 else {
-                    this.processUseParams(statement);
+                    this._processUseParams(statement);
                 }
             }
         });
     }
-    processImport(importStatement) {
+    _resolveImportsSync(ast) {
+        const importStatements = ast.findAll(n => {
+            return n.name === "import-from" || n.name === "param-name-with-default-value";
+        });
+        for (const statement of importStatements) {
+            if (statement.name === "import-from") {
+                this._processImportSync(statement);
+            }
+            else {
+                this._processUseParams(statement);
+            }
+        }
+    }
+    _processImportSync(importStatement) {
+        const parseContext = this._parseContext;
+        const resourceNode = importStatement.find(n => n.name === "resource");
+        const params = this._getParams(importStatement);
+        const resource = resourceNode.value.slice(1, -1);
+        const grammarFile = this._resolveImportSync(resource, this._originResource || null);
+        const grammar = new Grammar({
+            resolveImport: this._resolveImport,
+            resolveImportSync: this._resolveImportSync,
+            originResource: grammarFile.resource,
+            params,
+            decorators: this._parseContext.decorators
+        });
+        try {
+            const patterns = grammar.parseString(grammarFile.expression);
+            const importStatements = importStatement.findAll(n => n.name === "import-name" || n.name === "import-alias");
+            importStatements.forEach((node) => {
+                var _a, _b;
+                if (node.name === "import-name" && ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.name) === "import-alias") {
+                    return;
+                }
+                if (node.name === "import-name" && ((_b = node.parent) === null || _b === void 0 ? void 0 : _b.name) !== "import-alias") {
+                    const importName = node.value;
+                    if (parseContext.importedPatternsByName.has(importName)) {
+                        throw new Error(`'${importName}' was already used within another import.`);
+                    }
+                    const pattern = patterns[importName];
+                    if (pattern == null) {
+                        throw new Error(`Couldn't find pattern with name: ${importName}, from import: ${resource}.`);
+                    }
+                    parseContext.importedPatternsByName.set(importName, pattern);
+                }
+                else {
+                    const importNameNode = node.find(n => n.name === "import-name");
+                    const importName = importNameNode.value;
+                    const aliasNode = node.find(n => n.name === "import-name-alias");
+                    const alias = aliasNode.value;
+                    if (parseContext.importedPatternsByName.has(alias)) {
+                        throw new Error(`'${alias}' was already used within another import.`);
+                    }
+                    const pattern = patterns[importName];
+                    if (pattern == null) {
+                        throw new Error(`Couldn't find pattern with name: ${importName}, from import: ${resource}.`);
+                    }
+                    parseContext.importedPatternsByName.set(alias, pattern.clone(alias));
+                }
+            });
+        }
+        catch (e) {
+            throw new Error(`Failed loading expression from: "${resource}". Error details: "${e.message}"`);
+        }
+    }
+    _processImport(importStatement) {
         return __awaiter(this, void 0, void 0, function* () {
             const parseContext = this._parseContext;
             const resourceNode = importStatement.find(n => n.name === "resource");
@@ -3898,7 +3965,7 @@ class Grammar {
             }
         });
     }
-    processUseParams(paramName) {
+    _processUseParams(paramName) {
         const defaultValueNode = paramName.find(n => n.name === "param-default");
         if (defaultValueNode === null) {
             return;