@embedreach/components 0.3.26 → 0.3.27

package/dist/chunks/sandbox-loading-screen.js

@@ -20760,6 +20760,7 @@ const createPartnerLocationsFactory = (platformConfig, businessId, platformId, c
     phone: f.phone.number(),
     email: f.internet.email(),
     website: `https://${platformConfig.name.toLowerCase().replace(/\s+/g, "-")}.com`,
+    googleBusinessProfilePlaceId: null,
     businessId,
     platformId,
     createdAt: f.date.past(),
@@ -20835,6 +20836,7 @@ const createReputationConfigFactory = (platformConfig, businessId, partnerLocati
     id: f.string.uuid(),
     businessId,
     locationMappings,
+    // Backend provides this by reading from partner locations
     emailChannelSenderId: null,
     // Will be set when user configures
     smsChannelSenderId: null,
@@ -21432,11 +21434,7 @@ const createWebPresenceContentFactory = (platformConfig, businessConfig) => {
 const createSandboxMeasureAndAcquireData = (platformId, businessId) => {
   const platformConfigKey = getPlatformConfigKey(platformId);
   const platformConfig = {
-    id: platformConfigKey,
-    name: platformConfigKey === "goose" ? "ACME Pet Spa" : platformConfigKey === "renterra" ? "Tomers Rentals" : "Default",
-    brandColors: [],
-    locationNames: [],
-    locationAreas: []
+    id: platformConfigKey
   };
   const businessConfig = getBusinessConfig(platformId);
   const businessesMe = createBusinessDataFactory(
@@ -21703,7 +21701,7 @@ const native = {
   randomUUID
 };
 function v4(options, buf, offset) {
-  if (native.randomUUID && !buf && !options) {
+  if (native.randomUUID && true && !options) {
     return native.randomUUID();
   }
   options = options || {};
@@ -22162,7 +22160,7 @@ const measureAndAcquireHandlers = [
             locations: []
           }
         },
-        tracking_template: "{lpurl}?gclid={gclid}&er_campaign_id={campaignid}&utm_source=google&campaignid={campaignid}&adgroupid={adgroupid}&random={random}",
+        tracking_template: "{lpurl}?gclid={gclid}&er_campaign_id={campaignid}&utm_source=google&campaignid={campaignid}&adgroupid={adgroupid}&keyword={keyword}&random={random}",
         reach_managed: true,
         created_at: now,
         updated_at: now
@@ -22801,7 +22799,7 @@ const generateReviewAnalyticsData = ({
   const platformConfig = getPlatformConfig(
     platformData.businessesMe?.platform_id
   );
-  const isAllTimeQuery = !queryParams.start_date || !queryParams.end_date;
+  const isAllTimeQuery = !queryParams.start_date || !queryParams.end_date || queryParams.start_date && queryParams.start_date.startsWith("2020-");
   let scalingFactor = 1;
   if (!isAllTimeQuery) {
     const { requestedDays } = parseDateRange(
@@ -22816,14 +22814,15 @@ const generateReviewAnalyticsData = ({
     platformConfig,
     scalingFactor,
     false,
-    isAllTimeQuery
+    isAllTimeQuery || false
   );
-  if (queryParams.include_comparison) {
+  const includeComparison = Boolean(queryParams.include_comparison);
+  if (includeComparison) {
     const previousPeriodData = generateReviewPeriodData(
       platformConfig,
       scalingFactor,
       true,
-      isAllTimeQuery
+      isAllTimeQuery || false
     );
     const comparison = calculateReviewComparison(
       currentPeriodData,
@@ -22846,13 +22845,14 @@ const generateReviewAnalyticsData = ({
   return basicResponse;
 };
 function generateReviewPeriodData(platformConfig, scalingFactor, isPrevious = false, isAllTime = false) {
-  const baseMetrics = isAllTime ? getAllTimePlatformReviewMetrics(platformConfig) : getBasePlatformReviewMetrics(platformConfig);
+  const baseMetrics = isAllTime ? getAllTimePlatformReviewMetrics(platformConfig) : getBasePlatformReviewMetrics$1(platformConfig);
   const scaledTotalCount = isAllTime ? baseMetrics.totalCount : Math.max(1, Math.round(baseMetrics.totalCount * scalingFactor));
-  const performanceMultiplier = isPrevious ? f.number.float({ min: 0.85, max: 0.95 }) : 1;
+  const performanceMultiplier = isPrevious ? 0.9 : 1;
   const adjustedTotalCount = Math.round(
     scaledTotalCount * performanceMultiplier
   );
-  const adjustedAverageRating = baseMetrics.averageRating * performanceMultiplier;
+  const ratingDelta = isPrevious ? -0.2 : 0;
+  const adjustedAverageRating = baseMetrics.averageRating + ratingDelta;
   const ratingDistribution = generateRatingDistribution(
     adjustedTotalCount,
     adjustedAverageRating
@@ -22863,21 +22863,22 @@ function generateReviewPeriodData(platformConfig, scalingFactor, isPrevious = fa
     ratingDistribution
   };
 }
-function getBasePlatformReviewMetrics(platformConfig) {
+function getBasePlatformReviewMetrics$1(platformConfig) {
   const industryMultipliers = {
     // Pet spa industry (Goose) - high customer satisfaction
     "ACME Pet Spa": {
-      totalCount: 45,
+      totalCount: 8,
+      // Much lower - reviews are rare compared to emails
       averageRating: 4.6
     },
     // Equipment rental (Renterra) - moderate review volume
     "Tomer's Rentals": {
-      totalCount: 28,
+      totalCount: 5,
       averageRating: 4.2
     },
     // Default platform
     default: {
-      totalCount: 35,
+      totalCount: 6,
       averageRating: 4.3
     }
   };
@@ -22888,19 +22889,19 @@ function getAllTimePlatformReviewMetrics(platformConfig) {
   const industryMultipliers = {
     // Pet spa industry (Goose) - high customer satisfaction
     "ACME Pet Spa": {
-      totalCount: 342,
-      // Much higher for all-time
+      totalCount: 124,
+      // Much lower - reviews are rare compared to emails
       averageRating: 4.3
       // Slightly lower all-time average
     },
     // Equipment rental (Renterra) - moderate review volume
     "Tomer's Rentals": {
-      totalCount: 189,
+      totalCount: 78,
       averageRating: 4.1
     },
     // Default platform
     default: {
-      totalCount: 267,
+      totalCount: 95,
       averageRating: 4.2
     }
   };
@@ -23018,58 +23019,89 @@ const generateFeedbackAnalyticsData = ({
     averageRating: currentPeriodData.averageRating,
     responseRate: currentPeriodData.responseRate,
     positiveResponses: currentPeriodData.positiveResponses,
-    negativeResponses: currentPeriodData.negativeResponses
+    negativeResponses: currentPeriodData.negativeResponses,
+    passiveResponses: currentPeriodData.passiveResponses,
+    npsScore: currentPeriodData.npsScore
   };
   return basicResponse;
 };
 function generateFeedbackPeriodData(platformConfig, scalingFactor, isPrevious = false, isAllTime = false) {
-  const baseMetrics = isAllTime ? getAllTimePlatformFeedbackMetrics(platformConfig) : getBasePlatformFeedbackMetrics(platformConfig);
+  const baseMetrics = isAllTime ? getAllTimePlatformFeedbackMetrics(platformConfig) : getBasePlatformFeedbackMetrics$1(platformConfig);
   const scaledTotalSent = isAllTime ? baseMetrics.totalSent : Math.max(1, Math.round(baseMetrics.totalSent * scalingFactor));
-  const performanceMultiplier = isPrevious ? f.number.float({ min: 0.88, max: 0.95 }) : 1;
+  const performanceMultiplier = isPrevious ? 0.82 : 1;
   const adjustedTotalSent = Math.round(scaledTotalSent * performanceMultiplier);
   const responseRate = baseMetrics.responseRate * performanceMultiplier;
   const totalResponded = Math.round(adjustedTotalSent * (responseRate / 100));
-  const positiveRate = baseMetrics.positiveRate * performanceMultiplier;
-  const positiveResponses = Math.round(totalResponded * positiveRate);
-  const negativeResponses = totalResponded - positiveResponses;
-  const averageRating = calculateAverageFromSentiment(
-    positiveResponses,
-    negativeResponses
+  let promoterRate, passiveRate;
+  if (isPrevious) {
+    promoterRate = 0.5;
+    passiveRate = 0.3;
+  } else {
+    promoterRate = baseMetrics.promoterRate * performanceMultiplier;
+    passiveRate = baseMetrics.passiveRate * performanceMultiplier;
+  }
+  const promoters = Math.round(totalResponded * promoterRate);
+  const passives = Math.round(totalResponded * passiveRate);
+  const detractors = totalResponded - promoters - passives;
+  const npsScore = totalResponded > 0 ? Math.round((promoters - detractors) / totalResponded * 100) : 0;
+  const averageRating = calculateAverageFromNPS(
+    promoters,
+    passives,
+    detractors
   );
   return {
     totalSent: adjustedTotalSent,
     totalResponded,
     averageRating: parseFloat(averageRating.toFixed(1)),
     responseRate: parseFloat(responseRate.toFixed(1)),
-    positiveResponses,
-    negativeResponses
+    positiveResponses: promoters,
+    // promoters for backward compatibility
+    negativeResponses: detractors,
+    // detractors for backward compatibility
+    passiveResponses: passives,
+    // new field for passives
+    npsScore
+    // real NPS score
   };
 }
-function getBasePlatformFeedbackMetrics(platformConfig) {
+function getBasePlatformFeedbackMetrics$1(platformConfig) {
   const industryMultipliers = {
     // Pet spa industry (Goose) - high engagement, positive feedback
     "ACME Pet Spa": {
-      totalSent: 85,
+      totalSent: 1250,
+      // Much higher - businesses send way more emails than get reviews
       responseRate: 42,
       // 42% response rate
-      positiveRate: 0.78
-      // 78% positive
+      promoterRate: 0.65,
+      // 65% promoters (9-10) - much higher NPS
+      passiveRate: 0.2,
+      // 20% passives (7-8)
+      detractorRate: 0.15
+      // 15% detractors (1-6) - much lower
     },
     // Equipment rental (Renterra) - moderate engagement
     "Tomer's Rentals": {
-      totalSent: 65,
+      totalSent: 980,
       responseRate: 35,
       // 35% response rate
-      positiveRate: 0.72
-      // 72% positive
+      promoterRate: 0.55,
+      // 55% promoters
+      passiveRate: 0.25,
+      // 25% passives
+      detractorRate: 0.2
+      // 20% detractors
     },
     // Default platform
     default: {
-      totalSent: 75,
+      totalSent: 1100,
       responseRate: 38,
       // 38% response rate
-      positiveRate: 0.75
-      // 75% positive
+      promoterRate: 0.6,
+      // 60% promoters
+      passiveRate: 0.22,
+      // 22% passives
+      detractorRate: 0.18
+      // 18% detractors
     }
   };
   const baseKey = platformConfig.name in industryMultipliers ? platformConfig.name : "default";
@@ -23079,37 +23111,52 @@ function getAllTimePlatformFeedbackMetrics(platformConfig) {
   const industryMultipliers = {
     // Pet spa industry (Goose) - high engagement, positive feedback
     "ACME Pet Spa": {
-      totalSent: 1247,
-      // Much higher for all-time
+      totalSent: 18500,
+      // WAY higher - businesses send tons of emails over time
       responseRate: 39,
       // Slightly lower all-time response rate
-      positiveRate: 0.76
-      // Slightly lower positive rate
+      promoterRate: 0.61,
+      // 61% promoters - produces NPS of 42
+      passiveRate: 0.2,
+      // 20% passives
+      detractorRate: 0.19
+      // 19% detractors
     },
     // Equipment rental (Renterra) - moderate engagement
     "Tomer's Rentals": {
-      totalSent: 892,
+      totalSent: 14200,
       responseRate: 33,
-      positiveRate: 0.7
+      promoterRate: 0.58,
+      // 58% promoters - good NPS
+      passiveRate: 0.22,
+      // 22% passives
+      detractorRate: 0.2
+      // 20% detractors
     },
     // Default platform
     default: {
-      totalSent: 1089,
+      totalSent: 16500,
       responseRate: 36,
-      positiveRate: 0.73
+      promoterRate: 0.62,
+      // 62% promoters - good NPS
+      passiveRate: 0.2,
+      // 20% passives
+      detractorRate: 0.18
+      // 18% detractors
     }
   };
   const baseKey = platformConfig.name in industryMultipliers ? platformConfig.name : "default";
   return industryMultipliers[baseKey];
 }
-function calculateAverageFromSentiment(positiveCount, negativeCount) {
-  if (positiveCount === 0 && negativeCount === 0) {
+function calculateAverageFromNPS(promoters, passives, detractors) {
+  const totalResponses = promoters + passives + detractors;
+  if (totalResponses === 0) {
     return 0;
   }
-  const positiveAverage = 4.3;
-  const negativeAverage = 1.8;
-  const totalResponses = positiveCount + negativeCount;
-  const weightedSum = positiveCount * positiveAverage + negativeCount * negativeAverage;
+  const promoterAverage = 9.5;
+  const passiveAverage = 7.5;
+  const detractorAverage = 3.5;
+  const weightedSum = promoters * promoterAverage + passives * passiveAverage + detractors * detractorAverage;
   return weightedSum / totalResponses;
 }
 function calculateFeedbackComparison(currentPeriod, previousPeriod) {
@@ -23135,6 +23182,12 @@ function calculateFeedbackComparison(currentPeriod, previousPeriod) {
   const responseRateChangePercent = previousPeriod.responseRate > 0 ? parseFloat(
     (responseRateChange / previousPeriod.responseRate * 100).toFixed(1)
   ) : null;
+  const npsScoreChange = currentPeriod.npsScore - previousPeriod.npsScore;
+  const npsScoreChangePercent = previousPeriod.npsScore !== 0 ? parseFloat(
+    (npsScoreChange / Math.abs(previousPeriod.npsScore) * 100).toFixed(
+      1
+    )
+  ) : null;
   return {
     totalSentChange,
     totalSentChangePercent,
@@ -23143,7 +23196,469 @@ function calculateFeedbackComparison(currentPeriod, previousPeriod) {
     averageRatingChange,
     averageRatingChangePercent,
     responseRateChange: parseFloat(responseRateChange.toFixed(1)),
-    responseRateChangePercent
+    responseRateChangePercent,
+    npsScoreChange,
+    npsScoreChangePercent
+  };
+}
+const generateAuditLogData = ({
+  startDate,
+  endDate,
+  locationIds,
+  cursor,
+  limit,
+  searchTerm,
+  orderBy
+}) => {
+  const queryStartDate = startDate ? new Date(startDate) : new Date(Date.now() - 30 * 24 * 60 * 60 * 1e3);
+  const queryEndDate = endDate ? new Date(endDate) : /* @__PURE__ */ new Date();
+  const queryDays = Math.ceil(
+    (queryEndDate.getTime() - queryStartDate.getTime()) / (1e3 * 60 * 60 * 24)
+  ) + 1;
+  const baseLogCount = 100;
+  const scaledLogCount = Math.max(
+    20,
+    Math.round(baseLogCount * queryDays / 30)
+  );
+  const allLogs = generateAuditLogPool(
+    queryStartDate,
+    queryEndDate,
+    scaledLogCount
+  );
+  let filteredLogs = allLogs;
+  if (startDate || endDate) {
+    filteredLogs = filteredLogs.filter((item) => {
+      const itemDate = new Date(item.timestamp);
+      if (startDate && itemDate < new Date(startDate)) return false;
+      if (endDate && itemDate > new Date(endDate)) return false;
+      return true;
+    });
+  }
+  if (searchTerm && searchTerm.length >= 3) {
+    const searchLower = searchTerm.toLowerCase();
+    filteredLogs = filteredLogs.filter(
+      (item) => item.message.toLowerCase().includes(searchLower) || item.user.toLowerCase().includes(searchLower) || item.status.toLowerCase().includes(searchLower) || item.channel.toLowerCase().includes(searchLower) || item.type.toLowerCase().includes(searchLower)
+    );
+  }
+  if (locationIds && locationIds.length > 0) ;
+  filteredLogs.sort((a2, b2) => {
+    const dateA = new Date(a2.timestamp).getTime();
+    const dateB = new Date(b2.timestamp).getTime();
+    return orderBy.includes("desc") || orderBy === "timestamp" ? dateB - dateA : dateA - dateB;
+  });
+  let startIndex = 0;
+  if (cursor) {
+    const cursorIndex = filteredLogs.findIndex((item) => item.id === cursor);
+    if (cursorIndex !== -1) {
+      startIndex = cursorIndex + 1;
+    }
+  }
+  const pageData = filteredLogs.slice(startIndex, startIndex + limit);
+  const hasMore = startIndex + limit < filteredLogs.length;
+  const nextCursor = hasMore && pageData.length > 0 ? pageData[pageData.length - 1].id : void 0;
+  return {
+    data: pageData,
+    total: filteredLogs.length,
+    nextCursor
+  };
+};
+function generateAuditLogPool(startDate, endDate, count) {
+  const logs = [];
+  const timeSpan = endDate.getTime() - startDate.getTime();
+  const eventSequences = [
+    // Survey flow
+    {
+      type: "SURVEY_REQUEST",
+      channel: "EMAIL",
+      statuses: ["SENT", "DELIVERED", "OPENED", "COMPLETED"],
+      messages: [
+        "Survey request sent to customer",
+        "Survey request delivered to customer",
+        "Customer opened survey request",
+        "Survey completed by customer"
+      ]
+    },
+    // Review flow
+    {
+      type: "REVIEW_REQUEST",
+      channel: "SMS",
+      statuses: ["SENT", "DELIVERED"],
+      messages: ["Review request sent to", "Review request delivered to"]
+    },
+    // Google review flow
+    {
+      type: "GOOGLE_REVIEW",
+      channel: "EMAIL",
+      statuses: ["RECEIVED", "RESPONDED"],
+      messages: [
+        "New Google review received from",
+        "Response sent to Google review from"
+      ]
+    },
+    // Reminder flows
+    {
+      type: "SURVEY_REMINDER",
+      channel: "EMAIL",
+      statuses: ["SENT", "DELIVERED"],
+      messages: ["Survey reminder sent to", "Survey reminder delivered to"]
+    },
+    {
+      type: "REVIEW_REMINDER",
+      channel: "SMS",
+      statuses: ["SENT", "DELIVERED"],
+      messages: ["Review reminder sent to", "Review reminder delivered to"]
+    }
+  ];
+  for (let i2 = 0; i2 < count; i2++) {
+    const sequence = f.helpers.arrayElement(eventSequences);
+    const statusIndex = f.number.int({
+      min: 0,
+      max: sequence.statuses.length - 1
+    });
+    const status = sequence.statuses[statusIndex];
+    const messageTemplate = sequence.messages[statusIndex];
+    const timestamp = new Date(startDate.getTime() + Math.random() * timeSpan);
+    let contactInfo;
+    if (sequence.channel === "EMAIL") {
+      contactInfo = f.internet.email();
+    } else {
+      contactInfo = f.phone.number();
+    }
+    const user = status === "RESPONDED" ? f.internet.email({ provider: "business.com" }) : "system";
+    const customerName = status === "RECEIVED" || status === "RESPONDED" ? `${f.person.firstName()} ${f.person.lastName().charAt(0)}.` : null;
+    let message2;
+    if (customerName) {
+      message2 = `${messageTemplate} ${customerName}`;
+    } else {
+      message2 = `${messageTemplate} ${contactInfo}`;
+    }
+    logs.push({
+      id: f.string.uuid(),
+      timestamp: timestamp.toISOString(),
+      message: message2,
+      user,
+      status,
+      channel: sequence.channel,
+      type: sequence.type
+    });
+  }
+  return logs;
+}
+const generateReviewTimeSeriesData = ({
+  platformData,
+  queryParams
+}) => {
+  const platformConfig = getPlatformConfig(
+    platformData.businessesMe?.platform_id
+  );
+  const { requestedDays, startDate, endDate } = parseDateRange(
+    queryParams.start_date,
+    queryParams.end_date,
+    30
+  );
+  const baseMetrics = getBasePlatformReviewMetrics(platformConfig);
+  const basePeriodDays = 30;
+  const scalingFactor = requestedDays / basePeriodDays;
+  const totalScaledReviews = Math.max(
+    1,
+    Math.round(baseMetrics.totalReviews * scalingFactor)
+  );
+  let intervalDays = 7;
+  if (requestedDays <= 30)
+    intervalDays = 1;
+  else if (requestedDays <= 90) intervalDays = 3;
+  const numDataPoints = Math.max(1, Math.ceil(requestedDays / intervalDays));
+  const dataPoints = generateReviewTimeSeriesPoints({
+    totalScaledReviews,
+    startDate,
+    endDate,
+    numDataPoints,
+    intervalDays
+  });
+  return {
+    data: dataPoints
+  };
+};
+function generateReviewTimeSeriesPoints({
+  totalScaledReviews,
+  startDate,
+  endDate,
+  numDataPoints,
+  intervalDays
+}) {
+  const dataPoints = [];
+  let currentDate = new Date(startDate);
+  let cumulativeReviews = 0;
+  const basePointReviews = totalScaledReviews / numDataPoints;
+  const targetRating = 4.2;
+  const startingRating = 4;
+  const endingRating = 4.2;
+  for (let i2 = 0; i2 < numDataPoints; i2++) {
+    const pointDateStr = currentDate.toISOString().split("T")[0];
+    let currentPointReviews;
+    let currentPointRating;
+    if (i2 < numDataPoints - 1) {
+      currentPointReviews = Math.round(
+        basePointReviews * (1 + (Math.random() - 0.5) * 0.5)
+      );
+      const progress = i2 / (numDataPoints - 1);
+      currentPointRating = startingRating + (endingRating - startingRating) * Math.pow(progress, 1.3);
+      currentPointRating *= 1 + (Math.random() - 0.5) * 0.05;
+    } else {
+      currentPointReviews = Math.max(0, totalScaledReviews - cumulativeReviews);
+      currentPointRating = targetRating;
+    }
+    currentPointReviews = Math.max(0, currentPointReviews);
+    currentPointRating = Math.max(1, Math.min(5, currentPointRating));
+    cumulativeReviews += currentPointReviews;
+    const { promoterCount, detractorCount } = calculatePromoterDetractorSplit(
+      currentPointReviews,
+      currentPointRating
+    );
+    dataPoints.push({
+      date: pointDateStr,
+      totalReviews: currentPointReviews,
+      averageRating: currentPointReviews > 0 ? parseFloat(currentPointRating.toFixed(1)) : null,
+      promoterCount,
+      detractorCount
+    });
+    currentDate.setDate(currentDate.getDate() + intervalDays);
+    if (currentDate > endDate && i2 < numDataPoints - 1) {
+      currentDate = new Date(endDate);
+      if (dataPoints.length > 0 && dataPoints[dataPoints.length - 1].date === currentDate.toISOString().split("T")[0]) {
+        break;
+      }
+    }
+  }
+  return dataPoints;
+}
+function getBasePlatformReviewMetrics(platformConfig) {
+  const industryMetrics = {
+    // Pet spa industry (Goose) - high customer satisfaction, more reviews
+    "ACME Pet Spa": {
+      totalReviews: 52,
+      // Slightly higher than analytics factory
+      averageRating: 4.5,
+      promoterRate: 0.65,
+      // 65% 5-star
+      detractorRate: 0.15
+      // 15% 1-3 star
+    },
+    // Equipment rental (Renterra) - moderate review volume, good satisfaction
+    "Tomer's Rentals": {
+      totalReviews: 31,
+      averageRating: 4.2,
+      promoterRate: 0.55,
+      // 55% 5-star
+      detractorRate: 0.2
+      // 20% 1-3 star
+    },
+    // Default platform
+    default: {
+      totalReviews: 95,
+      // Match all-time analytics exactly
+      averageRating: 4.2,
+      // Match all-time analytics exactly
+      promoterRate: 0.6,
+      // 60% 5-star
+      detractorRate: 0.18
+      // 18% 1-3 star
+    }
+  };
+  const baseKey = platformConfig.name in industryMetrics ? platformConfig.name : "default";
+  return industryMetrics[baseKey];
+}
+function calculatePromoterDetractorSplit(totalReviews, averageRating) {
+  if (totalReviews === 0) {
+    return { promoterCount: 0, detractorCount: 0 };
+  }
+  let promoterRate = 0.6;
+  let detractorRate = 0.15;
+  if (averageRating >= 4.5) {
+    promoterRate = 0.7;
+    detractorRate = 0.1;
+  } else if (averageRating >= 4.2) {
+    promoterRate = 0.6;
+    detractorRate = 0.15;
+  } else if (averageRating >= 3.8) {
+    promoterRate = 0.45;
+    detractorRate = 0.25;
+  } else {
+    promoterRate = 0.3;
+    detractorRate = 0.4;
+  }
+  promoterRate *= 1 + (Math.random() - 0.5) * 0.2;
+  detractorRate *= 1 + (Math.random() - 0.5) * 0.2;
+  const promoterCount = Math.round(totalReviews * promoterRate);
+  const detractorCount = Math.round(totalReviews * detractorRate);
+  return { promoterCount, detractorCount };
+}
+const generateFeedbackTimeSeriesData = ({
+  platformData,
+  queryParams
+}) => {
+  const platformConfig = getPlatformConfig(
+    platformData.businessesMe?.platform_id
+  );
+  const { requestedDays, startDate, endDate } = parseDateRange(
+    queryParams.start_date,
+    queryParams.end_date,
+    30
+  );
+  const baseMetrics = getBasePlatformFeedbackMetrics(platformConfig);
+  const basePeriodDays = 30;
+  const scalingFactor = requestedDays / basePeriodDays;
+  const totalScaledSent = Math.max(
+    1,
+    Math.round(baseMetrics.totalSent * scalingFactor)
+  );
+  let intervalDays = 7;
+  if (requestedDays <= 30)
+    intervalDays = 1;
+  else if (requestedDays <= 90) intervalDays = 3;
+  const numDataPoints = Math.max(1, Math.ceil(requestedDays / intervalDays));
+  const dataPoints = generateFeedbackTimeSeriesPoints({
+    totalScaledSent,
+    baseMetrics,
+    startDate,
+    endDate,
+    numDataPoints,
+    intervalDays
+  });
+  return {
+    data: dataPoints
+  };
+};
+function generateFeedbackTimeSeriesPoints({
+  totalScaledSent,
+  baseMetrics,
+  startDate,
+  endDate,
+  numDataPoints,
+  intervalDays
+}) {
+  const dataPoints = [];
+  let currentDate = new Date(startDate);
+  let cumulativeSent = 0;
+  const basePointSent = totalScaledSent / numDataPoints;
+  const startingResponseRate = baseMetrics.responseRate * 0.75;
+  const endingResponseRate = baseMetrics.responseRate * 1.15;
+  const startingNPS = 30;
+  const endingNPS = 42;
+  for (let i2 = 0; i2 < numDataPoints; i2++) {
+    const pointDateStr = currentDate.toISOString().split("T")[0];
+    let currentPointSent;
+    let currentPointResponseRate;
+    let currentPointNPS;
+    if (i2 < numDataPoints - 1) {
+      currentPointSent = Math.round(
+        basePointSent * (1 + (Math.random() - 0.5) * 0.5)
+      );
+      const progress = i2 / (numDataPoints - 1);
+      currentPointResponseRate = startingResponseRate + (endingResponseRate - startingResponseRate) * Math.pow(progress, 1.3);
+      currentPointNPS = startingNPS + (endingNPS - startingNPS) * Math.pow(progress, 1.2);
+      currentPointResponseRate *= 1 + (Math.random() - 0.5) * 0.1;
+      currentPointNPS *= 1 + (Math.random() - 0.5) * 0.1;
+    } else {
+      currentPointSent = Math.max(0, totalScaledSent - cumulativeSent);
+      currentPointResponseRate = baseMetrics.responseRate;
+      currentPointNPS = 42;
+    }
+    currentPointSent = Math.max(0, currentPointSent);
+    currentPointResponseRate = Math.max(
+      5,
+      Math.min(80, currentPointResponseRate)
+    );
+    currentPointNPS = Math.max(-100, Math.min(100, currentPointNPS));
+    cumulativeSent += currentPointSent;
+    const currentPointResponded = Math.round(
+      currentPointSent * (currentPointResponseRate / 100)
+    );
+    const { promoterCount, detractorCount, passiveCount } = calculateNPSBreakdown(currentPointResponded, currentPointNPS);
+    dataPoints.push({
+      date: pointDateStr,
+      totalSent: currentPointSent,
+      totalResponded: currentPointResponded,
+      promoterCount,
+      detractorCount,
+      passiveCount,
+      npsScore: parseFloat(currentPointNPS.toFixed(1))
+      // Use the target NPS (30 → 42)
+    });
+    currentDate.setDate(currentDate.getDate() + intervalDays);
+    if (currentDate > endDate && i2 < numDataPoints - 1) {
+      currentDate = new Date(endDate);
+      if (dataPoints.length > 0 && dataPoints[dataPoints.length - 1].date === currentDate.toISOString().split("T")[0]) {
+        break;
+      }
+    }
+  }
+  return dataPoints;
+}
+function getBasePlatformFeedbackMetrics(platformConfig) {
+  const industryMetrics = {
+    // Pet spa industry (Goose) - high engagement, positive feedback
+    "ACME Pet Spa": {
+      totalSent: 1200,
+      // Much higher - realistic email volume
+      responseRate: 44,
+      // 44% response rate
+      targetNPS: 42,
+      // Match the all-time NPS score (42)
+      promoterRate: 0.78
+      // 78% promoters
+    },
+    // Equipment rental (Renterra) - moderate engagement
+    "Tomer's Rentals": {
+      totalSent: 950,
+      responseRate: 37,
+      // 37% response rate
+      targetNPS: 55,
+      // Good NPS for B2B
+      promoterRate: 0.72
+      // 72% promoters
+    },
+    // Default platform
+    default: {
+      totalSent: 1050,
+      responseRate: 40,
+      // 40% response rate
+      targetNPS: 60,
+      // Good overall NPS
+      promoterRate: 0.75
+      // 75% promoters
+    }
+  };
+  const baseKey = platformConfig.name in industryMetrics ? platformConfig.name : "default";
+  return industryMetrics[baseKey];
+}
+function calculateNPSBreakdown(totalResponses, targetNPS) {
+  if (totalResponses === 0) {
+    return { promoterCount: 0, detractorCount: 0, passiveCount: 0 };
+  }
+  const passiveRate = 0.25;
+  const passiveCount = Math.round(totalResponses * passiveRate);
+  const activeResponses = totalResponses - passiveCount;
+  const npsDecimal = targetNPS / 100;
+  const promoterCount = Math.round(
+    (activeResponses + npsDecimal * totalResponses) / 2
+  );
+  const detractorCount = Math.max(0, activeResponses - promoterCount);
+  const finalPromoterCount = Math.max(
+    0,
+    Math.min(promoterCount, totalResponses - passiveCount)
+  );
+  const finalDetractorCount = Math.max(
+    0,
+    Math.min(
+      detractorCount,
+      totalResponses - passiveCount - finalPromoterCount
+    )
+  );
+  return {
+    promoterCount: finalPromoterCount,
+    detractorCount: finalDetractorCount,
+    passiveCount
   };
 }
 const mockStore = {
@@ -23221,7 +23736,8 @@ const reputationHandlers = [
         locationMappings: body.locationMappings || currentConfig.locationMappings,
         emailChannelSenderId: body.emailChannelSenderId,
         smsChannelSenderId: body.smsChannelSenderId,
-        completedOnboardingAt: body.completedOnboardingAt,
+        // Preserve existing completedOnboardingAt if not provided in update
+        completedOnboardingAt: body.completedOnboardingAt || currentConfig.completedOnboardingAt,
         updatedAt: (/* @__PURE__ */ new Date()).toISOString()
       };
       mockStore.reputationConfig = updatedConfig;
@@ -23306,6 +23822,20 @@ const reputationHandlers = [
       }
     });
   }),
+  // OAuth GBP Connection Revoke
+  http.post(`${HOSTNAME}/api/oauth/gbp/revoke`, () => {
+    return HttpResponse.json(
+      {
+        success: false,
+        message: "Error (Sandbox)",
+        data: {
+          success: false,
+          message: "Unable to revoke sandbox account"
+        }
+      },
+      { status: 400 }
+    );
+  }),
   // OAuth GBP Connection Status
   http.get(`${HOSTNAME}/api/oauth/gbp/connection`, () => {
     const platformData = getSandboxDataForPlatform(currentSandboxPlatformId);
@@ -23368,7 +23898,6 @@ const reputationHandlers = [
     const includeComparison = url.searchParams.get("include_comparison") === "true";
     const platformData = getSandboxDataForPlatform(currentSandboxPlatformId);
     const queryParams = {
-      platform: "google_business_profile",
       start_date: startDate || void 0,
       end_date: endDate || void 0,
       location_ids: locationIds ? locationIds.split(",").filter(Boolean) : void 0,
@@ -23384,6 +23913,37 @@ const reputationHandlers = [
       data: analyticsData
     });
   }),
+  // Review Time-Series
+  http.get(`${HOSTNAME}/api/reviews/time-series`, ({ request }) => {
+    const url = new URL(request.url);
+    const startDate = url.searchParams.get("start_date");
+    const endDate = url.searchParams.get("end_date");
+    const locationIds = url.searchParams.get("location_ids");
+    if (!startDate || !endDate) {
+      return HttpResponse.json(
+        {
+          success: false,
+          message: "Missing required parameters: start_date and end_date"
+        },
+        { status: 400 }
+      );
+    }
+    const platformData = getSandboxDataForPlatform(currentSandboxPlatformId);
+    const queryParams = {
+      start_date: startDate,
+      end_date: endDate,
+      location_ids: locationIds ? locationIds.split(",").filter(Boolean) : void 0
+    };
+    const timeSeriesData = generateReviewTimeSeriesData({
+      platformData,
+      queryParams
+    });
+    return HttpResponse.json({
+      success: true,
+      message: "Success (Sandbox)",
+      data: timeSeriesData
+    });
+  }),
   // Feedback Analytics
   http.get(`${HOSTNAME}/api/feedback/analytics`, ({ request }) => {
     const url = new URL(request.url);
@@ -23409,6 +23969,60 @@ const reputationHandlers = [
       message: "Success (Sandbox)",
       data: analyticsData
     });
+  }),
+  // Feedback Time-Series
+  http.get(`${HOSTNAME}/api/feedback/time-series`, ({ request }) => {
+    const url = new URL(request.url);
+    const startDate = url.searchParams.get("start_date");
+    const endDate = url.searchParams.get("end_date");
+    if (!startDate || !endDate) {
+      return HttpResponse.json(
+        {
+          success: false,
+          message: "Missing required parameters: start_date and end_date"
+        },
+        { status: 400 }
+      );
+    }
+    const platformData = getSandboxDataForPlatform(currentSandboxPlatformId);
+    const queryParams = {
+      start_date: startDate,
+      end_date: endDate
+    };
+    const timeSeriesData = generateFeedbackTimeSeriesData({
+      platformData,
+      queryParams
+    });
+    return HttpResponse.json({
+      success: true,
+      message: "Success (Sandbox)",
+      data: timeSeriesData
+    });
+  }),
+  // Reputation Audit Logs
+  http.get(`${HOSTNAME}/api/reputation/audit-logs`, ({ request }) => {
+    const url = new URL(request.url);
+    const startDate = url.searchParams.get("start_date");
+    const endDate = url.searchParams.get("end_date");
+    const locationIds = url.searchParams.getAll("location_ids");
+    const cursor = url.searchParams.get("cursor");
+    const limit = parseInt(url.searchParams.get("limit") || "25", 10);
+    const searchTerm = url.searchParams.get("search_term");
+    const orderBy = url.searchParams.get("order_by") || "timestamp";
+    const auditLogResponse = generateAuditLogData({
+      startDate,
+      endDate,
+      locationIds,
+      cursor,
+      limit,
+      searchTerm,
+      orderBy
+    });
+    return HttpResponse.json({
+      success: true,
+      message: "Success (Sandbox)",
+      data: auditLogResponse
+    });
   })
 ];
 const getHandlersByFeatures = (features) => {