@kelnishi/satmouse-client 0.9.3 → 0.9.5

package/dist/react/index.d.ts

@@ -119,7 +119,42 @@ type AxisMap = {
     rz: keyof Vec3;
 };
 
+/** Input axis identifier */
+type InputAxis = "tx" | "ty" | "tz" | "rx" | "ry" | "rz";
+/** A single action binding — maps one input axis to a named output */
+interface ActionBinding {
+    /** Which input axis drives this action */
+    source: InputAxis;
+    /** Scale multiplier (default: 1) */
+    scale?: number;
+    /** Invert the value (default: false) */
+    invert?: boolean;
+}
+/**
+ * ActionMap defines how raw 6DOF axes map to named output actions.
+ *
+ * Client apps declare the actions they support and how device axes
+ * feed into them. Users can reassign axes via the settings UI.
+ *
+ * Default: 6 actions matching the 6 input axes (passthrough).
+ */
+type ActionMap = Record<string, ActionBinding>;
+/** Result of applying an ActionMap to spatial data */
+type ActionValues = Record<string, number>;
+
+/** Per-device transform overrides. Any field left undefined inherits from global defaults. */
+interface DeviceConfig {
+    sensitivity?: Partial<SensitivityConfig>;
+    flip?: Partial<FlipConfig>;
+    deadZone?: number;
+    dominant?: boolean;
+    axisRemap?: Partial<AxisMap>;
+    actionMap?: ActionMap;
+    lockPosition?: boolean;
+    lockRotation?: boolean;
+}
 interface InputConfig {
+    /** Global defaults applied to all devices */
     sensitivity: SensitivityConfig;
     flip: FlipConfig;
     deadZone: number;
@@ -127,6 +162,14 @@ interface InputConfig {
     axisRemap: AxisMap;
     lockPosition: boolean;
     lockRotation: boolean;
+    /** Action map — maps input axes to named output actions. Default: passthrough. */
+    actionMap: ActionMap;
+    /**
+     * Per-device overrides, keyed by device ID (e.g., "spacemouse-c635")
+     * or device family pattern (e.g., "spacemouse-*", "hid-054c-*").
+     * Values override global defaults for matching devices.
+     */
+    devices: Record<string, DeviceConfig>;
 }
 
 interface StorageAdapter {
@@ -135,8 +178,10 @@ interface StorageAdapter {
 }
 
 interface InputManagerEvents {
-    /** Processed spatial data (after all transforms) */
+    /** Processed spatial data (after all transforms + action map) */
     spatialData: (data: SpatialData) => void;
+    /** Named action values from the action map */
+    actionValues: (values: ActionValues) => void;
     /** Raw spatial data (before transforms) */
     rawSpatialData: (data: SpatialData) => void;
     /** Button event (pass-through from connection) */
@@ -148,18 +193,25 @@ interface InputManagerEvents {
     /** Configuration changed */
     configChange: (config: InputConfig) => void;
 }
+/** A connected device paired with its resolved configuration */
+interface DeviceWithConfig {
+    device: DeviceInfo$1;
+    config: DeviceConfig;
+}
 /**
  * Unified device service that wraps one or more SatMouseConnections
  * and provides a single processed event stream.
  *
- * Applies a configurable transform pipeline to spatial data:
+ * Applies a configurable transform pipeline per-device:
  *   deadZone → dominant → flip → axisRemap → sensitivity → lock
  *
- * Persists settings to storage (localStorage by default).
+ * Per-device overrides are resolved from InputConfig.devices using
+ * device ID matching (exact or pattern with wildcard "*").
  */
 declare class InputManager extends TypedEmitter<InputManagerEvents> {
     private connections;
     private storage?;
+    private knownDevices;
     private _config;
     get config(): InputConfig;
     constructor(config?: Partial<InputConfig>, storage?: StorageAdapter);
@@ -173,12 +225,20 @@ declare class InputManager extends TypedEmitter<InputManagerEvents> {
     disconnect(): void;
     /** Fetch device info from all connections */
     fetchDeviceInfo(): Promise<DeviceInfo$1[]>;
-    /** Update configuration. Persists by default. */
+    /** Get all known connected devices paired with their resolved config */
+    getDevicesWithConfig(): DeviceWithConfig[];
+    /** Get the resolved per-device config (global defaults + device overrides) */
+    getDeviceConfig(deviceId: string): DeviceConfig;
+    /** Update global configuration. Persists by default. */
     updateConfig(partial: Partial<InputConfig>, persist?: boolean): void;
+    /** Update configuration for a specific device. Persists by default. */
+    updateDeviceConfig(deviceId: string, partial: DeviceConfig, persist?: boolean): void;
     /** Register a callback for processed spatial data. Returns unsubscribe function. */
     onSpatialData(callback: (data: SpatialData) => void): () => void;
     /** Register a callback for button events. Returns unsubscribe function. */
     onButtonEvent(callback: (data: ButtonEvent) => void): () => void;
+    /** Register a callback for action values. Returns unsubscribe function. */
+    onActionValues(callback: (values: ActionValues) => void): () => void;
     private wireConnection;
     private processSpatialData;
 }

package/dist/react/index.js

@@ -425,6 +425,57 @@ function launchSatMouse(options) {
   });
 }
 
+// src/utils/action-map.ts
+var DEFAULT_ACTION_MAP = {
+  tx: { source: "tx" },
+  ty: { source: "ty" },
+  tz: { source: "tz" },
+  rx: { source: "rx" },
+  ry: { source: "ry" },
+  rz: { source: "rz" }
+};
+function readAxis(data, axis) {
+  switch (axis) {
+    case "tx":
+      return data.translation.x;
+    case "ty":
+      return data.translation.y;
+    case "tz":
+      return data.translation.z;
+    case "rx":
+      return data.rotation.x;
+    case "ry":
+      return data.rotation.y;
+    case "rz":
+      return data.rotation.z;
+  }
+}
+function applyActionMap(data, map) {
+  const result = {};
+  for (const [action, binding] of Object.entries(map)) {
+    let value = readAxis(data, binding.source);
+    if (binding.invert) value = -value;
+    value *= binding.scale ?? 1;
+    result[action] = value;
+  }
+  return result;
+}
+function actionValuesToSpatialData(values, timestamp) {
+  return {
+    translation: {
+      x: values.tx ?? 0,
+      y: values.ty ?? 0,
+      z: values.tz ?? 0
+    },
+    rotation: {
+      x: values.rx ?? 0,
+      y: values.ry ?? 0,
+      z: values.rz ?? 0
+    },
+    timestamp
+  };
+}
+
 // src/utils/config.ts
 var DEFAULT_CONFIG = {
   sensitivity: { translation: 1e-3, rotation: 1e-3 },
@@ -433,15 +484,60 @@ var DEFAULT_CONFIG = {
   dominant: false,
   axisRemap: { tx: "x", ty: "y", tz: "z", rx: "x", ry: "y", rz: "z" },
   lockPosition: false,
-  lockRotation: false
+  lockRotation: false,
+  actionMap: { ...DEFAULT_ACTION_MAP },
+  devices: {}
 };
 function mergeConfig(base, partial) {
-  return {
+  const merged = {
     ...base,
     ...partial,
     sensitivity: { ...base.sensitivity, ...partial.sensitivity },
     flip: { ...base.flip, ...partial.flip },
-    axisRemap: { ...base.axisRemap, ...partial.axisRemap }
+    axisRemap: { ...base.axisRemap, ...partial.axisRemap },
+    actionMap: partial.actionMap ? { ...base.actionMap, ...partial.actionMap } : { ...base.actionMap },
+    devices: { ...base.devices }
+  };
+  if (partial.devices) {
+    for (const [key, devCfg] of Object.entries(partial.devices)) {
+      merged.devices[key] = mergeDeviceConfig(merged.devices[key], devCfg);
+    }
+  }
+  return merged;
+}
+function mergeDeviceConfig(base, partial) {
+  if (!base) return partial;
+  return {
+    ...base,
+    ...partial,
+    sensitivity: partial.sensitivity ? { ...base.sensitivity, ...partial.sensitivity } : base.sensitivity,
+    flip: partial.flip ? { ...base.flip, ...partial.flip } : base.flip,
+    axisRemap: partial.axisRemap ? { ...base.axisRemap, ...partial.axisRemap } : base.axisRemap
+  };
+}
+function resolveDeviceConfig(config, deviceId) {
+  let deviceOverride;
+  if (config.devices[deviceId]) {
+    deviceOverride = config.devices[deviceId];
+  } else {
+    for (const [pattern, cfg] of Object.entries(config.devices)) {
+      if (pattern.endsWith("*") && deviceId.startsWith(pattern.slice(0, -1))) {
+        deviceOverride = cfg;
+        break;
+      }
+    }
+  }
+  if (!deviceOverride) return config;
+  return {
+    ...config,
+    sensitivity: { ...config.sensitivity, ...deviceOverride.sensitivity },
+    flip: { ...config.flip, ...deviceOverride.flip },
+    deadZone: deviceOverride.deadZone ?? config.deadZone,
+    dominant: deviceOverride.dominant ?? config.dominant,
+    axisRemap: { ...config.axisRemap, ...deviceOverride.axisRemap },
+    actionMap: deviceOverride.actionMap ? { ...config.actionMap, ...deviceOverride.actionMap } : config.actionMap,
+    lockPosition: deviceOverride.lockPosition ?? config.lockPosition,
+    lockRotation: deviceOverride.lockRotation ?? config.lockRotation
   };
 }
 
@@ -553,6 +649,7 @@ function applyAxisRemap(data, map) {
 var InputManager = class extends TypedEmitter {
   connections = [];
   storage;
+  knownDevices = /* @__PURE__ */ new Map();
   _config;
   get config() {
     return this._config;
@@ -585,14 +682,46 @@ var InputManager = class extends TypedEmitter {
   /** Fetch device info from all connections */
   async fetchDeviceInfo() {
     const results = await Promise.all(this.connections.map((c) => c.fetchDeviceInfo()));
-    return results.flat();
+    const devices = results.flat();
+    for (const d of devices) this.knownDevices.set(d.id, d);
+    return devices;
   }
-  /** Update configuration. Persists by default. */
+  /** Get all known connected devices paired with their resolved config */
+  getDevicesWithConfig() {
+    return Array.from(this.knownDevices.values()).map((device) => ({
+      device,
+      config: this.getDeviceConfig(device.id)
+    }));
+  }
+  /** Get the resolved per-device config (global defaults + device overrides) */
+  getDeviceConfig(deviceId) {
+    const resolved = resolveDeviceConfig(this._config, deviceId);
+    return {
+      sensitivity: resolved.sensitivity,
+      flip: resolved.flip,
+      deadZone: resolved.deadZone,
+      dominant: resolved.dominant,
+      axisRemap: resolved.axisRemap,
+      actionMap: resolved.actionMap,
+      lockPosition: resolved.lockPosition,
+      lockRotation: resolved.lockRotation
+    };
+  }
+  /** Update global configuration. Persists by default. */
   updateConfig(partial, persist = true) {
     this._config = mergeConfig(this._config, partial);
     if (persist) saveSettings(this._config, this.storage);
     this.emit("configChange", this._config);
   }
+  /** Update configuration for a specific device. Persists by default. */
+  updateDeviceConfig(deviceId, partial, persist = true) {
+    const existing = this._config.devices[deviceId] ?? {};
+    this._config = mergeConfig(this._config, {
+      devices: { [deviceId]: { ...existing, ...partial } }
+    });
+    if (persist) saveSettings(this._config, this.storage);
+    this.emit("configChange", this._config);
+  }
   /** Register a callback for processed spatial data. Returns unsubscribe function. */
   onSpatialData(callback) {
     this.on("spatialData", callback);
@@ -603,15 +732,25 @@ var InputManager = class extends TypedEmitter {
     this.on("buttonEvent", callback);
     return () => this.off("buttonEvent", callback);
   }
+  /** Register a callback for action values. Returns unsubscribe function. */
+  onActionValues(callback) {
+    this.on("actionValues", callback);
+    return () => this.off("actionValues", callback);
+  }
   wireConnection(connection) {
     connection.on("spatialData", (raw) => {
       this.emit("rawSpatialData", raw);
-      const processed = this.processSpatialData(raw);
-      if (processed) this.emit("spatialData", processed);
+      const { spatial, actions } = this.processSpatialData(raw);
+      if (spatial) this.emit("spatialData", spatial);
+      if (actions) this.emit("actionValues", actions);
     });
     connection.on("buttonEvent", (event) => this.emit("buttonEvent", event));
     connection.on("stateChange", (state, proto) => this.emit("stateChange", state, proto));
-    connection.on("deviceStatus", (event, device) => this.emit("deviceStatus", event, device));
+    connection.on("deviceStatus", (event, device) => {
+      if (event === "connected") this.knownDevices.set(device.id, device);
+      else this.knownDevices.delete(device.id);
+      this.emit("deviceStatus", event, device);
+    });
   }
   processSpatialData(raw) {
     const cfg = this._config;
@@ -627,7 +766,9 @@ var InputManager = class extends TypedEmitter {
     if (cfg.lockRotation) {
       data = { ...data, rotation: { x: 0, y: 0, z: 0 } };
     }
-    return data;
+    const actions = applyActionMap(data, cfg.actionMap);
+    const spatial = actionValuesToSpatialData(actions, data.timestamp);
+    return { spatial, actions };
   }
 };
 var SatMouseContext = createContext(null);