0
# @swc/types
1

2
@swc/types provides comprehensive TypeScript type definitions for @swc/core APIs, serving as a lightweight dependency for tools that need SWC type information without depending on the full @swc/core package. It contains extensive type definitions for JavaScript minification options (including Terser-compatible interfaces), parsing configurations, AST node types, plugin interfaces, and compilation assumptions.
3

4
## Package Information
5

6
- **Package Name**: @swc/types
7
- **Package Type**: npm
8
- **Language**: TypeScript
9
- **Installation**: `npm install @swc/types`
10

11
## Core Imports
12

13
```typescript
14
import type { 
15
  Options, Config, JscConfig, ModuleConfig,
16
  Plugin, ParseOptions, JsMinifyOptions,
17
  // AST types
18
  Program, Module, Statement, Expression,
19
  // JSX types
20
  JSXElement, JSXFragment, JSXElementChild,
21
  // TypeScript types
22
  TsType, TsInterfaceDeclaration,
23
  // Babel assumptions
24
  Assumptions
25
} from "@swc/types";
26
```
27

28
CommonJS:
29

30
```javascript
31
const { Options, Config } = require("@swc/types");
32
```
33

34
## Basic Usage
35

36
```typescript
37
import type { Options, JscConfig, ModuleConfig } from "@swc/types";
38

39
// SWC compilation configuration with JSX support
40
const swcOptions: Options = {
41
  jsc: {
42
    target: "es2020",
43
    parser: {
44
      syntax: "typescript",
45
      tsx: true,
46
      decorators: true
47
    },
48
    transform: {
49
      react: {
50
        runtime: "automatic"
51
      }
52
    },
53
    assumptions: {
54
      constantSuper: true,
55
      noClassCalls: true,
56
      privateFieldsAsProperties: true
57
    }
58
  },
59
  module: {
60
    type: "es6"
61
  },
62
  minify: true
63
};
64

65
// Minification configuration
66
const minifyOptions: JsMinifyOptions = {
67
  compress: {
68
    dead_code: true,
69
    drop_console: true
70
  },
71
  mangle: {
72
    topLevel: true
73
  }
74
};
75
```
76

77
## Architecture
78

79
@swc/types is organized around several key type categories:
80

81
- **Configuration Types**: Interfaces for configuring SWC compilation, parsing, and transformation
82
- **AST Node Types**: Complete JavaScript/TypeScript abstract syntax tree definitions
83
- **TypeScript Support**: TypeScript-specific syntax and type system representations
84
- **Minification Types**: Terser-compatible interfaces for code optimization
85
- **Module Systems**: Type definitions for various module formats (ES6, CommonJS, UMD, AMD)
86
- **Plugin System**: WebAssembly plugin interfaces and configuration types
87

88
## Capabilities
89

90
### Configuration and Options
91

92
Core configuration interfaces for SWC compilation, parsing, and transformation. Essential for any tool integrating with SWC.
93

94
```typescript { .api }
95
interface Options extends Config {
96
  script?: boolean;
97
  cwd?: string;
98
  filename?: string;
99
  root?: string;
100
  rootMode?: "root" | "upward" | "upward-optional";
101
}
102

103
interface Config {
104
  test?: string | string[];
105
  exclude?: string | string[];
106
  env?: EnvConfig;
107
  jsc?: JscConfig;
108
  module?: ModuleConfig;
109
  minify?: boolean;
110
  sourceMaps?: boolean | "inline";
111
}
112

113
interface JscConfig {
114
  assumptions?: Assumptions;
115
  parser?: ParserConfig;
116
  transform?: TransformConfig;
117
  target?: JscTarget;
118
  minify?: JsMinifyOptions;
119
}
120
```
121

122
[Configuration](./configuration.md)
123

124
### AST Node Types
125

126
Complete abstract syntax tree type definitions covering all JavaScript and TypeScript syntax elements. Used for AST manipulation and analysis.
127

128
```typescript { .api }
129
type Program = Module | Script;
130

131
interface Module extends Node, HasSpan {
132
  type: "Module";
133
  body: ModuleItem[];
134
}
135

136
type Statement = 
137
  | BlockStatement | EmptyStatement | DebuggerStatement
138
  | WithStatement | ReturnStatement | LabeledStatement
139
  | BreakStatement | ContinueStatement | IfStatement
140
  | SwitchStatement | ThrowStatement | TryStatement
141
  | WhileStatement | DoWhileStatement | ForStatement
142
  | ForInStatement | ForOfStatement | Declaration
143
  | ExpressionStatement;
144

145
type Expression = 
146
  | ThisExpression | ArrayExpression | ObjectExpression
147
  | FunctionExpression | UnaryExpression | UpdateExpression
148
  | BinaryExpression | AssignmentExpression | MemberExpression
149
  | ConditionalExpression | CallExpression | NewExpression
150
  | Identifier | Literal | TemplateLiteral
151
  | ArrowFunctionExpression | ClassExpression | YieldExpression
152
  | AwaitExpression | OptionalChainingExpression;
153
```
154

155
[AST Nodes](./ast-nodes.md)
156

157
### TypeScript Support
158

159
TypeScript-specific AST nodes and type system representations for TypeScript compilation and analysis.
160

161
```typescript { .api }
162
type TsType = 
163
  | TsKeywordType | TsThisType | TsFnOrConstructorType
164
  | TsTypeReference | TsTypeQuery | TsTypeLiteral
165
  | TsArrayType | TsTupleType | TsOptionalType
166
  | TsRestType | TsUnionOrIntersectionType
167
  | TsConditionalType | TsInferType | TsParenthesizedType
168
  | TsTypeOperator | TsIndexedAccessType | TsMappedType
169
  | TsLiteralType | TsTypePredicate | TsImportType;
170

171
interface TsInterfaceDeclaration extends Node, HasSpan {
172
  type: "TsInterfaceDeclaration";
173
  id: Identifier;
174
  declare: boolean;
175
  typeParams?: TsTypeParameterDeclaration;
176
  extends: TsExpressionWithTypeArguments[];
177
  body: TsInterfaceBody;
178
}
179

180
interface TsTypeAliasDeclaration extends Node, HasSpan {
181
  type: "TsTypeAliasDeclaration";
182
  declare: boolean;
183
  id: Identifier;
184
  typeParams?: TsTypeParameterDeclaration;
185
  typeAnnotation: TsType;
186
}
187
```
188

189
[TypeScript Support](./typescript.md)
190

191
### Minification Options
192

193
Terser-compatible interfaces for JavaScript minification and code optimization.
194

195
```typescript { .api }
196
interface JsMinifyOptions {
197
  compress?: TerserCompressOptions | boolean;
198
  format?: JsFormatOptions;
199
  mangle?: TerserMangleOptions | boolean;
200
  ecma?: TerserEcmaVersion;
201
  keep_classnames?: boolean;
202
  keep_fnames?: boolean;
203
  module?: boolean | "unknown";
204
  sourceMap?: boolean;
205
}
206

207
interface TerserCompressOptions {
208
  arguments?: boolean;
209
  arrows?: boolean;
210
  booleans?: boolean;
211
  dead_code?: boolean;
212
  drop_console?: boolean;
213
  drop_debugger?: boolean;
214
  evaluate?: boolean;
215
  // ... extensive compression options
216
}
217
```
218

219
[Minification](./minification.md)
220

221
### Module Systems
222

223
Type definitions for various JavaScript module systems and their configuration options.
224

225
```typescript { .api }
226
type ModuleConfig = 
227
  | Es6Config | CommonJsConfig | UmdConfig 
228
  | AmdConfig | NodeNextConfig | SystemjsConfig;
229

230
interface BaseModuleConfig {
231
  strict?: boolean;
232
  strictMode?: boolean;
233
  lazy?: boolean | string[];
234
  importInterop?: "swc" | "babel" | "node" | "none";
235
}
236

237
interface Es6Config extends BaseModuleConfig {
238
  type: "es6";
239
}
240

241
interface CommonJsConfig extends BaseModuleConfig {
242
  type: "commonjs";
243
}
244
```
245

246
[Module Systems](./modules.md)
247

248
### Parser Configuration
249

250
Parser configuration for JavaScript and TypeScript syntax support.
251

252
```typescript { .api }
253
type ParseOptions = ParserConfig & {
254
  comments?: boolean;
255
  script?: boolean;
256
  target?: JscTarget;
257
};
258

259
type ParserConfig = TsParserConfig | EsParserConfig;
260

261
interface TsParserConfig {
262
  syntax: "typescript";
263
  tsx?: boolean;
264
  decorators?: boolean;
265
}
266

267
interface EsParserConfig {
268
  syntax: "ecmascript";
269
  jsx?: boolean;
270
  decorators?: boolean;
271
  // ... additional ES feature flags
272
}
273
```
274

275
[Parser Configuration](./parser.md)
276

277
### JSX Support
278

279
Complete JSX/React AST node definitions for parsing and transforming JSX syntax. Essential for React applications and JSX-based frameworks.
280

281
```typescript { .api }
282
interface JSXElement extends Node, HasSpan {
283
  type: "JSXElement";
284
  opening: JSXOpeningElement;
285
  children: JSXElementChild[];
286
  closing?: JSXClosingElement;
287
}
288

289
interface JSXFragment extends Node, HasSpan {
290
  type: "JSXFragment";
291
  opening: JSXOpeningFragment;
292
  children: JSXElementChild[];
293
  closing: JSXClosingFragment;
294
}
295

296
type JSXElementName = 
297
  | Identifier              // <Button>
298
  | JSXMemberExpression     // <UI.Button>  
299
  | JSXNamespacedName;      // <svg:circle>
300

301
type JSXElementChild = 
302
  | JSXText | JSXExpressionContainer
303
  | JSXSpreadChild | JSXElement | JSXFragment;
304
```
305

306
[JSX Support](./jsx.md)
307

308
### Babel Assumptions
309

310
Optimization assumptions for Babel compatibility, enabling more efficient transformations when code behavior is predictable.
311

312
```typescript { .api }
313
interface Assumptions {
314
  /** Assume array-like objects are iterable */
315
  arrayLikeIsIterable?: boolean;
316
  /** Assume re-exported bindings are constant */
317
  constantReexports?: boolean;
318
  /** Assume super class doesn't change at runtime */
319
  constantSuper?: boolean;
320
  /** Assume classes are never called as functions */
321
  noClassCalls?: boolean;
322
  /** Transform private fields as regular properties */
323
  privateFieldsAsProperties?: boolean;
324
  /** Assume getters have no side effects */
325
  pureGetters?: boolean;
326
  // ... 17+ additional optimization flags
327
}
328
```
329

330
[Babel Assumptions](./assumptions.md)
331

332
## Types
333

334
```typescript { .api }
335
interface Node {
336
  type: string;
337
}
338

339
interface HasSpan {
340
  span: Span;
341
}
342

343
interface Span {
344
  start: number;
345
  end: number;
346
  ctxt: number;
347
}
348

349
type JscTarget = 
350
  | "es3" | "es5" | "es2015" | "es2016" | "es2017" 
351
  | "es2018" | "es2019" | "es2020" | "es2021" 
352
  | "es2022" | "es2023" | "es2024" | "esnext";
353

354
type TerserEcmaVersion = 5 | 2015 | 2016 | string | number;
355

356
interface Output {
357
  code: string;
358
  map?: string;
359
}
360
```