@depup/expo__cli 55.0.16-depup.0

package/build/src/utils/exit.js

@@ -0,0 +1,210 @@
+"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, {
+    ensureProcessExitsAfterDelay: function() {
+        return ensureProcessExitsAfterDelay;
+    },
+    installExitHooks: function() {
+        return installExitHooks;
+    }
+});
+function _nodechild_process() {
+    const data = require("node:child_process");
+    _nodechild_process = function() {
+        return data;
+    };
+    return data;
+}
+function _nodeprocess() {
+    const data = /*#__PURE__*/ _interop_require_default(require("node:process"));
+    _nodeprocess = function() {
+        return data;
+    };
+    return data;
+}
+const _fn = require("./fn");
+const _log = require("../log");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const debug = require('debug')('expo:utils:exit');
+const PRE_EXIT_SIGNALS = [
+    'SIGHUP',
+    'SIGINT',
+    'SIGTERM',
+    'SIGBREAK'
+];
+// We create a queue since Node.js throws an error if we try to append too many listeners:
+// (node:4405) MaxListenersExceededWarning: Possible EventEmitter memory leak detected. 11 SIGINT listeners added to [process]. Use emitter.setMaxListeners() to increase limit
+const queue = [];
+let unsubscribe = null;
+function installExitHooks(asyncExitHook) {
+    // We need to instantiate the master listener the first time the queue is used.
+    if (!queue.length) {
+        // Track the master listener so we can remove it later.
+        unsubscribe = attachMasterListener();
+    }
+    queue.push(asyncExitHook);
+    return ()=>{
+        const index = queue.indexOf(asyncExitHook);
+        if (index >= 0) {
+            queue.splice(index, 1);
+        }
+        // Clean up the master listener if we don't need it anymore.
+        if (!queue.length) {
+            unsubscribe == null ? void 0 : unsubscribe();
+        }
+    };
+}
+// Create a function that runs before the process exits and guards against running multiple times.
+function createExitHook(signal) {
+    return (0, _fn.guardAsync)(async ()=>{
+        debug(`pre-exit (signal: ${signal}, queue length: ${queue.length})`);
+        for (const [index, hookAsync] of Object.entries(queue)){
+            try {
+                await hookAsync(signal);
+            } catch (error) {
+                debug(`Error in exit hook: %O (queue: ${index})`, error);
+            }
+        }
+        debug(`post-exit (code: ${_nodeprocess().default.exitCode ?? 0})`);
+        _nodeprocess().default.exit();
+    });
+}
+function attachMasterListener() {
+    const hooks = [];
+    for (const signal of PRE_EXIT_SIGNALS){
+        const hook = createExitHook(signal);
+        hooks.push([
+            signal,
+            hook
+        ]);
+        _nodeprocess().default.on(signal, hook);
+    }
+    return ()=>{
+        for (const [signal, hook] of hooks){
+            _nodeprocess().default.removeListener(signal, hook);
+        }
+    };
+}
+function ensureProcessExitsAfterDelay(waitUntilExitMs = 10000, startedAtMs = Date.now()) {
+    // Create a list of the expected active resources before exiting.
+    // Note, the order is undeterministic
+    const expectedResources = [
+        _nodeprocess().default.stdout.isTTY ? 'TTYWrap' : 'PipeWrap',
+        _nodeprocess().default.stderr.isTTY ? 'TTYWrap' : 'PipeWrap',
+        _nodeprocess().default.stdin.isTTY ? 'TTYWrap' : 'PipeWrap'
+    ];
+    // Check active resources, besides the TTYWrap/PipeWrap (process.stdin, process.stdout, process.stderr)
+    const activeResources = _nodeprocess().default.getActiveResourcesInfo();
+    // Filter the active resource list by subtracting the expected resources, in undeterministic order
+    const unexpectedActiveResources = activeResources.filter((activeResource)=>{
+        const index = expectedResources.indexOf(activeResource);
+        if (index >= 0) {
+            expectedResources.splice(index, 1);
+            return false;
+        }
+        return true;
+    });
+    // Check if only Timeouts remain (no blocking resources like ProcessWrap/PipeWrap)
+    const hasBlockingResources = unexpectedActiveResources.some((resource)=>resource !== 'Timeout' && resource !== 'CloseReq');
+    const canExitProcess = !unexpectedActiveResources.length || !hasBlockingResources;
+    if (canExitProcess) {
+        if (unexpectedActiveResources.length && !hasBlockingResources) {
+            debug('only non-blocking resources remain (Timeout/CloseReq), process can safely exit');
+        } else {
+            debug('no active resources detected, process can safely exit');
+        }
+        return;
+    } else {
+        debug(`process is trying to exit, but is stuck on unexpected active resources:`, unexpectedActiveResources);
+    }
+    // Check if the process needs to be force-closed
+    const elapsedTime = Date.now() - startedAtMs;
+    if (elapsedTime > waitUntilExitMs) {
+        debug('active handles detected past the exit delay, forcefully exiting:', activeResources);
+        tryWarnActiveProcesses();
+        return _nodeprocess().default.exit(0);
+    }
+    const timeoutId = setTimeout(()=>{
+        // Ensure the timeout is cleared before checking the active resources
+        clearTimeout(timeoutId);
+        // Check if the process can exit
+        ensureProcessExitsAfterDelay(waitUntilExitMs, startedAtMs);
+    // setTimeout is using the global definitions from React Native which is missing the unref method in Node.js.
+    }, 100);
+    // Unref the timeout so it doesn't prevent the process from exiting naturally
+    // when this timeout is the only remaining active resource
+    timeoutId.unref();
+}
+/**
+ * Try to warn the user about unexpected active processes running in the background.
+ * This uses the internal `process._getActiveHandles` method, within a try-catch block.
+ * If active child processes are detected, the commands of these processes are logged.
+ *
+ * @example ```bash
+ * Done writing bundle output
+ * Detected 2 processes preventing Expo from exiting, forcefully exiting now.
+ *   - node /Users/cedric/../node_modules/nativewind/dist/metro/tailwind/v3/child.js
+ *   - node /Users/cedric/../node_modules/nativewind/dist/metro/tailwind/v3/child.js
+ * ```
+ */ function tryWarnActiveProcesses() {
+    const activeProcesses = [];
+    const handleSummary = {};
+    const timeoutDetails = [];
+    try {
+        const handles = _nodeprocess().default._getActiveHandles();
+        // Categorize handles by their constructor name
+        for (const handle of handles){
+            var _handle_constructor;
+            const name = (handle == null ? void 0 : (_handle_constructor = handle.constructor) == null ? void 0 : _handle_constructor.name) ?? 'Unknown';
+            handleSummary[name] = (handleSummary[name] ?? 0) + 1;
+            // Collect ChildProcess command info
+            if (handle instanceof _nodechild_process().ChildProcess) {
+                activeProcesses.push(handle.spawnargs.join(' '));
+            }
+            // Try to get more info about Timeout handles
+            if (name === 'Timeout') {
+                try {
+                    // Attempt to get callback name or source info
+                    const callback = handle._onTimeout ?? handle._repeat;
+                    const callbackName = (callback == null ? void 0 : callback.name) || '<anonymous>';
+                    const delay = handle._idleTimeout ?? 'unknown';
+                    timeoutDetails.push(`Timeout(${delay}ms, fn: ${callbackName})`);
+                } catch  {
+                    timeoutDetails.push('Timeout(details unavailable)');
+                }
+            }
+        }
+        // Log detailed handle info when debug is enabled
+        debug('active handles by type:', handleSummary);
+        if (timeoutDetails.length) {
+            debug('timeout details:', timeoutDetails);
+        }
+    } catch (error) {
+        debug('failed to get active process information:', error);
+    }
+    if (!activeProcesses.length) {
+        (0, _log.warn)('Something prevented Expo from exiting, forcefully exiting now.');
+        // Log handle summary when no specific processes are identified
+        if (Object.keys(handleSummary).length > 0) {
+            debug('handle summary (use DEBUG=expo:utils:exit for details):', handleSummary);
+        }
+    } else {
+        const singularOrPlural = activeProcesses.length === 1 ? '1 process' : `${activeProcesses.length} processes`;
+        (0, _log.warn)(`Detected ${singularOrPlural} preventing Expo from exiting, forcefully exiting now.`);
+        (0, _log.warn)('  - ' + activeProcesses.join('\n  - '));
+    }
+}
+
+//# sourceMappingURL=exit.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/exit.ts"],"sourcesContent":["import { ChildProcess } from 'node:child_process';\nimport process from 'node:process';\n\nimport { guardAsync } from './fn';\nimport { warn } from '../log';\n\nconst debug = require('debug')('expo:utils:exit') as typeof console.log;\n\n// NOTE: This is an internal method, not designed to be exposed. It's also our only way to get this info\ndeclare global {\n  namespace NodeJS {\n    interface Process {\n      _getActiveHandles(): readonly any[];\n    }\n  }\n}\n\ntype AsyncExitHook = (signal: NodeJS.Signals) => void | Promise<void>;\n\nconst PRE_EXIT_SIGNALS: NodeJS.Signals[] = ['SIGHUP', 'SIGINT', 'SIGTERM', 'SIGBREAK'];\n\n// We create a queue since Node.js throws an error if we try to append too many listeners:\n// (node:4405) MaxListenersExceededWarning: Possible EventEmitter memory leak detected. 11 SIGINT listeners added to [process]. Use emitter.setMaxListeners() to increase limit\nconst queue: AsyncExitHook[] = [];\n\nlet unsubscribe: (() => void) | null = null;\n\n/** Add functions that run before the process exits. Returns a function for removing the listeners. */\nexport function installExitHooks(asyncExitHook: AsyncExitHook): () => void {\n  // We need to instantiate the master listener the first time the queue is used.\n  if (!queue.length) {\n    // Track the master listener so we can remove it later.\n    unsubscribe = attachMasterListener();\n  }\n\n  queue.push(asyncExitHook);\n\n  return () => {\n    const index = queue.indexOf(asyncExitHook);\n    if (index >= 0) {\n      queue.splice(index, 1);\n    }\n    // Clean up the master listener if we don't need it anymore.\n    if (!queue.length) {\n      unsubscribe?.();\n    }\n  };\n}\n\n// Create a function that runs before the process exits and guards against running multiple times.\nfunction createExitHook(signal: NodeJS.Signals) {\n  return guardAsync(async () => {\n    debug(`pre-exit (signal: ${signal}, queue length: ${queue.length})`);\n\n    for (const [index, hookAsync] of Object.entries(queue)) {\n      try {\n        await hookAsync(signal);\n      } catch (error: any) {\n        debug(`Error in exit hook: %O (queue: ${index})`, error);\n      }\n    }\n\n    debug(`post-exit (code: ${process.exitCode ?? 0})`);\n\n    process.exit();\n  });\n}\n\nfunction attachMasterListener() {\n  const hooks: [NodeJS.Signals, () => any][] = [];\n  for (const signal of PRE_EXIT_SIGNALS) {\n    const hook = createExitHook(signal);\n    hooks.push([signal, hook]);\n    process.on(signal, hook);\n  }\n  return () => {\n    for (const [signal, hook] of hooks) {\n      process.removeListener(signal, hook);\n    }\n  };\n}\n\n/**\n * Monitor if the current process is exiting before the delay is reached.\n * If there are active resources, the process will be forced to exit after the delay is reached.\n *\n * @see https://nodejs.org/docs/latest-v18.x/api/process.html#processgetactiveresourcesinfo\n */\nexport function ensureProcessExitsAfterDelay(waitUntilExitMs = 10000, startedAtMs = Date.now()) {\n  // Create a list of the expected active resources before exiting.\n  // Note, the order is undeterministic\n  const expectedResources = [\n    process.stdout.isTTY ? 'TTYWrap' : 'PipeWrap',\n    process.stderr.isTTY ? 'TTYWrap' : 'PipeWrap',\n    process.stdin.isTTY ? 'TTYWrap' : 'PipeWrap',\n  ];\n  // Check active resources, besides the TTYWrap/PipeWrap (process.stdin, process.stdout, process.stderr)\n  const activeResources = process.getActiveResourcesInfo() as string[];\n  // Filter the active resource list by subtracting the expected resources, in undeterministic order\n  const unexpectedActiveResources = activeResources.filter((activeResource) => {\n    const index = expectedResources.indexOf(activeResource);\n    if (index >= 0) {\n      expectedResources.splice(index, 1);\n      return false;\n    }\n\n    return true;\n  });\n\n  // Check if only Timeouts remain (no blocking resources like ProcessWrap/PipeWrap)\n  const hasBlockingResources = unexpectedActiveResources.some(\n    (resource) => resource !== 'Timeout' && resource !== 'CloseReq'\n  );\n\n  const canExitProcess = !unexpectedActiveResources.length || !hasBlockingResources;\n  if (canExitProcess) {\n    if (unexpectedActiveResources.length && !hasBlockingResources) {\n      debug('only non-blocking resources remain (Timeout/CloseReq), process can safely exit');\n    } else {\n      debug('no active resources detected, process can safely exit');\n    }\n    return;\n  } else {\n    debug(\n      `process is trying to exit, but is stuck on unexpected active resources:`,\n      unexpectedActiveResources\n    );\n  }\n\n  // Check if the process needs to be force-closed\n  const elapsedTime = Date.now() - startedAtMs;\n  if (elapsedTime > waitUntilExitMs) {\n    debug('active handles detected past the exit delay, forcefully exiting:', activeResources);\n    tryWarnActiveProcesses();\n    return process.exit(0);\n  }\n\n  const timeoutId = setTimeout(() => {\n    // Ensure the timeout is cleared before checking the active resources\n    clearTimeout(timeoutId);\n    // Check if the process can exit\n    ensureProcessExitsAfterDelay(waitUntilExitMs, startedAtMs);\n\n    // setTimeout is using the global definitions from React Native which is missing the unref method in Node.js.\n  }, 100) as unknown as NodeJS.Timeout;\n\n  // Unref the timeout so it doesn't prevent the process from exiting naturally\n  // when this timeout is the only remaining active resource\n  timeoutId.unref();\n}\n\n/**\n * Try to warn the user about unexpected active processes running in the background.\n * This uses the internal `process._getActiveHandles` method, within a try-catch block.\n * If active child processes are detected, the commands of these processes are logged.\n *\n * @example ```bash\n * Done writing bundle output\n * Detected 2 processes preventing Expo from exiting, forcefully exiting now.\n *   - node /Users/cedric/../node_modules/nativewind/dist/metro/tailwind/v3/child.js\n *   - node /Users/cedric/../node_modules/nativewind/dist/metro/tailwind/v3/child.js\n * ```\n */\nfunction tryWarnActiveProcesses() {\n  const activeProcesses: string[] = [];\n  const handleSummary: Record<string, number> = {};\n  const timeoutDetails: string[] = [];\n\n  try {\n    const handles = process._getActiveHandles();\n\n    // Categorize handles by their constructor name\n    for (const handle of handles) {\n      const name = handle?.constructor?.name ?? 'Unknown';\n      handleSummary[name] = (handleSummary[name] ?? 0) + 1;\n\n      // Collect ChildProcess command info\n      if (handle instanceof ChildProcess) {\n        activeProcesses.push(handle.spawnargs.join(' '));\n      }\n\n      // Try to get more info about Timeout handles\n      if (name === 'Timeout') {\n        try {\n          // Attempt to get callback name or source info\n          const callback = handle._onTimeout ?? handle._repeat;\n          const callbackName = callback?.name || '<anonymous>';\n          const delay = handle._idleTimeout ?? 'unknown';\n          timeoutDetails.push(`Timeout(${delay}ms, fn: ${callbackName})`);\n        } catch {\n          timeoutDetails.push('Timeout(details unavailable)');\n        }\n      }\n    }\n\n    // Log detailed handle info when debug is enabled\n    debug('active handles by type:', handleSummary);\n    if (timeoutDetails.length) {\n      debug('timeout details:', timeoutDetails);\n    }\n  } catch (error) {\n    debug('failed to get active process information:', error);\n  }\n\n  if (!activeProcesses.length) {\n    warn('Something prevented Expo from exiting, forcefully exiting now.');\n    // Log handle summary when no specific processes are identified\n    if (Object.keys(handleSummary).length > 0) {\n      debug('handle summary (use DEBUG=expo:utils:exit for details):', handleSummary);\n    }\n  } else {\n    const singularOrPlural =\n      activeProcesses.length === 1 ? '1 process' : `${activeProcesses.length} processes`;\n\n    warn(`Detected ${singularOrPlural} preventing Expo from exiting, forcefully exiting now.`);\n    warn('  - ' + activeProcesses.join('\\n  - '));\n  }\n}\n"],"names":["ensureProcessExitsAfterDelay","installExitHooks","debug","require","PRE_EXIT_SIGNALS","queue","unsubscribe","asyncExitHook","length","attachMasterListener","push","index","indexOf","splice","createExitHook","signal","guardAsync","hookAsync","Object","entries","error","process","exitCode","exit","hooks","hook","on","removeListener","waitUntilExitMs","startedAtMs","Date","now","expectedResources","stdout","isTTY","stderr","stdin","activeResources","getActiveResourcesInfo","unexpectedActiveResources","filter","activeResource","hasBlockingResources","some","resource","canExitProcess","elapsedTime","tryWarnActiveProcesses","timeoutId","setTimeout","clearTimeout","unref","activeProcesses","handleSummary","timeoutDetails","handles","_getActiveHandles","handle","name","constructor","ChildProcess","spawnargs","join","callback","_onTimeout","_repeat","callbackName","delay","_idleTimeout","warn","keys","singularOrPlural"],"mappings":"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"}

package/build/src/utils/expoUpdatesCli.js

@@ -0,0 +1,120 @@
+"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, {
+    ExpoUpdatesCLICommandFailedError: function() {
+        return ExpoUpdatesCLICommandFailedError;
+    },
+    ExpoUpdatesCLIInvalidCommandError: function() {
+        return ExpoUpdatesCLIInvalidCommandError;
+    },
+    ExpoUpdatesCLIModuleNotFoundError: function() {
+        return ExpoUpdatesCLIModuleNotFoundError;
+    },
+    expoUpdatesCommandAsync: function() {
+        return expoUpdatesCommandAsync;
+    }
+});
+function _spawnasync() {
+    const data = /*#__PURE__*/ _interop_require_default(require("@expo/spawn-async"));
+    _spawnasync = function() {
+        return data;
+    };
+    return data;
+}
+function _resolvefrom() {
+    const data = /*#__PURE__*/ _interop_require_wildcard(require("resolve-from"));
+    _resolvefrom = 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();
+    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;
+}
+class ExpoUpdatesCLIModuleNotFoundError extends Error {
+}
+class ExpoUpdatesCLIInvalidCommandError extends Error {
+}
+class ExpoUpdatesCLICommandFailedError extends Error {
+}
+async function expoUpdatesCommandAsync(projectDir, args) {
+    let expoUpdatesCli;
+    try {
+        expoUpdatesCli = (0, _resolvefrom().silent)(projectDir, 'expo-updates/bin/cli') ?? (0, _resolvefrom().default)(projectDir, 'expo-updates/bin/cli.js');
+    } catch (e) {
+        if (e.code === 'MODULE_NOT_FOUND') {
+            throw new ExpoUpdatesCLIModuleNotFoundError(`The \`expo-updates\` package was not found. `);
+        }
+        throw e;
+    }
+    try {
+        return (await (0, _spawnasync().default)(expoUpdatesCli, args, {
+            stdio: 'pipe',
+            env: {
+                ...process.env
+            }
+        })).stdout;
+    } catch (e) {
+        if (e.stderr && typeof e.stderr === 'string') {
+            if (e.stderr.includes('Invalid command')) {
+                throw new ExpoUpdatesCLIInvalidCommandError(`The command specified by ${args} was not valid in the \`expo-updates\` CLI.`);
+            } else {
+                throw new ExpoUpdatesCLICommandFailedError(e.stderr);
+            }
+        }
+        throw e;
+    }
+}
+
+//# sourceMappingURL=expoUpdatesCli.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/expoUpdatesCli.ts"],"sourcesContent":["import spawnAsync from '@expo/spawn-async';\nimport resolveFrom, { silent as silentResolveFrom } from 'resolve-from';\n\nexport class ExpoUpdatesCLIModuleNotFoundError extends Error {}\nexport class ExpoUpdatesCLIInvalidCommandError extends Error {}\nexport class ExpoUpdatesCLICommandFailedError extends Error {}\n\nexport async function expoUpdatesCommandAsync(projectDir: string, args: string[]): Promise<string> {\n  let expoUpdatesCli;\n  try {\n    expoUpdatesCli =\n      silentResolveFrom(projectDir, 'expo-updates/bin/cli') ??\n      resolveFrom(projectDir, 'expo-updates/bin/cli.js');\n  } catch (e: any) {\n    if (e.code === 'MODULE_NOT_FOUND') {\n      throw new ExpoUpdatesCLIModuleNotFoundError(`The \\`expo-updates\\` package was not found. `);\n    }\n    throw e;\n  }\n\n  try {\n    return (\n      await spawnAsync(expoUpdatesCli, args, {\n        stdio: 'pipe',\n        env: { ...process.env },\n      })\n    ).stdout;\n  } catch (e: any) {\n    if (e.stderr && typeof e.stderr === 'string') {\n      if (e.stderr.includes('Invalid command')) {\n        throw new ExpoUpdatesCLIInvalidCommandError(\n          `The command specified by ${args} was not valid in the \\`expo-updates\\` CLI.`\n        );\n      } else {\n        throw new ExpoUpdatesCLICommandFailedError(e.stderr);\n      }\n    }\n\n    throw e;\n  }\n}\n"],"names":["ExpoUpdatesCLICommandFailedError","ExpoUpdatesCLIInvalidCommandError","ExpoUpdatesCLIModuleNotFoundError","expoUpdatesCommandAsync","Error","projectDir","args","expoUpdatesCli","silentResolveFrom","resolveFrom","e","code","spawnAsync","stdio","env","process","stdout","stderr","includes"],"mappings":";;;;;;;;;;;IAKaA,gCAAgC;eAAhCA;;IADAC,iCAAiC;eAAjCA;;IADAC,iCAAiC;eAAjCA;;IAISC,uBAAuB;eAAvBA;;;;gEAPC;;;;;;;iEACkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAElD,MAAMD,0CAA0CE;AAAO;AACvD,MAAMH,0CAA0CG;AAAO;AACvD,MAAMJ,yCAAyCI;AAAO;AAEtD,eAAeD,wBAAwBE,UAAkB,EAAEC,IAAc;IAC9E,IAAIC;IACJ,IAAI;QACFA,iBACEC,IAAAA,qBAAiB,EAACH,YAAY,2BAC9BI,IAAAA,sBAAW,EAACJ,YAAY;IAC5B,EAAE,OAAOK,GAAQ;QACf,IAAIA,EAAEC,IAAI,KAAK,oBAAoB;YACjC,MAAM,IAAIT,kCAAkC,CAAC,4CAA4C,CAAC;QAC5F;QACA,MAAMQ;IACR;IAEA,IAAI;QACF,OAAO,AACL,CAAA,MAAME,IAAAA,qBAAU,EAACL,gBAAgBD,MAAM;YACrCO,OAAO;YACPC,KAAK;gBAAE,GAAGC,QAAQD,GAAG;YAAC;QACxB,EAAC,EACDE,MAAM;IACV,EAAE,OAAON,GAAQ;QACf,IAAIA,EAAEO,MAAM,IAAI,OAAOP,EAAEO,MAAM,KAAK,UAAU;YAC5C,IAAIP,EAAEO,MAAM,CAACC,QAAQ,CAAC,oBAAoB;gBACxC,MAAM,IAAIjB,kCACR,CAAC,yBAAyB,EAAEK,KAAK,2CAA2C,CAAC;YAEjF,OAAO;gBACL,MAAM,IAAIN,iCAAiCU,EAAEO,MAAM;YACrD;QACF;QAEA,MAAMP;IACR;AACF"}

package/build/src/utils/fetch.js

@@ -0,0 +1,41 @@
+"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, {
+    Headers: function() {
+        return _fetchnodeshim().Headers;
+    },
+    Response: function() {
+        return _fetchnodeshim().Response;
+    },
+    fetch: function() {
+        return _fetchnodeshim().fetch;
+    }
+});
+function _fetchnodeshim() {
+    const data = require("fetch-nodeshim");
+    _fetchnodeshim = function() {
+        return data;
+    };
+    return data;
+}
+// NOTE(@kitten): Protect against accidental use of globals that don't match `fetch-nodeshim`
+Object.assign(globalThis, {
+    fetch: _fetchnodeshim().fetch,
+    Blob: _fetchnodeshim().Blob,
+    URL: _fetchnodeshim().URL,
+    URLSearchParams: _fetchnodeshim().URLSearchParams,
+    Request: _fetchnodeshim().Request,
+    Response: _fetchnodeshim().Response,
+    Headers: _fetchnodeshim().Headers,
+    FormData: _fetchnodeshim().FormData
+});
+
+//# sourceMappingURL=fetch.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/fetch.ts"],"sourcesContent":["import {\n  fetch,\n  Blob,\n  URL,\n  URLSearchParams,\n  Request,\n  Response,\n  Headers,\n  FormData,\n} from 'fetch-nodeshim';\n\n// NOTE(@kitten): Protect against accidental use of globals that don't match `fetch-nodeshim`\nObject.assign(globalThis, {\n  fetch,\n  Blob,\n  URL,\n  URLSearchParams,\n  Request,\n  Response,\n  Headers,\n  FormData,\n});\n\nexport { fetch, Headers, Response };\n"],"names":["Headers","Response","fetch","Object","assign","globalThis","Blob","URL","URLSearchParams","Request","FormData"],"mappings":";;;;;;;;;;;IAuBgBA,OAAO;eAAPA,wBAAO;;IAAEC,QAAQ;eAARA,yBAAQ;;IAAxBC,KAAK;eAALA,sBAAK;;;;yBAdP;;;;;;AAEP,6FAA6F;AAC7FC,OAAOC,MAAM,CAACC,YAAY;IACxBH,OAAAA,sBAAK;IACLI,MAAAA,qBAAI;IACJC,KAAAA,oBAAG;IACHC,iBAAAA,gCAAe;IACfC,SAAAA,wBAAO;IACPR,UAAAA,yBAAQ;IACRD,SAAAA,wBAAO;IACPU,UAAAA,yBAAQ;AACV"}

package/build/src/utils/filePath.js

@@ -0,0 +1,42 @@
+"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, {
+    resolveRealEntryFilePath: function() {
+        return resolveRealEntryFilePath;
+    },
+    toPosixPath: function() {
+        return toPosixPath;
+    }
+});
+function _fs() {
+    const data = /*#__PURE__*/ _interop_require_default(require("fs"));
+    _fs = function() {
+        return data;
+    };
+    return data;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const REGEXP_REPLACE_SLASHES = /\\/g;
+function resolveRealEntryFilePath(projectRoot, entryFile) {
+    if (projectRoot.startsWith('/private/var') && entryFile.startsWith('/var')) {
+        return _fs().default.realpathSync(entryFile);
+    }
+    return entryFile;
+}
+function toPosixPath(filePath) {
+    return filePath.replace(REGEXP_REPLACE_SLASHES, '/');
+}
+
+//# sourceMappingURL=filePath.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/filePath.ts"],"sourcesContent":["import fs from 'fs';\n\nconst REGEXP_REPLACE_SLASHES = /\\\\/g;\n\n/**\n * This is a workaround for Metro not resolving entry file paths to their real location.\n * When running exports through `eas build --local` on macOS, the `/var/folders` path is used instead of `/private/var/folders`.\n *\n * See: https://github.com/expo/expo/issues/28890\n */\nexport function resolveRealEntryFilePath(projectRoot: string, entryFile: string): string {\n  if (projectRoot.startsWith('/private/var') && entryFile.startsWith('/var')) {\n    return fs.realpathSync(entryFile);\n  }\n\n  return entryFile;\n}\n\n/**\n * Convert any platform-specific path to a POSIX path.\n */\nexport function toPosixPath(filePath: string): string {\n  return filePath.replace(REGEXP_REPLACE_SLASHES, '/');\n}\n"],"names":["resolveRealEntryFilePath","toPosixPath","REGEXP_REPLACE_SLASHES","projectRoot","entryFile","startsWith","fs","realpathSync","filePath","replace"],"mappings":";;;;;;;;;;;IAUgBA,wBAAwB;eAAxBA;;IAWAC,WAAW;eAAXA;;;;gEArBD;;;;;;;;;;;AAEf,MAAMC,yBAAyB;AAQxB,SAASF,yBAAyBG,WAAmB,EAAEC,SAAiB;IAC7E,IAAID,YAAYE,UAAU,CAAC,mBAAmBD,UAAUC,UAAU,CAAC,SAAS;QAC1E,OAAOC,aAAE,CAACC,YAAY,CAACH;IACzB;IAEA,OAAOA;AACT;AAKO,SAASH,YAAYO,QAAgB;IAC1C,OAAOA,SAASC,OAAO,CAACP,wBAAwB;AAClD"}

package/build/src/utils/findUp.js

@@ -0,0 +1,61 @@
+"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, {
+    findFileInParents: function() {
+        return findFileInParents;
+    },
+    findUpProjectRootOrAssert: function() {
+        return findUpProjectRootOrAssert;
+    }
+});
+function _path() {
+    const data = /*#__PURE__*/ _interop_require_default(require("path"));
+    _path = function() {
+        return data;
+    };
+    return data;
+}
+function _resolvefrom() {
+    const data = /*#__PURE__*/ _interop_require_default(require("resolve-from"));
+    _resolvefrom = function() {
+        return data;
+    };
+    return data;
+}
+const _errors = require("../utils/errors");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function findUpProjectRootOrAssert(cwd) {
+    const projectRoot = findUpProjectRoot(cwd);
+    if (!projectRoot) {
+        throw new _errors.CommandError(`Project root directory not found (working directory: ${cwd})`);
+    }
+    return projectRoot;
+}
+function findUpProjectRoot(cwd) {
+    const found = _resolvefrom().default.silent(cwd, './package.json');
+    if (found) return _path().default.dirname(found);
+    const parent = _path().default.dirname(cwd);
+    if (parent === cwd) return null;
+    return findUpProjectRoot(parent);
+}
+function findFileInParents(cwd, fileName) {
+    const found = _resolvefrom().default.silent(cwd, `./${fileName}`);
+    if (found) return found;
+    const parent = _path().default.dirname(cwd);
+    if (parent === cwd) return null;
+    return findFileInParents(parent, fileName);
+}
+
+//# sourceMappingURL=findUp.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/findUp.ts"],"sourcesContent":["import path from 'path';\nimport resolveFrom from 'resolve-from';\n\nimport { CommandError } from '../utils/errors';\n\n/** Look up directories until one with a `package.json` can be found, assert if none can be found. */\nexport function findUpProjectRootOrAssert(cwd: string): string {\n  const projectRoot = findUpProjectRoot(cwd);\n  if (!projectRoot) {\n    throw new CommandError(`Project root directory not found (working directory: ${cwd})`);\n  }\n  return projectRoot;\n}\n\nfunction findUpProjectRoot(cwd: string): string | null {\n  const found = resolveFrom.silent(cwd, './package.json');\n  if (found) return path.dirname(found);\n\n  const parent = path.dirname(cwd);\n  if (parent === cwd) return null;\n\n  return findUpProjectRoot(parent);\n}\n\n/**\n * Find a file in the (closest) parent directories.\n * This will recursively look for the file, until the root directory is reached.\n */\nexport function findFileInParents(cwd: string, fileName: string): string | null {\n  const found = resolveFrom.silent(cwd, `./${fileName}`);\n  if (found) return found;\n\n  const parent = path.dirname(cwd);\n  if (parent === cwd) return null;\n\n  return findFileInParents(parent, fileName);\n}\n"],"names":["findFileInParents","findUpProjectRootOrAssert","cwd","projectRoot","findUpProjectRoot","CommandError","found","resolveFrom","silent","path","dirname","parent","fileName"],"mappings":";;;;;;;;;;;IA4BgBA,iBAAiB;eAAjBA;;IAtBAC,yBAAyB;eAAzBA;;;;gEANC;;;;;;;gEACO;;;;;;wBAEK;;;;;;AAGtB,SAASA,0BAA0BC,GAAW;IACnD,MAAMC,cAAcC,kBAAkBF;IACtC,IAAI,CAACC,aAAa;QAChB,MAAM,IAAIE,oBAAY,CAAC,CAAC,qDAAqD,EAAEH,IAAI,CAAC,CAAC;IACvF;IACA,OAAOC;AACT;AAEA,SAASC,kBAAkBF,GAAW;IACpC,MAAMI,QAAQC,sBAAW,CAACC,MAAM,CAACN,KAAK;IACtC,IAAII,OAAO,OAAOG,eAAI,CAACC,OAAO,CAACJ;IAE/B,MAAMK,SAASF,eAAI,CAACC,OAAO,CAACR;IAC5B,IAAIS,WAAWT,KAAK,OAAO;IAE3B,OAAOE,kBAAkBO;AAC3B;AAMO,SAASX,kBAAkBE,GAAW,EAAEU,QAAgB;IAC7D,MAAMN,QAAQC,sBAAW,CAACC,MAAM,CAACN,KAAK,CAAC,EAAE,EAAEU,UAAU;IACrD,IAAIN,OAAO,OAAOA;IAElB,MAAMK,SAASF,eAAI,CAACC,OAAO,CAACR;IAC5B,IAAIS,WAAWT,KAAK,OAAO;IAE3B,OAAOF,kBAAkBW,QAAQC;AACnC"}

package/build/src/utils/fn.js

@@ -0,0 +1,44 @@
+/** `lodash.memoize` */ "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, {
+    guardAsync: function() {
+        return guardAsync;
+    },
+    memoize: function() {
+        return memoize;
+    }
+});
+function memoize(fn) {
+    const cache = new Map();
+    return (...args)=>{
+        const key = JSON.stringify(args);
+        if (cache.has(key)) {
+            return cache.get(key);
+        }
+        const result = fn(...args);
+        cache.set(key, result);
+        return result;
+    };
+}
+function guardAsync(fn) {
+    let invoked = false;
+    let returnValue;
+    const guard = async (...args)=>{
+        if (!invoked) {
+            invoked = true;
+            returnValue = await fn(...args);
+        }
+        return returnValue;
+    };
+    return guard;
+}
+
+//# sourceMappingURL=fn.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/fn.ts"],"sourcesContent":["/** `lodash.memoize` */\nexport function memoize<T extends (...args: any[]) => any>(fn: T): T {\n  const cache = new Map<string, any>();\n  return ((...args: any[]) => {\n    const key = JSON.stringify(args);\n    if (cache.has(key)) {\n      return cache.get(key);\n    }\n    const result = fn(...args);\n    cache.set(key, result);\n    return result;\n  }) as T;\n}\n\n/** memoizes an async function to prevent subsequent calls that might be invoked before the function has finished resolving. */\nexport function guardAsync<V, T extends (...args: any[]) => Promise<V>>(fn: T): T {\n  let invoked = false;\n  let returnValue: V;\n\n  const guard: any = async (...args: any[]): Promise<V> => {\n    if (!invoked) {\n      invoked = true;\n      returnValue = await fn(...args);\n    }\n\n    return returnValue;\n  };\n\n  return guard;\n}\n"],"names":["guardAsync","memoize","fn","cache","Map","args","key","JSON","stringify","has","get","result","set","invoked","returnValue","guard"],"mappings":"AAAA,qBAAqB;;;;;;;;;;;IAeLA,UAAU;eAAVA;;IAdAC,OAAO;eAAPA;;;AAAT,SAASA,QAA2CC,EAAK;IAC9D,MAAMC,QAAQ,IAAIC;IAClB,OAAQ,CAAC,GAAGC;QACV,MAAMC,MAAMC,KAAKC,SAAS,CAACH;QAC3B,IAAIF,MAAMM,GAAG,CAACH,MAAM;YAClB,OAAOH,MAAMO,GAAG,CAACJ;QACnB;QACA,MAAMK,SAAST,MAAMG;QACrBF,MAAMS,GAAG,CAACN,KAAKK;QACf,OAAOA;IACT;AACF;AAGO,SAASX,WAAwDE,EAAK;IAC3E,IAAIW,UAAU;IACd,IAAIC;IAEJ,MAAMC,QAAa,OAAO,GAAGV;QAC3B,IAAI,CAACQ,SAAS;YACZA,UAAU;YACVC,cAAc,MAAMZ,MAAMG;QAC5B;QAEA,OAAOS;IACT;IAEA,OAAOC;AACT"}

package/build/src/utils/freeport.js

@@ -0,0 +1,70 @@
+"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, {
+    freePortAsync: function() {
+        return freePortAsync;
+    },
+    testPortAsync: function() {
+        return testPortAsync;
+    }
+});
+function _nodenet() {
+    const data = /*#__PURE__*/ _interop_require_default(require("node:net"));
+    _nodenet = function() {
+        return data;
+    };
+    return data;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+async function testHostPortAsync(port, host) {
+    return new Promise((resolve)=>{
+        const server = _nodenet().default.createServer();
+        server.listen({
+            port,
+            host
+        }, ()=>{
+            server.once('close', ()=>{
+                setTimeout(()=>resolve(true), 0);
+            });
+            server.close();
+        });
+        server.once('error', (_error)=>{
+            setTimeout(()=>resolve(false), 0);
+        });
+    });
+}
+async function testPortAsync(port, hostnames) {
+    if (!(hostnames == null ? void 0 : hostnames.length)) {
+        hostnames = [
+            null
+        ];
+    }
+    for (const host of hostnames){
+        if (!await testHostPortAsync(port, host)) {
+            return false;
+        }
+    }
+    return true;
+}
+async function freePortAsync(portStart, hostnames) {
+    for(let port = portStart; port <= 65535; port++){
+        if (await testPortAsync(port, hostnames)) {
+            return port;
+        }
+    }
+    return null;
+}
+
+//# sourceMappingURL=freeport.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/freeport.ts"],"sourcesContent":["import net from 'node:net';\n\nasync function testHostPortAsync(port: number, host: string | null): Promise<boolean> {\n  return new Promise((resolve) => {\n    const server = net.createServer();\n    server.listen({ port, host }, () => {\n      server.once('close', () => {\n        setTimeout(() => resolve(true), 0);\n      });\n      server.close();\n    });\n    server.once('error', (_error) => {\n      setTimeout(() => resolve(false), 0);\n    });\n  });\n}\n\nexport async function testPortAsync(port: number, hostnames?: (string | null)[]): Promise<boolean> {\n  if (!hostnames?.length) {\n    hostnames = [null];\n  }\n  for (const host of hostnames) {\n    if (!(await testHostPortAsync(port, host))) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport async function freePortAsync(\n  portStart: number,\n  hostnames?: (string | null)[]\n): Promise<number | null> {\n  for (let port = portStart; port <= 65_535; port++) {\n    if (await testPortAsync(port, hostnames)) {\n      return port;\n    }\n  }\n  return null;\n}\n"],"names":["freePortAsync","testPortAsync","testHostPortAsync","port","host","Promise","resolve","server","net","createServer","listen","once","setTimeout","close","_error","hostnames","length","portStart"],"mappings":";;;;;;;;;;;IA6BsBA,aAAa;eAAbA;;IAZAC,aAAa;eAAbA;;;;gEAjBN;;;;;;;;;;;AAEhB,eAAeC,kBAAkBC,IAAY,EAAEC,IAAmB;IAChE,OAAO,IAAIC,QAAQ,CAACC;QAClB,MAAMC,SAASC,kBAAG,CAACC,YAAY;QAC/BF,OAAOG,MAAM,CAAC;YAAEP;YAAMC;QAAK,GAAG;YAC5BG,OAAOI,IAAI,CAAC,SAAS;gBACnBC,WAAW,IAAMN,QAAQ,OAAO;YAClC;YACAC,OAAOM,KAAK;QACd;QACAN,OAAOI,IAAI,CAAC,SAAS,CAACG;YACpBF,WAAW,IAAMN,QAAQ,QAAQ;QACnC;IACF;AACF;AAEO,eAAeL,cAAcE,IAAY,EAAEY,SAA6B;IAC7E,IAAI,EAACA,6BAAAA,UAAWC,MAAM,GAAE;QACtBD,YAAY;YAAC;SAAK;IACpB;IACA,KAAK,MAAMX,QAAQW,UAAW;QAC5B,IAAI,CAAE,MAAMb,kBAAkBC,MAAMC,OAAQ;YAC1C,OAAO;QACT;IACF;IACA,OAAO;AACT;AAEO,eAAeJ,cACpBiB,SAAiB,EACjBF,SAA6B;IAE7B,IAAK,IAAIZ,OAAOc,WAAWd,QAAQ,OAAQA,OAAQ;QACjD,IAAI,MAAMF,cAAcE,MAAMY,YAAY;YACxC,OAAOZ;QACT;IACF;IACA,OAAO;AACT"}