@putout/plugin-esm 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) coderaiser
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,221 @@
+# @putout/plugin-esm [![NPM version][NPMIMGURL]][NPMURL]
+
+[NPMIMGURL]: https://img.shields.io/npm/v/@putout/plugin-esm.svg?style=flat&longCache=true
+[NPMURL]: https://npmjs.org/package/@putout/plugin-esm "npm"
+
+> The static `import` statement is used to `import` read only live bindings which are exported by another module.
+> The imported bindings are called live bindings because they are updated by the module that exported the binding, but cannot be re-assigned by the importing module.
+>
+> (c) [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import)
+
+
+🐊[**Putout**](https://github.com/coderaiser/putout) plugin adds ability to transform to new **Node.js** API and apply best practices.
+
+## Install
+
+```
+npm i putout @putout/plugin-esm -D
+```
+
+## Rules
+
+- ✅ [declare-imports-first](#declare-imports-first);
+- ✅ [group-imports-by-source](#group-imports-by-source);
+- ✅ [merge-duplicate-imports](#merge-duplicate-imports);
+- ✅ [remove-quotes-from-import-assertions](#remove-quotes-from-import-assertions);
+- ✅ [remove-empty-import](#remove-empty-import);
+- ✅ [remove-empty-export](#remove-empty-export);
+- ✅ [sort-imports-by-specifiers](#sort-imports-by-specifiers);
+
+## Config
+
+```json
+{
+    "rules": {
+        "esm/declare-imports-first": "on",
+        "esm/group-imports-by-source": "on",
+        "esm/merge-duplicate-imports": "on",
+        "esm/remove-quotes-from-import-assertions": "on",
+        "esm/remove-empty-export": "on",
+        "esm/remove-empty-import": ["on", {
+            "ignore": []
+        }],
+        "esm/sort-imports-by-specifiers": "on"
+    }
+}
+```
+
+## declare-imports-first
+
+Check out in 🐊[**Putout Editor**](https://putout.cloudcmd.io/#/gist/b1c18e5d726afe4ebb69d6b7a7dda82b/8189590815a1b8adb35bb8a846e28228e3c7fadf). For **CommonJS** use [nodejs/declare-after-require](https://github.com/coderaiser/putout/tree/master/packages/plugin-nodejs#declare-after-require).
+
+## ❌ Example of incorrect code
+
+```js
+const [arg] = process.argv;
+import esbuild from 'esbuild';
+```
+
+## ✅ Example of correct code
+
+```js
+import esbuild from 'esbuild';
+
+const [arg] = process.argv;
+```
+
+## group-imports-by-source
+
+Group order:
+
+- ✅ builtins;
+- ✅ external;
+- ✅ internal;
+
+Checkout in 🐊[**Putout Editor**](https://putout.cloudcmd.io/#/gist/3cc782acf95211f9d456d63a99032ee1/0674223d050bba572f5271ffdccf8616cb441af5).
+
+## ❌ Example of incorrect code
+
+```js
+import fs from 'node:fs';
+import {lodash} from 'lodash';
+import react from 'react';
+import d from '../hello.js';
+import ss from '../../bb/ss.js';
+import b from './ss.js';
+
+const c = 5;
+```
+
+## ✅ Example of correct code
+
+```js
+import fs from 'node:fs';
+import react from 'react';
+import {lodash} from 'lodash';
+import b from './ss.js';
+import d from '../hello.js';
+import ss from '../../bb/ss.js';
+
+const c = 5;
+```
+
+## merge-duplicate-imports
+
+### join
+
+To disable use:
+
+```json
+{
+    "rules": {
+        "esm/merge-duplicate-imports-join": "off"
+    }
+}
+```
+
+#### ❌ Example of incorrect code
+
+```js
+import test from 'supertape';
+import {stub} from 'supertape';
+```
+
+#### ✅ Example of correct code
+
+```js
+import test, {stub} from 'supertape';
+```
+
+### rename
+
+Checkout in 🐊[**Putout Editor**](https://putout.cloudcmd.io/#/gist/6604936dec6b1eed8ce0d143f2962f15/17b310a6e4d85b0b8615a8b91d0e27414e8af291).
+
+To disable use:
+
+```json
+{
+    "rules": {
+        "esm/merge-duplicate-imports-rename": "off"
+    }
+}
+#### ❌ Example of incorrect code
+
+```js
+import putout from './putout.js';
+import all from './putout.js';
+import x from './putout.js';
+
+console.log(all);
+console.log(x);
+```
+
+#### ✅ Example of correct code
+
+```js
+import putout from './putout.js';
+
+console.log(putout);
+console.log(putout);
+```
+
+## remove-empty-export
+
+```diff
+-export {};
+```
+
+## remove-empty-import
+
+```diff
+-import 'abc';
+```
+
+
+## remove-quotes-from-import-assertions
+
+Checkout in 🐊[**Putout Editor**](https://putout.cloudcmd.io/#/gist/f9f34acddbefba0ded53225ca10fa44e/7b4dba44602b9b2d28fe3a98989474a4b0d8d73d).
+
+## ❌ Example of incorrect code
+
+```js
+import json from './mod.json' with { type: 'json' };
+```
+
+## ✅ Example of correct code
+
+```js
+import json from './mod.json' with { type: 'json' };
+```
+
+## sort-imports-by-specifiers
+
+Checkout in 🐊[**Putout Editor**](https://putout.cloudcmd.io/#/gist/521e2ff199243a7ce1f65db7140c272e/28c0588281286f8a6765b8aa2ecabbfcde2973a7).
+
+## ❌ Example of incorrect code
+
+```js
+import {
+    a,
+    b,
+    c,
+    d,
+} from 'd';
+import a1 from 'a1';
+```
+
+## ✅ Example of correct code
+
+```js
+import a1 from 'a1';
+import {
+    a,
+    b,
+    c,
+    d,
+} from 'd';
+```
+
+## License
+
+MIT

package/lib/declare-imports-first/index.js

@@ -0,0 +1,63 @@
+'use strict';
+
+const {replaceWith} = require('putout').operator;
+
+module.exports.report = () => `Declare imports first`;
+
+module.exports.fix = ({path, importPath}) => {
+    let prev = path;
+    let preventInfiniteLoop = 500;
+    
+    while (--preventInfiniteLoop) {
+        const {node} = importPath;
+        
+        replaceWith(importPath, prev.node);
+        replaceWith(prev, node);
+        
+        importPath = prev;
+        prev = prev.getPrevSibling();
+        
+        if (!prev.node || prev.isImportDeclaration())
+            return;
+    }
+};
+
+module.exports.traverse = ({push, pathStore}) => ({
+    ImportDeclaration: (path) => {
+        pathStore(path);
+    },
+    ExportNamedDeclaration: (path) => {
+        const {source} = path.node;
+        
+        if (!source)
+            return;
+        
+        pathStore(path);
+    },
+    ExportAllDeclaration: (path) => {
+        pathStore(path);
+    },
+    Program: {
+        exit: () => {
+            for (const importPath of pathStore()) {
+                if (importPath) {
+                    const path = importPath.getPrevSibling();
+                    
+                    if (!path.node)
+                        continue;
+                    
+                    if (path.isImportDeclaration())
+                        continue;
+                    
+                    if (path.isExportDeclaration())
+                        continue;
+                    
+                    push({
+                        path,
+                        importPath,
+                    });
+                }
+            }
+        },
+    },
+});

package/lib/group-imports-by-source/index.js

@@ -0,0 +1,70 @@
+'use strict';
+
+const {isDeepStrictEqual} = require('node:util');
+const {types, operator} = require('putout');
+const {isImportDeclaration} = types;
+
+const {
+    replaceWithMultiple,
+    remove,
+} = operator;
+
+module.exports.report = () => `Group imports by source: 'builtins', 'external', 'internal'`;
+
+module.exports.fix = ({grouped}) => {
+    const [first, ...others] = grouped;
+    const nodes = [first.node];
+    
+    for (const current of others) {
+        const {node} = current;
+        remove(current);
+        nodes.push(node);
+    }
+    
+    replaceWithMultiple(first, nodes);
+};
+
+module.exports.traverse = ({pathStore, push}) => ({
+    ImportDeclaration: pathStore,
+    Program: {
+        exit(path) {
+            const external = [];
+            const internal = [];
+            const builtin = [];
+            const all = pathStore().filter(isImportDeclaration);
+            
+            if (!all.length)
+                return;
+            
+            for (const current of all) {
+                const {value} = current.node.source;
+                
+                if (value.startsWith('.')) {
+                    internal.push(current);
+                    continue;
+                }
+                
+                if (value.startsWith('node:')) {
+                    builtin.push(current);
+                    continue;
+                }
+                
+                external.push(current);
+            }
+            
+            const grouped = [
+                ...builtin,
+                ...external,
+                ...internal,
+            ];
+            
+            if (isDeepStrictEqual(all, grouped))
+                return;
+            
+            push({
+                path,
+                grouped,
+            });
+        },
+    },
+});

package/lib/index.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const declareImportsFirst = require('./declare-imports-first');
+const groupImportsBySource = require('./group-imports-by-source');
+const mergeDuplicateImportsJoin = require('./merge-duplicate-imports-join');
+const mergeDuplicateImportsRename = require('./merge-duplicate-imports-rename');
+const removeQuotesFromImportAssertions = require('./remove-quotes-from-import-assertions');
+const sortImportsBySpecifiers = require('./sort-imports-by-specifiers');
+const removeEmptyImport = require('./remove-empty-import');
+const removeEmptyExport = require('./remove-empty-export');
+
+module.exports.rules = {
+    'declare-imports-first': declareImportsFirst,
+    'group-imports-by-source': groupImportsBySource,
+    'merge-duplicate-imports-join': mergeDuplicateImportsJoin,
+    'merge-duplicate-imports-rename': mergeDuplicateImportsRename,
+    'remove-quotes-from-import-assertions': removeQuotesFromImportAssertions,
+    'remove-empty-import': removeEmptyImport,
+    'remove-empty-export': removeEmptyExport,
+    'sort-imports-by-specifiers': sortImportsBySpecifiers,
+};

package/lib/merge-duplicate-imports-join/index.js

@@ -0,0 +1,109 @@
+'use strict';
+
+const {types, operator} = require('putout');
+
+const {remove} = operator;
+const {values} = Object;
+
+const {
+    isImportDefaultSpecifier,
+    isImportNamespaceSpecifier,
+    isImportDeclaration,
+} = types;
+
+module.exports.report = () => `Avoid duplicate imports`;
+
+module.exports.fix = ({path, imports}) => {
+    const all = [];
+    
+    for (const imp of imports) {
+        const {specifiers} = imp.node;
+        
+        for (const spec of specifiers) {
+            if (isImportDefaultSpecifier(spec)) {
+                path.node.specifiers.unshift(spec);
+                continue;
+            }
+            
+            all.push(spec);
+        }
+        
+        remove(imp);
+    }
+    
+    path.node.specifiers.push(...all);
+};
+
+module.exports.traverse = ({push, pathStore}) => ({
+    ImportDeclaration(path) {
+        pathStore(path);
+    },
+    Program: {
+        exit: () => {
+            const imports = pathStore().filter(isImportDeclaration);
+            processImports(push, imports);
+        },
+    },
+});
+
+function processImports(push, imports) {
+    const {get, add} = duplicatesStore();
+    const importDefaults = new Map();
+    
+    for (const path of imports) {
+        const {source, specifiers} = path.node;
+        
+        const {value} = source;
+        
+        if (specifiers.find(isImportNamespaceSpecifier))
+            continue;
+        
+        const count = importDefaults.get(value) || 0;
+        
+        const importDefaultCount = count + specifiers.filter(isImportDefaultSpecifier).length;
+        
+        importDefaults.set(value, importDefaultCount);
+    }
+    
+    for (const path of imports) {
+        const {source, specifiers} = path.node;
+        
+        const {value} = source;
+        
+        if (specifiers.find(isImportNamespaceSpecifier))
+            continue;
+        
+        if (importDefaults.get(value) > 1)
+            continue;
+        
+        add(value, path);
+    }
+    
+    for (const list of get()) {
+        if (list.length === 1)
+            continue;
+        
+        const [path, ...imports] = list;
+        
+        push({
+            path,
+            imports,
+        });
+    }
+}
+
+function duplicatesStore() {
+    const duplicates = [];
+    
+    const get = () => values(duplicates);
+    
+    const add = (value, path) => {
+        duplicates[value] = duplicates[value] || [];
+        duplicates[value].push(path);
+    };
+    
+    return {
+        get,
+        add,
+    };
+}

package/lib/merge-duplicate-imports-rename/index.js

@@ -0,0 +1,53 @@
+'use strict';
+
+const {types, operator} = require('putout');
+const {rename, remove} = operator;
+const {isImportDefaultSpecifier} = types;
+
+module.exports.report = () => 'Avoid duplicate imports';
+
+module.exports.fix = ({path, imports}) => {
+    const {name} = path.node.specifiers[0].local;
+    remove(path);
+    
+    const [first, ...other] = imports;
+    
+    const firstName = first.node.specifiers[0].local.name;
+    rename(first, firstName, name);
+    
+    for (const current of other) {
+        const currentName = current.node.specifiers[0].local.name;
+        rename(current, currentName, name);
+        remove(current);
+    }
+};
+
+module.exports.traverse = ({push, uplist}) => ({
+    ImportDeclaration: (path) => {
+        const {value} = path.node.source;
+        const [specifier, ...other] = path.node.specifiers;
+        
+        if (other.length)
+            return;
+        
+        if (!isImportDefaultSpecifier(specifier))
+            return;
+        
+        uplist(value, path);
+    },
+    Program: {
+        exit() {
+            for (const items of uplist()) {
+                if (items.length < 2)
+                    continue;
+                
+                const [path, ...imports] = items;
+                
+                push({
+                    path,
+                    imports,
+                });
+            }
+        },
+    },
+});

package/lib/remove-empty-export/index.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const {operator} = require('putout');
+const {remove} = operator;
+
+module.exports.report = () => 'Remove empty export';
+
+module.exports.fix = (path) => {
+    remove(path);
+};
+
+module.exports.include = () => [
+    'ExportNamedDeclaration',
+];
+
+module.exports.filter = (path) => {
+    const {specifiers, declaration} = path.node;
+    
+    return !declaration && !specifiers.length;
+};

package/lib/remove-empty-import/index.js

@@ -0,0 +1,35 @@
+'use strict';
+
+const {operator} = require('putout');
+const {remove} = operator;
+
+module.exports.report = () => `Avoid empty 'import' statement`;
+
+module.exports.fix = (path) => {
+    remove(path);
+};
+
+const isCSS = (a) => /\.css/.test(a);
+const isMin = (a) => /\.min\./.test(a);
+
+module.exports.include = () => [
+    'ImportDeclaration',
+];
+
+module.exports.filter = (path, {options}) => {
+    const {specifiers, source} = path.node;
+    
+    const {ignore = []} = options;
+    const {value} = source;
+    
+    if (ignore.includes(value))
+        return false;
+    
+    if (specifiers.length)
+        return false;
+    
+    if (isCSS(value))
+        return false;
+    
+    return !isMin(value);
+};

package/lib/remove-quotes-from-import-assertions/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+module.exports.report = () => 'Remove quotes from import assertions';
+
+module.exports.replace = () => ({
+    'import __imports from "__a" with {"type": "__b"}': 'import __imports from "__a" with {type: "__b"}',
+});

package/lib/sort-imports-by-specifiers/index.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const {parseImportSpecifiers} = require('parse-import-specifiers');
+const {operator} = require('putout');
+const {insertBefore, remove} = operator;
+
+module.exports.report = () => `Sort imports by specifiers count`;
+
+module.exports.fix = ({path, nextPath}) => {
+    const {node} = nextPath;
+    remove(nextPath);
+    insertBefore(path, node);
+};
+
+module.exports.traverse = ({push}) => ({
+    ImportDeclaration(path) {
+        const {node} = path;
+        const {source, specifiers} = node;
+        const {imports} = parseImportSpecifiers(specifiers);
+        
+        if (imports.length < 4)
+            return;
+        
+        const nextPath = path.getNextSibling();
+        
+        if (!nextPath.isImportDeclaration())
+            return;
+        
+        if (nextPath.node.specifiers.length !== 1)
+            return;
+        
+        if (!source.value.startsWith('./') && nextPath.node.source.value.startsWith('./'))
+            return;
+        
+        if (source.value.startsWith('node:') && !nextPath.node.source.value.startsWith('node:'))
+            return;
+        
+        push({
+            path,
+            nextPath,
+        });
+    },
+});

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@putout/plugin-esm",
+  "version": "1.0.0",
+  "type": "commonjs",
+  "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
+  "description": "🐊Putout plugin improves ability to transform ESM code",
+  "homepage": "https://github.com/coderaiser/putout/tree/master/packages/plugin-esm#readme",
+  "main": "lib/index.js",
+  "exports": {
+    ".": "./lib/index.js"
+  },
+  "release": false,
+  "tag": false,
+  "changelog": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/coderaiser/putout.git"
+  },
+  "scripts": {
+    "test": "madrun test",
+    "watch:test": "madrun watch:test",
+    "lint": "madrun lint",
+    "fresh:lint": "madrun fresh:lint",
+    "lint:fresh": "madrun lint:fresh",
+    "fix:lint": "madrun fix:lint",
+    "coverage": "madrun coverage",
+    "report": "madrun report"
+  },
+  "dependencies": {},
+  "keywords": [
+    "putout",
+    "putout-plugin",
+    "plugin",
+    "esm"
+  ],
+  "devDependencies": {
+    "@putout/eslint-flat": "^2.0.0",
+    "@putout/plugin-declare": "*",
+    "@putout/plugin-declare-before-reference": "*",
+    "@putout/plugin-putout": "*",
+    "@putout/plugin-reuse-duplicate-init": "*",
+    "@putout/plugin-typescript": "*",
+    "@putout/test": "^11.0.0",
+    "c8": "^10.0.0",
+    "eslint": "^9.0.0",
+    "eslint-plugin-n": "^17.0.0",
+    "eslint-plugin-putout": "^23.0.0",
+    "lerna": "^6.0.1",
+    "madrun": "^10.0.0",
+    "montag": "^1.2.1",
+    "nodemon": "^3.0.1"
+  },
+  "peerDependencies": {
+    "putout": ">=37"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}