saltfish 0.3.40 → 0.3.41

package/dist/saltfish-playlist-player.es.js

@@ -9723,6 +9723,9 @@ class TriggerManager {
     const elementVisibleCondition = this.evaluateElementVisibleCondition(triggers.elementVisible);
     conditions.push(elementVisibleCondition);
     log(`TriggerManager: ElementVisible condition for playlist ${playlistId}: ${elementVisibleCondition} (selector: ${triggers.elementVisible})`);
+    const userAttributesCondition = this.evaluateUserAttributesCondition(triggers.userAttributes);
+    conditions.push(userAttributesCondition);
+    log(`TriggerManager: UserAttributes condition for playlist ${playlistId}: ${userAttributesCondition} (conditions: ${JSON.stringify(triggers.userAttributes)})`);
     const shouldTrigger = this.applyOperators(conditions, triggers.operators);
     log(`TriggerManager: Final evaluation for playlist ${playlistId}: ${shouldTrigger} (operator: ${triggers.operators.join(", ")})`);
     if (shouldTrigger) {
@@ -9856,6 +9859,98 @@ class TriggerManager {
     const isVisible = this.visibleElements.has(selector);
     return isVisible;
   }
+  /**
+   * Evaluates user attribute conditions for a playlist
+   * All conditions must be met (AND logic)
+   * @param conditions - Array of user attribute conditions to evaluate
+   */
+  evaluateUserAttributesCondition(conditions) {
+    if (!conditions || conditions.length === 0) {
+      return true;
+    }
+    const store = getSaltfishStore();
+    const user = store.user;
+    if (!user) {
+      return false;
+    }
+    for (const condition of conditions) {
+      const { attributeKey, attributeType, operator, value: expectedValue } = condition;
+      const userValue = user[attributeKey];
+      if (userValue === void 0 || userValue === null) {
+        return false;
+      }
+      const result = this.compareValues(userValue, expectedValue, attributeType, operator);
+      if (!result) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Compares two values based on attribute type and operator
+   * @param userValue - The user's actual value
+   * @param expectedValue - The expected value from trigger condition (always a string)
+   * @param attributeType - The data type for comparison
+   * @param operator - The comparison operator
+   */
+  compareValues(userValue, expectedValue, attributeType, operator) {
+    try {
+      switch (attributeType) {
+        case "string": {
+          const userStr = String(userValue);
+          const expectedStr = expectedValue;
+          return this.applyOperator(userStr, expectedStr, operator);
+        }
+        case "boolean": {
+          const userBool = typeof userValue === "boolean" ? userValue : String(userValue).toLowerCase() === "true";
+          const expectedBool = expectedValue.toLowerCase() === "true";
+          if (operator === "equals") return userBool === expectedBool;
+          if (operator === "notEquals") return userBool !== expectedBool;
+          return false;
+        }
+        case "int": {
+          const userNum = typeof userValue === "number" ? userValue : parseFloat(String(userValue));
+          const expectedNum = parseFloat(expectedValue);
+          if (isNaN(userNum) || isNaN(expectedNum)) {
+            log(`TriggerManager: Invalid number comparison - userValue: ${userValue}, expected: ${expectedValue}`);
+            return false;
+          }
+          return this.applyOperator(userNum, expectedNum, operator);
+        }
+        case "date": {
+          const userDate = userValue instanceof Date ? userValue : new Date(String(userValue));
+          const expectedDate = new Date(expectedValue);
+          if (isNaN(userDate.getTime()) || isNaN(expectedDate.getTime())) {
+            log(`TriggerManager: Invalid date comparison - userValue: ${userValue}, expected: ${expectedValue}`);
+            return false;
+          }
+          return this.applyOperator(userDate.getTime(), expectedDate.getTime(), operator);
+        }
+        default:
+          log(`TriggerManager: Unknown attribute type: ${attributeType}`);
+          return false;
+      }
+    } catch (error2) {
+      return false;
+    }
+  }
+  /**
+   * Applies the comparison operator to two values
+   */
+  applyOperator(userValue, expectedValue, operator) {
+    switch (operator) {
+      case "equals":
+        return userValue === expectedValue;
+      case "notEquals":
+        return userValue !== expectedValue;
+      case "greaterThan":
+        return userValue > expectedValue;
+      case "lessThan":
+        return userValue < expectedValue;
+      default:
+        return false;
+    }
+  }
   /**
    * Sets up click event listeners for all playlists with elementClicked triggers
    */
@@ -11896,7 +11991,7 @@ const SaltfishPlayer$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.de
   __proto__: null,
   SaltfishPlayer
 }, Symbol.toStringTag, { value: "Module" }));
-const version = "0.3.40";
+const version = "0.3.41";
 const packageJson = {
   version
 };