tauri-plugin-tcpclient-api 0.1.0

package/README.md

@@ -0,0 +1,136 @@
+# tauri-plugin-tcpclient
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Tauri](https://img.shields.io/badge/Tauri-v2-blue.svg)](https://tauri.app)
+
+A Tauri plugin for TCP client connections. Send and receive TCP data directly from JavaScript.
+
+## Features
+
+- Connect to TCP servers from JavaScript
+- Send and receive data asynchronously
+- Event-based notifications for connection state changes
+- Support for binding to specific local addresses
+- Proper error handling including Windows disconnect detection
+
+## Platform Support
+
+| Platform | Supported |
+| -------- | --------- |
+| Linux    | ✓         |
+| Windows  | ✓         |
+| macOS    | ✓         |
+
+## Installation
+
+### Rust
+
+Add to your `src-tauri/Cargo.toml`:
+
+```toml
+[dependencies]
+tauri-plugin-tcpclient = "0.1"
+```
+
+### JavaScript
+
+```sh
+npm install @x93008/plugin-tcpclient
+```
+
+## Usage
+
+### Register Plugin
+
+```rust
+// src-tauri/src/lib.rs
+fn main() {
+    tauri::Builder::default()
+        .plugin(tauri_plugin_tcpclient::init())
+        .run(tauri::generate_context!())
+        .expect("error while running tauri application");
+}
+```
+
+### JavaScript API
+
+```typescript
+import {
+  connect,
+  send,
+  sendString,
+  disconnect,
+  listenEvents,
+  isConnected,
+  getConnections,
+  decodeMessage,
+} from '@x93008/plugin-tcpclient';
+
+// Listen for events
+const unlisten = await listenEvents((event) => {
+  const { id, event: e } = event.payload;
+
+  switch (e.type) {
+    case 'Connect':
+      console.log(`[${id}] Connected to ${e.data.endpoint}`);
+      break;
+    case 'Message':
+      const text = decodeMessage(e.data.data);
+      console.log(`[${id}] Received: ${text}`);
+      break;
+    case 'Disconnect':
+      console.log(`[${id}] Disconnected: ${e.data.reason.type}`);
+      break;
+    case 'Error':
+      console.error(`[${id}] Error: ${e.data.message}`);
+      break;
+  }
+});
+
+// Connect to server
+await connect('my-conn', '192.168.1.100:8080');
+
+// Check connection
+console.log('Connected:', await isConnected('my-conn'));
+
+// Send string
+await sendString('my-conn', 'Hello World');
+
+// Send raw bytes
+await send('my-conn', [0x01, 0x02, 0x03]);
+
+// Get all connections
+console.log('Active connections:', await getConnections());
+
+// Disconnect
+await disconnect('my-conn');
+
+// Stop listening
+unlisten();
+```
+
+## API Reference
+
+| Function | Description |
+|----------|-------------|
+| `connect(id, endpoint)` | Connect to TCP server |
+| `connectWithBind(id, localAddr, endpoint)` | Connect with specific local address |
+| `send(id, data)` | Send bytes to server |
+| `sendString(id, text)` | Send string to server |
+| `disconnect(id)` | Close connection |
+| `isConnected(id)` | Check if connection exists |
+| `getConnections()` | Get all active connection IDs |
+| `listenEvents(callback)` | Listen for TCP events |
+
+## Events
+
+| Event | Description |
+|-------|-------------|
+| `Connect` | Connection established |
+| `Message` | Data received from server |
+| `Disconnect` | Connection closed (with reason) |
+| `Error` | Error occurred |
+
+## License
+
+MIT License

package/dist-js/index.cjs

@@ -0,0 +1,86 @@
+'use strict';
+
+var core = require('@tauri-apps/api/core');
+var event = require('@tauri-apps/api/event');
+
+// ============================================================================
+// API Functions
+// ============================================================================
+/**
+ * Connect to a TCP server
+ * @param id - Unique identifier for this connection
+ * @param endpoint - Server address (e.g., "192.168.1.100:8080")
+ */
+async function connect(id, endpoint) {
+    await core.invoke('plugin:tcpclient|connect', { id, endpoint });
+}
+/**
+ * Connect to a TCP server with a specific local address
+ * @param id - Unique identifier for this connection
+ * @param localAddr - Local address to bind (e.g., "192.168.1.100:0")
+ * @param endpoint - Server address (e.g., "192.168.1.100:8080")
+ */
+async function connectWithBind(id, localAddr, endpoint) {
+    await core.invoke('plugin:tcpclient|connect_with_bind', { id, localAddr, endpoint });
+}
+/**
+ * Disconnect from a TCP server
+ * @param id - Connection identifier
+ */
+async function disconnect(id) {
+    await core.invoke('plugin:tcpclient|disconnect', { id });
+}
+/**
+ * Send data to the TCP server
+ * @param id - Connection identifier
+ * @param data - Data to send (as byte array or Uint8Array)
+ */
+async function send(id, data) {
+    const dataArray = data instanceof Uint8Array ? Array.from(data) : data;
+    await core.invoke('plugin:tcpclient|send', { id, data: dataArray });
+}
+/**
+ * Send a string to the TCP server (UTF-8 encoded)
+ * @param id - Connection identifier
+ * @param text - Text to send
+ */
+async function sendString(id, text) {
+    const encoder = new TextEncoder();
+    await send(id, encoder.encode(text));
+}
+/**
+ * Check if a connection exists
+ * @param id - Connection identifier
+ */
+async function isConnected(id) {
+    return await core.invoke('plugin:tcpclient|is_connected', { id });
+}
+/**
+ * Get all active connection IDs
+ */
+async function getConnections() {
+    return await core.invoke('plugin:tcpclient|get_connections');
+}
+/**
+ * Listen for TCP client events
+ * @param callback - Event callback function
+ */
+async function listenEvents(callback) {
+    return await event.listen('plugin://tcpclient', callback);
+}
+/**
+ * Decode message data to string
+ */
+function decodeMessage(data) {
+    return new TextDecoder().decode(new Uint8Array(data));
+}
+
+exports.connect = connect;
+exports.connectWithBind = connectWithBind;
+exports.decodeMessage = decodeMessage;
+exports.disconnect = disconnect;
+exports.getConnections = getConnections;
+exports.isConnected = isConnected;
+exports.listenEvents = listenEvents;
+exports.send = send;
+exports.sendString = sendString;

package/dist-js/index.d.ts

@@ -0,0 +1,94 @@
+import { UnlistenFn } from '@tauri-apps/api/event';
+/** Disconnect reason */
+export type DisconnectReason = {
+    type: 'Normal';
+} | {
+    type: 'Reset';
+} | {
+    type: 'Timeout';
+} | {
+    type: 'Error';
+    data: string;
+};
+/** Event types */
+export type EventType = {
+    type: 'Connect';
+    data: {
+        endpoint: string;
+    };
+} | {
+    type: 'Disconnect';
+    data: {
+        endpoint: string;
+        reason: DisconnectReason;
+    };
+} | {
+    type: 'Message';
+    data: {
+        endpoint: string;
+        data: number[];
+    };
+} | {
+    type: 'Error';
+    data: {
+        endpoint: string;
+        message: string;
+    };
+};
+/** Event payload */
+export interface EventPayload {
+    id: string;
+    event: EventType;
+}
+/** Event callback type */
+export type EventCallback = (event: {
+    payload: EventPayload;
+}) => void;
+/**
+ * Connect to a TCP server
+ * @param id - Unique identifier for this connection
+ * @param endpoint - Server address (e.g., "192.168.1.100:8080")
+ */
+export declare function connect(id: string, endpoint: string): Promise<void>;
+/**
+ * Connect to a TCP server with a specific local address
+ * @param id - Unique identifier for this connection
+ * @param localAddr - Local address to bind (e.g., "192.168.1.100:0")
+ * @param endpoint - Server address (e.g., "192.168.1.100:8080")
+ */
+export declare function connectWithBind(id: string, localAddr: string, endpoint: string): Promise<void>;
+/**
+ * Disconnect from a TCP server
+ * @param id - Connection identifier
+ */
+export declare function disconnect(id: string): Promise<void>;
+/**
+ * Send data to the TCP server
+ * @param id - Connection identifier
+ * @param data - Data to send (as byte array or Uint8Array)
+ */
+export declare function send(id: string, data: Uint8Array | number[]): Promise<void>;
+/**
+ * Send a string to the TCP server (UTF-8 encoded)
+ * @param id - Connection identifier
+ * @param text - Text to send
+ */
+export declare function sendString(id: string, text: string): Promise<void>;
+/**
+ * Check if a connection exists
+ * @param id - Connection identifier
+ */
+export declare function isConnected(id: string): Promise<boolean>;
+/**
+ * Get all active connection IDs
+ */
+export declare function getConnections(): Promise<string[]>;
+/**
+ * Listen for TCP client events
+ * @param callback - Event callback function
+ */
+export declare function listenEvents(callback: EventCallback): Promise<UnlistenFn>;
+/**
+ * Decode message data to string
+ */
+export declare function decodeMessage(data: number[]): string;

package/dist-js/index.js

@@ -0,0 +1,76 @@
+import { invoke } from '@tauri-apps/api/core';
+import { listen } from '@tauri-apps/api/event';
+
+// ============================================================================
+// API Functions
+// ============================================================================
+/**
+ * Connect to a TCP server
+ * @param id - Unique identifier for this connection
+ * @param endpoint - Server address (e.g., "192.168.1.100:8080")
+ */
+async function connect(id, endpoint) {
+    await invoke('plugin:tcpclient|connect', { id, endpoint });
+}
+/**
+ * Connect to a TCP server with a specific local address
+ * @param id - Unique identifier for this connection
+ * @param localAddr - Local address to bind (e.g., "192.168.1.100:0")
+ * @param endpoint - Server address (e.g., "192.168.1.100:8080")
+ */
+async function connectWithBind(id, localAddr, endpoint) {
+    await invoke('plugin:tcpclient|connect_with_bind', { id, localAddr, endpoint });
+}
+/**
+ * Disconnect from a TCP server
+ * @param id - Connection identifier
+ */
+async function disconnect(id) {
+    await invoke('plugin:tcpclient|disconnect', { id });
+}
+/**
+ * Send data to the TCP server
+ * @param id - Connection identifier
+ * @param data - Data to send (as byte array or Uint8Array)
+ */
+async function send(id, data) {
+    const dataArray = data instanceof Uint8Array ? Array.from(data) : data;
+    await invoke('plugin:tcpclient|send', { id, data: dataArray });
+}
+/**
+ * Send a string to the TCP server (UTF-8 encoded)
+ * @param id - Connection identifier
+ * @param text - Text to send
+ */
+async function sendString(id, text) {
+    const encoder = new TextEncoder();
+    await send(id, encoder.encode(text));
+}
+/**
+ * Check if a connection exists
+ * @param id - Connection identifier
+ */
+async function isConnected(id) {
+    return await invoke('plugin:tcpclient|is_connected', { id });
+}
+/**
+ * Get all active connection IDs
+ */
+async function getConnections() {
+    return await invoke('plugin:tcpclient|get_connections');
+}
+/**
+ * Listen for TCP client events
+ * @param callback - Event callback function
+ */
+async function listenEvents(callback) {
+    return await listen('plugin://tcpclient', callback);
+}
+/**
+ * Decode message data to string
+ */
+function decodeMessage(data) {
+    return new TextDecoder().decode(new Uint8Array(data));
+}
+
+export { connect, connectWithBind, decodeMessage, disconnect, getConnections, isConnected, listenEvents, send, sendString };

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "tauri-plugin-tcpclient-api",
+  "version": "0.1.0",
+  "author": "x93008",
+  "description": "A Tauri plugin for TCP client connections",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/x93008/tauri-plugin-tcpclient"
+  },
+  "type": "module",
+  "types": "./dist-js/index.d.ts",
+  "main": "./dist-js/index.cjs",
+  "module": "./dist-js/index.js",
+  "exports": {
+    "types": "./dist-js/index.d.ts",
+    "import": "./dist-js/index.js",
+    "require": "./dist-js/index.cjs"
+  },
+  "files": [
+    "dist-js",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "rollup -c",
+    "prepublishOnly": "npm run build",
+    "pretest": "npm run build"
+  },
+  "dependencies": {
+    "@tauri-apps/api": "^2.0.0"
+  },
+  "devDependencies": {
+    "@rollup/plugin-typescript": "^12.0.0",
+    "rollup": "^4.9.6",
+    "typescript": "^5.3.3",
+    "tslib": "^2.6.2"
+  },
+  "keywords": [
+    "tauri",
+    "tcp",
+    "client",
+    "network",
+    "plugin"
+  ]
+}