@magicfeedback/popup-sdk 1.7.2 → 1.8.0

package/README.md

@@ -9,7 +9,7 @@ Package name: `@magicfeedback/popup-sdk`
 - Loads popup definitions from the Deepdots API
 - Triggers popups by time on page, scroll depth, click, route exit, or host-driven events
 - Emits lifecycle events so the host app can track popup activity
-- Supports route and language targeting through `segments.path` / `segments.lang`
+- Supports route and language targeting through `segments.path` / `segments.excludedPaths` / `segments.lang`
 - Collects analytics (navigation, engagement, messaging, crashes) and sends them to Deepdots
 - Falls back to a no-op renderer outside the browser
 
@@ -345,8 +345,8 @@ Popup definitions use these trigger types:
 ## Popup Definition Shape
 
 The API returns popup definitions with this structure. `triggers` is an array, `time_on_page`
-values are in seconds, and `segments.path` accepts full URLs, path fragments such as `/pricing`,
-or hash routes such as `/#/home`:
+values are in seconds, and `segments.path` / `segments.excludedPaths` accept full URLs, path
+fragments such as `/pricing`, or hash routes such as `/#/home`:
 
 ```ts
 interface PopupDefinition {
@@ -395,7 +395,8 @@ interface PopupDefinition {
     };
   };
   segments?: {
-    path?: string[];
+    path?: string[];          // routes where it can be shown (empty/absent = all routes)
+    excludedPaths?: string[]; // routes where it must NOT be shown; wins over `path`
     lang?: string[];
     [key: string]: unknown;
   };
@@ -431,7 +432,9 @@ interface DeepdotsEvent {
 
 ## Important Behavior Notes
 
-- `segments.path` and `segments.lang` are the segments currently evaluated by the SDK runtime. If no language can be resolved, popups with `segments.lang` are shown rather than filtered out.
+- `segments.path`, `segments.excludedPaths`, and `segments.lang` are the segments currently evaluated by the SDK runtime. If no language can be resolved, popups with `segments.lang` are shown rather than filtered out.
+- `segments.excludedPaths` wins over `segments.path`, and applies on its own when `path` is absent. So `{ "path": ["/"], "excludedPaths": ["/cart"] }` means "everywhere except the cart", and `{ "excludedPaths": ["/cart"] }` means the same thing. Both lists use the same matching rules, which includes the substring match for entries starting with `/` — an entry such as `/cart` also excludes `/cart-recovery`, and `/` on its own would exclude every route.
+- For a deferred `exit` popup, `segments.excludedPaths` is checked twice: on the route the popup was queued from, and again on the destination route where it would be painted. `segments.path` is only checked on the first one, because the destination route is different by definition.
 - `exit` triggers work across anchor navigation, hash navigation, `history.pushState()`, and `history.replaceState()`.
 - Pending `exit` popups are stored in `sessionStorage` until they are shown or discarded.
 - The default browser renderer uses Deepdots forms and applies button labels from `actions.accept`, `actions.start`, `actions.back`, and `actions.complete`.

package/dist/index.d.mts

@@ -391,6 +391,15 @@ interface PopupStyle {
 interface PopupSegments {
     lang?: string[];
     path?: string[];
+    /**
+     * App routes where it must NOT be shown. Wins over `path`: a route listed here
+     * blocks the popup even if `path` matches it (so `path: ['/']` +
+     * `excludedPaths: ['/cart']` = everywhere but the cart).
+     * Same matching rules as `path`: an absolute URL matches the full href, an entry
+     * starting with `/` matches any href containing it (this is what covers hash
+     * routes like `/#/cart`), anything else matches the pathname exactly.
+     */
+    excludedPaths?: string[];
     [key: string]: unknown;
 }
 /** Full popup definition */
@@ -823,7 +832,27 @@ declare class DeepdotsPopups {
     private showDefinition;
     private shouldShow;
     private matchesSegmentsLang;
+    /** `segments.path`: rutas donde el popup PUEDE mostrarse. Sin lista, en todas. */
     private matchesSegmentsPath;
+    /**
+     * `segments.excludedPaths`: rutas donde el popup NO debe mostrarse. Gana sobre
+     * `segments.path` (`path: ['/']` + `excludedPaths: ['/cart']` = en todas menos el
+     * carrito) y se aplica también cuando no hay `path` (= en todas menos las excluidas).
+     */
+    private isPathExcluded;
+    /**
+     * Compara UN candidato de `segments.path`/`segments.excludedPaths` con la ruta
+     * actual. Mismas reglas para incluir y para excluir:
+     *  - URL absoluta  → href completo exacto
+     *  - empieza por / → subcadena del href (así entran las rutas con hash: `/#/home`)
+     *  - resto         → pathname exacto
+     * Ignora entradas que no sean string: el backend puede colar un `null` en la lista
+     * y no puede tumbar la evaluación del trigger entero (mismo fallo que hubo con
+     * `segments.lang`).
+     */
+    private matchesPathCandidate;
+    /** href + pathname normalizados de la ruta a evaluar, o null si no hay `window.location`. */
+    private resolveCurrentLocation;
     private evaluateCooldown;
     private evaluateLegacyCondition;
     private hasCooldownElapsed;

package/dist/index.d.ts

@@ -391,6 +391,15 @@ interface PopupStyle {
 interface PopupSegments {
     lang?: string[];
     path?: string[];
+    /**
+     * App routes where it must NOT be shown. Wins over `path`: a route listed here
+     * blocks the popup even if `path` matches it (so `path: ['/']` +
+     * `excludedPaths: ['/cart']` = everywhere but the cart).
+     * Same matching rules as `path`: an absolute URL matches the full href, an entry
+     * starting with `/` matches any href containing it (this is what covers hash
+     * routes like `/#/cart`), anything else matches the pathname exactly.
+     */
+    excludedPaths?: string[];
     [key: string]: unknown;
 }
 /** Full popup definition */
@@ -823,7 +832,27 @@ declare class DeepdotsPopups {
     private showDefinition;
     private shouldShow;
     private matchesSegmentsLang;
+    /** `segments.path`: rutas donde el popup PUEDE mostrarse. Sin lista, en todas. */
     private matchesSegmentsPath;
+    /**
+     * `segments.excludedPaths`: rutas donde el popup NO debe mostrarse. Gana sobre
+     * `segments.path` (`path: ['/']` + `excludedPaths: ['/cart']` = en todas menos el
+     * carrito) y se aplica también cuando no hay `path` (= en todas menos las excluidas).
+     */
+    private isPathExcluded;
+    /**
+     * Compara UN candidato de `segments.path`/`segments.excludedPaths` con la ruta
+     * actual. Mismas reglas para incluir y para excluir:
+     *  - URL absoluta  → href completo exacto
+     *  - empieza por / → subcadena del href (así entran las rutas con hash: `/#/home`)
+     *  - resto         → pathname exacto
+     * Ignora entradas que no sean string: el backend puede colar un `null` en la lista
+     * y no puede tumbar la evaluación del trigger entero (mismo fallo que hubo con
+     * `segments.lang`).
+     */
+    private matchesPathCandidate;
+    /** href + pathname normalizados de la ruta a evaluar, o null si no hay `window.location`. */
+    private resolveCurrentLocation;
     private evaluateCooldown;
     private evaluateLegacyCondition;
     private hasCooldownElapsed;

package/dist/index.js

@@ -2431,9 +2431,9 @@ var init_logo = __esm({
   }
 });
 
-// ../deepdots-popup-sdk/node_modules/@magicfeedback/native/dist/magicfeedback-sdk.browser.js
+// node_modules/@magicfeedback/native/dist/magicfeedback-sdk.browser.js
 var require_magicfeedback_sdk_browser = __commonJS({
-  "../deepdots-popup-sdk/node_modules/@magicfeedback/native/dist/magicfeedback-sdk.browser.js"(exports, module2) {
+  "node_modules/@magicfeedback/native/dist/magicfeedback-sdk.browser.js"(exports, module2) {
     "use strict";
     !(function(e, t) {
       "object" == typeof exports && "object" == typeof module2 ? module2.exports = t() : "function" == typeof define && define.amd ? define([], t) : "object" == typeof exports ? exports.magicfeedback = t() : e.magicfeedback = t();
@@ -7948,6 +7948,9 @@ var DeepdotsPopups = class {
     this.emitEvent("popup_shown", def.surveyId, { popupId: def.id });
   }
   shouldShow(def, pathUrl, skipPathCheck = false) {
+    if (this.isPathExcluded(def, pathUrl)) {
+      return false;
+    }
     if (!skipPathCheck && !this.matchesSegmentsPath(def, pathUrl)) {
       return false;
     }
@@ -7978,40 +7981,85 @@ var DeepdotsPopups = class {
     }
     return matches;
   }
+  /** `segments.path`: rutas donde el popup PUEDE mostrarse. Sin lista, en todas. */
   matchesSegmentsPath(def, pathUrl) {
     const paths = def.segments?.path;
-    if (!paths || paths.length === 0) return true;
-    if (typeof window === "undefined" || !window.location) {
+    if (!Array.isArray(paths) || paths.length === 0) return true;
+    const location = this.resolveCurrentLocation(pathUrl);
+    if (!location) {
       this.debug("No window.location available for path comparison", { popupId: def.id, paths });
       return true;
     }
-    const normalizedHref = this.normalizeUrl(pathUrl || window.location.href || "");
-    const currentUrl = this.safeParseUrl(normalizedHref);
-    const normalizedPath = this.normalizeUrl(currentUrl?.pathname || window.location.pathname || "");
     const matches = paths.some((rawCandidate) => {
-      const candidate = this.normalizeUrl(rawCandidate);
-      let match = false;
-      if (candidate.startsWith("http://") || candidate.startsWith("https://")) {
-        match = normalizedHref === candidate;
-      } else if (candidate.startsWith("/")) {
-        match = normalizedHref.includes(candidate);
-      } else {
-        match = normalizedPath === candidate;
-      }
+      const match = this.matchesPathCandidate(rawCandidate, location);
       this.debug("Path comparison", {
         popupId: def.id,
-        candidate,
-        currentPath: normalizedPath,
-        currentHref: normalizedHref,
+        candidate: rawCandidate,
+        currentPath: location.path,
+        currentHref: location.href,
         match
       });
       return match;
     });
     if (!matches) {
-      this.debug("No path match for popup", { popupId: def.id, paths, currentPath: normalizedPath });
+      this.debug("No path match for popup", { popupId: def.id, paths, currentPath: location.path });
     }
     return matches;
   }
+  /**
+   * `segments.excludedPaths`: rutas donde el popup NO debe mostrarse. Gana sobre
+   * `segments.path` (`path: ['/']` + `excludedPaths: ['/cart']` = en todas menos el
+   * carrito) y se aplica también cuando no hay `path` (= en todas menos las excluidas).
+   */
+  isPathExcluded(def, pathUrl) {
+    const excluded = def.segments?.excludedPaths;
+    if (!Array.isArray(excluded) || excluded.length === 0) return false;
+    const location = this.resolveCurrentLocation(pathUrl);
+    if (!location) {
+      this.debug("No window.location available for excluded path comparison", { popupId: def.id, excluded });
+      return false;
+    }
+    const hit = excluded.find((rawCandidate) => this.matchesPathCandidate(rawCandidate, location));
+    if (hit !== void 0) {
+      this.debug("Popup excluded by path", {
+        popupId: def.id,
+        candidate: hit,
+        currentPath: location.path,
+        currentHref: location.href
+      });
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Compara UN candidato de `segments.path`/`segments.excludedPaths` con la ruta
+   * actual. Mismas reglas para incluir y para excluir:
+   *  - URL absoluta  → href completo exacto
+   *  - empieza por / → subcadena del href (así entran las rutas con hash: `/#/home`)
+   *  - resto         → pathname exacto
+   * Ignora entradas que no sean string: el backend puede colar un `null` en la lista
+   * y no puede tumbar la evaluación del trigger entero (mismo fallo que hubo con
+   * `segments.lang`).
+   */
+  matchesPathCandidate(rawCandidate, location) {
+    if (typeof rawCandidate !== "string") return false;
+    const candidate = this.normalizeUrl(rawCandidate);
+    if (!candidate) return false;
+    if (candidate.startsWith("http://") || candidate.startsWith("https://")) {
+      return location.href === candidate;
+    }
+    if (candidate.startsWith("/")) {
+      return location.href.includes(candidate);
+    }
+    return location.path === candidate;
+  }
+  /** href + pathname normalizados de la ruta a evaluar, o null si no hay `window.location`. */
+  resolveCurrentLocation(pathUrl) {
+    if (typeof window === "undefined" || !window.location) return null;
+    const href = this.normalizeUrl(pathUrl || window.location.href || "");
+    const parsed = this.safeParseUrl(href);
+    return { href, path: this.normalizeUrl(parsed?.pathname || window.location.pathname || "") };
+  }
   evaluateCooldown(def, condition) {
     switch (condition.answered) {
       case "SHOWED":