xdl
- Version 60.0.12
- Published
- 9.43 MB
- 63 dependencies
- MIT license
Install
npm i xdl
yarn add xdl
pnpm add xdl
Overview
The Expo Development Library
Index
Variables
Functions
Classes
Type Aliases
Namespaces
Android
- activateEmulatorWindowAsync()
- attemptToStartEmulatorOrAssertAsync()
- checkSplashScreenImages()
- Device
- DeviceABI
- getAdbFileOutputAsync()
- getAdbOutputAsync()
- getAllAvailableDevicesAsync()
- getAttachedDevicesAsync()
- getDeviceABIsAsync()
- getDeviceAPIVersionAsync()
- getDeviceSDKVersionAsync()
- getPropertyForDeviceAsync()
- installExpoAsync()
- installOnDeviceAsync()
- isDeviceBootedAsync()
- isPlatformSupported()
- maybeStopAdbDaemonAsync()
- openAppAsync()
- openProjectAsync()
- openWebProjectAsync()
- parseAdbDeviceProperties()
- promptForDeviceAsync()
- resolveApplicationIdAsync()
- startAdbReverseAsync()
- stopAdbReverseAsync()
- uninstallExpoAsync()
- upgradeExpoAsync()
Project
- broadcastMessage()
- createBundlesAsync()
- getPublishExpConfigAsync()
- LoadedHook
- prepareHooks()
- publishAsync()
- PublishedProjectResult
- PublishOptions
- runHook()
- startAsync()
- startExpoServerAsync()
- StartOptions
- startReactNativeServerAsync()
- startTunnelsAsync()
- startWebpackAsync()
- stopAsync()
- stopReactNativeServerAsync()
- stopTunnelsAsync()
- writeArtifactSafelyAsync()
SimControl
- addMediaAsync()
- bootAsync()
- captureScreenAsync()
- deleteUnavailableAsync()
- eraseAllAsync()
- eraseAsync()
- getContainerPathAsync()
- getDefaultSimulatorDeviceUDIDAsync()
- installAsync()
- isLicenseOutOfDate()
- isXcrunInstalledAsync()
- listAsync()
- listDevicesAsync()
- listSimulatorDevicesAsync()
- openBundleIdAsync()
- openURLAsync()
- parseXcrunError()
- runBootAsync()
- setAppearanceAsync()
- shutdownAsync()
- simctlAsync()
- SimulatorDevice
- uninstallAsync()
- updatePermissionsAsync()
- waitForDeviceToBootAsync()
- xcrunAsync()
- xcrunWithLogging()
- XCTraceDevice
Simulator
- activateSimulatorWindowAsync()
- closeSimulatorAppAsync()
- doesExpoClientNeedUpdatedAsync()
- ensureSimulatorAppRunningAsync()
- ensureSimulatorOpenAsync()
- ensureXcodeCommandLineToolsInstalledAsync()
- ensureXcodeInstalledAsync()
- expoVersionOnSimulatorAsync()
- installExpoOnSimulatorAsync()
- isExpoClientInstalledOnSimulatorAsync()
- isPlatformSupported()
- isSimulatorBootedAsync()
- isSimulatorInstalledAsync()
- openProjectAsync()
- openWebProjectAsync()
- promptForSimulatorAsync()
- resolveApplicationIdAsync()
- sortDefaultDeviceToBeginningAsync()
- streamLogsAsync()
- uninstallExpoAppFromSimulatorAsync()
- upgradeExpoAsync()
- waitForExpoClientInstalledOnSimulatorAsync()
- waitForExpoClientUninstalledOnSimulatorAsync()
UrlUtils
- constructAssetsUrlAsync()
- constructBundleQueryParams()
- constructBundleQueryParamsWithConfig()
- constructBundleUrlAsync()
- constructDebuggerHostAsync()
- constructDeepLinkAsync()
- constructDevClientUrlAsync()
- constructHostUriAsync()
- constructLoadingUrlAsync()
- constructLogUrlAsync()
- constructManifestUrlAsync()
- constructPublishUrlAsync()
- constructSourceMapUrlAsync()
- constructUrlAsync()
- constructUrlWithExtensionAsync()
- constructWebAppUrlAsync()
- isHttps()
- isURL()
- stripJSExtension()
Variables
variable Analytics
const Analytics: AnalyticsClient;
variable Config
const Config: XDLConfig;
variable LoadingEvent
const LoadingEvent: { START_LOADING: string; STOP_LOADING: string; START_PROGRESS_BAR: string; TICK_PROGRESS_BAR: string; STOP_PROGRESS_BAR: string;};
variable Logger
const Logger: { child: (options: object) => bunyan; notifications: bunyan; global: bunyan; DEBUG: number; INFO: number; WARN: number; ERROR: number;};
variable UnifiedAnalytics
const UnifiedAnalytics: AnalyticsClient;
variable UserManager
const UserManager: UserManagerInstance;
variable UserSettings
const UserSettings: any;
Functions
function isDevClientPackageInstalled
isDevClientPackageInstalled: (projectRoot: string) => boolean;
function printBundleSizes
printBundleSizes: (bundles: { android?: BundleOutput; ios?: BundleOutput;}) => void;
Classes
class ApiV2
class ApiV2Client {}
constructor
constructor(options?: APIV2ClientOptions);
property accessToken
accessToken: string;
property exponentClient
static exponentClient: string;
property sessionSecret
sessionSecret: string;
method clientForUser
static clientForUser: (user?: APIV2ClientOptions | null) => ApiV2Client;
method deleteAsync
deleteAsync: ( methodName: string, args?: ParsedUrlQueryInput, extraOptions?: Partial<RequestOptions>, returnEntireResponse?: boolean) => Promise<any>;
method getAsync
getAsync: ( methodName: string, args?: ParsedUrlQueryInput, extraOptions?: Partial<RequestOptions>, returnEntireResponse?: boolean) => Promise<any>;
method patchAsync
patchAsync: ( methodName: string, data: JSONObject, extraOptions?: Partial<RequestOptions>, returnEntireResponse?: boolean) => Promise<any>;
method postAsync
postAsync: ( methodName: string, data?: JSONObject, extraOptions?: Partial<RequestOptions>, returnEntireResponse?: boolean) => Promise<any>;
method putAsync
putAsync: ( methodName: string, data: JSONObject, extraOptions?: Partial<RequestOptions>, returnEntireResponse?: boolean) => Promise<any>;
method setClientName
static setClientName: (name: string) => void;
method uploadFormDataAsync
uploadFormDataAsync: (methodName: string, formData: FormData) => Promise<any>;
class PackagerLogsStream
class PackagerLogsStream {}
constructor
constructor({ projectRoot, getCurrentOpenProjectId, updateLogs, onStartBuildBundle, onProgressBuildBundle, onFinishBuildBundle, getSnippetForError,}: { projectRoot: string; getCurrentOpenProjectId?: () => any; updateLogs: (updater: LogUpdater) => void; onStartBuildBundle?: StartBuildBundleCallback; onProgressBuildBundle?: ProgressBuildBundleCallback; onFinishBuildBundle?: FinishBuildBundleCallback; getSnippetForError?: (error: MetroError) => string | null;});
property bundleDetailsCache
bundleDetailsCache: Record<string, BundleDetails>;
property projectId
projectId?: number;
method getPlatformTagForBuildDetails
static getPlatformTagForBuildDetails: ( bundleDetails?: BundleDetails | null) => string;
class XDLError
class XDLError extends Error {}
constructor
constructor(code: ErrorCode, message: string);
property code
code: string;
property isXDLError
isXDLError: boolean;
property name
readonly name: string;
Type Aliases
type ErrorCode
type ErrorCode = | 'INVALID_USERNAME_PASSWORD' | 'TOO_MANY_ATTEMPTS' | 'REGISTRATION_ERROR' | 'LEGACY_ACCOUNT_ERROR' | 'ROBOT_ACCOUNT_ERROR' | 'USER_ACCOUNT_ERROR' | 'DIRECTORY_ALREADY_EXISTS' | 'HOOK_INITIALIZATION_ERROR' | 'INVALID_ARGUMENT' | 'INVALID_ASSETS' | 'INVALID_BUNDLE' | 'INVALID_JSON' | 'INVALID_MANIFEST' | 'INVALID_OPTIONS' | 'INVALID_VERSION' | 'NGROK_ERROR' | 'NO_EXPO_SERVER_PORT' | 'NO_PACKAGE_JSON' | 'NO_PACKAGER_PORT' | 'NO_PORT_FOUND' | 'NO_PROJECT_ROOT' | 'NO_SDK_VERSION' | 'NOT_LOGGED_IN' | 'PLATFORM_NOT_SUPPORTED' | 'PUBLISH_VALIDATION_ERROR' | 'WONT_OVERWRITE_WITHOUT_FORCE' | 'XCODE_LICENSE_NOT_ACCEPTED' | 'APP_NOT_INSTALLED' | 'SIMCTL_NOT_AVAILABLE' | 'WEB_NOT_CONFIGURED' | 'WEBPACK_BUNDLE' | 'WEBPACK_DEPRECATED' | 'WEBPACK_INVALID_OPTION' | 'NETWORK_REQUIRED' | 'ROBOT_OWNER_ERROR' | 'CREDENTIAL_ERROR' | 'NO_DEV_CLIENT_SCHEME';
type LogRecord
type LogRecord = (MetroLogRecord | ExpoLogRecord | DeviceLogRecord) & ProjectUtils.LogFields;
type LogUpdater
type LogUpdater = (logState: LogRecord[]) => LogRecord[];
type RobotUser
type RobotUser = { kind: 'robot'; userId: string; username: string; givenName?: string; currentConnection: ConnectionType; sessionSecret?: never; accessToken?: string;};
type User
type User = { kind: 'user'; username: string; nickname: string; userId: string; picture: string; email?: string; emailVerified?: boolean; givenName?: string; familyName?: string; userMetadata: { onboarded: boolean; legacy?: boolean; }; currentConnection: ConnectionType; sessionSecret?: string; accessToken?: string;};
Namespaces
namespace Android
module 'build/Android.d.ts' {}
Parameter device
Android device to open on
Parameter
props.launchActivity Activity to launch
[application identifier]/.[main activity name]
, ex:com.bacon.app/.MainActivity
function activateEmulatorWindowAsync
activateEmulatorWindowAsync: ( device: Pick<Device, 'type' | 'pid'>) => Promise<void>;
function attemptToStartEmulatorOrAssertAsync
attemptToStartEmulatorOrAssertAsync: (device: Device) => Promise<Device | null>;
function checkSplashScreenImages
checkSplashScreenImages: (projectRoot: string) => Promise<void>;
Checks whether
resizeMode
is set tonative
and iftrue
analyzes provided images for splashscreen providingLogger
feedback upon problems.Parameter projectRoot
directory of the expo project SDK33
function getAdbFileOutputAsync
getAdbFileOutputAsync: ( args: string[], encoding?: 'latin1') => Promise<string | Buffer>;
function getAdbOutputAsync
getAdbOutputAsync: (args: string[]) => Promise<string>;
function getAllAvailableDevicesAsync
getAllAvailableDevicesAsync: () => Promise<Device[]>;
function getAttachedDevicesAsync
getAttachedDevicesAsync: () => Promise<Device[]>;
function getDeviceABIsAsync
getDeviceABIsAsync: ( device: Pick<Device, 'name' | 'pid'>) => Promise<DeviceABI[]>;
function getDeviceAPIVersionAsync
getDeviceAPIVersionAsync: ( device: Pick<Device, 'name' | 'pid'>) => Promise<number>;
Returns
number like
30
(i.e. API 30)
function getDeviceSDKVersionAsync
getDeviceSDKVersionAsync: ( device: Pick<Device, 'name' | 'pid'>) => Promise<string>;
Returns
string like '11' (i.e. Android 11)
function getPropertyForDeviceAsync
getPropertyForDeviceAsync: ( device: Pick<Device, 'name' | 'pid'>, name: string, shouldRefresh?: boolean) => Promise<string>;
function installExpoAsync
installExpoAsync: ({ device, url, version,}: { device: Device; url?: string; version?: string;}) => Promise<string>;
function installOnDeviceAsync
installOnDeviceAsync: ( device: Pick<Device, 'pid'>, { binaryPath }: { binaryPath: string }) => Promise<string>;
function isDeviceBootedAsync
isDeviceBootedAsync: ({ name }?: { name?: string }) => Promise<Device | null>;
function isPlatformSupported
isPlatformSupported: () => boolean;
function maybeStopAdbDaemonAsync
maybeStopAdbDaemonAsync: () => Promise<boolean>;
function openAppAsync
openAppAsync: ( device: Pick<Device, 'pid' | 'type'>, { launchActivity }: { launchActivity: string }) => Promise<string>;
Parameter device
Android device to open on
Parameter
props.launchActivity Activity to launch
[application identifier]/.[main activity name]
, ex:com.bacon.app/.MainActivity
function openProjectAsync
openProjectAsync: ({ projectRoot, shouldPrompt, devClient, device, scheme, applicationId, launchActivity,}: { projectRoot: string; shouldPrompt?: boolean; devClient?: boolean; device?: Device; scheme?: string; applicationId?: string | null; launchActivity?: string;}) => Promise< { success: true; url: string } | { success: false; error: Error | string }>;
function openWebProjectAsync
openWebProjectAsync: ({ projectRoot, shouldPrompt,}: { projectRoot: string; shouldPrompt?: boolean;}) => Promise<{ success: true; url: string } | { success: false; error: string }>;
function parseAdbDeviceProperties
parseAdbDeviceProperties: (devicePropertiesString: string) => DeviceProperties;
function promptForDeviceAsync
promptForDeviceAsync: (devices: Device[]) => Promise<Device | null>;
function resolveApplicationIdAsync
resolveApplicationIdAsync: (projectRoot: string) => Promise<string | null>;
function startAdbReverseAsync
startAdbReverseAsync: (projectRoot: string) => Promise<boolean>;
function stopAdbReverseAsync
stopAdbReverseAsync: (projectRoot: string) => Promise<void>;
function uninstallExpoAsync
uninstallExpoAsync: (device: Device) => Promise<string | undefined>;
function upgradeExpoAsync
upgradeExpoAsync: ({ url, version, device,}?: { url?: string; version?: string; device?: Device | null;}) => Promise<boolean>;
enum DeviceABI
enum DeviceABI { arm = 'arm', arm64 = 'arm64', x64 = 'x64', x86 = 'x86', armeabiV7a = 'armeabi-v7a', armeabi = 'armeabi', universal = 'universal',}
type Device
type Device = { pid?: string; name: string; type: 'emulator' | 'device'; isBooted: boolean; isAuthorized: boolean;};
namespace AndroidCredentials
module 'build/credentials/AndroidCredentials.d.ts' {}
function exportCertBase64
exportCertBase64: ( { keystorePath, keystorePassword, keyAlias, }: Pick<KeystoreInfo, 'keystorePath' | 'keystorePassword' | 'keyAlias'>, certFile: string) => Promise<SpawnResult>;
function generateUploadKeystore
generateUploadKeystore: ( uploadKeystorePath: string, androidPackage: string, experienceName: string) => Promise<KeystoreInfo>;
function logKeystoreHashes
logKeystoreHashes: ( keystoreInfo: KeystoreInfo, linePrefix?: string) => Promise<void>;
type Keystore
type Keystore = { keystore: string; keystorePassword: string; keyPassword: string; keyAlias: string;};
type KeystoreInfo
type KeystoreInfo = { keystorePath: string; keystorePassword: string; keyPassword: string; keyAlias: string;};
namespace AppleDevice
module 'build/apple/AppleDevice.d.ts' {}
function getConnectedDevices
getConnectedDevices: () => Promise<DeviceValues[]>;
function isEnabled
isEnabled: () => boolean;
function runOnDevice
runOnDevice: ({ udid, appPath, bundleId, waitForApp, deltaPath, onProgress,}: { udid: string; appPath: string; bundleId: string; waitForApp: boolean; deltaPath: string; onProgress: OnInstallProgressCallback;}) => Promise<void>;
namespace Binaries
module 'build/Binaries.d.ts' {}
variable OSX_SOURCE_PATH
const OSX_SOURCE_PATH: string;
function addToPathAsync
addToPathAsync: (name: string) => Promise<void>;
function getBinariesPath
getBinariesPath: () => string;
function isXcodeInstalled
isXcodeInstalled: () => boolean;
function writePathToUserSettingsAsync
writePathToUserSettingsAsync: () => Promise<void>;
namespace ConnectionStatus
module 'build/ConnectionStatus.d.ts' {}
function isOffline
isOffline: () => boolean;
function setIsOffline
setIsOffline: (bool: boolean) => void;
namespace CoreSimulator
module 'build/apple/CoreSimulator.d.ts' {}
Get UDID for the first booted simulator. It's unclear if this is the exact method used by
xcrun simctl
to determine which device is "booted".Returns
EFEEA6EF-E3F5-4EDE-9B72-29EAFA7514AE
function devicePlistToSimulatorDevice
devicePlistToSimulatorDevice: ( deviceDirectory: string, data: any) => SimulatorDevice;
function getBootedDeviceAsync
getBootedDeviceAsync: () => Promise<{ UDID: string } | null>;
Get UDID for the first booted simulator. It's unclear if this is the exact method used by
xcrun simctl
to determine which device is "booted".Returns
EFEEA6EF-E3F5-4EDE-9B72-29EAFA7514AE
function getContainerPathAsync
getContainerPathAsync: ({ udid, bundleIdentifier,}: { udid: string; bundleIdentifier: string;}) => Promise<string | null>;
Returns the local path for the installed binary.app on a given Apple simulator. Returns null when the app isn't installed.
This can be used as a replacement for
xcrun simctl get_app_container <udid> <bundleIdentifier>
but it's over 200x faster.Parameter
props.udid device udid.
Parameter
props.bundleIdentifier bundle identifier for app
Returns
local file path to installed app binary, e.g. '/Users/evanbacon/Library/Developer/CoreSimulator/Devices/EFEEA6EF-E3F5-4EDE-9B72-29EAFA7514AE/data/Containers/Bundle/Application/FA43A0C6-C2AD-442D-B8B1-EAF3E88CF3BF/Exponent-2.21.3.tar.app'
function getDeviceInfoAsync
getDeviceInfoAsync: ({ udid }?: { udid?: string }) => Promise<SimulatorDevice>;
function isEnabled
isEnabled: () => boolean;
function listDevicesAsync
listDevicesAsync: () => Promise<SimulatorDevice[]>;
class CoreSimulatorError
class CoreSimulatorError extends Error {}
constructor
constructor(message: string, code?: 'MALFORMED_BINARY' | 'INVALID_UDID');
property code
code?: 'MALFORMED_BINARY' | 'INVALID_UDID';
property message
message: string;
namespace Detach
module 'build/detach/Detach.d.ts' {}
function bundleAssetsAsync
bundleAssetsAsync: (projectDir: string, args: any) => Promise<void>;
function prepareDetachedBuildAsync
prepareDetachedBuildAsync: (projectDir: string, args: any) => Promise<void>;
namespace Doctor
module 'build/project/Doctor.d.ts' {}
variable ERROR
const ERROR: number;
variable FATAL
const FATAL: number;
variable NO_ISSUES
const NO_ISSUES: number;
variable WARNING
const WARNING: number;
function validateExpoServersAsync
validateExpoServersAsync: (projectRoot: string) => Promise<number>;
function validateWithNetworkAsync
validateWithNetworkAsync: ( projectRoot: string, options?: { skipSDKVersionRequirement?: boolean }) => Promise<number>;
function validateWithoutNetworkAsync
validateWithoutNetworkAsync: ( projectRoot: string, options?: { skipSDKVersionRequirement?: boolean }) => Promise<number>;
namespace EmbeddedAssets
module 'build/EmbeddedAssets.d.ts' {}
The code below here is duplicated from expo-cli currently *
function configureAsync
configureAsync: (config: EmbeddedAssetsConfiguration) => Promise<void>;
function getEmbeddedManifestPath
getEmbeddedManifestPath: ( platform: 'ios' | 'android', projectRoot: string, exp: ExpoAppManifest) => string;
function getIOSPaths
getIOSPaths: (projectRoot: string) => { projectName: string; iosProjectDirectory: string; iosSupportingDirectory: string; iconPath: string;};
The code below here is duplicated from expo-cli currently *
function shouldEmbedAssetsForExpoUpdates
shouldEmbedAssetsForExpoUpdates: ( projectRoot: string, exp: ExpoAppManifest, pkg: PackageJSONConfig, target: ProjectTarget) => boolean;
type EmbeddedAssetsConfiguration
type EmbeddedAssetsConfiguration = { projectRoot: string; pkg: PackageJSONConfig; exp: ExpoAppManifest; releaseChannel?: string; iosManifestUrl: string; iosManifest: any; iosBundle: string | Uint8Array; androidManifestUrl: string; androidManifest: any; androidBundle: string | Uint8Array; target: ProjectTarget;};
namespace Env
module 'build/Env.d.ts' {}
Returns true if we should use Metro using its JS APIs via @expo/dev-server (the modern and fast way), false if we should fall back to spawning it as a subprocess (supported for backwards compatibility with SDK39 and older).
function getFeatureGateOverrides
getFeatureGateOverrides: () => { enable: string[]; disable: string[] };
function isDebug
isDebug: () => boolean;
function isInterstitiaLPageEnabled
isInterstitiaLPageEnabled: () => boolean;
function isLocal
isLocal: () => boolean;
function isStaging
isStaging: () => boolean;
function maySkipManifestValidation
maySkipManifestValidation: () => boolean;
function shouldEnableAnalytics
shouldEnableAnalytics: () => boolean;
function shouldUseDevServer
shouldUseDevServer: (exp: Pick<ExpoConfig, 'sdkVersion'>) => boolean;
Returns true if we should use Metro using its JS APIs via @expo/dev-server (the modern and fast way), false if we should fall back to spawning it as a subprocess (supported for backwards compatibility with SDK39 and older).
namespace Exp
module 'build/Exp.d.ts' {}
function sendAsync
sendAsync: ( recipient: string, url_: string, allowUnauthed?: boolean) => Promise<any>;
namespace IosCodeSigning
module 'build/detach/IosCodeSigning.d.ts' {}
function validateProvisioningProfile
validateProvisioningProfile: ( plistData: PlistObject, { distCertFingerprint, bundleIdentifier, }: { distCertFingerprint: string; bundleIdentifier: string }) => void;
type IPABuilderParams
type IPABuilderParams = { provisioningProfilePath: string; certPath: string; certPassword?: string; appUUID: string; keychainPath: string; bundleIdentifier: string; teamID: string; manifest: any; workspacePath: string; clientBuild?: boolean;};
namespace LoadingPageHandler
module 'build/start/LoadingPageHandler.d.ts' {}
variable DeepLinkEndpoint
const DeepLinkEndpoint: string;
variable LoadingEndpoint
const LoadingEndpoint: string;
function getLoadingPageHandler
getLoadingPageHandler: ( projectRoot: string) => ( req: express.Request | http.IncomingMessage, res: express.Response | http.ServerResponse, next: (err?: Error | undefined) => void) => Promise<void>;
function noCacheMiddleware
noCacheMiddleware: ( res: express.Response | http.ServerResponse) => express.Response | http.ServerResponse;
function setOnDeepLink
setOnDeepLink: (listener: OnDeepLinkListener) => void;
namespace ModuleVersion
module 'build/tools/ModuleVersion.d.ts' {}
Deprecated
just use the update-check npm package
function createModuleVersionChecker
createModuleVersionChecker: ( name: string, currentVersion: string) => { checkAsync: () => Promise<{ updateIsAvailable: boolean; latest: string; current: string; deprecated: unknown; }>;};
Deprecated
just use the update-check npm package
namespace PKCS12Utils
module 'build/detach/PKCS12Utils.d.ts' {}
function findP12CertSerialNumber
findP12CertSerialNumber: ( p12Buffer: Buffer | string, passwordRaw: string | null) => string | null;
function getCertData
getCertData: ( p12Buffer: Buffer | string, passwordRaw: string | null) => { serialNumber: string | null; version: number; signature: any; siginfo: any; validity: { notBefore: Date; notAfter: Date }; issuer: { getField(sn: string | forge.pki.CertificateFieldOptions): any; addField(attr: forge.pki.CertificateField): void; attributes: any[]; hash: any; }; subject: { getField(sn: string | forge.pki.CertificateFieldOptions): any; addField(attr: forge.pki.CertificateField): void; attributes: any[]; hash: any; }; extensions: any[]; privateKey: forge.pki.PrivateKey; publicKey: forge.pki.PublicKey; md: any; setSubject( attrs: forge.pki.CertificateField[], uniqueId?: string | undefined ): void; setIssuer( attrs: forge.pki.CertificateField[], uniqueId?: string | undefined ): void; setExtensions(exts: any[]): void; getExtension( options: string | { name: string } | { id: number } ): {} | undefined; sign(key: forge.pki.PrivateKey, md?: any): void; verify(child: forge.pki.Certificate): boolean; getAttribute( opts: string | forge.pki.GetAttributeOpts ): forge.pki.Attribute | null; isIssuer(parent: forge.pki.Certificate): boolean; issued(child: forge.pki.Certificate): boolean;};
function getP12CertFingerprint
getP12CertFingerprint: ( p12Buffer: Buffer | string, passwordRaw: string | null) => string;
namespace Project
module 'build/Project.d.ts' {}
function broadcastMessage
broadcastMessage: ( method: 'reload' | 'devMenu' | 'sendDevCommand', params?: Record<string, any> | undefined) => void;
Sends a message over web sockets to any connected device, does nothing when the dev server is not running.
Parameter method
name of the command. In RN projects
reload
, anddevMenu
are available. In Expo Go,sendDevCommand
is available.Parameter params
function createBundlesAsync
createBundlesAsync: ( projectRoot: string, publishOptions: PublishOptions | undefined, bundleOptions: { platforms: Platform[]; dev?: boolean; useDevServer: boolean }) => Promise<Partial<Record<Platform, BundleOutput>>>;
function getPublishExpConfigAsync
getPublishExpConfigAsync: ( projectRoot: string, options?: Pick<PublishOptions, 'releaseChannel'>) => Promise<{ exp: ExpoAppManifest; pkg: PackageJSONConfig; hooks: ExpoConfig['hooks'];}>;
function prepareHooks
prepareHooks: ( hooks: ExpoConfig, hookType: HookType, projectRoot: string) => LoadedHook[];
function publishAsync
publishAsync: ( projectRoot: string, options?: PublishOptions) => Promise<PublishedProjectResult>;
function runHook
runHook: ( hook: LoadedHook, hookOptions: Omit<HookArguments, 'config'>) => Promise<void>;
function startAsync
startAsync: ( projectRoot: string, { exp, ...options }?: StartDevServerOptions & { exp?: ExpoConfig }, verbose?: boolean) => Promise<ExpoConfig>;
function startExpoServerAsync
startExpoServerAsync: (projectRoot: string) => Promise<void>;
function startReactNativeServerAsync
startReactNativeServerAsync: ({ projectRoot, options, exp, verbose,}: { projectRoot: string; options: StartDevServerOptions; exp?: ExpoConfig; verbose?: boolean;}) => Promise<void>;
function startTunnelsAsync
startTunnelsAsync: ( projectRoot: string, options?: { autoInstall?: boolean }) => Promise<void>;
function startWebpackAsync
startWebpackAsync: ( projectRoot: string, { exp, ...options }?: StartDevServerOptions & { exp?: ExpoConfig }) => Promise<void>;
function stopAsync
stopAsync: (projectRoot: string) => Promise<void>;
function stopReactNativeServerAsync
stopReactNativeServerAsync: (projectRoot: string) => Promise<void>;
function stopTunnelsAsync
stopTunnelsAsync: (projectRoot: string) => Promise<void>;
function writeArtifactSafelyAsync
writeArtifactSafelyAsync: ( projectRoot: string, keyName: string | null, artifactPath: string, artifact: string | Uint8Array) => Promise<void>;
interface PublishedProjectResult
interface PublishedProjectResult {}
property err
err?: string;
TODO: What is this? Where does it come from?
property ids
ids: string[];
TODO: What is this?
property projectPageUrl
projectPageUrl: string;
Project page URL
property url
url: string;
Project manifest URL
type LoadedHook
type LoadedHook = Hook & { _fn: (input: HookArguments) => any;};
type PublishOptions
type PublishOptions = { releaseChannel?: string; target?: ProjectTarget; resetCache?: boolean; maxWorkers?: number; quiet?: boolean;};
type StartOptions
type StartOptions = { metroPort?: number; webpackPort?: number; isWebSocketsEnabled?: boolean; isRemoteReloadingEnabled?: boolean; devClient?: boolean; reset?: boolean; nonInteractive?: boolean; nonPersistent?: boolean; maxWorkers?: number; webOnly?: boolean; target?: ProjectTarget; platforms?: ExpoConfig['platforms']; forceManifestType?: 'expo-updates' | 'classic';};
namespace ProjectAssets
module 'build/ProjectAssets.d.ts' {}
function exportAssetsAsync
exportAssetsAsync: ({ projectRoot, exp, hostedUrl, assetPath, outputDir, bundles, experimentalBundle,}: ExportAssetsOptions) => Promise<{ exp: ExpoAppManifest; assets: Asset[] }>;
function publishAssetsAsync
publishAssetsAsync: ( options: Pick<ExportAssetsOptions, 'projectRoot' | 'exp' | 'bundles'>) => Promise<{ exp: ExpoAppManifest; assets: Asset[] }>;
function resolveGoogleServicesFile
resolveGoogleServicesFile: ( projectRoot: string, manifest: ExpoConfig) => Promise<void>;
function resolveManifestAssets
resolveManifestAssets: ({ projectRoot, manifest, resolver, strict,}: { projectRoot: string; manifest: ExpoConfig; resolver: (assetPath: string) => Promise<string>; strict?: boolean;}) => Promise<void>;
type Asset
type Asset = ManifestAsset | BundleAssetWithFileHashes;
namespace ProjectSettings
module 'build/ProjectSettings.d.ts' {}
function dotExpoProjectDirectory
dotExpoProjectDirectory: (projectRoot: string) => string;
function dotExpoProjectDirectoryExists
dotExpoProjectDirectoryExists: (projectRoot: string) => boolean;
function getCurrentStatusAsync
getCurrentStatusAsync: (projectRoot: string) => Promise<ProjectStatus>;
function getDevicesInfoAsync
getDevicesInfoAsync: (projectRoot: string) => Promise<DevicesInfo>;
function readAsync
readAsync: (projectRoot: string) => Promise<ProjectSettings>;
function readDevicesInfoAsync
readDevicesInfoAsync: (projectRoot: string) => Promise<DevicesInfo>;
function readPackagerInfoAsync
readPackagerInfoAsync: (projectRoot: string) => Promise<PackagerInfo>;
function saveDevicesAsync
saveDevicesAsync: ( projectRoot: string, deviceIds: string | string[]) => Promise<void>;
function setAsync
setAsync: ( projectRoot: string, json: Partial<ProjectSettings>) => Promise<ProjectSettings>;
function setDevicesInfoAsync
setDevicesInfoAsync: ( projectRoot: string, json: DevicesInfo) => Promise<DevicesInfo>;
function setPackagerInfoAsync
setPackagerInfoAsync: ( projectRoot: string, json: Partial<PackagerInfo>) => Promise<PackagerInfo>;
type DeviceInfo
type DeviceInfo = { installationId: string; lastUsed: number;};
type DevicesInfo
type DevicesInfo = { devices: DeviceInfo[];};
type ProjectSettings
type ProjectSettings = { scheme: string | null; hostType: 'localhost' | 'lan' | 'tunnel'; lanType: 'ip' | 'hostname'; dev: boolean; devClient: boolean; minify: boolean; urlRandomness: string | null; https: boolean; strict?: boolean;};
type Settings
type Settings = ProjectSettings;
namespace ProjectUtils
module 'build/project/ProjectUtils.d.ts' {}
function attachLoggerStream
attachLoggerStream: (projectRoot: string, stream: bunyan.Stream) => void;
function clearNotification
clearNotification: (projectRoot: string, id: string) => void;
function getLogger
getLogger: (projectRoot: string) => bunyan;
function logDebug
logDebug: ( projectRoot: string, tag: LogTag, message: string, id?: string) => void;
function logError
logError: ( projectRoot: string, tag: LogTag, message: string, id?: string) => void;
function logInfo
logInfo: ( projectRoot: string, tag: LogTag, message: string, id?: string) => void;
function logWarning
logWarning: ( projectRoot: string, tag: LogTag, message: string, id?: string) => void;
function logWithLevel
logWithLevel: ( projectRoot: string, level: string, fields: LogFields, msg: string, id?: string) => void;
type LogFields
type LogFields = { tag: LogTag; issueId?: string; issueCleared?: boolean; includesStack?: boolean; deviceId?: string; deviceName?: string; groupDepth?: number; shouldHide?: boolean; _expoEventType?: 'TUNNEL_READY';};
type LogTag
type LogTag = 'expo' | 'metro' | 'device';
namespace Prompts
module 'build/Prompts.d.ts' {}
Used to pause/resume interaction observers while prompting (made for TerminalUI).
Parameter callback
function addInteractionListener
addInteractionListener: (callback: InteractionCallback) => void;
Used to pause/resume interaction observers while prompting (made for TerminalUI).
Parameter callback
function confirmAsync
confirmAsync: (options: { initial?: boolean; message: string;}) => Promise<boolean>;
function pauseInteractions
pauseInteractions: (options?: Omit<InteractionOptions, 'pause'>) => void;
function removeInteractionListener
removeInteractionListener: (callback: InteractionCallback) => void;
function resumeInteractions
resumeInteractions: (options?: Omit<InteractionOptions, 'pause'>) => void;
namespace SimControl
module 'build/SimControl.d.ts' {}
'/Users/name/Library/Developer/CoreSimulator/Devices/00E55DC0-0364-49DF-9EC6-77BE587137D4/data'
function addMediaAsync
addMediaAsync: (udid: string, mediaPath: string) => Promise<SpawnResult>;
function bootAsync
bootAsync: ({ udid }: { udid: string }) => Promise<SimulatorDevice | null>;
function captureScreenAsync
captureScreenAsync: ( udid: string, captureType: 'screenshot' | 'recordVideo', outputFilePath: string) => Promise<SpawnResult>;
function deleteUnavailableAsync
deleteUnavailableAsync: () => Promise<SpawnResult>;
function eraseAllAsync
eraseAllAsync: () => Promise<SpawnResult>;
function eraseAsync
eraseAsync: (udid: string) => Promise<SpawnResult>;
function getContainerPathAsync
getContainerPathAsync: ({ udid, bundleIdentifier,}: { udid: string; bundleIdentifier: string;}) => Promise<string | null>;
Returns the local path for the installed tar.app. Returns null when the app isn't installed.
Parameter
props.udid device udid.
Parameter
props.bundleIdentifier bundle identifier for app
Returns
local file path to installed app binary, e.g. '/Users/evanbacon/Library/Developer/CoreSimulator/Devices/EFEEA6EF-E3F5-4EDE-9B72-29EAFA7514AE/data/Containers/Bundle/Application/FA43A0C6-C2AD-442D-B8B1-EAF3E88CF3BF/Exponent-2.21.3.tar.app'
function getDefaultSimulatorDeviceUDIDAsync
getDefaultSimulatorDeviceUDIDAsync: () => Promise<string | null>;
function installAsync
installAsync: (options: { udid: string; dir: string }) => Promise<any>;
function isLicenseOutOfDate
isLicenseOutOfDate: (text: string) => boolean;
function isXcrunInstalledAsync
isXcrunInstalledAsync: () => Promise<boolean>;
function listAsync
listAsync: ( type: 'devices' | 'devicetypes' | 'runtimes' | 'pairs', query?: string | 'available') => Promise<SimulatorDeviceList>;
function listDevicesAsync
listDevicesAsync: () => Promise<XCTraceDevice[]>;
Get a list of all connected devices.
function listSimulatorDevicesAsync
listSimulatorDevicesAsync: () => Promise<SimulatorDevice[]>;
function openBundleIdAsync
openBundleIdAsync: (options: { udid?: string; bundleIdentifier: string;}) => Promise<SpawnResult>;
function openURLAsync
openURLAsync: (options: { udid?: string; url: string }) => Promise<void>;
function parseXcrunError
parseXcrunError: (e: any) => Error;
function runBootAsync
runBootAsync: ({ udid }: { udid: string }) => Promise<void>;
function setAppearanceAsync
setAppearanceAsync: ( udid: string, theme: 'light' | 'dark') => Promise<SpawnResult>;
function shutdownAsync
shutdownAsync: (udid?: string) => Promise<SpawnResult | null>;
function simctlAsync
simctlAsync: ( [command, ...args]: (string | undefined)[], options?: SpawnOptions) => Promise<SpawnResult>;
function uninstallAsync
uninstallAsync: (options: { udid?: string; bundleIdentifier: string;}) => Promise<any>;
function updatePermissionsAsync
updatePermissionsAsync: ( udid: string, action: 'grant' | 'revoke' | 'reset', permission: PermissionName, bundleIdentifier?: string) => Promise<SpawnResult>;
function waitForDeviceToBootAsync
waitForDeviceToBootAsync: ({ udid,}: Pick<SimulatorDevice, 'udid'>) => Promise<SimulatorDevice | null>;
function xcrunAsync
xcrunAsync: (args: string[], options?: SpawnOptions) => Promise<SpawnResult>;
function xcrunWithLogging
xcrunWithLogging: ( args: string[], options?: SpawnOptions) => Promise<SpawnResult>;
type SimulatorDevice
type SimulatorDevice = { availabilityError: 'runtime profile not found'; /** * '/Users/name/Library/Developer/CoreSimulator/Devices/00E55DC0-0364-49DF-9EC6-77BE587137D4/data' */ dataPath: string; /** * '/Users/name/Library/Logs/CoreSimulator/00E55DC0-0364-49DF-9EC6-77BE587137D4' */ logPath: string; /** * '00E55DC0-0364-49DF-9EC6-77BE587137D4' */ udid: string; /** * com.apple.CoreSimulator.SimRuntime.tvOS-13-4 */ runtime: string; isAvailable: boolean; /** * 'com.apple.CoreSimulator.SimDeviceType.Apple-TV-1080p' */ deviceTypeIdentifier: string; state: DeviceState; /** * 'Apple TV' */ name: string; osType: OSType; /** * '13.4' */ osVersion: string; /** * 'iPhone 11 (13.6)' */ windowName: string;};
type XCTraceDevice
type XCTraceDevice = { /** * '00E55DC0-0364-49DF-9EC6-77BE587137D4' */ udid: string; /** * 'Apple TV' */ name: string; deviceType: 'device' | 'catalyst'; /** * '13.4' */ osVersion: string;};
namespace Simulator
module 'build/Simulator.d.ts' {}
Ensure Xcode is installed an recent enough to be used with Expo.
true when Xcode is installed, false when the process should end.
function activateSimulatorWindowAsync
activateSimulatorWindowAsync: () => Promise<string>;
function closeSimulatorAppAsync
closeSimulatorAppAsync: () => Promise<string>;
function doesExpoClientNeedUpdatedAsync
doesExpoClientNeedUpdatedAsync: ( simulator: Pick<SimControl.SimulatorDevice, 'udid'>, sdkVersion?: string) => Promise<boolean>;
function ensureSimulatorAppRunningAsync
ensureSimulatorAppRunningAsync: ({ udid }: { udid?: string }) => Promise<void>;
function ensureSimulatorOpenAsync
ensureSimulatorOpenAsync: ( { udid, osType }?: { udid?: string; osType?: string }, tryAgain?: boolean) => Promise<SimControl.SimulatorDevice>;
Ensure a simulator is booted and the Simulator app is opened. This is where any timeout related error handling should live.
function ensureXcodeCommandLineToolsInstalledAsync
ensureXcodeCommandLineToolsInstalledAsync: () => Promise<boolean>;
function ensureXcodeInstalledAsync
ensureXcodeInstalledAsync: () => Promise<boolean>;
Ensure Xcode is installed an recent enough to be used with Expo.
true when Xcode is installed, false when the process should end.
function expoVersionOnSimulatorAsync
expoVersionOnSimulatorAsync: ({ udid,}: { udid: string;}) => Promise<string | null>;
function installExpoOnSimulatorAsync
installExpoOnSimulatorAsync: ({ url, simulator, version,}: { simulator: Pick<SimControl.SimulatorDevice, 'name' | 'udid'>; url?: string; version?: string;}) => Promise<any>;
function isExpoClientInstalledOnSimulatorAsync
isExpoClientInstalledOnSimulatorAsync: ({ udid,}: { udid: string;}) => Promise<boolean>;
function isPlatformSupported
isPlatformSupported: () => boolean;
function isSimulatorBootedAsync
isSimulatorBootedAsync: ({ udid,}?: { udid?: string;}) => Promise<SimControl.SimulatorDevice | null>;
function isSimulatorInstalledAsync
isSimulatorInstalledAsync: () => Promise<boolean>;
function openProjectAsync
openProjectAsync: ({ projectRoot, shouldPrompt, devClient, udid, scheme, skipNativeLogs, applicationId,}: { projectRoot: string; shouldPrompt?: boolean; devClient?: boolean; scheme?: string; udid?: string; skipNativeLogs?: boolean; applicationId?: string;}) => Promise< | { success: true; url: string; udid: string; bundleIdentifier: string } | { success: false; error: string }>;
function openWebProjectAsync
openWebProjectAsync: ({ projectRoot, shouldPrompt,}: { shouldPrompt: boolean; projectRoot: string;}) => Promise<{ success: true; url: string } | { success: false; error: string }>;
function promptForSimulatorAsync
promptForSimulatorAsync: ( devices: SimControl.SimulatorDevice[], osType?: string) => Promise<SimControl.SimulatorDevice | null>;
function resolveApplicationIdAsync
resolveApplicationIdAsync: (projectRoot: string) => Promise<any>;
function sortDefaultDeviceToBeginningAsync
sortDefaultDeviceToBeginningAsync: ( devices: SimControl.SimulatorDevice[], osType?: string) => Promise<SimControl.SimulatorDevice[]>;
Sort the devices so the last simulator that was opened (user's default) is the first suggested.
Parameter devices
function streamLogsAsync
streamLogsAsync: ({ bundleIdentifier, udid,}: { bundleIdentifier: string; udid: string;}) => Promise<void>;
function uninstallExpoAppFromSimulatorAsync
uninstallExpoAppFromSimulatorAsync: ({ udid,}?: { udid?: string;}) => Promise<void>;
function upgradeExpoAsync
upgradeExpoAsync: (options?: { udid?: string; url?: string; version?: string;}) => Promise<boolean>;
function waitForExpoClientInstalledOnSimulatorAsync
waitForExpoClientInstalledOnSimulatorAsync: ({ udid,}: { udid: string;}) => Promise<boolean>;
function waitForExpoClientUninstalledOnSimulatorAsync
waitForExpoClientUninstalledOnSimulatorAsync: ({ udid,}: { udid: string;}) => Promise<boolean>;
namespace ThirdParty
module 'build/ThirdParty.d.ts' {}
function getManifest
getManifest: ( publicUrl: string, { platform }?: { platform?: 'android' | 'ios' | 'all' }) => Promise<any>;
namespace UrlUtils
module 'build/UrlUtils.d.ts' {}
function constructAssetsUrlAsync
constructAssetsUrlAsync: ( projectRoot: string, entryPoint: string, requestHostname?: string) => Promise<string>;
function constructBundleQueryParams
constructBundleQueryParams: ( projectRoot: string, opts: MetroQueryOptions) => string;
function constructBundleQueryParamsWithConfig
constructBundleQueryParamsWithConfig: ( projectRoot: string, opts: MetroQueryOptions, exp: Pick<ExpoConfig, 'sdkVersion'>) => string;
function constructBundleUrlAsync
constructBundleUrlAsync: ( projectRoot: string, opts: Partial<URLOptions>, requestHostname?: string) => Promise<string>;
function constructDebuggerHostAsync
constructDebuggerHostAsync: ( projectRoot: string, requestHostname?: string) => Promise<string>;
function constructDeepLinkAsync
constructDeepLinkAsync: ( projectRoot: string, opts?: Partial<URLOptions>, requestHostname?: string) => Promise<string>;
function constructDevClientUrlAsync
constructDevClientUrlAsync: ( projectRoot: string, opts?: Partial<URLOptions>, requestHostname?: string) => Promise<string>;
function constructHostUriAsync
constructHostUriAsync: ( projectRoot: string, requestHostname?: string) => Promise<string>;
function constructLoadingUrlAsync
constructLoadingUrlAsync: ( projectRoot: string, platform: 'ios' | 'android' | null, requestHostname?: string) => Promise<string>;
function constructLogUrlAsync
constructLogUrlAsync: ( projectRoot: string, requestHostname?: string) => Promise<string>;
function constructManifestUrlAsync
constructManifestUrlAsync: ( projectRoot: string, opts?: Partial<URLOptions>, requestHostname?: string) => Promise<string>;
function constructPublishUrlAsync
constructPublishUrlAsync: ( projectRoot: string, entryPoint: string, requestHostname?: string, metroQueryOptions?: MetroQueryOptions) => Promise<string>;
function constructSourceMapUrlAsync
constructSourceMapUrlAsync: ( projectRoot: string, entryPoint: string, requestHostname?: string) => Promise<string>;
function constructUrlAsync
constructUrlAsync: ( projectRoot: string, incomingOpts: Partial<URLOptions> | null, isPackager: boolean, requestHostname?: string) => Promise<string>;
function constructUrlWithExtensionAsync
constructUrlWithExtensionAsync: ( projectRoot: string, entryPoint: string, ext: string, requestHostname?: string, metroQueryOptions?: MetroQueryOptions) => Promise<string>;
function constructWebAppUrlAsync
constructWebAppUrlAsync: ( projectRoot: string, options?: { hostType?: 'localhost' | 'lan' | 'tunnel' }) => Promise<string | null>;
function isHttps
isHttps: (urlString: string) => boolean;
function isURL
isURL: ( urlString: string, { protocols, requireProtocol, }: { protocols?: string[]; requireProtocol?: boolean }) => boolean;
function stripJSExtension
stripJSExtension: (entryPoint: string) => string;
namespace Versions
module 'build/Versions.d.ts' {}
function canTurtleBuildSdkVersion
canTurtleBuildSdkVersion: ( sdkVersion: string, platform: keyof TurtleSDKVersions) => Promise<boolean>;
function gteSdkVersion
gteSdkVersion: ( expJson: Pick<ExpoConfig, 'sdkVersion'>, sdkVersion: string) => boolean;
function lteSdkVersion
lteSdkVersion: ( expJson: Pick<ExpoConfig, 'sdkVersion'>, sdkVersion: string) => boolean;
function newestReleasedSdkVersionAsync
newestReleasedSdkVersionAsync: () => Promise<{ version: string; data: SDKVersion | null;}>;
function oldestSupportedMajorVersionAsync
oldestSupportedMajorVersionAsync: () => Promise<number>;
function parseSdkVersionFromTag
parseSdkVersionFromTag: (tag: string) => string;
function releasedSdkVersionsAsync
releasedSdkVersionsAsync: () => Promise<SDKVersions>;
function sdkVersionsAsync
sdkVersionsAsync: () => Promise<SDKVersions>;
function versionsAsync
versionsAsync: (options?: { skipCache?: boolean }) => Promise<Versions>;
type SDKVersion
type SDKVersion = { androidExpoViewUrl?: string; expoReactNativeTag: string; exponentReactNativeTag?: string; expokitNpmPackage?: string; facebookReactNativeVersion: string; facebookReactVersion?: string; iosExpoViewUrl?: string; iosExponentViewUrl?: string; iosVersion?: string; isDeprecated?: boolean; packagesToInstallWhenEjecting?: { [name: string]: string; }; releaseNoteUrl?: string; iosClientUrl?: string; iosClientVersion?: string; androidClientUrl?: string; androidClientVersion?: string; relatedPackages?: { [name: string]: string; }; beta?: boolean;};
type SDKVersions
type SDKVersions = { [version: string]: SDKVersion;};
namespace Webpack
module 'build/Webpack.d.ts' {}
Get the URL for the running instance of Webpack dev server.
Parameter projectRoot
function broadcastMessage
broadcastMessage: (message: 'reload' | string, data?: any) => Promise<void>;
function bundleAsync
bundleAsync: (projectRoot: string, options?: BundlingOptions) => Promise<void>;
function getUrlAsync
getUrlAsync: (projectRoot: string) => Promise<string | null>;
Get the URL for the running instance of Webpack dev server.
Parameter projectRoot
function openAsync
openAsync: ( projectRoot: string) => Promise<{ success: true; url: string } | { success: false; error: Error }>;
function startAsync
startAsync: ( projectRoot: string, options?: CLIWebOptions) => Promise<WebpackDevServerResults | null>;
function stopAsync
stopAsync: (projectRoot: string) => Promise<void>;
type WebEnvironment
type WebEnvironment = { projectRoot: string; isImageEditingEnabled: boolean; pwa: boolean; mode: 'development' | 'production' | 'test' | 'none'; https: boolean; logger: Log; port?: number; platform?: string;};
type WebpackDevServerResults
type WebpackDevServerResults = { server: WebpackDevServer; location: Omit<WebpackSettings, 'server'>; messageSocket: MessageSocket;};
Package Files (50)
- build/Analytics.d.ts
- build/Android.d.ts
- build/ApiV2.d.ts
- build/Binaries.d.ts
- build/Config.d.ts
- build/ConnectionStatus.d.ts
- build/EmbeddedAssets.d.ts
- build/Env.d.ts
- build/ErrorCode.d.ts
- build/Exp.d.ts
- build/LoadingEvent.d.ts
- build/Logger.d.ts
- build/Project.d.ts
- build/ProjectAssets.d.ts
- build/ProjectSettings.d.ts
- build/Prompts.d.ts
- build/SimControl.d.ts
- build/Simulator.d.ts
- build/ThirdParty.d.ts
- build/UnifiedAnalytics.d.ts
- build/UrlUtils.d.ts
- build/User.d.ts
- build/UserSettings.d.ts
- build/Versions.d.ts
- build/Webpack.d.ts
- build/XDLError.d.ts
- build/apple/AppleDevice.d.ts
- build/apple/CoreSimulator.d.ts
- build/apple/utils/ensureSimulatorAppRunningAsync.d.ts
- build/credentials/AndroidCredentials.d.ts
- build/detach/Detach.d.ts
- build/detach/IosCodeSigning.d.ts
- build/detach/PKCS12Utils.d.ts
- build/index.d.ts
- build/logs/PackagerLogsStream.d.ts
- build/project/Doctor.d.ts
- build/project/ProjectUtils.d.ts
- build/project/createBundlesAsync.d.ts
- build/project/getPublishExpConfigAsync.d.ts
- build/project/publishAsync.d.ts
- build/project/runHook.d.ts
- build/start/LoadingPageHandler.d.ts
- build/start/ngrok.d.ts
- build/start/startAsync.d.ts
- build/start/startDevServerAsync.d.ts
- build/start/startLegacyExpoServerAsync.d.ts
- build/start/startLegacyReactNativeServerAsync.d.ts
- build/tools/ArtifactUtils.d.ts
- build/tools/ModuleVersion.d.ts
- build/utils/isDevClientPackageInstalled.d.ts
Dependencies (63)
- @expo/bunyan
- @expo/config
- @expo/config-plugins
- @expo/dev-server
- @expo/devcert
- @expo/json-file
- @expo/osascript
- @expo/package-manager
- @expo/plist
- @expo/rudder-sdk-node
- @expo/schemer
- @expo/sdk-runtime-versions
- @expo/spawn-async
- @expo/webpack-config
- axios
- better-opn
- boxen
- bplist-parser
- chalk
- concat-stream
- decache
- express
- form-data
- freeport-async
- fs-extra
- getenv
- glob
- hasbin
- internal-ip
- is-reachable
- is-root
- json-schema-deref-sync
- latest-version
- lodash
- md5hex
- minimatch
- mv
- node-forge
- nullthrows
- p-map
- p-retry
- p-timeout
- package-json
- pretty-bytes
- probe-image-size
- progress
- prompts
- requireg
- resolve-from
- semver
- serialize-error
- source-map-support
- split
- strip-ansi
- tar
- terminal-link
- text-table
- tree-kill
- url-join
- uuid
- webpack
- webpack-dev-server
- wrap-ansi
Dev Dependencies (19)
Peer Dependencies (0)
No peer dependencies.
Badge
To add a badge like this oneto your package's README, use the codes available below.
You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/xdl
.
- Markdown[](https://www.jsdocs.io/package/xdl)
- HTML<a href="https://www.jsdocs.io/package/xdl"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>
- Updated .
Package analyzed in 7562 ms. - Missing or incorrect documentation? Open an issue for this package.