clarity-pattern-parser 11.3.13 → 11.4.1

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/grammar_v2/patterns/Grammar.d.ts

@@ -0,0 +1,23 @@
+import { GrammarFile } from "../../grammar/Grammar";
+import { Pattern } from "../../patterns/Pattern";
+export type Decorator = (pattern: Pattern, arg?: string | boolean | number | null | Record<string, any> | any[]) => void;
+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>;
+}
+export declare class Grammar {
+    private _options;
+    private _parseContext;
+    private _resolveImportSync;
+    constructor(options: GrammarOptions);
+    private _resolveImportsSync;
+    private _processImportSync;
+    private _getWithParams;
+    private _processUseParams;
+    private _tryToParse;
+    private _flattenExpressions;
+    private _unwrapNode;
+}

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

@@ -0,0 +1,87 @@
+import { Expression } from "../../../patterns/Expression";
+import { Literal } from "../../../patterns/Literal";
+import { Optional } from "../../../patterns/Optional";
+import { Options } from "../../../patterns/Options";
+import { Regex } from "../../../patterns/Regex";
+import { Repeat } from "../../../patterns/Repeat";
+import { Sequence } from "../../../patterns/Sequence";
+export declare const syntax: Literal;
+export declare const imprt: Literal;
+export declare const useParams: Literal;
+export declare const withParams: Literal;
+export declare const from: Literal;
+export declare const right: Literal;
+export declare const ws: Regex;
+export declare const ls: Regex;
+export declare const assign: Literal;
+export declare const bar: Literal;
+export declare const greedyBar: Literal;
+export declare const concat: Literal;
+export declare const colon: Literal;
+export declare const openParen: Literal;
+export declare const closeParen: Literal;
+export declare const openSquareBracket: Literal;
+export declare const closeSquareBracket: Literal;
+export declare const openBracket: Literal;
+export declare const closeBracket: Literal;
+export declare const comma: Regex;
+export declare const trim: Literal;
+export declare const not: Literal;
+export declare const optional: Literal;
+export declare const newLine: Regex;
+export declare const syntaxVersion: Regex;
+export declare const at: Literal;
+export declare const optionalWS: Optional;
+export declare const optionalLS: Optional;
+export declare const literal: Regex;
+export declare const regex: Regex;
+export declare const integer: Regex;
+export declare const name: Regex;
+export declare const patternName: Regex;
+export declare const patternIdentifier: Regex;
+export declare const resource: Regex;
+export declare const comment: Regex;
+export declare const jsonString: Regex;
+export declare const jsonNumber: Regex;
+export declare const trueLiteral: Literal;
+export declare const falseLiteral: Literal;
+export declare const jsonBoolean: Options;
+export declare const jsonNull: Literal;
+export declare const jsonArrayItems: Repeat;
+export declare const jsonArray: Sequence;
+export declare const jsonObjectPropertyName: Regex;
+export declare const jsonObjectProperty: Sequence;
+export declare const jsonObjectProperties: Repeat;
+export declare const jsonObject: Sequence;
+export declare const jsonValue: Options;
+export declare const syntaxStatement: Sequence;
+export declare const decorationName: Regex;
+export declare const decorationStatement: Sequence;
+export declare const useParamPatterns: Repeat;
+export declare const useParamsStatement: Sequence;
+export declare const withParamStatements: Repeat;
+export declare const withParamsExpr: Sequence;
+export declare const patternNames: Repeat;
+export declare const importedPatterns: Sequence;
+export declare const importStatement: Sequence;
+export declare const notExpr: Sequence;
+export declare const optionalExpr: Sequence;
+export declare const rightAssociationExpr: Sequence;
+export declare const unaryPatternExpr: Expression;
+export declare const repeatBounds: Sequence;
+export declare const oneOrMore: Literal;
+export declare const zeroOrMore: Literal;
+export declare const repeatOptions: Options;
+export declare const delimiter: Sequence;
+export declare const repeatExpr: Sequence;
+export declare const sequenceExpr: Sequence;
+export declare const optionsExpr: Sequence;
+export declare const greedyOptionsExpr: Sequence;
+export declare const patternGroupExpr: Sequence;
+export declare const exportPattern: Regex;
+export declare const patternExpr: Expression;
+export declare const patternAssignment: Sequence;
+export declare const statement: Options;
+export declare const statements: Repeat;
+export declare const cpat: Sequence;
+export declare const grammar: Sequence;

package/dist/grammar_v2/patterns/patterns/grammar.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.browser.js

@@ -435,7 +435,7 @@
 
     class Cursor {
         get text() {
-            return this._text;
+            return this._chars.join("");
         }
         get isOnFirst() {
             return this._index === 0;
@@ -483,12 +483,12 @@
             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() {
@@ -522,7 +522,7 @@
             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);
@@ -771,7 +771,9 @@
         }
         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);
@@ -3503,11 +3505,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 +3540,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 +3847,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 +3973,7 @@
                 }
             });
         }
-        processUseParams(paramName) {
+        _processUseParams(paramName) {
             const defaultValueNode = paramName.find(n => n.name === "param-default");
             if (defaultValueNode === null) {
                 return;