refactor: add eslint rules and refactor based on that (#91)

Author: AmirSa12

bin/package-manager-completion.ts

@@ -4,6 +4,8 @@ import {
 } from 'child_process';
 import { RootCommand } from '../src/t.js';
 
+const noop = () => {};
+
 function debugLog(...args: unknown[]) {
   if (process.env.DEBUG) {
     console.error('[DEBUG]', ...args);
@@ -47,7 +49,9 @@ async function checkCliHasCompletions(
   try {
     const result = runCompletionCommand(cliName, [], []);
     if (result) return true;
-  } catch {}
+  } catch {
+    noop();
+  }
 
   try {
     const result = runCompletionCommand(packageManager, [cliName], []);
@@ -67,7 +71,9 @@ async function getCliCompletions(
     if (result) {
       return result.split('\n').filter(Boolean);
     }
-  } catch {}
+  } catch {
+    noop();
+  }
 
   try {
     const result = runCompletionCommand(packageManager, [cliName], args);

eslint.config.js

@@ -3,16 +3,47 @@ import { configs as tseslintConfigs } from 'typescript-eslint';
 import prettierConfig from 'eslint-config-prettier';
 
 const { configs: eslintConfigs } = eslintjs;
+const completionFileGlobs = [
+  'src/**/*.ts',
+  'bin/**/*.ts',
+  'benchmarks/**/*.ts',
+  '*.ts',
+];
 
 export default [
+  {
+    ignores: ['dist/**'],
+  },
   {
     ...eslintConfigs.recommended,
-    files: ['src/**/*.ts'],
+    files: completionFileGlobs,
   },
   ...tseslintConfigs.strict,
   {
+    files: completionFileGlobs,
     rules: {
-      '@typescript-eslint/no-unused-vars': 'off',
+      '@typescript-eslint/no-unused-vars': [
+        'error',
+        {
+          argsIgnorePattern: '^_',
+          varsIgnorePattern: '^_',
+          caughtErrorsIgnorePattern: '^ignore',
+          ignoreRestSiblings: true,
+        },
+      ],
+      '@typescript-eslint/consistent-type-imports': [
+        'warn',
+        {
+          prefer: 'type-imports',
+          fixStyle: 'separate-type-imports',
+        },
+      ],
+      '@typescript-eslint/consistent-type-definitions': ['error', 'interface'],
+      'default-case-last': 'error',
+      eqeqeq: ['error', 'smart'],
+      'no-fallthrough': ['error', { allowEmptyCase: true }],
+      'prefer-template': 'error',
+      'no-console': 'off',
     },
   },
   prettierConfig,

src/cac.ts

@@ -4,8 +4,8 @@ import * as fish from './fish';
 import * as powershell from './powershell';
 import type { CAC } from 'cac';
 import { assertDoubleDashes } from './shared';
-import { CompletionConfig } from './shared';
-import t, { RootCommand } from './t';
+import type { CompletionConfig } from './shared';
+import t, { type RootCommand } from './t';
 
 const execPath = process.execPath;
 const processArgs = process.argv.slice(1);

src/citty.ts

@@ -1,4 +1,5 @@
-import { ArgDef, defineCommand } from 'citty';
+import { defineCommand } from 'citty';
+import type { ArgDef } from 'citty';
 import * as zsh from './zsh';
 import * as bash from './bash';
 import * as fish from './fish';
@@ -10,8 +11,9 @@ import type {
   SubCommandsDef,
 } from 'citty';
 import { generateFigSpec } from './fig';
-import { CompletionConfig, assertDoubleDashes } from './shared';
-import t, { RootCommand } from './t';
+import { assertDoubleDashes } from './shared';
+import type { CompletionConfig } from './shared';
+import t, { type RootCommand } from './t';
 
 function quoteIfNeeded(path: string) {
   return path.includes(' ') ? `'${path}'` : path;

src/commander.ts

@@ -3,7 +3,7 @@ import * as bash from './bash';
 import * as fish from './fish';
 import * as powershell from './powershell';
 import type { Command as CommanderCommand, ParseOptions } from 'commander';
-import t, { RootCommand } from './t';
+import t, { type RootCommand } from './t';
 import { assertDoubleDashes } from './shared';
 
 const execPath = process.execPath;
@@ -22,10 +22,10 @@ export default function tab(instance: CommanderCommand): RootCommand {
   const programName = instance.name();
 
   // Process the root command
-  processRootCommand(instance, programName);
+  processRootCommand(instance);
 
   // Process all subcommands
-  processSubcommands(instance, programName);
+  processSubcommands(instance);
 
   // Add the complete command for normal shell script generation
   instance
@@ -101,10 +101,7 @@ export default function tab(instance: CommanderCommand): RootCommand {
   return t;
 }
 
-function processRootCommand(
-  command: CommanderCommand,
-  programName: string
-): void {
+function processRootCommand(command: CommanderCommand): void {
   // Add root command options to the root t instance
   for (const option of command.options) {
     // Extract short flag from the name if it exists (e.g., "-c, --config" -> "c")
@@ -122,10 +119,7 @@ function processRootCommand(
   }
 }
 
-function processSubcommands(
-  rootCommand: CommanderCommand,
-  programName: string
-): void {
+function processSubcommands(rootCommand: CommanderCommand): void {
   // Build a map of command paths
   const commandMap = new Map<string, CommanderCommand>();
 

src/fig.ts

@@ -1,40 +1,40 @@
 import type { CommandDef, ArgsDef, PositionalArgDef, CommandMeta } from 'citty';
 
-type FigSpec = {
+interface FigSpec {
   name: string;
   description: string;
   options?: FigOption[];
   subcommands?: FigSubcommand[];
   args?: FigArg[];
-};
+}
 
-type FigOption = {
+interface FigOption {
   name: string;
   description: string;
   args?: FigArg[];
   isRequired?: boolean;
-};
+}
 
-type FigSubcommand = {
+interface FigSubcommand {
   name: string;
   description: string;
   options?: FigOption[];
   subcommands?: FigSubcommand[];
   args?: FigArg[];
-};
+}
 
-type FigArg = {
+interface FigArg {
   name: string;
   description?: string;
   isOptional?: boolean;
   isVariadic?: boolean;
   suggestions?: FigSuggestion[];
-};
+}
 
-type FigSuggestion = {
+interface FigSuggestion {
   name: string;
   description?: string;
-};
+}
 
 async function processArgs<T extends ArgsDef>(
   args: T

src/powershell.ts

@@ -2,11 +2,7 @@ import { ShellCompDirective } from './t';
 
 // TODO: issue with -- -- completions
 
-export function generate(
-  name: string,
-  exec: string,
-  includeDesc = false
-): string {
+export function generate(name: string, exec: string): string {
   // Replace '-' and ':' with '_' for variable names
   const nameForVar = name.replace(/[-:]/g, '_');
 

src/shared.ts

@@ -1,4 +1,4 @@
-import { OptionHandler, ArgumentHandler } from './t';
+import type { OptionHandler, ArgumentHandler } from './t';
 
 export const noopHandler: OptionHandler = function () {
   // No-op handler for options

src/t.ts

@@ -20,10 +20,10 @@ export type OptionHandler = (
   options: OptionsMap
 ) => void;
 
-export type Completion = {
+export interface Completion {
   description?: string;
   value: string;
-};
+}
 
 export type ArgumentHandler = (
   this: Argument,
@@ -214,8 +214,7 @@ export class RootCommand extends Command {
 
   private shouldCompleteFlags(
     lastPrevArg: string | undefined,
-    toComplete: string,
-    endsWithSpace: boolean
+    toComplete: string
   ): boolean {
     if (toComplete.startsWith('-')) {
       return true;
@@ -244,10 +243,7 @@ export class RootCommand extends Command {
     return false;
   }
 
-  private shouldCompleteCommands(
-    toComplete: string,
-    endsWithSpace: boolean
-  ): boolean {
+  private shouldCompleteCommands(toComplete: string): boolean {
     return !toComplete.startsWith('-');
   }
 
@@ -256,7 +252,6 @@ export class RootCommand extends Command {
     command: Command,
     previousArgs: string[],
     toComplete: string,
-    endsWithSpace: boolean,
     lastPrevArg: string | undefined
   ) {
     // Handle flag value completion
@@ -350,12 +345,7 @@ export class RootCommand extends Command {
   }
 
   // positional argument completion
-  private handlePositionalCompletion(
-    command: Command,
-    previousArgs: string[],
-    toComplete: string,
-    endsWithSpace: boolean
-  ) {
+  private handlePositionalCompletion(command: Command, previousArgs: string[]) {
     // current argument position (subtract command name)
     const commandParts = command.value.split(' ').length;
     const currentArgIndex = Math.max(0, previousArgs.length - commandParts);
@@ -437,12 +427,11 @@ export class RootCommand extends Command {
     const [matchedCommand] = this.matchCommand(previousArgs);
     const lastPrevArg = previousArgs[previousArgs.length - 1];
 
-    if (this.shouldCompleteFlags(lastPrevArg, toComplete, endsWithSpace)) {
+    if (this.shouldCompleteFlags(lastPrevArg, toComplete)) {
       this.handleFlagCompletion(
         matchedCommand,
         previousArgs,
         toComplete,
-        endsWithSpace,
         lastPrevArg
       );
     } else {
@@ -461,16 +450,11 @@ export class RootCommand extends Command {
         }
       }
 
-      if (this.shouldCompleteCommands(toComplete, endsWithSpace)) {
+      if (this.shouldCompleteCommands(toComplete)) {
         this.handleCommandCompletion(previousArgs, toComplete);
       }
       if (matchedCommand && matchedCommand.arguments.size > 0) {
-        this.handlePositionalCompletion(
-          matchedCommand,
-          previousArgs,
-          toComplete,
-          endsWithSpace
-        );
+        this.handlePositionalCompletion(matchedCommand, previousArgs);
       }
     }