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

package/lib/commands/generate.js

@@ -3,10 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.GenerateCommand = void 0;
 const yok_1 = require("../common/yok");
 class GenerateCommand {
-    // private executionOptions: ExecutionOptions;
-    constructor($logger, 
-    // private $options: IOptions,
-    $errors) {
+    constructor($logger, $errors) {
         this.$logger = $logger;
         this.$errors = $errors;
         this.allowedParameters = [];
@@ -14,7 +11,6 @@ class GenerateCommand {
     async execute(_rawArgs) {
         try {
             this.$logger.info("If you have ideas for this command, please discuss at https://nativescript.org/discord");
-            // await run(this.executionOptions);
         }
         catch (error) {
             this.$errors.fail(error.message);
@@ -26,52 +22,9 @@ class GenerateCommand {
         return true;
     }
     validateExecutionOptions() {
-        // if (!this.executionOptions.schematic) {
-        // 	this.$errors.failWithHelp(
-        // 		`The generate command requires a schematic name to be specified.`
-        // 	);
-        // }
     }
     setExecutionOptions(rawArgs) {
-        // const options = this.parseRawArgs(rawArgs);
-        // this.executionOptions = {
-        // 	...options,
-        // 	logger: this.$logger,
-        // 	directory: process.cwd(),
-        // };
     }
 }
 exports.GenerateCommand = GenerateCommand;
-/**
- * Converts an array of command line arguments to options for the executed schematic.
- * @param rawArgs The command line arguments. They should be in the format 'key=value' for strings or 'key' for booleans.
- */
-// function parseSchematicSettings(rawArgs: string[]) {
-// 	const [optionStrings, args] = partition<string>(rawArgs, (item) =>
-// 		item.includes("=")
-// 	);
-// 	const options = optionStrings
-// 		.map((o) => o.split("=")) // split to key and value pairs
-// 		.map(([key, ...value]) => [key, value.join("=")]) // concat the value arrays if there are multiple = signs
-// 		.reduce((obj, [key, value]) => {
-// 			return { ...obj, [key]: value };
-// 		}, {});
-// 	return { options, args };
-// }
-/**
- * Splits an array into two groups based on a predicate.
- * @param array The array to split.
- * @param predicate The condition to be used for splitting.
- */
-// function partition<T>(array: T[], predicate: (item: T) => boolean): T[][] {
-// 	return array.reduce(
-// 		([pass, fail], item) => {
-// 			return predicate(item)
-// 				? [[...pass, item], fail]
-// 				: [pass, [...fail, item]];
-// 		},
-// 		[[], []]
-// 	);
-// }
 yok_1.injector.registerCommand("generate", GenerateCommand);
-//# sourceMappingURL=generate.js.map

package/lib/commands/hooks/common.d.ts

@@ -0,0 +1,22 @@
+import { IProjectData } from "../../definitions/project";
+import { IPluginData } from "../../definitions/plugins";
+import { ICommandParameter } from "../../common/definitions/commands";
+import { IErrors, IFileSystem } from "../../common/declarations";
+export declare const LOCK_FILE_NAME = "nativescript-lock.json";
+export interface OutputHook {
+    type: string;
+    hash: string;
+}
+export interface OutputPlugin {
+    name: string;
+    hooks: OutputHook[];
+}
+export declare class HooksVerify {
+    protected $projectData: IProjectData;
+    protected $errors: IErrors;
+    protected $fs: IFileSystem;
+    protected $logger: ILogger;
+    allowedParameters: ICommandParameter[];
+    constructor($projectData: IProjectData, $errors: IErrors, $fs: IFileSystem, $logger: ILogger);
+    protected verifyHooksLock(plugins: IPluginData[], hooksLockPath: string): Promise<void>;
+}

package/lib/commands/hooks/common.js

@@ -24,7 +24,7 @@ class HooksVerify {
         catch (err) {
             this.$errors.fail(`❌ Failed to read or parse ${exports.LOCK_FILE_NAME} at ${hooksLockPath}`);
         }
-        const lockMap = new Map(); // pluginName -> hookType -> hash
+        const lockMap = new Map();
         for (const plugin of hooksLock) {
             const hookMap = new Map();
             for (const hook of plugin.hooks) {
@@ -77,4 +77,3 @@ class HooksVerify {
     }
 }
 exports.HooksVerify = HooksVerify;
-//# sourceMappingURL=common.js.map

package/lib/commands/hooks/hooks-lock.d.ts

@@ -0,0 +1,24 @@
+import { IProjectData } from "../../definitions/project";
+import { IPluginsService } from "../../definitions/plugins";
+import { ICommand, ICommandParameter } from "../../common/definitions/commands";
+import { IErrors, IFileSystem } from "../../common/declarations";
+import { HooksVerify } from "./common";
+export declare class HooksLockPluginCommand implements ICommand {
+    private $pluginsService;
+    private $projectData;
+    private $errors;
+    private $fs;
+    private $logger;
+    allowedParameters: ICommandParameter[];
+    constructor($pluginsService: IPluginsService, $projectData: IProjectData, $errors: IErrors, $fs: IFileSystem, $logger: ILogger);
+    execute(): Promise<void>;
+    canExecute(args: string[]): Promise<boolean>;
+    private writeHooksLockFile;
+}
+export declare class HooksVerifyPluginCommand extends HooksVerify implements ICommand {
+    private $pluginsService;
+    allowedParameters: ICommandParameter[];
+    constructor($pluginsService: IPluginsService, $projectData: IProjectData, $errors: IErrors, $fs: IFileSystem, $logger: ILogger);
+    execute(): Promise<void>;
+    canExecute(args: string[]): Promise<boolean>;
+}

package/lib/commands/hooks/hooks-lock.js

@@ -98,4 +98,3 @@ class HooksVerifyPluginCommand extends common_1.HooksVerify {
 exports.HooksVerifyPluginCommand = HooksVerifyPluginCommand;
 yok_1.injector.registerCommand(["hooks|lock"], HooksLockPluginCommand);
 yok_1.injector.registerCommand(["hooks|verify"], HooksVerifyPluginCommand);
-//# sourceMappingURL=hooks-lock.js.map

package/lib/commands/hooks/hooks.d.ts

@@ -0,0 +1,17 @@
+import { IProjectData } from "../../definitions/project";
+import { IPluginsService } from "../../definitions/plugins";
+import { ICommand, ICommandParameter } from "../../common/definitions/commands";
+import { IErrors, IFileSystem } from "../../common/declarations";
+import { HooksVerify } from "./common";
+export declare class HooksPluginCommand extends HooksVerify implements ICommand {
+    private $pluginsService;
+    allowedParameters: ICommandParameter[];
+    constructor($pluginsService: IPluginsService, $projectData: IProjectData, $errors: IErrors, $fs: IFileSystem, $logger: ILogger);
+    execute(args: string[]): Promise<void>;
+    canExecute(args: string[]): Promise<boolean>;
+}
+export declare class HooksListPluginCommand extends HooksPluginCommand {
+    allowedParameters: ICommandParameter[];
+    constructor($pluginsService: IPluginsService, $projectData: IProjectData, $errors: IErrors, $fs: IFileSystem, $logger: ILogger);
+    execute(): Promise<void>;
+}

package/lib/commands/hooks/hooks.js

@@ -69,4 +69,3 @@ class HooksListPluginCommand extends HooksPluginCommand {
 exports.HooksListPluginCommand = HooksListPluginCommand;
 yok_1.injector.registerCommand(["hooks|install"], HooksPluginCommand);
 yok_1.injector.registerCommand(["hooks|*list"], HooksListPluginCommand);
-//# sourceMappingURL=hooks.js.map

package/lib/commands/info.d.ts

@@ -0,0 +1,8 @@
+import { IInfoService } from "../declarations";
+import { ICommand, ICommandParameter } from "../common/definitions/commands";
+export declare class InfoCommand implements ICommand {
+    private $infoService;
+    allowedParameters: ICommandParameter[];
+    constructor($infoService: IInfoService);
+    execute(args: string[]): Promise<void>;
+}

package/lib/commands/info.js

@@ -13,4 +13,3 @@ class InfoCommand {
 }
 exports.InfoCommand = InfoCommand;
 yok_1.injector.registerCommand("info", InfoCommand);
-//# sourceMappingURL=info.js.map

package/lib/commands/install.d.ts

@@ -0,0 +1,25 @@
+import { IProjectData, IProjectDataService } from "../definitions/project";
+import { IOptions, IPlatformCommandHelper, INodePackageManager } from "../declarations";
+import { IPlatformsDataService } from "../definitions/platform";
+import { IPluginsService } from "../definitions/plugins";
+import { ICommand, ICommandParameter } from "../common/definitions/commands";
+import { IFileSystem } from "../common/declarations";
+export declare class InstallCommand implements ICommand {
+    private $options;
+    private $mobileHelper;
+    private $platformsDataService;
+    private $platformCommandHelper;
+    private $projectData;
+    private $projectDataService;
+    private $pluginsService;
+    private $logger;
+    private $fs;
+    private $stringParameter;
+    private $packageManager;
+    enableHooks: boolean;
+    allowedParameters: ICommandParameter[];
+    constructor($options: IOptions, $mobileHelper: Mobile.IMobileHelper, $platformsDataService: IPlatformsDataService, $platformCommandHelper: IPlatformCommandHelper, $projectData: IProjectData, $projectDataService: IProjectDataService, $pluginsService: IPluginsService, $logger: ILogger, $fs: IFileSystem, $stringParameter: ICommandParameter, $packageManager: INodePackageManager);
+    execute(args: string[]): Promise<void>;
+    private installProjectDependencies;
+    private installModule;
+}

package/lib/commands/install.js

@@ -63,4 +63,3 @@ class InstallCommand {
 }
 exports.InstallCommand = InstallCommand;
 yok_1.injector.registerCommand("install", InstallCommand);
-//# sourceMappingURL=install.js.map

package/lib/commands/list-platforms.d.ts

@@ -0,0 +1,11 @@
+import { IProjectData } from "../definitions/project";
+import { IPlatformCommandHelper } from "../declarations";
+import { ICommandParameter, ICommand } from "../common/definitions/commands";
+export declare class ListPlatformsCommand implements ICommand {
+    private $platformCommandHelper;
+    private $projectData;
+    private $logger;
+    allowedParameters: ICommandParameter[];
+    constructor($platformCommandHelper: IPlatformCommandHelper, $projectData: IProjectData, $logger: ILogger);
+    execute(args: string[]): Promise<void>;
+}

package/lib/commands/list-platforms.js

@@ -32,4 +32,3 @@ class ListPlatformsCommand {
 }
 exports.ListPlatformsCommand = ListPlatformsCommand;
 yok_1.injector.registerCommand("platform|*list", ListPlatformsCommand);
-//# sourceMappingURL=list-platforms.js.map

package/lib/commands/migrate.d.ts

@@ -0,0 +1,13 @@
+import { IProjectData } from "../definitions/project";
+import { IMigrateController } from "../definitions/migrate";
+import { ICommand, ICommandParameter } from "../common/definitions/commands";
+export declare class MigrateCommand implements ICommand {
+    private $devicePlatformsConstants;
+    private $migrateController;
+    private $staticConfig;
+    private $projectData;
+    private $logger;
+    allowedParameters: ICommandParameter[];
+    constructor($devicePlatformsConstants: Mobile.IDevicePlatformsConstants, $migrateController: IMigrateController, $staticConfig: Config.IStaticConfig, $projectData: IProjectData, $logger: ILogger);
+    execute(args: string[]): Promise<void>;
+}

package/lib/commands/migrate.js

@@ -31,4 +31,3 @@ class MigrateCommand {
 }
 exports.MigrateCommand = MigrateCommand;
 yok_1.injector.registerCommand("migrate", MigrateCommand);
-//# sourceMappingURL=migrate.js.map

package/lib/commands/native-add.d.ts

@@ -0,0 +1,49 @@
+import { IProjectData } from "../definitions/project";
+import { ICommandParameter, ICommand } from "../common/definitions/commands";
+import { IErrors } from "../common/declarations";
+export declare class NativeAddCommand implements ICommand {
+    protected $projectData: IProjectData;
+    protected $logger: ILogger;
+    protected $errors: IErrors;
+    allowedParameters: ICommandParameter[];
+    constructor($projectData: IProjectData, $logger: ILogger, $errors: IErrors);
+    execute(args: string[]): Promise<void>;
+    protected failWithUsage(): void;
+    canExecute(args: string[]): Promise<boolean>;
+    protected getIosSourcePathBase(): string;
+    protected getAndroidSourcePathBase(): string;
+}
+export declare class NativeAddSingleCommand extends NativeAddCommand {
+    constructor($projectData: IProjectData, $logger: ILogger, $errors: IErrors);
+    canExecute(args: string[]): Promise<boolean>;
+}
+export declare class NativeAddAndroidCommand extends NativeAddSingleCommand {
+    constructor($projectData: IProjectData, $logger: ILogger, $errors: IErrors);
+    private getPackageName;
+    private getClassSimpleName;
+    private generateJavaClassContent;
+    private generateKotlinClassContent;
+    doJavaKotlin(className: string, extension: string): void;
+    private checkAndUpdateGradleProperties;
+}
+export declare class NativeAddJavaCommand extends NativeAddAndroidCommand {
+    constructor($projectData: IProjectData, $logger: ILogger, $errors: IErrors);
+    execute(args: string[]): Promise<void>;
+}
+export declare class NativeAddKotlinCommand extends NativeAddAndroidCommand {
+    constructor($projectData: IProjectData, $logger: ILogger, $errors: IErrors);
+    execute(args: string[]): Promise<void>;
+}
+export declare class NativeAddObjectiveCCommand extends NativeAddSingleCommand {
+    constructor($projectData: IProjectData, $logger: ILogger, $errors: IErrors);
+    execute(args: string[]): Promise<void>;
+    private doObjectiveC;
+    private generateOrUpdateModuleMap;
+    private generateObjectiveCFiles;
+}
+export declare class NativeAddSwiftCommand extends NativeAddSingleCommand {
+    constructor($projectData: IProjectData, $logger: ILogger, $errors: IErrors);
+    execute(args: string[]): Promise<void>;
+    private doSwift;
+    private generateSwiftFile;
+}

package/lib/commands/native-add.js

@@ -173,7 +173,6 @@ class NativeAddObjectiveCCommand extends NativeAddSingleCommand {
         const classFilePath = path.join(iosSourceBase, `${className}.m`);
         const headerFilePath = path.join(iosSourceBase, `${className}.h`);
         if (this.generateObjectiveCFiles(className, classFilePath, headerFilePath)) {
-            // Modify/Generate moduleMap
             this.generateOrUpdateModuleMap(`${className}.h`, path.join(iosSourceBase, "module.modulemap"));
         }
     }
@@ -186,9 +185,7 @@ class NativeAddObjectiveCCommand extends NativeAddSingleCommand {
         }
         const headerDeclaration = `header "${headerPath}"`;
         if (moduleMapContent.includes(`module ${moduleName}`)) {
-            // Module declaration already exists in the module map
             if (moduleMapContent.includes(headerDeclaration)) {
-                // Header is already present in the module map
                 this.$logger.warn(`Header '${headerFileName}' is already added to the module map.`);
                 return;
             }
@@ -196,7 +193,6 @@ class NativeAddObjectiveCCommand extends NativeAddSingleCommand {
             fs.writeFileSync(moduleMapPath, updatedModuleMapContent);
         }
         else {
-            // Module declaration does not exist in the module map
             const moduleDeclaration = `module ${moduleName} {${os_1.EOL}    ${headerDeclaration}${os_1.EOL}    export *${os_1.EOL}}`;
             moduleMapContent += `${os_1.EOL}${os_1.EOL}${moduleDeclaration}`;
             fs.writeFileSync(moduleMapPath, moduleMapContent);
@@ -279,4 +275,3 @@ yok_1.injector.registerCommand(["native|add|java"], NativeAddJavaCommand);
 yok_1.injector.registerCommand(["native|add|kotlin"], NativeAddKotlinCommand);
 yok_1.injector.registerCommand(["native|add|swift"], NativeAddSwiftCommand);
 yok_1.injector.registerCommand(["native|add|objective-c"], NativeAddObjectiveCCommand);
-//# sourceMappingURL=native-add.js.map

package/lib/commands/platform-clean.d.ts

@@ -0,0 +1,17 @@
+import { IProjectData } from "../definitions/project";
+import { IOptions, IPlatformCommandHelper, IPlatformValidationService } from "../declarations";
+import { IPlatformEnvironmentRequirements } from "../definitions/platform";
+import { ICommand, ICommandParameter } from "../common/definitions/commands";
+import { IErrors } from "../common/declarations";
+export declare class CleanCommand implements ICommand {
+    private $errors;
+    private $options;
+    private $platformCommandHelper;
+    private $platformValidationService;
+    private $platformEnvironmentRequirements;
+    private $projectData;
+    allowedParameters: ICommandParameter[];
+    constructor($errors: IErrors, $options: IOptions, $platformCommandHelper: IPlatformCommandHelper, $platformValidationService: IPlatformValidationService, $platformEnvironmentRequirements: IPlatformEnvironmentRequirements, $projectData: IProjectData);
+    execute(args: string[]): Promise<void>;
+    canExecute(args: string[]): Promise<boolean>;
+}

package/lib/commands/platform-clean.js

@@ -39,4 +39,3 @@ class CleanCommand {
 }
 exports.CleanCommand = CleanCommand;
 yok_1.injector.registerCommand("platform|clean", CleanCommand);
-//# sourceMappingURL=platform-clean.js.map

package/lib/commands/plugin/add-plugin.d.ts

@@ -0,0 +1,13 @@
+import { IProjectData } from "../../definitions/project";
+import { IPluginsService } from "../../definitions/plugins";
+import { ICommand, ICommandParameter } from "../../common/definitions/commands";
+import { IErrors } from "../../common/declarations";
+export declare class AddPluginCommand implements ICommand {
+    private $pluginsService;
+    private $projectData;
+    private $errors;
+    allowedParameters: ICommandParameter[];
+    constructor($pluginsService: IPluginsService, $projectData: IProjectData, $errors: IErrors);
+    execute(args: string[]): Promise<void>;
+    canExecute(args: string[]): Promise<boolean>;
+}

package/lib/commands/plugin/add-plugin.js

@@ -28,4 +28,3 @@ class AddPluginCommand {
 }
 exports.AddPluginCommand = AddPluginCommand;
 yok_1.injector.registerCommand(["plugin|add", "plugin|install"], AddPluginCommand);
-//# sourceMappingURL=add-plugin.js.map

package/lib/commands/plugin/build-plugin.d.ts

@@ -0,0 +1,18 @@
+import { IOptions } from "../../declarations";
+import { IAndroidPluginBuildService } from "../../definitions/android-plugin-migrator";
+import { ICommand, ICommandParameter } from "../../common/definitions/commands";
+import { IErrors, IFileSystem } from "../../common/declarations";
+import { ITempService } from "../../definitions/temp-service";
+export declare class BuildPluginCommand implements ICommand {
+    private $androidPluginBuildService;
+    private $errors;
+    private $logger;
+    private $fs;
+    private $options;
+    private $tempService;
+    allowedParameters: ICommandParameter[];
+    pluginProjectPath: string;
+    constructor($androidPluginBuildService: IAndroidPluginBuildService, $errors: IErrors, $logger: ILogger, $fs: IFileSystem, $options: IOptions, $tempService: ITempService);
+    execute(args: string[]): Promise<void>;
+    canExecute(args: string[]): Promise<boolean>;
+}

package/lib/commands/plugin/build-plugin.js

@@ -53,4 +53,3 @@ class BuildPluginCommand {
 }
 exports.BuildPluginCommand = BuildPluginCommand;
 yok_1.injector.registerCommand("plugin|build", BuildPluginCommand);
-//# sourceMappingURL=build-plugin.js.map

package/lib/commands/plugin/create-plugin.d.ts

@@ -0,0 +1,30 @@
+import { IOptions, INodePackageManager } from "../../declarations";
+import { ICommand, ICommandParameter } from "../../common/definitions/commands";
+import { IErrors, IFileSystem, IChildProcess } from "../../common/declarations";
+import { ITerminalSpinnerService } from "../../definitions/terminal-spinner-service";
+export declare class CreatePluginCommand implements ICommand {
+    private $options;
+    private $errors;
+    private $terminalSpinnerService;
+    private $logger;
+    private $pacoteService;
+    private $fs;
+    private $childProcess;
+    private $prompter;
+    private $packageManager;
+    allowedParameters: ICommandParameter[];
+    userMessage: string;
+    nameMessage: string;
+    includeTypeScriptDemoMessage: string;
+    includeAngularDemoMessage: string;
+    pathAlreadyExistsMessageTemplate: string;
+    constructor($options: IOptions, $errors: IErrors, $terminalSpinnerService: ITerminalSpinnerService, $logger: ILogger, $pacoteService: IPacoteService, $fs: IFileSystem, $childProcess: IChildProcess, $prompter: IPrompter, $packageManager: INodePackageManager);
+    execute(args: string[]): Promise<void>;
+    canExecute(args: string[]): Promise<boolean>;
+    private setupSeed;
+    private ensurePackageDir;
+    private downloadPackage;
+    private getGitHubUsername;
+    private getPluginNameSource;
+    private getShouldIncludeDemoResult;
+}

package/lib/commands/plugin/create-plugin.js

@@ -28,14 +28,12 @@ class CreatePluginCommand {
         const selectedTemplate = this.$options.template;
         const selectedPath = path.resolve(pathToProject || ".");
         const projectDir = path.join(selectedPath, pluginRepoName);
-        // Must be out of try catch block, because will throw error if folder alredy exists and we don't want to delete it.
         this.ensurePackageDir(projectDir);
         try {
             await this.downloadPackage(selectedTemplate, projectDir);
             await this.setupSeed(projectDir, pluginRepoName);
         }
         catch (err) {
-            // The call to this.ensurePackageDir() above will throw error if folder alredy exists, so it is safe to delete here.
             this.$fs.deleteDirectory(projectDir);
             throw err;
         }
@@ -71,7 +69,6 @@ class CreatePluginCommand {
                 !config.includeTypeScriptDemo)) {
             this.$logger.printMarkdown("Using default values for plugin creation options since your shell is not interactive.");
         }
-        // run postclone script manually and kill it if it takes more than 10 sec
         const pathToPostCloneScript = path.join("scripts", "postclone");
         const params = [
             pathToPostCloneScript,
@@ -126,7 +123,6 @@ class CreatePluginCommand {
     }
     async getPluginNameSource(pluginNameSource, pluginRepoName) {
         if (!pluginNameSource) {
-            // remove nativescript- prefix for naming plugin files
             const prefix = "nativescript-";
             pluginNameSource = pluginRepoName.toLowerCase().startsWith(prefix)
                 ? pluginRepoName.slice(prefix.length, pluginRepoName.length)
@@ -154,4 +150,3 @@ class CreatePluginCommand {
 }
 exports.CreatePluginCommand = CreatePluginCommand;
 yok_1.injector.registerCommand(["plugin|create"], CreatePluginCommand);
-//# sourceMappingURL=create-plugin.js.map

package/lib/commands/plugin/list-plugins.d.ts

@@ -0,0 +1,12 @@
+import { IProjectData } from "../../definitions/project";
+import { IPluginsService } from "../../definitions/plugins";
+import { ICommand, ICommandParameter } from "../../common/definitions/commands";
+export declare class ListPluginsCommand implements ICommand {
+    private $pluginsService;
+    private $projectData;
+    private $logger;
+    allowedParameters: ICommandParameter[];
+    constructor($pluginsService: IPluginsService, $projectData: IProjectData, $logger: ILogger);
+    execute(args: string[]): Promise<void>;
+    private createTableCells;
+}

package/lib/commands/plugin/list-plugins.js

@@ -41,4 +41,3 @@ class ListPluginsCommand {
 }
 exports.ListPluginsCommand = ListPluginsCommand;
 yok_1.injector.registerCommand("plugin|*list", ListPluginsCommand);
-//# sourceMappingURL=list-plugins.js.map

package/lib/commands/plugin/remove-plugin.d.ts

@@ -0,0 +1,14 @@
+import { IProjectData } from "../../definitions/project";
+import { IPluginsService } from "../../definitions/plugins";
+import { ICommand, ICommandParameter } from "../../common/definitions/commands";
+import { IErrors } from "../../common/declarations";
+export declare class RemovePluginCommand implements ICommand {
+    private $pluginsService;
+    private $errors;
+    private $logger;
+    private $projectData;
+    allowedParameters: ICommandParameter[];
+    constructor($pluginsService: IPluginsService, $errors: IErrors, $logger: ILogger, $projectData: IProjectData);
+    execute(args: string[]): Promise<void>;
+    canExecute(args: string[]): Promise<boolean>;
+}

package/lib/commands/plugin/remove-plugin.js

@@ -21,7 +21,6 @@ class RemovePluginCommand {
         }
         let pluginNames = [];
         try {
-            // try installing the plugins, so we can get information from node_modules about their native code, libs, etc.
             const installedPlugins = await this.$pluginsService.getAllInstalledPlugins(this.$projectData);
             pluginNames = installedPlugins.map((pl) => pl.name);
         }
@@ -38,4 +37,3 @@ class RemovePluginCommand {
 }
 exports.RemovePluginCommand = RemovePluginCommand;
 yok_1.injector.registerCommand("plugin|remove", RemovePluginCommand);
-//# sourceMappingURL=remove-plugin.js.map

package/lib/commands/plugin/update-plugin.d.ts

@@ -0,0 +1,13 @@
+import { IProjectData } from "../../definitions/project";
+import { IPluginsService } from "../../definitions/plugins";
+import { ICommand, ICommandParameter } from "../../common/definitions/commands";
+import { IErrors } from "../../common/declarations";
+export declare class UpdatePluginCommand implements ICommand {
+    private $pluginsService;
+    private $projectData;
+    private $errors;
+    constructor($pluginsService: IPluginsService, $projectData: IProjectData, $errors: IErrors);
+    execute(args: string[]): Promise<void>;
+    canExecute(args: string[]): Promise<boolean>;
+    allowedParameters: ICommandParameter[];
+}

package/lib/commands/plugin/update-plugin.js

@@ -37,4 +37,3 @@ class UpdatePluginCommand {
 }
 exports.UpdatePluginCommand = UpdatePluginCommand;
 yok_1.injector.registerCommand("plugin|update", UpdatePluginCommand);
-//# sourceMappingURL=update-plugin.js.map

package/lib/commands/post-install.d.ts

@@ -0,0 +1,16 @@
+import { ICommand, ICommandParameter } from "../common/definitions/commands";
+import { IFileSystem, IHelpService, ISettingsService, IAnalyticsService, IHostInfo } from "../common/declarations";
+export declare class PostInstallCliCommand implements ICommand {
+    private $fs;
+    private $commandsService;
+    private $helpService;
+    private $settingsService;
+    private $analyticsService;
+    private $logger;
+    private $hostInfo;
+    constructor($fs: IFileSystem, $commandsService: ICommandsService, $helpService: IHelpService, $settingsService: ISettingsService, $analyticsService: IAnalyticsService, $logger: ILogger, $hostInfo: IHostInfo);
+    disableAnalytics: boolean;
+    allowedParameters: ICommandParameter[];
+    execute(args: string[]): Promise<void>;
+    postCommandAction(args: string[]): Promise<void>;
+}

package/lib/commands/post-install.js

@@ -19,18 +19,13 @@ class PostInstallCliCommand {
     async execute(args) {
         const isRunningWithSudoUser = !!process.env.SUDO_USER;
         if (!this.$hostInfo.isWindows) {
-            // when running under 'sudo' we create a working dir with wrong owner (root) and
-            // it is no longer accessible for the user initiating the installation
-            // patch the owner here
             if (isRunningWithSudoUser) {
-                // TODO: Check if this is the correct place, probably we should set this at the end of the command.
                 await this.$fs.setCurrentUserAsOwner(this.$settingsService.getProfileDir(), process.env.SUDO_USER);
             }
         }
         const canExecutePostInstallTask = !isRunningWithSudoUser || (0, helpers_1.doesCurrentNpmCommandMatch)([/^--unsafe-perm$/]);
         if (canExecutePostInstallTask) {
             await this.$helpService.generateHtmlPages();
-            // Explicitly ask for confirmation of usage-reporting:
             await this.$analyticsService.checkConsent();
             await this.$commandsService.tryExecuteCommand("autocomplete", []);
         }
@@ -47,4 +42,3 @@ class PostInstallCliCommand {
 }
 exports.PostInstallCliCommand = PostInstallCliCommand;
 yok_1.injector.registerCommand("post-install-cli", PostInstallCliCommand);
-//# sourceMappingURL=post-install.js.map

package/lib/commands/prepare.d.ts

@@ -0,0 +1,40 @@
+import { ValidatePlatformCommandBase } from "./command-base";
+import { PrepareController } from "../controllers/prepare-controller";
+import { PrepareDataService } from "../services/prepare-data-service";
+import { IProjectData } from "../definitions/project";
+import { IOptions, IPlatformValidationService } from "../declarations";
+import { IPlatformsDataService } from "../definitions/platform";
+import { IMigrateController } from "../definitions/migrate";
+import { ICommand, ICommandParameter } from "../common/definitions/commands";
+import { OptionType } from "../common/enums";
+export declare class PrepareCommand extends ValidatePlatformCommandBase implements ICommand {
+    $options: IOptions;
+    $prepareController: PrepareController;
+    $platformValidationService: IPlatformValidationService;
+    $projectData: IProjectData;
+    $platformCommandParameter: ICommandParameter;
+    $platformsDataService: IPlatformsDataService;
+    $prepareDataService: PrepareDataService;
+    $migrateController: IMigrateController;
+    allowedParameters: ICommandParameter[];
+    dashedOptions: {
+        watch: {
+            type: OptionType;
+            default: boolean;
+            hasSensitiveValue: boolean;
+        };
+        hmr: {
+            type: OptionType;
+            default: boolean;
+            hasSensitiveValue: boolean;
+        };
+        skipNative: {
+            type: OptionType;
+            default: boolean;
+            hasSensitiveValue: boolean;
+        };
+    };
+    constructor($options: IOptions, $prepareController: PrepareController, $platformValidationService: IPlatformValidationService, $projectData: IProjectData, $platformCommandParameter: ICommandParameter, $platformsDataService: IPlatformsDataService, $prepareDataService: PrepareDataService, $migrateController: IMigrateController);
+    execute(args: string[]): Promise<void>;
+    canExecute(args: string[]): Promise<boolean>;
+}