@fyul/embed-sdk 2.2.0 → 2.3.0

package/dist/cjs/modules/product-publish/types/event/resultEventPayload.types.d.ts

@@ -1,4 +1,9 @@
 export interface ProductPublishData {
     productTemplateIds: number[];
+    templates: {
+        productTemplateId: number;
+        externalProductId: string;
+        externalCustomerId: string;
+    }[];
 }
 export type ProductPublishResultPayload = ProductPublishData;

package/dist/cjs/modules/sdk/sdkModule.d.ts

@@ -3,5 +3,6 @@ import { BaseModule } from '../../modules/baseModule';
 import { InitializeSdkPayload } from './types';
 import { NotificationEventPayload } from '../../types/event/notification/notificationEventPayload.types';
 export declare class SdkModule extends BaseModule implements ISdkModule {
+    constructor();
     setup(payload?: InitializeSdkPayload): Promise<NotificationEventPayload>;
 }

package/dist/cjs/modules/sdk/sdkModule.js

@@ -3,7 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SdkModule = void 0;
 const baseModule_1 = require("../../modules/baseModule");
 const events_1 = require("./events");
+const modules_1 = require("../../modules/modules");
 class SdkModule extends baseModule_1.BaseModule {
+    constructor() {
+        super(modules_1.MODULE_NAMES.SDK);
+    }
     async setup(payload) {
         return await this.sendRequest(events_1.EVENTS_ACTION.INITIALIZE_SDK, payload);
     }

package/dist/cjs/services/broadcastEventDispatcher.d.ts

@@ -0,0 +1,8 @@
+import { BROADCAST_EVENT_MAP } from '../types/event/broadcast/broadcastEventMap';
+import { BroadcastEventPayload } from '../types/event/broadcast/broadcastEventPayload.types';
+export declare class BroadcastEventDispatcher {
+    private eventHandlers;
+    constructor();
+    do(eventName: keyof typeof BROADCAST_EVENT_MAP, payload: BroadcastEventPayload): void;
+    private initHandlers;
+}

package/dist/cjs/services/broadcastEventDispatcher.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BroadcastEventDispatcher = void 0;
+const broadcastEventMap_1 = require("../types/event/broadcast/broadcastEventMap");
+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(broadcastEventMap_1.BROADCAST_EVENT_MAP)) {
+            this.eventHandlers.set(eventName, new EventHandlerClass());
+        }
+    }
+}
+exports.BroadcastEventDispatcher = BroadcastEventDispatcher;

package/dist/cjs/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/cjs/services/edm.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EDM = void 0;
+const iFrameManager_1 = require("../services/iFrameManager");
+const embedCommunicator_1 = require("../services/embedCommunicator");
+const moduleLoaderService_1 = require("../services/moduleLoaderService");
+const messageLogger_1 = require("../helpers/messageLogger");
+const moduleNames_1 = require("../modules/moduleNames");
+const version_1 = require("../version");
+const edmBroadcastModule_1 = require("../modules/edm/edmBroadcastModule");
+class EDM {
+    params;
+    config;
+    static BASE_URL = 'https://www.printful.com/embedded-designer';
+    static broadCastEventHandler;
+    nonce;
+    iFrameManager = null;
+    communicator = embedCommunicator_1.EmbedCommunicator.getInstance();
+    moduleLoader = moduleLoaderService_1.ModuleLoaderService.getInstance();
+    initialized = false;
+    constructor(params, config, callbacks) {
+        this.params = params;
+        this.config = config;
+        this.nonce = params.nonce;
+        EDM.broadCastEventHandler = new edmBroadcastModule_1.EdmBroadcastModule(callbacks);
+        (0, messageLogger_1.setLoggerState)(params?.debug ?? false, messageLogger_1.SOURCES.EDM);
+    }
+    async init() {
+        if (this.initialized) {
+            (0, messageLogger_1.logEmbedMessage)({
+                message: 'EDM already initialized',
+                logType: messageLogger_1.LOG_TYPES.WARN,
+            });
+            return;
+        }
+        const elementToBindTo = this.params.element ?? document.getElementById(this.params.elementId);
+        if (!elementToBindTo) {
+            (0, messageLogger_1.logEmbedMessage)({
+                message: 'Cant find element for EDM',
+                logType: messageLogger_1.LOG_TYPES.ERROR,
+            });
+            return;
+        }
+        this.iFrameManager = new iFrameManager_1.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(moduleNames_1.MODULE_NAMES.EDM, this.iFrameManager);
+        this.communicator.setupListener();
+        const edmModule = this.moduleLoader.getModule(moduleNames_1.MODULE_NAMES.EDM);
+        const notification = await edmModule.setup({
+            ...this.config,
+            ...this.params,
+            clientVersion: version_1.VERSION,
+        });
+        (0, messageLogger_1.logEmbedMessage)({
+            message: ['EDM setup notification', notification],
+            logType: messageLogger_1.LOG_TYPES.LOG,
+        });
+        this.initialized = true;
+    }
+    saveDesign() {
+        const edmModule = this.moduleLoader.getModule(moduleNames_1.MODULE_NAMES.EDM);
+        return edmModule.saveDesign();
+    }
+    setStyle(payload) {
+        const edmModule = this.moduleLoader.getModule(moduleNames_1.MODULE_NAMES.EDM);
+        return edmModule.setStyle(payload);
+    }
+    addImage(payload) {
+        const edmModule = this.moduleLoader.getModule(moduleNames_1.MODULE_NAMES.EDM);
+        return edmModule.addImage(payload);
+    }
+    navigateStep(payload) {
+        const edmModule = this.moduleLoader.getModule(moduleNames_1.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;
+    }
+}
+exports.EDM = EDM;

package/dist/cjs/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/cjs/services/embed.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Embed = void 0;
+const iFrameManager_1 = require("../services/iFrameManager");
+const embedCommunicator_1 = require("../services/embedCommunicator");
+const moduleLoaderService_1 = require("../services/moduleLoaderService");
+const catalogService_1 = require("../modules/catalog/catalogService");
+const mockupService_1 = require("../modules/mockup-generation/mockupService");
+const productPublishService_1 = require("../modules/product-publish/productPublishService");
+const messageLogger_1 = require("../helpers/messageLogger");
+const modules_1 = require("../modules/modules");
+const version_1 = require("../version");
+class Embed {
+    config;
+    static BASE_URL = 'https://www.printful.com/embed-sdk';
+    nonce;
+    iFrameManager = null;
+    communicator = embedCommunicator_1.EmbedCommunicator.getInstance();
+    moduleLoader = moduleLoaderService_1.ModuleLoaderService.getInstance();
+    initialized = false;
+    // Service composition
+    catalog;
+    mockup;
+    publish;
+    constructor(nonce, config) {
+        this.config = config;
+        this.nonce = nonce;
+        (0, messageLogger_1.setLoggerState)(config?.debug ?? false, messageLogger_1.SOURCES.SDK);
+        // Initialize services
+        this.catalog = new catalogService_1.CatalogService();
+        this.mockup = new mockupService_1.MockupService();
+        this.publish = new productPublishService_1.ProductPublishService();
+    }
+    async init() {
+        if (this.initialized) {
+            (0, messageLogger_1.logEmbedMessage)({
+                message: 'Embed SDK already initialized',
+                logType: messageLogger_1.LOG_TYPES.WARN,
+            });
+            return;
+        }
+        // Client mode: Create iframe and setup communication
+        this.iFrameManager = new iFrameManager_1.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(modules_1.MODULE_NAMES.SDK, this.iFrameManager);
+        this.communicator.setupListener();
+        // Get SDK module and setup
+        const sdkModule = this.moduleLoader.getModule(modules_1.MODULE_NAMES.SDK);
+        const notification = await sdkModule.setup({
+            ...this.config,
+            clientVersion: version_1.VERSION,
+        });
+        (0, messageLogger_1.logEmbedMessage)({
+            message: ['SDK (Main) module setup notification', notification],
+            logType: messageLogger_1.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;
+    }
+}
+exports.Embed = Embed;

package/dist/cjs/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/cjs/services/embedCommunicator.js

@@ -4,10 +4,14 @@ exports.EmbedCommunicator = void 0;
 const messageBroker_1 = require("./messageBroker");
 const eventTypes_1 = require("../modules/eventTypes");
 const messageLogger_1 = require("../helpers/messageLogger");
+const broadcastEventMap_1 = require("../types/event/broadcast/broadcastEventMap");
+const broadcastEventDispatcher_1 = require("../services/broadcastEventDispatcher");
+const moduleNames_1 = require("../modules/moduleNames");
 class EmbedCommunicator {
     static #instance;
+    broadcastEventHandler = new broadcastEventDispatcher_1.BroadcastEventDispatcher();
     messageBroker = new messageBroker_1.MessageBroker();
-    iFrameManager = null;
+    iFrameManagers = { [moduleNames_1.MODULE_NAMES.SDK]: null, [moduleNames_1.MODULE_NAMES.EDM]: null };
     isListening = false;
     constructor() { }
     static getInstance() {
@@ -16,7 +20,7 @@ class EmbedCommunicator {
         }
         return EmbedCommunicator.#instance;
     }
-    async sendCorrelatedRequest(eventName, payload) {
+    async sendCorrelatedRequest(eventName, moduleType, payload) {
         if (!this.isListening) {
             (0, messageLogger_1.logEmbedMessage)({
                 message: 'Warn [sendCorrelatedRequest]: Communicator is not listening, response may be ignored!',
@@ -32,11 +36,11 @@ 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) {
@@ -52,16 +56,21 @@ class EmbedCommunicator {
             message: ['Received message', event.data],
             logType: messageLogger_1.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 ((0, eventTypes_1.isBroadcast)(event)) {
+            this.handleBroadcastEvent(event);
+            return;
+        }
         if (!event.correlationId) {
             throw new Error(`Fail [handleInboundEvent (${event.name})]: correlationId missing`);
         }
@@ -78,6 +87,9 @@ 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;
@@ -86,20 +98,40 @@ 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 broadcastEventMap_1.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/cjs/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/cjs/services/iFrameManager.js

@@ -13,17 +13,14 @@ 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;
@@ -46,7 +43,7 @@ class iFrameManager {
             };
             iFrame.addEventListener('load', onLoad);
             iFrame.addEventListener('error', onError);
-            document.body.appendChild(iFrame);
+            this.config.elementToAppendTo.appendChild(iFrame);
         });
     }
     destroy() {

package/dist/cjs/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/cjs/services/moduleLoaderService.js

@@ -23,7 +23,8 @@ class ModuleLoaderService {
         return this.moduleCache.get(moduleName);
     }
     async loadModule(config) {
-        const notification = await this.communicator.sendCorrelatedRequest(types_1.EVENTS_ACTION.LOAD_MODULE, config);
+        const mainModule = modules_1.MODULE_DEPENDENCY_MAP[config.name];
+        const notification = await this.communicator.sendCorrelatedRequest(types_1.EVENTS_ACTION.LOAD_MODULE, mainModule, config);
         (0, messageLogger_1.logEmbedMessage)({
             message: ['Loaded module', notification],
             logType: messageLogger_1.LOG_TYPES.LOG,

package/dist/cjs/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/cjs/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/cjs/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/cjs/types/event/broadcast/broadcastEvent.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/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/cjs/types/event/broadcast/broadcastEventHandler.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/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/cjs/types/event/broadcast/broadcastEventMap.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BROADCAST_EVENT_MAP = void 0;
+const events_1 = require("../../../modules/events");
+const onDesignStatusUpdate_1 = require("../../../modules/edm/broadcastEvents/onDesignStatusUpdate");
+const onStepStatusUpdate_1 = require("../../../modules/edm/broadcastEvents/onStepStatusUpdate");
+const onPricingStatusUpdate_1 = require("../../../modules/edm/broadcastEvents/onPricingStatusUpdate");
+const onFilePickerRequested_1 = require("../../../modules/edm/broadcastEvents/onFilePickerRequested");
+const onErrorUpdate_1 = require("../../../modules/edm/broadcastEvents/onErrorUpdate");
+exports.BROADCAST_EVENT_MAP = {
+    [events_1.ALL_BROADCAST_EVENTS.ON_DESIGN_STATUS_UPDATE]: onDesignStatusUpdate_1.OnDesignStatusUpdate,
+    [events_1.ALL_BROADCAST_EVENTS.ON_FILE_PICKER_REQUESTED]: onFilePickerRequested_1.OnFilePickerRequested,
+    [events_1.ALL_BROADCAST_EVENTS.ON_STEP_STATUS_UPDATE]: onStepStatusUpdate_1.OnStepStatusUpdate,
+    [events_1.ALL_BROADCAST_EVENTS.ON_PRICING_STATUS_UPDATE]: onPricingStatusUpdate_1.OnPricingStatusUpdate,
+    [events_1.ALL_BROADCAST_EVENTS.ON_INTERNAL_ERROR]: onErrorUpdate_1.OnErrorUpdate,
+};

package/dist/cjs/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/cjs/types/event/broadcast/broadcastEventPayload.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/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/cjs/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;