@fyul/embed-sdk 1.2.1

package/dist/cjs/services/messageBroker.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageBroker = void 0;
+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'));
+        }
+    }
+}
+exports.MessageBroker = MessageBroker;

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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleLoaderService = void 0;
+const embedCommunicator_1 = require("./embedCommunicator");
+const modules_1 = require("../modules/modules");
+const types_1 = require("../modules/sdk/types");
+const messageLogger_1 = require("../helpers/messageLogger");
+class ModuleLoaderService {
+    static instance;
+    communicator = embedCommunicator_1.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_1.MODULES[moduleName]();
+            this.moduleCache.set(moduleName, module);
+        }
+        return this.moduleCache.get(moduleName);
+    }
+    async loadModule(config) {
+        const notification = await this.communicator.sendCorrelatedRequest(types_1.EVENTS_ACTION.LOAD_MODULE, config);
+        (0, messageLogger_1.logEmbedMessage)({
+            message: ['Loaded module', notification],
+            logType: messageLogger_1.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);
+    }
+}
+exports.ModuleLoaderService = ModuleLoaderService;

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

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

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

@@ -0,0 +1,5 @@
+import { ActionEventPayload as SdkEventPayload, LoadModulePayload } from '../../../modules/sdk/types/event/actionEventPayload.types';
+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;

package/dist/cjs/types/event/action/actionEventPayload.types.js

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

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

@@ -0,0 +1,15 @@
+import type { ALL_EVENTS } from '../../modules/events';
+import type { ActionEvent } from './action/actionEvent.types';
+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';
+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;
+}
+export type AnyEvent = ActionEvent | NotificationEvent | ResultEvent;

package/dist/cjs/types/event/event.types.js

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

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

@@ -0,0 +1,4 @@
+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;

package/dist/cjs/types/event/eventPayload.types.js

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

package/dist/cjs/types/event/notification/notificationEvent.types.d.ts

@@ -0,0 +1,6 @@
+import type { Event } from '../../../types/event/event.types';
+import type { NotificationEventPayload } from './notificationEventPayload.types';
+import { ALL_NOTIFICATION_EVENTS } from '../../../modules/events';
+import { EVENT_TYPES } from '../../../modules/eventTypes';
+export type NotificationEventName = (typeof ALL_NOTIFICATION_EVENTS)[keyof typeof ALL_NOTIFICATION_EVENTS];
+export type NotificationEvent = Event<NotificationEventName, typeof EVENT_TYPES.NOTIFICATION, NotificationEventPayload>;

package/dist/cjs/types/event/notification/notificationEvent.types.js

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

package/dist/cjs/types/event/notification/notificationEventPayload.types.d.ts

@@ -0,0 +1,5 @@
+export interface NotificationEventPayload {
+    status: 'success' | 'error';
+    message: string;
+    error?: Error;
+}

package/dist/cjs/types/event/notification/notificationEventPayload.types.js

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

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

@@ -0,0 +1,10 @@
+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 { 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;

package/dist/cjs/types/event/result/resultEvent.types.js

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

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

@@ -0,0 +1,11 @@
+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;
+export type HandledResponse<T, K extends Error> = {
+    data: T;
+    error: null;
+} | {
+    data: null;
+    error: K;
+};

package/dist/cjs/types/event/result/resultEventPayload.types.js

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

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

@@ -0,0 +1,22 @@
+import type { MODULE_NAMES } from '../../modules/modules';
+import { GetMockupsPayload, GetMockupsResultPayload } from '../../modules/mockup-generation/types';
+import { SdkModuleConfigData } from '../../modules/sdk/types';
+import { GetCatalogCategoriesResultPayload, GetCatalogProductsResultPayload, GetSingleCatalogProductResultPayload } from '../../modules/catalog/types';
+import { NotificationEventPayload } from '../../types/event/notification/notificationEventPayload.types';
+import { GetProductPublishPayload, ProductPublishData } from '../../modules/product-publish/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 {
+    setup(config?: SdkModuleConfigData): Promise<NotificationEventPayload> | Promise<void>;
+}
+export interface ICatalogModule {
+    getProducts(categoryId: number): GetCatalogProductsResultPayload;
+    getProduct(productId: number): GetSingleCatalogProductResultPayload;
+    getCategories(): GetCatalogCategoriesResultPayload;
+}
+export interface IMockupGenerationModule {
+    getMockups(data: GetMockupsPayload): GetMockupsResultPayload;
+}
+export interface IProductPublishModule {
+    productPublish(data: GetProductPublishPayload): ProductPublishData;
+}

package/dist/cjs/types/module/module.types.js

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

package/dist/cjs/types/module/moduleConfig.types.d.ts

@@ -0,0 +1,10 @@
+import { ModuleName } from './module.types';
+import { CatalogModuleConfigData } from '../../modules/catalog/types';
+import { MockupGenerationModuleConfigData } from '../../modules/mockup-generation/types';
+import { SdkConfig } from '../../modules/sdk/types';
+import { ProductPublishModuleConfigData } from '../../modules/product-publish/types';
+export interface ModuleConfig<TModuleName extends ModuleName, TData extends ModuleConfigData> {
+    name: TModuleName;
+    data?: TData;
+}
+export type ModuleConfigData = SdkConfig | MockupGenerationModuleConfigData | CatalogModuleConfigData | ProductPublishModuleConfigData | undefined;

package/dist/cjs/types/module/moduleConfig.types.js

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

package/dist/cjs/version.d.ts

@@ -0,0 +1 @@
+export declare const VERSION: "1.2.1";

package/dist/cjs/version.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = void 0;
+// AUTO-GENERATED
+exports.VERSION = '1.2.1';

package/dist/esm/helpers/messageLogger.d.ts

@@ -0,0 +1,20 @@
+export declare const LOG_TYPES: {
+    readonly LOG: "log";
+    readonly INFO: "info";
+    readonly WARN: "warn";
+    readonly ERROR: "error";
+};
+export declare const SOURCES: {
+    readonly HOST: "Host";
+    readonly SDK: "SDK";
+};
+export interface MessageLoggerState {
+    isLoggerEnabled: boolean;
+    source: (typeof SOURCES)[keyof typeof SOURCES];
+}
+export declare const messageLoggerState: MessageLoggerState;
+export declare function setLoggerState(isLoggerEnabled: boolean, source: MessageLoggerState['source']): void;
+export declare function logEmbedMessage({ message, logType, }: {
+    message: string | unknown[];
+    logType?: (typeof LOG_TYPES)[keyof typeof LOG_TYPES];
+}): void;

package/dist/esm/helpers/messageLogger.js

@@ -0,0 +1,68 @@
+export const LOG_TYPES = {
+    LOG: 'log',
+    INFO: 'info',
+    WARN: 'warn',
+    ERROR: 'error',
+};
+export const SOURCES = {
+    HOST: 'Host',
+    SDK: 'SDK',
+};
+export const messageLoggerState = {
+    isLoggerEnabled: true,
+    source: SOURCES.SDK,
+};
+export function setLoggerState(isLoggerEnabled, source) {
+    messageLoggerState.isLoggerEnabled = isLoggerEnabled;
+    messageLoggerState.source = source;
+}
+function getSourceStyle(source) {
+    switch (source) {
+        case SOURCES.HOST:
+            return `
+        background: #dc2626;
+        color: white;
+        padding: 2px 6px;
+        border-radius: 12px;
+        font-weight: bold;
+      `;
+        case SOURCES.SDK:
+            return `
+        background: #3a82f6;
+        color: white;
+        padding: 2px 6px;
+        border-radius: 12px;
+        font-weight: bold;
+      `;
+        default:
+            return '';
+    }
+}
+export function logEmbedMessage({ message, logType = LOG_TYPES.LOG, }) {
+    if (!messageLoggerState.isLoggerEnabled && logType !== LOG_TYPES.ERROR) {
+        return;
+    }
+    const src = messageLoggerState.source;
+    const style = getSourceStyle(src);
+    const prefix = `%c${src}%c`;
+    // Normalize message to array
+    const msgArray = Array.isArray(message) ? message : [message];
+    // Arguments: prefix, styles, and the message parts
+    const args = [prefix, style, '', ...msgArray];
+    switch (logType) {
+        case 'log':
+            console.log(...args);
+            break;
+        case 'info':
+            console.info(...args);
+            break;
+        case 'warn':
+            console.warn(...args);
+            break;
+        case 'error':
+            console.error(...args);
+            break;
+        default:
+            break;
+    }
+}

package/dist/esm/helpers/responseHandler.d.ts

@@ -0,0 +1,6 @@
+import { HandledResponse } from '../types/event/result/resultEventPayload.types';
+import { NotificationEventPayload } from '../types/event/notification/notificationEventPayload.types';
+import { ResultEventPayload } from '../types/event/result/resultEventPayload.types';
+export declare function isNotificationPayload(payload: ResultEventPayload | NotificationEventPayload): payload is NotificationEventPayload;
+export declare function isErrorNotification(payload: NotificationEventPayload): boolean;
+export declare function handleResponse<T extends ResultEventPayload>(response: T | NotificationEventPayload, context?: string): HandledResponse<T, Error>;

package/dist/esm/helpers/responseHandler.js

@@ -0,0 +1,23 @@
+export function isNotificationPayload(payload) {
+    return 'status' in payload && ('error' in payload || 'message' in payload);
+}
+export function isErrorNotification(payload) {
+    return payload.status === 'error';
+}
+export function handleResponse(response, context) {
+    if (isNotificationPayload(response)) {
+        if (isErrorNotification(response)) {
+            const errorMessage = context
+                ? `${context}: ${response.message}`
+                : response.message;
+            const error = response.error || new Error(errorMessage);
+            error.message = errorMessage;
+            return { error, data: null };
+        }
+        return {
+            error: new Error(`Unexpected success notification in request context: ${response.message}`),
+            data: null,
+        };
+    }
+    return { error: null, data: response };
+}

package/dist/esm/helpers/typeHelper.types.d.ts

@@ -0,0 +1,10 @@
+import { HandledResponse } from '../types/event/result/resultEventPayload.types';
+/** Wraps all method returns in promises */
+export type PromisifyMethods<T> = {
+    [K in keyof T]: T[K] extends (this: infer TThis, ...args: infer A) => infer R ? (this: TThis, ...args: A) => Promise<R> : T[K];
+};
+type AwaitedLike<T> = T extends PromiseLike<infer U> ? U : T;
+export type WithHandledResponses<T, E extends Error = Error> = {
+    [K in keyof T]: T[K] extends (this: infer TThis, ...args: infer A) => infer R ? (this: TThis, ...args: A) => Promise<HandledResponse<AwaitedLike<R>, E>> : T[K] /** If not a method, remains unchanged **/;
+};
+export {};

package/dist/esm/helpers/typeHelper.types.js

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

package/dist/esm/index.d.ts

@@ -0,0 +1,44 @@
+import { SdkConfig } from './modules/sdk/types';
+import { CatalogService } from './modules/catalog/catalogService';
+import { MockupService } from './modules/mockup-generation/mockupService';
+import { ProductPublishService } from './modules/product-publish/productPublishService';
+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;
+}
+export * from './types/event/event.types';
+export * from './types/event/eventPayload.types';
+export * from './types/event/action/actionEvent.types';
+export * from './types/event/action/actionEventPayload.types';
+export * from './types/event/notification/notificationEvent.types';
+export * from './types/event/notification/notificationEventPayload.types';
+export * from './types/event/result/resultEvent.types';
+export * from './types/event/result/resultEventPayload.types';
+export * from './types/module/module.types';
+export * from './types/module/moduleConfig.types';
+export * as CatalogModule from './modules/catalog/types';
+export * as MockupGenerationModule from './modules/mockup-generation/types';
+export * as ProductPublishModule from './modules/product-publish/types';
+export * as SdkModule from './modules/sdk/types';
+export { ALL_EVENTS } from './modules/events';
+export { MODULE_NAMES } from './modules/modules';
+export { EVENT_TYPES } from './modules/eventTypes';
+export { VERSION } from './version';
+export { logEmbedMessage, setLoggerState, LOG_TYPES, SOURCES, } from './helpers/messageLogger';
+export { handleResponse, isNotificationPayload, isErrorNotification, } from './helpers/responseHandler';
+export { getSortedVariantList, getVariantImageGallery, } from './modules/catalog/helpers/variantUtils';
+export { CatalogService } from './modules/catalog/catalogService';
+export { MockupService } from './modules/mockup-generation/mockupService';
+export { ProductPublishService } from './modules/product-publish/productPublishService';
+export { PromisifyMethods } from './helpers/typeHelper.types';

package/dist/esm/index.js

@@ -0,0 +1,101 @@
+import { iFrameManager } from './services/iFrameManager';
+import { EmbedCommunicator } from './services/embedCommunicator';
+import { ModuleLoaderService } from './services/moduleLoaderService';
+import { MODULE_NAMES } from './modules/modules';
+import { CatalogService } from './modules/catalog/catalogService';
+import { MockupService } from './modules/mockup-generation/mockupService';
+import { ProductPublishService } from './modules/product-publish/productPublishService';
+import { VERSION } from './version';
+import { setLoggerState, logEmbedMessage, SOURCES, LOG_TYPES, } from './helpers/messageLogger';
+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,
+            nonce: this.nonce,
+        });
+        await this.iFrameManager.create();
+        // Setup communicator with iframe manager
+        this.communicator.setIFrameManager(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;
+    }
+}
+/* EXPORTS */
+// TODO: properly foldered exports?
+// Common types
+export * from './types/event/event.types';
+export * from './types/event/eventPayload.types';
+export * from './types/event/action/actionEvent.types';
+export * from './types/event/action/actionEventPayload.types';
+export * from './types/event/notification/notificationEvent.types';
+export * from './types/event/notification/notificationEventPayload.types';
+export * from './types/event/result/resultEvent.types';
+export * from './types/event/result/resultEventPayload.types';
+export * from './types/module/module.types';
+export * from './types/module/moduleConfig.types';
+// Barrel module exports
+export * as CatalogModule from './modules/catalog/types';
+export * as MockupGenerationModule from './modules/mockup-generation/types';
+export * as ProductPublishModule from './modules/product-publish/types';
+export * as SdkModule from './modules/sdk/types';
+// Constants
+export { ALL_EVENTS } from './modules/events';
+export { MODULE_NAMES } from './modules/modules';
+export { EVENT_TYPES } from './modules/eventTypes';
+// Internals
+export { VERSION } from './version';
+export { logEmbedMessage, setLoggerState, LOG_TYPES, SOURCES, } from './helpers/messageLogger';
+// Helper utilities
+export { handleResponse, isNotificationPayload, isErrorNotification, } from './helpers/responseHandler';
+export { getSortedVariantList, getVariantImageGallery, } from './modules/catalog/helpers/variantUtils';
+// Service classes (for type annotations)
+export { CatalogService } from './modules/catalog/catalogService';
+export { MockupService } from './modules/mockup-generation/mockupService';
+export { ProductPublishService } from './modules/product-publish/productPublishService';

package/dist/esm/modules/baseModule.d.ts

@@ -0,0 +1,7 @@
+import { ActionEventName } from '../types/event/action/actionEvent.types';
+import { ActionEventPayload } from '../types/event/action/actionEventPayload.types';
+import { ResultEventPayload } from '../types/event/result/resultEventPayload.types';
+import { NotificationEventPayload } from '../types/event/notification/notificationEventPayload.types';
+export declare abstract class BaseModule {
+    protected sendRequest<T extends ResultEventPayload | NotificationEventPayload>(eventName: ActionEventName, eventPayload?: ActionEventPayload): Promise<T>;
+}

package/dist/esm/modules/baseModule.js

@@ -0,0 +1,6 @@
+import { EmbedCommunicator } from '../services/embedCommunicator';
+export class BaseModule {
+    async sendRequest(eventName, eventPayload) {
+        return await EmbedCommunicator.getInstance().sendCorrelatedRequest(eventName, eventPayload);
+    }
+}

package/dist/esm/modules/baseModuleService.d.ts

@@ -0,0 +1,10 @@
+import { ModuleLoaderService } from '../services/moduleLoaderService';
+import { ModuleName } from '../types/module/module.types';
+import { ModuleConfigData } from '../types/module/moduleConfig.types';
+import { MODULES } from './modules';
+type ModuleInstance = InstanceType<(typeof MODULES)[keyof typeof MODULES]>;
+export declare abstract class BaseModuleService {
+    protected moduleLoader: ModuleLoaderService;
+    protected ensureModuleLoaded<T extends ModuleInstance>(moduleName: ModuleName, config?: ModuleConfigData): Promise<T>;
+}
+export {};

package/dist/esm/modules/baseModuleService.js

@@ -0,0 +1,7 @@
+import { ModuleLoaderService } from '../services/moduleLoaderService';
+export class BaseModuleService {
+    moduleLoader = ModuleLoaderService.getInstance();
+    async ensureModuleLoaded(moduleName, config) {
+        return this.moduleLoader.ensureModuleLoaded(moduleName, config);
+    }
+}

package/dist/esm/modules/catalog/catalogModule.d.ts

@@ -0,0 +1,9 @@
+import { ICatalogModule } from '../../types/module/module.types';
+import { BaseModule } from '../../modules/baseModule';
+import { GetCatalogCategoriesResultPayload, GetCatalogProductsResultPayload, GetSingleCatalogProductResultPayload } from './types';
+import { WithHandledResponses } from '../../helpers/typeHelper.types';
+export declare class CatalogModule extends BaseModule implements WithHandledResponses<ICatalogModule> {
+    getProducts(categoryId: number, page?: number): Promise<import("../..").HandledResponse<GetCatalogProductsResultPayload, Error>>;
+    getProduct(productId: number): Promise<import("../..").HandledResponse<GetSingleCatalogProductResultPayload, Error>>;
+    getCategories(): Promise<import("../..").HandledResponse<GetCatalogCategoriesResultPayload, Error>>;
+}