@cleverence/edge-js-sdk 1.0.0

package/dist/react/index.d.ts

@@ -0,0 +1,456 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+
+/**
+ * Minimal typed event emitter for browser environments
+ */
+type EventHandler<T = unknown> = (data: T) => void;
+declare class EventEmitter<Events extends Record<string, any> = Record<string, unknown>> {
+    private handlers;
+    /**
+     * Subscribe to an event
+     */
+    on<K extends keyof Events>(event: K, handler: EventHandler<Events[K]>): this;
+    /**
+     * Subscribe to an event once (auto-unsubscribes after first call)
+     */
+    once<K extends keyof Events>(event: K, handler: EventHandler<Events[K]>): this;
+    /**
+     * Unsubscribe from an event
+     */
+    off<K extends keyof Events>(event: K, handler: EventHandler<Events[K]>): this;
+    /**
+     * Emit an event to all subscribers
+     */
+    protected emit<K extends keyof Events>(event: K, data: Events[K]): void;
+    /**
+     * Remove all listeners for an event, or all listeners if no event specified
+     */
+    removeAllListeners(event?: keyof Events): this;
+    /**
+     * Get listener count for an event
+     */
+    listenerCount(event: keyof Events): number;
+}
+
+/**
+ * Barcode scan event - simplified API surface for easy consumption
+ */
+interface ScanEvent {
+    /** Event type discriminator */
+    type: 'scan';
+    /** Unique event identifier */
+    id: string;
+    /** When the scan occurred */
+    timestamp: Date;
+    /** Decoded barcode data string */
+    data: string;
+    /** Human-readable symbology name: "ean13", "qrcode", "code128", etc. */
+    symbology: string;
+    /** Scanner source: "integrated-laser", "camera", "bluetooth-ring" */
+    source: string;
+    /** Device vendor: "zebra", "honeywell", "urovo", "datalogic" */
+    vendor: string;
+    /** Extended raw data (optional, for advanced use cases) */
+    raw?: {
+        /** Raw barcode bytes as hex string */
+        bytesHex: string;
+        /** Vendor-specific symbology identifier */
+        symbologyId: string;
+        /** AIM identifier for the symbology */
+        aimId: string;
+        /** Signal strength if available */
+        signalStrength: number | null;
+        /** How long the scan took in milliseconds */
+        scanDurationMs: number;
+    };
+}
+/**
+ * RFID read event - simplified API surface for easy consumption
+ */
+interface RfidEvent {
+    /** Event type discriminator */
+    type: 'rfid';
+    /** Unique event identifier */
+    id: string;
+    /** When the read occurred */
+    timestamp: Date;
+    /** EPC (Electronic Product Code) tag identifier */
+    epc: string;
+    /** Received Signal Strength Indicator in dBm */
+    rssi: number;
+    /** Antenna port number that read the tag */
+    antenna: number;
+    /** Tag Identifier (TID) memory bank data */
+    tid?: string | null;
+    /** User memory bank data */
+    userData?: string | null;
+    /** RF phase angle */
+    phase?: number;
+    /** RF channel frequency */
+    channel?: number;
+    /** Number of times this tag was read in current inventory */
+    readCount?: number;
+    /** Protocol Control (PC) bits */
+    pc?: string;
+    /** CRC checksum */
+    crc?: string;
+    /** Inventory session identifier */
+    inventorySession?: string;
+    /** Transmit power used for this read in dBm */
+    transmitPowerDbm?: number;
+}
+
+/**
+ * Device capabilities reported by the Edge service on connection
+ */
+interface DeviceCapabilities {
+    /** Device vendor: "zebra", "honeywell", "urovo", "datalogic", etc. */
+    vendor: string;
+    /** Device model name */
+    deviceModel: string;
+    /** Whether device has barcode scanning capability */
+    hasBarcode: boolean;
+    /** Whether device has RFID reading capability */
+    hasRfid: boolean;
+    /** List of supported barcode symbologies */
+    supportedSymbologies: string[];
+    /** RFID transmit power range in dBm (if RFID capable) */
+    rfidPowerRange?: {
+        min: number;
+        max: number;
+    };
+    /** Firmware version if available */
+    firmwareVersion?: string;
+    /** Serial number if available */
+    serialNumber?: string;
+}
+/**
+ * Edge service status information
+ */
+interface EdgeStatus {
+    /** Whether the service is connected to hardware */
+    connected: boolean;
+    /** Unique device identifier */
+    deviceId: string;
+    /** Edge service version */
+    version: string;
+    /** Service uptime in seconds */
+    uptime: number;
+    /** Current battery level (0-100) if available */
+    batteryLevel?: number;
+    /** Whether device is charging */
+    isCharging?: boolean;
+}
+/**
+ * Edge service configuration
+ */
+interface EdgeConfig {
+    /** Enabled barcode symbologies */
+    enabledSymbologies: string[];
+    /** RFID transmit power in dBm */
+    rfidPower?: number;
+    /** Whether to deduplicate rapid scans of same barcode */
+    deduplicateScans: boolean;
+    /** Deduplication window in milliseconds */
+    deduplicateWindowMs: number;
+    /** Whether sound feedback is enabled */
+    soundEnabled: boolean;
+    /** Whether vibration feedback is enabled */
+    vibrationEnabled: boolean;
+}
+/**
+ * RFID inventory options for startRfidInventory()
+ */
+interface RfidInventoryOptions {
+    /** Transmit power in dBm (uses device default if not specified) */
+    power?: number;
+    /** Which antenna ports to use (all if not specified) */
+    antennas?: number[];
+    /** Session (0-3, affects tag persistence behavior) */
+    session?: 0 | 1 | 2 | 3;
+    /** Target flag (A or B) */
+    target?: 'A' | 'B';
+}
+/**
+ * RFID tag information from inventory
+ */
+interface RfidTag {
+    /** EPC tag identifier */
+    epc: string;
+    /** Last seen RSSI */
+    rssi: number;
+    /** Antenna that last read the tag */
+    antenna: number;
+    /** Total read count during inventory */
+    readCount: number;
+    /** When the tag was first seen */
+    firstSeen: Date;
+    /** When the tag was last seen */
+    lastSeen: Date;
+}
+
+/**
+ * Connection state for the WebSocket
+ */
+type ConnectionState = 'disconnected' | 'connecting' | 'connected' | 'reconnecting';
+/**
+ * Options for creating a CleverenceEdge instance
+ */
+interface EdgeOptions {
+    /** WebSocket URL. Default: 'ws://localhost:8585' */
+    url?: string;
+    /** Auto-connect on instantiation. Default: true */
+    autoConnect?: boolean;
+    /** Initial reconnect delay in ms. Default: 1000 */
+    reconnectDelay?: number;
+    /** Maximum reconnect delay in ms. Default: 30000 */
+    maxReconnectDelay?: number;
+    /** Ping interval for keepalive in ms. Default: 30000 */
+    pingInterval?: number;
+}
+
+/**
+ * Events emitted by CleverenceEdge
+ */
+interface CleverenceEdgeEvents {
+    scan: ScanEvent;
+    rfid: RfidEvent;
+    connect: void;
+    disconnect: void;
+    reconnecting: void;
+    error: Error;
+    capabilities: DeviceCapabilities;
+}
+/**
+ * CleverenceEdge SDK - Connect to barcode scanners and RFID readers
+ *
+ * @example
+ * ```typescript
+ * const edge = new CleverenceEdge();
+ *
+ * edge.on('scan', (event) => {
+ *   console.log(event.data);       // "012345678905"
+ *   console.log(event.symbology);  // "ean13"
+ * });
+ *
+ * edge.on('rfid', (event) => {
+ *   console.log(event.epc);        // "3034257BF400B7800004CB2F"
+ *   console.log(event.rssi);       // -45
+ * });
+ *
+ * await edge.connect();
+ * ```
+ */
+declare class CleverenceEdge extends EventEmitter<CleverenceEdgeEvents> {
+    private ws;
+    private options;
+    private _capabilities;
+    constructor(options?: EdgeOptions);
+    /**
+     * Current connection state
+     */
+    get connectionState(): ConnectionState;
+    /**
+     * Whether currently connected to the Edge service
+     */
+    get isConnected(): boolean;
+    /**
+     * Cached device capabilities (available after connect)
+     */
+    get capabilities(): DeviceCapabilities | null;
+    /**
+     * Connect to the Edge service
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the Edge service
+     */
+    disconnect(): void;
+    /**
+     * Trigger a barcode scan programmatically
+     */
+    triggerScan(): Promise<void>;
+    /**
+     * Set enabled barcode symbologies
+     */
+    setSymbologies(symbologies: string[]): Promise<void>;
+    /**
+     * Start RFID inventory (continuous reading)
+     */
+    startRfidInventory(options?: RfidInventoryOptions): Promise<void>;
+    /**
+     * Stop RFID inventory
+     */
+    stopRfidInventory(): Promise<void>;
+    /**
+     * Get current Edge service status
+     */
+    getStatus(): Promise<EdgeStatus>;
+    /**
+     * Get device capabilities
+     */
+    getCapabilities(): Promise<DeviceCapabilities>;
+    /**
+     * Get current configuration
+     */
+    getConfig(): Promise<EdgeConfig>;
+    /**
+     * Get RFID tags from current/last inventory
+     */
+    getRfidTags(): Promise<RfidTag[]>;
+    /**
+     * Create a new CleverenceEdge instance
+     */
+    static create(options?: EdgeOptions): CleverenceEdge;
+    private setupWebSocketHandlers;
+    private handleServerMessage;
+    private handleEvent;
+    private ensureConnected;
+}
+
+interface EdgeProviderProps {
+    children: ReactNode;
+    /** Edge connection options */
+    options?: EdgeOptions;
+    /** Custom CleverenceEdge instance (if you want to manage it yourself) */
+    instance?: CleverenceEdge;
+}
+/**
+ * React context provider for CleverenceEdge
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   return (
+ *     <EdgeProvider>
+ *       <Scanner />
+ *     </EdgeProvider>
+ *   );
+ * }
+ * ```
+ */
+declare function EdgeProvider({ children, options, instance }: EdgeProviderProps): react_jsx_runtime.JSX.Element;
+
+interface UseEdgeReturn {
+    /** The CleverenceEdge instance */
+    edge: CleverenceEdge | null;
+    /** Whether connected to the Edge service */
+    isConnected: boolean;
+    /** Current connection state */
+    connectionState: ConnectionState;
+    /** Device capabilities (available after connect) */
+    capabilities: DeviceCapabilities | null;
+    /** Last error that occurred */
+    error: Error | null;
+}
+/**
+ * Hook to access the CleverenceEdge instance and connection state
+ *
+ * @example
+ * ```tsx
+ * function StatusBar() {
+ *   const { isConnected, capabilities, error } = useEdge();
+ *
+ *   if (error) return <div>Error: {error.message}</div>;
+ *   if (!isConnected) return <div>Connecting...</div>;
+ *
+ *   return (
+ *     <div>
+ *       Connected to {capabilities?.vendor} {capabilities?.deviceModel}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useEdge(): UseEdgeReturn;
+
+interface UseBarcodeOptions {
+    /** Maximum number of scans to keep in history. Default: 50 */
+    maxHistory?: number;
+    /** Called when a new scan is received */
+    onScan?: (event: ScanEvent) => void;
+}
+interface UseBarcodeReturn {
+    /** Most recent scan event */
+    lastScan: ScanEvent | null;
+    /** History of scan events (newest first) */
+    scanHistory: ScanEvent[];
+    /** Clear the scan history */
+    clearHistory: () => void;
+    /** Trigger a scan programmatically */
+    triggerScan: () => Promise<void>;
+}
+/**
+ * Hook for barcode scanning
+ *
+ * @example
+ * ```tsx
+ * function Scanner() {
+ *   const { lastScan, scanHistory, clearHistory } = useBarcode({
+ *     onScan: (scan) => console.log('Scanned:', scan.data),
+ *   });
+ *
+ *   return (
+ *     <div>
+ *       <h1>Last: {lastScan?.data}</h1>
+ *       <button onClick={clearHistory}>Clear</button>
+ *       <ul>
+ *         {scanHistory.map(scan => (
+ *           <li key={scan.id}>{scan.data} ({scan.symbology})</li>
+ *         ))}
+ *       </ul>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useBarcode(options?: UseBarcodeOptions): UseBarcodeReturn;
+
+interface UseRfidOptions {
+    /** Called when a new RFID tag is read */
+    onRead?: (event: RfidEvent) => void;
+}
+interface UseRfidReturn {
+    /** Most recent RFID read event */
+    lastRead: RfidEvent | null;
+    /** Aggregated list of unique tags (by EPC) */
+    tags: Map<string, RfidTag>;
+    /** Whether an inventory is currently active */
+    isInventoryActive: boolean;
+    /** Start RFID inventory */
+    startInventory: (options?: RfidInventoryOptions) => Promise<void>;
+    /** Stop RFID inventory */
+    stopInventory: () => Promise<void>;
+    /** Clear the tags list */
+    clearTags: () => void;
+}
+/**
+ * Hook for RFID reading
+ *
+ * @example
+ * ```tsx
+ * function RfidReader() {
+ *   const { tags, isInventoryActive, startInventory, stopInventory } = useRfid();
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={() => isInventoryActive ? stopInventory() : startInventory()}>
+ *         {isInventoryActive ? 'Stop' : 'Start'} Inventory
+ *       </button>
+ *       <p>{tags.size} unique tags found</p>
+ *       <ul>
+ *         {Array.from(tags.values()).map(tag => (
+ *           <li key={tag.epc}>
+ *             {tag.epc} (RSSI: {tag.rssi}, Count: {tag.readCount})
+ *           </li>
+ *         ))}
+ *       </ul>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useRfid(options?: UseRfidOptions): UseRfidReturn;
+
+export { type ConnectionState, type DeviceCapabilities, type EdgeConfig, type EdgeOptions, EdgeProvider, type EdgeProviderProps, type EdgeStatus, type RfidEvent, type RfidInventoryOptions, type RfidTag, type ScanEvent, type UseBarcodeOptions, type UseBarcodeReturn, type UseEdgeReturn, type UseRfidOptions, type UseRfidReturn, useBarcode, useEdge, useRfid };