@hangtime/grip-connect 0.4.1 → 0.4.2

package/README.md

@@ -60,10 +60,14 @@ motherboardButton.addEventListener("click", () => {
         console.log(data)
       })
 
-      // Check if device is being used
-      active((value) => {
-        console.log(value)
-      })
+      // Reactive check if device is active
+      active(
+        (isActive) => {
+          console.log(isActive)
+        },
+        // Optionally using a weight threshold and duration
+        { threshold: 2.5, duration: 1000 },
+      )
 
       // Read info: battery + firmware
       const batteryLevel = await battery(Motherboard)

package/dist/battery.d.ts

@@ -6,7 +6,5 @@ import type { Device } from "./types/devices";
  *
  * @param {Device} board - The device from which to retrieve battery information.
  * @returns {Promise<string | undefined>} A Promise that resolves with the battery or voltage information,
- *                            or rejects with an error if the device is not connected.
- * @throws {Error} Throws an error if the device is not connected.
  */
 export declare const battery: (board: Device) => Promise<string | undefined>;

package/dist/battery.js

@@ -10,8 +10,6 @@ import { ProgressorCommands } from "./commands";
  *
  * @param {Device} board - The device from which to retrieve battery information.
  * @returns {Promise<string | undefined>} A Promise that resolves with the battery or voltage information,
- *                            or rejects with an error if the device is not connected.
- * @throws {Error} Throws an error if the device is not connected.
  */
 export const battery = async (board) => {
     // Check if the device is connected
@@ -30,8 +28,7 @@ export const battery = async (board) => {
             });
             return response;
         }
-        // If device is not found, return undefined
-        return;
     }
-    throw new Error("Not connected.");
+    // If device is not found, return undefined
+    return undefined;
 };

package/dist/characteristic.js

@@ -17,4 +17,5 @@ export const getCharacteristic = (board, serviceId, characteristicId) => {
         }
     }
     // Return undefined if the service or characteristic is not found
+    return undefined;
 };

package/dist/disconnect.d.ts

@@ -1,6 +1,8 @@
 import type { Device } from "./types/devices";
 /**
- * Disconnects the device if it is connected.
- * @param {Device} board - The device to disconnect.
+ * Disconnects the device if it is currently connected.
+ * - Checks if the device is connected via its GATT server.
+ * - If the device is connected, it attempts to gracefully disconnect.
+ * @param {Device} board - The device to be disconnected. The device must have a `gatt` property accessible through `board.device`.
  */
 export declare const disconnect: (board: Device) => void;

package/dist/disconnect.js

@@ -1,12 +1,14 @@
 import { isConnected } from "./is-connected";
 /**
- * Disconnects the device if it is connected.
- * @param {Device} board - The device to disconnect.
+ * Disconnects the device if it is currently connected.
+ * - Checks if the device is connected via its GATT server.
+ * - If the device is connected, it attempts to gracefully disconnect.
+ * @param {Device} board - The device to be disconnected. The device must have a `gatt` property accessible through `board.device`.
  */
 export const disconnect = (board) => {
-    // Check if the device is connected
+    // Verify that the device is connected using the provided helper function
     if (isConnected(board)) {
-        // Disconnect the device using optional chaining
+        // Safely attempt to disconnect the device's GATT server, if available
         board.device?.gatt?.disconnect();
     }
 };

package/dist/firmware.d.ts

@@ -6,7 +6,5 @@ import type { Device } from "./types/devices";
  *
  * @param {Device} board - The device from which to retrieve firmware version.
  * @returns {Promise<string>} A Promise that resolves with the firmware version,
- *                            or rejects with an error if the device is not connected.
- * @throws {Error} Throws an error if the device is not connected.
  */
 export declare const firmware: (board: Device) => Promise<string | undefined>;

package/dist/firmware.js

@@ -10,8 +10,6 @@ import { isMotherboard, isProgressor } from "./is-device";
  *
  * @param {Device} board - The device from which to retrieve firmware version.
  * @returns {Promise<string>} A Promise that resolves with the firmware version,
- *                            or rejects with an error if the device is not connected.
- * @throws {Error} Throws an error if the device is not connected.
  */
 export const firmware = async (board) => {
     // Check if the device is connected
@@ -30,8 +28,7 @@ export const firmware = async (board) => {
             });
             return response;
         }
-        // If device is not found, return undefined
-        return;
     }
-    throw new Error("Not connected.");
+    // If device is not found, return undefined
+    return undefined;
 };

package/dist/hardware.d.ts

@@ -5,7 +5,5 @@ import type { Device } from "./types/devices";
  *
  * @param {Device} board - The device from which to retrieve hardware version.
  * @returns {Promise<string>} A Promise that resolves with the hardware version,
- *                            or rejects with an error if the device is not connected.
- * @throws {Error} Throws an error if the device is not connected.
  */
 export declare const hardware: (board: Device) => Promise<string | undefined>;

package/dist/hardware.js

@@ -7,8 +7,6 @@ import { isMotherboard } from "./is-device";
  *
  * @param {Device} board - The device from which to retrieve hardware version.
  * @returns {Promise<string>} A Promise that resolves with the hardware version,
- *                            or rejects with an error if the device is not connected.
- * @throws {Error} Throws an error if the device is not connected.
  */
 export const hardware = async (board) => {
     // Check if the device is connected
@@ -18,8 +16,7 @@ export const hardware = async (board) => {
             // Read hardware version from the Motherboard
             return await read(board, "device", "hardware", 250);
         }
-        // If device is not found, return undefined
-        return;
     }
-    throw new Error("Not connected.");
+    // If device is not found, return undefined
+    return;
 };

package/dist/is-active.d.ts

@@ -9,16 +9,24 @@ type IsActiveCallback = (value: boolean) => void;
  */
 export declare let isActive: boolean;
 /**
- * Sets the callback function to be called when the activity status changes.
+ * 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 {IsActiveCallback} 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}
  */
-export declare const active: (callback: IsActiveCallback) => void;
+export declare const active: (callback: IsActiveCallback, options?: {
+    threshold?: number;
+    duration?: number;
+}) => void;
 /**
  * Checks if a dynamic value is active based on a threshold and duration.
  *
@@ -27,11 +35,7 @@ export declare const active: (callback: IsActiveCallback) => void;
  * the previous state, the callback function is called with the updated activity status.
  *
  * @param {number} input - The dynamic value to check for activity status.
- * @param {number} [threshold=2.5] - The threshold value to determine if the input is considered active.
- *                                    Defaults to 2.5 if not provided.
- * @param {number} [duration=1000] - The duration (in milliseconds) to monitor the input for activity.
- *                                    Defaults to 1000 milliseconds if not provided.
  * @returns {Promise<void>} A promise that resolves once the activity check is complete.
  */
-export declare const checkActivity: (input: number, threshold?: number, duration?: number) => Promise<void>;
+export declare const checkActivity: (input: number) => Promise<void>;
 export {};

package/dist/is-active.js

@@ -5,17 +5,31 @@ let activeCallback;
  */
 export let isActive = false;
 /**
- * Sets the callback function to be called when the activity status changes.
+ * Configuration for threshold and duration.
+ */
+let config = { threshold: 2.5, duration: 1000 };
+/**
+ * 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 {IsActiveCallback} 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}
  */
-export const active = (callback) => {
+export const active = (callback, options) => {
     activeCallback = callback;
+    // Update the config values only if provided, otherwise use defaults
+    config = {
+        threshold: options?.threshold ?? config.threshold, // Use new threshold if provided, else use default
+        duration: options?.duration ?? config.duration, // Use new duration if provided, else use default
+    };
 };
 /**
  * Checks if a dynamic value is active based on a threshold and duration.
@@ -25,18 +39,14 @@ export const active = (callback) => {
  * the previous state, the callback function is called with the updated activity status.
  *
  * @param {number} input - The dynamic value to check for activity status.
- * @param {number} [threshold=2.5] - The threshold value to determine if the input is considered active.
- *                                    Defaults to 2.5 if not provided.
- * @param {number} [duration=1000] - The duration (in milliseconds) to monitor the input for activity.
- *                                    Defaults to 1000 milliseconds if not provided.
  * @returns {Promise<void>} A promise that resolves once the activity check is complete.
  */
-export const checkActivity = (input, threshold = 2.5, duration = 1000) => {
+export const checkActivity = (input) => {
     return new Promise((resolve) => {
         // Check the activity status after the specified duration
         setTimeout(() => {
-            // Determine the activity status based on the threshold
-            const activeNow = input > threshold;
+            // Determine the activity status based on the stored threshold in the config
+            const activeNow = input > config.threshold;
             if (isActive !== activeNow) {
                 isActive = activeNow;
                 if (activeCallback) {
@@ -44,6 +54,6 @@ export const checkActivity = (input, threshold = 2.5, duration = 1000) => {
                 }
             }
             resolve();
-        }, duration);
+        }, config.duration);
     });
 };

package/dist/led.js

@@ -190,7 +190,6 @@ export const led = async (board, config) => {
         const [redValue, greenValue] = colorMapping[color];
         await write(board, "led", "red", new Uint8Array(redValue));
         await write(board, "led", "green", new Uint8Array(greenValue), 1250);
-        return;
     }
-    return;
+    return undefined;
 };

package/dist/manufacturer.d.ts

@@ -5,7 +5,5 @@ import type { Device } from "./types/devices";
  *
  * @param {Device} board - The device from which to retrieve manufacturer information.
  * @returns {Promise<string>} A Promise that resolves with the manufacturer information,
- *                            or rejects with an error if the device is not connected.
- * @throws {Error} Throws an error if the device is not connected.
  */
 export declare const manufacturer: (board: Device) => Promise<string | undefined>;

package/dist/manufacturer.js

@@ -7,8 +7,6 @@ import { isMotherboard } from "./is-device";
  *
  * @param {Device} board - The device from which to retrieve manufacturer information.
  * @returns {Promise<string>} A Promise that resolves with the manufacturer information,
- *                            or rejects with an error if the device is not connected.
- * @throws {Error} Throws an error if the device is not connected.
  */
 export const manufacturer = async (board) => {
     // Check if the device is connected
@@ -18,8 +16,7 @@ export const manufacturer = async (board) => {
             // Read manufacturer information from the Motherboard
             return await read(board, "device", "manufacturer", 250);
         }
-        // If device is not found, return undefined
-        return;
     }
-    throw new Error("Not connected.");
+    // If device is not found, return undefined
+    return undefined;
 };

package/dist/read.js

@@ -40,8 +40,5 @@ export const read = (board, serviceId, characteristicId, duration = 0) => {
                 reject(new Error("Characteristic is undefined"));
             }
         }
-        else {
-            reject(new Error("Device is not connected"));
-        }
     });
 };

package/dist/serial.d.ts

@@ -5,7 +5,5 @@ import type { Device } from "./types/devices";
  *
  * @param {Device} board - The device from which to retrieve serial number.
  * @returns {Promise<string>} A Promise that resolves with the serial number,
- *                            or rejects with an error if the device is not connected.
- * @throws {Error} Throws an error if the device is not connected.
  */
 export declare const serial: (board: Device) => Promise<string | undefined>;

package/dist/serial.js

@@ -8,8 +8,6 @@ import { isMotherboard } from "./is-device";
  *
  * @param {Device} board - The device from which to retrieve serial number.
  * @returns {Promise<string>} A Promise that resolves with the serial number,
- *                            or rejects with an error if the device is not connected.
- * @throws {Error} Throws an error if the device is not connected.
  */
 export const serial = async (board) => {
     // Check if the device is connected
@@ -23,8 +21,7 @@ export const serial = async (board) => {
             });
             return response;
         }
-        // If device is not found, return undefined
-        return;
     }
-    throw new Error("Not connected.");
+    // If device is not found, return undefined
+    return undefined;
 };

package/dist/text.d.ts

@@ -8,7 +8,5 @@ import type { Device } from "./types/devices";
  *
  * @param {Device} board - The device from which to retrieve text information.
  * @returns {Promise<string>} A Promise that resolves with the 320-byte memory content as a string,
- *                            which includes both the written data and any unused, whitespace-padded segments.
- * @throws {Error} Throws an error if the device is not connected.
  */
 export declare const text: (board: Device) => Promise<string | undefined>;

package/dist/text.js

@@ -11,8 +11,6 @@ import { MotherboardCommands } from "./commands";
  *
  * @param {Device} board - The device from which to retrieve text information.
  * @returns {Promise<string>} A Promise that resolves with the 320-byte memory content as a string,
- *                            which includes both the written data and any unused, whitespace-padded segments.
- * @throws {Error} Throws an error if the device is not connected.
  */
 export const text = async (board) => {
     // Check if the device is connected
@@ -26,8 +24,7 @@ export const text = async (board) => {
             });
             return response;
         }
-        // If device is not found, return undefined
-        return;
     }
-    throw new Error("Not connected.");
+    // If device is not found, return undefined
+    return undefined;
 };

package/dist/write.d.ts

@@ -22,7 +22,7 @@ export declare let writeCallback: WriteCallback;
  *
  * @returns {Promise<void>} A promise that resolves once the write operation is complete.
  *
- * @throws {Error} Throws an error if the characteristic is undefined or if the device is not connected.
+ * @throws {Error} Throws an error if the characteristic is undefined.
  *
  * @example
  * // Example usage of the write function with a custom callback

package/dist/write.js

@@ -23,7 +23,7 @@ export let writeCallback = (data) => {
  *
  * @returns {Promise<void>} A promise that resolves once the write operation is complete.
  *
- * @throws {Error} Throws an error if the characteristic is undefined or if the device is not connected.
+ * @throws {Error} Throws an error if the characteristic is undefined.
  *
  * @example
  * // Example usage of the write function with a custom callback
@@ -32,29 +32,28 @@ export let writeCallback = (data) => {
  * });
  */
 export const write = async (board, serviceId, characteristicId, message, duration = 0, callback = writeCallback) => {
-    if (!isConnected(board)) {
-        throw new Error("Device is not connected");
-    }
-    // Check if message is provided
-    if (message === undefined) {
-        // If not provided, return without performing write operation
-        return;
-    }
-    // Get the characteristic from the device using serviceId and characteristicId
-    const characteristic = getCharacteristic(board, serviceId, characteristicId);
-    if (!characteristic) {
-        throw new Error("Characteristic is undefined");
-    }
-    // Convert the message to Uint8Array if it's a string
-    const valueToWrite = typeof message === "string" ? new TextEncoder().encode(message) : message;
-    // Write the value to the characteristic
-    await characteristic.writeValue(valueToWrite);
-    // Update the last written message
-    lastWrite = message;
-    // Assign the provided callback to `writeCallback`
-    writeCallback = callback;
-    // If a duration is specified, resolve the promise after the duration
-    if (duration > 0) {
-        await new Promise((resolve) => setTimeout(resolve, duration));
+    if (isConnected(board)) {
+        // Check if message is provided
+        if (message === undefined) {
+            // If not provided, return without performing write operation
+            return;
+        }
+        // Get the characteristic from the device using serviceId and characteristicId
+        const characteristic = getCharacteristic(board, serviceId, characteristicId);
+        if (!characteristic) {
+            throw new Error("Characteristic is undefined");
+        }
+        // Convert the message to Uint8Array if it's a string
+        const valueToWrite = typeof message === "string" ? new TextEncoder().encode(message) : message;
+        // Write the value to the characteristic
+        await characteristic.writeValue(valueToWrite);
+        // Update the last written message
+        lastWrite = message;
+        // Assign the provided callback to `writeCallback`
+        writeCallback = callback;
+        // If a duration is specified, resolve the promise after the duration
+        if (duration > 0) {
+            await new Promise((resolve) => setTimeout(resolve, duration));
+        }
     }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hangtime/grip-connect",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "description": "A client that can establish connections with various Force-Sensing Hangboards/Plates used by climbers for strength measurement. Examples of such hangboards include the Griptonite Motherboard, Climbro, SmartBoard, Entralpi or Tindeq Progressor",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/battery.ts

@@ -12,8 +12,6 @@ import { ProgressorCommands } from "./commands"
  *
  * @param {Device} board - The device from which to retrieve battery information.
  * @returns {Promise<string | undefined>} A Promise that resolves with the battery or voltage information,
- *                            or rejects with an error if the device is not connected.
- * @throws {Error} Throws an error if the device is not connected.
  */
 export const battery = async (board: Device): Promise<string | undefined> => {
   // Check if the device is connected
@@ -32,8 +30,7 @@ export const battery = async (board: Device): Promise<string | undefined> => {
       })
       return response
     }
-    // If device is not found, return undefined
-    return
   }
-  throw new Error("Not connected.")
+  // If device is not found, return undefined
+  return undefined
 }

package/src/characteristic.ts

@@ -25,4 +25,5 @@ export const getCharacteristic = (
     }
   }
   // Return undefined if the service or characteristic is not found
+  return undefined
 }

package/src/disconnect.ts

@@ -2,13 +2,15 @@ import type { Device } from "./types/devices"
 import { isConnected } from "./is-connected"
 
 /**
- * Disconnects the device if it is connected.
- * @param {Device} board - The device to disconnect.
+ * Disconnects the device if it is currently connected.
+ * - Checks if the device is connected via its GATT server.
+ * - If the device is connected, it attempts to gracefully disconnect.
+ * @param {Device} board - The device to be disconnected. The device must have a `gatt` property accessible through `board.device`.
  */
 export const disconnect = (board: Device): void => {
-  // Check if the device is connected
+  // Verify that the device is connected using the provided helper function
   if (isConnected(board)) {
-    // Disconnect the device using optional chaining
+    // Safely attempt to disconnect the device's GATT server, if available
     board.device?.gatt?.disconnect()
   }
 }

package/src/firmware.ts

@@ -12,8 +12,6 @@ import { isMotherboard, isProgressor } from "./is-device"
  *
  * @param {Device} board - The device from which to retrieve firmware version.
  * @returns {Promise<string>} A Promise that resolves with the firmware version,
- *                            or rejects with an error if the device is not connected.
- * @throws {Error} Throws an error if the device is not connected.
  */
 export const firmware = async (board: Device): Promise<string | undefined> => {
   // Check if the device is connected
@@ -32,8 +30,7 @@ export const firmware = async (board: Device): Promise<string | undefined> => {
       })
       return response
     }
-    // If device is not found, return undefined
-    return
   }
-  throw new Error("Not connected.")
+  // If device is not found, return undefined
+  return undefined
 }

package/src/hardware.ts

@@ -9,8 +9,6 @@ import { isMotherboard } from "./is-device"
  *
  * @param {Device} board - The device from which to retrieve hardware version.
  * @returns {Promise<string>} A Promise that resolves with the hardware version,
- *                            or rejects with an error if the device is not connected.
- * @throws {Error} Throws an error if the device is not connected.
  */
 export const hardware = async (board: Device): Promise<string | undefined> => {
   // Check if the device is connected
@@ -20,8 +18,7 @@ export const hardware = async (board: Device): Promise<string | undefined> => {
       // Read hardware version from the Motherboard
       return await read(board, "device", "hardware", 250)
     }
-    // If device is not found, return undefined
-    return
   }
-  throw new Error("Not connected.")
+  // If device is not found, return undefined
+  return
 }

package/src/is-active.ts

@@ -13,17 +13,33 @@ let activeCallback: IsActiveCallback | undefined
 export let isActive = false
 
 /**
- * Sets the callback function to be called when the activity status changes.
+ * Configuration for threshold and duration.
+ */
+let config = { threshold: 2.5, duration: 1000 }
+
+/**
+ * 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 {IsActiveCallback} 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}
  */
-export const active = (callback: IsActiveCallback): void => {
+export const active = (callback: IsActiveCallback, options?: { threshold?: number; duration?: number }): void => {
   activeCallback = callback
+
+  // Update the config values only if provided, otherwise use defaults
+  config = {
+    threshold: options?.threshold ?? config.threshold, // Use new threshold if provided, else use default
+    duration: options?.duration ?? config.duration, // Use new duration if provided, else use default
+  }
 }
 
 /**
@@ -34,18 +50,14 @@ export const active = (callback: IsActiveCallback): void => {
  * the previous state, the callback function is called with the updated activity status.
  *
  * @param {number} input - The dynamic value to check for activity status.
- * @param {number} [threshold=2.5] - The threshold value to determine if the input is considered active.
- *                                    Defaults to 2.5 if not provided.
- * @param {number} [duration=1000] - The duration (in milliseconds) to monitor the input for activity.
- *                                    Defaults to 1000 milliseconds if not provided.
  * @returns {Promise<void>} A promise that resolves once the activity check is complete.
  */
-export const checkActivity = (input: number, threshold = 2.5, duration = 1000): Promise<void> => {
+export const checkActivity = (input: number): Promise<void> => {
   return new Promise((resolve) => {
     // Check the activity status after the specified duration
     setTimeout(() => {
-      // Determine the activity status based on the threshold
-      const activeNow = input > threshold
+      // Determine the activity status based on the stored threshold in the config
+      const activeNow = input > config.threshold
       if (isActive !== activeNow) {
         isActive = activeNow
         if (activeCallback) {
@@ -53,6 +65,6 @@ export const checkActivity = (input: number, threshold = 2.5, duration = 1000):
         }
       }
       resolve()
-    }, duration)
+    }, config.duration)
   })
 }

package/src/led.ts

@@ -205,7 +205,6 @@ export const led = async (
     const [redValue, greenValue] = colorMapping[color]
     await write(board, "led", "red", new Uint8Array(redValue))
     await write(board, "led", "green", new Uint8Array(greenValue), 1250)
-    return
   }
-  return
+  return undefined
 }

package/src/manufacturer.ts

@@ -9,8 +9,6 @@ import { isMotherboard } from "./is-device"
  *
  * @param {Device} board - The device from which to retrieve manufacturer information.
  * @returns {Promise<string>} A Promise that resolves with the manufacturer information,
- *                            or rejects with an error if the device is not connected.
- * @throws {Error} Throws an error if the device is not connected.
  */
 export const manufacturer = async (board: Device): Promise<string | undefined> => {
   // Check if the device is connected
@@ -20,8 +18,7 @@ export const manufacturer = async (board: Device): Promise<string | undefined> =
       // Read manufacturer information from the Motherboard
       return await read(board, "device", "manufacturer", 250)
     }
-    // If device is not found, return undefined
-    return
   }
-  throw new Error("Not connected.")
+  // If device is not found, return undefined
+  return undefined
 }

package/src/read.ts

@@ -41,8 +41,6 @@ export const read = (board: Device, serviceId: string, characteristicId: string,
       } else {
         reject(new Error("Characteristic is undefined"))
       }
-    } else {
-      reject(new Error("Device is not connected"))
     }
   })
 }

package/src/serial.ts

@@ -10,8 +10,6 @@ import { isMotherboard } from "./is-device"
  *
  * @param {Device} board - The device from which to retrieve serial number.
  * @returns {Promise<string>} A Promise that resolves with the serial number,
- *                            or rejects with an error if the device is not connected.
- * @throws {Error} Throws an error if the device is not connected.
  */
 export const serial = async (board: Device): Promise<string | undefined> => {
   // Check if the device is connected
@@ -25,8 +23,7 @@ export const serial = async (board: Device): Promise<string | undefined> => {
       })
       return response
     }
-    // If device is not found, return undefined
-    return
   }
-  throw new Error("Not connected.")
+  // If device is not found, return undefined
+  return undefined
 }

package/src/text.ts

@@ -13,8 +13,6 @@ import { MotherboardCommands } from "./commands"
  *
  * @param {Device} board - The device from which to retrieve text information.
  * @returns {Promise<string>} A Promise that resolves with the 320-byte memory content as a string,
- *                            which includes both the written data and any unused, whitespace-padded segments.
- * @throws {Error} Throws an error if the device is not connected.
  */
 export const text = async (board: Device): Promise<string | undefined> => {
   // Check if the device is connected
@@ -28,8 +26,7 @@ export const text = async (board: Device): Promise<string | undefined> => {
       })
       return response
     }
-    // If device is not found, return undefined
-    return
   }
-  throw new Error("Not connected.")
+  // If device is not found, return undefined
+  return undefined
 }

package/src/write.ts

@@ -30,7 +30,7 @@ export let writeCallback: WriteCallback = (data: string) => {
  *
  * @returns {Promise<void>} A promise that resolves once the write operation is complete.
  *
- * @throws {Error} Throws an error if the characteristic is undefined or if the device is not connected.
+ * @throws {Error} Throws an error if the characteristic is undefined.
  *
  * @example
  * // Example usage of the write function with a custom callback
@@ -46,31 +46,30 @@ export const write = async (
   duration = 0,
   callback: WriteCallback = writeCallback,
 ): Promise<void> => {
-  if (!isConnected(board)) {
-    throw new Error("Device is not connected")
-  }
-  // Check if message is provided
-  if (message === undefined) {
-    // If not provided, return without performing write operation
-    return
-  }
-  // Get the characteristic from the device using serviceId and characteristicId
-  const characteristic = getCharacteristic(board, serviceId, characteristicId)
-  if (!characteristic) {
-    throw new Error("Characteristic is undefined")
-  }
-  // Convert the message to Uint8Array if it's a string
-  const valueToWrite: Uint8Array = typeof message === "string" ? new TextEncoder().encode(message) : message
-  // Write the value to the characteristic
-  await characteristic.writeValue(valueToWrite)
-  // Update the last written message
-  lastWrite = message
-  // Assign the provided callback to `writeCallback`
+  if (isConnected(board)) {
+    // Check if message is provided
+    if (message === undefined) {
+      // If not provided, return without performing write operation
+      return
+    }
+    // Get the characteristic from the device using serviceId and characteristicId
+    const characteristic = getCharacteristic(board, serviceId, characteristicId)
+    if (!characteristic) {
+      throw new Error("Characteristic is undefined")
+    }
+    // Convert the message to Uint8Array if it's a string
+    const valueToWrite: Uint8Array = typeof message === "string" ? new TextEncoder().encode(message) : message
+    // Write the value to the characteristic
+    await characteristic.writeValue(valueToWrite)
+    // Update the last written message
+    lastWrite = message
+    // Assign the provided callback to `writeCallback`
 
-  writeCallback = callback
-  // If a duration is specified, resolve the promise after the duration
+    writeCallback = callback
+    // If a duration is specified, resolve the promise after the duration
 
-  if (duration > 0) {
-    await new Promise<void>((resolve) => setTimeout(resolve, duration))
+    if (duration > 0) {
+      await new Promise<void>((resolve) => setTimeout(resolve, duration))
+    }
   }
 }