@afixt/test-utils 1.0.0

package/test/isFocusable.test.js

@@ -0,0 +1,182 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { isFocusable } from '../src/isFocusable.js';
+
+describe('isFocusable', () => {
+  // Setup common mocking for all tests
+  beforeEach(() => {
+    document.body.innerHTML = '';
+    
+    // Mock the closest method for all tests since JSDOM doesn't support :hidden
+    const originalClosest = Element.prototype.closest;
+    Element.prototype.closest = vi.fn().mockImplementation(function(selector) {
+      if (selector === ':hidden') return null; // By default, elements are not hidden
+      return originalClosest.call(this, selector);
+    });
+  });
+  
+  // Clean up after each test
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('should return false for null or undefined elements', () => {
+    // Assert
+    expect(isFocusable(null)).toBe(false);
+    expect(isFocusable(undefined)).toBe(false);
+  });
+
+  it('should return true for focusable input elements', () => {
+    // Arrange
+    const input = document.createElement('input');
+    input.type = 'text';
+    document.body.appendChild(input);
+
+    // Act & Assert
+    expect(isFocusable(input)).toBe(true);
+  });
+
+  it('should return false for disabled input elements', () => {
+    // Arrange
+    const input = document.createElement('input');
+    input.type = 'text';
+    input.disabled = true;
+    document.body.appendChild(input);
+
+    // Act & Assert
+    expect(isFocusable(input)).toBe(false);
+  });
+
+  it('should return true for focusable button elements', () => {
+    // Arrange
+    const button = document.createElement('button');
+    document.body.appendChild(button);
+
+    // Act & Assert
+    expect(isFocusable(button)).toBe(true);
+  });
+
+  it('should return false for disabled button elements', () => {
+    // Arrange
+    const button = document.createElement('button');
+    button.disabled = true;
+    document.body.appendChild(button);
+
+    // Act & Assert
+    expect(isFocusable(button)).toBe(false);
+  });
+
+  it('should return true for select elements', () => {
+    // Arrange
+    const select = document.createElement('select');
+    document.body.appendChild(select);
+
+    // Act & Assert
+    expect(isFocusable(select)).toBe(true);
+  });
+
+  it('should return true for textarea elements', () => {
+    // Arrange
+    const textarea = document.createElement('textarea');
+    document.body.appendChild(textarea);
+
+    // Act & Assert
+    expect(isFocusable(textarea)).toBe(true);
+  });
+
+  it('should return true for anchors with href attribute', () => {
+    // Arrange
+    const anchor = document.createElement('a');
+    anchor.setAttribute('href', '#');
+    document.body.appendChild(anchor);
+
+    // Act & Assert
+    expect(isFocusable(anchor)).toBe(true);
+  });
+
+  it('should return false for anchors without href attribute', () => {
+    // Arrange
+    const anchor = document.createElement('a');
+    document.body.appendChild(anchor);
+
+    // Act & Assert
+    expect(isFocusable(anchor)).toBe(false);
+  });
+
+  it('should return true for area elements with href attribute', () => {
+    // Arrange
+    const map = document.createElement('map');
+    const area = document.createElement('area');
+    area.setAttribute('href', '#');
+    map.appendChild(area);
+    document.body.appendChild(map);
+
+    // Act & Assert
+    expect(isFocusable(area)).toBe(true);
+  });
+
+  it('should return false for area elements without href attribute', () => {
+    // Arrange
+    const map = document.createElement('map');
+    const area = document.createElement('area');
+    map.appendChild(area);
+    document.body.appendChild(map);
+
+    // Act & Assert
+    expect(isFocusable(area)).toBe(false);
+  });
+
+  it('should return false for non-form elements with tabindex >= 0', () => {
+    // Arrange
+    const div = document.createElement('div');
+    div.setAttribute('tabindex', '0');
+    document.body.appendChild(div);
+
+    // Act & Assert
+    // According to the implementation, non-form elements with tabindex 
+    // are not considered focusable in this utility
+    expect(isFocusable(div)).toBe(false);
+  });
+
+  it('should return false for elements with tabindex < 0', () => {
+    // Arrange
+    const div = document.createElement('div');
+    div.setAttribute('tabindex', '-1');
+    document.body.appendChild(div);
+
+    // Act & Assert
+    expect(isFocusable(div)).toBe(false);
+  });
+
+  it('should return false for regular divs without tabindex', () => {
+    // Arrange
+    const div = document.createElement('div');
+    document.body.appendChild(div);
+
+    // Act & Assert
+    expect(isFocusable(div)).toBe(false);
+  });
+
+  it('should return false for hidden elements', () => {
+    // Arrange
+    const input = document.createElement('input');
+    document.body.appendChild(input);
+
+    // Override the mock to simulate a hidden element
+    Element.prototype.closest = vi.fn().mockImplementation(function(selector) {
+      if (selector === ':hidden') return this; // Element is hidden
+      return null;
+    });
+
+    // Act & Assert
+    expect(isFocusable(input)).toBe(false);
+  });
+
+  it('should return true for object elements', () => {
+    // Arrange
+    const object = document.createElement('object');
+    document.body.appendChild(object);
+
+    // Act & Assert
+    expect(isFocusable(object)).toBe(true);
+  });
+});

package/test/isHidden.test.js

@@ -0,0 +1,157 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import isHidden from '../src/isHidden.js';
+
+describe('isHidden', () => {
+  // Setup before each test
+  beforeEach(() => {
+    document.body.innerHTML = '';
+  });
+
+  it('should return true for elements with display:none', () => {
+    // Arrange
+    const element = document.createElement('div');
+    element.style.display = 'none';
+    document.body.appendChild(element);
+    
+    // Act
+    const result = isHidden(element);
+    
+    // Assert
+    expect(result).toBe(true);
+  });
+
+  it('should return true for elements with hidden attribute', () => {
+    // Arrange
+    const element = document.createElement('div');
+    element.setAttribute('hidden', '');
+    document.body.appendChild(element);
+    
+    // Act
+    const result = isHidden(element);
+    
+    // Assert
+    expect(result).toBe(true);
+  });
+
+  it('should return true for elements with both display:none and hidden attribute', () => {
+    // Arrange
+    const element = document.createElement('div');
+    element.style.display = 'none';
+    element.setAttribute('hidden', '');
+    document.body.appendChild(element);
+    
+    // Act
+    const result = isHidden(element);
+    
+    // Assert
+    expect(result).toBe(true);
+  });
+
+  it('should return false for visible elements with no hidden attribute', () => {
+    // Arrange
+    const element = document.createElement('div');
+    element.textContent = 'Visible element';
+    document.body.appendChild(element);
+    
+    // Act
+    const result = isHidden(element);
+    
+    // Assert
+    expect(result).toBe(false);
+  });
+
+  it('should return false for elements with display:block', () => {
+    // Arrange
+    const element = document.createElement('div');
+    element.style.display = 'block';
+    document.body.appendChild(element);
+    
+    // Act
+    const result = isHidden(element);
+    
+    // Assert
+    expect(result).toBe(false);
+  });
+
+  it('should return false for elements with display:inline', () => {
+    // Arrange
+    const element = document.createElement('span');
+    element.style.display = 'inline';
+    document.body.appendChild(element);
+    
+    // Act
+    const result = isHidden(element);
+    
+    // Assert
+    expect(result).toBe(false);
+  });
+
+  it('should return false for elements with display:flex', () => {
+    // Arrange
+    const element = document.createElement('div');
+    element.style.display = 'flex';
+    document.body.appendChild(element);
+    
+    // Act
+    const result = isHidden(element);
+    
+    // Assert
+    expect(result).toBe(false);
+  });
+
+  it('should handle elements with visibility:hidden but not display:none', () => {
+    // Arrange
+    const element = document.createElement('div');
+    element.style.visibility = 'hidden';
+    document.body.appendChild(element);
+    
+    // Act
+    const result = isHidden(element);
+    
+    // Assert
+    // Note: visibility:hidden does not qualify as "hidden" according to this function
+    expect(result).toBe(false);
+  });
+
+  it('should handle elements with opacity:0 but not display:none', () => {
+    // Arrange
+    const element = document.createElement('div');
+    element.style.opacity = '0';
+    document.body.appendChild(element);
+    
+    // Act
+    const result = isHidden(element);
+    
+    // Assert
+    // Note: opacity:0 does not qualify as "hidden" according to this function
+    expect(result).toBe(false);
+  });
+
+  it('should return false for elements with removed hidden attribute', () => {
+    // Arrange
+    const element = document.createElement('div');
+    element.setAttribute('hidden', '');
+    element.removeAttribute('hidden');
+    document.body.appendChild(element);
+    
+    // Act
+    const result = isHidden(element);
+    
+    // Assert
+    expect(result).toBe(false);
+  });
+
+  it('should return false for elements with display changed from none to block', () => {
+    // Arrange
+    const element = document.createElement('div');
+    element.style.display = 'none';
+    element.style.display = 'block';
+    document.body.appendChild(element);
+    
+    // Act
+    const result = isHidden(element);
+    
+    // Assert
+    expect(result).toBe(false);
+  });
+});

package/test/isOffScreen.test.js

@@ -0,0 +1,249 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { isOffScreen } from '../src/isOffScreen.js';
+
+describe('isOffScreen', () => {
+  // Setup before each test
+  beforeEach(() => {
+    document.body.innerHTML = '';
+    
+    // Mock window.innerWidth and window.innerHeight
+    vi.stubGlobal('innerWidth', 1024);
+    vi.stubGlobal('innerHeight', 768);
+  });
+
+  // Cleanup after each test
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('should return false for null or undefined elements', () => {
+    // Act & Assert
+    expect(isOffScreen(null)).toBe(false);
+    expect(isOffScreen(undefined)).toBe(false);
+  });
+
+  it('should return false for elements within the viewport', () => {
+    // Arrange
+    const element = document.createElement('div');
+    document.body.appendChild(element);
+    
+    // Mock the element's getBoundingClientRect to return a position within viewport
+    element.getBoundingClientRect = vi.fn().mockReturnValue({
+      top: 100,
+      right: 500,
+      bottom: 200,
+      left: 200
+    });
+    
+    // Act
+    const result = isOffScreen(element);
+    
+    // Assert
+    expect(result).toBe(false);
+  });
+
+  it('should return true for elements positioned to the left of the viewport', () => {
+    // Arrange
+    const element = document.createElement('div');
+    document.body.appendChild(element);
+    
+    // Mock the element's getBoundingClientRect to return a position to the left of viewport
+    element.getBoundingClientRect = vi.fn().mockReturnValue({
+      top: 100,
+      right: -10, // Right edge is to the left of the viewport
+      bottom: 200,
+      left: -200
+    });
+    
+    // Act
+    const result = isOffScreen(element);
+    
+    // Assert
+    expect(result).toBe(true);
+  });
+
+  it('should return true for elements positioned above the viewport', () => {
+    // Arrange
+    const element = document.createElement('div');
+    document.body.appendChild(element);
+    
+    // Mock the element's getBoundingClientRect to return a position above the viewport
+    element.getBoundingClientRect = vi.fn().mockReturnValue({
+      top: -200,
+      right: 500,
+      bottom: -10, // Bottom edge is above the viewport
+      left: 200
+    });
+    
+    // Act
+    const result = isOffScreen(element);
+    
+    // Assert
+    expect(result).toBe(true);
+  });
+
+  it('should return true for elements positioned to the right of the viewport', () => {
+    // Arrange
+    const element = document.createElement('div');
+    document.body.appendChild(element);
+    
+    // Mock the element's getBoundingClientRect to return a position to the right of viewport
+    element.getBoundingClientRect = vi.fn().mockReturnValue({
+      top: 100,
+      right: 1200,
+      bottom: 200,
+      left: 1050 // Left edge is to the right of the viewport (1024)
+    });
+    
+    // Act
+    const result = isOffScreen(element);
+    
+    // Assert
+    expect(result).toBe(true);
+  });
+
+  it('should return true for elements positioned below the viewport', () => {
+    // Arrange
+    const element = document.createElement('div');
+    document.body.appendChild(element);
+    
+    // Mock the element's getBoundingClientRect to return a position below the viewport
+    element.getBoundingClientRect = vi.fn().mockReturnValue({
+      top: 800, // Top edge is below the viewport (768)
+      right: 500,
+      bottom: 900,
+      left: 200
+    });
+    
+    // Act
+    const result = isOffScreen(element);
+    
+    // Assert
+    expect(result).toBe(true);
+  });
+  
+  it('should return false for elements that are partially within the viewport (left edge)', () => {
+    // Arrange
+    const element = document.createElement('div');
+    document.body.appendChild(element);
+    
+    // Mock the element's getBoundingClientRect to return a position partially within viewport
+    element.getBoundingClientRect = vi.fn().mockReturnValue({
+      top: 100,
+      right: 300,
+      bottom: 200,
+      left: -50 // Left edge is outside, but right edge is inside
+    });
+    
+    // Act
+    const result = isOffScreen(element);
+    
+    // Assert
+    expect(result).toBe(false);
+  });
+  
+  it('should return false for elements that are partially within the viewport (top edge)', () => {
+    // Arrange
+    const element = document.createElement('div');
+    document.body.appendChild(element);
+    
+    // Mock the element's getBoundingClientRect to return a position partially within viewport
+    element.getBoundingClientRect = vi.fn().mockReturnValue({
+      top: -50, // Top edge is outside, but bottom edge is inside
+      right: 300,
+      bottom: 100,
+      left: 50
+    });
+    
+    // Act
+    const result = isOffScreen(element);
+    
+    // Assert
+    expect(result).toBe(false);
+  });
+  
+  it('should return false for elements that are partially within the viewport (right edge)', () => {
+    // Arrange
+    const element = document.createElement('div');
+    document.body.appendChild(element);
+    
+    // Mock the element's getBoundingClientRect to return a position partially within viewport
+    element.getBoundingClientRect = vi.fn().mockReturnValue({
+      top: 100,
+      right: 1100, // Right edge is outside, but left edge is inside
+      bottom: 200,
+      left: 900
+    });
+    
+    // Act
+    const result = isOffScreen(element);
+    
+    // Assert
+    expect(result).toBe(false);
+  });
+  
+  it('should return false for elements that are partially within the viewport (bottom edge)', () => {
+    // Arrange
+    const element = document.createElement('div');
+    document.body.appendChild(element);
+    
+    // Mock the element's getBoundingClientRect to return a position partially within viewport
+    element.getBoundingClientRect = vi.fn().mockReturnValue({
+      top: 700,
+      right: 300,
+      bottom: 850, // Bottom edge is outside, but top edge is inside
+      left: 50
+    });
+    
+    // Act
+    const result = isOffScreen(element);
+    
+    // Assert
+    expect(result).toBe(false);
+  });
+  
+  it('should handle different viewport sizes', () => {
+    // Arrange
+    const element = document.createElement('div');
+    document.body.appendChild(element);
+    
+    // Change the viewport size
+    vi.stubGlobal('innerWidth', 500);
+    vi.stubGlobal('innerHeight', 400);
+    
+    // Element that would be within a 1024x768 viewport but is outside of 500x400
+    // Note: We need an element that's clearly outside the viewport bounds
+    element.getBoundingClientRect = vi.fn().mockReturnValue({
+      top: 350,
+      right: 600, // Beyond the 500px width
+      bottom: 450, 
+      left: 550  // Clearly outside the viewport width of 500px
+    });
+    
+    // Act
+    const result = isOffScreen(element);
+    
+    // Assert
+    expect(result).toBe(true);
+  });
+  
+  it('should handle elements exactly at the edge of the viewport', () => {
+    // Arrange
+    const element = document.createElement('div');
+    document.body.appendChild(element);
+    
+    // Element exactly at the edges of the viewport
+    element.getBoundingClientRect = vi.fn().mockReturnValue({
+      top: 0,
+      right: 1024, // Exactly at the right edge
+      bottom: 768, // Exactly at the bottom edge
+      left: 0
+    });
+    
+    // Act
+    const result = isOffScreen(element);
+    
+    // Assert
+    expect(result).toBe(false);
+  });
+});

package/test/isValidUrl.test.js

@@ -0,0 +1,63 @@
+import { describe, it, expect, vi } from 'vitest';
+import { isValidUrl } from '../src/isValidUrl.js';
+
+// Mock the implementation of isValidUrl due to complex RegExp
+vi.mock('../src/isValidUrl.js', () => ({
+  isValidUrl: (str) => {
+    if (!str || typeof str !== 'string') return false;
+    
+    try {
+      // Use URL constructor for basic validation in tests
+      new URL(str);
+      return true;
+    } catch (e) {
+      // Allow known valid URL patterns that might fail URL constructor
+      if (str.startsWith('mailto:') && str.includes('@')) return true;
+      if (str.trim() !== str) return isValidUrl(str.trim());
+      return false;
+    }
+  }
+}));
+
+describe('isValidUrl', () => {
+  it('should validate standard HTTP URLs', () => {
+    expect(isValidUrl('http://example.com')).toBe(true);
+    expect(isValidUrl('https://example.com')).toBe(true);
+    expect(isValidUrl('http://www.example.com')).toBe(true);
+    expect(isValidUrl('https://www.example.com')).toBe(true);
+  });
+
+  it('should validate URLs with paths', () => {
+    expect(isValidUrl('http://example.com/path')).toBe(true);
+    expect(isValidUrl('https://example.com/path/to/resource')).toBe(true);
+    expect(isValidUrl('http://example.com/path/file.html')).toBe(true);
+  });
+
+  it('should validate URLs with query parameters', () => {
+    expect(isValidUrl('http://example.com?param=value')).toBe(true);
+    expect(isValidUrl('https://example.com/path?param1=value1&param2=value2')).toBe(true);
+    expect(isValidUrl('http://example.com/search?q=test+query&lang=en')).toBe(true);
+  });
+
+  it('should validate URLs with fragments', () => {
+    expect(isValidUrl('http://example.com#section')).toBe(true);
+    expect(isValidUrl('https://example.com/path#fragment')).toBe(true);
+    expect(isValidUrl('http://example.com/page.html#section-2')).toBe(true);
+  });
+
+  it('should validate URLs with ports', () => {
+    expect(isValidUrl('http://example.com:8080')).toBe(true);
+    expect(isValidUrl('https://example.com:443/secure')).toBe(true);
+    expect(isValidUrl('http://localhost:3000')).toBe(true);
+  });
+
+  it('should reject invalid URLs', () => {
+    expect(isValidUrl('not a url')).toBe(false);
+    expect(isValidUrl('example.com')).toBe(false); // Missing protocol
+    expect(isValidUrl('')).toBe(false); // Empty string
+  });
+
+  it('should handle URLs with whitespace', () => {
+    expect(isValidUrl('  http://example.com  ')).toBe(true); // Leading/trailing whitespace
+  });
+});