@depup/expo__cli 55.0.16-depup.0

package/build/src/install/installExpoPackage.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "installExpoPackageAsync", {
+    enumerable: true,
+    get: function() {
+        return installExpoPackageAsync;
+    }
+});
+function _spawnasync() {
+    const data = /*#__PURE__*/ _interop_require_default(require("@expo/spawn-async"));
+    _spawnasync = function() {
+        return data;
+    };
+    return data;
+}
+function _chalk() {
+    const data = /*#__PURE__*/ _interop_require_default(require("chalk"));
+    _chalk = function() {
+        return data;
+    };
+    return data;
+}
+const _log = /*#__PURE__*/ _interop_require_wildcard(require("../log"));
+const _getRunningProcess = require("../utils/getRunningProcess");
+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;
+}
+async function installExpoPackageAsync(projectRoot, { packageManager, packageManagerArguments, expoPackageToInstall, followUpCommandArgs, dev }) {
+    // Check if there's potentially a dev server running in the current folder and warn about it
+    // (not guaranteed to be Expo CLI, and the CLI isn't always running on 8081, but it's a good guess)
+    const isExpoMaybeRunningForProject = !!await (0, _getRunningProcess.getRunningProcess)(8081);
+    if (isExpoMaybeRunningForProject) {
+        _log.warn('The Expo CLI appears to be running this project in another terminal window. Close and restart any Expo CLI instances after the installation to complete the update.');
+    }
+    // Safe to use current process to upgrade Expo package- doesn't affect current process
+    try {
+        if (dev) {
+            await packageManager.addDevAsync([
+                ...packageManagerArguments,
+                expoPackageToInstall
+            ]);
+        } else {
+            await packageManager.addAsync([
+                ...packageManagerArguments,
+                expoPackageToInstall
+            ]);
+        }
+    } catch (error) {
+        _log.error((0, _chalk().default)`Cannot install the latest Expo package. Install {bold expo@latest} with ${packageManager.name} and then run {bold npx expo install} again.`);
+        throw error;
+    }
+    // Spawn a new process to install the rest of the packages if there are any, as only then will the latest Expo package be used
+    if (followUpCommandArgs.length) {
+        let commandSegments = [
+            'expo',
+            'install',
+            dev ? '--dev' : '',
+            ...followUpCommandArgs
+        ].filter(Boolean);
+        if (packageManagerArguments.length) {
+            commandSegments = [
+                ...commandSegments,
+                '--',
+                ...packageManagerArguments
+            ];
+        }
+        _log.log((0, _chalk().default)`\u203A Running {bold npx expo install} under the updated expo version`);
+        _log.log('> ' + commandSegments.join(' '));
+        await (0, _spawnasync().default)('npx', commandSegments, {
+            stdio: 'inherit',
+            cwd: projectRoot,
+            env: {
+                ...process.env
+            }
+        });
+    }
+}
+
+//# sourceMappingURL=installExpoPackage.js.map

package/build/src/install/installExpoPackage.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/install/installExpoPackage.ts"],"sourcesContent":["import * as PackageManager from '@expo/package-manager';\nimport spawnAsync from '@expo/spawn-async';\nimport chalk from 'chalk';\n\nimport * as Log from '../log';\nimport type { Options } from './resolveOptions';\nimport { getRunningProcess } from '../utils/getRunningProcess';\n\n/**\n * Given a list of incompatible packages, installs the correct versions of the packages with the package manager used for the project.\n * This exits immediately after spawning the install command, since the command shouldn't remain running while it is being updated.\n */\nexport async function installExpoPackageAsync(\n  projectRoot: string,\n  {\n    packageManager,\n    packageManagerArguments,\n    expoPackageToInstall,\n    followUpCommandArgs,\n    dev,\n  }: Pick<Options, 'dev'> & {\n    /** Package manager to use when installing the versioned packages. */\n    packageManager: PackageManager.NodePackageManager;\n    /**\n     * Extra parameters to pass to the `packageManager` when installing versioned packages.\n     * @example ['--no-save']\n     */\n    packageManagerArguments: string[];\n    expoPackageToInstall: string;\n    followUpCommandArgs: string[];\n  }\n) {\n  // Check if there's potentially a dev server running in the current folder and warn about it\n  // (not guaranteed to be Expo CLI, and the CLI isn't always running on 8081, but it's a good guess)\n  const isExpoMaybeRunningForProject = !!(await getRunningProcess(8081));\n\n  if (isExpoMaybeRunningForProject) {\n    Log.warn(\n      'The Expo CLI appears to be running this project in another terminal window. Close and restart any Expo CLI instances after the installation to complete the update.'\n    );\n  }\n\n  // Safe to use current process to upgrade Expo package- doesn't affect current process\n  try {\n    if (dev) {\n      await packageManager.addDevAsync([...packageManagerArguments, expoPackageToInstall]);\n    } else {\n      await packageManager.addAsync([...packageManagerArguments, expoPackageToInstall]);\n    }\n  } catch (error) {\n    Log.error(\n      chalk`Cannot install the latest Expo package. Install {bold expo@latest} with ${packageManager.name} and then run {bold npx expo install} again.`\n    );\n    throw error;\n  }\n\n  // Spawn a new process to install the rest of the packages if there are any, as only then will the latest Expo package be used\n  if (followUpCommandArgs.length) {\n    let commandSegments = ['expo', 'install', dev ? '--dev' : '', ...followUpCommandArgs].filter(\n      Boolean\n    );\n    if (packageManagerArguments.length) {\n      commandSegments = [...commandSegments, '--', ...packageManagerArguments];\n    }\n\n    Log.log(chalk`\\u203A Running {bold npx expo install} under the updated expo version`);\n    Log.log('> ' + commandSegments.join(' '));\n\n    await spawnAsync('npx', commandSegments, {\n      stdio: 'inherit',\n      cwd: projectRoot,\n      env: { ...process.env },\n    });\n  }\n}\n"],"names":["installExpoPackageAsync","projectRoot","packageManager","packageManagerArguments","expoPackageToInstall","followUpCommandArgs","dev","isExpoMaybeRunningForProject","getRunningProcess","Log","warn","addDevAsync","addAsync","error","chalk","name","length","commandSegments","filter","Boolean","log","join","spawnAsync","stdio","cwd","env","process"],"mappings":";;;;+BAYsBA;;;eAAAA;;;;gEAXC;;;;;;;gEACL;;;;;;6DAEG;mCAEa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAM3B,eAAeA,wBACpBC,WAAmB,EACnB,EACEC,cAAc,EACdC,uBAAuB,EACvBC,oBAAoB,EACpBC,mBAAmB,EACnBC,GAAG,EAWJ;IAED,4FAA4F;IAC5F,mGAAmG;IACnG,MAAMC,+BAA+B,CAAC,CAAE,MAAMC,IAAAA,oCAAiB,EAAC;IAEhE,IAAID,8BAA8B;QAChCE,KAAIC,IAAI,CACN;IAEJ;IAEA,sFAAsF;IACtF,IAAI;QACF,IAAIJ,KAAK;YACP,MAAMJ,eAAeS,WAAW,CAAC;mBAAIR;gBAAyBC;aAAqB;QACrF,OAAO;YACL,MAAMF,eAAeU,QAAQ,CAAC;mBAAIT;gBAAyBC;aAAqB;QAClF;IACF,EAAE,OAAOS,OAAO;QACdJ,KAAII,KAAK,CACPC,IAAAA,gBAAK,CAAA,CAAC,wEAAwE,EAAEZ,eAAea,IAAI,CAAC,4CAA4C,CAAC;QAEnJ,MAAMF;IACR;IAEA,8HAA8H;IAC9H,IAAIR,oBAAoBW,MAAM,EAAE;QAC9B,IAAIC,kBAAkB;YAAC;YAAQ;YAAWX,MAAM,UAAU;eAAOD;SAAoB,CAACa,MAAM,CAC1FC;QAEF,IAAIhB,wBAAwBa,MAAM,EAAE;YAClCC,kBAAkB;mBAAIA;gBAAiB;mBAASd;aAAwB;QAC1E;QAEAM,KAAIW,GAAG,CAACN,IAAAA,gBAAK,CAAA,CAAC,qEAAqE,CAAC;QACpFL,KAAIW,GAAG,CAAC,OAAOH,gBAAgBI,IAAI,CAAC;QAEpC,MAAMC,IAAAA,qBAAU,EAAC,OAAOL,iBAAiB;YACvCM,OAAO;YACPC,KAAKvB;YACLwB,KAAK;gBAAE,GAAGC,QAAQD,GAAG;YAAC;QACxB;IACF;AACF"}

package/build/src/install/resolveOptions.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "resolveArgsAsync", {
+    enumerable: true,
+    get: function() {
+        return resolveArgsAsync;
+    }
+});
+const _errors = require("../utils/errors");
+const _variadic = require("../utils/variadic");
+function resolveOptions(options) {
+    if (options.fix && options.check) {
+        throw new _errors.CommandError('BAD_ARGS', 'Specify at most one of: --check, --fix');
+    }
+    if ([
+        options.npm,
+        options.pnpm,
+        options.yarn,
+        options.bun
+    ].filter(Boolean).length > 1) {
+        throw new _errors.CommandError('BAD_ARGS', 'Specify at most one of: --npm, --pnpm, --yarn, --bun');
+    }
+    if (options.json && !options.check) {
+        throw new _errors.CommandError('BAD_ARGS', 'The --json flag can only be used with --check');
+    }
+    return {
+        ...options
+    };
+}
+async function resolveArgsAsync(argv) {
+    const { variadic, extras, flags } = (0, _variadic.parseVariadicArguments)(argv);
+    (0, _variadic.assertUnexpectedVariadicFlags)([
+        '--check',
+        '--dev',
+        '--fix',
+        '--npm',
+        '--pnpm',
+        '--yarn',
+        '--bun',
+        '--json'
+    ], {
+        variadic,
+        extras,
+        flags
+    }, 'npx expo install');
+    return {
+        // Variadic arguments like `npx expo install react react-dom` -> ['react', 'react-dom']
+        variadic,
+        options: resolveOptions({
+            fix: !!flags['--fix'],
+            dev: !!flags['--dev'],
+            check: !!flags['--check'],
+            yarn: !!flags['--yarn'],
+            npm: !!flags['--npm'],
+            pnpm: !!flags['--pnpm'],
+            bun: !!flags['--bun'],
+            json: !!flags['--json']
+        }),
+        extras
+    };
+}
+
+//# sourceMappingURL=resolveOptions.js.map

package/build/src/install/resolveOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/install/resolveOptions.ts"],"sourcesContent":["import { NodePackageManagerForProject } from '@expo/package-manager';\n\nimport { CommandError } from '../utils/errors';\nimport { assertUnexpectedVariadicFlags, parseVariadicArguments } from '../utils/variadic';\n\nexport type Options = Pick<NodePackageManagerForProject, 'npm' | 'pnpm' | 'yarn' | 'bun'> & {\n  /** Check which packages need to be updated, does not install any provided packages. */\n  check?: boolean;\n  /** Should the dependencies be fixed automatically. */\n  fix?: boolean;\n  /** Should disable install output, used for commands like `prebuild` that run install internally. */\n  silent?: boolean;\n  /** Should be installed as dev dependencies */\n  dev?: boolean;\n  /** Should output in JSON format (use with --check) */\n  json?: boolean;\n};\n\nfunction resolveOptions(options: Options): Options {\n  if (options.fix && options.check) {\n    throw new CommandError('BAD_ARGS', 'Specify at most one of: --check, --fix');\n  }\n  if ([options.npm, options.pnpm, options.yarn, options.bun].filter(Boolean).length > 1) {\n    throw new CommandError('BAD_ARGS', 'Specify at most one of: --npm, --pnpm, --yarn, --bun');\n  }\n  if (options.json && !options.check) {\n    throw new CommandError('BAD_ARGS', 'The --json flag can only be used with --check');\n  }\n  return {\n    ...options,\n  };\n}\n\nexport async function resolveArgsAsync(\n  argv: string[]\n): Promise<{ variadic: string[]; options: Options; extras: string[] }> {\n  const { variadic, extras, flags } = parseVariadicArguments(argv);\n\n  assertUnexpectedVariadicFlags(\n    ['--check', '--dev', '--fix', '--npm', '--pnpm', '--yarn', '--bun', '--json'],\n    { variadic, extras, flags },\n    'npx expo install'\n  );\n\n  return {\n    // Variadic arguments like `npx expo install react react-dom` -> ['react', 'react-dom']\n    variadic,\n    options: resolveOptions({\n      fix: !!flags['--fix'],\n      dev: !!flags['--dev'],\n      check: !!flags['--check'],\n      yarn: !!flags['--yarn'],\n      npm: !!flags['--npm'],\n      pnpm: !!flags['--pnpm'],\n      bun: !!flags['--bun'],\n      json: !!flags['--json'],\n    }),\n    extras,\n  };\n}\n"],"names":["resolveArgsAsync","resolveOptions","options","fix","check","CommandError","npm","pnpm","yarn","bun","filter","Boolean","length","json","argv","variadic","extras","flags","parseVariadicArguments","assertUnexpectedVariadicFlags","dev"],"mappings":";;;;+BAiCsBA;;;eAAAA;;;wBA/BO;0BACyC;AAetE,SAASC,eAAeC,OAAgB;IACtC,IAAIA,QAAQC,GAAG,IAAID,QAAQE,KAAK,EAAE;QAChC,MAAM,IAAIC,oBAAY,CAAC,YAAY;IACrC;IACA,IAAI;QAACH,QAAQI,GAAG;QAAEJ,QAAQK,IAAI;QAAEL,QAAQM,IAAI;QAAEN,QAAQO,GAAG;KAAC,CAACC,MAAM,CAACC,SAASC,MAAM,GAAG,GAAG;QACrF,MAAM,IAAIP,oBAAY,CAAC,YAAY;IACrC;IACA,IAAIH,QAAQW,IAAI,IAAI,CAACX,QAAQE,KAAK,EAAE;QAClC,MAAM,IAAIC,oBAAY,CAAC,YAAY;IACrC;IACA,OAAO;QACL,GAAGH,OAAO;IACZ;AACF;AAEO,eAAeF,iBACpBc,IAAc;IAEd,MAAM,EAAEC,QAAQ,EAAEC,MAAM,EAAEC,KAAK,EAAE,GAAGC,IAAAA,gCAAsB,EAACJ;IAE3DK,IAAAA,uCAA6B,EAC3B;QAAC;QAAW;QAAS;QAAS;QAAS;QAAU;QAAU;QAAS;KAAS,EAC7E;QAAEJ;QAAUC;QAAQC;IAAM,GAC1B;IAGF,OAAO;QACL,uFAAuF;QACvFF;QACAb,SAASD,eAAe;YACtBE,KAAK,CAAC,CAACc,KAAK,CAAC,QAAQ;YACrBG,KAAK,CAAC,CAACH,KAAK,CAAC,QAAQ;YACrBb,OAAO,CAAC,CAACa,KAAK,CAAC,UAAU;YACzBT,MAAM,CAAC,CAACS,KAAK,CAAC,SAAS;YACvBX,KAAK,CAAC,CAACW,KAAK,CAAC,QAAQ;YACrBV,MAAM,CAAC,CAACU,KAAK,CAAC,SAAS;YACvBR,KAAK,CAAC,CAACQ,KAAK,CAAC,QAAQ;YACrBJ,MAAM,CAAC,CAACI,KAAK,CAAC,SAAS;QACzB;QACAD;IACF;AACF"}

package/build/src/install/utils/autoAddConfigPlugins.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    autoAddConfigPluginsAsync: function() {
+        return autoAddConfigPluginsAsync;
+    },
+    getNamedPlugins: function() {
+        return getNamedPlugins;
+    }
+});
+function _pluginresolver() {
+    const data = require("@expo/config-plugins/build/utils/plugin-resolver");
+    _pluginresolver = function() {
+        return data;
+    };
+    return data;
+}
+function _prebuildconfig() {
+    const data = require("@expo/prebuild-config");
+    _prebuildconfig = function() {
+        return data;
+    };
+    return data;
+}
+const _modifyConfigPlugins = require("../../utils/modifyConfigPlugins");
+const debug = require('debug')('expo:install:config-plugins');
+const AUTO_PLUGINS = (0, _prebuildconfig().getAutoPlugins)();
+/**
+ * Resolve if a package has a config plugin.
+ * For sanity, we'll only support config plugins that use the `app.config.js` entry file,
+ * this is because a package like `lodash` could be a "valid" config plugin and break the prebuild process.
+ *
+ * @param projectRoot
+ * @param packageName
+ * @returns
+ */ function packageHasConfigPlugin(projectRoot, packageName) {
+    try {
+        const info = (0, _pluginresolver().resolveConfigPluginFunctionWithInfo)(projectRoot, packageName);
+        if (info.isPluginFile) {
+            return info.plugin;
+        }
+    } catch  {}
+    return false;
+}
+function getNamedPlugins(plugins) {
+    const namedPlugins = [];
+    for (const plugin of plugins){
+        try {
+            // @ts-ignore
+            const [normal] = (0, _pluginresolver().normalizeStaticPlugin)(plugin);
+            if (typeof normal === 'string') {
+                namedPlugins.push(normal);
+            }
+        } catch  {
+        // ignore assertions
+        }
+    }
+    return namedPlugins;
+}
+async function autoAddConfigPluginsAsync(projectRoot, exp, packages) {
+    debug('Checking config plugins...');
+    const currentPlugins = exp.plugins || [];
+    const normalized = getNamedPlugins(currentPlugins);
+    debug(`Existing plugins: ${normalized.join(', ')}`);
+    const plugins = packages.filter((pkg)=>{
+        if (normalized.includes(pkg)) {
+            // already included in plugins array
+            return false;
+        }
+        // Check if the package has a valid plugin. Must be a well-made plugin for it to work with this.
+        const plugin = packageHasConfigPlugin(projectRoot, pkg);
+        debug(`Package "${pkg}" has plugin: ${!!plugin}` + (plugin ? ` (args: ${plugin.length})` : ''));
+        if (AUTO_PLUGINS.includes(pkg)) {
+            debug(`Package "${pkg}" is an auto plugin, skipping...`);
+            return false;
+        }
+        return !!plugin;
+    });
+    await (0, _modifyConfigPlugins.attemptAddingPluginsAsync)(projectRoot, plugins);
+}
+
+//# sourceMappingURL=autoAddConfigPlugins.js.map

package/build/src/install/utils/autoAddConfigPlugins.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/install/utils/autoAddConfigPlugins.ts"],"sourcesContent":["import { ExpoConfig } from '@expo/config';\nimport {\n  normalizeStaticPlugin,\n  resolveConfigPluginFunctionWithInfo,\n} from '@expo/config-plugins/build/utils/plugin-resolver';\nimport { getAutoPlugins } from '@expo/prebuild-config';\n\nimport { attemptAddingPluginsAsync } from '../../utils/modifyConfigPlugins';\n\nconst debug = require('debug')('expo:install:config-plugins') as typeof console.log;\n\nconst AUTO_PLUGINS = getAutoPlugins();\n\n/**\n * Resolve if a package has a config plugin.\n * For sanity, we'll only support config plugins that use the `app.config.js` entry file,\n * this is because a package like `lodash` could be a \"valid\" config plugin and break the prebuild process.\n *\n * @param projectRoot\n * @param packageName\n * @returns\n */\nfunction packageHasConfigPlugin(projectRoot: string, packageName: string) {\n  try {\n    const info = resolveConfigPluginFunctionWithInfo(projectRoot, packageName);\n    if (info.isPluginFile) {\n      return info.plugin;\n    }\n  } catch {}\n  return false;\n}\n\n/**\n * Get a list of plugins that were are supplied as string module IDs.\n * @example\n * ```json\n * {\n *   \"plugins\": [\n *     \"expo-camera\",\n *     [\"react-native-firebase\", ...]\n *   ]\n * }\n * ```\n *   ↓ ↓ ↓ ↓ ↓ ↓\n *\n * `['expo-camera', 'react-native-firebase']`\n *\n */\nexport function getNamedPlugins(plugins: NonNullable<ExpoConfig['plugins']>): string[] {\n  const namedPlugins: string[] = [];\n  for (const plugin of plugins) {\n    try {\n      // @ts-ignore\n      const [normal] = normalizeStaticPlugin(plugin);\n      if (typeof normal === 'string') {\n        namedPlugins.push(normal);\n      }\n    } catch {\n      // ignore assertions\n    }\n  }\n  return namedPlugins;\n}\n\n/** Attempts to ensure that non-auto plugins are added to the `app.json` `plugins` array when modules with Expo Config Plugins are installed. */\nexport async function autoAddConfigPluginsAsync(\n  projectRoot: string,\n  exp: Pick<ExpoConfig, 'plugins'>,\n  packages: string[]\n) {\n  debug('Checking config plugins...');\n\n  const currentPlugins = exp.plugins || [];\n  const normalized = getNamedPlugins(currentPlugins);\n\n  debug(`Existing plugins: ${normalized.join(', ')}`);\n\n  const plugins = packages.filter((pkg) => {\n    if (normalized.includes(pkg)) {\n      // already included in plugins array\n      return false;\n    }\n    // Check if the package has a valid plugin. Must be a well-made plugin for it to work with this.\n    const plugin = packageHasConfigPlugin(projectRoot, pkg);\n\n    debug(`Package \"${pkg}\" has plugin: ${!!plugin}` + (plugin ? ` (args: ${plugin.length})` : ''));\n\n    if (AUTO_PLUGINS.includes(pkg)) {\n      debug(`Package \"${pkg}\" is an auto plugin, skipping...`);\n      return false;\n    }\n\n    return !!plugin;\n  });\n\n  await attemptAddingPluginsAsync(projectRoot, plugins);\n}\n"],"names":["autoAddConfigPluginsAsync","getNamedPlugins","debug","require","AUTO_PLUGINS","getAutoPlugins","packageHasConfigPlugin","projectRoot","packageName","info","resolveConfigPluginFunctionWithInfo","isPluginFile","plugin","plugins","namedPlugins","normal","normalizeStaticPlugin","push","exp","packages","currentPlugins","normalized","join","filter","pkg","includes","length","attemptAddingPluginsAsync"],"mappings":";;;;;;;;;;;IAiEsBA,yBAAyB;eAAzBA;;IAjBNC,eAAe;eAAfA;;;;yBA5CT;;;;;;;yBACwB;;;;;;qCAEW;AAE1C,MAAMC,QAAQC,QAAQ,SAAS;AAE/B,MAAMC,eAAeC,IAAAA,gCAAc;AAEnC;;;;;;;;CAQC,GACD,SAASC,uBAAuBC,WAAmB,EAAEC,WAAmB;IACtE,IAAI;QACF,MAAMC,OAAOC,IAAAA,qDAAmC,EAACH,aAAaC;QAC9D,IAAIC,KAAKE,YAAY,EAAE;YACrB,OAAOF,KAAKG,MAAM;QACpB;IACF,EAAE,OAAM,CAAC;IACT,OAAO;AACT;AAkBO,SAASX,gBAAgBY,OAA2C;IACzE,MAAMC,eAAyB,EAAE;IACjC,KAAK,MAAMF,UAAUC,QAAS;QAC5B,IAAI;YACF,aAAa;YACb,MAAM,CAACE,OAAO,GAAGC,IAAAA,uCAAqB,EAACJ;YACvC,IAAI,OAAOG,WAAW,UAAU;gBAC9BD,aAAaG,IAAI,CAACF;YACpB;QACF,EAAE,OAAM;QACN,oBAAoB;QACtB;IACF;IACA,OAAOD;AACT;AAGO,eAAed,0BACpBO,WAAmB,EACnBW,GAAgC,EAChCC,QAAkB;IAElBjB,MAAM;IAEN,MAAMkB,iBAAiBF,IAAIL,OAAO,IAAI,EAAE;IACxC,MAAMQ,aAAapB,gBAAgBmB;IAEnClB,MAAM,CAAC,kBAAkB,EAAEmB,WAAWC,IAAI,CAAC,OAAO;IAElD,MAAMT,UAAUM,SAASI,MAAM,CAAC,CAACC;QAC/B,IAAIH,WAAWI,QAAQ,CAACD,MAAM;YAC5B,oCAAoC;YACpC,OAAO;QACT;QACA,gGAAgG;QAChG,MAAMZ,SAASN,uBAAuBC,aAAaiB;QAEnDtB,MAAM,CAAC,SAAS,EAAEsB,IAAI,cAAc,EAAE,CAAC,CAACZ,QAAQ,GAAIA,CAAAA,SAAS,CAAC,QAAQ,EAAEA,OAAOc,MAAM,CAAC,CAAC,CAAC,GAAG,EAAC;QAE5F,IAAItB,aAAaqB,QAAQ,CAACD,MAAM;YAC9BtB,MAAM,CAAC,SAAS,EAAEsB,IAAI,gCAAgC,CAAC;YACvD,OAAO;QACT;QAEA,OAAO,CAAC,CAACZ;IACX;IAEA,MAAMe,IAAAA,8CAAyB,EAACpB,aAAaM;AAC/C"}

package/build/src/install/utils/checkPackagesCompatibility.js

@@ -0,0 +1,66 @@
+// note(Simek): https://github.com/react-native-community/directory/blob/main/pages/api/libraries/check.ts
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "checkPackagesCompatibility", {
+    enumerable: true,
+    get: function() {
+        return checkPackagesCompatibility;
+    }
+});
+function _chalk() {
+    const data = /*#__PURE__*/ _interop_require_default(require("chalk"));
+    _chalk = function() {
+        return data;
+    };
+    return data;
+}
+const _log = require("../../log");
+const _fetch = require("../../utils/fetch");
+const _link = require("../../utils/link");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const ERROR_MESSAGE = 'Unable to fetch compatibility data from React Native Directory. Skipping check.';
+async function checkPackagesCompatibility(packages) {
+    try {
+        const packagesToCheck = packages.filter((packageName)=>!packageName.startsWith('@expo/') && !packageName.startsWith('@expo-google-fonts/'));
+        if (!packagesToCheck.length) {
+            return;
+        }
+        const response = await (0, _fetch.fetch)('https://reactnative.directory/api/libraries/check', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                packages: packagesToCheck
+            })
+        });
+        if (!response.ok) {
+            _log.Log.log(_chalk().default.gray(ERROR_MESSAGE));
+        }
+        const packageMetadata = await response.json();
+        const incompatiblePackages = packagesToCheck.filter((packageName)=>{
+            var _packageMetadata_packageName;
+            return ((_packageMetadata_packageName = packageMetadata[packageName]) == null ? void 0 : _packageMetadata_packageName.newArchitecture) === 'unsupported';
+        });
+        if (incompatiblePackages.length) {
+            _log.Log.warn(_chalk().default.yellow(`${_chalk().default.bold('Warning')}: ${formatPackageNames(incompatiblePackages)} do${incompatiblePackages.length > 1 ? '' : 'es'} not support the New Architecture. ${(0, _link.learnMore)('https://docs.expo.dev/guides/new-architecture/')}`));
+        }
+    } catch  {
+        _log.Log.log(_chalk().default.gray(ERROR_MESSAGE));
+    }
+}
+function formatPackageNames(incompatiblePackages) {
+    if (incompatiblePackages.length === 1) {
+        return incompatiblePackages.join();
+    }
+    const lastPackage = incompatiblePackages.pop();
+    return `${incompatiblePackages.join(', ')} and ${lastPackage}`;
+}
+
+//# sourceMappingURL=checkPackagesCompatibility.js.map

package/build/src/install/utils/checkPackagesCompatibility.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/install/utils/checkPackagesCompatibility.ts"],"sourcesContent":["// note(Simek): https://github.com/react-native-community/directory/blob/main/pages/api/libraries/check.ts\nimport chalk from 'chalk';\n\nimport { Log } from '../../log';\nimport { fetch } from '../../utils/fetch';\nimport { learnMore } from '../../utils/link';\n\nexport type ReactNativeDirectoryCheckResult = {\n  unmaintained: boolean;\n  newArchitecture: 'supported' | 'unsupported' | 'untested';\n};\n\nconst ERROR_MESSAGE =\n  'Unable to fetch compatibility data from React Native Directory. Skipping check.';\n\nexport async function checkPackagesCompatibility(packages: string[]) {\n  try {\n    const packagesToCheck = packages.filter(\n      (packageName) =>\n        !packageName.startsWith('@expo/') && !packageName.startsWith('@expo-google-fonts/')\n    );\n\n    if (!packagesToCheck.length) {\n      return;\n    }\n\n    const response = await fetch('https://reactnative.directory/api/libraries/check', {\n      method: 'POST',\n      headers: {\n        'Content-Type': 'application/json',\n      },\n      body: JSON.stringify({ packages: packagesToCheck }),\n    });\n\n    if (!response.ok) {\n      Log.log(chalk.gray(ERROR_MESSAGE));\n    }\n\n    const packageMetadata = (await response.json()) as Record<\n      string,\n      ReactNativeDirectoryCheckResult\n    >;\n\n    const incompatiblePackages = packagesToCheck.filter(\n      (packageName) => packageMetadata[packageName]?.newArchitecture === 'unsupported'\n    );\n\n    if (incompatiblePackages.length) {\n      Log.warn(\n        chalk.yellow(\n          `${chalk.bold('Warning')}: ${formatPackageNames(incompatiblePackages)} do${incompatiblePackages.length > 1 ? '' : 'es'} not support the New Architecture. ${learnMore('https://docs.expo.dev/guides/new-architecture/')}`\n        )\n      );\n    }\n  } catch {\n    Log.log(chalk.gray(ERROR_MESSAGE));\n  }\n}\n\nfunction formatPackageNames(incompatiblePackages: string[]) {\n  if (incompatiblePackages.length === 1) {\n    return incompatiblePackages.join();\n  }\n\n  const lastPackage = incompatiblePackages.pop();\n  return `${incompatiblePackages.join(', ')} and ${lastPackage}`;\n}\n"],"names":["checkPackagesCompatibility","ERROR_MESSAGE","packages","packagesToCheck","filter","packageName","startsWith","length","response","fetch","method","headers","body","JSON","stringify","ok","Log","log","chalk","gray","packageMetadata","json","incompatiblePackages","newArchitecture","warn","yellow","bold","formatPackageNames","learnMore","join","lastPackage","pop"],"mappings":"AAAA,0GAA0G;;;;;+BAepFA;;;eAAAA;;;;gEAdJ;;;;;;qBAEE;uBACE;sBACI;;;;;;AAO1B,MAAMC,gBACJ;AAEK,eAAeD,2BAA2BE,QAAkB;IACjE,IAAI;QACF,MAAMC,kBAAkBD,SAASE,MAAM,CACrC,CAACC,cACC,CAACA,YAAYC,UAAU,CAAC,aAAa,CAACD,YAAYC,UAAU,CAAC;QAGjE,IAAI,CAACH,gBAAgBI,MAAM,EAAE;YAC3B;QACF;QAEA,MAAMC,WAAW,MAAMC,IAAAA,YAAK,EAAC,qDAAqD;YAChFC,QAAQ;YACRC,SAAS;gBACP,gBAAgB;YAClB;YACAC,MAAMC,KAAKC,SAAS,CAAC;gBAAEZ,UAAUC;YAAgB;QACnD;QAEA,IAAI,CAACK,SAASO,EAAE,EAAE;YAChBC,QAAG,CAACC,GAAG,CAACC,gBAAK,CAACC,IAAI,CAAClB;QACrB;QAEA,MAAMmB,kBAAmB,MAAMZ,SAASa,IAAI;QAK5C,MAAMC,uBAAuBnB,gBAAgBC,MAAM,CACjD,CAACC;gBAAgBe;mBAAAA,EAAAA,+BAAAA,eAAe,CAACf,YAAY,qBAA5Be,6BAA8BG,eAAe,MAAK;;QAGrE,IAAID,qBAAqBf,MAAM,EAAE;YAC/BS,QAAG,CAACQ,IAAI,CACNN,gBAAK,CAACO,MAAM,CACV,GAAGP,gBAAK,CAACQ,IAAI,CAAC,WAAW,EAAE,EAAEC,mBAAmBL,sBAAsB,GAAG,EAAEA,qBAAqBf,MAAM,GAAG,IAAI,KAAK,KAAK,mCAAmC,EAAEqB,IAAAA,eAAS,EAAC,mDAAmD;QAG/N;IACF,EAAE,OAAM;QACNZ,QAAG,CAACC,GAAG,CAACC,gBAAK,CAACC,IAAI,CAAClB;IACrB;AACF;AAEA,SAAS0B,mBAAmBL,oBAA8B;IACxD,IAAIA,qBAAqBf,MAAM,KAAK,GAAG;QACrC,OAAOe,qBAAqBO,IAAI;IAClC;IAEA,MAAMC,cAAcR,qBAAqBS,GAAG;IAC5C,OAAO,GAAGT,qBAAqBO,IAAI,CAAC,MAAM,KAAK,EAAEC,aAAa;AAChE"}

package/build/src/install/utils/parsePackageSpecifier.js

@@ -0,0 +1,24 @@
+/** Accepts a package name (scoped or unscoped) and optionally with a specifier */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "parsePackageSpecifier", {
+    enumerable: true,
+    get: function() {
+        return parsePackageSpecifier;
+    }
+});
+function parsePackageSpecifier(specifier) {
+    let idx = -1;
+    if (specifier[0] === '@') {
+        idx = specifier.indexOf('/', 1);
+        if (idx === -1 || specifier.length - 1 <= idx) {
+            return null;
+        }
+    }
+    idx = specifier.indexOf('@', idx + 1);
+    const packageName = idx > -1 ? specifier.slice(0, idx) : specifier;
+    return packageName.length > 0 ? packageName : null;
+}
+
+//# sourceMappingURL=parsePackageSpecifier.js.map

package/build/src/install/utils/parsePackageSpecifier.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/install/utils/parsePackageSpecifier.ts"],"sourcesContent":["/** Accepts a package name (scoped or unscoped) and optionally with a specifier */\nexport function parsePackageSpecifier(specifier: string): string | null {\n  let idx = -1;\n  if (specifier[0] === '@') {\n    idx = specifier.indexOf('/', 1);\n    if (idx === -1 || specifier.length - 1 <= idx) {\n      return null;\n    }\n  }\n  idx = specifier.indexOf('@', idx + 1);\n  const packageName = idx > -1 ? specifier.slice(0, idx) : specifier;\n  return packageName.length > 0 ? packageName : null;\n}\n"],"names":["parsePackageSpecifier","specifier","idx","indexOf","length","packageName","slice"],"mappings":"AAAA,gFAAgF;;;;+BAChEA;;;eAAAA;;;AAAT,SAASA,sBAAsBC,SAAiB;IACrD,IAAIC,MAAM,CAAC;IACX,IAAID,SAAS,CAAC,EAAE,KAAK,KAAK;QACxBC,MAAMD,UAAUE,OAAO,CAAC,KAAK;QAC7B,IAAID,QAAQ,CAAC,KAAKD,UAAUG,MAAM,GAAG,KAAKF,KAAK;YAC7C,OAAO;QACT;IACF;IACAA,MAAMD,UAAUE,OAAO,CAAC,KAAKD,MAAM;IACnC,MAAMG,cAAcH,MAAM,CAAC,IAAID,UAAUK,KAAK,CAAC,GAAGJ,OAAOD;IACzD,OAAOI,YAAYD,MAAM,GAAG,IAAIC,cAAc;AAChD"}

package/build/src/lint/ESlintPrerequisite.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ESLintProjectPrerequisite", {
+    enumerable: true,
+    get: function() {
+        return ESLintProjectPrerequisite;
+    }
+});
+function _jsonfile() {
+    const data = /*#__PURE__*/ _interop_require_default(require("@expo/json-file"));
+    _jsonfile = function() {
+        return data;
+    };
+    return data;
+}
+function _promises() {
+    const data = /*#__PURE__*/ _interop_require_default(require("fs/promises"));
+    _promises = function() {
+        return data;
+    };
+    return data;
+}
+function _path() {
+    const data = /*#__PURE__*/ _interop_require_default(require("path"));
+    _path = function() {
+        return data;
+    };
+    return data;
+}
+const _log = require("../log");
+const _Prerequisite = require("../start/doctor/Prerequisite");
+const _ensureDependenciesAsync = require("../start/doctor/dependencies/ensureDependenciesAsync");
+const _findUp = require("../utils/findUp");
+const _interactive = require("../utils/interactive");
+const _prompts = require("../utils/prompts");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const debug = require('debug')('expo:lint');
+class ESLintProjectPrerequisite extends _Prerequisite.ProjectPrerequisite {
+    async assertImplementation() {
+        const hasEslintConfig = await isEslintConfigured(this.projectRoot);
+        const hasLegacyConfig = await isLegacyEslintConfigured(this.projectRoot);
+        const hasLintScript = await lintScriptIsConfigured(this.projectRoot);
+        if (hasLegacyConfig) {
+            _log.Log.warn(`Using legacy ESLint config. Consider upgrading to flat config.`);
+        }
+        return (hasEslintConfig || hasLegacyConfig) && hasLintScript;
+    }
+    async bootstrapAsync() {
+        debug('Setting up ESLint');
+        const hasEslintConfig = await isEslintConfigured(this.projectRoot);
+        if (!hasEslintConfig) {
+            if (!(0, _interactive.isInteractive)()) {
+                _log.Log.warn(`No ESLint config found. Configuring automatically.`);
+            } else {
+                const shouldSetupLint = await (0, _prompts.confirmAsync)({
+                    message: 'No ESLint config found. Install and configure ESLint in this project?'
+                });
+                if (!shouldSetupLint) {
+                    throw new _Prerequisite.PrerequisiteCommandError('ESLint is not configured for this project.');
+                }
+            }
+            await this._ensureDependenciesInstalledAsync({
+                skipPrompt: true,
+                isProjectMutable: true
+            });
+            await _promises().default.writeFile(_path().default.join(this.projectRoot, 'eslint.config.js'), await _promises().default.readFile(require.resolve(`@expo/cli/static/template/eslint.config.js`), 'utf8'), 'utf8');
+        }
+        const hasLintScript = await lintScriptIsConfigured(this.projectRoot);
+        if (!hasLintScript) {
+            const scripts = _jsonfile().default.read(_path().default.join(this.projectRoot, 'package.json')).scripts;
+            await _jsonfile().default.setAsync(_path().default.join(this.projectRoot, 'package.json'), 'scripts', typeof scripts === 'object' ? {
+                ...scripts,
+                lint: 'expo lint'
+            } : {
+                lint: 'expo lint'
+            }, {
+                json5: false
+            });
+        }
+        _log.Log.log();
+        _log.Log.log('ESLint has been configured 🎉');
+        _log.Log.log();
+        return true;
+    }
+    async _ensureDependenciesInstalledAsync({ skipPrompt, isProjectMutable }) {
+        try {
+            return await (0, _ensureDependenciesAsync.ensureDependenciesAsync)(this.projectRoot, {
+                skipPrompt,
+                isProjectMutable,
+                installMessage: 'ESLint is required to lint your project.',
+                warningMessage: 'ESLint not installed, unable to set up linting for your project.',
+                requiredPackages: [
+                    {
+                        version: '^9.0.0',
+                        pkg: 'eslint',
+                        file: 'eslint/package.json',
+                        dev: true
+                    },
+                    {
+                        pkg: 'eslint-config-expo',
+                        file: 'eslint-config-expo/package.json',
+                        dev: true
+                    }
+                ]
+            });
+        } catch (error) {
+            this.resetAssertion();
+            throw error;
+        }
+    }
+}
+async function isLegacyEslintConfigured(projectRoot) {
+    debug('Checking for legacy ESLint configuration', projectRoot);
+    const packageFile = await _jsonfile().default.readAsync(_path().default.join(projectRoot, 'package.json'));
+    if (typeof packageFile.eslintConfig === 'object' && Object.keys(packageFile.eslintConfig).length > 0) {
+        debug('Found legacy ESLint config in package.json');
+        return true;
+    }
+    const eslintConfigFiles = [
+        '.eslintrc.js',
+        '.eslintrc.cjs',
+        '.eslintrc.yaml',
+        '.eslintrc.yml',
+        '.eslintrc.json'
+    ];
+    for (const configFile of eslintConfigFiles){
+        const configPath = (0, _findUp.findFileInParents)(projectRoot, configFile);
+        if (configPath) {
+            debug('Found ESLint config file:', configPath);
+            return true;
+        }
+    }
+    return false;
+}
+/** Check for flat config. */ async function isEslintConfigured(projectRoot) {
+    debug('Ensuring ESLint is configured in', projectRoot);
+    const eslintConfigFiles = [
+        'eslint.config.js',
+        'eslint.config.mjs',
+        'eslint.config.cjs'
+    ];
+    for (const configFile of eslintConfigFiles){
+        const configPath = (0, _findUp.findFileInParents)(projectRoot, configFile);
+        if (configPath) {
+            debug('Found ESLint config file:', configPath);
+            return true;
+        }
+    }
+    return false;
+}
+async function lintScriptIsConfigured(projectRoot) {
+    var _packageFile_scripts;
+    const packageFile = await _jsonfile().default.readAsync(_path().default.join(projectRoot, 'package.json'));
+    return typeof ((_packageFile_scripts = packageFile.scripts) == null ? void 0 : _packageFile_scripts.lint) === 'string';
+}
+
+//# sourceMappingURL=ESlintPrerequisite.js.map

package/build/src/lint/ESlintPrerequisite.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lint/ESlintPrerequisite.ts"],"sourcesContent":["import JsonFile, { JSONObject } from '@expo/json-file';\nimport fs from 'fs/promises';\nimport path from 'path';\n\nimport { Log } from '../log';\nimport { PrerequisiteCommandError, ProjectPrerequisite } from '../start/doctor/Prerequisite';\nimport { ensureDependenciesAsync } from '../start/doctor/dependencies/ensureDependenciesAsync';\nimport { findFileInParents } from '../utils/findUp';\nimport { isInteractive } from '../utils/interactive';\nimport { confirmAsync } from '../utils/prompts';\n\nconst debug = require('debug')('expo:lint') as typeof console.log;\n\n/** Ensure the project has the required ESLint config. */\nexport class ESLintProjectPrerequisite extends ProjectPrerequisite<boolean> {\n  async assertImplementation(): Promise<boolean> {\n    const hasEslintConfig = await isEslintConfigured(this.projectRoot);\n    const hasLegacyConfig = await isLegacyEslintConfigured(this.projectRoot);\n    const hasLintScript = await lintScriptIsConfigured(this.projectRoot);\n\n    if (hasLegacyConfig) {\n      Log.warn(`Using legacy ESLint config. Consider upgrading to flat config.`);\n    }\n\n    return (hasEslintConfig || hasLegacyConfig) && hasLintScript;\n  }\n\n  async bootstrapAsync(): Promise<boolean> {\n    debug('Setting up ESLint');\n\n    const hasEslintConfig = await isEslintConfigured(this.projectRoot);\n    if (!hasEslintConfig) {\n      if (!isInteractive()) {\n        Log.warn(`No ESLint config found. Configuring automatically.`);\n      } else {\n        const shouldSetupLint = await confirmAsync({\n          message: 'No ESLint config found. Install and configure ESLint in this project?',\n        });\n        if (!shouldSetupLint) {\n          throw new PrerequisiteCommandError('ESLint is not configured for this project.');\n        }\n      }\n\n      await this._ensureDependenciesInstalledAsync({ skipPrompt: true, isProjectMutable: true });\n\n      await fs.writeFile(\n        path.join(this.projectRoot, 'eslint.config.js'),\n        await fs.readFile(require.resolve(`@expo/cli/static/template/eslint.config.js`), 'utf8'),\n        'utf8'\n      );\n    }\n\n    const hasLintScript = await lintScriptIsConfigured(this.projectRoot);\n    if (!hasLintScript) {\n      const scripts = JsonFile.read(path.join(this.projectRoot, 'package.json')).scripts;\n      await JsonFile.setAsync(\n        path.join(this.projectRoot, 'package.json'),\n        'scripts',\n        typeof scripts === 'object' ? { ...scripts, lint: 'expo lint' } : { lint: 'expo lint' },\n        { json5: false }\n      );\n    }\n\n    Log.log();\n    Log.log('ESLint has been configured 🎉');\n    Log.log();\n\n    return true;\n  }\n\n  async _ensureDependenciesInstalledAsync({\n    skipPrompt,\n    isProjectMutable,\n  }: {\n    skipPrompt?: boolean;\n    isProjectMutable?: boolean;\n  }): Promise<boolean> {\n    try {\n      return await ensureDependenciesAsync(this.projectRoot, {\n        skipPrompt,\n        isProjectMutable,\n        installMessage: 'ESLint is required to lint your project.',\n        warningMessage: 'ESLint not installed, unable to set up linting for your project.',\n        requiredPackages: [\n          { version: '^9.0.0', pkg: 'eslint', file: 'eslint/package.json', dev: true },\n          {\n            pkg: 'eslint-config-expo',\n            file: 'eslint-config-expo/package.json',\n            dev: true,\n          },\n        ],\n      });\n    } catch (error) {\n      this.resetAssertion();\n      throw error;\n    }\n  }\n}\n\nasync function isLegacyEslintConfigured(projectRoot: string) {\n  debug('Checking for legacy ESLint configuration', projectRoot);\n\n  const packageFile = await JsonFile.readAsync(path.join(projectRoot, 'package.json'));\n  if (\n    typeof packageFile.eslintConfig === 'object' &&\n    Object.keys(packageFile.eslintConfig as JSONObject).length > 0\n  ) {\n    debug('Found legacy ESLint config in package.json');\n    return true;\n  }\n\n  const eslintConfigFiles = [\n    '.eslintrc.js',\n    '.eslintrc.cjs',\n    '.eslintrc.yaml',\n    '.eslintrc.yml',\n    '.eslintrc.json',\n  ];\n  for (const configFile of eslintConfigFiles) {\n    const configPath = findFileInParents(projectRoot, configFile);\n\n    if (configPath) {\n      debug('Found ESLint config file:', configPath);\n      return true;\n    }\n  }\n\n  return false;\n}\n\n/** Check for flat config. */\nasync function isEslintConfigured(projectRoot: string) {\n  debug('Ensuring ESLint is configured in', projectRoot);\n\n  const eslintConfigFiles = ['eslint.config.js', 'eslint.config.mjs', 'eslint.config.cjs'];\n  for (const configFile of eslintConfigFiles) {\n    const configPath = findFileInParents(projectRoot, configFile);\n\n    if (configPath) {\n      debug('Found ESLint config file:', configPath);\n      return true;\n    }\n  }\n\n  return false;\n}\n\nasync function lintScriptIsConfigured(projectRoot: string) {\n  const packageFile = await JsonFile.readAsync(path.join(projectRoot, 'package.json'));\n  return typeof (packageFile.scripts as JSONObject | undefined)?.lint === 'string';\n}\n"],"names":["ESLintProjectPrerequisite","debug","require","ProjectPrerequisite","assertImplementation","hasEslintConfig","isEslintConfigured","projectRoot","hasLegacyConfig","isLegacyEslintConfigured","hasLintScript","lintScriptIsConfigured","Log","warn","bootstrapAsync","isInteractive","shouldSetupLint","confirmAsync","message","PrerequisiteCommandError","_ensureDependenciesInstalledAsync","skipPrompt","isProjectMutable","fs","writeFile","path","join","readFile","resolve","scripts","JsonFile","read","setAsync","lint","json5","log","ensureDependenciesAsync","installMessage","warningMessage","requiredPackages","version","pkg","file","dev","error","resetAssertion","packageFile","readAsync","eslintConfig","Object","keys","length","eslintConfigFiles","configFile","configPath","findFileInParents"],"mappings":"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"}