@illgrenoble/webx-client 1.8.1 → 1.9.0

package/dist/src/instruction/WebXInstructionResponse.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebXInstructionResponse = void 0;
+/**
+ * Represents a response to a WebX instruction.
+ *
+ * This class encapsulates the result of executing an instruction, including
+ * any data returned by the WebX Engine.
+ */
+class WebXInstructionResponse {
+    /**
+     * Constructs a new WebXInstructionResponse.
+     *
+     * @param instruction The WebX instruction associated with this response.
+     * @param timeoutMs The timeout duration in milliseconds.
+     */
+    constructor(instruction, timeoutMs) {
+        /**
+         * The ID of the timeout.
+         */
+        this._timeoutId = 0;
+        this.instructionId = instruction.id;
+        this.data = null;
+        if (timeoutMs) {
+            this._timeoutMs = timeoutMs;
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            this._timeoutId = setTimeout(() => {
+                this.reject('Request failed due to timeout');
+            }, this._timeoutMs);
+        }
+    }
+    /**
+     * Registers a callback to be invoked when a response is received.
+     *
+     * @param onResponseReceived The callback to be invoked.
+     * @returns The current instance of WebXInstructionResponse.
+     */
+    then(onResponseReceived) {
+        this._onResponseReceived = onResponseReceived;
+        return this;
+    }
+    /**
+     * Registers a callback to be invoked when an error occurs.
+     *
+     * @param onError The callback to be invoked.
+     * @returns The current instance of WebXInstructionResponse.
+     */
+    catch(onError) {
+        this._onError = onError;
+        return this;
+    }
+    /**
+     * Resolves the response with the provided message.
+     *
+     * @param message The response message.
+     */
+    resolve(message) {
+        if (this._timeoutId > 0) {
+            clearTimeout(this._timeoutId);
+        }
+        if (this._onResponseReceived != null) {
+            this._onResponseReceived(message);
+        }
+    }
+    /**
+     * Rejects the response with the provided error message.
+     *
+     * @param error The error message.
+     */
+    reject(error) {
+        if (this._onError) {
+            this._onError(new Error(error));
+        }
+    }
+}
+exports.WebXInstructionResponse = WebXInstructionResponse;
+//# sourceMappingURL=WebXInstructionResponse.js.map

package/dist/src/instruction/WebXInstructionResponse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebXInstructionResponse.js","sourceRoot":"","sources":["../../../src/instruction/WebXInstructionResponse.ts"],"names":[],"mappings":";;;AAEA;;;;;GAKG;AACH,MAAa,uBAAuB;IA+BlC;;;;;OAKG;IACH,YAAY,WAA4B,EAAE,SAAkB;QAX5D;;WAEG;QACc,eAAU,GAAW,CAAC,CAAC;QAStC,IAAI,CAAC,aAAa,GAAG,WAAW,CAAC,EAAE,CAAC;QACpC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QAEjB,IAAI,SAAS,EAAE,CAAC;YACd,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;YAC5B,6DAA6D;YAC7D,aAAa;YACb,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC,GAAG,EAAE;gBAChC,IAAI,CAAC,MAAM,CAAC,+BAA+B,CAAC,CAAC;YAC/C,CAAC,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;QACtB,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACH,IAAI,CAAC,kBAAwC;QAC3C,IAAI,CAAC,mBAAmB,GAAG,kBAAkB,CAAC;QAC9C,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,OAA+B;QACnC,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC;QACxB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;OAIG;IACH,OAAO,CAAC,OAAU;QAChB,IAAI,IAAI,CAAC,UAAU,GAAG,CAAC,EAAE,CAAC;YACxB,YAAY,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QAChC,CAAC;QACD,IAAI,IAAI,CAAC,mBAAmB,IAAI,IAAI,EAAE,CAAC;YACrC,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAAC,CAAC;QACpC,CAAC;IACH,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,KAAa;QAClB,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;YAClB,IAAI,CAAC,QAAQ,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;QAClC,CAAC;IACH,CAAC;CACF;AAjGD,0DAiGC"}

package/dist/src/instruction/WebXInstructionType.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Enum representing the types of WebX instructions.
+ *
+ * These types are used to categorize instructions sent to the WebX Engine.
+ */
+export declare enum WebXInstructionType {
+    /**
+     * Instruction to connect to the WebX Engine.
+     */
+    CONNECT = 1,
+    /**
+     * Instruction to request visible window layout.
+     */
+    WINDOWS = 2,
+    /**
+     * Instruction to request window image data.
+     */
+    IMAGE = 3,
+    /**
+     * Instruction to request the screen settings.
+     */
+    SCREEN = 4,
+    /**
+     * Instruction to send a mouse event.
+     */
+    MOUSE = 5,
+    /**
+     * Instruction to send a keyboard event.
+     */
+    KEYBOARD = 6,
+    /**
+     * Instruction to request the cursor image.
+     */
+    CURSOR_IMAGE = 7,
+    /**
+     * Instruction to set the quality index.
+     */
+    QUALITY = 8,
+    /**
+     * Instruction to respond to a ping message.
+     */
+    PONG = 9,
+    /**
+     * Instruction to acknowledge data.
+     */
+    DATA_ACK = 10,
+    /**
+     * Instruction to send clipboard data to the WebX Engine.
+     */
+    CLIPBOARD = 11,
+    /**
+     * Instruction to request the window shape image (stencil image).
+     */
+    SHAPE = 12
+}
+export declare namespace WebXInstructionType {
+    /**
+     * Converts a string representation of a WebX instruction type to its corresponding enum value.
+     * @param value the string representation of the instruction type.
+     * @returns the corresponding WebXInstructionType enum value.
+     */
+    function fromString(value: string): WebXInstructionType;
+}

package/dist/src/instruction/WebXInstructionType.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebXInstructionType = void 0;
+/**
+ * Enum representing the types of WebX instructions.
+ *
+ * These types are used to categorize instructions sent to the WebX Engine.
+ */
+var WebXInstructionType;
+(function (WebXInstructionType) {
+    /**
+     * Instruction to connect to the WebX Engine.
+     */
+    WebXInstructionType[WebXInstructionType["CONNECT"] = 1] = "CONNECT";
+    /**
+     * Instruction to request visible window layout.
+     */
+    WebXInstructionType[WebXInstructionType["WINDOWS"] = 2] = "WINDOWS";
+    /**
+     * Instruction to request window image data.
+     */
+    WebXInstructionType[WebXInstructionType["IMAGE"] = 3] = "IMAGE";
+    /**
+     * Instruction to request the screen settings.
+     */
+    WebXInstructionType[WebXInstructionType["SCREEN"] = 4] = "SCREEN";
+    /**
+     * Instruction to send a mouse event.
+     */
+    WebXInstructionType[WebXInstructionType["MOUSE"] = 5] = "MOUSE";
+    /**
+     * Instruction to send a keyboard event.
+     */
+    WebXInstructionType[WebXInstructionType["KEYBOARD"] = 6] = "KEYBOARD";
+    /**
+     * Instruction to request the cursor image.
+     */
+    WebXInstructionType[WebXInstructionType["CURSOR_IMAGE"] = 7] = "CURSOR_IMAGE";
+    /**
+     * Instruction to set the quality index.
+     */
+    WebXInstructionType[WebXInstructionType["QUALITY"] = 8] = "QUALITY";
+    /**
+     * Instruction to respond to a ping message.
+     */
+    WebXInstructionType[WebXInstructionType["PONG"] = 9] = "PONG";
+    /**
+     * Instruction to acknowledge data.
+     */
+    WebXInstructionType[WebXInstructionType["DATA_ACK"] = 10] = "DATA_ACK";
+    /**
+     * Instruction to send clipboard data to the WebX Engine.
+     */
+    WebXInstructionType[WebXInstructionType["CLIPBOARD"] = 11] = "CLIPBOARD";
+    /**
+     * Instruction to request the window shape image (stencil image).
+     */
+    WebXInstructionType[WebXInstructionType["SHAPE"] = 12] = "SHAPE";
+})(WebXInstructionType || (exports.WebXInstructionType = WebXInstructionType = {}));
+(function (WebXInstructionType) {
+    /**
+     * Converts a string representation of a WebX instruction type to its corresponding enum value.
+     * @param value the string representation of the instruction type.
+     * @returns the corresponding WebXInstructionType enum value.
+     */
+    function fromString(value) {
+        switch (value) {
+            case 'CONNECT':
+                return WebXInstructionType.CONNECT;
+            case 'WINDOWS':
+                return WebXInstructionType.WINDOWS;
+            case 'IMAGE':
+                return WebXInstructionType.IMAGE;
+            case 'SCREEN':
+                return WebXInstructionType.SCREEN;
+            case 'MOUSE':
+                return WebXInstructionType.MOUSE;
+            case 'KEYBOARD':
+                return WebXInstructionType.KEYBOARD;
+            case 'CURSOR_IMAGE':
+                return WebXInstructionType.CURSOR_IMAGE;
+            case 'QUALITY':
+                return WebXInstructionType.QUALITY;
+            case 'PONG':
+                return WebXInstructionType.PONG;
+            case 'DATA_ACK':
+                return WebXInstructionType.DATA_ACK;
+            case 'CLIPBOARD':
+                return WebXInstructionType.CLIPBOARD;
+            case 'SHAPE':
+                return WebXInstructionType.SHAPE;
+        }
+    }
+    WebXInstructionType.fromString = fromString;
+})(WebXInstructionType || (exports.WebXInstructionType = WebXInstructionType = {}));
+//# sourceMappingURL=WebXInstructionType.js.map

package/dist/src/instruction/WebXInstructionType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebXInstructionType.js","sourceRoot":"","sources":["../../../src/instruction/WebXInstructionType.ts"],"names":[],"mappings":";;;AAAA;;;;GAIG;AACH,IAAY,mBA6DX;AA7DD,WAAY,mBAAmB;IAE7B;;OAEG;IACH,mEAAW,CAAA;IAEX;;OAEG;IACH,mEAAW,CAAA;IAEX;;OAEG;IACH,+DAAS,CAAA;IAET;;OAEG;IACH,iEAAU,CAAA;IAEV;;OAEG;IACH,+DAAS,CAAA;IAET;;OAEG;IACH,qEAAY,CAAA;IAEZ;;OAEG;IACH,6EAAgB,CAAA;IAEhB;;OAEG;IACH,mEAAW,CAAA;IAEX;;OAEG;IACH,6DAAQ,CAAA;IAER;;OAEG;IACH,sEAAa,CAAA;IAEb;;OAEG;IACH,wEAAc,CAAA;IAEd;;OAEG;IACH,gEAAU,CAAA;AACZ,CAAC,EA7DW,mBAAmB,mCAAnB,mBAAmB,QA6D9B;AAED,WAAiB,mBAAmB;IAClC;;;;OAIG;IACH,SAAgB,UAAU,CAAC,KAAa;QACtC,QAAQ,KAAK,EAAE,CAAC;YACd,KAAK,SAAS;gBACZ,OAAO,mBAAmB,CAAC,OAAO,CAAC;YACrC,KAAK,SAAS;gBACZ,OAAO,mBAAmB,CAAC,OAAO,CAAC;YACrC,KAAK,OAAO;gBACV,OAAO,mBAAmB,CAAC,KAAK,CAAC;YACnC,KAAK,QAAQ;gBACX,OAAO,mBAAmB,CAAC,MAAM,CAAC;YACpC,KAAK,OAAO;gBACV,OAAO,mBAAmB,CAAC,KAAK,CAAC;YACnC,KAAK,UAAU;gBACb,OAAO,mBAAmB,CAAC,QAAQ,CAAC;YACtC,KAAK,cAAc;gBACjB,OAAO,mBAAmB,CAAC,YAAY,CAAC;YAC1C,KAAK,SAAS;gBACZ,OAAO,mBAAmB,CAAC,OAAO,CAAC;YACrC,KAAK,MAAM;gBACT,OAAO,mBAAmB,CAAC,IAAI,CAAC;YAClC,KAAK,UAAU;gBACb,OAAO,mBAAmB,CAAC,QAAQ,CAAC;YACtC,KAAK,WAAW;gBACd,OAAO,mBAAmB,CAAC,SAAS,CAAC;YACvC,KAAK,OAAO;gBACV,OAAO,mBAAmB,CAAC,KAAK,CAAC;QACrC,CAAC;IACH,CAAC;IA3Be,8BAAU,aA2BzB,CAAA;AACH,CAAC,EAlCgB,mBAAmB,mCAAnB,mBAAmB,QAkCnC"}

package/dist/src/instruction/WebXKeyboardInstruction.d.ts

@@ -0,0 +1,23 @@
+import { WebXInstruction } from './WebXInstruction';
+/**
+ * Represents an instruction to update the keyboard state in the WebX Engine.
+ *
+ * This instruction is used to send key press or release events to the WebX Engine.
+ */
+export declare class WebXKeyboardInstruction extends WebXInstruction {
+    /**
+     * The key code of the key being pressed or released.
+     */
+    readonly key: number;
+    /**
+     * Whether the key is being pressed (true) or released (false).
+     */
+    readonly pressed: boolean;
+    /**
+     * Constructs a new WebXKeyboardInstruction.
+     *
+     * @param key The key code of the key being pressed or released.
+     * @param pressed Whether the key is being pressed (true) or released (false).
+     */
+    constructor(key: number, pressed: boolean);
+}

package/dist/src/instruction/WebXKeyboardInstruction.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebXKeyboardInstruction = void 0;
+const WebXInstruction_1 = require("./WebXInstruction");
+const WebXInstructionType_1 = require("./WebXInstructionType");
+/**
+ * Represents an instruction to update the keyboard state in the WebX Engine.
+ *
+ * This instruction is used to send key press or release events to the WebX Engine.
+ */
+class WebXKeyboardInstruction extends WebXInstruction_1.WebXInstruction {
+    /**
+     * Constructs a new WebXKeyboardInstruction.
+     *
+     * @param key The key code of the key being pressed or released.
+     * @param pressed Whether the key is being pressed (true) or released (false).
+     */
+    constructor(key, pressed) {
+        super(WebXInstructionType_1.WebXInstructionType.KEYBOARD);
+        this.key = key;
+        this.pressed = pressed;
+    }
+}
+exports.WebXKeyboardInstruction = WebXKeyboardInstruction;
+//# sourceMappingURL=WebXKeyboardInstruction.js.map

package/dist/src/instruction/WebXKeyboardInstruction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebXKeyboardInstruction.js","sourceRoot":"","sources":["../../../src/instruction/WebXKeyboardInstruction.ts"],"names":[],"mappings":";;;AAAA,uDAAoD;AACpD,+DAA4D;AAE5D;;;;GAIG;AACH,MAAa,uBAAwB,SAAQ,iCAAe;IAW1D;;;;;OAKG;IACH,YAAY,GAAW,EAAE,OAAgB;QACvC,KAAK,CAAC,yCAAmB,CAAC,QAAQ,CAAC,CAAC;QACpC,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;QACf,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;IACzB,CAAC;CACF;AAtBD,0DAsBC"}

package/dist/src/instruction/WebXMouseInstruction.d.ts

@@ -0,0 +1,28 @@
+import { WebXInstruction } from './WebXInstruction';
+/**
+ * Represents an instruction to update the mouse state in the WebX Engine.
+ *
+ * This instruction is used to send mouse movement or button state changes to the WebX Engine.
+ */
+export declare class WebXMouseInstruction extends WebXInstruction {
+    /**
+     * The x-coordinate of the mouse pointer.
+     */
+    readonly x: number;
+    /**
+     * The y-coordinate of the mouse pointer.
+     */
+    readonly y: number;
+    /**
+     * The button mask representing the state of mouse buttons.
+     */
+    readonly buttonMask: number;
+    /**
+     * Constructs a new WebXMouseInstruction.
+     *
+     * @param x The x-coordinate of the mouse pointer.
+     * @param y The y-coordinate of the mouse pointer.
+     * @param buttonMask The button mask representing the state of mouse buttons.
+     */
+    constructor(x: number, y: number, buttonMask: number);
+}

package/dist/src/instruction/WebXMouseInstruction.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebXMouseInstruction = void 0;
+const WebXInstruction_1 = require("./WebXInstruction");
+const WebXInstructionType_1 = require("./WebXInstructionType");
+/**
+ * Represents an instruction to update the mouse state in the WebX Engine.
+ *
+ * This instruction is used to send mouse movement or button state changes to the WebX Engine.
+ */
+class WebXMouseInstruction extends WebXInstruction_1.WebXInstruction {
+    /**
+     * Constructs a new WebXMouseInstruction.
+     *
+     * @param x The x-coordinate of the mouse pointer.
+     * @param y The y-coordinate of the mouse pointer.
+     * @param buttonMask The button mask representing the state of mouse buttons.
+     */
+    constructor(x, y, buttonMask) {
+        super(WebXInstructionType_1.WebXInstructionType.MOUSE);
+        this.x = x;
+        this.y = y;
+        this.buttonMask = buttonMask;
+    }
+}
+exports.WebXMouseInstruction = WebXMouseInstruction;
+//# sourceMappingURL=WebXMouseInstruction.js.map

package/dist/src/instruction/WebXMouseInstruction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebXMouseInstruction.js","sourceRoot":"","sources":["../../../src/instruction/WebXMouseInstruction.ts"],"names":[],"mappings":";;;AAAA,uDAAoD;AACpD,+DAA4D;AAE5D;;;;GAIG;AACH,MAAa,oBAAqB,SAAQ,iCAAe;IAgBvD;;;;;;OAMG;IACH,YAAY,CAAS,EAAE,CAAS,EAAE,UAAkB;QAClD,KAAK,CAAC,yCAAmB,CAAC,KAAK,CAAC,CAAC;QACjC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;QACX,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;QACX,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;IAC/B,CAAC;CACF;AA7BD,oDA6BC"}

package/dist/src/instruction/WebXPongInstruction.d.ts

@@ -0,0 +1,18 @@
+import { WebXInstruction } from './WebXInstruction';
+/**
+ * Represents an instruction to respond to a ping from the WebX Engine.
+ *
+ * This instruction is used to acknowledge a ping and maintain the connection.
+ */
+export declare class WebXPongInstruction extends WebXInstruction {
+    /**
+     * The timestamp in milliseconds (copied from the message from the engine).
+     */
+    readonly timestampMs: Uint8Array;
+    /**
+     * Constructs a new WebXPongInstruction.
+     *
+     * @param timestampMs The timestamp in milliseconds.
+     */
+    constructor(timestampMs: Uint8Array);
+}

package/dist/src/instruction/WebXPongInstruction.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebXPongInstruction = void 0;
+const WebXInstruction_1 = require("./WebXInstruction");
+const WebXInstructionType_1 = require("./WebXInstructionType");
+/**
+ * Represents an instruction to respond to a ping from the WebX Engine.
+ *
+ * This instruction is used to acknowledge a ping and maintain the connection.
+ */
+class WebXPongInstruction extends WebXInstruction_1.WebXInstruction {
+    /**
+     * Constructs a new WebXPongInstruction.
+     *
+     * @param timestampMs The timestamp in milliseconds.
+     */
+    constructor(timestampMs) {
+        super(WebXInstructionType_1.WebXInstructionType.PONG);
+        this.timestampMs = timestampMs;
+    }
+}
+exports.WebXPongInstruction = WebXPongInstruction;
+//# sourceMappingURL=WebXPongInstruction.js.map

package/dist/src/instruction/WebXPongInstruction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebXPongInstruction.js","sourceRoot":"","sources":["../../../src/instruction/WebXPongInstruction.ts"],"names":[],"mappings":";;;AAAA,uDAAoD;AACpD,+DAA4D;AAE5D;;;;GAIG;AACH,MAAa,mBAAoB,SAAQ,iCAAe;IAMtD;;;;OAIG;IACH,YAAY,WAAuB;QACjC,KAAK,CAAC,yCAAmB,CAAC,IAAI,CAAC,CAAC;QAChC,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC;IACjC,CAAC;CACF;AAfD,kDAeC"}

package/dist/src/instruction/WebXQualityInstruction.d.ts

@@ -0,0 +1,19 @@
+import { WebXInstruction } from './WebXInstruction';
+/**
+ * Represents an instruction to set the quality index in the WebX client.
+ *
+ * This instruction is used to adjust the quality of the remote desktop display.
+ * The quality index determines the quality of the images and the refresh rate of the windows.
+ */
+export declare class WebXQualityInstruction extends WebXInstruction {
+    /**
+     * The quality index to set.
+     */
+    readonly qualityIndex: number;
+    /**
+     * Constructs a new WebXQualityInstruction.
+     *
+     * @param qualityIndex The quality index to set.
+     */
+    constructor(qualityIndex: number);
+}

package/dist/src/instruction/WebXQualityInstruction.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebXQualityInstruction = void 0;
+const WebXInstruction_1 = require("./WebXInstruction");
+const WebXInstructionType_1 = require("./WebXInstructionType");
+/**
+ * Represents an instruction to set the quality index in the WebX client.
+ *
+ * This instruction is used to adjust the quality of the remote desktop display.
+ * The quality index determines the quality of the images and the refresh rate of the windows.
+ */
+class WebXQualityInstruction extends WebXInstruction_1.WebXInstruction {
+    /**
+     * Constructs a new WebXQualityInstruction.
+     *
+     * @param qualityIndex The quality index to set.
+     */
+    constructor(qualityIndex) {
+        super(WebXInstructionType_1.WebXInstructionType.QUALITY);
+        this.qualityIndex = qualityIndex;
+    }
+}
+exports.WebXQualityInstruction = WebXQualityInstruction;
+//# sourceMappingURL=WebXQualityInstruction.js.map

package/dist/src/instruction/WebXQualityInstruction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebXQualityInstruction.js","sourceRoot":"","sources":["../../../src/instruction/WebXQualityInstruction.ts"],"names":[],"mappings":";;;AAAA,uDAAoD;AACpD,+DAA4D;AAE5D;;;;;GAKG;AACH,MAAa,sBAAuB,SAAQ,iCAAe;IAMzD;;;;OAIG;IACH,YAAY,YAAoB;QAC9B,KAAK,CAAC,yCAAmB,CAAC,OAAO,CAAC,CAAC;QACnC,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC;IACnC,CAAC;CACF;AAfD,wDAeC"}

package/dist/src/instruction/WebXScreenInstruction.d.ts

@@ -0,0 +1,12 @@
+import { WebXInstruction } from './WebXInstruction';
+/**
+ * Represents an instruction to request screen information from the WebX Engine.
+ *
+ * This instruction is used to retrieve the screen size.
+ */
+export declare class WebXScreenInstruction extends WebXInstruction {
+    /**
+     * Constructs a new WebXScreenInstruction.
+     */
+    constructor();
+}

package/dist/src/instruction/WebXScreenInstruction.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebXScreenInstruction = void 0;
+const WebXInstruction_1 = require("./WebXInstruction");
+const WebXInstructionType_1 = require("./WebXInstructionType");
+/**
+ * Represents an instruction to request screen information from the WebX Engine.
+ *
+ * This instruction is used to retrieve the screen size.
+ */
+class WebXScreenInstruction extends WebXInstruction_1.WebXInstruction {
+    /**
+     * Constructs a new WebXScreenInstruction.
+     */
+    constructor() {
+        super(WebXInstructionType_1.WebXInstructionType.SCREEN);
+    }
+}
+exports.WebXScreenInstruction = WebXScreenInstruction;
+//# sourceMappingURL=WebXScreenInstruction.js.map

package/dist/src/instruction/WebXScreenInstruction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebXScreenInstruction.js","sourceRoot":"","sources":["../../../src/instruction/WebXScreenInstruction.ts"],"names":[],"mappings":";;;AAAA,uDAAoD;AACpD,+DAA4D;AAE5D;;;;GAIG;AACH,MAAa,qBAAsB,SAAQ,iCAAe;IACxD;;OAEG;IACH;QACE,KAAK,CAAC,yCAAmB,CAAC,MAAM,CAAC,CAAC;IACpC,CAAC;CACF;AAPD,sDAOC"}

package/dist/src/instruction/WebXShapeInstruction.d.ts

@@ -0,0 +1,18 @@
+import { WebXInstruction } from './WebXInstruction';
+/**
+ * Represents an instruction to request a shape image for a specific window (stencil image).
+ *
+ * This instruction is used to fetch the stencil image data for a window from the WebX Engine.
+ */
+export declare class WebXShapeInstruction extends WebXInstruction {
+    /**
+     * The ID of the window for which the image is requested.
+     */
+    readonly windowId: number;
+    /**
+     * Constructs a new WebXImageInstruction.
+     *
+     * @param windowId The ID of the window.
+     */
+    constructor(windowId: number);
+}

package/dist/src/instruction/WebXShapeInstruction.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebXShapeInstruction = void 0;
+const WebXInstruction_1 = require("./WebXInstruction");
+const WebXInstructionType_1 = require("./WebXInstructionType");
+/**
+ * Represents an instruction to request a shape image for a specific window (stencil image).
+ *
+ * This instruction is used to fetch the stencil image data for a window from the WebX Engine.
+ */
+class WebXShapeInstruction extends WebXInstruction_1.WebXInstruction {
+    /**
+     * Constructs a new WebXImageInstruction.
+     *
+     * @param windowId The ID of the window.
+     */
+    constructor(windowId) {
+        super(WebXInstructionType_1.WebXInstructionType.SHAPE);
+        this.windowId = windowId;
+    }
+}
+exports.WebXShapeInstruction = WebXShapeInstruction;
+//# sourceMappingURL=WebXShapeInstruction.js.map

package/dist/src/instruction/WebXShapeInstruction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebXShapeInstruction.js","sourceRoot":"","sources":["../../../src/instruction/WebXShapeInstruction.ts"],"names":[],"mappings":";;;AAAA,uDAAoD;AACpD,+DAA4D;AAE5D;;;;GAIG;AACH,MAAa,oBAAqB,SAAQ,iCAAe;IAMvD;;;;OAIG;IACH,YAAY,QAAgB;QAC1B,KAAK,CAAC,yCAAmB,CAAC,KAAK,CAAC,CAAC;QACjC,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC3B,CAAC;CACF;AAfD,oDAeC"}

package/dist/src/instruction/WebXWindowsInstruction.d.ts

@@ -0,0 +1,13 @@
+import { WebXInstruction } from './WebXInstruction';
+/**
+ * Represents an instruction to request the list of visible windows.
+ *
+ * This instruction is used to fetch information about all currently visible
+ * windows from the WebX Engine.
+ */
+export declare class WebXWindowsInstruction extends WebXInstruction {
+    /**
+     * Constructs a new WebXWindowsInstruction.
+     */
+    constructor();
+}

package/dist/src/instruction/WebXWindowsInstruction.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebXWindowsInstruction = void 0;
+const WebXInstruction_1 = require("./WebXInstruction");
+const WebXInstructionType_1 = require("./WebXInstructionType");
+/**
+ * Represents an instruction to request the list of visible windows.
+ *
+ * This instruction is used to fetch information about all currently visible
+ * windows from the WebX Engine.
+ */
+class WebXWindowsInstruction extends WebXInstruction_1.WebXInstruction {
+    /**
+     * Constructs a new WebXWindowsInstruction.
+     */
+    constructor() {
+        super(WebXInstructionType_1.WebXInstructionType.WINDOWS);
+    }
+}
+exports.WebXWindowsInstruction = WebXWindowsInstruction;
+//# sourceMappingURL=WebXWindowsInstruction.js.map

package/dist/src/instruction/WebXWindowsInstruction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebXWindowsInstruction.js","sourceRoot":"","sources":["../../../src/instruction/WebXWindowsInstruction.ts"],"names":[],"mappings":";;;AAAA,uDAAoD;AACpD,+DAA4D;AAE5D;;;;;GAKG;AACH,MAAa,sBAAuB,SAAQ,iCAAe;IACzD;;OAEG;IACH;QACE,KAAK,CAAC,yCAAmB,CAAC,OAAO,CAAC,CAAC;IACrC,CAAC;CACF;AAPD,wDAOC"}

package/dist/src/instruction/index.d.ts

@@ -0,0 +1,15 @@
+export * from './WebXInstruction';
+export * from './WebXInstructionResponse';
+export * from './WebXInstructionType';
+export * from './WebXConnectInstruction';
+export * from './WebXScreenInstruction';
+export * from './WebXWindowsInstruction';
+export * from './WebXImageInstruction';
+export * from './WebXMouseInstruction';
+export * from './WebXKeyboardInstruction';
+export * from './WebXCursorImageInstruction';
+export * from './WebXQualityInstruction';
+export * from './WebXPongInstruction';
+export * from './WebXDataAckInstruction';
+export * from './WebXClipboardInstruction';
+export * from './WebXShapeInstruction';

package/dist/src/instruction/index.js

@@ -0,0 +1,32 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./WebXInstruction"), exports);
+__exportStar(require("./WebXInstructionResponse"), exports);
+__exportStar(require("./WebXInstructionType"), exports);
+__exportStar(require("./WebXConnectInstruction"), exports);
+__exportStar(require("./WebXScreenInstruction"), exports);
+__exportStar(require("./WebXWindowsInstruction"), exports);
+__exportStar(require("./WebXImageInstruction"), exports);
+__exportStar(require("./WebXMouseInstruction"), exports);
+__exportStar(require("./WebXKeyboardInstruction"), exports);
+__exportStar(require("./WebXCursorImageInstruction"), exports);
+__exportStar(require("./WebXQualityInstruction"), exports);
+__exportStar(require("./WebXPongInstruction"), exports);
+__exportStar(require("./WebXDataAckInstruction"), exports);
+__exportStar(require("./WebXClipboardInstruction"), exports);
+__exportStar(require("./WebXShapeInstruction"), exports);
+//# sourceMappingURL=index.js.map

package/dist/src/instruction/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/instruction/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,oDAAkC;AAClC,4DAA0C;AAC1C,wDAAsC;AACtC,2DAAyC;AACzC,0DAAwC;AACxC,2DAAyC;AACzC,yDAAuC;AACvC,yDAAuC;AACvC,4DAA0C;AAC1C,+DAA6C;AAC7C,2DAAyC;AACzC,wDAAsC;AACtC,2DAAyC;AACzC,6DAA2C;AAC3C,yDAAuC"}