@encatch/web-sdk 0.0.23 → 0.0.24

package/dist-sdk/plugin/sdk/{module-CEWmgbr-.js → module-Dicww8nS.js}

@@ -319,7 +319,7 @@ async function Ee() {
   if (!(te || typeof window > "u" || typeof document > "u")) {
     te = !0;
     try {
-      const { render: t } = await Promise.resolve().then(() => be), e = (await import("./core-wrapper-C-0jtOUK.js")).default;
+      const { render: t } = await Promise.resolve().then(() => be), e = (await import("./core-wrapper-Ga-OMvC7.js")).default;
       if (typeof document > "u") return;
       let n = document.getElementById("enisght-root");
       !n && document.body && (n = document.createElement("div"), n.id = "enisght-root", document.body.appendChild(n)), n && t(/* @__PURE__ */ Se(e, {}), n);

package/dist-sdk/plugin/sdk/module.js

@@ -1,4 +1,4 @@
-import { E as e, e as t } from "./module-CEWmgbr-.js";
+import { E as e, e as t } from "./module-Dicww8nS.js";
 export {
   e as Encatch,
   t as encatch

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@encatch/web-sdk",
-	"version": "0.0.23",
+	"version": "0.0.24",
 	"description": "A powerful, lightweight JavaScript SDK for collecting user feedback and running surveys on web applications",
 	"type": "module",
 	"main": "dist-sdk/plugin/sdk/module.js",

package/src/hooks/useFetchElligibleFeedbackConfiguration.ts

@@ -24,15 +24,27 @@ const filterByFrequencyRules = (
 
   const filtered = feedbacks.filter((fb) => {
     const fbId = fb.feedbackConfigurationId;
+    const isManual = fb.triggerProperties?.isManual === true;
 
     // Check frequency rules
     const tracking = frequencyTracking[fbId];
+
     if (!tracking) {
-      // Never interacted before, always eligible
+      // No tracking data yet
+      if (isManual && fb.frequencyAndScheduling) {
+        // For manual feedbacks without tracking, check date range directly
+        const startDate = new Date(fb.frequencyAndScheduling.startDate).getTime();
+        const stopDate = new Date(fb.frequencyAndScheduling.stopDate).getTime();
+        return currentTime >= startDate && currentTime <= stopDate;
+      }
+      // Never interacted before, always eligible for non-manual
       return true;
     }
 
-    const eligible = isEligibleByFrequency(tracking, currentTime);
+    // Pass isManual flag to eligibility check
+    // Manual feedbacks: Only check date range, bypass all other frequency rules
+    // Non-manual feedbacks: Apply all frequency rules
+    const eligible = isEligibleByFrequency(tracking, currentTime, isManual);
     return eligible;
   });
 
@@ -138,6 +150,7 @@ export const useFetchElligibleFeedbackConfiguration = ({
   const [loading, setLoading] = useState(false);
   const [error, setError] = useState<string | null>(null);
   const [data, setData] = useState<any>(null);
+  const [allFeedbacks, setAllFeedbacks] = useState<FeedbackConfigurationItem[]>([]); // Store all feedbacks including manual
   const [lastFetchParams, setLastFetchParams] =
     useState<FetchConfigurationListRequest | null>(null);
   const lastFetchParamsRef = useRef<FetchConfigurationListRequest | null>(null);
@@ -176,8 +189,15 @@ export const useFetchElligibleFeedbackConfiguration = ({
       ? []
       : config?.feedbackConfiguration || [];
 
+    // Store ALL feedbacks (including manual) for lookup by openFeedbackById/openFeedbackByName
+    setAllFeedbacks(feedbackConfigurations);
+
+    // Include all feedbacks in pending list
+    // Manual feedbacks will respect frequency rules but bypass showOnce
+    const pendingConfigurations = feedbackConfigurations || [];
+
     const storedConfig: StoredConfiguration = {
-      feedbackConfiguration: feedbackConfigurations,
+      feedbackConfiguration: pendingConfigurations,
       expiry,
       feedbackInterval: feedbackIntervalConfig,
       masterProperties: config?.masterProperties,
@@ -190,11 +210,14 @@ export const useFetchElligibleFeedbackConfiguration = ({
       JSON.stringify(storedConfig)
     );
 
-    setPendingFeedbacks(feedbackConfigurations);
+    // Persist all configurations (including manual)
+    setPendingFeedbacks(pendingConfigurations);
 
-    // Initialize tracking for new feedbacks (only once when fetching from API)
-    feedbackConfigurations.forEach((fb) => {
-      if (fb.frequencyAndScheduling) {
+    // Initialize tracking only for non-manual feedbacks
+    // Manual feedbacks don't need tracking as they only check date range
+    pendingConfigurations.forEach((fb) => {
+      const isManual = fb.triggerProperties?.isManual === true;
+      if (fb.frequencyAndScheduling && !isManual) {
         initializeOrUpdateTracking(
           fb.feedbackConfigurationId,
           fb.frequencyAndScheduling as any
@@ -321,6 +344,7 @@ export const useFetchElligibleFeedbackConfiguration = ({
 
   return {
     data,
+    allFeedbacks, // Export all feedbacks including manual ones
     loading,
     error,
     fetchConfiguration,

package/src/utils/duration-utils.ts

@@ -41,10 +41,14 @@ export const convertDurationToMs = (
 
 /**
  * Check if a feedback is eligible based on frequency rules
+ * @param tracking - The frequency tracking data
+ * @param currentTime - Current timestamp in milliseconds
+ * @param isManual - Whether this is a manual feedback (only checks date range, bypasses all other rules)
  */
 export const isEligibleByFrequency = (
   tracking: FeedbackFrequencyTracking,
-  currentTime: number = Date.now()
+  currentTime: number = Date.now(),
+  isManual: boolean = false
 ): boolean => {
   const {
     frequencyConfig,
@@ -53,6 +57,17 @@ export const isEligibleByFrequency = (
     responseCount,
   } = tracking;
 
+  // For manual feedbacks: Only check start/stop dates, bypass all other frequency rules
+  if (isManual) {
+    // Check if within date range
+    const startDate = new Date(frequencyConfig.startDate).getTime();
+    const stopDate = new Date(frequencyConfig.stopDate).getTime();
+
+    return currentTime >= startDate && currentTime <= stopDate;
+  }
+
+  // For non-manual feedbacks: Apply all frequency rules
+
   // Check if response limit reached
   const stopCount = parseInt(frequencyConfig.stopWhenResponsesCount, 10);