@rsalmn/extremerouter 0.7.8 → 0.7.9

package/app/node_modules/next/dist/lib/install-dependencies.js

@@ -28,7 +28,7 @@ async function installDependencies(baseDir, deps, dev = false) {
             console.log(`- ${(0, _picocolors.cyan)(dep.pkg)}`);
         }
         console.log();
-        await (0, _install.install)(_path.default.resolve(baseDir), deps.map((dep)=>dep.pkg), {
+        await (0, _install.install)(_path.default.resolve(baseDir), deps.map((dep)=>dep.install ?? dep.pkg), {
             devDependencies: dev,
             isOnline,
             packageManager

package/app/node_modules/next/dist/lib/patch-incorrect-lockfile.js

@@ -72,7 +72,7 @@ async function fetchPkgInfo(pkg) {
         });
     }
     const data = await res.json();
-    const versionData = data.versions["16.2.10"];
+    const versionData = data.versions["16.2.12"];
     return {
         os: versionData.os,
         cpu: versionData.cpu,
@@ -100,7 +100,7 @@ async function patchIncorrectLockfile(dir) {
     const expectedSwcPkgs = Object.keys(_packagejson.optionalDependencies || {}).filter((pkg)=>pkg.startsWith('@next/swc-'));
     const patchDependency = (pkg, pkgData)=>{
         lockfileParsed.dependencies[pkg] = {
-            version: "16.2.10",
+            version: "16.2.12",
             resolved: pkgData.tarball,
             integrity: pkgData.integrity,
             optional: true
@@ -108,7 +108,7 @@ async function patchIncorrectLockfile(dir) {
     };
     const patchPackage = (pkg, pkgData)=>{
         lockfileParsed.packages[pkg] = {
-            version: "16.2.10",
+            version: "16.2.12",
             resolved: pkgData.tarball,
             integrity: pkgData.integrity,
             cpu: pkgData.cpu,

package/app/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/app/node_modules/next/dist/lib/typescript/missingDependencyError.js

@@ -14,7 +14,7 @@ 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", {

package/app/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/app/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. ` + `Enable ${(0, _picocolors.bold)('experimental.useTypeScriptCli')} in your Next.js config to use the TypeScript CLI, ` + `or install TypeScript 6 instead.`), "__NEXT_ERROR_CODE", {
+        value: "E1150",
+        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: "E1149",
+            enumerable: false,
+            configurable: true
+        });
+    }
+}
+
+//# sourceMappingURL=runTypeScriptCli.js.map