@product7/product7-js 0.1.0

package/src/index.js

@@ -0,0 +1,894 @@
+import { APIService } from './core/APIService.js';
+import { EventBus } from './core/EventBus.js';
+import { Product7 as Product7SDK } from './core/Product7.js';
+import { CSS_STYLES } from './styles/styles.js';
+import {
+	APIError,
+	ConfigError,
+	SDKError,
+	ValidationError,
+	WidgetError,
+} from './utils/errors.js';
+import * as helpers from './utils/helpers.js';
+import { BaseWidget } from './widgets/BaseWidget.js';
+import { ButtonWidget } from './widgets/ButtonWidget.js';
+import { ChangelogWidget } from './widgets/ChangelogWidget.js';
+import { InlineWidget } from './widgets/InlineWidget.js';
+import { MessengerWidget } from './widgets/MessengerWidget.js';
+import { SurveyWidget } from './widgets/SurveyWidget.js';
+import { TabWidget } from './widgets/TabWidget.js';
+import { WidgetFactory } from './widgets/WidgetFactory.js';
+
+function injectStyles() {
+	if (typeof document === 'undefined') return;
+
+	if (!document.querySelector('#product7-styles')) {
+		const style = document.createElement('style');
+		style.id = 'product7-styles';
+		style.textContent = CSS_STYLES;
+		document.head.appendChild(style);
+	}
+
+	if (!document.querySelector('#product7-iconify')) {
+		const script = document.createElement('script');
+		script.id = 'product7-iconify';
+		script.src =
+			'https://cdn.jsdelivr.net/npm/iconify-icon@2/dist/iconify-icon.min.js';
+		script.async = true;
+		document.head.appendChild(script);
+	}
+}
+
+// --- Identify: transform flat user data into internal format ---
+
+function transformIdentifyData(data) {
+	const {
+		organization,
+		email,
+		name,
+		userId,
+		profilePicture,
+		locale,
+		companies,
+		...customAttrs
+	} = data;
+
+	const metadata = {
+		user_id: userId,
+		email,
+		name,
+		profile_picture: profilePicture,
+	};
+
+	// Flat custom attributes → custom_fields
+	const knownKeys = [
+		'organization',
+		'email',
+		'name',
+		'userId',
+		'profilePicture',
+		'locale',
+		'companies',
+		'debug',
+		'mock',
+		'env',
+		'apiUrl',
+	];
+	const customFields = {};
+	for (const [key, value] of Object.entries(customAttrs)) {
+		if (!knownKeys.includes(key)) {
+			customFields[key] = value;
+		}
+	}
+	if (Object.keys(customFields).length > 0) {
+		metadata.custom_fields = customFields;
+	}
+
+	// Companies array → company (use first for now, backend supports single)
+	if (Array.isArray(companies) && companies.length > 0) {
+		const c = companies[0];
+		metadata.company = {
+			id: c.id,
+			name: c.name,
+			monthly_spend: c.monthlySpend,
+			custom_fields: {},
+		};
+		const companyKnownKeys = ['id', 'name', 'monthlySpend', 'createdAt'];
+		for (const [key, value] of Object.entries(c)) {
+			if (!companyKnownKeys.includes(key)) {
+				metadata.company.custom_fields[key] = value;
+			}
+		}
+	}
+
+	return {
+		workspace: organization,
+		metadata,
+		locale,
+		debug: data.debug,
+		mock: data.mock,
+		env: data.env,
+		apiUrl: data.apiUrl,
+	};
+}
+
+function cleanUndefined(obj) {
+	Object.keys(obj).forEach((key) => {
+		if (obj[key] === undefined) delete obj[key];
+	});
+	return obj;
+}
+
+// --- Ensure SDK is initialized (shared by widget inits) ---
+
+async function ensureSDK(options) {
+	if (Product7._sdk) return Product7._sdk;
+
+	if (options.organization) {
+		injectStyles();
+		const config = cleanUndefined({
+			workspace: options.organization,
+			debug: options.debug,
+			mock: options.mock,
+			env: options.env,
+			apiUrl: options.apiUrl,
+		});
+
+		const sdk = new Product7SDK(config);
+		await sdk.init();
+		Product7._sdk = sdk;
+		Product7._organization = options.organization;
+		return sdk;
+	}
+
+	return null;
+}
+
+// --- Public API ---
+
+const Product7 = {
+	// Internal state
+	_sdk: null,
+	_identified: false,
+	_organization: null,
+	_q: [],
+	_feedbackWidget: null,
+	_messengerWidget: null,
+	_surveyWidget: null,
+
+	version: '1.0.0',
+
+	// ==================
+	// Identify
+	// ==================
+
+	async identify(data = {}, callback) {
+		try {
+			injectStyles();
+
+			const transformed = transformIdentifyData(data);
+			Product7._organization = transformed.workspace;
+
+			const config = cleanUndefined({
+				workspace: transformed.workspace,
+				metadata: transformed.metadata,
+				debug: transformed.debug,
+				mock: transformed.mock,
+				env: transformed.env,
+				apiUrl: transformed.apiUrl,
+			});
+
+			const sdk = new Product7SDK(config);
+			const initData = await sdk.init();
+
+			Product7._sdk = sdk;
+			Product7._identified = true;
+
+			// Sync custom attributes + segments via /widget/identify
+			if (transformed.metadata && sdk.apiService?.sessionToken) {
+				try {
+					const identifyPayload = {
+						user_id: transformed.metadata.user_id,
+						email: transformed.metadata.email,
+						name: transformed.metadata.name,
+						avatar: transformed.metadata.profile_picture,
+						attributes: transformed.metadata.custom_fields || {},
+					};
+					if (transformed.metadata.company) {
+						identifyPayload.company = transformed.metadata.company;
+					}
+					await sdk.apiService._makeRequest('/widget/identify', {
+						method: 'POST',
+						body: JSON.stringify(identifyPayload),
+						headers: {
+							'Content-Type': 'application/json',
+							Authorization: `Bearer ${sdk.apiService.sessionToken}`,
+						},
+					});
+				} catch (identifyErr) {
+					if (config.debug) {
+						console.warn('[Product7] Attribute sync failed:', identifyErr);
+					}
+				}
+			}
+
+			Product7._flushQueue();
+
+			if (typeof window !== 'undefined' && typeof CustomEvent !== 'undefined') {
+				window.dispatchEvent(
+					new CustomEvent('Product7Ready', {
+						detail: { sdk, config, initData },
+					})
+				);
+			}
+
+			if (typeof callback === 'function') callback(null);
+			return initData;
+		} catch (error) {
+			console.error('[Product7] Identify failed:', error);
+
+			if (typeof window !== 'undefined' && typeof CustomEvent !== 'undefined') {
+				window.dispatchEvent(
+					new CustomEvent('Product7Error', {
+						detail: { error, phase: 'identify' },
+					})
+				);
+			}
+
+			if (typeof callback === 'function') callback(error);
+			throw error;
+		}
+	},
+
+	// ==================
+	// Feedback
+	// ==================
+
+	async feedback(options = {}, callback) {
+		const sdk = await ensureSDK(options);
+		if (!sdk) {
+			Product7._q.push(['feedback', options, callback]);
+			return null;
+		}
+
+		injectStyles();
+
+		const widgetOptions = cleanUndefined({
+			displayMode: options.displayMode || 'panel',
+			theme: options.theme || sdk.config.theme || 'light',
+			size: options.size || 'medium',
+			primaryColor: options.primaryColor,
+			backgroundColor: options.backgroundColor,
+			textColor: options.textColor,
+			suppressAfterSubmission: options.suppressAfterSubmission,
+			suppressionDays: options.suppressionDays,
+			showBackdrop: options.showBackdrop !== false,
+			metadata: options.metadata,
+		});
+
+		// placement → position
+		if (options.placement === 'right') {
+			widgetOptions.position = 'right';
+		} else if (options.placement === 'left') {
+			widgetOptions.position = 'left';
+		} else if (options.placement) {
+			widgetOptions.position = options.placement;
+		}
+
+		// defaultBoard → boardName
+		if (options.defaultBoard) {
+			widgetOptions.boardName = options.defaultBoard;
+		}
+
+		// No placement = modal mode, no floating button
+		if (!options.placement) {
+			widgetOptions.autoShow = false;
+			widgetOptions.displayMode = 'modal';
+			widgetOptions._noTriggerButton = true;
+		} else {
+			// Trigger button is always visible when placement is set
+			widgetOptions.suppressAfterSubmission = false;
+			widgetOptions.enabled = true;
+		}
+
+		try {
+			const widget = sdk.createWidget('button', widgetOptions);
+			widget.mount();
+
+			if (options.placement) {
+				widget.show();
+			} else {
+				widget.hide();
+			}
+
+			Product7._feedbackWidget = widget;
+
+			if (typeof callback === 'function') {
+				callback({ action: 'widgetReady' });
+
+				sdk.eventBus.on('feedback:submitted', (data) => {
+					callback({ action: 'feedbackSubmitted', post: data.feedback });
+				});
+
+				sdk.eventBus.on('feedback:error', (data) => {
+					callback({ action: 'feedbackError', error: data.error });
+				});
+			}
+
+			Product7._setupAttributeTriggers();
+			Product7._setupPostMessageListener();
+
+			return widget;
+		} catch (error) {
+			console.error('[Product7] Failed to initialize feedback widget:', error);
+			if (typeof callback === 'function') callback({ action: 'error', error });
+			return null;
+		}
+	},
+
+	openFeedback(options = {}) {
+		if (Product7._feedbackWidget) {
+			if (options.setBoard) {
+				Product7._feedbackWidget.options.boardName = options.setBoard;
+			}
+			Product7._feedbackWidget.openPanel();
+		}
+	},
+
+	closeFeedback() {
+		if (Product7._feedbackWidget) {
+			Product7._feedbackWidget.closePanel();
+		}
+	},
+
+	destroyFeedback() {
+		if (Product7._feedbackWidget) {
+			Product7._feedbackWidget.destroy();
+			Product7._feedbackWidget = null;
+		}
+	},
+
+	// ==================
+	// Messenger
+	// ==================
+
+	async messenger(options = {}, callback) {
+		const sdk = await ensureSDK(options);
+		if (!sdk) {
+			Product7._q.push(['messenger', options, callback]);
+			return null;
+		}
+
+		injectStyles();
+
+		const widgetOptions = cleanUndefined({
+			theme: options.theme || sdk.config.theme || 'light',
+			primaryColor: options.primaryColor,
+			backgroundColor: options.backgroundColor,
+			textColor: options.textColor,
+			logoUrl: options.logoUrl,
+			teamName: options.teamName,
+			teamAvatars: options.teamAvatars,
+			greetingMessage: options.greetingMessage,
+			welcomeMessage: options.welcomeMessage,
+			enableHelp: options.enableHelp,
+			enableChangelog: options.enableChangelog,
+			enableNews: options.enableNews,
+			autoLoadData: options.autoLoadData,
+			initialView: options.initialView,
+			featuredContent: options.featuredContent,
+			feedbackUrl: options.feedbackUrl,
+			changelogUrl: options.changelogUrl,
+			helpUrl: options.helpUrl,
+			roadmapUrl: options.roadmapUrl,
+			previewData: options.previewData,
+		});
+
+		// placement → position
+		if (options.placement === 'right') {
+			widgetOptions.position = 'right';
+		} else if (options.placement === 'left') {
+			widgetOptions.position = 'left';
+		} else if (options.placement) {
+			widgetOptions.position = options.placement;
+		}
+
+		// Messenger is always explicitly shown — never suppress based on feedback submission history
+		widgetOptions.suppressAfterSubmission = false;
+		widgetOptions.enabled = true;
+
+		try {
+			const widget = sdk.createWidget('messenger', widgetOptions);
+			widget.mount();
+			widget.show();
+
+			Product7._messengerWidget = widget;
+
+			if (typeof callback === 'function') {
+				callback({ action: 'widgetReady' });
+
+				sdk.eventBus.on('messenger:messageSent', (data) => {
+					callback({ action: 'messageSent', message: data });
+				});
+
+				sdk.eventBus.on('messenger:opened', () => {
+					callback({ action: 'messengerOpened' });
+				});
+
+				sdk.eventBus.on('messenger:closed', () => {
+					callback({ action: 'messengerClosed' });
+				});
+			}
+
+			// Listen for data-product7-messenger clicks
+			Product7._setupMessengerAttributeTriggers();
+			Product7._setupPostMessageListener();
+
+			return widget;
+		} catch (error) {
+			console.error('[Product7] Failed to initialize messenger widget:', error);
+			if (typeof callback === 'function') callback({ action: 'error', error });
+			return null;
+		}
+	},
+
+	openMessenger() {
+		if (Product7._messengerWidget) {
+			Product7._messengerWidget.open?.() ||
+				Product7._messengerWidget.openPanel?.();
+		}
+	},
+
+	closeMessenger() {
+		if (Product7._messengerWidget) {
+			Product7._messengerWidget.close?.() ||
+				Product7._messengerWidget.closePanel?.();
+		}
+	},
+
+	destroyMessenger() {
+		if (Product7._messengerWidget) {
+			Product7._messengerWidget.destroy();
+			Product7._messengerWidget = null;
+		}
+	},
+
+	// ==================
+	// Survey
+	// ==================
+
+	async survey(options = {}, callback) {
+		const sdk = await ensureSDK(options);
+		if (!sdk) {
+			Product7._q.push(['survey', options, callback]);
+			return null;
+		}
+
+		injectStyles();
+
+		// placement → position
+		let position = 'right';
+		if (options.placement === 'right') {
+			position = 'right';
+		} else if (options.placement === 'left') {
+			position = 'left';
+		} else if (options.placement === 'center') {
+			position = 'center';
+		} else if (options.placement === 'bottom') {
+			position = 'bottom';
+		} else if (options.placement) {
+			position = options.placement;
+		}
+
+		// displayMode: "popover" (default), "modal", "fullscreen"
+		const displayMode = options.displayMode || 'popover';
+		if (displayMode === 'modal' || displayMode === 'fullscreen') {
+			position = 'center';
+		}
+
+		// Wire up all lifecycle callbacks
+		const surveyCallbacks = {
+			onSubmit: (response) => {
+				if (typeof callback === 'function') {
+					callback({ action: 'surveySubmitted', response });
+				}
+			},
+			onDismiss: () => {
+				if (typeof callback === 'function') {
+					callback({ action: 'surveyDismissed' });
+				}
+			},
+		};
+
+		// Register event bus listeners for additional callbacks
+		if (typeof callback === 'function') {
+			sdk.eventBus.on('survey:shown', (data) => {
+				callback({ action: 'surveyShown', survey: data });
+			});
+
+			sdk.eventBus.on('survey:questionAnswered', (data) => {
+				callback({
+					action: 'questionAnswered',
+					pageId: data.pageId,
+					pageType: data.pageType,
+					answer: data.answer,
+				});
+			});
+
+			sdk.eventBus.on('survey:closed', () => {
+				callback({ action: 'surveyClosed' });
+			});
+		}
+
+		// Display method: delayed, exitIntent, or immediate (default)
+		const displayMethod = options.displayMethod || 'immediate';
+		const showSurvey = async () => {
+			try {
+				let widget;
+
+				if (options.surveyId) {
+					// Show specific survey by ID
+					const showOpts = {
+						position,
+						displayMode,
+						theme: options.theme || sdk.config.theme || 'light',
+						showBackdrop:
+							displayMode === 'modal' || displayMode === 'fullscreen',
+						...surveyCallbacks,
+					};
+
+					// force flag: bypass eligibility checks
+					if (options.force) {
+						showOpts.context = { includeIneligible: true };
+					}
+
+					widget = await sdk.showSurveyById(options.surveyId, showOpts);
+				} else {
+					// Auto-fetch and show first eligible survey
+					const fetchOpts = options.force ? { includeIneligible: true } : {};
+					const surveys = await sdk.getActiveSurveys(fetchOpts);
+
+					if (surveys.length === 0) {
+						if (typeof callback === 'function') {
+							callback({ action: 'noSurveys' });
+						}
+						return null;
+					}
+
+					const surveyConfig = surveys[0];
+					widget = sdk.showSurvey({
+						surveyId: surveyConfig.surveyId || surveyConfig.id,
+						surveyType: surveyConfig.surveyType || surveyConfig.type || 'nps',
+						position,
+						displayMode,
+						theme: options.theme || sdk.config.theme || 'light',
+						showBackdrop:
+							displayMode === 'modal' || displayMode === 'fullscreen',
+						title: surveyConfig.title,
+						description: surveyConfig.description,
+						lowLabel: surveyConfig.lowLabel,
+						highLabel: surveyConfig.highLabel,
+						ratingScale: surveyConfig.ratingScale,
+						showFeedbackInput: surveyConfig.showFeedbackInput,
+						showSubmitButton: surveyConfig.showSubmitButton,
+						autoSubmitOnSelect: surveyConfig.autoSubmitOnSelect,
+						showTitle: surveyConfig.showTitle,
+						showDescription: surveyConfig.showDescription,
+						customQuestions: surveyConfig.customQuestions,
+						pages: surveyConfig.pages,
+						enabled: options.force ? true : surveyConfig.enabled,
+						...surveyCallbacks,
+					});
+
+					if (typeof callback === 'function') {
+						callback({ action: 'surveyReady', survey: surveyConfig });
+					}
+				}
+
+				Product7._surveyWidget = widget;
+				return widget;
+			} catch (error) {
+				console.error('[Product7] Failed to show survey:', error);
+				if (typeof callback === 'function')
+					callback({ action: 'error', error });
+				return null;
+			}
+		};
+
+		// Handle display methods
+		if (displayMethod === 'delayed') {
+			const delay = options.displayDelay || 5000;
+			Product7._surveyTimer = setTimeout(showSurvey, delay);
+			if (typeof callback === 'function') {
+				callback({ action: 'surveyScheduled', delay });
+			}
+			return null;
+		}
+
+		if (displayMethod === 'exitIntent') {
+			const handler = (e) => {
+				if (e.clientY <= 0) {
+					document.removeEventListener('mouseout', handler);
+					Product7._exitIntentHandler = null;
+					showSurvey();
+				}
+			};
+			Product7._exitIntentHandler = handler;
+			document.addEventListener('mouseout', handler);
+			if (typeof callback === 'function') {
+				callback({ action: 'surveyScheduled', trigger: 'exitIntent' });
+			}
+			return null;
+		}
+
+		if (displayMethod === 'onScroll') {
+			const scrollPercent = options.scrollPercentage || 50;
+			const handler = () => {
+				const scrolled =
+					(window.scrollY / (document.body.scrollHeight - window.innerHeight)) *
+					100;
+				if (scrolled >= scrollPercent) {
+					window.removeEventListener('scroll', handler);
+					Product7._scrollHandler = null;
+					showSurvey();
+				}
+			};
+			Product7._scrollHandler = handler;
+			window.addEventListener('scroll', handler, { passive: true });
+			if (typeof callback === 'function') {
+				callback({
+					action: 'surveyScheduled',
+					trigger: 'onScroll',
+					scrollPercentage: scrollPercent,
+				});
+			}
+			return null;
+		}
+
+		// Default: immediate
+		return showSurvey();
+	},
+
+	closeSurvey() {
+		if (Product7._surveyWidget) {
+			Product7._surveyWidget.hide?.() || Product7._surveyWidget.closePanel?.();
+		}
+	},
+
+	destroySurvey() {
+		// Clean up scheduled triggers
+		if (Product7._surveyTimer) {
+			clearTimeout(Product7._surveyTimer);
+			Product7._surveyTimer = null;
+		}
+		if (Product7._exitIntentHandler) {
+			document.removeEventListener('mouseout', Product7._exitIntentHandler);
+			Product7._exitIntentHandler = null;
+		}
+		if (Product7._scrollHandler) {
+			window.removeEventListener('scroll', Product7._scrollHandler);
+			Product7._scrollHandler = null;
+		}
+		if (Product7._surveyWidget) {
+			Product7._surveyWidget.destroy();
+			Product7._surveyWidget = null;
+		}
+	},
+
+	// ==================
+	// Event Tracking
+	// ==================
+
+	async track(eventName, properties = {}) {
+		if (!Product7._sdk) {
+			Product7._q.push(['track', eventName, properties]);
+			return null;
+		}
+
+		const sdk = Product7._sdk;
+		if (!sdk.apiService?.sessionToken) return null;
+
+		try {
+			const result = await sdk.apiService._makeRequest('/widget/track', {
+				method: 'POST',
+				body: JSON.stringify({
+					event: eventName,
+					properties,
+					timestamp: new Date().toISOString(),
+				}),
+				headers: {
+					'Content-Type': 'application/json',
+					Authorization: `Bearer ${sdk.apiService.sessionToken}`,
+				},
+			});
+
+			// If server returns a survey to show, show it
+			if (result?.survey) {
+				Product7.survey({
+					surveyId: result.survey.id || result.survey.survey_id,
+					force: true,
+				});
+			}
+
+			return result;
+		} catch (error) {
+			if (sdk.config.debug) {
+				console.warn('[Product7] Track failed:', error);
+			}
+			return null;
+		}
+	},
+
+	// ==================
+	// General
+	// ==================
+
+	getInstance() {
+		return Product7._sdk;
+	},
+
+	isReady() {
+		return Boolean(Product7._sdk?.initialized);
+	},
+
+	onReady(callback) {
+		if (typeof window === 'undefined') return;
+
+		if (Product7.isReady()) {
+			callback(Product7._sdk);
+		} else {
+			window.addEventListener(
+				'Product7Ready',
+				(event) => callback(event.detail.sdk, event.detail),
+				{ once: true }
+			);
+		}
+	},
+
+	onError(callback) {
+		if (typeof window === 'undefined') return;
+
+		window.addEventListener('Product7Error', (event) => {
+			callback(event.detail.error, event.detail);
+		});
+	},
+
+	destroy() {
+		Product7.destroyFeedback();
+		Product7.destroyMessenger();
+		Product7.destroySurvey();
+		if (Product7._sdk) {
+			Product7._sdk.destroy();
+			Product7._sdk = null;
+		}
+		Product7._identified = false;
+		Product7._organization = null;
+		Product7._q = [];
+		Product7._feedbackListenerAttached = false;
+		Product7._messengerListenerAttached = false;
+		Product7._postMessageListenerAttached = false;
+	},
+
+	// ==================
+	// Internal
+	// ==================
+
+	_flushQueue() {
+		const queue = Product7._q.splice(0);
+		for (const [method, ...args] of queue) {
+			if (typeof Product7[method] === 'function') {
+				Product7[method](...args);
+			}
+		}
+	},
+
+	_setupAttributeTriggers() {
+		if (typeof document === 'undefined') return;
+		if (Product7._feedbackListenerAttached) return;
+		Product7._feedbackListenerAttached = true;
+
+		document.addEventListener('click', (e) => {
+			const trigger = e.target.closest('[data-product7-feedback]');
+			if (trigger) {
+				e.preventDefault();
+				Product7.openFeedback();
+			}
+		});
+	},
+
+	_setupMessengerAttributeTriggers() {
+		if (typeof document === 'undefined') return;
+		if (Product7._messengerListenerAttached) return;
+		Product7._messengerListenerAttached = true;
+
+		document.addEventListener('click', (e) => {
+			const trigger = e.target.closest('[data-product7-messenger]');
+			if (trigger) {
+				e.preventDefault();
+				Product7.openMessenger();
+			}
+		});
+	},
+
+	_setupPostMessageListener() {
+		if (typeof window === 'undefined') return;
+		if (Product7._postMessageListenerAttached) return;
+		Product7._postMessageListenerAttached = true;
+
+		window.addEventListener('message', (event) => {
+			if (event.data?.target !== 'Product7Widget') return;
+
+			const { action, setBoard } = event.data.data || {};
+			switch (action) {
+				case 'openFeedback':
+					Product7.openFeedback({ setBoard });
+					break;
+				case 'closeFeedback':
+					Product7.closeFeedback();
+					break;
+				case 'openMessenger':
+					Product7.openMessenger();
+					break;
+				case 'closeMessenger':
+					Product7.closeMessenger();
+					break;
+				case 'closeSurvey':
+					Product7.closeSurvey();
+					break;
+			}
+		});
+	},
+
+	// Expose internals for advanced/npm usage
+	Product7SDK,
+	BaseWidget,
+	ButtonWidget,
+	ChangelogWidget,
+	TabWidget,
+	InlineWidget,
+	SurveyWidget,
+	MessengerWidget,
+	WidgetFactory,
+	EventBus,
+	APIService,
+	SDKError,
+	APIError,
+	WidgetError,
+	ConfigError,
+	ValidationError,
+	helpers,
+};
+
+// --- Pre-load queue support ---
+if (typeof window !== 'undefined') {
+	const existingQueue = window.Product7?._q || [];
+	window.Product7 = Product7;
+
+	for (const [method, ...args] of existingQueue) {
+		if (typeof Product7[method] === 'function') {
+			Product7[method](...args);
+		}
+	}
+}
+
+export default Product7;
+
+export {
+	APIError,
+	APIService,
+	BaseWidget,
+	ButtonWidget,
+	ChangelogWidget,
+	ConfigError,
+	EventBus,
+	helpers,
+	InlineWidget,
+	MessengerWidget,
+	Product7SDK as Product7,
+	SDKError,
+	SurveyWidget,
+	TabWidget,
+	ValidationError,
+	WidgetError,
+	WidgetFactory,
+};