Allow to await for mosaic to finish generating and fetch the path of the output.

dist/cli.d.ts

@@ -1 +1,2 @@
+#!/usr/bin/env node
 export {};

dist/cli.js

@@ -17,7 +17,7 @@ let checkArguments = (inputImage, tilesDirectory, thumbsReadDirectory, thumbsWri
  * Get parameters if we are executing the script directly from CLI
  */
 commander
-    .version('1.1.4')
+    .version('1.1.5')
     .option('-i, --input-image [input_image]', 'The input image path')
     .option('-d, --tiles-directory [tiles_directory]', 'The tiles directory path')
     .option('-R, --thumbs-read [thumbs_read_directory]', 'The thumbnails read directory')

dist/index.d.ts

@@ -15,5 +15,5 @@ import { MosaicImage } from './lib/mosaic-image';
  * @param thumbsDirectoryToWrite We will use this folder in order to write the generated thumbs of the tiles
  * @param enableConsoleLogging Enable console logging
  */
-export declare function mosaic(inputImagePath: string, tilesDirectory?: string, cellWidth?: number, cellHeight?: number, columns?: number, rows?: number, thumbsDirectoryFromRead?: string, thumbsDirectoryToWrite?: string, enableConsoleLogging?: boolean): void;
+export declare function mosaic(inputImagePath: string, tilesDirectory?: string, cellWidth?: number, cellHeight?: number, columns?: number, rows?: number, thumbsDirectoryFromRead?: string, thumbsDirectoryToWrite?: string, enableConsoleLogging?: boolean): Promise<any>;
 export { Image, JimpImage, MosaicImage, RGB, CONFIG };

dist/index.js

@@ -1,21 +1,23 @@
 "use strict";
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
         function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIG = exports.RGB = exports.MosaicImage = exports.JimpImage = exports.mosaic = void 0;
 const mosaic_default_config_json_1 = require("./lib/mosaic-default-config.json");
-exports.CONFIG = mosaic_default_config_json_1.CONFIG;
+Object.defineProperty(exports, "CONFIG", { enumerable: true, get: function () { return mosaic_default_config_json_1.CONFIG; } });
 const rgb_1 = require("./lib/rgb");
-exports.RGB = rgb_1.RGB;
+Object.defineProperty(exports, "RGB", { enumerable: true, get: function () { return rgb_1.RGB; } });
 const jimp_image_1 = require("./lib/jimp-image");
-exports.JimpImage = jimp_image_1.JimpImage;
+Object.defineProperty(exports, "JimpImage", { enumerable: true, get: function () { return jimp_image_1.JimpImage; } });
 const mosaic_image_1 = require("./lib/mosaic-image");
-exports.MosaicImage = mosaic_image_1.MosaicImage;
+Object.defineProperty(exports, "MosaicImage", { enumerable: true, get: function () { return mosaic_image_1.MosaicImage; } });
 const utility_1 = require("./lib/utility");
 /**
  * Generates a mosaic image
@@ -30,20 +32,27 @@ const utility_1 = require("./lib/utility");
  * @param enableConsoleLogging Enable console logging
  */
 function mosaic(inputImagePath, tilesDirectory, cellWidth, cellHeight, columns, rows, thumbsDirectoryFromRead, thumbsDirectoryToWrite, enableConsoleLogging = true) {
-    const _generateMosaic = () => __awaiter(this, void 0, void 0, function* () {
-        let [err, img] = yield utility_1.catchEm(jimp_image_1.JimpImage.read(inputImagePath));
-        if (err) {
-            console.error(err);
-        }
-        else {
-            let image = new jimp_image_1.JimpImage(img);
-            let mosaicImage = new mosaic_image_1.MosaicImage(image, tilesDirectory, cellWidth, cellHeight, columns, rows, thumbsDirectoryFromRead, thumbsDirectoryToWrite, enableConsoleLogging);
-            let [err, _] = yield utility_1.catchEm(mosaicImage.generate());
+    return __awaiter(this, void 0, void 0, function* () {
+        const _generateMosaic = () => __awaiter(this, void 0, void 0, function* () {
+            let [err, img] = yield utility_1.catchEm(jimp_image_1.JimpImage.read(inputImagePath));
             if (err) {
                 console.error(err);
+                throw err;
             }
-        }
+            else {
+                let image = new jimp_image_1.JimpImage(img);
+                let mosaicImage = new mosaic_image_1.MosaicImage(image, tilesDirectory, cellWidth, cellHeight, columns, rows, thumbsDirectoryFromRead, thumbsDirectoryToWrite, enableConsoleLogging);
+                let [err, outputImage] = yield utility_1.catchEm(mosaicImage.generate());
+                if (err) {
+                    console.error(err);
+                    throw err;
+                }
+                else {
+                    return outputImage;
+                }
+            }
+        });
+        return yield _generateMosaic();
     });
-    _generateMosaic();
 }
 exports.mosaic = mosaic;

dist/lib/jimp-image.d.ts

@@ -1,9 +1,10 @@
-/// <reference path="../../node_modules/jimp/jimp.d.ts" />
+/// <reference types="jimp/*" />
 import { Image } from './image';
 import { RGB } from './rgb';
+import * as Jimp from 'jimp';
 export declare class JimpImage implements Image {
-    image: Jimp.Jimp;
-    constructor(image: Jimp.Jimp);
+    image: Jimp;
+    constructor(image: Jimp);
     /**
      * Static method
      * Convert the image to Jimp image from path

dist/lib/jimp-image.js

@@ -1,6 +1,7 @@
 "use strict";
-/// <reference path="../node_modules/jimp/jimp.d.ts" />
+/// <reference path="../node_modules/jimp/types/ts3.1/index.d.ts" />
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.JimpImage = void 0;
 const rgb_1 = require("./rgb");
 const Jimp = require("jimp");
 const mosaic_default_config_json_1 = require("./mosaic-default-config.json");

dist/lib/mosaic-default-config.json.d.ts

@@ -1,9 +1,9 @@
 export declare var CONFIG: {
-    "tiles_directory": string;
-    "output_image_name": string;
-    "cell_width": number;
-    "cell_height": number;
-    "columns": number;
-    "rows": number;
-    "area_prevent_same_images": number;
+    tiles_directory: string;
+    output_image_name: string;
+    cell_width: number;
+    cell_height: number;
+    columns: number;
+    rows: number;
+    area_prevent_same_images: number;
 };

dist/lib/mosaic-default-config.json.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIG = void 0;
 exports.CONFIG = {
     "tiles_directory": "photos",
     "output_image_name": "outputs/output",

dist/lib/mosaic-image.d.ts

@@ -17,23 +17,23 @@ export declare class MosaicImage {
      * Recalculate columns and rows depending on the aspect ratio of the image
      * Resize the final image depending on the cell width and height, rows, columns...
      */
-    private _prepare();
+    private _prepare;
     /**
      * Helps calculate progress percentajes
      * @param currentRow
      * @param totalRows
      */
-    private _calcProgress(current, total);
+    private _calcProgress;
     /**
      * Basically reads all the tiles (pictures) from a folder, parses them as 'Image' objects and stores in the 'tiles' attribute
      * @param tilesDirectory
      */
-    private _readTiles(tilesDirectory?);
+    private _readTiles;
     /**
      * If attribute 'thumbsDirectoryFromRead' is true, it reads tiles as thumbs from the given thumbs folder
      * It does not resize them as they are supposed to be already thumbnails
      */
-    private _readThumbs();
+    private _readThumbs;
     /**
      * Saves the tiles in the 'thumbsDirectoryToWrite' folder, so we can use them later in order to save time
      */

dist/lib/mosaic-image.js

@@ -1,13 +1,15 @@
 "use strict";
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
         function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.MosaicImage = void 0;
 const mosaic_default_config_json_1 = require("./mosaic-default-config.json");
 const jimp_image_1 = require("./jimp-image");
 const fs = require("fs");
@@ -298,7 +300,7 @@ class MosaicImage {
                         console.log('Mosaic image saved! --> ' + outputImageName);
                     //Finally we generate the thumbs folder in order to save time in following executions
                     this.generateThumbs();
-                    resolve();
+                    resolve(outputImageName);
                 }
                 else {
                     reject(`Tiles were not loaded`);

dist/lib/mosaic-service.d.ts

@@ -7,8 +7,8 @@ export declare class MosaicService {
     private default_rows;
     private default_final_image_name;
     private default_tiles_dir;
-    orig_image: Jimp.Jimp;
-    image: Jimp.Jimp;
+    orig_image: Jimp;
+    image: Jimp;
     image_width: number;
     image_height: number;
     cell_width: number;
@@ -18,19 +18,19 @@ export declare class MosaicService {
     aspect_ratio: number;
     final_image_name: string;
     tiles_dir: string;
-    tiles: Jimp.Jimp[];
+    tiles: Jimp[];
     img_tiles_matrix: any[];
-    constructor(image: Jimp.Jimp, tiles_dir?: string, final_image_name?: string, cell_width?: number, cell_height?: number, columns?: number, rows?: number);
+    constructor(image: Jimp, tiles_dir?: string, final_image_name?: string, cell_width?: number, cell_height?: number, columns?: number, rows?: number);
     asyncForEach(arr: any[], cb: any): Promise<void>;
     asyncFor(n: number, cb: any): Promise<void>;
-    private _prepare();
-    readTiles(tilesDir?: string): Promise<Jimp.Jimp[]>;
-    getBestTileForImage(imageAvgColor: RGB, row: number, col: number): Promise<Jimp.Jimp>;
-    generateMosaicImage(tilesDir?: string): Promise<{}>;
+    private _prepare;
+    readTiles(tilesDir?: string): Promise<Jimp[]>;
+    getBestTileForImage(imageAvgColor: RGB, row: number, col: number): Promise<Jimp>;
+    generateMosaicImage(tilesDir?: string): Promise<void>;
     generateMosaicImage_new(tilesDir?: string): void;
-    private _generateMosaicImage(rowStart, colStart, numRows, numCols);
+    private _generateMosaicImage;
     cropImage(x: number, y: number, w: number, h: number): Jimp;
     save(imageName?: string): void;
-    private jimpRead(path);
-    getImageAvgColor(image: Jimp.Jimp, x_start: number, y_start: number, width: number, height: number): Promise<RGB>;
+    private jimpRead;
+    getImageAvgColor(image: Jimp, x_start: number, y_start: number, width: number, height: number): Promise<RGB>;
 }

dist/lib/mosaic-service.js

@@ -1,13 +1,15 @@
 "use strict";
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
         function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.MosaicService = void 0;
 const Jimp = require("jimp");
 const fs = require("fs");
 const rgb_1 = require("./rgb");

dist/lib/rgb.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.RGB = void 0;
 class RGB {
     constructor(r, g, b) {
         this.r = r;

dist/lib/utility.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.catchEm = void 0;
 function catchEm(promise) {
     return promise.then(data => [null, data]).catch(err => [err]);
 }

dist/test/ts/jimp-image.spec.js

@@ -1,9 +1,10 @@
 "use strict";
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
         function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };

dist/test/ts/mosaic-image.spec.js

@@ -1,9 +1,10 @@
 "use strict";
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
         function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };

index.ts

@@ -17,7 +17,7 @@ import { catchEm } from './lib/utility';
  * @param thumbsDirectoryToWrite We will use this folder in order to write the generated thumbs of the tiles
  * @param enableConsoleLogging Enable console logging
  */
-export function mosaic(
+export async function mosaic(
     inputImagePath: string,
     tilesDirectory?: string,
     cellWidth?: number, 
@@ -33,19 +33,23 @@ export function mosaic(
         let [err, img] = await catchEm( JimpImage.read( inputImagePath ) );
         if( err ) {
             console.error(err);
+            throw err;
         }
         else {
             let image: Image = new JimpImage( img );
             let mosaicImage = 
                 new MosaicImage( image, tilesDirectory, cellWidth, cellHeight, columns, rows, thumbsDirectoryFromRead, thumbsDirectoryToWrite, enableConsoleLogging );
-            let [err, _] = await catchEm( mosaicImage.generate() );
+            let [err, outputImage] = await catchEm( mosaicImage.generate() );
             if( err ) {
                 console.error(err);
+                throw err;
+            } else {
+                return outputImage;
             }
         }
     };
 
-    _generateMosaic();
+    return await _generateMosaic();
 }
 
 export { Image, JimpImage, MosaicImage, RGB, CONFIG };

lib/jimp-image.ts

@@ -1,4 +1,4 @@
-/// <reference path="../node_modules/jimp/jimp.d.ts" />
+/// <reference path="../node_modules/jimp/types/ts3.1/index.d.ts" />
 
 import { Image } from './image';
 import { RGB } from './rgb';
@@ -7,9 +7,9 @@ import { CONFIG } from './mosaic-default-config.json';
 
 export class JimpImage implements Image {
 
-    public image: Jimp.Jimp;
+    public image: Jimp;
 
-    constructor( image: Jimp.Jimp ) {
+    constructor( image: Jimp ) {
         this.image = image;
     }
 

lib/mosaic-image.ts

@@ -217,7 +217,7 @@ export class MosaicImage {
      * @param numCols 
      */
     public processRowsAndColumns( rowStart: number, colStart: number, numRows: number, numCols: number ): Promise<any> {
-        return new Promise( async(resolve, reject) => {
+        return new Promise<void>( async(resolve, reject) => {
             if(this.enableConsoleLogging) console.log(`${new Date().toString()} - Generating mosaic from (${rowStart}, ${colStart}) to (${rowStart + numRows}, ${colStart + numCols})`);
             for( let row = rowStart; row < numRows; row++ ) {
                 const _processColsForRow = async(): Promise<any> => {
@@ -329,7 +329,7 @@ export class MosaicImage {
                     if(this.enableConsoleLogging) console.log('Mosaic image saved! --> ' + outputImageName);
                     //Finally we generate the thumbs folder in order to save time in following executions
                     this.generateThumbs();
-                    resolve();
+                    resolve(outputImageName);
                 }
                 else {
                     reject(`Tiles were not loaded`);