askui 0.7.1 → 0.8.0

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

@@ -14,6 +14,7 @@ export declare class InferenceClient {
     isImageRequired(instruction: string): Promise<boolean>;
     private resizeIfNeeded;
     inference(customElements?: CustomElement[], image?: string, instruction?: string): Promise<ControlCommand | Annotation>;
+    private static logMetaInformation;
     predictControlCommand(instruction: string, customElements?: CustomElement[], image?: string): Promise<ControlCommand>;
     getDetectedElements(instruction: string, image: string, customElements?: CustomElement[]): Promise<DetectedElement[]>;
     predictImageAnnotation(image: string, customElements?: CustomElement[]): Promise<Annotation>;

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

@@ -13,6 +13,7 @@ import { Annotation } from '../core/annotation/annotation';
 import { resizeBase64ImageWithSameRatio } from '../utils/transformations';
 import { InferenceResponseError } from './inference-response-error';
 import { ConfigurationError } from './config-error';
+import { logger } from '../lib/logger';
 export class InferenceClient {
     constructor(baseUrl, httpClient, resize, workspaceId, apiVersion = 'v3') {
         this.baseUrl = baseUrl;
@@ -21,7 +22,9 @@ export class InferenceClient {
         this.workspaceId = workspaceId;
         this.apiVersion = apiVersion;
         const versionedBaseUrl = urljoin(this.baseUrl, 'api', this.apiVersion);
-        this.url = workspaceId ? urljoin(versionedBaseUrl, 'workspaces', workspaceId) : versionedBaseUrl;
+        this.url = workspaceId
+            ? urljoin(versionedBaseUrl, 'workspaces', workspaceId)
+            : versionedBaseUrl;
         if (this.resize !== undefined && this.resize <= 0) {
             throw new ConfigurationError(`Resize must be a positive number. The current resize value "${this.resize}" is not valid.`);
         }
@@ -30,17 +33,17 @@ export class InferenceClient {
     isImageRequired(instruction) {
         return __awaiter(this, void 0, void 0, function* () {
             const url = urljoin(this.url, 'instruction', 'is-image-required');
-            const httpBody = {
+            const requestBody = {
                 instruction,
             };
-            const httpResponse = yield this.httpClient.post(url, httpBody);
-            return httpResponse.isImageRequired;
+            const response = yield this.httpClient.post(url, requestBody);
+            return response.body.isImageRequired;
         });
     }
     // eslint-disable-next-line class-methods-use-this
     resizeIfNeeded(customElements, image) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!(image) || customElements.length > 0 || this.resize === undefined) {
+            if (!image || customElements.length > 0 || this.resize === undefined) {
                 return { base64Image: image, resizeRatio: 1 };
             }
             return resizeBase64ImageWithSameRatio(image, this.resize);
@@ -49,16 +52,22 @@ export class InferenceClient {
     inference(customElements = [], image, instruction) {
         return __awaiter(this, void 0, void 0, function* () {
             const resizedImage = yield this.resizeIfNeeded(customElements, image);
-            const httpBody = {
+            const requestBody = {
                 image: resizedImage.base64Image,
                 instruction,
                 customElements,
             };
             const url = urljoin(this.url, 'inference');
-            const httpResponse = yield this.httpClient.post(url, httpBody);
-            return InferenceResponse.fromJson(httpResponse, resizedImage.resizeRatio, image);
+            const response = yield this.httpClient.post(url, requestBody);
+            InferenceClient.logMetaInformation(response);
+            return InferenceResponse.fromJson(response.body, resizedImage.resizeRatio, image);
         });
     }
+    static logMetaInformation(response) {
+        if (response.headers['askui-usage-warnings'] !== undefined) {
+            logger.warn(response.headers['askui-usage-warnings']);
+        }
+    }
     predictControlCommand(instruction, customElements = [], image) {
         return __awaiter(this, void 0, void 0, function* () {
             const inferenceResponse = yield this.inference(customElements, image, instruction);

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

@@ -107,6 +107,7 @@ export class UiControlClient extends ApiCommands {
                     customElements,
                     secretText,
                 });
+                this.secretText = undefined;
                 yield this.annotateByDefault(TestStepState.PASSED, customElements);
                 return yield Promise.resolve();
             }

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

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import { OptionsOfJSONResponseBody } from 'got';
 import http from 'http';
 import https from 'https';
@@ -17,6 +18,9 @@ export declare class HttpClientGot {
     } | undefined);
     private initHeaders;
     private injectHeadersAndCookies;
-    post<T>(url: string, data: Record<string | number | symbol, unknown>): Promise<T>;
+    post<T>(url: string, data: Record<string | number | symbol, unknown>): Promise<{
+        headers: http.IncomingHttpHeaders;
+        body: T;
+    }>;
     get<T>(url: string, options?: OptionsOfJSONResponseBody): Promise<T>;
 }

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

@@ -24,18 +24,26 @@ export class HttpClientGot {
     }
     initHeaders(token, customHeaders = {}) {
         const credentials = token ? new Credentials(token) : undefined;
-        this.headers = Object.assign(Object.assign({}, (credentials ? { Authorization: `Basic ${credentials === null || credentials === void 0 ? void 0 : credentials.base64Encoded}` } : {})), customHeaders);
+        this.headers = Object.assign(Object.assign({}, (credentials
+            ? { Authorization: `Basic ${credentials === null || credentials === void 0 ? void 0 : credentials.base64Encoded}` }
+            : {})), customHeaders);
     }
     injectHeadersAndCookies(url, options) {
         const cookieJar = new CookieJar();
-        Object.keys(this.cookies).map((key) => `${key}=${this.cookies[key]}`).forEach((cookie) => {
+        Object.keys(this.cookies)
+            .map((key) => `${key}=${this.cookies[key]}`)
+            .forEach((cookie) => {
             cookieJar.setCookieSync(cookie, url);
         });
         return Object.assign(Object.assign({}, options), { headers: this.headers, cookieJar });
     }
     post(url, data) {
         return __awaiter(this, void 0, void 0, function* () {
-            const options = this.injectHeadersAndCookies(url, { json: data, responseType: 'json', throwHttpErrors: false });
+            const options = this.injectHeadersAndCookies(url, {
+                json: data,
+                responseType: 'json',
+                throwHttpErrors: false,
+            });
             const { body, statusCode, headers } = yield this.askuiGot.post(url, options);
             if (headers['deprecation'] !== undefined) {
                 logger.warn(headers['deprecation']);
@@ -43,7 +51,7 @@ export class HttpClientGot {
             if (statusCode !== 200) {
                 throw httpClientErrorHandler(statusCode, JSON.stringify(body));
             }
-            return body;
+            return { headers, body };
         });
     }
     get(url, options = { responseType: 'json' }) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "askui",
-    "version": "0.7.1",
+    "version": "0.8.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",