@object-ui/core 3.3.0 → 3.3.1

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

@@ -1,177 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import type { KeyboardNavigationConfig, FocusTrapConfig } from '@object-ui/types';
-import {
-  resolveKeyboardConfig,
-  parseShortcutKey,
-  matchesShortcut,
-  createFocusTrapConfig,
-} from '../../protocols/KeyboardProtocol';
-
-describe('KeyboardProtocol', () => {
-  // ==========================================================================
-  // resolveKeyboardConfig
-  // ==========================================================================
-  describe('resolveKeyboardConfig', () => {
-    it('should apply defaults for empty config', () => {
-      const config = {} as KeyboardNavigationConfig;
-      const resolved = resolveKeyboardConfig(config);
-
-      expect(resolved.shortcuts).toEqual([]);
-      expect(resolved.rovingTabindex).toBe(false);
-      expect(resolved.focusManagement.tabOrder).toBe('auto');
-      expect(resolved.focusManagement.skipLinks).toBe(false);
-      expect(resolved.focusManagement.focusVisible).toBe(true);
-      expect(resolved.focusManagement.arrowNavigation).toBe(false);
-      expect(resolved.focusManagement.focusTrap).toBeUndefined();
-    });
-
-    it('should resolve ariaLabel from string', () => {
-      const config = { ariaLabel: 'Navigation' } as KeyboardNavigationConfig;
-      const resolved = resolveKeyboardConfig(config);
-
-      expect(resolved.ariaLabel).toBe('Navigation');
-    });
-
-    it('should resolve ariaLabel from string', () => {
-      const config = {
-        ariaLabel: 'Nav panel',
-      } as unknown as KeyboardNavigationConfig;
-      const resolved = resolveKeyboardConfig(config);
-
-      expect(resolved.ariaLabel).toBe('Nav panel');
-    });
-
-    it('should preserve explicit values', () => {
-      const config = {
-        rovingTabindex: true,
-        role: 'toolbar',
-        ariaDescribedBy: 'desc-id',
-      } as KeyboardNavigationConfig;
-      const resolved = resolveKeyboardConfig(config);
-
-      expect(resolved.rovingTabindex).toBe(true);
-      expect(resolved.role).toBe('toolbar');
-      expect(resolved.ariaDescribedBy).toBe('desc-id');
-    });
-  });
-
-  // ==========================================================================
-  // parseShortcutKey
-  // ==========================================================================
-  describe('parseShortcutKey', () => {
-    it('should parse Ctrl+S', () => {
-      const parsed = parseShortcutKey('Ctrl+S');
-
-      expect(parsed.key).toBe('s');
-      expect(parsed.ctrlOrMeta).toBe(true);
-      expect(parsed.shift).toBe(false);
-      expect(parsed.alt).toBe(false);
-    });
-
-    it('should parse Alt+Shift+N', () => {
-      const parsed = parseShortcutKey('Alt+Shift+N');
-
-      expect(parsed.key).toBe('n');
-      expect(parsed.ctrlOrMeta).toBe(false);
-      expect(parsed.shift).toBe(true);
-      expect(parsed.alt).toBe(true);
-    });
-
-    it('should parse single key Escape', () => {
-      const parsed = parseShortcutKey('Escape');
-
-      expect(parsed.key).toBe('escape');
-      expect(parsed.ctrlOrMeta).toBe(false);
-      expect(parsed.shift).toBe(false);
-      expect(parsed.alt).toBe(false);
-    });
-
-    it('should be case insensitive', () => {
-      const parsed = parseShortcutKey('ctrl+s');
-
-      expect(parsed.key).toBe('s');
-      expect(parsed.ctrlOrMeta).toBe(true);
-    });
-
-    it('should parse single key F1', () => {
-      const parsed = parseShortcutKey('F1');
-
-      expect(parsed.key).toBe('f1');
-      expect(parsed.ctrlOrMeta).toBe(false);
-      expect(parsed.shift).toBe(false);
-      expect(parsed.alt).toBe(false);
-    });
-
-    it('should recognise Meta as ctrlOrMeta', () => {
-      const parsed = parseShortcutKey('Meta+K');
-
-      expect(parsed.ctrlOrMeta).toBe(true);
-      expect(parsed.key).toBe('k');
-    });
-  });
-
-  // ==========================================================================
-  // matchesShortcut
-  // ==========================================================================
-  describe('matchesShortcut', () => {
-    it('should match Ctrl+S event', () => {
-      const event = { key: 's', ctrlKey: true };
-      expect(matchesShortcut(event, 'Ctrl+S')).toBe(true);
-    });
-
-    it('should match Meta+S event (Cmd on Mac)', () => {
-      const event = { key: 's', metaKey: true };
-      expect(matchesShortcut(event, 'Ctrl+S')).toBe(true);
-    });
-
-    it('should not match when key differs', () => {
-      const event = { key: 'a', ctrlKey: true };
-      expect(matchesShortcut(event, 'Ctrl+S')).toBe(false);
-    });
-
-    it('should not match when modifier is missing', () => {
-      const event = { key: 's' };
-      expect(matchesShortcut(event, 'Ctrl+S')).toBe(false);
-    });
-
-    it('should not match when extra modifier is present', () => {
-      const event = { key: 's', ctrlKey: true, shiftKey: true };
-      expect(matchesShortcut(event, 'Ctrl+S')).toBe(false);
-    });
-
-    it('should match Escape without modifiers', () => {
-      const event = { key: 'Escape' };
-      expect(matchesShortcut(event, 'Escape')).toBe(true);
-    });
-  });
-
-  // ==========================================================================
-  // createFocusTrapConfig
-  // ==========================================================================
-  describe('createFocusTrapConfig', () => {
-    it('should apply defaults for minimal config', () => {
-      const config = {} as FocusTrapConfig;
-      const resolved = createFocusTrapConfig(config);
-
-      expect(resolved.enabled).toBe(false);
-      expect(resolved.returnFocus).toBe(true);
-      expect(resolved.escapeDeactivates).toBe(true);
-      expect(resolved.initialFocus).toBeUndefined();
-    });
-
-    it('should preserve explicit values', () => {
-      const config = {
-        enabled: true,
-        initialFocus: '#first-input',
-        returnFocus: false,
-        escapeDeactivates: false,
-      } as FocusTrapConfig;
-      const resolved = createFocusTrapConfig(config);
-
-      expect(resolved.enabled).toBe(true);
-      expect(resolved.initialFocus).toBe('#first-input');
-      expect(resolved.returnFocus).toBe(false);
-      expect(resolved.escapeDeactivates).toBe(false);
-    });
-  });
-});

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

@@ -1,142 +0,0 @@
-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 string title and message', () => {
-      const notification = {
-        title: 'Heads up',
-        message: '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

@@ -1,176 +0,0 @@
-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

@@ -1,188 +0,0 @@
-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([]);
-    });
-  });
-});