nativescript-doctor
Library that helps identifying if the environment can be used for development of {N} apps.
npm i --save nativescript-doctor
  • Version: 1.14.2
  • GitHub:
  • Downloads:
    • Last Day:   995
    • Last Week:  6582
    • Last Month: 28108

nativescript-doctor

Library that helps identifying if the environment can be used for development of {N} apps.

Installation

  1. Using npm
    $ npm install nativescript-doctor --save

Requirements

  1. Node.js 4.3.0 or later

Usage

  • Module doctor:

    • Usage:
    import { doctor } from "nativescript-doctor"

    async function main() {
    const canExecuteLocalBuildForAndroid = await doctor.canExecuteLocalBuild("Android");
    const canExecuteLocalBuildForIos = await doctor.canExecuteLocalBuild("iOS");
    console.log("Can execute local build for Android: ", canExecuteLocalBuildForAndroid);
    console.log("Can execute local build for iOS: ", canExecuteLocalBuildForIos);
    }

    main();
    • Interfaces:
    /**
    * Describes methods which help identifying if the environment can be used for development of {N} apps.
    */
    interface IDoctor {
    /**
    * Checks if a local build can be executed on the current machine.
    * @param {string} platform The platform for which to check if local build is possible.
    * @return {Promise<boolean>} true if local build can be executed for the provided platform.
    */
    canExecuteLocalBuild(platform: string): Promise<boolean>;

    /**
    * Executes all checks for the current environment and returns the warnings from each check.
    * @return {Promise<IWarning[]>} Array of all the warnings from all checks. If there are no warnings will return empty array.
    */
    getWarnings(): Promise<IWarning[]>;
    }

    /**
    * Describes warning returned from nativescript-doctor check.
    */
    interface IWarning {
    /**
    * The warning.
    * @type {string}
    */
    warning: string;

    /**
    * Additional information for the warning.
    * @type {string}
    */
    additionalInformation: string;

    /**
    * The platforms which are affected by this warning.
    * @type {string[]}
    */
    platforms: string[];
    }
  • Module sysInfo:

    • Usage:
    import { sysInfo, setShouldCacheSysInfo } from "nativescript-doctor";

    async function main() {
    // The default value is true. If set to false the result of each check for each element
    // of the sys info will not be cached.
    setShouldCacheSysInfo(false);

    const javacVersion = await sysInfo.getJavaCompilerVersion();
    console.log("javac: ", javacVersion);

    const adbVersion = await sysInfo.getAdbVersion();
    console.log("adb: ", adbVersion);

    const cocoaPodsVersion = await sysInfo.getCocoaPodsVersion();
    console.log("cocoapods: ", cocoaPodsVersion);

    const gitVersion = await sysInfo.getGitVersion();
    console.log("git: ", gitVersion);

    const gradleVersion = await sysInfo.getGradleVersion();
    console.log("gradle: ", gradleVersion);

    const monoVersion = await sysInfo.getMonoVersion();
    console.log("mono: ", monoVersion);

    const nodeVersion = await sysInfo.getNodeVersion();
    console.log("node: ", nodeVersion);

    const npmVersion = await sysInfo.getNpmVersion();
    console.log("npm: ", npmVersion);

    const nodeGypVersion = await sysInfo.getNodeGypVersion();
    console.log("node-gyp: ", nodeGypVersion);

    const osName = await sysInfo.getOs();
    console.log("os: ", osName);

    const xcodeprojLocation = await sysInfo.getXCodeProjLocation();
    console.log("xcodeproj location: ", xcodeprojLocation);

    const xcodeVersion = await sysInfo.getXCodeVersion();
    console.log("xcode: ", xcodeVersion);

    const isAndroidInstalled = await sysInfo.isAndroidInstalled();
    console.log("is Android installed: ", isAndroidInstalled);

    const isITunesInstalled = await sysInfo.isITunesInstalled();
    console.log("is iTunes installed: ", isITunesInstalled);

    const isCocoaPodsWorkingCorrectly = await sysInfo.isCocoaPodsWorkingCorrectly();
    console.log("is cocoapods working correctly: ", isCocoaPodsWorkingCorrectly);

    const nativeScriptCliVersion = await sysInfo.getNativeScriptCliVersion();
    console.log("{N} CLI version: ", nativeScriptCliVersion);

    const xcprojInfo = await sysInfo.getXcprojInfo();
    console.log("xcproj info: ", xcprojInfo);

    const isCocoaPodsUpdateRequired = await sysInfo.isCocoaPodsUpdateRequired();
    console.log("is CocoaPods update required: ", isCocoaPodsUpdateRequired);

    const pythonInfo = await sysInfo.getPythonInfo();
    console.log("python info: ", pythonInfo );

    const sysInfoData = await sysInfo.getSysInfo({ projectDir: "/Users/username/myProject" });
    console.log("sysInfo: ", sysInfoData);

    const gitPath = await sysInfo.getGitPath();
    console.log("Path to the git executable: ", gitPath);
    }

    main();
    • Interfaces:
    /**
    * Describes methods which helps collecting system information.
    */
    interface ISysInfo {
    /**
    * Returns the currently installed Java compiler version.
    * @return {Promise<string>} The currently installed Java compiler version.
    */
    getJavaCompilerVersion(): Promise<string>;

    /**
    * Returns the currently installed version of Xcode.
    * @return {Promise<string>} Returns the currently installed version of Xcode or null if Xcode is not installed or executed on Linux or Windows.
    */
    getXcodeVersion(): Promise<string>;

    /**
    * Returns the currently installed Node.js version.
    * @return {Promise<string>} Returns the currently installed Node.js version.
    */
    getNodeVersion(): Promise<string>;

    /**
    * Returns the currently installed npm version.
    * @return {Promise<string>} Returns the currently installed npm version.
    */
    getNpmVersion(): Promise<string>;

    /**
    * Returns the currently installed node-gyp version.
    * @return {Promise<string>} Returns the currently installed node-gyp version. If node-gyp is not installed it will return null.
    */
    getNodeGypVersion(): Promise<string>;

    /**
    * Returns the xcodeproj location.
    * @return {Promise<string>} Returns the xcodeproj location. If the the xcodeproj is not installed it will return null.
    */
    getXcodeprojLocation(): Promise<string>;

    /**
    * Checks if iTunes is installed.
    * @return {Promise<string>} Returns true if iTunes is installed.
    */
    isITunesInstalled(): Promise<boolean>;

    /**
    * Returns the currently installed Cocoapods version.
    * @return {Promise<string>} Returns the currently installed Cocoapods version. It will return null if Cocoapods is not installed.
    */
    getCocoaPodsVersion(): Promise<string>;

    /**
    * Returns the os name.
    * @return {Promise<string>} Returns the os name.
    */
    getOs(): Promise<string>;

    /**
    * Returns the currently installed ADB version.
    * @param {string} pathToAdb Defines path to adb
    * @return {Promise<string>} Returns the currently installed ADB version. It will return null if ADB is not installed.
    */
    getAdbVersion(pathToAdb?: string): Promise<string>;

    /**
    * Checks if Android is installed.
    * @return {Promise<boolean>} Returns true if Android is installed.
    */
    isAndroidInstalled(): Promise<boolean>;

    /**
    * Returns the currently installed Mono version.
    * @return {Promise<string>} Returns the currently installed Mono version. It will return null if Mono is not installed.
    */
    getMonoVersion(): Promise<string>;

    /**
    * Returns the currently installed Git version.
    * @return {Promise<string>} Returns the currently installed Git version. It will return null if Git is not installed.
    */
    getGitVersion(): Promise<string>;

    /**
    * Returns the currently installed Gradle version.
    * @return {Promise<string>} Returns the currently installed Gradle version. It will return null if Gradle is not installed.
    */
    getGradleVersion(): Promise<string>;

    /**
    * Checks if CocoaPods is working correctly by trying to install one pod.
    * @return {Promise<boolean>} Returns true if CocoaPods is working correctly.
    */
    isCocoaPodsWorkingCorrectly(): Promise<boolean>;

    /**
    * Returns the version of the globally installed NativeScript CLI.
    * @return {Promise<string>} Returns the version of the globally installed NativeScript CLI.
    */
    getNativeScriptCliVersion(): Promise<string>;

    /**
    * Checks if xcproj is required to build projects and if it is installed.
    * @return {Promise<IXcprojInfo>} Returns the collected information aboud xcproj.
    */
    getXcprojInfo(): Promise<IXcprojInfo>;

    /**
    * Checks if the current version of CocoaPods is compatible with the installed Xcode.
    * @return {boolean} true if an update us require.
    */
    isCocoaPodsUpdateRequired(): Promise<boolean>;

    /**
    * Checks if the Android SDK Tools are installed and configured correctly.
    * @return {Promise<boolean>} true if the Android SDK Tools are installed and configured correctly.
    */
    isAndroidSdkConfiguredCorrectly(): Promise<boolean>;

    /**
    * Returns the whole system information.
    * @param {ISysInfoConfig} config
    * @return {Promise<ISysInfoData>} The system information.
    */
    getSysInfo(config?: ISysInfoConfig): Promise<ISysInfoData>;

    /**
    * If set to true each method will cache it's result. The default value is true.
    * @param {boolean} shouldCache The cache switch.
    * @return {void}
    */
    setShouldCacheSysInfo(shouldCache: boolean): void;

    /**
    * Returns the path to the currently installed Git.
    * @return {Promise<string>} Returns the path to the currently installed Git. It will return null if Git is not installed.
    */
    getGitPath(): Promise<string>;
    }

    interface ISysInfoData {
    // os stuff
    /**
    * Os platform flavour, reported by os.platform.
    * @type {string}
    */
    platform: string;

    /**
    * Full os name, like `uname -a` on unix, registry query on win.
    * @type {string}
    */
    os: string;

    /**
    * .net version, applicable to windows only.
    * @type {string}
    */
    dotNetVer: string;

    /**
    * The command shell in use, usually bash or cmd.
    * @type {string}
    */
    shell: string;

    // node stuff
    /**
    * node.js version, returned by node -v.
    * @type {string}
    */
    nodeVer: string;

    /**
    * npm version, returned by `npm -v`.
    * @type {string}
    */
    npmVer: string;

    /**
    * Process architecture, returned by `process.arch`.
    * @type {string}
    */
    procArch: string;

    /**
    * node-gyp version as returned by `node-gyp -v`.
    * @type {string}
    */
    nodeGypVer: string;

    // dependencies
    /**
    * Xcode version string as returned by `xcodebuild -version`. Valid only on Mac.
    * @type {string}
    */
    xcodeVer: string;

    /**
    * Version string of adb, as returned by `adb version`.
    * @type {string}
    */
    adbVer: string;

    /**
    * Whether iTunes is installed on the machine.
    * @type {boolean}
    */
    itunesInstalled: boolean;

    /**
    * Whether `android` executable can be run.
    * @type {boolean}
    */
    androidInstalled: boolean;

    /**
    * mono version, relevant on Mac only.
    * @type {string}
    */
    monoVer: string;

    /**
    * git version string, as returned by `git --version`.
    * @type {string}
    */
    gitVer: string;

    /**
    * gradle version string as returned by `gradle -v`.
    * @type {string}
    */
    gradleVer: string;

    /**
    * javac version string as returned by `javac -version`.
    * @type {string}
    */
    javacVersion: string;

    /**
    * pod version string, as returned by `pod --version`.
    * @type {string}
    */
    cocoaPodsVer: string;

    /**
    * xcodeproj gem location, as returned by `which gem xcodeproj`.
    * @type {string}
    */
    xcodeprojLocation: string;

    /**
    * true id CocoaPods can successfully execute pod install.
    * @type {boolean}
    */
    isCocoaPodsWorkingCorrectly: boolean;

    /**
    * NativeScript CLI version string, as returned by `tns --version`.
    * @type {string}
    */
    nativeScriptCliVersion: string;

    /**
    * Information about xcproj.
    * @type {string}
    */
    xcprojInfo: IXcprojInfo;

    /**
    * true if the system requires xcproj to build projects successfully and the CocoaPods version is not compatible with the Xcode.
    */
    isCocoaPodsUpdateRequired: boolean;

    /**
    * true if the Android SDK Tools are installed and configured correctly.
    * @type {boolean}
    */
    isAndroidSdkConfiguredCorrectly: boolean;
    }

    /**
    * Describes information about xcproj brew formula.
    */
    interface IXcprojInfo {
    /**
    * Determines whether the system needs xcproj to execute ios builds sucessfully.
    */
    shouldUseXcproj: boolean;

    /**
    * Determines whether xcproj can be called from the command line.
    */
    xcprojAvailable: boolean;
    }
  • Module androidToolsInfo:

    • Usage:
    import { androidToolsInfo } from "nativescript-doctor"

    function main() {
    const projectDir = "/Users/username/myProject";
    console.log("path to adb from android home: ", await androidToolsInfo.getPathToAdbFromAndroidHome());
    console.log("path to emulator executable: ", androidToolsInfo.getPathToEmulatorExecutable());
    console.log("android tools info: ", androidToolsInfo.getToolsInfo());
    console.log("ANROID_HOME validation errors: ", await androidToolsInfo.validateAndroidHomeEnvVariable());
    console.log("android tools info validation errors: ", await androidToolsInfo.validateInfo());
    console.log("javac validation errors: ", await androidToolsInfo.validateJavacVersion(await sysInfo.getJavaCompilerVersion(), projectDir));
    }

    main();
    • Interfaces:
    /**
    * Describes methods for getting and validating Android tools.
    */
    interface IAndroidToolsInfo {
    /**
    * Returns the Android tools info.
    * @return {NativeScriptDoctor.IAndroidToolsInfoData} returns the Android tools info.
    */
    getToolsInfo(): NativeScriptDoctor.IAndroidToolsInfoData;

    /**
    * Checks if the Android tools are valid.
    * @param {string} projectDir @optional The project directory. Used to determine the Android Runtime version and validate the Java compiler version against it.
    * If it is not passed or the project does not have Android runtime, this validation is skipped.
    * @return {NativeScriptDoctor.IWarning[]} An array of errors from the validation checks. If there are no errors will return [].
    */
    validateInfo(projectDir?: string): NativeScriptDoctor.IWarning[];

    /**
    * Checks if the current javac version is valid.
    * @param {string} installedJavaVersion The version of javac to check.
    * @param {string} projectDir @optional The project directory. Used to determine the Android Runtime version and validate the Java compiler version against it.
    * If it is not passed or the project does not have Android runtime, this validation is skipped.
    * @return {NativeScriptDoctor.IWarning[]} An array of errors from the validation checks. If there are no errors will return [].
    */
    validateJavacVersion(installedJavaVersion: string, projectDir?: string): NativeScriptDoctor.IWarning[];

    /**
    * Returns the path to the adb which is located in ANDROID_HOME.
    * @return {Promise<string>} Path to the adb which is located in ANDROID_HOME.
    */
    getPathToAdbFromAndroidHome(): Promise<string>;

    /**
    * Checks if the ANDROID_HOME variable is set to the correct folder.
    * @return {NativeScriptDoctor.IWarning[]} An array of errors from the validation checks. If there are no errors will return [].
    */
    validateAndroidHomeEnvVariable(): NativeScriptDoctor.IWarning[];

    /**
    * Returns the path to the emulator executable.
    * @return {string} The path to the emulator executable.
    */
    getPathToEmulatorExecutable(): string;
    }

    /**
    * Describes information about installed Android tools and SDKs.
    */
    interface IAndroidToolsInfoData {
    /**
    * The value of ANDROID_HOME environment variable.
    */
    androidHomeEnvVar: string;

    /**
    * The latest installed version of Android Build Tools that satisfies CLI's requirements.
    */
    buildToolsVersion: string;

    /**
    * The latest installed version of Android SDK that satisfies CLI'
    s requirements.
    */
    compileSdkVersion: number;

    /**
    * The latest installed version of Android Support Repository that satisfies CLI's requirements.
    */
    supportRepositoryVersion: string;
    }
  • Module constants:

    • Usage:
    import { constants } from "nativescript-doctor"

    function main() {
    for(let constantName in constants) {
    console.log(`${constantName}: ${constants[constantName]}`);
    }
    }

    main();
    • Interfaces:
    /**
    * Describes the constants used in the module.
    */
    interface IConstants {
    ANDROID_PLATFORM_NAME: string;
    IOS_PLATFORM_NAME: string;
    SUPPORTED_PLATFORMS: string[];
    }