eslint-plugin-putout 29.3.0 → 29.4.0

package/eslint-v10/babel.js

@@ -2,23 +2,21 @@
  * @fileoverview Wrapper around @babel-eslint/parser to make it work with ESLint v10.
  * @author Milos Djermanovic
  */
-
-'use strict';
-
 //-----------------------------------------------------------------------------
 // Requirements
 //-----------------------------------------------------------------------------
-const eslintScope = require('eslint-scope');
-
-const babelESLintParser = require('@babel/eslint-parser/experimental-worker');
+import * as eslintScope from 'eslint-scope';
+import babelESLintParser from '@babel/eslint-parser/experimental-worker';
 
 //------------------------------------------------------------------------------
 // Type Definitions
 //------------------------------------------------------------------------------
+
 /** @typedef {import("eslint-scope").ScopeManager} ScopeManager */
 //-----------------------------------------------------------------------------
 // Helpers
 //-----------------------------------------------------------------------------
+
 /**
  * Add global variables and resolve references to all global variables.
  * @this {ScopeManager}
@@ -92,7 +90,7 @@ function addGlobals(names) {
 //-----------------------------------------------------------------------------
 // Exports
 //-----------------------------------------------------------------------------
-module.exports = {
+export default {
     ...babelESLintParser,
     parseForESLint(...args) {
         const retv = babelESLintParser.parseForESLint(...args);

package/eslint-v10/ts.js

@@ -2,22 +2,21 @@
  * @fileoverview Wrapper around @typescript-eslint/parser to make it work with ESLint v10.
  * @author Milos Djermanovic
  */
-
-'use strict';
-
 //-----------------------------------------------------------------------------
 // Requirements
 //-----------------------------------------------------------------------------
-const eslintScope = require('eslint-scope');
-const typescriptESLintParser = require('@typescript-eslint/parser');
+import * as eslintScope from 'eslint-scope';
+import typescriptESLintParser from '@typescript-eslint/parser';
 
 //------------------------------------------------------------------------------
 // Type Definitions
 //------------------------------------------------------------------------------
+
 /** @typedef {import("eslint-scope").ScopeManager} ScopeManager */
 //-----------------------------------------------------------------------------
 // Helpers
 //-----------------------------------------------------------------------------
+
 /**
  * Add global variables and resolve references to all global variables.
  * @this {ScopeManager}
@@ -89,7 +88,7 @@ function addGlobals(names) {
 //-----------------------------------------------------------------------------
 // Exports
 //-----------------------------------------------------------------------------
-module.exports = {
+export default {
     ...typescriptESLintParser,
     parseForESLint(...args) {
         const retv = typescriptESLintParser.parseForESLint(...args);

package/lib/add-newline-after-function-call/index.js

@@ -1,6 +1,5 @@
-'use strict';
+import {types} from 'putout';
 
-const {types} = require('putout');
 const {
     isBlockStatement,
     isExpressionStatement,
@@ -11,10 +10,10 @@ const {
 
 const regExp = /^;?\n( +)?\n( +)?/;
 
-module.exports.category = 'layout';
-module.exports.report = () => 'Add newline after function call';
+export const category = 'layout';
+export const report = () => 'Add newline after function call';
 
-module.exports.filter = ({node, getCommentsAfter, getSpacesAfterNode}) => {
+export const filter = ({node, getCommentsAfter, getSpacesAfterNode}) => {
     if (!isExpressionStatement(node.parent))
         return false;
     
@@ -76,10 +75,10 @@ module.exports.filter = ({node, getCommentsAfter, getSpacesAfterNode}) => {
     return false;
 };
 
-module.exports.fix = ({text}) => {
+export const fix = ({text}) => {
     return `${text};\n`;
 };
 
-module.exports.include = () => [
+export const include = () => [
     'CallExpression',
 ];

package/lib/add-newline-before-function-call/index.js

@@ -1,6 +1,5 @@
-'use strict';
+import {types} from 'putout';
 
-const {types} = require('putout');
 const {
     isBlockStatement,
     isVariableDeclaration,
@@ -11,9 +10,9 @@ const {
 //const regExp = /^\n( +)?\n( +)?$/;
 const regExp = /^\n(\s+)?\n(\s+)?((\n(\s+)+)?)$/;
 
-module.exports.report = () => 'Add newline before expression';
+export const report = () => 'Add newline before expression';
 
-module.exports.filter = ({text, node, getCommentsBefore, getSpacesBeforeNode}) => {
+export const filter = ({text, node, getCommentsBefore, getSpacesBeforeNode}) => {
     if (!isExpressionStatement(node.parent))
         return false;
     
@@ -61,11 +60,11 @@ module.exports.filter = ({text, node, getCommentsBefore, getSpacesBeforeNode}) =
     return false;
 };
 
-module.exports.fix = ({text}) => {
+export const fix = ({text}) => {
     return `\n${text}`;
 };
 
-module.exports.include = () => [
+export const include = () => [
     'CallExpression',
     'AssignmentExpression',
 ];

package/lib/add-newline-before-return/index.js

@@ -1,10 +1,8 @@
-'use strict';
-
 const regExp = /^\n( +)?\n +$/;
 
-module.exports.report = () => `Add newline before 'return'`;
+export const report = () => `Add newline before 'return'`;
 
-module.exports.filter = ({text, node, getCommentsBefore, getSpacesBeforeNode}) => {
+export const filter = ({text, node, getCommentsBefore, getSpacesBeforeNode}) => {
     if (getCommentsBefore(node).length)
         return false;
     
@@ -43,10 +41,10 @@ module.exports.filter = ({text, node, getCommentsBefore, getSpacesBeforeNode}) =
     return !(count < 1);
 };
 
-module.exports.fix = ({text}) => {
+export const fix = ({text}) => {
     return `\n${text}`;
 };
 
-module.exports.include = () => [
+export const include = () => [
     'ReturnStatement',
 ];

package/lib/add-newlines-between-specifiers/index.js

@@ -1,13 +1,11 @@
-'use strict';
+export const category = 'layout';
+export const report = () => 'Add newlines between specifiers';
 
-module.exports.category = 'layout';
-module.exports.report = () => 'Add newlines between specifiers';
-
-module.exports.include = () => [
+export const include = () => [
     'ExportNamedDeclaration',
 ];
 
-module.exports.fix = ({text}) => {
+export const fix = ({text}) => {
     return text
         .replace(/,\s+/g, ',\n    ')
         .replace(/{/g, '{\n')
@@ -16,7 +14,7 @@ module.exports.fix = ({text}) => {
         .replace(/\n+}/g, '\n}');
 };
 
-module.exports.filter = ({text, node}) => {
+export const filter = ({text, node}) => {
     const regExp = /, +?[a-zA-Z]/g;
     
     if (node.specifiers.length < 4)

package/lib/add-newlines-between-types-in-union/index.js

@@ -1,14 +1,13 @@
-'use strict';
+import {types} from 'putout';
 
-const {types} = require('putout');
 const {isTSTypeAliasDeclaration} = types;
 
-module.exports.category = 'typescript';
-module.exports.report = () => 'Add newlines between types in union';
+export const category = 'typescript';
+export const report = () => 'Add newlines between types in union';
 
 const regExp = /[^\n]\|\s[A-Za-z]/;
 
-module.exports.filter = ({text, node}) => {
+export const filter = ({text, node}) => {
     if (!isTSTypeAliasDeclaration(node.parent))
         return false;
     
@@ -21,8 +20,8 @@ module.exports.filter = ({text, node}) => {
     return regExp.test(text);
 };
 
-module.exports.fix = ({text}) => '\n    | ' + text.replace(/\s\|/g, '\n    |');
+export const fix = ({text}) => '\n    | ' + text.replace(/\s\|/g, '\n    |');
 
-module.exports.include = () => [
+export const include = () => [
     'TSUnionType',
 ];

package/lib/align-spaces/index.js

@@ -1,17 +1,16 @@
-'use strict';
+import alignSpaces from 'align-spaces';
 
-const alignSpaces = require('align-spaces');
 const alignedMap = new Map();
 
-module.exports.report = () => 'Keep whitespaces in blank lines';
+export const report = () => 'Keep whitespaces in blank lines';
 
-module.exports.include = () => ['Program'];
+export const include = () => ['Program'];
 
-module.exports.fix = ({text}) => {
+export const fix = ({text}) => {
     return alignedMap.get(text);
 };
 
-module.exports.filter = ({text}) => {
+export const filter = ({text}) => {
     const aligned = alignSpaces(text);
     
     if (text === aligned)

package/lib/array-element-newline/index.js

@@ -1,6 +1,5 @@
-'use strict';
+import {types} from 'putout';
 
-const {types} = require('putout');
 const {
     isArrayExpression,
     isMemberExpression,
@@ -11,8 +10,8 @@ const isString = (a) => typeof a === 'string';
 const isBool = (a) => typeof a === 'boolean';
 const isNumber = (a) => typeof a === 'number';
 
-module.exports.category = 'array';
-module.exports.report = () => 'Add newlines between array elements';
+export const category = 'array';
+export const report = () => 'Add newlines between array elements';
 
 const regexp = /['"\da-zA-Z]+, ['"\da-zA-Z]/;
 
@@ -26,7 +25,7 @@ const isSupportedNode = (a) => {
     return a.type === 'Identifier';
 };
 
-module.exports.filter = ({text, node}) => {
+export const filter = ({text, node}) => {
     if (isMemberExpression(node.parent))
         return false;
     
@@ -62,14 +61,14 @@ module.exports.filter = ({text, node}) => {
     return regexp.test(text);
 };
 
-module.exports.fix = ({text}) => {
+export const fix = ({text}) => {
     return text
         .replace(/\[/g, '[\n')
         .replace(/\]/g, '\n]')
         .replace(/,/g, ',\n');
 };
 
-module.exports.include = () => [
+export const include = () => [
     'ArrayExpression',
 ];
 

package/lib/common.js

@@ -1,8 +1,8 @@
-'use strict';
+import {types} from 'putout';
 
-const {isImportDefaultSpecifier} = require('putout').types;
+const {isImportDefaultSpecifier} = types;
 
-module.exports.isCorrectLoc = (line, properties) => {
+export const isCorrectLoc = (line, properties) => {
     for (const [i, prop] of properties.entries()) {
         if (prop.loc.start.line < i + line + 1)
             return false;
@@ -11,7 +11,7 @@ module.exports.isCorrectLoc = (line, properties) => {
     return true;
 };
 
-module.exports.isCorrectImportLoc = (line, specifiers) => {
+export const isCorrectImportLoc = (line, specifiers) => {
     if (!isImportDefaultSpecifier(specifiers[0]))
         ++line;
     

package/lib/destructuring-as-function-argument/index.js

@@ -1,11 +1,9 @@
-'use strict';
+export const category = 'destructuring';
+export const report = () => 'Keep curly braces on one line when you use destructuring as function argument';
 
-module.exports.category = 'destructuring';
-module.exports.report = () => 'Keep curly braces on one line when you use destructuring as function argument';
+export const filter = ({text}) => /\n/.test(text);
 
-module.exports.filter = ({text}) => /\n/.test(text);
-
-module.exports.fix = ({text}) => {
+export const fix = ({text}) => {
     return text
         .replace(/\n/g, '')
         .replace(/ /g, '')
@@ -14,7 +12,7 @@ module.exports.fix = ({text}) => {
 };
 
 // can't use because of an error// ':has(ArrowFunctionExpression, FunctionExpression, FunctionDeclaration) > .params[type=ObjectPattern]'// Error: Unknown node type JSXElement
-module.exports.include = () => [
+export const include = () => [
     'ArrowFunctionExpression > .params[type=ObjectPattern]',
     'FunctionExpression > .params[type=ObjectPattern]',
     'FunctionDeclaration > .params[type=ObjectPattern]',

package/lib/evaluate/index.js

@@ -1,20 +1,21 @@
-'use strict';
+import {dirname} from 'node:path';
+import {createRequire} from 'node:module';
+import putout from 'putout';
 
-const {dirname} = require('node:path');
-const putout = require('putout');
+const require = createRequire(import.meta.url);
 
-module.exports.category = 'evaluate';
-module.exports.report = () => 'Evaluate expression';
-module.exports.include = () => [
+export const category = 'evaluate';
+export const report = () => 'Evaluate expression';
+export const include = () => [
     'ImportDeclaration',
 ];
 
-module.exports.filter = ({node}) => {
+export const filter = ({node}) => {
     const {value} = node.source;
     return value.startsWith('__putout_evaluate:');
 };
 
-module.exports.fix = ({text, node, filename}) => {
+export const fix = ({text, node, filename}) => {
     const {value} = node.source;
     
     const result = evaluate({
@@ -27,6 +28,7 @@ module.exports.fix = ({text, node, filename}) => {
 
 function evaluate({value, filename}) {
     value = value.replace(/__putout_evaluate:\s?/, 'return ');
+    
     const {code} = putout(value, {
         fix: true,
         rules: {

package/lib/for-of-multiple-properties-destructuring/index.js

@@ -1,22 +1,20 @@
-'use strict';
+export const category = 'destructuring';
+export const report = () => 'Keep all properties in one line when using destructuring in for-of';
 
-module.exports.category = 'destructuring';
-module.exports.report = () => 'Keep all properties in one line when using destructuring in for-of';
-
-module.exports.include = ({options}) => {
+export const include = ({options}) => {
     const {maxProperties = 8} = options[0] || {};
     
     return [`VariableDeclarator[id.type="ObjectPattern"][id.properties.length<${maxProperties}]`];
 };
 
-module.exports.filter = ({node, text}) => {
+export const filter = ({node, text}) => {
     if (node.parent.parent.type !== 'ForOfStatement')
         return false;
     
     return text.includes('\n');
 };
 
-module.exports.fix = ({text}) => {
+export const fix = ({text}) => {
     return text
         .replace(/\n/g, '')
         .replace(/,/g, ', ')

package/lib/function-declaration-paren-newline/index.js

@@ -1,10 +1,8 @@
-'use strict';
-
-module.exports.report = () => {
+export const report = () => {
     return `Unexpected new lines around arguments`;
 };
 
-module.exports.fix = ({text, node, getText}) => {
+export const fix = ({text, node, getText}) => {
     const {body} = node.body;
     
     node.body.body = [];
@@ -23,13 +21,13 @@ module.exports.fix = ({text, node, getText}) => {
     return text.replace(paramsText, newText);
 };
 
-module.exports.include = () => [
+export const include = () => [
     'FunctionDeclaration',
     'FunctionExpression',
     'ArrowFunctionExpression',
 ];
 
-module.exports.filter = ({text}) => {
+export const filter = ({text}) => {
     const beforeCloseIndex = text.indexOf(')');
     const beforeCloseText = text.slice(0, beforeCloseIndex);
     

package/lib/{index.mjs → index.js}

@@ -1,11 +1,11 @@
 import config from '@putout/eslint-config';
 import nPlugin from 'eslint-plugin-n';
-import markdown from './markdown.mjs';
-import json from './json.mjs';
-import html from './html.mjs';
-import ts from './ts.mjs';
-import jsxConfig, {jsx} from './jsx.mjs';
-import * as putout from './plugin.mjs';
+import markdown from './markdown.js';
+import json from './json.js';
+import html from './html.js';
+import ts from './ts.js';
+import jsxConfig, {jsx} from './jsx.js';
+import * as putout from './plugin.js';
 
 const n = nPlugin.configs['flat/mixed-esm-and-cjs'];
 

package/lib/{json.mjs → json.js}

@@ -1,5 +1,5 @@
 import stylistic from '@stylistic/eslint-plugin';
-import * as putout from './plugin.mjs';
+import * as putout from './plugin.js';
 
 export default [{
     name: 'putout: json',

package/lib/long-properties-destructuring/index.js

@@ -1,7 +1,6 @@
-'use strict';
+import {types} from 'putout';
+import {isCorrectLoc} from '../common.js';
 
-const {types} = require('putout');
-const {isCorrectLoc} = require('../common');
 const {
     isImportDeclaration,
     isForOfStatement,
@@ -20,15 +19,15 @@ const parseOptions = (options) => {
 
 const notImportDefaultSpecifier = (a) => a.type !== 'ImportDefaultSpecifier';
 
-module.exports.category = 'destructuring';
-module.exports.report = () => 'Keep each property on separate lines when destructuring long properties';
+export const category = 'destructuring';
+export const report = () => 'Keep each property on separate lines when destructuring long properties';
 
-module.exports.include = () => [
+export const include = () => [
     'VariableDeclarator[id.type="ObjectPattern"][id.properties.length>=2]',
     'ImportDeclaration[specifiers.length>=2]',
 ];
 
-module.exports.fix = ({text}) => {
+export const fix = ({text}) => {
     const end = text.indexOf('}') + 1;
     
     const startText = text
@@ -42,7 +41,7 @@ module.exports.fix = ({text}) => {
     return `${startText}${endText}`;
 };
 
-module.exports.filter = ({node}, options) => {
+export const filter = ({node}, options) => {
     const {parent} = node.parent;
     const {maxLength} = parseOptions(options);
     

package/lib/{markdown.mjs → markdown.js}

@@ -1,8 +1,8 @@
 import * as parserOpts from '@putout/engine-parser/babel/options';
 import parserPlugins from '@putout/engine-parser/babel/plugins';
 import babel from '#babel/eslint-parser/experimental-worker';
-import tsConfig from './ts.mjs';
-import {jsx} from './jsx.mjs';
+import tsConfig from './ts.js';
+import {jsx} from './jsx.js';
 
 const [ts, tsx] = tsConfig;
 

package/lib/multiple-properties-destructuring/index.js

@@ -1,15 +1,14 @@
-'use strict';
-
-const {isImportDeclaration} = require('putout').types;
-const {parseImportSpecifiers} = require('parse-import-specifiers');
-
-const {
+import {types} from 'putout';
+import {parseImportSpecifiers} from 'parse-import-specifiers';
+import {
     isCorrectLoc,
     isCorrectImportLoc,
-} = require('../common');
+} from '../common.js';
+
+const {isImportDeclaration} = types;
 
-module.exports.category = 'destructuring';
-module.exports.report = () => 'Keep each property on separate lines when using multiple destructuring properties';
+export const category = 'destructuring';
+export const report = () => 'Keep each property on separate lines when using multiple destructuring properties';
 
 const parseOptions = (options) => {
     const {minProperties = 2} = options[0] || {};
@@ -19,7 +18,7 @@ const parseOptions = (options) => {
     };
 };
 
-module.exports.include = ({options}) => {
+export const include = ({options}) => {
     const {minProperties} = parseOptions(options);
     
     return [
@@ -28,7 +27,7 @@ module.exports.include = ({options}) => {
     ];
 };
 
-module.exports.filter = ({node}, options) => {
+export const filter = ({node}, options) => {
     const {minProperties} = parseOptions(options);
     const {line} = node.loc.start;
     
@@ -55,7 +54,7 @@ module.exports.filter = ({node}, options) => {
     return !isCorrectLoc(line, properties);
 };
 
-module.exports.fix = ({text}) => {
+export const fix = ({text}) => {
     return text
         .replace(/,/g, ',\n')
         .replace('{', '{\n')

package/lib/newline-function-call-arguments/index.js

@@ -1,12 +1,10 @@
-'use strict';
+export const report = () => 'Add new line before and after arguments in a function call';
 
-module.exports.report = () => 'Add new line before and after arguments in a function call';
-
-module.exports.include = () => [
+export const include = () => [
     'CallExpression',
 ];
 
-module.exports.filter = ({node, text}) => {
+export const filter = ({node, text}) => {
     if (node.callee.type !== 'Identifier')
         return false;
     
@@ -34,7 +32,7 @@ module.exports.filter = ({node, text}) => {
     return !(isOpenBracket && isCloseBracket);
 };
 
-module.exports.fix = ({text}) => {
+export const fix = ({text}) => {
     return text
         .replace('(', '(\n')
         .replace(/,\s?/g, ',\n')

package/lib/no-unresolved/index.js

@@ -1,16 +1,14 @@
-'use strict';
-
-const process = require('node:process');
-const {accessSync} = require('node:fs');
-
-const {
+import process from 'node:process';
+import {accessSync} from 'node:fs';
+import {
     extname,
     dirname,
     join,
-} = require('node:path');
-
-const {tryCatch} = require('try-catch');
+} from 'node:path';
+import {createRequire} from 'node:module';
+import {tryCatch} from 'try-catch';
 
+const require = createRequire(import.meta.url);
 const cwd = process.cwd();
 
 const RELATIVE = '\\.\\.?\\/?';
@@ -19,16 +17,16 @@ const isRelativeEnd = (a) => RegExp(`${RELATIVE}$`).test(a);
 const getDir = (a) => a === '<input>' ? cwd : dirname(a);
 const getValue = ({source}) => source?.value;
 
-module.exports.category = 'errors';
-module.exports.report = () => 'Always add an extension to relative imports';
-module.exports.include = () => [
+export const category = 'errors';
+export const report = () => 'Always add an extension to relative imports';
+export const include = () => [
     'ImportDeclaration',
     'ImportExpression',
     'ExportAllDeclaration',
     'ExportNamedDeclaration',
 ];
 
-module.exports.fix = ({node, text, filename}) => {
+export const fix = ({node, text, filename}) => {
     const value = getValue(node);
     const dir = getDir(filename);
     
@@ -40,7 +38,7 @@ module.exports.fix = ({node, text, filename}) => {
     return text.replace(value, resolved);
 };
 
-module.exports.filter = ({node}) => {
+export const filter = ({node}) => {
     const value = getValue(node);
     
     if (!value || value.endsWith('.js'))