@object-ui/core 3.0.2 → 3.1.0

package/src/__tests__/protocols/NotificationProtocol.test.ts

@@ -0,0 +1,142 @@
+import { describe, it, expect } from 'vitest';
+import type {
+  Notification as SpecNotification,
+  NotificationConfig,
+} from '@object-ui/types';
+import {
+  specNotificationToToast,
+  mapSeverityToVariant,
+  mapPosition,
+  resolveNotificationConfig,
+} from '../../protocols/NotificationProtocol';
+
+describe('NotificationProtocol', () => {
+  // ==========================================================================
+  // mapSeverityToVariant
+  // ==========================================================================
+  describe('mapSeverityToVariant', () => {
+    it.each([
+      ['info', 'default'],
+      ['success', 'success'],
+      ['warning', 'warning'],
+      ['error', 'destructive'],
+    ] as const)('should map "%s" to "%s"', (severity, expected) => {
+      expect(mapSeverityToVariant(severity)).toBe(expected);
+    });
+
+    it('should fall back to "default" for unknown severity', () => {
+      expect(mapSeverityToVariant('critical')).toBe('default');
+    });
+  });
+
+  // ==========================================================================
+  // mapPosition
+  // ==========================================================================
+  describe('mapPosition', () => {
+    it.each([
+      ['top_left', 'top-left'],
+      ['top_center', 'top-center'],
+      ['top_right', 'top-right'],
+      ['bottom_left', 'bottom-left'],
+      ['bottom_center', 'bottom-center'],
+      ['bottom_right', 'bottom-right'],
+    ] as const)('should map "%s" to "%s"', (spec, expected) => {
+      expect(mapPosition(spec)).toBe(expected);
+    });
+
+    it('should fall back to "top-right" for unknown position', () => {
+      expect(mapPosition('center')).toBe('top-right');
+    });
+  });
+
+  // ==========================================================================
+  // resolveNotificationConfig
+  // ==========================================================================
+  describe('resolveNotificationConfig', () => {
+    it('should apply all defaults for empty config', () => {
+      const config = {} as NotificationConfig;
+      const resolved = resolveNotificationConfig(config);
+
+      expect(resolved.defaultPosition).toBe('top_right');
+      expect(resolved.defaultDuration).toBe(5000);
+      expect(resolved.maxVisible).toBe(5);
+      expect(resolved.stackDirection).toBe('down');
+      expect(resolved.pauseOnHover).toBe(true);
+    });
+
+    it('should preserve explicit values', () => {
+      const config = {
+        defaultPosition: 'bottom_left',
+        defaultDuration: 3000,
+        maxVisible: 3,
+        stackDirection: 'up',
+        pauseOnHover: false,
+      } as NotificationConfig;
+      const resolved = resolveNotificationConfig(config);
+
+      expect(resolved.defaultPosition).toBe('bottom_left');
+      expect(resolved.defaultDuration).toBe(3000);
+      expect(resolved.maxVisible).toBe(3);
+      expect(resolved.stackDirection).toBe('up');
+      expect(resolved.pauseOnHover).toBe(false);
+    });
+  });
+
+  // ==========================================================================
+  // specNotificationToToast
+  // ==========================================================================
+  describe('specNotificationToToast', () => {
+    it('should convert a basic notification to toast', () => {
+      const notification = {
+        message: 'Record saved',
+        severity: 'success',
+      } as SpecNotification;
+      const toast = specNotificationToToast(notification);
+
+      expect(toast.description).toBe('Record saved');
+      expect(toast.variant).toBe('success');
+      expect(toast.position).toBe('top-right');
+      expect(toast.duration).toBe(5000);
+      expect(toast.dismissible).toBe(true);
+      expect(toast.actions).toEqual([]);
+    });
+
+    it('should handle translation objects for title and message', () => {
+      const notification = {
+        title: { key: 'notify.title', defaultValue: 'Heads up' },
+        message: { key: 'notify.msg', defaultValue: 'Something happened' },
+      } as unknown as SpecNotification;
+      const toast = specNotificationToToast(notification);
+
+      expect(toast.title).toBe('Heads up');
+      expect(toast.description).toBe('Something happened');
+    });
+
+    it('should map actions to toast actions', () => {
+      const notification = {
+        message: 'Error occurred',
+        severity: 'error',
+        actions: [
+          { label: 'Retry', action: 'retry', variant: 'primary' },
+          { label: 'Dismiss', action: 'dismiss', variant: 'secondary' },
+        ],
+      } as unknown as SpecNotification;
+      const toast = specNotificationToToast(notification);
+
+      expect(toast.actions).toHaveLength(2);
+      expect(toast.actions[0]).toEqual({ label: 'Retry', action: 'retry', variant: 'primary' });
+      expect(toast.actions[1]).toEqual({ label: 'Dismiss', action: 'dismiss', variant: 'secondary' });
+    });
+
+    it('should apply defaults for missing fields', () => {
+      const notification = {} as SpecNotification;
+      const toast = specNotificationToToast(notification);
+
+      expect(toast.description).toBe('');
+      expect(toast.variant).toBe('default');
+      expect(toast.position).toBe('top-right');
+      expect(toast.duration).toBe(5000);
+      expect(toast.dismissible).toBe(true);
+    });
+  });
+});

package/src/__tests__/protocols/ResponsiveProtocol.test.ts

@@ -0,0 +1,176 @@
+import { describe, it, expect } from 'vitest';
+import type { SpecResponsiveConfig } from '@object-ui/types';
+import {
+  getVisibilityClasses,
+  getColumnClasses,
+  getOrderClasses,
+  shouldHideAtBreakpoint,
+  resolveResponsiveConfig,
+  BREAKPOINT_VALUES,
+} from '../../protocols/ResponsiveProtocol';
+
+describe('ResponsiveProtocol', () => {
+  // ==========================================================================
+  // BREAKPOINT_VALUES
+  // ==========================================================================
+  describe('BREAKPOINT_VALUES', () => {
+    it('should export correct pixel values for all breakpoints', () => {
+      expect(BREAKPOINT_VALUES.xs).toBe(0);
+      expect(BREAKPOINT_VALUES.sm).toBe(640);
+      expect(BREAKPOINT_VALUES.md).toBe(768);
+      expect(BREAKPOINT_VALUES.lg).toBe(1024);
+      expect(BREAKPOINT_VALUES.xl).toBe(1280);
+      expect(BREAKPOINT_VALUES['2xl']).toBe(1536);
+    });
+  });
+
+  // ==========================================================================
+  // resolveResponsiveConfig
+  // ==========================================================================
+  describe('resolveResponsiveConfig', () => {
+    it('should apply defaults for empty config', () => {
+      const config = {} as SpecResponsiveConfig;
+      const resolved = resolveResponsiveConfig(config);
+
+      expect(resolved.breakpoint).toBeUndefined();
+      expect(resolved.hiddenOn).toEqual([]);
+      expect(resolved.columns).toEqual({});
+      expect(resolved.order).toEqual({});
+    });
+
+    it('should preserve explicit values', () => {
+      const config = {
+        breakpoint: 'md',
+        hiddenOn: ['sm'],
+        columns: { xs: 1, md: 2 },
+        order: { xs: 2, md: 1 },
+      } as SpecResponsiveConfig;
+      const resolved = resolveResponsiveConfig(config);
+
+      expect(resolved.breakpoint).toBe('md');
+      expect(resolved.hiddenOn).toEqual(['sm']);
+      expect(resolved.columns).toEqual({ xs: 1, md: 2 });
+      expect(resolved.order).toEqual({ xs: 2, md: 1 });
+    });
+  });
+
+  // ==========================================================================
+  // getVisibilityClasses
+  // ==========================================================================
+  describe('getVisibilityClasses', () => {
+    it('should return empty array for no visibility config', () => {
+      const config = {} as SpecResponsiveConfig;
+      expect(getVisibilityClasses(config)).toEqual([]);
+    });
+
+    it('should return hidden + breakpoint:block for minimum breakpoint', () => {
+      const config = { breakpoint: 'md' } as SpecResponsiveConfig;
+      const classes = getVisibilityClasses(config);
+
+      expect(classes).toContain('hidden');
+      expect(classes).toContain('md:block');
+    });
+
+    it('should not add hidden class for xs breakpoint', () => {
+      const config = { breakpoint: 'xs' } as SpecResponsiveConfig;
+      const classes = getVisibilityClasses(config);
+
+      expect(classes).not.toContain('hidden');
+    });
+
+    it('should generate toggle classes for hiddenOn', () => {
+      const config = { hiddenOn: ['sm'] } as SpecResponsiveConfig;
+      const classes = getVisibilityClasses(config);
+
+      expect(classes).toContain('sm:hidden');
+      expect(classes).toContain('md:block');
+    });
+
+    it('should handle hiddenOn at xs breakpoint', () => {
+      const config = { hiddenOn: ['xs'] } as SpecResponsiveConfig;
+      const classes = getVisibilityClasses(config);
+
+      expect(classes).toContain('hidden');
+      expect(classes).toContain('sm:block');
+    });
+  });
+
+  // ==========================================================================
+  // getColumnClasses
+  // ==========================================================================
+  describe('getColumnClasses', () => {
+    it('should return empty array when no columns set', () => {
+      const config = {} as SpecResponsiveConfig;
+      expect(getColumnClasses(config)).toEqual([]);
+    });
+
+    it('should return grid-cols classes for each breakpoint', () => {
+      const config = {
+        columns: { xs: 1, md: 2, xl: 4 },
+      } as SpecResponsiveConfig;
+      const classes = getColumnClasses(config);
+
+      expect(classes).toContain('grid-cols-1');
+      expect(classes).toContain('md:grid-cols-2');
+      expect(classes).toContain('xl:grid-cols-4');
+    });
+
+    it('should omit prefix for xs breakpoint', () => {
+      const config = { columns: { xs: 3 } } as SpecResponsiveConfig;
+      const classes = getColumnClasses(config);
+
+      expect(classes).toEqual(['grid-cols-3']);
+    });
+  });
+
+  // ==========================================================================
+  // getOrderClasses
+  // ==========================================================================
+  describe('getOrderClasses', () => {
+    it('should return empty array when no order set', () => {
+      const config = {} as SpecResponsiveConfig;
+      expect(getOrderClasses(config)).toEqual([]);
+    });
+
+    it('should return order classes for each breakpoint', () => {
+      const config = {
+        order: { xs: 2, lg: 1 },
+      } as SpecResponsiveConfig;
+      const classes = getOrderClasses(config);
+
+      expect(classes).toContain('order-2');
+      expect(classes).toContain('lg:order-1');
+    });
+  });
+
+  // ==========================================================================
+  // shouldHideAtBreakpoint
+  // ==========================================================================
+  describe('shouldHideAtBreakpoint', () => {
+    it('should hide below minimum breakpoint', () => {
+      const config = { breakpoint: 'md' } as SpecResponsiveConfig;
+
+      expect(shouldHideAtBreakpoint(config, 600)).toBe(true); // below 768
+      expect(shouldHideAtBreakpoint(config, 768)).toBe(false); // at 768
+      expect(shouldHideAtBreakpoint(config, 1024)).toBe(false); // above 768
+    });
+
+    it('should hide at breakpoints in hiddenOn list', () => {
+      const config = { hiddenOn: ['sm', 'lg'] } as SpecResponsiveConfig;
+
+      expect(shouldHideAtBreakpoint(config, 700)).toBe(true); // sm range
+      expect(shouldHideAtBreakpoint(config, 800)).toBe(false); // md range
+      expect(shouldHideAtBreakpoint(config, 1100)).toBe(true); // lg range
+    });
+
+    it('should return false when no config constraints', () => {
+      const config = {} as SpecResponsiveConfig;
+      expect(shouldHideAtBreakpoint(config, 500)).toBe(false);
+    });
+
+    it('should not hide at xs width when no constraints', () => {
+      const config = {} as SpecResponsiveConfig;
+      expect(shouldHideAtBreakpoint(config, 0)).toBe(false);
+    });
+  });
+});

package/src/__tests__/protocols/SharingProtocol.test.ts

@@ -0,0 +1,188 @@
+import { describe, it, expect } from 'vitest';
+import type { SharingConfig, EmbedConfig } from '@object-ui/types';
+import {
+  resolveSharingConfig,
+  resolveEmbedConfig,
+  generateEmbedCode,
+  validateSharingConfig,
+} from '../../protocols/SharingProtocol';
+
+describe('SharingProtocol', () => {
+  // ==========================================================================
+  // resolveSharingConfig
+  // ==========================================================================
+  describe('resolveSharingConfig', () => {
+    it('should apply defaults for empty config', () => {
+      const resolved = resolveSharingConfig({});
+
+      expect(resolved.enabled).toBe(false);
+      expect(resolved.allowedDomains).toEqual([]);
+      expect(resolved.allowAnonymous).toBe(false);
+      expect(resolved.publicLink).toBeUndefined();
+      expect(resolved.password).toBeUndefined();
+      expect(resolved.expiresAt).toBeUndefined();
+    });
+
+    it('should preserve explicit values', () => {
+      const config: Partial<SharingConfig> = {
+        enabled: true,
+        publicLink: 'https://example.com/share/abc',
+        password: 'secret',
+        allowedDomains: ['example.com'],
+        expiresAt: '2025-12-31T00:00:00Z',
+        allowAnonymous: true,
+      };
+      const resolved = resolveSharingConfig(config);
+
+      expect(resolved.enabled).toBe(true);
+      expect(resolved.publicLink).toBe('https://example.com/share/abc');
+      expect(resolved.password).toBe('secret');
+      expect(resolved.allowedDomains).toEqual(['example.com']);
+      expect(resolved.expiresAt).toBe('2025-12-31T00:00:00Z');
+      expect(resolved.allowAnonymous).toBe(true);
+    });
+  });
+
+  // ==========================================================================
+  // resolveEmbedConfig
+  // ==========================================================================
+  describe('resolveEmbedConfig', () => {
+    it('should apply defaults for empty config', () => {
+      const resolved = resolveEmbedConfig({});
+
+      expect(resolved.enabled).toBe(false);
+      expect(resolved.allowedOrigins).toEqual([]);
+      expect(resolved.width).toBe('100%');
+      expect(resolved.height).toBe('600px');
+      expect(resolved.showHeader).toBe(true);
+      expect(resolved.showNavigation).toBe(false);
+      expect(resolved.responsive).toBe(true);
+    });
+
+    it('should preserve explicit values', () => {
+      const config: Partial<EmbedConfig> = {
+        enabled: true,
+        width: '800px',
+        height: '400px',
+        showHeader: false,
+        responsive: false,
+      };
+      const resolved = resolveEmbedConfig(config);
+
+      expect(resolved.enabled).toBe(true);
+      expect(resolved.width).toBe('800px');
+      expect(resolved.height).toBe('400px');
+      expect(resolved.showHeader).toBe(false);
+      expect(resolved.responsive).toBe(false);
+    });
+  });
+
+  // ==========================================================================
+  // generateEmbedCode
+  // ==========================================================================
+  describe('generateEmbedCode', () => {
+    it('should return valid iframe HTML', () => {
+      const config = {} as EmbedConfig;
+      const html = generateEmbedCode(config, 'https://app.example.com/view/123');
+
+      expect(html).toContain('<iframe');
+      expect(html).toContain('</iframe>');
+      expect(html).toContain('src="https://app.example.com/view/123"');
+      expect(html).toContain('width="100%"');
+      expect(html).toContain('height="600px"');
+      expect(html).toContain('allowfullscreen');
+    });
+
+    it('should include responsive style when responsive is true', () => {
+      const config = { responsive: true } as EmbedConfig;
+      const html = generateEmbedCode(config, 'https://example.com');
+
+      expect(html).toContain('max-width: 100%');
+    });
+
+    it('should not include max-width when responsive is false', () => {
+      const config = { responsive: false } as EmbedConfig;
+      const html = generateEmbedCode(config, 'https://example.com');
+
+      expect(html).not.toContain('max-width');
+    });
+
+    it('should HTML-escape URLs to prevent XSS', () => {
+      const config = {} as EmbedConfig;
+      const maliciousUrl = 'https://example.com/"><script>alert("xss")</script>';
+      const html = generateEmbedCode(config, maliciousUrl);
+
+      expect(html).not.toContain('<script>');
+      expect(html).toContain('&lt;script&gt;');
+      expect(html).toContain('&quot;');
+    });
+  });
+
+  // ==========================================================================
+  // validateSharingConfig
+  // ==========================================================================
+  describe('validateSharingConfig', () => {
+    it('should return valid for a well-formed config', () => {
+      const config = {
+        enabled: true,
+        publicLink: 'https://example.com/share/abc',
+        allowedDomains: ['example.com'],
+      } as SharingConfig;
+      const result = validateSharingConfig(config);
+
+      expect(result.valid).toBe(true);
+      expect(result.errors).toEqual([]);
+    });
+
+    it('should error when enabled without publicLink', () => {
+      const config = { enabled: true } as SharingConfig;
+      const result = validateSharingConfig(config);
+
+      expect(result.valid).toBe(false);
+      expect(result.errors).toContain('A public link is required when sharing is enabled.');
+    });
+
+    it('should error for invalid expiresAt date', () => {
+      const config = {
+        enabled: false,
+        expiresAt: 'not-a-date',
+      } as SharingConfig;
+      const result = validateSharingConfig(config);
+
+      expect(result.valid).toBe(false);
+      expect(result.errors).toContain('expiresAt must be a valid ISO 8601 date string.');
+    });
+
+    it('should error for empty password string', () => {
+      const config = {
+        enabled: false,
+        password: '',
+      } as SharingConfig;
+      const result = validateSharingConfig(config);
+
+      expect(result.valid).toBe(false);
+      expect(result.errors).toContain('Password must not be an empty string when provided.');
+    });
+
+    it('should error for empty domain entries', () => {
+      const config = {
+        enabled: false,
+        allowedDomains: ['example.com', '  '],
+      } as SharingConfig;
+      const result = validateSharingConfig(config);
+
+      expect(result.valid).toBe(false);
+      expect(result.errors).toContain(
+        'allowedDomains contains an empty or whitespace-only entry.'
+      );
+    });
+
+    it('should return valid for disabled config with no issues', () => {
+      const config = { enabled: false } as SharingConfig;
+      const result = validateSharingConfig(config);
+
+      expect(result.valid).toBe(true);
+      expect(result.errors).toEqual([]);
+    });
+  });
+});