goldstein 5.19.2 → 5.20.0

package/ChangeLog

@@ -1,3 +1,8 @@
+2024.12.12, v5.20.0
+
+feature:
+- 01d6d6f goldstein: keyword-export-no-const: add
+
 2024.12.12, v5.19.2
 
 feature:

package/README.md

@@ -513,6 +513,19 @@ The same as:
 const a = require('a');
 ```
 
+### Export without `const`
+
+```gs
+export x = () => {};
+```
+
+The same as:
+
+```js
+export const x = () => {};
+```
+
+
 ## 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": "5.19.2",
+  "version": "5.20.0",
   "type": "module",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "JavaScript with no limits",

package/packages/goldstein/parser.js

@@ -20,6 +20,7 @@ import keywordUselessSemicolon from '../keyword-useless-semicolon/index.js';
 import keywordAssignFrom from '../keyword-assign-from/index.js';
 import internalParseMaybeAssign from '../internal-parse-maybe-assign/index.js';
 import operatorSafeAssignment from '../operator-safe-assignment/index.js';
+import keywordExportNoConst from '../keyword-export-no-const/index.js';
 
 const {values} = Object;
 
@@ -41,6 +42,7 @@ const defaultKeywords = {
     keywordUselessComma,
     keywordUselessSemicolon,
     keywordAssignFrom,
+    keywordExportNoConst,
     operatorSafeAssignment,
 };
 

package/packages/keyword-export-no-const/index.js

@@ -0,0 +1,88 @@
+import {types} from 'putout';
+import {tokTypes as tt} from '../operator/index.js';
+
+const {
+    VariableDeclaration,
+    VariableDeclarator,
+} = types;
+
+export default function keywordExportNoConst(Parser) {
+    return class extends Parser {
+        shouldParseExportStatement() {
+            if (!this.type.keyword)
+                return true;
+            
+            return super.shouldParseExportStatement();
+        }
+        
+        parseExport(node, exports) {
+            this.next();
+            
+            /* c8 ignore start */
+            // export * from '...'
+            if (this.eat(tt.star))
+                return this.parseExportAllDeclaration(node, exports);
+            /* c8 ignore end */
+            
+            /* c8 ignore start */
+            if (this.eat(tt._default)) {
+                // export default ...
+                this.checkExport(exports, 'default', this.lastTokStart);
+                node.declaration = this.parseExportDefaultDeclaration();
+                
+                return this.finishNode(node, 'ExportDefaultDeclaration');
+            }
+            
+            /* c8 ignore end */
+            // export var|const|let|function|class ...
+            if (this.shouldParseExportStatement()) {
+                node.declaration = this.parseExportDeclaration(node);
+                
+                if (node.declaration.type === 'VariableDeclaration')
+                    this.checkVariableExport(exports, node.declaration.declarations);
+                
+                if (node.declaration.type === 'ExpressionStatement')
+                    node.declaration = VariableDeclaration('const', [
+                        VariableDeclarator(node.declaration.expression.left, node.declaration.expression.right),
+                    ]);
+                else
+                    this.checkExport(exports, node.declaration.id, node.declaration.id.start);
+                
+                node.specifiers = [];
+                node.source = null;
+            } else {
+                // export { x, y as z } [from '...']
+                node.declaration = null;
+                node.specifiers = this.parseExportSpecifiers(exports);
+                
+                if (this.eatContextual('from')) {
+                    if (this.type !== tt.string)
+                        this.unexpected();
+                    
+                    node.source = this.parseExprAtom();
+                    
+                    if (this.options.ecmaVersion >= 16)
+                        node.attributes = this.parseWithClause();
+                } else {
+                    for (let i = 0, list = node.specifiers; i < list.length; ++i) {
+                        // check for keywords used as local names
+                        const spec = list[i];
+                        
+                        this.checkUnreserved(spec.local);
+                        // check if export is defined
+                        this.checkLocalExport(spec.local);
+                        
+                        if (spec.local.type === 'Literal')
+                            this.raise(spec.local.start, 'A string literal cannot be used as an exported binding without `from`.');
+                    }
+                    
+                    node.source = null;
+                }
+                
+                this.semicolon();
+            }
+            
+            return this.finishNode(node, 'ExportNamedDeclaration');
+        }
+    };
+}