askui 0.1.6 → 0.2.2

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

@@ -0,0 +1,31 @@
+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 os from 'os';
+import { UserIdentifier } from './user-identifier';
+import { InstallationTimestamp } from './installation-timestamp';
+export class Analytics {
+    constructor() {
+        this.userIdentifier = new UserIdentifier();
+    }
+    getAnalyticsHeaders() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const userID = yield this.userIdentifier.userId();
+            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/index.d.ts

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

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

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

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/analytics/user-identifier-interface.d.ts

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

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

@@ -0,0 +1 @@
+export {};

package/dist/esm/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/esm/utils/analytics/user-identifier.js

@@ -0,0 +1,18 @@
+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 { machineId } from 'node-machine-id';
+export class UserIdentifier {
+    // eslint-disable-next-line class-methods-use-this
+    userId() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return machineId();
+        });
+    }
+}

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

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

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

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

package/dist/esm/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/esm/utils/base_64_image/base-64-image-string-error.js

@@ -0,0 +1,7 @@
+import { Base64ImageError } from './base-64-image-error';
+export class Base64ImageStringError extends Base64ImageError {
+    constructor(str, prefix) {
+        super(`Can't create Base64Image instance from string:\n${str}\n\n`
+            + `String should start with "${prefix}".`);
+    }
+}

package/dist/esm/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/esm/utils/base_64_image/base-64-image.js

@@ -0,0 +1,79 @@
+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 sharp from 'sharp';
+import { Base64ImageStringError } from './base-64-image-string-error';
+export 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 Base64ImageStringError)) {
+                    throw error;
+                }
+            }
+            return Base64Image.fromPath(pathOrStr);
+        });
+    }
+    static fromPath(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Base64Image.fromSharp(sharp(path));
+        });
+    }
+    static fromString(str) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!str.startsWith(Base64Image.strPrefix)) {
+                throw new Base64ImageStringError(str, Base64Image.strPrefix);
+            }
+            const data = str.substring(Base64Image.strPrefix.length);
+            return Base64Image.fromSharp(sharp(Buffer.from(data, 'base64')));
+        });
+    }
+    static fromBuffer(buffer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Base64Image.fromSharp(sharp(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.fit.contain,
+            }).toBuffer();
+            return Base64Image.fromBuffer(buffer);
+        });
+    }
+    toString() {
+        return `${Base64Image.strPrefix}${this.buffer.toString('base64')}`;
+    }
+    toBuffer() {
+        return this.buffer;
+    }
+}
+Base64Image.strPrefix = 'data:image/png;base64,';

package/dist/esm/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/esm/utils/http/custom-errors/http-client-error.js

@@ -1,7 +1,2 @@
 export class HttpClientError extends Error {
-    constructor(message) {
-        super(message);
-        this.contructorName = this.constructor.name;
-        this.name = this.contructorName;
-    }
 }

package/dist/esm/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/esm/utils/http/http-client-got.js

@@ -11,22 +11,22 @@ import got from 'got';
 import { Credentials } from './credentials';
 import { httpClientErrorHandler } from './custom-errors';
 export class HttpClientGot {
-    constructor(credentialArgs) {
+    constructor(credentialArgs, customHeaders) {
         this.credentialArgs = credentialArgs;
-        this.credentials = this.credentialArgs ? new 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(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.post(url, options);
             if (statusCode !== 200) {
                 throw httpClientErrorHandler(statusCode, JSON.stringify(body));
@@ -36,7 +36,7 @@ export class HttpClientGot {
     }
     get(url, options = { responseType: 'json' }) {
         return __awaiter(this, void 0, void 0, function* () {
-            const response = yield got.get(url, this.injectAuthHeader(options));
+            const response = yield got.get(url, this.injectHeaders(options));
             return response.body;
         });
     }

package/dist/esm/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/esm/utils/image-resize-errors/image-resizing-base-error.js

@@ -1,7 +1,2 @@
 export class ImageResizingError extends Error {
-    constructor(message) {
-        super(message);
-        this.contructorName = this.constructor.name;
-        this.name = this.contructorName;
-    }
 }

package/dist/esm/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/esm/utils/image-resize-errors/index.js

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

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/dist/esm/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/esm/utils/transformations.js

@@ -7,28 +7,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import fs from 'fs';
-import { read } from 'jimp';
 import { logger } from '../lib';
-import { ImageResizingError, InvalidBase64Image } from './image-resize-errors';
-export function toBase64Image(imagePath) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!(fs.existsSync(imagePath))) {
-            throw new Error(`the image ${imagePath} does not exists!`);
-        }
-        const image = yield read(imagePath);
-        return image.getBase64Async('image/png');
-    });
-}
-export function toBase64ImageIfNeeded(pngPathOrBase64Image) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const isBase64Image = pngPathOrBase64Image.startsWith('data:image');
-        if (!isBase64Image) {
-            return toBase64Image(pngPathOrBase64Image);
-        }
-        return pngPathOrBase64Image;
-    });
-}
+import { Base64Image } from './base_64_image/base-64-image';
+import { ImageResizingError } from './image-resize-errors';
 /**
   * 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.
@@ -42,28 +23,19 @@ export function toBase64ImageIfNeeded(pngPathOrBase64Image) {
 export function resizeBase64ImageWithSameRatio(base64ImageString, maxEdge = 1400) {
     return __awaiter(this, void 0, void 0, function* () {
         logger.debug('Image resizing');
-        if (!(base64ImageString.startsWith('data:image'))) {
-            Promise.reject(new InvalidBase64Image('Invalid base64 image string'));
-        }
         try {
-            let resizeRatio = 1;
-            const orignalImage = yield 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 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 ImageResizingError(`A Problem has occured during the resizeing of the image. Error: ${error}`));
+            throw new ImageResizingError(`A Problem has occured during the resizing of the image. Error: ${error}`);
         }
     });
 }

package/dist/example_projects_templates/typescript_jest/test/helper/jest.setup.ts

@@ -1,16 +1,16 @@
-import { AskuiClient, AskuiControlServer } from 'askui';
+import { UiControlClient, UiController } from 'askui';
 
 // Server for controlling the operating system
-let askuiServer: AskuiControlServer;
+let uiController: UiController;
 
 // Client is necessary to use the askui API
 // eslint-disable-next-line import/no-mutable-exports
-let aui: AskuiClient;
+let aui: UiControlClient;
 
 jest.setTimeout(60 * 1000 * 60);
 
 beforeAll(async () => {
-  askuiServer = new AskuiControlServer({
+  uiController = new UiController({
     /**
      * Select the display you want to run your tests on, display 0 is your main display;
      * ignore if you have only one display
@@ -18,15 +18,15 @@ beforeAll(async () => {
     display: 0,
   });
 
-  await askuiServer.start();
+  await uiController.start();
 
-  aui = new AskuiClient();
+  aui = await UiControlClient.build();
 
   await aui.connect();
 });
 
 afterAll(async () => {
-  await askuiServer.stop();
+  await uiController.stop();
 
   aui.close();
 });

package/dist/example_projects_templates/typescript_jest/test/jest.config.ts

@@ -4,6 +4,9 @@ const config: Config.InitialOptions = {
   preset: 'ts-jest',
   testEnvironment: 'node',
   setupFilesAfterEnv: ['./helper/jest.setup.ts'],
+  sandboxInjectedGlobals: [
+    'Math',
+  ],
 };
 
 // eslint-disable-next-line import/no-default-export

package/package.json

@@ -1,16 +1,20 @@
 {
     "name": "askui",
-    "version": "0.1.6",
+    "version": "0.2.2",
     "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": "node -e \"require('./bin/askui-postinstall')\""
     },
     "files": [
         "dist/cjs/",
@@ -23,10 +27,11 @@
         "fkill": "~7.2.1",
         "fs-extra": "~10.0.0",
         "got": "~11.8.2",
-        "jimp": "~0.16.1",
         "jsdom": "~19.0.0",
+        "node-machine-id": "~1.1.12",
         "pino": "~7.8.1",
         "pino-pretty": "~7.5.3",
+        "sharp": "~0.30.6",
         "url-join": "~4.0.1",
         "wait-port": "~0.2.9",
         "ws": "~7.4.4",
@@ -37,15 +42,17 @@
         "@types/jest": "~27.4.0",
         "@types/jsdom": "~16.2.14",
         "@types/node": "~17.0.10",
+        "@types/sharp": "~0.30.4",
         "@types/url-join": "~4.0.1",
         "@types/webrtc": "~0.0.30",
         "@types/ws": "~7.4.4",
-        "jest": "~27.4.7",
-        "shx": "~0.3.4",
-        "ts-jest": "~27.1.3",
+        "jest": "28.1.1",
+        "sharp": "^0.30.6",
+        "shx": "0.3.4",
+        "ts-jest": "28.0.4",
         "typescript": "~4.5.4"
     },
     "lint-staged": {
         "./**/*.{js,ts}": "eslint --cache --fix --max-warnings 0"
     }
-}
+}

package/dist/cjs/execution/client-connection-state.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClientConnectionState = void 0;
-var ClientConnectionState;
-(function (ClientConnectionState) {
-    ClientConnectionState[ClientConnectionState["NOT_CONNECTED"] = 0] = "NOT_CONNECTED";
-    ClientConnectionState[ClientConnectionState["CONNECTING"] = 1] = "CONNECTING";
-    ClientConnectionState[ClientConnectionState["CONNECTED"] = 2] = "CONNECTED";
-    ClientConnectionState[ClientConnectionState["ERROR"] = 3] = "ERROR";
-})(ClientConnectionState = exports.ClientConnectionState || (exports.ClientConnectionState = {}));

package/dist/cjs/execution/client-error.d.ts

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

package/dist/cjs/execution/client-error.js

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

package/dist/cjs/execution/client-interface.d.ts

@@ -1,13 +0,0 @@
-import { CredentialArgs } from '../utils/http/credentials';
-import { AnnotationLevel } from './annotation-level';
-export interface ClientArgs {
-    readonly controlServerUrl?: string;
-    readonly controlYourUiApi?: string;
-    readonly annotationLevel?: AnnotationLevel;
-    readonly credentials?: CredentialArgs;
-}
-export interface ClientArgsWithDefaults extends ClientArgs {
-    readonly controlServerUrl: string;
-    readonly controlYourUiApi: string;
-    readonly annotationLevel: AnnotationLevel;
-}