ive-connect 0.6.0 → 1.0.0

package/dist/core/device-interface.d.ts

@@ -16,6 +16,7 @@ export declare enum DeviceCapability {
     VIBRATE = "vibrate",
     ROTATE = "rotate",
     LINEAR = "linear",
+    OSCILLATE = "oscillate",
     STROKE = "stroke"
 }
 /**
@@ -27,7 +28,7 @@ export interface DeviceInfo {
     type: string;
     firmware?: string;
     hardware?: string;
-    [key: string]: any;
+    [key: string]: unknown;
 }
 /**
  * Device settings interface
@@ -37,22 +38,60 @@ export interface DeviceSettings {
     id: string;
     name: string;
     enabled: boolean;
-    [key: string]: any;
+    [key: string]: unknown;
 }
 /**
- * Script data interface
+ * Funscript action
+ */
+export interface FunscriptAction {
+    at: number;
+    pos: number;
+}
+/**
+ * Funscript format
+ */
+export interface Funscript {
+    actions: FunscriptAction[];
+    inverted?: boolean;
+    range?: number;
+    version?: string;
+    metadata?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+/**
+ * Script data interface - input for loading scripts
  */
 export interface ScriptData {
     type: string;
     url?: string;
-    content?: any;
+    content?: Funscript;
 }
 /**
  * Script options interface
  */
-export type ScriptOptions = {
+export interface ScriptOptions {
     invertScript?: boolean;
-};
+}
+/**
+ * Result from loading a script to a single device
+ */
+export interface DeviceScriptLoadResult {
+    success: boolean;
+    error?: string;
+}
+/**
+ * Result from loading a script via DeviceManager
+ */
+export interface ScriptLoadResult {
+    /** The parsed and processed funscript content */
+    funscript: Funscript | null;
+    /** Whether the script was successfully fetched/parsed */
+    success: boolean;
+    /** Error message if fetching/parsing failed */
+    error?: string;
+    /** Per-device load results */
+    devices: Record<string, DeviceScriptLoadResult>;
+}
 /**
  * Common interface for all haptic devices
  */
@@ -73,7 +112,7 @@ export interface HapticDevice {
      * Connect to the device
      * @param config Optional configuration
      */
-    connect(config?: any): Promise<boolean>;
+    connect(config?: unknown): Promise<boolean>;
     /**
      * Disconnect from the device
      */
@@ -88,13 +127,14 @@ export interface HapticDevice {
      */
     updateConfig(config: Partial<DeviceSettings>): Promise<boolean>;
     /**
-     * Load a script for playback
-     * @param scriptData Script data to load
+     * Prepare the device to play a script
+     * The funscript content is already parsed - device just needs to prepare it
+     * (e.g., upload to server for Handy, store in memory for Buttplug)
+     *
+     * @param funscript The parsed funscript content
+     * @param options Script options (e.g., inversion already applied)
      */
-    loadScript(scriptData: ScriptData, options?: ScriptOptions): Promise<{
-        success: boolean;
-        scriptContent?: ScriptData;
-    }>;
+    prepareScript(funscript: Funscript, options?: ScriptOptions): Promise<DeviceScriptLoadResult>;
     /**
      * Play the loaded script at the specified time
      * @param timeMs Current time in milliseconds
@@ -121,11 +161,11 @@ export interface HapticDevice {
      * @param event Event name
      * @param callback Callback function
      */
-    on(event: string, callback: (data: any) => void): void;
+    on(event: string, callback: (data: unknown) => void): void;
     /**
      * Remove event listener
      * @param event Event name
      * @param callback Callback function
      */
-    off(event: string, callback: (data: any) => void): void;
+    off(event: string, callback: (data: unknown) => void): void;
 }

package/dist/core/device-interface.js

@@ -21,5 +21,6 @@ var DeviceCapability;
     DeviceCapability["VIBRATE"] = "vibrate";
     DeviceCapability["ROTATE"] = "rotate";
     DeviceCapability["LINEAR"] = "linear";
+    DeviceCapability["OSCILLATE"] = "oscillate";
     DeviceCapability["STROKE"] = "stroke";
 })(DeviceCapability || (exports.DeviceCapability = DeviceCapability = {}));

package/dist/core/device-manager.d.ts

@@ -1,17 +1,19 @@
 /**
  * Device Manager
  *
- * Central manager for all haptic devices
+ * Central manager for all haptic devices.
+ * Handles unified script loading and distribution to devices.
  */
 import { EventEmitter } from "./events";
-import { HapticDevice, ScriptData, ScriptOptions } from "./device-interface";
+import { HapticDevice, ScriptData, ScriptOptions, ScriptLoadResult, Funscript } from "./device-interface";
 /**
  * Device Manager class
  * Handles registration and control of multiple haptic devices
  */
 export declare class DeviceManager extends EventEmitter {
     private devices;
-    private scriptData;
+    private currentFunscript;
+    private currentScriptOptions;
     /**
      * Register a device with the manager
      * @param device Device to register
@@ -31,6 +33,10 @@ export declare class DeviceManager extends EventEmitter {
      * @param deviceId Device ID to retrieve
      */
     getDevice(deviceId: string): HapticDevice | undefined;
+    /**
+     * Get the currently loaded funscript
+     */
+    getCurrentFunscript(): Funscript | null;
     /**
      * Connect to all registered devices
      * @returns Object with success status for each device
@@ -42,12 +48,19 @@ export declare class DeviceManager extends EventEmitter {
      */
     disconnectAll(): Promise<Record<string, boolean>>;
     /**
-     * Load a script to all connected devices
-     * @param scriptData Script data to load
+     * Load a script - fetches, parses, and prepares on all connected devices
+     *
+     * This is the main entry point for loading scripts. It:
+     * 1. Fetches and parses the script (once, centrally)
+     * 2. Applies any transformations (inversion, sorting)
+     * 3. Distributes to all connected devices
+     * 4. Returns the funscript along with per-device results
+     *
+     * @param scriptData Script data to load (URL or content)
      * @param options Options for script loading (e.g., invertScript)
-     * @returns Object with success status for each device
+     * @returns ScriptLoadResult with funscript and per-device status
      */
-    loadScriptAll(scriptData: ScriptData, options?: ScriptOptions): Promise<Record<string, boolean | ScriptData>>;
+    loadScript(scriptData: ScriptData, options?: ScriptOptions): Promise<ScriptLoadResult>;
     /**
      * Start playback on all connected devices
      * @param timeMs Current time in milliseconds
@@ -68,6 +81,10 @@ export declare class DeviceManager extends EventEmitter {
      * @returns Object with success status for each device
      */
     syncTimeAll(timeMs: number, filter?: number): Promise<Record<string, boolean>>;
+    /**
+     * Clear the currently loaded script
+     */
+    clearScript(): void;
     /**
      * Set up event forwarding from a device to the manager
      * @param device Device to forward events from

package/dist/core/device-manager.js

@@ -4,9 +4,11 @@ exports.DeviceManager = void 0;
 /**
  * Device Manager
  *
- * Central manager for all haptic devices
+ * Central manager for all haptic devices.
+ * Handles unified script loading and distribution to devices.
  */
 const events_1 = require("./events");
+const script_loader_1 = require("./script-loader");
 /**
  * Device Manager class
  * Handles registration and control of multiple haptic devices
@@ -15,22 +17,29 @@ class DeviceManager extends events_1.EventEmitter {
     constructor() {
         super(...arguments);
         this.devices = new Map();
-        this.scriptData = null;
+        this.currentFunscript = null;
+        this.currentScriptOptions = null;
     }
     /**
      * Register a device with the manager
      * @param device Device to register
      */
     registerDevice(device) {
-        // Don't register the same device twice
+        var _a;
         if (this.devices.has(device.id)) {
             return;
         }
         this.devices.set(device.id, device);
-        // Forward events from this device
         this.setupDeviceEventForwarding(device);
-        // Emit device added event
         this.emit("deviceAdded", device);
+        // If we have a script loaded, prepare it on the new device
+        if (this.currentFunscript) {
+            device
+                .prepareScript(this.currentFunscript, (_a = this.currentScriptOptions) !== null && _a !== void 0 ? _a : undefined)
+                .catch((error) => {
+                console.error(`Error preparing script on newly registered device ${device.id}:`, error);
+            });
+        }
     }
     /**
      * Unregister a device from the manager
@@ -56,6 +65,12 @@ class DeviceManager extends events_1.EventEmitter {
     getDevice(deviceId) {
         return this.devices.get(deviceId);
     }
+    /**
+     * Get the currently loaded funscript
+     */
+    getCurrentFunscript() {
+        return this.currentFunscript;
+    }
     /**
      * Connect to all registered devices
      * @returns Object with success status for each device
@@ -91,36 +106,66 @@ class DeviceManager extends events_1.EventEmitter {
         return results;
     }
     /**
-     * Load a script to all connected devices
-     * @param scriptData Script data to load
+     * Load a script - fetches, parses, and prepares on all connected devices
+     *
+     * This is the main entry point for loading scripts. It:
+     * 1. Fetches and parses the script (once, centrally)
+     * 2. Applies any transformations (inversion, sorting)
+     * 3. Distributes to all connected devices
+     * 4. Returns the funscript along with per-device results
+     *
+     * @param scriptData Script data to load (URL or content)
      * @param options Options for script loading (e.g., invertScript)
-     * @returns Object with success status for each device
+     * @returns ScriptLoadResult with funscript and per-device status
      */
-    async loadScriptAll(scriptData, options) {
-        const results = {};
-        this.scriptData = scriptData;
+    async loadScript(scriptData, options) {
+        // Step 1: Fetch and parse the script centrally
+        const loadResult = await (0, script_loader_1.loadScript)(scriptData, options);
+        if (!loadResult.success || !loadResult.funscript) {
+            return {
+                success: false,
+                funscript: null,
+                error: loadResult.error,
+                devices: {},
+            };
+        }
+        // Store the loaded script
+        this.currentFunscript = loadResult.funscript;
+        this.currentScriptOptions = options !== null && options !== void 0 ? options : null;
+        // Step 2: Prepare on all connected devices
+        const deviceResults = {};
         for (const [id, device] of this.devices.entries()) {
+            // Only prepare on connected devices (or buttplug which manages its own connection)
             if (device.isConnected || device.id === "buttplug") {
                 try {
-                    results[id] = await device.loadScript(scriptData, options);
+                    const result = await device.prepareScript(loadResult.funscript, options);
+                    deviceResults[id] = result;
                 }
                 catch (error) {
-                    console.error(`Error loading script to device ${id}:`, error);
-                    results[id] = { success: false };
+                    console.error(`Error preparing script on device ${id}:`, error);
+                    deviceResults[id] = {
+                        success: false,
+                        error: error instanceof Error ? error.message : String(error),
+                    };
                 }
             }
             else {
-                results[id] = { success: false };
-            }
-        }
-        const transformedResults = {};
-        for (const [id, result] of Object.entries(results)) {
-            if (result.scriptContent) {
-                transformedResults["script"] = result.scriptContent;
+                deviceResults[id] = {
+                    success: false,
+                    error: "Device not connected",
+                };
             }
-            transformedResults[id] = result.success;
         }
-        return transformedResults;
+        // Emit event
+        this.emit("scriptLoaded", {
+            funscript: loadResult.funscript,
+            devices: deviceResults,
+        });
+        return {
+            success: true,
+            funscript: loadResult.funscript,
+            devices: deviceResults,
+        };
     }
     /**
      * Start playback on all connected devices
@@ -193,12 +238,18 @@ class DeviceManager extends events_1.EventEmitter {
         }
         return results;
     }
+    /**
+     * Clear the currently loaded script
+     */
+    clearScript() {
+        this.currentFunscript = null;
+        this.currentScriptOptions = null;
+    }
     /**
      * Set up event forwarding from a device to the manager
      * @param device Device to forward events from
      */
     setupDeviceEventForwarding(device) {
-        // Forward common events
         const eventsToForward = [
             "error",
             "connected",
@@ -211,7 +262,6 @@ class DeviceManager extends events_1.EventEmitter {
         for (const eventName of eventsToForward) {
             device.on(eventName, (data) => {
                 this.emit(`device:${device.id}:${eventName}`, data);
-                // Also emit a general event for any device
                 this.emit(`device:${eventName}`, { deviceId: device.id, data });
             });
         }

package/dist/core/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Core exports
+ */
+export * from "./device-interface";
+export * from "./device-manager";
+export * from "./events";
+export * from "./script-loader";

package/dist/core/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Core exports
+ */
+__exportStar(require("./device-interface"), exports);
+__exportStar(require("./device-manager"), exports);
+__exportStar(require("./events"), exports);
+__exportStar(require("./script-loader"), exports);

package/dist/core/script-loader.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Script Loader
+ *
+ * Centralized script fetching and parsing.
+ * Handles fetching from URLs, parsing CSV/JSON, and applying transformations.
+ */
+import { Funscript, ScriptData, ScriptOptions } from "./device-interface";
+/**
+ * Parse CSV content to Funscript format
+ */
+export declare function parseCSVToFunscript(csvText: string): Funscript;
+/**
+ * Apply inversion to funscript actions
+ */
+export declare function invertFunscript(funscript: Funscript): Funscript;
+/**
+ * Validate funscript structure
+ */
+export declare function isValidFunscript(content: unknown): content is Funscript;
+/**
+ * Result of loading a script
+ */
+export interface LoadScriptResult {
+    success: boolean;
+    funscript: Funscript | null;
+    error?: string;
+}
+/**
+ * Load and parse a script from ScriptData
+ *
+ * @param scriptData - The script data (URL or content)
+ * @param options - Script options (e.g., inversion)
+ * @returns Parsed funscript or error
+ */
+export declare function loadScript(scriptData: ScriptData, options?: ScriptOptions): Promise<LoadScriptResult>;

package/dist/core/script-loader.js

@@ -0,0 +1,172 @@
+"use strict";
+/**
+ * Script Loader
+ *
+ * Centralized script fetching and parsing.
+ * Handles fetching from URLs, parsing CSV/JSON, and applying transformations.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCSVToFunscript = parseCSVToFunscript;
+exports.invertFunscript = invertFunscript;
+exports.isValidFunscript = isValidFunscript;
+exports.loadScript = loadScript;
+/**
+ * Parse CSV content to Funscript format
+ */
+function parseCSVToFunscript(csvText) {
+    const lines = csvText.split(/\r?\n/).filter((line) => line.trim().length > 0);
+    const actions = [];
+    // Check if there's a header line (contains non-numeric characters in first column)
+    let startIndex = 0;
+    if (lines.length > 0 && isNaN(parseFloat(lines[0].split(",")[0]))) {
+        startIndex = 1;
+    }
+    // Parse each line
+    for (let i = startIndex; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (!line)
+            continue;
+        const columns = line.split(",");
+        if (columns.length >= 2) {
+            const at = parseFloat(columns[0].trim());
+            const pos = parseFloat(columns[1].trim());
+            if (!isNaN(at) && !isNaN(pos)) {
+                actions.push({
+                    at: Math.round(at),
+                    pos: Math.min(100, Math.max(0, Math.round(pos))),
+                });
+            }
+        }
+    }
+    return {
+        actions,
+        metadata: { convertedFrom: "csv" },
+    };
+}
+/**
+ * Apply inversion to funscript actions
+ */
+function invertFunscript(funscript) {
+    return {
+        ...funscript,
+        actions: funscript.actions.map((action) => ({
+            ...action,
+            pos: 100 - action.pos,
+        })),
+        inverted: !funscript.inverted,
+    };
+}
+/**
+ * Validate funscript structure
+ */
+function isValidFunscript(content) {
+    if (!content || typeof content !== "object") {
+        return false;
+    }
+    const obj = content;
+    if (!Array.isArray(obj.actions)) {
+        return false;
+    }
+    // Check that actions have the required properties
+    return obj.actions.every((action) => action &&
+        typeof action === "object" &&
+        typeof action.at === "number" &&
+        typeof action.pos === "number");
+}
+/**
+ * Load and parse a script from ScriptData
+ *
+ * @param scriptData - The script data (URL or content)
+ * @param options - Script options (e.g., inversion)
+ * @returns Parsed funscript or error
+ */
+async function loadScript(scriptData, options) {
+    try {
+        let funscript;
+        if (scriptData.content) {
+            // Content already provided
+            if (!isValidFunscript(scriptData.content)) {
+                return {
+                    success: false,
+                    funscript: null,
+                    error: "Invalid funscript format: content is not a valid funscript",
+                };
+            }
+            funscript = scriptData.content;
+        }
+        else if (scriptData.url) {
+            // Fetch from URL
+            const response = await fetch(scriptData.url);
+            if (!response.ok) {
+                return {
+                    success: false,
+                    funscript: null,
+                    error: `Failed to fetch script: ${response.status} ${response.statusText}`,
+                };
+            }
+            const fileExtension = scriptData.url.toLowerCase().split(".").pop();
+            if (fileExtension === "csv") {
+                const csvText = await response.text();
+                funscript = parseCSVToFunscript(csvText);
+            }
+            else {
+                // Assume JSON/funscript
+                const text = await response.text();
+                try {
+                    const parsed = JSON.parse(text);
+                    if (!isValidFunscript(parsed)) {
+                        return {
+                            success: false,
+                            funscript: null,
+                            error: "Invalid funscript format: missing or invalid actions array",
+                        };
+                    }
+                    funscript = parsed;
+                }
+                catch (_a) {
+                    // Try parsing as CSV if JSON fails
+                    funscript = parseCSVToFunscript(text);
+                    if (funscript.actions.length === 0) {
+                        return {
+                            success: false,
+                            funscript: null,
+                            error: "Failed to parse script: not valid JSON or CSV",
+                        };
+                    }
+                }
+            }
+        }
+        else {
+            return {
+                success: false,
+                funscript: null,
+                error: "Invalid script data: either URL or content must be provided",
+            };
+        }
+        // Validate we have actions
+        if (!funscript.actions || funscript.actions.length === 0) {
+            return {
+                success: false,
+                funscript: null,
+                error: "Invalid funscript: no actions found",
+            };
+        }
+        // Apply inversion if requested
+        if (options === null || options === void 0 ? void 0 : options.invertScript) {
+            funscript = invertFunscript(funscript);
+        }
+        // Sort actions by timestamp
+        funscript.actions.sort((a, b) => a.at - b.at);
+        return {
+            success: true,
+            funscript,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            funscript: null,
+            error: `Script loading error: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}