tauri-plugin-serialplugin-api 2.18.0

package/dist-js/index.js

@@ -0,0 +1,1112 @@
+import { invoke } from '@tauri-apps/api/core';
+import { listen } from '@tauri-apps/api/event';
+
+/**
+ * Auto-reconnect manager for serial ports
+ * Handles automatic reconnection logic with configurable settings
+ */
+class AutoReconnectManager {
+    constructor() {
+        this.enabled = false;
+        this.interval = 5000; // 5 seconds default
+        this.maxAttempts = 10; // 10 attempts default, null for infinite
+        this.currentAttempts = 0;
+        this.timer = null;
+    }
+    /**
+     * @description Enables auto-reconnect functionality
+     * @param {Object} options Auto-reconnect configuration options
+     * @param {number} [options.interval=5000] Reconnection interval in milliseconds
+     * @param {number | null} [options.maxAttempts=10] Maximum number of reconnection attempts (null for infinite)
+     * @param {Function} [options.onReconnect] Callback function called on each reconnection attempt
+     * @param {Function} options.reconnectFunction Function that performs the actual reconnection
+     * @returns {Promise<void>} A promise that resolves when auto-reconnect is enabled
+     */
+    async enable(options) {
+        if (this.enabled) {
+            console.warn('Auto-reconnect is already enabled');
+            return;
+        }
+        this.enabled = true;
+        this.interval = options.interval || 5000;
+        this.maxAttempts = options.maxAttempts === undefined ? 10 : options.maxAttempts;
+        this.currentAttempts = 0;
+        this.callback = options.onReconnect;
+        this.reconnectFunction = options.reconnectFunction;
+        console.log(`Auto-reconnect enabled: interval=${this.interval}ms, maxAttempts=${this.maxAttempts === null ? 'infinite' : this.maxAttempts}`);
+    }
+    /**
+     * @description Disables auto-reconnect functionality
+     * @returns {Promise<void>} A promise that resolves when auto-reconnect is disabled
+     */
+    async disable() {
+        if (!this.enabled) {
+            console.warn('Auto-reconnect is not enabled');
+            return;
+        }
+        this.enabled = false;
+        this.currentAttempts = 0;
+        this.callback = undefined;
+        this.reconnectFunction = undefined;
+        // Clear any pending reconnect timer
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        console.log('Auto-reconnect disabled');
+    }
+    /**
+     * @description Gets auto-reconnect status and configuration
+     * @returns {Object} Auto-reconnect information
+     */
+    getInfo() {
+        return {
+            enabled: this.enabled,
+            interval: this.interval,
+            maxAttempts: this.maxAttempts,
+            currentAttempts: this.currentAttempts,
+            hasCallback: !!this.callback
+        };
+    }
+    /**
+     * @description Starts the auto-reconnect process
+     * @returns {Promise<void>} A promise that resolves when auto-reconnect process starts
+     */
+    async start() {
+        if (!this.enabled || !this.reconnectFunction) {
+            return;
+        }
+        this.currentAttempts = 0;
+        await this.performAttempt();
+    }
+    /**
+     * @description Stops the auto-reconnect process (clears timer but keeps enabled)
+     * @returns {Promise<void>} A promise that resolves when auto-reconnect process stops
+     */
+    async stop() {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+    }
+    /**
+     * @description Resets the attempt counter
+     * @returns {Promise<void>} A promise that resolves when counter is reset
+     */
+    async reset() {
+        this.currentAttempts = 0;
+    }
+    /**
+     * @description Internal method to perform a single reconnection attempt
+     * @returns {Promise<void>} A promise that resolves when the attempt is complete
+     */
+    async performAttempt() {
+        if (!this.enabled || !this.reconnectFunction) {
+            return;
+        }
+        // Проверяем лимит ДО увеличения счётчика
+        if (this.maxAttempts !== null && this.currentAttempts >= this.maxAttempts) {
+            console.error(`Auto-reconnect failed after ${this.maxAttempts} attempts`);
+            if (this.callback) {
+                this.callback(false, this.currentAttempts);
+            }
+            return;
+        }
+        this.currentAttempts++;
+        console.log(`Auto-reconnect attempt ${this.currentAttempts}${this.maxAttempts !== null ? `/${this.maxAttempts}` : ''}`);
+        try {
+            const success = await this.reconnectFunction();
+            if (success) {
+                console.log('Auto-reconnect successful');
+                this.currentAttempts = 0; // Reset counter on success
+                if (this.callback) {
+                    this.callback(true, this.currentAttempts);
+                }
+            }
+            else {
+                throw new Error('Reconnect function returned false');
+            }
+        }
+        catch (error) {
+            console.error(`Auto-reconnect attempt ${this.currentAttempts} failed:`, error);
+            if (this.callback) {
+                this.callback(false, this.currentAttempts);
+            }
+            // Schedule next attempt
+            if (this.enabled) {
+                this.timer = setTimeout(() => {
+                    this.performAttempt();
+                }, this.interval);
+            }
+        }
+    }
+    isEnabled() {
+        return this.enabled;
+    }
+    getInterval() {
+        return this.interval;
+    }
+    getMaxAttempts() {
+        return this.maxAttempts;
+    }
+    getCurrentAttempts() {
+        return this.currentAttempts;
+    }
+    hasCallback() {
+        return !!this.callback;
+    }
+}
+
+class ListenerManager {
+    constructor() {
+        this.listeners = new Map();
+        this.listenerIdCounter = 0;
+    }
+    add(type, unlisten) {
+        const id = `${type}_${++this.listenerIdCounter}`;
+        this.listeners.set(id, { unlisten, type });
+        return () => {
+            try {
+                this.delete(id);
+                if (typeof unlisten === 'function') {
+                    unlisten();
+                }
+            }
+            catch (error) {
+                console.warn(`Error in unlisten function for ${id}:`, error);
+            }
+        };
+    }
+    set(id, listener) {
+        this.listeners.set(id, listener);
+        return () => {
+            try {
+                this.delete(id);
+                if (typeof listener.unlisten === 'function') {
+                    listener.unlisten();
+                }
+            }
+            catch (error) {
+                console.warn(`Error in unlisten function for ${id}:`, error);
+            }
+        };
+    }
+    delete(id) {
+        this.listeners.delete(id);
+    }
+    entries() {
+        return this.listeners.entries();
+    }
+    filterByType(type) {
+        return Array.from(this.listeners.entries()).filter(([_, l]) => l.type === type);
+    }
+    all() {
+        return Array.from(this.listeners.entries());
+    }
+    clear() {
+        this.listeners.clear();
+    }
+    getInfo() {
+        const all = this.all();
+        const data = all.filter(([_, l]) => l.type === 'data');
+        const disconnect = all.filter(([_, l]) => l.type === 'disconnect');
+        return {
+            total: all.length,
+            data: data.length,
+            disconnect: disconnect.length,
+            ids: all.map(([id]) => id)
+        };
+    }
+    get(id) {
+        return this.listeners.get(id);
+    }
+}
+
+var DataBits;
+(function (DataBits) {
+    DataBits["Five"] = "Five";
+    DataBits["Six"] = "Six";
+    DataBits["Seven"] = "Seven";
+    DataBits["Eight"] = "Eight";
+})(DataBits || (DataBits = {}));
+var FlowControl;
+(function (FlowControl) {
+    FlowControl["None"] = "None";
+    FlowControl["Software"] = "Software";
+    FlowControl["Hardware"] = "Hardware";
+})(FlowControl || (FlowControl = {}));
+var Parity;
+(function (Parity) {
+    Parity["None"] = "None";
+    Parity["Odd"] = "Odd";
+    Parity["Even"] = "Even";
+})(Parity || (Parity = {}));
+var StopBits;
+(function (StopBits) {
+    StopBits["One"] = "One";
+    StopBits["Two"] = "Two";
+})(StopBits || (StopBits = {}));
+var ClearBuffer;
+(function (ClearBuffer) {
+    ClearBuffer["Input"] = "Input";
+    ClearBuffer["Output"] = "Output";
+    ClearBuffer["All"] = "All";
+})(ClearBuffer || (ClearBuffer = {}));
+class SerialPort {
+    constructor(options) {
+        this.listeners = new ListenerManager();
+        this.autoReconnectManager = new AutoReconnectManager();
+        this.isOpen = false;
+        this.encoding = options.encoding || 'utf-8';
+        this.options = {
+            path: options.path,
+            baudRate: options.baudRate,
+            dataBits: options.dataBits || DataBits.Eight,
+            flowControl: options.flowControl || FlowControl.None,
+            parity: options.parity || Parity.None,
+            stopBits: options.stopBits || StopBits.One,
+            size: options.size || 1024,
+            timeout: options.timeout || 200,
+        };
+        this.size = options.size || 1024;
+    }
+    /**
+     * @description Lists all available serial ports
+     * @returns {Promise<{ [key: string]: PortInfo }>} A promise that resolves to a map of port names to port information
+     */
+    static async available_ports() {
+        try {
+            const result = await invoke('plugin:serialplugin|available_ports');
+            return Promise.resolve(result);
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+    /**
+     * @description Lists all available serial ports using platform-specific commands
+     * @returns {Promise<{ [key: string]: PortInfo }>} A promise that resolves to a map of port names to port information
+     */
+    static async available_ports_direct() {
+        try {
+            const result = await invoke('plugin:serialplugin|available_ports_direct');
+            return Promise.resolve(result);
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+    /**
+     * @description Lists all managed serial ports (ports that are currently open and managed by the application).
+     * @returns {Promise<string[]>} A promise that resolves to an array of port paths (names).
+     */
+    static async managed_ports() {
+        try {
+            const result = await invoke('plugin:serialplugin|managed_ports');
+            return Promise.resolve(result);
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+    /**
+     * @description Forcefully closes a specific serial port
+     * @param {string} path The path of the serial port to close
+     * @returns {Promise<void>} A promise that resolves when the port is closed
+     */
+    static async forceClose(path) {
+        return await invoke('plugin:serialplugin|force_close', { path });
+    }
+    /**
+     * @description Closes all open serial ports
+     * @returns {Promise<void>} A promise that resolves when all ports are closed
+     */
+    static async closeAll() {
+        return await invoke('plugin:serialplugin|close_all');
+    }
+    /**
+     * @description Gets the full serial number for a specific port
+     * On Windows, this can fix truncated serial numbers (e.g., "B4" → "B4:3D:4D:B1:5A:C8" for ESP32 devices)
+     * @param {string} path The port path (e.g., "COM3", "/dev/ttyUSB0")
+     * @returns {Promise<string>} A promise that resolves to the full serial number, or "Unknown" if not found
+     */
+    static async get_full_serial_number(path) {
+        try {
+            const result = await invoke('plugin:serialplugin|get_full_serial_number', { path });
+            return Promise.resolve(result);
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+    /**
+     * @description Cancels listening for serial port data (does not affect disconnect listeners)
+     * @returns {Promise<void>} A promise that resolves when listening is cancelled
+     */
+    async cancelListen() {
+        try {
+            // Cancel only data listeners - disconnect listeners remain active
+            const dataListeners = this.listeners.filterByType('data');
+            for (const [id, listener] of dataListeners) {
+                try {
+                    if (typeof listener.unlisten === 'function') {
+                        listener.unlisten();
+                    }
+                }
+                catch (error) {
+                    console.warn(`Error unlistening data listener ${id}:`, error);
+                }
+                // Remove from map regardless of success/failure
+                this.listeners.delete(id);
+            }
+            return;
+        }
+        catch (error) {
+            return Promise.reject('Failed to cancel serial monitoring: ' + error);
+        }
+    }
+    /**
+     * @description Cancels all listeners (both data and disconnect listeners)
+     * @returns {Promise<void>} A promise that resolves when all listeners are cancelled
+     */
+    async cancelAllListeners() {
+        try {
+            const allListeners = this.listeners.all();
+            for (const [id, listener] of allListeners) {
+                try {
+                    if (typeof listener.unlisten === 'function') {
+                        listener.unlisten();
+                    }
+                }
+                catch (error) {
+                    console.warn(`Error unlistening listener ${id}:`, error);
+                }
+                // Remove from map regardless of success/failure
+                this.listeners.delete(id);
+            }
+            return;
+        }
+        catch (error) {
+            return Promise.reject('Failed to cancel all listeners: ' + error);
+        }
+    }
+    /**
+     * @description Gets information about active listeners (for debugging)
+     * @returns {Object} Information about active listeners
+     */
+    getListenersInfo() {
+        return this.listeners.getInfo();
+    }
+    /**
+     * @description Cancels reading data from the serial port
+     * @returns {Promise<void>} A promise that resolves when reading is cancelled
+     */
+    async cancelRead() {
+        try {
+            await invoke('plugin:serialplugin|cancel_read', {
+                path: this.options.path,
+            });
+        }
+        catch (error) {
+            return Promise.reject(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    /**
+     * @description Changes the serial port configuration
+     * @param {object} options Configuration options
+     * @param {string} [options.path] New port path
+     * @param {number} [options.baudRate] New baud rate
+     * @returns {Promise<void>} A promise that resolves when configuration is changed
+     */
+    async change(options) {
+        try {
+            let isOpened = false;
+            if (this.isOpen) {
+                isOpened = true;
+                await this.close();
+            }
+            if (options.path) {
+                this.options.path = options.path;
+            }
+            if (options.baudRate) {
+                this.options.baudRate = options.baudRate;
+            }
+            if (isOpened) {
+                await this.open();
+            }
+            return Promise.resolve();
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+    /**
+     * @description Closes the currently open serial port
+     * @returns {Promise<void>} A promise that resolves when the port is closed
+     */
+    async close() {
+        try {
+            if (!this.isOpen) {
+                return;
+            }
+            // Stop auto-reconnect temporarily to prevent conflicts
+            const wasAutoReconnectEnabled = this.autoReconnectManager.isEnabled();
+            if (wasAutoReconnectEnabled) {
+                await this.autoReconnectManager.stop();
+            }
+            // First we cancel the reading
+            try {
+                await this.cancelRead();
+            }
+            catch (cancelReadError) {
+                console.warn('Error during cancelRead:', cancelReadError);
+            }
+            // Closing the port
+            let res = undefined;
+            try {
+                res = await invoke('plugin:serialplugin|close', {
+                    path: this.options.path,
+                });
+            }
+            catch (closeError) {
+                console.warn('Error during port close:', closeError);
+            }
+            // Cancel all listeners
+            try {
+                await this.cancelAllListeners();
+            }
+            catch (cancelListenError) {
+                console.warn('Error during cancelAllListeners:', cancelListenError);
+                // Try to clear listeners manually as fallback
+                try {
+                    this.listeners.clear();
+                }
+                catch (clearError) {
+                    console.warn('Error during manual listener clear:', clearError);
+                }
+            }
+            this.isOpen = false;
+            return res;
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+    /**
+     * @description Sets up a listener for port disconnection events
+     * @param {Function} fn Callback function to handle disconnection
+     * @returns {Promise<void>} A promise that resolves when the listener is set up
+     */
+    async disconnected(fn) {
+        let sub_path = this.options.path?.toString().replaceAll(".", "-").replaceAll("/", "-");
+        let checkEvent = `plugin-serialplugin-disconnected-${sub_path}`;
+        console.log('listen event: ' + checkEvent);
+        const unListenResult = await listen(checkEvent, () => {
+            try {
+                fn();
+            }
+            catch (error) {
+                console.error(error);
+            }
+        });
+        if (typeof unListenResult === 'function') {
+            this.listeners.add('disconnect', unListenResult);
+        }
+        else {
+            console.warn('disconnected() did not return a valid unlisten function');
+        }
+    }
+    /**
+     * @description Enables auto-reconnect functionality
+     * @param {Object} options Auto-reconnect configuration options
+     * @param {number} [options.interval=5000] Reconnection interval in milliseconds
+     * @param {number | null} [options.maxAttempts=10] Maximum number of reconnection attempts (null for infinite)
+     * @param {Function} [options.onReconnect] Callback function called on each reconnection attempt
+     * @returns {Promise<void>} A promise that resolves when auto-reconnect is enabled
+     */
+    async enableAutoReconnect(options = {}) {
+        try {
+            await this.autoReconnectManager.enable({
+                ...options,
+                reconnectFunction: async () => {
+                    if (this.isOpen) {
+                        return true;
+                    }
+                    try {
+                        await this.open();
+                        return true;
+                    }
+                    catch (error) {
+                        return false;
+                    }
+                }
+            });
+            // Set up disconnect listener that triggers auto-reconnect
+            await this.disconnected(async () => {
+                this.isOpen = false;
+                if (this.autoReconnectManager.isEnabled()) {
+                    await this.autoReconnectManager.start();
+                }
+            });
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+    /**
+     * @description Disables auto-reconnect functionality
+     * @returns {Promise<void>} A promise that resolves when auto-reconnect is disabled
+     */
+    async disableAutoReconnect() {
+        try {
+            await this.autoReconnectManager.disable();
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+    /**
+     * @description Gets auto-reconnect status and configuration
+     * @returns {Object} Auto-reconnect information
+     */
+    getAutoReconnectInfo() {
+        return {
+            enabled: this.autoReconnectManager.isEnabled(),
+            interval: this.autoReconnectManager.getInterval(),
+            maxAttempts: this.autoReconnectManager.getMaxAttempts(),
+            currentAttempts: this.autoReconnectManager.getCurrentAttempts(),
+            hasCallback: this.autoReconnectManager.hasCallback(),
+        };
+    }
+    /**
+     * @description Manually triggers a reconnection attempt
+     * @returns {Promise<boolean>} A promise that resolves to true if reconnection was successful
+     */
+    async manualReconnect() {
+        try {
+            if (this.isOpen) {
+                console.log('Port is already open, no need to reconnect');
+                return true;
+            }
+            console.log('Manual reconnection attempt...');
+            await this.open();
+            console.log('Manual reconnection successful');
+            return true;
+        }
+        catch (error) {
+            console.error('Manual reconnection failed:', error);
+            return false;
+        }
+    }
+    /**
+     * @description Monitors serial port data
+     * @param {Function} fn Callback function to handle received data
+     * @param {boolean} [isDecode=true] Whether to decode the received data
+     * @returns {Promise<UnlistenFn>} A promise that resolves to an unlisten function
+     */
+    async listen(fn, isDecode = true) {
+        try {
+            if (!this.isOpen) {
+                return Promise.reject('Port is not open');
+            }
+            let sub_path = this.options.path?.toString().replaceAll(".", "-").replaceAll("/", "-");
+            let readEvent = `plugin-serialplugin-read-${sub_path}`;
+            console.log('listen event: ' + readEvent);
+            try {
+                const unListenResult = await listen(readEvent, ({ payload }) => {
+                    try {
+                        if (isDecode) {
+                            const uint8Array = new Uint8Array(payload.data);
+                            try {
+                                const decoder = new TextDecoder(this.encoding);
+                                const textData = decoder.decode(uint8Array);
+                                fn(textData);
+                            }
+                            catch (error) {
+                                console.error('Error converting to text with configured encoding:', error);
+                                try {
+                                    const fallbackDecoder = new TextDecoder('utf-8');
+                                    const textData = fallbackDecoder.decode(uint8Array);
+                                    fn(textData);
+                                }
+                                catch (fallbackError) {
+                                    console.error('Fallback decoding also failed:', fallbackError);
+                                    fn(String.fromCharCode(...uint8Array));
+                                }
+                            }
+                        }
+                        else {
+                            fn(new Uint8Array(payload.data));
+                        }
+                    }
+                    catch (error) {
+                        console.error(error);
+                    }
+                });
+                if (typeof unListenResult === 'function') {
+                    return this.listeners.add('data', unListenResult);
+                }
+                else {
+                    console.warn('listen() did not return a valid unlisten function');
+                    return Promise.reject('Failed to get unlisten function');
+                }
+            }
+            catch (listenError) {
+                console.error('Error setting up listener:', listenError);
+                throw listenError;
+            }
+        }
+        catch (error) {
+            return Promise.reject('Failed to monitor serial port data: ' + error);
+        }
+    }
+    /**
+     * @description Opens the serial port with current settings
+     * @returns {Promise<void>} A promise that resolves when the port is opened
+     */
+    async open() {
+        try {
+            if (!this.options.path) {
+                return Promise.reject(`path Can not be empty!`);
+            }
+            if (!this.options.baudRate) {
+                return Promise.reject(`baudRate Can not be empty!`);
+            }
+            if (this.isOpen) {
+                return;
+            }
+            const res = await invoke('plugin:serialplugin|open', {
+                path: this.options.path,
+                baudRate: this.options.baudRate,
+                dataBits: this.options.dataBits,
+                flowControl: this.options.flowControl,
+                parity: this.options.parity,
+                stopBits: this.options.stopBits,
+                timeout: this.options.timeout,
+            });
+            this.isOpen = true;
+            this.disconnected(() => {
+                this.isOpen = false;
+            }).catch(err => console.error(err));
+            return Promise.resolve(res);
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+    /**
+     * Starts listening for data on the serial port
+     * The port will continuously monitor for incoming data and emit events
+     * @returns {Promise<void>} A promise that resolves when listening starts
+     * @throws {Error} If starting listener fails or port is not open
+     * @example
+     * const port = new SerialPort({ path: '/dev/ttyUSB0' });
+     * await port.startListening();
+     * // Listen for data events
+     * port.listen((data) => {
+     *   console.log('listen', data)
+     *   receivedData += data;
+     * });
+     */
+    async startListening() {
+        try {
+            await invoke('plugin:serialplugin|start_listening', {
+                path: this.options.path,
+                size: this.options.size,
+                timeout: this.options.timeout,
+            });
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+    /**
+     * Stops listening for data on the serial port
+     * Cleans up event listeners and monitoring threads
+     * @returns {Promise<void>} A promise that resolves when listening stops
+     * @throws {Error} If stopping listener fails or port is not open
+     * @example
+     * await port.stopListening();
+     */
+    async stopListening() {
+        try {
+            await invoke('plugin:serialplugin|stop_listening', {
+                path: this.options.path,
+            });
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+    /**
+     * @description Reads data from the serial port
+     * @param {ReadOptions} [options] Read options
+     * @returns {Promise<void>} A promise that resolves when data is read
+     */
+    async read(options) {
+        try {
+            if (!this.isOpen) {
+                return Promise.reject('Port is not open');
+            }
+            return await invoke('plugin:serialplugin|read', {
+                path: this.options.path,
+                timeout: options?.timeout || this.options.timeout,
+                size: options?.size || this.size,
+            });
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+    /**
+     * @description Reads binary data from the serial port
+     * @param {ReadOptions} [options] Read options
+     * @returns {Promise<Uint8Array>} A promise that resolves with binary data
+     */
+    async readBinary(options) {
+        try {
+            const result = await invoke('plugin:serialplugin|read_binary', {
+                path: this.options.path,
+                timeout: options?.timeout || this.options.timeout,
+                size: options?.size || this.size,
+            });
+            return new Uint8Array(result);
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+    /**
+     * @description Sets the baud rate of the serial port
+     * @param {number} value The new baud rate
+     * @returns {Promise<void>} A promise that resolves when baud rate is set
+     */
+    async setBaudRate(value) {
+        try {
+            return await invoke('plugin:serialplugin|set_baud_rate', {
+                path: this.options.path,
+                baudRate: value
+            });
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+    /**
+     * @description Sets the data bits configuration
+     * @param {DataBits} value The new data bits setting
+     * @returns {Promise<void>} A promise that resolves when data bits are set
+     */
+    async setDataBits(value) {
+        try {
+            return await invoke('plugin:serialplugin|set_data_bits', {
+                path: this.options.path,
+                dataBits: value
+            });
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+    /**
+     * @description Sets the flow control mode
+     * @param {FlowControl} value The new flow control setting
+     * @returns {Promise<void>} A promise that resolves when flow control is set
+     */
+    async setFlowControl(value) {
+        try {
+            return await invoke('plugin:serialplugin|set_flow_control', {
+                path: this.options.path,
+                flowControl: value
+            });
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+    /**
+     * @description Sets the parity checking mode
+     * @param {Parity} value The new parity setting
+     * @returns {Promise<void>} A promise that resolves when parity is set
+     */
+    async setParity(value) {
+        try {
+            return await invoke('plugin:serialplugin|set_parity', {
+                path: this.options.path,
+                parity: value
+            });
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+    /**
+     * @description Sets the number of stop bits
+     * @param {StopBits} value The new stop bits setting
+     * @returns {Promise<void>} A promise that resolves when stop bits are set
+     */
+    async setStopBits(value) {
+        try {
+            return await invoke('plugin:serialplugin|set_stop_bits', {
+                path: this.options.path,
+                stopBits: value
+            });
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+    /**
+     * @description Sets the timeout duration
+     * @param {number} value The new timeout in milliseconds
+     * @returns {Promise<void>} A promise that resolves when timeout is set
+     */
+    async setTimeout(value) {
+        try {
+            return await invoke('plugin:serialplugin|set_timeout', {
+                path: this.options.path,
+                timeout: value
+            });
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+    /**
+     * @description Sets the RTS (Request To Send) control signal
+     * @param {boolean} value The signal level to set
+     * @returns {Promise<void>} A promise that resolves when RTS is set
+     */
+    async setRequestToSend(value) {
+        try {
+            return await invoke('plugin:serialplugin|write_request_to_send', {
+                path: this.options.path,
+                level: value
+            });
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+    /**
+     * @description Sets the DTR (Data Terminal Ready) control signal
+     * @param {boolean} value The signal level to set
+     * @returns {Promise<void>} A promise that resolves when DTR is set
+     */
+    async setDataTerminalReady(value) {
+        try {
+            return await invoke('plugin:serialplugin|write_data_terminal_ready', {
+                path: this.options.path,
+                level: value
+            });
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+    /**
+     * @description Writes the RTS (Request To Send) control signal
+     * @param {boolean} level The signal level to set
+     * @returns {Promise<void>} A promise that resolves when RTS is set
+     */
+    async writeRequestToSend(level) {
+        try {
+            return await invoke('plugin:serialplugin|write_request_to_send', {
+                path: this.options.path,
+                level: level
+            });
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+    /**
+     * @description Writes the DTR (Data Terminal Ready) control signal
+     * @param {boolean} level The signal level to set
+     * @returns {Promise<void>} A promise that resolves when DTR is set
+     */
+    async writeDataTerminalReady(level) {
+        try {
+            return await invoke('plugin:serialplugin|write_data_terminal_ready', {
+                path: this.options.path,
+                level: level
+            });
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+    /**
+     * @description Reads the CTS (Clear To Send) control signal state
+     * @returns {Promise<boolean>} A promise that resolves to the CTS state
+     */
+    async readClearToSend() {
+        try {
+            return await invoke('plugin:serialplugin|read_clear_to_send', {
+                path: this.options.path
+            });
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+    /**
+     * @description Reads the DSR (Data Set Ready) control signal state
+     * @returns {Promise<boolean>} A promise that resolves to the DSR state
+     */
+    async readDataSetReady() {
+        try {
+            return await invoke('plugin:serialplugin|read_data_set_ready', {
+                path: this.options.path
+            });
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+    /**
+     * @description Reads the RI (Ring Indicator) control signal state
+     * @returns {Promise<boolean>} A promise that resolves to the RI state
+     */
+    async readRingIndicator() {
+        try {
+            return await invoke('plugin:serialplugin|read_ring_indicator', {
+                path: this.options.path
+            });
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+    /**
+     * @description Reads the CD (Carrier Detect) control signal state
+     * @returns {Promise<boolean>} A promise that resolves to the CD state
+     */
+    async readCarrierDetect() {
+        try {
+            return await invoke('plugin:serialplugin|read_carrier_detect', {
+                path: this.options.path
+            });
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+    /**
+     * @description Gets the number of bytes available to read
+     * @returns {Promise<number>} A promise that resolves to the number of bytes
+     */
+    async bytesToRead() {
+        try {
+            return await invoke('plugin:serialplugin|bytes_to_read', {
+                path: this.options.path
+            });
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+    /**
+     * @description Gets the number of bytes waiting to be written
+     * @returns {Promise<number>} A promise that resolves to the number of bytes
+     */
+    async bytesToWrite() {
+        try {
+            return await invoke('plugin:serialplugin|bytes_to_write', {
+                path: this.options.path
+            });
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+    /**
+     * @description Clears the specified buffer
+     * @param {ClearBuffer} buffer The buffer to clear
+     * @returns {Promise<void>} A promise that resolves when the buffer is cleared
+     */
+    async clearBuffer(buffer) {
+        try {
+            return await invoke('plugin:serialplugin|clear_buffer', {
+                path: this.options.path,
+                bufferType: buffer
+            });
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+    /**
+     * @description Starts transmitting a break signal
+     * @returns {Promise<void>} A promise that resolves when break signal starts
+     */
+    async setBreak() {
+        try {
+            return await invoke('plugin:serialplugin|set_break', {
+                path: this.options.path
+            });
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+    /**
+     * @description Stops transmitting a break signal
+     * @returns {Promise<void>} A promise that resolves when break signal stops
+     */
+    async clearBreak() {
+        try {
+            return await invoke('plugin:serialplugin|clear_break', {
+                path: this.options.path
+            });
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+    /**
+     * @description Writes string data to the serial port
+     * @param {string} value The data to write
+     * @returns {Promise<number>} A promise that resolves to the number of bytes written
+     */
+    async write(value) {
+        try {
+            if (!this.isOpen) {
+                return Promise.reject(`serial port ${this.options.path} not opened!`);
+            }
+            return await invoke('plugin:serialplugin|write', {
+                value,
+                path: this.options.path,
+            });
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+    /**
+     * @description Writes binary data to the serial port
+     * @param {Uint8Array | number[]} value The binary data to write
+     * @returns {Promise<number>} A promise that resolves to the number of bytes written
+     */
+    async writeBinary(value) {
+        try {
+            if (!this.isOpen) {
+                return Promise.reject(`serial port ${this.options.path} not opened!`);
+            }
+            if (value instanceof Uint8Array || value instanceof Array) {
+                return await invoke('plugin:serialplugin|write_binary', {
+                    value: Array.from(value),
+                    path: this.options.path,
+                });
+            }
+            else {
+                return Promise.reject('value Argument type error! Expected type: string, Uint8Array, number[]');
+            }
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+}
+
+export { ClearBuffer, DataBits, FlowControl, Parity, SerialPort, StopBits };