BUGFIX: Add TypeScript parser config when disable_typescript_base_config is true

Extended the previous fix to also handle TypeScript files. When users set
disable_typescript_base_config: true, TypeScript files failed to parse with
error: 'Unexpected token :' (from type annotations).

Root Cause:
Same as JavaScript bug - when the TypeScript base config is disabled, no
TypeScript parser was configured, causing ESLint to use a parser that cannot
handle TypeScript syntax.

Solution:
Added createMinimalTypescriptParserConfig() method that configures ONLY the
TypeScript parser (without base rules or projectService) when the base config
is disabled.

Note: The minimal TypeScript config intentionally omits projectService to allow
parsing TypeScript files that aren't part of a tsconfig.json project. This
means type-aware rules won't work, but syntax parsing (decorators, type
annotations) will function correctly.

Changes:
- base-config.ts: Added TypeScript fallback case and createMinimalTypescriptParserConfig()
- parser-selection.test.ts: Added 2 tests for TypeScript with base config disabled
- Test data: Added workspaceWithTsDecorators and workspaceWithTsx test fixtures

Test Coverage:
- TypeScript files with decorators when disable_typescript_base_config: true
- TSX files with JSX when disable_typescript_base_config: true

All 284 tests passing with 99.83% code coverage.

Author: aruntyagiTutu

packages/code-analyzer-eslint-engine/src/base-config.ts

@@ -60,6 +60,10 @@ export class BaseConfigFactory {
         }
         if (this.useTsBaseConfig()) {
             configArray.push(...this.createTypescriptConfigArray());
+        } else if (this.engineConfig.file_extensions.typescript.length > 0) {
+            // When TS base config is disabled, we still need to configure a parser for TypeScript files
+            // to avoid ESLint falling back to a parser that can't handle TypeScript syntax
+            configArray.push(...this.createMinimalTypescriptParserConfig());
         }
         // Add React plugin config for JSX files
         if (this.useReactBaseConfig()) {
@@ -246,6 +250,29 @@ export class BaseConfigFactory {
         }
     }
 
+    private createMinimalTypescriptParserConfig(): Linter.Config[] {
+        // When disable_typescript_base_config is true, we still need to configure a parser
+        // for TypeScript files to avoid ESLint falling back to Espree which can't parse
+        // TypeScript syntax. This method configures ONLY the parser, without applying base rules.
+        //
+        // Note: We intentionally do NOT set projectService here. The projectService option
+        // is used for type-aware linting, but it requires files to be in a tsconfig.json project.
+        // Without projectService, the TypeScript parser can still parse TypeScript syntax
+        // (decorators, type annotations, etc.) for non-type-aware rules.
+
+        // Get the first TypeScript config which contains the parser setup
+        const tsConfig = (eslintTs.configs.all as Linter.Config[])[0];
+
+        return [{
+            files: this.engineConfig.file_extensions.typescript.map(ext => `**/*${ext}`),
+            languageOptions: {
+                ...(tsConfig.languageOptions ?? {})
+                // Explicitly omit parserOptions.projectService to allow parsing files
+                // that aren't part of a TypeScript project
+            }
+        }];
+    }
+
     private createSldsHTMLConfigArray(): Linter.Config[] {
         return sldsEslintPlugin.configs['flat/recommended-html'].map((htmlConfig: Linter.Config) => {
             return {

packages/code-analyzer-eslint-engine/test/parser-selection.test.ts

@@ -698,4 +698,67 @@ describe('Parser Selection for Decorator Support', () => {
             expect(engine).toBeDefined();
         });
     });
+
+    describe('TypeScript with disable_typescript_base_config: Bug Check', () => {
+        const workspaceWithTsDecorators: string = path.join(testDataFolder, 'workspaceWithTsDecorators');
+
+        it('should parse .ts files with decorators when disable_typescript_base_config is true', async () => {
+            // This test checks if we have the same bug with TypeScript as we had with JavaScript
+            // When disable_typescript_base_config: true, is a TypeScript parser still configured?
+            const configWithTsDisabled: ConfigObject = {
+                disable_typescript_base_config: true,
+                file_extensions: {
+                    javascript: ['.js'],
+                    typescript: ['.ts'],
+                    html: ['.html'],
+                    css: ['.css'],
+                    other: []
+                },
+                config_root: __dirname
+            };
+
+            const engine: Engine = await createEngineFromPlugin(configWithTsDisabled);
+            const workspace: Workspace = new Workspace('test', [workspaceWithTsDecorators],
+                [path.join(workspaceWithTsDecorators, 'tsComponent.ts')]);
+
+            const runOptions: RunOptions = createRunOptions(workspace);
+            const results: EngineRunResults = await engine.runRules(['no-debugger'], runOptions);
+
+            // Assert: Should parse TypeScript decorators successfully
+            expect(results.violations).toBeDefined();
+            const parsingErrors = results.violations.filter(v =>
+                v.message.includes('Parsing error') || v.message.includes('Unexpected character')
+            );
+            expect(parsingErrors.length).toBe(0);
+        });
+
+        it('should parse .tsx files with JSX when disable_typescript_base_config is true', async () => {
+            const workspaceWithTsx: string = path.join(testDataFolder, 'workspaceWithTsx');
+            const configWithTsDisabled: ConfigObject = {
+                disable_typescript_base_config: true,
+                file_extensions: {
+                    javascript: ['.js'],
+                    typescript: ['.tsx'],
+                    html: ['.html'],
+                    css: ['.css'],
+                    other: []
+                },
+                config_root: __dirname
+            };
+
+            const engine: Engine = await createEngineFromPlugin(configWithTsDisabled);
+            const workspace: Workspace = new Workspace('test', [workspaceWithTsx],
+                [path.join(workspaceWithTsx, 'ReactTsComponent.tsx')]);
+
+            const runOptions: RunOptions = createRunOptions(workspace);
+            const results: EngineRunResults = await engine.runRules(['no-debugger'], runOptions);
+
+            // Assert: Should parse TSX (TypeScript + JSX) successfully
+            expect(results.violations).toBeDefined();
+            const parsingErrors = results.violations.filter(v =>
+                v.message.includes('Parsing error')
+            );
+            expect(parsingErrors.length).toBe(0);
+        });
+    });
 });

packages/code-analyzer-eslint-engine/test/test-data/workspaceWithTsDecorators/tsComponent.ts

@@ -0,0 +1,25 @@
+// TypeScript component with decorators - for testing ESLint parsing
+// @ts-nocheck
+function Component(target: any) {
+    return target;
+}
+
+function Property(target: any, propertyKey: string) {
+    // Property decorator
+}
+
+@Component
+class MyComponent {
+    @Property
+    public name: string;
+
+    constructor() {
+        this.name = "Test Component";
+    }
+
+    public greet(): string {
+        return `Hello from ${this.name}`;
+    }
+}
+
+export default MyComponent;

packages/code-analyzer-eslint-engine/test/test-data/workspaceWithTsx/ReactTsComponent.tsx

@@ -0,0 +1,16 @@
+// @ts-nocheck
+interface Props {
+    name: string;
+    age?: number;
+}
+
+const ReactTsComponent = ({ name, age }: Props) => {
+    return (
+        <div>
+            <h1>Hello, {name}!</h1>
+            {age && <p>Age: {age}</p>}
+        </div>
+    );
+};
+
+export default ReactTsComponent;