@swan-admin/swan-ai-measurements 1.0.28 → 1.0.30

package/auth.js

@@ -1,60 +1,93 @@
-import axios from "axios";
-import { API_ENDPOINTS, APP_AUTH_BASE_URL, APP_AUTH_WEBSOCKET_URL, APP_BASE_URL } from "./constants.js";
-let socketRef;
-
-export const registerUser = ({ email, appVerifyUrl, gender, height, username, accessKey }) => {
-  let body = {
-    username,
-    email,
-    appVerifyUrl,
-  };
-  if (gender && height) {
-    body = { ...body, attributes: { gender, height } };
-  }
-  return axios.post(`${APP_AUTH_BASE_URL}${API_ENDPOINTS.REGISTER_USER}`, body);
-};
-
-export const verifyToken = (token, accessKey) =>
-  axios.post(`${APP_AUTH_BASE_URL}${API_ENDPOINTS.VERIFY_USER}`, null, {
-    params: { token },
-  });
-
-export const addUser = ({ scanId, email, name, height, gender, accessKey, offsetMarketingConsent }) =>
-  axios.post(`${APP_AUTH_BASE_URL}${API_ENDPOINTS.ADD_USER}`, {
-    scan_id: scanId,
-    email,
-    name,
-    offsetMarketingConsent,
-    attributes: JSON.stringify({ height, gender }),
-  });
-
-export const getUserDetail = (email, accessKey) =>
-  axios.get(`${APP_BASE_URL}${API_ENDPOINTS.GET_USER_DETAIL}/${email}`);
-
-export const handleAuthSocket = ({ email, scanId, accessKey, onError, onSuccess, onClose, onOpen }) => {
-  socketRef?.close?.();
-
-  socketRef = new WebSocket(APP_AUTH_WEBSOCKET_URL);
-  const detailObj = {
-    email,
-    scanId,
-  };
-
-  socketRef.onopen = () => {
-    onOpen?.();
-    socketRef.send(JSON.stringify(detailObj));
-  };
-
-  socketRef.onmessage = (event) => {
-    const data = JSON.parse(event.data);
-    onSuccess?.(data);
-  };
-
-  socketRef.onclose = () => {
-    onClose?.();
-  };
-
-  socketRef.onerror = (event) => {
-    onError?.(event);
-  };
-};
+import axios from "axios";
+import {
+  API_ENDPOINTS,
+  APP_AUTH_BASE_URL,
+  APP_AUTH_WEBSOCKET_URL,
+  APP_BASE_URL,
+  REQUIRED_MESSAGE,
+} from "./constants.js";
+import { checkParameters } from "./utils.js";
+let socketRef;
+
+class Auth {
+  static accessKey;
+  constructor(key) {
+    Auth.accessKey = key;
+  }
+  registerUser({ email, appVerifyUrl, gender, height, username }) {
+    if (checkParameters(email, appVerifyUrl) === false) {
+      throw new Error(REQUIRED_MESSAGE);
+    }
+    let body = {
+      username,
+      email,
+      appVerifyUrl,
+    };
+    if (gender && height) {
+      body = { ...body, attributes: { gender, height } };
+    }
+    return axios.post(`${APP_AUTH_BASE_URL}${API_ENDPOINTS.REGISTER_USER}`, body);
+  }
+
+  verifyToken = (token) => {
+    if (!token) {
+      throw new Error(REQUIRED_MESSAGE);
+    }
+    return axios.post(`${APP_AUTH_BASE_URL}${API_ENDPOINTS.VERIFY_USER}`, null, {
+      params: { token },
+    });
+  };
+
+  addUser = ({ scanId, email, name, height, gender, offsetMarketingConsent }) => {
+    if (checkParameters(scanId, email, height, gender) === false) {
+      throw new Error(REQUIRED_MESSAGE);
+    }
+    return axios.post(`${APP_AUTH_BASE_URL}${API_ENDPOINTS.ADD_USER}`, {
+      scan_id: scanId,
+      email,
+      name,
+      offsetMarketingConsent,
+      attributes: JSON.stringify({ height, gender }),
+    });
+  };
+
+  getUserDetail = (email) => {
+    if (!email) {
+      throw new Error(REQUIRED_MESSAGE);
+    }
+    return axios.get(`${APP_BASE_URL}${API_ENDPOINTS.GET_USER_DETAIL}/${email}`);
+  };
+
+  handleAuthSocket = ({ email, scanId, onError, onSuccess, onClose, onOpen }) => {
+    if (checkParameters(email, scanId) === false) {
+      throw new Error(REQUIRED_MESSAGE);
+    }
+    socketRef?.close?.();
+
+    socketRef = new WebSocket(APP_AUTH_WEBSOCKET_URL);
+    const detailObj = {
+      email,
+      scanId,
+    };
+
+    socketRef.onopen = () => {
+      socketRef.send(JSON.stringify(detailObj));
+      onOpen?.();
+    };
+
+    socketRef.onmessage = (event) => {
+      const data = JSON.parse(event.data);
+      onSuccess?.(data);
+    };
+
+    socketRef.onclose = () => {
+      onClose?.();
+    };
+
+    socketRef.onerror = (event) => {
+      onError?.(event);
+    };
+  };
+}
+
+export default Auth;

package/constants.js

@@ -23,3 +23,5 @@ export const API_ENDPOINTS = {
   MODEL: "/model",
   TRY_ON: "/tryon/scan",
 };
+
+export const REQUIRED_MESSAGE = "Please verify required parameters";

package/custom.js

@@ -1,7 +1,22 @@
-import axios from "axios";
-import { API_ENDPOINTS, APP_AUTH_BASE_URL } from "./constants.js";
-
-export const getCustomCustomerConfig = (store_url, accessKey) =>
-  axios.get(`${APP_AUTH_BASE_URL}${API_ENDPOINTS.CUSTOM_CUSTOMER}`, { params: { store_url } });
-
-export const getModelUrl = (id, accessKey) => axios.get(`${APP_AUTH_BASE_URL}${API_ENDPOINTS.MODEL}/${id}`);
+import axios from "axios";
+import { API_ENDPOINTS, APP_AUTH_BASE_URL, REQUIRED_MESSAGE } from "./constants.js";
+
+export default class Custom {
+  static accessKey;
+  constructor(key) {
+    Custom.accessKey = key;
+  }
+  getCustomCustomerConfig = (store_url) => {
+    if (!store_url) {
+      throw new Error(REQUIRED_MESSAGE);
+    }
+    return axios.get(`${APP_AUTH_BASE_URL}${API_ENDPOINTS.CUSTOM_CUSTOMER}`, { params: { store_url } });
+  };
+
+  getModelUrl = (id) => {
+    if (!id) {
+      throw new Error(REQUIRED_MESSAGE);
+    }
+    return axios.get(`${APP_AUTH_BASE_URL}${API_ENDPOINTS.MODEL}/${id}`);
+  };
+}

package/fileUpload.js

@@ -1,81 +1,88 @@
-import AwsS3Multipart from "@uppy/aws-s3-multipart";
-import Uppy from "@uppy/core";
-import { FILE_UPLOAD_KEY, UPPY_FILE_UPLOAD_ENDPOINT } from "./constants.js";
-import { fetchData } from "./utils.js";
-
-function uploadFile({ file, objMetaData, scanId, accessKey }) {
-  return new Promise((resolve, reject) => {
-    const uppyIns = new Uppy({ autoProceed: true });
-    uppyIns.use(AwsS3Multipart, {
-      limit: 10,
-      retryDelays: [0, 1000, 3000, 5000],
-      getChunkSize: () => 5 * 1024 * 1024,
-      createMultipartUpload: (file) => {
-        const objectKey = `${scanId}.${file.extension}`;
-        return fetchData({
-          path: UPPY_FILE_UPLOAD_ENDPOINT.UPLOAD_START,
-          apiKey: FILE_UPLOAD_KEY,
-          body: {
-            objectKey,
-            contentType: file.type,
-            objectMetadata: objMetaData,
-          },
-        });
-      },
-      completeMultipartUpload: (file, { uploadId, key, parts }) =>
-        fetchData({
-          path: UPPY_FILE_UPLOAD_ENDPOINT.UPLOAD_COMPLETE,
-          apiKey: FILE_UPLOAD_KEY,
-          body: {
-            uploadId,
-            objectKey: key,
-            parts,
-            originalFileName: file.name,
-          },
-        }),
-
-      signPart: (file, partData) =>
-        fetchData({
-          path: UPPY_FILE_UPLOAD_ENDPOINT.UPLOAD_SIGN_PART,
-          apiKey: FILE_UPLOAD_KEY,
-          body: {
-            objectKey: partData.key,
-            uploadId: partData.uploadId,
-            partNumber: partData.partNumber,
-          },
-        }),
-
-      abortMultipartUpload: (file, { uploadId, key }) =>
-        fetchData({
-          path: UPPY_FILE_UPLOAD_ENDPOINT.UPLOAD_ABORT,
-          apiKey: FILE_UPLOAD_KEY,
-          body: {
-            uploadId,
-            objectKey: key,
-            originalFileName: file.name,
-          },
-        }),
-    });
-
-    uppyIns.addFile({
-      source: "manual",
-      name: file.name,
-      type: file.type,
-      data: file,
-    });
-
-    uppyIns.on("upload-error", (file, error, response) => {
-      reject(error);
-    });
-    uppyIns.on("upload-success", () => {
-      resolve({ message: "file uploaded successfully" });
-    });
-    uppyIns.on("complete", (result) => {
-      if (uppyIns) {
-        uppyIns.close();
-      }
-    });
-  });
-}
-
-export default uploadFile;
+import AwsS3Multipart from "@uppy/aws-s3-multipart";
+import Uppy from "@uppy/core";
+import { FILE_UPLOAD_KEY, REQUIRED_MESSAGE, UPPY_FILE_UPLOAD_ENDPOINT } from "./constants.js";
+import { checkParameters, fetchData } from "./utils.js";
+
+export default class FileUpload {
+  static accessKey;
+  constructor(key) {
+    FileUpload.accessKey = key;
+  }
+  uploadFile({ file, objMetaData, scanId }) {
+    if (checkParameters(file, objMetaData, scanId) === false) {
+      throw new Error(REQUIRED_MESSAGE);
+    }
+    return new Promise((resolve, reject) => {
+      const uppyIns = new Uppy({ autoProceed: true });
+      uppyIns.use(AwsS3Multipart, {
+        limit: 10,
+        retryDelays: [0, 1000, 3000, 5000],
+        getChunkSize: () => 5 * 1024 * 1024,
+        createMultipartUpload: (file) => {
+          const objectKey = `${scanId}.${file.extension}`;
+          return fetchData({
+            path: UPPY_FILE_UPLOAD_ENDPOINT.UPLOAD_START,
+            apiKey: FILE_UPLOAD_KEY,
+            body: {
+              objectKey,
+              contentType: file.type,
+              objectMetadata: objMetaData,
+            },
+          });
+        },
+        completeMultipartUpload: (file, { uploadId, key, parts }) =>
+          fetchData({
+            path: UPPY_FILE_UPLOAD_ENDPOINT.UPLOAD_COMPLETE,
+            apiKey: FILE_UPLOAD_KEY,
+            body: {
+              uploadId,
+              objectKey: key,
+              parts,
+              originalFileName: file.name,
+            },
+          }),
+
+        signPart: (file, partData) =>
+          fetchData({
+            path: UPPY_FILE_UPLOAD_ENDPOINT.UPLOAD_SIGN_PART,
+            apiKey: FILE_UPLOAD_KEY,
+            body: {
+              objectKey: partData.key,
+              uploadId: partData.uploadId,
+              partNumber: partData.partNumber,
+            },
+          }),
+
+        abortMultipartUpload: (file, { uploadId, key }) =>
+          fetchData({
+            path: UPPY_FILE_UPLOAD_ENDPOINT.UPLOAD_ABORT,
+            apiKey: FILE_UPLOAD_KEY,
+            body: {
+              uploadId,
+              objectKey: key,
+              originalFileName: file.name,
+            },
+          }),
+      });
+
+      uppyIns.addFile({
+        source: "manual",
+        name: file.name,
+        type: file.type,
+        data: file,
+      });
+
+      uppyIns.on("upload-error", (file, error, response) => {
+        reject(error);
+      });
+      uppyIns.on("upload-success", () => {
+        resolve({ message: "file uploaded successfully" });
+      });
+      uppyIns.on("complete", (result) => {
+        if (uppyIns) {
+          uppyIns.close();
+        }
+      });
+    });
+  }
+}

package/index.js

@@ -1,77 +1,24 @@
-import { addUser, getUserDetail, handleAuthSocket, registerUser, verifyToken } from "./auth.js";
-import { getCustomCustomerConfig } from "./custom.js";
-import uploadFile from "./fileUpload.js";
-import {
-  getMeasurementStatus,
-  getTryOnMeasurements,
-  handleMeasurementSocket,
-  handleTryOnSocket,
-} from "./measurement.js";
-import { handlePoseDetectionSocket } from "./poseDetection.js";
-export default class Swan {
-  constructor(key) {
-    if (key !== 9876543210) {
-      throw new Error("wrong access key");
-    }
-    this.accessKey = key;
-  }
-
-  registerUser({ email, appVerifyUrl, gender, height, username }) {
-    return registerUser({ email, appVerifyUrl, gender, height, username, accessKey: this.accessKey });
-  }
-
-  verifyToken(token) {
-    return verifyToken(token, this.accessKey);
-  }
-
-  addUser({ scanId, email, name, height, gender, offsetMarketingConsent }) {
-    return addUser({ scanId, email, name, height, gender, offsetMarketingConsent, accessKey: this.accessKey });
-  }
-
-  getUserDetail(email) {
-    return getUserDetail(email, this.accessKey);
-  }
-
-  uploadFile({ file, objMetaData, scanId }) {
-    return uploadFile({ file, objMetaData, scanId, accessKey: this.accessKey });
-  }
-
-  getModelUrl(id) {
-    return getModelUrl(id, this.accessKey);
-  }
-
-  getCustomCustomerConfig(storeUrl) {
-    return getCustomCustomerConfig(storeUrl, this.accessKey);
-  }
-
-  getMeasurementStatus(scanId) {
-    return getMeasurementStatus(scanId, this.accessKey);
-  }
-
-  getTryOnMeasurements({ scanId, shopDomain, productName }) {
-    return getTryOnMeasurements({ scanId, shopDomain, productName, accessKey: this.accessKey });
-  }
-
-  handleTryOnSocket({ shopDomain, scanId, productName, onError, onSuccess, onClose, onOpen }) {
-    return handleTryOnSocket({
-      shopDomain,
-      scanId,
-      productName,
-      accessKey: this.accessKey,
-      onError,
-      onSuccess,
-      onClose,
-      onOpen,
-    });
-  }
-
-  handleMeasurementSocket({ scanId, onError, onSuccess, onClose, onOpen }) {
-    return handleMeasurementSocket({ scanId, accessKey: this.accessKey, onError, onSuccess, onClose, onOpen });
-  }
-
-  handleAuthSocket({ email, scanId, onError, onSuccess, onClose, onOpen }) {
-    return handleAuthSocket({ email, scanId, accessKey: this.accessKey, onError, onSuccess, onClose, onOpen });
-  }
-
-  handlePoseDetectionSocket = handlePoseDetectionSocket;
-}
+import Auth from "./auth.js";
+import Custom from "./custom.js";
+import FileUpload from "./fileUpload.js";
+import Measurement from "./measurement.js";
+import PoseDetection from "./poseDetection.js";
+export default class Swan {
+  static accessKey;
+  constructor(key) {
+    if (key !== 9876543210) {
+      throw new Error("wrong access key");
+    }
+    Swan.accessKey = key;
+  }
+
+  auth = new Auth(Swan.accessKey);
+
+  custom = new Custom(Swan.accessKey);
+
+  fileUpload = new FileUpload(Swan.accessKey);
+
+  measurement = new Measurement(Swan.accessKey);
+
+  poseDetection = new PoseDetection(Swan.accessKey);
+}

package/measurement.js

@@ -1,136 +1,134 @@
-import axios from "axios";
-import {
-  API_ENDPOINTS,
-  APP_AUTH_BASE_URL,
-  APP_RECOMMENDATION_WEBSOCKET_URL,
-  APP_TRY_ON_WEBSOCKET_URL,
-  FILE_UPLOAD_KEY,
-} from "./constants.js";
-
-let tryOnSocketRef;
-let measurementSocketRef;
-let timerPollingRef;
-let timerWaitingRef;
-
-export const getMeasurementStatus = (scanId, accessKey) => {
-  const url = `${APP_AUTH_BASE_URL}/measurements?scanId=${scanId}`;
-  return axios.get(url, {
-    headers: { "X-Api-Key": FILE_UPLOAD_KEY },
-  });
-};
-
-export const getTryOnMeasurements = ({ scanId, shopDomain, productName, accessKey }) => {
-  const tryOnUrl = `${APP_AUTH_BASE_URL}${API_ENDPOINTS.TRY_ON}/${scanId}/shop/${shopDomain}/product/${productName}`;
-  return axios.get(tryOnUrl);
-};
-
-export const handleTryOnSocket = ({
-  shopDomain,
-  scanId,
-  productName,
-  accessKey,
-  onError,
-  onSuccess,
-  onClose,
-  onOpen,
-}) => {
-  if (tryOnSocketRef) {
-    tryOnSocketRef.close();
-  }
-  const url = `${APP_TRY_ON_WEBSOCKET_URL}/develop?store_url=${shopDomain}&product_name=${productName}&scan_id=${scanId}`;
-  tryOnSocketRef = new WebSocket(url);
-
-  tryOnSocketRef.onopen = () => {
-    if (onOpen) {
-      onOpen();
-    }
-  };
-
-  tryOnSocketRef.onmessage = (event) => {
-    const data = JSON.parse(event.data);
-    if (data?.tryOnProcessStatus === "available") {
-      if (onSuccess) {
-        onSuccess(data);
-      }
-    } else {
-      if (onError) {
-        onError({ message: "failed to get image urls" });
-      }
-    }
-  };
-
-  tryOnSocketRef.onclose = () => {
-    if (onClose) {
-      onClose();
-    }
-  };
-
-  tryOnSocketRef.onerror = (event) => {
-    if (onError) {
-      onError(event);
-    }
-  };
-};
-
-const getMeasurementsCheck = async (onSuccess, onError, scanId, accessKey) => {
-  try {
-    const res = await getMeasurementStatus(scanId, accessKey);
-    if (res?.data && res?.data?.[0]?.isMeasured === true) {
-      onSuccess?.(res?.data);
-      clearInterval(timerPollingRef);
-    }
-  } catch (e) {
-    clearInterval(timerPollingRef);
-    onError?.(e);
-  }
-};
-
-const handlePolling = (onSuccess, onError) => {
-  clearInterval(timerPollingRef);
-  timerPollingRef = setInterval(() => {
-    getMeasurementsCheck(onSuccess, onError);
-  }, 5000);
-};
-
-const disconnectSocket = () => {
-  if (measurementSocketRef) {
-    measurementSocketRef.close();
-    clearTimeout(timerWaitingRef);
-  }
-};
-
-const handleTimeOut = (onSuccess, onError) => {
-  timerWaitingRef = setTimeout(() => {
-    handlePolling(onSuccess, onError);
-    disconnectSocket();
-  }, 2 * 60000);
-};
-
-export const handleMeasurementSocket = ({ scanId, accessKey, onError, onSuccess, onClose, onOpen }) => {
-  disconnectSocket();
-  const url = `${APP_RECOMMENDATION_WEBSOCKET_URL}?scanId=${scanId}`;
-  measurementSocketRef = new WebSocket(url);
-
-  measurementSocketRef.onopen = () => {
-    onOpen?.();
-    handleTimeOut(onSuccess, onError);
-  };
-
-  measurementSocketRef.onmessage = (event) => {
-    const data = JSON.parse(event.data);
-    if (data?.code === 200 && data?.scanStatus === "success") {
-      onSuccess?.(data);
-    } else {
-      onError?.(data);
-    }
-    clearTimeout(timerWaitingRef);
-  };
-
-  measurementSocketRef.onclose = () => {
-    onClose?.();
-  };
-
-  measurementSocketRef.onerror = (event) => {
-    onError?.(event);
-  };
-};
+import axios from "axios";
+import {
+  API_ENDPOINTS,
+  APP_AUTH_BASE_URL,
+  APP_RECOMMENDATION_WEBSOCKET_URL,
+  APP_TRY_ON_WEBSOCKET_URL,
+  FILE_UPLOAD_KEY,
+  REQUIRED_MESSAGE,
+} from "./constants.js";
+import { checkParameters } from "./utils.js";
+
+export default class Measurement {
+  static accessKey;
+  constructor(key) {
+    Measurement.accessKey = key;
+  }
+  static tryOnSocketRef = null;
+  static measurementSocketRef = null;
+  static timerPollingRef = null;
+  static timerWaitingRef = null;
+
+  getMeasurementStatus(scanId) {
+    if (!scanId) {
+      throw new Error(REQUIRED_MESSAGE);
+    }
+    const url = `${APP_AUTH_BASE_URL}/measurements?scanId=${scanId}`;
+    return axios.get(url, {
+      headers: { "X-Api-Key": FILE_UPLOAD_KEY },
+    });
+  }
+
+  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}/${scanId}/shop/${shopDomain}/product/${productName}`;
+    return axios.get(tryOnUrl);
+  }
+
+  handleTryOnSocket({ shopDomain, scanId, productName, onError, onSuccess, onClose, onOpen }) {
+    if (checkParameters(shopDomain, scanId, productName) === false) {
+      throw new Error(REQUIRED_MESSAGE);
+    }
+    Measurement.tryOnSocketRef?.close();
+
+    const url = `${APP_TRY_ON_WEBSOCKET_URL}/develop?store_url=${shopDomain}&product_name=${productName}&scan_id=${scanId}`;
+    Measurement.tryOnSocketRef = new WebSocket(url);
+
+    Measurement.tryOnSocketRef.onopen = () => {
+      onOpen?.();
+    };
+
+    Measurement.tryOnSocketRef.onmessage = (event) => {
+      const data = JSON.parse(event.data);
+      if (data?.tryOnProcessStatus === "available") {
+        onSuccess?.(data);
+      } else {
+        onError?.({ message: "failed to get image urls" });
+      }
+    };
+
+    Measurement.tryOnSocketRef.onclose = () => {
+      onClose?.();
+    };
+
+    Measurement.tryOnSocketRef.onerror = (event) => {
+      onError?.(event);
+    };
+  }
+
+  static getMeasurementsCheck = async (onSuccess, onError, scanId) => {
+    try {
+      const res = await getMeasurementStatus(scanId);
+      if (res?.data && res?.data?.[0]?.isMeasured === true) {
+        onSuccess?.(res?.data);
+        clearInterval(Measurement.timerPollingRef);
+      }
+    } catch (e) {
+      clearInterval(Measurement.timerPollingRef);
+      onError?.(e);
+    }
+  };
+
+  static handlePolling(onSuccess, onError) {
+    clearInterval(Measurement.timerPollingRef);
+    Measurement.timerPollingRef = setInterval(() => {
+      Measurement.getMeasurementsCheck(onSuccess, onError);
+    }, 5000);
+  }
+
+  static disconnectSocket = () => {
+    Measurement.measurementSocketRef?.close();
+    clearTimeout(Measurement.timerWaitingRef);
+  };
+
+  static handleTimeOut = (onSuccess, onError) => {
+    Measurement.timerWaitingRef = setTimeout(() => {
+      Measurement.handlePolling(onSuccess, onError);
+      disconnectSocket();
+    }, 2 * 60000);
+  };
+
+  handleMeasurementSocket = ({ scanId, onError, onSuccess, onClose, onOpen }) => {
+    if (!scanId) {
+      throw new Error(REQUIRED_MESSAGE);
+    }
+    Measurement.disconnectSocket();
+    const url = `${APP_RECOMMENDATION_WEBSOCKET_URL}?scanId=${scanId}`;
+    Measurement.measurementSocketRef = new WebSocket(url);
+
+    Measurement.measurementSocketRef.onopen = () => {
+      onOpen?.();
+      Measurement.handleTimeOut(onSuccess, onError);
+    };
+
+    Measurement.measurementSocketRef.onmessage = (event) => {
+      const data = JSON.parse(event.data);
+      if (data?.code === 200 && data?.scanStatus === "success") {
+        onSuccess?.(data);
+      } else {
+        onError?.(data);
+      }
+      clearTimeout(Measurement.timerWaitingRef);
+    };
+
+    Measurement.measurementSocketRef.onclose = () => {
+      onClose?.();
+    };
+
+    Measurement.measurementSocketRef.onerror = (event) => {
+      onError?.(event);
+    };
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swan-admin/swan-ai-measurements",
-  "version": "1.0.28",
+  "version": "1.0.30",
   "description": "provides ai measurement suggestion",
   "main": "index.js",
   "type": "module",

package/poseDetection.js

@@ -1,44 +1,46 @@
-import { APP_POSE_DETECTION_WEbSOCKET_URL } from "./constants.js";
-import { io } from "socket.io-client";
-let socket;
-
-export function handlePoseDetectionSocket() {
-  return {
-    connect: function () {
-      return new Promise((resolve, reject) => {
-        socket = io.connect(APP_POSE_DETECTION_WEbSOCKET_URL);
-        socket?.on("connect", () => {
-          resolve(socket.id); // "G5p5..."
-        });
-        socket?.on("connect_error", (err) => reject(err));
-      });
-    },
-
-    videoEmit: function ({ image, scanId }) {
-      if (!socket) {
-        throw new Error("socket is not connected");
-      }
-      socket.emit("video", {
-        image,
-        user_unique_key: scanId,
-      });
-    },
-
-    disconnect: function () {
-      socket?.disconnect?.();
-    },
-
-    poseStatus: function (callBack) {
-      if (!socket) {
-        throw new Error("socket is not connected");
-      }
-      socket.on("pose_status", (data) => {
-        callBack(data);
-      });
-    },
-
-    connected: function () {
-      return !!socket?.connected;
-    },
-  };
-}
+import { APP_POSE_DETECTION_WEbSOCKET_URL } from "./constants.js";
+import { io } from "socket.io-client";
+
+export default class PoseDetection {
+  static socket = null;
+  static accessKey;
+  constructor(key) {
+    PoseDetection.accessKey = key;
+  }
+  connect() {
+    return new Promise((resolve, reject) => {
+      PoseDetection.socket = io.connect(APP_POSE_DETECTION_WEbSOCKET_URL);
+      PoseDetection.socket?.on("connect", () => {
+        resolve(PoseDetection.socket.id); // "G5p5..."
+      });
+      PoseDetection.socket?.on("connect_error", (err) => reject(err));
+    });
+  }
+
+  videoEmit({ image, scanId }) {
+    if (!PoseDetection.socket) {
+      throw new Error("socket is not connected");
+    }
+    PoseDetection.socket.emit("video", {
+      image,
+      user_unique_key: scanId,
+    });
+  }
+
+  disconnect() {
+    PoseDetection.socket?.disconnect?.();
+  }
+
+  poseStatus(callBack) {
+    if (!PoseDetection.socket) {
+      throw new Error("socket is not connected");
+    }
+    PoseDetection.socket.on("pose_status", (data) => {
+      callBack?.(data);
+    });
+  }
+
+  connected() {
+    return !!PoseDetection.socket?.connected;
+  }
+}

package/utils.js

@@ -21,3 +21,12 @@ export async function fetchData({
     return {};
   }
 }
+
+export const checkParameters = (...args) => {
+  for (const element of args) {
+    if (!element) {
+      return false;
+    }
+  }
+  return true;
+};