@cleverence/edge-js-sdk 1.0.0

package/dist/vue/index.cjs

@@ -0,0 +1,702 @@
+'use strict';
+
+var vue = require('vue');
+
+// src/vue/useEdge.ts
+
+// 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.");
+    }
+  }
+};
+
+// src/vue/useEdge.ts
+var sharedEdge = null;
+var refCount = 0;
+function useEdge(options = {}) {
+  const { shared = true, ...edgeOptions } = options;
+  const edge = vue.shallowRef(null);
+  const isConnected = vue.ref(false);
+  const connectionState = vue.ref("disconnected");
+  const capabilities = vue.ref(null);
+  const error = vue.ref(null);
+  const handleConnect = () => {
+    connectionState.value = "connected";
+    isConnected.value = true;
+    error.value = null;
+  };
+  const handleDisconnect = () => {
+    connectionState.value = "disconnected";
+    isConnected.value = false;
+  };
+  const handleReconnecting = () => {
+    connectionState.value = "reconnecting";
+    isConnected.value = false;
+  };
+  const handleError = (err) => {
+    error.value = err;
+  };
+  const handleCapabilities = (caps) => {
+    capabilities.value = caps;
+  };
+  const setupListeners = (instance) => {
+    instance.on("connect", handleConnect);
+    instance.on("disconnect", handleDisconnect);
+    instance.on("reconnecting", handleReconnecting);
+    instance.on("error", handleError);
+    instance.on("capabilities", handleCapabilities);
+  };
+  const removeListeners = (instance) => {
+    instance.off("connect", handleConnect);
+    instance.off("disconnect", handleDisconnect);
+    instance.off("reconnecting", handleReconnecting);
+    instance.off("error", handleError);
+    instance.off("capabilities", handleCapabilities);
+  };
+  vue.onMounted(() => {
+    let instance;
+    if (shared) {
+      if (!sharedEdge) {
+        sharedEdge = new CleverenceEdge(edgeOptions);
+      }
+      instance = sharedEdge;
+      refCount++;
+    } else {
+      instance = new CleverenceEdge(edgeOptions);
+    }
+    edge.value = instance;
+    connectionState.value = instance.connectionState;
+    isConnected.value = instance.isConnected;
+    capabilities.value = instance.capabilities;
+    setupListeners(instance);
+  });
+  vue.onUnmounted(() => {
+    const instance = edge.value;
+    if (!instance) return;
+    removeListeners(instance);
+    if (shared) {
+      refCount--;
+      if (refCount === 0 && sharedEdge) {
+        sharedEdge.disconnect();
+        sharedEdge = null;
+      }
+    } else {
+      instance.disconnect();
+    }
+    edge.value = null;
+  });
+  const connect = async () => {
+    if (edge.value) {
+      await edge.value.connect();
+    }
+  };
+  const disconnect = () => {
+    if (edge.value) {
+      edge.value.disconnect();
+    }
+  };
+  return {
+    edge,
+    isConnected,
+    connectionState,
+    capabilities,
+    error,
+    connect,
+    disconnect
+  };
+}
+function useBarcode(options) {
+  const { edge, maxHistory = 50, onScan } = options;
+  const lastScan = vue.ref(null);
+  const scanHistory = vue.ref([]);
+  let currentHandler = null;
+  const handleScan = (event) => {
+    lastScan.value = event;
+    scanHistory.value = [event, ...scanHistory.value].slice(0, maxHistory);
+    onScan?.(event);
+  };
+  const stopWatch = vue.watch(
+    edge,
+    (newEdge, oldEdge) => {
+      if (oldEdge && currentHandler) {
+        oldEdge.off("scan", currentHandler);
+      }
+      if (newEdge) {
+        currentHandler = handleScan;
+        newEdge.on("scan", currentHandler);
+      }
+    },
+    { immediate: true }
+  );
+  vue.onUnmounted(() => {
+    stopWatch();
+    if (edge.value && currentHandler) {
+      edge.value.off("scan", currentHandler);
+    }
+  });
+  const clearHistory = () => {
+    lastScan.value = null;
+    scanHistory.value = [];
+  };
+  const triggerScan = async () => {
+    if (!edge.value) throw new Error("Not connected");
+    await edge.value.triggerScan();
+  };
+  return {
+    lastScan,
+    scanHistory,
+    clearHistory,
+    triggerScan
+  };
+}
+function useRfid(options) {
+  const { edge, onRead } = options;
+  const lastRead = vue.ref(null);
+  const tags = vue.ref(/* @__PURE__ */ new Map());
+  const isInventoryActive = vue.ref(false);
+  let currentHandler = null;
+  const handleRfid = (event) => {
+    lastRead.value = event;
+    const newTags = new Map(tags.value);
+    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
+      });
+    }
+    tags.value = newTags;
+    onRead?.(event);
+  };
+  const stopWatch = vue.watch(
+    edge,
+    (newEdge, oldEdge) => {
+      if (oldEdge && currentHandler) {
+        oldEdge.off("rfid", currentHandler);
+      }
+      if (newEdge) {
+        currentHandler = handleRfid;
+        newEdge.on("rfid", currentHandler);
+      }
+    },
+    { immediate: true }
+  );
+  vue.onUnmounted(() => {
+    stopWatch();
+    if (edge.value && currentHandler) {
+      edge.value.off("rfid", currentHandler);
+    }
+  });
+  const startInventory = async (inventoryOptions) => {
+    if (!edge.value) throw new Error("Not connected");
+    await edge.value.startRfidInventory(inventoryOptions);
+    isInventoryActive.value = true;
+  };
+  const stopInventory = async () => {
+    if (!edge.value) throw new Error("Not connected");
+    await edge.value.stopRfidInventory();
+    isInventoryActive.value = false;
+  };
+  const clearTags = () => {
+    lastRead.value = null;
+    tags.value = /* @__PURE__ */ new Map();
+  };
+  return {
+    lastRead,
+    tags,
+    isInventoryActive,
+    startInventory,
+    stopInventory,
+    clearTags
+  };
+}
+
+exports.useBarcode = useBarcode;
+exports.useEdge = useEdge;
+exports.useRfid = useRfid;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map