askui 0.30.0 → 0.31.0

package/dist/esm/execution/dsl.js

@@ -3,6 +3,15 @@
 /* eslint-disable max-classes-per-file */
 /* eslint-disable max-len */
 // Autogenerated from typescript.template file
+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());
+    });
+};
 function isStackTraceCodeline(line) {
     return /[ \t]+at .+/.test(line);
 }
@@ -14,21 +23,18 @@ function splitStackTrace(stacktrace) {
     return { head: errorStacktraceHead, codelines: errorStacktraceCodeLines };
 }
 function rewriteStackTraceForError(error, newStackTrace) {
-    const errorCopy = new Error(error.message);
-    if (!error.stack) {
-        errorCopy.stack = newStackTrace;
-        return errorCopy;
-    }
-    const errorStacktraceSplit = splitStackTrace(error.stack);
+    var _a;
+    const errorStacktraceSplit = splitStackTrace((_a = error.stack) !== null && _a !== void 0 ? _a : '');
     const newStacktraceSplit = splitStackTrace(newStackTrace);
-    errorCopy.stack = [
+    // eslint-disable-next-line no-param-reassign
+    error.stack = [
         ...errorStacktraceSplit.head,
         ...newStacktraceSplit.codelines,
         ' ',
         ...errorStacktraceSplit.head,
         ...errorStacktraceSplit.codelines,
     ].join('\n');
-    return errorCopy;
+    return error;
 }
 export var Separators;
 (function (Separators) {
@@ -52,7 +58,7 @@ class FluentBase {
         });
         return paramsList;
     }
-    fluentCommandStringBuilder(modelComposition, currentInstruction = '', paramsList = new Map()) {
+    fluentCommandStringBuilder(modelComposition = [], skipCache = false, retryStrategy, currentInstruction = '', paramsList = new Map()) {
         const newCurrentInstruction = `${this.textStr} ${currentInstruction}`;
         const newParamsList = FluentBase.addParams(paramsList, this._params);
         if (this instanceof FluentCommand) {
@@ -62,12 +68,12 @@ class FluentBase {
             return fluentCommand.fluentCommandExecutor(newCurrentInstruction.trim(), modelComposition, {
                 customElementsJson: customElements,
                 aiElementNames,
-            });
+            }, skipCache, retryStrategy);
         }
         if (!this.prev) {
             throw new Error('Prev element not defined');
         }
-        return this.prev.fluentCommandStringBuilder(modelComposition, newCurrentInstruction, newParamsList);
+        return this.prev.fluentCommandStringBuilder(modelComposition, skipCache, retryStrategy, newCurrentInstruction, newParamsList);
     }
     getterStringBuilder(currentInstruction = '', paramsList = new Map()) {
         const newCurrentInstruction = `${this.textStr} ${currentInstruction}`;
@@ -90,10 +96,10 @@ class FluentBase {
     get params() { return this._params; }
 }
 export class Exec extends FluentBase {
-    exec(modelComposition = []) {
+    exec(execOptions) {
         const originStacktrace = { stack: '' };
         Error.captureStackTrace(originStacktrace, this.exec);
-        return this.fluentCommandStringBuilder(modelComposition).catch((err) => Promise.reject(rewriteStackTraceForError(err, originStacktrace.stack)));
+        return this.fluentCommandStringBuilder(execOptions === null || execOptions === void 0 ? void 0 : execOptions.modelComposition, execOptions === null || execOptions === void 0 ? void 0 : execOptions.skipCache, execOptions === null || execOptions === void 0 ? void 0 : execOptions.retryStrategy).catch((err) => Promise.reject(rewriteStackTraceForError(err, originStacktrace.stack)));
     }
 }
 // Filters
@@ -1043,10 +1049,10 @@ export class FluentFiltersOrRelations extends FluentFilters {
         this._textStr += 'contains';
         return new FluentFilters(this);
     }
-    exec(modelComposition = []) {
+    exec(execOptions) {
         const originStacktrace = { stack: '' };
         Error.captureStackTrace(originStacktrace, this.exec);
-        return this.fluentCommandStringBuilder(modelComposition).catch((err) => Promise.reject(rewriteStackTraceForError(err, originStacktrace.stack)));
+        return this.fluentCommandStringBuilder(execOptions === null || execOptions === void 0 ? void 0 : execOptions.modelComposition, execOptions === null || execOptions === void 0 ? void 0 : execOptions.skipCache, execOptions === null || execOptions === void 0 ? void 0 : execOptions.retryStrategy).catch((err) => Promise.reject(rewriteStackTraceForError(err, originStacktrace.stack)));
     }
 }
 // Filters
@@ -2055,6 +2061,15 @@ export class FluentFiltersOrRelationsCondition extends FluentFiltersCondition {
     }
 }
 class ExecCondition extends Exec {
+    exec(execOptions) {
+        const _super = Object.create(null, {
+            exec: { get: () => super.exec }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const options = Object.assign(Object.assign({}, execOptions), { skipCache: true });
+            return _super.exec.call(this, options);
+        });
+    }
 }
 // Commands
 export class FluentCommand extends FluentBase {

package/dist/esm/execution/execution-runtime.d.ts

@@ -21,7 +21,7 @@ export declare class ExecutionRuntime {
     stopVideoRecording(): Promise<void>;
     readVideoRecording(): Promise<string>;
     requestControl(controlCommand: ControlCommand): Promise<void>;
-    executeInstruction(instruction: Instruction, modelComposition: ModelCompositionBranch[]): Promise<void>;
+    executeInstruction(instruction: Instruction, modelComposition: ModelCompositionBranch[], skipCache?: boolean, retryStrategy?: RetryStrategy): Promise<void>;
     private readonly EXEC_REPETITION_COUNT;
     private executeCommandRepeatedly;
     /**

package/dist/esm/execution/execution-runtime.js

@@ -25,10 +25,12 @@ export class ExecutionRuntime {
     }
     connect() {
         return __awaiter(this, void 0, void 0, function* () {
+            this.inferenceClient.cacheManager.loadFromFile();
             return this.uiControllerClient.connect();
         });
     }
     disconnect() {
+        this.inferenceClient.cacheManager.saveToFile();
         this.uiControllerClient.disconnect();
     }
     startVideoRecording() {
@@ -52,10 +54,10 @@ export class ExecutionRuntime {
             yield this.uiControllerClient.requestControl(controlCommand);
         });
     }
-    executeInstruction(instruction, modelComposition) {
-        return __awaiter(this, void 0, void 0, function* () {
+    executeInstruction(instruction_1, modelComposition_1) {
+        return __awaiter(this, arguments, void 0, function* (instruction, modelComposition, skipCache = false, retryStrategy) {
             var _a, _b, _c;
-            const controlCommand = yield this.predictCommandWithRetry(instruction, modelComposition);
+            const controlCommand = yield this.predictCommandWithRetry(instruction, modelComposition, skipCache, retryStrategy);
             if (controlCommand.code === ControlCommandCode.OK) {
                 return this.requestControl(controlCommand);
             }
@@ -95,19 +97,20 @@ export class ExecutionRuntime {
      * --> retry with linear back-off
      */
     /* eslint-disable-next-line consistent-return */
-    predictCommandWithRetry(instruction, modelComposition) {
-        return __awaiter(this, void 0, void 0, function* () {
+    predictCommandWithRetry(instruction_1, modelComposition_1) {
+        return __awaiter(this, arguments, void 0, function* (instruction, modelComposition, skipCache = false, retryStrategy) {
             var _a, _b, _c;
-            let command = yield this.predictCommand(instruction, modelComposition);
+            const strategy = retryStrategy !== null && retryStrategy !== void 0 ? retryStrategy : this.retryStrategy;
+            let command = yield this.predictCommand(instruction, modelComposition, skipCache);
             /* eslint-disable no-await-in-loop */
-            for (let k = 0; k < this.retryStrategy.retryCount; k += 1) {
+            for (let k = 0; k < strategy.retryCount; k += 1) {
                 if (command.code === ControlCommandCode.OK) {
                     return command;
                 }
-                const msUntilRetry = this.retryStrategy.getDelay(k + 1);
-                logger.debug(`Wait ${msUntilRetry} and retry predicting command...`);
+                const msUntilRetry = strategy.getDelay(k + 1);
+                logger.debug(`Wait ${msUntilRetry} and retry ${k + 1}/${strategy.retryCount} predicting command...`);
                 yield delay(msUntilRetry);
-                command = yield this.predictCommand(instruction, modelComposition, new ControlCommandError((_c = (_b = (_a = command.actions) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.text) !== null && _c !== void 0 ? _c : ''));
+                command = yield this.predictCommand(instruction, modelComposition, skipCache, new ControlCommandError((_c = (_b = (_a = command.actions) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.text) !== null && _c !== void 0 ? _c : ''));
             }
             /* eslint-enable no-await-in-loop */
             return command;
@@ -117,11 +120,11 @@ export class ExecutionRuntime {
         return this.stepReporter.config.withScreenshots === 'begin'
             || this.stepReporter.config.withScreenshots === 'always';
     }
-    isImageRequired(instruction) {
+    isImageRequired(instruction, customElements) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.isImageRequiredByConfig())
                 return Promise.resolve(true);
-            return this.inferenceClient.isImageRequired(instruction);
+            return this.inferenceClient.isImageRequired(instruction, customElements);
         });
     }
     isAnnotationRequired() {
@@ -136,8 +139,9 @@ export class ExecutionRuntime {
     }
     buildSnapshot(instruction) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a;
             const createdAt = new Date();
-            const screenshot = (yield this.isImageRequired(instruction))
+            const screenshot = (yield this.isImageRequired(instruction.value, (_a = instruction.customElements) !== null && _a !== void 0 ? _a : []))
                 ? yield this.getScreenshot() : undefined;
             const annotation = this.isAnnotationRequired() ? yield this.annotateImage() : undefined;
             return {
@@ -147,14 +151,14 @@ export class ExecutionRuntime {
             };
         });
     }
-    predictCommand(instruction, modelComposition, retryError) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const snapshot = yield this.buildSnapshot(instruction.value);
+    predictCommand(instruction_1, modelComposition_1) {
+        return __awaiter(this, arguments, void 0, function* (instruction, modelComposition, skipCache = false, retryError) {
+            const snapshot = yield this.buildSnapshot(instruction);
             if (retryError !== undefined)
                 this.stepReporter.onStepRetry(snapshot, retryError);
             else
                 this.stepReporter.onStepBegin(snapshot);
-            const controlCommand = yield this.inferenceClient.predictControlCommand(instruction.value, modelComposition, instruction.customElements, snapshot.screenshot);
+            const controlCommand = yield this.inferenceClient.predictControlCommand(instruction.value, modelComposition, instruction.customElements, snapshot.screenshot, skipCache);
             if (instruction.secretText !== undefined) {
                 controlCommand.setTextToBeTyped(instruction.secretText);
             }

package/dist/esm/execution/inference-client.d.ts

@@ -6,21 +6,23 @@ import { Annotation } from '../core/annotation/annotation';
 import { DetectedElement } from '../core/model/annotation-result/detected-element';
 import { VQAInferenceResponseBody } from '../core/inference-response/inference-response';
 import { ModelCompositionBranch } from './model-composition-branch';
+import { CacheInterface } from '../core/cache';
 export declare class InferenceClient {
     private readonly baseUrl;
     private readonly httpClient;
+    readonly cacheManager: CacheInterface;
     private readonly resize?;
     readonly workspaceId?: string | undefined;
     readonly modelComposition?: ModelCompositionBranch[] | undefined;
     private readonly apiVersion;
     private urls;
-    constructor(baseUrl: string, httpClient: HttpClientGot, resize?: number | undefined, workspaceId?: string | undefined, modelComposition?: ModelCompositionBranch[] | undefined, apiVersion?: string);
-    isImageRequired(instruction: string): Promise<boolean>;
+    constructor(baseUrl: string, httpClient: HttpClientGot, cacheManager: CacheInterface, resize?: number | undefined, workspaceId?: string | undefined, modelComposition?: ModelCompositionBranch[] | undefined, apiVersion?: string);
+    isImageRequired(instruction: string, customElements: CustomElement[]): Promise<boolean>;
     private resizeIfNeeded;
     inference(customElements?: CustomElement[], image?: string, instruction?: string, modelComposition?: ModelCompositionBranch[]): Promise<ControlCommand | Annotation>;
     vqaInference(image: string, prompt: string, config?: object): Promise<VQAInferenceResponseBody>;
     private static logMetaInformation;
-    predictControlCommand(instruction: string, modelComposition: ModelCompositionBranch[], customElements?: CustomElement[], image?: string): Promise<ControlCommand>;
+    predictControlCommand(instruction: string, modelComposition: ModelCompositionBranch[], customElements?: CustomElement[], image?: string, skipCache?: boolean): Promise<ControlCommand>;
     getDetectedElements(instruction: string, image: string, customElements?: CustomElement[]): Promise<DetectedElement[]>;
     predictImageAnnotation(image: string, customElements?: CustomElement[]): Promise<Annotation>;
     predictVQAAnswer(prompt: string, image: string, config?: object): Promise<any>;

package/dist/esm/execution/inference-client.js

@@ -14,10 +14,12 @@ import { resizeBase64ImageWithSameRatio } from '../utils/transformations';
 import { InferenceResponseError } from './inference-response-error';
 import { ConfigurationError } from './config-error';
 import { logger } from '../lib/logger';
+import { ControlCommandCode } from '../core/ui-control-commands/control-command-code';
 export class InferenceClient {
-    constructor(baseUrl, httpClient, resize, workspaceId, modelComposition, apiVersion = 'v1') {
+    constructor(baseUrl, httpClient, cacheManager, resize, workspaceId, modelComposition, apiVersion = 'v1') {
         this.baseUrl = baseUrl;
         this.httpClient = httpClient;
+        this.cacheManager = cacheManager;
         this.resize = resize;
         this.workspaceId = workspaceId;
         this.modelComposition = modelComposition;
@@ -38,8 +40,13 @@ export class InferenceClient {
         }
         this.resize = this.resize ? Math.ceil(this.resize) : this.resize;
     }
-    isImageRequired(instruction) {
+    isImageRequired(instruction, customElements) {
         return __awaiter(this, void 0, void 0, function* () {
+            const cachedImageRequired = this.cacheManager.isImageRequired(instruction, customElements);
+            if (cachedImageRequired !== undefined) {
+                logger.debug(`Cache hit for image required: '${instruction}'.`);
+                return Promise.resolve(cachedImageRequired);
+            }
             const response = yield this.httpClient.post(this.urls.isImageRequired, {
                 instruction,
             });
@@ -90,11 +97,23 @@ export class InferenceClient {
         }
     }
     predictControlCommand(instruction_1, modelComposition_1) {
-        return __awaiter(this, arguments, void 0, function* (instruction, modelComposition, customElements = [], image) {
+        return __awaiter(this, arguments, void 0, function* (instruction, modelComposition, customElements = [], image, skipCache = false) {
+            if (!skipCache) {
+                const cachedControlCommand = yield this.cacheManager.getCachedControlCommand(instruction, customElements, image);
+                if (cachedControlCommand !== undefined) {
+                    logger.debug(`Cache hit for instruction: '${instruction}'.`);
+                    return Promise.resolve(cachedControlCommand);
+                }
+                logger.debug(`Cache miss for instruction: '${instruction}'.`);
+            }
             const inferenceResponse = yield this.inference(customElements, image, instruction, modelComposition);
             if (!(inferenceResponse instanceof ControlCommand)) {
                 throw new InferenceResponseError('Internal Error. Can not execute command');
             }
+            if (!skipCache && inferenceResponse.code === ControlCommandCode.OK) {
+                yield this.cacheManager.addCacheEntryFromControlCommand(instruction, inferenceResponse, customElements, image);
+                logger.debug(`Cache added for instruction: '${instruction}'`);
+            }
             return inferenceResponse;
         });
     }

package/dist/esm/execution/ui-control-client-dependency-builder.js

@@ -17,6 +17,7 @@ import { ExecutionRuntime } from './execution-runtime';
 import { StepReporter } from '../core/reporting';
 import { readCredentials } from './read-credentials';
 import { LinearRetryStrategy } from './retry-strategies/linear-retry-strategy';
+import { CacheManager, DummyCacheManager } from '../core/cache';
 export class UiControlClientDependencyBuilder {
     static buildHttpClient(clientArgs) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -31,7 +32,11 @@ export class UiControlClientDependencyBuilder {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
             const httpClient = yield UiControlClientDependencyBuilder.buildHttpClient(clientArgs);
-            return new InferenceClient(clientArgs.inferenceServerUrl, httpClient, clientArgs.resize, (_a = clientArgs.credentials) === null || _a === void 0 ? void 0 : _a.workspaceId, clientArgs.modelComposition, clientArgs.inferenceServerApiVersion);
+            let cacheManager = new DummyCacheManager();
+            if (clientArgs.cacheConfig) {
+                cacheManager = new CacheManager(clientArgs.cacheConfig);
+            }
+            return new InferenceClient(clientArgs.inferenceServerUrl, httpClient, cacheManager, clientArgs.resize, (_a = clientArgs.credentials) === null || _a === void 0 ? void 0 : _a.workspaceId, clientArgs.modelComposition, clientArgs.inferenceServerApiVersion);
         });
     }
     static buildUiControllerClient(clientArgs) {

package/dist/esm/execution/ui-control-client.d.ts

@@ -5,6 +5,7 @@ import { AnnotationRequest } from '../core/model/annotation-result/annotation-in
 import { DetectedElement } from '../core/model/annotation-result/detected-element';
 import { ClientArgs } from './ui-controller-client-interface';
 import { ModelCompositionBranch } from './model-composition-branch';
+import { RetryStrategy } from './retry-strategies';
 import { AskUIAgent, AgentHistory, ActOptions } from '../core/models/anthropic';
 export type RelationsForConvenienceMethods = 'nearestTo' | 'leftOf' | 'above' | 'rightOf' | 'below' | 'contains';
 export type TextMatchingOption = 'similar' | 'exact' | 'regex';
@@ -62,7 +63,7 @@ export declare class UiControlClient extends ApiCommands {
     private escapeSeparatorString;
     private buildInstruction;
     private getAIElementsByNames;
-    fluentCommandExecutor(instructionString: string, modelComposition: ModelCompositionBranch[], context?: CommandExecutorContext): Promise<void>;
+    fluentCommandExecutor(instructionString: string, modelComposition: ModelCompositionBranch[], context?: CommandExecutorContext, skipCache?: boolean, retryStrategy?: RetryStrategy): Promise<void>;
     getterExecutor(instruction: string, context?: CommandExecutorContext): Promise<DetectedElement[]>;
     /**
      * Takes a prompt that contains a question you want to be answered

package/dist/esm/execution/ui-control-client.js

@@ -15,6 +15,7 @@ import { logger } from '../lib/logger';
 import { UiControlClientDependencyBuilder } from './ui-control-client-dependency-builder';
 import { AIElementCollection } from '../core/ai-element/ai-element-collection';
 import { NoRetryStrategy } from './retry-strategies';
+import { ControlCommandError } from './control-command-error';
 import { AskUIAgent } from '../core/models/anthropic';
 import { AskUIGetAskUIElementTool, AskUIListAIElementTool } from '../core/models/anthropic/tools/askui-api-tools';
 export class UiControlClient extends ApiCommands {
@@ -157,7 +158,7 @@ export class UiControlClient extends ApiCommands {
         });
     }
     fluentCommandExecutor(instructionString_1, modelComposition_1) {
-        return __awaiter(this, arguments, void 0, function* (instructionString, modelComposition, context = { customElementsJson: [], aiElementNames: [] }) {
+        return __awaiter(this, arguments, void 0, function* (instructionString, modelComposition, context = { customElementsJson: [], aiElementNames: [] }, skipCache = false, retryStrategy) {
             const aiElements = yield this.getAIElementsByNames(context.aiElementNames);
             const instruction = yield this.buildInstruction(instructionString, [
                 ...context.customElementsJson,
@@ -166,7 +167,7 @@ export class UiControlClient extends ApiCommands {
             logger.debug(instruction);
             try {
                 this.stepReporter.resetStep(instruction);
-                yield this.executionRuntime.executeInstruction(instruction, modelComposition);
+                yield this.executionRuntime.executeInstruction(instruction, modelComposition, skipCache, retryStrategy);
                 yield this.afterCommandExecution(instruction);
                 return yield Promise.resolve();
             }
@@ -450,18 +451,34 @@ export class UiControlClient extends ApiCommands {
      */
     waitUntil(AskUICommand_1) {
         return __awaiter(this, arguments, void 0, function* (AskUICommand, maxTry = 5, waitTime = 2000) {
+            logger.debug(`waitUntil: Starting with maxTry=${maxTry}, waitTime=${waitTime}ms, retryStrategy=${this.executionRuntime.retryStrategy.constructor.name}`);
             const userDefinedStrategy = this.executionRuntime.retryStrategy;
-            try {
-                this.executionRuntime.retryStrategy = new NoRetryStrategy();
-                yield AskUICommand.exec();
-                this.executionRuntime.retryStrategy = userDefinedStrategy;
-            }
-            catch (error) {
-                if (maxTry === 0) {
+            this.executionRuntime.retryStrategy = new NoRetryStrategy();
+            const attempt = (retriesLeft) => __awaiter(this, void 0, void 0, function* () {
+                const attemptNumber = maxTry - retriesLeft;
+                logger.debug(`waitUntil: Attempt ${attemptNumber}/${maxTry} (${retriesLeft} retries remaining)`);
+                try {
+                    yield AskUICommand.exec();
+                    logger.debug(`waitUntil: Command succeeded on attempt ${attemptNumber}/${maxTry}`);
+                    return;
+                }
+                catch (error) {
+                    if (error instanceof ControlCommandError && retriesLeft > 0) {
+                        logger.debug(`waitUntil: ControlCommandError on attempt ${attemptNumber}/${maxTry}, waiting ${waitTime}ms before retry.`, error);
+                        yield this.waitFor(waitTime).exec();
+                        yield attempt(retriesLeft - 1);
+                        return;
+                    }
+                    const errorName = error instanceof Error ? error.name : 'Error';
+                    logger.debug(`waitUntil: ${errorName} on attempt ${attemptNumber}/${maxTry}, no retries remaining.`, error);
                     throw error;
                 }
-                yield this.waitFor(waitTime).exec();
-                yield this.waitUntil(AskUICommand, maxTry - 1, waitTime);
+            });
+            try {
+                yield attempt(maxTry - 1);
+            }
+            finally {
+                this.executionRuntime.retryStrategy = userDefinedStrategy;
             }
         });
     }

package/dist/esm/execution/ui-controller-client-interface.d.ts

@@ -5,6 +5,7 @@ import { Reporter } from '../core/reporting';
 import { Context } from './context';
 import { RetryStrategy } from './retry-strategies/retry-strategy';
 import { AIElementArgs } from '../core/ai-element/ai-elements-args';
+import { CacheConfig } from '../core/cache';
 /**
  * Context object to provide additional information about the context of (test) automation.
  *
@@ -63,6 +64,7 @@ export interface ClientArgs {
     readonly inferenceServerApiVersion?: string;
     readonly retryStrategy?: RetryStrategy;
     readonly aiElementArgs?: AIElementArgs;
+    readonly cacheConfig?: CacheConfig;
 }
 export interface ClientArgsWithDefaults extends ClientArgs {
     readonly uiControllerUrl: string;

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

@@ -12,5 +12,7 @@ export declare class Base64Image {
     getInfo(): Promise<sharp.OutputInfo>;
     resizeToFitInto(dimension: number): Promise<Base64Image>;
     resizeWithSameAspectRatio(width: number, height: number): Promise<Base64Image>;
+    cropRegion(x: number, y: number, croppedWidth: number, croppedHeight: number): Promise<Base64Image>;
     toString(withPrefix?: boolean): string;
+    toBuffer(): Buffer;
 }

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

@@ -61,11 +61,12 @@ export class Base64Image {
     resizeToFitInto(dimension) {
         return __awaiter(this, void 0, void 0, function* () {
             const { width, height } = yield this.getInfo();
+            const roundedDimension = Math.round(dimension);
             const buffer = yield (yield this.getSharp())
                 .resize({
                 fit: 'contain',
-                height: height > width ? dimension : undefined,
-                width: width >= height ? dimension : undefined,
+                height: height > width ? roundedDimension : undefined,
+                width: width >= height ? roundedDimension : undefined,
             })
                 .toBuffer();
             return Base64Image.fromBuffer(buffer);
@@ -73,11 +74,30 @@ export class Base64Image {
     }
     resizeWithSameAspectRatio(width, height) {
         return __awaiter(this, void 0, void 0, function* () {
+            const roundedWidth = Math.round(width);
+            const roundedHeight = Math.round(height);
             const buffer = yield (yield this.getSharp())
                 .resize({
                 fit: 'contain',
-                height,
-                width,
+                height: roundedHeight,
+                width: roundedWidth,
+            })
+                .toBuffer();
+            return Base64Image.fromBuffer(buffer);
+        });
+    }
+    cropRegion(x, y, croppedWidth, croppedHeight) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const roundedX = Math.round(x);
+            const roundedY = Math.round(y);
+            const roundedCroppedWidth = Math.round(croppedWidth);
+            const roundedCroppedHeight = Math.round(croppedHeight);
+            const buffer = yield (yield this.getSharp())
+                .extract({
+                height: roundedCroppedHeight,
+                left: roundedX,
+                top: roundedY,
+                width: roundedCroppedWidth,
             })
                 .toBuffer();
             return Base64Image.fromBuffer(buffer);
@@ -89,5 +109,8 @@ export class Base64Image {
         }
         return this.buffer.toString('base64');
     }
+    toBuffer() {
+        return this.buffer;
+    }
 }
 Base64Image.strPrefix = 'data:image/png;base64,';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "askui",
-    "version": "0.30.0",
+    "version": "0.31.0",
     "license": "MIT",
     "author": "askui GmbH <info@askui.com> (http://www.askui.com/)",
     "description": "Reliable, automated end-to-end-testing that depends on what is shown on your screen instead of the technology you are running on",