nsd-ble 0.3.3 → 0.4.1

package/dist/objects.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./Objects-WdcC281c.cjs");exports.Buffer=e.Buffer;exports.ButtonResult=e.ButtonResult;exports.Standee=e.Standee;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./Objects-Zntmn07s.cjs");exports.Buffer=e.Buffer;exports.ButtonResult=e.ButtonResult;exports.Standee=e.Standee;

package/dist/objects.js

@@ -1,4 +1,4 @@
-import { B as a, d as s, S as f } from "./Objects-C2BH61j-.js";
+import { B as a, e as s, S as f } from "./Objects-ulh5Kfet.js";
 export {
   a as Buffer,
   s as ButtonResult,

package/dist/types/Types.d.ts

@@ -22,3 +22,102 @@ type ImagePixels = {
     height: number;
     pixels: number[];
 };
+
+interface ReconnectStatus {
+    attempt: number;
+    maxRetries: number;
+    delay: number;
+}
+
+interface PacketSentEvent {
+    cacheId: number;
+    position: number;
+    dataSize: number;
+    packetBytes: number;
+    batchIndex: number;
+    timestamp: number;
+}
+
+interface MessageQueuedEvent {
+    cacheId: number;
+    type: number;
+    targetId: number;
+    packetCount: number;
+    totalBytes: number;
+    timestamp: number;
+}
+
+interface RetransmitEvent {
+    cacheId: number;
+    packetCount: number;
+    reason: "feedback" | "timeout";
+    timestamp: number;
+}
+
+interface TimeoutEvent {
+    cacheId: number;
+    retryCount: number;
+    maxRetries: number;
+    willRetry: boolean;
+    timestamp: number;
+}
+
+interface MessageCompleteEvent {
+    cacheId: number;
+    timestamp: number;
+}
+
+interface DebugLogEntry {
+    type: DebugEventType;
+    timestamp: number;
+    data: Record<string, unknown>;
+}
+
+type DebugEventType =
+    | "packet_sent"
+    | "message_queued"
+    | "retransmit"
+    | "timeout"
+    | "message_complete"
+    | "message_done"
+    | "received_packets"
+    | "node_discovered"
+    | "node_lost"
+    | "connected"
+    | "disconnected";
+
+interface DecodedPacket {
+    cacheId: number;
+    targetId: number;
+    ttl: number;
+    position: number;
+    dataSize: number;
+    typeName: string;
+    typeValue: number;
+    payloadBytes: number;
+    raw: number[];
+}
+
+interface MessageTimingRecord {
+    cacheId: number;
+    queuedAt: number;
+    firstPacketAt: number | null;
+    completedAt: number | null;
+    latencyMs: number | null;
+    retransmitCount: number;
+    timeoutCount: number;
+    packetsSent: number;
+    totalPackets: number;
+}
+
+interface VirtualStandee {
+    id: number;
+    neighbors: number[];
+}
+
+interface MockMeshConfig {
+    standees: VirtualStandee[];
+    responseDelay?: number;
+    dropRate?: number;
+    partialDelivery?: boolean;
+}

package/dist/types/ble/BluetoothProvider.d.ts

@@ -0,0 +1,9 @@
+export interface BluetoothProvider {
+    connect(options: BluetoothOptions): Promise<void>;
+    reconnect(): Promise<void>;
+    readCharacteristic(serviceUuid: string, charUuid: string): Promise<DataView<ArrayBufferLike> | undefined>;
+    writeCharacteristic(serviceUuid: string, charUuid: string, data: Uint8Array): Promise<void>;
+    subscribe(serviceUuid: string, charUuid: string, callback: characteristicCallback): Promise<void>;
+}
+export declare function setBluetoothProvider(provider: BluetoothProvider | null): void;
+export declare function getBluetoothProvider(): BluetoothProvider | null;

package/dist/types/ble/Mesh.d.ts

@@ -1,16 +1,21 @@
+import { SyncEvent } from 'ts-events';
 declare function connect(): Promise<void>;
 declare function reconnect(): Promise<void>;
+declare function _resetForTesting(): void;
 export declare function useMesh(): {
     connect: typeof connect;
-    onConnect: import('ts-events').SyncEvent<void>;
-    onDisconnect: import('ts-events').SyncEvent<void>;
+    onConnect: SyncEvent<void>;
+    onDisconnect: SyncEvent<void>;
+    onReconnecting: SyncEvent<ReconnectStatus>;
+    onReconnectFailed: SyncEvent<void>;
     reconnect: typeof reconnect;
-    onNodes: import('ts-events').SyncEvent<Map<number, number[]>>;
-    onNode: import('ts-events').SyncEvent<Map<number, number[]>>;
-    onNodeLost: import('ts-events').SyncEvent<number>;
-    onPlusButton: import('ts-events').SyncEvent<import('./MessageCharacteristic.js').ButtonResult>;
-    onMinButton: import('ts-events').SyncEvent<import('./MessageCharacteristic.js').ButtonResult>;
-    onEitherButton: import('ts-events').SyncEvent<import('./MessageCharacteristic.js').ButtonResult>;
-    onMessageDone: import('ts-events').SyncEvent<number>;
+    onNodes: SyncEvent<Map<number, number[]>>;
+    onNode: SyncEvent<Map<number, number[]>>;
+    onNodeLost: SyncEvent<number>;
+    onPlusButton: SyncEvent<import('./MessageCharacteristic.js').ButtonResult>;
+    onMinButton: SyncEvent<import('./MessageCharacteristic.js').ButtonResult>;
+    onEitherButton: SyncEvent<import('./MessageCharacteristic.js').ButtonResult>;
+    onMessageDone: SyncEvent<number>;
+    _resetForTesting: typeof _resetForTesting;
 };
 export {};

package/dist/types/ble/MeshWriter.d.ts

@@ -1,6 +1,14 @@
+import { SyncEvent } from 'ts-events';
 import { default as Buffer } from './Buffer.js';
 declare function write(buffer: Buffer): Promise<void>;
+declare function abortAll(error: Error): void;
 export declare function useMeshWriter(): {
     write: typeof write;
+    abortAll: typeof abortAll;
+    onPacketSent: SyncEvent<PacketSentEvent>;
+    onMessageQueued: SyncEvent<MessageQueuedEvent>;
+    onRetransmit: SyncEvent<RetransmitEvent>;
+    onTimeout: SyncEvent<TimeoutEvent>;
+    onMessageComplete: SyncEvent<MessageCompleteEvent>;
 };
 export {};

package/dist/types/ble/MockBluetooth.d.ts

@@ -0,0 +1,25 @@
+declare function activate(config: MockMeshConfig): void;
+declare function deactivate(): void;
+declare function isActive(): boolean;
+declare function getConfig(): MockMeshConfig;
+declare function updateConfig(partial: Partial<MockMeshConfig>): void;
+declare function pressButton(standeeId: number, button: "plus" | "minus" | "either", data?: string): void;
+declare function simulateNodeLost(standeeId: number): void;
+declare function simulateNodeJoin(standee: VirtualStandee): void;
+declare function disconnect(): void;
+declare function reconnectable(value: boolean): void;
+declare function _resetForTesting(): void;
+export declare function useMockBluetooth(): {
+    activate: typeof activate;
+    deactivate: typeof deactivate;
+    isActive: typeof isActive;
+    getConfig: typeof getConfig;
+    updateConfig: typeof updateConfig;
+    pressButton: typeof pressButton;
+    simulateNodeLost: typeof simulateNodeLost;
+    simulateNodeJoin: typeof simulateNodeJoin;
+    disconnect: typeof disconnect;
+    reconnectable: typeof reconnectable;
+    _resetForTesting: typeof _resetForTesting;
+};
+export {};

package/dist/types/ble/Settings.d.ts

@@ -7,4 +7,8 @@ export declare function useBluetoothSettings(): {
     TTL: number;
     PACKET_SIZE: number;
     BATCH_SIZE: number;
+    ACK_TIMEOUT: number;
+    MAX_RETRIES: number;
+    RECONNECT_DELAY: number;
+    RECONNECT_MAX_RETRIES: number;
 };

package/dist/types/composable/Debug.d.ts

@@ -0,0 +1,26 @@
+import { SyncEvent } from 'ts-events';
+declare function enable(): void;
+declare function disable(): void;
+declare function isEnabled(): boolean;
+declare function setMaxLogSize(size: number): void;
+declare function getLog(): ReadonlyArray<DebugLogEntry>;
+declare function getTimings(): ReadonlyArray<MessageTimingRecord>;
+declare function getTimingForCache(cacheId: number): MessageTimingRecord | undefined;
+declare function clear(): void;
+declare function decodePacket(packet: Uint8Array): DecodedPacket;
+declare function _resetForTesting(): void;
+export declare function useDebug(): {
+    enable: typeof enable;
+    disable: typeof disable;
+    isEnabled: typeof isEnabled;
+    clear: typeof clear;
+    getLog: typeof getLog;
+    getTimings: typeof getTimings;
+    getTimingForCache: typeof getTimingForCache;
+    setMaxLogSize: typeof setMaxLogSize;
+    decodePacket: typeof decodePacket;
+    onDebugEvent: SyncEvent<DebugLogEntry>;
+    onTimingUpdate: SyncEvent<MessageTimingRecord>;
+    _resetForTesting: typeof _resetForTesting;
+};
+export {};

package/dist/types/main.d.ts

@@ -10,4 +10,6 @@ import { useBinary } from './composable/Binary';
 import { useImage } from './composable/Image';
 import { useConverter } from './composable/Converter';
 import { useUtils } from './composable/DisplayUtils';
-export { useMesh, useGraphics, useStandees, useLoader, useStandeeElements, useDisplay, useActions, useButtons, useBinary, useImage, useConverter, useUtils, };
+import { useDebug } from './composable/Debug';
+import { useMockBluetooth } from './ble/MockBluetooth';
+export { useMesh, useGraphics, useStandees, useLoader, useStandeeElements, useDisplay, useActions, useButtons, useBinary, useImage, useConverter, useUtils, useDebug, useMockBluetooth, };

package/dist/types/standee/Loader.d.ts

@@ -6,11 +6,16 @@ export interface LoaderProgress {
     total: number;
     percentage: number;
 }
+export interface LoaderError {
+    buffer: number;
+    error: Error;
+}
 declare class Loader {
     id: number;
     buffers: Buffer[];
     totalPackets: number;
     onProgress: SyncEvent<LoaderProgress>;
+    onError: SyncEvent<LoaderError>;
     constructor(buffers: Buffer[], id: number);
     send(): Promise<void>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nsd-ble",
-  "version": "0.3.3",
+  "version": "0.4.1",
   "type": "module",
   "files": [
     "dist"