main repo

node_modules/next/dist/esm/lib/eslint/customFormatter.js

@@ -0,0 +1,70 @@
+import chalk from "next/dist/compiled/chalk";
+import path from "path";
+export var MessageSeverity;
+(function(MessageSeverity) {
+    MessageSeverity[MessageSeverity["Warning"] = 1] = "Warning";
+    MessageSeverity[MessageSeverity["Error"] = 2] = "Error";
+})(MessageSeverity || (MessageSeverity = {}));
+function pluginCount(messages) {
+    let nextPluginWarningCount = 0;
+    let nextPluginErrorCount = 0;
+    for(let i = 0; i < messages.length; i++){
+        const { severity, ruleId } = messages[i];
+        if (ruleId == null ? void 0 : ruleId.includes("@next/next")) {
+            if (severity === 1) {
+                nextPluginWarningCount += 1;
+            } else {
+                nextPluginErrorCount += 1;
+            }
+        }
+    }
+    return {
+        nextPluginErrorCount,
+        nextPluginWarningCount
+    };
+}
+function formatMessage(dir, messages, filePath) {
+    let fileName = path.posix.normalize(path.relative(dir, filePath).replace(/\\/g, "/"));
+    if (!fileName.startsWith(".")) {
+        fileName = "./" + fileName;
+    }
+    let output = "\n" + chalk.cyan(fileName);
+    for(let i = 0; i < messages.length; i++){
+        const { message, severity, line, column, ruleId } = messages[i];
+        output = output + "\n";
+        if (line && column) {
+            output = output + chalk.yellow(line.toString()) + ":" + chalk.yellow(column.toString()) + "  ";
+        }
+        if (severity === 1) {
+            output += chalk.yellow.bold("Warning") + ": ";
+        } else {
+            output += chalk.red.bold("Error") + ": ";
+        }
+        output += message;
+        if (ruleId) {
+            output += "  " + chalk.gray.bold(ruleId);
+        }
+    }
+    return output;
+}
+export function formatResults(baseDir, results, format) {
+    let totalNextPluginErrorCount = 0;
+    let totalNextPluginWarningCount = 0;
+    let resultsWithMessages = results.filter(({ messages })=>messages == null ? void 0 : messages.length);
+    // Track number of Next.js plugin errors and warnings
+    resultsWithMessages.forEach(({ messages })=>{
+        const res = pluginCount(messages);
+        totalNextPluginErrorCount += res.nextPluginErrorCount;
+        totalNextPluginWarningCount += res.nextPluginWarningCount;
+    });
+    // Use user defined formatter or Next.js's built-in custom formatter
+    const output = format ? format(resultsWithMessages) : resultsWithMessages.map(({ messages, filePath })=>formatMessage(baseDir, messages, filePath)).join("\n");
+    return {
+        output: output,
+        outputWithMessages: resultsWithMessages.length > 0 ? output + `\n\n${chalk.cyan("info")}  - Need to disable some ESLint rules? Learn more here: https://nextjs.org/docs/basic-features/eslint#disabling-rules` : "",
+        totalNextPluginErrorCount,
+        totalNextPluginWarningCount
+    };
+}
+
+//# sourceMappingURL=customFormatter.js.map

node_modules/next/dist/esm/lib/eslint/customFormatter.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/eslint/customFormatter.ts"],"names":["chalk","path","MessageSeverity","Warning","Error","pluginCount","messages","nextPluginWarningCount","nextPluginErrorCount","i","length","severity","ruleId","includes","formatMessage","dir","filePath","fileName","posix","normalize","relative","replace","startsWith","output","cyan","message","line","column","yellow","toString","bold","red","gray","formatResults","baseDir","results","format","totalNextPluginErrorCount","totalNextPluginWarningCount","resultsWithMessages","filter","forEach","res","map","join","outputWithMessages"],"mappings":"AAAA,OAAOA,WAAW,2BAA0B;AAC5C,OAAOC,UAAU,OAAM;WAGhB;UAAKC,eAAe;IAAfA,gBAAAA,gBACVC,aAAU,KAAVA;IADUD,gBAAAA,gBAEVE,WAAQ,KAARA;GAFUF,oBAAAA;AAsBZ,SAASG,YAAYC,QAAuB;IAI1C,IAAIC,yBAAyB;IAC7B,IAAIC,uBAAuB;IAE3B,IAAK,IAAIC,IAAI,GAAGA,IAAIH,SAASI,MAAM,EAAED,IAAK;QACxC,MAAM,EAAEE,QAAQ,EAAEC,MAAM,EAAE,GAAGN,QAAQ,CAACG,EAAE;QAExC,IAAIG,0BAAAA,OAAQC,QAAQ,CAAC,eAAe;YAClC,IAAIF,aAhCE,GAgCoC;gBACxCJ,0BAA0B;YAC5B,OAAO;gBACLC,wBAAwB;YAC1B;QACF;IACF;IAEA,OAAO;QACLA;QACAD;IACF;AACF;AAEA,SAASO,cACPC,GAAW,EACXT,QAAuB,EACvBU,QAAgB;IAEhB,IAAIC,WAAWhB,KAAKiB,KAAK,CAACC,SAAS,CACjClB,KAAKmB,QAAQ,CAACL,KAAKC,UAAUK,OAAO,CAAC,OAAO;IAG9C,IAAI,CAACJ,SAASK,UAAU,CAAC,MAAM;QAC7BL,WAAW,OAAOA;IACpB;IAEA,IAAIM,SAAS,OAAOvB,MAAMwB,IAAI,CAACP;IAE/B,IAAK,IAAIR,IAAI,GAAGA,IAAIH,SAASI,MAAM,EAAED,IAAK;QACxC,MAAM,EAAEgB,OAAO,EAAEd,QAAQ,EAAEe,IAAI,EAAEC,MAAM,EAAEf,MAAM,EAAE,GAAGN,QAAQ,CAACG,EAAE;QAE/Dc,SAASA,SAAS;QAElB,IAAIG,QAAQC,QAAQ;YAClBJ,SACEA,SACAvB,MAAM4B,MAAM,CAACF,KAAKG,QAAQ,MAC1B,MACA7B,MAAM4B,MAAM,CAACD,OAAOE,QAAQ,MAC5B;QACJ;QAEA,IAAIlB,aA3EI,GA2EkC;YACxCY,UAAUvB,MAAM4B,MAAM,CAACE,IAAI,CAAC,aAAa;QAC3C,OAAO;YACLP,UAAUvB,MAAM+B,GAAG,CAACD,IAAI,CAAC,WAAW;QACtC;QAEAP,UAAUE;QAEV,IAAIb,QAAQ;YACVW,UAAU,OAAOvB,MAAMgC,IAAI,CAACF,IAAI,CAAClB;QACnC;IACF;IAEA,OAAOW;AACT;AAEA,OAAO,SAASU,cACdC,OAAe,EACfC,OAAqB,EACrBC,MAAmC;IAOnC,IAAIC,4BAA4B;IAChC,IAAIC,8BAA8B;IAClC,IAAIC,sBAAsBJ,QAAQK,MAAM,CAAC,CAAC,EAAElC,QAAQ,EAAE,GAAKA,4BAAAA,SAAUI,MAAM;IAE3E,qDAAqD;IACrD6B,oBAAoBE,OAAO,CAAC,CAAC,EAAEnC,QAAQ,EAAE;QACvC,MAAMoC,MAAMrC,YAAYC;QACxB+B,6BAA6BK,IAAIlC,oBAAoB;QACrD8B,+BAA+BI,IAAInC,sBAAsB;IAC3D;IAEA,oEAAoE;IACpE,MAAMgB,SAASa,SACXA,OAAOG,uBACPA,oBACGI,GAAG,CAAC,CAAC,EAAErC,QAAQ,EAAEU,QAAQ,EAAE,GAC1BF,cAAcoB,SAAS5B,UAAUU,WAElC4B,IAAI,CAAC;IAEZ,OAAO;QACLrB,QAAQA;QACRsB,oBACEN,oBAAoB7B,MAAM,GAAG,IACzBa,SACA,CAAC,IAAI,EAAEvB,MAAMwB,IAAI,CACf,QACA,qHAAqH,CAAC,GACxH;QACNa;QACAC;IACF;AACF"}

node_modules/next/dist/esm/lib/eslint/hasEslintConfiguration.js

@@ -0,0 +1,27 @@
+import { promises as fs } from "fs";
+export async function hasEslintConfiguration(eslintrcFile, packageJsonConfig) {
+    const configObject = {
+        exists: false,
+        emptyEslintrc: false,
+        emptyPkgJsonConfig: false
+    };
+    if (eslintrcFile) {
+        const content = await fs.readFile(eslintrcFile, {
+            encoding: "utf8"
+        }).then((txt)=>txt.trim().replace(/\n/g, ""), ()=>null);
+        if (content === "" || content === "{}" || content === "---" || content === "module.exports = {}") {
+            configObject.emptyEslintrc = true;
+        } else {
+            configObject.exists = true;
+        }
+    } else if (packageJsonConfig == null ? void 0 : packageJsonConfig.eslintConfig) {
+        if (Object.keys(packageJsonConfig.eslintConfig).length) {
+            configObject.exists = true;
+        } else {
+            configObject.emptyPkgJsonConfig = true;
+        }
+    }
+    return configObject;
+}
+
+//# sourceMappingURL=hasEslintConfiguration.js.map

node_modules/next/dist/esm/lib/eslint/hasEslintConfiguration.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/eslint/hasEslintConfiguration.ts"],"names":["promises","fs","hasEslintConfiguration","eslintrcFile","packageJsonConfig","configObject","exists","emptyEslintrc","emptyPkgJsonConfig","content","readFile","encoding","then","txt","trim","replace","eslintConfig","Object","keys","length"],"mappings":"AAAA,SAASA,YAAYC,EAAE,QAAQ,KAAI;AASnC,OAAO,eAAeC,uBACpBC,YAA2B,EAC3BC,iBAA+C;IAE/C,MAAMC,eAAe;QACnBC,QAAQ;QACRC,eAAe;QACfC,oBAAoB;IACtB;IAEA,IAAIL,cAAc;QAChB,MAAMM,UAAU,MAAMR,GAAGS,QAAQ,CAACP,cAAc;YAAEQ,UAAU;QAAO,GAAGC,IAAI,CACxE,CAACC,MAAQA,IAAIC,IAAI,GAAGC,OAAO,CAAC,OAAO,KACnC,IAAM;QAGR,IACEN,YAAY,MACZA,YAAY,QACZA,YAAY,SACZA,YAAY,uBACZ;YACAJ,aAAaE,aAAa,GAAG;QAC/B,OAAO;YACLF,aAAaC,MAAM,GAAG;QACxB;IACF,OAAO,IAAIF,qCAAAA,kBAAmBY,YAAY,EAAE;QAC1C,IAAIC,OAAOC,IAAI,CAACd,kBAAkBY,YAAY,EAAEG,MAAM,EAAE;YACtDd,aAAaC,MAAM,GAAG;QACxB,OAAO;YACLD,aAAaG,kBAAkB,GAAG;QACpC;IACF;IACA,OAAOH;AACT"}

node_modules/next/dist/esm/lib/eslint/runLintCheck.js

@@ -0,0 +1,247 @@
+import { promises as fs } from "fs";
+import chalk from "next/dist/compiled/chalk";
+import path from "path";
+import findUp from "next/dist/compiled/find-up";
+import semver from "next/dist/compiled/semver";
+import * as CommentJson from "next/dist/compiled/comment-json";
+import { formatResults } from "./customFormatter";
+import { writeDefaultConfig } from "./writeDefaultConfig";
+import { hasEslintConfiguration } from "./hasEslintConfiguration";
+import { writeOutputFile } from "./writeOutputFile";
+import { ESLINT_PROMPT_VALUES } from "../constants";
+import { existsSync, findPagesDir } from "../find-pages-dir";
+import { installDependencies } from "../install-dependencies";
+import { hasNecessaryDependencies } from "../has-necessary-dependencies";
+import * as Log from "../../build/output/log";
+import isError, { getProperError } from "../is-error";
+import { getPkgManager } from "../helpers/get-pkg-manager";
+// 0 is off, 1 is warn, 2 is error. See https://eslint.org/docs/user-guide/configuring/rules#configuring-rules
+const VALID_SEVERITY = [
+    "off",
+    "warn",
+    "error"
+];
+function isValidSeverity(severity) {
+    return VALID_SEVERITY.includes(severity);
+}
+const requiredPackages = [
+    {
+        file: "eslint",
+        pkg: "eslint",
+        exportsRestrict: false
+    },
+    {
+        file: "eslint-config-next",
+        pkg: "eslint-config-next",
+        exportsRestrict: false
+    }
+];
+async function cliPrompt() {
+    console.log(chalk.bold(`${chalk.cyan("?")} How would you like to configure ESLint? https://nextjs.org/docs/basic-features/eslint`));
+    try {
+        const cliSelect = (await Promise.resolve(require("next/dist/compiled/cli-select"))).default;
+        const { value } = await cliSelect({
+            values: ESLINT_PROMPT_VALUES,
+            valueRenderer: ({ title, recommended }, selected)=>{
+                const name = selected ? chalk.bold.underline.cyan(title) : title;
+                return name + (recommended ? chalk.bold.yellow(" (recommended)") : "");
+            },
+            selected: chalk.cyan("❯ "),
+            unselected: "  "
+        });
+        return {
+            config: (value == null ? void 0 : value.config) ?? null
+        };
+    } catch  {
+        return {
+            config: null
+        };
+    }
+}
+async function lint(baseDir, lintDirs, eslintrcFile, pkgJsonPath, { lintDuringBuild = false, eslintOptions = null, reportErrorsOnly = false, maxWarnings = -1, formatter = null, outputFile = null }) {
+    try {
+        var _mod_CLIEngine, _ESLint_getErrorResults;
+        // Load ESLint after we're sure it exists:
+        const deps = await hasNecessaryDependencies(baseDir, requiredPackages);
+        const packageManager = getPkgManager(baseDir);
+        if (deps.missing.some((dep)=>dep.pkg === "eslint")) {
+            Log.error(`ESLint must be installed${lintDuringBuild ? " in order to run during builds:" : ":"} ${chalk.bold.cyan((packageManager === "yarn" ? "yarn add --dev" : packageManager === "pnpm" ? "pnpm install --save-dev" : "npm install --save-dev") + " eslint")}`);
+            return null;
+        }
+        const mod = await Promise.resolve(require(deps.resolved.get("eslint")));
+        const { ESLint } = mod;
+        let eslintVersion = (ESLint == null ? void 0 : ESLint.version) ?? ((_mod_CLIEngine = mod.CLIEngine) == null ? void 0 : _mod_CLIEngine.version);
+        if (!eslintVersion || semver.lt(eslintVersion, "7.0.0")) {
+            return `${chalk.red("error")} - Your project has an older version of ESLint installed${eslintVersion ? " (" + eslintVersion + ")" : ""}. Please upgrade to ESLint version 7 or above`;
+        }
+        let options = {
+            useEslintrc: true,
+            baseConfig: {},
+            errorOnUnmatchedPattern: false,
+            extensions: [
+                ".js",
+                ".jsx",
+                ".ts",
+                ".tsx"
+            ],
+            cache: true,
+            ...eslintOptions
+        };
+        let eslint = new ESLint(options);
+        let nextEslintPluginIsEnabled = false;
+        const nextRulesEnabled = new Map();
+        for (const configFile of [
+            eslintrcFile,
+            pkgJsonPath
+        ]){
+            var _completeConfig_plugins;
+            if (!configFile) continue;
+            const completeConfig = await eslint.calculateConfigForFile(configFile);
+            if ((_completeConfig_plugins = completeConfig.plugins) == null ? void 0 : _completeConfig_plugins.includes("@next/next")) {
+                nextEslintPluginIsEnabled = true;
+                for (const [name, [severity]] of Object.entries(completeConfig.rules)){
+                    if (!name.startsWith("@next/next/")) {
+                        continue;
+                    }
+                    if (typeof severity === "number" && severity >= 0 && severity < VALID_SEVERITY.length) {
+                        nextRulesEnabled.set(name, VALID_SEVERITY[severity]);
+                    } else if (typeof severity === "string" && isValidSeverity(severity)) {
+                        nextRulesEnabled.set(name, severity);
+                    }
+                }
+                break;
+            }
+        }
+        const pagesDir = findPagesDir(baseDir).pagesDir;
+        const pagesDirRules = pagesDir ? [
+            "@next/next/no-html-link-for-pages"
+        ] : [];
+        if (nextEslintPluginIsEnabled) {
+            let updatedPagesDir = false;
+            for (const rule of pagesDirRules){
+                var _options_baseConfig_rules, _options_baseConfig_rules1;
+                if (!((_options_baseConfig_rules = options.baseConfig.rules) == null ? void 0 : _options_baseConfig_rules[rule]) && !((_options_baseConfig_rules1 = options.baseConfig.rules) == null ? void 0 : _options_baseConfig_rules1[rule.replace("@next/next", "@next/babel-plugin-next")])) {
+                    if (!options.baseConfig.rules) {
+                        options.baseConfig.rules = {};
+                    }
+                    options.baseConfig.rules[rule] = [
+                        1,
+                        pagesDir
+                    ];
+                    updatedPagesDir = true;
+                }
+            }
+            if (updatedPagesDir) {
+                eslint = new ESLint(options);
+            }
+        } else {
+            Log.warn("");
+            Log.warn("The Next.js plugin was not detected in your ESLint configuration. See https://nextjs.org/docs/basic-features/eslint#migrating-existing-config");
+        }
+        const lintStart = process.hrtime();
+        let results = await eslint.lintFiles(lintDirs);
+        let selectedFormatter = null;
+        if (options.fix) await ESLint.outputFixes(results);
+        if (reportErrorsOnly) results = await ESLint.getErrorResults(results) // Only return errors if --quiet flag is used
+        ;
+        if (formatter) selectedFormatter = await eslint.loadFormatter(formatter);
+        const formattedResult = formatResults(baseDir, results, selectedFormatter == null ? void 0 : selectedFormatter.format);
+        const lintEnd = process.hrtime(lintStart);
+        const totalWarnings = results.reduce((sum, file)=>sum + file.warningCount, 0);
+        if (outputFile) await writeOutputFile(outputFile, formattedResult.output);
+        return {
+            output: formattedResult.outputWithMessages,
+            isError: ((_ESLint_getErrorResults = ESLint.getErrorResults(results)) == null ? void 0 : _ESLint_getErrorResults.length) > 0 || maxWarnings >= 0 && totalWarnings > maxWarnings,
+            eventInfo: {
+                durationInSeconds: lintEnd[0],
+                eslintVersion: eslintVersion,
+                lintedFilesCount: results.length,
+                lintFix: !!options.fix,
+                nextEslintPluginVersion: nextEslintPluginIsEnabled && deps.resolved.has("eslint-config-next") ? require(path.join(path.dirname(deps.resolved.get("eslint-config-next")), "package.json")).version : null,
+                nextEslintPluginErrorsCount: formattedResult.totalNextPluginErrorCount,
+                nextEslintPluginWarningsCount: formattedResult.totalNextPluginWarningCount,
+                nextRulesEnabled: Object.fromEntries(nextRulesEnabled)
+            }
+        };
+    } catch (err) {
+        if (lintDuringBuild) {
+            Log.error(`ESLint: ${isError(err) && err.message ? err.message.replace(/\n/g, " ") : err}`);
+            return null;
+        } else {
+            throw getProperError(err);
+        }
+    }
+}
+export async function runLintCheck(baseDir, lintDirs, opts) {
+    const { lintDuringBuild = false, eslintOptions = null, reportErrorsOnly = false, maxWarnings = -1, formatter = null, outputFile = null, strict = false } = opts;
+    try {
+        // Find user's .eslintrc file
+        // See: https://eslint.org/docs/user-guide/configuring/configuration-files#configuration-file-formats
+        const eslintrcFile = await findUp([
+            ".eslintrc.js",
+            ".eslintrc.cjs",
+            ".eslintrc.yaml",
+            ".eslintrc.yml",
+            ".eslintrc.json",
+            ".eslintrc"
+        ], {
+            cwd: baseDir
+        }) ?? null;
+        const pkgJsonPath = await findUp("package.json", {
+            cwd: baseDir
+        }) ?? null;
+        let packageJsonConfig = null;
+        if (pkgJsonPath) {
+            const pkgJsonContent = await fs.readFile(pkgJsonPath, {
+                encoding: "utf8"
+            });
+            packageJsonConfig = CommentJson.parse(pkgJsonContent);
+        }
+        const config = await hasEslintConfiguration(eslintrcFile, packageJsonConfig);
+        let deps;
+        if (config.exists) {
+            // Run if ESLint config exists
+            return await lint(baseDir, lintDirs, eslintrcFile, pkgJsonPath, {
+                lintDuringBuild,
+                eslintOptions,
+                reportErrorsOnly,
+                maxWarnings,
+                formatter,
+                outputFile
+            });
+        } else {
+            // Display warning if no ESLint configuration is present inside
+            // config file during "next build", no warning is shown when
+            // no eslintrc file is present
+            if (lintDuringBuild) {
+                if (config.emptyPkgJsonConfig || config.emptyEslintrc) {
+                    Log.warn(`No ESLint configuration detected. Run ${chalk.bold.cyan("next lint")} to begin setup`);
+                }
+                return null;
+            } else {
+                // Ask user what config they would like to start with for first time "next lint" setup
+                const { config: selectedConfig } = strict ? ESLINT_PROMPT_VALUES.find((opt)=>opt.title === "Strict") : await cliPrompt();
+                if (selectedConfig == null) {
+                    // Show a warning if no option is selected in prompt
+                    Log.warn("If you set up ESLint yourself, we recommend adding the Next.js ESLint plugin. See https://nextjs.org/docs/basic-features/eslint#migrating-existing-config");
+                    return null;
+                } else {
+                    // Check if necessary deps installed, and install any that are missing
+                    deps = await hasNecessaryDependencies(baseDir, requiredPackages);
+                    if (deps.missing.length > 0) await installDependencies(baseDir, deps.missing, true);
+                    // Write default ESLint config.
+                    // Check for /pages and src/pages is to make sure this happens in Next.js folder
+                    if (existsSync(path.join(baseDir, "pages")) || existsSync(path.join(baseDir, "src/pages"))) {
+                        await writeDefaultConfig(baseDir, config, selectedConfig, eslintrcFile, pkgJsonPath, packageJsonConfig);
+                    }
+                }
+                Log.ready(`ESLint has successfully been configured. Run ${chalk.bold.cyan("next lint")} again to view warnings and errors.`);
+                return null;
+            }
+        }
+    } catch (err) {
+        throw err;
+    }
+}
+
+//# sourceMappingURL=runLintCheck.js.map

node_modules/next/dist/esm/lib/eslint/writeDefaultConfig.js

@@ -0,0 +1,31 @@
+import { promises as fs } from "fs";
+import chalk from "next/dist/compiled/chalk";
+import os from "os";
+import path from "path";
+import * as CommentJson from "next/dist/compiled/comment-json";
+import * as Log from "../../build/output/log";
+export async function writeDefaultConfig(baseDir, { exists, emptyEslintrc, emptyPkgJsonConfig }, selectedConfig, eslintrcFile, pkgJsonPath, packageJsonConfig) {
+    if (!exists && emptyEslintrc && eslintrcFile) {
+        const ext = path.extname(eslintrcFile);
+        let newFileContent;
+        if (ext === ".yaml" || ext === ".yml") {
+            newFileContent = "extends: 'next'";
+        } else {
+            newFileContent = CommentJson.stringify(selectedConfig, null, 2);
+            if (ext === ".js") {
+                newFileContent = "module.exports = " + newFileContent;
+            }
+        }
+        await fs.writeFile(eslintrcFile, newFileContent + os.EOL);
+        Log.info(`We detected an empty ESLint configuration file (${chalk.bold(path.basename(eslintrcFile))}) and updated it for you!`);
+    } else if (!exists && emptyPkgJsonConfig && packageJsonConfig) {
+        packageJsonConfig.eslintConfig = selectedConfig;
+        if (pkgJsonPath) await fs.writeFile(pkgJsonPath, CommentJson.stringify(packageJsonConfig, null, 2) + os.EOL);
+        Log.info(`We detected an empty ${chalk.bold("eslintConfig")} field in package.json and updated it for you!`);
+    } else if (!exists) {
+        await fs.writeFile(path.join(baseDir, ".eslintrc.json"), CommentJson.stringify(selectedConfig, null, 2) + os.EOL);
+        console.log(chalk.green(`We created the ${chalk.bold(".eslintrc.json")} file for you and included your selected configuration.`));
+    }
+}
+
+//# sourceMappingURL=writeDefaultConfig.js.map

node_modules/next/dist/esm/lib/eslint/writeDefaultConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/eslint/writeDefaultConfig.ts"],"names":["promises","fs","chalk","os","path","CommentJson","Log","writeDefaultConfig","baseDir","exists","emptyEslintrc","emptyPkgJsonConfig","selectedConfig","eslintrcFile","pkgJsonPath","packageJsonConfig","ext","extname","newFileContent","stringify","writeFile","EOL","info","bold","basename","eslintConfig","join","console","log","green"],"mappings":"AAAA,SAASA,YAAYC,EAAE,QAAQ,KAAI;AACnC,OAAOC,WAAW,2BAA0B;AAC5C,OAAOC,QAAQ,KAAI;AACnB,OAAOC,UAAU,OAAM;AACvB,YAAYC,iBAAiB,kCAAiC;AAG9D,YAAYC,SAAS,yBAAwB;AAE7C,OAAO,eAAeC,mBACpBC,OAAe,EACf,EAAEC,MAAM,EAAEC,aAAa,EAAEC,kBAAkB,EAAmB,EAC9DC,cAAmB,EACnBC,YAA2B,EAC3BC,WAA0B,EAC1BC,iBAA+C;IAE/C,IAAI,CAACN,UAAUC,iBAAiBG,cAAc;QAC5C,MAAMG,MAAMZ,KAAKa,OAAO,CAACJ;QAEzB,IAAIK;QACJ,IAAIF,QAAQ,WAAWA,QAAQ,QAAQ;YACrCE,iBAAiB;QACnB,OAAO;YACLA,iBAAiBb,YAAYc,SAAS,CAACP,gBAAgB,MAAM;YAE7D,IAAII,QAAQ,OAAO;gBACjBE,iBAAiB,sBAAsBA;YACzC;QACF;QAEA,MAAMjB,GAAGmB,SAAS,CAACP,cAAcK,iBAAiBf,GAAGkB,GAAG;QAExDf,IAAIgB,IAAI,CACN,CAAC,gDAAgD,EAAEpB,MAAMqB,IAAI,CAC3DnB,KAAKoB,QAAQ,CAACX,eACd,yBAAyB,CAAC;IAEhC,OAAO,IAAI,CAACJ,UAAUE,sBAAsBI,mBAAmB;QAC7DA,kBAAkBU,YAAY,GAAGb;QAEjC,IAAIE,aACF,MAAMb,GAAGmB,SAAS,CAChBN,aACAT,YAAYc,SAAS,CAACJ,mBAAmB,MAAM,KAAKZ,GAAGkB,GAAG;QAG9Df,IAAIgB,IAAI,CACN,CAAC,qBAAqB,EAAEpB,MAAMqB,IAAI,CAChC,gBACA,8CAA8C,CAAC;IAErD,OAAO,IAAI,CAACd,QAAQ;QAClB,MAAMR,GAAGmB,SAAS,CAChBhB,KAAKsB,IAAI,CAAClB,SAAS,mBACnBH,YAAYc,SAAS,CAACP,gBAAgB,MAAM,KAAKT,GAAGkB,GAAG;QAGzDM,QAAQC,GAAG,CACT1B,MAAM2B,KAAK,CACT,CAAC,eAAe,EAAE3B,MAAMqB,IAAI,CAC1B,kBACA,uDAAuD,CAAC;IAGhE;AACF"}

node_modules/next/dist/esm/lib/eslint/writeOutputFile.js

@@ -0,0 +1,36 @@
+import { promises as fs } from "fs";
+import path from "path";
+import * as Log from "../../build/output/log";
+import isError from "../../lib/is-error";
+/**
+ * Check if a given file path is a directory or not.
+ * Returns `true` if the path is a directory.
+ */ function isDirectory(/**  The path to a file to check. */ filePath) {
+    return fs.stat(filePath).then((stat)=>stat.isDirectory()).catch((error)=>{
+        if (isError(error) && (error.code === "ENOENT" || error.code === "ENOTDIR")) {
+            return false;
+        }
+        throw error;
+    });
+}
+/**
+ * Create a file with eslint output data
+ */ export async function writeOutputFile(/** The name file that needs to be created */ outputFile, /** The data that needs to be inserted into the file */ outputData) {
+    const filePath = path.resolve(process.cwd(), outputFile);
+    if (await isDirectory(filePath)) {
+        Log.error(`Cannot write to output file path, it is a directory: ${filePath}`);
+    } else {
+        try {
+            await fs.mkdir(path.dirname(filePath), {
+                recursive: true
+            });
+            await fs.writeFile(filePath, outputData);
+            Log.info(`The output file has been created: ${filePath}`);
+        } catch (err) {
+            Log.error(`There was a problem writing the output file: ${filePath}`);
+            console.error(err);
+        }
+    }
+}
+
+//# sourceMappingURL=writeOutputFile.js.map

node_modules/next/dist/esm/lib/eslint/writeOutputFile.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/eslint/writeOutputFile.ts"],"names":["promises","fs","path","Log","isError","isDirectory","filePath","stat","then","catch","error","code","writeOutputFile","outputFile","outputData","resolve","process","cwd","mkdir","dirname","recursive","writeFile","info","err","console"],"mappings":"AAAA,SAASA,YAAYC,EAAE,QAAQ,KAAI;AACnC,OAAOC,UAAU,OAAM;AACvB,YAAYC,SAAS,yBAAwB;AAC7C,OAAOC,aAAa,qBAAoB;AAExC;;;CAGC,GACD,SAASC,YACP,kCAAkC,GAClCC,QAAgB;IAEhB,OAAOL,GACJM,IAAI,CAACD,UACLE,IAAI,CAAC,CAACD,OAASA,KAAKF,WAAW,IAC/BI,KAAK,CAAC,CAACC;QACN,IACEN,QAAQM,UACPA,CAAAA,MAAMC,IAAI,KAAK,YAAYD,MAAMC,IAAI,KAAK,SAAQ,GACnD;YACA,OAAO;QACT;QACA,MAAMD;IACR;AACJ;AACA;;CAEC,GACD,OAAO,eAAeE,gBACpB,2CAA2C,GAC3CC,UAAkB,EAClB,qDAAqD,GACrDC,UAAkB;IAElB,MAAMR,WAAWJ,KAAKa,OAAO,CAACC,QAAQC,GAAG,IAAIJ;IAE7C,IAAI,MAAMR,YAAYC,WAAW;QAC/BH,IAAIO,KAAK,CACP,CAAC,qDAAqD,EAAEJ,SAAS,CAAC;IAEtE,OAAO;QACL,IAAI;YACF,MAAML,GAAGiB,KAAK,CAAChB,KAAKiB,OAAO,CAACb,WAAW;gBAAEc,WAAW;YAAK;YACzD,MAAMnB,GAAGoB,SAAS,CAACf,UAAUQ;YAC7BX,IAAImB,IAAI,CAAC,CAAC,kCAAkC,EAAEhB,SAAS,CAAC;QAC1D,EAAE,OAAOiB,KAAK;YACZpB,IAAIO,KAAK,CAAC,CAAC,6CAA6C,EAAEJ,SAAS,CAAC;YACpEkB,QAAQd,KAAK,CAACa;QAChB;IACF;AACF"}