nativescript 9.1.0-alpha.15 → 9.1.0-alpha.17

package/lib/common/services/hooks-service.js

@@ -11,6 +11,9 @@ const path = require("path");
 const util = require("util");
 const _ = require("lodash");
 const helpers_1 = require("../helpers");
+const deprecation_1 = require("../deprecation");
+const define_hook_1 = require("../define-hook");
+const inject_1 = require("../di/inject");
 const constants_1 = require("../../constants");
 const yok_1 = require("../yok");
 const color_1 = require("../../color");
@@ -52,20 +55,19 @@ class HooksService {
         }
     }
     static formatHookName(commandName) {
-        // Remove everything after | (including the pipe)
         return commandName.replace(/\|[\s\S]*$/, "");
     }
-    executeBeforeHooks(commandName, hookArguments) {
+    executeBeforeHooks(commandName, hookArguments, options) {
         const beforeHookName = `before-${HooksService.formatHookName(commandName)}`;
         const traceMessage = `BeforeHookName for command ${commandName} is ${beforeHookName}`;
-        return this.executeHooks(beforeHookName, traceMessage, hookArguments);
+        return this.executeHooks(beforeHookName, traceMessage, hookArguments, !!(options && options.consumesMiddlewares));
     }
     executeAfterHooks(commandName, hookArguments) {
         const afterHookName = `after-${HooksService.formatHookName(commandName)}`;
         const traceMessage = `AfterHookName for command ${commandName} is ${afterHookName}`;
-        return this.executeHooks(afterHookName, traceMessage, hookArguments);
+        return this.executeHooks(afterHookName, traceMessage, hookArguments, false);
     }
-    async executeHooks(hookName, traceMessage, hookArguments) {
+    async executeHooks(hookName, traceMessage, hookArguments, consumesMiddlewares) {
         if (this.$config.DISABLE_HOOKS || !this.$options.hooks) {
             return;
         }
@@ -81,11 +83,11 @@ class HooksService {
         const results = [];
         try {
             for (const hooksDirectory of this.hooksDirectories) {
-                results.push(await this.executeHooksInDirectory(hooksDirectory, hookName, hookArguments));
+                results.push(await this.executeHooksInDirectory(hooksDirectory, hookName, hookArguments, consumesMiddlewares));
             }
             const customHooks = this.getCustomHooksByName(hookName);
             for (const hook of customHooks) {
-                results.push(await this.executeHook(this.$projectHelper.projectDir, hookName, hook, hookArguments));
+                results.push(await this.executeHook(this.$projectHelper.projectDir, hookName, hook, hookArguments, consumesMiddlewares));
             }
         }
         catch (err) {
@@ -98,7 +100,8 @@ class HooksService {
         const ext = path.extname(hook.fullPath).toLowerCase();
         return ext === ".mjs";
     }
-    async executeHook(directoryPath, hookName, hook, hookArguments) {
+    async executeHook(directoryPath, hookName, hook, hookArguments, consumesMiddlewares) {
+        var _a;
         hookArguments = hookArguments || {};
         let result;
         const relativePath = path.relative(directoryPath, hook.fullPath);
@@ -124,43 +127,62 @@ class HooksService {
                 hookEntryPoint = hookFn;
             }
             else {
-                hookEntryPoint = require(hook.fullPath);
+                const hookModule = require(hook.fullPath);
+                hookEntryPoint =
+                    hookModule && typeof hookModule.default === "function"
+                        ? hookModule.default
+                        : hookModule;
             }
-            this.$logger.trace(`Validating ${hookName} arguments.`);
-            const invalidArguments = this.validateHookArguments(hookEntryPoint, hook.fullPath);
-            if (invalidArguments.length) {
-                this.$logger.warn(`${hook.fullPath} will NOT be executed because it has invalid arguments - ${color_1.color.grey(invalidArguments.join(", "))}.`);
-                return;
+            const definitionCandidate = (_a = (hookEntryPoint && hookEntryPoint.default)) !== null && _a !== void 0 ? _a : hookEntryPoint;
+            if (Array.isArray(definitionCandidate)) {
+                throw new Error(`${hook.fullPath} exports an array, which is not a supported hook entry point. Export a single hook definition or function per file.`);
+            }
+            if ((0, define_hook_1.isHookDefinition)(definitionCandidate)) {
+                result = await this.executeHookDefinition(definitionCandidate, hookName, hook, hookArguments, consumesMiddlewares);
             }
-            // HACK for backwards compatibility:
-            // In case $projectData wasn't resolved by the time we got here (most likely we got here without running a command but through a service directly)
-            // then it is probably passed as a hookArg
-            // if that is the case then pass it directly to the hook instead of trying to resolve $projectData via injector
-            // This helps make hooks stateless
-            const projectDataHookArg = hookArguments["hookArgs"] && hookArguments["hookArgs"]["projectData"];
-            if (projectDataHookArg) {
-                hookArguments["projectData"] = hookArguments["$projectData"] =
-                    projectDataHookArg;
+            else if (typeof hookEntryPoint !== "function") {
+                this.$logger.warn(`${hook.fullPath} will NOT be executed because it does not export a function.`);
+                return;
             }
-            const maybePromise = this.$injector.resolve(hookEntryPoint, hookArguments);
-            if (maybePromise) {
-                this.$logger.trace("Hook promises to signal completion");
-                try {
-                    result = await maybePromise;
+            else {
+                this.$logger.trace(`Validating ${hookName} arguments.`);
+                const invalidArguments = this.validateHookArguments(hookEntryPoint, hook.fullPath);
+                if (invalidArguments.length) {
+                    this.$logger.warn(`${hook.fullPath} will NOT be executed because it has invalid arguments - ${color_1.color.grey(invalidArguments.join(", "))}.`);
+                    return;
+                }
+                const projectDataHookArg = hookArguments["hookArgs"] && hookArguments["hookArgs"]["projectData"];
+                if (projectDataHookArg) {
+                    hookArguments["projectData"] = hookArguments["$projectData"] =
+                        projectDataHookArg;
                 }
-                catch (err) {
-                    if (err &&
-                        _.isBoolean(err.stopExecution) &&
-                        err.errorAsWarning === true) {
-                        this.$logger.warn(err.message || err);
+                const usesParamNameInjection = (hookEntryPoint.$inject.args).some((argument) => argument !== this.hookArgsName);
+                if (usesParamNameInjection) {
+                    (0, deprecation_1.reportDeprecation)({
+                        api: "hooks.param-name-signature",
+                        detail: hook.fullPath,
+                        logger: this.$logger,
+                    });
+                }
+                const maybePromise = this.$injector.resolve(hookEntryPoint, hookArguments);
+                if (maybePromise) {
+                    this.$logger.trace("Hook promises to signal completion");
+                    try {
+                        result = await maybePromise;
                     }
-                    else {
-                        // Print the actual error with its callstack, so it is easy to find out which hooks is causing troubles.
-                        this.$logger.error(err);
-                        throw err || new Error(`Failed to execute hook: ${hook.fullPath}.`);
+                    catch (err) {
+                        if (err &&
+                            _.isBoolean(err.stopExecution) &&
+                            err.errorAsWarning === true) {
+                            this.$logger.warn(err.message || err);
+                        }
+                        else {
+                            this.$logger.error(err);
+                            throw (err || new Error(`Failed to execute hook: ${hook.fullPath}.`));
+                        }
                     }
+                    this.$logger.trace("Hook completed");
                 }
-                this.$logger.trace("Hook completed");
             }
         }
         else {
@@ -179,18 +201,47 @@ class HooksService {
         ]);
         return result;
     }
-    async executeHooksInDirectory(directoryPath, hookName, hookArguments) {
+    async executeHookDefinition(definition, hookName, hook, hookArguments, consumesMiddlewares) {
+        if (definition.name !== hookName) {
+            this.$logger.warn(`${hook.fullPath} will NOT be executed: it defines the "${definition.name}" hook but is placed at the "${hookName}" hook point.`);
+            return;
+        }
+        const { context, middlewares } = (0, define_hook_1.createHookInvocation)(hookArguments, {
+            hookName,
+            consumesMiddlewares,
+        });
+        try {
+            const returnedValue = await (0, inject_1.runInInjectionContext)(this.$injector, () => definition.run(context));
+            if (typeof returnedValue === "function") {
+                this.$logger.warn(`${hook.fullPath} returned a function. Returning a middleware is the legacy convention and is ignored for hook definitions — use ctx.wrap() instead.`);
+            }
+        }
+        catch (err) {
+            if (err &&
+                _.isBoolean(err.stopExecution) &&
+                err.errorAsWarning === true) {
+                this.$logger.warn(err.message || err);
+            }
+            else {
+                this.$logger.error(err);
+                throw err || new Error(`Failed to execute hook: ${hook.fullPath}.`);
+            }
+        }
+        this.$logger.trace("Hook completed");
+        return middlewares.length ? middlewares : undefined;
+    }
+    async executeHooksInDirectory(directoryPath, hookName, hookArguments, consumesMiddlewares) {
         hookArguments = hookArguments || {};
         const results = [];
         const hooks = this.getHooksByName(directoryPath, hookName);
         for (let i = 0; i < hooks.length; ++i) {
             const hook = hooks[i];
-            const result = await this.executeHook(directoryPath, hookName, hook, hookArguments);
+            const result = await this.executeHook(directoryPath, hookName, hook, hookArguments, consumesMiddlewares);
             if (result) {
                 results.push(result);
             }
         }
-        return results;
+        return _.flatten(results);
     }
     getCustomHooksByName(hookName) {
         const hooks = [];
@@ -260,7 +311,6 @@ class HooksService {
                 interpreter = sheBangMatch[1];
             }
             if (interpreter) {
-                // Likewise, make /usr/bin/bash work like "bash".
                 shMatch = interpreter.match(/bin\/((?:ba)?sh)$/);
             }
             if (shMatch) {
@@ -274,26 +324,27 @@ class HooksService {
     }
     shouldExecuteInProcess(scriptSource) {
         try {
-            const esprima = require("esprima");
-            const ast = esprima.parse(scriptSource);
-            let inproc = false;
-            ast.body.forEach((statement) => {
-                if (statement.type !== "ExpressionStatement" ||
-                    statement.expression.type !== "AssignmentExpression") {
-                    return;
+            const ts = require("typescript");
+            const sourceFile = ts.createSourceFile("hook.js", scriptSource, ts.ScriptTarget.Latest, false, ts.ScriptKind.JS);
+            const isExportsTarget = (node) => {
+                if (!ts.isPropertyAccessExpression(node)) {
+                    return false;
                 }
-                const left = statement.expression.left;
-                if (left.type === "MemberExpression" &&
-                    left.object &&
-                    left.object.type === "Identifier" &&
-                    left.object.name === "module" &&
-                    left.property &&
-                    left.property.type === "Identifier" &&
-                    left.property.name === "exports") {
-                    inproc = true;
+                if (!ts.isIdentifier(node.expression)) {
+                    return false;
                 }
+                const object = node.expression.text;
+                const property = node.name.text;
+                return ((object === "module" && property === "exports") ||
+                    (object === "exports" && property === "default"));
+            };
+            return sourceFile.statements.some((statement) => {
+                return (ts.isExpressionStatement(statement) &&
+                    ts.isBinaryExpression(statement.expression) &&
+                    statement.expression.operatorToken.kind ===
+                        ts.SyntaxKind.EqualsToken &&
+                    isExportsTarget(statement.expression.left));
             });
-            return inproc;
         }
         catch (err) {
             return false;
@@ -301,7 +352,6 @@ class HooksService {
     }
     validateHookArguments(hookConstructor, hookFullPath) {
         const invalidArguments = [];
-        // We need to annotate the hook in order to have the arguments of the constructor.
         (0, helpers_1.annotate)(hookConstructor);
         _.each(hookConstructor.$inject.args, (argument) => {
             try {
@@ -322,12 +372,8 @@ HooksService.HOOKS_DIRECTORY_NAME = "hooks";
 __decorate([
     (0, decorators_1.memoize)({
         shouldCache() {
-            // only cache if we have hooks directories, the only case to
-            // not have hooks directories is when the project dir is
-            // not set yet, ie. when creating a project.
             return !!this.hooksDirectories.length;
         },
     })
 ], HooksService.prototype, "initialize", null);
 yok_1.injector.register("hooksService", HooksService);
-//# sourceMappingURL=hooks-service.js.map

package/lib/common/services/ios-notification-service.d.ts

@@ -0,0 +1,7 @@
+import { IiOSNotificationService } from "../declarations";
+export declare class IOSNotificationService implements IiOSNotificationService {
+    private $iosDeviceOperations;
+    constructor($iosDeviceOperations: IIOSDeviceOperations);
+    awaitNotification(deviceIdentifier: string, socket: number, timeout: number): Promise<string>;
+    postNotification(deviceIdentifier: string, notification: string, commandType?: string): Promise<number>;
+}

package/lib/common/services/ios-notification-service.js

@@ -34,4 +34,3 @@ class IOSNotificationService {
 }
 exports.IOSNotificationService = IOSNotificationService;
 yok_1.injector.register("iOSNotificationService", IOSNotificationService);
-//# sourceMappingURL=ios-notification-service.js.map

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/json-file-settings-service.js

@@ -25,8 +25,6 @@ class JsonFileSettingsService {
                 const dataToReturn = data.modifiedByCacheMechanism ? data.value : data;
                 if (cacheOpts && cacheOpts.cacheTimeout) {
                     if (!data.modifiedByCacheMechanism) {
-                        // If data has no cache, but we want to check the timeout, consider the data as outdated.
-                        // this should be a really rare case
                         return null;
                     }
                     const currentTime = Date.now();
@@ -84,8 +82,6 @@ class JsonFileSettingsService {
         if (!this.$fs.exists(this.jsonSettingsFilePath)) {
             const unexistingDirs = this.getUnexistingDirectories(this.jsonSettingsFilePath);
             this.$fs.writeFile(this.jsonSettingsFilePath, null);
-            // when running under 'sudo' we create the <path to home dir>/.local/share/.nativescript-cli dir with root as owner
-            // and other Applications cannot access this directory anymore. (bower/heroku/etc)
             if (process.env.SUDO_USER) {
                 for (const dir of unexistingDirs) {
                     await this.$fs.setCurrentUserAsOwner(dir, process.env.SUDO_USER);
@@ -105,7 +101,6 @@ class JsonFileSettingsService {
         const unexistingDirs = [];
         let currentDir = path.join(filePath, "..");
         while (true) {
-            // this directory won't be created.
             if (this.$fs.exists(currentDir)) {
                 break;
             }
@@ -117,4 +112,3 @@ class JsonFileSettingsService {
 }
 exports.JsonFileSettingsService = JsonFileSettingsService;
 yok_1.injector.register("jsonFileSettingsService", JsonFileSettingsService, false);
-//# sourceMappingURL=json-file-settings-service.js.map

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/lock-service.js

@@ -22,7 +22,6 @@ class LockService {
     }
     get defaultLockParams() {
         const lockParams = {
-            // https://www.npmjs.com/package/retry#retrytimeoutsoptions
             retriesObj: { retries: 13, minTimeout: 100, maxTimeout: 1000, factor: 2 },
             stale: 10 * 1000,
             realpath: false,
@@ -73,8 +72,6 @@ class LockService {
         }
     }
     getPathsForCleanupAction(lockPath) {
-        // The proper-lockfile creates directory with the passed name and `.lock` at the end.
-        // Ensure we will take care of it as well.
         return [lockPath, `${lockPath}.lock`];
     }
     getLockFileSettings(filePath, fileOpts) {
@@ -90,7 +87,6 @@ class LockService {
             fileOpts.retriesObj.retries = fileOpts.retries;
         }
         if (fileOpts.retryWait) {
-            // backwards compatibility
             fileOpts.retriesObj.minTimeout = fileOpts.retriesObj.maxTimeout =
                 fileOpts.retryWait;
         }
@@ -113,6 +109,4 @@ __decorate([
     (0, decorators_1.cache)()
 ], LockService.prototype, "defaultLockFilePath", null);
 yok_1.injector.register("lockService", LockService);
-// backwards compatibility
 yok_1.injector.register("lockfile", LockService);
-//# sourceMappingURL=lock-service.js.map

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/message-contract-generator.js

@@ -70,4 +70,3 @@ class MessageContractGenerator {
 }
 exports.MessageContractGenerator = MessageContractGenerator;
 yok_1.injector.register("messageContractGenerator", MessageContractGenerator);
-//# sourceMappingURL=message-contract-generator.js.map

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/messages-service.js

@@ -75,4 +75,3 @@ class MessagesService {
 }
 exports.MessagesService = MessagesService;
 yok_1.injector.register("messagesService", MessagesService);
-//# sourceMappingURL=messages-service.js.map

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/micro-templating-service.js

@@ -9,15 +9,11 @@ const _ = require("lodash");
 class MicroTemplateService {
     constructor($injector) {
         this.$injector = $injector;
-        // Injector's dynamicCallRegex doesn't have 'g' option, which we need here.
-        // Use ( ) in order to use $1 to get whole expression later
         this.dynamicCallRegex = new RegExp(util.format("(%s)", this.$injector.dynamicCallRegex.source), "g");
     }
     async parseContent(data, options) {
         const localVariables = this.getLocalVariables(options);
         const compiledTemplate = _.template(data.replace(this.dynamicCallRegex, 'this.$injector.getDynamicCallData("$1")'));
-        // When debugging parsing, uncomment the line below:
-        // console.log(compiledTemplate.source);
         return await compiledTemplate.apply(this, [localVariables]);
     }
     isPlatform(...args) {
@@ -26,7 +22,6 @@ class MicroTemplateService {
     }
     getLocalVariables(options) {
         const isHtml = options.isHtml;
-        // in html help we want to show all help. Only CONSOLE specific help(wrapped in if(isConsole) ) must be omitted
         const localVariables = {
             constants,
         };
@@ -41,4 +36,3 @@ class MicroTemplateService {
 }
 exports.MicroTemplateService = MicroTemplateService;
 yok_1.injector.register("microTemplateService", MicroTemplateService);
-//# sourceMappingURL=micro-templating-service.js.map

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/net-service.js

@@ -14,7 +14,6 @@ class Net {
     }
     async getFreePort() {
         const server = net.createServer((sock) => {
-            /* empty - noone will connect here */
         });
         return new Promise((resolve, reject) => {
             let isResolved = false;
@@ -46,7 +45,6 @@ class Net {
             });
             server.once("close", () => {
                 if (!isResolved) {
-                    // "close" will be emitted right after "error"
                     isResolved = true;
                     resolve(true);
                 }
@@ -120,4 +118,3 @@ class Net {
 exports.Net = Net;
 Net.DEFAULT_INTERVAL = 1000;
 yok_1.injector.register("net", Net);
-//# sourceMappingURL=net-service.js.map

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-manager.js

@@ -53,7 +53,6 @@ class ProjectFilesManager {
         this.processPlatformSpecificFilesCore(platform, files, projectFilesConfig);
     }
     processPlatformSpecificFilesCore(platform, files, projectFilesConfig) {
-        // Renames the files that have `platform` as substring and removes the files from other platform
         _.each(files, (filePath) => {
             const projectFileInfo = this.$projectFilesProvider.getProjectFileInfo(filePath, platform, projectFilesConfig);
             if (!projectFileInfo.shouldIncludeFile) {
@@ -61,7 +60,6 @@ class ProjectFilesManager {
             }
             else if (projectFileInfo.onDeviceFileName) {
                 const onDeviceFilePath = path.join(path.dirname(filePath), projectFileInfo.onDeviceFileName);
-                // Fix .js.map entries
                 const extension = path.extname(projectFileInfo.onDeviceFileName);
                 if (onDeviceFilePath !== filePath) {
                     if (extension === ".js" || extension === ".map") {
@@ -75,8 +73,6 @@ class ProjectFilesManager {
                         fileContent = fileContent.replace(new RegExp(oldName, "g"), newName);
                         this.$fs.writeFile(filePath, fileContent);
                     }
-                    // Rename the file
-                    // this.$fs.rename is not called as it is error prone on some systems with slower hard drives and rigorous antivirus software
                     this.$fs.writeFile(onDeviceFilePath, this.$fs.readText(filePath));
                     this.$fs.deleteFile(filePath);
                 }
@@ -89,4 +85,3 @@ class ProjectFilesManager {
 }
 exports.ProjectFilesManager = ProjectFilesManager;
 yok_1.injector.register("projectFilesManager", ProjectFilesManager);
-//# sourceMappingURL=project-files-manager.js.map

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/project-files-provider-base.js

@@ -52,4 +52,3 @@ class ProjectFilesProviderBase {
     }
 }
 exports.ProjectFilesProviderBase = ProjectFilesProviderBase;
-//# sourceMappingURL=project-files-provider-base.js.map

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/proxy-service.js

@@ -51,4 +51,3 @@ class ProxyService {
 }
 exports.ProxyService = ProxyService;
 yok_1.injector.register("proxyService", ProxyService);
-//# sourceMappingURL=proxy-service.js.map

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/qr.js

@@ -26,4 +26,3 @@ class QrCodeGenerator {
 }
 exports.QrCodeGenerator = QrCodeGenerator;
 yok_1.injector.register("qr", QrCodeGenerator);
-//# sourceMappingURL=qr.js.map

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/settings-service.js

@@ -40,4 +40,3 @@ __decorate([
     (0, decorators_1.exported)("settingsService")
 ], SettingsService.prototype, "setSettings", null);
 yok_1.injector.register("settingsService", SettingsService);
-//# sourceMappingURL=settings-service.js.map