@putout/plugin-nodejs 8.0.0 → 9.0.0

package/README.md

@@ -21,10 +21,13 @@ npm i putout @putout/plugin-nodejs -D
 {
     "rules": {
         "nodejs/add-node-prefix": "on",
+        "nodejs/convert-commonjs-to-esm": "on",
+        "nodejs/convert-esm-to-commonjs": "on",
         "nodejs/convert-buffer-to-buffer-alloc": "on",
         "nodejs/convert-fs-promises": "on",
         "nodejs/convert-promisify-to-fs-promises": "on",
         "nodejs/convert-dirname-to-url": "on",
+        "nodejs/convert-exportst-to-module-exports": "on",
         "nodejs/convert-url-to-dirname": "on",
         "nodejs/convert-top-level-return": "on",
         "nodejs/declare": "on",
@@ -171,6 +174,23 @@ In most cases `process.exit()` is called from `bin` directory, if not - disable
 -process.exit();
 ```
 
+### convert-exports-to-module-exports
+
+Since `exports = 5` wan't make any export, just change value of variable.
+Checkout in 🐊[**Putout Editor**](https://putout.cloudcmd.io/#/gist/8b2af2c4ad005ed1c77cde41377caaad/dfdccc794037d7f67bde1e7d7244bf5f14abebce).
+
+#### ❌ Example of incorrect code
+
+```js
+exports.x = 5;
+```
+
+#### ✅ Example of correct code
+
+```js
+module.exports.x = 5;
+```
+
 ### convert-top-level-return
 
 #### ❌ Example of incorrect code
@@ -251,6 +271,99 @@ const {readFile} = require('fs/promises');
 const name = 'hello.txt';
 ```
 
+### convert-commonjs-to-esm
+
+Convert **CommonJS** **EcmaScript Modules**.
+
+> **CommonJS** is a module system supported in Node, it provides a `require` function, which can be used to access the `exports` object exposed by another file.
+>
+> **EcmaScript module** syntax is the standard way to import and export values between files in **JavaScript**. The `import` statement can be used to reference a value exposed by the `export` statement in another file.
+>
+> (c) [parceljs](https://parceljs.org/languages/javascript/)
+
+#### require
+
+##### ❌ Example of incorrect code
+
+```js
+const {join} = require('path');
+
+const args = require('minimist')({
+    string: ['a', 'b'],
+});
+```
+
+##### ✅ Example of correct code
+
+```js
+import {join} from 'path';
+import minimist from 'minimist';
+
+const args = minimist({
+    string: ['a', 'b'],
+});
+```
+
+#### exports
+
+##### ❌ Example of incorrect code
+
+```js
+module.exports = () => {};
+```
+
+##### ✅ Example of correct code
+
+```js
+export default () => {};
+```
+
+#### Commons
+
+##### ❌ Example of incorrect code
+
+```js
+const {readFile} = require('fs/promises');
+
+await readFile(__filename);
+```
+
+##### ✅ Example of correct code
+
+```js
+import {readFile} from 'fs/promises';
+import {fileURLToPath} from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+await readFile(__filename);
+```
+
+### convert-esm-to-commonjs
+
+> **EcmaScript module** syntax is the standard way to import and export values between files in **JavaScript**. The `import` statement can be used to reference a value exposed by the `export` statement in another file.
+>
+> **CommonJS** is a module system supported in Node, it provides a `require` function, which can be used to access the `exports` object exposed by another file.
+>
+> (c) [parceljs](https://parceljs.org/languages/javascript/)
+
+Convert **EcmaScript Modules** to **CommonJS**.
+
+## ❌ Example of incorrect code
+
+```js
+import hello from 'world';
+```
+
+## ✅ Example of correct code
+
+```js
+const hello = require('world');
+```
+
+## License
+
+MIT
+
 ## License
 
 MIT

package/lib/convert-commonjs-to-esm-commons/index.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const {template, operator} = require('putout');
+
+const {
+    getPathAfterImports,
+    insertBefore,
+} = operator;
+
+const initCommons = template.ast(`
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    const require = createRequire(import.meta.url);
+`);
+
+module.exports.report = () => '"__filename", "__dirname" and "require" should be declared in ESM';
+
+module.exports.fix = ({scope}) => {
+    const programScope = scope.getProgramParent();
+    const body = programScope.path.get('body');
+    const afterImportPath = getPathAfterImports(body);
+    
+    insertBefore(afterImportPath, initCommons);
+};
+
+module.exports.include = () => [
+    '__filename',
+    '__dirname',
+    'require',
+];
+
+module.exports.filter = ({scope}) => {
+    const isDirname = scope.hasBinding('__dirname');
+    const isFilename = scope.hasBinding('__filename');
+    const isRequire = scope.hasBinding('require');
+    
+    return !isDirname && !isFilename && !isRequire;
+};

package/lib/convert-commonjs-to-esm-exports/index.js

@@ -0,0 +1,42 @@
+'use strict';
+
+const {types, operator} = require('putout');
+const {replaceWith} = operator;
+
+const {
+    isIdentifier,
+    ExportNamedDeclaration,
+} = types;
+
+module.exports.report = () => `Use 'ESM' instead of 'CommonJS'`;
+
+module.exports.exclude = () => ['__, __'];
+
+module.exports.replace = () => ({
+    'module.exports = __a': 'export default __a',
+    'module.exports.__a = __b': ({__a, __b}, path) => {
+        if (isIdentifier(__b, {name: __a.name}))
+            return addExportToBinding(__b.name, path);
+        
+        return 'export const __a = __b';
+    },
+});
+
+function addExportToBinding(name, path) {
+    const {scope} = path;
+    const binding = scope.bindings[name];
+    const bindingPath = parseBindingPath(binding.path);
+    
+    const exportNode = ExportNamedDeclaration(bindingPath.node);
+    
+    replaceWith(bindingPath, exportNode);
+    
+    return '';
+}
+
+function parseBindingPath(path) {
+    if (path.isVariableDeclarator())
+        return path.parentPath;
+    
+    return path;
+}

package/lib/convert-commonjs-to-esm-require/index.js

@@ -0,0 +1,159 @@
+'use strict';
+
+const justCamelCase = require('just-camel-case');
+
+const {
+    types,
+    operator,
+    template,
+} = require('putout');
+
+const {replaceWith, insertBefore} = operator;
+
+const {
+    isFunction,
+    isObjectPattern,
+    isIdentifier,
+    isStringLiteral,
+    AwaitExpression,
+    ImportDeclaration,
+    ImportDefaultSpecifier,
+    Identifier,
+} = types;
+
+const camelCase = (a) => justCamelCase(a.replace('@', ''));
+
+module.exports.report = () => `Use 'ESM' instead of 'CommonJS'`;
+
+const __B = 'declarations.0.init.arguments.0';
+
+const createImport = ({name, source}) => {
+    const specifiers = [
+        ImportDefaultSpecifier(name),
+    ];
+    
+    return ImportDeclaration(specifiers, source);
+};
+
+const createFnDeclaration = template('const NAME1 = FN(NAME2)');
+const isPackage = ({value}) => /package(\.json)?$/.test(value);
+
+module.exports.match = () => ({
+    'const __a = require(__b)': ({__b}, path) => {
+        // exclude jsons while not supported
+        if (/\.json/.test(__b.value))
+            return false;
+        
+        if (path.scope.getBinding('require'))
+            return false;
+        
+        const __bPath = path.get(__B);
+        
+        const {confident, value} = __bPath.evaluate();
+        
+        if (isPackage(__b))
+            return false;
+        
+        return value && confident;
+    },
+    'require("__a")': (vars, path) => Boolean(path.parentPath.parentPath.isProgram()),
+    'const __a = __b(require(__c))': ({__a, __c}) => {
+        return isIdentifier(__a) && isStringLiteral(__c);
+    },
+    'const __a = require("__b")(__args)': checkCall,
+    'const __a = require("__b").__c(__args)': checkCall,
+});
+
+module.exports.replace = () => ({
+    'const __a = require(".")': 'import __a from "./index.js"',
+    'const __a = require(__b).default': 'import __a from "__b"',
+    'const __a = require(__b).__c': `{
+        const {__c} = require(__b);
+        const __a = __c;
+    }`,
+    'require("__a")': 'import("__a")',
+    'const __a = require(__b)': ({__a}, path) => {
+        let {value} = path
+            .get(__B)
+            .evaluate();
+        
+        if (value.includes('./') && !/\.js(on)?$/.test(value) && !value.endsWith('..'))
+            value += '.js';
+        
+        const fnPath = path.findParent(isFunction);
+        
+        if (fnPath) {
+            fnPath.node.async = true;
+            return applyDynamicImport(path);
+        }
+        
+        // disabled while not supported        // https://babeljs.io/blog/2023/05/26/7.22.0#import-attributes-15536-15620        //        // const isJSON = /\.json$/.test(value);        // const assertion = !isJSON ? '' : 'with { type: "json" }';
+        const assertion = '';
+        
+        if (isObjectPattern(__a)) {
+            const imports = [];
+            
+            for (const {key, value} of __a.properties)
+                imports.push(`${key.name} as ${value.name}`);
+            
+            const importsStr = imports.join(',');
+            
+            return `import {${importsStr}} from "${value}" ${assertion}`;
+        }
+        
+        return `import __a from "${value}" ${assertion}`;
+    },
+    'const __a = __b(require(__c))': ({__a, __b, __c}, path) => {
+        const name = `_${__a.name}`;
+        
+        const importNode = createImport({
+            name: Identifier(name),
+            source: __c,
+        });
+        
+        const declarationNode = createFnDeclaration({
+            NAME1: __a,
+            FN: __b,
+            NAME2: Identifier(name),
+        });
+        
+        insertBefore(path, [importNode]);
+        
+        return declarationNode;
+    },
+    'const __a = require("__b")(__args)': ({__b}) => {
+        const name = camelCase(__b.value);
+        
+        return `{
+            import ${name} from "__b";
+            const __a = ${name}(__args);
+        }`;
+    },
+    'const __a = require("__b").__c(__args)': ({__b}) => {
+        const name = camelCase(__b.value);
+        
+        return `{
+            import ${name} from "__b";
+            const __a = ${name}.__c(__args);
+        }`;
+    },
+});
+
+function checkCall({__b}, path) {
+    const name = camelCase(__b.value);
+    
+    if (!name)
+        return false;
+    
+    return !path.scope.bindings[name];
+}
+
+function applyDynamicImport(path) {
+    const initPath = path.get('declarations.0.init');
+    const {node} = initPath;
+    
+    initPath.node.callee.name = 'import';
+    replaceWith(initPath, AwaitExpression(node));
+    
+    return path;
+}

package/lib/convert-commonjs-to-esm.js

@@ -0,0 +1,11 @@
+'use strict';
+
+const convertCommonjsToEsmExports = require('./convert-commonjs-to-esm-exports');
+const convertCommonjsToEsmCommons = require('./convert-commonjs-to-esm-commons');
+const convertCommonjsToEsmRequire = require('./convert-commonjs-to-esm-require');
+
+module.exports.rules = {
+    'convert-commonjs-to-esm-exports': convertCommonjsToEsmExports,
+    'convert-commonjs-to-esm-common': convertCommonjsToEsmCommons,
+    'convert-commonjs-to-esm-require': convertCommonjsToEsmRequire,
+};

package/lib/convert-esm-to-commonjs/index.js

@@ -0,0 +1,57 @@
+'use strict';
+
+const {types, template} = require('putout');
+const {isImportDefaultSpecifier} = types;
+
+module.exports.report = () => `Use 'CommonJS' instead of 'ESM'`;
+
+module.exports.replace = () => ({
+    'export default __a': 'module.exports = __a',
+    'export class __a {}': 'module.exports.__a = class __a {}',
+    'export function __a(__args) {}': replaceFn,
+    'export async function __a(__args) {}': replaceFn,
+    'export const __a = __b': 'module.exports.__a = __b',
+    
+    'import "__a"': 'require("__a")',
+    'import * as __a from "__b"': 'const __a = require("__b")',
+    'import __imports from "__a"': ({__imports, __a}) => {
+        let assignment = '';
+        let destructuring = 'const {\n';
+        let hasSpecifiers = false;
+        
+        for (const currentImport of __imports) {
+            const {imported, local} = currentImport;
+            
+            if (isImportDefaultSpecifier(currentImport)) {
+                assignment = `const ${local.name} = require("__a")`;
+                continue;
+            }
+            
+            hasSpecifiers = true;
+            destructuring += `${imported.name}: ${local.name},\n`;
+        }
+        
+        destructuring += `\n} = require("${__a.value}");`;
+        
+        if (assignment && !hasSpecifiers)
+            return assignment;
+        
+        if (!assignment && hasSpecifiers)
+            return destructuring;
+        
+        return `{
+            ${assignment};
+            ${destructuring};
+        }`;
+    },
+});
+
+function replaceFn({__a}, path) {
+    const {name} = __a;
+    const {declaration} = path.node;
+    const node = template.ast.fresh(`module.exports.${name} = __x`);
+    
+    node.right = declaration;
+    
+    return node;
+}

package/lib/convert-exports-to-module-exports/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+module.exports.report = () => `Use 'module.exports' instead of 'exports'`;
+
+module.exports.replace = () => ({
+    'exports.__a': 'module.exports.__a',
+});

package/lib/index.js

@@ -10,6 +10,10 @@ const declare = require('./declare');
 const declareAfterRequire = require('./declare-after-require');
 const removeProcessExit = require('./remove-process-exit');
 const addNodePrefix = require('./add-node-prefix');
+const convertExportsToModuleExports = require('./convert-exports-to-module-exports');
+
+const convertEsmToCommonjs = require('./convert-esm-to-commonjs');
+const convertCommonjsToEsm = require('./convert-commonjs-to-esm');
 
 module.exports.rules = {
     'convert-buffer-to-buffer-alloc': convertBufferToBufferAlloc,
@@ -22,4 +26,7 @@ module.exports.rules = {
     'declare-after-require': declareAfterRequire,
     'remove-process-exit': removeProcessExit,
     'add-node-prefix': addNodePrefix,
+    'convert-exports-to-module-exports': convertExportsToModuleExports,
+    'convert-esm-to-commonjs': convertEsmToCommonjs,
+    ...convertCommonjsToEsm.rules,
 };

package/package.json

@@ -1,11 +1,16 @@
 {
   "name": "@putout/plugin-nodejs",
-  "version": "8.0.0",
+  "version": "9.0.0",
   "type": "commonjs",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "🐊Putout plugin adds ability to transform code to new API of Node.js",
   "homepage": "https://github.com/coderaiser/putout/tree/master/packages/plugin-nodejs#readme",
   "main": "lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./convert-esm-to-commonjs": "./lib/convert-esm-to-commonjs/index.js",
+    "./convert-commonjs-to-esm": "./lib/convert-commonjs-to-esm.js"
+  },
   "release": false,
   "tag": false,
   "changelog": false,
@@ -23,7 +28,9 @@
     "coverage": "madrun coverage",
     "report": "madrun report"
   },
-  "dependencies": {},
+  "dependencies": {
+    "just-camel-case": "^6.2.0"
+  },
   "keywords": [
     "putout",
     "putout-plugin",
@@ -31,21 +38,19 @@
     "nodejs"
   ],
   "devDependencies": {
-    "@putout/plugin-convert-commonjs-to-esm": "*",
-    "@putout/plugin-convert-esm-to-commonjs": "*",
     "@putout/plugin-putout": "*",
     "@putout/test": "^7.0.0",
     "c8": "^8.0.0",
     "eslint": "^8.0.1",
     "eslint-plugin-n": "^16.0.0",
-    "eslint-plugin-putout": "^20.0.0",
+    "eslint-plugin-putout": "^21.0.0",
     "lerna": "^6.0.1",
     "madrun": "^9.0.0",
     "montag": "^1.2.1",
     "nodemon": "^3.0.1"
   },
   "peerDependencies": {
-    "putout": ">=32"
+    "putout": ">=33"
   },
   "license": "MIT",
   "engines": {