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

package/src/store/formResponses.ts

@@ -1,211 +0,0 @@
-import { signal, computed } from "@preact/signals";
-
-import {
-  Answer,
-  CombinedQuestion,
-  QuestionResponse,
-  QuestionType,
-  QuestionTypes,
-} from "@encatch/schema";
-
-// Type for the entire form responses store
-interface FormResponsesStore {
-  questions: QuestionResponse[];
-  questionsData: Record<string, CombinedQuestion>;
-}
-
-// Create the initial store state
-const initialStore: FormResponsesStore = {
-  questions: [],
-  questionsData: {},
-};
-
-// Create signals for the store
-const formResponsesSignal = signal<FormResponsesStore>(initialStore);
-
-// Create a computed property to access the store (similar to Solid's store access)
-const formResponses = computed(() => formResponsesSignal.value);
-
-// Helper function to update the store
-const setFormResponses = (
-  key: keyof FormResponsesStore,
-  updater: any[] | Record<string, any> | ((current: any) => any)
-) => {
-  formResponsesSignal.value = {
-    ...formResponsesSignal.value,
-    [key]:
-      typeof updater === "function"
-        ? updater(formResponsesSignal.value[key])
-        : updater,
-  };
-};
-
-// Helper function to update a question response
-const updateQuestionResponse = (
-  questionId: string,
-  answerValue: any,
-  type: QuestionType,
-  error?: string
-) => {
-  // Check if answer is empty and should be removed instead
-  const isEmpty =
-    answerValue === null ||
-    answerValue === undefined ||
-    answerValue === "" ||
-    (Array.isArray(answerValue) && answerValue.length === 0);
-
-  // If empty and no error, remove the question response instead of updating it
-  if (isEmpty && !error) {
-    removeQuestionResponse(questionId);
-    return;
-  }
-
-  // Transform the answer value into the correct format based on question type
-  let formattedAnswer: Answer;
-
-  switch (type) {
-    case QuestionTypes.RATING:
-      formattedAnswer = { rating: answerValue };
-      break;
-    case QuestionTypes.NPS:
-      formattedAnswer = { nps: answerValue };
-      break;
-    case QuestionTypes.LONG_TEXT:
-      formattedAnswer = { longText: answerValue };
-      break;
-    case QuestionTypes.SHORT_ANSWER:
-      formattedAnswer = { shortAnswer: answerValue };
-      break;
-    case QuestionTypes.SINGLE_CHOICE:
-      formattedAnswer = { singleChoice: answerValue };
-      break;
-    case QuestionTypes.MULTIPLE_CHOICE_MULTIPLE:
-      formattedAnswer = {
-        multipleChoiceMultiple: Array.isArray(answerValue)
-          ? answerValue
-          : [answerValue],
-      };
-      break;
-    case QuestionTypes.NESTED_SELECTION:
-      formattedAnswer = {
-        nestedSelection: Array.isArray(answerValue)
-          ? answerValue
-          : [answerValue],
-      };
-      break;
-    case QuestionTypes.ANNOTATION:
-      formattedAnswer = { annotation: answerValue };
-      break;
-    default:
-      // If we can't determine the type, just use the answer as is (assuming it's already correctly formatted)
-      formattedAnswer = answerValue as Answer;
-  }
-
-  setFormResponses("questions", (questions) => {
-    const existingIndex = questions.findIndex(
-      (q) => q.questionId === questionId
-    );
-
-    if (existingIndex !== -1) {
-      // Update existing response
-      return questions.map((q, index) =>
-        index === existingIndex
-          ? { ...q, answer: formattedAnswer, type, error }
-          : q
-      );
-    } else {
-      // Add new response
-      return [
-        ...questions,
-        { questionId: questionId, answer: formattedAnswer, type, error },
-      ];
-    }
-  });
-
-  // Emit the event after updating the store
-  // surveySDK.emit("question_answered", {
-  //   feedbackId: "your-feedback-id", // <-- Replace with actual feedbackId from context/store
-  //   questionId,
-  //   questionText: getQuestionData(questionId)?.title || "",
-  //   answer: formattedAnswer,
-  //   timestamp: Date.now(),
-  // });
-};
-
-// Helper function to set/clear validation errors for a question
-const setQuestionError = (questionId: string, error?: string) => {
-  const existingQuestion = getQuestionResponse(questionId);
-  if (existingQuestion) {
-    // Update the error for existing question
-    setFormResponses("questions", (questions) =>
-      questions.map((q) => (q.questionId === questionId ? { ...q, error } : q))
-    );
-  } else if (error) {
-    // If there's an error but no existing question response, create one with empty answer
-    // This is useful for required fields that haven't been filled out yet
-    setFormResponses("questions", (questions) => [
-      ...questions,
-      {
-        questionId: questionId,
-        answer: {} as any,
-        type: QuestionTypes.SHORT_ANSWER,
-        error,
-      },
-    ]);
-  }
-};
-
-// Helper function to clear all validation errors in the form
-const clearValidationErrors = () => {
-  setFormResponses("questions", (questions) =>
-    questions.map((q) => ({ ...q, error: undefined }))
-  );
-};
-
-// Helper function to check if there are any validation errors in the form
-const hasValidationErrors = () => {
-  return formResponsesSignal.value.questions.some(
-    (q) => q.error !== undefined && q.error !== null && q.error !== ""
-  );
-};
-
-// Helper function to remove a question response
-const removeQuestionResponse = (questionId: string) => {
-  setFormResponses("questions", (questions) =>
-    questions.filter((q) => q.questionId !== questionId)
-  );
-};
-
-// Helper function to get a question response
-const getQuestionResponse = (questionId: string) => {
-  return formResponsesSignal.value.questions.find(
-    (q) => q.questionId === questionId
-  );
-};
-
-// Helper function to clear all responses
-const clearResponses = () => {
-  setFormResponses("questions", []);
-};
-
-// Function to store questions data
-const storeQuestions = (questions: Record<string, CombinedQuestion>) => {
-  setFormResponses("questionsData", questions);
-};
-
-const getQuestionData = (questionId: string): CombinedQuestion | undefined => {
-  return formResponsesSignal.value.questionsData[questionId];
-};
-
-export {
-  formResponses,
-  updateQuestionResponse,
-  getQuestionResponse,
-  removeQuestionResponse,
-  setQuestionError,
-  hasValidationErrors,
-  clearValidationErrors,
-  clearResponses,
-  storeQuestions,
-  getQuestionData,
-};

package/src/utils/browser-details.ts

@@ -1,36 +0,0 @@
-
-//import DeviceDetector from "device-detector-js";
-import { DeviceInfo } from "@encatch/schema";
-import { UAParser } from "ua-parser-js";
-
-export const getDeviceInfo = (userAgent: string, deviceId: string): DeviceInfo => {
-    const { browser, device, os } = UAParser(userAgent);
-    const resolvedDeviceType =
-    device?.type ||
-    (os?.name?.toLowerCase().includes("windows") ||
-    os?.name?.toLowerCase().includes("mac") ||
-    os?.name?.toLowerCase().includes("linux")
-      ? "desktop"
-      : "Unknown");
-
-    const isDarkMode = window.matchMedia('(prefers-color-scheme: dark)').matches;
-    const theme = isDarkMode ? "dark" : "light";
-
-  // console.log((new UAParser(userAgent)).getResult());
-  return {
-    $deviceType: resolvedDeviceType,
-    $timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
-    $theme: theme || "system", // This would need to be determined separately
-    $os: os?.name || "Unknown",
-    $osVersion: os?.version || "Unknown",
-    $appVersion: browser?.version || "Unknown", // This would need to be provided from app context
-    $app: browser?.name || "Unknown", // This would need to be provided from app context
-    $language: typeof navigator !== "undefined" ? navigator.language : "Unknown",
-    $deviceId: deviceId,
-  };
-};
-
-// Helper Function to Generate a UUID
-export function generateUUID(): string {
-  return crypto.randomUUID();
-}

package/src/utils/duration-utils.ts

@@ -1,158 +0,0 @@
-/**
- * Utility functions for duration calculations and frequency eligibility
- */
-
-import { FeedbackFrequencyTracking } from "./feedback-frequency-storage";
-
-/**
- * Convert duration value and unit to milliseconds
- */
-export const convertDurationToMs = (
-  value: string | number,
-  unit: "minutes" | "hours" | "days" | "weeks" | "months" | "years"
-): number => {
-  const numValue = typeof value === "string" ? parseInt(value, 10) : value;
-
-  if (isNaN(numValue) || numValue < 0) {
-    console.warn(
-      `Invalid duration value: ${value}. Defaulting to 0 milliseconds.`
-    );
-    return 0;
-  }
-
-  switch (unit) {
-    case "minutes":
-      return numValue * 60 * 1000;
-    case "hours":
-      return numValue * 60 * 60 * 1000;
-    case "days":
-      return numValue * 24 * 60 * 60 * 1000;
-    case "weeks":
-      return numValue * 7 * 24 * 60 * 60 * 1000;
-    case "months":
-      return numValue * 30 * 24 * 60 * 60 * 1000; // Approximate
-    case "years":
-      return numValue * 365 * 24 * 60 * 60 * 1000; // Approximate
-    default:
-      console.error(`Unknown duration unit: ${unit}. Defaulting to 0.`);
-      return 0;
-  }
-};
-
-/**
- * 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(),
-  isManual: boolean = false
-): boolean => {
-  const {
-    frequencyConfig,
-    lastSubmittedAt,
-    lastDismissedAt,
-    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);
-
-  if (stopCount > 0 && responseCount >= stopCount) {
-    return false;
-  }
-
-  // For non-recurring types (S = one-time), check if already submitted
-  if (frequencyConfig.surveyType !== "R") {
-    const eligible = responseCount === 0;
-    return eligible;
-  }
-
-  // For recurring type "R"
-  const durationMs = convertDurationToMs(
-    frequencyConfig.recurringValue,
-    frequencyConfig.recurringUnit
-  );
-
-  // Determine which timestamp to use based on showOnce
-  let referenceTime: number | null = null;
-
-  if (frequencyConfig.showOnce === "Y") {
-    // Use the most recent of submitted or dismissed
-    const maxTime = Math.max(lastSubmittedAt || 0, lastDismissedAt || 0);
-    referenceTime = maxTime > 0 ? maxTime : null;
-  } else {
-    // Only use submission time
-    referenceTime = lastSubmittedAt;
-  }
-
-  // If never interacted (or only dismissed when showOnce=N), it's eligible
-  if (referenceTime === null) {
-    return true;
-  }
-
-  // Check if enough time has passed
-  const nextEligibleTime = referenceTime + durationMs;
-  const eligible = currentTime >= nextEligibleTime;
-
-  return eligible;
-};
-
-/**
- * Calculate the next eligible time for a feedback
- * Returns null if already eligible or never interacted
- */
-export const getNextEligibleTime = (
-  tracking: FeedbackFrequencyTracking
-): Date | null => {
-  const {
-    frequencyConfig,
-    lastSubmittedAt,
-    lastDismissedAt,
-    responseCount,
-  } = tracking;
-
-  // If response limit reached, never eligible again
-  const stopCount = parseInt(frequencyConfig.stopWhenResponsesCount, 10);
-  if (stopCount > 0 && responseCount >= stopCount) {
-    return null;
-  }
-
-  // For non-recurring, if already submitted, never eligible again
-  if (frequencyConfig.surveyType !== "R" && responseCount > 0) {
-    return null;
-  }
-
-  // If never interacted, eligible now
-  let referenceTime: number | null = null;
-  if (frequencyConfig.showOnce === "Y") {
-    const maxTime = Math.max(lastSubmittedAt || 0, lastDismissedAt || 0);
-    referenceTime = maxTime > 0 ? maxTime : null;
-  } else {
-    referenceTime = lastSubmittedAt;
-  }
-
-  if (referenceTime === null) {
-    return null; // Already eligible
-  }
-
-  const durationMs = convertDurationToMs(
-    frequencyConfig.recurringValue,
-    frequencyConfig.recurringUnit
-  );
-
-  return new Date(referenceTime + durationMs);
-};

package/src/utils/feedback-frequency-storage.ts

@@ -1,214 +0,0 @@
-/**
- * Storage utilities for tracking feedback frequency and eligibility
- * Uses localStorage for persistence across sessions
- */
-
-/**
- * Feedback frequency tracking data
- * Matches the actual schema structure from @encatch/schema
- */
-export interface FeedbackFrequencyTracking {
-  feedbackConfigurationId: string;
-  lastSubmittedAt: number | null; // timestamp in ms
-  lastDismissedAt: number | null; // timestamp when viewed but not submitted
-  responseCount: number; // total number of submissions
-  frequencyConfig: {
-    surveyType: "R" | "S"; // "R" = recurring, "S" = one-time
-    recurringValue: string; // e.g., "15"
-    recurringUnit: "minutes" | "hours" | "days" | "weeks" | "months" | "years";
-    showOnce: "Y" | "N"; // "Y" = show once after dismissed/submitted, "N" = can show again
-    stopWhenResponsesCount: number; // e.g., "5" or "0" for unlimited
-    startDate: string; // ISO date string
-    stopDate: string; // ISO date string
-  };
-  lastUpdated: number; // timestamp of last update
-}
-
-/**
- * Storage key for frequency tracking 
- */
-const FREQUENCY_TRACKING_KEY = "encatch_frequency_tracking";
-
-/**
- * Get all frequency tracking data from localStorage
- */
-export const getFrequencyTracking = (): Record<
-  string,
-  FeedbackFrequencyTracking
-> => {
-  try {
-    const stored = localStorage.getItem(FREQUENCY_TRACKING_KEY);
-    if (!stored) return {};
-
-    const parsed = JSON.parse(stored);
-    return parsed;
-  } catch (error) {
-    console.error("[Frequency Storage] Error reading tracking data:", error);
-    return {};
-  }
-};
-
-/**
- * Get frequency tracking for a specific feedback
- */
-export const getFrequencyTrackingById = (
-  feedbackConfigurationId: string
-): FeedbackFrequencyTracking | null => {
-  const allTracking = getFrequencyTracking();
-  return allTracking[feedbackConfigurationId] || null;
-};
-
-/**
- * Update frequency tracking for a feedback
- * @param tracking - The tracking data to update
- */
-export const updateFrequencyTracking = (
-  tracking: FeedbackFrequencyTracking
-): void => {
-  try {
-    const allTracking = getFrequencyTracking();
-    tracking.lastUpdated = Date.now();
-    allTracking[tracking.feedbackConfigurationId] = tracking;
-    localStorage.setItem(
-      FREQUENCY_TRACKING_KEY,
-      JSON.stringify(allTracking)
-    );
-  } catch (error) {
-    console.error("[Frequency Storage] Error updating tracking:", error);
-  }
-};
-
-/**
- * Record a feedback submission
- */
-export const recordFeedbackSubmission = (
-  feedbackConfigurationId: string,
-  frequencyConfig: FeedbackFrequencyTracking["frequencyConfig"]
-): void => {
-  const existing = getFrequencyTrackingById(feedbackConfigurationId);
-
-  const newTracking: FeedbackFrequencyTracking = {
-    feedbackConfigurationId,
-    lastSubmittedAt: Date.now(),
-    lastDismissedAt: existing?.lastDismissedAt || null, // Preserve dismissed time
-    responseCount: (existing?.responseCount || 0) + 1,
-    frequencyConfig,
-    lastUpdated: Date.now(),
-  };
-
-  updateFrequencyTracking(newTracking);
-};
-
-/**
- * Record a feedback dismissal (viewed but not submitted)
- */
-export const recordFeedbackDismissal = (
-  feedbackConfigurationId: string,
-  frequencyConfig: FeedbackFrequencyTracking["frequencyConfig"]
-): void => {
-  // Only record dismissal if showOnce is "Y"
-  if (frequencyConfig.showOnce !== "Y") {
-    return;
-  }
-
-  const existing = getFrequencyTrackingById(feedbackConfigurationId);
-
-  const newTracking: FeedbackFrequencyTracking = {
-    feedbackConfigurationId,
-    lastSubmittedAt: existing?.lastSubmittedAt || null,
-    lastDismissedAt: Date.now(),
-    responseCount: existing?.responseCount || 0,
-    frequencyConfig,
-    lastUpdated: Date.now(),
-  };
-
-  updateFrequencyTracking(newTracking);
-};
-
-/**
- * Initialize or update tracking with latest config from server
- * This ensures we always have the latest frequency rules
- */
-export const initializeOrUpdateTracking = (
-  feedbackConfigurationId: string,
-  frequencyConfig: FeedbackFrequencyTracking["frequencyConfig"]
-): void => {
-  const existing = getFrequencyTrackingById(feedbackConfigurationId);
-
-  if (existing) {
-    // Update existing tracking with latest config
-    existing.frequencyConfig = frequencyConfig;
-    updateFrequencyTracking(existing);
-  } else {
-    // Initialize new tracking
-    const newTracking: FeedbackFrequencyTracking = {
-      feedbackConfigurationId,
-      lastSubmittedAt: null,
-      lastDismissedAt: null,
-      responseCount: 0,
-      frequencyConfig,
-      lastUpdated: Date.now(),
-    };
-    updateFrequencyTracking(newTracking);
-  }
-};
-
-/**
- * Clear frequency tracking for a specific feedback
- */
-export const clearFrequencyTrackingById = (
-  feedbackConfigurationId: string
-): void => {
-  try {
-    const allTracking = getFrequencyTracking();
-    delete allTracking[feedbackConfigurationId];
-    localStorage.setItem(
-      FREQUENCY_TRACKING_KEY,
-      JSON.stringify(allTracking)
-    );
-  } catch (error) {
-    console.error(
-      "[Frequency Storage] Error clearing tracking by ID:",
-      error
-    );
-  }
-};
-
-/**
- * Clear all frequency tracking data
- */
-export const clearAllFrequencyTracking = (): void => {
-  try {
-    localStorage.removeItem(FREQUENCY_TRACKING_KEY);
-  } catch (error) {
-    console.error("[Frequency Storage] Error clearing all tracking:", error);
-  }
-};
-
-/**
- * Get statistics about tracked feedbacks
- */
-export const getFrequencyTrackingStats = (): {
-  totalTracked: number;
-  totalSubmissions: number;
-  feedbacksWithResponses: number;
-  feedbacksAtLimit: number;
-} => {
-  const allTracking = getFrequencyTracking();
-  const trackingArray = Object.values(allTracking);
-
-  return {
-    totalTracked: trackingArray.length,
-    totalSubmissions: trackingArray.reduce(
-      (sum, t) => sum + t.responseCount,
-      0
-    ),
-    feedbacksWithResponses: trackingArray.filter((t) => t.responseCount > 0)
-      .length,
-    feedbacksAtLimit: trackingArray.filter(
-      (t) =>
-        t.frequencyConfig.stopWhenResponsesCount > 0 &&
-        t.responseCount >= t.frequencyConfig.stopWhenResponsesCount
-    ).length,
-  };
-};