goldstein 3.0.0 → 3.1.0

package/ChangeLog

@@ -1,3 +1,9 @@
+2023.04.18, v3.1.0
+
+feature:
+- 4236346 goldstein: add ability to use arrow in FunctionDeclaration
+- 8e2197f goldstein: add ability tot pass keywords and 🐊Putout optionts
+
 2023.04.02, v3.0.0
 
 feature:

package/README.md

@@ -99,9 +99,56 @@ function hello() {
 `;
 ```
 
+By default, all keywords mentioned in the next section used, but you can limit the list setting with `keywords` option.
+You can add any keywords, and even create your own:
+
+```js
+import {
+    compile,
+    keywords,
+} from 'goldstein';
+
+const source = `
+    fn hello() {
+        return id('hello');
+    }
+`;
+
+const {keywordFn} = keywords;
+
+compile(source, {
+    keywords: [
+        keywordFn,
+        function id(Parser) {
+            const {keywordTypes} = Parser.acorn;
+            return class extends Parser {
+            };
+        },
+    ],
+    rules: {
+        declare: ['on', {
+            declarations: {
+                id: 'const id = (a) => a',
+            },
+        }],
+    },
+});
+
+// returns
+`
+const id = (a) => a;
+
+function hello() {
+    return id('hello');
+}
+`;
+```
+
+You can declare variables with using [`@putout/operator-declare`](https://github.com/coderaiser/putout/tree/master/packages/operator-declare).
+
 ### `parse(source)`
 
-When you need to get **JavaScript** ESTree AST use `parse`:
+When you need to get **JavaScript** Babel AST use `parse`:
 
 ```js
 import {parse} from 'goldstein';
@@ -115,7 +162,8 @@ parse(`
         return "Hello " + text
     }
 `);
-// returns ESTree AST
+
+// returns Babel AST
 ```
 
 ## Keywords
@@ -282,6 +330,22 @@ Will be converted to:
 import hello from './hello.js';
 ```
 
+### `FunctionDeclaration` with `Arrow`
+
+If you mistakenly put `=>` in function declaration:
+
+```gs
+function hello() => {
+}
+```
+
+That absolutely fine, it will be converted to:
+
+```js
+function hello() {
+}
+```
+
 ## How to contribute?
 
 Clone the registry, create a new keyword with a prefix `keyword-`, then create directory `fixture` and put there two files with extensions `.js` and `.gs`. Half way done 🥳!

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "goldstein",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "type": "module",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "JavaScript with no limits",

package/packages/goldstein/index.js

@@ -15,27 +15,34 @@ import keywordImport from '../keyword-import/index.js';
 
 import estreeToBabel from 'estree-to-babel';
 
-export const parse = (source) => {
-    const {parse} = extendParser([
-        keywordFn,
-        keywordGuard,
-        keywordTry,
-        keywordShould,
-        keywordThrow,
-        keywordCurry,
-        keywordFreeze,
-        keywordIf,
-        keywordImport,
-        stringInterpolation,
-    ]);
+const defaultKeywords = {
+    keywordFn,
+    keywordGuard,
+    keywordTry,
+    keywordShould,
+    keywordThrow,
+    keywordCurry,
+    keywordFreeze,
+    keywordIf,
+    keywordImport,
+    stringInterpolation,
+};
+
+export const keywords = defaultKeywords;
+
+export const parse = (source, keywords = defaultKeywords) => {
+    const {parse} = extendParser(Object.values(keywords));
     
     return estreeToBabel(parse(source));
 };
 
-export const compile = (source) => {
+export const compile = (source, options = {}) => {
     const ast = parse(source);
     
     transform(ast, source, {
+        rules: {
+            ...options.rules,
+        },
         plugins: [
             'try-catch',
             'declare',
@@ -43,7 +50,9 @@ export const compile = (source) => {
         ],
     });
     
-    return fixEmpty(print(ast));
+    const {keywords} = options;
+    
+    return fixEmpty(print(ast, {keywords}));
 };
 
 const fixEmpty = (source) => {

package/packages/keyword-arrow/index.js

@@ -0,0 +1,43 @@
+import {
+    tokTypes as tt,
+} from 'acorn';
+
+export default function fn(Parser) {
+    return class extends Parser {
+        parseBlock(createNewLexicalScope, node, exitStrict) {
+            if (createNewLexicalScope === void 0)
+                createNewLexicalScope = true;
+            
+            if (node === void 0)
+                node = this.startNode();
+            
+            node.body = [];
+            
+            // optionally parse arrow
+            this.eat(tt.arrow);
+            this.expect(tt.braceL);
+            
+            if (createNewLexicalScope) {
+                this.enterScope(0);
+            }
+            
+            while (this.type !== tt.braceR) {
+                const stmt = this.parseStatement(null);
+                node.body.push(stmt);
+            }
+            
+            if (exitStrict) {
+                this.strict = false;
+            }
+            
+            this.next();
+            
+            if (createNewLexicalScope) {
+                this.exitScope();
+            }
+            
+            return this.finishNode(node, 'BlockStatement');
+        }
+    };
+}
+