@hangtime/grip-connect 0.5.6 → 0.5.7

package/dist/models/device/wh-c06.model.d.ts

@@ -8,27 +8,32 @@ export declare class WHC06 extends Device implements IWHC06 {
     /**
      * Offset for the byte location in the manufacturer data to extract the weight.
      * @type {number}
+     * @static
+     * @readonly
      * @constant
      */
-    private static readonly WEIGHT_OFFSET;
+    private static readonly weightOffset;
     /**
      * Company identifier for WH-C06, also used by 'TomTom International BV': https://www.bluetooth.com/specifications/assigned-numbers/
      * @type {number}
+     * @static
+     * @readonly
      * @constant
      */
-    private static readonly MANUFACTURER_ID;
+    private static readonly manufacturerId;
     /**
      * To track disconnection timeout.
      * @type {number|null}
-     * @constant
+     * @private
      */
     private advertisementTimeout;
     /**
      * The limit in seconds when timeout is triggered
-     * @type {number|null}
-     * @constant
+     * @type {number}
+     * @private
+     * @readonly
      */
-    private advertisementTimeoutTime;
+    private readonly advertisementTimeoutTime;
     constructor();
     /**
      * Connects to a Bluetooth device.

package/dist/models/device/wh-c06.model.js

@@ -1,7 +1,4 @@
 import { Device } from "../device.model";
-import { applyTare } from "../../helpers/tare";
-import { checkActivity } from "../../helpers/is-active";
-import { DownloadPackets } from "../../helpers/download";
 /**
  * Represents a  Weiheng - WH-C06 (or MAT Muscle Meter) device
  * Enable 'Experimental Web Platform features' Chrome Flags.
@@ -10,28 +7,40 @@ export class WHC06 extends Device {
     /**
      * Offset for the byte location in the manufacturer data to extract the weight.
      * @type {number}
+     * @static
+     * @readonly
      * @constant
      */
-    static WEIGHT_OFFSET = 10;
+    static weightOffset = 10;
     /**
      * Company identifier for WH-C06, also used by 'TomTom International BV': https://www.bluetooth.com/specifications/assigned-numbers/
      * @type {number}
+     * @static
+     * @readonly
      * @constant
      */
-    static MANUFACTURER_ID = 256;
+    static manufacturerId = 256;
     /**
      * To track disconnection timeout.
      * @type {number|null}
-     * @constant
+     * @private
      */
     advertisementTimeout = null;
     /**
      * The limit in seconds when timeout is triggered
-     * @type {number|null}
-     * @constant
+     * @type {number}
+     * @private
+     * @readonly
      */
     advertisementTimeoutTime = 10;
-    // private static readonly  STABLE_OFFSET = 14
+    // /**
+    //  * Offset for the byte location in the manufacturer data to determine weight stability.
+    //  * @type {number}
+    //  * @static
+    //  * @readonly
+    //  * @constant
+    //  */
+    // private static readonly stableOffset: number = 14
     constructor() {
         super({
             filters: [
@@ -66,18 +75,23 @@ export class WHC06 extends Device {
             // Device has no services / characteristics, so we directly call onSuccess
             onSuccess();
             this.bluetooth.addEventListener("advertisementreceived", (event) => {
-                const data = event.manufacturerData.get(WHC06.MANUFACTURER_ID);
+                const data = event.manufacturerData.get(WHC06.manufacturerId);
                 if (data) {
                     // Handle recieved data
-                    const weight = (data.getUint8(WHC06.WEIGHT_OFFSET) << 8) | data.getUint8(WHC06.WEIGHT_OFFSET + 1);
+                    const weight = (data.getUint8(WHC06.weightOffset) << 8) | data.getUint8(WHC06.weightOffset + 1);
                     // const stable = (data.getUint8(STABLE_OFFSET) & 0xf0) >> 4
                     // const unit = data.getUint8(STABLE_OFFSET) & 0x0f
                     const receivedTime = Date.now();
                     const receivedData = weight / 100;
                     // Tare correction
-                    const numericData = receivedData - applyTare(receivedData);
+                    // 0.20kg - 0.20kg = 0kg
+                    // 0.40kg - 0.20kg = 0.20kg
+                    const numericData = receivedData - this.applyTare(receivedData) * -1;
+                    // what i want (if tare is available)
+                    // 75kg - 75kg = 0
+                    // 50kg - 75kg = -25kg * -1 = 25kg
                     // Add data to downloadable Array
-                    DownloadPackets.push({
+                    this.downloadPackets.push({
                         received: receivedTime,
                         sampleNum: this.dataPointCount,
                         battRaw: 0,
@@ -93,7 +107,7 @@ export class WHC06 extends Device {
                     // Calculate the average dynamically
                     this.massAverage = (this.massTotalSum / this.dataPointCount).toFixed(1);
                     // Check if device is being used
-                    checkActivity(numericData);
+                    this.activityCheck(numericData);
                     // Notify with weight data
                     this.notifyCallback({
                         massMax: this.massMax,
@@ -142,8 +156,8 @@ export class WHC06 extends Device {
             // Mimic a disconnect
             const disconnectedEvent = new Event("gattserverdisconnected");
             Object.defineProperty(disconnectedEvent, "target", { value: this.bluetooth, writable: false });
-            // Also display a e
-            throw new Error(`No advertisement received for ${this.advertisementTimeoutTime} seconds, stopping tracking..`);
+            // Print error to the console
+            console.error(`No advertisement received for ${this.advertisementTimeoutTime} seconds, stopping tracking..`);
             this.onDisconnected(disconnectedEvent);
         }, this.advertisementTimeoutTime * 1000); // 10 seconds
     };

package/dist/models/device.model.d.ts

@@ -1,32 +1,61 @@
 import { BaseModel } from "./../models/base.model";
 import type { IDevice, Service } from "../interfaces/device.interface";
-import type { NotifyCallback, WriteCallback } from "../interfaces/callback.interface";
+import type { NotifyCallback, WriteCallback, ActiveCallback } from "../interfaces/callback.interface";
+import type { DownloadPacket } from "../interfaces/download.interface";
 import type { Commands } from "../interfaces/command.interface";
 export declare abstract class Device extends BaseModel implements IDevice {
     /**
      * Filters to identify the device during Bluetooth scanning.
      * Used to match devices that meet specific criteria such as name, service UUIDs, etc.
+     * @type {BluetoothLEScanFilter[]}
+     * @public
+     * @readonly
      */
-    filters: BluetoothLEScanFilter[];
+    readonly filters: BluetoothLEScanFilter[];
     /**
      * Array of services provided by the device.
      * Services represent functionalities that the device supports, such as weight measurement, battery information, or custom services.
+     * @type {Service[]}
+     * @public
+     * @readonly
      */
-    services: Service[];
+    readonly services: Service[];
     /**
      * Reference to the `BluetoothDevice` object representing this device.
      * This is the actual device object obtained from the Web Bluetooth API after a successful connection.
+     * @type {BluetoothDevice | undefined}
+     * @public
      */
     bluetooth?: BluetoothDevice | undefined;
     /**
      * Object representing the set of commands available for this device.
      * These commands allow communication with the device to perform various operations such as starting measurements, retrieving data, or calibrating the device.
+     * @type {Commands}
+     * @public
+     * @readonly
      */
-    commands: Commands;
+    readonly commands: Commands;
     /**
      * The BluetoothRemoteGATTServer interface of the Web Bluetooth API represents a GATT Server on a remote device.
+     * @type {BluetoothRemoteGATTServer | undefined}
+     * @private
      */
     private server;
+    /**
+     * The last message written to the device.
+     * @type {string | Uint8Array | null}
+     * @protected
+     */
+    protected writeLast: string | Uint8Array | null;
+    /**
+     * Indicates whether the device is currently active.
+     * @type {boolean}
+     */
+    protected isActive: boolean;
+    /**
+     * Configuration for threshold and duration.
+     */
+    private activeConfig;
     /**
      * Maximum mass recorded from the device, initialized to "0".
      * @type {string}
@@ -53,6 +82,38 @@ export declare abstract class Device extends BaseModel implements IDevice {
      * @protected
      */
     protected dataPointCount: number;
+    /**
+     * Array of DownloadPacket entries.
+     * This array holds packets that contain data downloaded from the device.
+     * @type {DownloadPacket[]}
+     * @protected
+     */
+    protected downloadPackets: DownloadPacket[];
+    /**
+     * Represents the current tare value for calibration.
+     * @type {number}
+     */
+    private tareCurrent;
+    /**
+     * Indicates whether the tare calibration process is active.
+     * @type {boolean}
+     */
+    private tareActive;
+    /**
+     * Timestamp when the tare calibration process started.
+     * @type {number | null}
+     */
+    private tareStartTime;
+    /**
+     * Array holding the samples collected during tare calibration.
+     * @type {number[]}
+     */
+    private tareSamples;
+    /**
+     * Duration time for the tare calibration process.
+     * @type {number}
+     */
+    private tareDuration;
     /**
      * Optional callback for handling write operations.
      * @callback NotifyCallback
@@ -70,69 +131,156 @@ export declare abstract class Device extends BaseModel implements IDevice {
      */
     protected writeCallback: WriteCallback;
     /**
-     * The last message written to the device.
-     * @type {string | Uint8Array | null}
+     * Optional callback for handling write operations.
+     * @callback ActiveCallback
+     * @param {string} data - The data passed to the callback.
+     * @type {ActiveCallback | undefined}
+     * @protected
      */
-    protected writeLast: string | Uint8Array | null;
+    protected activeCallback: ActiveCallback;
     constructor(device: Partial<IDevice>);
+    /**
+     * Sets the callback function to be called when the activity status changes,
+     * and optionally sets the configuration for threshold and duration.
+     *
+     * This function allows you to specify a callback that will be invoked whenever
+     * the activity status changes, indicating whether the device is currently active.
+     * It also allows optionally configuring the threshold and duration used to determine activity.
+     *
+     * @param {ActiveCallback} callback - The callback function to be set. This function
+     *                                      receives a boolean value indicating the new activity status.
+     * @param {object} [options] - Optional configuration object containing the threshold and duration.
+     * @param {number} [options.threshold=2.5] - The threshold value for determining activity.
+     * @param {number} [options.duration=1000] - The duration (in milliseconds) to monitor the input for activity.
+     * @returns {void}
+     * @public
+     */
+    active: (callback: ActiveCallback, options?: {
+        threshold?: number;
+        duration?: number;
+    }) => void;
+    /**
+     * Checks if a dynamic value is active based on a threshold and duration.
+     *
+     * This function assesses whether a given dynamic value surpasses a specified threshold
+     * and remains active for a specified duration. If the activity status changes from
+     * the previous state, the callback function is called with the updated activity status.
+     *
+     * @param {number} input - The dynamic value to check for activity status.
+     * @returns {Promise<void>} A promise that resolves once the activity check is complete.
+     */
+    protected activityCheck: (input: number) => Promise<void>;
     /**
      * Connects to a Bluetooth device.
      * @param {Function} [onSuccess] - Optional callback function to execute on successful connection. Default logs success.
      * @param {Function} [onError] - Optional callback function to execute on error. Default logs the error.
+     * @public
      */
     connect: (onSuccess?: () => void, onError?: (error: Error) => void) => Promise<void>;
     /**
      * Disconnects the device if it is currently connected.
      * - Checks if the device is connected via it's GATT server.
      * - If the device is connected, it attempts to gracefully disconnect.
+     * @public
      */
     disconnect: () => void;
+    /**
+     * Converts the `downloadPackets` array into a CSV formatted string.
+     * @returns {string} A CSV string representation of the `downloadPackets` data, with each packet on a new line.
+     * @private
+     */
+    private downloadToCSV;
+    /**
+     * Converts an array of DownloadPacket objects to a JSON string.
+     * @returns {string} JSON string representation of the data.
+     * @private
+     */
+    private downloadToJSON;
+    /**
+     * Converts an array of DownloadPacket objects to an XML string.
+     * @returns {string}  XML string representation of the data.
+     * @private
+     */
+    private downloadToXML;
+    /**
+     * Exports the data in the specified format (CSV, JSON, XML) with a filename format:
+     * 'data-export-YYYY-MM-DD-HH-MM-SS.{format}'.
+     *
+     * @param {('csv' | 'json' | 'xml')} [format='csv'] - The format in which to download the data.
+     * Defaults to 'csv'. Accepted values are 'csv', 'json', and 'xml'.
+     *
+     * @returns {void} Initiates a download of the data in the specified format.
+     * @private
+     */
+    download: (format?: "csv" | "json" | "xml") => void;
     /**
      * Returns UUIDs of all services associated with the device.
      * @returns {string[]} Array of service UUIDs.
+     * @protected
      */
-    getAllServiceUUIDs: () => string[];
+    protected getAllServiceUUIDs: () => string[];
     /**
      * Retrieves the characteristic from the device's service.
      * @param {string} serviceId - The UUID of the service.
      * @param {string} characteristicId - The UUID of the characteristic.
      * @returns {BluetoothRemoteGATTCharacteristic | undefined} The characteristic, if found.
+     * @protected
      */
-    getCharacteristic: (serviceId: string, characteristicId: string) => BluetoothRemoteGATTCharacteristic | undefined;
+    protected getCharacteristic: (serviceId: string, characteristicId: string) => BluetoothRemoteGATTCharacteristic | undefined;
     /**
      * Handles notifications received from a characteristic.
      * @param {Event} event - The notification event.
+     * @protected
      */
-    handleNotifications: (event: Event) => void;
+    protected handleNotifications: (event: Event) => void;
     /**
      * Checks if a Bluetooth device is connected.
      * @returns {boolean} A boolean indicating whether the device is connected.
+     * @public
      */
     isConnected: () => boolean;
     /**
      * Sets the callback function to be called when notifications are received.
      * @param {NotifyCallback} callback - The callback function to be set.
      * @returns {void}
+     * @public
      */
     notify: (callback: NotifyCallback) => void;
     /**
      * Handles the 'connected' event.
      * @param {Function} onSuccess - Callback function to execute on successful connection.
+     * @public
      */
-    onConnected: (onSuccess: () => void) => Promise<void>;
+    protected onConnected: (onSuccess: () => void) => Promise<void>;
     /**
      * Handles the 'disconnected' event.
      * @param {Event} event - The 'disconnected' event.
+     * @public
      */
-    onDisconnected: (event: Event) => void;
+    protected onDisconnected: (event: Event) => void;
     /**
      * Reads the value of the specified characteristic from the device.
      * @param {string} serviceId - The service ID where the characteristic belongs.
      * @param {string} characteristicId - The characteristic ID to read from.
      * @param {number} [duration=0] - The duration to wait before resolving the promise, in milliseconds.
      * @returns {Promise<string | undefined>} A promise that resolves when the read operation is completed.
+     * @public
      */
     read: (serviceId: string, characteristicId: string, duration?: number) => Promise<string | undefined>;
+    /**
+     * Initiates the tare calibration process.
+     * @param {number} duration - The duration time for tare calibration.
+     * @returns {void}
+     * @public
+     */
+    tare(duration?: number): void;
+    /**
+     * Apply tare calibration to the provided sample.
+     * @param {number} sample - The sample to calibrate.
+     * @returns {number} The calibrated tare value.
+     * @protected
+     */
+    protected applyTare(sample: number): number;
     /**
      * Writes a message to the specified characteristic of a Bluetooth device and optionally provides a callback to handle responses.
      * @param {string} serviceId - The service UUID of the Bluetooth device containing the target characteristic.
@@ -140,9 +288,8 @@ export declare abstract class Device extends BaseModel implements IDevice {
      * @param {string | Uint8Array | undefined} message - The message to be written to the characteristic. It can be a string or a Uint8Array.
      * @param {number} [duration=0] - Optional. The time in milliseconds to wait before resolving the promise. Defaults to 0 for immediate resolution.
      * @param {WriteCallback} [callback=writeCallback] - Optional. A custom callback to handle the response after the write operation is successful.
-     *
      * @returns {Promise<void>} A promise that resolves once the write operation is complete.
-     *
+     * @public
      * @throws {Error} Throws an error if the characteristic is undefined.
      *
      * @example