goldstein 2.6.0 → 3.1.0

package/ChangeLog

@@ -1,3 +1,18 @@
+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:
+- 3eeeab7 goldstein: add ability to simplify logical expressions during compilation
+- 7959e57 goldstein: add ability to compile import gs to js
+- c61e500 goldstein: improve compiler, disable bundling
+- 6cd279e goldstein: enable support of ifStatments with no round braces
+- 0ba6f9c major: goldstein: compile: use @putout/pinter instead of recast, parse: provide Babel AST
+
 2023.04.01, v2.6.0
 
 feature:

package/README.md

@@ -43,6 +43,32 @@ export {
 };
 ```
 
+Let's do a bit more!
+
+```gs
+const a = () => throw 'hello';
+
+if a > 2 {
+    log('hello');
+}
+
+fn hello() {
+    console.log('hello');
+}
+```
+
+Will give us:
+
+```js
+const a = () => {
+    throw 'hello';
+};
+
+if (a > 2) {
+    log('hello');
+}
+```
+
 ## API
 
 ### `compile(source)`
@@ -73,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';
@@ -89,7 +162,8 @@ parse(`
         return "Hello " + text
     }
 `);
-// returns ESTree AST
+
+// returns Babel AST
 ```
 
 ## Keywords
@@ -133,7 +207,7 @@ Is the same as:
 
 ```js
 function hello() {
-    if (!(text !== 'world')) {
+    if (text === 'world') {
         return '';
     }
     
@@ -237,6 +311,41 @@ inc(5);
 6
 ```
 
+### `Import`
+
+When you import `.gs` files during compile step it will be replaced with `.js`:
+
+```gs
+// hello.js
+export const hello = () => 'world';
+
+// index.js
+import hello from './hello.gs';
+```
+
+Will be converted to:
+
+```js
+// index.js
+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/bin/gs.js

@@ -24,7 +24,7 @@ const outfile = compiledName.replace('~', '');
 
 esbuild.buildSync({
     entryPoints: [compiledName],
-    bundle: true,
+    bundle: false,
     write: true,
     outfile,
     mainFields: ['main'],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "goldstein",
-  "version": "2.6.0",
+  "version": "3.1.0",
   "type": "module",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "JavaScript with no limits",
@@ -25,8 +25,10 @@
     "fix:lint": "madrun fix:lint"
   },
   "dependencies": {
+    "@putout/printer": "^1.16.0",
     "acorn": "^8.7.1",
     "esbuild": "^0.17.14",
+    "estree-to-babel": "^5.0.1",
     "putout": "^29.1.11",
     "try-catch": "^3.0.1"
   },

package/packages/goldstein/index.js

@@ -1,6 +1,6 @@
-import putout, {
-    print,
-} from 'putout';
+import {transform} from 'putout';
+
+import {print} from '@putout/printer';
 import {extendParser} from '../parser/index.js';
 import keywordFn from '../keyword-fn/index.js';
 import keywordGuard from '../keyword-guard/index.js';
@@ -10,31 +10,51 @@ import keywordThrow from '../keyword-throw/index.js';
 import stringInterpolation from '../string-interpolation/index.js';
 import keywordCurry from '../keyword-curry/index.js';
 import keywordFreeze from '../keyword-freeze/index.js';
+import keywordIf from '../keyword-if/index.js';
+import keywordImport from '../keyword-import/index.js';
+
+import estreeToBabel from 'estree-to-babel';
+
+const defaultKeywords = {
+    keywordFn,
+    keywordGuard,
+    keywordTry,
+    keywordShould,
+    keywordThrow,
+    keywordCurry,
+    keywordFreeze,
+    keywordIf,
+    keywordImport,
+    stringInterpolation,
+};
+
+export const keywords = defaultKeywords;
 
-export const parse = (source) => {
-    const {parse} = extendParser([
-        keywordFn,
-        keywordGuard,
-        keywordTry,
-        keywordShould,
-        keywordThrow,
-        keywordCurry,
-        keywordFreeze,
-        stringInterpolation,
-    ]);
+export const parse = (source, keywords = defaultKeywords) => {
+    const {parse} = extendParser(Object.values(keywords));
     
-    return parse(source);
+    return estreeToBabel(parse(source));
 };
 
-export const compile = (source) => {
+export const compile = (source, options = {}) => {
     const ast = parse(source);
-    const jsCode = print(ast);
-    const {code} = putout(jsCode, {
+    
+    transform(ast, source, {
+        rules: {
+            ...options.rules,
+        },
         plugins: [
             'try-catch',
             'declare',
+            'logical-expressions',
         ],
     });
     
-    return code;
+    const {keywords} = options;
+    
+    return fixEmpty(print(ast, {keywords}));
+};
+
+const fixEmpty = (source) => {
+    return source.replace(';;', ';');
 };

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');
+        }
+    };
+}
+

package/packages/keyword-if/index.js

@@ -1,6 +1,4 @@
-import {
-    tokTypes as tt,
-} from '../operator/index.js';
+import {tokTypes as tt} from '../operator/index.js';
 
 export default function fn(Parser) {
     return class extends Parser {

package/packages/keyword-import/index.js

@@ -0,0 +1,34 @@
+import {tokTypes} from '../operator/index.js';
+
+const empty = [];
+
+export default function keywordImport(Parser) {
+    return class extends Parser {
+        parseImport(node) {
+            this.next();
+            
+            // import '...'
+            if (this.type === tokTypes.string) {
+                node.specifiers = empty;
+                node.source = this.parseExprAtom();
+            } else {
+                node.specifiers = this.parseImportSpecifiers();
+                this.expectContextual('from');
+                
+                node.source = this.type === tokTypes.string ? this.parseLiteral(this.value) : this.unexpected();
+            }
+            
+            const {raw, value} = node.source;
+            
+            if (value.endsWith('.gs')) {
+                node.source.raw = raw.replace('.gs', '.js');
+                node.source.value = value.replace(/\.gs$/, '.js');
+            }
+            
+            this.semicolon();
+            
+            return this.finishNode(node, 'ImportDeclaration');
+        }
+    };
+}
+

package/packages/keyword-throw/index.js

@@ -19,11 +19,13 @@ export default function keywordThrow(Parser) {
             const expression = this.parseExpression();
             
             assign(node, {
-                operator: 'throw',
-                argument: expression,
+                body: [{
+                    type: 'ThrowStatement',
+                    argument: expression,
+                }],
             });
             
-            return super.finishNode(node, 'UnaryExpression');
+            return super.finishNode(node, 'BlockStatement');
         }
     };
 }

package/packages/parser/index.js

@@ -15,4 +15,5 @@ export const extendParser = (keywords) => {
 const createParse = (parser) => (a) => parser.parse(a, {
     ecmaVersion: 'latest',
     sourceType: 'module',
+    locations: true,
 });