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

package/lib/services/livesync/ios-device-livesync-service.d.ts

@@ -0,0 +1,28 @@
+import { DeviceLiveSyncServiceBase } from "./device-livesync-service-base";
+import { IiOSSocketRequestExecutor, IPlatformCommandHelper } from "../../declarations";
+import { IPlatformsDataService } from "../../definitions/platform";
+import { IProjectData } from "../../definitions/project";
+export declare class IOSDeviceLiveSyncService extends DeviceLiveSyncServiceBase implements INativeScriptDeviceLiveSyncService {
+    private $logger;
+    private $iOSSocketRequestExecutor;
+    private $devicePlatformsConstants;
+    private $lockService;
+    protected platformsDataService: IPlatformsDataService;
+    private $platformCommandHelper;
+    protected device: Mobile.IiOSDevice;
+    private static MIN_RUNTIME_VERSION_WITH_REFRESH_NOTIFICATION;
+    private socket;
+    constructor($logger: ILogger, $iOSSocketRequestExecutor: IiOSSocketRequestExecutor, $devicePlatformsConstants: Mobile.IDevicePlatformsConstants, $lockService: ILockService, platformsDataService: IPlatformsDataService, $platformCommandHelper: IPlatformCommandHelper, device: Mobile.IiOSDevice);
+    private canRefreshWithNotification;
+    private setupSocketIfNeeded;
+    removeFiles(deviceAppData: Mobile.IDeviceAppData, localToDevicePaths: Mobile.ILocalToDevicePathData[]): Promise<void>;
+    shouldRestart(projectData: IProjectData, liveSyncInfo: ILiveSyncResultInfo): Promise<boolean>;
+    tryRefreshApplication(projectData: IProjectData, liveSyncInfo: ILiveSyncResultInfo): Promise<boolean>;
+    private refreshApplicationCore;
+    private refreshWithNotification;
+    restartApplication(projectData: IProjectData, liveSyncInfo: ILiveSyncResultInfo): Promise<void>;
+    private reloadPage;
+    private attachEventHandlers;
+    private sendMessage;
+    private destroySocket;
+}

package/lib/services/livesync/ios-livesync-service.d.ts

@@ -0,0 +1,17 @@
+import { PlatformLiveSyncServiceBase } from "./platform-livesync-service-base";
+import { IPlatformsDataService } from "../../definitions/platform";
+import { IFileSystem, IProjectFilesManager, IProjectDir } from "../../common/declarations";
+import { IInjector } from "../../common/definitions/yok";
+import { ITempService } from "../../definitions/temp-service";
+import { IOptions } from "../../declarations";
+export declare class IOSLiveSyncService extends PlatformLiveSyncServiceBase implements IPlatformLiveSyncService {
+    protected $fs: IFileSystem;
+    protected $platformsDataService: IPlatformsDataService;
+    protected $projectFilesManager: IProjectFilesManager;
+    private $injector;
+    private $tempService;
+    constructor($fs: IFileSystem, $platformsDataService: IPlatformsDataService, $projectFilesManager: IProjectFilesManager, $injector: IInjector, $tempService: ITempService, $devicePathProvider: IDevicePathProvider, $logger: ILogger, $options: IOptions);
+    fullSync(syncInfo: IFullSyncInfo): Promise<ILiveSyncResultInfo>;
+    syncAfterInstall(device: Mobile.IDevice, liveSyncInfo: ILiveSyncWatchInfo): Promise<void>;
+    protected _getDeviceLiveSyncService(device: Mobile.IDevice, data: IProjectDir): INativeScriptDeviceLiveSyncService;
+}

package/lib/services/livesync/livesync-socket.d.ts

@@ -0,0 +1,5 @@
+import * as net from "net";
+export declare class LiveSyncSocket extends net.Socket implements ILiveSyncSocket {
+    uid: string;
+    writeAsync(data: Buffer): Promise<Boolean>;
+}

package/lib/services/livesync/platform-livesync-service-base.d.ts

@@ -0,0 +1,25 @@
+import { IPlatformsDataService } from "../../definitions/platform";
+import { IProjectData } from "../../definitions/project";
+import { IFileSystem, IProjectFilesManager } from "../../common/declarations";
+import { IOptions } from "../../declarations";
+export declare abstract class PlatformLiveSyncServiceBase {
+    protected $fs: IFileSystem;
+    protected $logger: ILogger;
+    protected $platformsDataService: IPlatformsDataService;
+    protected $projectFilesManager: IProjectFilesManager;
+    private $devicePathProvider;
+    private $options;
+    private _deviceLiveSyncServicesCache;
+    constructor($fs: IFileSystem, $logger: ILogger, $platformsDataService: IPlatformsDataService, $projectFilesManager: IProjectFilesManager, $devicePathProvider: IDevicePathProvider, $options: IOptions);
+    getDeviceLiveSyncService(device: Mobile.IDevice, projectData: IProjectData): INativeScriptDeviceLiveSyncService;
+    protected abstract _getDeviceLiveSyncService(device: Mobile.IDevice, data: IProjectData, frameworkVersion: string): INativeScriptDeviceLiveSyncService;
+    shouldRestart(projectData: IProjectData, liveSyncInfo: ILiveSyncResultInfo): Promise<boolean>;
+    syncAfterInstall(device: Mobile.IDevice, liveSyncInfo: ILiveSyncWatchInfo): Promise<void>;
+    restartApplication(projectData: IProjectData, liveSyncInfo: ILiveSyncResultInfo): Promise<void>;
+    tryRefreshApplication(projectData: IProjectData, liveSyncInfo: ILiveSyncResultInfo): Promise<boolean>;
+    fullSync(syncInfo: IFullSyncInfo): Promise<ILiveSyncResultInfo>;
+    liveSyncWatchAction(device: Mobile.IDevice, liveSyncInfo: ILiveSyncWatchInfo): Promise<ILiveSyncResultInfo>;
+    private transferFiles;
+    getAppData(syncInfo: IFullSyncInfo): Promise<Mobile.IDeviceAppData>;
+    private logFilesSyncInformation;
+}

package/lib/services/livesync-process-data-service.d.ts

@@ -0,0 +1,10 @@
+import { IDictionary } from "../common/declarations";
+export declare class LiveSyncProcessDataService implements ILiveSyncProcessDataService {
+    protected processes: IDictionary<ILiveSyncProcessData>;
+    persistData(projectDir: string, deviceDescriptors: ILiveSyncDeviceDescriptor[], platforms: string[]): void;
+    getPersistedData(projectDir: string): ILiveSyncProcessData;
+    getDeviceDescriptors(projectDir: string): ILiveSyncDeviceDescriptor[];
+    hasDeviceDescriptors(projectDir: string): boolean;
+    getAllPersistedData(): IDictionary<ILiveSyncProcessData>;
+    getPlatforms(projectDir: string): string[];
+}

package/lib/services/log-parser-service.d.ts

@@ -0,0 +1,11 @@
+import { EventEmitter } from "events";
+import { IErrors } from "../common/declarations";
+export declare class LogParserService extends EventEmitter implements ILogParserService {
+    private $deviceLogProvider;
+    private $errors;
+    private parseRules;
+    constructor($deviceLogProvider: Mobile.IDeviceLogProvider, $errors: IErrors);
+    addParseRule(rule: ILogParseRule): void;
+    private startParsingLogCore;
+    private processDeviceLogResponse;
+}

package/lib/services/log-source-map-service.d.ts

@@ -0,0 +1,28 @@
+import { IProjectDataService } from "../definitions/project";
+import { IFileSystem } from "../common/declarations";
+import { IInjector } from "../common/definitions/yok";
+import { IOptions } from "../declarations";
+export declare class LogSourceMapService implements Mobile.ILogSourceMapService {
+    private $fs;
+    private $projectDataService;
+    private $injector;
+    private $options;
+    private $devicePlatformsConstants;
+    private $logger;
+    private static FILE_PREFIX;
+    private static FILE_PREFIX_REPLACEMENT;
+    private static MEMOIZE_FUNCTION_RANDOM_KEY_FOR_JOIN;
+    private getProjectData;
+    private getRuntimeVersion;
+    private cache;
+    private originalFilesLocationCache;
+    private get $platformsDataService();
+    constructor($fs: IFileSystem, $projectDataService: IProjectDataService, $injector: IInjector, $options: IOptions, $devicePlatformsConstants: Mobile.IDevicePlatformsConstants, $logger: ILogger);
+    setSourceMapConsumerForFile(filePath: string): Promise<void>;
+    replaceWithOriginalFileLocations(platform: string, messageData: string, loggingOptions: Mobile.IDeviceLogOptions): string;
+    private getRuntimeVersionCore;
+    private getOriginalFileLocation;
+    private parseAndroidLog;
+    private parseIosLog;
+    private getFilesLocation;
+}

package/lib/services/marking-mode-service.d.ts

@@ -0,0 +1,12 @@
+import { IProjectConfigService, IProjectDataService } from "../definitions/project";
+import { IProjectHelper } from "../common/declarations";
+export declare class MarkingModeService implements IMarkingModeService {
+    private $logger;
+    private $projectConfigService;
+    private $projectHelper;
+    private $projectDataService;
+    constructor($logger: ILogger, $projectConfigService: IProjectConfigService, $projectHelper: IProjectHelper, $projectDataService: IProjectDataService);
+    handleMarkingModeFullDeprecation(options: IMarkingModeFullDeprecationOptions): Promise<void>;
+    private setMarkingMode;
+    private showMarkingModeFullWarning;
+}

package/lib/services/metadata-filtering-service.d.ts

@@ -0,0 +1,19 @@
+import { IPluginsService } from "../definitions/plugins";
+import { IPlatformsDataService } from "../definitions/platform";
+import { IProjectData } from "../definitions/project";
+import { IMetadataFilteringService } from "../definitions/metadata-filtering-service";
+import { IFileSystem } from "../common/declarations";
+export declare class MetadataFilteringService implements IMetadataFilteringService {
+    private $fs;
+    private $pluginsService;
+    private $mobileHelper;
+    private $platformsDataService;
+    private $logger;
+    constructor($fs: IFileSystem, $pluginsService: IPluginsService, $mobileHelper: Mobile.IMobileHelper, $platformsDataService: IPlatformsDataService, $logger: ILogger);
+    generateMetadataFilters(projectData: IProjectData, platform: string): void;
+    private generateWhitelist;
+    private generateBlacklist;
+    private getNativeApiConfigurationForPlatform;
+    private getPlatformsDirPath;
+    private getPathToApplicationConfigurationForPlatform;
+}

package/lib/services/npm-config-service.d.ts

@@ -0,0 +1,7 @@
+import { INpmConfigService } from "../declarations";
+import { IDictionary } from "../common/declarations";
+export declare class NpmConfigService implements INpmConfigService {
+    private config;
+    getConfig(): IDictionary<any>;
+    private readConfig;
+}

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

@@ -0,0 +1,16 @@
+import { INpmConfigService, INodePackageManager } from "../declarations";
+import { IProxyService, IFileSystem } from "../common/declarations";
+import { IInjector } from "../common/definitions/yok";
+export declare class PacoteService implements IPacoteService {
+    private $fs;
+    private $injector;
+    private $logger;
+    private $npmConfigService;
+    private $proxyService;
+    constructor($fs: IFileSystem, $injector: IInjector, $logger: ILogger, $npmConfigService: INpmConfigService, $proxyService: IProxyService);
+    get $packageManager(): INodePackageManager;
+    manifest(packageName: string, options?: IPacoteManifestOptions): Promise<any>;
+    extractPackage(packageName: string, destinationDirectory: string, options?: IPacoteExtractOptions): Promise<void>;
+    private getPacoteBaseOptions;
+    private getRealPackageName;
+}

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

@@ -0,0 +1,19 @@
+import { IPerformanceService, IOptions } from "../declarations";
+import { IFileSystem, IAnalyticsService } from "../common/declarations";
+export declare class PerformanceService implements IPerformanceService {
+    private $options;
+    private $fs;
+    private $logger;
+    private $analyticsService;
+    static LOG_MESSAGE_TEMPLATE: string;
+    static FAIL_LOG_MESSAGE_TEMPLATE: string;
+    private static MIN_NODE_PERFORMANCE_MODULE_VERSION;
+    private performance;
+    constructor($options: IOptions, $fs: IFileSystem, $logger: ILogger, $analyticsService: IAnalyticsService);
+    processExecutionData(methodInfo: string, startTime: number, endTime: number, args: any[]): void;
+    now(): number;
+    private isPerformanceModuleSupported;
+    private trackAnalyticsData;
+    private logDataToFile;
+    private getJsonSanitizer;
+}

package/lib/services/platform/add-platform-service.d.ts

@@ -0,0 +1,21 @@
+import { IAddPlatformData, IAddPlatformService, IPlatformData } from "../../definitions/platform";
+import { IProjectData } from "../../definitions/project";
+import { IAnalyticsService, IFileSystem } from "../../common/declarations";
+import { IOptions, IPackageManager } from "../../declarations";
+import { ITerminalSpinnerService } from "../../definitions/terminal-spinner-service";
+export declare class AddPlatformService implements IAddPlatformService {
+    private $fs;
+    private $logger;
+    private $options;
+    private $packageManager;
+    private $terminalSpinnerService;
+    private $analyticsService;
+    constructor($fs: IFileSystem, $logger: ILogger, $options: IOptions, $packageManager: IPackageManager, $terminalSpinnerService: ITerminalSpinnerService, $analyticsService: IAnalyticsService);
+    addProjectHost(): Promise<void>;
+    addPlatformSafe(projectData: IProjectData, platformData: IPlatformData, packageToInstall: string, addPlatformData: IAddPlatformData): Promise<string>;
+    setPlatformVersion(platformData: IPlatformData, projectData: IProjectData, frameworkVersion: string): Promise<void>;
+    private installPackage;
+    private resolveFrameworkDir;
+    private addNativePlatform;
+    private trackPlatformVersion;
+}

package/lib/services/platform/platform-validation-service.d.ts

@@ -0,0 +1,17 @@
+import { IPlatformValidationService } from "../../declarations";
+import { IPlatformsDataService } from "../../definitions/platform";
+import { IProjectData } from "../../definitions/project";
+import { IErrors, IFileSystem } from "../../common/declarations";
+export declare class PlatformValidationService implements IPlatformValidationService {
+    private $errors;
+    private $fs;
+    private $logger;
+    private $mobileHelper;
+    private $platformsDataService;
+    constructor($errors: IErrors, $fs: IFileSystem, $logger: ILogger, $mobileHelper: Mobile.IMobileHelper, $platformsDataService: IPlatformsDataService);
+    isValidPlatform(platform: string, projectData: IProjectData): boolean;
+    validatePlatform(platform: string, projectData: IProjectData): void;
+    validatePlatformInstalled(platform: string, projectData: IProjectData): void;
+    validateOptions(provision: true | string, teamId: true | string, projectData: IProjectData, platform?: string, aab?: boolean): Promise<boolean>;
+    isPlatformSupportedForOS(platform: string, projectData: IProjectData): boolean;
+}

package/lib/services/platform/prepare-native-platform-service.d.ts

@@ -0,0 +1,15 @@
+import { INodeModulesBuilder, IPlatformData } from "../../definitions/platform";
+import { IProjectData } from "../../definitions/project";
+import { IMetadataFilteringService } from "../../definitions/metadata-filtering-service";
+import { IHooksService } from "../../common/declarations";
+import { IOptions } from "../../declarations";
+export declare class PrepareNativePlatformService implements IPrepareNativePlatformService {
+    $hooksService: IHooksService;
+    private $nodeModulesBuilder;
+    private $projectChangesService;
+    private $metadataFilteringService;
+    private $options;
+    constructor($hooksService: IHooksService, $nodeModulesBuilder: INodeModulesBuilder, $projectChangesService: IProjectChangesService, $metadataFilteringService: IMetadataFilteringService, $options: IOptions);
+    prepareNativePlatform(platformData: IPlatformData, projectData: IProjectData, prepareData: IPrepareData): Promise<boolean>;
+    private cleanProject;
+}

package/lib/services/platform-environment-requirements.d.ts

@@ -0,0 +1,15 @@
+import { IPlatformEnvironmentRequirements, ICheckEnvironmentRequirementsInput, ICheckEnvironmentRequirementsOutput } from "../definitions/platform";
+import { IErrors, IAnalyticsService, IDoctorService } from "../common/declarations";
+import { IInjector } from "../common/definitions/yok";
+export declare class PlatformEnvironmentRequirements implements IPlatformEnvironmentRequirements {
+    private $doctorService;
+    private $errors;
+    private $analyticsService;
+    private $injector;
+    constructor($doctorService: IDoctorService, $errors: IErrors, $analyticsService: IAnalyticsService, $injector: IInjector);
+    private static MISSING_LOCAL_SETUP_MESSAGE;
+    checkEnvironmentRequirements(input: ICheckEnvironmentRequirementsInput): Promise<ICheckEnvironmentRequirementsOutput>;
+    private fail;
+    private getNonInteractiveConsoleMessage;
+    private getEnvVerificationMessage;
+}

package/lib/services/platform-project-service-base.d.ts

@@ -0,0 +1,14 @@
+import { EventEmitter } from "events";
+import { IProjectDataService, IPlatformProjectServiceBase, IProjectData } from "../definitions/project";
+import { IPlatformData } from "../definitions/platform";
+import { IPluginData } from "../definitions/plugins";
+import { IFileSystem } from "../common/declarations";
+export declare abstract class PlatformProjectServiceBase extends EventEmitter implements IPlatformProjectServiceBase {
+    protected $fs: IFileSystem;
+    protected $projectDataService: IProjectDataService;
+    constructor($fs: IFileSystem, $projectDataService: IProjectDataService);
+    protected abstract getPlatformData(projectData: IProjectData): IPlatformData;
+    getPluginPlatformsFolderPath(pluginData: IPluginData, platform: string): string;
+    getFrameworkVersion(projectData: IProjectData): string;
+    protected getAllNativeLibrariesForPlugin(pluginData: IPluginData, platform: string, filter: (fileName: string, _pluginPlatformsFolderPath: string) => boolean): string[];
+}

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

@@ -0,0 +1,9 @@
+import { IProjectData } from "../definitions/project";
+import { IPlatformData, IPlatformsDataService } from "../definitions/platform";
+import { IOptions } from "../declarations";
+export declare class PlatformsDataService implements IPlatformsDataService {
+    private $options;
+    private platformsDataService;
+    constructor($options: IOptions, $androidProjectService: IPlatformProjectService, $iOSProjectService: IPlatformProjectService);
+    getPlatformData(platform: string, projectData: IProjectData): IPlatformData;
+}

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

@@ -0,0 +1,60 @@
+import { IPluginsService, IPreparePluginNativeCodeData, IPluginData, IPackageJsonDepedenciesResult } from "../definitions/plugins";
+import { INodeModulesDependenciesBuilder } from "../definitions/platform";
+import { IProjectData } from "../definitions/project";
+import { INodePackageManager, IOptions, IDependencyData } from "../declarations";
+import { IFileSystem, IErrors } from "../common/declarations";
+import { IFilesHashService } from "../definitions/files-hash-service";
+import { IInjector } from "../common/definitions/yok";
+export declare class PluginsService implements IPluginsService {
+    private $packageManager;
+    private $fs;
+    private $options;
+    private $logger;
+    private $errors;
+    private $filesHashService;
+    private $injector;
+    private $mobileHelper;
+    private $nodeModulesDependenciesBuilder;
+    private static INSTALL_COMMAND_NAME;
+    private static UNINSTALL_COMMAND_NAME;
+    private static NPM_CONFIG;
+    private static LOCK_FILES;
+    private get $platformsDataService();
+    private get $projectDataService();
+    private get npmInstallOptions();
+    constructor($packageManager: INodePackageManager, $fs: IFileSystem, $options: IOptions, $logger: ILogger, $errors: IErrors, $filesHashService: IFilesHashService, $injector: IInjector, $mobileHelper: Mobile.IMobileHelper, $nodeModulesDependenciesBuilder: INodeModulesDependenciesBuilder);
+    add(plugin: string, projectData: IProjectData): Promise<void>;
+    remove(pluginName: string, projectData: IProjectData): Promise<void>;
+    addToPackageJson(plugin: string, version: string, isDev: boolean, projectDir: string): void;
+    removeFromPackageJson(plugin: string, projectDir: string): void;
+    preparePluginNativeCode({ pluginData, platform, projectData, }: IPreparePluginNativeCodeData): Promise<void>;
+    ensureAllDependenciesAreInstalled(projectData: IProjectData): Promise<void>;
+    getAllInstalledPlugins(projectData: IProjectData): Promise<IPluginData[]>;
+    getAllProductionPlugins(projectData: IProjectData, platform: string, dependencies?: IDependencyData[]): IPluginData[];
+    getDependenciesFromPackageJson(projectDir: string): IPackageJsonDepedenciesResult;
+    isNativeScriptPlugin(pluginPackageJsonPath: string): boolean;
+    private ensureValidProductionPlugins;
+    private _ensureValidProductionPlugins;
+    private ensureValidProductionPluginsForAndroid;
+    private ensureValidProductionPluginsForIOS;
+    private getFailureMessageForDifferentDependencyVersions;
+    private getHelpMessage;
+    private convertToPluginData;
+    private removeDependencyFromPackageJsonContent;
+    private getBasicPluginInformation;
+    private getNodeModulesPath;
+    private getPackageJsonFilePath;
+    private getPackageJsonFilePathForModule;
+    private getDependencies;
+    private getNodeModuleData;
+    private ensure;
+    private getAllInstalledModules;
+    private executeNpmCommand;
+    private parseNpmCommandResult;
+    private executeForAllInstalledPlatforms;
+    private getInstalledFrameworkVersion;
+    private isPluginDataValidForPlatform;
+    private getPluginNativeHashes;
+    private getAllPluginsNativeHashes;
+    private setPluginNativeHashes;
+}

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

@@ -0,0 +1,7 @@
+import { IOSPrepareData, AndroidPrepareData } from "../data/prepare-data";
+import { IOptions } from "../declarations";
+export declare class PrepareDataService implements IPrepareDataService {
+    private $mobileHelper;
+    constructor($mobileHelper: Mobile.IMobileHelper);
+    getPrepareData(projectDir: string, platform: string, data: IOptions): IOSPrepareData | AndroidPrepareData;
+}

package/lib/services/project-backup-service.d.ts

@@ -0,0 +1,12 @@
+import { IBackup, IProjectBackupService } from "../definitions/project";
+import { IFileSystem, IProjectHelper } from "../common/declarations";
+export declare class ProjectBackupService implements IProjectBackupService {
+    protected $fs: IFileSystem;
+    protected $logger: ILogger;
+    protected $projectHelper: IProjectHelper;
+    constructor($fs: IFileSystem, $logger: ILogger, $projectHelper: IProjectHelper);
+    getBackup(backupName: string): IBackup;
+    backup(name: string, pathsToBackup: string[]): IBackup;
+    restore(name: string): IBackup;
+    static Backup: new ($super: ProjectBackupService, name: string, pathsToBackup?: string[], basePath?: string) => IBackup;
+}

package/lib/services/project-changes-service.d.ts

@@ -0,0 +1,30 @@
+import { INodeModulesDependenciesBuilder, IPlatformData } from "../definitions/platform";
+import { IProjectData } from "../definitions/project";
+import { IFileSystem, IHooksService } from "../common/declarations";
+import { IProjectChangesInfo, IPrepareInfo, IAddedNativePlatform } from "../definitions/project-changes";
+import { IOptions } from "../declarations";
+export declare class ProjectChangesService implements IProjectChangesService {
+    private $devicePlatformsConstants;
+    private $fs;
+    private $logger;
+    private $options;
+    $hooksService: IHooksService;
+    private $nodeModulesDependenciesBuilder;
+    private _changesInfo;
+    private _prepareInfo;
+    private _outputProjectMtime;
+    private _outputProjectCTime;
+    constructor($devicePlatformsConstants: Mobile.IDevicePlatformsConstants, $fs: IFileSystem, $logger: ILogger, $options: IOptions, $hooksService: IHooksService, $nodeModulesDependenciesBuilder: INodeModulesDependenciesBuilder);
+    get currentChanges(): IProjectChangesInfo;
+    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): Promise<void>;
+    private ensurePrepareInfo;
+    private getProjectFileStrippedHash;
+    private isProjectFileChanged;
+    private filesChanged;
+    private containsNewerFiles;
+    private isFileModified;
+}

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

@@ -0,0 +1,13 @@
+import { IProjectCleanupOptions, IProjectCleanupResult, IProjectCleanupService, IProjectPathCleanupResult } from "../definitions/project";
+import { IFileSystem, IProjectHelper } from "../common/declarations";
+import { ITerminalSpinnerService } from "../definitions/terminal-spinner-service";
+export declare class ProjectCleanupService implements IProjectCleanupService {
+    private $fs;
+    private $logger;
+    private $projectHelper;
+    private $terminalSpinnerService;
+    private spinner;
+    constructor($fs: IFileSystem, $logger: ILogger, $projectHelper: IProjectHelper, $terminalSpinnerService: ITerminalSpinnerService);
+    clean(pathsToClean: string[], options?: IProjectCleanupOptions): Promise<IProjectCleanupResult>;
+    cleanPath(pathToClean: string, options?: IProjectCleanupOptions): Promise<IProjectPathCleanupResult>;
+}

package/lib/services/project-config-service.d.ts

@@ -0,0 +1,33 @@
+import { IFileSystem, IProjectHelper } from "../common/declarations";
+import { INsConfig, IProjectConfigInformation, IProjectConfigService } from "../definitions/project";
+import { IInjector } from "../common/definitions/yok";
+import { SupportedConfigValues } from "../tools/config-manipulation/config-transformer";
+import { IBasePluginData } from "../definitions/plugins";
+import { IOptions } from "../declarations";
+import { ICleanupService } from "../definitions/cleanup-service";
+export declare class ProjectConfigService implements IProjectConfigService {
+    private $fs;
+    private $logger;
+    private $injector;
+    private $options;
+    private $cleanupService;
+    private forceUsingNewConfig;
+    private forceUsingLegacyConfig;
+    constructor($fs: IFileSystem, $logger: ILogger, $injector: IInjector, $options: IOptions, $cleanupService: ICleanupService);
+    setForceUsingNewConfig(force: boolean): boolean;
+    setForceUsingLegacyConfig(force: boolean): boolean;
+    private requireFromString;
+    get projectHelper(): IProjectHelper;
+    getDefaultTSConfig(appId?: string, appPath?: string): string;
+    private warnUsingLegacyNSConfig;
+    detectProjectConfigs(projectDir?: string): IProjectConfigInformation;
+    readConfig(projectDir?: string): INsConfig;
+    getValue(key: string, defaultValue?: any): any;
+    setValue(key: string, value: SupportedConfigValues): Promise<boolean>;
+    private loadPrettier;
+    private formatConfig;
+    writeDefaultConfig(projectDir: string, appId?: string): string | false;
+    private fallbackToLegacyNSConfig;
+    writeLegacyNSConfigIfNeeded(projectDir: string, runtimePackage: IBasePluginData): Promise<void>;
+    private flattenObjectToPaths;
+}

package/lib/services/project-config-service.js

@@ -15,7 +15,6 @@ const ts = require("typescript");
 const config_transformer_1 = require("../tools/config-manipulation/config-transformer");
 const yok_1 = require("../common/yok");
 const os_1 = require("os");
-const prettier_1 = require("prettier");
 const decorators_1 = require("../common/decorators");
 const semver = require("semver/preload");
 class ProjectConfigService {
@@ -180,16 +179,7 @@ export default {
         try {
             const transformer = new config_transformer_1.ConfigTransformer(configContent);
             const newContent = transformer.setValue(key, value);
-            const prettierOptions = (await (0, prettier_1.resolveConfig)(this.projectHelper.projectDir, { editorconfig: true })) || {
-                semi: false,
-                singleQuote: true,
-            };
-            this.$logger.trace("updating config, prettier options: ", prettierOptions);
-            this.$fs.writeFile(configFilePath, await (0, prettier_1.format)(newContent, {
-                ...prettierOptions,
-                parser: "typescript",
-                plugins: [],
-            }));
+            this.$fs.writeFile(configFilePath, await this.formatConfig(newContent));
         }
         catch (error) {
             this.$logger.error(`Failed to update config.` + error);
@@ -204,6 +194,38 @@ export default {
             return true;
         }
     }
+    loadPrettier() {
+        const projectDir = this.projectHelper.projectDir;
+        if (projectDir) {
+            try {
+                return require(require.resolve("prettier", { paths: [projectDir] }));
+            }
+            catch (error) {
+                this.$logger.trace("Could not load prettier from the project, using the bundled one.", error);
+            }
+        }
+        return require("prettier");
+    }
+    async formatConfig(content) {
+        try {
+            const prettier = this.loadPrettier();
+            const prettierOptions = (await prettier.resolveConfig(this.projectHelper.projectDir, { editorconfig: true })) || {
+                semi: false,
+                singleQuote: true,
+            };
+            this.$logger.trace("updating config, prettier options: ", prettierOptions);
+            return await prettier.format(content, {
+                ...prettierOptions,
+                parser: "typescript",
+                plugins: [],
+            });
+        }
+        catch (error) {
+            this.$logger.warn("Could not format the config with prettier - it will be written unformatted.");
+            this.$logger.trace("prettier failed with: ", error);
+            return content;
+        }
+    }
     writeDefaultConfig(projectDir, appId) {
         const TSConfigPath = path.resolve(projectDir, constants_1.CONFIG_FILE_NAME_TS);
         if (this.$fs.exists(TSConfigPath)) {

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

@@ -0,0 +1,48 @@
+import * as constants from "../constants";
+import { IAssetGroup, IAssetsStructure, IProjectData, IProjectDataService } from "../definitions/project";
+import { IAndroidResourcesMigrationService, IStaticConfig } from "../declarations";
+import { IBasePluginData, IPluginsService } from "../definitions/plugins";
+import { IFileSystem, IProjectDir } from "../common/declarations";
+import { IInjector } from "../common/definitions/yok";
+export declare class ProjectDataService implements IProjectDataService {
+    private $fs;
+    private $staticConfig;
+    private $logger;
+    private $projectData;
+    private $devicePlatformsConstants;
+    private $androidResourcesMigrationService;
+    private $injector;
+    private defaultProjectDir;
+    private static DEPENDENCIES_KEY_NAME;
+    private projectDataCache;
+    constructor($fs: IFileSystem, $staticConfig: IStaticConfig, $logger: ILogger, $projectData: IProjectData, $devicePlatformsConstants: Mobile.IDevicePlatformsConstants, $androidResourcesMigrationService: IAndroidResourcesMigrationService, $injector: IInjector);
+    get $pluginsService(): IPluginsService;
+    getNSValue(projectDir: string, propertyName: string): any;
+    getNSValueFromContent(jsonData: Object, propertyName: string): any;
+    setNSValue(projectDir: string, key: string, value: any): void;
+    removeNSProperty(projectDir: string, propertyName: string): void;
+    removeDependency(projectDir: string, dependencyName: string): void;
+    getProjectData(projectDir: string): IProjectData;
+    getProjectDataFromContent(packageJsonContent: string, projectDir?: string): IProjectData;
+    getAssetsStructure(opts: IProjectDir): Promise<IAssetsStructure>;
+    getIOSAssetsStructure(opts: IProjectDir): Promise<IAssetGroup>;
+    removeNSConfigProperty(projectDir: string, propertyName: string): void;
+    getAndroidAssetsStructure(opts: IProjectDir): Promise<IAssetGroup>;
+    getAppExecutableFiles(projectDir: string): string[];
+    private refreshProjectData;
+    private updateNsConfigValue;
+    private getNsConfig;
+    private getImageDefinitions;
+    private getIOSAssetSubGroup;
+    private getAndroidAssetSubGroup;
+    private getValue;
+    private getNativeScriptPropertyName;
+    private getPropertyValueFromJson;
+    private setValue;
+    private removeProperty;
+    private getProjectFileData;
+    private getNsConfigDefaultObject;
+    getRuntimePackage(projectDir: string, platform: constants.SupportedPlatform): IBasePluginData;
+    private getInstalledRuntimePackage;
+    getNsConfigDefaultContent(data?: Object): string;
+}

package/lib/services/project-name-service.d.ts

@@ -0,0 +1,16 @@
+import { IProjectNameService } from "../declarations";
+import { IErrors } from "../common/declarations";
+import { ProjectNameService as ProjectNameServiceContract } from "../contracts/project-name-service";
+export declare class ProjectNameServiceImpl implements IProjectNameService, ProjectNameServiceContract {
+    private $projectNameValidator;
+    private $errors;
+    private $logger;
+    private $prompter;
+    constructor($projectNameValidator: IProjectNameValidator, $errors: IErrors, $logger: ILogger, $prompter: IPrompter);
+    ensureValidName(projectName: string, validateOptions?: {
+        force: boolean;
+    }): Promise<string>;
+    private checkIfNameStartsWithLetter;
+    private promptForNewName;
+    private promptForForceNameConfirm;
+}

package/lib/services/project-name-service.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProjectNameService = void 0;
+exports.ProjectNameServiceImpl = void 0;
 const helpers_1 = require("../common/helpers");
 const yok_1 = require("../common/yok");
-class ProjectNameService {
+class ProjectNameServiceImpl {
     constructor($projectNameValidator, $errors, $logger, $prompter) {
         this.$projectNameValidator = $projectNameValidator;
         this.$errors = $errors;
@@ -48,5 +48,5 @@ class ProjectNameService {
         return await this.$prompter.confirm("Do you want to create the project with this name?");
     }
 }
-exports.ProjectNameService = ProjectNameService;
-yok_1.injector.register("projectNameService", ProjectNameService);
+exports.ProjectNameServiceImpl = ProjectNameServiceImpl;
+yok_1.injector.register("projectNameService", ProjectNameServiceImpl);