@dmitryrechkin/eslint-standard 1.1.0 → 1.1.2

package/eslint.config.mjs

@@ -6,7 +6,8 @@ import stylisticPlugin from '@stylistic/eslint-plugin';
 import jsdocPlugin from 'eslint-plugin-jsdoc';
 import simpleImportSortPlugin from 'eslint-plugin-simple-import-sort';
 import perfectionistPlugin from 'eslint-plugin-perfectionist';
-import jsdocIndentPlugin from './eslint-plugin-jsdoc-indent.mjs';
+import jsdocIndentPlugin from './src/plugins/jsdoc-indent.mjs';
+import interfaceBracePlugin from './src/plugins/interface-brace.mjs';
 
 export default function ({
 	tsconfigPath = './tsconfig.json',
@@ -37,6 +38,7 @@ export default function ({
 				'simple-import-sort': simpleImportSortPlugin,
 				'perfectionist': perfectionistPlugin,
 				'jsdoc-indent': jsdocIndentPlugin,
+				'interface-brace': interfaceBracePlugin,
 				...plugins,
 			},
 			rules: {
@@ -45,15 +47,21 @@ export default function ({
 				'@typescript-eslint/no-explicit-any': 'off',
 
 				// Original coding guidelines
-				'brace-style': ['error', 'allman', { allowSingleLine: true }],
+				'brace-style': 'off', // Disabled in favor of @stylistic/brace-style
+				'@stylistic/brace-style': ['error', 'allman', { allowSingleLine: true }],
 				indent: 'off', // Disabled to avoid conflicts with @stylistic/indent and our JSDoc plugin
 				'@stylistic/indent': ['error', 'tab', { SwitchCase: 1 }],
-				quotes: ['error', 'single'],
-				semi: ['error', 'always'],
+				quotes: 'off', // Disabled in favor of @stylistic/quotes
+				'@stylistic/quotes': ['error', 'single'],
+				semi: 'off', // Disabled in favor of @stylistic/semi
+				'@stylistic/semi': ['error', 'always'],
 				'@typescript-eslint/no-unused-vars': ['error', { argsIgnorePattern: '^_' }],
-				'no-trailing-spaces': 'error',
-				'eol-last': ['error', 'always'],
-				'comma-dangle': ['error', 'never'],
+				'no-trailing-spaces': 'off', // Disabled in favor of @stylistic/no-trailing-spaces
+				'@stylistic/no-trailing-spaces': 'error',
+				'eol-last': 'off', // Disabled in favor of @stylistic/eol-last
+				'@stylistic/eol-last': ['error', 'always'],
+				'comma-dangle': 'off', // Disabled in favor of @stylistic/comma-dangle
+				'@stylistic/comma-dangle': ['error', 'never'],
 
 				// Original naming conventions
 				'@typescript-eslint/naming-convention': [
@@ -147,6 +155,9 @@ export default function ({
 				'jsdoc/check-indentation': 'off', // Disabled to avoid conflicts with our custom plugin
 				'jsdoc/tag-lines': 'off', // Disabled to avoid conflicts with our custom plugin
 				'jsdoc-indent/jsdoc-indent': ['error', { tabWidth: 4 }],
+				
+				// Enhanced: Interface brace style
+				'interface-brace/interface-brace-style': 'error',
 
 				// Allow custom rules to be added
 				...rules,

package/package.json

@@ -1,16 +1,19 @@
 {
 	"name": "@dmitryrechkin/eslint-standard",
 	"description": "This package provides a shared ESLint configuration which includes TypeScript support and a set of specific linting rules designed to ensure high-quality and consistent code style across projects.",
-	"version": "1.1.0",
+	"version": "1.1.2",
 	"main": "eslint.config.mjs",
+	"bin": {
+	  "eslint-standard": "./src/cli/index.mjs"
+	},
 	"files": [
 	  "eslint.config.mjs",
-	  "eslint-plugin-jsdoc-indent.mjs",
+	  "src/",
 	  "README.md",
 	  "LICENSE"
 	],
 	"scripts": {
-	  "postinstall": "echo 'Remember to install peer dependencies:\n npm install eslint @typescript-eslint/parser @typescript-eslint/eslint-plugin eslint-plugin-unused-imports @stylistic/eslint-plugin eslint-plugin-jsdoc --save-dev\n bun add eslint @typescript-eslint/parser @typescript-eslint/eslint-plugin eslint-plugin-unused-imports @stylistic/eslint-plugin eslint-plugin-jsdoc --dev'",
+	  "postinstall": "node src/cli/postinstall.mjs",
 	  "package:publish": "npm publish --access public",
 	  "test": "npm run test:formatting",
 	  "test:formatting": "node tests/test-runner.js"

package/src/cli/check-deps.mjs

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join, resolve } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Get peer dependencies
+const packageJsonPath = join(__dirname, '../../package.json');
+const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+const peerDeps = packageJson.peerDependencies || {};
+
+// Check if running from node_modules
+const isInNodeModules = __dirname.includes('node_modules');
+const projectRoot = isInNodeModules 
+	? resolve(__dirname, '../../../../') 
+	: process.cwd();
+
+// Read project's package.json
+let projectPackageJson;
+try {
+	projectPackageJson = JSON.parse(readFileSync(join(projectRoot, 'package.json'), 'utf8'));
+} catch (error) {
+	console.error('❌ Could not read project package.json');
+	process.exit(1);
+}
+
+const allDeps = {
+	...projectPackageJson.dependencies || {},
+	...projectPackageJson.devDependencies || {}
+};
+
+console.log('🔍 Checking ESLint Standard peer dependencies...\n');
+
+let missingDeps = [];
+let outdatedDeps = [];
+
+for (const [dep, requiredVersion] of Object.entries(peerDeps)) {
+	if (!allDeps[dep]) {
+		missingDeps.push(`${dep}@${requiredVersion}`);
+		console.log(`❌ Missing: ${dep} (required: ${requiredVersion})`);
+	} else {
+		console.log(`✅ Found: ${dep}@${allDeps[dep]}`);
+		// Simple version check - could be improved
+		if (!allDeps[dep].includes('^') && !allDeps[dep].includes('~') && allDeps[dep] !== requiredVersion) {
+			outdatedDeps.push(`${dep} (installed: ${allDeps[dep]}, required: ${requiredVersion})`);
+		}
+	}
+}
+
+console.log('\n📊 Summary:');
+if (missingDeps.length === 0 && outdatedDeps.length === 0) {
+	console.log('✅ All peer dependencies are satisfied!');
+} else {
+	if (missingDeps.length > 0) {
+		console.log(`\n❌ Missing ${missingDeps.length} dependencies:`);
+		console.log('Run: npx @dmitryrechkin/eslint-standard install-deps');
+	}
+	if (outdatedDeps.length > 0) {
+		console.log(`\n⚠️  ${outdatedDeps.length} dependencies may be outdated:`);
+		outdatedDeps.forEach(dep => console.log(`  - ${dep}`));
+	}
+	process.exit(1);
+}
+
+export default function checkDeps() {
+	// Export for programmatic use
+}

package/src/cli/index.mjs

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+
+const command = process.argv[2];
+
+switch (command) {
+	case 'install-deps':
+		await import('./install-deps.mjs');
+		break;
+	case 'check-deps':
+		await import('./check-deps.mjs');
+		break;
+	case 'help':
+	case '--help':
+	case '-h':
+	case undefined:
+		console.log(`
+@dmitryrechkin/eslint-standard CLI
+
+Usage:
+  npx @dmitryrechkin/eslint-standard <command>
+
+Commands:
+  install-deps    Install all peer dependencies
+  check-deps      Check if all peer dependencies are installed
+  help            Show this help message
+
+Examples:
+  npx @dmitryrechkin/eslint-standard install-deps
+  npx @dmitryrechkin/eslint-standard check-deps
+		`);
+		break;
+	default:
+		console.error(`Unknown command: ${command}`);
+		console.log('Run "npx @dmitryrechkin/eslint-standard help" for usage information');
+		process.exit(1);
+}

package/src/cli/install-deps.mjs

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+
+import { execSync } from 'child_process';
+import { readFileSync, existsSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Detect package manager
+function detectPackageManager() {
+	if (existsSync('pnpm-lock.yaml')) return 'pnpm';
+	if (existsSync('yarn.lock')) return 'yarn';
+	if (existsSync('package-lock.json')) return 'npm';
+	if (existsSync('bun.lockb')) return 'bun';
+	return 'npm'; // default
+}
+
+// Get peer dependencies from package.json
+const packageJsonPath = join(__dirname, '../../package.json');
+const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+const peerDeps = packageJson.peerDependencies || {};
+
+// Build install command
+const packageManager = detectPackageManager();
+const deps = Object.entries(peerDeps).map(([name, version]) => `${name}@${version}`).join(' ');
+
+const installCommands = {
+	npm: `npm install --save-dev ${deps}`,
+	pnpm: `pnpm add -D ${deps}`,
+	yarn: `yarn add -D ${deps}`,
+	bun: `bun add -d ${deps}`
+};
+
+const command = installCommands[packageManager];
+
+console.log(`🔧 Installing ESLint Standard peer dependencies...`);
+console.log(`📦 Detected package manager: ${packageManager}`);
+console.log(`📋 Running: ${command}\n`);
+
+try {
+	execSync(command, { stdio: 'inherit' });
+	console.log('\n✅ All peer dependencies installed successfully!');
+} catch (error) {
+	console.error('\n❌ Failed to install dependencies. Please run manually:');
+	console.error(command);
+	process.exit(1);
+}

package/src/cli/postinstall.mjs

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Don't run during local development
+if (!__dirname.includes('node_modules')) {
+	process.exit(0);
+}
+
+console.log(`
+╔════════════════════════════════════════════════════════════════╗
+║                                                                ║
+║   🎉 Thanks for installing @dmitryrechkin/eslint-standard!    ║
+║                                                                ║
+╚════════════════════════════════════════════════════════════════╝
+
+📦 This package requires peer dependencies to work properly.
+
+🚀 Quick install (auto-detects your package manager):
+   ${'\x1b[36m'}npx @dmitryrechkin/eslint-standard install-deps${'\x1b[0m'}
+
+📋 Or install manually:
+   ${'\x1b[90m'}npm install -D eslint @typescript-eslint/parser @typescript-eslint/eslint-plugin eslint-plugin-unused-imports @stylistic/eslint-plugin eslint-plugin-jsdoc eslint-plugin-simple-import-sort eslint-plugin-perfectionist${'\x1b[0m'}
+
+🔍 To check if all dependencies are installed:
+   ${'\x1b[36m'}npx @dmitryrechkin/eslint-standard check-deps${'\x1b[0m'}
+
+📚 Documentation: https://github.com/dmitryrechkin/eslint-standard
+`);
+
+// Run check-deps to show current status
+try {
+	await import('./check-deps.mjs');
+} catch (error) {
+	// Silent fail - don't break installation
+}

package/src/plugins/interface-brace.mjs

@@ -0,0 +1,121 @@
+/**
+ * Custom ESLint plugin to enforce Allman brace style for TypeScript interfaces
+ */
+
+const interfaceBraceRule = {
+	meta: {
+		type: 'layout',
+		docs: {
+			description: 'Enforce Allman brace style for TypeScript interfaces',
+			category: 'Stylistic Issues',
+			recommended: false
+		},
+		fixable: 'whitespace',
+		schema: []
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode || context.getSourceCode();
+
+		return {
+			TSInterfaceDeclaration(node) {
+				// Get the interface name token
+				const interfaceId = node.id;
+				const typeParams = node.typeParameters;
+				const extendsClause = node.extends;
+				
+				// Find the opening brace
+				let tokenBeforeBrace;
+				if (node.heritage && node.heritage.length > 0) {
+					// Interface extends something
+					tokenBeforeBrace = node.heritage[node.heritage.length - 1];
+				} else if (extendsClause && extendsClause.length > 0) {
+					// Interface extends something (newer AST)
+					tokenBeforeBrace = extendsClause[extendsClause.length - 1];
+				} else if (typeParams) {
+					// Interface has type parameters
+					tokenBeforeBrace = typeParams;
+				} else {
+					// Simple interface
+					tokenBeforeBrace = interfaceId;
+				}
+				
+				// Get the opening brace token
+				const openingBrace = sourceCode.getTokenAfter(tokenBeforeBrace, token => token.type === 'Punctuator' && token.value === '{');
+				
+				if (!openingBrace) return;
+				
+				// Check if there's a newline before the opening brace
+				const tokenBefore = sourceCode.getTokenBefore(openingBrace);
+				const textBetween = sourceCode.text.slice(tokenBefore.range[1], openingBrace.range[0]);
+				
+				// Check if brace is on the same line
+				if (!textBetween.includes('\n')) {
+					context.report({
+						node: openingBrace,
+						message: 'Opening brace should be on a new line (Allman style)',
+						fix(fixer) {
+							// Get the base indentation of the interface declaration
+							const interfaceLine = sourceCode.getLines()[node.loc.start.line - 1];
+							const baseIndentMatch = interfaceLine.match(/^(\s*)/);
+							const baseIndent = baseIndentMatch ? baseIndentMatch[1] : '';
+							
+							// Replace the space before the brace with a newline and proper indentation
+							return fixer.replaceTextRange(
+								[tokenBefore.range[1], openingBrace.range[0]], 
+								'\n' + baseIndent
+							);
+						}
+					});
+				}
+			},
+			
+			// Also handle TSTypeAliasDeclaration with object type
+			TSTypeAliasDeclaration(node) {
+				if (node.typeAnnotation && node.typeAnnotation.type === 'TSTypeLiteral') {
+					const typeParams = node.typeParameters;
+					const tokenBeforeBrace = typeParams ? typeParams : node.id;
+					
+					// Find the equals sign
+					const equalsToken = sourceCode.getTokenAfter(tokenBeforeBrace, token => token.type === 'Punctuator' && token.value === '=');
+					
+					if (!equalsToken) return;
+					
+					// Get the opening brace token
+					const openingBrace = sourceCode.getTokenAfter(equalsToken, token => token.type === 'Punctuator' && token.value === '{');
+					
+					if (!openingBrace) return;
+					
+					// Check if there's a newline before the opening brace
+					const textBetween = sourceCode.text.slice(equalsToken.range[1], openingBrace.range[0]);
+					
+					// Check if brace is on the same line
+					if (!textBetween.includes('\n')) {
+						context.report({
+							node: openingBrace,
+							message: 'Opening brace should be on a new line (Allman style)',
+							fix(fixer) {
+								// Get the base indentation
+								const typeLine = sourceCode.getLines()[node.loc.start.line - 1];
+								const baseIndentMatch = typeLine.match(/^(\s*)/);
+								const baseIndent = baseIndentMatch ? baseIndentMatch[1] : '';
+								
+								// Replace the space before the brace with a newline and proper indentation
+								return fixer.replaceTextRange(
+									[equalsToken.range[1], openingBrace.range[0]], 
+									' =\n' + baseIndent
+								);
+							}
+						});
+					}
+				}
+			}
+		};
+	}
+};
+
+export default {
+	rules: {
+		'interface-brace-style': interfaceBraceRule
+	}
+};

package/{eslint-plugin-jsdoc-indent.mjs → src/plugins/jsdoc-indent.mjs}

@@ -46,43 +46,69 @@ const jsdocIndentRule = {
 						const baseIndentMatch = commentLine.match(/^(\s*)/);
 						const baseIndent = baseIndentMatch ? baseIndentMatch[1] : '';
 						
-						for (let i = 1; i < lines.length; i++) { // Skip first line, include last line for closing */
+						for (let i = 0; i < lines.length; i++) {
 							const line = lines[i];
-							const leadingSpaces = line.match(/^( +)/);
 							
-							if (leadingSpaces) {
-								// Check if this is the closing line (ends with */)
-								const isClosingLine = line.trim() === '*/';
+							// Skip the opening line (/**)
+							if (i === 0) continue;
+							
+							// Handle different line types
+							const trimmedLine = line.trim();
+							
+							// Lines without asterisks in JSDoc (like "Text" instead of "* Text")
+							if (trimmedLine !== '' && !trimmedLine.startsWith('*') && !trimmedLine.endsWith('*/')) {
+								// This line should have an asterisk added
+								const start = comment.range[0] + 2; // +2 for "/*"
+								let lineOffset = 0;
+								for (let j = 0; j < i; j++) {
+									lineOffset += lines[j].length + 1; // +1 for \n
+								}
+								
+								context.report({
+									node: comment,
+									loc: {
+										start: sourceCode.getLocFromIndex(start + lineOffset),
+										end: sourceCode.getLocFromIndex(start + lineOffset + line.length)
+									},
+									message: `JSDoc comment should be properly aligned`,
+									fix(fixer) {
+										return fixer.replaceTextRange(
+											[start + lineOffset, start + lineOffset + line.length], 
+											baseIndent + ' * ' + trimmedLine
+										);
+									}
+								});
+							} else if (trimmedLine === '' || trimmedLine.startsWith('*')) {
+								// Check indentation for lines with asterisks
+								const leadingMatch = line.match(/^(\s*)/);
+								if (!leadingMatch) continue;
 								
-								// Calculate correct indentation
+								const leadingSpaces = leadingMatch[1];
+								const isClosingLine = trimmedLine === '*/';
 								const correctIndent = isClosingLine ? baseIndent : baseIndent + ' ';
 								
 								// Skip if already correct to avoid circular fixes
-								if (isClosingLine && line.startsWith(correctIndent + '*/')) {
-									continue;
-								} else if (!isClosingLine && line.startsWith(correctIndent + '*')) {
-									continue;
-								}
+								if (leadingSpaces === correctIndent) continue;
 								
 								// Calculate the position in the original source
-								const lineStart = comment.range[0] + 2; // +2 for "/*"
+								const start = comment.range[0] + 2; // +2 for "/*"
 								let lineOffset = 0;
 								for (let j = 0; j < i; j++) {
 									lineOffset += lines[j].length + 1; // +1 for \n
 								}
 								
-								const start = lineStart + lineOffset;
-								const end = start + leadingSpaces[1].length;
+								const lineStart = start + lineOffset;
+								const lineEnd = lineStart + leadingSpaces.length;
 								
 								context.report({
 									node: comment,
 									loc: {
-										start: sourceCode.getLocFromIndex(start),
-										end: sourceCode.getLocFromIndex(end)
+										start: sourceCode.getLocFromIndex(lineStart),
+										end: sourceCode.getLocFromIndex(lineEnd)
 									},
 									message: `JSDoc comment should be properly aligned`,
 									fix(fixer) {
-										return fixer.replaceTextRange([start, end], correctIndent);
+										return fixer.replaceTextRange([lineStart, lineEnd], correctIndent);
 									}
 								});
 							}