@swan-admin/swan-ai-measurements 1.0.53 → 1.0.55

package/auth.js

@@ -2,11 +2,38 @@ const axios = require("axios");
 const { API_ENDPOINTS, APP_AUTH_BASE_URL, APP_AUTH_WEBSOCKET_URL, APP_BASE_URL, REQUIRED_MESSAGE } = require("./constants.js");
 const { checkParameters } = require("./utils.js");
 
+/**
+ * Represents a Auth class for handling authentication operations.
+ */
 class Auth {
   #socketRef;
 
-  registerUser({ email, appVerifyUrl, gender, height, username, accessKey }) {
-    if (checkParameters(email, appVerifyUrl, accessKey) === false) {
+  /**
+   * The access key used for authentication.
+   * @type {string}
+   * @private
+   */
+  #accessKey;
+
+  /**
+   * Constructs a new instance of the Auth class.
+   * @param {string} accessKey - The access key used for authentication.
+   */
+  constructor(accessKey) {
+    this.#accessKey = accessKey;
+  }
+  /**
+   * Register a new user.
+   * @param {Object} params - The parameters for user registration.
+   * @param {string} params.email - The email of the user.
+   * @param {string} params.appVerifyUrl - The verification URL.
+   * @param {string} [params.gender] - Optional. The gender of the user.
+   * @param {string} [params.height] - Optional. The height of the user.
+   * @param {string} params.username - Optional. The username of the user.
+   * @returns {Promise} - The axios response promise.
+   */
+  registerUser({ email, appVerifyUrl, gender, height, username }) {
+    if (checkParameters(email, appVerifyUrl) === false) {
       throw new Error(REQUIRED_MESSAGE);
     }
     let body = {
@@ -18,22 +45,40 @@ class Auth {
       body = { ...body, attributes: { gender, height } };
     }
     return axios.post(`${APP_AUTH_BASE_URL}${API_ENDPOINTS.REGISTER_USER}`, body, {
-      headers: { "X-Api-Key": accessKey },
+      headers: { "X-Api-Key": this.#accessKey },
     });
   }
 
+  /**
+   * Verify a user token.
+   * @param {string} token
+   * @returns {Promise}
+   */
+
   verifyToken = (token, accessKey) => {
-    if (checkParameters(token, accessKey) === false) {
+    if (checkParameters(token) === false) {
       throw new Error(REQUIRED_MESSAGE);
     }
     return axios.post(`${APP_AUTH_BASE_URL}${API_ENDPOINTS.VERIFY_USER}`, null, {
       params: { token },
-      headers: { "X-Api-Key": accessKey },
+      headers: { "X-Api-Key": this.#accessKey },
     });
   };
 
-  addUser = ({ scanId, email, name, height, gender, offsetMarketingConsent, accessKey }) => {
-    if (checkParameters(scanId, email, height, gender, accessKey) === false) {
+  /**
+   * Add a user.
+   * @param {Object} params
+   * @param {string} params.scanId - The scan ID.
+   * @param {string} params.email - The email of the user.
+   * @param {string} params.name - The name of the user.
+   * @param {string} params.height - The height of the user.
+   * @param {string} params.gender - The gender of the user.
+   * @param {boolean} [params.offsetMarketingConsent] - Optional. The marketing consent offset.
+   * @returns {Promise} - The axios response promise.
+   */
+
+  addUser = ({ scanId, email, name, height, gender, offsetMarketingConsent }) => {
+    if (checkParameters(scanId, email, height, gender) === false) {
       throw new Error(REQUIRED_MESSAGE);
     }
     return axios.post(
@@ -45,21 +90,36 @@ class Auth {
         offsetMarketingConsent,
         attributes: JSON.stringify({ height, gender }),
       },
-      { headers: { "X-Api-Key": accessKey } }
+      { headers: { "X-Api-Key": this.#accessKey } }
     );
   };
 
-  getUserDetail = (email, accessKey) => {
-    if (checkParameters(email, accessKey) === false) {
+  /**
+   * Get user details.
+   * @param {string} email
+   * @returns {Promise}
+   */
+
+  getUserDetail = (email) => {
+    if (checkParameters(email) === false) {
       throw new Error(REQUIRED_MESSAGE);
     }
     return axios.get(`${APP_BASE_URL}${API_ENDPOINTS.GET_USER_DETAIL}/${email}`, {
-      headers: { "X-Api-Key": accessKey },
+      headers: { "X-Api-Key": this.#accessKey },
     });
   };
-
-  handleAuthSocket = ({ email, scanId, onError, onSuccess, onClose, onOpen, accessKey }) => {
-    if (checkParameters(email, scanId, accessKey) === false) {
+  /**
+   * Handle authentication via WebSocket.
+   * @param {Object} params
+   * @param {string} params.email - The email address of the user.
+   * @param {string} params.scanId - The scan ID associated with the user.
+   * @param {function} [params.onError] - Optional. Callback function to handle errors.
+   * @param {function} [params.onSuccess] - Optional. Callback function to handle successful authentication.
+   * @param {function} [params.onClose] - Optional. Callback function to handle the WebSocket close event.
+   * @param {function} [params.onOpen] - Optional. Callback function to handle the WebSocket open event.
+   */
+  handleAuthSocket = ({ email, scanId, onError, onSuccess, onClose, onOpen }) => {
+    if (checkParameters(email, scanId) === false) {
       throw new Error(REQUIRED_MESSAGE);
     }
     this.#socketRef?.close?.();

package/custom.js

@@ -2,22 +2,52 @@ const axios = require("axios");
 const { API_ENDPOINTS, APP_AUTH_BASE_URL, REQUIRED_MESSAGE } = require("./constants.js");
 const { checkParameters } = require("./utils.js");
 
+/**
+ * Represents a Custom class for handling custom operations.
+ */
 class Custom {
-  getCustomCustomerConfig = (store_url, accessKey) => {
-    if (checkParameters(store_url, accessKey) === false) {
+  /**
+   * The access key used for authentication.
+   * @type {string}
+   * @private
+   */
+  #accessKey;
+  /**
+   * Constructs a new instance of the Custom class.
+   * @param {string} accessKey - The access key used for authentication.
+   */
+  constructor(accessKey) {
+    this.#accessKey = accessKey;
+  }
+
+  /**
+   * Retrieves custom customer configuration based on the store URL.
+   * @param {string} store_url - The URL of the store.
+   * @returns {Promise} - A promise that resolves with the custom customer configuration.
+   * @throws {Error} - If required parameters are missing.
+   */
+
+  getCustomCustomerConfig = (store_url) => {
+    if (checkParameters(store_url) === false) {
       throw new Error(REQUIRED_MESSAGE);
     }
     return axios.get(`${APP_AUTH_BASE_URL}${API_ENDPOINTS.CUSTOM_CUSTOMER}`, {
       params: { store_url },
-      headers: { "X-Api-Key": accessKey },
+      headers: { "X-Api-Key": this.#accessKey },
     });
   };
 
-  getModelUrl = (id, accessKey) => {
-    if (checkParameters(id, accessKey) === false) {
+  /**
+   * Retrieves the model URL based on the model ID.
+   * @param {string} id - The ID of the model.
+   * @returns {Promise} - A promise that resolves with the model URL.
+   * @throws {Error} - If required parameters are missing.
+   */
+  getModelUrl = (id) => {
+    if (checkParameters(id) === false) {
       throw new Error(REQUIRED_MESSAGE);
     }
-    return axios.get(`${APP_AUTH_BASE_URL}${API_ENDPOINTS.MODEL}/${id}`, { headers: { "X-Api-Key": accessKey } });
+    return axios.get(`${APP_AUTH_BASE_URL}${API_ENDPOINTS.MODEL}/${id}`, { headers: { "X-Api-Key": this.#accessKey } });
   };
 }
 

package/fileUpload.js

@@ -1,22 +1,62 @@
 const { REQUIRED_MESSAGE, REQUIRED_MESSAGE_FOR_META_DATA, UPPY_FILE_UPLOAD_ENDPOINT } = require("./constants.js");
 const { checkMetaDataValue, checkParameters, fetchData } = require("./utils.js");
-
+/**
+ * Class representing a file uploader using Uppy for multipart uploads.
+ */
 class FileUpload {
+  /**
+   * The Uppy instance.
+   * @type {Object}
+   * @private
+   */
   #uppyIns;
+
+  /**
+   * Reference to the Uppy module.
+   * @type {Object}
+   * @private
+   */
   #Uppy;
-  #AwsS3Multipart;
+  /**
+   * Reference to the AwsS3Multipart module.
+   * @type {Object}
+   * @private
+   */
 
-  constructor() {
+  #AwsS3Multipart;
+  /**
+   * The access key used for authentication.
+   * @type {string}
+   * @private
+   */
+  #accessKey;
+  /**
+   * Constructs a new instance of the FileUpload class.
+   * @param {string} accessKey - The access key used for authentication.
+   */
+  constructor(accessKey) {
     this.initializeModules();
+    this.#accessKey = accessKey;
   }
-
+  /**
+   * Asynchronously initializes the Uppy and AwsS3Multipart modules.
+   * @private
+   */
   async initializeModules() {
     this.#Uppy = (await import("@uppy/core")).default;
     this.#AwsS3Multipart = (await import("@uppy/aws-s3-multipart")).default;
   }
-
-  async uploadFile({ file, objMetaData, scanId, accessKey }) {
-    if (checkParameters(file, objMetaData, scanId, accessKey) === false) {
+  /**
+   * Uploads a file with optional metadata and scan ID.
+   * @param {Object} params - The parameters for file upload.
+   * @param {File} params.file - The file to upload.
+   * @param {Object} params.objMetaData - Optional. Metadata associated with the file.
+   * @param {string} params.scanId - Optional. The ID of the scan.
+   * @returns {Promise} - A promise that resolves when the file is uploaded successfully.
+   * @throws {Error} - If required parameters are missing or metadata value is invalid.
+   */
+  async uploadFile({ file, objMetaData, scanId }) {
+    if (checkParameters(file, objMetaData, scanId) === false) {
       throw new Error(REQUIRED_MESSAGE);
     }
     if (checkMetaDataValue(objMetaData) === false) {
@@ -40,7 +80,7 @@ class FileUpload {
           const objectKey = `${scanId}.${file.extension}`;
           return fetchData({
             path: UPPY_FILE_UPLOAD_ENDPOINT.UPLOAD_START,
-            apiKey: accessKey,
+            apiKey: this.#accessKey,
             body: {
               objectKey,
               contentType: file.type,
@@ -51,7 +91,7 @@ class FileUpload {
         completeMultipartUpload: (file, { uploadId, key, parts }) =>
           fetchData({
             path: UPPY_FILE_UPLOAD_ENDPOINT.UPLOAD_COMPLETE,
-            apiKey: accessKey,
+            apiKey: this.#accessKey,
             body: {
               uploadId,
               objectKey: key,
@@ -62,7 +102,7 @@ class FileUpload {
         signPart: (file, partData) =>
           fetchData({
             path: UPPY_FILE_UPLOAD_ENDPOINT.UPLOAD_SIGN_PART,
-            apiKey: accessKey,
+            apiKey: this.#accessKey,
             body: {
               objectKey: partData.key,
               uploadId: partData.uploadId,
@@ -72,7 +112,7 @@ class FileUpload {
         abortMultipartUpload: (file, { uploadId, key }) =>
           fetchData({
             path: UPPY_FILE_UPLOAD_ENDPOINT.UPLOAD_ABORT,
-            apiKey: accessKey,
+            apiKey: this.#accessKey,
             body: {
               uploadId,
               objectKey: key,

package/index.js

@@ -5,17 +5,21 @@ const Measurement = require("./measurement.js");
 const PoseDetection = require("./poseDetection.js");
 const TryOn = require("./tryOn.js");
 class Swan {
-  auth = new Auth();
+  #accessKey;
+  constructor(accessKey) {
+    this.#accessKey = accessKey;
+  }
+  auth = new Auth(this.#accessKey);
 
-  custom = new Custom();
+  custom = new Custom(this.#accessKey);
 
-  fileUpload = new FileUpload();
+  fileUpload = new FileUpload(this.#accessKey);
 
-  measurement = new Measurement();
+  measurement = new Measurement(this.#accessKey);
 
-  poseDetection = new PoseDetection();
+  poseDetection = new PoseDetection(this.#accessKey);
 
-  tryOn = new TryOn();
+  tryOn = new TryOn(this.#accessKey);
 }
 
 module.exports = Swan;

package/measurement.js

@@ -2,33 +2,71 @@ const axios = require("axios");
 const { API_ENDPOINTS, APP_AUTH_BASE_URL, APP_RECOMMENDATION_WEBSOCKET_URL, APP_TRY_ON_WEBSOCKET_URL, REQUIRED_MESSAGE } = require("./constants.js");
 const { checkParameters } = require("./utils.js");
 
+/**
+ * Class representing measurement-related functionality.
+ */
 class Measurement {
   #tryOnSocketRef = null;
   #measurementSocketRef = null;
   #timerPollingRef = null;
   #timerWaitingRef = null;
   #count = 1;
+  #accessKey;
+
+  /**
+   * Constructs a new instance of the Measurement class.
+   * @param {string} accessKey - The access key used for authentication.
+   */
+  constructor(accessKey) {
+    this.#accessKey = accessKey;
+  }
 
-  getMeasurementStatus(scanId, accessKey) {
-    if (checkParameters(scanId, accessKey) === false) {
+  /**
+   * Retrieves the measurement status for a given scan ID.
+   * @param {string} scanId - The ID of the scan.
+   * @returns {Promise} - The axios response promise.
+   * @throws {Error} - If the required parameter is missing.
+   */
+  getMeasurementStatus(scanId) {
+    if (checkParameters(scanId) === false) {
       throw new Error(REQUIRED_MESSAGE);
     }
     const url = `${APP_AUTH_BASE_URL}/measurements?scanId=${scanId}`;
     return axios.get(url, {
-      headers: { "X-Api-Key": accessKey },
+      headers: { "X-Api-Key": this.#accessKey },
     });
   }
 
-  getTryOnMeasurements({ scanId, shopDomain, productName, accessKey }) {
-    if (checkParameters(scanId, shopDomain, productName, accessKey) === false) {
+  /**
+   * Retrieves the try-on measurements for a given scan ID, shop domain, and product name.
+   * @param {Object} params - The parameters for the try-on measurements.
+   * @param {string} params.scanId - The ID of the scan.
+   * @param {string} params.shopDomain - The shop domain.
+   * @param {string} params.productName - The product name.
+   * @returns {Promise} - The axios response promise.
+   * @throws {Error} - If the required parameters are missing.
+   */
+  getTryOnMeasurements({ scanId, shopDomain, productName }) {
+    if (checkParameters(scanId, shopDomain, productName) === false) {
       throw new Error(REQUIRED_MESSAGE);
     }
     const tryOnUrl = `${APP_AUTH_BASE_URL}${API_ENDPOINTS.TRY_ON_SCAN}/${scanId}/shop/${shopDomain}/product/${productName}`;
-    return axios.get(tryOnUrl, { headers: { "X-Api-Key": accessKey } });
+    return axios.get(tryOnUrl, { headers: { "X-Api-Key": this.#accessKey } });
   }
 
-  handleTryOnSocket({ shopDomain, scanId, productName, onError, onSuccess, onClose, onOpen, accessKey }) {
-    if (checkParameters(shopDomain, scanId, productName, accessKey) === false) {
+  /**
+   * Handles the try-on WebSocket connection.
+   * @param {Object} params - The parameters for the WebSocket connection.
+   * @param {string} params.shopDomain - The shop domain.
+   * @param {string} params.scanId - The ID of the scan.
+   * @param {string} params.productName - The product name.
+   * @param {function} [params.onError] - Optional. Callback function to handle errors.
+   * @param {function} [params.onSuccess] - Optional. Callback function to handle successful messages.
+   * @param {function} [params.onClose] - Optional. Callback function to handle WebSocket close event.
+   * @param {function} [params.onOpen] - Optional. Callback function to handle WebSocket open event.
+   */
+  handleTryOnSocket({ shopDomain, scanId, productName, onError, onSuccess, onClose, onOpen }) {
+    if (checkParameters(shopDomain, scanId, productName) === false) {
       throw new Error(REQUIRED_MESSAGE);
     }
     this.#tryOnSocketRef?.close();
@@ -57,16 +95,24 @@ class Measurement {
     };
   }
 
-  #getMeasurementsCheck = async ({ scanId, onSuccess, onError, accessKey }) => {
+  /**
+   * Checks the measurement status and handles polling.
+   * @param {Object} params - The parameters for checking measurements.
+   * @param {string} params.scanId - The ID of the scan.
+   * @param {function} [params.onSuccess] - Optional. Callback function to handle successful status check.
+   * @param {function} [params.onError] - Optional. Callback function to handle errors.
+   * @private
+   */
+  async #getMeasurementsCheck({ scanId, onSuccess, onError }) {
     try {
-      const res = await this.getMeasurementStatus(scanId, accessKey);
+      const res = await this.getMeasurementStatus(scanId);
       if (res?.data && res?.data?.[0]?.isMeasured === true) {
         onSuccess?.(res?.data);
         clearInterval(this.#timerPollingRef);
       } else {
         if (this.#count < 8) {
           this.#count++;
-          this.#handlePolling({ scanId, onSuccess, onError, accessKey });
+          this.#handlePolling({ scanId, onSuccess, onError });
         } else {
           this.#count = 1;
           clearInterval(this.#timerPollingRef);
@@ -77,30 +123,59 @@ class Measurement {
       clearInterval(this.#timerPollingRef);
       onError?.(e);
     }
-  };
+  }
 
-  #handlePolling({ scanId, onSuccess, onError, accessKey }) {
+  /**
+   * Handles polling for measurements.
+   * @param {Object} params - The parameters for polling.
+   * @param {string} params.scanId - The ID of the scan.
+   * @param {function} [params.onSuccess] - Optional. Callback function to handle successful polling.
+   * @param {function} [params.onError] - Optional. Callback function to handle errors.
+   * @private
+   */
+  #handlePolling({ scanId, onSuccess, onError }) {
     clearInterval(this.#timerPollingRef);
     this.#timerPollingRef = setTimeout(() => {
-      this.#getMeasurementsCheck({ scanId, onSuccess, onError, accessKey });
+      this.#getMeasurementsCheck({ scanId, onSuccess, onError });
     }, this.#count * 5000);
   }
 
-  #disconnectSocket = () => {
+  /**
+   * Disconnects the measurement WebSocket and clears the timeout.
+   * @private
+   */
+  #disconnectSocket() {
     this.#measurementSocketRef?.close();
     clearTimeout(this.#timerWaitingRef);
-  };
+  }
 
-  #handleTimeOut = ({ scanId, onSuccess, onError, accessKey }) => {
+  /**
+   * Handles the timeout for the measurement WebSocket.
+   * @param {Object} params - The parameters for handling timeout.
+   * @param {string} params.scanId - The ID of the scan.
+   * @param {function} [params.onSuccess] - Optional. Callback function to handle successful timeout.
+   * @param {function} [params.onError] - Optional. Callback function to handle errors.
+   * @private
+   */
+  #handleTimeOut({ scanId, onSuccess, onError }) {
     this.#count = 1;
     this.#timerWaitingRef = setTimeout(() => {
-      this.#handlePolling({ scanId, onSuccess, onError, accessKey });
+      this.#handlePolling({ scanId, onSuccess, onError });
       this.#disconnectSocket();
     }, 2 * 60000);
-  };
+  }
 
-  handleMeasurementSocket = ({ scanId, onError, onSuccess, onClose, onOpen, accessKey }) => {
-    if (checkParameters(scanId, accessKey) === false) {
+  /**
+   * Handles the measurement WebSocket connection.
+   * @param {Object} params - The parameters for the WebSocket connection.
+   * @param {string} params.scanId - The ID of the scan.
+   * @param {function} [params.onError] - Optional. Callback function to handle errors.
+   * @param {function} [params.onSuccess] - Optional. Callback function to handle successful messages.
+   * @param {function} [params.onClose] - Optional. Callback function to handle WebSocket close event.
+   * @param {function} [params.onOpen] - Optional. Callback function to handle WebSocket open event.
+   */
+  handleMeasurementSocket({ scanId, onError, onSuccess, onClose, onOpen }) {
+    if (checkParameters(scanId) === false) {
       throw new Error(REQUIRED_MESSAGE);
     }
     setTimeout(() => {
@@ -109,7 +184,7 @@ class Measurement {
       this.#measurementSocketRef = new WebSocket(url);
       this.#measurementSocketRef.onopen = () => {
         onOpen?.();
-        this.#handleTimeOut({ scanId, onSuccess, onError, accessKey });
+        this.#handleTimeOut({ scanId, onSuccess, onError });
       };
 
       this.#measurementSocketRef.onmessage = (event) => {
@@ -130,7 +205,7 @@ class Measurement {
         onError?.(event);
       };
     }, 5000);
-  };
+  }
 }
 
 module.exports = Measurement;

package/package.json

@@ -1,21 +1,38 @@
 {
   "name": "@swan-admin/swan-ai-measurements",
-  "version": "1.0.53",
+  "version": "1.0.55",
   "description": "provides ai measurement suggestion",
   "main": "index.js",
+  "types": "types/index.d.ts",
+  "files": [
+    "index.js",
+    "auth.js",
+    "constant.js",
+    "custom.js",
+    "fileUpload.js",
+    "measurement.js",
+    "poseDetection.js",
+    "tryOn.js",
+    "utils.js",
+    "types/"
+  ],
   "dependencies": {
+    "@types/axios": "^0.14.0",
     "@uppy/aws-s3-multipart": "^3.10.2",
     "@uppy/core": "^3.9.3",
     "axios": "^1.6.7",
     "dotenv": "^16.4.5",
+    "socket.io": "^4.7.5",
     "socket.io-client": "^4.7.5"
   },
   "devDependencies": {
-    "nodemon": "^3.1.0"
+    "nodemon": "^3.1.0",
+    "typescript": "^5.4.5"
   },
   "scripts": {
     "start": "nodemon index.js",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build:types": "tsc"
   },
   "repository": {
     "type": "git",

package/poseDetection.js

@@ -1,29 +1,45 @@
-const { APP_POSE_DETECTION_WEbSOCKET_URL, REQUIRED_MESSAGE } = require("./constants.js");
-const { io } = require("socket.io-client");
+const { APP_POSE_DETECTION_WEBSOCKET_URL, REQUIRED_MESSAGE } = require("./constants.js");
+const io = require("socket.io");
 
+/**
+ * Class representing pose detection functionality.
+ */
 class PoseDetection {
   #socketRef = null;
+  #accessKey;
 
-  connect(accessKey) {
-    if (!accessKey) {
-      throw new Error(REQUIRED_MESSAGE);
-    }
+  /**
+   * Constructs a new instance of the PoseDetection class.
+   * @param {string} accessKey - The access key used for authentication.
+   */
+  constructor(accessKey) {
+    this.#accessKey = accessKey;
+  }
+
+  /**
+   * Connects to the pose detection WebSocket server.
+   * @returns {Promise<string>} - A promise that resolves with the socket ID on successful connection.
+   */
+  connect() {
     return new Promise((resolve, reject) => {
-      this.#socketRef = io.connect(APP_POSE_DETECTION_WEbSOCKET_URL);
+      this.#socketRef = io.connect(APP_POSE_DETECTION_WEBSOCKET_URL);
       this.#socketRef?.on("connect", () => {
-        resolve(this.#socketRef.id); // "G5p5..."
+        resolve(this.#socketRef.id);
       });
       this.#socketRef?.on("connect_error", (err) => reject(err));
     });
   }
 
-  videoEmit({ image, scanId, accessKey }) {
-    if (!accessKey) {
-      throw new Error(REQUIRED_MESSAGE);
-    }
-
+  /**
+   * Emits a video frame to the pose detection server.
+   * @param {Object} params - The parameters for emitting the video frame.
+   * @param {string} params.image - The image data.
+   * @param {string} params.scanId - The unique scan ID.
+   * @throws {Error} - If the socket is not connected.
+   */
+  videoEmit({ image, scanId }) {
     if (!this.#socketRef) {
-      throw new Error("socket is not connected");
+      throw new Error("Socket is not connected");
     }
     this.#socketRef.emit("video", {
       image,
@@ -31,22 +47,31 @@ class PoseDetection {
     });
   }
 
+  /**
+   * Disconnects from the pose detection WebSocket server.
+   */
   disconnect() {
     this.#socketRef?.disconnect?.();
   }
 
-  poseStatus(accessKey, callBack) {
-    if (!accessKey) {
-      throw new Error(REQUIRED_MESSAGE);
-    }
+  /**
+   * Registers a callback function to handle pose status updates.
+   * @param {function} callBack - The callback function to handle pose status updates.
+   * @throws {Error} - If the socket is not connected.
+   */
+  poseStatus(callBack) {
     if (!this.#socketRef) {
-      throw new Error("socket is not connected");
+      throw new Error("Socket is not connected");
     }
     this.#socketRef.on("pose_status", (data) => {
       callBack?.(data);
     });
   }
 
+  /**
+   * Checks if the socket is connected.
+   * @returns {boolean} - True if the socket is connected, false otherwise.
+   */
   connected() {
     return !!this.#socketRef?.connected;
   }