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

package/lib/common/services/json-file-settings-service.d.ts

@@ -0,0 +1,24 @@
+import { IFileSystem } from "../declarations";
+import { IJsonFileSettingsService } from "../definitions/json-file-settings-service";
+export declare class JsonFileSettingsService implements IJsonFileSettingsService {
+    private $fs;
+    private $lockService;
+    private $logger;
+    private jsonSettingsFilePath;
+    protected jsonSettingsData: any;
+    private get lockFilePath();
+    constructor(jsonFileSettingsPath: string, $fs: IFileSystem, $lockService: ILockService, $logger: ILogger);
+    getSettingValue<T>(settingName: string, cacheOpts?: {
+        cacheTimeout: number;
+    }): Promise<T>;
+    saveSetting<T>(key: string, value: T, cacheOpts?: {
+        useCaching: boolean;
+    }): Promise<void>;
+    removeSetting(key: string): Promise<void>;
+    saveSettings(data?: any, cacheOpts?: {
+        useCaching: boolean;
+    }): Promise<void>;
+    loadUserSettingsFile(): Promise<void>;
+    private loadUserSettingsData;
+    private getUnexistingDirectories;
+}

package/lib/common/services/lock-service.d.ts

@@ -0,0 +1,18 @@
+import { IFileSystem, ISettingsService } from "../declarations";
+import { ICleanupService } from "../../definitions/cleanup-service";
+export declare class LockService implements ILockService {
+    private $fs;
+    private $settingsService;
+    private $cleanupService;
+    private get defaultLockFilePath();
+    private getAbsoluteLockFilePath;
+    private get defaultLockParams();
+    constructor($fs: IFileSystem, $settingsService: ISettingsService, $cleanupService: ICleanupService);
+    executeActionWithLock<T>(action: () => Promise<T>, lockFilePath?: string, lockOpts?: ILockOptions): Promise<T>;
+    lock(lockFilePath?: string, lockOpts?: ILockOptions): Promise<() => void>;
+    unlock(lockFilePath?: string): Promise<void>;
+    private cleanLock;
+    private getPathsForCleanupAction;
+    private getLockFileSettings;
+    private getShortFileLock;
+}

package/lib/common/services/message-contract-generator.d.ts

@@ -0,0 +1,8 @@
+import { IServiceContractGenerator, IFileSystem, IMessagesService, IServiceContractClientCode } from "../declarations";
+export declare class MessageContractGenerator implements IServiceContractGenerator {
+    private $fs;
+    private $messagesService;
+    constructor($fs: IFileSystem, $messagesService: IMessagesService);
+    generate(): Promise<IServiceContractClientCode>;
+    private generateFileRecursive;
+}

package/lib/common/services/messages-service.d.ts

@@ -0,0 +1,15 @@
+import { IMessagesService, IFileSystem } from "../declarations";
+export declare class MessagesService implements IMessagesService {
+    private $fs;
+    private _pathsToMessageJsonFiles;
+    private _messageJsonFilesContentsCache;
+    private get pathToDefaultMessageJson();
+    private get messageJsonFilesContents();
+    constructor($fs: IFileSystem);
+    get pathsToMessageJsonFiles(): string[];
+    set pathsToMessageJsonFiles(pathsToMessageJsonFiles: string[]);
+    getMessage(id: string, ...args: string[]): string;
+    private getMessageFromJsonRecursive;
+    private refreshMessageJsonContentsCache;
+    private getFormatedMessage;
+}

package/lib/common/services/micro-templating-service.d.ts

@@ -0,0 +1,12 @@
+import { IInjector } from "../definitions/yok";
+import { IMicroTemplateService } from "../declarations";
+export declare class MicroTemplateService implements IMicroTemplateService {
+    private $injector;
+    private dynamicCallRegex;
+    constructor($injector: IInjector);
+    parseContent(data: string, options: {
+        isHtml: boolean;
+    }): Promise<string>;
+    private isPlatform;
+    private getLocalVariables;
+}

package/lib/common/services/net-service.d.ts

@@ -0,0 +1,13 @@
+import { IErrors, INet, IChildProcess, IOsInfo, IWaitForPortListenData } from "../declarations";
+export declare class Net implements INet {
+    private $errors;
+    private $childProcess;
+    private $logger;
+    private $osInfo;
+    private static DEFAULT_INTERVAL;
+    constructor($errors: IErrors, $childProcess: IChildProcess, $logger: ILogger, $osInfo: IOsInfo);
+    getFreePort(): Promise<number>;
+    isPortAvailable(port: number): Promise<boolean>;
+    getAvailablePortInRange(startPort: number, endPort?: number): Promise<number>;
+    waitForPortToListen(waitForPortListenData: IWaitForPortListenData): Promise<boolean>;
+}

package/lib/common/services/project-files-manager.d.ts

@@ -0,0 +1,14 @@
+import { IFileSystem, IProjectFilesManager, IProjectFilesProvider, IFsStats, IProjectFilesConfig } from "../declarations";
+export declare class ProjectFilesManager implements IProjectFilesManager {
+    private $fs;
+    private $localToDevicePathDataFactory;
+    private $logger;
+    private $projectFilesProvider;
+    constructor($fs: IFileSystem, $localToDevicePathDataFactory: Mobile.ILocalToDevicePathDataFactory, $logger: ILogger, $projectFilesProvider: IProjectFilesProvider);
+    getProjectFiles(projectFilesPath: string, excludedProjectDirsAndFiles?: string[], filter?: (filePath: string, stat: IFsStats) => boolean, opts?: any): string[];
+    isFileExcluded(filePath: string, excludedProjectDirsAndFiles?: string[]): boolean;
+    createLocalToDevicePaths(deviceAppData: Mobile.IDeviceAppData, projectFilesPath: string, files: string[], excludedProjectDirsAndFiles: string[], projectFilesConfig?: IProjectFilesConfig): Promise<Mobile.ILocalToDevicePathData[]>;
+    processPlatformSpecificFiles(directoryPath: string, platform: string, projectFilesConfig: IProjectFilesConfig, excludedDirs?: string[]): void;
+    private processPlatformSpecificFilesCore;
+    private getFileName;
+}

package/lib/common/services/project-files-provider-base.d.ts

@@ -0,0 +1,12 @@
+import { IOptions } from "../../declarations";
+import { IProjectFilesConfig, IProjectFilesProvider, IProjectFileInfo } from "../declarations";
+export declare abstract class ProjectFilesProviderBase implements IProjectFilesProvider {
+    private $mobileHelper;
+    protected $options: IOptions;
+    abstract isFileExcluded(filePath: string): boolean;
+    abstract mapFilePath(filePath: string, platform: string, projectData: any, projectFilesConfig: IProjectFilesConfig): string;
+    constructor($mobileHelper: Mobile.IMobileHelper, $options: IOptions);
+    getPreparedFilePath(filePath: string, projectFilesConfig?: IProjectFilesConfig): string;
+    getProjectFileInfo(filePath: string, platform: string, projectFilesConfig?: IProjectFilesConfig): IProjectFileInfo;
+    private parseFile;
+}

package/lib/common/services/proxy-service.d.ts

@@ -0,0 +1,12 @@
+import { IProxyService, ISettingsService, IProxyLibSettings, IProxySettings } from "../declarations";
+export declare class ProxyService implements IProxyService {
+    private $settingsService;
+    private $staticConfig;
+    private proxyCacheFilePath;
+    private credentialsKey;
+    constructor($settingsService: ISettingsService, $staticConfig: Config.IStaticConfig);
+    setCache(settings: IProxyLibSettings): Promise<void>;
+    getCache(): Promise<IProxySettings>;
+    clearCache(): Promise<void>;
+    getInfo(): Promise<string>;
+}

package/lib/common/services/qr.d.ts

@@ -0,0 +1,7 @@
+import { IQrCodeGenerator } from "../declarations";
+export declare class QrCodeGenerator implements IQrCodeGenerator {
+    private $staticConfig;
+    private $logger;
+    constructor($staticConfig: Config.IStaticConfig, $logger: ILogger);
+    generateDataUri(data: string): Promise<string>;
+}

package/lib/common/services/settings-service.d.ts

@@ -0,0 +1,10 @@
+import { IHostInfo, ISettingsService, IConfigurationSettings } from "../declarations";
+export declare class SettingsService implements ISettingsService {
+    private $staticConfig;
+    private $hostInfo;
+    private _profileDir;
+    constructor($staticConfig: Config.IStaticConfig, $hostInfo: IHostInfo);
+    setSettings(settings: IConfigurationSettings): void;
+    getProfileDir(): string;
+    private getDefaultProfileDir;
+}

package/lib/common/services/xcode-select-service.d.ts

@@ -0,0 +1,12 @@
+import { IHostInfo, IErrors, IXcodeSelectService, IChildProcess, IVersionData } from "../declarations";
+import { IInjector } from "../definitions/yok";
+export declare class XcodeSelectService implements IXcodeSelectService {
+    private $childProcess;
+    private $errors;
+    private $hostInfo;
+    private $injector;
+    constructor($childProcess: IChildProcess, $errors: IErrors, $hostInfo: IHostInfo, $injector: IInjector);
+    getDeveloperDirectoryPath(): Promise<string>;
+    getContentsDirectoryPath(): Promise<string>;
+    getXcodeVersion(): Promise<IVersionData>;
+}

package/lib/common/utils.d.ts

@@ -0,0 +1,10 @@
+import { IOptions } from "../declarations";
+import { IUtils } from "./declarations";
+export declare class Utils implements IUtils {
+    private $options;
+    private $logger;
+    constructor($options: IOptions, $logger: ILogger);
+    getParsedTimeout(defaultTimeout: number): number;
+    getMilliSecondsTimeout(defaultTimeout: number): number;
+}
+export declare function capitalizeFirstLetter(value: string): string;

package/lib/common/validators/project-name-validator.d.ts

@@ -0,0 +1,18 @@
+import { IErrors } from "../declarations";
+export declare class ProjectNameValidator implements IProjectNameValidator {
+    private $errors;
+    private static MAX_FILENAME_LENGTH;
+    private static EMPTY_FILENAME_ERROR_MESSAGE;
+    private static NOT_VALID_NAME_ERROR_MESSAGE;
+    private static RESERVED_NAME_ERROR_MESSAGE;
+    private static INVALID_EXTENSION_ERROR_MESSAGE;
+    private static TOO_LONG_NAME_ERROR_MESSAGE;
+    private static TRAILING_DOTS_ERROR_MESSAGE;
+    private static LEADING_SPACES_ERROR_MESSAGE;
+    private static TRAILING_SPACES_ERROR_MESSAGE;
+    private static INVALID_FILENAMES;
+    private static INVALID_EXTENSIONS;
+    constructor($errors: IErrors);
+    private validateName;
+    validate(name: string): boolean;
+}

package/lib/common/validators/validation-result.d.ts

@@ -0,0 +1,7 @@
+export declare class ValidationResult implements IValidationResult {
+    private errorMsg;
+    static Successful: ValidationResult;
+    constructor(errorMsg: string);
+    get error(): string;
+    get isSuccessful(): boolean;
+}

package/lib/common/verify-node-version.d.ts

@@ -0,0 +1,3 @@
+import { ISystemWarning } from "./declarations";
+export declare function verifyNodeVersion(): void;
+export declare function getNodeWarning(): ISystemWarning;

package/lib/common/yok.d.ts

@@ -0,0 +1,60 @@
+import { IDictionary } from "./declarations";
+import { IInjector } from "./definitions/yok";
+import { ICommand } from "./definitions/commands";
+import { IKeyCommand, IValidKeyName } from "./definitions/key-commands";
+import { Injector } from "./di/injector";
+import type { Provider } from "./di/providers";
+import type { DeferredCommandOptions, DeferredCommandResult } from "./contracts";
+export declare let injector: IInjector;
+export declare function register(...rest: any[]): (target: any) => void;
+export interface IDependency {
+    require?: string;
+    resolver?: () => any;
+    instances?: any[];
+    shared?: boolean;
+}
+export declare class Yok extends Injector implements IInjector {
+    overrideAlreadyRequiredModule: boolean;
+    constructor();
+    private COMMANDS_NAMESPACE;
+    private synthesizedParents;
+    private placeholderParents;
+    private KEY_COMMANDS_NAMESPACE;
+    private hierarchicalCommands;
+    private deferredCommandOwners;
+    requireCommand(names: any, file: string): void;
+    registerDeferredCommand(name: string, options: DeferredCommandOptions): DeferredCommandResult;
+    require(names: any, file: string): void;
+    requireKeyCommand(name: any, file: string): void;
+    publicApi: any;
+    requirePublic(names: any, file: string): void;
+    requirePublicClass(names: any, file: string): void;
+    private addClassToPublicApi;
+    private resolvePublicApi;
+    private resolveInstance;
+    private requireOne;
+    registerCommand(names: any, resolver: any): void;
+    registerKeyCommand(name: IValidKeyName, resolver: IKeyCommand): void;
+    private getDefaultCommand;
+    buildHierarchicalCommand(parentCommandName: string, commandLineArguments: string[]): any;
+    private createHierarchicalCommand;
+    private getHierarchicalCommandName;
+    isValidHierarchicalCommand(commandName: string, commandArguments: string[]): Promise<boolean>;
+    isDefaultCommand(commandName: string): boolean;
+    register(name: string, resolver: any, shared?: boolean): void;
+    register(providers: Provider | Provider[]): void;
+    resolveCommand(name: string): ICommand;
+    resolveKeyCommand(name: string): IKeyCommand;
+    resolve(param: any, ctorArguments?: IDictionary<any>): any;
+    get dynamicCallRegex(): RegExp;
+    getDynamicCallData(call: string, args?: any[]): any;
+    dynamicCall(call: string, args?: any[]): Promise<any>;
+    getRegisteredCommandsNames(includeDev: boolean): string[];
+    getRegisteredKeyCommandsNames(): string[];
+    getChildrenCommandsNames(commandName: string): string[];
+    private createCommandName;
+    private createKeyCommandName;
+    dispose(exclude?: any[]): void;
+}
+export declare function getInjector(): IInjector;
+export declare function setGlobalInjector(inj: IInjector): IInjector;