Parcel TypeScript TSC Transformer

{
  "extends": "@parcel/config-default",
  "transformers": {
    "*.{ts,tsx}": ["@parcel/transformer-typescript-tsc"]
  }
}

import TSCTransformer from "@parcel/transformer-typescript-tsc";

{
  "extends": "@parcel/config-default",
  "transformers": {
    "*.{ts,tsx}": ["@parcel/transformer-typescript-tsc"]
  }
}

{
  "compilerOptions": {
    "target": "es2020",
    "module": "esnext",
    "jsx": "react",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules"]
}

/**
 * Default export: Pre-configured Transformer instance created with new Transformer()
 * Contains loadConfig and transform function implementations
 */
export default Transformer;

/**
 * Transformer instance created with object literal containing:
 */
interface TransformerInstance {
  loadConfig({config, options}): Promise<TSConfig>;
  transform({asset, config, options}): Promise<Asset[]>;
}

interface LoadConfigParams {
  config: ConfigFile;
  options: ParcelOptions;
}

interface TransformParams {
  asset: Asset;
  config: TSConfig;
  options: ParcelOptions;
}

/**
 * Loads TypeScript configuration using @parcel/ts-utils.loadTSConfig
 * @param config - Parcel config object  
 * @param options - Parcel options object
 * @returns Processed TypeScript compiler options
 */
loadConfig({config, options}): Promise<TSConfig>;

/**
 * Transforms TypeScript asset to JavaScript using typescript.transpileModule
 * The implementation:
 * 1. Gets code and source map from asset
 * 2. Calls typescript.transpileModule with merged compiler options
 * 3. Processes source maps and extends with original map if present
 * 4. Sets asset type to 'js' and returns the modified asset
 * @param asset - Input TypeScript asset
 * @param config - TypeScript compiler configuration from loadConfig
 * @param options - Parcel build options
 * @returns Array containing single transformed JavaScript asset
 */
transform({asset, config, options}): Promise<Asset[]>;

/**
 * Compiler options merged in transform() method:
 * User config is spread first, then these options override/ensure correct behavior
 */
interface AppliedCompilerOptions {
  jsx: typescript.JsxEmit.React;           // React JSX compilation (default, user can override via tsconfig)
  noEmit: false;                           // Always emit output (forced)
  module: typescript.ModuleKind.ESNext;    // Preserve ES modules for scope hoisting (forced)
  sourceMap: boolean;                      // Based on asset.env.sourceMap (forced)
  mapRoot: string;                         // Set to options.projectRoot (forced)
}

/**
 * TranspileOptions passed to typescript.transpileModule
 */
interface TranspileOptions {
  compilerOptions: AppliedCompilerOptions;
  fileName: string;                        // Set to asset.filePath
}

// Flow type import (source uses Flow types)
import type {TranspileOptions} from 'typescript';

// Core Parcel plugin system
import {Transformer} from '@parcel/plugin';

// TypeScript configuration utilities
import {loadTSConfig} from '@parcel/ts-utils';  

// TypeScript compiler API
import typescript from 'typescript';

// Source map handling
import SourceMap from '@parcel/source-map';

{
  "compilerOptions": {
    "jsx": "react-jsx",
    "target": "es2022", 
    "strict": true,
    "experimentalDecorators": true,
    "emitDecoratorMetadata": true
  }
}

// Source maps enabled in development
process.env.NODE_ENV === 'development'

// Controlled via Parcel CLI
parcel build --no-source-maps

// Complete type definitions used by the transformer

// From TypeScript compiler API (imported as Flow type)
interface TranspileOptions {
  compilerOptions?: CompilerOptions;
  fileName?: string;
  reportDiagnostics?: boolean;
  moduleName?: string;
  renamedDependencies?: MapLike<string>;
}

interface TranspileOutput {
  outputText: string;
  diagnostics?: Diagnostic[];
  sourceMapText?: string;
}

interface CompilerOptions {
  jsx?: JsxEmit;
  noEmit?: boolean;
  module?: ModuleKind;
  sourceMap?: boolean;
  mapRoot?: string;
  target?: ScriptTarget;
  strict?: boolean;
  // ... plus all other TypeScript compiler options
}

// Asset interface from Parcel plugin system
interface Asset {
  getCode(): Promise<string>;
  getMap(): Promise<SourceMap | null>;
  setCode(code: string): void;  
  setMap(map: SourceMap): void;
  type: string;
  filePath: string;
  env: Environment;
}

interface Environment {
  sourceMap: boolean;
}

interface ParcelOptions {
  projectRoot: string;
}

interface ConfigFile {
  // Parcel config file interface
}

interface TSConfig {
  // TypeScript configuration object returned by loadTSConfig
}

// Constants from TypeScript API
enum JsxEmit {
  React = 'react'
}

enum ModuleKind {
  ESNext = 'esnext'
}