@sency/react-native-smkit-ui 2.0.6 → 2.0.8

package/android/src/main/java/com/smkituilibrary/SmkitUiLibraryModule.kt

@@ -1,7 +1,5 @@
 package com.smkituilibrary
 
-import android.os.Handler
-import android.os.Looper
 import android.util.Log
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.Promise
@@ -24,9 +22,18 @@ import com.sency.smkitui.model.UserData
 import com.sency.smkitui.model.UIColorTheme
 import com.sency.smkitui.model.WorkoutSummaryData
 import com.sency.smkitui.model.Gender
+import com.sency.smkitui.model.InstructionVideoConfig
+import com.sency.smkitui.model.VideoDisplayMode
+import com.sency.smkitui.model.SkeletonSettings
+import com.sency.smkitui.model.SkeletonPreset
+import com.sency.smkitui.model.SkeletonConnectionStyle
+import com.sency.smkitui.model.SkeletonJointShape
+import com.sency.smkitui.model.SkeletonColorOption
 import com.sency.smkitui.model.smkitui.Body360
+import com.sency.smkitui.model.smkitui.Cardio
 import com.sency.smkitui.model.smkitui.Custom
 import com.sency.smkitui.model.smkitui.Fitness
+import com.sency.smkitui.model.smkitui.Strength
 import com.sency.smkitui.model.workoutConfig.CounterPreference
 import com.sency.smkitui.model.workoutConfig.EndExercisePreference
 import com.sency.smkitui.model.workoutConfig.SMLanguage
@@ -94,14 +101,7 @@ class SmkitUiLibraryModule(reactContext: ReactApplicationContext) :
       }
       resultPromise?.resolve(result)
       sendEvent(reactApplicationContext, "workoutDidFinish", params)
-      // Dismiss the SDK UI on the main thread
-      Handler(Looper.getMainLooper()).post {
-        try {
-          smKitUI?.exitSDK()
-        } catch (e: Exception) {
-          Log.e(TAG, "Error exiting SDK: ${e.message}", e)
-        }
-      }
+      // SDK dismisses automatically after workout finishes
     }
 
     override fun didExitWorkout(summary: WorkoutSummaryData) {
@@ -124,14 +124,7 @@ class SmkitUiLibraryModule(reactContext: ReactApplicationContext) :
       }
       resultPromise?.resolve(result)
       sendEvent(reactApplicationContext, "didExitWorkout", params)
-      // Dismiss the SDK UI on the main thread
-      Handler(Looper.getMainLooper()).post {
-        try {
-          smKitUI?.exitSDK()
-        } catch (e: Exception) {
-          Log.e(TAG, "Error exiting SDK: ${e.message}", e)
-        }
-      }
+      // SDK dismisses automatically after workout exits
     }
 
 
@@ -200,6 +193,197 @@ class SmkitUiLibraryModule(reactContext: ReactApplicationContext) :
     promise.resolve("")
   }
 
+  // Instruction video config (align with ../smkit_android ConfigureViewModel).
+  // displayMode: "default" | "mediumCycle". mediumCycle: video at 75% for first N reps, then 50%.
+  // mediumSizeCycles: 1–5, only used when displayMode is mediumCycle.
+  @ReactMethod
+  fun setInstructionVideoConfig(configJson: String, promise: Promise) {
+    try {
+      val adapter = moshi.adapter(Map::class.java)
+      val configMap = adapter.fromJson(configJson) as? Map<String, Any> ?: mapOf()
+
+      val displayModeStr = configMap["displayMode"] as? String ?: "default"
+      val displayMode = if (displayModeStr == "mediumCycle") VideoDisplayMode.MEDIUM_CYCLE else VideoDisplayMode.DEFAULT
+      val mediumSizeCycles = (configMap["mediumSizeCycles"] as? Number)?.toInt() ?: 2
+
+      val config = InstructionVideoConfig(displayMode = displayMode, mediumSizeCycles = mediumSizeCycles)
+      smKitUI?.setInstructionVideoConfig(config)
+      promise.resolve("")
+    } catch (e: Exception) {
+      Log.e(TAG, "setInstructionVideoConfig error: ${e.message}")
+      promise.reject("setInstructionVideoConfig Failed", e.message)
+    }
+  }
+
+  @ReactMethod
+  fun setIntelligenceRestEnabled(enabled: Boolean, promise: Promise) {
+    try {
+      smKitUI?.setIntelligenceRestEnabled(enabled)
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.reject("ERROR", e.message)
+    }
+  }
+
+  @ReactMethod
+  fun setSkeletonSettings(configJson: String, promise: Promise) {
+    try {
+      val config = org.json.JSONObject(configJson)
+      config.optBoolean("hidden", false).let { SkeletonSettings.skeletonHidden = it }
+      config.optString("preset", "").takeIf { it.isNotEmpty() }?.let { s ->
+        skeletonPresetFromString(s)?.let { SkeletonSettings.skeletonPreset = it }
+      }
+      config.optString("connectionStyle", "").takeIf { it.isNotEmpty() }?.let { s ->
+        skeletonConnectionStyleFromString(s)?.let { SkeletonSettings.skeletonConnectionStyle = it }
+      }
+      config.optString("jointShape", "").takeIf { it.isNotEmpty() }?.let { s ->
+        skeletonJointShapeFromString(s)?.let { SkeletonSettings.skeletonJointShape = it }
+      }
+      if (config.has("dotsOpacity")) SkeletonSettings.skeletonDotsOpacity = config.getDouble("dotsOpacity").toFloat()
+      if (config.has("connectionsOpacity")) SkeletonSettings.skeletonConnectionsOpacity = config.getDouble("connectionsOpacity").toFloat()
+      if (config.has("dotsGlow")) SkeletonSettings.skeletonDotsGlow = config.getDouble("dotsGlow").toFloat()
+      if (config.has("connectionsGlow")) SkeletonSettings.skeletonConnectionsGlow = config.getDouble("connectionsGlow").toFloat()
+      if (config.has("lineWidthScale")) SkeletonSettings.skeletonLineWidthScale = config.getDouble("lineWidthScale").toFloat()
+      if (config.has("outlineScale")) SkeletonSettings.skeletonOutlineScale = config.getDouble("outlineScale").toFloat()
+      if (config.has("softness")) SkeletonSettings.skeletonSoftness = config.getDouble("softness").toFloat()
+      if (config.has("animationDuration")) SkeletonSettings.skeletonAnimationDurationSeconds = config.getDouble("animationDuration").toFloat()
+      config.optString("dotsInnerColor", "").takeIf { it.isNotEmpty() }?.let { s ->
+        skeletonColorFromString(s)?.let { SkeletonSettings.skeletonDotsInnerColorOption = it }
+      }
+      config.optString("dotsOuterColor", "").takeIf { it.isNotEmpty() }?.let { s ->
+        skeletonColorFromString(s)?.let { SkeletonSettings.skeletonDotsOuterColorOption = it }
+      }
+      config.optString("connectionsInnerColor", "").takeIf { it.isNotEmpty() }?.let { s ->
+        skeletonColorFromString(s)?.let { SkeletonSettings.skeletonConnectionsInnerColorOption = it }
+      }
+      config.optString("connectionsOuterColor", "").takeIf { it.isNotEmpty() }?.let { s ->
+        skeletonColorFromString(s)?.let { SkeletonSettings.skeletonConnectionsOuterColorOption = it }
+      }
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.reject("ERROR", e.message)
+    }
+  }
+
+  @ReactMethod
+  fun setPauseTypes(typesJson: String, promise: Promise) {
+    try {
+      val arr = org.json.JSONArray(typesJson)
+      val nameMap = mapOf(
+        "resume" to "Resume",
+        "startOver" to "StartOver",
+        "skip" to "Skip",
+        "quit" to "Quit",
+        "rest" to "Rest",
+        "switchExercise" to "Switch"
+      )
+      val enumClass = Class.forName("com.sency.smkitui.presentation.fragment.PauseDialogTypes")
+      val constants = enumClass.enumConstants as Array<*>
+      val byName = constants.associateBy { (it as Enum<*>).name }
+      val types = (0 until arr.length())
+        .mapNotNull { nameMap[arr.getString(it)] }
+        .mapNotNull { byName[it] }
+        .toTypedArray()
+      val method = smKitUI?.javaClass?.getMethod("setPauseTypes", types.javaClass)
+      method?.invoke(smKitUI, types)
+      promise.resolve(null)
+    } catch (e: Exception) {
+      Log.d(TAG, "setPauseTypes: ${e.message}")
+      promise.resolve(null) // non-fatal — resolve even if not available
+    }
+  }
+
+  // iOS-only stubs — no-op on Android, resolve immediately for API parity
+  @ReactMethod fun setAllowAudioMixing(enabled: Boolean, promise: Promise) { promise.resolve(null) }
+  @ReactMethod fun setShowExternalAudioControl(enabled: Boolean, promise: Promise) { promise.resolve(null) }
+  @ReactMethod fun setAccuratePoseEstimation(enabled: Boolean, promise: Promise) { promise.resolve(null) }
+
+  private fun skeletonPresetFromString(s: String): SkeletonPreset? = when (s) {
+    "defaultPreset" -> SkeletonPreset.DEFAULT
+    "minimalDots" -> SkeletonPreset.MINIMAL_DOTS
+    "thinOutline" -> SkeletonPreset.THIN_OUTLINE
+    "monochromeClean" -> SkeletonPreset.MONOCHROME_CLEAN
+    "neonGlow" -> SkeletonPreset.NEON_GLOW
+    "boldHighlight" -> SkeletonPreset.BOLD_HIGHLIGHT
+    "softFill" -> SkeletonPreset.SOFT_FILL
+    "wireframe" -> SkeletonPreset.WIREFRAME
+    "highContrast" -> SkeletonPreset.HIGH_CONTRAST
+    "pastel" -> SkeletonPreset.PASTEL
+    "darkOutline" -> SkeletonPreset.DARK_OUTLINE
+    "minimalLine" -> SkeletonPreset.MINIMAL_LINE
+    "doubleStroke" -> SkeletonPreset.DOUBLE_STROKE
+    "gradientReady" -> SkeletonPreset.GRADIENT_READY
+    "subtleShadow" -> SkeletonPreset.SUBTLE_SHADOW
+    "classic" -> SkeletonPreset.CLASSIC
+    "athletic" -> SkeletonPreset.ATHLETIC
+    "premium" -> SkeletonPreset.PREMIUM
+    "hologram" -> SkeletonPreset.HOLOGRAM
+    "matte" -> SkeletonPreset.MATTE
+    "neonPulse" -> SkeletonPreset.NEON_PULSE
+    "outlineOnly" -> SkeletonPreset.OUTLINE_ONLY
+    "slim" -> SkeletonPreset.SLIM
+    "thick" -> SkeletonPreset.THICK
+    "studio" -> SkeletonPreset.STUDIO
+    "accessibility" -> SkeletonPreset.ACCESSIBILITY
+    else -> null
+  }
+
+  private fun skeletonConnectionStyleFromString(s: String): SkeletonConnectionStyle? = when (s) {
+    "none" -> SkeletonConnectionStyle.NONE
+    "dotted" -> SkeletonConnectionStyle.DOTTED
+    "dashed" -> SkeletonConnectionStyle.DASHED
+    "solid" -> SkeletonConnectionStyle.SOLID
+    "longDashed" -> SkeletonConnectionStyle.LONG_DASHED
+    "thinDots" -> SkeletonConnectionStyle.THIN_DOTS
+    "dotDashed" -> SkeletonConnectionStyle.DOT_DASHED
+    "rounded" -> SkeletonConnectionStyle.ROUNDED
+    else -> null
+  }
+
+  private fun skeletonJointShapeFromString(s: String): SkeletonJointShape? = when (s) {
+    "circle" -> SkeletonJointShape.CIRCLE
+    "square" -> SkeletonJointShape.SQUARE
+    "triangle" -> SkeletonJointShape.TRIANGLE
+    "diamond" -> SkeletonJointShape.DIAMOND
+    "star" -> SkeletonJointShape.STAR
+    "hexagon" -> SkeletonJointShape.HEXAGON
+    else -> null
+  }
+
+  private fun skeletonColorFromString(s: String): SkeletonColorOption? = when (s) {
+    "white" -> SkeletonColorOption.WHITE
+    "black" -> SkeletonColorOption.BLACK
+    "red" -> SkeletonColorOption.RED
+    "blue" -> SkeletonColorOption.BLUE
+    "green" -> SkeletonColorOption.GREEN
+    "yellow" -> SkeletonColorOption.YELLOW
+    "orange" -> SkeletonColorOption.ORANGE
+    "purple" -> SkeletonColorOption.PURPLE
+    "gray" -> SkeletonColorOption.GRAY
+    "cyan" -> SkeletonColorOption.CYAN
+    "lightGray" -> SkeletonColorOption.LIGHT_GRAY
+    "darkGray" -> SkeletonColorOption.DARK_GRAY
+    "offWhite" -> SkeletonColorOption.OFF_WHITE
+    "charcoal" -> SkeletonColorOption.CHARCOAL
+    "lightBlue" -> SkeletonColorOption.LIGHT_BLUE
+    "darkBlue" -> SkeletonColorOption.DARK_BLUE
+    "lightGreen" -> SkeletonColorOption.LIGHT_GREEN
+    "darkGreen" -> SkeletonColorOption.DARK_GREEN
+    "lightPurple" -> SkeletonColorOption.LIGHT_PURPLE
+    "darkPurple" -> SkeletonColorOption.DARK_PURPLE
+    "gold" -> SkeletonColorOption.GOLD
+    "darkGold" -> SkeletonColorOption.DARK_GOLD
+    "lightPink" -> SkeletonColorOption.LIGHT_PINK
+    "darkPink" -> SkeletonColorOption.DARK_PINK
+    "mediumGray" -> SkeletonColorOption.MEDIUM_GRAY
+    "silver" -> SkeletonColorOption.SILVER
+    "navy" -> SkeletonColorOption.NAVY
+    "forestGreen" -> SkeletonColorOption.FOREST_GREEN
+    "lavender" -> SkeletonColorOption.LAVENDER
+    "rosePink" -> SkeletonColorOption.ROSE_PINK
+    else -> null
+  }
+
   private fun mapColorToTheme(primaryColor: String): UIColorTheme {
     // Remove # if present and convert to lowercase for comparison
     val color = primaryColor.replace("#", "").lowercase()
@@ -284,6 +468,8 @@ class SmkitUiLibraryModule(reactContext: ReactApplicationContext) :
       val assessmentType = when (type) {
         "fitness" -> Fitness
         "body360" -> Body360
+        "cardio" -> Cardio
+        "strength" -> Strength
         else -> {
           // Validate customAssessmentId is not empty for custom assessments
           if (customAssessmentId.isNullOrBlank()) {

package/android/src/main/java/com/smkituilibrary/mapper/SMMapper.kt

@@ -81,7 +81,7 @@ private fun SMKitExercise.toSMExerciseWithoutScoringParams(): SMExercise = SMExe
   summaryTitle = summaryTitle ?: "",
   summarySubTitle = summarySubTitle ?: "",
   summaryMainMetricTitle = summaryTitleMainMetric ?: "",
-  summarySubTitleMainMetric = summarySubTitleMainMetric ?: "",
+  summaryMainMetricSubTitle = summarySubTitleMainMetric ?: "",
   side = side
 )
 

package/ios/SMKitUIManager.mm

@@ -11,4 +11,12 @@ RCT_EXTERN_METHOD(setSessionLanguage:(NSString*)language)
 RCT_EXTERN_METHOD(setEndExercisePreferences:(NSString*)preferencesString)
 RCT_EXTERN_METHOD(setCounterPreferences:(NSString*)preferencesString)
 
+RCT_EXTERN_METHOD(setIntelligenceRestEnabled:(BOOL)enabled)
+RCT_EXTERN_METHOD(setSkeletonSettings:(NSString*)configString)
+RCT_EXTERN_METHOD(setPauseTypes:(NSString*)typesJson)
+RCT_EXTERN_METHOD(setAllowAudioMixing:(BOOL)enabled)
+RCT_EXTERN_METHOD(setShowExternalAudioControl:(BOOL)enabled)
+RCT_EXTERN_METHOD(setAccuratePoseEstimation:(BOOL)enabled)
+RCT_EXTERN_METHOD(setInstructionVideoConfig:(NSString*)configString)
+
 @end

package/ios/SMKitUIManager.swift

@@ -2,6 +2,7 @@ import Foundation
 import UIKit
 import SMKitUI
 import SMBase
+import SMKit
 
 @objc(SMKitUIManager)
 class SMKitUIManager: NSObject, RCTBridgeModule {
@@ -35,7 +36,15 @@ class SMKitUIManager: NSObject, RCTBridgeModule {
     }
     
     var smkitUIViewController: UIViewController? {
-        let keyWindow = UIApplication.shared.windows.filter {$0.isKeyWindow}.first
+        let keyWindow: UIWindow?
+        if #available(iOS 15.0, *) {
+            keyWindow = UIApplication.shared.connectedScenes
+                .compactMap { $0 as? UIWindowScene }
+                .first { $0.activationState == .foregroundActive }
+                .flatMap { $0.windows.first { $0.isKeyWindow } }
+        } else {
+            keyWindow = UIApplication.shared.windows.first { $0.isKeyWindow }
+        }
         if var topController = keyWindow?.rootViewController {
             while let presentedViewController = topController.presentedViewController {
                 topController = presentedViewController
@@ -94,6 +103,15 @@ class SMKitUIManager: NSObject, RCTBridgeModule {
                 print("SMKitUIManager: Final showPhoneCalibration: \(showPhoneCalibration)")
                 
                 if let assessmentType = AssessmentTypes(rawValue: "\(type)") {
+                    // Validate customAssessmentID for Custom assessment type
+                    if assessmentType == .Custom {
+                        if customAssessmentID == nil || customAssessmentID!.length == 0 {
+                            onWorkoutFailed("StartAssessment Failed", "Custom assessment ID is required for custom assessment type", nil)
+                            return
+                        }
+                        print("SMKitUIManager: Creating Custom assessment with ID: \(customAssessmentID!)")
+                    }
+                    
                     try SMKitUIModel.startAssessmet(
                         viewController: smkitUIViewController,
                         type: assessmentType,
@@ -103,6 +121,7 @@ class SMKitUIManager: NSObject, RCTBridgeModule {
                         showSummary: showSummary,
                         delegate: self,
                         onFailure: { error in
+                            print("SMKitUIManager: Assessment failed with error: \(error.localizedDescription)")
                             onWorkoutFailed("StartAssessment Failed", error.localizedDescription, error)
                         },
                         modifications: finalModifications,
@@ -227,6 +246,191 @@ class SMKitUIManager: NSObject, RCTBridgeModule {
         SMKitUIModel.setCounterPreferences(counterPreferences: preferences)
     }
 
+    @objc(setIntelligenceRestEnabled:)
+    func setIntelligenceRestEnabled(_ enabled: Bool) {
+        SMKitUIModel.enableIntelligenceRest = enabled
+    }
+
+    @objc(setSkeletonSettings:)
+    func setSkeletonSettings(_ configString: String) {
+        guard let data = configString.data(using: .utf8),
+              let rawConfig = try? JSONSerialization.jsonObject(with: data),
+              let config = rawConfig as? [String: Any] else {
+            print("setSkeletonSettings: invalid JSON")
+            return
+        }
+        if let v = config["hidden"] as? Bool { SMKitUIModel.skeletonHidden = v }
+        if let v = config["preset"] as? String, let p = skeletonPreset(from: v) { SMKitUIModel.skeletonPreset = p }
+        if let v = config["connectionStyle"] as? String, let s = skeletonConnectionStyle(from: v) { SMKitUIModel.skeletonConnectionStyle = s }
+        if let v = config["jointShape"] as? String, let s = skeletonJointShape(from: v) { SMKitUIModel.skeletonJointShape = s }
+        if let v = config["dotsOpacity"] as? Double { SMKitUIModel.skeletonDotsOpacity = CGFloat(v) }
+        if let v = config["connectionsOpacity"] as? Double { SMKitUIModel.skeletonConnectionsOpacity = CGFloat(v) }
+        if let v = config["dotsGlow"] as? Double { SMKitUIModel.skeletonDotsGlow = CGFloat(v) }
+        if let v = config["connectionsGlow"] as? Double { SMKitUIModel.skeletonConnectionsGlow = CGFloat(v) }
+        if let v = config["lineWidthScale"] as? Double { SMKitUIModel.skeletonLineWidthScale = CGFloat(v) }
+        if let v = config["outlineScale"] as? Double { SMKitUIModel.skeletonOutlineScale = CGFloat(v) }
+        if let v = config["softness"] as? Double { SMKitUIModel.skeletonSoftness = CGFloat(v) }
+        if let v = config["animationDuration"] as? Double { SMKitUIModel.skeletonAnimationDuration = TimeInterval(v) }
+        if let v = config["dotsInnerColor"] as? String, let c = skeletonColor(from: v) { SMKitUIModel.skeletonDotsInnerColorOption = c }
+        if let v = config["dotsOuterColor"] as? String, let c = skeletonColor(from: v) { SMKitUIModel.skeletonDotsOuterColorOption = c }
+        if let v = config["connectionsInnerColor"] as? String, let c = skeletonColor(from: v) { SMKitUIModel.skeletonConnectionsInnerColorOption = c }
+        if let v = config["connectionsOuterColor"] as? String, let c = skeletonColor(from: v) { SMKitUIModel.skeletonConnectionsOuterColorOption = c }
+    }
+
+    @objc(setPauseTypes:)
+    func setPauseTypes(_ typesJson: String) {
+        guard let data = typesJson.data(using: .utf8),
+              let rawArray = try? JSONSerialization.jsonObject(with: data),
+              let arr = rawArray as? [String] else { return }
+        let types = arr.compactMap { pauseAlertType(from: $0) }
+        try? SMKitUIModel.setAllowedPauseTypes(types: types)
+    }
+
+    @objc(setAllowAudioMixing:)
+    func setAllowAudioMixing(_ enabled: Bool) {
+        SMKitUIModel.allowAudioMixing = enabled
+    }
+
+    @objc(setShowExternalAudioControl:)
+    func setShowExternalAudioControl(_ enabled: Bool) {
+        SMKitUIModel.showExternalAudioControl = enabled
+    }
+
+    @objc(setAccuratePoseEstimation:)
+    func setAccuratePoseEstimation(_ enabled: Bool) {
+        SMKitUIModel.accuratePoseEstimation = enabled
+    }
+
+    // Instruction video config (align with ../smkit_android ConfigureViewModel).
+    // displayMode: "default" | "mediumCycle". mediumCycle: video at 75% for first N reps, then 50%.
+    // mediumSizeCycles: 1–5, only used when displayMode is mediumCycle.
+    @objc(setInstructionVideoConfig:)
+    func setInstructionVideoConfig(_ configString: String) {
+        do {
+            let configDict = try stringJsonToDic(stringJSON: configString)
+
+            // Parse displayMode: "default" or "mediumCycle"
+            let displayModeStr = configDict["displayMode"] as? String ?? "default"
+            let displayMode: VideoDisplayMode = (displayModeStr == "mediumCycle") ? .mediumCycle : .default
+
+            // Parse mediumSizeCycles (1-5)
+            let mediumSizeCycles = configDict["mediumSizeCycles"] as? Int ?? 2
+
+            let config = InstructionVideoConfig(displayMode: displayMode, mediumSizeCycles: mediumSizeCycles)
+            SMKitUIModel.instructionVideoConfig = config
+
+            print("SMKitUIManager: Set InstructionVideoConfig - mode: \(displayModeStr), cycles: \(mediumSizeCycles)")
+        } catch {
+            print("SMKitUIManager: Error parsing InstructionVideoConfig - \(error.localizedDescription)")
+        }
+    }
+
+    private func pauseAlertType(from s: String) -> PauseAlertType? {
+        switch s {
+        case "resume":         return .Resume
+        case "startOver":      return .StartOver
+        case "skip":           return .Skip
+        case "quit":           return .Quit
+        case "rest":           return .Rest
+        case "switchExercise": return .Switch
+        default:               return nil
+        }
+    }
+
+    private func skeletonPreset(from s: String) -> SkeletonPreset? {
+        switch s {
+        case "defaultPreset": return .default
+        case "minimalDots": return .minimalDots
+        case "thinOutline": return .thinOutline
+        case "monochromeClean": return .monochromeClean
+        case "neonGlow": return .neonGlow
+        case "boldHighlight": return .boldHighlight
+        case "softFill": return .softFill
+        case "wireframe": return .wireframe
+        case "highContrast": return .highContrast
+        case "pastel": return .pastel
+        case "darkOutline": return .darkOutline
+        case "minimalLine": return .minimalLine
+        case "doubleStroke": return .doubleStroke
+        case "gradientReady": return .gradientReady
+        case "subtleShadow": return .subtleShadow
+        case "classic": return .classic
+        case "athletic": return .athletic
+        case "premium": return .premium
+        case "hologram": return .hologram
+        case "matte": return .matte
+        case "neonPulse": return .neonPulse
+        case "outlineOnly": return .outlineOnly
+        case "slim": return .slim
+        case "thick": return .thick
+        case "studio": return .studio
+        case "accessibility": return .accessibility
+        default: return nil
+        }
+    }
+
+    private func skeletonConnectionStyle(from s: String) -> SkeletonConnectionStyle? {
+        switch s {
+        case "none": return SkeletonConnectionStyle.none
+        case "dotted": return .dotted
+        case "dashed": return .dashed
+        case "solid": return .solid
+        case "longDashed": return .longDashed
+        case "thinDots": return .thinDots
+        case "dotDashed": return .dotDashed
+        case "rounded": return .rounded
+        default: return nil
+        }
+    }
+
+    private func skeletonJointShape(from s: String) -> SkeletonJointShape? {
+        switch s {
+        case "circle": return .circle
+        case "square": return .square
+        case "triangle": return .triangle
+        case "diamond": return .diamond
+        case "star": return .star
+        case "hexagon": return .hexagon
+        default: return nil
+        }
+    }
+
+    private func skeletonColor(from s: String) -> SkeletonColorOption? {
+        switch s {
+        case "white": return .white
+        case "black": return .black
+        case "red": return .red
+        case "blue": return .blue
+        case "green": return .green
+        case "yellow": return .yellow
+        case "orange": return .orange
+        case "purple": return .purple
+        case "gray": return .gray
+        case "cyan": return .cyan
+        case "lightGray": return .lightGray
+        case "darkGray": return .darkGray
+        case "offWhite": return .offWhite
+        case "charcoal": return .charcoal
+        case "lightBlue": return .lightBlue
+        case "darkBlue": return .darkBlue
+        case "lightGreen": return .lightGreen
+        case "darkGreen": return .darkGreen
+        case "lightPurple": return .lightPurple
+        case "darkPurple": return .darkPurple
+        case "gold": return .gold
+        case "darkGold": return .darkGold
+        case "lightPink": return .lightPink
+        case "darkPink": return .darkPink
+        case "mediumGray": return .mediumGray
+        case "silver": return .silver
+        case "navy": return .navy
+        case "forestGreen": return .forestGreen
+        case "lavender": return .lavender
+        case "rosePink": return .rosePink
+        default: return nil
+        }
+    }
+
     private func stringJsonToDic(stringJSON: String) throws -> [String: Any] {
         guard let data = stringJSON.data(using: .utf8),
               let json = try JSONSerialization.jsonObject(with: data) as? [String: Any]

package/lib/commonjs/SMWorkout.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.WorkoutDuration = exports.WorkoutDifficulty = exports.WorkoutConfig = exports.UserData = exports.UIElement = exports.ScoringType = exports.SMWorkout = exports.SMScoringParams = exports.SMExercise = exports.SMAssessmentExercise = exports.Language = exports.Gender = exports.EndExercisePreferences = exports.CounterPreferences = exports.BodyZone = exports.AssessmentTypes = void 0;
+exports.WorkoutDuration = exports.WorkoutDifficulty = exports.WorkoutConfig = exports.UserData = exports.UIElement = exports.SkeletonPreset = exports.SkeletonJointShape = exports.SkeletonConnectionStyle = exports.SkeletonConfig = exports.SkeletonColorOption = exports.ScoringType = exports.SMWorkout = exports.SMScoringParams = exports.SMExercise = exports.SMAssessmentExercise = exports.PauseType = exports.Language = exports.Gender = exports.EndExercisePreferences = exports.CounterPreferences = exports.BodyZone = exports.AssessmentTypes = void 0;
 /**
  * Enum representing assessment types.
  * @enum {string}
@@ -12,8 +12,19 @@ let AssessmentTypes = exports.AssessmentTypes = /*#__PURE__*/function (Assessmen
   AssessmentTypes["Fitness"] = "fitness";
   AssessmentTypes["Custom"] = "custom";
   AssessmentTypes["Body360"] = "body360";
+  AssessmentTypes["Cardio"] = "cardio";
+  AssessmentTypes["Strength"] = "strength";
   return AssessmentTypes;
 }({});
+let PauseType = exports.PauseType = /*#__PURE__*/function (PauseType) {
+  PauseType["Resume"] = "resume";
+  PauseType["Skip"] = "skip";
+  PauseType["StartOver"] = "startOver";
+  PauseType["Quit"] = "quit";
+  PauseType["Rest"] = "rest";
+  PauseType["Switch"] = "switchExercise";
+  return PauseType;
+}({});
 /**
  * Enum representing UI elements that can be displayed during workouts.
  * @enum {string}
@@ -97,9 +108,94 @@ let EndExercisePreferences = exports.EndExercisePreferences = /*#__PURE__*/funct
   EndExercisePreferences["TargetBased"] = "TargetBased"; //on target reached
   return EndExercisePreferences;
 }({});
+let SkeletonPreset = exports.SkeletonPreset = /*#__PURE__*/function (SkeletonPreset) {
+  SkeletonPreset["Default"] = "defaultPreset";
+  SkeletonPreset["MinimalDots"] = "minimalDots";
+  SkeletonPreset["ThinOutline"] = "thinOutline";
+  SkeletonPreset["MonochromeClean"] = "monochromeClean";
+  SkeletonPreset["NeonGlow"] = "neonGlow";
+  SkeletonPreset["BoldHighlight"] = "boldHighlight";
+  SkeletonPreset["SoftFill"] = "softFill";
+  SkeletonPreset["Wireframe"] = "wireframe";
+  SkeletonPreset["HighContrast"] = "highContrast";
+  SkeletonPreset["Pastel"] = "pastel";
+  SkeletonPreset["DarkOutline"] = "darkOutline";
+  SkeletonPreset["MinimalLine"] = "minimalLine";
+  SkeletonPreset["DoubleStroke"] = "doubleStroke";
+  SkeletonPreset["GradientReady"] = "gradientReady";
+  SkeletonPreset["SubtleShadow"] = "subtleShadow";
+  SkeletonPreset["Classic"] = "classic";
+  SkeletonPreset["Athletic"] = "athletic";
+  SkeletonPreset["Premium"] = "premium";
+  SkeletonPreset["Hologram"] = "hologram";
+  SkeletonPreset["Matte"] = "matte";
+  SkeletonPreset["NeonPulse"] = "neonPulse";
+  SkeletonPreset["OutlineOnly"] = "outlineOnly";
+  SkeletonPreset["Slim"] = "slim";
+  SkeletonPreset["Thick"] = "thick";
+  SkeletonPreset["Studio"] = "studio";
+  SkeletonPreset["Accessibility"] = "accessibility";
+  return SkeletonPreset;
+}({});
+let SkeletonConnectionStyle = exports.SkeletonConnectionStyle = /*#__PURE__*/function (SkeletonConnectionStyle) {
+  SkeletonConnectionStyle["None"] = "none";
+  SkeletonConnectionStyle["Dotted"] = "dotted";
+  SkeletonConnectionStyle["Dashed"] = "dashed";
+  SkeletonConnectionStyle["Solid"] = "solid";
+  SkeletonConnectionStyle["LongDashed"] = "longDashed";
+  SkeletonConnectionStyle["ThinDots"] = "thinDots";
+  SkeletonConnectionStyle["DotDashed"] = "dotDashed";
+  SkeletonConnectionStyle["Rounded"] = "rounded";
+  return SkeletonConnectionStyle;
+}({});
+let SkeletonJointShape = exports.SkeletonJointShape = /*#__PURE__*/function (SkeletonJointShape) {
+  SkeletonJointShape["Circle"] = "circle";
+  SkeletonJointShape["Square"] = "square";
+  SkeletonJointShape["Triangle"] = "triangle";
+  SkeletonJointShape["Diamond"] = "diamond";
+  SkeletonJointShape["Star"] = "star";
+  SkeletonJointShape["Hexagon"] = "hexagon";
+  return SkeletonJointShape;
+}({});
+let SkeletonColorOption = exports.SkeletonColorOption = /*#__PURE__*/function (SkeletonColorOption) {
+  SkeletonColorOption["White"] = "white";
+  SkeletonColorOption["Black"] = "black";
+  SkeletonColorOption["Red"] = "red";
+  SkeletonColorOption["Blue"] = "blue";
+  SkeletonColorOption["Green"] = "green";
+  SkeletonColorOption["Yellow"] = "yellow";
+  SkeletonColorOption["Orange"] = "orange";
+  SkeletonColorOption["Purple"] = "purple";
+  SkeletonColorOption["Gray"] = "gray";
+  SkeletonColorOption["Cyan"] = "cyan";
+  SkeletonColorOption["LightGray"] = "lightGray";
+  SkeletonColorOption["DarkGray"] = "darkGray";
+  SkeletonColorOption["OffWhite"] = "offWhite";
+  SkeletonColorOption["Charcoal"] = "charcoal";
+  SkeletonColorOption["LightBlue"] = "lightBlue";
+  SkeletonColorOption["DarkBlue"] = "darkBlue";
+  SkeletonColorOption["LightGreen"] = "lightGreen";
+  SkeletonColorOption["DarkGreen"] = "darkGreen";
+  SkeletonColorOption["LightPurple"] = "lightPurple";
+  SkeletonColorOption["DarkPurple"] = "darkPurple";
+  SkeletonColorOption["Gold"] = "gold";
+  SkeletonColorOption["DarkGold"] = "darkGold";
+  SkeletonColorOption["LightPink"] = "lightPink";
+  SkeletonColorOption["DarkPink"] = "darkPink";
+  SkeletonColorOption["MediumGray"] = "mediumGray";
+  SkeletonColorOption["Silver"] = "silver";
+  SkeletonColorOption["Navy"] = "navy";
+  SkeletonColorOption["ForestGreen"] = "forestGreen";
+  SkeletonColorOption["Lavender"] = "lavender";
+  SkeletonColorOption["RosePink"] = "rosePink";
+  return SkeletonColorOption;
+}({});
+class SkeletonConfig {}
+
 /**
  * Class representing a workout.
  */
+exports.SkeletonConfig = SkeletonConfig;
 class SMWorkout {
   /**
    * @param {string | null} id - Unique identifier for the workout.