clarity-pattern-parser 11.3.12 → 11.4.0

package/dist/patterns/Repeat.d.ts

@@ -33,8 +33,8 @@ export declare class Repeat implements Pattern {
     get options(): InternalRepeatOptions;
     constructor(name: string, pattern: Pattern, options?: RepeatOptions);
     parse(cursor: Cursor): Node | null;
-    exec(text: string): ParseResult;
-    test(text: string): boolean;
+    exec(text: string, record?: boolean): ParseResult;
+    test(text: string, record?: boolean): boolean;
     clone(name?: string): Repeat;
     getTokens(): string[];
     getTokensAfter(_childReference: Pattern): string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clarity-pattern-parser",
-  "version": "11.3.12",
+  "version": "11.4.0",
   "description": "Parsing Library for Typescript and Javascript.",
   "main": "./dist/index.js",
   "module": "./dist/index.esm.js",

package/src/grammar/Grammar.test.ts

@@ -779,4 +779,42 @@ describe("Grammar", () => {
         expect(result?.value).toBe("function(){}");
     });
 
+    test("Import Sync", () => {
+        function resolveImportSync(path: string, importer: string | null) {
+            return {
+                expression: pathMap[path],
+                resource: path,
+            }
+        }
+        
+        const rootExpression = `
+        import { name } from "first-name.cpat"
+        full-name = name
+        `;
+
+        const firstNameExpression = `
+        import { last-name } from "last-name.cpat"
+        first-name = "John"
+        name = first-name + " " +  last-name
+        `;
+
+        const lastNameExpression = `
+        last-name = "Doe"
+        `;
+
+        const pathMap: Record<string, string> = {
+            "first-name.cpat": firstNameExpression,
+            "last-name.cpat": lastNameExpression,
+        };
+
+        const patterns = Grammar.parseString(rootExpression, {
+            resolveImportSync: resolveImportSync,
+            originResource: "/root.cpat",
+        });
+
+        expect(patterns["full-name"]).not.toBeNull();
+        const result = patterns["full-name"].exec("John Doe");
+        expect(result?.ast?.value).toBe("John Doe");
+    });
+
 });

package/src/grammar/Grammar.ts

@@ -50,6 +50,10 @@ function defaultImportResolver(_path: string, _basePath: string | null): Promise
     throw new Error("No import resolver supplied.");
 }
 
+function defaultImportResolverSync(_path: string, _basePath: string | null): GrammarFile {
+    throw new Error("No import resolver supplied.");
+}
+
 export interface GrammarFile {
     resource: string;
     expression: string;
@@ -57,6 +61,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>;
@@ -66,12 +71,14 @@ export class Grammar {
     private _params: Pattern[];
     private _originResource?: string | null;
     private _resolveImport: (resource: string, originResource: string | null) => Promise<GrammarFile>;
+    private _resolveImportSync: (resource: string, originResource: string | null) => GrammarFile;
     private _parseContext: ParseContext;
 
     constructor(options: GrammarOptions = {}) {
         this._params = options?.params == null ? [] : options.params;
         this._originResource = 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 || {});
     }
 
@@ -101,10 +108,7 @@ export class Grammar {
         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();
@@ -476,14 +480,89 @@ export class Grammar {
 
         for (const statement of importStatements) {
             if (statement.name === "import-from") {
-                await this.processImport(statement);
+                await this._processImport(statement);
             } else {
-                this.processUseParams(statement);
+                this._processUseParams(statement);
             }
         }
     }
 
-    private async processImport(importStatement: Node) {
+    private _resolveImportsSync(ast: Node) {
+        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);
+            }
+        }
+    }
+
+    private _processImportSync(importStatement: Node) {
+        const parseContext = this._parseContext;
+        const resourceNode = importStatement.find(n => n.name === "resource") as Node;
+        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) => {
+                if (node.name === "import-name" && node.parent?.name === "import-alias") {
+                    return;
+                }
+
+                if (node.name === "import-name" && node.parent?.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") as Node;
+                    const importName = importNameNode.value;
+                    const aliasNode = node.find(n => n.name === "import-name-alias") as Node;
+                    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: any) {
+            throw new Error(`Failed loading expression from: "${resource}". Error details: "${e.message}"`);
+        }
+
+    }
+
+    private async _processImport(importStatement: Node) {
         const parseContext = this._parseContext;
         const resourceNode = importStatement.find(n => n.name === "resource") as Node;
         const params = this._getParams(importStatement);
@@ -543,7 +622,7 @@ export class Grammar {
 
     }
 
-    private processUseParams(paramName: Node) {
+    private _processUseParams(paramName: Node) {
         const defaultValueNode = paramName.find(n => n.name === "param-default");
         if (defaultValueNode === null) {
             return;

package/src/patterns/Repeat.ts

@@ -96,12 +96,12 @@ export class Repeat implements Pattern {
         return this._repeatPattern.parse(cursor);
     }
 
-    exec(text: string): ParseResult {
-        return this._repeatPattern.exec(text);
+    exec(text: string, record = false): ParseResult {
+        return this._repeatPattern.exec(text, record);
     }
 
-    test(text: string): boolean {
-        return this._repeatPattern.test(text);
+    test(text: string, record = false): boolean {
+        return this._repeatPattern.test(text, record);
     }
 
     clone(name = this.name) {