clarity-pattern-parser 11.3.13 → 11.4.0

package/dist/grammar/Grammar.d.ts

@@ -6,6 +6,7 @@ export interface GrammarFile {
 }
 export interface GrammarOptions {
     resolveImport?: (resource: string, originResource: string | null) => Promise<GrammarFile>;
+    resolveImportSync?: (resource: string, originResource: string | null) => GrammarFile;
     originResource?: string | null;
     params?: Pattern[];
     decorators?: Record<string, Decorator>;
@@ -14,6 +15,7 @@ export declare class Grammar {
     private _params;
     private _originResource?;
     private _resolveImport;
+    private _resolveImportSync;
     private _parseContext;
     constructor(options?: GrammarOptions);
     import(path: string): Promise<Record<string, Pattern>>;
@@ -42,8 +44,10 @@ export declare class Grammar {
     private _saveConfigurableAnonymous;
     private _buildComplexAnonymousPattern;
     private _resolveImports;
-    private processImport;
-    private processUseParams;
+    private _resolveImportsSync;
+    private _processImportSync;
+    private _processImport;
+    private _processUseParams;
     private _applyDecorators;
     private _getParams;
     private _getPattern;

package/dist/index.browser.js

@@ -3503,11 +3503,15 @@
     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) {
@@ -3534,9 +3538,7 @@
         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();
         }
@@ -3843,15 +3845,80 @@
                 });
                 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");
@@ -3904,7 +3971,7 @@
                 }
             });
         }
-        processUseParams(paramName) {
+        _processUseParams(paramName) {
             const defaultValueNode = paramName.find(n => n.name === "param-default");
             if (defaultValueNode === null) {
                 return;