featuredrop 1.0.1 → 1.2.0

package/dist/testing.js

@@ -0,0 +1,1415 @@
+import { createContext, useRef, useState, useMemo, useCallback, useEffect } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+// src/analytics.ts
+var AnalyticsCollector = class {
+  adapter;
+  queue = [];
+  batchSize;
+  flushInterval;
+  sampleRate;
+  enabled;
+  now;
+  random;
+  sessionId;
+  userId;
+  timer = null;
+  flushing = false;
+  constructor(options) {
+    this.adapter = options.adapter;
+    this.batchSize = options.batchSize ?? 20;
+    this.flushInterval = options.flushInterval ?? 1e4;
+    this.sampleRate = options.sampleRate ?? 1;
+    this.enabled = options.enabled ?? true;
+    this.sessionId = options.sessionId;
+    this.userId = options.userId;
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+    this.random = options.random ?? Math.random;
+    this.startTimer();
+  }
+  setEnabled(enabled) {
+    this.enabled = enabled;
+  }
+  setContext(context) {
+    if (context.sessionId !== void 0) this.sessionId = context.sessionId;
+    if (context.userId !== void 0) this.userId = context.userId;
+  }
+  getQueueSize() {
+    return this.queue.length;
+  }
+  track(event) {
+    if (!this.enabled) return;
+    if (this.sampleRate < 1 && this.random() > this.sampleRate) return;
+    const normalized = {
+      ...event,
+      timestamp: event.timestamp ?? this.now().toISOString(),
+      sessionId: event.sessionId ?? this.sessionId,
+      userId: event.userId ?? this.userId
+    };
+    this.queue.push(normalized);
+    if (this.queue.length >= this.batchSize) {
+      void this.flush();
+    }
+  }
+  async flush() {
+    if (this.flushing) return;
+    if (this.queue.length === 0) return;
+    this.flushing = true;
+    const batch = this.queue.splice(0, this.queue.length);
+    try {
+      if (this.adapter.trackBatch) {
+        await this.adapter.trackBatch(batch);
+      } else {
+        for (const event of batch) {
+          await this.adapter.track(event);
+        }
+      }
+    } catch {
+      this.queue = [...batch, ...this.queue];
+    } finally {
+      this.flushing = false;
+    }
+  }
+  async destroy() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    await this.flush();
+  }
+  startTimer() {
+    if (this.flushInterval <= 0) return;
+    this.timer = setInterval(() => {
+      void this.flush();
+    }, this.flushInterval);
+  }
+};
+
+// src/semver.ts
+var SEMVER_REGEX = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?/;
+function parseSemver(input) {
+  const match = input.trim().match(SEMVER_REGEX);
+  if (!match) return null;
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    prerelease: match[4] ? match[4].split(".") : []
+  };
+}
+function compareSemver(a, b) {
+  const pa = parseSemver(a);
+  const pb = parseSemver(b);
+  if (!pa || !pb) return 0;
+  for (const key of ["major", "minor", "patch"]) {
+    if (pa[key] !== pb[key]) return pa[key] - pb[key];
+  }
+  const aPre = pa.prerelease;
+  const bPre = pb.prerelease;
+  if (aPre.length === 0 && bPre.length === 0) return 0;
+  if (aPre.length === 0) return 1;
+  if (bPre.length === 0) return -1;
+  const len = Math.max(aPre.length, bPre.length);
+  for (let i = 0; i < len; i++) {
+    const ai = aPre[i];
+    const bi = bPre[i];
+    if (ai === void 0) return -1;
+    if (bi === void 0) return 1;
+    const aNum = Number(ai);
+    const bNum = Number(bi);
+    const aIsNum = Number.isInteger(aNum);
+    const bIsNum = Number.isInteger(bNum);
+    if (aIsNum && bIsNum && aNum !== bNum) return aNum - bNum;
+    if (aIsNum !== bIsNum) return aIsNum ? -1 : 1;
+    if (ai !== bi) return ai < bi ? -1 : 1;
+  }
+  return 0;
+}
+function parseComparator(comp) {
+  const match = comp.trim().match(/^(>=|<=|>|<|=)?\\s*(.+)$/);
+  if (!match) return null;
+  const op = match[1] || ">=";
+  const version = match[2];
+  if (!parseSemver(version)) return null;
+  return { op, version };
+}
+function satisfiesComparator(version, comp) {
+  const diff = compareSemver(version, comp.version);
+  switch (comp.op) {
+    case ">":
+      return diff > 0;
+    case ">=":
+      return diff >= 0;
+    case "<":
+      return diff < 0;
+    case "<=":
+      return diff <= 0;
+    case "=":
+      return diff === 0;
+    default:
+      return false;
+  }
+}
+function satisfiesRange(version, range) {
+  const parts = range.split(/\s+/).filter(Boolean);
+  if (parts.length === 0) return true;
+  for (const part of parts) {
+    const comp = parseComparator(part);
+    if (!comp) return false;
+    if (!satisfiesComparator(version, comp)) return false;
+  }
+  return true;
+}
+
+// src/triggers.ts
+function wildcardToRegExp(value) {
+  const escaped = value.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = `^${escaped.replace(/\*/g, ".*")}$`;
+  return new RegExp(pattern);
+}
+function matchPath(path, pattern) {
+  if (pattern instanceof RegExp) return pattern.test(path);
+  if (!pattern) return false;
+  if (pattern.includes("*")) return wildcardToRegExp(pattern).test(path);
+  return path === pattern || path.startsWith(pattern);
+}
+function isTriggerMatch(trigger, context) {
+  if (!trigger) return true;
+  if (!context) return false;
+  if (trigger.type === "page") {
+    const path = context.path;
+    if (!path) return false;
+    return matchPath(path, trigger.match);
+  }
+  if (trigger.type === "usage") {
+    const usage = context.usage ?? {};
+    const count = usage[trigger.event] ?? 0;
+    return count >= (trigger.minActions ?? 1);
+  }
+  if (trigger.type === "time") {
+    const elapsedMs = context.elapsedMs ?? 0;
+    return elapsedMs >= trigger.minSeconds * 1e3;
+  }
+  if (trigger.type === "milestone") {
+    return context.milestones?.has(trigger.event) ?? false;
+  }
+  if (trigger.type === "frustration") {
+    const usage = context.usage ?? {};
+    const count = usage[trigger.pattern] ?? 0;
+    return count >= (trigger.threshold ?? 1);
+  }
+  if (trigger.type === "scroll") {
+    return (context.scrollPercent ?? 0) >= (trigger.minPercent ?? 50);
+  }
+  try {
+    return trigger.evaluate(context);
+  } catch {
+    return false;
+  }
+}
+var TriggerEngine = class {
+  context;
+  constructor(initial) {
+    this.context = {
+      path: initial?.path,
+      events: new Set(initial?.events ?? []),
+      milestones: new Set(initial?.milestones ?? []),
+      usage: { ...initial?.usage ?? {} },
+      elapsedMs: initial?.elapsedMs ?? 0,
+      scrollPercent: initial?.scrollPercent ?? 0,
+      metadata: { ...initial?.metadata ?? {} }
+    };
+  }
+  setPath(path) {
+    this.context.path = path;
+  }
+  trackEvent(event) {
+    const next = new Set(this.context.events ?? /* @__PURE__ */ new Set());
+    next.add(event);
+    this.context.events = next;
+  }
+  trackUsage(event, delta = 1) {
+    const usage = { ...this.context.usage ?? {} };
+    usage[event] = (usage[event] ?? 0) + Math.max(1, delta);
+    this.context.usage = usage;
+  }
+  trackMilestone(event) {
+    const next = new Set(this.context.milestones ?? /* @__PURE__ */ new Set());
+    next.add(event);
+    this.context.milestones = next;
+  }
+  setElapsedMs(elapsedMs) {
+    this.context.elapsedMs = Math.max(0, elapsedMs);
+  }
+  setScrollPercent(scrollPercent) {
+    const clamped = Math.max(0, Math.min(100, scrollPercent));
+    this.context.scrollPercent = clamped;
+  }
+  setMetadata(next) {
+    this.context.metadata = { ...next };
+  }
+  getContext() {
+    return {
+      path: this.context.path,
+      events: new Set(this.context.events ?? []),
+      milestones: new Set(this.context.milestones ?? []),
+      usage: { ...this.context.usage ?? {} },
+      elapsedMs: this.context.elapsedMs,
+      scrollPercent: this.context.scrollPercent,
+      metadata: { ...this.context.metadata ?? {} }
+    };
+  }
+  evaluate(trigger) {
+    return isTriggerMatch(trigger, this.context);
+  }
+  evaluateFeature(feature) {
+    return this.evaluate(feature.trigger);
+  }
+};
+
+// src/core.ts
+function matchesAudience(audience, userContext) {
+  if (audience.plan && audience.plan.length > 0) {
+    if (!userContext.plan || !audience.plan.includes(userContext.plan)) {
+      return false;
+    }
+  }
+  if (audience.role && audience.role.length > 0) {
+    if (!userContext.role || !audience.role.includes(userContext.role)) {
+      return false;
+    }
+  }
+  if (audience.region && audience.region.length > 0) {
+    if (!userContext.region || !audience.region.includes(userContext.region)) {
+      return false;
+    }
+  }
+  return true;
+}
+function isAudienceMatch(feature, userContext, matchFn) {
+  if (!feature.audience) return true;
+  const { plan, role, region, custom } = feature.audience;
+  const hasRules = plan && plan.length > 0 || role && role.length > 0 || region && region.length > 0 || custom && Object.keys(custom).length > 0;
+  if (!hasRules) return true;
+  if (!userContext) return false;
+  if (matchFn) return matchFn(feature.audience, userContext);
+  return matchesAudience(feature.audience, userContext);
+}
+function isVersionMatch(feature, appVersion) {
+  const v = feature.version;
+  if (!v || typeof v === "string") return true;
+  if (!appVersion) return false;
+  if (!v.introduced && !v.showNewUntil && !v.deprecatedAt && !v.showIn) return true;
+  if (v.showIn && !satisfiesRange(appVersion, v.showIn)) return false;
+  if (v.introduced && compareSemver(appVersion, v.introduced) < 0) return false;
+  if (v.deprecatedAt && compareSemver(appVersion, v.deprecatedAt) >= 0) return false;
+  if (v.showNewUntil && compareSemver(appVersion, v.showNewUntil) >= 0) return false;
+  return true;
+}
+function isDependencyMatch(feature, dismissedIds, dependencyState) {
+  const dependsOn = feature.dependsOn;
+  if (!dependsOn) return true;
+  const seenIds = dependencyState?.seenIds;
+  const clickedIds = dependencyState?.clickedIds;
+  const dismissedDependencyIds = dependencyState?.dismissedIds ?? dismissedIds;
+  if (dependsOn.seen && dependsOn.seen.length > 0) {
+    for (const id of dependsOn.seen) {
+      const seen = seenIds?.has(id) ?? false;
+      if (!seen && !dismissedDependencyIds.has(id)) return false;
+    }
+  }
+  if (dependsOn.clicked && dependsOn.clicked.length > 0) {
+    for (const id of dependsOn.clicked) {
+      if (!(clickedIds?.has(id) ?? false)) return false;
+    }
+  }
+  if (dependsOn.dismissed && dependsOn.dismissed.length > 0) {
+    for (const id of dependsOn.dismissed) {
+      if (!dismissedDependencyIds.has(id)) return false;
+    }
+  }
+  return true;
+}
+function isNew(feature, watermark, dismissedIds, now = /* @__PURE__ */ new Date(), userContext, matchAudience, appVersion, dependencyState, triggerContext) {
+  if (dismissedIds.has(feature.id)) return false;
+  if (!isAudienceMatch(feature, userContext, matchAudience)) return false;
+  if (!isDependencyMatch(feature, dismissedIds, dependencyState)) return false;
+  if (!isVersionMatch(feature, appVersion)) return false;
+  if (!isTriggerMatch(feature.trigger, triggerContext)) return false;
+  const nowMs = now.getTime();
+  if (feature.publishAt) {
+    const publishMs = new Date(feature.publishAt).getTime();
+    if (nowMs < publishMs) return false;
+  }
+  const showUntilMs = new Date(feature.showNewUntil).getTime();
+  if (nowMs >= showUntilMs) return false;
+  if (watermark) {
+    const watermarkMs = new Date(watermark).getTime();
+    const releasedMs = new Date(feature.releasedAt).getTime();
+    if (releasedMs <= watermarkMs) return false;
+  }
+  return true;
+}
+function getNewFeatures(manifest, storage, now = /* @__PURE__ */ new Date(), userContext, matchAudience, appVersion, dependencyState, triggerContext) {
+  const watermark = storage.getWatermark();
+  const dismissedIds = storage.getDismissedIds();
+  return manifest.filter(
+    (f) => isNew(
+      f,
+      watermark,
+      dismissedIds,
+      now,
+      userContext,
+      matchAudience,
+      appVersion,
+      dependencyState,
+      triggerContext
+    )
+  );
+}
+
+// src/helpers.ts
+function createManifest(entries) {
+  return Object.freeze([...entries]);
+}
+function getFeatureById(manifest, id) {
+  return manifest.find((f) => f.id === id);
+}
+
+// src/throttle.ts
+function sortByPriorityAndRecency(features) {
+  const priorityWeight = { critical: 3, normal: 2, low: 1 };
+  return [...features].sort((a, b) => {
+    const scoreA = priorityWeight[a.priority ?? "normal"];
+    const scoreB = priorityWeight[b.priority ?? "normal"];
+    if (scoreA !== scoreB) return scoreB - scoreA;
+    return new Date(b.releasedAt).getTime() - new Date(a.releasedAt).getTime();
+  });
+}
+function applyAnnouncementThrottle(features, options, state, now = Date.now()) {
+  const sorted = sortByPriorityAndRecency(features);
+  if (sorted.length === 0) {
+    return { visible: [], queued: [] };
+  }
+  if (options?.sessionCooldown && options.sessionCooldown > 0) {
+    const elapsed = now - state.sessionStartedAt;
+    if (elapsed < options.sessionCooldown) {
+      return { visible: [], queued: sorted };
+    }
+  }
+  if (options?.respectDoNotDisturb && state.quietMode) {
+    const visible = sorted.filter((feature) => feature.priority === "critical");
+    const queued = sorted.filter((feature) => feature.priority !== "critical");
+    return { visible, queued };
+  }
+  const maxVisible = options?.maxSimultaneousBadges;
+  if (!maxVisible || !Number.isFinite(maxVisible) || maxVisible < 1) {
+    return { visible: sorted, queued: [] };
+  }
+  return {
+    visible: sorted.slice(0, maxVisible),
+    queued: sorted.slice(maxVisible)
+  };
+}
+
+// src/i18n.ts
+var EN_TRANSLATIONS = {
+  newBadge: "New",
+  whatsNewTitle: "What's New",
+  markAllRead: "Mark all as read",
+  allCaughtUp: "You're all caught up!",
+  close: "Close",
+  changelogTitle: "Changelog",
+  searchPlaceholder: "Search updates",
+  allCategories: "All categories",
+  noUpdatesYet: "No updates yet",
+  loadMore: "Load more",
+  share: "Share",
+  skipToEntries: "Skip to changelog entries",
+  stepOf: (current, total) => `Step ${current} of ${total}`,
+  back: "Back",
+  next: "Next",
+  skip: "Skip",
+  finish: "Finish",
+  gotIt: "Got it",
+  announcement: "Announcement",
+  feedbackTitle: "Share feedback",
+  feedbackTrigger: "Feedback",
+  feedbackSubmitted: "Thanks for the feedback.",
+  submit: "Submit",
+  cancel: "Cancel",
+  askLater: "Ask me later"
+};
+var SIMPLE_TRANSLATIONS = {
+  es: {
+    newBadge: "Nuevo",
+    whatsNewTitle: "Novedades",
+    markAllRead: "Marcar todo como le\xEDdo",
+    allCaughtUp: "Est\xE1s al d\xEDa.",
+    close: "Cerrar",
+    changelogTitle: "Registro de cambios",
+    searchPlaceholder: "Buscar actualizaciones",
+    allCategories: "Todas las categor\xEDas",
+    noUpdatesYet: "A\xFAn no hay actualizaciones",
+    loadMore: "Cargar m\xE1s",
+    share: "Compartir",
+    skipToEntries: "Saltar a las entradas del changelog",
+    back: "Atr\xE1s",
+    next: "Siguiente",
+    skip: "Saltar",
+    finish: "Finalizar",
+    gotIt: "Entendido",
+    announcement: "Anuncio",
+    feedbackTitle: "Enviar comentarios",
+    feedbackTrigger: "Comentarios",
+    feedbackSubmitted: "Gracias por tus comentarios.",
+    submit: "Enviar",
+    cancel: "Cancelar",
+    askLater: "Preguntar m\xE1s tarde"
+  },
+  fr: {
+    newBadge: "Nouveau",
+    whatsNewTitle: "Nouveaut\xE9s",
+    markAllRead: "Tout marquer comme lu",
+    allCaughtUp: "Vous \xEAtes \xE0 jour.",
+    close: "Fermer",
+    changelogTitle: "Journal des changements",
+    searchPlaceholder: "Rechercher des mises \xE0 jour",
+    allCategories: "Toutes les cat\xE9gories",
+    noUpdatesYet: "Aucune mise \xE0 jour",
+    loadMore: "Charger plus",
+    share: "Partager",
+    skipToEntries: "Aller aux entr\xE9es du changelog",
+    back: "Retour",
+    next: "Suivant",
+    skip: "Passer",
+    finish: "Terminer",
+    gotIt: "Compris",
+    announcement: "Annonce",
+    feedbackTitle: "Partager un avis",
+    feedbackTrigger: "Avis",
+    feedbackSubmitted: "Merci pour votre avis.",
+    submit: "Envoyer",
+    cancel: "Annuler",
+    askLater: "Demander plus tard"
+  },
+  de: {
+    newBadge: "Neu",
+    whatsNewTitle: "Neuigkeiten",
+    markAllRead: "Alles als gelesen markieren",
+    allCaughtUp: "Alles erledigt.",
+    close: "Schlie\xDFen",
+    changelogTitle: "\xC4nderungsprotokoll",
+    searchPlaceholder: "Updates suchen",
+    allCategories: "Alle Kategorien",
+    noUpdatesYet: "Noch keine Updates",
+    loadMore: "Mehr laden",
+    share: "Teilen",
+    skipToEntries: "Zu den Eintr\xE4gen springen",
+    back: "Zur\xFCck",
+    next: "Weiter",
+    skip: "\xDCberspringen",
+    finish: "Fertig",
+    gotIt: "Verstanden",
+    announcement: "Ank\xFCndigung",
+    feedbackTitle: "Feedback teilen",
+    feedbackTrigger: "Feedback",
+    feedbackSubmitted: "Danke f\xFCr dein Feedback.",
+    submit: "Senden",
+    cancel: "Abbrechen",
+    askLater: "Sp\xE4ter fragen"
+  },
+  pt: {
+    newBadge: "Novo",
+    whatsNewTitle: "Novidades",
+    markAllRead: "Marcar tudo como lido",
+    allCaughtUp: "Tudo em dia.",
+    close: "Fechar",
+    changelogTitle: "Hist\xF3rico de mudan\xE7as",
+    searchPlaceholder: "Buscar atualiza\xE7\xF5es",
+    allCategories: "Todas as categorias",
+    noUpdatesYet: "Sem atualiza\xE7\xF5es ainda",
+    loadMore: "Carregar mais",
+    share: "Compartilhar",
+    skipToEntries: "Ir para entradas do changelog",
+    back: "Voltar",
+    next: "Pr\xF3ximo",
+    skip: "Pular",
+    finish: "Concluir",
+    gotIt: "Entendi",
+    announcement: "An\xFAncio",
+    feedbackTitle: "Enviar feedback",
+    feedbackTrigger: "Feedback",
+    feedbackSubmitted: "Obrigado pelo feedback.",
+    submit: "Enviar",
+    cancel: "Cancelar",
+    askLater: "Perguntar depois"
+  },
+  "zh-cn": {
+    newBadge: "\u65B0",
+    whatsNewTitle: "\u6700\u65B0\u52A8\u6001",
+    markAllRead: "\u5168\u90E8\u6807\u8BB0\u4E3A\u5DF2\u8BFB",
+    allCaughtUp: "\u4F60\u5DF2\u67E5\u770B\u5168\u90E8\u66F4\u65B0\u3002",
+    close: "\u5173\u95ED",
+    changelogTitle: "\u66F4\u65B0\u65E5\u5FD7",
+    searchPlaceholder: "\u641C\u7D22\u66F4\u65B0",
+    allCategories: "\u5168\u90E8\u5206\u7C7B",
+    noUpdatesYet: "\u6682\u65E0\u66F4\u65B0",
+    loadMore: "\u52A0\u8F7D\u66F4\u591A",
+    share: "\u5206\u4EAB",
+    skipToEntries: "\u8DF3\u8F6C\u5230\u66F4\u65B0\u6761\u76EE",
+    back: "\u8FD4\u56DE",
+    next: "\u4E0B\u4E00\u6B65",
+    skip: "\u8DF3\u8FC7",
+    finish: "\u5B8C\u6210",
+    gotIt: "\u77E5\u9053\u4E86",
+    announcement: "\u516C\u544A",
+    feedbackTitle: "\u63D0\u4EA4\u53CD\u9988",
+    feedbackTrigger: "\u53CD\u9988",
+    feedbackSubmitted: "\u611F\u8C22\u4F60\u7684\u53CD\u9988\u3002",
+    submit: "\u63D0\u4EA4",
+    cancel: "\u53D6\u6D88",
+    askLater: "\u7A0D\u540E\u8BE2\u95EE"
+  },
+  ja: {
+    newBadge: "\u65B0\u7740",
+    whatsNewTitle: "\u65B0\u6A5F\u80FD",
+    markAllRead: "\u3059\u3079\u3066\u65E2\u8AAD\u306B\u3059\u308B",
+    allCaughtUp: "\u3059\u3079\u3066\u78BA\u8A8D\u6E08\u307F\u3067\u3059\u3002",
+    close: "\u9589\u3058\u308B",
+    changelogTitle: "\u5909\u66F4\u5C65\u6B74",
+    searchPlaceholder: "\u66F4\u65B0\u3092\u691C\u7D22",
+    allCategories: "\u3059\u3079\u3066\u306E\u30AB\u30C6\u30B4\u30EA",
+    noUpdatesYet: "\u66F4\u65B0\u306F\u3042\u308A\u307E\u305B\u3093",
+    loadMore: "\u3055\u3089\u306B\u8868\u793A",
+    share: "\u5171\u6709",
+    skipToEntries: "\u5909\u66F4\u5C65\u6B74\u3078\u79FB\u52D5",
+    back: "\u623B\u308B",
+    next: "\u6B21\u3078",
+    skip: "\u30B9\u30AD\u30C3\u30D7",
+    finish: "\u5B8C\u4E86",
+    gotIt: "\u4E86\u89E3",
+    announcement: "\u304A\u77E5\u3089\u305B",
+    feedbackTitle: "\u30D5\u30A3\u30FC\u30C9\u30D0\u30C3\u30AF\u3092\u9001\u4FE1",
+    feedbackTrigger: "\u30D5\u30A3\u30FC\u30C9\u30D0\u30C3\u30AF",
+    feedbackSubmitted: "\u30D5\u30A3\u30FC\u30C9\u30D0\u30C3\u30AF\u3042\u308A\u304C\u3068\u3046\u3054\u3056\u3044\u307E\u3059\u3002",
+    submit: "\u9001\u4FE1",
+    cancel: "\u30AD\u30E3\u30F3\u30BB\u30EB",
+    askLater: "\u5F8C\u3067\u805E\u304F"
+  },
+  ko: {
+    newBadge: "\uC0C8\uB85C\uC6C0",
+    whatsNewTitle: "\uC0C8 \uC18C\uC2DD",
+    markAllRead: "\uBAA8\uB450 \uC77D\uC74C \uCC98\uB9AC",
+    allCaughtUp: "\uBAA8\uB4E0 \uC5C5\uB370\uC774\uD2B8\uB97C \uD655\uC778\uD588\uC2B5\uB2C8\uB2E4.",
+    close: "\uB2EB\uAE30",
+    changelogTitle: "\uBCC0\uACBD \uB85C\uADF8",
+    searchPlaceholder: "\uC5C5\uB370\uC774\uD2B8 \uAC80\uC0C9",
+    allCategories: "\uC804\uCCB4 \uCE74\uD14C\uACE0\uB9AC",
+    noUpdatesYet: "\uC5C5\uB370\uC774\uD2B8\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4",
+    loadMore: "\uB354 \uBCF4\uAE30",
+    share: "\uACF5\uC720",
+    skipToEntries: "\uBCC0\uACBD \uD56D\uBAA9\uC73C\uB85C \uC774\uB3D9",
+    back: "\uB4A4\uB85C",
+    next: "\uB2E4\uC74C",
+    skip: "\uAC74\uB108\uB6F0\uAE30",
+    finish: "\uC644\uB8CC",
+    gotIt: "\uD655\uC778",
+    announcement: "\uACF5\uC9C0",
+    feedbackTitle: "\uD53C\uB4DC\uBC31 \uBCF4\uB0B4\uAE30",
+    feedbackTrigger: "\uD53C\uB4DC\uBC31",
+    feedbackSubmitted: "\uD53C\uB4DC\uBC31 \uAC10\uC0AC\uD569\uB2C8\uB2E4.",
+    submit: "\uC81C\uCD9C",
+    cancel: "\uCDE8\uC18C",
+    askLater: "\uB098\uC911\uC5D0 \uBB3B\uAE30"
+  },
+  ar: {
+    newBadge: "\u062C\u062F\u064A\u062F",
+    whatsNewTitle: "\u0645\u0627 \u0627\u0644\u062C\u062F\u064A\u062F",
+    markAllRead: "\u062A\u062D\u062F\u064A\u062F \u0627\u0644\u0643\u0644 \u0643\u0645\u0642\u0631\u0648\u0621",
+    allCaughtUp: "\u062A\u0645\u062A \u0645\u062A\u0627\u0628\u0639\u0629 \u0643\u0644 \u0627\u0644\u062A\u062D\u062F\u064A\u062B\u0627\u062A.",
+    close: "\u0625\u063A\u0644\u0627\u0642",
+    changelogTitle: "\u0633\u062C\u0644 \u0627\u0644\u062A\u063A\u064A\u064A\u0631\u0627\u062A",
+    searchPlaceholder: "\u0627\u0628\u062D\u062B \u0641\u064A \u0627\u0644\u062A\u062D\u062F\u064A\u062B\u0627\u062A",
+    allCategories: "\u0643\u0644 \u0627\u0644\u0641\u0626\u0627\u062A",
+    noUpdatesYet: "\u0644\u0627 \u062A\u0648\u062C\u062F \u062A\u062D\u062F\u064A\u062B\u0627\u062A \u0628\u0639\u062F",
+    loadMore: "\u062A\u062D\u0645\u064A\u0644 \u0627\u0644\u0645\u0632\u064A\u062F",
+    share: "\u0645\u0634\u0627\u0631\u0643\u0629",
+    skipToEntries: "\u062A\u062E\u0637\u064A \u0625\u0644\u0649 \u0639\u0646\u0627\u0635\u0631 \u0627\u0644\u0633\u062C\u0644",
+    back: "\u0631\u062C\u0648\u0639",
+    next: "\u0627\u0644\u062A\u0627\u0644\u064A",
+    skip: "\u062A\u062E\u0637\u064A",
+    finish: "\u0625\u0646\u0647\u0627\u0621",
+    gotIt: "\u062A\u0645",
+    announcement: "\u0625\u0639\u0644\u0627\u0646",
+    feedbackTitle: "\u0634\u0627\u0631\u0643 \u0645\u0644\u0627\u062D\u0638\u0627\u062A\u0643",
+    feedbackTrigger: "\u0645\u0644\u0627\u062D\u0638\u0627\u062A",
+    feedbackSubmitted: "\u0634\u0643\u0631\u064B\u0627 \u0639\u0644\u0649 \u0645\u0644\u0627\u062D\u0638\u0627\u062A\u0643.",
+    submit: "\u0625\u0631\u0633\u0627\u0644",
+    cancel: "\u0625\u0644\u063A\u0627\u0621",
+    askLater: "\u0627\u0633\u0623\u0644\u0646\u064A \u0644\u0627\u062D\u0642\u064B\u0627"
+  },
+  hi: {
+    newBadge: "\u0928\u092F\u093E",
+    whatsNewTitle: "\u0928\u092F\u093E \u0915\u094D\u092F\u093E \u0939\u0948",
+    markAllRead: "\u0938\u092D\u0940 \u0915\u094B \u092A\u0922\u093C\u093E \u0939\u0941\u0906 \u091A\u093F\u0939\u094D\u0928\u093F\u0924 \u0915\u0930\u0947\u0902",
+    allCaughtUp: "\u0906\u092A\u0928\u0947 \u0938\u092D\u0940 \u0905\u092A\u0921\u0947\u091F \u0926\u0947\u0916 \u0932\u093F\u090F \u0939\u0948\u0902\u0964",
+    close: "\u092C\u0902\u0926 \u0915\u0930\u0947\u0902",
+    changelogTitle: "\u092A\u0930\u093F\u0935\u0930\u094D\u0924\u0928 \u0938\u0942\u091A\u0940",
+    searchPlaceholder: "\u0905\u092A\u0921\u0947\u091F \u0916\u094B\u091C\u0947\u0902",
+    allCategories: "\u0938\u092D\u0940 \u0936\u094D\u0930\u0947\u0923\u093F\u092F\u093E\u0902",
+    noUpdatesYet: "\u0905\u092D\u0940 \u0915\u094B\u0908 \u0905\u092A\u0921\u0947\u091F \u0928\u0939\u0940\u0902",
+    loadMore: "\u0914\u0930 \u0932\u094B\u0921 \u0915\u0930\u0947\u0902",
+    share: "\u0938\u093E\u091D\u093E \u0915\u0930\u0947\u0902",
+    skipToEntries: "\u091A\u0947\u0902\u091C\u0932\u0949\u0917 \u092A\u094D\u0930\u0935\u093F\u0937\u094D\u091F\u093F\u092F\u094B\u0902 \u092A\u0930 \u091C\u093E\u090F\u0902",
+    back: "\u0935\u093E\u092A\u0938",
+    next: "\u0905\u0917\u0932\u093E",
+    skip: "\u091B\u094B\u0921\u093C\u0947\u0902",
+    finish: "\u0938\u092E\u093E\u092A\u094D\u0924",
+    gotIt: "\u0920\u0940\u0915 \u0939\u0948",
+    announcement: "\u0918\u094B\u0937\u0923\u093E",
+    feedbackTitle: "\u092B\u0940\u0921\u092C\u0948\u0915 \u0938\u093E\u091D\u093E \u0915\u0930\u0947\u0902",
+    feedbackTrigger: "\u092B\u0940\u0921\u092C\u0948\u0915",
+    feedbackSubmitted: "\u092B\u0940\u0921\u092C\u0948\u0915 \u0915\u0947 \u0932\u093F\u090F \u0927\u0928\u094D\u092F\u0935\u093E\u0926\u0964",
+    submit: "\u091C\u092E\u093E \u0915\u0930\u0947\u0902",
+    cancel: "\u0930\u0926\u094D\u0926 \u0915\u0930\u0947\u0902",
+    askLater: "\u092C\u093E\u0926 \u092E\u0947\u0902 \u092A\u0942\u091B\u0947\u0902"
+  }
+};
+function resolveTranslations(locale, overrides) {
+  const normalizedLocale = (locale ?? "en").toLowerCase();
+  const base = SIMPLE_TRANSLATIONS[normalizedLocale] ?? SIMPLE_TRANSLATIONS[normalizedLocale.split("-")[0]] ?? {};
+  return {
+    ...EN_TRANSLATIONS,
+    ...base,
+    ...overrides ?? {},
+    stepOf: overrides?.stepOf ?? EN_TRANSLATIONS.stepOf
+  };
+}
+
+// src/variants.ts
+var VARIANT_META_KEY = "featuredropVariant";
+var VARIANT_KEY_STORAGE = "featuredrop:variant-key";
+function readStorageValue(key) {
+  const storage = globalThis.localStorage;
+  if (!storage || typeof storage.getItem !== "function") return null;
+  try {
+    return storage.getItem(key);
+  } catch {
+    return null;
+  }
+}
+function writeStorageValue(key, value) {
+  const storage = globalThis.localStorage;
+  if (!storage || typeof storage.setItem !== "function") return;
+  try {
+    storage.setItem(key, value);
+  } catch {
+  }
+}
+function hashToPercent(value) {
+  let hash = 2166136261;
+  for (let i = 0; i < value.length; i += 1) {
+    hash ^= value.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0) % 100;
+}
+function normalizeSplit(count, split) {
+  if (!split || split.length !== count) {
+    return Array.from({ length: count }, () => 100 / count);
+  }
+  const cleaned = split.map((value) => Number.isFinite(value) && value > 0 ? value : 0);
+  const total = cleaned.reduce((sum, value) => sum + value, 0);
+  if (total <= 0) {
+    return Array.from({ length: count }, () => 100 / count);
+  }
+  return cleaned.map((value) => value / total * 100);
+}
+function pickVariantName(feature, variantKey) {
+  const variants = feature.variants;
+  if (!variants) return null;
+  const names = Object.keys(variants);
+  if (names.length === 0) return null;
+  if (names.length === 1) return names[0];
+  const split = normalizeSplit(names.length, feature.variantSplit);
+  const bucket = hashToPercent(`${feature.id}:${variantKey}`);
+  let cumulative = 0;
+  for (let i = 0; i < names.length; i += 1) {
+    cumulative += split[i];
+    if (bucket < cumulative) return names[i];
+  }
+  return names[names.length - 1];
+}
+function getFeatureVariantName(feature) {
+  const raw = feature.meta?.[VARIANT_META_KEY];
+  return typeof raw === "string" ? raw : void 0;
+}
+function applyFeatureVariant(feature, variantKey) {
+  const variantName = pickVariantName(feature, variantKey);
+  if (!variantName) return feature;
+  const variant = feature.variants?.[variantName];
+  if (!variant) return feature;
+  return {
+    ...feature,
+    label: variant.label ?? feature.label,
+    description: variant.description ?? feature.description,
+    image: variant.image ?? feature.image,
+    cta: variant.cta ?? feature.cta,
+    meta: {
+      ...feature.meta ?? {},
+      ...variant.meta ?? {},
+      [VARIANT_META_KEY]: variantName
+    }
+  };
+}
+function applyFeatureVariants(manifest, variantKey) {
+  return manifest.map((feature) => applyFeatureVariant(feature, variantKey));
+}
+function createRandomKey() {
+  return Math.random().toString(36).slice(2, 12);
+}
+function getOrCreateVariantKey(explicitKey) {
+  if (explicitKey) return explicitKey;
+  const existing = readStorageValue(VARIANT_KEY_STORAGE);
+  if (existing) return existing;
+  const next = createRandomKey();
+  writeStorageValue(VARIANT_KEY_STORAGE, next);
+  return next;
+}
+var FeatureDropContext = createContext(
+  null
+);
+var QUIET_MODE_STORAGE_KEY = "featuredrop:quiet-mode";
+var SEEN_FEATURES_STORAGE_KEY = "featuredrop:seen-features";
+var CLICKED_FEATURES_STORAGE_KEY = "featuredrop:clicked-features";
+function getCurrentPath() {
+  if (typeof window === "undefined") return "";
+  return `${window.location.pathname}${window.location.search}${window.location.hash}`;
+}
+function getScrollPercent() {
+  if (typeof window === "undefined" || typeof document === "undefined") return 0;
+  const root = document.documentElement;
+  const max = root.scrollHeight - window.innerHeight;
+  if (max <= 0) return 100;
+  return Math.max(0, Math.min(100, Math.round(window.scrollY / max * 100)));
+}
+function readQuietMode() {
+  const storage = globalThis.localStorage;
+  if (!storage || typeof storage.getItem !== "function") return false;
+  try {
+    return storage.getItem(QUIET_MODE_STORAGE_KEY) === "1";
+  } catch {
+    return false;
+  }
+}
+function writeQuietMode(enabled) {
+  const storage = globalThis.localStorage;
+  if (!storage || typeof storage.setItem !== "function") return;
+  try {
+    storage.setItem(QUIET_MODE_STORAGE_KEY, enabled ? "1" : "0");
+  } catch {
+  }
+}
+function readIdSet(key) {
+  const storage = globalThis.localStorage;
+  if (!storage || typeof storage.getItem !== "function") return /* @__PURE__ */ new Set();
+  try {
+    const raw = storage.getItem(key);
+    if (!raw) return /* @__PURE__ */ new Set();
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return /* @__PURE__ */ new Set();
+    return new Set(parsed.filter((value) => typeof value === "string"));
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function writeIdSet(key, values) {
+  const storage = globalThis.localStorage;
+  if (!storage || typeof storage.setItem !== "function") return;
+  try {
+    storage.setItem(key, JSON.stringify(Array.from(values)));
+  } catch {
+  }
+}
+function computeFeatureState({
+  manifest,
+  storage,
+  now,
+  userContext,
+  matchAudience,
+  appVersion,
+  throttle,
+  sessionStartedAt,
+  quietMode,
+  seenFeatureIds,
+  clickedFeatureIds,
+  triggerContext
+}) {
+  const dismissedIds = storage.getDismissedIds();
+  const allFeatures = getNewFeatures(
+    manifest,
+    storage,
+    now,
+    userContext,
+    matchAudience,
+    appVersion,
+    {
+      seenIds: seenFeatureIds,
+      clickedIds: clickedFeatureIds,
+      dismissedIds
+    },
+    triggerContext
+  );
+  const throttled = applyAnnouncementThrottle(
+    allFeatures,
+    throttle,
+    {
+      sessionStartedAt,
+      quietMode
+    },
+    now.getTime()
+  );
+  return {
+    allFeatures,
+    visibleFeatures: throttled.visible,
+    queuedFeatures: throttled.queued
+  };
+}
+function FeatureDropProvider({
+  manifest,
+  storage,
+  analytics,
+  userContext,
+  matchAudience: matchAudienceFn,
+  appVersion,
+  throttle,
+  variantKey,
+  collector,
+  locale = "en",
+  translations: translationOverrides,
+  children
+}) {
+  const analyticsRef = useRef(analytics);
+  analyticsRef.current = analytics;
+  const sessionStartedAtRef = useRef(Date.now());
+  const lastModalAtRef = useRef(null);
+  const lastTourAtRef = useRef(null);
+  const activeSpotlightIdsRef = useRef(/* @__PURE__ */ new Set());
+  const triggerEngineRef = useRef(null);
+  if (!triggerEngineRef.current) {
+    triggerEngineRef.current = new TriggerEngine({
+      path: getCurrentPath(),
+      scrollPercent: getScrollPercent()
+    });
+  }
+  const lastScrollPercentRef = useRef(getScrollPercent());
+  const [triggerVersion, setTriggerVersion] = useState(0);
+  const [quietMode, setQuietModeState] = useState(() => readQuietMode());
+  const [toastShownIds, setToastShownIds] = useState(/* @__PURE__ */ new Set());
+  const [activeSpotlightIds, setActiveSpotlightIds] = useState(/* @__PURE__ */ new Set());
+  const [seenFeatureIds, setSeenFeatureIds] = useState(
+    () => readIdSet(SEEN_FEATURES_STORAGE_KEY)
+  );
+  const [clickedFeatureIds, setClickedFeatureIds] = useState(
+    () => readIdSet(CLICKED_FEATURES_STORAGE_KEY)
+  );
+  const resolvedVariantKey = useMemo(() => getOrCreateVariantKey(variantKey), [variantKey]);
+  const translations = useMemo(
+    () => resolveTranslations(locale, translationOverrides),
+    [locale, translationOverrides]
+  );
+  const resolvedManifest = useMemo(
+    () => applyFeatureVariants(manifest, resolvedVariantKey),
+    [manifest, resolvedVariantKey]
+  );
+  const [featureState, setFeatureState] = useState(
+    () => computeFeatureState({
+      manifest: resolvedManifest,
+      storage,
+      now: /* @__PURE__ */ new Date(),
+      userContext,
+      matchAudience: matchAudienceFn,
+      appVersion,
+      throttle,
+      sessionStartedAt: sessionStartedAtRef.current,
+      quietMode: readQuietMode(),
+      seenFeatureIds: readIdSet(SEEN_FEATURES_STORAGE_KEY),
+      clickedFeatureIds: readIdSet(CLICKED_FEATURES_STORAGE_KEY),
+      triggerContext: (() => {
+        const engine = triggerEngineRef.current;
+        if (!engine) return void 0;
+        engine.setElapsedMs(Date.now() - sessionStartedAtRef.current);
+        return engine.getContext();
+      })()
+    })
+  );
+  const recompute = useCallback(() => {
+    const engine = triggerEngineRef.current;
+    let triggerContext;
+    if (engine) {
+      engine.setElapsedMs(Date.now() - sessionStartedAtRef.current);
+      triggerContext = engine.getContext();
+    }
+    setFeatureState(
+      computeFeatureState({
+        manifest: resolvedManifest,
+        storage,
+        now: /* @__PURE__ */ new Date(),
+        userContext,
+        matchAudience: matchAudienceFn,
+        appVersion,
+        throttle,
+        sessionStartedAt: sessionStartedAtRef.current,
+        quietMode,
+        seenFeatureIds,
+        clickedFeatureIds,
+        triggerContext
+      })
+    );
+  }, [
+    resolvedManifest,
+    storage,
+    userContext,
+    matchAudienceFn,
+    appVersion,
+    throttle,
+    quietMode,
+    seenFeatureIds,
+    clickedFeatureIds,
+    triggerVersion
+  ]);
+  useEffect(() => {
+    recompute();
+  }, [recompute]);
+  const hasTimeTriggers = useMemo(
+    () => resolvedManifest.some((feature) => feature.trigger?.type === "time"),
+    [resolvedManifest]
+  );
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    const updatePath = () => {
+      triggerEngineRef.current?.setPath(getCurrentPath());
+      setTriggerVersion((value2) => value2 + 1);
+    };
+    window.addEventListener("popstate", updatePath);
+    window.addEventListener("hashchange", updatePath);
+    return () => {
+      window.removeEventListener("popstate", updatePath);
+      window.removeEventListener("hashchange", updatePath);
+    };
+  }, []);
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    const updateScroll = () => {
+      const percent = getScrollPercent();
+      if (percent === lastScrollPercentRef.current) return;
+      lastScrollPercentRef.current = percent;
+      triggerEngineRef.current?.setScrollPercent(percent);
+      setTriggerVersion((value2) => value2 + 1);
+    };
+    updateScroll();
+    window.addEventListener("scroll", updateScroll, { passive: true });
+    window.addEventListener("resize", updateScroll);
+    return () => {
+      window.removeEventListener("scroll", updateScroll);
+      window.removeEventListener("resize", updateScroll);
+    };
+  }, []);
+  useEffect(() => {
+    if (!hasTimeTriggers) return;
+    const timer = setInterval(() => {
+      setTriggerVersion((value2) => value2 + 1);
+    }, 1e3);
+    return () => {
+      clearInterval(timer);
+    };
+  }, [hasTimeTriggers]);
+  useEffect(() => {
+    const sessionCooldown = throttle?.sessionCooldown;
+    if (!sessionCooldown || sessionCooldown <= 0) return;
+    const elapsed = Date.now() - sessionStartedAtRef.current;
+    const remaining = sessionCooldown - elapsed;
+    if (remaining <= 0) return;
+    const timer = setTimeout(() => {
+      recompute();
+    }, remaining + 5);
+    return () => clearTimeout(timer);
+  }, [recompute, throttle?.sessionCooldown]);
+  useEffect(() => {
+    let changed = false;
+    const next = new Set(seenFeatureIds);
+    for (const feature of featureState.visibleFeatures) {
+      if (next.has(feature.id)) continue;
+      next.add(feature.id);
+      changed = true;
+    }
+    if (!changed) return;
+    setSeenFeatureIds(next);
+    writeIdSet(SEEN_FEATURES_STORAGE_KEY, next);
+  }, [featureState.visibleFeatures, seenFeatureIds]);
+  const dismiss = useCallback(
+    (id) => {
+      const feature = getFeatureById(resolvedManifest, id);
+      storage.dismiss(id);
+      if (feature) {
+        analyticsRef.current?.onFeatureDismissed?.(feature);
+      }
+      collector?.track({
+        type: "feature_dismissed",
+        featureId: id,
+        variant: feature ? getFeatureVariantName(feature) : void 0
+      });
+      recompute();
+    },
+    [collector, resolvedManifest, storage, recompute]
+  );
+  const dismissAll = useCallback(async () => {
+    await storage.dismissAll(/* @__PURE__ */ new Date());
+    analyticsRef.current?.onAllDismissed?.();
+    recompute();
+  }, [recompute, storage]);
+  const inSessionCooldown = useCallback((now) => {
+    const sessionCooldown = throttle?.sessionCooldown ?? 0;
+    if (!sessionCooldown || sessionCooldown <= 0) return false;
+    return now - sessionStartedAtRef.current < sessionCooldown;
+  }, [throttle?.sessionCooldown]);
+  const shouldSuppressForQuietMode = useCallback((priority) => {
+    if (!throttle?.respectDoNotDisturb || !quietMode) return false;
+    return priority !== "critical";
+  }, [quietMode, throttle?.respectDoNotDisturb]);
+  const getRemainingToastSlots = useCallback(() => {
+    const maxToastsPerSession = throttle?.maxToastsPerSession;
+    if (!maxToastsPerSession || maxToastsPerSession <= 0) return Number.POSITIVE_INFINITY;
+    return Math.max(0, maxToastsPerSession - toastShownIds.size);
+  }, [throttle?.maxToastsPerSession, toastShownIds.size]);
+  const markToastsShown = useCallback((featureIds) => {
+    if (featureIds.length === 0) return;
+    setToastShownIds((previous) => {
+      let changed = false;
+      const next = new Set(previous);
+      for (const id of featureIds) {
+        if (!id || next.has(id)) continue;
+        next.add(id);
+        changed = true;
+      }
+      return changed ? next : previous;
+    });
+  }, []);
+  const canShowModal = useCallback((priority) => {
+    const now = Date.now();
+    if (inSessionCooldown(now)) return false;
+    if (shouldSuppressForQuietMode(priority)) return false;
+    const minTime = throttle?.minTimeBetweenModals ?? 0;
+    const lastShown = lastModalAtRef.current;
+    if (minTime > 0 && lastShown && now - lastShown < minTime) return false;
+    return true;
+  }, [inSessionCooldown, shouldSuppressForQuietMode, throttle?.minTimeBetweenModals]);
+  const markModalShown = useCallback(() => {
+    lastModalAtRef.current = Date.now();
+  }, []);
+  const canShowTour = useCallback(() => {
+    const now = Date.now();
+    if (inSessionCooldown(now)) return false;
+    if (shouldSuppressForQuietMode(void 0)) return false;
+    const minTime = throttle?.minTimeBetweenTours ?? 0;
+    const lastShown = lastTourAtRef.current;
+    if (minTime > 0 && lastShown && now - lastShown < minTime) return false;
+    return true;
+  }, [inSessionCooldown, shouldSuppressForQuietMode, throttle?.minTimeBetweenTours]);
+  const markTourShown = useCallback(() => {
+    lastTourAtRef.current = Date.now();
+  }, []);
+  const acquireSpotlightSlot = useCallback((id, priority) => {
+    if (!id) return false;
+    if (shouldSuppressForQuietMode(priority)) return false;
+    const current = activeSpotlightIdsRef.current;
+    if (current.has(id)) return true;
+    const maxSpotlights = throttle?.maxSimultaneousSpotlights;
+    if (maxSpotlights && maxSpotlights > 0 && current.size >= maxSpotlights) return false;
+    const next = new Set(current);
+    next.add(id);
+    activeSpotlightIdsRef.current = next;
+    setActiveSpotlightIds(next);
+    return true;
+  }, [shouldSuppressForQuietMode, throttle?.maxSimultaneousSpotlights]);
+  const releaseSpotlightSlot = useCallback((id) => {
+    if (!id) return;
+    const current = activeSpotlightIdsRef.current;
+    if (!current.has(id)) return;
+    const next = new Set(current);
+    next.delete(id);
+    activeSpotlightIdsRef.current = next;
+    setActiveSpotlightIds(next);
+  }, []);
+  const setQuietMode = useCallback((enabled) => {
+    setQuietModeState(enabled);
+    writeQuietMode(enabled);
+  }, []);
+  const markFeatureSeen = useCallback((featureId) => {
+    setSeenFeatureIds((previous) => {
+      if (previous.has(featureId)) return previous;
+      const next = new Set(previous);
+      next.add(featureId);
+      writeIdSet(SEEN_FEATURES_STORAGE_KEY, next);
+      const feature = getFeatureById(resolvedManifest, featureId);
+      collector?.track({
+        type: "feature_seen",
+        featureId,
+        variant: feature ? getFeatureVariantName(feature) : void 0
+      });
+      return next;
+    });
+  }, [collector, resolvedManifest]);
+  const markFeatureClicked = useCallback((featureId) => {
+    setClickedFeatureIds((previous) => {
+      if (previous.has(featureId)) return previous;
+      const next = new Set(previous);
+      next.add(featureId);
+      writeIdSet(CLICKED_FEATURES_STORAGE_KEY, next);
+      const feature = getFeatureById(resolvedManifest, featureId);
+      collector?.track({
+        type: "feature_clicked",
+        featureId,
+        variant: feature ? getFeatureVariantName(feature) : void 0
+      });
+      return next;
+    });
+  }, [collector, resolvedManifest]);
+  const trackAdoptionEvent = useCallback((event) => {
+    if (!collector) return;
+    const feature = event.featureId ? getFeatureById(resolvedManifest, event.featureId) : void 0;
+    collector.track({
+      ...event,
+      variant: event.variant ?? (feature ? getFeatureVariantName(feature) : void 0)
+    });
+  }, [collector, resolvedManifest]);
+  const trackUsageEvent = useCallback((event, delta = 1) => {
+    if (!event) return;
+    triggerEngineRef.current?.trackUsage(event, delta);
+    setTriggerVersion((value2) => value2 + 1);
+  }, []);
+  const trackTriggerEvent = useCallback((event) => {
+    if (!event) return;
+    triggerEngineRef.current?.trackEvent(event);
+    setTriggerVersion((value2) => value2 + 1);
+  }, []);
+  const trackMilestone = useCallback((event) => {
+    if (!event) return;
+    triggerEngineRef.current?.trackMilestone(event);
+    setTriggerVersion((value2) => value2 + 1);
+  }, []);
+  const setTriggerPath = useCallback((path) => {
+    if (!path) return;
+    triggerEngineRef.current?.setPath(path);
+    setTriggerVersion((value2) => value2 + 1);
+  }, []);
+  const isNewFn = useCallback(
+    (sidebarKey) => featureState.visibleFeatures.some((feature) => feature.sidebarKey === sidebarKey),
+    [featureState.visibleFeatures]
+  );
+  const getFeature = useCallback(
+    (sidebarKey) => featureState.visibleFeatures.find((feature) => feature.sidebarKey === sidebarKey),
+    [featureState.visibleFeatures]
+  );
+  const newFeaturesSorted = useMemo(() => {
+    const priorityOrder = { critical: 0, normal: 1, low: 2 };
+    return [...featureState.visibleFeatures].sort((a, b) => {
+      const pa = priorityOrder[a.priority ?? "normal"];
+      const pb = priorityOrder[b.priority ?? "normal"];
+      if (pa !== pb) return pa - pb;
+      return new Date(b.releasedAt).getTime() - new Date(a.releasedAt).getTime();
+    });
+  }, [featureState.visibleFeatures]);
+  const value = useMemo(
+    () => ({
+      manifest: resolvedManifest,
+      newFeatures: featureState.visibleFeatures,
+      queuedFeatures: featureState.queuedFeatures,
+      newCount: featureState.visibleFeatures.length,
+      totalNewCount: featureState.allFeatures.length,
+      newFeaturesSorted,
+      isNew: isNewFn,
+      dismiss,
+      dismissAll,
+      getFeature,
+      quietMode,
+      setQuietMode,
+      markFeatureSeen,
+      markFeatureClicked,
+      getRemainingToastSlots,
+      markToastsShown,
+      canShowModal,
+      markModalShown,
+      canShowTour,
+      markTourShown,
+      acquireSpotlightSlot,
+      releaseSpotlightSlot,
+      activeSpotlightCount: activeSpotlightIds.size,
+      trackAdoptionEvent,
+      locale,
+      translations,
+      trackUsageEvent,
+      trackTriggerEvent,
+      trackMilestone,
+      setTriggerPath
+    }),
+    [
+      resolvedManifest,
+      featureState.visibleFeatures,
+      featureState.queuedFeatures,
+      featureState.allFeatures.length,
+      newFeaturesSorted,
+      isNewFn,
+      dismiss,
+      dismissAll,
+      getFeature,
+      quietMode,
+      setQuietMode,
+      markFeatureSeen,
+      markFeatureClicked,
+      getRemainingToastSlots,
+      markToastsShown,
+      canShowModal,
+      markModalShown,
+      canShowTour,
+      markTourShown,
+      acquireSpotlightSlot,
+      releaseSpotlightSlot,
+      activeSpotlightIds.size,
+      trackAdoptionEvent,
+      locale,
+      translations,
+      trackUsageEvent,
+      trackTriggerEvent,
+      trackMilestone,
+      setTriggerPath
+    ]
+  );
+  return /* @__PURE__ */ jsx(FeatureDropContext.Provider, { value, children });
+}
+function toSlug(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-");
+}
+function toIso(value, now, fallbackDays = 0) {
+  const trimmed = value.trim();
+  if (!trimmed || trimmed === "today") return new Date(now).toISOString();
+  const rel = trimmed.match(/^([+-]\d+)d$/);
+  if (rel) {
+    const days = Number(rel[1]);
+    return new Date(now.getTime() + days * 24 * 60 * 60 * 1e3).toISOString();
+  }
+  const parsed = new Date(trimmed).getTime();
+  if (Number.isFinite(parsed)) return new Date(parsed).toISOString();
+  return new Date(now.getTime() + fallbackDays * 24 * 60 * 60 * 1e3).toISOString();
+}
+function createMockManifest(entries, now = /* @__PURE__ */ new Date()) {
+  const normalized = entries.map((entry, index) => {
+    const label = entry.label?.trim() || `Feature ${index + 1}`;
+    const id = entry.id?.trim() || toSlug(label) || `feature-${index + 1}`;
+    const releasedAt = toIso(entry.releasedAt ?? "today", now);
+    const showNewUntil = toIso(entry.showNewUntil ?? "+14d", now, 14);
+    const normalizedEntry = {
+      ...entry,
+      id,
+      label,
+      releasedAt,
+      showNewUntil,
+      type: entry.type ?? "feature"
+    };
+    return normalizedEntry;
+  });
+  return createManifest(normalized);
+}
+var MockStorageAdapter = class {
+  watermark;
+  dismissed = /* @__PURE__ */ new Set();
+  constructor(initial) {
+    this.watermark = initial?.watermark ?? null;
+    if (initial?.dismissedIds) {
+      for (const id of initial.dismissedIds) this.dismissed.add(id);
+    }
+  }
+  getWatermark() {
+    return this.watermark;
+  }
+  getDismissedIds() {
+    return this.dismissed;
+  }
+  dismiss(id) {
+    this.dismissed.add(id);
+  }
+  async dismissAll(now) {
+    this.watermark = now.toISOString();
+    this.dismissed.clear();
+  }
+  setWatermark(watermark) {
+    this.watermark = watermark;
+  }
+  setDismissedIds(ids) {
+    this.dismissed = new Set(ids);
+  }
+  reset() {
+    this.watermark = null;
+    this.dismissed.clear();
+  }
+};
+function createMockStorage(initial) {
+  return new MockStorageAdapter(initial);
+}
+function createTestProvider(props) {
+  return function TestProvider({ children }) {
+    return /* @__PURE__ */ jsx(FeatureDropProvider, { ...props, children });
+  };
+}
+function getTimerController() {
+  const viController = globalThis.vi;
+  if (viController && typeof viController.advanceTimersByTime === "function") return viController;
+  const jestController = globalThis.jest;
+  if (jestController && typeof jestController.advanceTimersByTime === "function") return jestController;
+  return null;
+}
+function advanceTime(ms) {
+  const controller = getTimerController();
+  if (!controller) throw new Error("No fake timer controller found (vi/jest).");
+  controller.advanceTimersByTime(ms);
+}
+function setMockTime(now) {
+  const controller = getTimerController();
+  if (!controller || typeof controller.setSystemTime !== "function") {
+    throw new Error("Timer controller does not support setSystemTime.");
+  }
+  controller.setSystemTime(now);
+}
+var MockAnalyticsCollector = class extends AnalyticsCollector {
+  events = [];
+  constructor(options = {}) {
+    const events = [];
+    super({
+      adapter: {
+        track: (event) => {
+          events.push(event);
+        },
+        trackBatch: (batch) => {
+          events.push(...batch);
+        }
+      },
+      batchSize: options.batchSize ?? 1,
+      flushInterval: options.flushInterval ?? 0,
+      sampleRate: options.sampleRate,
+      enabled: options.enabled,
+      sessionId: options.sessionId,
+      userId: options.userId,
+      now: options.now,
+      random: options.random
+    });
+    this.events = events;
+  }
+  clear() {
+    this.events.splice(0, this.events.length);
+  }
+};
+
+export { MockAnalyticsCollector, advanceTime, createMockManifest, createMockStorage, createTestProvider, setMockTime };
+//# sourceMappingURL=testing.js.map
+//# sourceMappingURL=testing.js.map