askui 0.1.6 → 0.2.0

package/dist/cjs/lib/{askui-control-server.js → ui-controller.js}

@@ -9,23 +9,23 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AskuiControlServer = void 0;
-const control_ui_server_darwin_1 = require("./control-ui-server-darwin");
-const control_ui_server_linux_1 = require("./control-ui-server-linux");
-const control_ui_server_win32_1 = require("./control-ui-server-win32");
+exports.UiController = void 0;
+const ui_controller_darwin_1 = require("./ui-controller-darwin");
+const ui_controller_linux_1 = require("./ui-controller-linux");
+const ui_controller_win32_1 = require("./ui-controller-win32");
 const download_binaries_1 = require("./download-binaries");
-class AskuiControlServer {
+class UiController {
     constructor(args) {
         this.args = args;
         switch ((0, download_binaries_1.platform)()) {
             case 'darwin':
-                this.server = new control_ui_server_darwin_1.ControlUiServerDarwin();
+                this.server = new ui_controller_darwin_1.UiControllerDarwin();
                 break;
             case 'linux':
-                this.server = new control_ui_server_linux_1.ControlUiServerLinux();
+                this.server = new ui_controller_linux_1.UiControllerLinux();
                 break;
             case 'win32':
-                this.server = new control_ui_server_win32_1.ControlUiServerWin32();
+                this.server = new ui_controller_win32_1.UiControllerWin32();
                 break;
             default:
                 throw new Error(`Platform "${(0, download_binaries_1.platform)()}" not supported.`);
@@ -42,4 +42,4 @@ class AskuiControlServer {
         });
     }
 }
-exports.AskuiControlServer = AskuiControlServer;
+exports.UiController = UiController;

package/dist/cjs/lib/unkown-error.d.ts

@@ -1,4 +1,2 @@
 export declare class UnkownError extends Error {
-    contructorName: string;
-    constructor(message: string);
 }

package/dist/cjs/lib/unkown-error.js

@@ -2,10 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UnkownError = void 0;
 class UnkownError extends Error {
-    constructor(message) {
-        super(message);
-        this.contructorName = this.constructor.name;
-        this.name = this.contructorName;
-    }
 }
 exports.UnkownError = UnkownError;

package/dist/cjs/lib/wayland-error.d.ts

@@ -0,0 +1,2 @@
+export declare class WaylandError extends Error {
+}

package/dist/cjs/lib/wayland-error.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaylandError = void 0;
+class WaylandError extends Error {
+}
+exports.WaylandError = WaylandError;

package/dist/cjs/main.d.ts

@@ -1,2 +1,3 @@
-export { AskuiControlServer } from './lib';
-export { AskuiClient } from './execution';
+export { UiController } from './lib';
+export { UiControlClient, AnnotationLevel } from './execution';
+export { LogLevels } from './shared';

package/dist/cjs/main.js

@@ -1,7 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AskuiClient = exports.AskuiControlServer = void 0;
+exports.LogLevels = exports.AnnotationLevel = exports.UiControlClient = exports.UiController = void 0;
 var lib_1 = require("./lib");
-Object.defineProperty(exports, "AskuiControlServer", { enumerable: true, get: function () { return lib_1.AskuiControlServer; } });
+Object.defineProperty(exports, "UiController", { enumerable: true, get: function () { return lib_1.UiController; } });
 var execution_1 = require("./execution");
-Object.defineProperty(exports, "AskuiClient", { enumerable: true, get: function () { return execution_1.AskuiClient; } });
+Object.defineProperty(exports, "UiControlClient", { enumerable: true, get: function () { return execution_1.UiControlClient; } });
+Object.defineProperty(exports, "AnnotationLevel", { enumerable: true, get: function () { return execution_1.AnnotationLevel; } });
+var shared_1 = require("./shared");
+Object.defineProperty(exports, "LogLevels", { enumerable: true, get: function () { return shared_1.LogLevels; } });

package/dist/cjs/shared/index.d.ts

@@ -0,0 +1 @@
+export { LogLevels } from './log-levels';

package/dist/cjs/shared/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogLevels = void 0;
+var log_levels_1 = require("./log-levels");
+Object.defineProperty(exports, "LogLevels", { enumerable: true, get: function () { return log_levels_1.LogLevels; } });

package/dist/cjs/utils/analytics/analytics-interface.d.ts

@@ -0,0 +1,3 @@
+export interface AnalyticsInterface {
+    getAnalyticsHeaders(): Promise<Record<string, string>>;
+}

package/dist/cjs/utils/analytics/analytics-interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/utils/analytics/analytics.d.ts

@@ -0,0 +1,5 @@
+import { AnalyticsInterface } from './analytics-interface';
+export declare class Analytics implements AnalyticsInterface {
+    private userIdentifier;
+    getAnalyticsHeaders(): Promise<Record<string, string>>;
+}

package/dist/cjs/utils/analytics/analytics.js

@@ -0,0 +1,32 @@
+"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) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Analytics = void 0;
+const os_1 = __importDefault(require("os"));
+const user_identifier_1 = require("./user-identifier");
+class Analytics {
+    constructor() {
+        this.userIdentifier = new user_identifier_1.UserIdentifier();
+    }
+    getAnalyticsHeaders() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const userID = yield this.userIdentifier.userId();
+            return {
+                'askui-user-id': userID,
+                'askui-user-agent': `os:${os_1.default.platform()};arch:${os_1.default.arch()}`,
+            };
+        });
+    }
+}
+exports.Analytics = Analytics;

package/dist/cjs/utils/analytics/index.d.ts

@@ -0,0 +1 @@
+export { Analytics } from './analytics';

package/dist/cjs/utils/analytics/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Analytics = void 0;
+var analytics_1 = require("./analytics");
+Object.defineProperty(exports, "Analytics", { enumerable: true, get: function () { return analytics_1.Analytics; } });

package/dist/cjs/utils/analytics/user-identifier-interface.d.ts

@@ -0,0 +1,3 @@
+export interface UserIdentifierInterface {
+    userId(): Promise<string>;
+}

package/dist/cjs/utils/analytics/user-identifier-interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/utils/analytics/user-identifier.d.ts

@@ -0,0 +1,4 @@
+import { UserIdentifierInterface } from './user-identifier-interface';
+export declare class UserIdentifier implements UserIdentifierInterface {
+    userId(): Promise<string>;
+}

package/dist/cjs/utils/analytics/user-identifier.js

@@ -0,0 +1,22 @@
+"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) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserIdentifier = void 0;
+const node_machine_id_1 = require("node-machine-id");
+class UserIdentifier {
+    // eslint-disable-next-line class-methods-use-this
+    userId() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (0, node_machine_id_1.machineId)();
+        });
+    }
+}
+exports.UserIdentifier = UserIdentifier;

package/dist/cjs/utils/base_64_image/base-64-image-error.d.ts

@@ -0,0 +1,2 @@
+export declare class Base64ImageError extends Error {
+}

package/dist/cjs/utils/base_64_image/base-64-image-error.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Base64ImageError = void 0;
+class Base64ImageError extends Error {
+}
+exports.Base64ImageError = Base64ImageError;

package/dist/cjs/utils/base_64_image/base-64-image-path-error.d.ts

@@ -0,0 +1,4 @@
+import { Base64ImageError } from "./base-64-image-error";
+export declare class Base64ImagePathError extends Base64ImageError {
+    constructor(path: string);
+}

package/dist/cjs/utils/base_64_image/base-64-image-path-error.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Base64ImagePathError = void 0;
+const base_64_image_error_1 = require("./base-64-image-error");
+class Base64ImagePathError extends base_64_image_error_1.Base64ImageError {
+    constructor(path) {
+        super(`Can't create Base64Image instance from path:\n${path}\n\n` +
+            `No image exists at path.`);
+    }
+}
+exports.Base64ImagePathError = Base64ImagePathError;

package/dist/cjs/utils/base_64_image/base-64-image-string-error.d.ts

@@ -0,0 +1,4 @@
+import { Base64ImageError } from './base-64-image-error';
+export declare class Base64ImageStringError extends Base64ImageError {
+    constructor(str: string, prefix: string);
+}

package/dist/cjs/utils/base_64_image/base-64-image-string-error.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Base64ImageStringError = void 0;
+const base_64_image_error_1 = require("./base-64-image-error");
+class Base64ImageStringError extends base_64_image_error_1.Base64ImageError {
+    constructor(str, prefix) {
+        super(`Can't create Base64Image instance from string:\n${str}\n\n`
+            + `String should start with "${prefix}".`);
+    }
+}
+exports.Base64ImageStringError = Base64ImageStringError;

package/dist/cjs/utils/base_64_image/base-64-image.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+export declare class Base64Image {
+    private readonly aSharp;
+    private info;
+    private buffer;
+    static readonly strPrefix = "data:image/png;base64,";
+    private constructor();
+    private static fromSharp;
+    static fromPathOrString(pathOrStr: string): Promise<Base64Image>;
+    static fromPath(path: string): Promise<Base64Image>;
+    static fromString(str: string): Promise<Base64Image>;
+    static fromBuffer(buffer: Buffer): Promise<Base64Image>;
+    get width(): number;
+    get height(): number;
+    resizeToFitInto(dimension: number): Promise<Base64Image>;
+    toString(): string;
+    toBuffer(): Buffer;
+}

package/dist/cjs/utils/base_64_image/base-64-image.js

@@ -0,0 +1,86 @@
+"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) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Base64Image = void 0;
+const sharp_1 = __importDefault(require("sharp"));
+const base_64_image_string_error_1 = require("./base-64-image-string-error");
+class Base64Image {
+    constructor(aSharp, info, buffer) {
+        this.aSharp = aSharp;
+        this.info = info;
+        this.buffer = buffer;
+    }
+    static fromSharp(s) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { info, data } = yield s.toBuffer({ resolveWithObject: true });
+            return new Base64Image(s, info, data);
+        });
+    }
+    static fromPathOrString(pathOrStr) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield Base64Image.fromString(pathOrStr);
+            }
+            catch (error) {
+                if (!(error instanceof base_64_image_string_error_1.Base64ImageStringError)) {
+                    throw error;
+                }
+            }
+            return Base64Image.fromPath(pathOrStr);
+        });
+    }
+    static fromPath(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Base64Image.fromSharp((0, sharp_1.default)(path));
+        });
+    }
+    static fromString(str) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!str.startsWith(Base64Image.strPrefix)) {
+                throw new base_64_image_string_error_1.Base64ImageStringError(str, Base64Image.strPrefix);
+            }
+            const data = str.substring(Base64Image.strPrefix.length);
+            return Base64Image.fromSharp((0, sharp_1.default)(Buffer.from(data, 'base64')));
+        });
+    }
+    static fromBuffer(buffer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Base64Image.fromSharp((0, sharp_1.default)(buffer));
+        });
+    }
+    get width() {
+        return this.info.width;
+    }
+    get height() {
+        return this.info.height;
+    }
+    resizeToFitInto(dimension) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const buffer = yield this.aSharp.resize({
+                width: this.width >= this.height ? dimension : undefined,
+                height: this.height > this.width ? dimension : undefined,
+                fit: sharp_1.default.fit.contain,
+            }).toBuffer();
+            return Base64Image.fromBuffer(buffer);
+        });
+    }
+    toString() {
+        return `${Base64Image.strPrefix}${this.buffer.toString('base64')}`;
+    }
+    toBuffer() {
+        return this.buffer;
+    }
+}
+exports.Base64Image = Base64Image;
+Base64Image.strPrefix = 'data:image/png;base64,';

package/dist/cjs/utils/http/custom-errors/http-client-error.d.ts

@@ -1,4 +1,2 @@
 export declare class HttpClientError extends Error {
-    contructorName: string;
-    constructor(message: string);
 }

package/dist/cjs/utils/http/custom-errors/http-client-error.js

@@ -2,10 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpClientError = void 0;
 class HttpClientError extends Error {
-    constructor(message) {
-        super(message);
-        this.contructorName = this.constructor.name;
-        this.name = this.contructorName;
-    }
 }
 exports.HttpClientError = HttpClientError;

package/dist/cjs/utils/http/http-client-got.d.ts

@@ -1,11 +1,12 @@
 import { OptionsOfJSONResponseBody } from 'got';
 import { CredentialArgs } from './credentials';
 export declare class HttpClientGot {
-    private credentialArgs?;
-    private credentials;
-    constructor(credentialArgs?: CredentialArgs | undefined);
-    private get headers();
-    private injectAuthHeader;
+    readonly credentialArgs?: CredentialArgs | undefined;
+    readonly customHeaders?: Record<string, string> | undefined;
+    private headers;
+    constructor(credentialArgs?: CredentialArgs | undefined, customHeaders?: Record<string, string> | undefined);
+    private initHeaders;
+    private injectHeaders;
     post<T>(url: string, data: Record<string | number | symbol, unknown>): Promise<T>;
     get<T>(url: string, options?: OptionsOfJSONResponseBody): Promise<T>;
 }

package/dist/cjs/utils/http/http-client-got.js

@@ -17,22 +17,22 @@ const got_1 = __importDefault(require("got"));
 const credentials_1 = require("./credentials");
 const custom_errors_1 = require("./custom-errors");
 class HttpClientGot {
-    constructor(credentialArgs) {
+    constructor(credentialArgs, customHeaders) {
         this.credentialArgs = credentialArgs;
-        this.credentials = this.credentialArgs ? new credentials_1.Credentials(this.credentialArgs) : undefined;
+        this.customHeaders = customHeaders;
+        this.headers = {};
+        this.initHeaders(credentialArgs, customHeaders);
     }
-    get headers() {
-        var _a;
-        return {
-            Authorization: `Basic ${(_a = this.credentials) === null || _a === void 0 ? void 0 : _a.base64Encoded}`,
-        };
+    initHeaders(credentialArgs, customHeaders = {}) {
+        const credentials = credentialArgs ? new credentials_1.Credentials(credentialArgs) : undefined;
+        this.headers = Object.assign(Object.assign({}, (credentials ? { Authorization: `Basic ${credentials === null || credentials === void 0 ? void 0 : credentials.base64Encoded}` } : {})), customHeaders);
     }
-    injectAuthHeader(options) {
-        return this.credentials ? Object.assign(Object.assign({}, options), { headers: this.headers }) : options;
+    injectHeaders(options) {
+        return Object.assign(Object.assign({}, options), { headers: this.headers });
     }
     post(url, data) {
         return __awaiter(this, void 0, void 0, function* () {
-            const options = this.injectAuthHeader({ json: data, responseType: 'json', throwHttpErrors: false });
+            const options = this.injectHeaders({ json: data, responseType: 'json', throwHttpErrors: false });
             const { body, statusCode } = yield got_1.default.post(url, options);
             if (statusCode !== 200) {
                 throw (0, custom_errors_1.httpClientErrorHandler)(statusCode, JSON.stringify(body));
@@ -42,7 +42,7 @@ class HttpClientGot {
     }
     get(url, options = { responseType: 'json' }) {
         return __awaiter(this, void 0, void 0, function* () {
-            const response = yield got_1.default.get(url, this.injectAuthHeader(options));
+            const response = yield got_1.default.get(url, this.injectHeaders(options));
             return response.body;
         });
     }

package/dist/cjs/utils/image-resize-errors/image-resizing-base-error.d.ts

@@ -1,4 +1,2 @@
 export declare class ImageResizingError extends Error {
-    contructorName: string;
-    constructor(message: string);
 }

package/dist/cjs/utils/image-resize-errors/image-resizing-base-error.js

@@ -2,10 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ImageResizingError = void 0;
 class ImageResizingError extends Error {
-    constructor(message) {
-        super(message);
-        this.contructorName = this.constructor.name;
-        this.name = this.contructorName;
-    }
 }
 exports.ImageResizingError = ImageResizingError;

package/dist/cjs/utils/image-resize-errors/index.d.ts

@@ -1,2 +1 @@
 export { ImageResizingError } from './image-resizing-base-error';
-export { InvalidBase64Image } from './invalid-base64-image-error';

package/dist/cjs/utils/image-resize-errors/index.js

@@ -1,7 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InvalidBase64Image = exports.ImageResizingError = void 0;
+exports.ImageResizingError = void 0;
 var image_resizing_base_error_1 = require("./image-resizing-base-error");
 Object.defineProperty(exports, "ImageResizingError", { enumerable: true, get: function () { return image_resizing_base_error_1.ImageResizingError; } });
-var invalid_base64_image_error_1 = require("./invalid-base64-image-error");
-Object.defineProperty(exports, "InvalidBase64Image", { enumerable: true, get: function () { return invalid_base64_image_error_1.InvalidBase64Image; } });

package/dist/cjs/utils/transformations.d.ts

@@ -1,6 +1,4 @@
 import { ResizedImage } from './resized-image-interface';
-export declare function toBase64Image(imagePath: string): Promise<string>;
-export declare function toBase64ImageIfNeeded(pngPathOrBase64Image: string): Promise<string>;
 /**
   * Resizes a base64image only when the height or the width is bigger than the maxEdge Param,so that
   * the returned image keeps the same aspect ratio but have a max size equal to the threshold.

package/dist/cjs/utils/transformations.js

@@ -8,35 +8,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resizeBase64ImageWithSameRatio = exports.toBase64ImageIfNeeded = exports.toBase64Image = void 0;
-const fs_1 = __importDefault(require("fs"));
-const jimp_1 = require("jimp");
+exports.resizeBase64ImageWithSameRatio = void 0;
 const lib_1 = require("../lib");
+const base_64_image_1 = require("./base_64_image/base-64-image");
 const image_resize_errors_1 = require("./image-resize-errors");
-function toBase64Image(imagePath) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!(fs_1.default.existsSync(imagePath))) {
-            throw new Error(`the image ${imagePath} does not exists!`);
-        }
-        const image = yield (0, jimp_1.read)(imagePath);
-        return image.getBase64Async('image/png');
-    });
-}
-exports.toBase64Image = toBase64Image;
-function toBase64ImageIfNeeded(pngPathOrBase64Image) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const isBase64Image = pngPathOrBase64Image.startsWith('data:image');
-        if (!isBase64Image) {
-            return toBase64Image(pngPathOrBase64Image);
-        }
-        return pngPathOrBase64Image;
-    });
-}
-exports.toBase64ImageIfNeeded = toBase64ImageIfNeeded;
 /**
   * Resizes a base64image only when the height or the width is bigger than the maxEdge Param,so that
   * the returned image keeps the same aspect ratio but have a max size equal to the threshold.
@@ -50,28 +26,19 @@ exports.toBase64ImageIfNeeded = toBase64ImageIfNeeded;
 function resizeBase64ImageWithSameRatio(base64ImageString, maxEdge = 1400) {
     return __awaiter(this, void 0, void 0, function* () {
         lib_1.logger.debug('Image resizing');
-        if (!(base64ImageString.startsWith('data:image'))) {
-            Promise.reject(new image_resize_errors_1.InvalidBase64Image('Invalid base64 image string'));
-        }
         try {
-            let resizeRatio = 1;
-            const orignalImage = yield (0, jimp_1.read)(Buffer.from(base64ImageString.replace(/^data:image\/png;base64,/, ''), 'base64'));
-            const imageHeight = orignalImage.getHeight();
-            const imageWidth = orignalImage.getWidth();
-            if (Math.max(imageHeight, imageWidth) <= maxEdge) {
-                return yield Promise.resolve({ base64Image: base64ImageString, resizeRatio });
+            const image = yield base_64_image_1.Base64Image.fromString(base64ImageString);
+            if (image.height <= maxEdge && image.width <= maxEdge) {
+                return { base64Image: base64ImageString, resizeRatio: 1 };
             }
-            const imageRatio = imageHeight / imageWidth;
-            const isHeigthBiggerThanWidth = imageRatio > 1;
-            const newHeigh = isHeigthBiggerThanWidth ? maxEdge : maxEdge * imageRatio;
-            const newWidth = isHeigthBiggerThanWidth ? maxEdge / imageRatio : maxEdge;
-            const newImage = orignalImage.resize(newWidth, newHeigh);
-            resizeRatio = imageHeight / newHeigh;
-            const newImageBase64 = yield newImage.getBase64Async('image/png');
-            return yield Promise.resolve({ base64Image: newImageBase64, resizeRatio });
+            const resizedImage = yield image.resizeToFitInto(maxEdge);
+            return {
+                base64Image: resizedImage.toString(),
+                resizeRatio: image.width / resizedImage.width,
+            };
         }
         catch (error) {
-            return Promise.reject(new image_resize_errors_1.ImageResizingError(`A Problem has occured during the resizeing of the image. Error: ${error}`));
+            throw new image_resize_errors_1.ImageResizingError(`A Problem has occured during the resizing of the image. Error: ${error}`);
         }
     });
 }

package/dist/esm/core/model/test-case-dto/custom-element.d.ts

@@ -4,13 +4,13 @@ export declare class CustomElement implements CustomElementJson {
     name?: string | undefined;
     threshold?: number | undefined;
     rotationDegreePerStep?: number | undefined;
-    imageCompareFormat?: "grayscale" | "RGB" | undefined;
+    imageCompareFormat?: "RGB" | "grayscale" | undefined;
     mask?: {
         x: number;
         y: number;
     }[] | undefined;
     private static schema;
-    constructor(customImage: string, name?: string | undefined, threshold?: number | undefined, rotationDegreePerStep?: number | undefined, imageCompareFormat?: "grayscale" | "RGB" | undefined, mask?: {
+    constructor(customImage: string, name?: string | undefined, threshold?: number | undefined, rotationDegreePerStep?: number | undefined, imageCompareFormat?: "RGB" | "grayscale" | undefined, mask?: {
         x: number;
         y: number;
     }[] | undefined);

package/dist/esm/core/model/test-case-dto/custom-element.js

@@ -8,7 +8,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { array, number, object, ValidationError, } from 'yup';
-import { toBase64ImageIfNeeded } from '../../../utils/transformations';
+import { Base64Image } from '../../../utils/base_64_image/base-64-image';
 export class CustomElement {
     constructor(customImage, name, threshold, rotationDegreePerStep, imageCompareFormat, mask) {
         this.customImage = customImage;
@@ -25,7 +25,7 @@ export class CustomElement {
     }
     static fromJsonWithImagePathOrImage(ceJson) {
         return __awaiter(this, void 0, void 0, function* () {
-            const customImage = yield toBase64ImageIfNeeded(ceJson.customImage);
+            const customImage = (yield Base64Image.fromPathOrString(ceJson.customImage)).toString();
             const customElement = CustomElement.fromJson(Object.assign(Object.assign({}, ceJson), { customImage }));
             customElement.validate();
             return customElement;