xdl

Version 60.0.12
Published 1 year ago
9.43 MB
63 dependencies
MIT license

Install

npm i xdl

yarn add xdl

pnpm add xdl

Overview

The Expo Development Library

Index

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 to native and if true analyzes provided images for splashscreen providing Logger 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',
}

member arm

arm = 'arm'

member arm64

arm64 = 'arm64'

member armeabi

armeabi = 'armeabi'

member armeabiV7a

armeabiV7a = 'armeabi-v7a'

member universal

universal = 'universal'

member x64

x64 = 'x64'

member x86

x86 = 'x86'

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, and devMenu 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)

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

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](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 1 year ago.
Package analyzed in 7562 ms.
Missing or incorrect documentation? Open an issue for this package.

xdl

Install

Overview

Index

Variables

Functions

Classes

Type Aliases

Namespaces

Variables

variable Analytics

variable Config

variable LoadingEvent

variable Logger

variable UnifiedAnalytics

variable UserManager

variable UserSettings

Functions

function isDevClientPackageInstalled

function printBundleSizes

Classes

class ApiV2

constructor

property accessToken

property exponentClient

property sessionSecret

method clientForUser

method deleteAsync

method getAsync

method patchAsync

method postAsync

method putAsync

method setClientName

method uploadFormDataAsync

class PackagerLogsStream

constructor

property bundleDetailsCache

property projectId

method getPlatformTagForBuildDetails

class XDLError

constructor

property code

property isXDLError

property name

Type Aliases

type ErrorCode

type LogRecord

type LogUpdater

type RobotUser

type User

Namespaces

namespace Android

Parameter device

Parameter

function activateEmulatorWindowAsync

function attemptToStartEmulatorOrAssertAsync

function checkSplashScreenImages

Parameter projectRoot

function getAdbFileOutputAsync

function getAdbOutputAsync

function getAllAvailableDevicesAsync

function getAttachedDevicesAsync

function getDeviceABIsAsync

function getDeviceAPIVersionAsync

Returns

function getDeviceSDKVersionAsync

Returns

function getPropertyForDeviceAsync

function installExpoAsync

function installOnDeviceAsync

function isDeviceBootedAsync

function isPlatformSupported

function maybeStopAdbDaemonAsync

function openAppAsync

Parameter device

Parameter

function openProjectAsync

function openWebProjectAsync

function parseAdbDeviceProperties

function promptForDeviceAsync