tauri-plugin-serialplugin-api 2.18.0

package/dist-js/index.d.ts

@@ -0,0 +1,372 @@
+import { UnlistenFn } from '@tauri-apps/api/event';
+export interface PortInfo {
+    path: "Unknown" | string;
+    manufacturer: "Unknown" | string;
+    pid: "Unknown" | string;
+    product: "Unknown" | string;
+    serial_number: "Unknown" | string;
+    type: "PCI" | string;
+    vid: "Unknown" | string;
+}
+export interface ReadDataResult {
+    size: number;
+    data: number[];
+}
+export interface SerialportOptions {
+    path: string;
+    baudRate: number;
+    encoding?: string;
+    dataBits?: DataBits;
+    flowControl?: FlowControl;
+    parity?: Parity;
+    stopBits?: StopBits;
+    timeout?: number;
+    size?: number;
+    [key: string]: any;
+}
+export interface Options {
+    path?: string;
+    baudRate?: number;
+    dataBits: DataBits;
+    flowControl: FlowControl;
+    parity: Parity;
+    stopBits: StopBits;
+    size?: number;
+    timeout: number;
+    [key: string]: any;
+}
+export interface ReadOptions {
+    timeout?: number;
+    size?: number;
+}
+export declare enum DataBits {
+    Five = "Five",
+    Six = "Six",
+    Seven = "Seven",
+    Eight = "Eight"
+}
+export declare enum FlowControl {
+    None = "None",
+    Software = "Software",
+    Hardware = "Hardware"
+}
+export declare enum Parity {
+    None = "None",
+    Odd = "Odd",
+    Even = "Even"
+}
+export declare enum StopBits {
+    One = "One",
+    Two = "Two"
+}
+export declare enum ClearBuffer {
+    Input = "Input",
+    Output = "Output",
+    All = "All"
+}
+export type SerialPortConfig = {
+    path: string;
+    baudRate: number;
+    dataBits?: DataBits;
+    flowControl?: FlowControl;
+    parity?: Parity;
+    stopBits?: StopBits;
+    timeout?: number;
+    size?: number;
+    encoding?: string;
+};
+export type BaudRate = 110 | 300 | 600 | 1200 | 2400 | 4800 | 9600 | 14400 | 19200 | 38400 | 57600 | 115200 | 230400 | 460800 | 921600;
+declare class SerialPort {
+    isOpen: boolean;
+    encoding: string;
+    options: Options;
+    size: number;
+    private listeners;
+    private autoReconnectManager;
+    constructor(options: SerialportOptions);
+    /**
+     * @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 available_ports(): Promise<{
+        [key: string]: PortInfo;
+    }>;
+    /**
+     * @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 available_ports_direct(): Promise<{
+        [key: string]: PortInfo;
+    }>;
+    /**
+     * @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 managed_ports(): Promise<string[]>;
+    /**
+     * @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 forceClose(path: string): Promise<void>;
+    /**
+     * @description Closes all open serial ports
+     * @returns {Promise<void>} A promise that resolves when all ports are closed
+     */
+    static closeAll(): Promise<void>;
+    /**
+     * @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 get_full_serial_number(path: string): Promise<string>;
+    /**
+     * @description Cancels listening for serial port data (does not affect disconnect listeners)
+     * @returns {Promise<void>} A promise that resolves when listening is cancelled
+     */
+    cancelListen(): Promise<void>;
+    /**
+     * @description Cancels all listeners (both data and disconnect listeners)
+     * @returns {Promise<void>} A promise that resolves when all listeners are cancelled
+     */
+    cancelAllListeners(): Promise<void>;
+    /**
+     * @description Gets information about active listeners (for debugging)
+     * @returns {Object} Information about active listeners
+     */
+    getListenersInfo(): {
+        total: number;
+        data: number;
+        disconnect: number;
+        ids: string[];
+    };
+    /**
+     * @description Cancels reading data from the serial port
+     * @returns {Promise<void>} A promise that resolves when reading is cancelled
+     */
+    private cancelRead;
+    /**
+     * @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
+     */
+    change(options: {
+        path?: string;
+        baudRate?: number;
+    }): Promise<void>;
+    /**
+     * @description Closes the currently open serial port
+     * @returns {Promise<void>} A promise that resolves when the port is closed
+     */
+    close(): Promise<void>;
+    /**
+     * @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
+     */
+    disconnected(fn: (...args: any[]) => void): Promise<void>;
+    /**
+     * @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
+     */
+    enableAutoReconnect(options?: {
+        interval?: number;
+        maxAttempts?: number | null;
+        onReconnect?: (success: boolean, attempt: number) => void;
+    }): Promise<void>;
+    /**
+     * @description Disables auto-reconnect functionality
+     * @returns {Promise<void>} A promise that resolves when auto-reconnect is disabled
+     */
+    disableAutoReconnect(): Promise<void>;
+    /**
+     * @description Gets auto-reconnect status and configuration
+     * @returns {Object} Auto-reconnect information
+     */
+    getAutoReconnectInfo(): {
+        enabled: boolean;
+        interval: number;
+        maxAttempts: number | null;
+        currentAttempts: number;
+        hasCallback: boolean;
+    };
+    /**
+     * @description Manually triggers a reconnection attempt
+     * @returns {Promise<boolean>} A promise that resolves to true if reconnection was successful
+     */
+    manualReconnect(): Promise<boolean>;
+    /**
+     * @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
+     */
+    listen(fn: (...args: any[]) => void, isDecode?: boolean): Promise<UnlistenFn>;
+    /**
+     * @description Opens the serial port with current settings
+     * @returns {Promise<void>} A promise that resolves when the port is opened
+     */
+    open(): Promise<void>;
+    /**
+     * 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;
+     * });
+     */
+    startListening(): Promise<void>;
+    /**
+     * 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();
+     */
+    stopListening(): Promise<void>;
+    /**
+     * @description Reads data from the serial port
+     * @param {ReadOptions} [options] Read options
+     * @returns {Promise<void>} A promise that resolves when data is read
+     */
+    read(options?: ReadOptions): Promise<string>;
+    /**
+     * @description Reads binary data from the serial port
+     * @param {ReadOptions} [options] Read options
+     * @returns {Promise<Uint8Array>} A promise that resolves with binary data
+     */
+    readBinary(options?: ReadOptions): Promise<Uint8Array>;
+    /**
+     * @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
+     */
+    setBaudRate(value: number | BaudRate): Promise<void>;
+    /**
+     * @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
+     */
+    setDataBits(value: DataBits): Promise<void>;
+    /**
+     * @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
+     */
+    setFlowControl(value: FlowControl): Promise<void>;
+    /**
+     * @description Sets the parity checking mode
+     * @param {Parity} value The new parity setting
+     * @returns {Promise<void>} A promise that resolves when parity is set
+     */
+    setParity(value: Parity): Promise<void>;
+    /**
+     * @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
+     */
+    setStopBits(value: StopBits): Promise<void>;
+    /**
+     * @description Sets the timeout duration
+     * @param {number} value The new timeout in milliseconds
+     * @returns {Promise<void>} A promise that resolves when timeout is set
+     */
+    setTimeout(value: number): Promise<void>;
+    /**
+     * @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
+     */
+    setRequestToSend(value: boolean): Promise<void>;
+    /**
+     * @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
+     */
+    setDataTerminalReady(value: boolean): Promise<void>;
+    /**
+     * @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
+     */
+    writeRequestToSend(level: boolean): Promise<void>;
+    /**
+     * @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
+     */
+    writeDataTerminalReady(level: boolean): Promise<void>;
+    /**
+     * @description Reads the CTS (Clear To Send) control signal state
+     * @returns {Promise<boolean>} A promise that resolves to the CTS state
+     */
+    readClearToSend(): Promise<boolean>;
+    /**
+     * @description Reads the DSR (Data Set Ready) control signal state
+     * @returns {Promise<boolean>} A promise that resolves to the DSR state
+     */
+    readDataSetReady(): Promise<boolean>;
+    /**
+     * @description Reads the RI (Ring Indicator) control signal state
+     * @returns {Promise<boolean>} A promise that resolves to the RI state
+     */
+    readRingIndicator(): Promise<boolean>;
+    /**
+     * @description Reads the CD (Carrier Detect) control signal state
+     * @returns {Promise<boolean>} A promise that resolves to the CD state
+     */
+    readCarrierDetect(): Promise<boolean>;
+    /**
+     * @description Gets the number of bytes available to read
+     * @returns {Promise<number>} A promise that resolves to the number of bytes
+     */
+    bytesToRead(): Promise<number>;
+    /**
+     * @description Gets the number of bytes waiting to be written
+     * @returns {Promise<number>} A promise that resolves to the number of bytes
+     */
+    bytesToWrite(): Promise<number>;
+    /**
+     * @description Clears the specified buffer
+     * @param {ClearBuffer} buffer The buffer to clear
+     * @returns {Promise<void>} A promise that resolves when the buffer is cleared
+     */
+    clearBuffer(buffer: ClearBuffer): Promise<void>;
+    /**
+     * @description Starts transmitting a break signal
+     * @returns {Promise<void>} A promise that resolves when break signal starts
+     */
+    setBreak(): Promise<void>;
+    /**
+     * @description Stops transmitting a break signal
+     * @returns {Promise<void>} A promise that resolves when break signal stops
+     */
+    clearBreak(): Promise<void>;
+    /**
+     * @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
+     */
+    write(value: string): Promise<number>;
+    /**
+     * @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
+     */
+    writeBinary(value: Uint8Array | number[]): Promise<number>;
+}
+export { SerialPort };