@fusionkit/cli 0.1.1 → 0.1.3

package/scope/node_modules/next/dist/lib/typescript/diagnosticFormatter.js

@@ -0,0 +1,240 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getFormattedDiagnostic", {
+    enumerable: true,
+    get: function() {
+        return getFormattedDiagnostic;
+    }
+});
+const _picocolors = require("../picocolors");
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function getFormattedLinkDiagnosticMessageText(diagnostic) {
+    const message = diagnostic.messageText;
+    if (typeof message === 'string' && diagnostic.code === 2322) {
+        const match = message.match(/Type '"(.+)"' is not assignable to type 'RouteImpl<.+> \| UrlObject'\./) || message.match(/Type '"(.+)"' is not assignable to type 'UrlObject \| RouteImpl<.+>'\./);
+        if (match) {
+            const [, href] = match;
+            return `"${(0, _picocolors.bold)(href)}" is not an existing route. If it is intentional, please type it explicitly with \`as Route\`.`;
+        } else if (message === "Type 'string' is not assignable to type 'UrlObject'.") {
+            var _diagnostic_relatedInformation_, _diagnostic_relatedInformation;
+            const relatedMessage = (_diagnostic_relatedInformation = diagnostic.relatedInformation) == null ? void 0 : (_diagnostic_relatedInformation_ = _diagnostic_relatedInformation[0]) == null ? void 0 : _diagnostic_relatedInformation_.messageText;
+            if (typeof relatedMessage === 'string' && relatedMessage.match(/The expected type comes from property 'href' which is declared here on type 'IntrinsicAttributes & /)) {
+                return `Invalid \`href\` property of \`Link\`: the route does not exist. If it is intentional, please type it explicitly with \`as Route\`.`;
+            }
+        }
+    } else if (typeof message === 'string' && diagnostic.code === 2820) {
+        const match = message.match(/Type '"(.+)"' is not assignable to type 'RouteImpl<.+> \| UrlObject'\. Did you mean '"(.+)"'?/) || message.match(/Type '"(.+)"' is not assignable to type 'UrlObject \| RouteImpl<.+>'\. Did you mean '"(.+)"'?/);
+        if (match) {
+            const [, href, suggestion] = match;
+            return `"${(0, _picocolors.bold)(href)}" is not an existing route. Did you mean "${(0, _picocolors.bold)(suggestion)}" instead? If it is intentional, please type it explicitly with \`as Route\`.`;
+        }
+    }
+}
+function getFormattedLayoutAndPageDiagnosticMessageText(relativeSourceFilepath, diagnostic) {
+    const message = typeof diagnostic.messageText === 'string' ? diagnostic : diagnostic.messageText;
+    const messageText = message.messageText;
+    if (typeof messageText === 'string') {
+        const type = /page\.[^.]+$/.test(relativeSourceFilepath) ? 'Page' : /route\.[^.]+$/.test(relativeSourceFilepath) ? 'Route' : 'Layout';
+        // Reference of error codes:
+        // https://github.com/Microsoft/TypeScript/blob/main/src/compiler/diagnosticMessages.json
+        switch(message.code){
+            case 2344:
+                const filepathAndType = messageText.match(/typeof import\("(.+)"\)/);
+                if (filepathAndType) {
+                    let main = `${type} "${(0, _picocolors.bold)(relativeSourceFilepath)}" does not match the required types of a Next.js ${type}.`;
+                    function processNext(indent, next) {
+                        if (!next) return;
+                        for (const item of next){
+                            switch(item.code){
+                                case 2200:
+                                    const mismatchedField = item.messageText.match(/The types of '(.+)'/);
+                                    if (mismatchedField) {
+                                        main += '\n' + ' '.repeat(indent * 2);
+                                        main += `"${(0, _picocolors.bold)(mismatchedField[1])}" has the wrong type:`;
+                                    }
+                                    break;
+                                case 2322:
+                                    const types = item.messageText.match(/Type '(.+)' is not assignable to type '(.+)'./);
+                                    if (types) {
+                                        main += '\n' + ' '.repeat(indent * 2);
+                                        if (types[2] === 'PageComponent' || types[2] === 'LayoutComponent') {
+                                            main += `The exported ${type} component isn't correctly typed.`;
+                                        } else {
+                                            main += `Expected "${(0, _picocolors.bold)(types[2].replace('"__invalid_negative_number__"', 'number (>= 0)'))}", got "${(0, _picocolors.bold)(types[1])}".`;
+                                        }
+                                    }
+                                    break;
+                                case 2326:
+                                    const invalidConfig = item.messageText.match(/Types of property '(.+)' are incompatible\./);
+                                    main += '\n' + ' '.repeat(indent * 2);
+                                    main += `Invalid configuration${invalidConfig ? ` "${(0, _picocolors.bold)(invalidConfig[1])}"` : ''}:`;
+                                    break;
+                                case 2530:
+                                    const invalidField = item.messageText.match(/Property '(.+)' is incompatible with index signature/);
+                                    if (invalidField) {
+                                        main += '\n' + ' '.repeat(indent * 2);
+                                        main += `"${(0, _picocolors.bold)(invalidField[1])}" is not a valid ${type} export field.`;
+                                    }
+                                    return;
+                                case 2739:
+                                    const invalidProp = item.messageText.match(/Type '(.+)' is missing the following properties from type '(.+)'/);
+                                    if (invalidProp) {
+                                        if (invalidProp[1] === 'LayoutProps' || invalidProp[1] === 'PageProps') {
+                                            main += '\n' + ' '.repeat(indent * 2);
+                                            main += `Prop "${invalidProp[2]}" is incompatible with the ${type}.`;
+                                        }
+                                    }
+                                    break;
+                                case 2559:
+                                    const invalid = item.messageText.match(/Type '(.+)' has/);
+                                    if (invalid) {
+                                        main += '\n' + ' '.repeat(indent * 2);
+                                        main += `Type "${(0, _picocolors.bold)(invalid[1])}" isn't allowed.`;
+                                    }
+                                    break;
+                                case 2741:
+                                    const incompatPageProp = item.messageText.match(/Property '(.+)' is missing in type 'PageProps'/);
+                                    if (incompatPageProp) {
+                                        main += '\n' + ' '.repeat(indent * 2);
+                                        main += `Prop "${(0, _picocolors.bold)(incompatPageProp[1])}" will never be passed. Remove it from the component's props.`;
+                                    } else {
+                                        const extraLayoutProp = item.messageText.match(/Property '(.+)' is missing in type 'LayoutProps' but required in type '(.+)'/);
+                                        if (extraLayoutProp) {
+                                            main += '\n' + ' '.repeat(indent * 2);
+                                            main += `Prop "${(0, _picocolors.bold)(extraLayoutProp[1])}" is not valid for this Layout, remove it to fix.`;
+                                        }
+                                    }
+                                    break;
+                                default:
+                            }
+                            processNext(indent + 1, item.next);
+                        }
+                    }
+                    if ('next' in message) processNext(1, message.next);
+                    return main;
+                }
+                const invalidExportFnArg = messageText.match(/Type 'OmitWithTag<(.+), .+, "(.+)">' does not satisfy the constraint/);
+                if (invalidExportFnArg) {
+                    const main = `${type} "${(0, _picocolors.bold)(relativeSourceFilepath)}" has an invalid "${(0, _picocolors.bold)(invalidExportFnArg[2])}" export:\n  Type "${(0, _picocolors.bold)(invalidExportFnArg[1])}" is not valid.`;
+                    return main;
+                }
+                function processNextItems(indent, next) {
+                    if (!next) return '';
+                    let result = '';
+                    for (const item of next){
+                        switch(item.code){
+                            case 2322:
+                                const types = item.messageText.match(/Type '(.+)' is not assignable to type '(.+)'./);
+                                if (types) {
+                                    result += '\n' + ' '.repeat(indent * 2);
+                                    result += `Expected "${(0, _picocolors.bold)(types[2])}", got "${(0, _picocolors.bold)(types[1])}".`;
+                                }
+                                break;
+                            default:
+                        }
+                        result += processNextItems(indent + 1, item.next);
+                    }
+                    return result;
+                }
+                const invalidParamFn = messageText.match(/Type '{ __tag__: (.+); __param_position__: "(.*)"; __param_type__: (.+); }' does not satisfy/);
+                if (invalidParamFn) {
+                    let main = `${type} "${(0, _picocolors.bold)(relativeSourceFilepath)}" has an invalid ${invalidParamFn[1]} export:\n  Type "${(0, _picocolors.bold)(invalidParamFn[3])}" is not a valid type for the function's ${invalidParamFn[2]} argument.`;
+                    if ('next' in message) main += processNextItems(1, message.next);
+                    return main;
+                }
+                const invalidExportFnReturn = messageText.match(/Type '{ __tag__: "(.+)"; __return_type__: (.+); }' does not satisfy/);
+                if (invalidExportFnReturn) {
+                    let main = `${type} "${(0, _picocolors.bold)(relativeSourceFilepath)}" has an invalid export:\n  "${(0, _picocolors.bold)(invalidExportFnReturn[2])}" is not a valid ${invalidExportFnReturn[1]} return type:`;
+                    if ('next' in message) main += processNextItems(1, message.next);
+                    return main;
+                }
+                break;
+            case 2345:
+                const filepathAndInvalidExport = messageText.match(/'typeof import\("(.+)"\)'.+Impossible<"(.+)">/);
+                if (filepathAndInvalidExport) {
+                    const main = `${type} "${(0, _picocolors.bold)(relativeSourceFilepath)}" exports an invalid "${(0, _picocolors.bold)(filepathAndInvalidExport[2])}" field. ${type} should only export a default React component and configuration options. Learn more: https://nextjs.org/docs/messages/invalid-segment-export`;
+                    return main;
+                }
+                break;
+            case 2559:
+                const invalid = messageText.match(/Type '(.+)' has no properties in common with type '(.+)'/);
+                if (invalid) {
+                    const main = `${type} "${(0, _picocolors.bold)(relativeSourceFilepath)}" contains an invalid type "${(0, _picocolors.bold)(invalid[1])}" as ${invalid[2]}.`;
+                    return main;
+                }
+                break;
+            default:
+        }
+    }
+}
+function getAppEntrySourceFilePath(baseDir, diagnostic) {
+    var _diagnostic_file_text_trim_match, _diagnostic_file;
+    const sourceFilepath = ((_diagnostic_file = diagnostic.file) == null ? void 0 : (_diagnostic_file_text_trim_match = _diagnostic_file.text.trim().match(/^\/\/ File: (.+)\n/)) == null ? void 0 : _diagnostic_file_text_trim_match[1]) || '';
+    return _path.default.relative(baseDir, sourceFilepath);
+}
+function getFormattedDiagnostic(ts, baseDir, distDir, diagnostic, isAppDirEnabled) {
+    var _diagnostic_file;
+    // If the error comes from .next/types/, we handle it specially.
+    const isLayoutOrPageError = isAppDirEnabled && ((_diagnostic_file = diagnostic.file) == null ? void 0 : _diagnostic_file.fileName.startsWith(_path.default.join(baseDir, distDir, 'types')));
+    let message = '';
+    const appPath = isLayoutOrPageError ? getAppEntrySourceFilePath(baseDir, diagnostic) : null;
+    const linkReason = getFormattedLinkDiagnosticMessageText(diagnostic);
+    const appReason = !linkReason && isLayoutOrPageError && appPath ? getFormattedLayoutAndPageDiagnosticMessageText(appPath, diagnostic) : null;
+    const reason = linkReason || appReason || ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
+    const category = diagnostic.category;
+    switch(category){
+        // Warning
+        case ts.DiagnosticCategory.Warning:
+            {
+                message += (0, _picocolors.yellow)((0, _picocolors.bold)('Type warning')) + ': ';
+                break;
+            }
+        // Error
+        case ts.DiagnosticCategory.Error:
+            {
+                message += (0, _picocolors.red)((0, _picocolors.bold)('Type error')) + ': ';
+                break;
+            }
+        // 2 = Suggestion, 3 = Message
+        case ts.DiagnosticCategory.Suggestion:
+        case ts.DiagnosticCategory.Message:
+            message += (0, _picocolors.cyan)((0, _picocolors.bold)(category === 2 ? 'Suggestion' : 'Info')) + ': ';
+            break;
+        default:
+            {
+                category;
+            }
+    }
+    message += reason + '\n';
+    if (!isLayoutOrPageError && diagnostic.file) {
+        const { codeFrameColumns } = require('next/dist/compiled/babel/code-frame');
+        const pos = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
+        const line = pos.line + 1;
+        const character = pos.character + 1;
+        let fileName = _path.default.posix.normalize(_path.default.relative(baseDir, diagnostic.file.fileName).replace(/\\/g, '/'));
+        if (!fileName.startsWith('.')) {
+            fileName = './' + fileName;
+        }
+        message = (0, _picocolors.cyan)(fileName) + ':' + (0, _picocolors.yellow)(line.toString()) + ':' + (0, _picocolors.yellow)(character.toString()) + '\n' + message;
+        message += '\n' + codeFrameColumns(diagnostic.file.getFullText(diagnostic.file.getSourceFile()), {
+            start: {
+                line: line,
+                column: character
+            }
+        }, {
+            forceColor: true
+        });
+    } else if (isLayoutOrPageError && appPath) {
+        message = (0, _picocolors.cyan)(appPath) + '\n' + message;
+    }
+    return message;
+}
+
+//# sourceMappingURL=diagnosticFormatter.js.map

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

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getTypeScriptConfiguration", {
+    enumerable: true,
+    get: function() {
+        return getTypeScriptConfiguration;
+    }
+});
+const _picocolors = require("../picocolors");
+const _os = /*#__PURE__*/ _interop_require_default(require("os"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+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
+    };
+}
+async function getTypeScriptConfiguration(ts, tsConfigPath, metaOnly) {
+    try {
+        var _result_errors;
+        const formatDiagnosticsHost = {
+            getCanonicalFileName: (fileName)=>fileName,
+            getCurrentDirectory: ts.sys.getCurrentDirectory,
+            getNewLine: ()=>_os.default.EOL
+        };
+        const { config, error } = ts.readConfigFile(tsConfigPath, ts.sys.readFile);
+        if (error) {
+            throw Object.defineProperty(new _fatalerror.FatalError(ts.formatDiagnostic(error, formatDiagnosticsHost)), "__NEXT_ERROR_CODE", {
+                value: "E394",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        let configToParse = config;
+        const result = ts.parseJsonConfigFileContent(configToParse, // When only interested in meta info,
+        // avoid enumerating all files (for performance reasons)
+        metaOnly ? {
+            ...ts.sys,
+            readDirectory (_path, extensions, _excludes, _includes, _depth) {
+                return [
+                    extensions ? `file${extensions[0]}` : `file.ts`
+                ];
+            }
+        } : ts.sys, _path.default.dirname(tsConfigPath));
+        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(ts.formatDiagnostic(result.errors[0], formatDiagnosticsHost)), "__NEXT_ERROR_CODE", {
+                value: "E394",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        return result;
+    } 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", {
+                value: "E339",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        throw err;
+    }
+}
+
+//# sourceMappingURL=getTypeScriptConfiguration.js.map

package/scope/node_modules/next/dist/lib/typescript/getTypeScriptIntent.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getTypeScriptIntent", {
+    enumerable: true,
+    get: function() {
+        return getTypeScriptIntent;
+    }
+});
+const _fs = require("fs");
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _recursivereaddir = require("../recursive-readdir");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+async function getTypeScriptIntent(baseDir, intentDirs, tsconfigPath) {
+    const resolvedTsConfigPath = _path.default.join(baseDir, tsconfigPath);
+    // The integration turns on if we find a `tsconfig.json` in the user's
+    // project.
+    const hasTypeScriptConfiguration = (0, _fs.existsSync)(resolvedTsConfigPath);
+    if (hasTypeScriptConfiguration) {
+        const content = await _fs.promises.readFile(resolvedTsConfigPath, {
+            encoding: 'utf8'
+        }).then((txt)=>txt.trim(), ()=>null);
+        return {
+            firstTimeSetup: content === '' || content === '{}'
+        };
+    }
+    // Next.js also offers a friendly setup mode that bootstraps a TypeScript
+    // project for the user when we detect TypeScript files. So, we need to check
+    // the `pages/` directory for a TypeScript file.
+    // Checking all directories is too slow, so this is a happy medium.
+    const tsFilesRegex = /.*\.(ts|tsx)$/;
+    const excludedRegex = /(node_modules|.*\.d\.ts$)/;
+    for (const dir of intentDirs){
+        const typescriptFiles = await (0, _recursivereaddir.recursiveReadDir)(dir, {
+            pathnameFilter: (name)=>tsFilesRegex.test(name),
+            ignoreFilter: (name)=>excludedRegex.test(name)
+        });
+        if (typescriptFiles.length) {
+            return {
+                firstTimeSetup: true
+            };
+        }
+    }
+    return false;
+}
+
+//# sourceMappingURL=getTypeScriptIntent.js.map

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "missingDepsError", {
+    enumerable: true,
+    get: function() {
+        return 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 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", {
+        value: "E532",
+        enumerable: false,
+        configurable: true
+    });
+}
+
+//# sourceMappingURL=missingDependencyError.js.map

package/scope/node_modules/next/dist/lib/typescript/required-packages.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getTypeScriptPackageSpec: null,
+    requiredNodeTypesVersion: null,
+    requiredTypeScriptVersion: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getTypeScriptPackageSpec: function() {
+        return getTypeScriptPackageSpec;
+    },
+    requiredNodeTypesVersion: function() {
+        return requiredNodeTypesVersion;
+    },
+    requiredTypeScriptVersion: function() {
+        return requiredTypeScriptVersion;
+    }
+});
+const requiredTypeScriptVersion = '5.8.2';
+const requiredNodeTypesVersion = '20.17.6';
+function getTypeScriptPackageSpec(pkg) {
+    switch(pkg){
+        case 'typescript':
+            return `${pkg}@${requiredTypeScriptVersion}`;
+        case '@types/node':
+            return `${pkg}@${requiredNodeTypesVersion}`;
+        default:
+            return pkg;
+    }
+}
+
+//# sourceMappingURL=required-packages.js.map

package/scope/node_modules/next/dist/lib/typescript/runTypeCheck.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "runTypeCheck", {
+    enumerable: true,
+    get: function() {
+        return runTypeCheck;
+    }
+});
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _diagnosticFormatter = require("./diagnosticFormatter");
+const _getTypeScriptConfiguration = require("./getTypeScriptConfiguration");
+const _writeConfigurationDefaults = require("./writeConfigurationDefaults");
+const _compileerror = require("../compile-error");
+const _log = require("../../build/output/log");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+async function runTypeCheck(ts, baseDir, distDir, tsConfigPath, cacheDir, isAppDirEnabled) {
+    const effectiveConfiguration = await (0, _getTypeScriptConfiguration.getTypeScriptConfiguration)(ts, tsConfigPath);
+    if (effectiveConfiguration.fileNames.length < 1) {
+        return {
+            hasWarnings: false,
+            inputFilesCount: 0,
+            totalFilesCount: 0,
+            incremental: false
+        };
+    }
+    const requiredConfig = (0, _writeConfigurationDefaults.getRequiredConfiguration)(ts);
+    const options = {
+        ...requiredConfig,
+        ...effectiveConfiguration.options,
+        declarationMap: false,
+        emitDeclarationOnly: false,
+        noEmit: true
+    };
+    let program;
+    let incremental = false;
+    if ((options.incremental || options.composite) && cacheDir) {
+        if (options.composite) {
+            (0, _log.warn)('TypeScript project references are not fully supported. Attempting to build in incremental mode.');
+        }
+        incremental = true;
+        program = ts.createIncrementalProgram({
+            rootNames: effectiveConfiguration.fileNames,
+            options: {
+                ...options,
+                composite: false,
+                incremental: true,
+                tsBuildInfoFile: _path.default.join(cacheDir, '.tsbuildinfo')
+            }
+        });
+    } else {
+        program = ts.createProgram(effectiveConfiguration.fileNames, options);
+    }
+    const result = program.emit();
+    const ignoreRegex = [
+        // matches **/__(tests|mocks)__/**
+        /[\\/]__(?:tests|mocks)__[\\/]/,
+        // matches **/*.(spec|test).*
+        /(?<=[\\/.])(?:spec|test)\.[^\\/]+$/
+    ];
+    const regexIgnoredFile = new RegExp(ignoreRegex.map((r)=>r.source).join('|'));
+    const allDiagnostics = ts.getPreEmitDiagnostics(program).concat(result.diagnostics).filter((d)=>!(d.file && regexIgnoredFile.test(d.file.fileName)));
+    const firstError = allDiagnostics.find((d)=>d.category === ts.DiagnosticCategory.Error && Boolean(d.file)) ?? allDiagnostics.find((d)=>d.category === ts.DiagnosticCategory.Error);
+    // In test mode, we want to check all diagnostics, not just the first one.
+    if (process.env.__NEXT_TEST_MODE) {
+        if (firstError) {
+            const allErrors = allDiagnostics.filter((d)=>d.category === ts.DiagnosticCategory.Error).map((d)=>'[Test Mode] ' + (0, _diagnosticFormatter.getFormattedDiagnostic)(ts, baseDir, distDir, d, isAppDirEnabled));
+            console.error('\n\n===== TS errors =====\n\n' + allErrors.join('\n\n') + '\n\n===== TS errors =====\n\n');
+            // Make sure all stdout is flushed before we exit.
+            await new Promise((resolve)=>setTimeout(resolve, 100));
+        }
+    }
+    if (firstError) {
+        throw Object.defineProperty(new _compileerror.CompileError((0, _diagnosticFormatter.getFormattedDiagnostic)(ts, baseDir, distDir, firstError, isAppDirEnabled)), "__NEXT_ERROR_CODE", {
+            value: "E394",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    const warnings = allDiagnostics.filter((d)=>d.category === ts.DiagnosticCategory.Warning).map((d)=>(0, _diagnosticFormatter.getFormattedDiagnostic)(ts, baseDir, distDir, d, isAppDirEnabled));
+    return {
+        hasWarnings: true,
+        warnings,
+        inputFilesCount: effectiveConfiguration.fileNames.length,
+        totalFilesCount: program.getSourceFiles().length,
+        incremental
+    };
+}
+
+//# sourceMappingURL=runTypeCheck.js.map

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

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "writeAppTypeDeclarations", {
+    enumerable: true,
+    get: function() {
+        return writeAppTypeDeclarations;
+    }
+});
+const _os = /*#__PURE__*/ _interop_require_default(require("os"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _fs = require("fs");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+async function writeAppTypeDeclarations({ baseDir, distDir, imageImportsEnabled, hasPagesDir, hasAppDir }) {
+    // Reference `next` types
+    const appTypeDeclarations = _path.default.join(baseDir, 'next-env.d.ts');
+    // Defaults EOL to system default
+    let eol = _os.default.EOL;
+    let currentContent;
+    try {
+        currentContent = await _fs.promises.readFile(appTypeDeclarations, 'utf8');
+        // If file already exists then preserve its line ending
+        const lf = currentContent.indexOf('\n', /* skip first so we can lf - 1 */ 1);
+        if (lf !== -1) {
+            if (currentContent[lf - 1] === '\r') {
+                eol = '\r\n';
+            } else {
+                eol = '\n';
+            }
+        }
+    } catch  {}
+    /**
+   * "Triple-slash directives" used to create typings files for Next.js projects
+   * using Typescript .
+   *
+   * @see https://www.typescriptlang.org/docs/handbook/triple-slash-directives.html
+   */ const directives = [
+        // Include the core Next.js typings.
+        '/// <reference types="next" />'
+    ];
+    if (imageImportsEnabled) {
+        directives.push('/// <reference types="next/image-types/global" />');
+    }
+    if (hasAppDir && hasPagesDir) {
+        directives.push('/// <reference types="next/navigation-types/compat/navigation" />');
+    }
+    const routeTypesPath = _path.default.posix.join(distDir.replaceAll(_path.default.win32.sep, _path.default.posix.sep), 'types/routes.d.ts');
+    directives.push(`/// <reference path="./${routeTypesPath}" />`);
+    // Push the notice in.
+    directives.push('', '// NOTE: This file should not be edited', `// see https://nextjs.org/docs/${hasAppDir ? 'app' : 'pages'}/api-reference/config/typescript for more information.`);
+    const content = directives.join(eol) + eol;
+    // Avoids an un-necessary write on read-only fs
+    if (currentContent === content) {
+        return;
+    }
+    await _fs.promises.writeFile(appTypeDeclarations, content);
+}
+
+//# sourceMappingURL=writeAppTypeDeclarations.js.map