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

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");
+        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/services/unsubscribeApi.d.ts

@@ -0,0 +1,4 @@
+import type { UnsubscribePage } from '@@/Types/unsubscribe';
+export declare const useUnsubscribeApi: () => {
+    getUnsubscribePages: () => Promise<UnsubscribePage[]>;
+};

package/dist/services/unsubscribeApi.js

@@ -0,0 +1,16 @@
+import { useHttp as t } from "../composables/useHttp.js";
+import { useToaster as n } from "../composables/useToaster.js";
+const u = () => {
+  const { get: r } = t(), { handleError: s } = n();
+  return { getUnsubscribePages: async () => {
+    try {
+      const { data: e = [] } = await r("/unsubscribe-pages/get-all");
+      return e;
+    } catch (e) {
+      return s(e, "Failed to fetch unsubscribe pages"), [];
+    }
+  } };
+};
+export {
+  u as useUnsubscribeApi
+};

package/dist/stores/config.d.ts

@@ -0,0 +1,96 @@
+import type { GuidoConfig, TemplateConfig } from '@@/Types/generic';
+interface StoreState {
+    guidoConfig: GuidoConfig;
+    templateConfig?: TemplateConfig;
+}
+export declare const useConfigStore: import("pinia").StoreDefinition<"config", StoreState, {
+    getVariationId: (state: {
+        guidoConfig: {
+            translationsPath: string;
+            htmlCompilerRules?: ({
+                type: "replace";
+                search: string;
+                replacement: string;
+                replaceAll?: boolean | undefined;
+                id: string;
+                description?: string | undefined;
+                priority: number;
+            } | {
+                type: "regex";
+                pattern: string;
+                replacement: string;
+                flags?: string | undefined;
+                id: string;
+                description?: string | undefined;
+                priority: number;
+            } | {
+                type: "remove";
+                targets: string[] | {
+                    exec: (string: string) => RegExpExecArray | null;
+                    test: (string: string) => boolean;
+                    readonly source: string;
+                    readonly global: boolean;
+                    readonly ignoreCase: boolean;
+                    readonly multiline: boolean;
+                    lastIndex: number;
+                    compile: (pattern: string, flags?: string) => RegExp;
+                    readonly flags: string;
+                    readonly sticky: boolean;
+                    readonly unicode: boolean;
+                    readonly dotAll: boolean;
+                    readonly hasIndices: boolean;
+                    [Symbol.match]: (string: string) => RegExpMatchArray | null;
+                    [Symbol.replace]: {
+                        (string: string, replaceValue: string): string;
+                        (string: string, replacer: (substring: string, ...args: any[]) => string): string;
+                    };
+                    [Symbol.search]: (string: string) => number;
+                    [Symbol.split]: (string: string, limit?: number) => string[];
+                    [Symbol.matchAll]: (str: string) => IterableIterator<RegExpMatchArray>;
+                }[];
+                id: string;
+                description?: string | undefined;
+                priority: number;
+            } | {
+                type: "custom";
+                processor: (html: string) => string;
+                id: string;
+                description?: string | undefined;
+                priority: number;
+            })[] | undefined;
+            ignoreDefaultHtmlCompilerRules?: boolean | undefined;
+            useHeader?: boolean | undefined;
+            emailHeader: {
+                senderName: string;
+                subject: string;
+            };
+            partner?: {
+                partnerName: string;
+                productType: number;
+                messageType: number;
+            } | undefined;
+            extensions?: {
+                unsubscribe?: boolean | undefined;
+            } | undefined;
+            features?: {
+                dynamicContent?: boolean | undefined;
+                saveAsTemplate?: boolean | undefined;
+                versionHistory?: boolean | undefined;
+            } | undefined;
+        };
+        templateConfig?: {
+            preselectedDynamicContentList?: {
+                value: string;
+                text: string;
+                fallback?: string | undefined;
+                format?: {
+                    key: string;
+                    value: string;
+                } | undefined;
+            }[] | undefined;
+            selectedUnsubscribePages?: number[] | undefined;
+            variationId?: string | undefined;
+        } | undefined;
+    } & import("pinia").PiniaCustomStateProperties<StoreState>) => string;
+}, {}>;
+export {};

package/dist/stores/config.js

@@ -0,0 +1,17 @@
+import { DefaultGuidoConfig as e } from "../enums/defaults.js";
+import { defineStore as i } from "pinia";
+const r = i("config", {
+  state: () => ({
+    guidoConfig: e,
+    templateConfig: {}
+  }),
+  getters: {
+    getVariationId: (t) => {
+      var o;
+      return ((o = t.templateConfig) == null ? void 0 : o.variationId) ?? "";
+    }
+  }
+});
+export {
+  r as useConfigStore
+};

package/dist/stores/editor.d.ts

@@ -7,6 +7,7 @@ export declare const useEditorStore: import("pinia").StoreDefinition<"editor", {
     editorVisualMode: string;
     hasChanges: boolean;
     isStripoInitialized: boolean;
+    templateId: string;
 }, {
     isUndoButtonDisabled: (state: {
         loadingStatus: boolean;
@@ -17,6 +18,7 @@ export declare const useEditorStore: import("pinia").StoreDefinition<"editor", {
         editorVisualMode: string;
         hasChanges: boolean;
         isStripoInitialized: boolean;
+        templateId: string;
     } & import("pinia").PiniaCustomStateProperties<{
         loadingStatus: boolean;
         isCodeEditorOpen: boolean;
@@ -26,6 +28,7 @@ export declare const useEditorStore: import("pinia").StoreDefinition<"editor", {
         editorVisualMode: string;
         hasChanges: boolean;
         isStripoInitialized: boolean;
+        templateId: string;
     }>) => boolean;
     isRedoButtonDisabled: (state: {
         loadingStatus: boolean;
@@ -36,6 +39,7 @@ export declare const useEditorStore: import("pinia").StoreDefinition<"editor", {
         editorVisualMode: string;
         hasChanges: boolean;
         isStripoInitialized: boolean;
+        templateId: string;
     } & import("pinia").PiniaCustomStateProperties<{
         loadingStatus: boolean;
         isCodeEditorOpen: boolean;
@@ -45,6 +49,7 @@ export declare const useEditorStore: import("pinia").StoreDefinition<"editor", {
         editorVisualMode: string;
         hasChanges: boolean;
         isStripoInitialized: boolean;
+        templateId: string;
     }>) => boolean;
     isCodeEditorButtonDisabled: (state: {
         loadingStatus: boolean;
@@ -55,6 +60,7 @@ export declare const useEditorStore: import("pinia").StoreDefinition<"editor", {
         editorVisualMode: string;
         hasChanges: boolean;
         isStripoInitialized: boolean;
+        templateId: string;
     } & import("pinia").PiniaCustomStateProperties<{
         loadingStatus: boolean;
         isCodeEditorOpen: boolean;
@@ -64,6 +70,7 @@ export declare const useEditorStore: import("pinia").StoreDefinition<"editor", {
         editorVisualMode: string;
         hasChanges: boolean;
         isStripoInitialized: boolean;
+        templateId: string;
     }>) => boolean;
     isPreviewButtonDisabled: (state: {
         loadingStatus: boolean;
@@ -74,6 +81,7 @@ export declare const useEditorStore: import("pinia").StoreDefinition<"editor", {
         editorVisualMode: string;
         hasChanges: boolean;
         isStripoInitialized: boolean;
+        templateId: string;
     } & import("pinia").PiniaCustomStateProperties<{
         loadingStatus: boolean;
         isCodeEditorOpen: boolean;
@@ -83,6 +91,7 @@ export declare const useEditorStore: import("pinia").StoreDefinition<"editor", {
         editorVisualMode: string;
         hasChanges: boolean;
         isStripoInitialized: boolean;
+        templateId: string;
     }>) => boolean;
     isViewOptionsDisabled: (state: {
         loadingStatus: boolean;
@@ -93,6 +102,7 @@ export declare const useEditorStore: import("pinia").StoreDefinition<"editor", {
         editorVisualMode: string;
         hasChanges: boolean;
         isStripoInitialized: boolean;
+        templateId: string;
     } & import("pinia").PiniaCustomStateProperties<{
         loadingStatus: boolean;
         isCodeEditorOpen: boolean;
@@ -102,6 +112,7 @@ export declare const useEditorStore: import("pinia").StoreDefinition<"editor", {
         editorVisualMode: string;
         hasChanges: boolean;
         isStripoInitialized: boolean;
+        templateId: string;
     }>) => boolean;
     isVersionHistoryButtonDisabled: (state: {
         loadingStatus: boolean;
@@ -112,6 +123,7 @@ export declare const useEditorStore: import("pinia").StoreDefinition<"editor", {
         editorVisualMode: string;
         hasChanges: boolean;
         isStripoInitialized: boolean;
+        templateId: string;
     } & import("pinia").PiniaCustomStateProperties<{
         loadingStatus: boolean;
         isCodeEditorOpen: boolean;
@@ -121,6 +133,7 @@ export declare const useEditorStore: import("pinia").StoreDefinition<"editor", {
         editorVisualMode: string;
         hasChanges: boolean;
         isStripoInitialized: boolean;
+        templateId: string;
     }>) => boolean;
     isExportButtonDisabled: (state: {
         loadingStatus: boolean;
@@ -131,6 +144,7 @@ export declare const useEditorStore: import("pinia").StoreDefinition<"editor", {
         editorVisualMode: string;
         hasChanges: boolean;
         isStripoInitialized: boolean;
+        templateId: string;
     } & import("pinia").PiniaCustomStateProperties<{
         loadingStatus: boolean;
         isCodeEditorOpen: boolean;
@@ -140,6 +154,7 @@ export declare const useEditorStore: import("pinia").StoreDefinition<"editor", {
         editorVisualMode: string;
         hasChanges: boolean;
         isStripoInitialized: boolean;
+        templateId: string;
     }>) => boolean;
     isSaveAsButtonDisabled: (state: {
         loadingStatus: boolean;
@@ -150,6 +165,7 @@ export declare const useEditorStore: import("pinia").StoreDefinition<"editor", {
         editorVisualMode: string;
         hasChanges: boolean;
         isStripoInitialized: boolean;
+        templateId: string;
     } & import("pinia").PiniaCustomStateProperties<{
         loadingStatus: boolean;
         isCodeEditorOpen: boolean;
@@ -159,6 +175,7 @@ export declare const useEditorStore: import("pinia").StoreDefinition<"editor", {
         editorVisualMode: string;
         hasChanges: boolean;
         isStripoInitialized: boolean;
+        templateId: string;
     }>) => boolean;
     isTestButtonDisabled: (state: {
         loadingStatus: boolean;
@@ -169,6 +186,7 @@ export declare const useEditorStore: import("pinia").StoreDefinition<"editor", {
         editorVisualMode: string;
         hasChanges: boolean;
         isStripoInitialized: boolean;
+        templateId: string;
     } & import("pinia").PiniaCustomStateProperties<{
         loadingStatus: boolean;
         isCodeEditorOpen: boolean;
@@ -178,6 +196,7 @@ export declare const useEditorStore: import("pinia").StoreDefinition<"editor", {
         editorVisualMode: string;
         hasChanges: boolean;
         isStripoInitialized: boolean;
+        templateId: string;
     }>) => boolean;
     isSaveButtonDisabled: (state: {
         loadingStatus: boolean;
@@ -188,6 +207,7 @@ export declare const useEditorStore: import("pinia").StoreDefinition<"editor", {
         editorVisualMode: string;
         hasChanges: boolean;
         isStripoInitialized: boolean;
+        templateId: string;
     } & import("pinia").PiniaCustomStateProperties<{
         loadingStatus: boolean;
         isCodeEditorOpen: boolean;
@@ -197,5 +217,6 @@ export declare const useEditorStore: import("pinia").StoreDefinition<"editor", {
         editorVisualMode: string;
         hasChanges: boolean;
         isStripoInitialized: boolean;
+        templateId: string;
     }>) => boolean;
 }, {}>;

package/dist/stores/editor.js

@@ -8,7 +8,8 @@ const o = e("editor", {
     isPreviewModeOpen: !1,
     editorVisualMode: "desktop",
     hasChanges: !1,
-    isStripoInitialized: !1
+    isStripoInitialized: !1,
+    templateId: ""
   }),
   getters: {
     // Middle Slot