@evoscientist/webui 0.2.5 → 0.2.7

package/dist/node_modules/next/dist/lib/typescript/getTypeScriptConfiguration.js

@@ -11,49 +11,12 @@ Object.defineProperty(exports, "getTypeScriptConfiguration", {
 const _picocolors = require("../picocolors");
 const _os = /*#__PURE__*/ _interop_require_default(require("os"));
 const _path = /*#__PURE__*/ _interop_require_default(require("path"));
-const _semver = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/semver"));
-const _fatalerror = require("../fatal-error");
 const _iserror = /*#__PURE__*/ _interop_require_default(require("../is-error"));
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
-function resolvePathAliasTarget(baseUrl, target) {
-    if (_path.default.isAbsolute(target) || target.startsWith('./') || target.startsWith('../')) {
-        return target;
-    }
-    if (baseUrl === '.' || baseUrl === './') {
-        return `./${target}`;
-    }
-    const resolvedTarget = _path.default.join(baseUrl, target);
-    if (_path.default.isAbsolute(resolvedTarget) || resolvedTarget.startsWith('./') || resolvedTarget.startsWith('../')) {
-        return resolvedTarget;
-    }
-    return `./${resolvedTarget}`;
-}
-function rewritePathAliasesWithoutBaseUrl(baseUrl, originalPaths) {
-    const rewrittenPaths = originalPaths && typeof originalPaths === 'object' ? Object.fromEntries(Object.entries(originalPaths).map(([key, values])=>[
-            key,
-            Array.isArray(values) ? values.map((value)=>typeof value === 'string' ? resolvePathAliasTarget(baseUrl, value) : value) : values
-        ])) : {
-        '*': [
-            resolvePathAliasTarget(baseUrl, '*')
-        ]
-    };
-    if (!Object.prototype.hasOwnProperty.call(rewrittenPaths, '*')) {
-        rewrittenPaths['*'] = [
-            resolvePathAliasTarget(baseUrl, '*')
-        ];
-    }
-    return rewrittenPaths;
-}
-function getNormalizedBaseUrlForPaths(baseUrl, tsConfigPath) {
-    const tsConfigDir = _path.default.resolve(_path.default.dirname(tsConfigPath));
-    const absoluteBaseUrl = _path.default.isAbsolute(baseUrl) ? baseUrl : baseUrl.startsWith('./') || baseUrl.startsWith('../') ? _path.default.resolve(tsConfigDir, baseUrl) : _path.default.resolve(baseUrl);
-    const relativeBaseUrl = _path.default.relative(tsConfigDir, absoluteBaseUrl);
-    return relativeBaseUrl || '.';
-}
 async function getTypeScriptConfiguration(typescript, tsConfigPath, metaOnly) {
     try {
         var _result_errors;
@@ -64,46 +27,13 @@ async function getTypeScriptConfiguration(typescript, tsConfigPath, metaOnly) {
         };
         const { config, error } = typescript.readConfigFile(tsConfigPath, typescript.sys.readFile);
         if (error) {
-            throw Object.defineProperty(new _fatalerror.FatalError(typescript.formatDiagnostic(error, formatDiagnosticsHost)), "__NEXT_ERROR_CODE", {
+            throw Object.defineProperty(new Error(typescript.formatDiagnostic(error, formatDiagnosticsHost)), "__NEXT_ERROR_CODE", {
                 value: "E394",
                 enumerable: false,
                 configurable: true
             });
         }
         let configToParse = config;
-        if (_semver.default.gte(typescript.version, '6.0.0')) {
-            var _configToParse_compilerOptions, _configToParse_compilerOptions1;
-            const target = (_configToParse_compilerOptions = configToParse.compilerOptions) == null ? void 0 : _configToParse_compilerOptions.target;
-            if (typeof target === 'string' && (target.toLowerCase() === 'es3' || target.toLowerCase() === 'es5')) {
-                const { target: _target, ...restCompilerOptions } = configToParse.compilerOptions ?? {};
-                // TypeScript 6 deprecates ES3/ES5 targets. Rewrite deprecated
-                // targets in-memory to keep typechecking working without requiring
-                // `ignoreDeprecations`.
-                configToParse = {
-                    ...configToParse,
-                    compilerOptions: {
-                        ...restCompilerOptions,
-                        target: 'es2015'
-                    }
-                };
-            }
-            const baseUrl = (_configToParse_compilerOptions1 = configToParse.compilerOptions) == null ? void 0 : _configToParse_compilerOptions1.baseUrl;
-            const hasBaseUrl = typeof baseUrl === 'string' && baseUrl.length > 0;
-            if (hasBaseUrl) {
-                var _configToParse_compilerOptions2;
-                const rewrittenPaths = rewritePathAliasesWithoutBaseUrl(baseUrl, (_configToParse_compilerOptions2 = configToParse.compilerOptions) == null ? void 0 : _configToParse_compilerOptions2.paths);
-                const { baseUrl: _baseUrl, ...restCompilerOptions } = configToParse.compilerOptions ?? {};
-                // TypeScript 6 deprecates `baseUrl`; rewrite aliases to explicit
-                // relative paths so path mapping still works without this option.
-                configToParse = {
-                    ...configToParse,
-                    compilerOptions: {
-                        ...restCompilerOptions,
-                        paths: rewrittenPaths
-                    }
-                };
-            }
-        }
         const result = typescript.parseJsonConfigFileContent(configToParse, // When only interested in meta info,
         // avoid enumerating all files (for performance reasons)
         metaOnly ? {
@@ -114,23 +44,13 @@ async function getTypeScriptConfiguration(typescript, tsConfigPath, metaOnly) {
                 ];
             }
         } : typescript.sys, _path.default.dirname(tsConfigPath));
-        if (_semver.default.gte(typescript.version, '6.0.0')) {
-            const parsedBaseUrl = result.options.baseUrl;
-            if (typeof parsedBaseUrl === 'string' && parsedBaseUrl.length > 0) {
-                const normalizedBaseUrl = getNormalizedBaseUrlForPaths(parsedBaseUrl, tsConfigPath);
-                // `baseUrl` can come from extended tsconfigs. Rewrite paths from the
-                // fully-resolved baseUrl and remove it so TS6 deprecation checks do not
-                // fail type checking.
-                result.options.paths = rewritePathAliasesWithoutBaseUrl(normalizedBaseUrl, result.options.paths);
-                delete result.options.baseUrl;
-            }
-        }
         if (result.errors) {
             result.errors = result.errors.filter(({ code })=>// No inputs were found in config file
                 code !== 18003);
         }
         if ((_result_errors = result.errors) == null ? void 0 : _result_errors.length) {
-            throw Object.defineProperty(new _fatalerror.FatalError(typescript.formatDiagnostic(result.errors[0], formatDiagnosticsHost)), "__NEXT_ERROR_CODE", {
+            // TODO: Throw AggregateError for all diagnostics.
+            throw Object.defineProperty(new Error(typescript.formatDiagnostic(result.errors[0], formatDiagnosticsHost)), "__NEXT_ERROR_CODE", {
                 value: "E394",
                 enumerable: false,
                 configurable: true
@@ -140,7 +60,7 @@ async function getTypeScriptConfiguration(typescript, tsConfigPath, metaOnly) {
     } catch (err) {
         if ((0, _iserror.default)(err) && err.name === 'SyntaxError') {
             const reason = '\n' + (err.message ?? '');
-            throw Object.defineProperty(new _fatalerror.FatalError((0, _picocolors.bold)('Could not parse' + (0, _picocolors.cyan)('tsconfig.json') + '.' + ' Please make sure it contains syntactically correct JSON.') + reason), "__NEXT_ERROR_CODE", {
+            throw Object.defineProperty(new Error((0, _picocolors.bold)('Could not parse' + (0, _picocolors.cyan)('tsconfig.json') + '.' + ' Please make sure it contains syntactically correct JSON.') + reason), "__NEXT_ERROR_CODE", {
                 value: "E1023",
                 enumerable: false,
                 configurable: true

package/dist/node_modules/next/dist/lib/typescript/loadTsConfig.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "loadTsConfigOptions", {
+    enumerable: true,
+    get: function() {
+        return loadTsConfigOptions;
+    }
+});
+const _nodefs = require("node:fs");
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _commentjson = /*#__PURE__*/ _interop_require_wildcard(require("next/dist/compiled/comment-json"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+function resolveConfigDirValue(value, configDir, rootConfigDir) {
+    return _nodepath.default.resolve(configDir, value.replace(/\$\{configDir\}/g, rootConfigDir));
+}
+function resolveConfigFile(candidate) {
+    for (const configPath of [
+        candidate,
+        candidate.endsWith('.json') ? undefined : candidate + '.json'
+    ]){
+        if (configPath && (0, _nodefs.existsSync)(configPath) && (0, _nodefs.statSync)(configPath).isFile()) {
+            return configPath;
+        }
+    }
+}
+function resolvePackageTsConfig(extendsPath, currentConfigDir) {
+    const parts = extendsPath.split('/');
+    const isPackageRoot = extendsPath.startsWith('@') ? parts.length === 2 : parts.length === 1;
+    if (!isPackageRoot) {
+        return undefined;
+    }
+    try {
+        const packageJsonPath = require.resolve(extendsPath + '/package.json', {
+            paths: [
+                currentConfigDir
+            ]
+        });
+        const packageJson = JSON.parse((0, _nodefs.readFileSync)(packageJsonPath, 'utf8'));
+        if (packageJson.exports !== undefined) {
+            try {
+                const exportedConfig = require.resolve(extendsPath, {
+                    paths: [
+                        currentConfigDir
+                    ]
+                });
+                if (_nodepath.default.extname(exportedConfig) === '.json') {
+                    return exportedConfig;
+                }
+            } catch  {}
+        }
+        if (typeof packageJson.tsconfig === 'string') {
+            return resolveConfigFile(_nodepath.default.resolve(_nodepath.default.dirname(packageJsonPath), packageJson.tsconfig));
+        }
+        return resolveConfigFile(_nodepath.default.join(_nodepath.default.dirname(packageJsonPath), 'tsconfig'));
+    } catch  {}
+}
+function resolveExtends(extendsPath, currentConfigDir) {
+    if (extendsPath.startsWith('./') || extendsPath.startsWith('../') || _nodepath.default.isAbsolute(extendsPath)) {
+        const resolved = _nodepath.default.resolve(currentConfigDir, extendsPath);
+        if ((0, _nodefs.existsSync)(resolved)) {
+            return resolved;
+        }
+        if (!resolved.endsWith('.json') && (0, _nodefs.existsSync)(resolved + '.json')) {
+            return resolved + '.json';
+        }
+        return resolved;
+    }
+    const packageConfigPath = resolvePackageTsConfig(extendsPath, currentConfigDir);
+    if (packageConfigPath) {
+        return packageConfigPath;
+    }
+    try {
+        const resolved = require.resolve(extendsPath, {
+            paths: [
+                currentConfigDir
+            ]
+        });
+        if (_nodepath.default.extname(resolved) === '.json') {
+            return resolved;
+        }
+    } catch  {}
+    try {
+        return require.resolve(extendsPath + '/tsconfig.json', {
+            paths: [
+                currentConfigDir
+            ]
+        });
+    } catch  {
+        return _nodepath.default.resolve(currentConfigDir, extendsPath);
+    }
+}
+function loadTsConfigOptionsRecursive(configPath, visited, rootConfigDir) {
+    const resolvedPath = _nodepath.default.resolve(configPath);
+    if (visited.has(resolvedPath) || !(0, _nodefs.existsSync)(resolvedPath)) {
+        return {};
+    }
+    const nextVisited = new Set(visited);
+    nextVisited.add(resolvedPath);
+    const configContent = (0, _nodefs.readFileSync)(resolvedPath, 'utf8');
+    const config = _commentjson.parse(configContent);
+    const configDir = _nodepath.default.dirname(resolvedPath);
+    let mergedOptions = {};
+    if (config.extends) {
+        const extendsList = Array.isArray(config.extends) ? config.extends : [
+            config.extends
+        ];
+        for (const extendsPath of extendsList){
+            const parentConfigPath = resolveExtends(extendsPath, configDir);
+            const parentOptions = loadTsConfigOptionsRecursive(parentConfigPath, nextVisited, rootConfigDir);
+            mergedOptions = {
+                ...mergedOptions,
+                ...parentOptions
+            };
+        }
+    }
+    const currentOptions = config.compilerOptions ?? {};
+    if (Object.hasOwn(currentOptions, 'paths')) {
+        mergedOptions.paths = currentOptions.paths;
+        mergedOptions.pathsBasePath = configDir;
+    }
+    if (Object.hasOwn(currentOptions, 'baseUrl') && typeof currentOptions.baseUrl === 'string') {
+        mergedOptions.baseUrl = resolveConfigDirValue(currentOptions.baseUrl, configDir, rootConfigDir);
+    }
+    if (mergedOptions.baseUrl) {
+        mergedOptions.pathsBasePath = undefined;
+    }
+    return mergedOptions;
+}
+function loadTsConfigOptions(configPath) {
+    const resolvedPath = _nodepath.default.resolve(configPath);
+    return loadTsConfigOptionsRecursive(resolvedPath, new Set(), _nodepath.default.dirname(resolvedPath));
+}
+
+//# sourceMappingURL=loadTsConfig.js.map

package/dist/node_modules/next/dist/lib/typescript/missingDependencyError.js

@@ -10,14 +10,13 @@ Object.defineProperty(exports, "missingDepsError", {
 });
 const _picocolors = require("../picocolors");
 const _oxfordcommalist = require("../oxford-comma-list");
-const _fatalerror = require("../fatal-error");
 const _getpkgmanager = require("../helpers/get-pkg-manager");
 function missingDepsError(dir, missingPackages) {
     const packagesHuman = (0, _oxfordcommalist.getOxfordCommaList)(missingPackages.map((p)=>p.pkg));
-    const packagesCli = missingPackages.map((p)=>p.pkg).join(' ');
+    const packagesCli = missingPackages.map((p)=>p.install ?? p.pkg).join(' ');
     const packageManager = (0, _getpkgmanager.getPkgManager)(dir);
     const removalMsg = '\n\n' + (0, _picocolors.bold)('If you are not trying to use TypeScript, please remove the ' + (0, _picocolors.cyan)('tsconfig.json') + ' file from your package root (and any TypeScript files in your app and pages directories).');
-    throw Object.defineProperty(new _fatalerror.FatalError((0, _picocolors.bold)((0, _picocolors.red)(`It looks like you're trying to use TypeScript but do not have the required package(s) installed.`)) + '\n\n' + (0, _picocolors.bold)(`Please install ${(0, _picocolors.bold)(packagesHuman)} by running:`) + '\n\n' + `\t${(0, _picocolors.bold)((0, _picocolors.cyan)((packageManager === 'yarn' ? 'yarn add --dev' : packageManager === 'pnpm' ? 'pnpm install --save-dev' : 'npm install --save-dev') + ' ' + packagesCli))}` + removalMsg + '\n'), "__NEXT_ERROR_CODE", {
+    throw Object.defineProperty(new Error((0, _picocolors.bold)((0, _picocolors.red)(`It looks like you're trying to use TypeScript but do not have the required package(s) installed.`)) + '\n\n' + (0, _picocolors.bold)(`Please install ${(0, _picocolors.bold)(packagesHuman)} by running:`) + '\n\n' + `\t${(0, _picocolors.bold)((0, _picocolors.cyan)((packageManager === 'yarn' ? 'yarn add --dev' : packageManager === 'pnpm' ? 'pnpm install --save-dev' : 'npm install --save-dev') + ' ' + packagesCli))}` + removalMsg + '\n'), "__NEXT_ERROR_CODE", {
         value: "E552",
         enumerable: false,
         configurable: true

package/dist/node_modules/next/dist/lib/typescript/runTypeCheckCli.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "runTypeCheckCli", {
+    enumerable: true,
+    get: function() {
+        return runTypeCheckCli;
+    }
+});
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _compileerror = require("../compile-error");
+const _runTypeScriptCli = require("./runTypeScriptCli");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+async function runTypeCheckCli({ baseDir, tsConfigPath, tscPath, cacheDir, onFirstOutput }) {
+    const configuration = await (0, _runTypeScriptCli.getTypeScriptConfigurationCli)({
+        baseDir,
+        tsConfigPath,
+        tscPath
+    });
+    const incremental = Boolean(configuration.compilerOptions.incremental || configuration.compilerOptions.composite);
+    const args = [
+        '--project',
+        tsConfigPath,
+        '--noEmit',
+        '--declarationMap',
+        'false',
+        '--emitDeclarationOnly',
+        'false'
+    ];
+    if (incremental && cacheDir) {
+        args.push('--tsBuildInfoFile', _nodepath.default.join(cacheDir, '.tsbuildinfo'));
+    }
+    const result = await (0, _runTypeScriptCli.runTypeScriptCli)({
+        cwd: baseDir,
+        tscPath,
+        args,
+        onFirstOutput
+    });
+    if (result.exitCode !== 0) {
+        throw new _compileerror.CompileError();
+    }
+    return {
+        hasWarnings: false,
+        incremental
+    };
+}
+
+//# sourceMappingURL=runTypeCheckCli.js.map

package/dist/node_modules/next/dist/lib/typescript/runTypeScriptCli.js

@@ -0,0 +1,256 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getTypeScriptApiMissingError: null,
+    getTypeScriptConfigurationCli: null,
+    getTypeScriptPackageInfo: null,
+    hasNativeTypeScriptPreview: null,
+    runTypeScriptCli: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getTypeScriptApiMissingError: function() {
+        return getTypeScriptApiMissingError;
+    },
+    getTypeScriptConfigurationCli: function() {
+        return getTypeScriptConfigurationCli;
+    },
+    getTypeScriptPackageInfo: function() {
+        return getTypeScriptPackageInfo;
+    },
+    hasNativeTypeScriptPreview: function() {
+        return hasNativeTypeScriptPreview;
+    },
+    runTypeScriptCli: function() {
+        return runTypeScriptCli;
+    }
+});
+const _nodefs = require("node:fs");
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _nodechild_process = require("node:child_process");
+const _crossspawn = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/cross-spawn"));
+const _picocolors = require("../picocolors");
+const _resolvefrom = require("../resolve-from");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function getTypeScriptPackageInfo(baseDir) {
+    var _packageJson_bin;
+    let packageJsonPath;
+    try {
+        packageJsonPath = (0, _resolvefrom.resolveFrom)(baseDir, 'typescript/package.json');
+    } catch  {
+        return null;
+    }
+    const packageJson = JSON.parse((0, _nodefs.readFileSync)(packageJsonPath, 'utf8'));
+    const packageDir = _nodepath.default.dirname(packageJsonPath);
+    const apiPath = _nodepath.default.join(packageDir, 'lib', 'typescript.js');
+    const tscBin = typeof packageJson.bin === 'string' ? packageJson.bin : (_packageJson_bin = packageJson.bin) == null ? void 0 : _packageJson_bin.tsc;
+    const tscBinPath = tscBin ? _nodepath.default.resolve(packageDir, tscBin) : undefined;
+    let tscPath = tscBinPath;
+    if (tscBinPath && (0, _nodefs.existsSync)(tscBinPath) && packageJson.type === 'module' && _nodepath.default.extname(tscBinPath) === '') {
+        // TypeScript 7's extensionless ESM bin wrapper cannot be used as Node's
+        // main entry point on Node.js 20.9. Its imported JS entry is the same CLI
+        // wrapper and works across all supported Node.js versions.
+        const tscJsPath = _nodepath.default.join(packageDir, 'lib', 'tsc.js');
+        if ((0, _nodefs.existsSync)(tscJsPath)) {
+            tscPath = tscJsPath;
+        }
+    }
+    return {
+        packageJsonPath,
+        packageDir,
+        version: packageJson.version,
+        apiPath: (0, _nodefs.existsSync)(apiPath) ? apiPath : undefined,
+        tscPath: tscPath && (0, _nodefs.existsSync)(tscPath) ? tscPath : undefined
+    };
+}
+function hasNativeTypeScriptPreview(baseDir) {
+    try {
+        (0, _resolvefrom.resolveFrom)(baseDir, '@typescript/native-preview/package.json');
+        return true;
+    } catch  {
+        return false;
+    }
+}
+function getTypeScriptApiMissingError(version) {
+    return Object.defineProperty(new Error(`TypeScript ${version} does not provide the compiler API required by Next.js. ` + `Set ${(0, _picocolors.bold)('experimental.useTypeScriptCli')} back to true in your Next.js config to use the TypeScript CLI, ` + `or install TypeScript 6 instead.`), "__NEXT_ERROR_CODE", {
+        value: "E1467",
+        enumerable: false,
+        configurable: true
+    });
+}
+const terminationSignals = [
+    'SIGINT',
+    'SIGTERM',
+    'SIGHUP'
+];
+function runTypeScriptCli({ cwd, tscPath, args, captureOutput = false, onFirstOutput }) {
+    return new Promise((resolve, reject)=>{
+        var _child_stdout, _child_stderr;
+        const child = (0, _crossspawn.default)(process.execPath, [
+            tscPath,
+            ...args
+        ], {
+            cwd,
+            // TypeScript 7's Node wrapper starts the native compiler synchronously
+            // on older Node.js releases. A separate process group lets termination
+            // reach both processes instead of orphaning the native compiler.
+            detached: process.platform !== 'win32',
+            shell: false,
+            stdio: [
+                'ignore',
+                'pipe',
+                'pipe'
+            ],
+            env: {
+                ...process.env,
+                // Piping stdio makes `tsc` disable colored/pretty diagnostics. Restore
+                // them when we are forwarding output to a TTY (not capturing it for
+                // parsing, e.g. `--showConfig`).
+                ...!captureOutput && process.stdout.isTTY ? {
+                    FORCE_COLOR: '1'
+                } : undefined
+            }
+        });
+        let stdout = '';
+        let stderr = '';
+        (_child_stdout = child.stdout) == null ? void 0 : _child_stdout.setEncoding('utf8');
+        (_child_stderr = child.stderr) == null ? void 0 : _child_stderr.setEncoding('utf8');
+        if (captureOutput) {
+            var _child_stdout1, _child_stderr1;
+            (_child_stdout1 = child.stdout) == null ? void 0 : _child_stdout1.on('data', (chunk)=>{
+                stdout += chunk;
+            });
+            (_child_stderr1 = child.stderr) == null ? void 0 : _child_stderr1.on('data', (chunk)=>{
+                stderr += chunk;
+            });
+        } else {
+            var _child_stdout2, _child_stderr2;
+            const forward = (dest, chunk)=>{
+                onFirstOutput == null ? void 0 : onFirstOutput();
+                onFirstOutput = undefined // ensure we don't call it again
+                ;
+                dest.write(chunk);
+            };
+            (_child_stdout2 = child.stdout) == null ? void 0 : _child_stdout2.on('data', (chunk)=>{
+                forward(process.stdout, chunk);
+            });
+            (_child_stderr2 = child.stderr) == null ? void 0 : _child_stderr2.on('data', (chunk)=>{
+                forward(process.stderr, chunk);
+            });
+        }
+        let terminationRequested = false;
+        const terminateChild = ()=>{
+            if (terminationRequested || child.killed || child.pid === undefined) {
+                return;
+            }
+            terminationRequested = true;
+            // The native compiler ignores SIGTERM and SIGINT, so send a kill signal.
+            // Target the whole process group so the signal reaches the native compiler whether
+            // it is a grandchild or a direct child.
+            // https://github.com/microsoft/typescript-go/pull/4592 should improve this in the long run
+            if (process.platform === 'win32') {
+                (0, _nodechild_process.spawnSync)('taskkill', [
+                    '/pid',
+                    String(child.pid),
+                    '/T',
+                    '/F'
+                ], {
+                    stdio: 'ignore',
+                    windowsHide: true
+                });
+            } else {
+                try {
+                    // https://www.youtube.com/watch?v=Fow7iUaKrq4
+                    process.kill(-child.pid, 'SIGKILL');
+                } catch  {
+                // The process may have exited between the lifecycle event and kill.
+                }
+            }
+        };
+        const terminateOnExit = ()=>terminateChild();
+        process.once('exit', terminateOnExit);
+        const handler = ()=>{
+            terminateChild();
+            process.exit(1);
+        };
+        for (const signal of terminationSignals){
+            process.once(signal, handler);
+        }
+        const cleanup = ()=>{
+            process.off('exit', terminateOnExit);
+            for (const signal of terminationSignals){
+                process.off(signal, handler);
+            }
+        };
+        let settled = false;
+        const finish = (settle)=>{
+            if (settled) {
+                return;
+            }
+            settled = true;
+            cleanup();
+            settle();
+        };
+        child.on('error', (error)=>{
+            finish(()=>reject(error));
+        });
+        child.on('close', (code, signal)=>{
+            finish(()=>{
+                resolve({
+                    exitCode: code ?? 1,
+                    signal,
+                    stdout,
+                    stderr
+                });
+            });
+        });
+    });
+}
+async function getTypeScriptConfigurationCli({ baseDir, tsConfigPath, tscPath }) {
+    const result = await runTypeScriptCli({
+        cwd: baseDir,
+        tscPath,
+        args: [
+            '--showConfig',
+            '--project',
+            tsConfigPath,
+            '--pretty',
+            'false'
+        ],
+        captureOutput: true
+    });
+    if (result.exitCode !== 0) {
+        throw Object.defineProperty(new Error([
+            result.stdout,
+            result.stderr
+        ].filter(Boolean).join('\n').trim()), "__NEXT_ERROR_CODE", {
+            value: "E394",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    try {
+        return JSON.parse(result.stdout);
+    } catch (cause) {
+        throw Object.defineProperty(new Error(`Could not parse output from TypeScript's --showConfig.`, {
+            cause
+        }), "__NEXT_ERROR_CODE", {
+            value: "E1417",
+            enumerable: false,
+            configurable: true
+        });
+    }
+}
+
+//# sourceMappingURL=runTypeScriptCli.js.map

package/dist/node_modules/next/dist/lib/typescript/writeAppTypeDeclarations.js

@@ -52,6 +52,8 @@ async function writeAppTypeDeclarations({ baseDir, distDir, imageImportsEnabled,
     const routeTypesPath = _path.default.posix.join(distDir.replaceAll(_path.default.win32.sep, _path.default.posix.sep), 'types/routes.d.ts');
     // Use ESM import instead of triple-slash reference for better ESLint compatibility
     lines.push(`import "./${routeTypesPath}";`);
+    const rootParamsTypesPath = _path.default.posix.join(distDir.replaceAll(_path.default.win32.sep, _path.default.posix.sep), 'types/root-params.d.ts');
+    lines.push(`import "./${rootParamsTypesPath}";`);
     if (strictRouteTypes) {
         const cacheLifePath = _path.default.posix.join(distDir.replaceAll(_path.default.win32.sep, _path.default.posix.sep), 'types/cache-life.d.ts');
         lines.push(`import "./${cacheLifePath}";`);