@melio-eng/web-sdk 1.0.26 → 1.0.27-pr.53.6e729bc

package/dist/flows/BaseFlow.d.ts

@@ -0,0 +1,57 @@
+import { FlowInstance, FlowEventType, FlowEventCallback, FlowCompletionData, NavigationData, BaseFlowConfig, Environment, ErrorData } from '../types.js';
+/**
+ * Base Flow class implementation for handling iframe flows and events
+ */
+export declare abstract class BaseFlow implements FlowInstance {
+    private containerId;
+    protected config: BaseFlowConfig;
+    protected partnerName: string;
+    protected environment: Environment;
+    protected branchOverride?: string | undefined;
+    protected iframe: HTMLIFrameElement | null;
+    private container;
+    private eventListeners;
+    protected keepAliveInterval: number | null;
+    constructor(containerId: string, config: BaseFlowConfig, partnerName: string, environment: Environment, branchOverride?: string | undefined);
+    /**
+     * Initialize the flow by creating and injecting the iframe
+     */
+    initialize(): Promise<void>;
+    /**
+     * Construct the specific flow URL - must be implemented by subclasses
+     */
+    protected abstract constructFlowUrl(baseUrl: string): string;
+    /**
+     * Create flow URL using partner name and environment
+     */
+    protected createFlowUrl(): string;
+    private setupEventListeners;
+    /**
+     * Emit events to registered listeners
+     */
+    emit(event: 'completed', data: FlowCompletionData): void;
+    emit(event: 'loaded'): void;
+    emit(event: 'exit'): void;
+    emit(event: 'navigated', data: NavigationData): void;
+    emit(event: 'authenticationSucceeded'): void;
+    emit(event: 'authenticationFailed'): void;
+    emit(event: 'error', data: ErrorData): void;
+    /**
+     * Register an event listener
+     */
+    on(event: 'completed', callback: (data: FlowCompletionData) => void): void;
+    on(event: 'exit', callback: () => void): void;
+    on(event: 'navigated', callback: (payload: NavigationData) => void): void;
+    on(event: 'authenticationSucceeded', callback: () => void): void;
+    on(event: 'authenticationFailed', callback: () => void): void;
+    on(event: 'error', callback: (data: ErrorData) => void): void;
+    on(event: 'loaded', callback: () => void): void;
+    /**
+     * Remove an event listener
+     */
+    off(event: FlowEventType, callback: FlowEventCallback): void;
+    /**
+     * Close the flow and clean up resources
+     */
+    close(): void;
+}

package/dist/flows/BaseFlow.js

@@ -0,0 +1,143 @@
+import { getBaseUrl } from '../utils/environment.js';
+/**
+ * Base Flow class implementation for handling iframe flows and events
+ */
+export class BaseFlow {
+    constructor(containerId, config, partnerName, environment, branchOverride) {
+        this.containerId = containerId;
+        this.config = config;
+        this.partnerName = partnerName;
+        this.environment = environment;
+        this.branchOverride = branchOverride;
+        this.iframe = null;
+        this.container = null;
+        this.eventListeners = new Map();
+        this.keepAliveInterval = null;
+        this.setupEventListeners();
+    }
+    /**
+     * Initialize the flow by creating and injecting the iframe
+     */
+    async initialize() {
+        this.container = document.getElementById(this.containerId);
+        if (!this.container) {
+            throw new Error(`Container with ID "${this.containerId}" not found`);
+        }
+        this.iframe = document.createElement('iframe');
+        this.iframe.src = this.createFlowUrl();
+        this.iframe.style.width = '100%';
+        this.iframe.style.height = '1000px';
+        this.iframe.style.border = 'none';
+        this.iframe.style.display = 'block';
+        this.container.appendChild(this.iframe);
+    }
+    /**
+     * Create flow URL using partner name and environment
+     */
+    createFlowUrl() {
+        console.log('🔧 Creating flow URL...');
+        console.log('📝 Config:', this.config);
+        console.log('🏢 Partner:', this.partnerName);
+        console.log('🌍 Environment:', this.environment);
+        console.log('🔝 Branch Override:', this.branchOverride);
+        const baseUrl = getBaseUrl(this.environment);
+        let finalUrl = this.constructFlowUrl(baseUrl);
+        // Add cdn_branch_override parameter for non-production environments
+        if (this.branchOverride && this.environment !== 'production') {
+            const separator = finalUrl.includes('?') ? '&' : '?';
+            finalUrl += `${separator}cdn_branch_override=${this.branchOverride}`;
+        }
+        console.log('🌐 Final URL:', finalUrl);
+        return finalUrl;
+    }
+    setupEventListeners() {
+        // Add post message handlers for internal events - setHeight, scroll etc
+        // Also need to implement callbacks for flow completed exit etc in the platform-app
+        window.addEventListener('message', (event) => {
+            if (!/melio\.com|melioservices\.com/.test(event.origin)) {
+                return;
+            }
+            const { type, ...data } = event.data;
+            console.log('📬 Received message from iframe:', {
+                type,
+                data,
+                origin: event.origin,
+            });
+            switch (type) {
+                case 'FLOW_COMPLETED':
+                    this.emit('completed', data);
+                    break;
+                case 'FLOW_EXIT':
+                    this.emit('exit');
+                    break;
+                case 'NAVIGATED_TO_TARGET':
+                    this.emit('navigated', data);
+                    break;
+                case 'AUTHENTICATION_SUCCESS':
+                    this.emit('authenticationSucceeded');
+                    break;
+                case 'AUTHENTICATION_ERROR':
+                    this.emit('authenticationFailed');
+                    break;
+                case 'ONBOARDING_COMPLETED':
+                    this.emit('completed', { flowName: 'onboarding', ...data });
+                    break;
+                case 'READY_FOR_INTERACTION':
+                    this.emit('loaded');
+                    break;
+                case 'MELIO_ERROR':
+                    if (data.code === 'failed_to_sync_bills') {
+                        this.emit('error', { errorCode: 'billsSyncFailed' });
+                    }
+                    break;
+                case 'HEIGHT_CHANGE':
+                    if (this.iframe) {
+                        this.iframe.style.height = `${data.height}px`;
+                    }
+                    break;
+            }
+        });
+    }
+    emit(event, data) {
+        const listeners = this.eventListeners.get(event);
+        if (listeners) {
+            listeners.forEach((callback) => {
+                try {
+                    callback(data);
+                }
+                catch (error) {
+                    console.error(`Error in ${event} event listener:`, error);
+                }
+            });
+        }
+    }
+    on(event, callback) {
+        if (!this.eventListeners.has(event)) {
+            this.eventListeners.set(event, new Set());
+        }
+        this.eventListeners.get(event).add(callback);
+    }
+    /**
+     * Remove an event listener
+     */
+    off(event, callback) {
+        const listeners = this.eventListeners.get(event);
+        if (listeners) {
+            listeners.delete(callback);
+        }
+    }
+    /**
+     * Close the flow and clean up resources
+     */
+    close() {
+        if (this.keepAliveInterval) {
+            clearInterval(this.keepAliveInterval);
+            this.keepAliveInterval = null;
+        }
+        if (this.iframe && this.container) {
+            this.container.removeChild(this.iframe);
+            this.iframe = null;
+        }
+        this.eventListeners.clear();
+    }
+}

package/dist/flows/InitFlow.d.ts

@@ -0,0 +1,17 @@
+import { BaseFlow } from './BaseFlow.js';
+import { InitConfig, Environment } from '../types.js';
+/**
+ * InitFlow subclass for handling initialization with callbacks
+ */
+export declare class InitFlow extends BaseFlow {
+    private authorizationCode;
+    constructor(containerId: string, config: InitConfig, partnerName: string, environment: Environment, branchOverride?: string);
+    /**
+     * Initialize the init flow by creating and injecting a hidden iframe
+     */
+    initialize(): Promise<void>;
+    /**
+     * Construct the specific flow URL for initialization
+     */
+    protected constructFlowUrl(_baseUrl: string): string;
+}

package/dist/flows/InitFlow.js

@@ -0,0 +1,44 @@
+import { BaseFlow } from './BaseFlow.js';
+/**
+ * InitFlow subclass for handling initialization with callbacks
+ */
+export class InitFlow extends BaseFlow {
+    constructor(containerId, config, partnerName, environment, branchOverride) {
+        super(containerId, config, partnerName, environment, branchOverride);
+        if (isEmptyString(config.authCode)) {
+            throw new Error('Authorization code is required for init flow');
+        }
+        this.authorizationCode = config.authCode;
+    }
+    /**
+     * Initialize the init flow by creating and injecting a hidden iframe
+     */
+    async initialize() {
+        this.emit('authenticationSucceeded');
+        // Disabled for quick performance improvement. Will be re-enabled in the future.
+        // For init flow, we create a hidden iframe instead of a visible one
+        // this.iframe = document.createElement('iframe');
+        // this.iframe.src = this.createFlowUrl();
+        // this.iframe.style.width = '1px';
+        // this.iframe.style.height = '1px';
+        // this.iframe.style.position = 'absolute';
+        // this.iframe.style.left = '-9999px';
+        // this.iframe.style.top = '-9999px';
+        // document.body.appendChild(this.iframe);
+    }
+    /**
+     * Construct the specific flow URL for initialization
+     */
+    constructFlowUrl(_baseUrl) {
+        return '';
+        // Disabled for quick performance improvement. Will be re-enabled in the future.
+        //   const params = new URLSearchParams({
+        //     token: this.authorizationCode,
+        //     theme: this.partnerName,
+        //   });
+        //   return `${baseUrl}/${this.partnerName}/auth?${params.toString()}`;
+    }
+}
+const isEmptyString = (str) => {
+    return !str?.trim();
+};

package/dist/flows/OnboardingFlow.d.ts

@@ -0,0 +1,14 @@
+import { BaseFlow } from './BaseFlow.js';
+import { OnboardingConfig, Environment } from '../types.js';
+/**
+ * OnboardingFlow subclass with custom URL construction
+ */
+export declare class OnboardingFlow extends BaseFlow {
+    private preFilledParams;
+    private enforceOnboarding?;
+    constructor(containerId: string, config: OnboardingConfig, partnerName: string, environment: Environment, branchOverride?: string);
+    /**
+     * Construct the specific flow URL for onboarding
+     */
+    protected constructFlowUrl(baseUrl: string): string;
+}

package/dist/flows/OnboardingFlow.js

@@ -0,0 +1,43 @@
+import { BaseFlow } from './BaseFlow.js';
+import { BASE_ACTION } from '../utils/environment.js';
+/**
+ * OnboardingFlow subclass with custom URL construction
+ */
+export class OnboardingFlow extends BaseFlow {
+    constructor(containerId, config, partnerName, environment, branchOverride) {
+        super(containerId, config, partnerName, environment, branchOverride);
+        const { userDetails, organizationDetails, enforceOnboarding } = config;
+        this.preFilledParams = { userDetails, organizationDetails };
+        this.enforceOnboarding = enforceOnboarding;
+    }
+    /**
+     * Construct the specific flow URL for onboarding
+     */
+    constructFlowUrl(baseUrl) {
+        const params = Object.fromEntries(Object.entries(this.preFilledParams).filter(([_, v]) => v !== undefined));
+        let preFilledBase64 = '';
+        if (Object.keys(params).length > 0) {
+            try {
+                const json = JSON.stringify(params);
+                preFilledBase64 = btoa(unescape(encodeURIComponent(json)));
+            }
+            catch (e) {
+                preFilledBase64 = '';
+            }
+        }
+        const authCode = this.config.authCode || '';
+        let url = `${baseUrl}/${this.partnerName}${BASE_ACTION}`;
+        const queryParams = [];
+        if (preFilledBase64) {
+            queryParams.push(`preFilledParams=${encodeURIComponent(preFilledBase64)}`);
+        }
+        if (this.enforceOnboarding !== undefined) {
+            queryParams.push(`enforceOnboarding=${this.enforceOnboarding}`);
+        }
+        queryParams.push(`externalOrigin=${this.partnerName}`);
+        queryParams.push('target=/welcome');
+        queryParams.push(`token=${authCode}`);
+        url += `?${queryParams.join('&')}`;
+        return url;
+    }
+}

package/dist/flows/PayFlow.d.ts

@@ -0,0 +1,14 @@
+import { BaseFlow } from './BaseFlow.js';
+import { PayFlowConfig, Environment } from '../types.js';
+/**
+ * PayFlow subclass with custom URL construction
+ */
+export declare class PayFlow extends BaseFlow {
+    private billIds;
+    private authCode;
+    constructor(containerId: string, config: PayFlowConfig, partnerName: string, environment: Environment, branchOverride?: string);
+    /**
+     * Construct the specific flow URL for bill payment
+     */
+    protected constructFlowUrl(baseUrl: string): string;
+}

package/dist/flows/PayFlow.js

@@ -0,0 +1,18 @@
+import { BaseFlow } from './BaseFlow.js';
+import { BASE_ACTION } from '../utils/environment.js';
+/**
+ * PayFlow subclass with custom URL construction
+ */
+export class PayFlow extends BaseFlow {
+    constructor(containerId, config, partnerName, environment, branchOverride) {
+        super(containerId, config, partnerName, environment, branchOverride);
+        this.billIds = config.billIds;
+        this.authCode = config.authCode || '';
+    }
+    /**
+     * Construct the specific flow URL for bill payment
+     */
+    constructFlowUrl(baseUrl) {
+        return `${baseUrl}/${this.partnerName}${BASE_ACTION}?token=${this.authCode}&target=/external-entries/payment-flow?billIds=${this.billIds.join(',')}&externalOrigin=${this.partnerName}`;
+    }
+}

package/dist/flows/PaymentsDashboardFlow.d.ts

@@ -0,0 +1,13 @@
+import { BaseFlow } from './BaseFlow.js';
+import { PaymentsDashboardConfig, Environment } from '../types.js';
+/**
+ * PaymentsDashboardFlow subclass with custom URL construction
+ */
+export declare class PaymentsDashboardFlow extends BaseFlow {
+    private authCode;
+    constructor(containerId: string, config: PaymentsDashboardConfig, partnerName: string, environment: Environment, branchOverride?: string);
+    /**
+     * Construct the specific flow URL for payments dashboard
+     */
+    protected constructFlowUrl(baseUrl: string): string;
+}

package/dist/flows/PaymentsDashboardFlow.js

@@ -0,0 +1,17 @@
+import { BaseFlow } from './BaseFlow.js';
+import { BASE_ACTION } from '../utils/environment.js';
+/**
+ * PaymentsDashboardFlow subclass with custom URL construction
+ */
+export class PaymentsDashboardFlow extends BaseFlow {
+    constructor(containerId, config, partnerName, environment, branchOverride) {
+        super(containerId, config, partnerName, environment, branchOverride);
+        this.authCode = config.authCode || '';
+    }
+    /**
+     * Construct the specific flow URL for payments dashboard
+     */
+    constructFlowUrl(baseUrl) {
+        return `${baseUrl}/${this.partnerName}${BASE_ACTION}?token=${this.authCode}&target=/pay-dashboard/payments`;
+    }
+}

package/dist/flows/SettingsFlow.d.ts

@@ -0,0 +1,13 @@
+import { BaseFlow } from './BaseFlow.js';
+import { SettingsConfig, Environment } from '../types.js';
+/**
+ * SettingsFlow subclass with custom URL construction
+ */
+export declare class SettingsFlow extends BaseFlow {
+    private authCode;
+    constructor(containerId: string, config: SettingsConfig, partnerName: string, environment: Environment, branchOverride?: string);
+    /**
+     * Construct the specific flow URL for settings
+     */
+    protected constructFlowUrl(baseUrl: string): string;
+}

package/dist/flows/SettingsFlow.js

@@ -0,0 +1,17 @@
+import { BaseFlow } from './BaseFlow.js';
+import { BASE_ACTION } from '../utils/environment.js';
+/**
+ * SettingsFlow subclass with custom URL construction
+ */
+export class SettingsFlow extends BaseFlow {
+    constructor(containerId, config, partnerName, environment, branchOverride) {
+        super(containerId, config, partnerName, environment, branchOverride);
+        this.authCode = config.authCode || '';
+    }
+    /**
+     * Construct the specific flow URL for settings
+     */
+    constructFlowUrl(baseUrl) {
+        return `${baseUrl}/${this.partnerName}${BASE_ACTION}?token=${this.authCode}&target=/settings`;
+    }
+}

package/dist/index.d.ts

@@ -7,6 +7,7 @@ export declare class MelioSDK implements MelioSDK {
     private environment;
     private partnerName;
     private branchOverride;
+    private authenticationCode;
     constructor();
     /**
      * Initialize the SDK by creating an authentication flow

package/dist/index.js

@@ -1,296 +1,9 @@
-/**
- * Utility function to get the base URL for a given environment
- */
-function getBaseUrl(environment) {
-    switch (environment) {
-        case 'production':
-            return 'https://partnerships.production.melioservices.com';
-        case 'staging01':
-            return 'https://partnerships.staging01.melioservices.com';
-        case 'public-qa':
-            return 'https://partnerships.public-qa.melioservices.com';
-        case 'certification':
-            return 'https://partnerships.certification.melioservices.com';
-        case 'eilat':
-            return 'https://partnerships.eilat.melioservices.com';
-        case 'localhost':
-            return 'http://localhost:3005';
-        default:
-            return 'https://partnerships.melioservices.com';
-    }
-}
-/**
- * Flow class implementation for handling iframe flows and events
- */
-class Flow {
-    constructor(containerId, config, partnerName, environment, branchOverride) {
-        this.containerId = containerId;
-        this.config = config;
-        this.partnerName = partnerName;
-        this.environment = environment;
-        this.branchOverride = branchOverride;
-        this.iframe = null;
-        this.container = null;
-        this.eventListeners = new Map();
-        this.keepAliveInterval = null;
-        this.setupEventListeners();
-    }
-    /**
-     * Initialize the flow by creating and injecting the iframe
-     */
-    async initialize() {
-        this.container = document.getElementById(this.containerId);
-        if (!this.container) {
-            throw new Error(`Container with ID "${this.containerId}" not found`);
-        }
-        this.iframe = document.createElement('iframe');
-        this.iframe.src = this.createFlowUrl();
-        this.iframe.style.width = '100%';
-        this.iframe.style.height = '1000px';
-        this.iframe.style.border = 'none';
-        this.iframe.style.display = 'block';
-        this.container.appendChild(this.iframe);
-    }
-    /**
-     * Construct the specific flow URL for onboarding - can be overridden by subclasses
-     */
-    constructFlowUrl(baseUrl) {
-        return `${baseUrl}/${this.partnerName}/auth`;
-    }
-    /**
-     * Create flow URL using partner name and environment
-     */
-    createFlowUrl() {
-        console.log('🔧 Creating flow URL...');
-        console.log('📝 Config:', this.config);
-        console.log('🏢 Partner:', this.partnerName);
-        console.log('🌍 Environment:', this.environment);
-        console.log('🔝 Branch Override:', this.branchOverride);
-        const baseUrl = getBaseUrl(this.environment);
-        let finalUrl = this.constructFlowUrl(baseUrl);
-        // Add cdn_branch_override parameter for non-production environments
-        if (this.branchOverride && this.environment !== 'production') {
-            const separator = finalUrl.includes('?') ? '&' : '?';
-            finalUrl += `${separator}cdn_branch_override=${this.branchOverride}`;
-        }
-        console.log('🌐 Final URL:', finalUrl);
-        return finalUrl;
-    }
-    setupEventListeners() {
-        // Add post message handlers for internal events - setHeight, scroll etc
-        // Also need to implement callbacks for flow completed exit etc in the platform-app
-        window.addEventListener('message', (event) => {
-            if (!/melio\.com|melioservices\.com/.test(event.origin)) {
-                return;
-            }
-            const { type, ...data } = event.data;
-            console.log('📬 Received message from iframe:', {
-                type,
-                data,
-                origin: event.origin,
-            });
-            switch (type) {
-                case 'FLOW_COMPLETED':
-                    this.emit('completed', data);
-                    break;
-                case 'FLOW_EXIT':
-                    this.emit('exit');
-                    break;
-                case 'NAVIGATED_TO_TARGET':
-                    this.emit('navigated', data);
-                    break;
-                case 'AUTHENTICATION_SUCCESS':
-                    this.emit('authenticationSucceeded');
-                    break;
-                case 'AUTHENTICATION_ERROR':
-                    this.emit('authenticationFailed');
-                    break;
-                case 'ONBOARDING_COMPLETED':
-                    this.emit('completed', { flowName: 'onboarding', ...data });
-                    break;
-                case 'READY_FOR_INTERACTION':
-                    this.emit('loaded');
-                    break;
-                case 'MELIO_ERROR':
-                    if (data.code === 'failed_to_sync_bills') {
-                        this.emit('error', { errorCode: 'billsSyncFailed' });
-                    }
-                    break;
-                case 'HEIGHT_CHANGE':
-                    if (this.iframe) {
-                        this.iframe.style.height = `${data.height}px`;
-                    }
-                    break;
-            }
-        });
-    }
-    emit(event, data) {
-        const listeners = this.eventListeners.get(event);
-        if (listeners) {
-            listeners.forEach((callback) => {
-                try {
-                    callback(data);
-                }
-                catch (error) {
-                    console.error(`Error in ${event} event listener:`, error);
-                }
-            });
-        }
-    }
-    on(event, callback) {
-        if (!this.eventListeners.has(event)) {
-            this.eventListeners.set(event, new Set());
-        }
-        this.eventListeners.get(event).add(callback);
-    }
-    /**
-     * Remove an event listener
-     */
-    off(event, callback) {
-        const listeners = this.eventListeners.get(event);
-        if (listeners) {
-            listeners.delete(callback);
-        }
-    }
-    /**
-     * Close the flow and clean up resources
-     */
-    close() {
-        if (this.keepAliveInterval) {
-            clearInterval(this.keepAliveInterval);
-            this.keepAliveInterval = null;
-        }
-        if (this.iframe && this.container) {
-            this.container.removeChild(this.iframe);
-            this.iframe = null;
-        }
-        this.eventListeners.clear();
-    }
-}
-/**
- * OnboardingFlow subclass with custom URL construction
- */
-class OnboardingFlow extends Flow {
-    constructor(containerId, config, partnerName, environment, branchOverride) {
-        super(containerId, config, partnerName, environment, branchOverride);
-        const { userDetails, organizationDetails, enforceOnboarding } = config;
-        this.preFilledParams = { userDetails, organizationDetails };
-        this.enforceOnboarding = enforceOnboarding;
-    }
-    /**
-     * Construct the specific flow URL for onboarding
-     */
-    constructFlowUrl(baseUrl) {
-        const params = Object.fromEntries(Object.entries(this.preFilledParams).filter(([_, v]) => v !== undefined));
-        let preFilledBase64 = '';
-        if (Object.keys(params).length > 0) {
-            try {
-                const json = JSON.stringify(params);
-                preFilledBase64 = btoa(unescape(encodeURIComponent(json)));
-            }
-            catch (e) {
-                preFilledBase64 = '';
-            }
-        }
-        let url = `${baseUrl}/${this.partnerName}/welcome`;
-        const queryParams = [];
-        if (preFilledBase64) {
-            queryParams.push(`preFilledParams=${encodeURIComponent(preFilledBase64)}`);
-        }
-        if (this.enforceOnboarding !== undefined) {
-            queryParams.push(`enforceOnboarding=${this.enforceOnboarding}`);
-        }
-        queryParams.push(`externalOrigin=${this.partnerName}`);
-        url += `?${queryParams.join('&')}`;
-        return url;
-    }
-}
-/**
- * PayFlow subclass with custom URL construction
- */
-class PayFlow extends Flow {
-    constructor(containerId, config, partnerName, environment, branchOverride) {
-        super(containerId, config, partnerName, environment, branchOverride);
-        this.billIds = config.billIds;
-    }
-    /**
-     * Construct the specific flow URL for bill payment
-     */
-    constructFlowUrl(baseUrl) {
-        return `${baseUrl}/${this.partnerName}/external-entries/payment-flow?billIds=${this.billIds.join(',')}&externalOrigin=${this.partnerName}`;
-    }
-}
-/**
- * SettingsFlow subclass with custom URL construction
- */
-class SettingsFlow extends Flow {
-    constructor(containerId, config, partnerName, environment, branchOverride) {
-        super(containerId, config, partnerName, environment, branchOverride);
-    }
-    /**
-     * Construct the specific flow URL for settings
-     */
-    constructFlowUrl(baseUrl) {
-        return `${baseUrl}/${this.partnerName}/settings`;
-    }
-}
-class PaymentsDashboardFlow extends Flow {
-    constructor(containerId, config, partnerName, environment, branchOverride) {
-        super(containerId, config, partnerName, environment, branchOverride);
-    }
-    /**
-     * Construct the specific flow URL for payments dashboard
-     */
-    constructFlowUrl(baseUrl) {
-        return `${baseUrl}/${this.partnerName}/pay-dashboard/payments`;
-    }
-}
-const isEmptyString = (str) => {
-    return !str?.trim();
-};
-/**
- * InitFlow subclass for handling initialization with callbacks
- */
-class InitFlow extends Flow {
-    constructor(containerId, config, partnerName, environment, branchOverride) {
-        super(containerId, config, partnerName, environment, branchOverride);
-        if (isEmptyString(config.authCode)) {
-            throw new Error('Authorization code is required for init flow');
-        }
-        this.authorizationCode = config.authCode;
-    }
-    /**
-     * Initialize the init flow by creating and injecting a hidden iframe
-     */
-    async initialize() {
-        // For init flow, we create a hidden iframe instead of a visible one
-        this.iframe = document.createElement('iframe');
-        this.iframe.src = this.createFlowUrl();
-        this.iframe.style.width = '1px';
-        this.iframe.style.height = '1px';
-        this.iframe.style.position = 'absolute';
-        this.iframe.style.left = '-9999px';
-        this.iframe.style.top = '-9999px';
-        document.body.appendChild(this.iframe);
-    }
-    /**
-     * Construct the specific flow URL for initialization
-     */
-    constructFlowUrl(baseUrl) {
-        const params = new URLSearchParams({
-            token: this.authorizationCode,
-            theme: this.partnerName,
-        });
-        return `${baseUrl}/${this.partnerName}/start?${params.toString()}`;
-    }
-    setupKeepAlive() {
-        this.keepAliveInterval = window.setInterval(() => {
-            if (this.iframe && this.iframe.contentWindow) {
-                this.iframe.contentWindow.postMessage({ type: 'USER_ACTIVE_PING' }, '*');
-            }
-        }, 30000); // Send ping every 30 seconds
-    }
-}
+// Import flow classes
+import { InitFlow } from './flows/InitFlow.js';
+import { OnboardingFlow } from './flows/OnboardingFlow.js';
+import { PayFlow } from './flows/PayFlow.js';
+import { SettingsFlow } from './flows/SettingsFlow.js';
+import { PaymentsDashboardFlow } from './flows/PaymentsDashboardFlow.js';
 /**
  * Main SDK implementation - now partner agnostic
  */
@@ -300,6 +13,7 @@ export class MelioSDK {
         this.environment = 'production';
         this.partnerName = '';
         this.branchOverride = undefined;
+        this.authenticationCode = '';
     }
     /**
      * Initialize the SDK by creating an authentication flow
@@ -308,23 +22,32 @@ export class MelioSDK {
         this.partnerName = options.partnerName;
         this.environment = options.environment || 'production';
         this.branchOverride = options.branchOverride;
+        this.authenticationCode = authenticationCode;
         console.log('starting init flow', {
             partnerName: this.partnerName,
             environment: this.environment,
         });
+        const initConfig = {
+            authCode: authenticationCode,
+            containerId: '',
+        };
         const initFlow = new InitFlow('', // no need container id for init flow as it is created inside the initialization
-        { authCode: authenticationCode, containerId: '' }, this.partnerName, this.environment, this.branchOverride);
+        initConfig, this.partnerName, this.environment, this.branchOverride);
         initFlow.initialize();
-        console.log('InitFlow initialized successfully');
-        if (options.keepAlive)
-            initFlow.setupKeepAlive();
+        // Disabled for quick performance improvement. Will be re-enabled in the future.
+        // console.log('InitFlow initialized successfully');
+        // if (options.keepAlive) initFlow.setupKeepAlive();
         return initFlow;
     }
     /**
      * Launch the onboarding flow
      */
     openOnboarding(config) {
-        const flow = new OnboardingFlow(config.containerId, config, this.partnerName, this.environment, this.branchOverride);
+        const configWithAuth = {
+            ...config,
+            authCode: config.authCode || this.authenticationCode,
+        };
+        const flow = new OnboardingFlow(config.containerId, configWithAuth, this.partnerName, this.environment, this.branchOverride);
         flow.initialize();
         return flow;
     }

package/dist/utils/environment.d.ts

@@ -0,0 +1,6 @@
+import { Environment } from '../types.js';
+/**
+ * Get the base URL for a given environment
+ */
+export declare function getBaseUrl(environment: Environment): string;
+export declare const BASE_ACTION = "/auth";

package/dist/utils/environment.js

@@ -0,0 +1,22 @@
+/**
+ * Get the base URL for a given environment
+ */
+export function getBaseUrl(environment) {
+    switch (environment) {
+        case 'production':
+            return 'https://partnerships.production.melioservices.com';
+        case 'staging01':
+            return 'https://partnerships.staging01.melioservices.com';
+        case 'public-qa':
+            return 'https://partnerships.public-qa.melioservices.com';
+        case 'certification':
+            return 'https://partnerships.certification.melioservices.com';
+        case 'eilat':
+            return 'https://partnerships.eilat.melioservices.com';
+        case 'localhost':
+            return 'http://localhost:3005';
+        default:
+            return 'https://partnerships.melioservices.com';
+    }
+}
+export const BASE_ACTION = '/auth';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@melio-eng/web-sdk",
-  "version": "1.0.26",
+  "version": "1.0.27-pr.53.6e729bc",
   "description": "Melio Web SDK - Embed core Melio workflows directly into partner UI with minimal effort",
   "main": "dist/index.js",
   "module": "dist/index.js",