clarity-pattern-parser 8.4.9 → 8.4.11

package/TODO.md

@@ -1,3 +1,12 @@
+* Anonymous patterns within cpat files.
+```
+pattern = ("Name" | "Name") & "Blah" & /foo/
+```
+* Aliasing imports.
+* Send through params 
+
+* Generate typescript files from cpat
+
 * We should make a Block, Segments Pattern. These will be breadth first patterns. It look something like this.
 
 ```ts
@@ -5,11 +14,12 @@ new Block(startPattern,contentPattern,endPattern);
 ```
 
 ```
-block = [start-pattern content-pattern end-pattern];
+block = [start-pattern, end-pattern];
 ```
 
 It will count the startPattern and only be done when its ends equal to end Pattern. It will store the internal pattern needed for its content. This is what is lazily done at some point in the future.
 
 ```ts
-new Segments(pattern, segmentPattern);
+new Segments(segmentPattern);
+
 ```

package/dist/grammar/Grammar.d.ts

@@ -1,17 +1,16 @@
 import { Pattern } from "../patterns/Pattern";
-export interface GrammarMeta {
-    originPath?: string;
-}
 export interface GrammarFile {
-    path: string;
+    resource: string;
     expression: string;
 }
 export interface GrammarOptions {
-    resolveImport?: (path: string, originPath: string | null) => Promise<GrammarFile>;
-    meta?: GrammarMeta | null;
+    resolveImport?: (resource: string, originResource: string | null) => Promise<GrammarFile>;
+    originResource?: string | null;
+    params?: Pattern[];
 }
 export declare class Grammar {
-    private _meta;
+    private _params;
+    private _originResource?;
     private _resolveImport;
     private _parseContext;
     private _autoComplete;
@@ -23,6 +22,7 @@ export declare class Grammar {
     private _hasImports;
     private _buildPatterns;
     private _resolveImports;
+    private _getParams;
     private _buildLiteral;
     private _buildRegex;
     private _buildOr;
@@ -32,5 +32,5 @@ export declare class Grammar {
     private _buildAlias;
     static parse(expression: string, options?: GrammarOptions): Promise<Map<string, Pattern>>;
     static import(path: string, options?: GrammarOptions): Promise<Map<string, Pattern>>;
-    static parseString(expression: string): Map<string, Pattern>;
+    static parseString(expression: string, options?: GrammarOptions): Map<string, Pattern>;
 }

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

@@ -0,0 +1,2 @@
+import { Repeat } from "../../patterns/Repeat";
+export declare const body: Repeat;

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

@@ -1,2 +1,2 @@
-import { Repeat } from "../../patterns/Repeat";
-export declare const grammar: Repeat;
+import { And } from "../../patterns/And";
+export declare const grammar: And;

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

@@ -1,2 +1,2 @@
-import { And } from "../../patterns/And";
-export declare const importStatement: And;
+import { Or } from "../../patterns/Or";
+export declare const importStatement: Or;

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

@@ -1,2 +1,7 @@
 import { Regex } from "../../patterns/Regex";
+import { Repeat } from "../../patterns/Repeat";
+export declare const tabs: Regex;
 export declare const spaces: Regex;
+export declare const newLine: Regex;
+export declare const lineSpaces: Repeat;
+export declare const allSpaces: Regex;

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

@@ -1,2 +1,2 @@
-import { And } from "../../patterns/And";
-export declare const statement: And;
+import { Or } from "../../patterns/Or";
+export declare const statement: Or;

package/dist/index.browser.js

@@ -1690,6 +1690,17 @@
         }
     }
 
+    const literal = new Regex("literal", "\"(?:\\\\[\"\\\\]|[^\n\"\\\\])*\"");
+
+    const tabs$1 = new Regex("tabs", "\\t+");
+    const spaces$1 = new Regex("spaces", "[ ]+");
+    const newLine$1 = new Regex("new-line", "(\\r?\\n)+");
+    spaces$1.setTokens([" "]);
+    tabs$1.setTokens(["\t"]);
+    newLine$1.setTokens(["\n"]);
+    const lineSpaces$1 = new Repeat("line-spaces", new Or("line-space", [tabs$1, spaces$1]));
+    const allSpaces = new Regex("all-spaces", "\\s+", true);
+
     const name$1 = new Regex("name", "[a-zA-Z_-]+[a-zA-Z0-9_-]*");
 
     const optionalNot = new Literal("not", "!", true);
@@ -1711,9 +1722,6 @@
 
     const regexLiteral = new Regex("regex-literal", "/(\\\\/|[^/\\n\\r])*/");
 
-    const spaces$1 = new Regex("spaces", "[ \\t]+");
-    spaces$1.setTokens([" "]);
-
     const patternName = name$1.clone("pattern-name");
     const optionalSpaces$2 = spaces$1.clone("optional-spaces", true);
     const dividerPattern = name$1.clone("divider-pattern");
@@ -1766,11 +1774,8 @@
         new And("optional-trim-divider-section", [spaces$1, trimDivider], true)
     ]);
 
-    const literal = new Regex("literal", "\"(?:\\\\[\"\\\\]|[^\n\"\\\\])*\"");
-
     const optionalSpaces$1 = spaces$1.clone("optional-spaces", true);
     const assignOperator = new Literal("assign-operator", "=");
-    const optionalComment = comment.clone("inline-comment", true);
     const statements = new Or("statements", [
         literal,
         regexLiteral,
@@ -1779,53 +1784,106 @@
         repeatLiteral,
         name$1.clone("alias-literal"),
     ]);
-    const statement = new And("statement", [
+    const assignStatement = new And("assign-statement", [
         optionalSpaces$1,
         name$1,
         optionalSpaces$1,
         assignOperator,
         optionalSpaces$1,
-        statements,
-        optionalSpaces$1,
-        optionalComment,
-        optionalSpaces$1,
+        statements
     ]);
+    const statement = new Or("statement", [assignStatement, name$1.clone("export-name")]);
 
-    const spaces = new Regex("spaces", "\\s+", true);
+    const bodyLineContent = new Or("body-line-content", [
+        comment,
+        statement
+    ]);
+    const bodyLine = new And("body-line", [
+        lineSpaces$1.clone("line-spaces", true),
+        bodyLineContent,
+        lineSpaces$1.clone("line-spaces", true),
+    ]);
+    const body = new Repeat("body", bodyLine, { divider: newLine$1, min: 0 });
+
+    const optionalSpaces = allSpaces.clone("optional-spaces", true);
+    const optionalLineSpaces = lineSpaces$1.clone("options-line-spaces", true);
     const importNameDivider = new Regex("import-name-divider", "(\\s+)?,(\\s+)?");
     const importKeyword = new Literal("import", "import");
+    const useParamsKeyword = new Literal("use-params", "use params");
+    const asKeyword = new Literal("as", "as");
     const fromKeyword = new Literal("from", "from");
     const openBracket = new Literal("open-bracket", "{");
     const closeBracket = new Literal("close-bracket", "}");
     const name = new Regex("import-name", "[^}\\s,]+");
-    const importedNames = new Repeat("imported-names", name, { divider: importNameDivider });
-    const optionalSpaces = spaces.clone("optional-spaces", true);
-    const importStatement = new And("import-statement", [
-        importKeyword,
+    const importNameAlias = name.clone("import-name-alias");
+    const importAlias = new And("import-alias", [name, lineSpaces$1, asKeyword, lineSpaces$1, importNameAlias]);
+    const importedNames = new Repeat("imported-names", new Or("import-names", [importAlias, name]), { divider: importNameDivider });
+    const paramName = name.clone("param-name");
+    const paramNames = new Repeat("param-names", paramName, { divider: importNameDivider });
+    const resource = literal.clone("resource");
+    const useParams = new And("import-params", [
+        useParamsKeyword,
+        optionalLineSpaces,
+        openBracket,
+        optionalSpaces,
+        paramNames,
         optionalSpaces,
+        closeBracket
+    ]);
+    const withParamsKeyword = new Literal("with-params", "with params");
+    const withParamsStatement = new And("with-params-statement", [
+        withParamsKeyword,
+        optionalLineSpaces,
+        openBracket,
+        optionalSpaces,
+        body.clone("with-params-body"),
+        optionalSpaces,
+        closeBracket
+    ], true);
+    const importFromStatement = new And("import-from", [
+        importKeyword,
+        optionalLineSpaces,
         openBracket,
         optionalSpaces,
         importedNames,
         optionalSpaces,
         closeBracket,
-        optionalSpaces,
+        optionalLineSpaces,
         fromKeyword,
-        spaces,
-        literal.clone("url"),
+        optionalLineSpaces,
+        resource,
+        optionalLineSpaces,
+        withParamsStatement
+    ]);
+    const importStatement = new Or("import-statement", [
+        useParams,
+        importFromStatement
     ]);
 
-    const whitespace = new Regex("whitespace", "[ \\t]+((\\r?\\n)+)?");
+    const tabs = new Regex("tabs", "\\t+");
+    const spaces = new Regex("spaces", "[ ]+");
     const newLine = new Regex("new-line", "(\\r?\\n)+");
-    whitespace.setTokens([" "]);
+    spaces.setTokens([" "]);
+    tabs.setTokens(["\t"]);
     newLine.setTokens(["\n"]);
-    const line = new Or("line", [
-        newLine,
-        whitespace,
+    const lineSpaces = new Repeat("line-spaces", new Or("line-space", [tabs, spaces]));
+    const headLineContent = new Or("head-line-content", [
         comment,
-        importStatement,
-        statement
+        importStatement
+    ]);
+    const headLine = new And("head-line-content", [
+        lineSpaces.clone("line-spaces", true),
+        headLineContent,
+        lineSpaces.clone("line-spaces", true),
+    ]);
+    const head = new Repeat("head", headLine, { divider: newLine, min: 0 });
+    const grammar = new And("grammar", [
+        allSpaces,
+        head,
+        allSpaces,
+        body,
+        allSpaces
     ]);
-    const grammar = new Repeat("grammer", line);
 
     class Not {
         get type() {
@@ -2128,9 +2186,11 @@
     }
 
     class ParseContext {
-        constructor() {
+        constructor(params) {
             this.patternsByName = new Map();
             this.importedPatternsByName = new Map();
+            this.paramsByName = new Map();
+            params.forEach(p => this.paramsByName.set(p.name, p));
         }
     }
     function defaultImportResolver(_path, _basePath) {
@@ -2138,9 +2198,10 @@
     }
     class Grammar {
         constructor(options = {}) {
-            this._meta = options.meta == null ? null : options.meta;
+            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._parseContext = new ParseContext();
+            this._parseContext = new ParseContext(this._params);
             this._autoComplete = new AutoComplete(grammar, {
                 greedyPatternNames: ["spaces", "optional-spaces", "whitespace", "new-line"],
                 customTokens: {
@@ -2154,13 +2215,17 @@
         import(path) {
             return __awaiter(this, void 0, void 0, function* () {
                 const grammarFile = yield this._resolveImport(path, null);
-                const grammar = new Grammar({ resolveImport: this._resolveImport, meta: { originPath: grammarFile.path } });
+                const grammar = new Grammar({
+                    resolveImport: this._resolveImport,
+                    originResource: grammarFile.resource,
+                    params: this._params
+                });
                 return grammar.parse(grammarFile.expression);
             });
         }
         parse(expression) {
             return __awaiter(this, void 0, void 0, function* () {
-                this._parseContext = new ParseContext();
+                this._parseContext = new ParseContext(this._params);
                 const ast = this._tryToParse(expression);
                 yield this._resolveImports(ast);
                 this._buildPatterns(ast);
@@ -2168,7 +2233,7 @@
             });
         }
         parseString(expression) {
-            this._parseContext = new ParseContext();
+            this._parseContext = new ParseContext(this._params);
             const ast = this._tryToParse(expression);
             if (this._hasImports(ast)) {
                 throw new Error("Cannot use imports on parseString, use parse instead.");
@@ -2200,9 +2265,13 @@
             return importBlock && importBlock.children.length > 0;
         }
         _buildPatterns(ast) {
-            ast.children.forEach((n) => {
+            const body = ast.find(n => n.name === "body");
+            if (body == null) {
+                return;
+            }
+            body.findAll(n => n.name === "assign-statement" || n.name === "export-name").forEach((n) => {
                 const typeNode = n.find(n => n.name.includes("literal"));
-                const type = (typeNode === null || typeNode === void 0 ? void 0 : typeNode.name) || "unknown";
+                const type = n.name === "export-name" ? "export-name" : (typeNode === null || typeNode === void 0 ? void 0 : typeNode.name) || "unknown";
                 switch (type) {
                     case "literal": {
                         this._buildLiteral(n);
@@ -2228,39 +2297,87 @@
                         this._buildAlias(n);
                         break;
                     }
+                    case "export-name": {
+                        const pattern = this._getPattern(n.value);
+                        this._parseContext.patternsByName.set(n.value, pattern);
+                        break;
+                    }
                 }
             });
         }
         _resolveImports(ast) {
-            var _a;
             return __awaiter(this, void 0, void 0, function* () {
                 const parseContext = this._parseContext;
-                const importStatements = ast.findAll(n => n.name === "import-statement");
+                const importStatements = ast.findAll(n => n.name === "import-from");
                 for (const importStatement of importStatements) {
-                    const urlNode = importStatement.find(n => n.name === "url");
-                    const url = urlNode.value.slice(1, -1);
-                    const grammarFile = yield this._resolveImport(url, ((_a = this._meta) === null || _a === void 0 ? void 0 : _a.originPath) || null);
-                    const grammar = new Grammar({ resolveImport: this._resolveImport, meta: { originPath: grammarFile.path } });
+                    const resourceNode = importStatement.find(n => n.name === "resource");
+                    const params = this._getParams(importStatement);
+                    const resource = resourceNode.value.slice(1, -1);
+                    const grammarFile = yield this._resolveImport(resource, this._originResource || null);
+                    const grammar = new Grammar({
+                        resolveImport: this._resolveImport,
+                        originResource: grammarFile.resource,
+                        params
+                    });
                     try {
                         const patterns = yield grammar.parse(grammarFile.expression);
-                        const importNames = importStatement.findAll(n => n.name === "import-name").map(n => n.value);
-                        importNames.forEach((importName) => {
-                            if (parseContext.importedPatternsByName.has(importName)) {
-                                throw new Error(`'${importName}' was already used within another import.`);
+                        const importStatements = importStatement.findAll(n => n.name === "import-name" || n.name === "import-alias");
+                        importStatements.forEach((node) => {
+                            if (node.name === "import-name") {
+                                const importName = node.value;
+                                if (parseContext.importedPatternsByName.has(importName)) {
+                                    throw new Error(`'${importName}' was already used within another import.`);
+                                }
+                                const pattern = patterns.get(importName);
+                                if (pattern == null) {
+                                    throw new Error(`Couldn't find pattern with name: ${importName}, from import: ${resource}.`);
+                                }
+                                parseContext.importedPatternsByName.set(importName, pattern);
                             }
-                            const pattern = patterns.get(importName);
-                            if (pattern == null) {
-                                throw new Error(`Couldn't find pattern with name: ${importName}, from import: ${url}.`);
+                            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.get(importName);
+                                if (pattern == null) {
+                                    throw new Error(`Couldn't find pattern with name: ${importName}, from import: ${resource}.`);
+                                }
+                                parseContext.importedPatternsByName.set(alias, pattern);
                             }
-                            parseContext.importedPatternsByName.set(importName, pattern);
                         });
                     }
                     catch (e) {
-                        throw new Error(`Failed loading expression from: "${url}". Error details: "${e.message}"`);
+                        throw new Error(`Failed loading expression from: "${resource}". Error details: "${e.message}"`);
                     }
                 }
             });
         }
+        _getParams(importStatement) {
+            let params = [];
+            const paramsStatement = importStatement.find(n => n.name === "with-params-statement");
+            if (paramsStatement != null) {
+                const statements = paramsStatement.find(n => n.name === "with-params-body");
+                if (statements != null) {
+                    const expression = statements.toString();
+                    const importedValues = Array.from(this
+                        ._parseContext
+                        .importedPatternsByName
+                        .values());
+                    const grammar = new Grammar({
+                        params: importedValues,
+                        originResource: this._originResource,
+                        resolveImport: this._resolveImport
+                    });
+                    const patterns = grammar.parseString(expression);
+                    params = Array.from(patterns.values());
+                }
+            }
+            return params;
+        }
         _buildLiteral(statementNode) {
             const nameNode = statementNode.find(n => n.name === "name");
             const literalNode = statementNode.find(n => n.name === "literal");
@@ -2291,6 +2408,9 @@
             if (pattern == null) {
                 pattern = this._parseContext.importedPatternsByName.get(name);
             }
+            if (pattern == null) {
+                pattern = this._parseContext.paramsByName.get(name);
+            }
             if (pattern == null) {
                 return new Reference(name);
             }
@@ -2382,8 +2502,8 @@
             const grammar = new Grammar(options);
             return grammar.import(path);
         }
-        static parseString(expression) {
-            const grammar = new Grammar();
+        static parseString(expression, options) {
+            const grammar = new Grammar(options);
             return grammar.parseString(expression);
         }
     }