or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

compilation.mdconfiguration.mdindex.mdprojects.mdreporters.mdstreams.md
tile.json

configuration.mddocs/

Configuration

Complete TypeScript compiler configuration with gulp-specific extensions, deprecated option handling, and support for custom transformers. The Settings interface provides comprehensive control over TypeScript compilation behavior.

Capabilities

Settings Interface

Core configuration interface for TypeScript compilation with support for all standard TypeScript compiler options plus gulp-specific extensions.

interface Settings {
    /** @deprecated Use outFile instead - Output file path for single file compilation */
    out?: string;
    /** Generate single JavaScript output file (only works with no module system) */
    outFile?: string;
    /** Output directory for compiled files */
    outDir?: string;
    /** Allow compilation of non-TypeScript files */
    allowNonTsExtensions?: boolean;
    /** Character set for reading source files */
    charset?: string;
    /** Code page for reading source files */
    codepage?: number;
    /** Generate corresponding .d.ts declaration files */
    declaration?: boolean;
    /** Locale for error messages */
    locale?: string;
    /** Root directory for source maps */
    mapRoot?: string;
    /** Do not emit outputs if any type checking errors were reported */
    noEmitOnError?: boolean;
    /** Warn on expressions and declarations with an implied 'any' type */
    noImplicitAny?: boolean;
    /** Do not include the default library file */
    noLib?: boolean;
    /** Skip type checking of declaration files */
    noLibCheck?: boolean;
    /** Do not resolve module imports */
    noResolve?: boolean;
    /** Do not erase const enum declarations in generated code */
    preserveConstEnums?: boolean;
    /** Do not emit comments to output */
    removeComments?: boolean;
    /** Suppress noImplicitAny errors for indexing objects lacking index signatures */
    suppressImplicitAnyIndexErrors?: boolean;
    /** Specify ECMAScript target version */
    target?: string | ts.ScriptTarget;
    /** Specify module code generation */
    module?: string | ts.ModuleKind;
    /** Specify module resolution strategy */
    moduleResolution?: string | number;
    /** Specify JSX code generation */
    jsx?: string | number;
    /** @deprecated Use declaration instead - Generate corresponding .d.ts files */
    declarationFiles?: boolean;
    /** @deprecated Use noResolve instead - Do not resolve external modules */
    noExternalResolve?: boolean;
    /** @deprecated Removed in v3.0 - Sort output files */
    sortOutput?: boolean;
    /** Custom TypeScript transformers */
    getCustomTransformers?: GetCustomTransformers;
    /** TypeScript instance to use for compilation */
    typescript?: typeof ts;
    /** Compile files separately without type checking for faster builds */
    isolatedModules?: boolean;
    /** Specify root directory of input files */
    rootDir?: string;
    /** Specify list of root directories for module resolution */
    rootDirs?: any;
    /** List of library files to be included in compilation */
    lib?: string[];
    /** Enable experimental support for ES7 decorators */
    experimentalDecorators?: boolean;
    /** @deprecated Use gulp-sourcemaps instead - Source map root directory */
    sourceRoot?: string;
    /** Additional TypeScript compiler options */
    [name: string]: any;
}

Usage Examples:

import * as gulp from 'gulp';
import * as ts from 'gulp-typescript';

// Basic configuration
gulp.task('compile-basic', () => {
    return gulp.src('src/**/*.ts')
        .pipe(ts({
            target: 'ES2017',
            module: 'commonjs',
            outDir: 'dist',
            declaration: true
        }))
        .pipe(gulp.dest('dist'));
});

// Strict configuration for modern TypeScript  
gulp.task('compile-strict', () => {
    return gulp.src('src/**/*.ts')
        .pipe(ts({
            target: 'ES2020',
            module: 'ESNext',
            strict: true,
            noImplicitAny: true,
            noUnusedLocals: true,
            noUnusedParameters: true,
            exactOptionalPropertyTypes: true
        }))
        .pipe(gulp.dest('dist'));
});

// Configuration for library builds
gulp.task('compile-library', () => {
    return gulp.src('src/**/*.ts')
        .pipe(ts({
            target: 'ES5',
            module: 'umd', 
            declaration: true,
            removeComments: false,
            preserveConstEnums: true,
            lib: ['ES2015', 'DOM']
        }))
        .pipe(gulp.dest('lib'));
});

// Fast compilation with isolated modules
gulp.task('compile-fast', () => {
    return gulp.src('src/**/*.ts')
        .pipe(ts({
            isolatedModules: true,
            target: 'ES2017',
            module: 'commonjs'
        }))
        .pipe(gulp.dest('dist'));
});

Custom Transformers

Support for TypeScript custom transformers that modify the compilation process.

type GetCustomTransformers = string | ((program?: ts.Program) => ts.CustomTransformers | undefined);

type FinalTransformers = undefined | ((program?: ts.Program) => ts.CustomTransformers);

Usage Examples:

import * as gulp from 'gulp';
import * as ts from 'gulp-typescript';

// Using transformer from a module
const tsProject = ts.createProject('tsconfig.json', {
    getCustomTransformers: 'typescript-transform-paths'
});

// Using transformer function
const customProject = ts.createProject('tsconfig.json', {
    getCustomTransformers: (program) => ({
        before: [
            // Custom transformer that removes console.log statements
            (context) => (sourceFile) => {
                function visitor(node) {
                    // Remove console.log calls
                    if (ts.isCallExpression(node) && 
                        ts.isPropertyAccessExpression(node.expression) &&
                        node.expression.expression.getText() === 'console' &&
                        node.expression.name.getText() === 'log') {
                        return undefined;
                    }
                    return ts.visitEachChild(node, visitor, context);
                }
                return ts.visitNode(sourceFile, visitor);
            }
        ]
    })
});

gulp.task('compile-custom-transform', () => {
    return gulp.src('src/**/*.ts')
        .pipe(customProject())
        .pipe(gulp.dest('dist'));
});

TypeScript Version Configuration

Support for using custom TypeScript versions or forks.

interface Settings {
    /** TypeScript instance to use for compilation */
    typescript?: typeof ts;
}

Usage Examples:

import * as gulp from 'gulp';
import * as ts from 'gulp-typescript';

// Use specific TypeScript version
const customTsProject = ts.createProject('tsconfig.json', {
    typescript: require('typescript')
});

// Use TypeScript nightly build
const nightlyProject = ts.createProject('tsconfig.json', {
    typescript: require('typescript@next')
});

// Use custom TypeScript fork
const forkProject = ts.createProject('tsconfig.json', {
    typescript: require('my-typescript-fork')
});

gulp.task('compile-custom-ts', () => {
    return gulp.src('src/**/*.ts')
        .pipe(customTsProject())
        .pipe(gulp.dest('dist'));
});

Deprecated Options

Legacy configuration options that have been deprecated or removed in newer versions.

interface Settings {
    /** @deprecated Use outFile instead */
    out?: string;
    /** @deprecated Use declaration instead */
    declarationFiles?: boolean;
    /** @deprecated Use noResolve instead */
    noExternalResolve?: boolean;
    /** @deprecated Removed in v3.0 */
    sortOutput?: boolean;
    /** @deprecated Use gulp-sourcemaps instead */
    sourceRoot?: string;
}

Migration Examples:

// Deprecated usage (pre-v3.0)
const oldConfig = {
    out: 'bundle.js',              // Use outFile instead
    declarationFiles: true,        // Use declaration instead
    noExternalResolve: true,       // Use noResolve instead
    sortOutput: true,              // Removed - use outFile with gulp-concat
    sourceRoot: '../src'           // Use gulp-sourcemaps instead
};

// Modern equivalent
const modernConfig = {
    outFile: 'bundle.js',
    declaration: true,
    noResolve: true
    // sortOutput removed - use outFile or gulp-concat for concatenation
    // sourceRoot handled by gulp-sourcemaps plugin
};

// With gulp-sourcemaps for source map configuration
import * as sourcemaps from 'gulp-sourcemaps';

gulp.task('compile-with-sourcemaps', () => {
    return gulp.src('src/**/*.ts')
        .pipe(sourcemaps.init())
        .pipe(ts(modernConfig))
        .pipe(sourcemaps.write('.', { 
            sourceRoot: '../src',
            includeContent: false 
        }))
        .pipe(gulp.dest('dist'));
});

Standard TypeScript Options

All standard TypeScript compiler options are supported. Common options include:

interface StandardTypeScriptOptions {
    // Target and Module
    target?: 'ES3' | 'ES5' | 'ES2015' | 'ES2016' | 'ES2017' | 'ES2018' | 'ES2019' | 'ES2020' | 'ESNext';
    module?: 'none' | 'commonjs' | 'amd' | 'system' | 'umd' | 'es6' | 'es2015' | 'es2020' | 'esnext';
    
    // Strict Type Checking
    strict?: boolean;
    noImplicitAny?: boolean;
    strictNullChecks?: boolean;
    strictFunctionTypes?: boolean;
    strictBindCallApply?: boolean;
    strictPropertyInitialization?: boolean;
    noImplicitReturns?: boolean;
    noFallthroughCasesInSwitch?: boolean;
    noUncheckedIndexedAccess?: boolean;
    
    // Module Resolution
    moduleResolution?: 'node' | 'classic';
    baseUrl?: string;
    paths?: { [key: string]: string[] };
    rootDirs?: string[];
    typeRoots?: string[];
    types?: string[];
    allowSyntheticDefaultImports?: boolean;
    esModuleInterop?: boolean;
    
    // Emit
    declaration?: boolean;
    declarationMap?: boolean;
    emitDeclarationOnly?: boolean;
    sourceMap?: boolean;
    inlineSourceMap?: boolean;
    inlineSources?: boolean;
    outFile?: string;
    outDir?: string;
    removeComments?: boolean;
    noEmit?: boolean;
    noEmitOnError?: boolean;
    
    // JavaScript Support
    allowJs?: boolean;
    checkJs?: boolean;
    
    // Advanced
    skipLibCheck?: boolean;
    forceConsistentCasingInFileNames?: boolean;
}