@fyul/embed-sdk 1.2.1

package/README.md

@@ -0,0 +1,198 @@
+# @fyulorg/embed-sdk
+
+A TypeScript SDK for integrating with Printful services via iframe-based cross-origin communication. The SDK provides a modular architecture for catalog browsing, mockup generation, and other Printful services through secure iframe messaging.
+
+## Features
+
+- 🎯 **Modular Architecture**: Separate modules for different services (Catalog, Mockup Generation, SDK core)
+- 🔒 **Secure Communication**: iframe-based cross-origin messaging with correlation ID tracking
+- 📦 **Dual Package Support**: Both ESM and CommonJS builds included
+- 🧪 **Fully Tested**: Comprehensive Jest test suite with 130+ tests and ~90% coverage
+- 🎨 **TypeScript First**: Complete type safety with extensive type definitions
+- 🔧 **Development Ready**: ESLint, Prettier, and modern tooling configured
+
+## Installation
+
+```bash
+npm install @fyulorg/embed-sdk
+```
+
+## Quick Start
+
+```typescript
+import { Embed } from '@fyulorg/embed-sdk';
+
+// Create SDK instance with your authentication nonce
+const embedSdk = new Embed('your-nonce-here', {
+  targetOrigin: 'https://your-domain.com',
+  modules: [
+    { name: 'catalog', data: { apiKey: 'your-api-key' } },
+    { name: 'mockupGeneration', data: { timeout: 30000 } }
+  ]
+});
+
+// Initialize connection
+await embedSdk.init();
+
+// Use catalog service
+const products = await embedSdk.catalog.getProducts(123);
+console.log('Products:', products);
+
+// Use mockup service
+const imageFile = new File(['...'], 'design.png', { type: 'image/png' });
+const mockups = await embedSdk.mockup.getMockups(imageFile, [1, 2, 3]);
+console.log('Generated mockups:', mockups);
+
+// Clean up when done
+embedSdk.destroy();
+```
+
+## API Reference
+
+### `new Embed(nonce, config?)`
+
+Creates a new SDK instance.
+
+**Parameters:**
+- `nonce` (string): Authentication token from your backend
+- `config` (optional): Configuration object
+  - `targetOrigin` (string): Target origin for iframe messages
+  - `modules` (array): Module configurations to initialize
+
+### Core Methods
+
+#### `embed.init(): Promise<void>`
+Initializes the SDK, creates iframe, and establishes communication channel.
+
+#### `embed.destroy(): void`
+Cleans up resources, removes iframe, and clears all pending messages.
+
+### Services
+
+#### Catalog Service (`embed.catalog`)
+```typescript
+// Get products by category
+const products = await embed.catalog.getProducts(categoryId);
+
+// Get all categories
+const categories = await embed.catalog.getCategories();
+```
+
+#### Mockup Service (`embed.mockup`)
+```typescript
+// Generate mockups from design file
+const mockups = await embed.mockup.getMockups(
+  designFile,      // Blob | File
+  productIds       // number[] (optional)
+);
+```
+
+## Module System
+
+The SDK uses a modular architecture where different services are loaded as separate modules:
+
+- **SDK Module**: Core functionality and initialization
+- **Catalog Module**: Product and category browsing
+- **Mockup Generation Module**: Design-to-mockup conversion
+
+Each module can be configured independently and loaded on-demand.
+
+## Event System
+
+The SDK implements a comprehensive event system for iframe communication:
+
+- **Action Events**: Commands sent to the iframe (e.g., initialize, load module)
+- **Result Events**: Successful responses from iframe operations
+- **Notification Events**: Status updates and error notifications
+
+All events include correlation IDs for request/response tracking.
+
+## TypeScript Support
+
+Full TypeScript support with extensive type definitions:
+
+```typescript
+import { 
+  Embed, 
+  CatalogModule, 
+  MockupGenerationModule,
+  NotificationEvent,
+  ResultEvent,
+  handleResponse
+} from '@fyulorg/embed-sdk';
+
+// All types are fully typed
+const embed = new Embed('nonce');
+const result: CatalogModule.GetProductsResult = await embed.catalog.getProducts(1);
+```
+
+## Development
+
+### Setup
+
+```bash
+# Install dependencies
+npm install
+
+# Run tests
+npm test
+npm run test:watch
+npm run test:coverage
+
+# Build
+npm run build
+
+# Lint and format
+npm run lint
+npm run prettier
+npm run lint:fix
+npm run prettier:fix
+```
+
+### Project Structure
+
+```
+src/
+├── index.ts              # Main SDK export
+├── services/             # Core services
+│   ├── embedCommunicator.ts
+│   ├── iFrameManager.ts
+│   ├── messagebroker.ts
+│   └── moduleLoaderService.ts
+├── modules/              # Feature modules
+│   ├── catalog/
+│   ├── mockup-generation/
+│   └── sdk/
+├── types/                # Shared type definitions
+│   ├── event/
+│   └── module/
+└── helpers/              # Utility functions
+
+tests/                    # Test files (mirrors src structure)
+├── services/
+├── modules/
+└── helpers/
+```
+
+### Import Aliases
+
+The project uses `~` aliases for clean imports:
+
+```typescript
+import { EmbedCommunicator } from '~/services/embedCommunicator';
+import { CatalogModule } from '~/modules/catalog/catalogModule';
+import { Event } from '~/types/event/event.types';
+```
+
+## Building
+
+The project builds to both ESM and CommonJS formats:
+
+- **ESM**: `dist/esm/` - Modern ES modules
+- **CJS**: `dist/cjs/` - Compatible CommonJS modules
+
+The build process uses TypeScript compilation followed by `tsc-alias` for path resolution.
+
+## License
+
+ISC

package/dist/cjs/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/cjs/helpers/messageLogger.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.messageLoggerState = exports.SOURCES = exports.LOG_TYPES = void 0;
+exports.setLoggerState = setLoggerState;
+exports.logEmbedMessage = logEmbedMessage;
+exports.LOG_TYPES = {
+    LOG: 'log',
+    INFO: 'info',
+    WARN: 'warn',
+    ERROR: 'error',
+};
+exports.SOURCES = {
+    HOST: 'Host',
+    SDK: 'SDK',
+};
+exports.messageLoggerState = {
+    isLoggerEnabled: true,
+    source: exports.SOURCES.SDK,
+};
+function setLoggerState(isLoggerEnabled, source) {
+    exports.messageLoggerState.isLoggerEnabled = isLoggerEnabled;
+    exports.messageLoggerState.source = source;
+}
+function getSourceStyle(source) {
+    switch (source) {
+        case exports.SOURCES.HOST:
+            return `
+        background: #dc2626;
+        color: white;
+        padding: 2px 6px;
+        border-radius: 12px;
+        font-weight: bold;
+      `;
+        case exports.SOURCES.SDK:
+            return `
+        background: #3a82f6;
+        color: white;
+        padding: 2px 6px;
+        border-radius: 12px;
+        font-weight: bold;
+      `;
+        default:
+            return '';
+    }
+}
+function logEmbedMessage({ message, logType = exports.LOG_TYPES.LOG, }) {
+    if (!exports.messageLoggerState.isLoggerEnabled && logType !== exports.LOG_TYPES.ERROR) {
+        return;
+    }
+    const src = exports.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/cjs/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/cjs/helpers/responseHandler.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNotificationPayload = isNotificationPayload;
+exports.isErrorNotification = isErrorNotification;
+exports.handleResponse = handleResponse;
+function isNotificationPayload(payload) {
+    return 'status' in payload && ('error' in payload || 'message' in payload);
+}
+function isErrorNotification(payload) {
+    return payload.status === 'error';
+}
+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/cjs/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/cjs/helpers/typeHelper.types.js

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

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

@@ -0,0 +1,157 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProductPublishService = exports.MockupService = exports.CatalogService = exports.getVariantImageGallery = exports.getSortedVariantList = exports.isErrorNotification = exports.isNotificationPayload = exports.handleResponse = exports.SOURCES = exports.LOG_TYPES = exports.setLoggerState = exports.logEmbedMessage = exports.VERSION = exports.EVENT_TYPES = exports.MODULE_NAMES = exports.ALL_EVENTS = exports.SdkModule = exports.ProductPublishModule = exports.MockupGenerationModule = exports.CatalogModule = exports.Embed = void 0;
+const iFrameManager_1 = require("./services/iFrameManager");
+const embedCommunicator_1 = require("./services/embedCommunicator");
+const moduleLoaderService_1 = require("./services/moduleLoaderService");
+const modules_1 = require("./modules/modules");
+const catalogService_1 = require("./modules/catalog/catalogService");
+const mockupService_1 = require("./modules/mockup-generation/mockupService");
+const productPublishService_1 = require("./modules/product-publish/productPublishService");
+const version_1 = require("./version");
+const messageLogger_1 = require("./helpers/messageLogger");
+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,
+            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(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;
+/* EXPORTS */
+// TODO: properly foldered exports?
+// Common types
+__exportStar(require("./types/event/event.types"), exports);
+__exportStar(require("./types/event/eventPayload.types"), exports);
+__exportStar(require("./types/event/action/actionEvent.types"), exports);
+__exportStar(require("./types/event/action/actionEventPayload.types"), exports);
+__exportStar(require("./types/event/notification/notificationEvent.types"), exports);
+__exportStar(require("./types/event/notification/notificationEventPayload.types"), exports);
+__exportStar(require("./types/event/result/resultEvent.types"), exports);
+__exportStar(require("./types/event/result/resultEventPayload.types"), exports);
+__exportStar(require("./types/module/module.types"), exports);
+__exportStar(require("./types/module/moduleConfig.types"), exports);
+// Barrel module exports
+exports.CatalogModule = __importStar(require("./modules/catalog/types"));
+exports.MockupGenerationModule = __importStar(require("./modules/mockup-generation/types"));
+exports.ProductPublishModule = __importStar(require("./modules/product-publish/types"));
+exports.SdkModule = __importStar(require("./modules/sdk/types"));
+// Constants
+var events_1 = require("./modules/events");
+Object.defineProperty(exports, "ALL_EVENTS", { enumerable: true, get: function () { return events_1.ALL_EVENTS; } });
+var modules_2 = require("./modules/modules");
+Object.defineProperty(exports, "MODULE_NAMES", { enumerable: true, get: function () { return modules_2.MODULE_NAMES; } });
+var eventTypes_1 = require("./modules/eventTypes");
+Object.defineProperty(exports, "EVENT_TYPES", { enumerable: true, get: function () { return eventTypes_1.EVENT_TYPES; } });
+// Internals
+var version_2 = require("./version");
+Object.defineProperty(exports, "VERSION", { enumerable: true, get: function () { return version_2.VERSION; } });
+var messageLogger_2 = require("./helpers/messageLogger");
+Object.defineProperty(exports, "logEmbedMessage", { enumerable: true, get: function () { return messageLogger_2.logEmbedMessage; } });
+Object.defineProperty(exports, "setLoggerState", { enumerable: true, get: function () { return messageLogger_2.setLoggerState; } });
+Object.defineProperty(exports, "LOG_TYPES", { enumerable: true, get: function () { return messageLogger_2.LOG_TYPES; } });
+Object.defineProperty(exports, "SOURCES", { enumerable: true, get: function () { return messageLogger_2.SOURCES; } });
+// Helper utilities
+var responseHandler_1 = require("./helpers/responseHandler");
+Object.defineProperty(exports, "handleResponse", { enumerable: true, get: function () { return responseHandler_1.handleResponse; } });
+Object.defineProperty(exports, "isNotificationPayload", { enumerable: true, get: function () { return responseHandler_1.isNotificationPayload; } });
+Object.defineProperty(exports, "isErrorNotification", { enumerable: true, get: function () { return responseHandler_1.isErrorNotification; } });
+var variantUtils_1 = require("./modules/catalog/helpers/variantUtils");
+Object.defineProperty(exports, "getSortedVariantList", { enumerable: true, get: function () { return variantUtils_1.getSortedVariantList; } });
+Object.defineProperty(exports, "getVariantImageGallery", { enumerable: true, get: function () { return variantUtils_1.getVariantImageGallery; } });
+// Service classes (for type annotations)
+var catalogService_2 = require("./modules/catalog/catalogService");
+Object.defineProperty(exports, "CatalogService", { enumerable: true, get: function () { return catalogService_2.CatalogService; } });
+var mockupService_2 = require("./modules/mockup-generation/mockupService");
+Object.defineProperty(exports, "MockupService", { enumerable: true, get: function () { return mockupService_2.MockupService; } });
+var productPublishService_2 = require("./modules/product-publish/productPublishService");
+Object.defineProperty(exports, "ProductPublishService", { enumerable: true, get: function () { return productPublishService_2.ProductPublishService; } });

package/dist/cjs/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/cjs/modules/baseModule.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseModule = void 0;
+const embedCommunicator_1 = require("../services/embedCommunicator");
+class BaseModule {
+    async sendRequest(eventName, eventPayload) {
+        return await embedCommunicator_1.EmbedCommunicator.getInstance().sendCorrelatedRequest(eventName, eventPayload);
+    }
+}
+exports.BaseModule = BaseModule;

package/dist/cjs/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/cjs/modules/baseModuleService.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseModuleService = void 0;
+const moduleLoaderService_1 = require("../services/moduleLoaderService");
+class BaseModuleService {
+    moduleLoader = moduleLoaderService_1.ModuleLoaderService.getInstance();
+    async ensureModuleLoaded(moduleName, config) {
+        return this.moduleLoader.ensureModuleLoaded(moduleName, config);
+    }
+}
+exports.BaseModuleService = BaseModuleService;

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

package/dist/cjs/modules/catalog/catalogModule.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CatalogModule = void 0;
+const baseModule_1 = require("../../modules/baseModule");
+const types_1 = require("./types");
+const responseHandler_1 = require("../../helpers/responseHandler");
+class CatalogModule extends baseModule_1.BaseModule {
+    async getProducts(categoryId, page = 1) {
+        const response = await this.sendRequest(types_1.EVENTS_ACTION.GET_CATALOG_PRODUCTS, {
+            categoryId,
+            page,
+        }).catch((e) => e);
+        return (0, responseHandler_1.handleResponse)(response, 'Failed to get catalog products');
+    }
+    async getProduct(productId) {
+        const response = await this.sendRequest(types_1.EVENTS_ACTION.GET_SINGLE_CATALOG_PRODUCT, {
+            productId,
+        }).catch((e) => e);
+        return (0, responseHandler_1.handleResponse)(response, 'Failed to get catalog products');
+    }
+    async getCategories() {
+        const response = await this.sendRequest(types_1.EVENTS_ACTION.GET_CATALOG_CATEGORIES).catch((e) => e);
+        return (0, responseHandler_1.handleResponse)(response, 'Failed to get catalog categories');
+    }
+}
+exports.CatalogModule = CatalogModule;

package/dist/cjs/modules/catalog/catalogService.d.ts

@@ -0,0 +1,7 @@
+import { BaseModuleService } from '../../modules/baseModuleService';
+export declare class CatalogService extends BaseModuleService {
+    private getCatalogModule;
+    getCategories(): Promise<import("../..").HandledResponse<import("./types").GetCatalogCategoriesResultPayload, Error>>;
+    getProducts(categoryId: number, page?: number): Promise<import("../..").HandledResponse<import("./types").GetCatalogProductsResultPayload, Error>>;
+    getProduct(productId: number): Promise<import("../..").HandledResponse<import("./types").GetSingleCatalogProductResultPayload, Error>>;
+}

package/dist/cjs/modules/catalog/catalogService.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CatalogService = void 0;
+const baseModuleService_1 = require("../../modules/baseModuleService");
+const modules_1 = require("../../modules/modules");
+class CatalogService extends baseModuleService_1.BaseModuleService {
+    async getCatalogModule() {
+        return this.ensureModuleLoaded(modules_1.MODULE_NAMES.CATALOG);
+    }
+    async getCategories() {
+        const module = await this.getCatalogModule();
+        return module.getCategories();
+    }
+    async getProducts(categoryId, page = 1) {
+        const module = await this.getCatalogModule();
+        return module.getProducts(categoryId, page);
+    }
+    async getProduct(productId) {
+        const module = await this.getCatalogModule();
+        return module.getProduct(productId);
+    }
+}
+exports.CatalogService = CatalogService;