clarity-pattern-parser 11.3.13 → 11.4.1

package/dist/index.js

@@ -433,7 +433,7 @@ class CursorHistory {
 
 class Cursor {
     get text() {
-        return this._text;
+        return this._chars.join("");
     }
     get isOnFirst() {
         return this._index === 0;
@@ -481,12 +481,12 @@ class Cursor {
         return this._history.error != null;
     }
     get currentChar() {
-        return this._text[this._index];
+        return this._chars[this._index];
     }
     constructor(text) {
-        this._text = text;
+        this._chars = [...text];
         this._index = 0;
-        this._length = [...text].length;
+        this._length = this._chars.length;
         this._history = new CursorHistory();
     }
     hasNext() {
@@ -520,7 +520,7 @@ class Cursor {
         return this._length - 1;
     }
     getChars(first, last) {
-        return this._text.slice(first, last + 1);
+        return this._chars.slice(first, last + 1).join("");
     }
     recordMatch(pattern, node) {
         this._history.recordMatch(pattern, node);
@@ -769,7 +769,9 @@ class Regex {
     }
     processResult(cursor, result) {
         const currentIndex = cursor.index;
-        const newIndex = currentIndex + result[0].length - 1;
+        const match = result[0];
+        const matchLength = [...match].length;
+        const newIndex = currentIndex + matchLength - 1;
         this._node = new Node("regex", this._name, currentIndex, newIndex, undefined, result[0]);
         cursor.moveTo(newIndex);
         cursor.recordMatch(this, this._node);
@@ -3501,11 +3503,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) {
@@ -3532,9 +3538,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();
     }
@@ -3841,15 +3845,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");
@@ -3902,7 +3971,7 @@ class Grammar {
             }
         });
     }
-    processUseParams(paramName) {
+    _processUseParams(paramName) {
         const defaultValueNode = paramName.find(n => n.name === "param-default");
         if (defaultValueNode === null) {
             return;