@cleverence/edge-js-sdk 1.0.0

package/dist/react/index.js

@@ -0,0 +1,649 @@
+import { createContext, useState, useEffect, useMemo, useCallback, useContext } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+// src/react/EdgeContext.tsx
+
+// src/core/events.ts
+var EventEmitter = class {
+  constructor() {
+    this.handlers = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Subscribe to an event
+   */
+  on(event, handler) {
+    if (!this.handlers.has(event)) {
+      this.handlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this.handlers.get(event).add(handler);
+    return this;
+  }
+  /**
+   * Subscribe to an event once (auto-unsubscribes after first call)
+   */
+  once(event, handler) {
+    const onceHandler = (data) => {
+      this.off(event, onceHandler);
+      handler(data);
+    };
+    return this.on(event, onceHandler);
+  }
+  /**
+   * Unsubscribe from an event
+   */
+  off(event, handler) {
+    const eventHandlers = this.handlers.get(event);
+    if (eventHandlers) {
+      eventHandlers.delete(handler);
+    }
+    return this;
+  }
+  /**
+   * Emit an event to all subscribers
+   */
+  emit(event, data) {
+    const eventHandlers = this.handlers.get(event);
+    if (eventHandlers) {
+      eventHandlers.forEach((handler) => {
+        try {
+          handler(data);
+        } catch (err) {
+          console.error(`Error in event handler for "${String(event)}":`, err);
+        }
+      });
+    }
+  }
+  /**
+   * Remove all listeners for an event, or all listeners if no event specified
+   */
+  removeAllListeners(event) {
+    if (event) {
+      this.handlers.delete(event);
+    } else {
+      this.handlers.clear();
+    }
+    return this;
+  }
+  /**
+   * Get listener count for an event
+   */
+  listenerCount(event) {
+    return this.handlers.get(event)?.size ?? 0;
+  }
+};
+
+// src/core/websocket.ts
+var DEFAULT_WS_OPTIONS = {
+  reconnect: true,
+  reconnectDelay: 1e3,
+  maxReconnectDelay: 3e4,
+  pingInterval: 3e4
+};
+var WebSocketManager = class extends EventEmitter {
+  constructor(url, options = {}) {
+    super();
+    this.ws = null;
+    this._state = "disconnected";
+    this.reconnectAttempts = 0;
+    this.reconnectTimer = null;
+    this.pingTimer = null;
+    this.pendingRequests = /* @__PURE__ */ new Map();
+    this.intentionalClose = false;
+    this.url = url;
+    this.options = { ...DEFAULT_WS_OPTIONS, ...options };
+  }
+  /**
+   * Current connection state
+   */
+  get state() {
+    return this._state;
+  }
+  /**
+   * Whether currently connected
+   */
+  get isConnected() {
+    return this._state === "connected";
+  }
+  /**
+   * Connect to the WebSocket server
+   */
+  connect() {
+    return new Promise((resolve, reject) => {
+      if (this._state === "connected" || this._state === "connecting") {
+        resolve();
+        return;
+      }
+      this.intentionalClose = false;
+      this.setState("connecting");
+      try {
+        this.ws = new WebSocket(this.url);
+        const onOpen = () => {
+          this.ws?.removeEventListener("error", onError);
+          this.reconnectAttempts = 0;
+          this.setState("connected");
+          this.startPing();
+          this.emit("open", void 0);
+          resolve();
+        };
+        const onError = (event) => {
+          this.ws?.removeEventListener("open", onOpen);
+          const error = new Error("WebSocket connection failed");
+          reject(error);
+        };
+        this.ws.addEventListener("open", onOpen, { once: true });
+        this.ws.addEventListener("error", onError, { once: true });
+        this.ws.addEventListener("message", this.handleMessage.bind(this));
+        this.ws.addEventListener("close", this.handleClose.bind(this));
+        this.ws.addEventListener("error", this.handleError.bind(this));
+      } catch (err) {
+        this.setState("disconnected");
+        reject(err instanceof Error ? err : new Error(String(err)));
+      }
+    });
+  }
+  /**
+   * Disconnect from the WebSocket server
+   */
+  disconnect() {
+    this.intentionalClose = true;
+    this.cleanup();
+    this.setState("disconnected");
+    this.emit("close", void 0);
+  }
+  /**
+   * Send a message to the server
+   */
+  send(message) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      throw new Error("WebSocket is not connected");
+    }
+    this.ws.send(JSON.stringify(message));
+  }
+  /**
+   * Send a query and wait for response (request/response pattern)
+   */
+  request(query, timeoutMs = 1e4) {
+    return new Promise((resolve, reject) => {
+      const id = this.generateId();
+      const timeout = setTimeout(() => {
+        this.pendingRequests.delete(id);
+        reject(new Error(`Request timeout: ${query}`));
+      }, timeoutMs);
+      this.pendingRequests.set(id, {
+        resolve,
+        reject,
+        timeout
+      });
+      try {
+        this.send({ type: "query", id, query });
+      } catch (err) {
+        clearTimeout(timeout);
+        this.pendingRequests.delete(id);
+        reject(err);
+      }
+    });
+  }
+  /**
+   * Send a command (fire and forget, but throws if not connected)
+   */
+  command(message) {
+    this.send(message);
+  }
+  handleMessage(event) {
+    try {
+      const message = JSON.parse(event.data);
+      if (message.type === "response") {
+        const pending = this.pendingRequests.get(message.id);
+        if (pending) {
+          clearTimeout(pending.timeout);
+          this.pendingRequests.delete(message.id);
+          if (message.success) {
+            pending.resolve(message.data.result);
+          } else {
+            pending.reject(new Error(message.error));
+          }
+          return;
+        }
+      }
+      if (message.type === "pong") {
+        return;
+      }
+      this.emit("message", message);
+    } catch (err) {
+      console.error("Failed to parse WebSocket message:", err);
+    }
+  }
+  handleClose() {
+    this.cleanup();
+    if (this.intentionalClose) {
+      this.setState("disconnected");
+      return;
+    }
+    this.emit("close", void 0);
+    if (this.options.reconnect) {
+      this.scheduleReconnect();
+    } else {
+      this.setState("disconnected");
+    }
+  }
+  handleError(event) {
+    const error = new Error("WebSocket error");
+    this.emit("error", error);
+  }
+  scheduleReconnect() {
+    if (this.reconnectTimer) return;
+    this.setState("reconnecting");
+    const delay = Math.min(
+      this.options.reconnectDelay * Math.pow(2, this.reconnectAttempts),
+      this.options.maxReconnectDelay
+    );
+    this.reconnectTimer = setTimeout(async () => {
+      this.reconnectTimer = null;
+      this.reconnectAttempts++;
+      try {
+        await this.connect();
+      } catch {
+      }
+    }, delay);
+  }
+  startPing() {
+    this.stopPing();
+    this.pingTimer = setInterval(() => {
+      if (this.ws?.readyState === WebSocket.OPEN) {
+        try {
+          this.send({ type: "ping" });
+        } catch {
+        }
+      }
+    }, this.options.pingInterval);
+  }
+  stopPing() {
+    if (this.pingTimer) {
+      clearInterval(this.pingTimer);
+      this.pingTimer = null;
+    }
+  }
+  cleanup() {
+    this.stopPing();
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    this.pendingRequests.forEach((pending) => {
+      clearTimeout(pending.timeout);
+      pending.reject(new Error("WebSocket disconnected"));
+    });
+    this.pendingRequests.clear();
+    if (this.ws) {
+      const ws = this.ws;
+      this.ws = null;
+      if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) {
+        ws.close();
+      }
+    }
+  }
+  setState(state) {
+    if (this._state !== state) {
+      this._state = state;
+      this.emit("statechange", state);
+    }
+  }
+  generateId() {
+    return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  }
+};
+
+// src/types/messages.ts
+var DEFAULT_OPTIONS = {
+  url: "ws://localhost:8585",
+  autoConnect: true,
+  reconnectDelay: 1e3,
+  maxReconnectDelay: 3e4,
+  pingInterval: 3e4
+};
+
+// src/core/client.ts
+var CleverenceEdge = class _CleverenceEdge extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    this._capabilities = null;
+    this.options = { ...DEFAULT_OPTIONS, ...options };
+    this.ws = new WebSocketManager(this.options.url, {
+      reconnect: true,
+      reconnectDelay: this.options.reconnectDelay,
+      maxReconnectDelay: this.options.maxReconnectDelay,
+      pingInterval: this.options.pingInterval
+    });
+    this.setupWebSocketHandlers();
+    if (this.options.autoConnect) {
+      setTimeout(() => this.connect().catch(() => {
+      }), 0);
+    }
+  }
+  /**
+   * Current connection state
+   */
+  get connectionState() {
+    return this.ws.state;
+  }
+  /**
+   * Whether currently connected to the Edge service
+   */
+  get isConnected() {
+    return this.ws.isConnected;
+  }
+  /**
+   * Cached device capabilities (available after connect)
+   */
+  get capabilities() {
+    return this._capabilities;
+  }
+  /**
+   * Connect to the Edge service
+   */
+  async connect() {
+    await this.ws.connect();
+  }
+  /**
+   * Disconnect from the Edge service
+   */
+  disconnect() {
+    this.ws.disconnect();
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Commands
+  // ─────────────────────────────────────────────────────────────────────────────
+  /**
+   * Trigger a barcode scan programmatically
+   */
+  async triggerScan() {
+    this.ensureConnected();
+    this.ws.command({ type: "command", command: "trigger_scan" });
+  }
+  /**
+   * Set enabled barcode symbologies
+   */
+  async setSymbologies(symbologies) {
+    this.ensureConnected();
+    this.ws.command({ type: "command", command: "set_symbologies", symbologies });
+  }
+  /**
+   * Start RFID inventory (continuous reading)
+   */
+  async startRfidInventory(options) {
+    this.ensureConnected();
+    this.ws.command({ type: "command", command: "start_rfid_inventory", options });
+  }
+  /**
+   * Stop RFID inventory
+   */
+  async stopRfidInventory() {
+    this.ensureConnected();
+    this.ws.command({ type: "command", command: "stop_rfid_inventory" });
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Queries
+  // ─────────────────────────────────────────────────────────────────────────────
+  /**
+   * Get current Edge service status
+   */
+  async getStatus() {
+    this.ensureConnected();
+    return this.ws.request("status");
+  }
+  /**
+   * Get device capabilities
+   */
+  async getCapabilities() {
+    this.ensureConnected();
+    return this.ws.request("capabilities");
+  }
+  /**
+   * Get current configuration
+   */
+  async getConfig() {
+    this.ensureConnected();
+    return this.ws.request("config");
+  }
+  /**
+   * Get RFID tags from current/last inventory
+   */
+  async getRfidTags() {
+    this.ensureConnected();
+    return this.ws.request("rfid_tags");
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Static factory
+  // ─────────────────────────────────────────────────────────────────────────────
+  /**
+   * Create a new CleverenceEdge instance
+   */
+  static create(options) {
+    return new _CleverenceEdge(options);
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Private methods
+  // ─────────────────────────────────────────────────────────────────────────────
+  setupWebSocketHandlers() {
+    this.ws.on("open", () => {
+      this.emit("connect", void 0);
+      this.getCapabilities().then((caps) => {
+        this._capabilities = caps;
+        this.emit("capabilities", caps);
+      }).catch(() => {
+      });
+    });
+    this.ws.on("close", () => {
+      this.emit("disconnect", void 0);
+    });
+    this.ws.on("error", (error) => {
+      this.emit("error", error);
+    });
+    this.ws.on("statechange", (state) => {
+      if (state === "reconnecting") {
+        this.emit("reconnecting", void 0);
+      }
+    });
+    this.ws.on("message", (message) => {
+      this.handleServerMessage(message);
+    });
+  }
+  handleServerMessage(message) {
+    switch (message.type) {
+      case "event":
+        this.handleEvent(message.event);
+        break;
+      case "capabilities":
+        this._capabilities = message.data;
+        this.emit("capabilities", message.data);
+        break;
+      case "error":
+        this.emit("error", new Error(message.message));
+        break;
+    }
+  }
+  handleEvent(event) {
+    const parsedEvent = {
+      ...event,
+      timestamp: typeof event.timestamp === "string" ? new Date(event.timestamp) : event.timestamp
+    };
+    if (event.type === "scan") {
+      this.emit("scan", parsedEvent);
+    } else if (event.type === "rfid") {
+      this.emit("rfid", parsedEvent);
+    }
+  }
+  ensureConnected() {
+    if (!this.isConnected) {
+      throw new Error("Not connected to Edge service. Call connect() first.");
+    }
+  }
+};
+var EdgeContext = createContext(null);
+function EdgeProvider({ children, options, instance }) {
+  const [edge] = useState(() => instance ?? new CleverenceEdge(options));
+  const [connectionState, setConnectionState] = useState(edge.connectionState);
+  const [capabilities, setCapabilities] = useState(edge.capabilities);
+  const [error, setError] = useState(null);
+  useEffect(() => {
+    const handleConnect = () => {
+      setConnectionState("connected");
+      setError(null);
+    };
+    const handleDisconnect = () => {
+      setConnectionState("disconnected");
+    };
+    const handleReconnecting = () => {
+      setConnectionState("reconnecting");
+    };
+    const handleError = (err) => {
+      setError(err);
+    };
+    const handleCapabilities = (caps) => {
+      setCapabilities(caps);
+    };
+    edge.on("connect", handleConnect);
+    edge.on("disconnect", handleDisconnect);
+    edge.on("reconnecting", handleReconnecting);
+    edge.on("error", handleError);
+    edge.on("capabilities", handleCapabilities);
+    setConnectionState(edge.connectionState);
+    setCapabilities(edge.capabilities);
+    return () => {
+      edge.off("connect", handleConnect);
+      edge.off("disconnect", handleDisconnect);
+      edge.off("reconnecting", handleReconnecting);
+      edge.off("error", handleError);
+      edge.off("capabilities", handleCapabilities);
+      if (!instance) {
+        edge.disconnect();
+      }
+    };
+  }, [edge, instance]);
+  const value = useMemo(
+    () => ({
+      edge,
+      isConnected: connectionState === "connected",
+      connectionState,
+      capabilities,
+      error
+    }),
+    [edge, connectionState, capabilities, error]
+  );
+  return /* @__PURE__ */ jsx(EdgeContext.Provider, { value, children });
+}
+function useEdgeContext() {
+  const context = useContext(EdgeContext);
+  if (!context) {
+    throw new Error("useEdgeContext must be used within an EdgeProvider");
+  }
+  return context;
+}
+
+// src/react/useEdge.ts
+function useEdge() {
+  return useEdgeContext();
+}
+function useBarcode(options = {}) {
+  const { maxHistory = 50, onScan } = options;
+  const { edge } = useEdgeContext();
+  const [lastScan, setLastScan] = useState(null);
+  const [scanHistory, setScanHistory] = useState([]);
+  useEffect(() => {
+    if (!edge) return;
+    const handleScan = (event) => {
+      setLastScan(event);
+      setScanHistory((prev) => {
+        const newHistory = [event, ...prev];
+        return newHistory.slice(0, maxHistory);
+      });
+      onScan?.(event);
+    };
+    edge.on("scan", handleScan);
+    return () => {
+      edge.off("scan", handleScan);
+    };
+  }, [edge, maxHistory, onScan]);
+  const clearHistory = useCallback(() => {
+    setLastScan(null);
+    setScanHistory([]);
+  }, []);
+  const triggerScan = useCallback(async () => {
+    if (!edge) throw new Error("Not connected");
+    await edge.triggerScan();
+  }, [edge]);
+  return {
+    lastScan,
+    scanHistory,
+    clearHistory,
+    triggerScan
+  };
+}
+function useRfid(options = {}) {
+  const { onRead } = options;
+  const { edge } = useEdgeContext();
+  const [lastRead, setLastRead] = useState(null);
+  const [tags, setTags] = useState(/* @__PURE__ */ new Map());
+  const [isInventoryActive, setIsInventoryActive] = useState(false);
+  useEffect(() => {
+    if (!edge) return;
+    const handleRfid = (event) => {
+      setLastRead(event);
+      setTags((prev) => {
+        const newTags = new Map(prev);
+        const existing = newTags.get(event.epc);
+        const now = /* @__PURE__ */ new Date();
+        if (existing) {
+          newTags.set(event.epc, {
+            ...existing,
+            rssi: event.rssi,
+            antenna: event.antenna,
+            readCount: existing.readCount + 1,
+            lastSeen: now
+          });
+        } else {
+          newTags.set(event.epc, {
+            epc: event.epc,
+            rssi: event.rssi,
+            antenna: event.antenna,
+            readCount: 1,
+            firstSeen: now,
+            lastSeen: now
+          });
+        }
+        return newTags;
+      });
+      onRead?.(event);
+    };
+    edge.on("rfid", handleRfid);
+    return () => {
+      edge.off("rfid", handleRfid);
+    };
+  }, [edge, onRead]);
+  const startInventory = useCallback(async (inventoryOptions) => {
+    if (!edge) throw new Error("Not connected");
+    await edge.startRfidInventory(inventoryOptions);
+    setIsInventoryActive(true);
+  }, [edge]);
+  const stopInventory = useCallback(async () => {
+    if (!edge) throw new Error("Not connected");
+    await edge.stopRfidInventory();
+    setIsInventoryActive(false);
+  }, [edge]);
+  const clearTags = useCallback(() => {
+    setLastRead(null);
+    setTags(/* @__PURE__ */ new Map());
+  }, []);
+  return {
+    lastRead,
+    tags,
+    isInventoryActive,
+    startInventory,
+    stopInventory,
+    clearTags
+  };
+}
+
+export { EdgeProvider, useBarcode, useEdge, useRfid };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map