feat: Introduce methods to get current assets structure

Introduce new methods in `projectDataService` to get the current assets strucuture. Use a predefined .json file in the resources to get information about image sizes.
For iOS read the Contents.json file in specific iOS Resource directories.
For Android - enumerate the files and construct required objects.

Use the new method in the assetsGenerationService. Generate icons and splashes based on the argument.
Require projectDir instead of resourcesDir for assets generation in order to get all CLI's specific files info (nsconfig, package.json, project location, etc.).

Fix comands for generating assets to have mandatory command parameter - previously it had a non-mandatory param.
Add newly exposed methods to the tests.

Author: rosen-vladimirov

lib/commands/generate-assets.ts

@@ -1,34 +1,33 @@
-import { StringCommandParameter } from "../common/command-params";
-
 export abstract class GenerateCommandBase implements ICommand {
-	public allowedParameters: ICommandParameter[] = [new StringCommandParameter(this.$injector)];
+	public allowedParameters: ICommandParameter[] = [this.$stringParameterBuilder.createMandatoryParameter("You have to provide path to image to generate other images based on it.")];
 
 	constructor(protected $options: IOptions,
 		protected $injector: IInjector,
 		protected $projectData: IProjectData,
+		protected $stringParameterBuilder: IStringParameterBuilder,
 		protected $assetsGenerationService: IAssetsGenerationService) {
 			this.$projectData.initializeProjectData();
 	}
 
 	public async execute(args: string[]): Promise<void> {
 		const [ imagePath ] = args;
-		const resourcesPath = this.$projectData.getAppResourcesDirectoryPath();
-		await this.generate(imagePath, resourcesPath, this.$options.background);
+		await this.generate(imagePath, this.$options.background);
 	}
 
-	protected abstract generate(imagePath: string, resourcesPath: string, background?: string): Promise<void>;
+	protected abstract generate(imagePath: string, background?: string): Promise<void>;
 }
 
 export class GenerateIconsCommand extends GenerateCommandBase implements ICommand {
 	constructor(protected $options: IOptions,
 		$injector: IInjector,
-		$projectData: IProjectData,
+		protected $projectData: IProjectData,
+		protected $stringParameterBuilder: IStringParameterBuilder,
 		$assetsGenerationService: IAssetsGenerationService) {
-			super($options, $injector, $projectData, $assetsGenerationService);
+			super($options, $injector, $projectData, $stringParameterBuilder, $assetsGenerationService);
 	}
 
-	protected async generate(imagePath: string, resourcesPath: string, background?: string): Promise<void> {
-		await this.$assetsGenerationService.generateIcons({ imagePath, resourcesPath });
+	protected async generate(imagePath: string, background?: string): Promise<void> {
+		await this.$assetsGenerationService.generateIcons({ imagePath, projectDir: this.$projectData.projectDir });
 	}
 }
 
@@ -37,13 +36,14 @@ $injector.registerCommand("resources|generate|icons", GenerateIconsCommand);
 export class GenerateSplashScreensCommand extends GenerateCommandBase implements ICommand {
 	constructor(protected $options: IOptions,
 		$injector: IInjector,
-		$projectData: IProjectData,
+		protected $projectData: IProjectData,
+		protected $stringParameterBuilder: IStringParameterBuilder,
 		$assetsGenerationService: IAssetsGenerationService) {
-			super($options, $injector, $projectData, $assetsGenerationService);
+			super($options, $injector, $projectData, $stringParameterBuilder, $assetsGenerationService);
 	}
 
 	protected async generate(imagePath: string, resourcesPath: string, background?: string): Promise<void> {
-		await this.$assetsGenerationService.generateSplashScreens({ imagePath, resourcesPath, background });
+		await this.$assetsGenerationService.generateSplashScreens({ imagePath, background, projectDir: this.$projectData.projectDir });
 	}
 }
 

lib/constants.ts

@@ -148,3 +148,18 @@ export const NATIVESCRIPT_CLOUD_EXTENSION_NAME = "nativescript-cloud";
  * Used in ProjectDataService to concatenate the names of the properties inside nativescript key of package.json.
  */
 export const NATIVESCRIPT_PROPS_INTERNAL_DELIMITER = "**|__**";
+export const CLI_RESOURCES_DIR_NAME = "resources";
+
+export class AssetConstants {
+	public static iOSResourcesFileName = "Contents.json";
+	public static iOSAssetsDirName = "Assets.xcassets";
+	public static iOSIconsDirName = "AppIcon.appiconset";
+	public static iOSSplashBackgroundsDirName = "LaunchScreen.AspectFill.imageset";
+	public static iOSSplashCenterImagesDirName = "LaunchScreen.Center.imageset";
+	public static iOSSplashImagesDirName = "LaunchImage.launchimage";
+
+	public static imageDefinitionsFileName = "image-definitions.json";
+	public static assets = "assets";
+
+	public static sizeDelimiter = "x";
+}

lib/declarations.d.ts

@@ -571,7 +571,7 @@ interface IAndroidToolsInfo {
 	 */
 	validateAndroidHomeEnvVariable(options?: IAndroidToolsInfoOptions): boolean;
 
-	/** 
+	/**
 	 * Validates target sdk
 	 * @param {IAndroidToolsInfoOptions} options @optional Defines if the warning messages should treated as error.
 	 * @returns {boolean} True if there are detected issues, false otherwise
@@ -791,25 +791,22 @@ interface IBundleValidatorHelper {
 interface INativescriptCloudExtensionService {
 	/**
 	 * Installs nativescript-cloud extension
-	 * @return {Promise<IExtensionData>} returns the extension data 
+	 * @return {Promise<IExtensionData>} returns the extension data
 	 */
 	install(): Promise<IExtensionData>;
 }
 
 /**
  * Describes the basic data needed for resource generation
  */
-interface IResourceGenerationData {
+interface IResourceGenerationData extends IProjectDir {
 	/**
 	 * @param {string} imagePath Path to the image that will be used for generation
 	 */
-	imagePath: string, 
-	/**
-	 * @param {string} resourcesPath Path to the app resources
-	 */
-	resourcesPath: string,
+	imagePath: string,
+
 	/**
-	 * @param {string} platform Specify for which platform to generate assets. If not defined will generate for all platforms 
+	 * @param {string} platform Specify for which platform to generate assets. If not defined will generate for all platforms
 	 */
 	platform?: string
 }
@@ -824,7 +821,6 @@ interface ISplashesGenerationData extends IResourceGenerationData {
 	background?: string
 }
 
-
 /**
  * Describes service used for assets generation
  */

lib/definitions/project.d.ts

@@ -55,7 +55,7 @@ interface IProjectService {
 
 interface INsConfig {
 	appPath?: string;
-	appResourcesPath?:string;
+	appResourcesPath?: string;
 }
 
 interface IProjectData extends IProjectDir {
@@ -123,6 +123,43 @@ interface IProjectDataService {
 	removeDependency(projectDir: string, dependencyName: string): void;
 
 	getProjectData(projectDir?: string): IProjectData;
+
+	getAssetsStructure(opts: IProjectDir): Promise<IAssetsStructure>;
+
+	getIOSAssetsStructure(opts: IProjectDir): Promise<IAssetGroup>;
+
+	getAndroidAssetsStructure(opts: IProjectDir): Promise<IAssetGroup>;
+}
+
+interface IAssetItem {
+	path: string;
+	size: string;
+	width: number;
+	height: number;
+	filename: string;
+	directory: string;
+	scale: number;
+	idiom: string;
+	resizeOperation?: string;
+}
+
+interface IAssetSubGroup {
+	images: IAssetItem[];
+	info?: { version: string, author: string };
+}
+
+interface IAssetGroup {
+	icons: IAssetSubGroup;
+	splashBackgrounds: IAssetSubGroup;
+	splashCenterImages: IAssetSubGroup;
+	splashImages?: IAssetSubGroup;
+	[imageType: string]: IAssetSubGroup;
+}
+
+interface IAssetsStructure {
+	ios: IAssetGroup;
+	android: IAssetGroup;
+	[platform: string]: IAssetGroup;
 }
 
 /**

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

@@ -1,65 +1,102 @@
-import * as path from "path";
 import * as Jimp from "jimp";
 import * as Color from "color";
-import { Icons, SplashScreens, Operations } from "./image-definitions";
 import { exported } from "../../common/decorators";
 
+export const enum Operations {
+	OverlayWith = "overlayWith",
+	Blank = "blank",
+	Resize = "resize"
+}
+
+interface IGenerateImagesData extends ISplashesGenerationData {
+	propertiesToEnumerate: string[];
+}
+
 export class AssetsGenerationService implements IAssetsGenerationService {
+	private get propertiesToEnumerate(): any {
+		return {
+			icon: ["icons"],
+			splash: ["splashBackgrounds", "splashCenterImages", "splashImages"]
+		};
+	}
+
 	constructor(private $logger: ILogger,
-		private $androidResourcesMigrationService: IAndroidResourcesMigrationService) {
+		private $projectDataService: IProjectDataService) {
 	}
 
 	@exported("assetsGenerationService")
 	public async generateIcons(resourceGenerationData: IResourceGenerationData): Promise<void> {
 		this.$logger.info("Generating icons ...");
-		await this.generateImagesForDefinitions(resourceGenerationData.imagePath, resourceGenerationData.resourcesPath, Icons, resourceGenerationData.platform);
+		const generationData = (<IGenerateImagesData>resourceGenerationData);
+		generationData.propertiesToEnumerate = this.propertiesToEnumerate.icon;
+		await this.generateImagesForDefinitions(generationData);
 		this.$logger.info("Icons generation completed.");
 	}
 
 	@exported("assetsGenerationService")
 	public async generateSplashScreens(splashesGenerationData: ISplashesGenerationData): Promise<void> {
 		this.$logger.info("Generating splash screens ...");
-		await this.generateImagesForDefinitions(splashesGenerationData.imagePath, splashesGenerationData.resourcesPath, SplashScreens, splashesGenerationData.platform, splashesGenerationData.background);
+		const generationData = (<IGenerateImagesData>splashesGenerationData);
+		generationData.propertiesToEnumerate = this.propertiesToEnumerate.splash;
+		await this.generateImagesForDefinitions(generationData);
 		this.$logger.info("Splash screens generation completed.");
 	}
 
-	private async generateImagesForDefinitions(imagePath: string, resourcesPath: string, definitions: any[], platform?: string, background: string = "white") : Promise<void> {
-		const hasMigrated = this.$androidResourcesMigrationService.hasMigrated(resourcesPath);
-
-		const filteredDefinitions = platform ? _.filter(definitions, definition => _.toLower(definition.platform) === _.toLower(platform)) : definitions;
-
-		for (const definition of filteredDefinitions) {
-			const operation = definition.operation || Operations.Resize;
-			const scale = definition.scale || 0.8;
-			const path = hasMigrated ? definition.path : (definition.pathBeforeMigration || definition.path);
-			const outputPath = this.convertToAbsolutePath(resourcesPath, path);
-
-			switch (operation) {
-				case Operations.OverlayWith:
-					const imageResize = Math.round(Math.min(definition.width, definition.height) * scale);
-					const image = await this.resize(imagePath, imageResize, imageResize);
-					await this.generateImage(background, definition.width, definition.height, outputPath, image);
-					break;
-				case Operations.Blank:
-					await this.generateImage(background, definition.width, definition.height, outputPath);
-					break;
-				case Operations.Resize:
-					const resizedImage = await this.resize(imagePath, definition.width, definition.height);
-					resizedImage.write(outputPath);
-					break;
-				default:
-					throw new Error(`Invalid image generation operation: ${operation}`);
+	private async generateImagesForDefinitions(data: IGenerateImagesData): Promise<void> {
+		data.background = data.background || "white";
+		const assetsStructure = await this.$projectDataService.getAssetsStructure({ projectDir: data.projectDir });
+
+		for (const platform in assetsStructure) {
+			if (data.platform && platform.toLowerCase() !== data.platform.toLowerCase()) {
+				continue;
+			}
+
+			const platformAssetsStructure = assetsStructure[platform];
+
+			for (const imageTypeKey in platformAssetsStructure) {
+				if (data.propertiesToEnumerate.indexOf(imageTypeKey) === -1 || !platformAssetsStructure[imageTypeKey]) {
+					continue;
+				}
+
+				const imageType = platformAssetsStructure[imageTypeKey];
+
+				for (const assetItem of imageType.images) {
+					if (!assetItem.filename) {
+						continue;
+					}
+
+					const operation = assetItem.resizeOperation || Operations.Resize;
+					const scale = assetItem.scale || 0.8;
+					const outputPath = assetItem.path;
+
+					switch (operation) {
+						case Operations.OverlayWith:
+							const imageResize = Math.round(Math.min(assetItem.width, assetItem.height) * scale);
+							const image = await this.resize(data.imagePath, imageResize, imageResize);
+							await this.generateImage(data.background, assetItem.width, assetItem.height, outputPath, image);
+							break;
+						case Operations.Blank:
+							await this.generateImage(data.background, assetItem.width, assetItem.height, outputPath);
+							break;
+						case Operations.Resize:
+							const resizedImage = await this.resize(data.imagePath, assetItem.width, assetItem.height);
+							resizedImage.write(outputPath);
+							break;
+						default:
+							throw new Error(`Invalid image generation operation: ${operation}`);
+					}
+				}
 			}
 		}
 	}
 
-	private async resize(imagePath: string, width: number, height: number) : Promise<Jimp> {
+	private async resize(imagePath: string, width: number, height: number): Promise<Jimp> {
 		const image = await Jimp.read(imagePath);
 		return image.scaleToFit(width, height);
 	}
 
 	private generateImage(background: string, width: number, height: number, outputPath: string, overlayImage?: Jimp): void {
-		//Typescript declarations for Jimp are not updated to define the constructor with backgroundColor so we workaround it by casting it to <any> for this case only.
+		// Typescript declarations for Jimp are not updated to define the constructor with backgroundColor so we workaround it by casting it to <any> for this case only.
 		const J = <any>Jimp;
 		const backgroundColor = this.getRgbaNumber(background);
 		let image = new J(width, height, backgroundColor);
@@ -73,11 +110,7 @@ export class AssetsGenerationService implements IAssetsGenerationService {
 		image.write(outputPath);
 	}
 
-	private convertToAbsolutePath(resourcesPath: string, resourcePath: string) {
-		return path.isAbsolute(resourcePath) ? resourcePath : path.join(resourcesPath, resourcePath);
-	}
-
-	private getRgbaNumber(colorString: string) : number {
+	private getRgbaNumber(colorString: string): number {
 		const color = new Color(colorString);
 		const colorRgb = color.rgb();
 		const alpha = Math.round(colorRgb.alpha() * 255);