goldstein 2.3.0 → 2.4.0

package/ChangeLog

@@ -1,3 +1,10 @@
+2022.06.30, v2.4.0
+
+feature:
+- goldstein: freeze: simplify: MemberExpression -> Identifier
+- goldstein: add freeze keyword (#6)
+
+
 2022.06.27, v2.3.0
 
 feature:

package/README.md

@@ -166,6 +166,24 @@ try hello();
 
 > ☝️ *Warning: this feature can be helpful but also dangerous especially if you're debugging your application. In fact, this is made to be used as an optional function call (ex. should load content, but not necessary and knowing this feature is optional), if you call a function in this way while debugging, no error will be printed and the application will continue run as nothing happened.*
 
+### `freeze`
+
+You can use `freeze` instead of `Object.freeze()` like that:
+
+```gs
+freeze {
+    'example': true
+}
+```
+
+Is the same as:
+
+```js
+Object.freeze({
+    example: true,
+});
+```
+
 ### `if`
 
 You can omit parens. But you must use braces in this case.
@@ -184,12 +202,12 @@ You can use [throw as expression](https://github.com/tc39/proposal-throw-express
 const a = () => throw 'hello';
 ```
 
-### Curry
+### `Curry`
 
 Similar to [partial application](https://github.com/tc39/proposal-partial-application):
 
 ```gs
-const sum = a + b;
+const sum = (a, b) => a + b;
 const inc = sum~(1);
 
 inc(5);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "goldstein",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "type": "module",
   "commitType": "colon",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",

package/packages/goldstein/index.js

@@ -9,6 +9,7 @@ import keywordShould from '../keyword-should/index.js';
 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';
 
 export const compile = (source) => {
     const {parse} = extendParser([
@@ -18,6 +19,7 @@ export const compile = (source) => {
         keywordShould,
         keywordThrow,
         keywordCurry,
+        keywordFreeze,
         stringInterpolation,
     ]);
     

package/packages/keyword-freeze/index.js

@@ -0,0 +1,59 @@
+import {types} from 'putout';
+import {
+    addKeyword,
+    TokenType,
+} from '../operator/index.js';
+
+const {
+    isObjectExpression,
+    isArrayExpression,
+} = types;
+
+export default function keywordFreeze(Parser) {
+    const {keywordTypes} = Parser.acorn;
+    keywordTypes.freeze = new TokenType('freeze', {
+        keyword: 'freeze',
+    });
+    
+    return class extends Parser {
+        parse() {
+            this.keywords = addKeyword('freeze', this.keywords);
+            return super.parse();
+        }
+        parseStatement(context, topLevel, exports) {
+            if (this.type === keywordTypes.freeze) {
+                return this.parseFreeze();
+            }
+            
+            return super.parseStatement(context, topLevel, exports);
+        }
+        
+        parseFreeze() {
+            this.next();
+            
+            const node = super.startNode();
+            const expression = this.parseExpression();
+            
+            if (isObjectExpression(expression) || isArrayExpression(expression))
+                node.expression = {
+                    type: 'ExpressionStatement',
+                    expression: {
+                        type: 'CallExpression',
+                        callee: {
+                            type: 'Identifier',
+                            name: 'freeze',
+                        },
+                        arguments: [
+                            expression,
+                        ],
+                    },
+                };
+            
+            else
+                this.raise(this.start, `After 'freeze' only objects and arrays can come`);
+            
+            return super.finishNode(node, 'ExpressionStatement');
+        }
+    };
+}
+