@fyul/embed-sdk 1.2.1

package/dist/esm/modules/modules.js

@@ -0,0 +1,16 @@
+import { SdkModule } from './sdk/sdkModule';
+import { CatalogModule } from './catalog/catalogModule';
+import { MockupGenerationModule } from './mockup-generation/mockupGenerationModule';
+import { ProductPublishModule } from './product-publish/productPublishModule';
+export const MODULE_NAMES = {
+    SDK: 'sdk', // MAIN MODULE
+    CATALOG: 'catalog',
+    MOCKUP_GENERATION: 'mockupGeneration',
+    PRODUCT_PUBLISH: 'productPublish',
+};
+export const MODULES = {
+    [MODULE_NAMES.SDK]: SdkModule,
+    [MODULE_NAMES.CATALOG]: CatalogModule,
+    [MODULE_NAMES.MOCKUP_GENERATION]: MockupGenerationModule,
+    [MODULE_NAMES.PRODUCT_PUBLISH]: ProductPublishModule,
+};

package/dist/esm/modules/product-publish/events.d.ts

@@ -0,0 +1,14 @@
+export declare const EVENTS_ACTION: {
+    readonly PRODUCT_PUBLISH: "actionProductPublish";
+};
+export declare const EVENTS_NOTIFICATION: {
+    readonly GET_PRODUCT_PUBLISH_FAILURE: "actionGetProductPublishFailure";
+};
+export declare const EVENTS_RESULT: {
+    readonly GET_PRODUCT_PUBLISH_RESULT: "resultGetProductPublish";
+};
+export declare const EVENTS: {
+    readonly GET_PRODUCT_PUBLISH_RESULT: "resultGetProductPublish";
+    readonly GET_PRODUCT_PUBLISH_FAILURE: "actionGetProductPublishFailure";
+    readonly PRODUCT_PUBLISH: "actionProductPublish";
+};

package/dist/esm/modules/product-publish/events.js

@@ -0,0 +1,14 @@
+export const EVENTS_ACTION = {
+    PRODUCT_PUBLISH: 'actionProductPublish',
+};
+export const EVENTS_NOTIFICATION = {
+    GET_PRODUCT_PUBLISH_FAILURE: 'actionGetProductPublishFailure',
+};
+export const EVENTS_RESULT = {
+    GET_PRODUCT_PUBLISH_RESULT: 'resultGetProductPublish',
+};
+export const EVENTS = {
+    ...EVENTS_ACTION,
+    ...EVENTS_NOTIFICATION,
+    ...EVENTS_RESULT,
+};

package/dist/esm/modules/product-publish/productPublishModule.d.ts

@@ -0,0 +1,7 @@
+import { IProductPublishModule } from '../../types/module/module.types';
+import { BaseModule } from '../../modules/baseModule';
+import { GetProductPublishPayload } from '../../modules/product-publish/types';
+import { WithHandledResponses } from '../../helpers/typeHelper.types';
+export declare class ProductPublishModule extends BaseModule implements WithHandledResponses<IProductPublishModule> {
+    productPublish(data: GetProductPublishPayload): Promise<import("../..").HandledResponse<import("../../modules/product-publish/types").ProductPublishData, Error>>;
+}

package/dist/esm/modules/product-publish/productPublishModule.js

@@ -0,0 +1,9 @@
+import { BaseModule } from '../../modules/baseModule';
+import { EVENTS_ACTION, } from '../../modules/product-publish/types';
+import { handleResponse } from '../../helpers/responseHandler';
+export class ProductPublishModule extends BaseModule {
+    async productPublish(data) {
+        const response = await this.sendRequest(EVENTS_ACTION.PRODUCT_PUBLISH, data).catch((e) => e);
+        return handleResponse(response, 'Failed to publish products');
+    }
+}

package/dist/esm/modules/product-publish/productPublishService.d.ts

@@ -0,0 +1,6 @@
+import { BaseModuleService } from '../../modules/baseModuleService';
+import { GetProductPublishPayload } from '../../modules/product-publish/types';
+export declare class ProductPublishService extends BaseModuleService {
+    private getProductPublishModule;
+    productPublish(data: GetProductPublishPayload): Promise<import("../..").HandledResponse<import("../../modules/product-publish/types").ProductPublishData, Error>>;
+}

package/dist/esm/modules/product-publish/productPublishService.js

@@ -0,0 +1,11 @@
+import { BaseModuleService } from '../../modules/baseModuleService';
+import { MODULE_NAMES } from '../../modules/modules';
+export class ProductPublishService extends BaseModuleService {
+    async getProductPublishModule() {
+        return this.ensureModuleLoaded(MODULE_NAMES.PRODUCT_PUBLISH);
+    }
+    async productPublish(data) {
+        const module = await this.getProductPublishModule();
+        return await module.productPublish(data);
+    }
+}

package/dist/esm/modules/product-publish/types/event/actionEvent.types.d.ts

@@ -0,0 +1,5 @@
+import { EVENTS_ACTION } from '../../../../modules/product-publish/events';
+import type { GetProductPublishPayload } from './actionEventPayload.types';
+import { BaseActionEvent } from '../../../../types/event/action/actionEvent.types';
+export type GetProductPublishAction = BaseActionEvent<typeof EVENTS_ACTION.PRODUCT_PUBLISH, GetProductPublishPayload>;
+export type ActionEvent = GetProductPublishAction;

package/dist/esm/modules/product-publish/types/event/actionEvent.types.js

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

package/dist/esm/modules/product-publish/types/event/actionEventPayload.types.d.ts

@@ -0,0 +1,8 @@
+export interface GetProductPublishPayload {
+    blob: Blob | null;
+    publishData: {
+        productId: number;
+        variantIds: number[];
+    }[];
+}
+export type ActionEventPayload = GetProductPublishPayload;

package/dist/esm/modules/product-publish/types/event/actionEventPayload.types.js

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

package/dist/esm/modules/product-publish/types/event/resultEvent.types.d.ts

@@ -0,0 +1,5 @@
+import type { EVENTS_RESULT } from '../../../../modules/product-publish/events';
+import type { ProductPublishResultPayload } from './resultEventPayload.types';
+import { BaseResultEvent } from '../../../../types/event/result/resultEvent.types';
+export type GetProductPublishResult = BaseResultEvent<typeof EVENTS_RESULT.GET_PRODUCT_PUBLISH_RESULT, ProductPublishResultPayload>;
+export type ResultEvent = GetProductPublishResult;

package/dist/esm/modules/product-publish/types/event/resultEvent.types.js

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

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

@@ -0,0 +1,4 @@
+export interface ProductPublishData {
+    productTemplateIds: number[];
+}
+export type ProductPublishResultPayload = ProductPublishData;

package/dist/esm/modules/product-publish/types/event/resultEventPayload.types.js

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

package/dist/esm/modules/product-publish/types/index.d.ts

@@ -0,0 +1,6 @@
+export * from './event/actionEvent.types';
+export * from './event/actionEventPayload.types';
+export * from './event/resultEvent.types';
+export * from './event/resultEventPayload.types';
+export * from '../../../modules/product-publish/events';
+export * from './moduleConfig.types';

package/dist/esm/modules/product-publish/types/index.js

@@ -0,0 +1,9 @@
+// Event types
+export * from './event/actionEvent.types';
+export * from './event/actionEventPayload.types';
+export * from './event/resultEvent.types';
+export * from './event/resultEventPayload.types';
+// Event names
+export * from '../../../modules/product-publish/events';
+// Module config types
+export * from './moduleConfig.types';

package/dist/esm/modules/product-publish/types/moduleConfig.types.d.ts

@@ -0,0 +1,2 @@
+import { ActionEventPayload } from './event/actionEventPayload.types';
+export type ProductPublishModuleConfigData = ActionEventPayload;

package/dist/esm/modules/product-publish/types/moduleConfig.types.js

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

package/dist/esm/modules/sdk/events.d.ts

@@ -0,0 +1,13 @@
+export declare const EVENTS_ACTION: {
+    readonly INITIALIZE_SDK: "actionInitializeSdk";
+    readonly LOAD_MODULE: "actionLoadModule";
+};
+export declare const EVENTS_NOTIFICATION: {
+    readonly SDK_INITIALIZATION_SUCCESS: "notificationSdkInitializationSuccess";
+};
+export declare const EVENTS_RESULT: {};
+export declare const EVENTS: {
+    readonly SDK_INITIALIZATION_SUCCESS: "notificationSdkInitializationSuccess";
+    readonly INITIALIZE_SDK: "actionInitializeSdk";
+    readonly LOAD_MODULE: "actionLoadModule";
+};

package/dist/esm/modules/sdk/events.js

@@ -0,0 +1,13 @@
+export const EVENTS_ACTION = {
+    INITIALIZE_SDK: 'actionInitializeSdk',
+    LOAD_MODULE: 'actionLoadModule',
+};
+export const EVENTS_NOTIFICATION = {
+    SDK_INITIALIZATION_SUCCESS: 'notificationSdkInitializationSuccess',
+};
+export const EVENTS_RESULT = {};
+export const EVENTS = {
+    ...EVENTS_ACTION,
+    ...EVENTS_NOTIFICATION,
+    ...EVENTS_RESULT,
+};

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

@@ -0,0 +1,7 @@
+import { ISdkModule } from '../../types/module/module.types';
+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 {
+    setup(payload?: InitializeSdkPayload): Promise<NotificationEventPayload>;
+}

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

@@ -0,0 +1,7 @@
+import { BaseModule } from '../../modules/baseModule';
+import { EVENTS_ACTION } from './events';
+export class SdkModule extends BaseModule {
+    async setup(payload) {
+        return await this.sendRequest(EVENTS_ACTION.INITIALIZE_SDK, payload);
+    }
+}

package/dist/esm/modules/sdk/types/data.types.d.ts

@@ -0,0 +1,10 @@
+import type { ModuleName } from '../../../types/module/module.types';
+import { ModuleConfig, ModuleConfigData } from '../../../types/module/moduleConfig.types';
+export interface SdkConfig {
+    targetOrigin?: string;
+    modules?: ModuleConfig<ModuleName, ModuleConfigData | undefined>[];
+    debug?: boolean;
+}
+export interface SdkConfigWithVersion extends SdkConfig {
+    clientVersion: string;
+}

package/dist/esm/modules/sdk/types/data.types.js

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

package/dist/esm/modules/sdk/types/event/actionEvent.types.d.ts

@@ -0,0 +1,6 @@
+import { EVENTS_ACTION } from '../../../../modules/sdk/events';
+import { InitializeSdkPayload, LoadModulePayload } from './actionEventPayload.types';
+import { BaseActionEvent } from '../../../../types/event/action/actionEvent.types';
+export type InitializeSdkAction = BaseActionEvent<typeof EVENTS_ACTION.INITIALIZE_SDK, InitializeSdkPayload>;
+export type LoadModuleAction = BaseActionEvent<typeof EVENTS_ACTION.LOAD_MODULE, LoadModulePayload>;
+export type ActionEvent = LoadModuleAction | InitializeSdkAction;

package/dist/esm/modules/sdk/types/event/actionEvent.types.js

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

package/dist/esm/modules/sdk/types/event/actionEventPayload.types.d.ts

@@ -0,0 +1,6 @@
+import { SdkConfig, SdkConfigWithVersion } from '../../../../modules/sdk/types/data.types';
+import { ModuleName } from '../../../../types/module/module.types';
+import type { ModuleConfig, ModuleConfigData } from '../../../../types/module/moduleConfig.types';
+export type InitializeSdkPayload = SdkConfig | SdkConfigWithVersion;
+export type LoadModulePayload = ModuleConfig<ModuleName, ModuleConfigData>;
+export type ActionEventPayload = LoadModulePayload | InitializeSdkPayload;

package/dist/esm/modules/sdk/types/event/actionEventPayload.types.js

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

package/dist/esm/modules/sdk/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from './data.types';
+export * from './event/actionEvent.types';
+export * from './event/actionEventPayload.types';
+export * from '../../../modules/sdk/events';
+export * from './moduleConfig.types';

package/dist/esm/modules/sdk/types/index.js

@@ -0,0 +1,9 @@
+// Data types
+export * from './data.types';
+// Event types
+export * from './event/actionEvent.types';
+export * from './event/actionEventPayload.types';
+// Event names
+export * from '../../../modules/sdk/events';
+// Module configs
+export * from './moduleConfig.types';

package/dist/esm/modules/sdk/types/moduleConfig.types.d.ts

@@ -0,0 +1,2 @@
+import { SdkConfig } from './data.types';
+export type SdkModuleConfigData = SdkConfig;

package/dist/esm/modules/sdk/types/moduleConfig.types.js

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

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

@@ -0,0 +1,21 @@
+import { iFrameManager } from './iFrameManager';
+import { ActionEvent, ActionEventName } from '../types/event/action/actionEvent.types';
+import { ActionEventPayload } from '../types/event/action/actionEventPayload.types';
+export declare class EmbedCommunicator {
+    #private;
+    private messageBroker;
+    private iFrameManager;
+    private isListening;
+    private constructor();
+    static getInstance(): EmbedCommunicator;
+    sendCorrelatedRequest<TReturn>(eventName: ActionEventName, payload?: ActionEventPayload): Promise<TReturn>;
+    setIFrameManager(iFrameManager: iFrameManager): void;
+    setupListener(): void;
+    private handleInboundMessageEvent;
+    private handleInboundEvent;
+    private handleInboundEventNotification;
+    private isNotificationSuccess;
+    private resolveSuccessfulEvent;
+    protected send(event: ActionEvent): void;
+    cleanup(): void;
+}

package/dist/esm/services/embedCommunicator.js

@@ -0,0 +1,104 @@
+import { MessageBroker } from './messageBroker';
+import { EVENT_TYPES, isNotification, isResult } from '../modules/eventTypes';
+import { LOG_TYPES, logEmbedMessage } from '../helpers/messageLogger';
+export class EmbedCommunicator {
+    static #instance;
+    messageBroker = new MessageBroker();
+    iFrameManager = null;
+    isListening = false;
+    constructor() { }
+    static getInstance() {
+        if (!EmbedCommunicator.#instance) {
+            EmbedCommunicator.#instance = new EmbedCommunicator();
+        }
+        return EmbedCommunicator.#instance;
+    }
+    async sendCorrelatedRequest(eventName, payload) {
+        if (!this.isListening) {
+            logEmbedMessage({
+                message: 'Warn [sendCorrelatedRequest]: Communicator is not listening, response may be ignored!',
+                logType: LOG_TYPES.WARN,
+            });
+        }
+        const correlationId = this.messageBroker.generateCorrelationId();
+        const pendingMessagePromise = this.messageBroker.createPendingMessage(correlationId);
+        // Only action events supported as of now (and probably forever)
+        const actionEvent = {
+            name: eventName,
+            type: EVENT_TYPES.ACTION,
+            payload,
+            correlationId,
+        };
+        this.send(actionEvent);
+        return pendingMessagePromise;
+    }
+    setIFrameManager(iFrameManager) {
+        this.iFrameManager = iFrameManager;
+    }
+    setupListener() {
+        if (this.isListening) {
+            return;
+        }
+        window.addEventListener('message', (event) => {
+            this.handleInboundMessageEvent(event);
+        });
+        this.isListening = true;
+    }
+    handleInboundMessageEvent(event) {
+        logEmbedMessage({
+            message: ['Received message', event.data],
+            logType: LOG_TYPES.LOG,
+        });
+        if (!this.iFrameManager) {
+            throw new Error('iFrameManager not set');
+        }
+        // Only process messages from our iframe
+        if (!this.iFrameManager.isMessageFromIFrame(event)) {
+            return;
+        }
+        this.handleInboundEvent(event.data);
+    }
+    handleInboundEvent(event) {
+        if (!event.correlationId) {
+            throw new Error(`Fail [handleInboundEvent (${event.name})]: correlationId missing`);
+        }
+        // Result event gets inbound ONLY if there's nothing wrong.
+        // Otherwise it's a notification.
+        if (isResult(event)) {
+            this.resolveSuccessfulEvent(event);
+            return;
+        }
+        if (isNotification(event)) {
+            this.handleInboundEventNotification(event);
+            return;
+        }
+        throw new Error('Fail [handleInboundEvent]: Unsupported event type received!');
+    }
+    handleInboundEventNotification(event) {
+        if (this.isNotificationSuccess(event)) {
+            this.resolveSuccessfulEvent(event);
+            return;
+        }
+        this.messageBroker.rejectMessage(event.correlationId, 
+        // Error should always be provided on a notification with fail status
+        event.payload);
+    }
+    isNotificationSuccess(event) {
+        if (!event.payload) {
+            throw new Error(`Fail [handleNotification (${event.name})] Payload missing!`);
+        }
+        return event.payload.status === 'success';
+    }
+    resolveSuccessfulEvent(event) {
+        this.messageBroker.resolveMessage(event.correlationId, event.payload);
+    }
+    send(event) {
+        if (!this.iFrameManager) {
+            throw new Error('iFrameManager not set');
+        }
+        this.iFrameManager.postMessage(event);
+    }
+    cleanup() {
+        this.messageBroker.clearAll();
+    }
+}

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

@@ -0,0 +1,15 @@
+export interface IFrameConfig {
+    baseUrl: string;
+    nonce: string;
+    style?: Partial<CSSStyleDeclaration>;
+}
+export declare class iFrameManager {
+    private config;
+    private iFrame;
+    private readonly targetOrigin;
+    constructor(config: IFrameConfig);
+    create(): Promise<HTMLIFrameElement>;
+    destroy(): void;
+    postMessage(message: unknown): void;
+    isMessageFromIFrame(event: MessageEvent): boolean;
+}

package/dist/esm/services/iFrameManager.js

@@ -0,0 +1,66 @@
+export class iFrameManager {
+    config;
+    iFrame = null;
+    targetOrigin;
+    constructor(config) {
+        this.config = config;
+        this.targetOrigin = new URL(config.baseUrl).origin;
+    }
+    async create() {
+        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)}`;
+            let settled = false;
+            const cleanup = () => {
+                settled = true;
+                iFrame.removeEventListener('load', onLoad);
+                iFrame.removeEventListener('error', onError);
+            };
+            const onLoad = () => {
+                if (!settled) {
+                    cleanup();
+                    this.iFrame = iFrame;
+                    resolve(iFrame);
+                }
+            };
+            const onError = () => {
+                if (!settled) {
+                    cleanup();
+                    iFrame.remove();
+                    reject(new Error('Failed to load communication iframe'));
+                }
+            };
+            iFrame.addEventListener('load', onLoad);
+            iFrame.addEventListener('error', onError);
+            document.body.appendChild(iFrame);
+        });
+    }
+    destroy() {
+        if (!this.iFrame) {
+            return;
+        }
+        this.iFrame.remove();
+        this.iFrame = null;
+    }
+    postMessage(message) {
+        if (!this.iFrame || !this.iFrame.contentWindow) {
+            throw new Error('Iframe not initialized');
+        }
+        this.iFrame.contentWindow.postMessage(message, this.targetOrigin);
+    }
+    isMessageFromIFrame(event) {
+        return (event.source === this.iFrame?.contentWindow &&
+            event.origin === this.targetOrigin);
+    }
+}

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

@@ -0,0 +1,19 @@
+import { EventPayload } from '../types/event/eventPayload.types';
+import { NotificationEventPayload } from '../types/event/notification/notificationEventPayload.types';
+export interface PendingMessage<T = unknown> {
+    resolve: (value: T) => void;
+    reject: (reason?: unknown) => void;
+    timestamp: number;
+    timeoutId?: ReturnType<typeof setTimeout>;
+}
+export declare class MessageBroker {
+    private pendingMessages;
+    private defaultTimeout;
+    generateCorrelationId(): string;
+    createPendingMessage<TReturn>(correlationId: string, timeout?: number): Promise<TReturn>;
+    resolveMessage(correlationId: string, data: EventPayload): boolean;
+    rejectMessage(correlationId: string, error?: NotificationEventPayload | Error): boolean;
+    hasPendingMessage(correlationId: string): boolean;
+    clearExpiredMessages(maxAge?: number): void;
+    clearAll(): void;
+}

package/dist/esm/services/messageBroker.js

@@ -0,0 +1,60 @@
+export class MessageBroker {
+    pendingMessages = new Map();
+    defaultTimeout = 30000; // 30 seconds
+    generateCorrelationId() {
+        return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+    createPendingMessage(correlationId, timeout = this.defaultTimeout) {
+        return new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(() => {
+                this.rejectMessage(correlationId, new Error(`Request timeout after ${timeout}ms`));
+            }, timeout);
+            this.pendingMessages.set(correlationId, {
+                resolve: resolve,
+                reject,
+                timestamp: Date.now(),
+                timeoutId,
+            });
+        });
+    }
+    resolveMessage(correlationId, data) {
+        const pending = this.pendingMessages.get(correlationId);
+        if (!pending) {
+            return false;
+        }
+        if (pending.timeoutId) {
+            clearTimeout(pending.timeoutId);
+        }
+        pending.resolve(data);
+        this.pendingMessages.delete(correlationId);
+        return true;
+    }
+    rejectMessage(correlationId, error) {
+        const pending = this.pendingMessages.get(correlationId);
+        if (!pending) {
+            return false;
+        }
+        if (pending.timeoutId) {
+            clearTimeout(pending.timeoutId);
+        }
+        pending.reject(error);
+        this.pendingMessages.delete(correlationId);
+        return true;
+    }
+    hasPendingMessage(correlationId) {
+        return this.pendingMessages.has(correlationId);
+    }
+    clearExpiredMessages(maxAge = 60000) {
+        const now = Date.now();
+        for (const [correlationId, pending] of this.pendingMessages.entries()) {
+            if (now - pending.timestamp > maxAge) {
+                this.rejectMessage(correlationId, new Error('Message expired without response'));
+            }
+        }
+    }
+    clearAll() {
+        for (const [correlationId] of this.pendingMessages.entries()) {
+            this.rejectMessage(correlationId, new Error('Broker cleared'));
+        }
+    }
+}

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

@@ -0,0 +1,16 @@
+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 declare class ModuleLoaderService {
+    private static instance;
+    private communicator;
+    private moduleCache;
+    static getInstance(): ModuleLoaderService;
+    getModule<T extends ModuleInstance>(moduleName: ModuleName): T;
+    loadModule(config: ModuleConfig<ModuleName, ModuleConfigData>): Promise<void>;
+    ensureModuleLoaded<T extends ModuleInstance>(moduleName: ModuleName, config?: ModuleConfigData): Promise<T>;
+    clearCache(): void;
+    isModuleLoaded(moduleName: ModuleName): boolean;
+}
+export {};

package/dist/esm/services/moduleLoaderService.js

@@ -0,0 +1,46 @@
+import { EmbedCommunicator } from './embedCommunicator';
+import { MODULES } from '../modules/modules';
+import { EVENTS_ACTION } from '../modules/sdk/types';
+import { LOG_TYPES, logEmbedMessage } from '../helpers/messageLogger';
+export class ModuleLoaderService {
+    static instance;
+    communicator = EmbedCommunicator.getInstance();
+    moduleCache = new Map();
+    static getInstance() {
+        if (!ModuleLoaderService.instance) {
+            ModuleLoaderService.instance = new ModuleLoaderService();
+        }
+        return ModuleLoaderService.instance;
+    }
+    getModule(moduleName) {
+        if (!this.isModuleLoaded(moduleName)) {
+            const module = new MODULES[moduleName]();
+            this.moduleCache.set(moduleName, module);
+        }
+        return this.moduleCache.get(moduleName);
+    }
+    async loadModule(config) {
+        const notification = await this.communicator.sendCorrelatedRequest(EVENTS_ACTION.LOAD_MODULE, config);
+        logEmbedMessage({
+            message: ['Loaded module', notification],
+            logType: LOG_TYPES.LOG,
+        });
+    }
+    async ensureModuleLoaded(moduleName, config) {
+        if (!this.isModuleLoaded(moduleName)) {
+            await this.loadModule({
+                name: moduleName,
+                data: config,
+            });
+            const module = this.getModule(moduleName);
+            this.moduleCache.set(moduleName, module);
+        }
+        return this.moduleCache.get(moduleName);
+    }
+    clearCache() {
+        this.moduleCache.clear();
+    }
+    isModuleLoaded(moduleName) {
+        return this.moduleCache.has(moduleName);
+    }
+}

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

@@ -0,0 +1,11 @@
+import { ActionEvent as SdkActionEvent, LoadModuleAction } from '../../../modules/sdk/types/event/actionEvent.types';
+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 { 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 = LoadModuleAction | MockupGenerationActionEvent | CatalogActionEvent | ProductPublishActionEvent | SdkActionEvent;

package/dist/esm/types/event/action/actionEvent.types.js

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