@useinsider/guido 1.0.3-beta.ce3ed00 → 1.0.3-beta.cedc8cb

package/dist/services/recommendationApi.js

@@ -1,13 +1,19 @@
 import { useHttp as c } from "../composables/useHttp.js";
 import { URLS as a } from "../enums/extensions/recommendationBlock.js";
-const R = () => {
+import { useEditorStore as m } from "../stores/editor.js";
+import { replaceString as s } from "../utils/genericUtil.js";
+const l = () => {
   const { get: o } = c();
   return {
     fetchRecommendationCreateData: async () => {
+      const e = m();
       try {
-        return (await o("/newsletter/recommendations/create-data")).data;
-      } catch (e) {
-        throw console.error("fetchUserModalState error:", e), e;
+        return (await o(s(
+          "/newsletter/{id}/recommendations/get-campaign-create-data",
+          { id: e.templateId }
+        ))).data;
+      } catch (t) {
+        throw console.error("fetchUserModalState error:", t), t;
       }
     },
     fetchRecommendationFilters: async () => {
@@ -18,20 +24,20 @@ const R = () => {
         throw console.error("fetchRecommendationFilters error:", e), e;
       }
     },
-    fetchRecommendationProducts: async (e, n) => {
+    fetchRecommendationProducts: async (e, t) => {
       try {
-        const t = decodeURIComponent(new URLSearchParams(Object.entries(n)).toString());
-        console.debug("🏁 Recommendation API Query:", t);
-        const r = await o(
-          `${a.RECOMMENDATION_API_URL}/v2/${e}?${t}`
+        const r = decodeURIComponent(new URLSearchParams(Object.entries(t)).toString());
+        console.debug("🏁 Recommendation API Query:", r);
+        const n = await o(
+          `${a.RECOMMENDATION_API_URL}/v2/${e}?${r}`
         );
-        return (r == null ? void 0 : r.data) ?? [];
-      } catch (t) {
-        throw console.error("fetchRecommendationProducts error:", t), t;
+        return (n == null ? void 0 : n.data) ?? [];
+      } catch (r) {
+        throw console.error("fetchRecommendationProducts error:", r), r;
       }
     }
   };
 };
 export {
-  R as useRecommendationApi
+  l as useRecommendationApi
 };

package/dist/services/slackNotificationService.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Slack notification payload structure
+ */
+export interface SlackNotificationPayload {
+    channel?: string;
+    username?: string;
+    icon_emoji?: string;
+    text?: string;
+    attachments?: SlackAttachment[];
+}
+/**
+ * Slack attachment for formatted messages
+ */
+export interface SlackAttachment {
+    color?: string;
+    title?: string;
+    title_link?: string;
+    text?: string;
+    fields?: SlackField[];
+    footer?: string;
+    ts?: number;
+}
+/**
+ * Slack field for structured data
+ */
+export interface SlackField {
+    title: string;
+    value: string;
+    short?: boolean;
+}
+/**
+ * Slack error notification content
+ */
+export interface SlackErrorNotification {
+    title: string;
+    message: string;
+    errorType: string;
+    severity: 'low' | 'medium' | 'high' | 'critical';
+    context?: Record<string, unknown>;
+    stackTrace?: string;
+    timestamp?: number;
+}
+/**
+ * Service for sending error notifications to Slack
+ * Used to alert team members about critical Stripo errors
+ */
+export declare class SlackNotificationService {
+    private webhookUrl;
+    private channel;
+    private defaultUsername;
+    private enabled;
+    constructor(webhookUrl?: string, options?: {
+        channel?: string;
+        username?: string;
+        enabled?: boolean;
+    });
+    /**
+     * Send an error notification to Slack
+     */
+    sendErrorNotification(notification: SlackErrorNotification): Promise<boolean>;
+    /**
+     * Send a critical error that requires immediate attention
+     */
+    sendCriticalError(title: string, message: string, context?: Record<string, unknown>): Promise<boolean>;
+    /**
+     * Send a CORS error notification
+     */
+    sendCorsErrorNotification(resourceUrl?: string, additionalContext?: Record<string, unknown>): Promise<boolean>;
+    /**
+     * Send a plugin load error notification
+     */
+    sendPluginLoadErrorNotification(reason: string, additionalContext?: Record<string, unknown>): Promise<boolean>;
+    /**
+     * Build Slack message payload from error notification
+     */
+    private buildErrorPayload;
+    /**
+     * Format field title for Slack (e.g., emailId -> Email ID)
+     */
+    private formatFieldTitle;
+    /**
+     * Format field value for Slack display
+     */
+    private formatFieldValue;
+    /**
+     * Check if notifications are enabled
+     */
+    isEnabled(): boolean;
+    /**
+     * Update webhook URL
+     */
+    setWebhookUrl(url: string): void;
+    /**
+     * Update channel
+     */
+    setChannel(channel: string): void;
+    /**
+     * Enable/disable notifications
+     */
+    setEnabled(enabled: boolean): void;
+}
+export declare const getSlackNotificationService: () => SlackNotificationService;
+/**
+ * Initialize or reinitialize Slack notification service
+ */
+export declare const initializeSlackNotificationService: (webhookUrl?: string, options?: {
+    channel?: string;
+    username?: string;
+    enabled?: boolean;
+}) => SlackNotificationService;

package/dist/services/slackNotificationService.js

@@ -0,0 +1,167 @@
+var d = Object.defineProperty;
+var h = (t, e, r) => e in t ? d(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r;
+var i = (t, e, r) => h(t, typeof e != "symbol" ? e + "" : e, r);
+class u {
+  constructor(e, r) {
+    i(this, "webhookUrl");
+    i(this, "channel");
+    i(this, "defaultUsername");
+    i(this, "enabled");
+    this.webhookUrl = e || void 0 || "", this.channel = (r == null ? void 0 : r.channel) || "#errors", this.defaultUsername = (r == null ? void 0 : r.username) || "Guido Error Bot", this.enabled = (r == null ? void 0 : r.enabled) !== !1, this.webhookUrl || (console.warn("[SlackNotificationService] Webhook URL not configured, Slack notifications disabled"), this.enabled = !1);
+  }
+  /**
+   * Send an error notification to Slack
+   */
+  async sendErrorNotification(e) {
+    if (!this.enabled || !this.webhookUrl)
+      return !1;
+    try {
+      const r = this.buildErrorPayload(e), a = await fetch(this.webhookUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(r)
+      });
+      return a.ok ? !0 : (console.error("[SlackNotificationService] Failed to send Slack notification:", a.statusText), !1);
+    } catch (r) {
+      return console.error("[SlackNotificationService] Error sending Slack notification:", r), !1;
+    }
+  }
+  /**
+   * Send a critical error that requires immediate attention
+   */
+  async sendCriticalError(e, r, a) {
+    return this.sendErrorNotification({
+      title: e,
+      message: r,
+      errorType: "critical",
+      severity: "critical",
+      context: a,
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * Send a CORS error notification
+   */
+  async sendCorsErrorNotification(e, r) {
+    return this.sendCriticalError(
+      "CORS Error in Stripo Email Editor",
+      "Failed to load Stripo resources due to CORS restrictions",
+      {
+        resourceUrl: e,
+        ...r,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    );
+  }
+  /**
+   * Send a plugin load error notification
+   */
+  async sendPluginLoadErrorNotification(e, r) {
+    return this.sendCriticalError(
+      "Stripo Plugin Failed to Load",
+      `Email editor initialization failed: ${e}`,
+      {
+        ...r,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    );
+  }
+  /**
+   * Build Slack message payload from error notification
+   */
+  buildErrorPayload(e) {
+    const a = {
+      critical: "#E74C3C",
+      // Red
+      high: "#E67E22",
+      // Orange
+      medium: "#F39C12",
+      // Yellow
+      low: "#3498DB"
+      // Blue
+    }[e.severity] || "#95A5A6", l = [
+      {
+        title: "Error Type",
+        value: e.errorType,
+        short: !0
+      },
+      {
+        title: "Severity",
+        value: e.severity.toUpperCase(),
+        short: !0
+      },
+      {
+        title: "Timestamp",
+        value: e.timestamp ? new Date(e.timestamp).toISOString() : (/* @__PURE__ */ new Date()).toISOString(),
+        short: !0
+      }
+    ];
+    e.context && Object.entries(e.context).forEach(([n, c]) => {
+      l.length < 20 && l.push({
+        title: this.formatFieldTitle(n),
+        value: this.formatFieldValue(c),
+        short: !0
+      });
+    });
+    const s = {
+      color: a,
+      title: e.title,
+      text: e.message,
+      fields: l,
+      footer: "Guido Error Tracking",
+      ts: Math.floor((e.timestamp || Date.now()) / 1e3)
+    };
+    return e.stackTrace && (s.text = `${e.message}
+\`\`\`${e.stackTrace}\`\`\``), {
+      channel: this.channel,
+      username: this.defaultUsername,
+      // eslint-disable-next-line camelcase
+      icon_emoji: ":warning:",
+      attachments: [s]
+    };
+  }
+  /**
+   * Format field title for Slack (e.g., emailId -> Email ID)
+   */
+  formatFieldTitle(e) {
+    return e.replace(/([A-Z])/g, " $1").replace(/^./, (r) => r.toUpperCase()).trim();
+  }
+  /**
+   * Format field value for Slack display
+   */
+  formatFieldValue(e) {
+    return e == null ? "(empty)" : typeof e == "object" ? JSON.stringify(e).slice(0, 500) : String(e).slice(0, 500);
+  }
+  /**
+   * Check if notifications are enabled
+   */
+  isEnabled() {
+    return this.enabled;
+  }
+  /**
+   * Update webhook URL
+   */
+  setWebhookUrl(e) {
+    this.webhookUrl = e, this.enabled = !!e;
+  }
+  /**
+   * Update channel
+   */
+  setChannel(e) {
+    this.channel = e;
+  }
+  /**
+   * Enable/disable notifications
+   */
+  setEnabled(e) {
+    this.enabled = e && !!this.webhookUrl;
+  }
+}
+let o = null;
+const S = () => (o || (o = new u()), o);
+export {
+  u as SlackNotificationService,
+  S as getSlackNotificationService
+};

package/dist/services/stripoApi.js

@@ -1,25 +1,45 @@
-import { useHttp as a } from "../composables/useHttp.js";
-import { useToaster as s } from "../composables/useToaster.js";
-const m = () => {
-  const { get: r } = a(), { handleError: o } = s();
+import { useApiErrorTracking as i } from "../composables/useApiErrorTracking.js";
+import { useHttp as c } from "../composables/useHttp.js";
+import { useToaster as p } from "../composables/useToaster.js";
+const h = () => {
+  const { get: s } = c(), { handleError: n } = p(), { withParsingErrorTracking: a } = i();
   return {
     getToken: async () => {
       try {
-        const t = Number(localStorage.getItem("ins-guido-test-instance")), { data: e } = await r(`/stripo/get-user-token?test=${t}`);
-        return e.body.token;
+        const t = Number(localStorage.getItem("ins-guido-test-instance")), { data: e } = await s(`/stripo/get-user-token?test=${t}`);
+        return a(
+          () => {
+            var o;
+            if (!((o = e == null ? void 0 : e.body) != null && o.token))
+              throw new Error("Invalid token response: missing token in response body");
+            return e.body.token;
+          },
+          "/stripo/get-user-token",
+          e,
+          { endpoint: "/stripo/get-user-token", operation: "getToken" }
+        );
       } catch (t) {
-        return o(t, "Failed to fetch token"), "";
+        return n(t, "Failed to fetch token"), "";
       }
     },
     getCustomFonts: async () => {
       try {
-        const { data: t = [] } = await r("/stripo/get-partner-custom-fonts");
-        return t.map((e) => ({
-          ...e,
-          active: !0
-        }));
+        const { data: t = [] } = await s("/stripo/get-partner-custom-fonts");
+        return a(
+          () => {
+            if (!Array.isArray(t))
+              throw new Error("Invalid fonts response: expected array");
+            return t.map((r) => ({
+              ...r,
+              active: !0
+            }));
+          },
+          "/stripo/get-partner-custom-fonts",
+          t,
+          { endpoint: "/stripo/get-partner-custom-fonts", operation: "getCustomFonts" }
+        );
       } catch (t) {
-        return o(t, "Failed to fetch custom fonts"), [];
+        return n(t, "Failed to fetch custom fonts"), [];
       }
     },
     getDefaultTemplate: async () => {
@@ -29,21 +49,31 @@ const m = () => {
         forceRecreate: !0
       };
       try {
-        const { data: e } = await r("/stripo/default-template/0");
+        const { data: e } = await s("/stripo/default-template");
         try {
           return {
-            ...JSON.parse(e),
+            ...a(
+              () => {
+                const o = JSON.parse(e);
+                if (!o.html)
+                  throw new Error("Invalid template response: missing html field");
+                return o;
+              },
+              "/stripo/default-template",
+              e,
+              { endpoint: "/stripo/default-template", operation: "getDefaultTemplate" }
+            ),
             forceRecreate: !0
           };
-        } catch {
-          return t;
+        } catch (r) {
+          return r instanceof Error && !r.message.includes("Invalid template") && n(r, "Failed to parse template as JSON"), t;
         }
       } catch (e) {
-        return o(e, "Failed to fetch default template"), t;
+        return n(e, "Failed to fetch default template"), t;
       }
     }
   };
 };
 export {
-  m as useStripoApi
+  h as useStripoApi
 };

package/dist/services/stripoErrorDeduplicationService.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Service for handling Stripo error deduplication locally in Guido
+ *
+ * IMPORTANT: These errors are Guido's responsibility, not consuming teams'
+ * - Errors are caught and handled within Guido
+ * - Slack alerts notify Guido team to take action
+ * - Do NOT propagate errors to consuming teams' error tracking
+ * - Do NOT require backend involvement (errors are client-side)
+ *
+ * This keeps Stripo integration issues isolated to Guido's systems
+ */
+export interface StripoErrorDuplication {
+    errorType: string;
+    errorMessage: string;
+    errorCategory: string;
+    context: {
+        emailId?: string;
+        userId?: string;
+        environment?: string;
+        timestamp: string;
+        [key: string]: unknown;
+    };
+    reportedAt: string;
+}
+/**
+ * Service for deduplicating Stripo error alerts locally in Guido
+ * Prevents duplicate Slack notifications for the same error within a session
+ *
+ * Errors are handled entirely on the FE:
+ * - Slack notification alerts Guido team immediately (first occurrence)
+ * - Duplicate alerts suppressed within same session
+ * - Sentry/FullStory logs for analysis
+ * - No backend endpoint required
+ * - No propagation to consuming teams
+ */
+export declare class StripoErrorDeduplicationService {
+    private reportedErrors;
+    constructor();
+    /**
+     * Track an error locally to prevent duplicate Slack alerts
+     * Only sends Slack alert once per unique error within the same session
+     */
+    trackError(errorData: StripoErrorDuplication): boolean;
+    /**
+     * Track plugin load error locally (CORS, script failure, timeout)
+     */
+    trackPluginLoadError(errorMessage: string, context?: Record<string, unknown>): boolean;
+    /**
+     * Track CORS error locally
+     */
+    trackCorsError(errorMessage: string, context?: Record<string, unknown>): boolean;
+    /**
+     * Track authentication error locally (token refresh failure)
+     * Tracks it, but Slack notifier decides whether to alert based on token expiration
+     */
+    trackAuthenticationError(errorMessage: string, context?: Record<string, unknown>): boolean;
+    /**
+     * Generate unique deduplication key for error
+     * Format: "errorType:emailId:userId" to allow same error on different emails
+     */
+    private getDeduplicationKey;
+    /**
+     * Clear tracked errors (for testing or session reset)
+     */
+    clearTrackedErrors(): void;
+    /**
+     * Get count of errors tracked in this session
+     */
+    getTrackedErrorCount(): number;
+}
+export declare const getStripoErrorDeduplicationService: () => StripoErrorDeduplicationService;
+/**
+ * Reset tracked errors (useful for testing or session reset)
+ */
+export declare const resetStripoErrorDeduplicationService: () => void;

package/dist/services/stripoErrorDeduplicationService.js

@@ -0,0 +1,91 @@
+var c = Object.defineProperty;
+var a = (e, r, t) => r in e ? c(e, r, { enumerable: !0, configurable: !0, writable: !0, value: t }) : e[r] = t;
+var n = (e, r, t) => a(e, typeof r != "symbol" ? r + "" : r, t);
+class s {
+  constructor() {
+    n(this, "reportedErrors", /* @__PURE__ */ new Set());
+  }
+  /**
+   * Track an error locally to prevent duplicate Slack alerts
+   * Only sends Slack alert once per unique error within the same session
+   */
+  trackError(r) {
+    const t = this.getDeduplicationKey(r);
+    return this.reportedErrors.has(t) ? !1 : (this.reportedErrors.add(t), !0);
+  }
+  /**
+   * Track plugin load error locally (CORS, script failure, timeout)
+   */
+  trackPluginLoadError(r, t) {
+    return this.trackError({
+      errorType: "plugin_load_error",
+      errorMessage: r,
+      errorCategory: "critical",
+      context: {
+        ...t,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        environment: "production"
+      },
+      reportedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  /**
+   * Track CORS error locally
+   */
+  trackCorsError(r, t) {
+    return this.trackError({
+      errorType: "cors_error",
+      errorMessage: r,
+      errorCategory: "handled",
+      context: {
+        ...t,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        environment: "production"
+      },
+      reportedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  /**
+   * Track authentication error locally (token refresh failure)
+   * Tracks it, but Slack notifier decides whether to alert based on token expiration
+   */
+  trackAuthenticationError(r, t) {
+    return this.trackError({
+      errorType: "authentication_error",
+      errorMessage: r,
+      errorCategory: "critical",
+      context: {
+        ...t,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        environment: "production"
+      },
+      reportedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  /**
+   * Generate unique deduplication key for error
+   * Format: "errorType:emailId:userId" to allow same error on different emails
+   */
+  getDeduplicationKey(r) {
+    const t = r.context.emailId || "unknown", i = r.context.userId || "unknown";
+    return `${r.errorType}:${t}:${i}`;
+  }
+  /**
+   * Clear tracked errors (for testing or session reset)
+   */
+  clearTrackedErrors() {
+    this.reportedErrors.clear();
+  }
+  /**
+   * Get count of errors tracked in this session
+   */
+  getTrackedErrorCount() {
+    return this.reportedErrors.size;
+  }
+}
+let o = null;
+const u = () => (o || (o = new s()), o);
+export {
+  s as StripoErrorDeduplicationService,
+  u as getStripoErrorDeduplicationService
+};

package/dist/static/styles/components/narrow-panel.css.js

@@ -32,16 +32,6 @@ ue-stripe-thumb:hover:not(.disabled),
     padding: 0 16px 16px;
     grid-row-gap: 16px;
 }
-
-/* TODO: will be removed after we find another way to hide stripo custom modules */
-#moduleTab_tab1,
-button[aria-label="Default Modules"],
-button[aria-controls="moduleTab_tab1_content"],
-#moduleTab_tab2,
-button[aria-label="Pre-Built AMP"],
-button[aria-controls="moduleTab_tab2_content"] {
-    display: none !important;
-}
 `;
 export {
   o as default

package/dist/static/styles/customEditorStyle.css.js

@@ -18,11 +18,6 @@ const n = `.esd-x,
     border-radius: 0;
     box-shadow: none;
 }
-.ins-product-cart ue-node-actions,
-.ins-recommendation-v3-block-v2 .product-attribute-cell ue-node-actions,
-.ins-recommendation-v3-block-v2 .product-attribute-cell ue-node-panel {
-    display: none !important;
-}
 `;
 export {
   n as default

package/dist/{src/stores → stores}/config.d.ts

@@ -64,7 +64,6 @@ export declare const useConfigStore: import("pinia").StoreDefinition<"config", S
                 senderName: string;
                 subject: string;
             };
-            migrationDate: number;
             partner?: {
                 partnerName: string;
                 productType: number;
@@ -77,13 +76,7 @@ export declare const useConfigStore: import("pinia").StoreDefinition<"config", S
                 dynamicContent?: boolean | undefined;
                 saveAsTemplate?: boolean | undefined;
                 versionHistory?: boolean | undefined;
-                testMessage?: boolean | undefined;
             } | undefined;
-            blocks?: {
-                excludeDefaults?: import("@@/Types/generic").GuidoBlockType[] | undefined;
-                includeCustoms?: import("@@/Types/generic").GuidoCustomBlockType[] | undefined;
-            } | undefined;
-            backButtonLabel?: string | undefined;
         };
         templateConfig?: {
             preselectedDynamicContentList?: {

package/dist/utils/dateUtil.d.ts

@@ -0,0 +1 @@
+export declare const formatPatchDate: (timestamp: number) => string;

package/dist/utils/dateUtil.js

@@ -1,19 +1,4 @@
-import { DEFAULT_LOCALE as r, DEFAULT as a, DEFAULT_TZ as c } from "../enums/date.js";
-const m = (t) => t ? t instanceof Date ? t : typeof t == "string" ? t.length === 10 ? new Date(Number(t) * 1e3) : new Date(t) : typeof t == "number" ? t.toString().length === 10 ? new Date(t * 1e3) : new Date(t) : /* @__PURE__ */ new Date() : /* @__PURE__ */ new Date(), s = () => {
-  const t = window.l10n;
-  return (t == null ? void 0 : t.locale) === a ? r : (t == null ? void 0 : t.locale) || r;
-}, u = new Intl.DateTimeFormat().resolvedOptions().timeZone, f = () => {
-  const t = window.l10n;
-  return (t == null ? void 0 : t.timezone) || u || c;
-}, D = (t, e = s(), n = f()) => {
-  const o = {
-    year: "numeric",
-    month: "2-digit",
-    day: "2-digit",
-    timeZone: n
-  }, i = m(t);
-  return new Intl.DateTimeFormat(e, o).format(i);
-}, T = (t) => {
+const o = (t) => {
   if (!t)
     return "";
   const e = new Date(t);
@@ -25,13 +10,7 @@ const m = (t) => t ? t instanceof Date ? t : typeof t == "string" ? t.length ===
     second: "2-digit",
     hour12: !1
   }).format(e);
-}, h = (t) => t ? Math.floor(Date.now() / 1e3) >= t : !1;
+};
 export {
-  m as convertToDateObject,
-  T as formatPatchDate,
-  D as formatShortDate,
-  h as isAfterDate,
-  u as localTz,
-  s as locale,
-  f as timezone
+  o as formatPatchDate
 };