@encatch/web-sdk 0.0.35 → 1.0.0-beta.0

package/src/feedback-api-types.ts

@@ -1,18 +0,0 @@
-import { Answer } from "@encatch/schema";
-
-interface Duration {
-  from: string;
-  to: string;
-}
-
-interface TriggerProperties {
-  screens: string[];
-}
-
-interface PrepopulatedAnswer {
-  sectionIndex: number;
-  questionIndex: number;
-  value: Answer;
-}
-
-export type {  Duration, TriggerProperties,PrepopulatedAnswer };

package/src/hooks/useDevice.ts

@@ -1,30 +0,0 @@
-import { generateUUID, getDeviceInfo } from "../utils/browser-details";
-import { DeviceInfo } from "@encatch/schema";
-import { useState, useEffect } from "preact/hooks";
-
-const DEVICE_STORAGE_KEY = "app_device";
-
-export const useDevice = () => {
-  const [deviceId, setDeviceId] = useState<string | null>(null);
-  const [deviceInfo, setDeviceInfo] = useState<DeviceInfo | null>(null);
-
-  useEffect(() => {
-    const storedId = localStorage.getItem(DEVICE_STORAGE_KEY);
-    let currentDeviceId: string;
-
-    if (storedId) {
-      setDeviceId(storedId);
-      currentDeviceId = storedId;
-    } else {
-      const newId = generateUUID();
-      localStorage.setItem(DEVICE_STORAGE_KEY, newId);
-      setDeviceId(newId);
-      currentDeviceId = newId;
-    }
-    const userAgent = navigator.userAgent;
-    const deviceInfo = getDeviceInfo(userAgent, currentDeviceId);
-    setDeviceInfo(deviceInfo);
-  }, []);
-
-  return { deviceId, deviceInfo };
-};

package/src/hooks/useFeedbackInterval.ts

@@ -1,71 +0,0 @@
-import { useState, useEffect } from "preact/hooks";
-
-const FEEDBACK_VISIBLE_KEY = "encatch_feedback_visible";
-const FEEDBACK_INTERVAL_KEY = "encatch_feedback_interval";
-
-export const useFeedbackInterval = () => {
-  const [feedbackInterval, setFeedbackInterval] = useState<number>(0);
-  const [isFeedbackVisible, setIsFeedbackVisible] = useState<boolean>(false);
-  const [lastVisibleTime, setLastVisibleTime] = useState<number | null>(null);
-
-  const canShowFeedbackModal = () => {
-    const currentInterval = feedbackInterval;
-    const lastVisible = lastVisibleTime;
-
-    if (!lastVisible || !currentInterval) {
-      return true;
-    }
-
-    const timeSinceLastVisible = Date.now() - lastVisible;
-    const canShow = timeSinceLastVisible >= currentInterval;
-
-    return canShow;
-  };
-
-  const setFeedbackVisible = (visible: boolean) => {
-    setIsFeedbackVisible(visible);
-    if (visible) {
-      const timestamp = Date.now();
-      setLastVisibleTime(timestamp);
-      localStorage.setItem(FEEDBACK_VISIBLE_KEY, timestamp.toString());
-    } else {
-      setLastVisibleTime(null);
-      localStorage.removeItem(FEEDBACK_VISIBLE_KEY);
-    }
-  };
-
-  const updateFeedbackInterval = (interval: number) => {
-    // Convert minutes to milliseconds (interval * 60 * 1000)
-    const intervalInMs = interval * 60 * 1000;
-    setFeedbackInterval(intervalInMs);
-    localStorage.setItem(FEEDBACK_INTERVAL_KEY, intervalInMs.toString());
-  };
-
-  useEffect(() => {
-    // Load stored interval
-    const storedInterval = localStorage.getItem(FEEDBACK_INTERVAL_KEY);
-    if (storedInterval) {
-      const interval = parseInt(storedInterval);
-      const intervalInMs = interval * 60 * 1000;
-      setFeedbackInterval(intervalInMs);
-    }
-
-    // Check if feedback was recently shown
-    const storedLastVisible = localStorage.getItem(FEEDBACK_VISIBLE_KEY);
-    if (storedLastVisible) {
-      const timestamp = parseInt(storedLastVisible);
-      setLastVisibleTime(timestamp);
-      const timeSinceLastVisible = Date.now() - timestamp;
-      const currentInterval = feedbackInterval;
-      const isVisible = timeSinceLastVisible < currentInterval;
-      setIsFeedbackVisible(isVisible);
-    }
-  }, []);
-
-  return {
-    canShowFeedbackModal,
-    setFeedbackVisible,
-    setFeedbackInterval: updateFeedbackInterval,
-    isFeedbackVisible
-  };
-};

package/src/hooks/useFeedbackTriggers.ts

@@ -1,342 +0,0 @@
-import { useState, useRef, useCallback } from "preact/hooks";
-import {
-  TriggerProperties as BaseTriggerProperties,
-} from "../feedback-api-types";
-
-import jsonLogic from "json-logic-js";
-import { match as pathMatch } from "path-to-regexp";
-import { FeedbackConfigurationItem, QueryOutput, TriggerAction } from "@encatch/schema";
-
-jsonLogic.add_operation("startsWith", (a: any, b: any) => {
-  if (typeof a !== "string" || typeof b !== "string") return false;
-  return a.startsWith(b);
-});
-
-jsonLogic.add_operation("regex", (a: any, b: any) => {
-  if (typeof a !== "string" || typeof b !== "string") {
-    return true;
-  }
-  return matchesDynamicRoute(a, b);
-});
-function matchesDynamicRoute(inputPath: string, routePattern: string): boolean {
-  try {
-    const matcher = pathMatch(routePattern, { decode: decodeURIComponent });
-    const result = matcher(inputPath);
-    return !!result;
-  } catch (error) {
-    console.error("[swat] pathMatch error", { inputPath, routePattern, error });
-    return false;
-  }
-}
-type TriggerConfig = {
-  feedbackConfigurationId: string;
-  eventName: string;
-  jsonLogicField: any;
-  thenAction: any;
-  isImportant: boolean;
-};
-
-type WhenCondition = {
-  if: {
-    id: string;
-    event: string;
-    queryOutput: QueryOutput;
-  };
-  then: TriggerAction;
-};
-
-type Segment = {
-  when: WhenCondition[];
-  isImportant?: boolean;
-};
-
-interface ExtendedTriggerProperties extends BaseTriggerProperties {
-  isAuto: boolean;
-  segments: Segment[];
-}
-
-type QueuedEvent = {
-  eventName: string;
-  properties?: Record<string, any>;
-};
-
-export const useFeedbackTriggers = (
-  onTriggerMatch?: (configId: string, event: string) => void
-) => {
-
-  const [pageLoadTriggers, setPageLoadTriggers] = useState<TriggerConfig[] | null>(null);
-  const [feedbackConfig, setFeedbackConfig] = useState<FeedbackConfigurationItem[] | null>(null);
-  const [customEventTriggers, setCustomEventTriggers] = useState<TriggerConfig[] | null>(null);
-  const [eventQueue, setEventQueue] = useState<QueuedEvent[]>([]);
-  const [canShowFeedbackModal, setCanShowFeedbackModal] = useState(false);
-
-  const [activeFeedbackConfig, setActiveFeedbackConfig] = useState<{
-    configId: string;
-    isImportant: boolean;
-    eventName: string;
-  } | null>(null);
-
-  const currentTimeoutIdRef = useRef<number | null>(null);
-
-  // Store triggers in refs to avoid stale closure issues
-  const pageLoadTriggersRef = useRef<TriggerConfig[] | null>(null);
-  const customEventTriggersRef = useRef<TriggerConfig[] | null>(null);
-
-  const showFeedbackByConfigId = (configId: string, event: string) => {
-    if (onTriggerMatch) {
-      onTriggerMatch(configId, event);
-    }
-  };
-
-   /**
-   * Exposes a function to manually trigger feedback modal based on scroll percentage.
-   * Instead of calculating scroll, uses the scroll value from WhenCondition.
-   * When the scroll percentage matches or exceeds, displays the modal.
-   */
- const triggeredFeedbacksRef = useRef(new Set<string>());
-
- const capturePageScrollEvent = useCallback((scrollPercent: string) => {
-  let percentNum: number;
-
-  if (typeof scrollPercent === 'string') {
-    percentNum = parseFloat(scrollPercent.replace('%', ''));
-  } else {
-    percentNum = scrollPercent;
-  }
-
-  const configs = feedbackConfig || [];
-
-  for (const config of configs) {
-    if (triggeredFeedbacksRef.current.has(config.feedbackConfigurationId)) continue;
-
-    if (config.triggerProperties) {
-      const triggerProps = config.triggerProperties ;
-      for (const segment of triggerProps.segments) {
-        for (const whenItem of segment.when) {
-          let scrollValue = 0;
-          if (typeof whenItem.then.scroll === 'string') {
-            scrollValue = parseFloat(whenItem.then.scroll.replace('%', ''));
-          } else {
-            scrollValue = Number(whenItem.then.scroll);
-          }
-
-          if (
-            whenItem.then.triggerType === "scroll" &&
-            !isNaN(scrollValue) &&
-            percentNum >= scrollValue
-          ) {
-            triggeredFeedbacksRef.current.add(config.feedbackConfigurationId);
-            onTriggerMatch?.(config.feedbackConfigurationId, whenItem.if.event);
-            return;
-          }
-        }
-      }
-    }
-  }
-}, [feedbackConfig, onTriggerMatch]);
-
-  const updateFeedbackConfigRef = useRef<(configs: FeedbackConfigurationItem[]) => void>();
-
-  updateFeedbackConfigRef.current = (configs: FeedbackConfigurationItem[]) => {
-    const pageLoadTriggersList: TriggerConfig[] = [];
-    const customEventTriggersList: TriggerConfig[] = [];
-
-    configs.forEach((config) => {
-      if (config.triggerProperties) {
-        const triggerProps =
-          config.triggerProperties as unknown as ExtendedTriggerProperties;
-        const { isAuto, segments } = triggerProps;
-
-        if (isAuto && segments) {
-          segments.forEach((seg: Segment) => {
-            if (seg.when) {
-              seg.when.forEach((whenItem: WhenCondition) => {
-                if (whenItem.if) {
-                  const { event, queryOutput } = whenItem.if;
-                  let jsonLogicField: any = queryOutput.jsonLogic;
-
-                  // Parse jsonLogic if it's a string
-                  if (typeof jsonLogicField === "string") {
-                    if (jsonLogicField.trim() === "") {
-                      console.warn("Empty jsonLogic string received");
-                      jsonLogicField = null;
-                    } else {
-                      try {
-                        jsonLogicField = JSON.parse(jsonLogicField);
-                      } catch (e) {
-                        console.warn("Failed to parse jsonLogic string:", jsonLogicField, e);
-                        jsonLogicField = null;
-                      }
-                    }
-                  }
-
-                  // Skip if jsonLogic is null, undefined, or an empty object
-                  if (!jsonLogicField || (typeof jsonLogicField === 'object' && Object.keys(jsonLogicField).length === 0)) {
-                    return;
-                  }
-
-                  const triggerConfig: TriggerConfig = {
-                    feedbackConfigurationId: config.feedbackConfigurationId,
-                    eventName: event,
-                    jsonLogicField,
-                    thenAction: whenItem.then,
-                    isImportant: seg.isImportant ?? false,
-                  };
-
-                  if (event === "pageLoad") {
-                    pageLoadTriggersList.push(triggerConfig);
-                  } else {
-                    customEventTriggersList.push(triggerConfig);
-                  }
-                }
-              });
-            }
-          });
-        }
-      }
-    });
-
-    // Update refs immediately so processTrigger can access fresh values
-    pageLoadTriggersRef.current = pageLoadTriggersList;
-    customEventTriggersRef.current = customEventTriggersList;
-
-    setPageLoadTriggers(pageLoadTriggersList);
-    setCustomEventTriggers(customEventTriggersList);
-    setFeedbackConfig(configs);
-
-    // Process any queued events now that we have the configuration
-    const queue = eventQueue;
-    if (queue.length > 0) {
-      queue.forEach(event => {
-        processTriggerRef.current?.(event.eventName, event.properties);
-      });
-      setEventQueue([]); // Clear the queue after processing
-    }
-  };
-
-  const processTriggerRef = useRef<(eventName: string, properties?: Record<string, any>) => void>();
-
-  processTriggerRef.current = (
-    eventName: string,
-    properties?: Record<string, any>
-  ) => {
-    let identifiedTrigger: TriggerConfig | undefined;
-
-    if (eventName === "pageLoad") {
-      const pageTriggers = pageLoadTriggersRef.current;
-      if (pageTriggers) {
-        identifiedTrigger = pageTriggers.find((trigger) => {
-          let jsonLogicResult = false;
-          try {
-            const props = properties || {};
-            jsonLogicResult = jsonLogic.apply(trigger.jsonLogicField, props);
-          } catch (e) {
-            console.error('[swat] Error applying jsonLogic for pageLoad trigger:', {
-              configId: trigger.feedbackConfigurationId,
-              jsonLogicField: trigger.jsonLogicField,
-              error: e
-            });
-            jsonLogicResult = false;
-          }
-          const match = trigger.eventName === eventName && jsonLogicResult;
-          return match;
-        });
-      }
-    } else {
-      const customTriggers = customEventTriggersRef.current;
-      if (customTriggers) {
-        identifiedTrigger = customTriggers.find((trigger) => {
-          const eventMatches = trigger.eventName === eventName;
-          let jsonLogicResult = false;
-          try {
-            jsonLogicResult = jsonLogic.apply(trigger.jsonLogicField, properties || {});
-          } catch (e) {
-            console.error('[swat] Error applying jsonLogic for custom event trigger:', {
-              configId: trigger.feedbackConfigurationId,
-              eventName: trigger.eventName,
-              jsonLogicField: trigger.jsonLogicField,
-              error: e
-            });
-            jsonLogicResult = false;
-          }
-          const match = eventMatches && jsonLogicResult;
-          return match;
-        });
-      }
-    }
-
-    if (identifiedTrigger) {
-      // Allow delay triggers to bypass modal restrictions, but block other non-important triggers
-      const isDelayTrigger = identifiedTrigger.thenAction.triggerType === "delay";
-      if (!identifiedTrigger.isImportant && !canShowFeedbackModal && !isDelayTrigger) {
-        return;
-      }
-
-      const { triggerType, delay, scroll } = identifiedTrigger.thenAction;
-      if (activeFeedbackConfig && activeFeedbackConfig?.isImportant && identifiedTrigger.isImportant) {
-        setActiveFeedbackConfig({
-          configId: identifiedTrigger.feedbackConfigurationId,
-          isImportant: identifiedTrigger.isImportant,
-          eventName: identifiedTrigger.eventName
-        });
-      } else if (
-        activeFeedbackConfig &&
-        activeFeedbackConfig?.isImportant &&
-        !identifiedTrigger.isImportant
-      ) {
-        return;
-      }
-
-      if (currentTimeoutIdRef.current !== null) {
-        clearTimeout(currentTimeoutIdRef.current);
-        currentTimeoutIdRef.current = null;
-      }
-
-      if (triggerType === "immediately") {
-        showFeedbackByConfigId(identifiedTrigger.feedbackConfigurationId, identifiedTrigger.eventName);
-        setActiveFeedbackConfig(null);
-      } else if (triggerType === "delay") {
-        const delayInMs = delay * 1000; // Convert seconds to milliseconds
-        setActiveFeedbackConfig({
-          configId: identifiedTrigger.feedbackConfigurationId,
-          isImportant: identifiedTrigger.isImportant,
-          eventName: identifiedTrigger.eventName
-        });
-        currentTimeoutIdRef.current = window.setTimeout(() => {
-          showFeedbackByConfigId(identifiedTrigger.feedbackConfigurationId, identifiedTrigger.eventName);
-          setActiveFeedbackConfig(null);
-          currentTimeoutIdRef.current = null;
-        }, delayInMs);
-      }
-    }
-  };
-
-  const invokeTrigger = (
-    eventName: string,
-    properties?: Record<string, any>,
-    canShowFeedbackModal?: boolean
-  ) => {
-    setCanShowFeedbackModal(canShowFeedbackModal ?? true);
-
-    // If feedback configuration is not loaded yet, queue the event
-    if (!feedbackConfig) {
-      setEventQueue([...eventQueue, { eventName, properties }]);
-      return;
-    }
-
-    // If configuration is loaded, process the trigger
-    processTriggerRef.current?.(eventName, properties);
-  };
-
-  const updateFeedbackConfig = (configs: FeedbackConfigurationItem[]) => {
-    updateFeedbackConfigRef.current?.(configs);
-  };
-
-  return {
-    updateFeedbackConfig,
-    invokeTrigger,
-    pageLoadTriggers,
-    customEventTriggers,
-    capturePageScrollEvent,
-  };
-};