goldstein 4.3.0 → 4.5.0

package/ChangeLog

@@ -1,3 +1,14 @@
+2023.10.03, v4.5.0
+
+feature:
+- c55a3d1 goldstein: parse: type
+- db6bcbe goldstein: types
+
+2023.10.03, v4.4.0
+
+feature:
+- 02f16ef goldstein: add convert js to gs
+
 2023.10.03, v4.3.0
 
 feature:

package/build/parser.cjs

@@ -1,6 +1,8 @@
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -14,6 +16,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // packages/goldstein/parser.js
@@ -23,6 +33,7 @@ __export(parser_exports, {
   parse: () => parse3
 });
 module.exports = __toCommonJS(parser_exports);
+var import_estree_to_babel = __toESM(require("estree-to-babel"), 1);
 
 // node_modules/acorn/dist/acorn.mjs
 var astralIdentifierCodes = [509, 0, 227, 0, 150, 4, 294, 9, 1368, 2, 2, 1, 6, 3, 41, 2, 5, 0, 166, 1, 574, 3, 9, 9, 370, 1, 81, 2, 71, 10, 50, 3, 123, 2, 54, 14, 32, 10, 3, 1, 11, 3, 46, 10, 8, 0, 46, 9, 7, 2, 37, 13, 2, 9, 6, 1, 45, 0, 13, 2, 49, 13, 9, 3, 2, 11, 83, 11, 7, 0, 3, 0, 158, 11, 6, 9, 7, 3, 56, 1, 2, 6, 3, 1, 3, 2, 10, 0, 11, 1, 3, 6, 4, 4, 193, 17, 10, 9, 5, 0, 82, 19, 13, 9, 214, 6, 3, 8, 28, 1, 83, 16, 16, 9, 82, 12, 9, 9, 84, 14, 5, 9, 243, 14, 166, 9, 71, 5, 2, 1, 3, 3, 2, 0, 2, 1, 13, 9, 120, 6, 3, 6, 4, 0, 29, 9, 41, 6, 2, 3, 9, 0, 10, 10, 47, 15, 406, 7, 2, 7, 17, 9, 57, 21, 2, 13, 123, 5, 4, 0, 2, 1, 2, 6, 2, 0, 9, 9, 49, 4, 2, 1, 2, 4, 9, 9, 330, 3, 10, 1, 2, 0, 49, 6, 4, 4, 14, 9, 5351, 0, 7, 14, 13835, 9, 87, 9, 39, 4, 60, 6, 26, 9, 1014, 0, 2, 54, 8, 3, 82, 0, 12, 1, 19628, 1, 4706, 45, 3, 22, 543, 4, 4, 5, 9, 7, 3, 6, 31, 3, 149, 2, 1418, 49, 513, 54, 5, 49, 9, 0, 15, 0, 23, 4, 2, 14, 1361, 6, 2, 16, 3, 6, 2, 1, 2, 4, 101, 0, 161, 6, 10, 9, 357, 0, 62, 13, 499, 13, 983, 6, 110, 6, 6, 9, 4759, 9, 787719, 239];
@@ -5469,11 +5480,55 @@ function newSpeak(Parser3) {
 }
 
 // packages/keyword-try/index.js
+var import_putout2 = require("putout");
+
+// packages/types/try.js
 var import_putout = require("putout");
 var {
-  isCallExpression,
-  isAwaitExpression
+  isAwaitExpression,
+  isCallExpression
 } = import_putout.types;
+function createGoldsteinTry({ async, callee, args }) {
+  return {
+    type: "TryStatement",
+    expression: true,
+    async,
+    argument: {
+      type: "CallExpression",
+      callee,
+      arguments: args
+    }
+  };
+}
+var setGoldsteinTry = (node) => {
+  if (!isCallExpression(node) && !isAwaitExpression(node))
+    return;
+  node.goldstein = createGoldsteinTry(parseExpression(node));
+};
+var parseExpression = (node) => {
+  const { argument, arguments: allArgs } = node;
+  const async = isAwaitExpression(node);
+  if (!async) {
+    const [callee2, ...args2] = allArgs;
+    return {
+      async,
+      args: args2,
+      callee: callee2
+    };
+  }
+  const [callee, ...args] = argument.arguments;
+  return {
+    async,
+    args,
+    callee
+  };
+};
+
+// packages/keyword-try/index.js
+var {
+  isCallExpression: isCallExpression2,
+  isAwaitExpression: isAwaitExpression2
+} = import_putout2.types;
 function keywordTry(Parser3) {
   const { keywordTypes } = Parser3.acorn;
   return class extends Parser3 {
@@ -5488,7 +5543,7 @@ function keywordTry(Parser3) {
       if (this.type === types$1.braceL)
         return this.parseUglyTry(node);
       const expression = this.parseExpression();
-      if (isCallExpression(expression))
+      if (isCallExpression2(expression))
         node.expression = {
           type: "CallExpression",
           callee: {
@@ -5498,21 +5553,11 @@ function keywordTry(Parser3) {
           arguments: [
             expression.callee,
             ...expression.arguments
-          ],
-          goldstein: createGoldsteinNode({
-            await: false,
-            callee: expression.callee,
-            arguments: expression.arguments
-          })
+          ]
         };
-      else if (isAwaitExpression(expression))
+      else if (isAwaitExpression2(expression))
         node.expression = {
           type: "AwaitExpression",
-          goldstein: createGoldsteinNode({
-            await: true,
-            callee: expression.argument.callee,
-            arguments: expression.argument.arguments
-          }),
           argument: {
             type: "CallExpression",
             callee: {
@@ -5527,6 +5572,7 @@ function keywordTry(Parser3) {
         };
       else
         this.raise(this.start, `After 'try' only '{', 'await' and 'function call' can come`);
+      setGoldsteinTry(node.expression);
       return super.finishNode(node, "ExpressionStatement");
     }
     parseUglyTry(node) {
@@ -5552,29 +5598,18 @@ function keywordTry(Parser3) {
       node.finalizer = this.eat(types$1._finally) ? this.parseBlock() : null;
       if (!node.handler && !node.finalizer)
         this.raise(node.start, "Missing catch or finally clause");
+      setGoldsteinTry(node);
       return this.finishNode(node, "TryStatement");
     }
   };
 }
-function createGoldsteinNode(args) {
-  return {
-    type: "TryStatement",
-    expression: true,
-    await: args.await,
-    argument: {
-      type: "CallExpression",
-      callee: args.callee,
-      arguments: args.arguments
-    }
-  };
-}
 
 // packages/keyword-should/index.js
-var import_putout2 = require("putout");
+var import_putout3 = require("putout");
 var {
-  isCallExpression: isCallExpression2,
-  isAwaitExpression: isAwaitExpression2
-} = import_putout2.types;
+  isCallExpression: isCallExpression3,
+  isAwaitExpression: isAwaitExpression3
+} = import_putout3.types;
 function newSpeak2(Parser3) {
   const { keywordTypes } = Parser3.acorn;
   keywordTypes.should = new TokenType("should", {
@@ -5597,7 +5632,7 @@ function newSpeak2(Parser3) {
       if (this.type === types$1.braceL)
         return this.raise(this.start, `After 'should' only 'await' and 'function call' can come, brackets are not supported`);
       const expression = this.parseExpression();
-      if (isCallExpression2(expression))
+      if (isCallExpression3(expression))
         node.expression = {
           type: "TryStatement",
           block: {
@@ -5619,7 +5654,7 @@ function newSpeak2(Parser3) {
             }
           }
         };
-      else if (isAwaitExpression2(expression))
+      else if (isAwaitExpression3(expression))
         node.expression = {
           type: "TryStatement",
           block: {
@@ -5671,7 +5706,7 @@ function keywordThrow(Parser3) {
 }
 
 // packages/string-interpolation/index.js
-var import_putout3 = require("putout");
+var import_putout4 = require("putout");
 var isString = (a) => typeof a === "string";
 var { assign: assign2 } = Object;
 function stringInterpolation(Parser3) {
@@ -5706,7 +5741,7 @@ function stringInterpolation(Parser3) {
       if (isTemplateLiteral) {
         const node = this.startNode();
         this.next();
-        const { quasis, expressions } = import_putout3.template.ast(`\`${out.join("")}\``);
+        const { quasis, expressions } = import_putout4.template.ast(`\`${out.join("")}\``);
         assign2(node, {
           quasis,
           expressions
@@ -5719,8 +5754,8 @@ function stringInterpolation(Parser3) {
 }
 
 // packages/keyword-curry/index.js
-var import_putout4 = require("putout");
-var { Identifier } = import_putout4.types;
+var import_putout5 = require("putout");
+var { Identifier } = import_putout5.types;
 function keywordCurry(Parser3) {
   return class extends Parser3 {
     parseSubscript(base, startPos, startLoc, noCalls, maybeAsyncArrow, optionalChained, forInit) {
@@ -5743,11 +5778,11 @@ function keywordCurry(Parser3) {
 }
 
 // packages/keyword-freeze/index.js
-var import_putout5 = require("putout");
+var import_putout6 = require("putout");
 var {
   isObjectExpression,
   isArrayExpression
-} = import_putout5.types;
+} = import_putout6.types;
 function keywordFreeze(Parser3) {
   const { keywordTypes } = Parser3.acorn;
   keywordTypes.freeze = new TokenType("freeze", {
@@ -5787,6 +5822,11 @@ function keywordFreeze(Parser3) {
   };
 }
 
+// packages/types/if.js
+var setGoldsteinIf = (node) => {
+  node.goldsteinIf = true;
+};
+
 // packages/keyword-if/index.js
 function fn2(Parser3) {
   return class extends Parser3 {
@@ -5801,7 +5841,7 @@ function fn2(Parser3) {
         this.raise(this.start, `Use both parens ('(', ')') or none`);
       node.consequent = this.parseStatement("if");
       node.alternate = this.eat(types$1._else) ? this.parseStatement("if") : null;
-      node.goldsteinIf = true;
+      setGoldsteinIf(node);
       return this.finishNode(node, "IfStatement");
     }
   };
@@ -5882,5 +5922,8 @@ var parse3 = (source, options = {}, keywords3 = defaultKeywords) => {
     ...options.keywords,
     ...keywords3
   }));
-  return parse4(source);
+  const ast = parse4(source);
+  if (options.type === "estree")
+    return ast;
+  return (0, import_estree_to_babel.default)(ast);
 };

package/package.json

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

package/packages/convert/apply-try/index.js

@@ -0,0 +1,23 @@
+import {createGoldsteinTry} from '../../types/try.js';
+
+export const report = () => `Use 'try' instead of 'tryCatch/tryToCatch'`;
+export const replace = () => ({
+    'tryCatch(__args)': createTry({
+        async: false,
+    }),
+    'await tryToCatch(__args)': createTry({
+        async: true,
+    }),
+});
+
+const createTry = ({async}) => ({__args}, path) => {
+    const [callee, ...args] = __args;
+    
+    path.node.goldstein = createGoldsteinTry({
+        async,
+        callee,
+        args,
+    });
+    
+    return path;
+};

package/packages/convert/index.js

@@ -0,0 +1,20 @@
+import estreeToBabel from 'estree-to-babel';
+import {transform} from 'putout';
+import {print} from '../printer/index.js';
+import * as applyTry from './apply-try/index.js';
+import {
+    fixEmpty,
+    parse,
+} from '../goldstein/index.js';
+
+export const convert = (source) => {
+    const ast = estreeToBabel(parse(source));
+    
+    transform(ast, source, {
+        plugins: [
+            ['apply-try', applyTry],
+        ],
+    });
+    
+    return fixEmpty(print(ast));
+};

package/packages/goldstein/index.js

@@ -1,14 +1,14 @@
 import {transform} from 'putout';
 import {print} from '@putout/printer';
-import {parse} from './parser.js';
-import estreeToBabel from 'estree-to-babel';
 import tryCatchPlugin from '@putout/plugin-try-catch';
 import declarePlugin from '@putout/plugin-declare';
 import logicalExpressionsPlugin from '@putout/plugin-logical-expressions';
+import {parse} from './parser.js';
 
 export * from './parser.js';
+export {print} from '../printer/index.js';
 export const compile = (source, options = {}) => {
-    const ast = estreeToBabel(parse(source, options));
+    const ast = parse(source, options);
     
     transform(ast, source, {
         rules: {

package/packages/goldstein/parser.js

@@ -1,3 +1,5 @@
+import estreeToBabel from 'estree-to-babel';
+
 import {extendParser} from '../parser/index.js';
 import keywordFn from '../keyword-fn/index.js';
 import keywordGuard from '../keyword-guard/index.js';
@@ -33,5 +35,10 @@ export const parse = (source, options = {}, keywords = defaultKeywords) => {
         ...keywords,
     }));
     
-    return parse(source);
+    const ast = parse(source);
+    
+    if (options.type === 'estree')
+        return ast;
+    
+    return estreeToBabel(ast);
 };

package/packages/keyword-if/index.js

@@ -1,4 +1,5 @@
 import {tokTypes as tt} from '../operator/index.js';
+import {setGoldsteinIf} from '../types/if.js';
 
 export default function fn(Parser) {
     return class extends Parser {
@@ -6,6 +7,7 @@ export default function fn(Parser) {
             this.next();
             
             const isParenL = this.eat(tt.parenL);
+            
             node.test = this.parseExpression();
             const isParenR = this.eat(tt.parenR);
             
@@ -18,9 +20,10 @@ export default function fn(Parser) {
             node.consequent = this.parseStatement('if');
             node.alternate = this.eat(tt._else) ? this.parseStatement('if') : null;
             
-            node.goldsteinIf = true;
+            setGoldsteinIf(node);
             
             return this.finishNode(node, 'IfStatement');
         }
     };
 }
+

package/packages/keyword-try/index.js

@@ -5,6 +5,7 @@ import {
     SCOPE_SIMPLE_CATCH,
     tokTypes as tt,
 } from '../operator/index.js';
+import {setGoldsteinTry} from '../types/try.js';
 
 const {
     isCallExpression,
@@ -43,20 +44,10 @@ export default function keywordTry(Parser) {
                         expression.callee,
                         ...expression.arguments,
                     ],
-                    goldstein: createGoldsteinNode({
-                        await: false,
-                        callee: expression.callee,
-                        arguments: expression.arguments,
-                    }),
                 };
             else if (isAwaitExpression(expression))
                 node.expression = {
                     type: 'AwaitExpression',
-                    goldstein: createGoldsteinNode({
-                        await: true,
-                        callee: expression.argument.callee,
-                        arguments: expression.argument.arguments,
-                    }),
                     argument: {
                         type: 'CallExpression',
                         callee: {
@@ -72,6 +63,8 @@ export default function keywordTry(Parser) {
             else
                 this.raise(this.start, `After 'try' only '{', 'await' and 'function call' can come`);
             
+            setGoldsteinTry(node.expression);
+            
             return super.finishNode(node, 'ExpressionStatement');
         }
         
@@ -105,12 +98,14 @@ export default function keywordTry(Parser) {
             if (!node.handler && !node.finalizer)
                 this.raise(node.start, 'Missing catch or finally clause');
             
+            setGoldsteinTry(node);
+            
             return this.finishNode(node, 'TryStatement');
         }
     };
 }
 
-function createGoldsteinNode(args) {
+export function createGoldsteinTry(args) {
     return {
         type: 'TryStatement',
         expression: true,
@@ -118,7 +113,8 @@ function createGoldsteinNode(args) {
         argument: {
             type: 'CallExpression',
             callee: args.callee,
-            arguments: args.arguments,
+            arguments: args.args,
         },
     };
 }
+

package/packages/printer/index.js

@@ -1,5 +1,4 @@
 import {print as printJS} from '@putout/printer';
-
 import {fixEmpty} from '../goldstein/index.js';
 import {AwaitExpression} from './visitors/await-expression.js';
 import {CallExpression} from './visitors/call-expression.js';

package/packages/printer/visitors/try-statement.js

@@ -8,6 +8,6 @@ export const TryStatement = (path, printer, semantics) => {
         return v.TryStatement(path, printer, semantics);
     
     print('try ');
-    maybe.print(node.await, 'await ');
+    maybe.print(node.async, 'await ');
     print('__argument');
 };

package/packages/types/if.js

@@ -0,0 +1,3 @@
+export const setGoldsteinIf = (node) => {
+    node.goldsteinIf = true;
+};

package/packages/types/try.js

@@ -0,0 +1,50 @@
+import {types} from 'putout';
+
+const {
+    isAwaitExpression,
+    isCallExpression,
+} = types;
+
+export function createGoldsteinTry({async, callee, args}) {
+    return {
+        type: 'TryStatement',
+        expression: true,
+        async,
+        argument: {
+            type: 'CallExpression',
+            callee,
+            arguments: args,
+        },
+    };
+}
+
+export const setGoldsteinTry = (node) => {
+    if (!isCallExpression(node) && !isAwaitExpression(node))
+        return;
+    
+    node.goldstein = createGoldsteinTry(parseExpression(node));
+};
+
+const parseExpression = (node) => {
+    const {argument, arguments: allArgs} = node;
+    
+    const async = isAwaitExpression(node);
+    
+    if (!async) {
+        const [callee, ...args] = allArgs;
+        
+        return {
+            async,
+            args,
+            callee,
+        };
+    }
+    
+    const [callee, ...args] = argument.arguments;
+    
+    return {
+        async,
+        args,
+        callee,
+    };
+};