expo-doctor 1.13.6-canary-20250722-599a28f → 1.14.0-canary-20250811-5c940c0

package/build/@expo/cli/src/api/endpoint.d.ts

@@ -0,0 +1,4 @@
+/** Get the URL for the expo.dev API. */
+export declare function getExpoApiBaseUrl(): string;
+/** Get the URL for the expo.dev website. */
+export declare function getExpoWebsiteBaseUrl(): string;

package/build/@expo/cli/src/api/getNativeModuleVersions.d.ts

@@ -0,0 +1,21 @@
+export type BundledNativeModules = Record<string, string>;
+/**
+ * The endpoint returns the list of bundled native modules for a given SDK version.
+ * The data is populated by the `et sync-bundled-native-modules` script from expo/expo repo.
+ * See the code for more details:
+ * https://github.com/expo/expo/blob/main/tools/src/commands/SyncBundledNativeModules.ts
+ *
+ * Example result:
+ * [
+ *   {
+ *     id: "79285187-e5c4-47f7-b6a9-664f5d16f0db",
+ *     sdkVersion: "41.0.0",
+ *     npmPackage: "expo-camera",
+ *     versionRange: "~10.1.0",
+ *     createdAt: "2021-04-29T09:34:32.825Z",
+ *     updatedAt: "2021-04-29T09:34:32.825Z"
+ *   },
+ *   ...
+ * ]
+ */
+export declare function getNativeModuleVersionsAsync(sdkVersion: string): Promise<BundledNativeModules>;

package/build/@expo/cli/src/api/rest/cache/FileSystemResponseCache.d.ts

@@ -0,0 +1,18 @@
+import type { ResponseCache, ResponseCacheEntry } from './ResponseCache';
+export declare class FileSystemResponseCache implements ResponseCache {
+    /** The absolute path to the directory used to store responses */
+    private cacheDirectory;
+    /** Optional auto-expiration for all stored responses */
+    private timeToLive?;
+    constructor(options: {
+        cacheDirectory: string;
+        ttl?: number;
+    });
+    private getFilePaths;
+    /** Retrieve the cache response, if any */
+    get(cacheKey: string): Promise<ResponseCacheEntry | undefined>;
+    /** Store the response for caching */
+    set(cacheKey: string, response: ResponseCacheEntry): Promise<ResponseCacheEntry | undefined>;
+    /** Remove the response from caching */
+    remove(cacheKey: string): Promise<void>;
+}

package/build/@expo/cli/src/api/rest/cache/ResponseCache.d.ts

@@ -0,0 +1,48 @@
+import type { Response, RequestInfo, RequestInit } from 'undici';
+export type ResponseCacheEntry = {
+    body: import('stream/web').ReadableStream;
+    info: ReturnType<typeof getResponseInfo>;
+};
+export interface ResponseCache {
+    /** Load the response info from cache, if any */
+    get(cacheKey: string): Promise<ResponseCacheEntry | undefined>;
+    /** Store the response info to cache, and return the cached info */
+    set(cacheKey: string, response: ResponseCacheEntry): Promise<ResponseCacheEntry | undefined>;
+    /** Remove a response entry from the cache */
+    remove(cacheKey: string): Promise<void>;
+}
+export declare function getResponseInfo(response: Response): {
+    url: string;
+    status: number;
+    statusText: string;
+    headers: {
+        [k: string]: string;
+    };
+};
+export declare function getRequestCacheKey(info: RequestInfo, init?: RequestInit): string;
+/** @internal Exposed for testing */
+export declare function getRequestInfoCacheData(info: RequestInfo): {
+    url: string;
+    credentials?: undefined;
+    destination?: undefined;
+    headers?: undefined;
+    integrity?: undefined;
+    method?: undefined;
+    redirect?: undefined;
+    referrer?: undefined;
+    referrerPolicy?: undefined;
+} | {
+    credentials: string;
+    destination: string;
+    headers: {
+        [k: string]: string;
+    };
+    integrity: string;
+    method: string;
+    redirect: import("undici-types").RequestRedirect;
+    referrer: string;
+    referrerPolicy: import("undici-types").ReferrerPolicy;
+    url: string;
+};
+/** @internal Exposed for testing */
+export declare function getRequestBodyCacheData(body: RequestInit['body']): string | Buffer<ArrayBufferLike> | null | undefined;

package/build/@expo/cli/src/api/rest/cache/wrapFetchWithCache.d.ts

@@ -0,0 +1,3 @@
+import { type ResponseCache } from './ResponseCache';
+import type { FetchLike } from '../client.types';
+export declare function wrapFetchWithCache(fetch: FetchLike, cache: ResponseCache): FetchLike;

package/build/@expo/cli/src/api/rest/client.d.ts

@@ -0,0 +1,52 @@
+import type { JSONValue } from '@expo/json-file';
+import type { FetchLike } from './client.types';
+export declare class ApiV2Error extends Error {
+    readonly name = "ApiV2Error";
+    readonly code: string;
+    readonly expoApiV2ErrorCode: string;
+    readonly expoApiV2ErrorDetails?: JSONValue;
+    readonly expoApiV2ErrorServerStack?: string;
+    readonly expoApiV2ErrorMetadata?: object;
+    readonly expoApiV2RequestId?: string;
+    constructor(response: {
+        message: string;
+        code: string;
+        stack?: string;
+        details?: JSONValue;
+        metadata?: object;
+        requestId: string;
+    });
+    toString(): string;
+}
+/**
+ * An Expo server error that didn't return the expected error JSON information.
+ * The only 'expected' place for this is in testing, all other cases are bugs with the server.
+ */
+export declare class UnexpectedServerError extends Error {
+    readonly name = "UnexpectedServerError";
+}
+/**
+ * An error defining that the server didn't return the expected error JSON information.
+ * The only 'expected' place for this is in testing, all other cases are bugs with the client.
+ */
+export declare class UnexpectedServerData extends Error {
+    readonly name = "UnexpectedServerData";
+}
+/** Validate the response json contains `.data` property, or throw an unexpected server data error */
+export declare function getResponseDataOrThrow<T = any>(json: unknown): T;
+/**
+ * @returns a `fetch` function that will inject user authentication information and handle errors from the Expo API.
+ */
+export declare function wrapFetchWithCredentials(fetchFunction: FetchLike): FetchLike;
+/**
+ * Create an instance of the fully qualified fetch command (auto authentication and api) but with caching in the '~/.expo' directory.
+ * Caching is disabled automatically if the EXPO_NO_CACHE or EXPO_BETA environment variables are enabled.
+ */
+export declare function createCachedFetch({ fetch, cacheDirectory, ttl, skipCache, }: {
+    fetch?: FetchLike;
+    cacheDirectory: string;
+    ttl?: number;
+    skipCache?: boolean;
+}): FetchLike;
+/** Instance of fetch with automatic base URL pointing to the Expo API, user credential injection, and API error handling. Caching not included.  */
+export declare const fetchAsync: FetchLike;

package/build/@expo/cli/src/api/rest/client.types.d.ts

@@ -0,0 +1,19 @@
+import type { RequestInfo, RequestInit, Response } from 'undici';
+import type { URLSearchParams } from 'url';
+export type ProgressCallback = (props: {
+    /** Number ranging from 0 to 1 representing the download percentage. */
+    progress: number;
+    /** Total size of the download, in bytes. */
+    total: number;
+    /** Current amount of data downloaded, in bytes. */
+    loaded: number;
+}) => void;
+/**
+ * Represents a `fetch`-like function. Used since `typeof fetch` has statics we don't
+ * use and aren't interested in hoisting every time we wrap fetch with extra features.
+ */
+export type FetchLike = (url: RequestInfo, init?: RequestInit & {
+    searchParams?: URLSearchParams;
+    /** Progress callback, only implemented when `wrapFetchWithProgress` is used. */
+    onProgress?: ProgressCallback;
+}) => Promise<Response>;

package/build/@expo/cli/src/api/rest/wrapFetchWithBaseUrl.d.ts

@@ -0,0 +1,6 @@
+import { FetchLike } from './client.types';
+/**
+ * Wrap a fetch function with support for a predefined base URL.
+ * This implementation works like the browser fetch, applying the input to a prefix base URL.
+ */
+export declare function wrapFetchWithBaseUrl(fetch: FetchLike, baseUrl: string): FetchLike;

package/build/@expo/cli/src/api/rest/wrapFetchWithOffline.d.ts

@@ -0,0 +1,3 @@
+import { FetchLike } from './client.types';
+/** Wrap fetch with support for `EXPO_OFFLINE` to disable network requests. */
+export declare function wrapFetchWithOffline(fetchFunction: FetchLike): FetchLike;

package/build/@expo/cli/src/api/rest/wrapFetchWithProgress.d.ts

@@ -0,0 +1,2 @@
+import { FetchLike } from './client.types';
+export declare function wrapFetchWithProgress(fetch: FetchLike): FetchLike;

package/build/@expo/cli/src/api/rest/wrapFetchWithProxy.d.ts

@@ -0,0 +1,3 @@
+import { FetchLike } from './client.types';
+/** Wrap fetch with support for proxies. */
+export declare function wrapFetchWithProxy(fetchFunction: FetchLike): FetchLike;

package/build/@expo/cli/src/api/rest/wrapFetchWithUserAgent.d.ts

@@ -0,0 +1,2 @@
+import { FetchLike } from './client.types';
+export declare function wrapFetchWithUserAgent(fetch: FetchLike): FetchLike;

package/build/@expo/cli/src/api/settings.d.ts

@@ -0,0 +1 @@
+export declare function disableNetwork(): void;

package/build/@expo/cli/src/api/user/UserSettings.d.ts

@@ -0,0 +1,45 @@
+import JsonFile from '@expo/json-file';
+type SessionData = {
+    sessionSecret?: string;
+    userId?: string;
+    username?: string;
+    currentConnection?: 'Username-Password-Authentication' | 'Browser-Flow-Authentication';
+};
+export type UserSettingsData = {
+    auth?: SessionData | null;
+    ignoreBundledBinaries?: string[];
+    PATH?: string;
+    /** Last development code signing ID used for `npx expo run:ios`. */
+    developmentCodeSigningId?: string;
+    /** Unique user ID which is generated anonymously and can be cleared locally. */
+    uuid?: string;
+};
+export declare function getExpoHomeDirectory(): string;
+/** Return the user cache directory. */
+export declare function getSettingsDirectory(): string;
+/** Return the file path of the settings file */
+export declare function getSettingsFilePath(): string;
+/** Get a new JsonFile instance pointed towards the settings file */
+export declare function getSettings(): JsonFile<UserSettingsData>;
+export declare function getAccessToken(): string | null;
+export declare function getSession(): SessionData | null;
+export declare function setSessionAsync(sessionData?: SessionData): Promise<void>;
+/**
+ * Check if there are credentials available, without fetching the user information.
+ * This can be used as a faster check to see if users are authenticated.
+ * Note, this isn't checking the validity of the credentials.
+ */
+export declare function hasCredentials(): boolean;
+/**
+ * Get an anonymous and randomly generated identifier.
+ * This is used to group telemetry event by unknown actor,
+ * and cannot be used to identify a single user.
+ */
+export declare function getAnonymousIdAsync(): Promise<string>;
+/**
+ * Get an anonymous and randomly generated identifier.
+ * This is used to group telemetry event by unknown actor,
+ * and cannot be used to identify a single user.
+ */
+export declare function getAnonymousId(): string;
+export {};

package/build/@expo/cli/src/log.d.ts

@@ -0,0 +1,24 @@
+export declare function time(label?: string): void;
+export declare function timeEnd(label?: string): void;
+export declare function error(...message: string[]): void;
+/** Print an error and provide additional info (the stack trace) in debug mode. */
+export declare function exception(e: Error): void;
+export declare function warn(...message: string[]): void;
+export declare function log(...message: string[]): void;
+/** @deprecated use `debug` package with the `expo:` prefix instead.  */
+export declare function debug(...message: any[]): void;
+/** Clear the terminal of all text. */
+export declare function clear(): void;
+/** Log a message and exit the current process. If the `code` is non-zero then `console.error` will be used instead of `console.log`. */
+export declare function exit(message: string | Error, code?: number): never;
+export declare const Log: {
+    time: typeof time;
+    timeEnd: typeof timeEnd;
+    error: typeof error;
+    exception: typeof exception;
+    warn: typeof warn;
+    log: typeof log;
+    debug: typeof debug;
+    clear: typeof clear;
+    exit: typeof exit;
+};

package/build/@expo/cli/src/start/doctor/dependencies/bundledNativeModules.d.ts

@@ -0,0 +1,11 @@
+export type BundledNativeModules = Record<string, string>;
+/**
+ * Gets the bundledNativeModules.json for a given SDK version:
+ * - Tries to fetch the data from the /sdks/:sdkVersion/native-modules API endpoint.
+ * - If the data is missing on the server (it can happen for SDKs that are yet fully released)
+ *    or there's a downtime, reads the local .json file from the "expo" package.
+ * - For UNVERSIONED, returns the local .json file contents.
+ */
+export declare function getVersionedNativeModulesAsync(projectRoot: string, sdkVersion: string, options?: {
+    skipRemoteVersions?: boolean;
+}): Promise<BundledNativeModules>;

package/build/@expo/cli/src/utils/dir.d.ts

@@ -0,0 +1,10 @@
+export declare function fileExistsSync(file: string): boolean;
+export declare function directoryExistsSync(file: string): boolean;
+export declare function directoryExistsAsync(file: string): Promise<boolean>;
+export declare function fileExistsAsync(file: string): Promise<boolean>;
+export declare const ensureDirectoryAsync: (path: string) => Promise<string | undefined>;
+export declare const ensureDirectory: (path: string) => void;
+export declare const copySync: (src: string, dest: string) => void;
+export declare const copyAsync: (src: string, dest: string) => Promise<void>;
+export declare const removeAsync: (path: string) => Promise<void>;
+export declare function isPathInside(child: string, parent: string): boolean;

package/build/@expo/cli/src/utils/env.d.ts

@@ -0,0 +1,127 @@
+declare class Env {
+    /** Enable profiling metrics */
+    get EXPO_PROFILE(): boolean;
+    /** Enable debug logging */
+    get EXPO_DEBUG(): boolean;
+    /** Disable all network requests */
+    get EXPO_OFFLINE(): boolean;
+    /** Enable the beta version of Expo (TODO: Should this just be in the beta version of expo releases?) */
+    get EXPO_BETA(): boolean;
+    /** Enable staging API environment */
+    get EXPO_STAGING(): boolean;
+    /** Enable local API environment */
+    get EXPO_LOCAL(): boolean;
+    /** Is running in non-interactive CI mode */
+    get CI(): boolean;
+    /** Disable telemetry (analytics) */
+    get EXPO_NO_TELEMETRY(): boolean;
+    /** Disable detaching telemetry to separate process */
+    get EXPO_NO_TELEMETRY_DETACH(): boolean;
+    /** local directory to the universe repo for testing locally */
+    get EXPO_UNIVERSE_DIR(): string;
+    /** @deprecated Default Webpack host string */
+    get WEB_HOST(): string;
+    /** Skip warning users about a dirty git status */
+    get EXPO_NO_GIT_STATUS(): boolean;
+    /** Disable auto web setup */
+    get EXPO_NO_WEB_SETUP(): boolean;
+    /** Disable auto TypeScript setup */
+    get EXPO_NO_TYPESCRIPT_SETUP(): boolean;
+    /** Disable all API caches. Does not disable bundler caches. */
+    get EXPO_NO_CACHE(): boolean;
+    /** Disable the app select redirect page. */
+    get EXPO_NO_REDIRECT_PAGE(): boolean;
+    /** The React Metro port that's baked into react-native scripts and tools. */
+    get RCT_METRO_PORT(): number;
+    /** Skip validating the manifest during `export`. */
+    get EXPO_SKIP_MANIFEST_VALIDATION_TOKEN(): boolean;
+    /** Public folder path relative to the project root. Default to `public` */
+    get EXPO_PUBLIC_FOLDER(): string;
+    /** Higher priority `$EDIOTR` variable for indicating which editor to use when pressing `o` in the Terminal UI. */
+    get EXPO_EDITOR(): string;
+    /**
+     * Overwrite the dev server URL, disregarding the `--port`, `--host`, `--tunnel`, `--lan`, `--localhost` arguments.
+     * This is useful for browser editors that require custom proxy URLs.
+     */
+    get EXPO_PACKAGER_PROXY_URL(): string;
+    /**
+     * **Experimental** - Disable using `exp.direct` as the hostname for
+     * `--tunnel` connections. This enables **https://** forwarding which
+     * can be used to test universal links on iOS.
+     *
+     * This may cause issues with `expo-linking` and Expo Go.
+     *
+     * Select the exact subdomain by passing a string value that is not one of: `true`, `false`, `1`, `0`.
+     */
+    get EXPO_TUNNEL_SUBDOMAIN(): string | boolean;
+    /**
+     * Force Expo CLI to use the [`resolver.resolverMainFields`](https://facebook.github.io/metro/docs/configuration/#resolvermainfields) from the project `metro.config.js` for all platforms.
+     *
+     * By default, Expo CLI will use `['browser', 'module', 'main']` (default for Webpack) for web and the user-defined main fields for other platforms.
+     */
+    get EXPO_METRO_NO_MAIN_FIELD_OVERRIDE(): boolean;
+    /**
+     * HTTP/HTTPS proxy to connect to for network requests. Configures [https-proxy-agent](https://www.npmjs.com/package/https-proxy-agent).
+     */
+    get HTTP_PROXY(): string;
+    /**
+     * Use the network inspector by overriding the metro inspector proxy with a custom version.
+     * @deprecated This has been replaced by `@react-native/dev-middleware` and is now unused.
+     */
+    get EXPO_NO_INSPECTOR_PROXY(): boolean;
+    /** Disable lazy bundling in Metro bundler. */
+    get EXPO_NO_METRO_LAZY(): boolean;
+    /**
+     * Enable the unstable inverse dependency stack trace for Metro bundling errors.
+     * @deprecated This will be removed in the future.
+     */
+    get EXPO_METRO_UNSTABLE_ERRORS(): boolean;
+    /** Enable the experimental sticky resolver for Metro. */
+    get EXPO_USE_STICKY_RESOLVER(): boolean;
+    /** Enable the unstable fast resolver for Metro. */
+    get EXPO_USE_FAST_RESOLVER(): boolean;
+    /** Disable Environment Variable injection in client bundles. */
+    get EXPO_NO_CLIENT_ENV_VARS(): boolean;
+    /** Set the default `user` that should be passed to `--user` with ADB commands. Used for installing APKs on Android devices with multiple profiles. Defaults to `0`. */
+    get EXPO_ADB_USER(): string;
+    /** Used internally to enable E2E utilities. This behavior is not stable to external users. */
+    get __EXPO_E2E_TEST(): boolean;
+    /** Unstable: Force single-bundle exports in production. */
+    get EXPO_NO_BUNDLE_SPLITTING(): boolean;
+    /**
+     * Enable Atlas to gather bundle information during development or export.
+     * Note, because this used to be an experimental feature, both `EXPO_ATLAS` and `EXPO_UNSTABLE_ATLAS` are supported.
+     */
+    get EXPO_ATLAS(): boolean;
+    /** Unstable: Enable tree shaking for Metro. */
+    get EXPO_UNSTABLE_TREE_SHAKING(): boolean;
+    /** Unstable: Enable eager bundling where transformation runs uncached after the entire bundle has been created. This is required for production tree shaking and less optimized for development bundling. */
+    get EXPO_UNSTABLE_METRO_OPTIMIZE_GRAPH(): boolean;
+    /** Enable the use of Expo's custom metro require implementation. The custom require supports better debugging, tree shaking, and React Server Components. */
+    get EXPO_USE_METRO_REQUIRE(): boolean;
+    /** Internal key used to pass eager bundle data from the CLI to the native run scripts during `npx expo run` commands. */
+    get __EXPO_EAGER_BUNDLE_OPTIONS(): string;
+    /** Disable server deployment during production builds (during `expo export:embed`). This is useful for testing API routes and server components against a local server. */
+    get EXPO_NO_DEPLOY(): boolean;
+    /** Enable hydration during development when rendering Expo Web */
+    get EXPO_WEB_DEV_HYDRATE(): boolean;
+    /** Enable experimental React Server Functions support. */
+    get EXPO_UNSTABLE_SERVER_FUNCTIONS(): boolean;
+    /** Enable unstable/experimental mode where React Native Web isn't required to run Expo apps on web. */
+    get EXPO_NO_REACT_NATIVE_WEB(): boolean;
+    /** Enable unstable/experimental support for deploying the native server in `npx expo run` commands. */
+    get EXPO_UNSTABLE_DEPLOY_SERVER(): boolean;
+    /** Is running in EAS Build. This is set by EAS: https://docs.expo.dev/eas/environment-variables/ */
+    get EAS_BUILD(): boolean;
+    /** Disable the React Native Directory compatibility check for new architecture when installing packages */
+    get EXPO_NO_NEW_ARCH_COMPAT_CHECK(): boolean;
+    /** Disable the dependency validation when installing other dependencies and starting the project */
+    get EXPO_NO_DEPENDENCY_VALIDATION(): boolean;
+    /** Force Expo CLI to run in webcontainer mode, this has impact on which URL Expo is using by default */
+    get EXPO_FORCE_WEBCONTAINER_ENV(): boolean;
+    /** Disable by falsy value live binding in experimental import export support. Enabled by default. */
+    get EXPO_UNSTABLE_LIVE_BINDINGS(): boolean;
+}
+export declare const env: Env;
+export declare function envIsWebcontainer(): boolean;
+export {};

package/build/@expo/cli/src/utils/errors.d.ts

@@ -0,0 +1,23 @@
+/**
+ * General error, formatted as a message in red text when caught by expo-cli (no stack trace is printed). Should be used in favor of `log.error()` in most cases.
+ */
+export declare class CommandError extends Error {
+    code: string;
+    name: string;
+    readonly isCommandError = true;
+    constructor(code: string, message?: string);
+}
+export declare class AbortCommandError extends CommandError {
+    constructor();
+}
+/**
+ * Used to end a CLI process without printing a stack trace in the Expo CLI. Should be used in favor of `process.exit`.
+ */
+export declare class SilentError extends CommandError {
+    constructor(messageOrError?: string | Error);
+}
+export declare function logCmdError(error: any): never;
+/** This should never be thrown in production. */
+export declare class UnimplementedError extends Error {
+    constructor();
+}

package/build/@expo/cli/src/utils/fetch.d.ts

@@ -0,0 +1,11 @@
+import type { FetchLike } from '../api/rest/client.types';
+/**
+ * The Node's built-in fetch API, but polyfilled from `undici` if necessary.
+ * @todo(cedric): remove this once we min-support a Node version where fetch can't be disabled
+ */
+export declare const fetch: FetchLike;
+/**
+ * Node's built-in fetch Headers class, or the polyfilled Headers from `undici` when unavailable.
+ * @todo(cedric): remove this once we min-support a Node version where fetch can't be disabled
+ */
+export declare const Headers: typeof import('undici').Headers;

package/build/expo-doctor/src/checks/PeerDependencyChecks.d.ts

@@ -0,0 +1,7 @@
+import { DoctorCheck, DoctorCheckParams, DoctorCheckResult } from './checks.types';
+export declare class PeerDependencyChecks implements DoctorCheck {
+    description: string;
+    sdkVersionRange: string;
+    runAsync({ pkg, projectRoot, exp }: DoctorCheckParams): Promise<DoctorCheckResult>;
+    private checkPackagePeerDependencies;
+}

package/build/{utils → expo-doctor/src/utils}/metroConfigLoader.d.ts

@@ -1,3 +1,3 @@
-import type MetroConfig from 'metro-config';
+import type MetroConfig from '@expo/metro/metro-config';
 export declare function configExistsAsync(projectRoot: string): Promise<boolean>;
 export declare function loadConfigAsync(projectDir: string): Promise<MetroConfig.ConfigT>;