@capillarytech/creatives-library 8.0.212 → 8.0.214

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@capillarytech/creatives-library",
   "author": "meharaj",
-  "version": "8.0.212",
+  "version": "8.0.214",
   "description": "Capillary creatives ui",
   "main": "./index.js",
   "module": "./index.es.js",

package/utils/commonUtils.js

@@ -429,3 +429,62 @@ export const validateInAppContent = async (formData, options) => {
   // Errors already reported via the 'onError' callback passed to _validatePlatformSpecificContent
   return false;
 };
+
+/**
+ * Validate carousel cards for errors
+ * Checks each card for body errors, missing text, missing media, and unsaved buttons
+ *
+ * @param {Array} carouselData - Array of carousel card objects
+ * @param {string} mediaType - Media type ('image' or 'video', case-insensitive)
+ * @param {Object} options - Optional configuration
+ * @param {string} options.imageConstant - Constant for image media type (default: 'IMAGE')
+ * @param {string} options.videoConstant - Constant for video media type (default: 'VIDEO')
+ * @returns {Object} Object containing validation results: { isValid: boolean, reasons: string[] }
+ */
+export const validateCarouselCards = (
+  carouselData = [],
+  mediaType = '',
+  options = {}
+) => {
+  const {
+    imageConstant = 'IMAGE',
+    videoConstant = 'VIDEO',
+  } = options;
+
+  const reasons = [];
+  const normalizedMediaType = mediaType?.toLowerCase() || '';
+  const normalizedImageType = imageConstant?.toLowerCase() || '';
+  const normalizedVideoType = videoConstant?.toLowerCase() || '';
+
+  carouselData?.forEach((card, idx) => {
+    // Check for body errors
+    if (card?.bodyError) {
+      reasons.push(`card ${idx + 1}: bodyError=${card.bodyError}`);
+    }
+
+    // Check for empty body text
+    if (!card?.bodyText) {
+      reasons.push(`card ${idx + 1}: bodyText empty`);
+    }
+
+    // Check for missing image source when media type is image
+    if (normalizedMediaType === normalizedImageType && !card?.imageSrc) {
+      reasons.push(`card ${idx + 1}: imageSrc missing`);
+    }
+
+    // Check for missing video source when media type is video
+    if (normalizedMediaType === normalizedVideoType && !card?.videoSrc) {
+      reasons.push(`card ${idx + 1}: videoSrc missing`);
+    }
+
+    // Check if all buttons are saved
+    if (card?.buttons && !card.buttons.every((b) => b?.isSaved === true)) {
+      reasons.push(`card ${idx + 1}: some buttons not saved`);
+    }
+  });
+
+  return {
+    isValid: reasons.length === 0,
+    reasons,
+  };
+};

package/utils/tests/commonUtil.test.js

@@ -3,7 +3,9 @@ import {
   validateMobilePushContent,
   validateInAppContent,
   getChannelData,
-  extractContent,addBaseToTemplate
+  extractContent,
+  addBaseToTemplate,
+  validateCarouselCards,
 } from "../commonUtils";
 import { SMS_TRAI_VAR } from '../../v2Containers/SmsTrai/Edit/constants';
 import { ANDROID, IOS } from '../../v2Containers/CreativesContainer/constants';
@@ -656,3 +658,473 @@ describe("extractContent", () => {
     expect(extractContent({ title: "T", message: "M" })).toBe("T M");
   });
 });
+
+describe("validateCarouselCards", () => {
+  describe("Valid carousel cards", () => {
+    it("should return isValid true for valid image carousel cards", () => {
+      const carouselData = [
+        {
+          bodyText: "Card 1 text",
+          imageSrc: "https://example.com/image1.jpg",
+          buttons: [{ isSaved: true }],
+        },
+        {
+          bodyText: "Card 2 text",
+          imageSrc: "https://example.com/image2.jpg",
+          buttons: [{ isSaved: true }, { isSaved: true }],
+        },
+      ];
+
+      const result = validateCarouselCards(carouselData, "image", {
+        imageConstant: "IMAGE",
+        videoConstant: "VIDEO",
+      });
+
+      expect(result.isValid).toBe(true);
+      expect(result.reasons).toEqual([]);
+    });
+
+    it("should return isValid true for valid video carousel cards", () => {
+      const carouselData = [
+        {
+          bodyText: "Card 1 text",
+          videoSrc: "https://example.com/video1.mp4",
+          buttons: [{ isSaved: true }],
+        },
+        {
+          bodyText: "Card 2 text",
+          videoSrc: "https://example.com/video2.mp4",
+          buttons: [{ isSaved: true }],
+        },
+      ];
+
+      const result = validateCarouselCards(carouselData, "video", {
+        imageConstant: "IMAGE",
+        videoConstant: "VIDEO",
+      });
+
+      expect(result.isValid).toBe(true);
+      expect(result.reasons).toEqual([]);
+    });
+
+    it("should return isValid true for cards without buttons", () => {
+      const carouselData = [
+        {
+          bodyText: "Card 1 text",
+          imageSrc: "https://example.com/image1.jpg",
+        },
+        {
+          bodyText: "Card 2 text",
+          imageSrc: "https://example.com/image2.jpg",
+        },
+      ];
+
+      const result = validateCarouselCards(carouselData, "image", {
+        imageConstant: "IMAGE",
+        videoConstant: "VIDEO",
+      });
+
+      expect(result.isValid).toBe(true);
+      expect(result.reasons).toEqual([]);
+    });
+  });
+
+  describe("Body errors", () => {
+    it("should detect body errors in carousel cards", () => {
+      const carouselData = [
+        {
+          bodyText: "Card 1 text",
+          bodyError: "Invalid characters",
+          imageSrc: "https://example.com/image1.jpg",
+          buttons: [{ isSaved: true }],
+        },
+        {
+          bodyText: "Card 2 text",
+          imageSrc: "https://example.com/image2.jpg",
+          buttons: [{ isSaved: true }],
+        },
+      ];
+
+      const result = validateCarouselCards(carouselData, "image", {
+        imageConstant: "IMAGE",
+        videoConstant: "VIDEO",
+      });
+
+      expect(result.isValid).toBe(false);
+      expect(result.reasons).toContain("card 1: bodyError=Invalid characters");
+    });
+
+    it("should detect body errors in multiple cards", () => {
+      const carouselData = [
+        {
+          bodyText: "Card 1 text",
+          bodyError: "Error 1",
+          imageSrc: "https://example.com/image1.jpg",
+        },
+        {
+          bodyText: "Card 2 text",
+          bodyError: "Error 2",
+          imageSrc: "https://example.com/image2.jpg",
+        },
+      ];
+
+      const result = validateCarouselCards(carouselData, "image", {
+        imageConstant: "IMAGE",
+        videoConstant: "VIDEO",
+      });
+
+      expect(result.isValid).toBe(false);
+      expect(result.reasons).toContain("card 1: bodyError=Error 1");
+      expect(result.reasons).toContain("card 2: bodyError=Error 2");
+    });
+  });
+
+  describe("Empty body text", () => {
+    it("should detect empty body text", () => {
+      const carouselData = [
+        {
+          bodyText: "",
+          imageSrc: "https://example.com/image1.jpg",
+          buttons: [{ isSaved: true }],
+        },
+        {
+          bodyText: "Card 2 text",
+          imageSrc: "https://example.com/image2.jpg",
+          buttons: [{ isSaved: true }],
+        },
+      ];
+
+      const result = validateCarouselCards(carouselData, "image", {
+        imageConstant: "IMAGE",
+        videoConstant: "VIDEO",
+      });
+
+      expect(result.isValid).toBe(false);
+      expect(result.reasons).toContain("card 1: bodyText empty");
+    });
+
+    it("should detect missing body text", () => {
+      const carouselData = [
+        {
+          imageSrc: "https://example.com/image1.jpg",
+          buttons: [{ isSaved: true }],
+        },
+        {
+          bodyText: "Card 2 text",
+          imageSrc: "https://example.com/image2.jpg",
+          buttons: [{ isSaved: true }],
+        },
+      ];
+
+      const result = validateCarouselCards(carouselData, "image", {
+        imageConstant: "IMAGE",
+        videoConstant: "VIDEO",
+      });
+
+      expect(result.isValid).toBe(false);
+      expect(result.reasons).toContain("card 1: bodyText empty");
+    });
+  });
+
+  describe("Missing image source", () => {
+    it("should detect missing imageSrc for image carousel", () => {
+      const carouselData = [
+        {
+          bodyText: "Card 1 text",
+          imageSrc: "https://example.com/image1.jpg",
+          buttons: [{ isSaved: true }],
+        },
+        {
+          bodyText: "Card 2 text",
+          buttons: [{ isSaved: true }],
+        },
+      ];
+
+      const result = validateCarouselCards(carouselData, "image", {
+        imageConstant: "IMAGE",
+        videoConstant: "VIDEO",
+      });
+
+      expect(result.isValid).toBe(false);
+      expect(result.reasons).toContain("card 2: imageSrc missing");
+    });
+
+    it("should not check imageSrc for video carousel", () => {
+      const carouselData = [
+        {
+          bodyText: "Card 1 text",
+          videoSrc: "https://example.com/video1.mp4",
+          buttons: [{ isSaved: true }],
+        },
+        {
+          bodyText: "Card 2 text",
+          videoSrc: "https://example.com/video2.mp4",
+          buttons: [{ isSaved: true }],
+        },
+      ];
+
+      const result = validateCarouselCards(carouselData, "video", {
+        imageConstant: "IMAGE",
+        videoConstant: "VIDEO",
+      });
+
+      expect(result.isValid).toBe(true);
+      expect(result.reasons).not.toContain(expect.stringContaining("imageSrc"));
+    });
+  });
+
+  describe("Missing video source", () => {
+    it("should detect missing videoSrc for video carousel", () => {
+      const carouselData = [
+        {
+          bodyText: "Card 1 text",
+          videoSrc: "https://example.com/video1.mp4",
+          buttons: [{ isSaved: true }],
+        },
+        {
+          bodyText: "Card 2 text",
+          buttons: [{ isSaved: true }],
+        },
+      ];
+
+      const result = validateCarouselCards(carouselData, "video", {
+        imageConstant: "IMAGE",
+        videoConstant: "VIDEO",
+      });
+
+      expect(result.isValid).toBe(false);
+      expect(result.reasons).toContain("card 2: videoSrc missing");
+    });
+
+    it("should not check videoSrc for image carousel", () => {
+      const carouselData = [
+        {
+          bodyText: "Card 1 text",
+          imageSrc: "https://example.com/image1.jpg",
+          buttons: [{ isSaved: true }],
+        },
+        {
+          bodyText: "Card 2 text",
+          imageSrc: "https://example.com/image2.jpg",
+          buttons: [{ isSaved: true }],
+        },
+      ];
+
+      const result = validateCarouselCards(carouselData, "image", {
+        imageConstant: "IMAGE",
+        videoConstant: "VIDEO",
+      });
+
+      expect(result.isValid).toBe(true);
+      expect(result.reasons).not.toContain(expect.stringContaining("videoSrc"));
+    });
+  });
+
+  describe("Unsaved buttons", () => {
+    it("should detect unsaved buttons", () => {
+      const carouselData = [
+        {
+          bodyText: "Card 1 text",
+          imageSrc: "https://example.com/image1.jpg",
+          buttons: [{ isSaved: false }],
+        },
+        {
+          bodyText: "Card 2 text",
+          imageSrc: "https://example.com/image2.jpg",
+          buttons: [{ isSaved: true }],
+        },
+      ];
+
+      const result = validateCarouselCards(carouselData, "image", {
+        imageConstant: "IMAGE",
+        videoConstant: "VIDEO",
+      });
+
+      expect(result.isValid).toBe(false);
+      expect(result.reasons).toContain("card 1: some buttons not saved");
+    });
+
+    it("should detect when some buttons are saved and some are not", () => {
+      const carouselData = [
+        {
+          bodyText: "Card 1 text",
+          imageSrc: "https://example.com/image1.jpg",
+          buttons: [{ isSaved: true }, { isSaved: false }],
+        },
+      ];
+
+      const result = validateCarouselCards(carouselData, "image", {
+        imageConstant: "IMAGE",
+        videoConstant: "VIDEO",
+      });
+
+      expect(result.isValid).toBe(false);
+      expect(result.reasons).toContain("card 1: some buttons not saved");
+    });
+
+    it("should pass when all buttons are saved", () => {
+      const carouselData = [
+        {
+          bodyText: "Card 1 text",
+          imageSrc: "https://example.com/image1.jpg",
+          buttons: [{ isSaved: true }, { isSaved: true }],
+        },
+      ];
+
+      const result = validateCarouselCards(carouselData, "image", {
+        imageConstant: "IMAGE",
+        videoConstant: "VIDEO",
+      });
+
+      expect(result.isValid).toBe(true);
+      expect(result.reasons).not.toContain(expect.stringContaining("buttons"));
+    });
+  });
+
+  describe("Multiple errors", () => {
+    it("should collect all errors from a single card", () => {
+      const carouselData = [
+        {
+          bodyError: "Error message",
+          imageSrc: "https://example.com/image1.jpg",
+          buttons: [{ isSaved: false }],
+        },
+      ];
+
+      const result = validateCarouselCards(carouselData, "image", {
+        imageConstant: "IMAGE",
+        videoConstant: "VIDEO",
+      });
+
+      expect(result.isValid).toBe(false);
+      expect(result.reasons).toContain("card 1: bodyError=Error message");
+      expect(result.reasons).toContain("card 1: bodyText empty");
+      expect(result.reasons).toContain("card 1: some buttons not saved");
+    });
+
+    it("should collect errors from multiple cards", () => {
+      const carouselData = [
+        {
+          bodyError: "Error 1",
+          imageSrc: "https://example.com/image1.jpg",
+        },
+        {
+          bodyText: "Card 2 text",
+          buttons: [{ isSaved: false }],
+        },
+      ];
+
+      const result = validateCarouselCards(carouselData, "image", {
+        imageConstant: "IMAGE",
+        videoConstant: "VIDEO",
+      });
+
+      expect(result.isValid).toBe(false);
+      expect(result.reasons.length).toBeGreaterThan(1);
+      expect(result.reasons).toContain("card 1: bodyError=Error 1");
+      expect(result.reasons).toContain("card 1: bodyText empty");
+      expect(result.reasons).toContain("card 2: imageSrc missing");
+      expect(result.reasons).toContain("card 2: some buttons not saved");
+    });
+  });
+
+  describe("Case insensitivity", () => {
+    it("should handle uppercase media type", () => {
+      const carouselData = [
+        {
+          bodyText: "Card 1 text",
+          imageSrc: "https://example.com/image1.jpg",
+          buttons: [{ isSaved: true }],
+        },
+      ];
+
+      const result = validateCarouselCards(carouselData, "IMAGE", {
+        imageConstant: "IMAGE",
+        videoConstant: "VIDEO",
+      });
+
+      expect(result.isValid).toBe(true);
+    });
+
+    it("should handle mixed case media type", () => {
+      const carouselData = [
+        {
+          bodyText: "Card 1 text",
+          videoSrc: "https://example.com/video1.mp4",
+          buttons: [{ isSaved: true }],
+        },
+      ];
+
+      const result = validateCarouselCards(carouselData, "ViDeO", {
+        imageConstant: "IMAGE",
+        videoConstant: "VIDEO",
+      });
+
+      expect(result.isValid).toBe(true);
+    });
+  });
+
+  describe("Edge cases", () => {
+    it("should handle empty array", () => {
+      const result = validateCarouselCards([], "image", {
+        imageConstant: "IMAGE",
+        videoConstant: "VIDEO",
+      });
+
+      expect(result.isValid).toBe(true);
+      expect(result.reasons).toEqual([]);
+    });
+
+    it("should handle null carouselData", () => {
+      const result = validateCarouselCards(null, "image", {
+        imageConstant: "IMAGE",
+        videoConstant: "VIDEO",
+      });
+
+      expect(result.isValid).toBe(true);
+      expect(result.reasons).toEqual([]);
+    });
+
+    it("should handle undefined carouselData", () => {
+      const result = validateCarouselCards(undefined, "image", {
+        imageConstant: "IMAGE",
+        videoConstant: "VIDEO",
+      });
+
+      expect(result.isValid).toBe(true);
+      expect(result.reasons).toEqual([]);
+    });
+
+    it("should handle empty media type", () => {
+      const carouselData = [
+        {
+          bodyText: "Card 1 text",
+          imageSrc: "https://example.com/image1.jpg",
+          buttons: [{ isSaved: true }],
+        },
+      ];
+
+      const result = validateCarouselCards(carouselData, "", {
+        imageConstant: "IMAGE",
+        videoConstant: "VIDEO",
+      });
+
+      // Should not check for imageSrc or videoSrc when mediaType is empty
+      expect(result.isValid).toBe(true);
+    });
+
+    it("should use default constants when options are not provided", () => {
+      const carouselData = [
+        {
+          bodyText: "Card 1 text",
+          imageSrc: "https://example.com/image1.jpg",
+          buttons: [{ isSaved: true }],
+        },
+      ];
+
+      const result = validateCarouselCards(carouselData, "image");
+
+      expect(result.isValid).toBe(true);
+    });
+  });
+});