@knighted/duel 1.0.4 → 1.0.5

package/dist/cjs/duel.cjs

@@ -0,0 +1,215 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.duel = void 0;
+const node_process_1 = require("node:process");
+const node_path_1 = require("node:path");
+const node_child_process_1 = require("node:child_process");
+const promises_1 = require("node:fs/promises");
+const node_crypto_1 = require("node:crypto");
+const node_perf_hooks_1 = require("node:perf_hooks");
+const glob_1 = require("glob");
+const find_up_1 = require("find-up");
+const specifier_1 = require("@knighted/specifier");
+const init_js_1 = require("./init.cjs");
+const util_js_1 = require("./util.cjs");
+const tsc = await (0, find_up_1.findUp)(async (dir) => {
+    const tscBin = (0, node_path_1.join)(dir, 'node_modules', '.bin', 'tsc');
+    if (await (0, find_up_1.pathExists)(tscBin)) {
+        return tscBin;
+    }
+});
+const runBuild = (project, outDir) => {
+    return new Promise((resolve, reject) => {
+        const args = outDir ? ['-p', project, '--outDir', outDir] : ['-p', project];
+        const build = (0, node_child_process_1.spawn)(tsc, args, { stdio: 'inherit' });
+        build.on('error', err => {
+            reject(new Error(`Failed to compile: ${err.message}`));
+        });
+        build.on('close', code => {
+            if (code === null) {
+                return reject(new Error('Failed to compile.'));
+            }
+            if (code > 0) {
+                return reject(new Error('Compilation errors found.'));
+            }
+            resolve(code);
+        });
+    });
+};
+const duel = async (args) => {
+    const ctx = await (0, init_js_1.init)(args);
+    if (ctx) {
+        const { projectDir, tsconfig, configPath, parallel, dirs, pkg } = ctx;
+        const pkgDir = (0, node_path_1.dirname)(pkg.path);
+        const outDir = tsconfig.compilerOptions?.outDir ?? 'dist';
+        const absoluteOutDir = (0, node_path_1.resolve)(projectDir, outDir);
+        const originalType = pkg.packageJson.type ?? 'commonjs';
+        const isCjsBuild = originalType !== 'commonjs';
+        const targetExt = isCjsBuild ? '.cjs' : '.mjs';
+        const hex = (0, node_crypto_1.randomBytes)(4).toString('hex');
+        const getOverrideTsConfig = () => {
+            return {
+                ...tsconfig,
+                compilerOptions: {
+                    ...tsconfig.compilerOptions,
+                    module: 'NodeNext',
+                    moduleResolution: 'NodeNext',
+                },
+            };
+        };
+        const runPrimaryBuild = () => {
+            return runBuild(configPath, dirs
+                ? isCjsBuild
+                    ? (0, node_path_1.join)(absoluteOutDir, 'esm')
+                    : (0, node_path_1.join)(absoluteOutDir, 'cjs')
+                : absoluteOutDir);
+        };
+        const updateSpecifiersAndFileExtensions = async (filenames) => {
+            for (const filename of filenames) {
+                const dts = /(\.d\.ts)$/;
+                const outFilename = dts.test(filename)
+                    ? filename.replace(dts, isCjsBuild ? '.d.cts' : '.d.mts')
+                    : filename.replace(/\.js$/, targetExt);
+                const { code, error } = await specifier_1.specifier.update(filename, ({ value }) => {
+                    // Collapse any BinaryExpression or NewExpression to test for a relative specifier
+                    const collapsed = value.replace(/['"`+)\s]|new String\(/g, '');
+                    const relative = /^(?:\.|\.\.)\//;
+                    if (relative.test(collapsed)) {
+                        // $2 is for any closing quotation/parens around BE or NE
+                        return value.replace(/(.+)\.js([)'"`]*)?$/, `$1${targetExt}$2`);
+                    }
+                });
+                if (code && !error) {
+                    await (0, promises_1.writeFile)(outFilename, code);
+                    await (0, promises_1.rm)(filename, { force: true });
+                }
+            }
+        };
+        const logSuccess = start => {
+            (0, util_js_1.log)(`Successfully created a dual ${isCjsBuild ? 'CJS' : 'ESM'} build in ${Math.round(node_perf_hooks_1.performance.now() - start)}ms.`);
+        };
+        if (parallel) {
+            const paraName = `_${hex}_`;
+            const paraParent = (0, node_path_1.join)(projectDir, '..');
+            const paraTempDir = (0, node_path_1.join)(paraParent, paraName);
+            let isDirWritable = true;
+            try {
+                const stats = await (0, promises_1.stat)(paraParent);
+                if (stats.isDirectory()) {
+                    await (0, promises_1.access)(paraParent, promises_1.constants.W_OK);
+                }
+                else {
+                    isDirWritable = false;
+                }
+            }
+            catch {
+                isDirWritable = false;
+            }
+            if (!isDirWritable) {
+                (0, util_js_1.logError)('No writable directory to prepare parallel builds. Exiting.');
+                return;
+            }
+            (0, util_js_1.log)('Preparing parallel build...');
+            const prepStart = node_perf_hooks_1.performance.now();
+            await (0, promises_1.cp)(projectDir, paraTempDir, {
+                recursive: true,
+                /**
+                 * Ignore common .gitignored directories in Node.js projects.
+                 * Except node_modules.
+                 *
+                 * @see https://github.com/github/gitignore/blob/main/Node.gitignore
+                 */
+                filter: src => !/logs|pids|lib-cov|coverage|bower_components|build|dist|jspm_packages|web_modules|out|\.next|\.tsbuildinfo|\.npm|\.node_repl_history|\.tgz|\.yarn|\.pnp|\.nyc_output|\.grunt|\.DS_Store/i.test(src),
+            });
+            const dualConfigPath = (0, node_path_1.join)(paraTempDir, 'tsconfig.json');
+            const absoluteDualOutDir = (0, node_path_1.join)(paraTempDir, isCjsBuild ? (0, node_path_1.join)(outDir, 'cjs') : (0, node_path_1.join)(outDir, 'esm'));
+            const tsconfigDual = getOverrideTsConfig();
+            await (0, promises_1.writeFile)(dualConfigPath, JSON.stringify(tsconfigDual));
+            await (0, promises_1.writeFile)((0, node_path_1.join)(paraTempDir, 'package.json'), JSON.stringify({
+                type: isCjsBuild ? 'commonjs' : 'module',
+            }));
+            (0, util_js_1.log)(`Prepared in ${Math.round(node_perf_hooks_1.performance.now() - prepStart)}ms.`);
+            (0, util_js_1.log)('Starting parallel dual builds...');
+            let success = false;
+            const startTime = node_perf_hooks_1.performance.now();
+            try {
+                await Promise.all([
+                    runPrimaryBuild(),
+                    runBuild(dualConfigPath, absoluteDualOutDir),
+                ]);
+                success = true;
+            }
+            catch ({ message }) {
+                (0, util_js_1.logError)(message);
+            }
+            if (success) {
+                const filenames = await (0, glob_1.glob)(`${absoluteDualOutDir}/**/*{.js,.d.ts}`, {
+                    ignore: 'node_modules/**',
+                });
+                await updateSpecifiersAndFileExtensions(filenames);
+                // Copy over and cleanup
+                await (0, promises_1.cp)(absoluteDualOutDir, (0, node_path_1.join)(absoluteOutDir, isCjsBuild ? 'cjs' : 'esm'), {
+                    recursive: true,
+                });
+                await (0, promises_1.rm)(paraTempDir, { force: true, recursive: true });
+                logSuccess(startTime);
+            }
+        }
+        else {
+            (0, util_js_1.log)('Starting primary build...');
+            let success = false;
+            const startTime = node_perf_hooks_1.performance.now();
+            try {
+                await runPrimaryBuild();
+                success = true;
+            }
+            catch ({ message }) {
+                (0, util_js_1.logError)(message);
+            }
+            if (success) {
+                const dualConfigPath = (0, node_path_1.join)(projectDir, `tsconfig.${hex}.json`);
+                const absoluteDualOutDir = (0, node_path_1.join)(projectDir, isCjsBuild ? (0, node_path_1.join)(outDir, 'cjs') : (0, node_path_1.join)(outDir, 'esm'));
+                const tsconfigDual = getOverrideTsConfig();
+                const pkgRename = 'package.json.bak';
+                /**
+                 * Create a new package.json with updated `type` field.
+                 * Create a new tsconfig.json.
+                 *
+                 * The need to create a new package.json makes doing
+                 * the builds in parallel difficult.
+                 */
+                await (0, promises_1.rename)(pkg.path, (0, node_path_1.join)(pkgDir, pkgRename));
+                await (0, promises_1.writeFile)(pkg.path, JSON.stringify({
+                    type: isCjsBuild ? 'commonjs' : 'module',
+                }));
+                await (0, promises_1.writeFile)(dualConfigPath, JSON.stringify(tsconfigDual));
+                // Build dual
+                (0, util_js_1.log)('Starting dual build...');
+                try {
+                    await runBuild(dualConfigPath, absoluteDualOutDir);
+                }
+                catch ({ message }) {
+                    success = false;
+                    (0, util_js_1.logError)(message);
+                }
+                // Cleanup and restore
+                await (0, promises_1.rm)(dualConfigPath, { force: true });
+                await (0, promises_1.rm)(pkg.path, { force: true });
+                await (0, promises_1.rename)((0, node_path_1.join)(pkgDir, pkgRename), pkg.path);
+                if (success) {
+                    const filenames = await (0, glob_1.glob)(`${absoluteDualOutDir}/**/*{.js,.d.ts}`, {
+                        ignore: 'node_modules/**',
+                    });
+                    await updateSpecifiersAndFileExtensions(filenames);
+                    logSuccess(startTime);
+                }
+            }
+        }
+    }
+};
+exports.duel = duel;
+const realFileUrlArgv1 = await (0, util_js_1.getRealPathAsFileUrl)(node_process_1.argv[1]);
+if (import.meta.url === realFileUrlArgv1) {
+    await duel();
+}

package/dist/cjs/duel.d.cts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export function duel(args: any): Promise<void>;

package/dist/cjs/init.cjs

@@ -0,0 +1,126 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = void 0;
+const node_process_1 = require("node:process");
+const node_util_1 = require("node:util");
+const node_path_1 = require("node:path");
+const promises_1 = require("node:fs/promises");
+const read_pkg_up_1 = require("read-pkg-up");
+const jsonc_parser_1 = __importDefault(require("jsonc-parser"));
+const util_js_1 = require("./util.cjs");
+const init = async (args) => {
+    let parsed = null;
+    try {
+        const { values } = (0, node_util_1.parseArgs)({
+            args,
+            options: {
+                project: {
+                    type: 'string',
+                    short: 'p',
+                    default: 'tsconfig.json',
+                },
+                'target-extension': {
+                    type: 'string',
+                    short: 'x',
+                    default: '',
+                },
+                'pkg-dir': {
+                    type: 'string',
+                    short: 'k',
+                    default: (0, node_process_1.cwd)(),
+                },
+                parallel: {
+                    type: 'boolean',
+                    short: 'l',
+                    default: false,
+                },
+                dirs: {
+                    type: 'boolean',
+                    short: 'd',
+                    default: false,
+                },
+                help: {
+                    type: 'boolean',
+                    short: 'h',
+                    default: false,
+                },
+            },
+        });
+        parsed = values;
+    }
+    catch (err) {
+        (0, util_js_1.logError)(err.message);
+        return false;
+    }
+    if (parsed.help) {
+        (0, util_js_1.log)('Usage: duel [options]\n');
+        (0, util_js_1.log)('Options:');
+        (0, util_js_1.log)("--project, -p [path] \t Compile the project given the path to its configuration file, or to a folder with a 'tsconfig.json'.");
+        (0, util_js_1.log)('--pkg-dir, -k [path] \t The directory to start looking for a package.json file. Defaults to cwd.');
+        (0, util_js_1.log)('--dirs, -d \t\t Output both builds to directories inside of outDir. [esm, cjs].');
+        (0, util_js_1.log)('--parallel, -l \t\t Run the builds in parallel.');
+        (0, util_js_1.log)('--help, -h \t\t Print this message.');
+    }
+    else {
+        const { project, 'target-extension': targetExt, 'pkg-dir': pkgDir, parallel, dirs, } = parsed;
+        let configPath = (0, node_path_1.resolve)(project);
+        let stats = null;
+        let pkg = null;
+        if (targetExt) {
+            (0, util_js_1.logError)('--target-extension is deprecated. Define "type" in your package.json instead and the dual build will be inferred from that.');
+            return false;
+        }
+        pkg = await (0, read_pkg_up_1.readPackageUp)({ cwd: pkgDir });
+        if (!pkg) {
+            (0, util_js_1.logError)('No package.json file found.');
+            return false;
+        }
+        try {
+            stats = await (0, promises_1.stat)(configPath);
+        }
+        catch {
+            (0, util_js_1.logError)(`Provided --project '${project}' resolves to ${configPath} which is not a file or directory.`);
+            return false;
+        }
+        if (stats.isDirectory()) {
+            configPath = (0, node_path_1.join)(configPath, 'tsconfig.json');
+            try {
+                stats = await (0, promises_1.stat)(configPath);
+            }
+            catch {
+                (0, util_js_1.logError)(`Provided --project '${project}' resolves to a directory ${(0, node_path_1.dirname)(configPath)} with no tsconfig.json.`);
+                return false;
+            }
+        }
+        if (stats.isFile()) {
+            let tsconfig = null;
+            const errors = [];
+            const jsonText = (await (0, promises_1.readFile)(configPath)).toString();
+            tsconfig = jsonc_parser_1.default.parse(jsonText, errors, {
+                disallowComments: false,
+                allowTrailingComma: true,
+            });
+            if (errors.length) {
+                (0, util_js_1.logError)(`The config file found at ${configPath} is not parsable as JSONC.`);
+                return false;
+            }
+            if (!tsconfig.compilerOptions?.outDir) {
+                (0, util_js_1.log)('No outDir defined in tsconfig.json. Build output will be in "dist".');
+            }
+            const projectDir = (0, node_path_1.dirname)(configPath);
+            return {
+                pkg,
+                dirs,
+                parallel,
+                tsconfig,
+                projectDir,
+                configPath,
+            };
+        }
+    }
+    return false;
+};
+exports.init = init;

package/dist/cjs/init.d.ts

@@ -0,0 +1,8 @@
+export function init(args: any): Promise<false | {
+    pkg: import("read-pkg-up", { with: { "resolution-mode": "import" } }).NormalizedReadResult;
+    dirs: boolean | undefined;
+    parallel: boolean | undefined;
+    tsconfig: any;
+    projectDir: string;
+    configPath: string;
+}>;

package/dist/cjs/util.cjs

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRealPathAsFileUrl = exports.logError = exports.log = void 0;
+const node_url_1 = require("node:url");
+const promises_1 = require("node:fs/promises");
+const log = (color = '\x1b[30m', msg = '') => {
+    // eslint-disable-next-line no-console
+    console.log(`${color}%s\x1b[0m`, msg);
+};
+exports.log = log;
+const logError = log.bind(null, '\x1b[31m');
+exports.logError = logError;
+const getRealPathAsFileUrl = async (path) => {
+    const realPath = await (0, promises_1.realpath)(path);
+    const asFileUrl = (0, node_url_1.pathToFileURL)(realPath).href;
+    return asFileUrl;
+};
+exports.getRealPathAsFileUrl = getRealPathAsFileUrl;

package/dist/cjs/util.d.cts

@@ -0,0 +1,3 @@
+export function log(color?: string, msg?: string): void;
+export const logError: (msg?: string | undefined) => void;
+export function getRealPathAsFileUrl(path: any): Promise<string>;

package/dist/esm/duel.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export function duel(args: any): Promise<void>;

package/dist/esm/duel.js

@@ -0,0 +1,212 @@
+#!/usr/bin/env node
+import { argv } from 'node:process';
+import { join, dirname, resolve } from 'node:path';
+import { spawn } from 'node:child_process';
+import { writeFile, rm, cp, rename, stat, access, constants } from 'node:fs/promises';
+import { randomBytes } from 'node:crypto';
+import { performance } from 'node:perf_hooks';
+import { glob } from 'glob';
+import { findUp, pathExists } from 'find-up';
+import { specifier } from '@knighted/specifier';
+import { init } from './init.js';
+import { getRealPathAsFileUrl, logError, log } from './util.js';
+const tsc = await findUp(async (dir) => {
+    const tscBin = join(dir, 'node_modules', '.bin', 'tsc');
+    if (await pathExists(tscBin)) {
+        return tscBin;
+    }
+});
+const runBuild = (project, outDir) => {
+    return new Promise((resolve, reject) => {
+        const args = outDir ? ['-p', project, '--outDir', outDir] : ['-p', project];
+        const build = spawn(tsc, args, { stdio: 'inherit' });
+        build.on('error', err => {
+            reject(new Error(`Failed to compile: ${err.message}`));
+        });
+        build.on('close', code => {
+            if (code === null) {
+                return reject(new Error('Failed to compile.'));
+            }
+            if (code > 0) {
+                return reject(new Error('Compilation errors found.'));
+            }
+            resolve(code);
+        });
+    });
+};
+const duel = async (args) => {
+    const ctx = await init(args);
+    if (ctx) {
+        const { projectDir, tsconfig, configPath, parallel, dirs, pkg } = ctx;
+        const pkgDir = dirname(pkg.path);
+        const outDir = tsconfig.compilerOptions?.outDir ?? 'dist';
+        const absoluteOutDir = resolve(projectDir, outDir);
+        const originalType = pkg.packageJson.type ?? 'commonjs';
+        const isCjsBuild = originalType !== 'commonjs';
+        const targetExt = isCjsBuild ? '.cjs' : '.mjs';
+        const hex = randomBytes(4).toString('hex');
+        const getOverrideTsConfig = () => {
+            return {
+                ...tsconfig,
+                compilerOptions: {
+                    ...tsconfig.compilerOptions,
+                    module: 'NodeNext',
+                    moduleResolution: 'NodeNext',
+                },
+            };
+        };
+        const runPrimaryBuild = () => {
+            return runBuild(configPath, dirs
+                ? isCjsBuild
+                    ? join(absoluteOutDir, 'esm')
+                    : join(absoluteOutDir, 'cjs')
+                : absoluteOutDir);
+        };
+        const updateSpecifiersAndFileExtensions = async (filenames) => {
+            for (const filename of filenames) {
+                const dts = /(\.d\.ts)$/;
+                const outFilename = dts.test(filename)
+                    ? filename.replace(dts, isCjsBuild ? '.d.cts' : '.d.mts')
+                    : filename.replace(/\.js$/, targetExt);
+                const { code, error } = await specifier.update(filename, ({ value }) => {
+                    // Collapse any BinaryExpression or NewExpression to test for a relative specifier
+                    const collapsed = value.replace(/['"`+)\s]|new String\(/g, '');
+                    const relative = /^(?:\.|\.\.)\//;
+                    if (relative.test(collapsed)) {
+                        // $2 is for any closing quotation/parens around BE or NE
+                        return value.replace(/(.+)\.js([)'"`]*)?$/, `$1${targetExt}$2`);
+                    }
+                });
+                if (code && !error) {
+                    await writeFile(outFilename, code);
+                    await rm(filename, { force: true });
+                }
+            }
+        };
+        const logSuccess = start => {
+            log(`Successfully created a dual ${isCjsBuild ? 'CJS' : 'ESM'} build in ${Math.round(performance.now() - start)}ms.`);
+        };
+        if (parallel) {
+            const paraName = `_${hex}_`;
+            const paraParent = join(projectDir, '..');
+            const paraTempDir = join(paraParent, paraName);
+            let isDirWritable = true;
+            try {
+                const stats = await stat(paraParent);
+                if (stats.isDirectory()) {
+                    await access(paraParent, constants.W_OK);
+                }
+                else {
+                    isDirWritable = false;
+                }
+            }
+            catch {
+                isDirWritable = false;
+            }
+            if (!isDirWritable) {
+                logError('No writable directory to prepare parallel builds. Exiting.');
+                return;
+            }
+            log('Preparing parallel build...');
+            const prepStart = performance.now();
+            await cp(projectDir, paraTempDir, {
+                recursive: true,
+                /**
+                 * Ignore common .gitignored directories in Node.js projects.
+                 * Except node_modules.
+                 *
+                 * @see https://github.com/github/gitignore/blob/main/Node.gitignore
+                 */
+                filter: src => !/logs|pids|lib-cov|coverage|bower_components|build|dist|jspm_packages|web_modules|out|\.next|\.tsbuildinfo|\.npm|\.node_repl_history|\.tgz|\.yarn|\.pnp|\.nyc_output|\.grunt|\.DS_Store/i.test(src),
+            });
+            const dualConfigPath = join(paraTempDir, 'tsconfig.json');
+            const absoluteDualOutDir = join(paraTempDir, isCjsBuild ? join(outDir, 'cjs') : join(outDir, 'esm'));
+            const tsconfigDual = getOverrideTsConfig();
+            await writeFile(dualConfigPath, JSON.stringify(tsconfigDual));
+            await writeFile(join(paraTempDir, 'package.json'), JSON.stringify({
+                type: isCjsBuild ? 'commonjs' : 'module',
+            }));
+            log(`Prepared in ${Math.round(performance.now() - prepStart)}ms.`);
+            log('Starting parallel dual builds...');
+            let success = false;
+            const startTime = performance.now();
+            try {
+                await Promise.all([
+                    runPrimaryBuild(),
+                    runBuild(dualConfigPath, absoluteDualOutDir),
+                ]);
+                success = true;
+            }
+            catch ({ message }) {
+                logError(message);
+            }
+            if (success) {
+                const filenames = await glob(`${absoluteDualOutDir}/**/*{.js,.d.ts}`, {
+                    ignore: 'node_modules/**',
+                });
+                await updateSpecifiersAndFileExtensions(filenames);
+                // Copy over and cleanup
+                await cp(absoluteDualOutDir, join(absoluteOutDir, isCjsBuild ? 'cjs' : 'esm'), {
+                    recursive: true,
+                });
+                await rm(paraTempDir, { force: true, recursive: true });
+                logSuccess(startTime);
+            }
+        }
+        else {
+            log('Starting primary build...');
+            let success = false;
+            const startTime = performance.now();
+            try {
+                await runPrimaryBuild();
+                success = true;
+            }
+            catch ({ message }) {
+                logError(message);
+            }
+            if (success) {
+                const dualConfigPath = join(projectDir, `tsconfig.${hex}.json`);
+                const absoluteDualOutDir = join(projectDir, isCjsBuild ? join(outDir, 'cjs') : join(outDir, 'esm'));
+                const tsconfigDual = getOverrideTsConfig();
+                const pkgRename = 'package.json.bak';
+                /**
+                 * Create a new package.json with updated `type` field.
+                 * Create a new tsconfig.json.
+                 *
+                 * The need to create a new package.json makes doing
+                 * the builds in parallel difficult.
+                 */
+                await rename(pkg.path, join(pkgDir, pkgRename));
+                await writeFile(pkg.path, JSON.stringify({
+                    type: isCjsBuild ? 'commonjs' : 'module',
+                }));
+                await writeFile(dualConfigPath, JSON.stringify(tsconfigDual));
+                // Build dual
+                log('Starting dual build...');
+                try {
+                    await runBuild(dualConfigPath, absoluteDualOutDir);
+                }
+                catch ({ message }) {
+                    success = false;
+                    logError(message);
+                }
+                // Cleanup and restore
+                await rm(dualConfigPath, { force: true });
+                await rm(pkg.path, { force: true });
+                await rename(join(pkgDir, pkgRename), pkg.path);
+                if (success) {
+                    const filenames = await glob(`${absoluteDualOutDir}/**/*{.js,.d.ts}`, {
+                        ignore: 'node_modules/**',
+                    });
+                    await updateSpecifiersAndFileExtensions(filenames);
+                    logSuccess(startTime);
+                }
+            }
+        }
+    }
+};
+const realFileUrlArgv1 = await getRealPathAsFileUrl(argv[1]);
+if (import.meta.url === realFileUrlArgv1) {
+    await duel();
+}
+export { duel };

package/dist/esm/init.d.ts

@@ -0,0 +1,8 @@
+export function init(args: any): Promise<false | {
+    pkg: import("read-pkg-up").NormalizedReadResult;
+    dirs: boolean | undefined;
+    parallel: boolean | undefined;
+    tsconfig: any;
+    projectDir: string;
+    configPath: string;
+}>;