@fyul/embed-sdk 2.2.0 → 2.3.0

package/dist/esm/services/broadcastEventDispatcher.js

@@ -0,0 +1,20 @@
+import { BROADCAST_EVENT_MAP } from '../types/event/broadcast/broadcastEventMap';
+export class BroadcastEventDispatcher {
+    eventHandlers = new Map();
+    constructor() {
+        this.initHandlers();
+    }
+    do(eventName, payload) {
+        const handler = this.eventHandlers.get(eventName);
+        if (!handler) {
+            throw new Error(`Fail [do]: No event handler for '${eventName}'!`);
+        }
+        return handler.handle(payload);
+    }
+    // Initializes the event handlers by iterating over the BROADCAST_EVENT_MAP and creating instances of each handler.
+    initHandlers() {
+        for (const [eventName, EventHandlerClass] of Object.entries(BROADCAST_EVENT_MAP)) {
+            this.eventHandlers.set(eventName, new EventHandlerClass());
+        }
+    }
+}

package/dist/esm/services/edm.d.ts

@@ -0,0 +1,23 @@
+import { EDMConfig, EDMParams } from '../modules/edm/types/data.types';
+import { EdmBroadcastModule } from '../modules/edm/edmBroadcastModule';
+import { BroadcastListeners } from '../modules/edm/types/event/broadcastEvent.types';
+import type { AddImagePayload, NavigateStepPayload, SetStylePayload } from '../modules/edm/types';
+export declare class EDM {
+    private params;
+    private config?;
+    static BASE_URL: string;
+    static broadCastEventHandler: EdmBroadcastModule | null;
+    private nonce;
+    private iFrameManager;
+    private communicator;
+    private moduleLoader;
+    private initialized;
+    constructor(params: EDMParams, config?: EDMConfig | undefined, callbacks?: Partial<BroadcastListeners>);
+    init(): Promise<void>;
+    saveDesign(): Promise<import("..").HandledResponse<import("../modules/edm/types").SaveDesignResultPayload, Error>>;
+    setStyle(payload: SetStylePayload): Promise<import("..").HandledResponse<import("../modules/edm/types").SetStyleResultPayload, Error>>;
+    addImage(payload: AddImagePayload): Promise<import("..").HandledResponse<import("../modules/edm/types").AddImageResultPayload, Error>>;
+    navigateStep(payload: NavigateStepPayload): Promise<import("..").HandledResponse<import("../modules/edm/types").NavigateStepResultPayload, Error>>;
+    destroy(): void;
+    static getBroadCastEventHandler(): EdmBroadcastModule;
+}

package/dist/esm/services/edm.js

@@ -0,0 +1,98 @@
+import { iFrameManager } from '../services/iFrameManager';
+import { EmbedCommunicator } from '../services/embedCommunicator';
+import { ModuleLoaderService } from '../services/moduleLoaderService';
+import { LOG_TYPES, logEmbedMessage, setLoggerState, SOURCES, } from '../helpers/messageLogger';
+import { MODULE_NAMES } from '../modules/moduleNames';
+import { VERSION } from '../version';
+import { EdmBroadcastModule } from '../modules/edm/edmBroadcastModule';
+export class EDM {
+    params;
+    config;
+    static BASE_URL = 'https://www.printful.com/embedded-designer';
+    static broadCastEventHandler;
+    nonce;
+    iFrameManager = null;
+    communicator = EmbedCommunicator.getInstance();
+    moduleLoader = ModuleLoaderService.getInstance();
+    initialized = false;
+    constructor(params, config, callbacks) {
+        this.params = params;
+        this.config = config;
+        this.nonce = params.nonce;
+        EDM.broadCastEventHandler = new EdmBroadcastModule(callbacks);
+        setLoggerState(params?.debug ?? false, SOURCES.EDM);
+    }
+    async init() {
+        if (this.initialized) {
+            logEmbedMessage({
+                message: 'EDM already initialized',
+                logType: LOG_TYPES.WARN,
+            });
+            return;
+        }
+        const elementToBindTo = this.params.element ?? document.getElementById(this.params.elementId);
+        if (!elementToBindTo) {
+            logEmbedMessage({
+                message: 'Cant find element for EDM',
+                logType: LOG_TYPES.ERROR,
+            });
+            return;
+        }
+        this.iFrameManager = new iFrameManager({
+            baseUrl: EDM.BASE_URL,
+            urlParams: {
+                nonce: this.nonce,
+                sdkMode: true,
+                locale: this.config?.locale ?? '',
+            },
+            class: this.params.iframeClassName,
+            elementToAppendTo: elementToBindTo,
+        });
+        await this.iFrameManager.create();
+        this.communicator.setIFrameManager(MODULE_NAMES.EDM, this.iFrameManager);
+        this.communicator.setupListener();
+        const edmModule = this.moduleLoader.getModule(MODULE_NAMES.EDM);
+        const notification = await edmModule.setup({
+            ...this.config,
+            ...this.params,
+            clientVersion: VERSION,
+        });
+        logEmbedMessage({
+            message: ['EDM setup notification', notification],
+            logType: LOG_TYPES.LOG,
+        });
+        this.initialized = true;
+    }
+    saveDesign() {
+        const edmModule = this.moduleLoader.getModule(MODULE_NAMES.EDM);
+        return edmModule.saveDesign();
+    }
+    setStyle(payload) {
+        const edmModule = this.moduleLoader.getModule(MODULE_NAMES.EDM);
+        return edmModule.setStyle(payload);
+    }
+    addImage(payload) {
+        const edmModule = this.moduleLoader.getModule(MODULE_NAMES.EDM);
+        return edmModule.addImage(payload);
+    }
+    navigateStep(payload) {
+        const edmModule = this.moduleLoader.getModule(MODULE_NAMES.EDM);
+        return edmModule.navigateStep(payload);
+    }
+    destroy() {
+        if (this.iFrameManager) {
+            this.iFrameManager.destroy();
+            this.iFrameManager = null;
+        }
+        this.communicator.cleanup();
+        this.moduleLoader.clearCache();
+        this.initialized = false;
+        EDM.broadCastEventHandler = null;
+    }
+    static getBroadCastEventHandler() {
+        if (!EDM.broadCastEventHandler) {
+            throw new Error('No active EdmBroadcastModule instance');
+        }
+        return EDM.broadCastEventHandler;
+    }
+}

package/dist/esm/services/embed.d.ts

@@ -0,0 +1,19 @@
+import { CatalogService } from '../modules/catalog/catalogService';
+import { MockupService } from '../modules/mockup-generation/mockupService';
+import { ProductPublishService } from '../modules/product-publish/productPublishService';
+import { SdkConfig } from '../modules/sdk/types';
+export declare class Embed {
+    private config?;
+    static BASE_URL: string;
+    private nonce;
+    private iFrameManager;
+    private communicator;
+    private moduleLoader;
+    private initialized;
+    readonly catalog: CatalogService;
+    readonly mockup: MockupService;
+    readonly publish: ProductPublishService;
+    constructor(nonce: string, config?: SdkConfig | undefined);
+    init(): Promise<void>;
+    destroy(): void;
+}

package/dist/esm/services/embed.js

@@ -0,0 +1,79 @@
+import { iFrameManager } from '../services/iFrameManager';
+import { EmbedCommunicator } from '../services/embedCommunicator';
+import { ModuleLoaderService } from '../services/moduleLoaderService';
+import { CatalogService } from '../modules/catalog/catalogService';
+import { MockupService } from '../modules/mockup-generation/mockupService';
+import { ProductPublishService } from '../modules/product-publish/productPublishService';
+import { LOG_TYPES, logEmbedMessage, setLoggerState, SOURCES, } from '../helpers/messageLogger';
+import { MODULE_NAMES } from '../modules/modules';
+import { VERSION } from '../version';
+export class Embed {
+    config;
+    static BASE_URL = 'https://www.printful.com/embed-sdk';
+    nonce;
+    iFrameManager = null;
+    communicator = EmbedCommunicator.getInstance();
+    moduleLoader = ModuleLoaderService.getInstance();
+    initialized = false;
+    // Service composition
+    catalog;
+    mockup;
+    publish;
+    constructor(nonce, config) {
+        this.config = config;
+        this.nonce = nonce;
+        setLoggerState(config?.debug ?? false, SOURCES.SDK);
+        // Initialize services
+        this.catalog = new CatalogService();
+        this.mockup = new MockupService();
+        this.publish = new ProductPublishService();
+    }
+    async init() {
+        if (this.initialized) {
+            logEmbedMessage({
+                message: 'Embed SDK already initialized',
+                logType: LOG_TYPES.WARN,
+            });
+            return;
+        }
+        // Client mode: Create iframe and setup communication
+        this.iFrameManager = new iFrameManager({
+            baseUrl: Embed.BASE_URL,
+            urlParams: {
+                nonce: this.nonce,
+            },
+            style: {
+                display: 'none',
+                position: 'fixed',
+                width: '0',
+                height: '0',
+                border: 'none',
+            },
+            elementToAppendTo: document.body,
+        });
+        await this.iFrameManager.create();
+        // Setup communicator with iframe manager
+        this.communicator.setIFrameManager(MODULE_NAMES.SDK, this.iFrameManager);
+        this.communicator.setupListener();
+        // Get SDK module and setup
+        const sdkModule = this.moduleLoader.getModule(MODULE_NAMES.SDK);
+        const notification = await sdkModule.setup({
+            ...this.config,
+            clientVersion: VERSION,
+        });
+        logEmbedMessage({
+            message: ['SDK (Main) module setup notification', notification],
+            logType: LOG_TYPES.LOG,
+        });
+        this.initialized = true;
+    }
+    destroy() {
+        if (this.iFrameManager) {
+            this.iFrameManager.destroy();
+            this.iFrameManager = null;
+        }
+        this.communicator.cleanup();
+        this.moduleLoader.clearCache();
+        this.initialized = false;
+    }
+}

package/dist/esm/services/embedCommunicator.d.ts

@@ -1,21 +1,27 @@
 import { iFrameManager } from './iFrameManager';
 import { ActionEvent, ActionEventName } from '../types/event/action/actionEvent.types';
 import { ActionEventPayload } from '../types/event/action/actionEventPayload.types';
+import { BroadcastEvent } from '../types/event/broadcast/broadcastEvent.types';
+import { MODULE_NAMES } from '../modules/moduleNames';
 export declare class EmbedCommunicator {
     #private;
+    private broadcastEventHandler;
     private messageBroker;
-    private iFrameManager;
+    private iFrameManagers;
     private isListening;
     private constructor();
     static getInstance(): EmbedCommunicator;
-    sendCorrelatedRequest<TReturn>(eventName: ActionEventName, payload?: ActionEventPayload): Promise<TReturn>;
-    setIFrameManager(iFrameManager: iFrameManager): void;
+    sendCorrelatedRequest<TReturn>(eventName: ActionEventName, moduleType: typeof MODULE_NAMES.SDK | typeof MODULE_NAMES.EDM, payload?: ActionEventPayload): Promise<TReturn>;
+    setIFrameManager(mainModule: typeof MODULE_NAMES.SDK | typeof MODULE_NAMES.EDM, iFrameManager: iFrameManager): void;
     setupListener(): void;
     private handleInboundMessageEvent;
     private handleInboundEvent;
     private handleInboundEventNotification;
+    private getIframeManagerByMainModule;
     private isNotificationSuccess;
+    isValidBroadcastEvent(event: BroadcastEvent): false | import("../modules/edm/types").OnDesignStatusEvent | import("../modules/edm/types").OnErrorEvent | import("../modules/edm/types").OnFilePickerRequestedEvent | import("../modules/edm/types").StepResponse | import("../modules/edm/types/event/broadcastEventPayload.types").OnPricingStatusUpdateEventPayload | undefined;
     private resolveSuccessfulEvent;
-    protected send(event: ActionEvent): void;
+    handleBroadcastEvent(event: BroadcastEvent): void;
+    protected send(event: ActionEvent, moduleType: typeof MODULE_NAMES.SDK | typeof MODULE_NAMES.EDM): void;
     cleanup(): void;
 }

package/dist/esm/services/embedCommunicator.js

@@ -1,10 +1,14 @@
 import { MessageBroker } from './messageBroker';
-import { EVENT_TYPES, isNotification, isResult } from '../modules/eventTypes';
+import { EVENT_TYPES, isBroadcast, isNotification, isResult, } from '../modules/eventTypes';
 import { LOG_TYPES, logEmbedMessage } from '../helpers/messageLogger';
+import { BROADCAST_EVENT_MAP } from '../types/event/broadcast/broadcastEventMap';
+import { BroadcastEventDispatcher } from '../services/broadcastEventDispatcher';
+import { MODULE_NAMES } from '../modules/moduleNames';
 export class EmbedCommunicator {
     static #instance;
+    broadcastEventHandler = new BroadcastEventDispatcher();
     messageBroker = new MessageBroker();
-    iFrameManager = null;
+    iFrameManagers = { [MODULE_NAMES.SDK]: null, [MODULE_NAMES.EDM]: null };
     isListening = false;
     constructor() { }
     static getInstance() {
@@ -13,7 +17,7 @@ export class EmbedCommunicator {
         }
         return EmbedCommunicator.#instance;
     }
-    async sendCorrelatedRequest(eventName, payload) {
+    async sendCorrelatedRequest(eventName, moduleType, payload) {
         if (!this.isListening) {
             logEmbedMessage({
                 message: 'Warn [sendCorrelatedRequest]: Communicator is not listening, response may be ignored!',
@@ -29,11 +33,11 @@ export class EmbedCommunicator {
             payload,
             correlationId,
         };
-        this.send(actionEvent);
+        this.send(actionEvent, moduleType);
         return pendingMessagePromise;
     }
-    setIFrameManager(iFrameManager) {
-        this.iFrameManager = iFrameManager;
+    setIFrameManager(mainModule, iFrameManager) {
+        this.iFrameManagers[mainModule] = iFrameManager;
     }
     setupListener() {
         if (this.isListening) {
@@ -49,16 +53,21 @@ export class EmbedCommunicator {
             message: ['Received message', event.data],
             logType: LOG_TYPES.LOG,
         });
-        if (!this.iFrameManager) {
+        const iframeManagerType = this.getIframeManagerByMainModule(event);
+        if (!iframeManagerType) {
             throw new Error('iFrameManager not set');
         }
         // Only process messages from our iframe
-        if (!this.iFrameManager.isMessageFromIFrame(event)) {
+        if (!iframeManagerType.isMessageFromIFrame(event)) {
             return;
         }
         this.handleInboundEvent(event.data);
     }
     handleInboundEvent(event) {
+        if (isBroadcast(event)) {
+            this.handleBroadcastEvent(event);
+            return;
+        }
         if (!event.correlationId) {
             throw new Error(`Fail [handleInboundEvent (${event.name})]: correlationId missing`);
         }
@@ -75,6 +84,9 @@ export class EmbedCommunicator {
         throw new Error('Fail [handleInboundEvent]: Unsupported event type received!');
     }
     handleInboundEventNotification(event) {
+        if (!event.correlationId) {
+            throw new Error(`Fail [handleInboundEventNotification (${event.name})]: correlationId missing`);
+        }
         if (this.isNotificationSuccess(event)) {
             this.resolveSuccessfulEvent(event);
             return;
@@ -83,20 +95,40 @@ export class EmbedCommunicator {
         // Error should always be provided on a notification with fail status
         event.payload);
     }
+    getIframeManagerByMainModule(event) {
+        for (const manager of Object.values(this.iFrameManagers)) {
+            if (manager?.isMessageFromIFrame(event)) {
+                return manager;
+            }
+        }
+        return null;
+    }
     isNotificationSuccess(event) {
         if (!event.payload) {
             throw new Error(`Fail [handleNotification (${event.name})] Payload missing!`);
         }
         return event.payload.status === 'success';
     }
+    isValidBroadcastEvent(event) {
+        return event.name in BROADCAST_EVENT_MAP && event.payload;
+    }
     resolveSuccessfulEvent(event) {
+        if (!event.correlationId) {
+            throw new Error(`Fail [resolveSuccessfulEvent (${event.name})]: correlationId missing`);
+        }
         this.messageBroker.resolveMessage(event.correlationId, event.payload);
     }
-    send(event) {
-        if (!this.iFrameManager) {
+    handleBroadcastEvent(event) {
+        if (!this.isValidBroadcastEvent(event) || !event.payload) {
+            throw new Error(`Fail [handleInboundEvent (${event.name})]: Broadcast event payload missing`);
+        }
+        this.broadcastEventHandler.do(event.name, event.payload);
+    }
+    send(event, moduleType) {
+        if (!this.iFrameManagers[moduleType]) {
             throw new Error('iFrameManager not set');
         }
-        this.iFrameManager.postMessage(event);
+        this.iFrameManagers[moduleType].postMessage(event);
     }
     cleanup() {
         this.messageBroker.clearAll();

package/dist/esm/services/iFrameManager.d.ts

@@ -1,7 +1,9 @@
 export interface IFrameConfig {
     baseUrl: string;
-    nonce: string;
     style?: Partial<CSSStyleDeclaration>;
+    urlParams: Record<string, string | number | boolean>;
+    class?: string;
+    elementToAppendTo: HTMLElement;
 }
 export declare class iFrameManager {
     private config;

package/dist/esm/services/iFrameManager.js

@@ -10,17 +10,14 @@ export class iFrameManager {
         return new Promise((resolve, reject) => {
             this.destroy();
             const iFrame = document.createElement('iframe');
-            // Apply default styles
-            iFrame.style.display = 'none';
-            iFrame.style.position = 'fixed';
-            iFrame.style.width = '0';
-            iFrame.style.height = '0';
-            iFrame.style.border = 'none';
-            // Apply custom styles if provided
             if (this.config.style) {
                 Object.assign(iFrame.style, this.config.style);
             }
-            iFrame.src = `${this.config.baseUrl}?nonce=${encodeURIComponent(this.config.nonce)}`;
+            if (this.config.class) {
+                iFrame.setAttribute('class', this.config.class);
+            }
+            const convertedUrlParams = Object.entries(this.config.urlParams).map(([k, v]) => [k, String(v)]);
+            iFrame.src = `${this.config.baseUrl}?${new URLSearchParams(convertedUrlParams).toString()}`;
             let settled = false;
             const cleanup = () => {
                 settled = true;
@@ -43,7 +40,7 @@ export class iFrameManager {
             };
             iFrame.addEventListener('load', onLoad);
             iFrame.addEventListener('error', onError);
-            document.body.appendChild(iFrame);
+            this.config.elementToAppendTo.appendChild(iFrame);
         });
     }
     destroy() {

package/dist/esm/services/moduleLoaderService.d.ts

@@ -1,7 +1,7 @@
 import { ModuleName } from '../types/module/module.types';
 import { MODULES } from '../modules/modules';
 import { ModuleConfig, ModuleConfigData } from '../types/module/moduleConfig.types';
-type ModuleInstance = InstanceType<(typeof MODULES)[keyof typeof MODULES]>;
+export type ModuleInstance = InstanceType<(typeof MODULES)[keyof typeof MODULES]>;
 export declare class ModuleLoaderService {
     private static instance;
     private communicator;
@@ -13,4 +13,3 @@ export declare class ModuleLoaderService {
     clearCache(): void;
     isModuleLoaded(moduleName: ModuleName): boolean;
 }
-export {};

package/dist/esm/services/moduleLoaderService.js

@@ -1,5 +1,5 @@
 import { EmbedCommunicator } from './embedCommunicator';
-import { MODULES } from '../modules/modules';
+import { MODULE_DEPENDENCY_MAP, MODULES } from '../modules/modules';
 import { EVENTS_ACTION } from '../modules/sdk/types';
 import { LOG_TYPES, logEmbedMessage } from '../helpers/messageLogger';
 export class ModuleLoaderService {
@@ -20,7 +20,8 @@ export class ModuleLoaderService {
         return this.moduleCache.get(moduleName);
     }
     async loadModule(config) {
-        const notification = await this.communicator.sendCorrelatedRequest(EVENTS_ACTION.LOAD_MODULE, config);
+        const mainModule = MODULE_DEPENDENCY_MAP[config.name];
+        const notification = await this.communicator.sendCorrelatedRequest(EVENTS_ACTION.LOAD_MODULE, mainModule, config);
         logEmbedMessage({
             message: ['Loaded module', notification],
             logType: LOG_TYPES.LOG,

package/dist/esm/types/event/action/actionEvent.types.d.ts

@@ -2,10 +2,11 @@ import { ActionEvent as SdkActionEvent } from '../../../modules/sdk/types/event/
 import { ActionEvent as CatalogActionEvent } from '../../../modules/catalog/types/event/actionEvent.types';
 import { ActionEvent as MockupGenerationActionEvent } from '../../../modules/mockup-generation/types/event/actionEvent.types';
 import { ActionEvent as ProductPublishActionEvent } from '../../../modules/product-publish/types/event/actionEvent.types';
+import { ActionEvent as EdmActionEvent } from '../../../modules/edm/types/event/actionEvent.types';
 import { ALL_ACTION_EVENTS } from '../../../modules/events';
 import { Event } from '../../../types/event/event.types';
 import { EVENT_TYPES } from '../../../modules/eventTypes';
 import { ActionEventPayload } from './actionEventPayload.types';
 export type ActionEventName = (typeof ALL_ACTION_EVENTS)[keyof typeof ALL_ACTION_EVENTS];
 export type BaseActionEvent<TName extends ActionEventName, TPayload extends ActionEventPayload> = Event<TName, typeof EVENT_TYPES.ACTION, TPayload>;
-export type ActionEvent = MockupGenerationActionEvent | CatalogActionEvent | ProductPublishActionEvent | SdkActionEvent;
+export type ActionEvent = MockupGenerationActionEvent | CatalogActionEvent | ProductPublishActionEvent | SdkActionEvent | EdmActionEvent;

package/dist/esm/types/event/action/actionEventPayload.types.d.ts

@@ -2,4 +2,5 @@ import { ActionEventPayload as SdkEventPayload, LoadModulePayload } from '../../
 import { ActionEventPayload as CatalogEventPayload } from '../../../modules/catalog/types/event/actionEventPayload.types';
 import { ActionEventPayload as MockupGenerationEventPayload } from '../../../modules/mockup-generation/types/event/actionEventPayload.types';
 import { ActionEventPayload as ProductPublishEventPayload } from '../../../modules/product-publish/types/event/actionEventPayload.types';
-export type ActionEventPayload = LoadModulePayload | MockupGenerationEventPayload | CatalogEventPayload | SdkEventPayload | ProductPublishEventPayload | undefined;
+import { ActionEventPayload as EdmEventPayload } from '../../../modules/edm/types/event/actionEventPayload.types';
+export type ActionEventPayload = LoadModulePayload | MockupGenerationEventPayload | CatalogEventPayload | SdkEventPayload | ProductPublishEventPayload | EdmEventPayload | undefined;

package/dist/esm/types/event/broadcast/broadcastEvent.types.d.ts

@@ -0,0 +1,8 @@
+import { ALL_BROADCAST_EVENTS } from '../../../modules/events';
+import { Event } from '../../../types/event/event.types';
+import { EVENT_TYPES } from '../../../modules/eventTypes';
+import { BroadcastEventPayload } from '../../../types/event/broadcast/broadcastEventPayload.types';
+import { BroadcastEvent as EdmBroadcastEvent } from '../../../modules/edm/types/event/broadcastEvent.types';
+export type BroadcastEventName = (typeof ALL_BROADCAST_EVENTS)[keyof typeof ALL_BROADCAST_EVENTS];
+export type BaseBroadcastEvent<TName extends BroadcastEventName, TPayload extends BroadcastEventPayload> = Event<TName, typeof EVENT_TYPES.BROADCAST, TPayload>;
+export type BroadcastEvent = EdmBroadcastEvent;

package/dist/esm/types/event/broadcast/broadcastEvent.types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/event/broadcast/broadcastEventHandler.d.ts

@@ -0,0 +1,5 @@
+import { BroadcastEventPayload } from '../../../types/event/broadcast/broadcastEventPayload.types';
+import { BROADCAST_EVENT_MAP } from '../../../types/event/broadcast/broadcastEventMap';
+export interface BroadcastEventHandler {
+    handle(payload?: BroadcastEventPayload): typeof BROADCAST_EVENT_MAP;
+}

package/dist/esm/types/event/broadcast/broadcastEventHandler.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/event/broadcast/broadcastEventMap.d.ts

@@ -0,0 +1,12 @@
+import { OnDesignStatusUpdate } from '../../../modules/edm/broadcastEvents/onDesignStatusUpdate';
+import { OnStepStatusUpdate } from '../../../modules/edm/broadcastEvents/onStepStatusUpdate';
+import { OnPricingStatusUpdate } from '../../../modules/edm/broadcastEvents/onPricingStatusUpdate';
+import { OnFilePickerRequested } from '../../../modules/edm/broadcastEvents/onFilePickerRequested';
+import { OnErrorUpdate } from '../../../modules/edm/broadcastEvents/onErrorUpdate';
+export declare const BROADCAST_EVENT_MAP: {
+    onDesignStatusUpdate: typeof OnDesignStatusUpdate;
+    onFilePickerRequested: typeof OnFilePickerRequested;
+    onStepStatusUpdate: typeof OnStepStatusUpdate;
+    onPricingStatusUpdate: typeof OnPricingStatusUpdate;
+    onError: typeof OnErrorUpdate;
+};

package/dist/esm/types/event/broadcast/broadcastEventMap.js

@@ -0,0 +1,13 @@
+import { ALL_BROADCAST_EVENTS } from '../../../modules/events';
+import { OnDesignStatusUpdate } from '../../../modules/edm/broadcastEvents/onDesignStatusUpdate';
+import { OnStepStatusUpdate } from '../../../modules/edm/broadcastEvents/onStepStatusUpdate';
+import { OnPricingStatusUpdate } from '../../../modules/edm/broadcastEvents/onPricingStatusUpdate';
+import { OnFilePickerRequested } from '../../../modules/edm/broadcastEvents/onFilePickerRequested';
+import { OnErrorUpdate } from '../../../modules/edm/broadcastEvents/onErrorUpdate';
+export const BROADCAST_EVENT_MAP = {
+    [ALL_BROADCAST_EVENTS.ON_DESIGN_STATUS_UPDATE]: OnDesignStatusUpdate,
+    [ALL_BROADCAST_EVENTS.ON_FILE_PICKER_REQUESTED]: OnFilePickerRequested,
+    [ALL_BROADCAST_EVENTS.ON_STEP_STATUS_UPDATE]: OnStepStatusUpdate,
+    [ALL_BROADCAST_EVENTS.ON_PRICING_STATUS_UPDATE]: OnPricingStatusUpdate,
+    [ALL_BROADCAST_EVENTS.ON_INTERNAL_ERROR]: OnErrorUpdate,
+};

package/dist/esm/types/event/broadcast/broadcastEventPayload.types.d.ts

@@ -0,0 +1,2 @@
+import { BroadcastEventPayload as EdmBroadcastEvent } from '../../../modules/edm/types/event/broadcastEventPayload.types';
+export type BroadcastEventPayload = EdmBroadcastEvent;

package/dist/esm/types/event/broadcast/broadcastEventPayload.types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/event/event.types.d.ts

@@ -4,12 +4,13 @@ import type { NotificationEvent } from './notification/notificationEvent.types';
 import type { ResultEvent } from './result/resultEvent.types';
 import { EVENT_TYPES } from '../../modules/eventTypes';
 import { EventPayload } from './eventPayload.types';
+import { BroadcastEvent } from '../../types/event/broadcast/broadcastEvent.types';
 export type EventName = (typeof ALL_EVENTS)[keyof typeof ALL_EVENTS];
 export type EventTypeName = (typeof EVENT_TYPES)[keyof typeof EVENT_TYPES];
 export interface Event<TName extends EventName, TType extends EventTypeName, TPayload extends EventPayload> {
     name: TName;
     type: TType;
     payload?: TPayload;
-    correlationId: string;
+    correlationId?: string;
 }
-export type AnyEvent = ActionEvent | NotificationEvent | ResultEvent;
+export type AnyEvent = ActionEvent | NotificationEvent | ResultEvent | BroadcastEvent;

package/dist/esm/types/event/eventPayload.types.d.ts

@@ -1,4 +1,5 @@
 import type { ActionEventPayload } from './action/actionEventPayload.types';
 import type { NotificationEventPayload } from './notification/notificationEventPayload.types';
 import { ResultEventPayload } from './result/resultEventPayload.types';
-export type EventPayload = ActionEventPayload | NotificationEventPayload | ResultEventPayload | undefined;
+import { BroadcastEventPayload } from '../../types/event/broadcast/broadcastEventPayload.types';
+export type EventPayload = ActionEventPayload | NotificationEventPayload | ResultEventPayload | BroadcastEventPayload | undefined;

package/dist/esm/types/event/result/resultEvent.types.d.ts

@@ -1,10 +1,11 @@
 import { ResultEvent as CatalogResultEvent } from '../../../modules/catalog/types/event/resultEvent.types';
 import { ResultEvent as MockupGenerationResultEvent } from '../../../modules/mockup-generation/types/event/resultEvent.types';
 import { ResultEvent as ProductPublishResultEvent } from '../../../modules/product-publish/types/event/resultEvent.types';
+import { ResultEvent as EdmResultPayload } from '../../../modules/edm/types/event/resultEvent.types';
 import { ResultEventPayload } from './resultEventPayload.types';
 import { EVENT_TYPES } from '../../../modules/eventTypes';
 import { Event } from '../../../types/event/event.types';
 import { ALL_RESULT_EVENTS } from '../../../modules/events';
 export type ResultEventName = (typeof ALL_RESULT_EVENTS)[keyof typeof ALL_RESULT_EVENTS];
 export type BaseResultEvent<TName extends ResultEventName, TPayload extends ResultEventPayload> = Event<TName, typeof EVENT_TYPES.RESULT, TPayload>;
-export type ResultEvent = MockupGenerationResultEvent | CatalogResultEvent | ProductPublishResultEvent;
+export type ResultEvent = MockupGenerationResultEvent | CatalogResultEvent | ProductPublishResultEvent | EdmResultPayload;

package/dist/esm/types/event/result/resultEventPayload.types.d.ts

@@ -1,7 +1,8 @@
 import type { CatalogResultPayload } from '../../../modules/catalog/types';
 import type { MockupGenerationResultPayload } from '../../../modules/mockup-generation/types';
 import type { ProductPublishResultPayload } from '../../../modules/product-publish/types';
-export type ResultEventPayload = MockupGenerationResultPayload | CatalogResultPayload | ProductPublishResultPayload;
+import type { EdmResultPayload } from '../../../modules/edm/types/event/resultEventPayload.types';
+export type ResultEventPayload = MockupGenerationResultPayload | CatalogResultPayload | ProductPublishResultPayload | EdmResultPayload;
 export type HandledResponse<T, K extends Error> = {
     data: T;
     error: null;

package/dist/esm/types/module/module.types.d.ts

@@ -4,6 +4,8 @@ import { SdkModuleConfigData } from '../../modules/sdk/types';
 import { GetCatalogCategoriesResultPayload, GetCatalogProductsByIdsPayload, GetCatalogProductsPayload, GetCatalogProductsResultPayload, GetSingleCatalogProductPayload, GetSingleCatalogProductResultPayload } from '../../modules/catalog/types';
 import { NotificationEventPayload } from '../../types/event/notification/notificationEventPayload.types';
 import { GetProductPublishPayload, ProductPublishData } from '../../modules/product-publish/types';
+import { OnDesignStatusEventPayload, OnErrorEventPayload, OnFilePickerRequestedEventPayload, OnPricingStatusUpdateEventPayload, OnStepStatusUpdateEventPayload } from '../../modules/edm/types/event/broadcastEventPayload.types';
+import { AddImagePayload, AddImageResultPayload, InitializeEdmPayload, NavigateStepPayload, NavigateStepResultPayload, SaveDesignResultPayload, SetStylePayload, SetStyleResultPayload } from '../../modules/edm/types';
 /** This file ensures that Iframe and SDK has the same source of truth for return values */
 export type ModuleName = (typeof MODULE_NAMES)[keyof typeof MODULE_NAMES];
 export interface ISdkModule {
@@ -22,3 +24,17 @@ export interface IMockupGenerationModule {
 export interface IProductPublishModule {
     productPublish(data: GetProductPublishPayload): ProductPublishData;
 }
+export interface IEdmModule {
+    setup(config?: InitializeEdmPayload): NotificationEventPayload | void;
+    saveDesign(): SaveDesignResultPayload;
+    addImage(payload: AddImagePayload): AddImageResultPayload;
+    setStyle(payload: SetStylePayload): SetStyleResultPayload;
+    navigateStep(payload: NavigateStepPayload): NavigateStepResultPayload;
+}
+export interface IEdmBroadcastModule {
+    onDesignStatusUpdate(event: OnDesignStatusEventPayload): void;
+    onFilePickerRequested(event: OnFilePickerRequestedEventPayload): void;
+    onPricingStatusUpdate(event: OnPricingStatusUpdateEventPayload): void;
+    onStepStatusUpdate(event: OnStepStatusUpdateEventPayload): void;
+    onErrorUpdate(event: OnErrorEventPayload): void;
+}

package/dist/esm/version.d.ts

@@ -1 +1 @@
-export declare const VERSION: "2.2.0";
+export declare const VERSION: "2.3.0";

package/dist/esm/version.js

@@ -1,2 +1,2 @@
 // AUTO-GENERATED
-export const VERSION = '2.2.0';
+export const VERSION = '2.3.0';