askui 0.2.0 → 0.2.1

package/dist/esm/core/ui-control-commands/control-command.js

@@ -1,5 +1,6 @@
 import { Action } from './action';
 import { ControlCommandCode } from './control-command-code';
+import { InputEvent } from './input-event';
 export class ControlCommand {
     constructor(code, actions, tryToRepeat = false) {
         this.code = code;
@@ -9,4 +10,8 @@ export class ControlCommand {
     static fromJson(json, resizeRatio = 1) {
         return new ControlCommand(ControlCommandCode[json.code], json.actions.map((action) => Action.fromJson(action, resizeRatio)), json.tryToRepeat);
     }
+    setTextToBeTyped(text) {
+        this.actions = this.actions.map((action) => ([InputEvent.TYPE, InputEvent.TYPE_TEXT].includes(action.inputEvent)
+            ? new Action(action.inputEvent, action.position, text) : action));
+    }
 }

package/dist/esm/core/ui-control-commands/input-event.d.ts

@@ -16,6 +16,5 @@ export declare enum InputEvent {
     MOUSE_MOVE = "MOUSE_MOVE",
     MOUSE_DOWN = "MOUSE_DOWN",
     MOUSE_UP = "MOUSE_UP",
-    EXECUTE_COMMAND = "EXECUTE_COMMAND",
-    WAIT = "WAIT"
+    EXECUTE_COMMAND = "EXECUTE_COMMAND"
 }

package/dist/esm/core/ui-control-commands/input-event.js

@@ -18,5 +18,4 @@ export var InputEvent;
     InputEvent["MOUSE_DOWN"] = "MOUSE_DOWN";
     InputEvent["MOUSE_UP"] = "MOUSE_UP";
     InputEvent["EXECUTE_COMMAND"] = "EXECUTE_COMMAND";
-    InputEvent["WAIT"] = "WAIT";
 })(InputEvent || (InputEvent = {}));

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

@@ -8,6 +8,7 @@ export declare class ExecutionRuntime {
     private inferenceClient;
     constructor(uiControllerClient: UiControllerClient, inferenceClient: InferenceClient);
     executeTestStep(step: TestStep): Promise<void>;
+    private requestControl;
     /**
      * @param {TestStep} step - Test step used for predicting command.
      */
@@ -20,6 +21,7 @@ export declare class ExecutionRuntime {
      * --> retry with linear back-off
      */
     private predictCommandWithRetry;
+    private getImageIfRequired;
     private predictCommand;
     annotateInteractively(): Promise<void>;
     takeScreenshotIfImageisNotProvided(imagePath?: string): Promise<string>;

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

@@ -27,6 +27,11 @@ export class ExecutionRuntime {
             yield this.executeCommand(step);
         });
     }
+    requestControl(controlCommand) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.uiControllerClient.requestControl(controlCommand);
+        });
+    }
     /**
      * @param {TestStep} step - Test step used for predicting command.
      */
@@ -35,15 +40,13 @@ export class ExecutionRuntime {
         return __awaiter(this, void 0, void 0, function* () {
             const controlCommand = yield this.predictCommandWithRetry(step);
             if (controlCommand.code === ControlCommandCode.OK) {
-                yield this.uiControllerClient.requestControl(controlCommand);
+                return this.requestControl(controlCommand);
             }
-            else if (controlCommand.tryToRepeat) {
-                yield this.uiControllerClient.requestControl(controlCommand);
-                this.executeCommandRepeatedly(step);
-            }
-            else {
-                throw new ControlCommandError(((_a = controlCommand.actions[0]) === null || _a === void 0 ? void 0 : _a.text) || '');
+            if (controlCommand.tryToRepeat) {
+                yield this.requestControl(controlCommand);
+                return this.executeCommandRepeatedly(step);
             }
+            throw new ControlCommandError(((_a = controlCommand.actions[0]) === null || _a === void 0 ? void 0 : _a.text) || '');
         });
     }
     executeCommandRepeatedly(step) {
@@ -60,8 +63,8 @@ export class ExecutionRuntime {
                 if (controlCommand.code === ControlCommandCode.OK) {
                     break;
                 }
-                else if (controlCommand.tryToRepeat) {
-                    yield this.uiControllerClient.requestControl(controlCommand);
+                if (controlCommand.tryToRepeat) {
+                    yield this.requestControl(controlCommand);
                 }
                 else {
                     throw new ControlCommandError(((_a = controlCommand.actions[0]) === null || _a === void 0 ? void 0 : _a.text) || '');
@@ -91,15 +94,24 @@ export class ExecutionRuntime {
             return command;
         });
     }
+    getImageIfRequired(instruction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const isImageRequired = yield this.inferenceClient.isImageRequired(instruction);
+            if (!isImageRequired) {
+                return undefined;
+            }
+            const screenshotResponse = yield this.uiControllerClient.requestScreenshot();
+            return screenshotResponse.data.image;
+        });
+    }
     predictCommand(step) {
         return __awaiter(this, void 0, void 0, function* () {
-            const isImageRequired = yield this.inferenceClient.isImageRequired(step.instruction);
-            let image;
-            if (isImageRequired) {
-                const screenshotResponse = yield this.uiControllerClient.requestScreenshot();
-                image = screenshotResponse.data.image;
+            const image = yield this.getImageIfRequired(step.instruction);
+            const controlCommand = yield this.inferenceClient.predictControlCommand(step.instruction, step.customElements, image);
+            if (step.secretText !== undefined) {
+                controlCommand.setTextToBeTyped(step.secretText);
             }
-            return this.inferenceClient.predictControlCommand(step.instruction, step.customElements, image);
+            return controlCommand;
         });
     }
     annotateInteractively() {

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

@@ -8,6 +8,6 @@ export declare class InferenceClient {
     constructor(url: string, httpClient: HttpClientGot);
     isImageRequired(instruction: string): Promise<boolean>;
     private resizeIfNeeded;
-    predictControlCommand(instruction: string, customElements: CustomElement[], image?: string): Promise<ControlCommand>;
+    predictControlCommand(instruction: string, customElements?: CustomElement[], image?: string): Promise<ControlCommand>;
     predictImageAnnotation(image: string, customElements?: CustomElement[]): Promise<Annotation>;
 }

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

@@ -35,7 +35,7 @@ export class InferenceClient {
             return resizeBase64ImageWithSameRatio(image);
         });
     }
-    predictControlCommand(instruction, customElements, image) {
+    predictControlCommand(instruction, customElements = [], image) {
         return __awaiter(this, void 0, void 0, function* () {
             const resizedImage = yield this.resizeIfNeeded(customElements, image);
             const httpBody = {

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

@@ -1,5 +1,5 @@
 import { CustomElementJson } from '../core/model/test-case-dto';
-import { Executable, FluentCommand } from './dsl';
+import { Exec, Executable, FluentCommand, FluentFilters } from './dsl';
 import { UiControllerClientConnectionState } from './ui-controller-client-connection-state';
 import { Annotation } from '../core/annotation/annotation';
 import { AnnotationRequest } from '../core/model/annotation-result/annotation-interface';
@@ -18,6 +18,51 @@ export declare class UiControlClient extends FluentCommand {
     annotate(annotationRequest?: AnnotationRequest): Promise<Annotation>;
     annotateInteractively(): Promise<void>;
     exec(instruction: string, customElementJson?: CustomElementJson[]): Promise<void>;
+    private secretText;
+    /**
+     * Types a text inside the filtered element.
+     *
+     * By default, the `text` is included in the logs and sent over to the askui Inference server to
+     * predict in which context the typing has to occur. You can exclude the `text` from the logs
+     * and the request to the askui Inference server setting `options.isSecret` to `true`.
+     * This should not change the quality of the prediction of the askui Inference server. In this
+     * case, `options.secretMask` is included in logs and sent over instead of the `text`.
+     *
+     * @param {string} text - A text to type.
+     * @param {Object} [options]
+     * @param {boolean} [options.isSecret = false] - If set to `true`, `text` is neither included in
+     *   logs of askui nor sent over to askui Inference for prediction.
+     * @param {string} [options.secretMask = '****'] - If `options.isSecret` is set to `true`, this
+     *   is included in logs and sent over to askui Inference for prediction instead of the `text`.
+     *
+     * @return {FluentFilters}
+     */
+    typeIn(text: string, { isSecret, secretMask }?: {
+        isSecret?: boolean | undefined;
+        secretMask?: string | undefined;
+    }): FluentFilters;
+    /**
+     * Types a text at the current position.
+     *
+     * By default, the `text` is included in the logs and sent over to the askui Inference server to
+     * predict in which context the typing has to occur. You can exclude the `text` from the logs
+     * and the request to the askui Inference server setting `options.isSecret` to `true`.
+     * This should not change the quality of the prediction of the askui Inference server. In this
+     * case, `options.secretMask` is included in logs and sent over instead of the `text`.
+     *
+     * @param {string} text - A text to type.
+     * @param {Object} options
+     * @param {boolean} [options.isSecret = false] - If set to `true`, `text` is neither included in
+     *   logs of askui nor sent over to askui Inference for prediction.
+     * @param {string} [options.secretMask = '****'] - If `options.isSecret` is set to `true`, this
+     *   is included in logs and sent over to askui Inference for prediction instead of the `text`.
+     *
+     * @return {Exec}
+     */
+    type(text: string, { isSecret, secretMask }?: {
+        isSecret?: boolean | undefined;
+        secretMask?: string | undefined;
+    }): Exec;
     /**
      * Waits for `<delayInMs>` ms, e.g., 1000 ms. The exact delay may be a little longer
      * than `<delayInMs>` but never shorter than that.

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

@@ -8,7 +8,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { CustomElement } from '../core/model/test-case-dto';
-import { FluentCommand } from './dsl';
+import { FluentCommand, } from './dsl';
 import { HttpClientGot } from '../utils/http/http-client-got';
 import { UiControllerClient } from './ui-controller-client';
 import { ExecutionRuntime } from './execution-runtime';
@@ -26,6 +26,7 @@ export class UiControlClient extends FluentCommand {
         super();
         this.httpClient = httpClient;
         this.clientArgs = clientArgs;
+        this.secretText = undefined;
     }
     static build(clientArgs) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -85,16 +86,15 @@ export class UiControlClient extends FluentCommand {
             }
         });
     }
-    exec(instruction, customElementJson) {
+    exec(instruction, customElementJson = []) {
         return __awaiter(this, void 0, void 0, function* () {
-            let customElements = [];
-            if (customElementJson !== undefined) {
-                customElements = yield CustomElement.fromJsonListWithImagePathOrImage(customElementJson);
-            }
+            const customElements = yield CustomElement.fromJsonListWithImagePathOrImage(customElementJson);
+            const { secretText } = this;
             try {
                 yield this.executionRuntime.executeTestStep({
                     instruction,
                     customElements,
+                    secretText,
                 });
                 yield this.annotateByDefault(TestStepState.PASSED, customElements);
                 return yield Promise.resolve();
@@ -105,6 +105,56 @@ export class UiControlClient extends FluentCommand {
             }
         });
     }
+    /**
+     * Types a text inside the filtered element.
+     *
+     * By default, the `text` is included in the logs and sent over to the askui Inference server to
+     * predict in which context the typing has to occur. You can exclude the `text` from the logs
+     * and the request to the askui Inference server setting `options.isSecret` to `true`.
+     * This should not change the quality of the prediction of the askui Inference server. In this
+     * case, `options.secretMask` is included in logs and sent over instead of the `text`.
+     *
+     * @param {string} text - A text to type.
+     * @param {Object} [options]
+     * @param {boolean} [options.isSecret = false] - If set to `true`, `text` is neither included in
+     *   logs of askui nor sent over to askui Inference for prediction.
+     * @param {string} [options.secretMask = '****'] - If `options.isSecret` is set to `true`, this
+     *   is included in logs and sent over to askui Inference for prediction instead of the `text`.
+     *
+     * @return {FluentFilters}
+     */
+    typeIn(text, { isSecret = false, secretMask = '****' } = {}) {
+        if (isSecret) {
+            this.secretText = text;
+            return super.typeIn(secretMask);
+        }
+        return super.typeIn(text);
+    }
+    /**
+     * Types a text at the current position.
+     *
+     * By default, the `text` is included in the logs and sent over to the askui Inference server to
+     * predict in which context the typing has to occur. You can exclude the `text` from the logs
+     * and the request to the askui Inference server setting `options.isSecret` to `true`.
+     * This should not change the quality of the prediction of the askui Inference server. In this
+     * case, `options.secretMask` is included in logs and sent over instead of the `text`.
+     *
+     * @param {string} text - A text to type.
+     * @param {Object} options
+     * @param {boolean} [options.isSecret = false] - If set to `true`, `text` is neither included in
+     *   logs of askui nor sent over to askui Inference for prediction.
+     * @param {string} [options.secretMask = '****'] - If `options.isSecret` is set to `true`, this
+     *   is included in logs and sent over to askui Inference for prediction instead of the `text`.
+     *
+     * @return {Exec}
+     */
+    type(text, { isSecret = false, secretMask = '****' } = {}) {
+        if (isSecret) {
+            this.secretText = text;
+            return super.type(secretMask);
+        }
+        return super.type(text);
+    }
     /**
      * Waits for `<delayInMs>` ms, e.g., 1000 ms. The exact delay may be a little longer
      * than `<delayInMs>` but never shorter than that.

package/dist/esm/lib/copy-example-project.js

@@ -1,6 +1,7 @@
 import { Command } from 'commander';
 import path from 'path';
 import fs from 'fs-extra';
+import { getPathToNodeModulesRoot } from '../utils/path';
 const createProgram = () => {
     const program = new Command('askui');
     program.usage('<command> [options]');
@@ -8,7 +9,7 @@ const createProgram = () => {
 };
 function copyExampleProject() {
     const exampleProjectPath = path.join('example_projects_templates', 'typescript_jest');
-    fs.copySync(path.join(__dirname, '..', '..', exampleProjectPath), '.');
+    fs.copySync(path.join(getPathToNodeModulesRoot(), exampleProjectPath), '.');
 }
 export function init(argv) {
     const args = argv || process.argv;

package/dist/esm/lib/download-binaries.js

@@ -2,6 +2,7 @@ import fs from 'fs';
 import got from 'got';
 import os from 'os';
 import path from 'path';
+import { getPathToNodeModulesRoot } from '../utils/path';
 import { logger } from './logger';
 var SupportedPlatform;
 (function (SupportedPlatform) {
@@ -28,7 +29,7 @@ function buildBinaryNotAvailbleError(binaryVersion) {
     return new Error(`It seems that the UI Controller version "${binaryVersion}" for your system "${platform()} ${os.arch}" is not availble, Please contact as at info@askui.com for more information`);
 }
 export function getBinaryPath(version) {
-    return path.join(__dirname, '..', '..', 'release', version, ...binarySubPathsByPlatform[platform()]);
+    return path.join(getPathToNodeModulesRoot(), 'release', version, ...binarySubPathsByPlatform[platform()]);
 }
 function getBinaryDownloadUrl(binaryVersion) {
     const baseUrl = `https://askui-public.s3.eu-central-1.amazonaws.com/releases/askui-ui-controller/${binaryVersion}`;

package/dist/esm/lib/ui-controller-linux.js

@@ -24,7 +24,7 @@ export class UiControllerLinux extends UiControllerFacade {
             const runCommand = promisify(exec);
             const waylandStatus = yield runCommand('echo $WAYLAND_DISPLAY');
             if (waylandStatus.stdout.trim().includes('wayland')) {
-                throw new WaylandError('Wayland is not supported: https://docs.askui.com/docs/general/Troubleshooting/askui-ui-controller-starting-problems#wayland');
+                throw new WaylandError('Wayland is not supported: https://docs.askui.com/docs/general/Troubleshooting/askui-ui-controller#wayland');
             }
             /* First we want to check if the user is using a debian distribution.
             * and in the following if libfuse2 is installed.
@@ -41,7 +41,7 @@ export class UiControllerLinux extends UiControllerFacade {
                 yield runCommand('dpkg -s libfuse2 | grep Status');
             }
             catch (_a) {
-                throw new LibfuseError('Libfuse2 package is missing: https://docs.askui.com/docs/general/Troubleshooting/askui-ui-controller-starting-problems#libfuse2');
+                throw new LibfuseError('Libfuse2 package is missing: https://docs.askui.com/docs/general/Troubleshooting/askui-ui-controller#libfuse2');
             }
         });
     }

package/dist/esm/utils/analytics/analytics.js

@@ -9,6 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import os from 'os';
 import { UserIdentifier } from './user-identifier';
+import { InstallationTimestamp } from './installation-timestamp';
 export class Analytics {
     constructor() {
         this.userIdentifier = new UserIdentifier();
@@ -16,10 +17,15 @@ export class Analytics {
     getAnalyticsHeaders() {
         return __awaiter(this, void 0, void 0, function* () {
             const userID = yield this.userIdentifier.userId();
-            return {
+            const headers = {
                 'askui-user-id': userID,
                 'askui-user-agent': `os:${os.platform()};arch:${os.arch()}`,
             };
+            const askuiInstalledAt = yield InstallationTimestamp.get();
+            if (askuiInstalledAt) {
+                headers['askui-installed-at'] = askuiInstalledAt.toISOString();
+            }
+            return headers;
         });
     }
 }

package/dist/esm/utils/analytics/installation-timestamp-create-error.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+export declare class InstallationTimestampCreateError extends Error {
+    constructor(err: NodeJS.ErrnoException);
+}

package/dist/esm/utils/analytics/installation-timestamp-create-error.js

@@ -0,0 +1,5 @@
+export class InstallationTimestampCreateError extends Error {
+    constructor(err) {
+        super(`Installation timestamp could not be created. \n${err.message}`);
+    }
+}

package/dist/esm/utils/analytics/installation-timestamp-get-error.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+export declare class InstallationTimestampGetError extends Error {
+    constructor(err: NodeJS.ErrnoException);
+}

package/dist/esm/utils/analytics/installation-timestamp-get-error.js

@@ -0,0 +1,5 @@
+export class InstallationTimestampGetError extends Error {
+    constructor(err) {
+        super(`Installation timestamp does not exist. Try reinstalling the lib to create it. \n${err.message}`);
+    }
+}

package/dist/esm/utils/analytics/installation-timestamp.d.ts

@@ -0,0 +1,7 @@
+export declare abstract class InstallationTimestamp {
+    private static fileName;
+    private static value?;
+    static create(): Promise<void>;
+    static get(): Promise<Date | null>;
+    private static getFromFile;
+}

package/dist/esm/utils/analytics/installation-timestamp.js

@@ -0,0 +1,61 @@
+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());
+    });
+};
+import fs from 'fs';
+import path from 'path';
+import { logger } from '../../lib';
+import { InstallationTimestampCreateError } from './installation-timestamp-create-error';
+import { InstallationTimestampGetError } from './installation-timestamp-get-error';
+import { getPathToNodeModulesRoot } from '../path';
+export class InstallationTimestamp {
+    static create() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const timestamp = new Date().toISOString();
+            return new Promise((resolve, reject) => {
+                fs.writeFile(InstallationTimestamp.fileName, timestamp, { encoding: 'utf-8' }, (err) => {
+                    if (err) {
+                        reject(new InstallationTimestampCreateError(err));
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            });
+        });
+    }
+    static get() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (InstallationTimestamp.value === undefined) {
+                try {
+                    InstallationTimestamp.value = yield this.getFromFile();
+                }
+                catch (err) {
+                    InstallationTimestamp.value = null;
+                    logger.warn(err.message);
+                }
+            }
+            return InstallationTimestamp.value;
+        });
+    }
+    static getFromFile() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                fs.readFile(InstallationTimestamp.fileName, 'utf-8', (err, isoDateStr) => {
+                    if (err) {
+                        reject(new InstallationTimestampGetError(err));
+                    }
+                    else {
+                        resolve(new Date(isoDateStr));
+                    }
+                });
+            });
+        });
+    }
+}
+InstallationTimestamp.fileName = path.join(getPathToNodeModulesRoot(), 'install-timestamp');

package/dist/esm/utils/path.d.ts

@@ -0,0 +1 @@
+export declare function getPathToNodeModulesRoot(): string;

package/dist/esm/utils/path.js

@@ -0,0 +1,4 @@
+import path from 'path';
+export function getPathToNodeModulesRoot() {
+    return path.join(__dirname, '..', '..');
+}

package/package.json

@@ -1,16 +1,20 @@
 {
     "name": "askui",
-    "version": "0.2.0",
+    "version": "0.2.1",
     "main": "./dist/cjs/main.js",
     "module": "./dist/esm/main.js",
-    "bin": "bin/askui",
+    "bin": {
+        "askui": "bin/askui",
+        "askui-postinstall": "bin/askui-postinstall"
+    },
     "scripts": {
         "build": "tsc -p tsconfig.json && tsc -p tsconfig-cjs.json && npm run copyTemplate && npm run copyExampleProject",
         "copyTemplate": "shx cp -r src/core/annotation/template.html dist/cjs/core/annotation/ && shx cp -r src/core/annotation/template.html dist/esm/core/annotation/",
         "copyExampleProject": "shx cp  -r example_projects_templates/ dist/  && shx cp -r bin/* dist/",
         "lint": "eslint --cache --fix --max-warnings 0 \"./**/*.{js,ts}\"",
         "lint:staged": "lint-staged",
-        "test": "jest '/src'"
+        "test": "jest '/src'",
+        "postinstall": "$npm_package_bin_askui-postinstall"
     },
     "files": [
         "dist/cjs/",

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

@@ -1,4 +0,0 @@
-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

@@ -1,11 +0,0 @@
-"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/image-resize-errors/invalid-base64-image-error.d.ts

@@ -1,3 +0,0 @@
-import { ImageResizingError } from './image-resizing-base-error';
-export declare class InvalidBase64Image extends ImageResizingError {
-}

package/dist/cjs/utils/image-resize-errors/invalid-base64-image-error.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InvalidBase64Image = void 0;
-const image_resizing_base_error_1 = require("./image-resizing-base-error");
-class InvalidBase64Image extends image_resizing_base_error_1.ImageResizingError {
-}
-exports.InvalidBase64Image = InvalidBase64Image;

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

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

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

@@ -1,7 +0,0 @@
-import { Base64ImageError } from "./base-64-image-error";
-export class Base64ImagePathError extends Base64ImageError {
-    constructor(path) {
-        super(`Can't create Base64Image instance from path:\n${path}\n\n` +
-            `No image exists at path.`);
-    }
-}

package/dist/esm/utils/image-resize-errors/invalid-base64-image-error.d.ts

@@ -1,3 +0,0 @@
-import { ImageResizingError } from './image-resizing-base-error';
-export declare class InvalidBase64Image extends ImageResizingError {
-}

package/dist/esm/utils/image-resize-errors/invalid-base64-image-error.js

@@ -1,3 +0,0 @@
-import { ImageResizingError } from './image-resizing-base-error';
-export class InvalidBase64Image extends ImageResizingError {
-}