@prosdevlab/experience-sdk-plugins 0.1.4 → 0.3.0

package/src/modal/form-validation.ts

@@ -0,0 +1,126 @@
+/**
+ * Pure validation functions for form fields
+ *
+ * These functions are intentionally pure (no side effects) to make them:
+ * - Easy to test
+ * - Easy to extract into a separate form plugin later
+ * - Reusable across different contexts
+ */
+
+import type { FormConfig, FormField, ValidationResult } from './types';
+
+/**
+ * Validate a single form field
+ *
+ * @param field - Field configuration
+ * @param value - Current field value
+ * @returns Validation result with errors if invalid
+ */
+export function validateField(field: FormField, value: string): ValidationResult {
+  const errors: Record<string, string> = {};
+
+  // Required field validation
+  if (field.required && (!value || value.trim() === '')) {
+    errors[field.name] = field.errorMessage || `${field.label || field.name} is required`;
+    return { valid: false, errors };
+  }
+
+  // Skip further validation if field is empty and not required
+  if (!value || value.trim() === '') {
+    return { valid: true };
+  }
+
+  // Type-specific validation
+  switch (field.type) {
+    case 'email': {
+      const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+      if (!emailRegex.test(value)) {
+        errors[field.name] = field.errorMessage || 'Please enter a valid email address';
+      }
+      break;
+    }
+
+    case 'url': {
+      try {
+        new URL(value);
+      } catch {
+        errors[field.name] = field.errorMessage || 'Please enter a valid URL';
+      }
+      break;
+    }
+
+    case 'tel': {
+      // Basic phone validation (allows digits, spaces, dashes, parentheses, plus)
+      const phoneRegex = /^[\d\s\-()+]+$/;
+      if (!phoneRegex.test(value)) {
+        errors[field.name] = field.errorMessage || 'Please enter a valid phone number';
+      }
+      break;
+    }
+
+    case 'number': {
+      if (Number.isNaN(Number(value))) {
+        errors[field.name] = field.errorMessage || 'Please enter a valid number';
+      }
+      break;
+    }
+  }
+
+  // Custom pattern validation (regex)
+  if (field.pattern && value) {
+    try {
+      const regex = new RegExp(field.pattern);
+      if (!regex.test(value)) {
+        errors[field.name] =
+          field.errorMessage || `Invalid format for ${field.label || field.name}`;
+      }
+    } catch (_error) {
+      // Invalid regex pattern - log warning but don't break validation
+      console.warn(`Invalid regex pattern for field ${field.name}:`, field.pattern);
+    }
+  }
+
+  return {
+    valid: Object.keys(errors).length === 0,
+    errors: Object.keys(errors).length > 0 ? errors : undefined,
+  };
+}
+
+/**
+ * Validate entire form
+ *
+ * @param config - Form configuration
+ * @param data - Current form data
+ * @returns Validation result with all field errors if invalid
+ */
+export function validateForm(config: FormConfig, data: Record<string, string>): ValidationResult {
+  const errors: Record<string, string> = {};
+
+  // Validate each field
+  config.fields.forEach((field) => {
+    const value = data[field.name] || '';
+    const result = validateField(field, value);
+
+    if (!result.valid && result.errors) {
+      Object.assign(errors, result.errors);
+    }
+  });
+
+  // Custom validation function
+  if (config.validate) {
+    try {
+      const customResult = config.validate(data);
+      if (!customResult.valid && customResult.errors) {
+        Object.assign(errors, customResult.errors);
+      }
+    } catch (error) {
+      console.error('Custom validation function threw an error:', error);
+      // Don't prevent submission if custom validation has a bug
+    }
+  }
+
+  return {
+    valid: Object.keys(errors).length === 0,
+    errors: Object.keys(errors).length > 0 ? errors : undefined,
+  };
+}

package/src/modal/index.ts

@@ -0,0 +1,3 @@
+export { modalPlugin } from './modal';
+export * from './types';
+export * from './types';

package/src/modal/modal-styles.ts

@@ -0,0 +1,204 @@
+/**
+ * Modal styling with CSS variables for theming
+ *
+ * Design tokens for modal dialogs, fully customizable via CSS variables.
+ * Users can override by setting CSS variables in their stylesheet.
+ *
+ * @example
+ * ```css
+ * :root {
+ *   --xp-modal-backdrop-bg: rgba(0, 0, 0, 0.7);
+ *   --xp-modal-dialog-bg: #ffffff;
+ *   --xp-modal-dialog-radius: 12px;
+ * }
+ * ```
+ */
+
+/**
+ * Get CSS for modal backdrop
+ */
+export function getBackdropStyles(): string {
+  return `
+    position: absolute;
+    inset: 0;
+    background-color: var(--xp-modal-backdrop-bg, rgba(0, 0, 0, 0.5));
+  `.trim();
+}
+
+/**
+ * Get CSS for modal dialog
+ */
+export function getDialogStyles(params: {
+  width: string;
+  maxWidth: string;
+  height: string;
+  maxHeight: string;
+  borderRadius: string;
+  padding: string;
+}): string {
+  return `
+    position: relative;
+    background: var(--xp-modal-dialog-bg, white);
+    border-radius: var(--xp-modal-dialog-radius, ${params.borderRadius});
+    box-shadow: var(--xp-modal-dialog-shadow, 0 4px 6px rgba(0, 0, 0, 0.1));
+    max-width: ${params.width};
+    width: ${params.maxWidth};
+    height: ${params.height};
+    max-height: ${params.maxHeight};
+    overflow-y: auto;
+    padding: ${params.padding};
+  `.trim();
+}
+
+/**
+ * Get CSS for hero image
+ */
+export function getHeroImageStyles(params: { maxHeight: number; borderRadius: string }): string {
+  return `
+    width: 100%;
+    height: auto;
+    max-height: ${params.maxHeight}px;
+    object-fit: cover;
+    border-radius: ${params.borderRadius};
+    display: block;
+    margin: 0;
+  `.trim();
+}
+
+/**
+ * Get CSS for close button
+ */
+export function getCloseButtonStyles(): string {
+  return `
+    position: absolute;
+    top: var(--xp-modal-close-top, 16px);
+    right: var(--xp-modal-close-right, 16px);
+    background: none;
+    border: none;
+    font-size: var(--xp-modal-close-size, 24px);
+    line-height: 1;
+    cursor: pointer;
+    padding: var(--xp-modal-close-padding, 4px 8px);
+    color: var(--xp-modal-close-color, #666);
+    opacity: var(--xp-modal-close-opacity, 0.7);
+    transition: opacity 0.2s;
+  `.trim();
+}
+
+/**
+ * Get close button hover opacity
+ */
+export function getCloseButtonHoverOpacity(): string {
+  return 'var(--xp-modal-close-hover-opacity, 1)';
+}
+
+/**
+ * Get close button default opacity
+ */
+export function getCloseButtonDefaultOpacity(): string {
+  return 'var(--xp-modal-close-opacity, 0.7)';
+}
+
+/**
+ * Get CSS for content wrapper
+ */
+export function getContentWrapperStyles(padding: string): string {
+  return `padding: ${padding};`;
+}
+
+/**
+ * Get CSS for modal title
+ */
+export function getTitleStyles(): string {
+  return `
+    margin: 0 0 var(--xp-modal-title-margin-bottom, 16px) 0;
+    font-size: var(--xp-modal-title-size, 20px);
+    font-weight: var(--xp-modal-title-weight, 600);
+    color: var(--xp-modal-title-color, #111);
+  `.trim();
+}
+
+/**
+ * Get CSS for modal message
+ */
+export function getMessageStyles(): string {
+  return `
+    margin: 0 0 var(--xp-modal-message-margin-bottom, 20px) 0;
+    font-size: var(--xp-modal-message-size, 14px);
+    line-height: var(--xp-modal-message-line-height, 1.5);
+    color: var(--xp-modal-message-color, #444);
+  `.trim();
+}
+
+/**
+ * Get CSS for button container
+ */
+export function getButtonContainerStyles(): string {
+  return `
+    display: flex;
+    gap: var(--xp-modal-buttons-gap, 8px);
+    flex-wrap: wrap;
+  `.trim();
+}
+
+/**
+ * Get CSS for primary button
+ */
+export function getPrimaryButtonStyles(): string {
+  return `
+    padding: var(--xp-button-padding, 10px 20px);
+    font-size: var(--xp-button-font-size, 14px);
+    font-weight: var(--xp-button-font-weight, 500);
+    border-radius: var(--xp-button-radius, 6px);
+    cursor: pointer;
+    transition: all 0.2s;
+    border: none;
+    background: var(--xp-button-primary-bg, #2563eb);
+    color: var(--xp-button-primary-color, white);
+  `.trim();
+}
+
+/**
+ * Get primary button hover background
+ */
+export function getPrimaryButtonHoverBg(): string {
+  return 'var(--xp-button-primary-bg-hover, #1d4ed8)';
+}
+
+/**
+ * Get primary button default background
+ */
+export function getPrimaryButtonDefaultBg(): string {
+  return 'var(--xp-button-primary-bg, #2563eb)';
+}
+
+/**
+ * Get CSS for secondary button
+ */
+export function getSecondaryButtonStyles(): string {
+  return `
+    padding: var(--xp-button-padding, 10px 20px);
+    font-size: var(--xp-button-font-size, 14px);
+    font-weight: var(--xp-button-font-weight, 500);
+    border-radius: var(--xp-button-radius, 6px);
+    cursor: pointer;
+    transition: all 0.2s;
+    border: none;
+    background: var(--xp-button-secondary-bg, #f3f4f6);
+    color: var(--xp-button-secondary-color, #374151);
+  `.trim();
+}
+
+/**
+ * Get secondary button hover background
+ */
+export function getSecondaryButtonHoverBg(): string {
+  return 'var(--xp-button-secondary-bg-hover, #e5e7eb)';
+}
+
+/**
+ * Get secondary button default background
+ */
+export function getSecondaryButtonDefaultBg(): string {
+  return 'var(--xp-button-secondary-bg, #f3f4f6)';
+}

package/src/modal/modal.browser.test.ts

@@ -0,0 +1,164 @@
+/**
+ * Browser-specific tests for modal plugin
+ * Run with: pnpm test:browser
+ *
+ * These tests run in a real browser (Chromium via Playwright) to test
+ * features that depend on actual browser APIs like window.innerWidth.
+ */
+
+import { SDK } from '@lytics/sdk-kit';
+import { beforeEach, describe, expect, it } from 'vitest';
+import { modalPlugin } from './modal';
+
+// Helper to initialize SDK with modal plugin
+function initPlugin(config = {}) {
+  const sdk = new SDK({
+    name: 'test-sdk',
+    ...config,
+  });
+
+  sdk.use(modalPlugin);
+  return sdk;
+}
+
+describe('Modal Plugin - Browser Tests', () => {
+  beforeEach(() => {
+    // Clean up any existing modals
+    document.querySelectorAll('.xp-modal').forEach((el) => {
+      el.remove();
+    });
+  });
+
+  describe('Mobile Viewport Detection', () => {
+    it('should detect mobile viewport (width < 640px)', () => {
+      // This test verifies that window.innerWidth works in the browser environment
+      // The actual viewport size is set by the test runner config
+      expect(window.innerWidth).toBeGreaterThan(0);
+      expect(typeof window.innerWidth).toBe('number');
+    });
+
+    it('should auto-enable fullscreen for lg size on mobile viewport @mobile', async () => {
+      // Note: @mobile tag would be used with test.describe.each for different viewports
+      // For now, we'll test the logic assuming the viewport is set externally
+
+      // Mock small viewport
+      Object.defineProperty(window, 'innerWidth', {
+        writable: true,
+        configurable: true,
+        value: 375,
+      });
+
+      const sdk = initPlugin({
+        modal: {
+          size: 'lg',
+        },
+      });
+      await sdk.init();
+
+      const experience = {
+        id: 'lg-mobile',
+        type: 'modal' as const,
+        targeting: {},
+        content: {
+          message: 'Large on mobile',
+        },
+      };
+
+      sdk.modal.show(experience);
+
+      // In a real mobile viewport, lg should become fullscreen
+      const modal = document.querySelector('.xp-modal');
+      const hasFullscreenClass = modal?.classList.contains('xp-modal--fullscreen');
+      const hasLgClass = modal?.classList.contains('xp-modal--lg');
+
+      // Since we're mocking innerWidth, this tests the check logic
+      // With innerWidth=375, isMobile() should return true
+      expect(modal).toBeTruthy();
+      expect(hasFullscreenClass || hasLgClass).toBe(true);
+
+      // Cleanup
+      await sdk.destroy();
+
+      // Restore
+      Object.defineProperty(window, 'innerWidth', {
+        writable: true,
+        configurable: true,
+        value: 1024,
+      });
+    });
+
+    it('should respect mobileFullscreen: false configuration', async () => {
+      // Mock mobile viewport
+      Object.defineProperty(window, 'innerWidth', {
+        writable: true,
+        configurable: true,
+        value: 375,
+      });
+
+      const sdk = initPlugin({
+        modal: {
+          size: 'lg',
+          mobileFullscreen: false,
+        },
+      });
+      await sdk.init();
+
+      const experience = {
+        id: 'lg-no-fullscreen',
+        type: 'modal' as const,
+        targeting: {},
+        content: {
+          message: 'Large without fullscreen',
+        },
+      };
+
+      sdk.modal.show(experience);
+
+      const modal = document.querySelector('.xp-modal');
+      expect(modal?.classList.contains('xp-modal--lg')).toBe(true);
+
+      // Cleanup
+      await sdk.destroy();
+
+      // Restore
+      Object.defineProperty(window, 'innerWidth', {
+        writable: true,
+        configurable: true,
+        value: 1024,
+      });
+    });
+  });
+
+  describe('Real Browser APIs', () => {
+    it('should access window object', () => {
+      expect(window).toBeDefined();
+      expect(window.document).toBeDefined();
+      expect(window.innerWidth).toBeGreaterThan(0);
+      expect(window.innerHeight).toBeGreaterThan(0);
+    });
+
+    it('should manipulate DOM', async () => {
+      const sdk = initPlugin();
+      await sdk.init();
+
+      const experience = {
+        id: 'dom-test',
+        type: 'modal' as const,
+        targeting: {},
+        content: {
+          message: 'DOM test',
+        },
+      };
+
+      sdk.modal.show(experience);
+
+      // Modal should be in the DOM
+      const modal = document.querySelector('.xp-modal');
+      expect(modal).toBeInstanceOf(HTMLElement);
+      expect(modal?.getAttribute('data-xp-id')).toBe('dom-test');
+
+      // Cleanup
+      await sdk.destroy();
+    });
+  });
+});