@product7/product7-js 0.1.0

package/src/utils/errors.js

@@ -0,0 +1,142 @@
+export class SDKError extends Error {
+	constructor(message, cause) {
+		super(message);
+		this.name = 'SDKError';
+		this.cause = cause;
+
+		if (Error.captureStackTrace) {
+			Error.captureStackTrace(this, SDKError);
+		}
+	}
+}
+
+export class APIError extends Error {
+	constructor(status, message, response) {
+		super(message);
+		this.name = 'APIError';
+		this.status = status;
+		this.response = response;
+
+		if (Error.captureStackTrace) {
+			Error.captureStackTrace(this, APIError);
+		}
+	}
+
+	isNetworkError() {
+		return this.status === 0;
+	}
+
+	isClientError() {
+		return this.status >= 400 && this.status < 500;
+	}
+
+	isServerError() {
+		return this.status >= 500 && this.status < 600;
+	}
+}
+
+export class WidgetError extends Error {
+	constructor(message, widgetType, widgetId) {
+		super(message);
+		this.name = 'WidgetError';
+		this.widgetType = widgetType;
+		this.widgetId = widgetId;
+
+		if (Error.captureStackTrace) {
+			Error.captureStackTrace(this, WidgetError);
+		}
+	}
+}
+
+export class ConfigError extends Error {
+	constructor(message, configKey) {
+		super(message);
+		this.name = 'ConfigError';
+		this.configKey = configKey;
+
+		if (Error.captureStackTrace) {
+			Error.captureStackTrace(this, ConfigError);
+		}
+	}
+}
+
+export class ValidationError extends Error {
+	constructor(message, field, value) {
+		super(message);
+		this.name = 'ValidationError';
+		this.field = field;
+		this.value = value;
+
+		if (Error.captureStackTrace) {
+			Error.captureStackTrace(this, ValidationError);
+		}
+	}
+}
+
+export class ErrorHandler {
+	constructor(debug = false) {
+		this.debug = debug;
+	}
+
+	handle(error, context = '') {
+		const errorInfo = {
+			name: error.name,
+			message: error.message,
+			context,
+			timestamp: new Date().toISOString(),
+		};
+
+		if (error instanceof APIError) {
+			errorInfo.status = error.status;
+			errorInfo.type = 'api';
+		} else if (error instanceof WidgetError) {
+			errorInfo.widgetType = error.widgetType;
+			errorInfo.widgetId = error.widgetId;
+			errorInfo.type = 'widget';
+		} else if (error instanceof ConfigError) {
+			errorInfo.configKey = error.configKey;
+			errorInfo.type = 'config';
+		} else if (error instanceof ValidationError) {
+			errorInfo.field = error.field;
+			errorInfo.value = error.value;
+			errorInfo.type = 'validation';
+		} else {
+			errorInfo.type = 'unknown';
+		}
+
+		if (this.debug) {
+			console.error('[Product7 Error]', errorInfo, error);
+		} else {
+			console.error('[Product7 Error]', error.message);
+		}
+
+		return errorInfo;
+	}
+
+	getUserMessage(error) {
+		if (error instanceof APIError) {
+			if (error.isNetworkError()) {
+				return 'Network error. Please check your connection and try again.';
+			} else if (error.isClientError()) {
+				return 'Invalid request. Please check your input and try again.';
+			} else if (error.isServerError()) {
+				return 'Server error. Please try again later.';
+			}
+			return 'Failed to submit feedback. Please try again.';
+		}
+
+		if (error instanceof ValidationError) {
+			return `Please check your ${error.field}: ${error.message}`;
+		}
+
+		if (error instanceof ConfigError) {
+			return 'Configuration error. Please check your SDK setup.';
+		}
+
+		if (error instanceof WidgetError) {
+			return 'Widget error. Please try refreshing the page.';
+		}
+
+		return 'An unexpected error occurred. Please try again.';
+	}
+}

package/src/utils/helpers.js

@@ -0,0 +1,219 @@
+export function generateId(prefix = 'feedback') {
+	const timestamp = Date.now();
+	const random = Math.random().toString(36).substring(2, 9);
+	return `${prefix}_${timestamp}_${random}`;
+}
+
+export function deepMerge(target, source) {
+	const result = { ...target };
+
+	for (const key in source) {
+		if (source.hasOwnProperty(key)) {
+			if (
+				source[key] &&
+				typeof source[key] === 'object' &&
+				!Array.isArray(source[key])
+			) {
+				result[key] = deepMerge(target[key] || {}, source[key]);
+			} else {
+				result[key] = source[key];
+			}
+		}
+	}
+
+	return result;
+}
+
+export function debounce(func, wait) {
+	let timeout;
+	return function executedFunction(...args) {
+		const later = () => {
+			clearTimeout(timeout);
+			func(...args);
+		};
+		clearTimeout(timeout);
+		timeout = setTimeout(later, wait);
+	};
+}
+
+export function throttle(func, limit) {
+	let lastFunc;
+	let lastRan;
+	return function (...args) {
+		if (!lastRan) {
+			func(...args);
+			lastRan = Date.now();
+		} else {
+			clearTimeout(lastFunc);
+			lastFunc = setTimeout(
+				() => {
+					if (Date.now() - lastRan >= limit) {
+						func(...args);
+						lastRan = Date.now();
+					}
+				},
+				limit - (Date.now() - lastRan)
+			);
+		}
+	};
+}
+
+export function isValidEmail(email) {
+	if (!email || typeof email !== 'string') return false;
+
+	const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+	return emailRegex.test(email.trim());
+}
+
+export function sanitizeHTML(str) {
+	if (!str || typeof str !== 'string') return '';
+
+	const div = document.createElement('div');
+	div.textContent = str;
+	return div.innerHTML;
+}
+
+export function getCSSProperty(element, property, fallback = '') {
+	if (!element || !property) return fallback;
+
+	try {
+		const style = window.getComputedStyle(element);
+		return style.getPropertyValue(property) || fallback;
+	} catch (error) {
+		return fallback;
+	}
+}
+
+export function isInViewport(element) {
+	if (!element) return false;
+
+	const rect = element.getBoundingClientRect();
+	return (
+		rect.top >= 0 &&
+		rect.left >= 0 &&
+		rect.bottom <=
+			(window.innerHeight || document.documentElement.clientHeight) &&
+		rect.right <= (window.innerWidth || document.documentElement.clientWidth)
+	);
+}
+
+export function scrollToElement(element, options = {}) {
+	if (!element) return;
+
+	const defaultOptions = {
+		behavior: 'smooth',
+		block: 'center',
+		inline: 'nearest',
+	};
+
+	element.scrollIntoView({ ...defaultOptions, ...options });
+}
+
+export function getBrowserInfo() {
+	const userAgent = navigator.userAgent;
+	const platform = navigator.platform;
+
+	return {
+		userAgent,
+		platform,
+		language: navigator.language || navigator.userLanguage,
+		cookieEnabled: navigator.cookieEnabled,
+		screenResolution: `${screen.width}x${screen.height}`,
+		windowSize: `${window.innerWidth}x${window.innerHeight}`,
+		timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+	};
+}
+
+export function formatFileSize(bytes) {
+	if (bytes === 0) return '0 Bytes';
+
+	const k = 1024;
+	const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+	const i = Math.floor(Math.log(bytes) / Math.log(k));
+
+	return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+}
+
+export function delay(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export function safeJsonParse(str, fallback = null) {
+	try {
+		return JSON.parse(str);
+	} catch (error) {
+		return fallback;
+	}
+}
+
+export function escapeRegex(string) {
+	return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+export function getNestedProperty(obj, path, defaultValue = undefined) {
+	if (!obj || !path) return defaultValue;
+
+	const keys = path.split('.');
+	let current = obj;
+
+	for (const key of keys) {
+		if (current === null || current === undefined || !(key in current)) {
+			return defaultValue;
+		}
+		current = current[key];
+	}
+
+	return current;
+}
+
+export function setNestedProperty(obj, path, value) {
+	if (!obj || !path) return obj;
+
+	const keys = path.split('.');
+	const lastKey = keys.pop();
+	let current = obj;
+
+	for (const key of keys) {
+		if (!(key in current) || typeof current[key] !== 'object') {
+			current[key] = {};
+		}
+		current = current[key];
+	}
+
+	current[lastKey] = value;
+	return obj;
+}
+
+export function isBrowser() {
+	return typeof window !== 'undefined' && typeof document !== 'undefined';
+}
+
+export function isMobile() {
+	if (!isBrowser()) return false;
+
+	return (
+		/Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(
+			navigator.userAgent
+		) || window.innerWidth <= 768
+	);
+}
+
+export function getCurrentTimestamp() {
+	return new Date().toISOString();
+}
+
+export function validateConfig(config, required = []) {
+	const missing = [];
+
+	for (const key of required) {
+		if (!config[key]) {
+			missing.push(key);
+		}
+	}
+
+	if (missing.length > 0) {
+		throw new Error(`Missing required configuration: ${missing.join(', ')}`);
+	}
+
+	return true;
+}