clarity-pattern-parser 8.4.10 → 8.4.12

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,16 @@ 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);
+
+```
+
+
+
+NEVER BE TEMPTED TO PUT LOGIC IN SYNTAX. THIS IS MEANT TO BE DECLARATIVE AND COMPOSABLE. If you want a different behavior from a parse, then compose it.

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

@@ -1784,7 +1784,7 @@
         repeatLiteral,
         name$1.clone("alias-literal"),
     ]);
-    const statement = new And("statement", [
+    const assignStatement = new And("assign-statement", [
         optionalSpaces$1,
         name$1,
         optionalSpaces$1,
@@ -1792,6 +1792,7 @@
         optionalSpaces$1,
         statements
     ]);
+    const statement = new Or("statement", [assignStatement, name$1.clone("export-name")]);
 
     const bodyLineContent = new Or("body-line-content", [
         comment,
@@ -1804,18 +1805,21 @@
     ]);
     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 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 optionalSpaces = allSpaces.clone("optional-spaces", true);
-    const optionalLineSpaces = lineSpaces$1.clone("options-line-spaces", true);
     const resource = literal.clone("resource");
     const useParams = new And("import-params", [
         useParamsKeyword,
@@ -1832,7 +1836,7 @@
         optionalLineSpaces,
         openBracket,
         optionalSpaces,
-        body,
+        body.clone("with-params-body"),
         optionalSpaces,
         closeBracket
     ], true);
@@ -2261,9 +2265,13 @@
             return importBlock && importBlock.children.length > 0;
         }
         _buildPatterns(ast) {
-            ast.findAll(n => n.name === "statement").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);
@@ -2289,6 +2297,11 @@
                         this._buildAlias(n);
                         break;
                     }
+                    case "export-name": {
+                        const pattern = this._getPattern(n.value);
+                        this._parseContext.patternsByName.set(n.value, pattern);
+                        break;
+                    }
                 }
             });
         }
@@ -2308,16 +2321,33 @@
                     });
                     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: ${resource}.`);
+                            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) {
@@ -2330,7 +2360,7 @@
             let params = [];
             const paramsStatement = importStatement.find(n => n.name === "with-params-statement");
             if (paramsStatement != null) {
-                const statements = paramsStatement.find(n => n.name === "body");
+                const statements = paramsStatement.find(n => n.name === "with-params-body");
                 if (statements != null) {
                     const expression = statements.toString();
                     const importedValues = Array.from(this