Single File Type Checking Support

[BojanRatkovic]

Problem Statement

Currently, Glint only supports project-wide type checking, which means checking individual files or a subset of files is not possible. This limitation creates friction in several common development workflows:

# ❌ Currently NOT supported
glint src/components/header.gts
glint src/file1.gts src/file2.gts

# ✅ Only this works
glint  # checks entire project

Use Cases & Benefits

Developer Productivity

• Faster feedback loops - check only the files you're working on
• IDE integrations - enable file-level type checking on save
• Large codebases - avoid waiting for full project analysis

Git Workflow Integration

• lint-staged compatibility - check only modified files in pre-commit hooks
• CI optimizations - incremental checking in pull requests
• Git hooks - validate only changed files

Editor Experience

• VS Code extensions - provide instant feedback
• Language servers - enable per-file analysis
• Development tools - integrate with various toolchains

Proposed Solution

Add support for specifying individual files or multiple files:

# Single file checking
glint src/components/my-component.gts

# Multiple files (perfect for lint-staged)
glint src/header.gts src/footer.gts src/utils.ts

Implementation Approach

Technical Implementation Details

The solution involves:

1. Temporary tsconfig.json generation - Create a temporary config that inherits from the project's tsconfig.json but only includes specified files
2. Project settings preservation - Maintain all compiler options, paths, and project references
3. Clean architecture - Minimal changes to existing codebase
4. Backward compatibility - Zero breaking changes to current functionality

// When files are specified:
// 1. Find project's tsconfig.json
// 2. Create temporary config inheriting all settings
// 3. Override 'files' array with specified files
// 4. Run TypeScript with --project pointing to temp config
// 5. Clean up temp file

Benefits for the Ecosystem

lint-staged Integration

{
  "lint-staged": {
    "*.{gts,gjs,ts}": ["glint", "prettier --write"]
  }
}

CI/CD Optimizations

# Only check changed files in PR
- name: Type check changed files
  run: glint $(git diff --name-only --diff-filter=AM origin/main... | grep -E '\.(gts|gjs|ts)$')

Development Workflow

# Quick feedback during development
glint src/components/form/*.gts

# IDE save hooks
glint $FILE_PATH

Current Implementation Status

I have already implemented this feature locally and have it working with:

• ✅ Single and multiple file support
• ✅ Full tsconfig.json inheritance
• ✅ Proper cleanup of temporary files
• ✅ Test coverage
• ✅ Documentation updates

The implementation is minimal, non-breaking, and follows existing Glint patterns.

Would love to hear thoughts from the maintainers and community!

[NullVoxPopuli]

The limitation here is with typescript, as we build on top of that.

Does typescript have a similar feature?

[BojanRatkovic]

TypeScript does support single file checking, but with significant limitations that prevent it from being useful in real-world projects.

TypeScript's Current Behavior:

✅ Works: Single file, but ignores tsconfig.json
tsc file.ts

✅ Works: Uses tsconfig.json, but checks ALL files  
tsc --project tsconfig.json

❌ FAILS: Cannot combine project config with specific files
tsc --project tsconfig.json file.ts
# Error: "Option 'project' cannot be mixed with source files on a command line"

So When you run tsc file.ts, TypeScript ignores your tsconfig.json entirely, which means no baseUrl or paths mappings, o project-specific compilerOptions, no types configuration etc... Basically this makes single-file checking essentially useless for any real project that relies on TypeScript configuration.

My solution

• Reading your project's tsconfig.json.
• Creating a temporary config that inherits ALL your settings.
• Adding only "files": ["specific-file.gts"] to limit scope.
• Cleanup

This gives you the best of both worlds: project configuration + file-specific checking.

I've successfully implemented a working solution that uses TypeScript's built-in features to enable single and multiple file checking while preserving full project context. P.S I'm unable to create a PR due to a 403.

I'd be happy to discuss the approach further or find alternative ways to contribute.

[NullVoxPopuli]

403? What do you mean?

[BojanRatkovic]

No permissions. 🤷‍♂️

remote: Permission to typed-ember/glint.git denied to BojanRatkovic.
fatal: unable to access 'https://github.com/typed-ember/glint.git/': The requested URL returned error: 403

[NullVoxPopuli]

You have to fork the repo first, push to your remote, and then it'll let you make a pr <3