Systematic workflow for auditing TypeScript codebases for import hygiene issues (value vs. type imports, duplicates), missing base class extensions, and incomplete barrel file re-exports, with actionable fix patterns.
A step-by-step workflow for auditing TypeScript projects for common structural and import hygiene problems, then applying targeted fixes.
This skill covers four audit checks and their corresponding fixes:
| # | Issue | Fix |
|---|---|---|
| 1 | Value imports used only as type annotations | Split with import type |
| 2 | Duplicate imports from the same module | Consolidate into one import statement |
| 3 | Classes missing expected base class extension | Add extends BaseClass |
| 4 | Missing re-exports in barrel (index.ts) files | Add the missing export lines |
Before making any changes, read all files that need to be audited in a single parallel batch. This avoids slow sequential reads.
Read in parallel:
- src/index.ts (barrel file)
- src/**/*.ts (all source files)
- Any explicitly named files from the task spec
Look for:
import statements at the top of each fileclass Foo)For every import { A, B } from 'module' statement, check whether each
imported name is used only in type positions (: TypeName, as TypeName,
<TypeName> generics, implements TypeName). If a name never appears in a
value position (instantiation, function call, assignment), it should be a
type-only import.
// ❌ Bad — Foo is only used as a type annotation
import { Foo, bar } from './module';
const x: Foo = bar();
// ✅ Good — split into value import + type import
import { bar } from './module';
import type { Foo } from './module';
import type { ... } from 'module' statement.Scan for two or more import statements that reference the same module path:
// ❌ Bad — two imports from the same source
import { ComponentA } from './components';
import { ComponentB } from './components';
Merge all named imports from the same module into a single statement:
// ✅ Good
import { ComponentA, ComponentB } from './components';
If there is a mix of value and type imports from the same module, keep them as two separate lines (import { ... } and import type { ... }), but ensure there is at most one of each kind per module path.
Look for class declarations that:
// ❌ Missing base class
class MyPanel implements PanelInterface {
render() { ... }
}
// ✅ Correct
class MyPanel extends BasePanel implements PanelInterface {
render() { ... }
}
Add extends BaseClass between the class name and any implements clause:
class ClassName extends BaseClass implements InterfaceName { ... }
Ensure the base class is imported if it is not already.
A barrel file (index.ts) should re-export everything that is part of the
public API. Common gaps:
index.ts// src/components/MyWidget.ts
export class MyWidget { ... }
export type MyWidgetProps = { ... }
// src/components/index.ts — ❌ missing MyWidget
export { SomeOtherThing } from './SomeOtherThing';
Add the missing re-export line:
// src/components/index.ts — ✅ fixed
export { SomeOtherThing } from './SomeOtherThing';
export { MyWidget } from './MyWidget';
export type { MyWidgetProps } from './MyWidget';
Use export type { ... } for type-only exports to maintain strict type/value separation.
After edits, confirm:
import statements reference the same module path (same kind).import type { ... } statements.index.ts.tsc --noEmit).// Value import
import { foo, bar } from './module';
// Type-only import
import type { Foo, Bar } from './module';
// Mixed (value + type from same module — two lines)
import { foo } from './module';
import type { Foo } from './module';
// Re-export value
export { foo } from './module';
// Re-export type
export type { Foo } from './module';
// Re-export everything
export * from './module';
export type * from './module'; // TypeScript 5.0+
export * in barrel files for better tree-shaking and discoverability.verbatimModuleSyntax or isolatedModules in tsconfig.json, import type is required for type-only imports — the compiler will error otherwise.tsc --noEmit after each fix category to catch regressions early.38:["$","$L40",null,{"content":"$41","frontMatter":{"name":"typescript-import-audit","description":"Systematic workflow for auditing TypeScript codebases for import hygiene issues (value vs. type imports, duplicates), missing base class extensions, and incomplete barrel file re-exports, with actionable fix patterns."}}]