nativescript 9.1.0-alpha.16 → 9.1.0-alpha.17

package/lib/services/apple-portal/apple-portal-cookie-service.d.ts

@@ -0,0 +1,10 @@
+import { IApplePortalCookieService } from "./definitions";
+export declare class ApplePortalCookieService implements IApplePortalCookieService {
+    private userSessionCookies;
+    private validUserSessionCookieNames;
+    private validWebSessionCookieNames;
+    getWebSessionCookie(cookiesData: string[]): string;
+    getUserSessionCookie(): string;
+    updateUserSessionCookie(cookiesData: string[]): void;
+    private parseCookiesData;
+}

package/lib/services/apple-portal/apple-portal-session-service.d.ts

@@ -0,0 +1,19 @@
+import { IErrors, Server, ICredentials } from "../../common/declarations";
+import { IAppleCreateUserSessionOptions, IApplePortalUserDetail, IApplePortalCookieService, IApplePortalSessionService } from "./definitions";
+export declare class ApplePortalSessionService implements IApplePortalSessionService {
+    private $applePortalCookieService;
+    private $errors;
+    private $httpClient;
+    private $logger;
+    private $prompter;
+    private loginConfigEndpoint;
+    private defaultLoginConfig;
+    constructor($applePortalCookieService: IApplePortalCookieService, $errors: IErrors, $httpClient: Server.IHttpClient, $logger: ILogger, $prompter: IPrompter);
+    createUserSession(credentials: ICredentials, opts?: IAppleCreateUserSessionOptions): Promise<IApplePortalUserDetail>;
+    createWebSession(contentProviderId: number): Promise<string>;
+    private login;
+    private loginCore;
+    private getLoginConfig;
+    private fetchHashcash;
+    private handleTwoFactorAuthentication;
+}

package/lib/services/apple-portal/srp/srp-wrapper.d.ts

@@ -0,0 +1,29 @@
+export type SRPProtocol = "s2k" | "s2k_fo";
+export interface ServerSRPInitRequest {
+    a: string;
+    accountName: string;
+    protocols: SRPProtocol[];
+}
+export interface ServerSRPInitResponse {
+    iteration: number;
+    salt: string;
+    protocol: "s2k" | "s2k_fo";
+    b: string;
+    c: string;
+}
+export interface ServerSRPCompleteRequest {
+    accountName: string;
+    c: string;
+    m1: string;
+    m2: string;
+    rememberMe: boolean;
+    trustTokens: string[];
+}
+export declare class GSASRPAuthenticator {
+    private username;
+    constructor(username: string);
+    private srpClient?;
+    private derivePassword;
+    getInit(): Promise<ServerSRPInitRequest>;
+    getComplete(password: string, serverData: ServerSRPInitResponse): Promise<Pick<ServerSRPCompleteRequest, "m1" | "m2" | "c" | "accountName">>;
+}

package/lib/services/assets-generation/assets-generation-service.d.ts

@@ -0,0 +1,24 @@
+import { IAssetsGenerationService, IOptions, IResourceGenerationData } from "../../declarations";
+import { IProjectDataService } from "../../definitions/project";
+import { IFileSystem } from "../../common/declarations";
+export declare const enum Operations {
+    OverlayWith = "overlayWith",
+    Blank = "blank",
+    Resize = "resize",
+    OuterScale = "outerScale"
+}
+export declare class AssetsGenerationService implements IAssetsGenerationService {
+    private $logger;
+    private $projectDataService;
+    private $fs;
+    private $options;
+    private get propertiesToEnumerate();
+    constructor($logger: ILogger, $projectDataService: IProjectDataService, $fs: IFileSystem, $options: IOptions);
+    generateIcons(resourceGenerationData: IResourceGenerationData): Promise<void>;
+    generateSplashScreens(splashesGenerationData: IResourceGenerationData): Promise<void>;
+    private generateImagesForDefinitions;
+    private resize;
+    private generateImage;
+    private getRgbaNumber;
+    private isAssetFilePath;
+}

package/lib/services/build-artifacts-service.d.ts

@@ -0,0 +1,16 @@
+import { IBuildArtifactsService } from "../definitions/build";
+import { IPlatformData, IBuildOutputOptions, IValidBuildOutputData } from "../definitions/platform";
+import { IApplicationPackage } from "../declarations";
+import { IErrors, IFileSystem } from "../common/declarations";
+export declare class BuildArtifactsService implements IBuildArtifactsService {
+    private $errors;
+    private $fs;
+    private $logger;
+    constructor($errors: IErrors, $fs: IFileSystem, $logger: ILogger);
+    getLatestAppPackagePath(platformData: IPlatformData, buildOutputOptions: IBuildOutputOptions): Promise<string>;
+    getAllAppPackages(buildOutputPath: string, validBuildOutputData: IValidBuildOutputData): IApplicationPackage[];
+    copyLatestAppPackage(targetPath: string, platformData: IPlatformData, buildOutputOptions: IBuildOutputOptions): void;
+    private getLatestApplicationPackage;
+    private getApplicationPackagesCore;
+    private createApplicationPackages;
+}

package/lib/services/build-data-service.d.ts

@@ -0,0 +1,7 @@
+import { AndroidBuildData, IOSBuildData } from "../data/build-data";
+import { IBuildDataService } from "../definitions/build";
+export declare class BuildDataService implements IBuildDataService {
+    private $mobileHelper;
+    constructor($mobileHelper: Mobile.IMobileHelper);
+    getBuildData(projectDir: string, platform: string, data: any): IOSBuildData | AndroidBuildData;
+}

package/lib/services/build-info-file-service.d.ts

@@ -0,0 +1,16 @@
+import { IPlatformData, IBuildInfo } from "../definitions/platform";
+import { IBuildInfoFileService, IBuildData } from "../definitions/build";
+import { IProjectData } from "../definitions/project";
+import { IFileSystem } from "../common/declarations";
+export declare class BuildInfoFileService implements IBuildInfoFileService {
+    private $devicePathProvider;
+    private $fs;
+    private $mobileHelper;
+    private $projectChangesService;
+    constructor($devicePathProvider: IDevicePathProvider, $fs: IFileSystem, $mobileHelper: Mobile.IMobileHelper, $projectChangesService: IProjectChangesService);
+    getLocalBuildInfo(platformData: IPlatformData, buildData: IBuildData): IBuildInfo;
+    getDeviceBuildInfo(device: Mobile.IDevice, projectData: IProjectData): Promise<IBuildInfo>;
+    saveLocalBuildInfo(platformData: IPlatformData, buildInfoFileDirname: string): void;
+    saveDeviceBuildInfo(device: Mobile.IDevice, projectData: IProjectData, outputFilePath: string): Promise<void>;
+    private getDeviceBuildInfoFilePath;
+}

package/lib/services/bundler/bundler-compiler-service.d.ts

@@ -0,0 +1,50 @@
+import { EventEmitter } from "events";
+import { IPackageManager, IPackageInstallationManager, IOptions } from "../../declarations";
+import { IPlatformData } from "../../definitions/platform";
+import { BundlerType, IProjectConfigService, IProjectData } from "../../definitions/project";
+import { IErrors, IChildProcess, IFileSystem, IHooksService, IHostInfo } from "../../common/declarations";
+import { ICleanupService } from "../../definitions/cleanup-service";
+export declare class BundlerCompilerService extends EventEmitter implements IBundlerCompilerService {
+    private $options;
+    private $errors;
+    private $childProcess;
+    $fs: IFileSystem;
+    $hooksService: IHooksService;
+    $hostInfo: IHostInfo;
+    private $logger;
+    private $mobileHelper;
+    private $cleanupService;
+    private $packageManager;
+    private $packageInstallationManager;
+    private $projectConfigService;
+    private bundlerProcesses;
+    private viteServeProcesses;
+    private expectedHashes;
+    constructor($options: IOptions, $errors: IErrors, $childProcess: IChildProcess, $fs: IFileSystem, $hooksService: IHooksService, $hostInfo: IHostInfo, $logger: ILogger, $mobileHelper: Mobile.IMobileHelper, $cleanupService: ICleanupService, $packageManager: IPackageManager, $packageInstallationManager: IPackageInstallationManager, $projectConfigService: IProjectConfigService);
+    private getViteDistOutputPath;
+    private getViteBuildPaths;
+    compileWithWatch(platformData: IPlatformData, projectData: IProjectData, prepareData: IPrepareData): Promise<any>;
+    compileWithoutWatch(platformData: IPlatformData, projectData: IProjectData, prepareData: IPrepareData): Promise<void>;
+    stopBundlerCompiler(platform: string): Promise<void>;
+    private shouldUsePreserveSymlinksOption;
+    private startBundleProcess;
+    private getViteHmrPort;
+    private startViteDevServer;
+    private waitForPort;
+    private buildEnvData;
+    private buildEnvCommandLineParams;
+    getUpdatedEmittedFiles(allEmittedFiles: string[], chunkFiles: string[], nextHash: string, platform: string): {
+        emittedFiles: string[];
+        fallbackFiles: string[];
+        hash: string;
+    };
+    private getCurrentHotUpdateHash;
+    private stopBundlerForPlatform;
+    private handleHMRMessage;
+    private getBundlerExecutablePath;
+    private isModernBundler;
+    getBundler(): BundlerType;
+    private copyViteBundleToNative;
+    private getIncrementalFilesToCopy;
+    private copyRecursiveSync;
+}

package/lib/services/bundler/bundler-compiler-service.js

@@ -246,7 +246,8 @@ class BundlerCompilerService extends events_1.EventEmitter {
     }
     async shouldUsePreserveSymlinksOption() {
         const currentPackageManager = await this.$packageManager.getPackageManagerName();
-        const res = currentPackageManager !== constants_1.PackageManagers.pnpm;
+        const res = currentPackageManager !== constants_1.PackageManagers.pnpm &&
+            currentPackageManager !== constants_1.PackageManagers.bun;
         return res;
     }
     async startBundleProcess(platformData, projectData, prepareData) {

package/lib/services/bundler/bundler.d.ts

@@ -0,0 +1,75 @@
+import { EventEmitter } from "events";
+import { BuildData } from "../../data/build-data";
+import { PrepareData } from "../../data/prepare-data";
+import { IPlatformProjectServiceBase, IProjectData, IValidatePlatformOutput } from "../../definitions/project";
+import { IOptions, IDependencyData } from "../../declarations";
+import { IPlatformData } from "../../definitions/platform";
+import { IPluginData } from "../../definitions/plugins";
+import { IRelease, ISpawnResult } from "../../common/declarations";
+import { IProjectChangesInfo, IPrepareInfo, IAddedNativePlatform } from "../../definitions/project-changes";
+import { INotConfiguredEnvOptions } from "../../common/definitions/commands";
+declare global {
+    interface IBundlerCompilerService extends EventEmitter {
+        compileWithWatch(platformData: IPlatformData, projectData: IProjectData, prepareData: IPrepareData): Promise<any>;
+        compileWithoutWatch(platformData: IPlatformData, projectData: IProjectData, prepareData: IPrepareData): Promise<void>;
+        stopBundlerCompiler(platform: string): Promise<void>;
+    }
+    interface IBundlerEnvOptions {
+        sourceMap?: boolean;
+        uglify?: boolean;
+        production?: boolean;
+    }
+    interface IProjectChangesService {
+        checkForChanges(platformData: IPlatformData, projectData: IProjectData, prepareData: IPrepareData): Promise<IProjectChangesInfo>;
+        getPrepareInfoFilePath(platformData: IPlatformData): string;
+        getPrepareInfo(platformData: IPlatformData): IPrepareInfo;
+        savePrepareInfo(platformData: IPlatformData, projectData: IProjectData, prepareData: IPrepareData): Promise<void>;
+        setNativePlatformStatus(platformData: IPlatformData, projectData: IProjectData, addedPlatform: IAddedNativePlatform): void;
+        currentChanges: IProjectChangesInfo;
+    }
+    interface IFilesChangeEventData {
+        platform: string;
+        files: string[];
+        staleFiles: string[];
+        hmrData: IPlatformHmrData;
+        hasOnlyHotUpdateFiles: boolean;
+        hasNativeChanges: boolean;
+    }
+    interface IBundlerEmitMessage {
+        emittedFiles: string[];
+        chunkFiles: string[];
+        hash: string;
+        changedFiles?: string[];
+        isHMR?: boolean;
+        filesToCopy?: string[];
+        buildType?: string;
+    }
+    interface IPlatformProjectService extends NodeJS.EventEmitter, IPlatformProjectServiceBase {
+        getPlatformData(projectData: IProjectData): IPlatformData;
+        validate(projectData: IProjectData, options: IOptions, notConfiguredEnvOptions?: INotConfiguredEnvOptions): Promise<IValidatePlatformOutput>;
+        createProject(frameworkDir: string, frameworkVersion: string, projectData: IProjectData): Promise<void>;
+        interpolateData(projectData: IProjectData): Promise<void>;
+        interpolateConfigurationFile(projectData: IProjectData): void;
+        afterCreateProject(projectRoot: string, projectData: IProjectData): void;
+        validateOptions(projectId?: string, provision?: true | string, teamId?: true | string): Promise<boolean>;
+        buildProject<T extends BuildData>(projectRoot: string, projectData: IProjectData, buildConfig: T): Promise<void>;
+        prepareProject<T extends PrepareData>(projectData: IProjectData, prepareData: T): Promise<void>;
+        prepareAppResources(projectData: IProjectData): void;
+        isPlatformPrepared(projectRoot: string, projectData: IProjectData): boolean;
+        preparePluginNativeCode(pluginData: IPluginData, options?: any): Promise<void>;
+        shouldRepreparePlugin?(pluginData: IPluginData, projectData: IProjectData): boolean;
+        removePluginNativeCode(pluginData: IPluginData, projectData: IProjectData): Promise<void>;
+        beforePrepareAllPlugins(projectData: IProjectData, dependencies?: IDependencyData[]): Promise<IDependencyData[]>;
+        handleNativeDependenciesChange(projectData: IProjectData, opts: IRelease): Promise<void>;
+        getAppResourcesDestinationDirectoryPath(projectData: IProjectData): string;
+        cleanDeviceTempFolder(deviceIdentifier: string, projectData: IProjectData): Promise<void>;
+        processConfigurationFilesFromAppResources(projectData: IProjectData, opts: {
+            release: boolean;
+        }): Promise<void>;
+        ensureConfigurationFileInAppResources(projectData: IProjectData): void;
+        stopServices?(projectRoot: string): Promise<ISpawnResult>;
+        cleanProject?(projectRoot: string): Promise<void>;
+        checkForChanges<T extends PrepareData>(changeset: IProjectChangesInfo, prepareData: T, projectData: IProjectData): Promise<void>;
+        getDeploymentTarget?(projectData: IProjectData): any;
+    }
+}

package/lib/services/cleanup-service.d.ts

@@ -0,0 +1,29 @@
+import { IOptions } from "../declarations";
+import { IChildProcess } from "../common/declarations";
+import { ICleanupService } from "../definitions/cleanup-service";
+import { ISpawnCommandInfo, IRequestInfo, IJSCommand } from "../detached-processes/cleanup-process-definitions";
+export declare class CleanupService implements ICleanupService {
+    private $staticConfig;
+    private $childProcess;
+    private static CLEANUP_PROCESS_START_TIMEOUT;
+    private pathToCleanupLogFile;
+    private cleanupProcess;
+    constructor($options: IOptions, $staticConfig: Config.IStaticConfig, $childProcess: IChildProcess);
+    shouldDispose: boolean;
+    addCleanupCommand(commandInfo: ISpawnCommandInfo): Promise<void>;
+    removeCleanupCommand(commandInfo: ISpawnCommandInfo): Promise<void>;
+    addRequest(requestInfo: IRequestInfo): Promise<void>;
+    removeRequest(requestInfo: IRequestInfo): Promise<void>;
+    addCleanupDeleteAction(filePath: string): Promise<void>;
+    removeCleanupDeleteAction(filePath: string): Promise<void>;
+    addCleanupJS(jsCommand: IJSCommand): Promise<void>;
+    removeCleanupJS(jsCommand: IJSCommand): Promise<void>;
+    addKillProcess(pid: string): Promise<void>;
+    removeKillProcess(pid: string): Promise<void>;
+    setCleanupLogFile(filePath: string): void;
+    dispose(): void;
+    setShouldDispose(shouldDispose: boolean): void;
+    private getCleanupProcess;
+    private getCleanupProcessArgs;
+    private getKillProcesSpawnInfo;
+}

package/lib/services/cocoapods-platform-manager.d.ts

@@ -0,0 +1,17 @@
+import { IProjectData, ICocoaPodsPlatformManager, IPodfilePlatformData } from "../definitions/project";
+export declare class CocoaPodsPlatformManager implements ICocoaPodsPlatformManager {
+    private $logger;
+    constructor($logger: ILogger);
+    addPlatformSection(projectData: IProjectData, podfilePlatformData: IPodfilePlatformData, projectPodfileContent: string): string;
+    removePlatformSection(moduleName: string, projectPodfileContent: string, podfilePath: string): string;
+    replacePlatformRow(podfileContent: string, podfilePath: string): {
+        replacedContent: string;
+        podfilePlatformData: IPodfilePlatformData;
+    };
+    private getPlatformSectionData;
+    private selectPlatformDataFromProjectPodfile;
+    private shouldReplacePlatformSection;
+    private buildPlatformSection;
+    private getPlatformSectionHeader;
+    private getPlatformSectionFooter;
+}

package/lib/services/cocoapods-service.d.ts

@@ -0,0 +1,47 @@
+import { IPluginData } from "../definitions/plugins";
+import { IProjectData, ICocoaPodsPlatformManager, ICocoaPodsService } from "../definitions/project";
+import { IPlatformData } from "../definitions/platform";
+import { IConfiguration, IXcconfigService } from "../declarations";
+import { IFileSystem, IChildProcess, IErrors, ISpawnResult } from "../common/declarations";
+import { XcodeSelectService } from "../common/services/xcode-select-service";
+export declare class CocoaPodsService implements ICocoaPodsService {
+    private $cocoaPodsPlatformManager;
+    private $fs;
+    private $childProcess;
+    private $errors;
+    private $logger;
+    private $config;
+    private $xcconfigService;
+    private $xcodeSelectService;
+    private static PODFILE_POST_INSTALL_SECTION_NAME;
+    private static INSTALLER_BLOCK_PARAMETER_NAME;
+    private getCocoaPodsFromPodfile;
+    constructor($cocoaPodsPlatformManager: ICocoaPodsPlatformManager, $fs: IFileSystem, $childProcess: IChildProcess, $errors: IErrors, $logger: ILogger, $config: IConfiguration, $xcconfigService: IXcconfigService, $xcodeSelectService: XcodeSelectService);
+    getPodfileHeader(targetName: string): string;
+    getPodfileFooter(): string;
+    getProjectPodfilePath(projectRoot: string): string;
+    executePodInstall(projectRoot: string, xcodeProjPath: string): Promise<ISpawnResult>;
+    mergePodXcconfigFile(projectData: IProjectData, platformData: IPlatformData): Promise<void>;
+    applyPodfileFromAppResources(projectData: IProjectData, platformData: IPlatformData): Promise<void>;
+    applyPodfileArchExclusions(projectData: IProjectData, platformData: IPlatformData): Promise<void>;
+    applyPodfileFromExtensions(projectData: IProjectData, platformData: IPlatformData): Promise<void>;
+    applyPodfileToProject(moduleName: string, podfilePath: string, projectData: IProjectData, platformData: IPlatformData): Promise<void>;
+    removePodfileFromProject(moduleName: string, podfilePath: string, projectData: IProjectData, projectRoot: string): void;
+    getPluginPodfilePath(pluginData: IPluginData): string;
+    private addPostInstallHook;
+    private getPodfileContentWithoutTarget;
+    private saveProjectPodfile;
+    private removePostInstallHook;
+    private getHookBasicFuncNameForPlugin;
+    private replaceHookContent;
+    private getPluginPodfileHeader;
+    private getPluginPodfileEnd;
+    private getExtensionPodfileHeader;
+    private getExtensionPodfileEnd;
+    private getPostInstallHookHeader;
+    private buildPodfileContent;
+    private getMainPodFilePath;
+    private isMainPodFile;
+    private overridePodsFromFile;
+    private _getCocoaPodsFromPodfile;
+}

package/lib/services/debug-data-service.d.ts

@@ -0,0 +1,7 @@
+import { IProjectData } from "../definitions/project";
+import { IDebugOptions, IDebugData, IDebugDataService } from "../definitions/debug";
+export declare class DebugDataService implements IDebugDataService {
+    private $devicesService;
+    constructor($devicesService: Mobile.IDevicesService);
+    getDebugData(deviceIdentifier: string, projectData: IProjectData, debugOptions: IDebugOptions): IDebugData;
+}

package/lib/services/debug-service-base.d.ts

@@ -0,0 +1,12 @@
+import { EventEmitter } from "events";
+import { IDebugData, IDebugOptions, IDeviceDebugService, IDebugResultInfo } from "../definitions/debug";
+export declare abstract class DebugServiceBase extends EventEmitter implements IDeviceDebugService {
+    protected device: Mobile.IDevice;
+    protected $devicesService: Mobile.IDevicesService;
+    constructor(device: Mobile.IDevice, $devicesService: Mobile.IDevicesService);
+    abstract get platform(): string;
+    abstract debug(debugData: IDebugData, debugOptions: IDebugOptions): Promise<IDebugResultInfo>;
+    abstract debugStop(): Promise<void>;
+    protected getCanExecuteAction(deviceIdentifier: string): (device: Mobile.IDevice) => boolean;
+    protected getChromeDebugUrl(debugOptions: IDebugOptions, port: number): string;
+}

package/lib/services/device/device-install-app-service.d.ts

@@ -0,0 +1,19 @@
+import { IBuildArtifactsService, IBuildInfoFileService, IBuildData } from "../../definitions/build";
+import { IProjectDataService } from "../../definitions/project";
+import { IPlatformsDataService } from "../../definitions/platform";
+import { IAnalyticsService, IFileSystem } from "../../common/declarations";
+export declare class DeviceInstallAppService {
+    private $analyticsService;
+    private $buildArtifactsService;
+    private $buildInfoFileService;
+    private $fs;
+    private $logger;
+    private $mobileHelper;
+    private $projectDataService;
+    private $platformsDataService;
+    constructor($analyticsService: IAnalyticsService, $buildArtifactsService: IBuildArtifactsService, $buildInfoFileService: IBuildInfoFileService, $fs: IFileSystem, $logger: ILogger, $mobileHelper: Mobile.IMobileHelper, $projectDataService: IProjectDataService, $platformsDataService: IPlatformsDataService);
+    installOnDevice(device: Mobile.IDevice, buildData: IBuildData, packageFile?: string): Promise<void>;
+    installOnDeviceIfNeeded(device: Mobile.IDevice, buildData: IBuildData, packageFile?: string): Promise<void>;
+    shouldInstall(device: Mobile.IDevice, buildData: IBuildData): Promise<boolean>;
+    private updateHashesOnDevice;
+}

package/lib/services/doctor-service.d.ts

@@ -0,0 +1,51 @@
+import { IProjectDataService } from "../definitions/project";
+import { IVersionsService, IOptions } from "../declarations";
+import { IDoctorService, IAnalyticsService, IHostInfo, IChildProcess, IFileSystem, ISettingsService, ISpawnResult } from "../common/declarations";
+import { IInjector } from "../common/definitions/yok";
+import { DoctorService as DoctorServiceContract } from "../contracts/doctor-service";
+import { ITerminalSpinnerService } from "../definitions/terminal-spinner-service";
+export declare class DoctorServiceImpl implements IDoctorService, DoctorServiceContract {
+    private $analyticsService;
+    private $hostInfo;
+    private $logger;
+    private $childProcess;
+    private $injector;
+    private $projectDataService;
+    private $fs;
+    private $terminalSpinnerService;
+    private $versionsService;
+    private $settingsService;
+    private static DarwinSetupScriptLocation;
+    private static WindowsSetupScriptExecutable;
+    private static WindowsSetupScriptArguments;
+    private get jsonFileSettingsPath();
+    private get $jsonFileSettingsService();
+    constructor($analyticsService: IAnalyticsService, $hostInfo: IHostInfo, $logger: ILogger, $childProcess: IChildProcess, $injector: IInjector, $projectDataService: IProjectDataService, $fs: IFileSystem, $terminalSpinnerService: ITerminalSpinnerService, $versionsService: IVersionsService, $settingsService: ISettingsService);
+    printWarnings(configOptions?: {
+        trackResult?: boolean;
+        projectDir?: string;
+        runtimeVersion?: string;
+        options?: IOptions;
+        forceCheck?: boolean;
+        platform?: string;
+    }): Promise<void>;
+    runSetupScript(): Promise<ISpawnResult>;
+    canExecuteLocalBuild(configuration?: {
+        platform?: string;
+        projectDir?: string;
+        runtimeVersion?: string;
+        forceCheck?: boolean;
+    }): Promise<boolean>;
+    checkForDeprecatedShortImportsInAppDir(projectDir: string): void;
+    protected getDeprecatedShortImportsInFiles(files: string[], projectDir: string): {
+        file: string;
+        line: string;
+    }[];
+    private getShortImportRegExp;
+    private runSetupScriptCore;
+    private printPackageManagerTip;
+    private printInfosCore;
+    private filterInfosByType;
+    private getKeyForConfiguration;
+    private getInfos;
+}

package/lib/services/doctor-service.js

@@ -6,7 +6,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DoctorService = void 0;
+exports.DoctorServiceImpl = void 0;
 const os_1 = require("os");
 const path = require("path");
 const _ = require("lodash");
@@ -16,7 +16,7 @@ const constants_1 = require("../constants");
 const doctor_1 = require("@nativescript/doctor");
 const yok_1 = require("../common/yok");
 const color_1 = require("../color");
-class DoctorService {
+class DoctorServiceImpl {
     get jsonFileSettingsPath() {
         return path.join(this.$settingsService.getProfileDir(), "doctor-cache.json");
     }
@@ -91,18 +91,21 @@ class DoctorService {
             return;
         }
         this.$logger.info("Running the setup script to try and automatically configure your environment.");
+        let result;
         if (this.$hostInfo.isDarwin) {
-            await this.runSetupScriptCore(DoctorService.DarwinSetupScriptLocation, []);
+            result = await this.runSetupScriptCore(DoctorServiceImpl.DarwinSetupScriptLocation, []);
         }
         if (this.$hostInfo.isWindows) {
-            await this.runSetupScriptCore(DoctorService.WindowsSetupScriptExecutable, DoctorService.WindowsSetupScriptArguments);
+            result = await this.runSetupScriptCore(DoctorServiceImpl.WindowsSetupScriptExecutable, DoctorServiceImpl.WindowsSetupScriptArguments);
         }
         await this.$analyticsService.trackEventActionInGoogleAnalytics({
             action: constants_1.TrackActionNames.RunSetupScript,
             additionalData: "Finished",
         });
+        return result;
     }
     async canExecuteLocalBuild(configuration) {
+        configuration = configuration || {};
         await this.$analyticsService.trackEventActionInGoogleAnalytics({
             action: constants_1.TrackActionNames.CheckLocalBuildSetup,
             additionalData: "Starting",
@@ -254,10 +257,10 @@ class DoctorService {
         return infos;
     }
 }
-exports.DoctorService = DoctorService;
-DoctorService.DarwinSetupScriptLocation = path.join(__dirname, "..", "..", "setup", "mac-startup-shell-script.sh");
-DoctorService.WindowsSetupScriptExecutable = "powershell.exe";
-DoctorService.WindowsSetupScriptArguments = [
+exports.DoctorServiceImpl = DoctorServiceImpl;
+DoctorServiceImpl.DarwinSetupScriptLocation = path.join(__dirname, "..", "..", "setup", "mac-startup-shell-script.sh");
+DoctorServiceImpl.WindowsSetupScriptExecutable = "powershell.exe";
+DoctorServiceImpl.WindowsSetupScriptArguments = [
     "start-process",
     "-FilePath",
     "PowerShell.exe",
@@ -268,8 +271,8 @@ DoctorService.WindowsSetupScriptArguments = [
 ];
 __decorate([
     (0, decorators_1.cache)()
-], DoctorService.prototype, "jsonFileSettingsPath", null);
+], DoctorServiceImpl.prototype, "jsonFileSettingsPath", null);
 __decorate([
     (0, decorators_1.cache)()
-], DoctorService.prototype, "$jsonFileSettingsService", null);
-yok_1.injector.register("doctorService", DoctorService);
+], DoctorServiceImpl.prototype, "$jsonFileSettingsService", null);
+yok_1.injector.register("doctorService", DoctorServiceImpl);

package/lib/services/extensibility-service.d.ts

@@ -0,0 +1,36 @@
+import { INodePackageManager } from "../declarations";
+import { IFileSystem, ISettingsService, IStringDictionary } from "../common/declarations";
+import { IExtensibilityService, IExtensionData, IExtensionCommandInfo, IGetExtensionCommandInfoParams } from "../common/definitions/extensibility";
+import { IInjector } from "../common/definitions/yok";
+export declare class ExtensibilityService implements IExtensibilityService {
+    private $fs;
+    private $logger;
+    private $packageManager;
+    private $settingsService;
+    private $requireService;
+    private $injector;
+    private customPathToExtensions;
+    private commandRegistry;
+    private get pathToPackageJson();
+    get pathToExtensions(): string;
+    set pathToExtensions(pathToExtensions: string);
+    constructor($fs: IFileSystem, $logger: ILogger, $packageManager: INodePackageManager, $settingsService: ISettingsService, $requireService: IRequireService, $injector: IInjector);
+    installExtension(extensionName: string): Promise<IExtensionData>;
+    uninstallExtension(extensionName: string): Promise<void>;
+    removeAllExtensions(): void;
+    getInstalledExtensionsData(): IExtensionData[];
+    loadExtensions(): Promise<IExtensionData>[];
+    getInstalledExtensions(): IStringDictionary;
+    private getInstalledExtensionData;
+    loadExtension(extensionName: string): Promise<IExtensionData>;
+    getExtensionNameWhereCommandIsRegistered(inputOpts: IGetExtensionCommandInfoParams): Promise<IExtensionCommandInfo>;
+    private getDeclaredCommandsMap;
+    private registerDeclaredCommands;
+    private loadDeclaredCommand;
+    private warnOnDeclaredNameMismatch;
+    private getPathToExtension;
+    private getExtensionPackageJsonData;
+    private assertExtensionIsInstalled;
+    private assertExtensionsDirExists;
+    private assertPackageJsonExists;
+}