@kelnishi/satmouse-client 0.9.9 → 0.9.13

package/dist/react/index.d.ts

@@ -21,6 +21,8 @@ interface SpatialData {
     translation: Vec3;
     rotation: Vec3;
     timestamp: number;
+    /** Source device ID (e.g., "cnx-c635", "hid-054c-5c4") */
+    deviceId?: string;
 }
 /** Button press/release event — matches button-event.schema.json */
 interface ButtonEvent {
@@ -39,7 +41,7 @@ interface DeviceInfo$1 {
     connectionType?: "usb" | "wireless" | "bluetooth" | "unknown";
     connected?: boolean;
 }
-type ConnectionState = "disconnected" | "connecting" | "connected";
+type ConnectionState = "disconnected" | "connecting" | "connected" | "failed";
 type TransportProtocol = "webtransport" | "websocket" | "none";
 interface SatMouseEvents {
     spatialData: (data: SpatialData) => void;
@@ -67,6 +69,8 @@ interface ConnectOptions {
     transports?: TransportProtocol[];
     /** Auto-reconnect delay in ms. 0 to disable. Default: 2000 */
     reconnectDelay?: number;
+    /** Max reconnect attempts before giving up. Default: 3 */
+    maxRetries?: number;
     /** WebSocket subprotocol. Default: "satmouse-json" */
     wsSubprotocol?: "satmouse-json" | "satmouse-binary";
 }
@@ -83,12 +87,15 @@ declare class SatMouseConnection extends TypedEmitter<SatMouseEvents> {
     private reconnectTimer;
     private intentionalClose;
     private deviceInfoUrl;
+    private retryCount;
     private _state;
     private _protocol;
     get state(): ConnectionState;
     get protocol(): TransportProtocol;
     constructor(options?: ConnectOptions);
     connect(): Promise<void>;
+    /** Reset retry count and reconnect. Use after "failed" state. */
+    retry(): void;
     disconnect(): void;
     fetchDeviceInfo(): Promise<DeviceInfo$1[]>;
     private tryTransport;
@@ -212,6 +219,9 @@ declare class InputManager extends TypedEmitter<InputManagerEvents> {
     private connections;
     private storage?;
     private knownDevices;
+    private deviceAccumulators;
+    private accDirty;
+    private flushTimer;
     private _config;
     get config(): InputConfig;
     constructor(config?: Partial<InputConfig>, storage?: StorageAdapter);
@@ -240,7 +250,11 @@ declare class InputManager extends TypedEmitter<InputManagerEvents> {
     /** Register a callback for action values. Returns unsubscribe function. */
     onActionValues(callback: (values: ActionValues) => void): () => void;
     private wireConnection;
-    private processSpatialData;
+    private flushAccumulator;
+    /** Per-device transforms: flip, sensitivity, dead zone, dominant, axis remap */
+    private processPerDevice;
+    /** Global transforms applied after per-device merge: locks + action map */
+    private applyGlobalTransforms;
 }
 
 interface SatMouseContextValue {

package/dist/react/index.js

@@ -267,6 +267,7 @@ function parseSatMouseUri(uri) {
 var DEFAULT_OPTIONS = {
   transports: ["webtransport", "websocket"],
   reconnectDelay: 2e3,
+  maxRetries: 3,
   wsSubprotocol: "satmouse-json"
 };
 var SatMouseConnection = class extends TypedEmitter {
@@ -275,6 +276,7 @@ var SatMouseConnection = class extends TypedEmitter {
   reconnectTimer = null;
   intentionalClose = false;
   deviceInfoUrl = null;
+  retryCount = 0;
   _state = "disconnected";
   _protocol = "none";
   get state() {
@@ -335,6 +337,12 @@ var SatMouseConnection = class extends TypedEmitter {
     this.setState("disconnected", "none");
     this.scheduleReconnect();
   }
+  /** Reset retry count and reconnect. Use after "failed" state. */
+  retry() {
+    this.retryCount = 0;
+    this.intentionalClose = false;
+    this.connect();
+  }
   disconnect() {
     this.intentionalClose = true;
     this.clearReconnect();
@@ -366,6 +374,7 @@ var SatMouseConnection = class extends TypedEmitter {
     try {
       await adapter.connect();
       this.transport = adapter;
+      this.retryCount = 0;
       this.setState("connected", adapter.protocol);
       return true;
     } catch (err) {
@@ -381,6 +390,13 @@ var SatMouseConnection = class extends TypedEmitter {
   }
   scheduleReconnect() {
     if (this.options.reconnectDelay <= 0 || this.intentionalClose) return;
+    this.retryCount++;
+    console.log(`[SatMouse] Reconnect attempt ${this.retryCount}/${this.options.maxRetries}`);
+    if (this.retryCount > this.options.maxRetries) {
+      console.log("[SatMouse] Max retries exceeded, giving up");
+      this.setState("failed", "none");
+      return;
+    }
     this.clearReconnect();
     this.reconnectTimer = setTimeout(() => {
       this.reconnectTimer = null;
@@ -479,14 +495,17 @@ function actionValuesToSpatialData(values, timestamp) {
 // src/utils/config.ts
 var DEFAULT_CONFIG = {
   sensitivity: { translation: 1e-3, rotation: 1e-3 },
-  flip: { tx: false, ty: true, tz: true, rx: false, ry: true, rz: true },
+  flip: { tx: false, ty: false, tz: false, rx: false, ry: false, rz: false },
   deadZone: 0,
   dominant: false,
   axisRemap: { tx: "x", ty: "y", tz: "z", rx: "x", ry: "y", rz: "z" },
   lockPosition: false,
   lockRotation: false,
   actionMap: { ...DEFAULT_ACTION_MAP },
-  devices: {}
+  devices: {
+    // SpaceMouse Z-up → Three.js Y-up axis correction
+    "cnx-*": { flip: { ty: true, tz: true, ry: true, rz: true } }
+  }
 };
 function mergeConfig(base, partial) {
   const merged = {
@@ -650,6 +669,10 @@ var InputManager = class extends TypedEmitter {
   connections = [];
   storage;
   knownDevices = /* @__PURE__ */ new Map();
+  // Per-device accumulators: latest value from each device per frame tick
+  deviceAccumulators = /* @__PURE__ */ new Map();
+  accDirty = false;
+  flushTimer = null;
   _config;
   get config() {
     return this._config;
@@ -659,6 +682,7 @@ var InputManager = class extends TypedEmitter {
     this.storage = storage;
     const persisted = loadSettings(storage);
     this._config = mergeConfig(DEFAULT_CONFIG, { ...config, ...persisted });
+    this.flushTimer = setInterval(() => this.flushAccumulator(), 16);
   }
   /** Add a connection to the managed set */
   addConnection(connection) {
@@ -678,6 +702,10 @@ var InputManager = class extends TypedEmitter {
   /** Disconnect all managed connections */
   disconnect() {
     for (const c of this.connections) c.disconnect();
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
   }
   /** Fetch device info from all connections */
   async fetchDeviceInfo() {
@@ -740,9 +768,17 @@ var InputManager = class extends TypedEmitter {
   wireConnection(connection) {
     connection.on("spatialData", (raw) => {
       this.emit("rawSpatialData", raw);
-      const { spatial, actions } = this.processSpatialData(raw);
-      if (spatial) this.emit("spatialData", spatial);
-      if (actions) this.emit("actionValues", actions);
+      const id = raw.deviceId ?? "_default";
+      const processed = this.processPerDevice(raw, id);
+      this.deviceAccumulators.set(id, {
+        tx: processed.translation.x,
+        ty: processed.translation.y,
+        tz: processed.translation.z,
+        rx: processed.rotation.x,
+        ry: processed.rotation.y,
+        rz: processed.rotation.z
+      });
+      this.accDirty = true;
     });
     connection.on("buttonEvent", (event) => this.emit("buttonEvent", event));
     connection.on("stateChange", (state, proto) => this.emit("stateChange", state, proto));
@@ -752,14 +788,42 @@ var InputManager = class extends TypedEmitter {
       this.emit("deviceStatus", event, device);
     });
   }
-  processSpatialData(raw) {
-    const cfg = this._config;
+  flushAccumulator() {
+    if (!this.accDirty) return;
+    const merged = { tx: 0, ty: 0, tz: 0, rx: 0, ry: 0, rz: 0 };
+    for (const acc of this.deviceAccumulators.values()) {
+      merged.tx += acc.tx;
+      merged.ty += acc.ty;
+      merged.tz += acc.tz;
+      merged.rx += acc.rx;
+      merged.ry += acc.ry;
+      merged.rz += acc.rz;
+    }
+    this.deviceAccumulators.clear();
+    this.accDirty = false;
+    const data = {
+      translation: { x: merged.tx, y: merged.ty, z: merged.tz },
+      rotation: { x: merged.rx, y: merged.ry, z: merged.rz },
+      timestamp: performance.now() * 1e3
+    };
+    const { spatial, actions } = this.applyGlobalTransforms(data);
+    if (spatial) this.emit("spatialData", spatial);
+    if (actions) this.emit("actionValues", actions);
+  }
+  /** Per-device transforms: flip, sensitivity, dead zone, dominant, axis remap */
+  processPerDevice(raw, deviceId) {
+    const cfg = resolveDeviceConfig(this._config, deviceId);
     let data = raw;
     if (cfg.deadZone > 0) data = applyDeadZone(data, cfg.deadZone);
     if (cfg.dominant) data = applyDominant(data);
     data = applyFlip(data, cfg.flip);
     data = applyAxisRemap(data, cfg.axisRemap);
     data = applySensitivity(data, cfg.sensitivity);
+    return data;
+  }
+  /** Global transforms applied after per-device merge: locks + action map */
+  applyGlobalTransforms(data) {
+    const cfg = this._config;
     if (cfg.lockPosition) {
       data = { ...data, translation: { x: 0, y: 0, z: 0 } };
     }