Code Transformations

/**
 * Creates transformer to replace Angular component resources
 * Replaces templateUrl and styleUrls with webpack imports or direct content
 * @param shouldTransform - Function to determine if file should be transformed
 * @param getTypeChecker - Function to get TypeScript type checker
 * @param inlineStyleFileExtension - Optional file extension for inline styles
 * @returns TypeScript transformer factory
 */
function replaceResources(
  shouldTransform: (fileName: string) => boolean,
  getTypeChecker: () => ts.TypeChecker,
  inlineStyleFileExtension?: string
): ts.TransformerFactory<ts.SourceFile>;

import { replaceResources } from '@ngtools/webpack';

const transformer = replaceResources(
  (fileName) => fileName.endsWith('.component.ts'),
  () => typeChecker,
  'scss'
);

// Original component
@Component({
  selector: 'app-example',
  templateUrl: './example.component.html',
  styleUrls: ['./example.component.scss']
})

// Transformed (with directTemplateLoading: false)
@Component({
  selector: 'app-example',
  template: require('./example.component.html?ngResource'),
  styles: [require('./example.component.scss?ngResource')]
})

/**
 * Removes imports for which all identifiers have been removed
 * Works with type checker to identify unused imports after transformations
 * @param sourceFile - TypeScript source file to process
 * @param removedNodes - Array of nodes that have been removed by other transformers
 * @param getTypeChecker - Function to get TypeScript type checker
 * @param compilerOptions - TypeScript compiler options
 * @returns Set of import nodes to remove
 */
function elideImports(
  sourceFile: ts.SourceFile,
  removedNodes: ts.Node[],
  getTypeChecker: () => ts.TypeChecker,
  compilerOptions: ts.CompilerOptions
): Set<ts.Node>;

import { elideImports } from '@ngtools/webpack';

// After other transformers have removed code
const removedImports = elideImports(
  sourceFile,
  removedNodes,
  () => typeChecker,
  compilerOptions
);

// Original file
import { Component, OnInit, ViewChild } from '@angular/core';
import { HttpClient } from '@angular/common/http';

// If OnInit and ViewChild were removed by other transformers
// Result after elision:
import { Component } from '@angular/core';
// HttpClient import removed if unused

/**
 * Removes Ivy JIT support calls from compiled code
 * Optimizes production builds by removing development-only code
 * @param shouldTransform - Function to determine if file should be transformed
 * @returns TypeScript transformer factory
 */
function removeIvyJitSupportCalls(
  shouldTransform: (fileName: string) => boolean
): ts.TransformerFactory<ts.SourceFile>;

import { removeIvyJitSupportCalls } from '@ngtools/webpack';

const transformer = removeIvyJitSupportCalls(
  (fileName) => !fileName.includes('node_modules')
);

// Removes calls like:
// ɵɵsetClassMetadata, ɵɵsetNgModuleScope, etc.

/**
 * Finds and collects image domains from Angular applications  
 * Populates the global imageDomains set during compilation
 * @param imageDomains - Set to populate with discovered domains
 * @returns TypeScript transformer factory
 */
function findImageDomains(imageDomains: Set<string>): ts.TransformerFactory<ts.SourceFile>;

import { findImageDomains, imageDomains } from '@ngtools/webpack';

const transformer = findImageDomains(imageDomains);

// Automatically discovers domains from:
// <img src="https://example.com/image.jpg">
// backgroundImage: 'url(https://cdn.example.com/bg.png)'

/**
 * Creates transformers for Angular AOT compilation
 * Includes all necessary transformers for production AOT builds
 * @param compilerHost - Angular compiler host
 * @param compilerOptions - Angular compiler options  
 * @param program - TypeScript program
 * @param angularCompilerOptions - Angular-specific compiler options
 * @returns Object containing before and after transformers
 */
function createAotTransformers(
  compilerHost: CompilerHost,
  compilerOptions: CompilerOptions,
  program: ts.Program,
  angularCompilerOptions: AngularCompilerOptions
): {
  before: ts.TransformerFactory<ts.SourceFile>[];
  after: ts.TransformerFactory<ts.SourceFile>[];
};

/**
 * Creates transformers for Angular JIT compilation
 * Includes transformers needed for JIT development builds
 * @param compilerHost - Angular compiler host
 * @param compilerOptions - Angular compiler options
 * @param program - TypeScript program
 * @param angularCompilerOptions - Angular-specific compiler options
 * @returns Object containing before and after transformers
 */
function createJitTransformers(
  compilerHost: CompilerHost,
  compilerOptions: CompilerOptions,
  program: ts.Program,
  angularCompilerOptions: AngularCompilerOptions
): {
  before: ts.TransformerFactory<ts.SourceFile>[];
  after: ts.TransformerFactory<ts.SourceFile>[];
};

/**
 * Merges multiple transformer collections into a single collection
 * Combines before and after transformers from multiple sources
 * @param transformers - Array of transformer collections to merge
 * @returns Merged transformer collection
 */
function mergeTransformers(
  transformers: Array<{
    before?: ts.TransformerFactory<ts.SourceFile>[];
    after?: ts.TransformerFactory<ts.SourceFile>[];
  }>
): {
  before: ts.TransformerFactory<ts.SourceFile>[];
  after: ts.TransformerFactory<ts.SourceFile>[];
};

/**
 * Replaces bootstrap code in Angular applications
 * Modifies main.ts and similar bootstrap files for different compilation modes
 * @param shouldTransform - Function to determine if file should be transformed
 * @param getEntryModule - Function to get the entry module information
 * @param getTypeChecker - Function to get TypeScript type checker
 * @returns TypeScript transformer factory
 */
function replaceBootstrap(
  shouldTransform: (fileName: string) => boolean,
  getEntryModule: () => { path: string; className: string } | null,
  getTypeChecker: () => ts.TypeChecker
): ts.TransformerFactory<ts.SourceFile>;

import {
  createAotTransformers,
  createJitTransformers,
  mergeTransformers,
  replaceResources,
  elideImports,
  removeIvyJitSupportCalls,
  findImageDomains,
  imageDomains
} from '@ngtools/webpack';

// Create base transformers based on compilation mode
const baseTransformers = jitMode 
  ? createJitTransformers(host, options, program, angularOptions)
  : createAotTransformers(host, options, program, angularOptions);

// Create additional transformers
const resourceTransformer = replaceResources(
  (fileName) => fileName.endsWith('.component.ts'),
  () => typeChecker,
  'scss'
);

const domainTransformer = findImageDomains(imageDomains);

const jitRemovalTransformer = removeIvyJitSupportCalls(
  (fileName) => !fileName.includes('node_modules')
);

// Merge all transformers
const allTransformers = mergeTransformers([
  baseTransformers,
  {
    before: [resourceTransformer, domainTransformer],
    after: [jitRemovalTransformer]
  }
]);

// Apply transformers during TypeScript compilation
const result = ts.transpileModule(sourceCode, {
  compilerOptions,
  transformers: allTransformers
});

// Selective transformation based on file type
const shouldTransform = (fileName: string) => {
  return fileName.endsWith('.component.ts') || 
         fileName.endsWith('.module.ts') ||
         fileName.includes('/src/');
};

// Use cached type checker
let cachedTypeChecker: ts.TypeChecker;
const getTypeChecker = () => {
  return cachedTypeChecker || (cachedTypeChecker = program.getTypeChecker());
};