ts-node

constructor

constructor(
    diagnosticText: string,
    diagnosticCodes: number[],
    diagnostics?: readonly _ts.Diagnostic[]
);

property diagnosticCodes

diagnosticCodes: number[];

property diagnostics

diagnostics: readonly _ts.Diagnostic[];

property diagnosticText

diagnosticText: string;

property name

name: string;

property compiler

compiler?: string;

• Specify a custom TypeScript compiler.

  "typescript"

property compilerHost

compilerHost?: boolean;

• Use TypeScript's compiler host API instead of the language service API.

  false

property compilerOptions

compilerOptions?: object;

• JSON object to merge with TypeScript compilerOptions.

  [{"$ref": "https://schemastore.azurewebsites.net/schemas/json/tsconfig.json#definitions/compilerOptionsDefinition/properties/compilerOptions"}]

property cwd

cwd?: string;

• Behave as if invoked within this working directory. Roughly equivalent to cd $dir && ts-node ...

  process.cwd()

property dir

dir?: string;

• Legacy alias for cwd

  Deprecated

  use projectSearchDir or cwd

property emit

emit?: boolean;

• Emit output files into .ts-node directory.

  false

property esm

esm?: boolean;

• Enable native ESM support.

  For details, see https://typestrong.org/ts-node/docs/imports#native-ecmascript-modules

property experimentalReplAwait

experimentalReplAwait?: boolean;

• Allows the usage of top level await in REPL.

  Uses node's implementation which accomplishes this with an AST syntax transformation.

  Enabled by default when tsconfig target is es2018 or above. Set to false to disable.

  **Note**: setting to true when tsconfig target is too low will throw an Error. Leave as undefined to get default, automatic behavior.

property experimentalSpecifierResolution

experimentalSpecifierResolution?: 'node' | 'explicit';

• Like node's --experimental-specifier-resolution, , but can also be set in your tsconfig.json for convenience.

  For details, see https://nodejs.org/dist/latest-v18.x/docs/api/esm.html#customizing-esm-specifier-resolution-algorithm

property experimentalTsImportSpecifiers

experimentalTsImportSpecifiers?: boolean;

• Allow using voluntary .ts file extension in import specifiers.

  Typically, in ESM projects, import specifiers must have an emit extension, .js, .cjs, or .mjs, and we automatically map to the corresponding .ts, .cts, or .mts source file. This is the recommended approach.

  However, if you really want to use .ts in import specifiers, and are aware that this may break tooling, you can enable this flag.

property fileExists

fileExists?: (path: string) => boolean;

property files

files?: boolean;

• Load "files" and "include" from tsconfig.json on startup.

  Default is to override tsconfig.json "files" and "include" to only include the entrypoint script.

  false

property ignore

ignore?: string[];

• Paths which should not be compiled.

  Each string in the array is converted to a regular expression via new RegExp() and tested against source paths prior to compilation.

  Source paths are normalized to posix-style separators, relative to the directory containing tsconfig.json or to cwd if no tsconfig.json is loaded.

  Default is to ignore all node_modules subdirectories.

  ["(?:^|/)node_modules/"]

property ignoreDiagnostics

ignoreDiagnostics?: Array<number | string>;

• Ignore TypeScript warnings by diagnostic code.

property logError

logError?: boolean;

• Logs TypeScript errors to stderr instead of throwing exceptions.

  false

property moduleTypes

moduleTypes?: ModuleTypes;

• Override certain paths to be compiled and executed as CommonJS or ECMAScript modules. When overridden, the tsconfig "module" and package.json "type" fields are overridden, and the file extension is ignored. This is useful if you cannot use .mts, .cts, .mjs, or .cjs file extensions; it achieves the same effect.

  Each key is a glob pattern following the same rules as tsconfig's "include" array. When multiple patterns match the same file, the last pattern takes precedence.

  cjs overrides matches files to compile and execute as CommonJS. esm overrides matches files to compile and execute as native ECMAScript modules. package overrides either of the above to default behavior, which obeys package.json "type" and tsconfig.json "module" options.

property preferTsExts

preferTsExts?: boolean;

• Re-order file extensions so that TypeScript imports are preferred.

  For example, when both index.js and index.ts exist, enabling this option causes require('./index') to resolve to index.ts instead of index.js

  false

property pretty

pretty?: boolean;

• Use pretty diagnostic formatter.

  false

property project

project?: string;

• Path to TypeScript config file or directory containing a tsconfig.json. Similar to the tsc --project flag: https://www.typescriptlang.org/docs/handbook/compiler-options.html

property projectSearchDir

projectSearchDir?: string;

• Search for TypeScript config file (tsconfig.json) in this or parent directories.

property readFile

readFile?: (path: string) => string | undefined;

property require

require?: Array<string>;

• Modules to require, like node's --require flag.

  If specified in tsconfig.json, the modules will be resolved relative to the tsconfig.json file.

  If specified programmatically, each input string should be pre-resolved to an absolute path for best results.

property scope

scope?: boolean;

• Scope compiler to files within scopeDir.

  false

property scopeDir

scopeDir?: string;

• First of: tsconfig.json "rootDir" if specified, directory containing tsconfig.json, or cwd if no tsconfig.json is loaded.

property skipIgnore

skipIgnore?: boolean;

• Skip ignore check, so that compilation will be attempted for all files with matching extensions.

  false

property skipProject

skipProject?: boolean;

• Skip project config resolution and loading.

  false

property swc

swc?: boolean;

• Transpile with swc instead of the TypeScript compiler, and skip typechecking.

  Equivalent to setting both transpileOnly: true and transpiler: 'ts-node/transpilers/swc'

  For complete instructions: https://typestrong.org/ts-node/docs/transpilers

property transformers

transformers?:
    | _ts.CustomTransformers
    | ((p: _ts.Program) => _ts.CustomTransformers);

property transpileOnly

transpileOnly?: boolean;

• Use TypeScript's faster transpileModule.

  false

property transpiler

transpiler?: string | [string, object];

• Specify a custom transpiler for use with transpileOnly

property tsTrace

tsTrace?: (str: string) => void;

• A function to collect trace messages from the TypeScript compiler, for example when traceResolution is enabled.

  console.log

property typeCheck

typeCheck?: boolean;

• **DEPRECATED** Specify type-check is enabled (e.g. transpileOnly == false).

  true

property service

service?: Service;

property state

state?: EvalState;

property stderr

stderr?: NodeJS.WritableStream;

property stdin

stdin?: NodeJS.ReadableStream;

property stdout

stdout?: NodeJS.WritableStream;

property service

service: Pick<
    Service,
    Extract<'config' | 'options' | 'projectLocalResolveHelper', keyof Service>
>;

property getFormat

getFormat: NodeLoaderHooksAPI1.GetFormatHook;

property resolve

resolve: NodeLoaderHooksAPI1.ResolveHook;

property transformSource

transformSource: NodeLoaderHooksAPI1.TransformSourceHook;

property load

load: NodeLoaderHooksAPI2.LoadHook;

property resolve

resolve: NodeLoaderHooksAPI2.ResolveHook;

property experimentalResolver

experimentalResolver?: boolean;

• Enable experimental features that re-map imports and require calls to support: baseUrl, paths, rootDirs, .js to .ts file extension mappings, outDir to rootDir mappings for composite projects and monorepos.

  For details, see https://github.com/TypeStrong/ts-node/issues/1514

property evalAwarePartialHost

evalAwarePartialHost: EvalAwarePartialHost;

property state

readonly state: EvalState;

method evalCode

evalCode: (code: string) => any;

• Append code to the virtual source file, compile it to JavaScript, throw semantic errors if the typechecker is enabled, and execute it.

  Note: typically, you will want to call start() instead of using this method.

  Parameter code

  string of TypeScript.

method nodeEval

nodeEval: (
    code: string,
    context: any,
    _filename: string,
    callback: (err: Error | null, result?: any) => any
) => void;

• eval implementation compatible with node's REPL API

  Can be used in advanced scenarios if you want to manually create your own node REPL instance and delegate eval to this ReplService.

  Example:

  import {start} from 'repl'; const replService: tsNode.ReplService = ...; // assuming you have already created a ts-node ReplService const nodeRepl = start({eval: replService.eval});

method setService

setService: (service: Service) => void;

• Bind this REPL to a ts-node compiler service. A compiler service must be bound before eval-ing code or starting the REPL

method start

start: { (): void; (code: string): void };

• Start a node REPL

• Start a node REPL, evaling a string of TypeScript before it starts.

  Deprecated

property config

config: _ts.ParsedCommandLine;

property options

options: RegisterOptions;

property ts

ts: TSCommon;

method compile

compile: (code: string, fileName: string, lineOffset?: number) => string;

method enabled

enabled: (enabled?: boolean) => boolean;

method getTypeInfo

getTypeInfo: (code: string, fileName: string, position: number) => TypeInfo;

method ignored

ignored: (fileName: string) => boolean;

property fileName

fileName: string;

property diagnostics

diagnostics?: ts.Diagnostic[];

property outputText

outputText: string;

property sourceMapText

sourceMapText?: string;

method transpile

transpile: (input: string, options: TranspileOptions) => TranspileOutput;

property create

create: TranspilerFactory;

property createDocumentRegistry

createDocumentRegistry: typeof _ts.createDocumentRegistry;

property createEmitAndSemanticDiagnosticsBuilderProgram

createEmitAndSemanticDiagnosticsBuilderProgram: typeof _ts.createEmitAndSemanticDiagnosticsBuilderProgram;

property createIncrementalCompilerHost

createIncrementalCompilerHost: typeof _ts.createIncrementalCompilerHost;

property createIncrementalProgram

createIncrementalProgram: typeof _ts.createIncrementalProgram;

property createLanguageService

createLanguageService: typeof _ts.createLanguageService;

property createModuleResolutionCache

createModuleResolutionCache: typeof _ts.createModuleResolutionCache;

property createSourceFile

createSourceFile: typeof _ts.createSourceFile;

property displayPartsToString

displayPartsToString: typeof _ts.displayPartsToString;

property Extension

Extension: typeof _ts.Extension;

property findConfigFile

findConfigFile: typeof _ts.findConfigFile;

property flattenDiagnosticMessageText

flattenDiagnosticMessageText: typeof _ts.flattenDiagnosticMessageText;

property formatDiagnostics

formatDiagnostics: typeof _ts.formatDiagnostics;

property formatDiagnosticsWithColorAndContext

formatDiagnosticsWithColorAndContext: typeof _ts.formatDiagnosticsWithColorAndContext;

property getDefaultLibFileName

getDefaultLibFileName: typeof _ts.getDefaultLibFileName;

property getDefaultLibFilePath

getDefaultLibFilePath: typeof _ts.getDefaultLibFilePath;

property getPreEmitDiagnostics

getPreEmitDiagnostics: typeof _ts.getPreEmitDiagnostics;

property JsxEmit

JsxEmit: typeof _ts.JsxEmit;

property ModuleKind

ModuleKind: TSCommon.ModuleKindEnum;

property ModuleResolutionKind

ModuleResolutionKind: typeof _ts.ModuleResolutionKind;

property parseJsonConfigFileContent

parseJsonConfigFileContent: typeof _ts.parseJsonConfigFileContent;

property readConfigFile

readConfigFile: typeof _ts.readConfigFile;

property resolveModuleName

resolveModuleName: typeof _ts.resolveModuleName;

property resolveModuleNameFromCache

resolveModuleNameFromCache: typeof _ts.resolveModuleNameFromCache;

property resolveTypeReferenceDirective

resolveTypeReferenceDirective: typeof _ts.resolveTypeReferenceDirective;

property ScriptSnapshot

ScriptSnapshot: typeof _ts.ScriptSnapshot;

property ScriptTarget

ScriptTarget: typeof _ts.ScriptTarget;

property sys

sys: typeof _ts.sys;

property transpileModule

transpileModule: typeof _ts.transpileModule;

property version

version: typeof _ts.version;

property comment

comment: string;

property name

name: string;

type GetFormatHook

type GetFormatHook = (
    url: string,
    context: {},
    defaultGetFormat: GetFormatHook
) => Promise<{
    format: NodeLoaderHooksFormat;
}>;

type ResolveHook

type ResolveHook = NodeLoaderHooksAPI2.ResolveHook;

type TransformSourceHook

type TransformSourceHook = (
    source: string | Buffer,
    context: {
        url: string;
        format: NodeLoaderHooksFormat;
    },
    defaultTransformSource: NodeLoaderHooksAPI1.TransformSourceHook
) => Promise<{
    source: string | Buffer;
}>;

type LoadHook

type LoadHook = (
    url: string,
    context: {
        format: NodeLoaderHooksFormat | null | undefined;
        importAssertions?: NodeImportAssertions;
    },
    defaultLoad: NodeLoaderHooksAPI2['load']
) => Promise<{
    format: NodeLoaderHooksFormat;
    source: string | Buffer | undefined;
    shortCircuit?: boolean;
}>;

type NodeImportConditions

type NodeImportConditions = unknown;

type ResolveHook

type ResolveHook = (
    specifier: string,
    context: {
        conditions?: NodeImportConditions;
        importAssertions?: NodeImportAssertions;
        parentURL: string;
    },
    defaultResolve: ResolveHook
) => Promise<{
    url: string;
    format?: NodeLoaderHooksFormat;
    shortCircuit?: boolean;
}>;

type CompilerOptions

type CompilerOptions = _ts.CompilerOptions;

type FileReference

type FileReference = _ts.FileReference;

type ModuleKindEnum

type ModuleKindEnum = typeof _ts.ModuleKind & {
    Node16: typeof _ts.ModuleKind extends {
        Node16: any;
    }
        ? (typeof _ts.ModuleKind)['Node16']
        : 100;
};

type ModuleResolutionHost

type ModuleResolutionHost = _ts.ModuleResolutionHost;

type ParsedCommandLine

type ParsedCommandLine = _ts.ParsedCommandLine;

type ResolvedModule

type ResolvedModule = _ts.ResolvedModule;

type ResolvedModuleWithFailedLookupLocations

type ResolvedModuleWithFailedLookupLocations =
    _ts.ResolvedModuleWithFailedLookupLocations;

type ResolvedProjectReference

type ResolvedProjectReference = _ts.ResolvedProjectReference;

type ResolvedTypeReferenceDirective

type ResolvedTypeReferenceDirective = _ts.ResolvedTypeReferenceDirective;

type SourceFile

type SourceFile = _ts.SourceFile;

type CommonJS

type CommonJS = _ts.ModuleKind.CommonJS;

type ESNext

type ESNext = _ts.ModuleKind.ESNext;