broccoli-typescript-compiler/dist/index.cjs.js

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var ts = require('typescript');
var fs = require('fs');
var crypto = require('crypto');

const useCaseSensitiveFileNames = ts.sys.useCaseSensitiveFileNames;
const getCanonicalFileName = ts.sys.useCaseSensitiveFileNames
    ? (fileName) => fileName
    : (fileName) => fileName.toLowerCase();
const defaultLibLocation = ts.getDirectoryPath(toCanonicalPath(ts.sys.getExecutingFilePath()));
function normalizePath(path) {
    if (path.length === 0) {
        return path;
    }
    return trimTrailingSlash(ts.normalizePath(path));
}
function isWithin(rootPath, path) {
    return (path.length > rootPath.length &&
        path.lastIndexOf(rootPath, 0) === 0 &&
        path.charCodeAt(rootPath.length) === 47 /* Slash */);
}
function relativePathWithin(root, path) {
    let relativePath;
    if (path.length > root.length &&
        path.lastIndexOf(root, 0) === 0 &&
        path.charCodeAt(root.length) === 47 /* Slash */) {
        relativePath = path.substring(root.length + 1);
    }
    else if (path === root) {
        relativePath = "";
    }
    return relativePath;
}
function toCanonicalPath(fileName, basePath) {
    const p = ts.toPath(fileName, basePath === undefined ? currentDirectory() : basePath, getCanonicalFileName);
    return trimTrailingSlash(p);
}
function toAbsolutePath(fileName, basePath) {
    const p = ts.toPath(fileName, basePath === undefined ? currentDirectory() : basePath, name => name);
    return trimTrailingSlash(p);
}
function trimTrailingSlash(path) {
    if (path.charCodeAt(path.length - 1) === 47 /* Slash */) {
        return path.slice(0, path.length - 1);
    }
    return path;
}
function currentDirectory() {
    return normalizePath(process.cwd());
}

function createParseConfigHost(workingPath, input) {
    function getFileSystemEntries(path) {
        return input.getFileSystemEntries(path);
    }
    function realpath(path) {
        return input.realpath(path) || path;
    }
    function readDirectory(rootDir, extensions, excludes, includes, depth) {
        return ts.matchFiles(rootDir, extensions, excludes, includes, useCaseSensitiveFileNames, workingPath, depth, getFileSystemEntries, realpath);
    }
    function fileExists(path) {
        return input.fileExists(path);
    }
    function readFile(path) {
        return input.readFile(path);
    }
    return {
        fileExists,
        readDirectory,
        readFile,
        useCaseSensitiveFileNames,
    };
}

class ConfigParser {
    constructor(projectPath, rawConfig, configFileName, compilerOptions, workingPath, input) {
        this.projectPath = projectPath;
        this.rawConfig = rawConfig;
        this.configFileName = configFileName;
        this.compilerOptions = compilerOptions;
        this.host = createParseConfigHost(workingPath, input);
    }
    parseConfig() {
        const configFileName = this.resolveConfigFileName();
        const basePath = this.getBasePath(configFileName);
        const existingOptions = this.convertExistingOptions(basePath);
        const result = this.parseConfigContent(configFileName, basePath, existingOptions.options);
        if (existingOptions.errors.length > 0) {
            result.errors = existingOptions.errors.concat(result.errors);
        }
        if (result.options.noEmit === true) {
            result.options.noEmit = false;
        }
        return result;
    }
    resolveConfigFileName() {
        if (this.rawConfig !== undefined) {
            return;
        }
        return ts.findConfigFile(this.projectPath, this.host.fileExists, this.configFileName);
    }
    getBasePath(configFilePath) {
        if (configFilePath === undefined) {
            return this.projectPath;
        }
        return ts.getDirectoryPath(configFilePath);
    }
    convertExistingOptions(basePath) {
        const { compilerOptions } = this;
        if (compilerOptions === undefined) {
            return {
                errors: [],
                options: undefined,
            };
        }
        return ts.convertCompilerOptionsFromJson(this.compilerOptions, basePath);
    }
    readConfigSourceFile(configFilePath) {
        if (configFilePath === undefined) {
            return;
        }
        const configFileText = this.host.readFile(configFilePath);
        if (configFileText === undefined) {
            throw new Error(`File '${configFilePath}' not found.`);
        }
        return ts.parseJsonText(configFilePath, configFileText);
    }
    parseConfigContent(configFileName, basePath, existingOptions) {
        const configSourceFile = this.readConfigSourceFile(configFileName);
        if (configSourceFile === undefined) {
            return ts.parseJsonConfigFileContent(this.rawConfig || {}, this.host, basePath, existingOptions);
        }
        return ts.parseJsonSourceFileConfigFileContent(configSourceFile, this.host, basePath, existingOptions, configFileName);
    }
}

function createCompilerHost(workingPath, input, sourceCache, compilerOptions) {
    const newLine = getNewLine(compilerOptions);
    return {
        directoryExists: path => input.directoryExists(path),
        fileExists: path => input.fileExists(path),
        getCanonicalFileName,
        getCurrentDirectory: () => workingPath,
        getDefaultLibFileName: options => toCanonicalPath(ts.getDefaultLibFileName(options), defaultLibLocation),
        getDefaultLibLocation: () => defaultLibLocation,
        getDirectories: path => input.getDirectories(path),
        getNewLine: () => newLine,
        getSourceFile: fileName => sourceCache.getSourceFile(fileName),
        getSourceFileByPath: (fileName, path) => sourceCache.getSourceFileByPath(fileName, path),
        readFile: path => input.readFile(path),
        realpath: path => input.realpath(path),
        trace: s => ts.sys.write(s + newLine),
        useCaseSensitiveFileNames: () => useCaseSensitiveFileNames,
        writeFile: () => {
            // we provide a write file on emit.
            throw new Error("compiler host does not write output");
        },
    };
}
function getNewLine(options) {
    let newLine;
    if (options.newLine === undefined) {
        newLine = ts.sys.newLine;
    }
    else {
        newLine = options.newLine === ts.NewLineKind.LineFeed ? "\n" : "\r\n";
    }
    return newLine;
}

class Cache {
    constructor(delegate) {
        this.delegate = delegate;
        this.hits = 0;
        this.misses = 0;
        this.store = new Map();
    }
    get(key) {
        const cacheKey = this.delegate.cacheKey(key);
        let value = this.store.get(cacheKey);
        if (value === undefined) {
            this.misses++;
            value = this.delegate.create(key);
            this.store.set(cacheKey, value);
        }
        else {
            this.hits++;
        }
        return value;
    }
    clear() {
        this.store.clear();
    }
}

function readFile(path) {
    const buffer = fs.readFileSync(path);
    const hash = crypto.createHash("sha1");
    hash.update(buffer);
    return { buffer, version: hash.digest("hex") };
}
function readFileResolution(resolution) {
    let path;
    if (resolution.isFile()) {
        if (resolution.isInput()) {
            path = resolution.pathInInput;
        }
        else {
            path = resolution.path;
        }
    }
    if (path) {
        return readFile(path);
    }
}
function stat(path) {
    try {
        return fs.statSync(path);
    }
    catch (e) {
        if (e.code === "ENOENT" || e.code === "EACCES") {
            return;
        }
        throw e;
    }
}
function readdir(path, resolver) {
    const prefix = path + "/";
    const files = [];
    const directories = [];
    for (const entry of fs.readdirSync(path).sort()) {
        const resolution = resolver.resolve(prefix + entry);
        if (resolution.isFile()) {
            files.push(entry);
        }
        else if (resolution.isDirectory()) {
            directories.push(entry);
        }
    }
    return { files, directories };
}

class DirEntriesCacheDelegate {
    constructor(resolver) {
        this.resolver = resolver;
    }
    cacheKey(path) {
        return path;
    }
    create(path) {
        return readdir(path, this.resolver);
    }
}

class DirEntriesCache extends Cache {
    constructor(resolver) {
        super(new DirEntriesCacheDelegate(resolver));
    }
}

class Input {
    constructor(resolver) {
        this.resolver = resolver;
        this.realpathCache = Object.create(null);
        this.entriesCache = new DirEntriesCache(resolver);
    }
    fileExists(path) {
        return this.resolve(path).isFile();
    }
    directoryExists(path) {
        return this.resolve(path).isDirectory();
    }
    /**
     * Used for type resolution.
     *
     * Will merge the view of input path and root path.
     */
    getDirectories(path) {
        const resolution = this.resolve(path);
        let directories;
        if (resolution.isDirectory()) {
            if (resolution.isInput()) {
                directories = this.readdir(resolution.canonicalPathInInput).directories;
                if (resolution.isMerged()) {
                    for (const other in this.readdir(resolution.canonicalPath)
                        .directories) {
                        if (directories.indexOf(other) === -1) {
                            directories.push(other);
                        }
                    }
                }
            }
            else {
                directories = this.readdir(resolution.canonicalPath).directories;
            }
        }
        else {
            directories = [];
        }
        return directories;
    }
    /**
     * Used by config parser for matching input.
     *
     * Unlike getDirectories which merges the view of input node and root.
     * We only allow this to return entries for things within the
     * broccoli input node.
     */
    getFileSystemEntries(path) {
        const resolution = this.resolve(path);
        let entries;
        if (resolution.isDirectory() && resolution.isInput()) {
            entries = this.readdir(resolution.canonicalPathInInput);
        }
        else {
            entries = { files: [], directories: [] };
        }
        return entries;
    }
    readFile(path) {
        const resolution = this.resolve(path);
        let resolved;
        if (resolution.isFile()) {
            if (resolution.isInput()) {
                resolved = resolution.pathInInput;
            }
            else {
                resolved = resolution.path;
            }
        }
        if (resolved !== undefined) {
            return ts.sys.readFile(resolved);
        }
    }
    relativePath(path) {
        return this.resolve(path).relativePath;
    }
    realpath(path) {
        const resolution = this.resolve(path);
        if (resolution.isInput()) {
            return resolution.path;
        }
        else if (resolution.exists()) {
            const realpath = fs.realpathSync(resolution.path, this.realpathCache);
            return this.resolve(realpath).path;
        }
    }
    reset() {
        this.entriesCache.clear();
        this.realpathCache = Object.create(null);
    }
    resolve(path) {
        return this.resolver.resolve(path);
    }
    readdir(path) {
        return this.entriesCache.get(path);
    }
}

const FSTree = require("fs-tree-diff");
const BroccoliPlugin = require("broccoli-plugin");
const walkSync = require("walk-sync");
const md5Hex = require("md5-hex");
const heimdall = require("heimdalljs");

class OutputPatcher {
    constructor(outputPath) {
        this.outputPath = outputPath;
        this.entries = [];
        this.contents = new Map();
        this.lastTree = undefined;
        this.isUnchanged = (entryA, entryB) => {
            if (entryA.isDirectory() && entryB.isDirectory()) {
                return true;
            }
            if (entryA.mode === entryB.mode && entryA.checksum === entryB.checksum) {
                return true;
            }
            return false;
        };
    }
    // relativePath should be without leading '/' and use forward slashes
    add(relativePath, content) {
        this.entries.push(new Entry(this.outputPath, relativePath, md5Hex(content)));
        this.contents.set(relativePath, content);
    }
    patch() {
        try {
            this.lastTree = this._patch();
        }
        catch (e) {
            // walkSync(output);
            this.lastTree = undefined;
            throw e;
        }
        finally {
            this.entries = [];
            this.contents = new Map();
        }
    }
    _patch() {
        const entries = this.entries;
        let lastTree = this.lastTree;
        const isUnchanged = this.isUnchanged;
        const outputPath = this.outputPath;
        const contents = this.contents;
        const nextTree = FSTree.fromEntries(entries, { sortAndExpand: true });
        if (!lastTree) {
            lastTree = FSTree.fromEntries(walkSync.entries(outputPath));
        }
        const patch = lastTree.calculatePatch(nextTree, isUnchanged);
        patch.forEach(change => {
            var _a;
            const op = change[0];
            const path = change[1];
            const entry = change[2];
            switch (op) {
                case "mkdir":
                    // the expanded dirs don't have a base
                    fs.mkdirSync(outputPath + "/" + path);
                    break;
                case "rmdir":
                    // the expanded dirs don't have a base
                    fs.rmdirSync(outputPath + "/" + path);
                    break;
                case "unlink":
                    fs.unlinkSync(entry.fullPath);
                    break;
                case "create":
                case "change":
                    fs.writeFileSync(entry.fullPath, (_a = contents.get(path)) !== null && _a !== void 0 ? _a : "");
                    break;
                default:
                    throw new Error(`unrecognized case ${op}`);
            }
        });
        return nextTree;
    }
}
/* tslint:disable:max-classes-per-file */
class Entry {
    constructor(basePath, relativePath, checksum) {
        this.basePath = basePath;
        this.relativePath = relativePath;
        this.checksum = checksum;
        this.mode = 0;
        this.size = 0;
        this.mtime = new Date();
        this.fullPath = basePath + "/" + relativePath;
        this.checksum = checksum;
    }
    isDirectory() {
        return false;
    }
}

function parsePath(rootPath, inputPath, rawPath) {
    let path = toAbsolutePath(rawPath, rootPath);
    let pathInInput;
    let relativePath = relativePathWithin(rootPath, path);
    if (relativePath === undefined) {
        relativePath = relativePathWithin(inputPath, path);
        if (relativePath !== undefined) {
            pathInInput = path;
            path = toAbsolutePath(relativePath, rootPath);
        }
    }
    else {
        pathInInput = toAbsolutePath(relativePath, inputPath);
    }
    const canonicalPath = toCanonicalPath(path);
    const canonicalPathInInput = pathInInput && toCanonicalPath(pathInInput);
    return {
        canonicalPath,
        canonicalPathInInput,
        path,
        pathInInput,
        relativePath,
    };
}

class PathInfoCacheDelegate {
    constructor(rootPath, inputPath) {
        this.rootPath = rootPath;
        this.inputPath = inputPath;
    }
    cacheKey(key) {
        return toCanonicalPath(key, this.rootPath);
    }
    create(key) {
        return parsePath(this.rootPath, this.inputPath, key);
    }
}

class PathInfoCache extends Cache {
    constructor(rootPath, inputPath) {
        super(new PathInfoCacheDelegate(rootPath, inputPath));
    }
}

function resolve(pathInfo) {
    let flags = 0 /* None */;
    let stats;
    let otherStats;
    if (pathInfo.pathInInput) {
        stats = stat(pathInfo.pathInInput);
        if (stats !== undefined) {
            flags |= 4 /* Input */;
        }
    }
    if (stats === undefined) {
        stats = stat(pathInfo.path);
    }
    if (stats !== undefined) {
        flags |= stats.isDirectory() ? 2 /* Dir */ : 1 /* File */;
    }
    if ((flags & 6 /* InputDir */) === 6 /* InputDir */) {
        otherStats = stat(pathInfo.path);
        if (otherStats !== undefined && otherStats.isDirectory()) {
            flags |= 8 /* Merge */;
        }
    }
    return new ResolutionImpl(pathInfo, stats, otherStats, flags);
}
class ResolutionImpl {
    constructor(pathInfo, stats, otherStats, flags) {
        this.stats = stats;
        this.otherStats = otherStats;
        this.flags = flags;
        this.canonicalPath = pathInfo.canonicalPath;
        this.canonicalPathInInput = pathInfo.canonicalPathInInput;
        this.path = pathInfo.path;
        this.pathInInput = pathInfo.pathInInput;
        this.relativePath = pathInfo.relativePath;
    }
    isInput() {
        return this.hasFlag(4 /* Input */);
    }
    isFile() {
        return this.hasFlag(1 /* File */);
    }
    isDirectory() {
        return this.hasFlag(2 /* Dir */);
    }
    isMerged() {
        return this.hasFlag(1 /* File */);
    }
    exists() {
        return this.stats !== undefined;
    }
    hasFlag(flag) {
        return (this.flags & flag) === flag;
    }
}

class ResolutionCacheDelegate {
    cacheKey(pathInfo) {
        return pathInfo.canonicalPath;
    }
    create(pathInfo) {
        return resolve(pathInfo);
    }
}

class ResolutionCache extends Cache {
    constructor() {
        super(new ResolutionCacheDelegate());
    }
}

class PathResolverImpl {
    constructor(rootPath, inputPath) {
        this.resolutionCache = new ResolutionCache();
        this.pathInfoCache = new PathInfoCache(rootPath, inputPath);
    }
    resolve(path) {
        const pathInfo = this.pathInfoCache.get(path);
        return this.resolutionCache.get(pathInfo);
    }
    reset() {
        // PathInfo cache is not build specific
        // resolutions are
        this.resolutionCache.clear();
    }
}

const SharedRegistry = ts.createDocumentRegistry();
class SourceCache {
    constructor(resolver, options) {
        this.resolver = resolver;
        this.options = options;
        this.sourceFiles = new Map();
        this.bucketKey = SharedRegistry.getKeyForCompilationSettings(options);
    }
    updateOptions(options) {
        const bucketKey = SharedRegistry.getKeyForCompilationSettings(options);
        this.options = options;
        if (this.bucketKey !== bucketKey) {
            this.releaseAll();
            this.bucketKey = bucketKey;
        }
    }
    getSourceFile(fileName) {
        const resolution = this.resolve(fileName);
        return this.getSourceFileByPath(fileName, resolution.canonicalPath);
    }
    getSourceFileByPath(fileName, path) {
        const resolution = this.resolve(path);
        return this.getSourceFileByResolution(resolution, fileName, path);
    }
    releaseUnusedSourceFiles(program) {
        const bucketKey = this.bucketKey;
        for (const path of this.sourceFiles.keys()) {
            if (program.getSourceFileByPath(path) === undefined) {
                SharedRegistry.releaseDocumentWithKey(path, bucketKey);
            }
        }
    }
    releaseAll() {
        const { bucketKey } = this;
        const paths = this.sourceFiles.keys();
        for (const path of paths) {
            SharedRegistry.releaseDocumentWithKey(path, bucketKey);
        }
        this.sourceFiles.clear();
    }
    resolve(fileName) {
        return this.resolver.resolve(fileName);
    }
    getSourceFileByResolution(resolution, fileName, path) {
        const content = readFileResolution(resolution);
        if (content) {
            return this.getOrUpdateSourceFile(fileName, path, content);
        }
    }
    getOrUpdateSourceFile(fileName, path, content) {
        const existing = this.sourceFiles.get(path);
        if (existing) {
            return this.updateSourceFile(existing, fileName, path, content);
        }
        else {
            return this.createSourceFile(fileName, path, content);
        }
    }
    updateSourceFile(existing, fileName, path, content) {
        const { version } = content;
        const { options, bucketKey } = this;
        const sourceFile = SharedRegistry.updateDocumentWithKey(fileName, path, options, bucketKey, snapshot(content.buffer), version);
        existing.sourceFile = sourceFile;
        existing.version = version;
        return sourceFile;
    }
    createSourceFile(fileName, path, content) {
        const { options, bucketKey, sourceFiles } = this;
        const { buffer, version } = content;
        const sourceFile = SharedRegistry.acquireDocumentWithKey(fileName, path, options, bucketKey, snapshot(buffer), version);
        sourceFiles.set(path, { sourceFile, version });
        return sourceFile;
    }
}
function snapshot(buffer) {
    return ts.ScriptSnapshot.fromString(buffer.toString("utf8"));
}

class Compiler {
    constructor(inputPath, outputPath, options, diagnosticsHandler) {
        this.inputPath = inputPath;
        this.outputPath = outputPath;
        this.options = options;
        this.diagnosticsHandler = diagnosticsHandler;
        const workingPath = (this.workingPath = options.workingPath);
        const rootPath = (this.rootPath = options.rootPath);
        this.buildPath = options.buildPath;
        const resolver = (this.resolver = new PathResolverImpl(rootPath, inputPath));
        const input = (this.input = new Input(resolver));
        this.configParser = new ConfigParser(options.projectPath, options.rawConfig, options.configFileName, options.compilerOptions, workingPath, input);
        this.output = new OutputPatcher(outputPath);
    }
    compile() {
        const config = this.parseConfig();
        const sourceCache = this.getSourceCache(config.options);
        const program = this.createProgram(config, sourceCache);
        this.emitDiagnostics(program);
        sourceCache.releaseUnusedSourceFiles(program);
        this.emitProgram(program, this.resolveBuildPath(config.options));
        this.patchOutput();
        this.resetCaches();
    }
    parseConfig() {
        const token = heimdall.start("TypeScript:parseConfig");
        const config = this.configParser.parseConfig();
        heimdall.stop(token);
        return config;
    }
    getSourceCache(options) {
        let sourceCache = this.sourceCache;
        if (sourceCache === undefined) {
            sourceCache = this.sourceCache = new SourceCache(this.resolver, options);
        }
        else {
            sourceCache.updateOptions(options);
        }
        return sourceCache;
    }
    createProgram(config, sourceCache) {
        const token = heimdall.start("TypeScript:createProgram");
        const host = createCompilerHost(this.workingPath, this.input, sourceCache, config.options);
        const oldProgram = this.program;
        const program = ts.createProgram(config.fileNames, config.options, host, oldProgram);
        this.program = program;
        heimdall.stop(token);
        return program;
    }
    emitDiagnostics(program) {
        // this is where bindings are resolved and typechecking is done
        const token = heimdall.start("TypeScript:emitDiagnostics");
        const diagnostics = ts.getPreEmitDiagnostics(program);
        heimdall.stop(token);
        this.diagnosticsHandler.check(diagnostics);
    }
    resolveBuildPath(options) {
        if (this.buildPath !== undefined) {
            return this.buildPath;
        }
        if (options.outDir !== undefined) {
            return normalizePath(options.outDir);
        }
        return this.rootPath;
    }
    emitProgram(program, buildPath) {
        const token = heimdall.start("TypeScript:emitProgram");
        const { output } = this;
        const emitResult = program.emit(undefined, (fileName, data) => {
            /* tslint:disable:no-console */
            // the fileName is absolute but not normalized if outDir is not normalized
            const relativePath = relativePathWithin(buildPath, toAbsolutePath(fileName, this.workingPath));
            if (relativePath) {
                output.add(relativePath, data);
            }
        });
        heimdall.stop(token);
        this.diagnosticsHandler.check(emitResult.diagnostics);
    }
    patchOutput() {
        const token = heimdall.start("TypeScript:patchOutput");
        this.output.patch();
        heimdall.stop(token);
    }
    resetCaches() {
        this.resolver.reset();
        this.input.reset();
    }
}

class DiagnosticsHandlerImpl {
    constructor(options) {
        this.write = ts.sys.write;
        this.throwOnError = options.throwOnError;
        this.host = createFormatDiagnosticsHost(options.workingPath);
    }
    setWrite(write) {
        this.write = write;
    }
    check(diagnostics, throwOnError) {
        const normalized = normalize(diagnostics);
        if (normalized === undefined) {
            return false;
        }
        const message = this.format(normalized);
        if (this.throwOnError || throwOnError === true) {
            throw new Error(message);
        }
        this.write(message);
        return true;
    }
    format(diagnostics) {
        return ts.formatDiagnostics(diagnostics, this.host);
    }
}
function normalize(diagnostics) {
    if (diagnostics === undefined) {
        return undefined;
    }
    if (Array.isArray(diagnostics)) {
        return diagnostics.length === 0 ? undefined : diagnostics;
    }
    return [diagnostics];
}
function createFormatDiagnosticsHost(rootPath) {
    const newLine = ts.sys.newLine;
    return {
        getCanonicalFileName,
        getCurrentDirectory: () => rootPath,
        getNewLine: () => newLine,
    };
}

function normalizeOptions(options) {
    const workingPath = toAbsolutePath(options.workingPath === undefined ? process.cwd() : options.workingPath);
    const rootPath = options.rootPath === undefined
        ? workingPath
        : toAbsolutePath(options.rootPath, workingPath);
    const projectPath = options.projectPath === undefined
        ? rootPath
        : toAbsolutePath(options.projectPath, workingPath);
    const buildPath = options.buildPath === undefined
        ? undefined
        : toAbsolutePath(options.buildPath, workingPath);
    const tsconfig = options.tsconfig;
    if (buildPath !== undefined &&
        !(rootPath === buildPath || isWithin(rootPath, buildPath))) {
        throw new Error(`buildPath "${buildPath}" must be at or within rootPath "${rootPath}"`);
    }
    let configFileName;
    let rawConfig;
    if (typeof tsconfig === "object") {
        configFileName = undefined;
        rawConfig = tsconfig;
    }
    else if (tsconfig) {
        configFileName = normalizePath(tsconfig);
        rawConfig = undefined;
    }
    let throwOnError = options.throwOnError;
    if (throwOnError === undefined) {
        throwOnError = process.env.NODE_ENV === "production";
    }
    return {
        buildPath,
        compilerOptions: options.compilerOptions,
        configFileName,
        projectPath,
        rawConfig,
        rootPath,
        throwOnError,
        workingPath,
    };
}

/**
 * Returns a Broccoli plugin instance that compiles
 * the files in the tsconfig.
 *
 * It is rooted to the inputNode's outputPath, all
 * files it imports must be resolvable from its input
 * except for the default library file.
 *
 * Errors are logged and it will try to emit whatever
 * it could successfully compile.
 *
 * It will only emit based on the root source files
 * you give it, by default it will look for all .ts
 * files, but if you specify a files or filesGlob
 * it will use these as entry points and only compile
 * the files and files they reference from the input.
 */
function typescript(inputNode, options) {
    return new TypescriptCompiler(inputNode, options);
}
/**
 * TypeScript Broccoli plugin class.
 */
class TypescriptCompiler extends BroccoliPlugin {
    constructor(inputNode, options) {
        super([inputNode], {
            annotation: options && options.annotation,
            name: "broccoli-typescript-compiler",
            persistentOutput: true,
        });
        const normalizedOptions = normalizeOptions(options || {});
        this.options = normalizedOptions;
        this.diagnosticHandler = new DiagnosticsHandlerImpl(normalizedOptions);
    }
    build() {
        const token = heimdall.start("TypeScript:compile");
        let compiler = this.compiler;
        if (!compiler) {
            compiler = this.compiler = new Compiler(toAbsolutePath(this.inputPaths[0]), toAbsolutePath(this.outputPath), this.options, this.diagnosticHandler);
        }
        compiler.compile();
        heimdall.stop(token);
    }
    setDiagnosticWriter(write) {
        this.diagnosticHandler.setWrite(write);
    }
}

const Funnel = require("broccoli-funnel");
const MergeTrees = require("broccoli-merge-trees");
/**
 * Backwards compat filter behavior.
 *
 * Preserves the filter aspect of compiling only .ts
 * and passing through all other files.
 */
function filterLike(inputNode, options) {
    const passthrough = new Funnel(inputNode, {
        annotation: "TypeScript passthrough",
        exclude: ["**/*.ts"],
    });
    const filter = new Funnel(inputNode, {
        annotation: "TypeScript input",
        include: ["**/*.ts"],
    });
    return new MergeTrees([passthrough, new TypescriptCompiler(filter, options)], {
        annotation: "TypeScript passthrough + output",
        overwrite: true,
    });
}

exports.ConfigParser = ConfigParser;
exports.InputIO = Input;
exports.PathResolver = PathResolverImpl;
exports.TypescriptCompiler = TypescriptCompiler;
exports.default = typescript;
exports.filterTypescript = filterLike;
exports.normalizePath = normalizePath;
exports.relativePathWithin = relativePathWithin;
exports.toAbsolutePath = toAbsolutePath;
exports.toCanonicalPath = toCanonicalPath;
//# sourceMappingURL=index.cjs.js.map