@expo/cli 55.0.7 → 55.0.9

package/build/src/utils/getRunningProcess.js

@@ -15,13 +15,16 @@ _export(exports, {
     getPID: function() {
         return getPID;
     },
+    getProcessCommand: function() {
+        return getProcessCommand;
+    },
     getRunningProcess: function() {
         return getRunningProcess;
     }
 });
-function _child_process() {
-    const data = require("child_process");
-    _child_process = function() {
+function _spawnasync() {
+    const data = /*#__PURE__*/ _interop_require_default(require("@expo/spawn-async"));
+    _spawnasync = function() {
         return data;
     };
     return data;
@@ -33,6 +36,11 @@ function _path() {
     };
     return data;
 }
+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();
@@ -75,68 +83,99 @@ function _interop_require_wildcard(obj, nodeInterop) {
     return newObj;
 }
 const debug = require('debug')('expo:utils:getRunningProcess');
-const defaultOptions = {
-    encoding: 'utf8',
-    stdio: [
-        'pipe',
-        'pipe',
-        'ignore'
-    ]
-};
-function getPID(port) {
+/** Timeout applied to shell commands */ const timeout = 350;
+async function getPID(port) {
     try {
-        const results = (0, _child_process().execFileSync)('lsof', [
+        const { stdout } = await (0, _spawnasync().default)('lsof', [
             `-i:${port}`,
             '-P',
             '-t',
             '-sTCP:LISTEN'
-        ], defaultOptions).split('\n')[0].trim();
-        const pid = Number(results);
+        ], {
+            timeout
+        });
+        const pid = Number(stdout.split('\n', 1)[0].trim());
         debug(`pid: ${pid} for port: ${port}`);
-        return pid;
+        return Number.isSafeInteger(pid) ? pid : null;
     } catch (error) {
         debug(`No pid found for port: ${port}. Error: ${error}`);
         return null;
     }
 }
 /** Get `package.json` `name` field for a given directory. Returns `null` if none exist. */ function getPackageName(packageRoot) {
-    const packageJson = _path().join(packageRoot, 'package.json');
     try {
+        const packageJson = _path().resolve(packageRoot, 'package.json');
         return require(packageJson).name || null;
-    } catch  {
+    } catch (error) {
         return null;
     }
 }
-/** Returns a command like `node /Users/evanbacon/.../bin/expo start` or the package.json name. */ function getProcessCommand(pid, procDirectory) {
-    const name = getPackageName(procDirectory);
-    if (name) {
-        return name;
+async function getProcessCommand(pid, procDirectory) {
+    let name = getPackageName(procDirectory);
+    if (!name) {
+        // ps
+        // -o args=: Output argv without header
+        // -p [pid]: For process of PID
+        const { stdout } = await (0, _spawnasync().default)('ps', [
+            '-o',
+            'args=',
+            '-p',
+            `${pid}`
+        ], {
+            timeout
+        });
+        name = stdout.trim();
     }
-    return (0, _child_process().execSync)(`ps -o command -p ${pid} | sed -n 2p`, defaultOptions).replace(/\n$/, '').trim();
+    return name || null;
 }
-function getDirectoryOfProcessById(processId) {
-    return (0, _child_process().execSync)(`lsof -p ${processId} | awk '$4=="cwd" {for (i=9; i<=NF; i++) printf "%s ", $i}'`, defaultOptions).trim();
+async function getDirectoryOfProcessById(pid) {
+    try {
+        var _stdout_split_find;
+        // lsof
+        // -F n: ask for machine readable output
+        // -a: apply conditions as logical AND
+        // -d cwd: Filter by cwd fd
+        // -p [pid]: Filter by input process id
+        const { stdout } = await (0, _spawnasync().default)('lsof', [
+            '-F',
+            'n',
+            '-a',
+            '-d',
+            'cwd',
+            '-p',
+            `${pid}`
+        ], {
+            timeout
+        });
+        const processCWD = (_stdout_split_find = stdout.split('\n').find((output)=>output.startsWith('n'))) == null ? void 0 : _stdout_split_find.slice(1);
+        return processCWD && _path().isAbsolute(processCWD) ? _path().normalize(processCWD) : null;
+    } catch  {
+        return null;
+    }
 }
-function getRunningProcess(port) {
-    // 63828
-    const pid = getPID(port);
-    if (!pid) {
+async function getRunningProcess(port) {
+    // Don't even try on Windows, since `lsof` and `ps` are not available there
+    if (process.platform === 'win32') {
         return null;
     }
-    try {
-        // /Users/evanbacon/Documents/GitHub/lab/myapp
-        const directory = getDirectoryOfProcessById(pid);
-        // /Users/evanbacon/Documents/GitHub/lab/myapp/package.json
-        const command = getProcessCommand(pid, directory);
-        // TODO: Have a better message for reusing another process.
-        return {
-            pid,
-            directory,
-            command
-        };
-    } catch  {
+    const pid = await getPID(port);
+    if (!pid) {
         return null;
     }
+    try {
+        const directory = await getDirectoryOfProcessById(pid);
+        if (directory) {
+            const command = await getProcessCommand(pid, directory);
+            if (command) {
+                return {
+                    pid,
+                    directory,
+                    command
+                };
+            }
+        }
+    } catch  {}
+    return null;
 }
 
 //# sourceMappingURL=getRunningProcess.js.map

package/build/src/utils/getRunningProcess.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/utils/getRunningProcess.ts"],"sourcesContent":["import { execFileSync, execSync, ExecSyncOptionsWithStringEncoding } from 'child_process';\nimport * as path from 'path';\n\nconst debug = require('debug')('expo:utils:getRunningProcess') as typeof console.log;\n\nconst defaultOptions: ExecSyncOptionsWithStringEncoding = {\n  encoding: 'utf8',\n  stdio: ['pipe', 'pipe', 'ignore'],\n};\n\n/** Returns a pid value for a running port like `63828` or null if nothing is running on the given port. */\nexport function getPID(port: number): number | null {\n  try {\n    const results = execFileSync('lsof', [`-i:${port}`, '-P', '-t', '-sTCP:LISTEN'], defaultOptions)\n      .split('\\n')[0]\n      .trim();\n    const pid = Number(results);\n    debug(`pid: ${pid} for port: ${port}`);\n    return pid;\n  } catch (error: any) {\n    debug(`No pid found for port: ${port}. Error: ${error}`);\n    return null;\n  }\n}\n\n/** Get `package.json` `name` field for a given directory. Returns `null` if none exist. */\nfunction getPackageName(packageRoot: string): string | null {\n  const packageJson = path.join(packageRoot, 'package.json');\n  try {\n    return require(packageJson).name || null;\n  } catch {\n    return null;\n  }\n}\n\n/** Returns a command like `node /Users/evanbacon/.../bin/expo start` or the package.json name. */\nfunction getProcessCommand(pid: number, procDirectory: string): string {\n  const name = getPackageName(procDirectory);\n\n  if (name) {\n    return name;\n  }\n  return execSync(`ps -o command -p ${pid} | sed -n 2p`, defaultOptions).replace(/\\n$/, '').trim();\n}\n\n/** Get directory for a given process ID. */\nexport function getDirectoryOfProcessById(processId: number): string {\n  return execSync(\n    `lsof -p ${processId} | awk '$4==\"cwd\" {for (i=9; i<=NF; i++) printf \"%s \", $i}'`,\n    defaultOptions\n  ).trim();\n}\n\n/** Get information about a running process given a port. Returns null if no process is running on the given port. */\nexport function getRunningProcess(port: number): {\n  /** The PID value for the port. */\n  pid: number;\n  /** Get the directory for the running process. */\n  directory: string;\n  /** The command running the process like `node /Users/evanbacon/.../bin/expo start` or the `package.json` name like `my-app`. */\n  command: string;\n} | null {\n  // 63828\n  const pid = getPID(port);\n  if (!pid) {\n    return null;\n  }\n\n  try {\n    // /Users/evanbacon/Documents/GitHub/lab/myapp\n    const directory = getDirectoryOfProcessById(pid);\n    // /Users/evanbacon/Documents/GitHub/lab/myapp/package.json\n    const command = getProcessCommand(pid, directory);\n    // TODO: Have a better message for reusing another process.\n    return { pid, directory, command };\n  } catch {\n    return null;\n  }\n}\n"],"names":["getDirectoryOfProcessById","getPID","getRunningProcess","debug","require","defaultOptions","encoding","stdio","port","results","execFileSync","split","trim","pid","Number","error","getPackageName","packageRoot","packageJson","path","join","name","getProcessCommand","procDirectory","execSync","replace","processId","directory","command"],"mappings":";;;;;;;;;;;IA8CgBA,yBAAyB;eAAzBA;;IAnCAC,MAAM;eAANA;;IA2CAC,iBAAiB;eAAjBA;;;;yBAtD0D;;;;;;;iEACpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEtB,MAAMC,QAAQC,QAAQ,SAAS;AAE/B,MAAMC,iBAAoD;IACxDC,UAAU;IACVC,OAAO;QAAC;QAAQ;QAAQ;KAAS;AACnC;AAGO,SAASN,OAAOO,IAAY;IACjC,IAAI;QACF,MAAMC,UAAUC,IAAAA,6BAAY,EAAC,QAAQ;YAAC,CAAC,GAAG,EAAEF,MAAM;YAAE;YAAM;YAAM;SAAe,EAAEH,gBAC9EM,KAAK,CAAC,KAAK,CAAC,EAAE,CACdC,IAAI;QACP,MAAMC,MAAMC,OAAOL;QACnBN,MAAM,CAAC,KAAK,EAAEU,IAAI,WAAW,EAAEL,MAAM;QACrC,OAAOK;IACT,EAAE,OAAOE,OAAY;QACnBZ,MAAM,CAAC,uBAAuB,EAAEK,KAAK,SAAS,EAAEO,OAAO;QACvD,OAAO;IACT;AACF;AAEA,yFAAyF,GACzF,SAASC,eAAeC,WAAmB;IACzC,MAAMC,cAAcC,QAAKC,IAAI,CAACH,aAAa;IAC3C,IAAI;QACF,OAAOb,QAAQc,aAAaG,IAAI,IAAI;IACtC,EAAE,OAAM;QACN,OAAO;IACT;AACF;AAEA,gGAAgG,GAChG,SAASC,kBAAkBT,GAAW,EAAEU,aAAqB;IAC3D,MAAMF,OAAOL,eAAeO;IAE5B,IAAIF,MAAM;QACR,OAAOA;IACT;IACA,OAAOG,IAAAA,yBAAQ,EAAC,CAAC,iBAAiB,EAAEX,IAAI,YAAY,CAAC,EAAER,gBAAgBoB,OAAO,CAAC,OAAO,IAAIb,IAAI;AAChG;AAGO,SAASZ,0BAA0B0B,SAAiB;IACzD,OAAOF,IAAAA,yBAAQ,EACb,CAAC,QAAQ,EAAEE,UAAU,2DAA2D,CAAC,EACjFrB,gBACAO,IAAI;AACR;AAGO,SAASV,kBAAkBM,IAAY;IAQ5C,QAAQ;IACR,MAAMK,MAAMZ,OAAOO;IACnB,IAAI,CAACK,KAAK;QACR,OAAO;IACT;IAEA,IAAI;QACF,8CAA8C;QAC9C,MAAMc,YAAY3B,0BAA0Ba;QAC5C,2DAA2D;QAC3D,MAAMe,UAAUN,kBAAkBT,KAAKc;QACvC,2DAA2D;QAC3D,OAAO;YAAEd;YAAKc;YAAWC;QAAQ;IACnC,EAAE,OAAM;QACN,OAAO;IACT;AACF"}
+{"version":3,"sources":["../../../src/utils/getRunningProcess.ts"],"sourcesContent":["import spawnAsync from '@expo/spawn-async';\nimport * as path from 'path';\n\nconst debug = require('debug')('expo:utils:getRunningProcess') as typeof console.log;\n\n/** Timeout applied to shell commands */\nconst timeout = 350;\n\n/** Returns a pid value for a running port like `63828` or null if nothing is running on the given port. */\nexport async function getPID(port: number): Promise<number | null> {\n  try {\n    const { stdout } = await spawnAsync('lsof', [`-i:${port}`, '-P', '-t', '-sTCP:LISTEN'], {\n      timeout,\n    });\n    const pid = Number(stdout.split('\\n', 1)[0].trim());\n    debug(`pid: ${pid} for port: ${port}`);\n    return Number.isSafeInteger(pid) ? pid : null;\n  } catch (error: any) {\n    debug(`No pid found for port: ${port}. Error: ${error}`);\n    return null;\n  }\n}\n\n/** Get `package.json` `name` field for a given directory. Returns `null` if none exist. */\nfunction getPackageName(packageRoot: string): string | null {\n  try {\n    const packageJson = path.resolve(packageRoot, 'package.json');\n    return require(packageJson).name || null;\n  } catch (error) {\n    return null;\n  }\n}\n\n/** Returns a command like `node /Users/evanbacon/.../bin/expo start` or the package.json name. */\nexport async function getProcessCommand(\n  pid: number,\n  procDirectory: string\n): Promise<string | null> {\n  let name = getPackageName(procDirectory);\n  if (!name) {\n    // ps\n    // -o args=: Output argv without header\n    // -p [pid]: For process of PID\n    const { stdout } = await spawnAsync('ps', ['-o', 'args=', '-p', `${pid}`], {\n      timeout,\n    });\n    name = stdout.trim();\n  }\n  return name || null;\n}\n\n/** Get directory for a given process ID. */\nexport async function getDirectoryOfProcessById(pid: number): Promise<string | null> {\n  try {\n    // lsof\n    // -F n: ask for machine readable output\n    // -a: apply conditions as logical AND\n    // -d cwd: Filter by cwd fd\n    // -p [pid]: Filter by input process id\n    const { stdout } = await spawnAsync('lsof', ['-F', 'n', '-a', '-d', 'cwd', '-p', `${pid}`], {\n      timeout,\n    });\n    const processCWD = stdout\n      .split('\\n')\n      .find((output) => output.startsWith('n'))\n      ?.slice(1);\n    return processCWD && path.isAbsolute(processCWD) ? path.normalize(processCWD) : null;\n  } catch {\n    return null;\n  }\n}\n\ninterface RunningProcess {\n  /** The PID value for the port. */\n  pid: number;\n  /** Get the directory for the running process. */\n  directory: string;\n  /** The command running the process like `node /Users/evanbacon/.../bin/expo start` or the `package.json` name like `my-app`. */\n  command: string;\n}\n\n/** Get information about a running process given a port. Returns null if no process is running on the given port. */\nexport async function getRunningProcess(port: number): Promise<RunningProcess | null> {\n  // Don't even try on Windows, since `lsof` and `ps` are not available there\n  if (process.platform === 'win32') {\n    return null;\n  }\n\n  const pid = await getPID(port);\n  if (!pid) {\n    return null;\n  }\n  try {\n    const directory = await getDirectoryOfProcessById(pid);\n    if (directory) {\n      const command = await getProcessCommand(pid, directory);\n      if (command) {\n        return { pid, directory, command };\n      }\n    }\n  } catch {}\n  return null;\n}\n"],"names":["getDirectoryOfProcessById","getPID","getProcessCommand","getRunningProcess","debug","require","timeout","port","stdout","spawnAsync","pid","Number","split","trim","isSafeInteger","error","getPackageName","packageRoot","packageJson","path","resolve","name","procDirectory","processCWD","find","output","startsWith","slice","isAbsolute","normalize","process","platform","directory","command"],"mappings":";;;;;;;;;;;IAoDsBA,yBAAyB;eAAzBA;;IA3CAC,MAAM;eAANA;;IAyBAC,iBAAiB;eAAjBA;;IAgDAC,iBAAiB;eAAjBA;;;;gEAlFC;;;;;;;iEACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEtB,MAAMC,QAAQC,QAAQ,SAAS;AAE/B,sCAAsC,GACtC,MAAMC,UAAU;AAGT,eAAeL,OAAOM,IAAY;IACvC,IAAI;QACF,MAAM,EAAEC,MAAM,EAAE,GAAG,MAAMC,IAAAA,qBAAU,EAAC,QAAQ;YAAC,CAAC,GAAG,EAAEF,MAAM;YAAE;YAAM;YAAM;SAAe,EAAE;YACtFD;QACF;QACA,MAAMI,MAAMC,OAAOH,OAAOI,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,CAACC,IAAI;QAChDT,MAAM,CAAC,KAAK,EAAEM,IAAI,WAAW,EAAEH,MAAM;QACrC,OAAOI,OAAOG,aAAa,CAACJ,OAAOA,MAAM;IAC3C,EAAE,OAAOK,OAAY;QACnBX,MAAM,CAAC,uBAAuB,EAAEG,KAAK,SAAS,EAAEQ,OAAO;QACvD,OAAO;IACT;AACF;AAEA,yFAAyF,GACzF,SAASC,eAAeC,WAAmB;IACzC,IAAI;QACF,MAAMC,cAAcC,QAAKC,OAAO,CAACH,aAAa;QAC9C,OAAOZ,QAAQa,aAAaG,IAAI,IAAI;IACtC,EAAE,OAAON,OAAO;QACd,OAAO;IACT;AACF;AAGO,eAAeb,kBACpBQ,GAAW,EACXY,aAAqB;IAErB,IAAID,OAAOL,eAAeM;IAC1B,IAAI,CAACD,MAAM;QACT,KAAK;QACL,uCAAuC;QACvC,+BAA+B;QAC/B,MAAM,EAAEb,MAAM,EAAE,GAAG,MAAMC,IAAAA,qBAAU,EAAC,MAAM;YAAC;YAAM;YAAS;YAAM,GAAGC,KAAK;SAAC,EAAE;YACzEJ;QACF;QACAe,OAAOb,OAAOK,IAAI;IACpB;IACA,OAAOQ,QAAQ;AACjB;AAGO,eAAerB,0BAA0BU,GAAW;IACzD,IAAI;YASiBF;QARnB,OAAO;QACP,wCAAwC;QACxC,sCAAsC;QACtC,2BAA2B;QAC3B,uCAAuC;QACvC,MAAM,EAAEA,MAAM,EAAE,GAAG,MAAMC,IAAAA,qBAAU,EAAC,QAAQ;YAAC;YAAM;YAAK;YAAM;YAAM;YAAO;YAAM,GAAGC,KAAK;SAAC,EAAE;YAC1FJ;QACF;QACA,MAAMiB,cAAaf,qBAAAA,OAChBI,KAAK,CAAC,MACNY,IAAI,CAAC,CAACC,SAAWA,OAAOC,UAAU,CAAC,0BAFnBlB,mBAGfmB,KAAK,CAAC;QACV,OAAOJ,cAAcJ,QAAKS,UAAU,CAACL,cAAcJ,QAAKU,SAAS,CAACN,cAAc;IAClF,EAAE,OAAM;QACN,OAAO;IACT;AACF;AAYO,eAAepB,kBAAkBI,IAAY;IAClD,2EAA2E;IAC3E,IAAIuB,QAAQC,QAAQ,KAAK,SAAS;QAChC,OAAO;IACT;IAEA,MAAMrB,MAAM,MAAMT,OAAOM;IACzB,IAAI,CAACG,KAAK;QACR,OAAO;IACT;IACA,IAAI;QACF,MAAMsB,YAAY,MAAMhC,0BAA0BU;QAClD,IAAIsB,WAAW;YACb,MAAMC,UAAU,MAAM/B,kBAAkBQ,KAAKsB;YAC7C,IAAIC,SAAS;gBACX,OAAO;oBAAEvB;oBAAKsB;oBAAWC;gBAAQ;YACnC;QACF;IACF,EAAE,OAAM,CAAC;IACT,OAAO;AACT"}

package/build/src/utils/ip.js

@@ -2,10 +2,21 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "getIpAddress", {
-    enumerable: true,
-    get: function() {
-        return getIpAddress;
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getGateway: function() {
+        return getGateway;
+    },
+    getGatewayAsync: function() {
+        return getGatewayAsync;
+    },
+    getIpAddressAsync: function() {
+        return getIpAddressAsync;
     }
 });
 function _lannetwork() {
@@ -15,13 +26,38 @@ function _lannetwork() {
     };
     return data;
 }
-function getIpAddress() {
+const _env = require("./env");
+// NOTE(@kitten): In headless mode, there's no point in trying to run DHCP, since
+// we assume we're online and probing is going to be enough
+const options = {
+    noDhcp: (0, _env.envIsHeadless)()
+};
+function getGateway() {
+    try {
+        return (0, _lannetwork().lanNetworkSync)(options);
+    } catch  {
+        return {
+            iname: null,
+            address: '127.0.0.1',
+            gateway: null,
+            internal: true
+        };
+    }
+}
+async function getGatewayAsync() {
     try {
-        const lan = (0, _lannetwork().lanNetworkSync)();
-        return lan.address;
+        return await (0, _lannetwork().lanNetwork)(options);
     } catch  {
-        return '127.0.0.1';
+        return {
+            iname: null,
+            address: '127.0.0.1',
+            gateway: null,
+            internal: true
+        };
     }
 }
+async function getIpAddressAsync() {
+    return (await getGatewayAsync()).address;
+}
 
 //# sourceMappingURL=ip.js.map

package/build/src/utils/ip.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/utils/ip.ts"],"sourcesContent":["import { lanNetworkSync } from 'lan-network';\n\nexport function getIpAddress(): string {\n  try {\n    const lan = lanNetworkSync();\n    return lan.address;\n  } catch {\n    return '127.0.0.1';\n  }\n}\n"],"names":["getIpAddress","lan","lanNetworkSync","address"],"mappings":";;;;+BAEgBA;;;eAAAA;;;;yBAFe;;;;;;AAExB,SAASA;IACd,IAAI;QACF,MAAMC,MAAMC,IAAAA,4BAAc;QAC1B,OAAOD,IAAIE,OAAO;IACpB,EAAE,OAAM;QACN,OAAO;IACT;AACF"}
+{"version":3,"sources":["../../../src/utils/ip.ts"],"sourcesContent":["import { lanNetworkSync, lanNetwork } from 'lan-network';\n\nimport { envIsHeadless } from './env';\n\n// NOTE(@kitten): In headless mode, there's no point in trying to run DHCP, since\n// we assume we're online and probing is going to be enough\nconst options = {\n  noDhcp: envIsHeadless(),\n};\n\nexport interface GatewayInfo {\n  iname: string | null;\n  address: string;\n  gateway: string | null;\n  internal: boolean;\n}\n\nexport function getGateway(): GatewayInfo {\n  try {\n    return lanNetworkSync(options);\n  } catch {\n    return {\n      iname: null,\n      address: '127.0.0.1',\n      gateway: null,\n      internal: true,\n    };\n  }\n}\n\nexport async function getGatewayAsync(): Promise<GatewayInfo> {\n  try {\n    return await lanNetwork(options);\n  } catch {\n    return {\n      iname: null,\n      address: '127.0.0.1',\n      gateway: null,\n      internal: true,\n    };\n  }\n}\n\nexport async function getIpAddressAsync(): Promise<string> {\n  return (await getGatewayAsync()).address;\n}\n"],"names":["getGateway","getGatewayAsync","getIpAddressAsync","options","noDhcp","envIsHeadless","lanNetworkSync","iname","address","gateway","internal","lanNetwork"],"mappings":";;;;;;;;;;;IAiBgBA,UAAU;eAAVA;;IAaMC,eAAe;eAAfA;;IAaAC,iBAAiB;eAAjBA;;;;yBA3CqB;;;;;;qBAEb;AAE9B,iFAAiF;AACjF,2DAA2D;AAC3D,MAAMC,UAAU;IACdC,QAAQC,IAAAA,kBAAa;AACvB;AASO,SAASL;IACd,IAAI;QACF,OAAOM,IAAAA,4BAAc,EAACH;IACxB,EAAE,OAAM;QACN,OAAO;YACLI,OAAO;YACPC,SAAS;YACTC,SAAS;YACTC,UAAU;QACZ;IACF;AACF;AAEO,eAAeT;IACpB,IAAI;QACF,OAAO,MAAMU,IAAAA,wBAAU,EAACR;IAC1B,EAAE,OAAM;QACN,OAAO;YACLI,OAAO;YACPC,SAAS;YACTC,SAAS;YACTC,UAAU;QACZ;IACF;AACF;AAEO,eAAeR;IACpB,OAAO,AAAC,CAAA,MAAMD,iBAAgB,EAAGO,OAAO;AAC1C"}

package/build/src/utils/nodeEnv.js

@@ -9,9 +9,15 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    getEnvFiles: function() {
+        return getEnvFiles;
+    },
     loadEnvFiles: function() {
         return loadEnvFiles;
     },
+    reloadEnvFiles: function() {
+        return reloadEnvFiles;
+    },
     setNodeEnv: function() {
         return setNodeEnv;
     }
@@ -23,6 +29,18 @@ function _env() {
     };
     return data;
 }
+function _nodepath() {
+    const data = /*#__PURE__*/ _interop_require_default(require("node:path"));
+    _nodepath = function() {
+        return data;
+    };
+    return data;
+}
+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();
@@ -69,8 +87,55 @@ function setNodeEnv(mode) {
     process.env.BABEL_ENV = process.env.BABEL_ENV || process.env.NODE_ENV;
     globalThis.__DEV__ = process.env.NODE_ENV !== 'production';
 }
+let prevEnvKeys;
 function loadEnvFiles(projectRoot, options) {
-    return _env().load(projectRoot, options);
+    const params = {
+        ...options,
+        force: !!(options == null ? void 0 : options.force),
+        silent: !!(options == null ? void 0 : options.silent),
+        mode: process.env.NODE_ENV,
+        systemEnv: process.env
+    };
+    const envInfo = _env().loadProjectEnv(projectRoot, params);
+    const envOutput = {};
+    if (envInfo.result === 'loaded') {
+        prevEnvKeys = new Set();
+        for (const key of envInfo.loaded){
+            envOutput[key] = envInfo.env[key] ?? undefined;
+            prevEnvKeys.add(key);
+        }
+    }
+    _env().logLoadedEnv(envInfo, params);
+    return process.env;
+}
+function getEnvFiles(projectRoot) {
+    return _env().getEnvFiles({
+        mode: process.env.NODE_ENV
+    }).map((fileName)=>_nodepath().default.join(projectRoot, fileName));
+}
+function reloadEnvFiles(projectRoot) {
+    const isEnabled = _env().isEnabled();
+    if (isEnabled) {
+        const params = {
+            force: true,
+            silent: true,
+            mode: process.env.NODE_ENV,
+            systemEnv: process.env
+        };
+        // We use a global tracker to allow overwrites of env vars we set ourselves
+        const envInfo = _env().parseProjectEnv(projectRoot, params);
+        const envOutput = {};
+        for(const key in envInfo.env){
+            const value = envInfo.env[key];
+            if (process.env[key] !== value) {
+                if (typeof process.env[key] === 'undefined' || (!prevEnvKeys || prevEnvKeys.has(key)) && process.env[key] !== value) {
+                    (prevEnvKeys ||= new Set()).add(key);
+                    process.env[key] = envInfo.env[key];
+                    envOutput[key] = value ?? undefined;
+                }
+            }
+        }
+    }
 }
 
 //# sourceMappingURL=nodeEnv.js.map

package/build/src/utils/nodeEnv.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/utils/nodeEnv.ts"],"sourcesContent":["import * as env from '@expo/env';\n\n// TODO(@kitten): We assign this here to run server-side code bundled by metro\n// It's not isolated into a worker thread yet\ndeclare namespace globalThis {\n  let __DEV__: boolean | undefined;\n}\n\n/**\n * Set the environment to production or development\n * lots of tools use this to determine if they should run in a dev mode.\n */\nexport function setNodeEnv(mode: 'development' | 'production') {\n  process.env.NODE_ENV = process.env.NODE_ENV || mode;\n  process.env.BABEL_ENV = process.env.BABEL_ENV || process.env.NODE_ENV;\n  globalThis.__DEV__ = process.env.NODE_ENV !== 'production';\n}\n\n/**\n * Load the dotenv files into the current `process.env` scope.\n * Note, this requires `NODE_ENV` being set through `setNodeEnv`.\n */\nexport function loadEnvFiles(projectRoot: string, options?: Parameters<typeof env.load>[1]) {\n  return env.load(projectRoot, options);\n}\n"],"names":["loadEnvFiles","setNodeEnv","mode","process","env","NODE_ENV","BABEL_ENV","globalThis","__DEV__","projectRoot","options","load"],"mappings":";;;;;;;;;;;IAsBgBA,YAAY;eAAZA;;IAVAC,UAAU;eAAVA;;;;iEAZK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAYd,SAASA,WAAWC,IAAkC;IAC3DC,QAAQC,GAAG,CAACC,QAAQ,GAAGF,QAAQC,GAAG,CAACC,QAAQ,IAAIH;IAC/CC,QAAQC,GAAG,CAACE,SAAS,GAAGH,QAAQC,GAAG,CAACE,SAAS,IAAIH,QAAQC,GAAG,CAACC,QAAQ;IACrEE,WAAWC,OAAO,GAAGL,QAAQC,GAAG,CAACC,QAAQ,KAAK;AAChD;AAMO,SAASL,aAAaS,WAAmB,EAAEC,OAAwC;IACxF,OAAON,OAAIO,IAAI,CAACF,aAAaC;AAC/B"}
+{"version":3,"sources":["../../../src/utils/nodeEnv.ts"],"sourcesContent":["import * as env from '@expo/env';\nimport path from 'node:path';\n\ntype EnvOutput = Record<string, string | undefined>;\n\n// TODO(@kitten): We assign this here to run server-side code bundled by metro\n// It's not isolated into a worker thread yet\ndeclare namespace globalThis {\n  let __DEV__: boolean | undefined;\n}\n\n/**\n * Set the environment to production or development\n * lots of tools use this to determine if they should run in a dev mode.\n */\nexport function setNodeEnv(mode: 'development' | 'production') {\n  process.env.NODE_ENV = process.env.NODE_ENV || mode;\n  process.env.BABEL_ENV = process.env.BABEL_ENV || process.env.NODE_ENV;\n  globalThis.__DEV__ = process.env.NODE_ENV !== 'production';\n}\n\ninterface LoadEnvFilesOptions {\n  force?: boolean;\n  silent?: boolean;\n  mode?: string;\n}\n\nlet prevEnvKeys: Set<string> | undefined;\n\n/**\n * Load the dotenv files into the current `process.env` scope.\n * Note, this requires `NODE_ENV` being set through `setNodeEnv`.\n */\nexport function loadEnvFiles(projectRoot: string, options?: LoadEnvFilesOptions) {\n  const params = {\n    ...options,\n    force: !!options?.force,\n    silent: !!options?.silent,\n    mode: process.env.NODE_ENV,\n    systemEnv: process.env,\n  };\n\n  const envInfo = env.loadProjectEnv(projectRoot, params);\n  const envOutput: EnvOutput = {};\n  if (envInfo.result === 'loaded') {\n    prevEnvKeys = new Set();\n    for (const key of envInfo.loaded) {\n      envOutput[key] = envInfo.env[key] ?? undefined;\n      prevEnvKeys.add(key);\n    }\n  }\n\n  env.logLoadedEnv(envInfo, params);\n  return process.env;\n}\n\nexport function getEnvFiles(projectRoot: string) {\n  return env\n    .getEnvFiles({ mode: process.env.NODE_ENV })\n    .map((fileName) => path.join(projectRoot, fileName));\n}\n\nexport function reloadEnvFiles(projectRoot: string) {\n  const isEnabled = env.isEnabled();\n  if (isEnabled) {\n    const params = {\n      force: true,\n      silent: true,\n      mode: process.env.NODE_ENV,\n      systemEnv: process.env,\n    };\n\n    // We use a global tracker to allow overwrites of env vars we set ourselves\n    const envInfo = env.parseProjectEnv(projectRoot, params);\n    const envOutput: EnvOutput = {};\n    for (const key in envInfo.env) {\n      const value = envInfo.env[key];\n      if (process.env[key] !== value) {\n        if (\n          typeof process.env[key] === 'undefined' ||\n          ((!prevEnvKeys || prevEnvKeys.has(key)) && process.env[key] !== value)\n        ) {\n          (prevEnvKeys ||= new Set()).add(key);\n          process.env[key] = envInfo.env[key];\n          envOutput[key] = value ?? undefined;\n        }\n      }\n    }\n  }\n}\n"],"names":["getEnvFiles","loadEnvFiles","reloadEnvFiles","setNodeEnv","mode","process","env","NODE_ENV","BABEL_ENV","globalThis","__DEV__","prevEnvKeys","projectRoot","options","params","force","silent","systemEnv","envInfo","loadProjectEnv","envOutput","result","Set","key","loaded","undefined","add","logLoadedEnv","map","fileName","path","join","isEnabled","parseProjectEnv","value","has"],"mappings":";;;;;;;;;;;IAwDgBA,WAAW;eAAXA;;IAvBAC,YAAY;eAAZA;;IA6BAC,cAAc;eAAdA;;IA/CAC,UAAU;eAAVA;;;;iEAfK;;;;;;;gEACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAcV,SAASA,WAAWC,IAAkC;IAC3DC,QAAQC,GAAG,CAACC,QAAQ,GAAGF,QAAQC,GAAG,CAACC,QAAQ,IAAIH;IAC/CC,QAAQC,GAAG,CAACE,SAAS,GAAGH,QAAQC,GAAG,CAACE,SAAS,IAAIH,QAAQC,GAAG,CAACC,QAAQ;IACrEE,WAAWC,OAAO,GAAGL,QAAQC,GAAG,CAACC,QAAQ,KAAK;AAChD;AAQA,IAAII;AAMG,SAASV,aAAaW,WAAmB,EAAEC,OAA6B;IAC7E,MAAMC,SAAS;QACb,GAAGD,OAAO;QACVE,OAAO,CAAC,EAACF,2BAAAA,QAASE,KAAK;QACvBC,QAAQ,CAAC,EAACH,2BAAAA,QAASG,MAAM;QACzBZ,MAAMC,QAAQC,GAAG,CAACC,QAAQ;QAC1BU,WAAWZ,QAAQC,GAAG;IACxB;IAEA,MAAMY,UAAUZ,OAAIa,cAAc,CAACP,aAAaE;IAChD,MAAMM,YAAuB,CAAC;IAC9B,IAAIF,QAAQG,MAAM,KAAK,UAAU;QAC/BV,cAAc,IAAIW;QAClB,KAAK,MAAMC,OAAOL,QAAQM,MAAM,CAAE;YAChCJ,SAAS,CAACG,IAAI,GAAGL,QAAQZ,GAAG,CAACiB,IAAI,IAAIE;YACrCd,YAAYe,GAAG,CAACH;QAClB;IACF;IAEAjB,OAAIqB,YAAY,CAACT,SAASJ;IAC1B,OAAOT,QAAQC,GAAG;AACpB;AAEO,SAASN,YAAYY,WAAmB;IAC7C,OAAON,OACJN,WAAW,CAAC;QAAEI,MAAMC,QAAQC,GAAG,CAACC,QAAQ;IAAC,GACzCqB,GAAG,CAAC,CAACC,WAAaC,mBAAI,CAACC,IAAI,CAACnB,aAAaiB;AAC9C;AAEO,SAAS3B,eAAeU,WAAmB;IAChD,MAAMoB,YAAY1B,OAAI0B,SAAS;IAC/B,IAAIA,WAAW;QACb,MAAMlB,SAAS;YACbC,OAAO;YACPC,QAAQ;YACRZ,MAAMC,QAAQC,GAAG,CAACC,QAAQ;YAC1BU,WAAWZ,QAAQC,GAAG;QACxB;QAEA,2EAA2E;QAC3E,MAAMY,UAAUZ,OAAI2B,eAAe,CAACrB,aAAaE;QACjD,MAAMM,YAAuB,CAAC;QAC9B,IAAK,MAAMG,OAAOL,QAAQZ,GAAG,CAAE;YAC7B,MAAM4B,QAAQhB,QAAQZ,GAAG,CAACiB,IAAI;YAC9B,IAAIlB,QAAQC,GAAG,CAACiB,IAAI,KAAKW,OAAO;gBAC9B,IACE,OAAO7B,QAAQC,GAAG,CAACiB,IAAI,KAAK,eAC3B,AAAC,CAAA,CAACZ,eAAeA,YAAYwB,GAAG,CAACZ,IAAG,KAAMlB,QAAQC,GAAG,CAACiB,IAAI,KAAKW,OAChE;oBACCvB,CAAAA,gBAAgB,IAAIW,KAAI,EAAGI,GAAG,CAACH;oBAChClB,QAAQC,GAAG,CAACiB,IAAI,GAAGL,QAAQZ,GAAG,CAACiB,IAAI;oBACnCH,SAAS,CAACG,IAAI,GAAGW,SAAST;gBAC5B;YACF;QACF;IACF;AACF"}

package/build/src/utils/port.js

@@ -116,7 +116,7 @@ function isRestrictedPort(port) {
 }
 async function isBusyPortRunningSameProcessAsync(projectRoot, { port }) {
     const { getRunningProcess } = require('./getRunningProcess');
-    const runningProcess = isRestrictedPort(port) ? null : getRunningProcess(port);
+    const runningProcess = isRestrictedPort(port) ? null : await getRunningProcess(port);
     if (runningProcess) {
         if (runningProcess.directory === projectRoot) {
             return true;
@@ -137,7 +137,7 @@ async function choosePortAsync(projectRoot, { defaultPort, host, reuseExistingPo
         const isRestricted = port && isRestrictedPort(port);
         let message = isRestricted ? `Admin permissions are required to run a server on a port below 1024` : `Port ${_chalk().default.bold(defaultPort)} is`;
         const { getRunningProcess } = require('./getRunningProcess');
-        const runningProcess = isRestricted ? null : getRunningProcess(defaultPort);
+        const runningProcess = isRestricted ? null : await getRunningProcess(defaultPort);
         if (runningProcess) {
             const pidTag = _chalk().default.gray(`(pid ${runningProcess.pid})`);
             if (runningProcess.directory === projectRoot) {

package/build/src/utils/port.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/utils/port.ts"],"sourcesContent":["import chalk from 'chalk';\n\nimport { env } from './env';\nimport { CommandError } from './errors';\nimport { testPortAsync, freePortAsync } from './freeport';\nimport * as Log from '../log';\n\n/** Get a free port or assert a CLI command error. */\nexport async function getFreePortAsync(rangeStart: number): Promise<number> {\n  const port = await freePortAsync(rangeStart, [null, 'localhost']);\n  if (!port) {\n    throw new CommandError('NO_PORT_FOUND', 'No available port found');\n  }\n\n  return port;\n}\n\n/** @return `true` if the port can still be used to start the dev server, `false` if the dev server should be skipped, and asserts if the port is now taken. */\nexport async function ensurePortAvailabilityAsync(\n  projectRoot: string,\n  { port }: { port: number }\n): Promise<boolean> {\n  const isFreePort = await testPortAsync(port, [null]);\n  // Check if port has become busy during the build.\n  if (isFreePort) {\n    return true;\n  }\n\n  const isBusy = await isBusyPortRunningSameProcessAsync(projectRoot, { port });\n  if (!isBusy) {\n    throw new CommandError(\n      `Port \"${port}\" became busy running another process while the app was compiling. Re-run command to use a new port.`\n    );\n  }\n\n  // Log that the dev server will not be started and that the logs will appear in another window.\n  Log.log(\n    '› The dev server for this app is already running in another window. Logs will appear there.'\n  );\n  return false;\n}\n\nfunction isRestrictedPort(port: number) {\n  if (process.platform !== 'win32' && port < 1024) {\n    const isRoot = process.getuid && process.getuid() === 0;\n    return !isRoot;\n  }\n  return false;\n}\n\nasync function isBusyPortRunningSameProcessAsync(projectRoot: string, { port }: { port: number }) {\n  const { getRunningProcess } =\n    require('./getRunningProcess') as typeof import('./getRunningProcess');\n\n  const runningProcess = isRestrictedPort(port) ? null : getRunningProcess(port);\n  if (runningProcess) {\n    if (runningProcess.directory === projectRoot) {\n      return true;\n    } else {\n      return false;\n    }\n  }\n\n  return null;\n}\n\n// TODO(Bacon): Revisit after all start and run code is merged.\nexport async function choosePortAsync(\n  projectRoot: string,\n  {\n    defaultPort,\n    host,\n    reuseExistingPort,\n  }: {\n    defaultPort: number;\n    host?: string;\n    reuseExistingPort?: boolean;\n  }\n): Promise<number | null> {\n  try {\n    const port = await freePortAsync(defaultPort, [host ?? null]);\n    if (port === defaultPort || defaultPort === 0) {\n      return port;\n    }\n\n    const isRestricted = port && isRestrictedPort(port);\n\n    let message = isRestricted\n      ? `Admin permissions are required to run a server on a port below 1024`\n      : `Port ${chalk.bold(defaultPort)} is`;\n\n    const { getRunningProcess } =\n      require('./getRunningProcess') as typeof import('./getRunningProcess');\n    const runningProcess = isRestricted ? null : getRunningProcess(defaultPort);\n\n    if (runningProcess) {\n      const pidTag = chalk.gray(`(pid ${runningProcess.pid})`);\n      if (runningProcess.directory === projectRoot) {\n        message += ` running this app in another window`;\n        if (reuseExistingPort) {\n          return null;\n        }\n      } else {\n        message += ` running ${chalk.cyan(runningProcess.command)} in another window`;\n      }\n      message += '\\n' + chalk.gray(`  ${runningProcess.directory} ${pidTag}`);\n    } else {\n      message += ' being used by another process';\n    }\n\n    Log.log(`\\u203A ${message}`);\n    const { confirmAsync } = require('./prompts') as typeof import('./prompts');\n    const change = await confirmAsync({\n      message: `Use port ${port} instead?`,\n      initial: true,\n    });\n    return change ? port : null;\n  } catch (error: any) {\n    if (error.code === 'ABORTED') {\n      throw error;\n    } else if (error.code === 'NON_INTERACTIVE') {\n      Log.warn(chalk.yellow(error.message));\n      return null;\n    }\n    throw error;\n  }\n}\n\n// TODO(Bacon): Revisit after all start and run code is merged.\nexport async function resolvePortAsync(\n  projectRoot: string,\n  {\n    /** Should opt to reuse a port that is running the same project in another window. */\n    reuseExistingPort,\n    /** Preferred port. */\n    defaultPort,\n    /** Backup port for when the default isn't available. */\n    fallbackPort,\n  }: {\n    reuseExistingPort?: boolean;\n    defaultPort?: string | number;\n    fallbackPort?: number;\n  } = {}\n): Promise<number | null> {\n  let port: number;\n  if (typeof defaultPort === 'string') {\n    port = parseInt(defaultPort, 10);\n  } else if (typeof defaultPort === 'number') {\n    port = defaultPort;\n  } else {\n    port = env.RCT_METRO_PORT || fallbackPort || 8081;\n  }\n\n  // Only check the port when the bundler is running.\n  const resolvedPort = await choosePortAsync(projectRoot, {\n    defaultPort: port,\n    reuseExistingPort,\n  });\n  if (resolvedPort == null) {\n    Log.log('\\u203A Skipping dev server');\n    // Skip bundling if the port is null\n  } else {\n    // Use the new or resolved port\n    process.env.RCT_METRO_PORT = String(resolvedPort);\n  }\n\n  return resolvedPort;\n}\n"],"names":["choosePortAsync","ensurePortAvailabilityAsync","getFreePortAsync","resolvePortAsync","rangeStart","port","freePortAsync","CommandError","projectRoot","isFreePort","testPortAsync","isBusy","isBusyPortRunningSameProcessAsync","Log","log","isRestrictedPort","process","platform","isRoot","getuid","getRunningProcess","require","runningProcess","directory","defaultPort","host","reuseExistingPort","isRestricted","message","chalk","bold","pidTag","gray","pid","cyan","command","confirmAsync","change","initial","error","code","warn","yellow","fallbackPort","parseInt","env","RCT_METRO_PORT","resolvedPort","String"],"mappings":"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"}
+{"version":3,"sources":["../../../src/utils/port.ts"],"sourcesContent":["import chalk from 'chalk';\n\nimport { env } from './env';\nimport { CommandError } from './errors';\nimport { testPortAsync, freePortAsync } from './freeport';\nimport * as Log from '../log';\n\n/** Get a free port or assert a CLI command error. */\nexport async function getFreePortAsync(rangeStart: number): Promise<number> {\n  const port = await freePortAsync(rangeStart, [null, 'localhost']);\n  if (!port) {\n    throw new CommandError('NO_PORT_FOUND', 'No available port found');\n  }\n\n  return port;\n}\n\n/** @return `true` if the port can still be used to start the dev server, `false` if the dev server should be skipped, and asserts if the port is now taken. */\nexport async function ensurePortAvailabilityAsync(\n  projectRoot: string,\n  { port }: { port: number }\n): Promise<boolean> {\n  const isFreePort = await testPortAsync(port, [null]);\n  // Check if port has become busy during the build.\n  if (isFreePort) {\n    return true;\n  }\n\n  const isBusy = await isBusyPortRunningSameProcessAsync(projectRoot, { port });\n  if (!isBusy) {\n    throw new CommandError(\n      `Port \"${port}\" became busy running another process while the app was compiling. Re-run command to use a new port.`\n    );\n  }\n\n  // Log that the dev server will not be started and that the logs will appear in another window.\n  Log.log(\n    '› The dev server for this app is already running in another window. Logs will appear there.'\n  );\n  return false;\n}\n\nfunction isRestrictedPort(port: number) {\n  if (process.platform !== 'win32' && port < 1024) {\n    const isRoot = process.getuid && process.getuid() === 0;\n    return !isRoot;\n  }\n  return false;\n}\n\nasync function isBusyPortRunningSameProcessAsync(projectRoot: string, { port }: { port: number }) {\n  const { getRunningProcess } =\n    require('./getRunningProcess') as typeof import('./getRunningProcess');\n  const runningProcess = isRestrictedPort(port) ? null : await getRunningProcess(port);\n  if (runningProcess) {\n    if (runningProcess.directory === projectRoot) {\n      return true;\n    } else {\n      return false;\n    }\n  }\n\n  return null;\n}\n\n// TODO(Bacon): Revisit after all start and run code is merged.\nexport async function choosePortAsync(\n  projectRoot: string,\n  {\n    defaultPort,\n    host,\n    reuseExistingPort,\n  }: {\n    defaultPort: number;\n    host?: string;\n    reuseExistingPort?: boolean;\n  }\n): Promise<number | null> {\n  try {\n    const port = await freePortAsync(defaultPort, [host ?? null]);\n    if (port === defaultPort || defaultPort === 0) {\n      return port;\n    }\n\n    const isRestricted = port && isRestrictedPort(port);\n\n    let message = isRestricted\n      ? `Admin permissions are required to run a server on a port below 1024`\n      : `Port ${chalk.bold(defaultPort)} is`;\n\n    const { getRunningProcess } =\n      require('./getRunningProcess') as typeof import('./getRunningProcess');\n    const runningProcess = isRestricted ? null : await getRunningProcess(defaultPort);\n\n    if (runningProcess) {\n      const pidTag = chalk.gray(`(pid ${runningProcess.pid})`);\n      if (runningProcess.directory === projectRoot) {\n        message += ` running this app in another window`;\n        if (reuseExistingPort) {\n          return null;\n        }\n      } else {\n        message += ` running ${chalk.cyan(runningProcess.command)} in another window`;\n      }\n      message += '\\n' + chalk.gray(`  ${runningProcess.directory} ${pidTag}`);\n    } else {\n      message += ' being used by another process';\n    }\n\n    Log.log(`\\u203A ${message}`);\n    const { confirmAsync } = require('./prompts') as typeof import('./prompts');\n    const change = await confirmAsync({\n      message: `Use port ${port} instead?`,\n      initial: true,\n    });\n    return change ? port : null;\n  } catch (error: any) {\n    if (error.code === 'ABORTED') {\n      throw error;\n    } else if (error.code === 'NON_INTERACTIVE') {\n      Log.warn(chalk.yellow(error.message));\n      return null;\n    }\n    throw error;\n  }\n}\n\n// TODO(Bacon): Revisit after all start and run code is merged.\nexport async function resolvePortAsync(\n  projectRoot: string,\n  {\n    /** Should opt to reuse a port that is running the same project in another window. */\n    reuseExistingPort,\n    /** Preferred port. */\n    defaultPort,\n    /** Backup port for when the default isn't available. */\n    fallbackPort,\n  }: {\n    reuseExistingPort?: boolean;\n    defaultPort?: string | number;\n    fallbackPort?: number;\n  } = {}\n): Promise<number | null> {\n  let port: number;\n  if (typeof defaultPort === 'string') {\n    port = parseInt(defaultPort, 10);\n  } else if (typeof defaultPort === 'number') {\n    port = defaultPort;\n  } else {\n    port = env.RCT_METRO_PORT || fallbackPort || 8081;\n  }\n\n  // Only check the port when the bundler is running.\n  const resolvedPort = await choosePortAsync(projectRoot, {\n    defaultPort: port,\n    reuseExistingPort,\n  });\n  if (resolvedPort == null) {\n    Log.log('\\u203A Skipping dev server');\n    // Skip bundling if the port is null\n  } else {\n    // Use the new or resolved port\n    process.env.RCT_METRO_PORT = String(resolvedPort);\n  }\n\n  return resolvedPort;\n}\n"],"names":["choosePortAsync","ensurePortAvailabilityAsync","getFreePortAsync","resolvePortAsync","rangeStart","port","freePortAsync","CommandError","projectRoot","isFreePort","testPortAsync","isBusy","isBusyPortRunningSameProcessAsync","Log","log","isRestrictedPort","process","platform","isRoot","getuid","getRunningProcess","require","runningProcess","directory","defaultPort","host","reuseExistingPort","isRestricted","message","chalk","bold","pidTag","gray","pid","cyan","command","confirmAsync","change","initial","error","code","warn","yellow","fallbackPort","parseInt","env","RCT_METRO_PORT","resolvedPort","String"],"mappings":"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"}

package/build/src/utils/qr.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "printQRCode", {
+    enumerable: true,
+    get: function() {
+        return printQRCode;
+    }
+});
+function _nodetty() {
+    const data = /*#__PURE__*/ _interop_require_default(require("node:tty"));
+    _nodetty = function() {
+        return data;
+    };
+    return data;
+}
+function _toqr() {
+    const data = require("toqr");
+    _toqr = function() {
+        return data;
+    };
+    return data;
+}
+const _env = require("./env");
+const _log = /*#__PURE__*/ _interop_require_wildcard(require("../log"));
+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 printQRCode(url) {
+    const qr = (0, _toqr().toQR)(url);
+    const output = supportsSextants() ? createSextantOutput(qr) : createHalfblockOutput(qr);
+    return {
+        lines: output.split('\n').length,
+        print () {
+            _log.log(output);
+        }
+    };
+}
+/** On specific terminals we can print a smaller QR code */ function supportsSextants() {
+    var _process_env_WT_SESSION, _process_env_KITTY_WINDOW_ID, _process_env_ALACRITTY_WINDOW_ID;
+    if (_env.env.CI || !_nodetty().default.isatty(1) || !_nodetty().default.isatty(2)) {
+        return false;
+    } else if (process.env.COLOR === '0' || process.env.COLOR === 'false') {
+        return false;
+    }
+    const isWindowsTerminal = process.platform === 'win32' && !!((_process_env_WT_SESSION = process.env.WT_SESSION) == null ? void 0 : _process_env_WT_SESSION.length);
+    const isGhostty = process.env.TERM_PROGRAM === 'ghostty';
+    const isWezterm = process.env.TERM_PROGRAM === 'WezTerm';
+    const isKitty = !!((_process_env_KITTY_WINDOW_ID = process.env.KITTY_WINDOW_ID) == null ? void 0 : _process_env_KITTY_WINDOW_ID.length);
+    const isAlacritty = !!((_process_env_ALACRITTY_WINDOW_ID = process.env.ALACRITTY_WINDOW_ID) == null ? void 0 : _process_env_ALACRITTY_WINDOW_ID.length);
+    return isWindowsTerminal || isGhostty || isWezterm || isKitty || isAlacritty;
+}
+/** ANSI QR code output by using half-blocks (1x2-sized unicode blocks) */ function createHalfblockOutput(data) {
+    const extent = Math.sqrt(data.byteLength) | 0;
+    const CHAR_00 = '\u2588';
+    const CHAR_10 = '\u2584';
+    const CHAR_01 = '\u2580';
+    const CHAR_11 = ' ';
+    let output = '';
+    output += CHAR_10.repeat(extent + 2);
+    for(let row = 0; row < extent; row += 2){
+        output += '\n' + CHAR_00;
+        for(let col = 0; col < extent; col++){
+            const value = data[row * extent + col] << 1 | data[(row + 1) * extent + col];
+            switch(value){
+                case 0:
+                    output += CHAR_00;
+                    break;
+                case 1:
+                    output += CHAR_01;
+                    break;
+                case 2:
+                    output += CHAR_10;
+                    break;
+                case 3:
+                    output += CHAR_11;
+                    break;
+            }
+        }
+        output += CHAR_00;
+    }
+    if (extent % 2 === 0) {
+        output += '\n' + CHAR_01.repeat(extent + 2);
+    }
+    output += '\n';
+    return output;
+}
+/** ANSI QR code output by using sextant-blocks (2x3-sized unicode blocks) */ function createSextantOutput(data) {
+    const getChar = (p)=>{
+        // Invert then reverse
+        let char = p ^ 63;
+        char = (char & 0xaa) >> 1 | (char & 0x55) << 1;
+        char = (char & 0xcc) >> 2 | (char & 0x33) << 2;
+        char = char >> 4 | char << 4;
+        char = char >> 2 & 63;
+        switch(char){
+            case 0:
+                return ' ';
+            case 63:
+                return '\u2588';
+            case 21:
+                return '\u258C';
+            case 42:
+                return '\u2590';
+            default:
+                return String.fromCodePoint(0x1fb00 + char - 1 - (char > 21 ? 1 : 0) - (char > 42 ? 1 : 0));
+        }
+    };
+    const extent = Math.sqrt(data.byteLength) | 0;
+    const padded = extent + 2;
+    let output = '';
+    for(let baseRow = 0; baseRow < padded; baseRow += 3){
+        if (baseRow) output += '\n';
+        for(let baseCol = 0; baseCol < padded; baseCol += 2){
+            let p = 0;
+            for(let dr = 0; dr < 3; dr++){
+                for(let dc = 0; dc < 2; dc++){
+                    const r = baseRow + dr;
+                    const c = baseCol + dc;
+                    const bit = 5 - (dr * 2 + dc);
+                    let cell = 1; // default empty (out of bounds)
+                    if (r < padded && c < padded) {
+                        if (r === 0 || c === 0 || r === padded - 1 || c === padded - 1) {
+                            cell = 0; // border is filled
+                        } else if (r <= extent && c <= extent) {
+                            cell = data[(r - 1) * extent + (c - 1)];
+                        }
+                    }
+                    p |= (cell & 1) << bit;
+                }
+            }
+            output += getChar(p);
+        }
+    }
+    if (padded % 3 === 0) {
+        // Only add newline if the padded output lines up with a newline exactly
+        output += '\n';
+    }
+    return output;
+}
+
+//# sourceMappingURL=qr.js.map