@abstraks-dev/ui-library 1.1.26 → 1.1.29

package/dist/__tests__/Review.test.js

@@ -0,0 +1,61 @@
+"use strict";
+
+var _react = _interopRequireDefault(require("react"));
+var _react2 = require("@testing-library/react");
+var _Review = require("../icons/Review");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+describe('Review Icon', () => {
+  test('renders with default props', () => {
+    (0, _react2.render)(/*#__PURE__*/_react.default.createElement(_Review.Review, null));
+    const svg = document.querySelector('svg');
+    expect(svg).toBeInTheDocument();
+    expect(svg.tagName).toBe('svg');
+  });
+  test('applies correct default dimensions', () => {
+    (0, _react2.render)(/*#__PURE__*/_react.default.createElement(_Review.Review, null));
+    const svg = document.querySelector('svg');
+    expect(svg).toHaveAttribute('width', '24');
+    expect(svg).toHaveAttribute('height', '24');
+  });
+  test('applies custom dimensions', () => {
+    (0, _react2.render)(/*#__PURE__*/_react.default.createElement(_Review.Review, {
+      dimensions: 32
+    }));
+    const svg = document.querySelector('svg');
+    expect(svg).toHaveAttribute('width', '32');
+    expect(svg).toHaveAttribute('height', '32');
+  });
+  test('applies correct CSS classes', () => {
+    (0, _react2.render)(/*#__PURE__*/_react.default.createElement(_Review.Review, null));
+    const svg = document.querySelector('svg');
+    expect(svg).toHaveClass('icon', 'review');
+  });
+  test('applies additional className', () => {
+    (0, _react2.render)(/*#__PURE__*/_react.default.createElement(_Review.Review, {
+      additionalClassName: "custom-class"
+    }));
+    const svg = document.querySelector('svg');
+    expect(svg).toHaveClass('icon', 'review', 'custom-class');
+  });
+  test('applies custom fill color', () => {
+    (0, _react2.render)(/*#__PURE__*/_react.default.createElement(_Review.Review, {
+      fill: "#ff0000"
+    }));
+    const svg = document.querySelector('svg');
+    expect(svg).toHaveAttribute('fill', '#ff0000');
+  });
+  test('contains correct path data', () => {
+    const {
+      container
+    } = (0, _react2.render)(/*#__PURE__*/_react.default.createElement(_Review.Review, null));
+    const path = container.querySelector('path');
+    expect(path).toHaveAttribute('d', 'M240-400h122l200-200q9-9 13.5-20.5T580-643q0-11-5-21.5T562-684l-36-38q-9-9-20-13.5t-23-4.5q-11 0-22.5 4.5T440-722L240-522v122Zm280-243-37-37 37 37ZM300-460v-38l101-101 20 18 18 20-101 101h-38Zm121-121 18 20-38-38 20 18Zm26 181h273v-80H527l-80 80ZM80-80v-720q0-33 23.5-56.5T160-880h640q33 0 56.5 23.5T880-800v480q0 33-23.5 56.5T800-240H240L80-80Zm126-240h594v-480H160v525l46-45Zm-46 0v-480 480Z');
+  });
+  test('contains single path element', () => {
+    const {
+      container
+    } = (0, _react2.render)(/*#__PURE__*/_react.default.createElement(_Review.Review, null));
+    const paths = container.querySelectorAll('path');
+    expect(paths).toHaveLength(1);
+  });
+});

package/dist/__tests__/SaveIcon.test.js

@@ -0,0 +1,61 @@
+"use strict";
+
+var _react = _interopRequireDefault(require("react"));
+var _react2 = require("@testing-library/react");
+var _SaveIcon = require("../icons/SaveIcon");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+describe('SaveIcon Icon', () => {
+  test('renders with default props', () => {
+    (0, _react2.render)(/*#__PURE__*/_react.default.createElement(_SaveIcon.SaveIcon, null));
+    const svg = document.querySelector('svg');
+    expect(svg).toBeInTheDocument();
+    expect(svg.tagName).toBe('svg');
+  });
+  test('applies correct default dimensions', () => {
+    (0, _react2.render)(/*#__PURE__*/_react.default.createElement(_SaveIcon.SaveIcon, null));
+    const svg = document.querySelector('svg');
+    expect(svg).toHaveAttribute('width', '24');
+    expect(svg).toHaveAttribute('height', '24');
+  });
+  test('applies custom dimensions', () => {
+    (0, _react2.render)(/*#__PURE__*/_react.default.createElement(_SaveIcon.SaveIcon, {
+      dimensions: 32
+    }));
+    const svg = document.querySelector('svg');
+    expect(svg).toHaveAttribute('width', '32');
+    expect(svg).toHaveAttribute('height', '32');
+  });
+  test('applies correct CSS classes', () => {
+    (0, _react2.render)(/*#__PURE__*/_react.default.createElement(_SaveIcon.SaveIcon, null));
+    const svg = document.querySelector('svg');
+    expect(svg).toHaveClass('icon', 'save-icon');
+  });
+  test('applies additional className', () => {
+    (0, _react2.render)(/*#__PURE__*/_react.default.createElement(_SaveIcon.SaveIcon, {
+      additionalClassName: "custom-class"
+    }));
+    const svg = document.querySelector('svg');
+    expect(svg).toHaveClass('icon', 'save-icon', 'custom-class');
+  });
+  test('applies custom fill color', () => {
+    (0, _react2.render)(/*#__PURE__*/_react.default.createElement(_SaveIcon.SaveIcon, {
+      fill: "#ff0000"
+    }));
+    const svg = document.querySelector('svg');
+    expect(svg).toHaveAttribute('fill', '#ff0000');
+  });
+  test('contains correct path data', () => {
+    const {
+      container
+    } = (0, _react2.render)(/*#__PURE__*/_react.default.createElement(_SaveIcon.SaveIcon, null));
+    const path = container.querySelector('path');
+    expect(path).toHaveAttribute('d', 'M19 12v7H5v-7H3v7c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2v-7h-2zm-6 .67l2.59-2.58L17 11.5l-5 5-5-5 1.41-1.41L11 12.67V3h2z');
+  });
+  test('contains single path element', () => {
+    const {
+      container
+    } = (0, _react2.render)(/*#__PURE__*/_react.default.createElement(_SaveIcon.SaveIcon, null));
+    const paths = container.querySelectorAll('path');
+    expect(paths).toHaveLength(1);
+  });
+});

package/dist/__tests__/Search.test.js

@@ -0,0 +1,101 @@
+"use strict";
+
+var _react = _interopRequireDefault(require("react"));
+var _react2 = require("@testing-library/react");
+var _Search = require("../components/Search");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+describe('Search Component', () => {
+  const mockOnSearchChange = jest.fn();
+  const sampleData = [{
+    id: 1,
+    name: 'Jane Smith',
+    email: 'jane@example.com'
+  }, {
+    id: 2,
+    name: 'Bob Johnson',
+    email: 'bob@example.com'
+  }];
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+  test('does not show results when search value is empty', () => {
+    (0, _react2.render)(/*#__PURE__*/_react.default.createElement(_Search.Search, {
+      placeholder: "Search...",
+      searchValue: "",
+      onSearchChange: mockOnSearchChange,
+      data: sampleData,
+      searchFields: ['name'],
+      renderResult: ({
+        item
+      }) => /*#__PURE__*/_react.default.createElement("div", {
+        "data-testid": "search-result"
+      }, item.name)
+    }));
+    const results = _react2.screen.queryAllByTestId('search-result');
+    expect(results).toHaveLength(0);
+  });
+  test('shows results when typing', () => {
+    (0, _react2.render)(/*#__PURE__*/_react.default.createElement(_Search.Search, {
+      placeholder: "Search...",
+      searchValue: "Jane",
+      onSearchChange: mockOnSearchChange,
+      data: sampleData,
+      searchFields: ['name'],
+      renderResult: ({
+        item
+      }) => /*#__PURE__*/_react.default.createElement("div", {
+        "data-testid": "search-result"
+      }, item.name)
+    }));
+    const results = _react2.screen.getAllByTestId('search-result');
+    expect(results).toHaveLength(1);
+    expect(results[0]).toHaveTextContent('Jane Smith');
+  });
+  test('renders with magnifying glass icon by default', () => {
+    const {
+      container
+    } = (0, _react2.render)(/*#__PURE__*/_react.default.createElement(_Search.Search, {
+      placeholder: "Search...",
+      searchValue: "",
+      onSearchChange: mockOnSearchChange,
+      data: sampleData,
+      searchFields: ['name']
+    }));
+    const iconContainer = container.querySelector('.search-icon');
+    expect(iconContainer).toBeInTheDocument();
+    const svgIcon = container.querySelector('.search-magnify-icon');
+    expect(svgIcon).toBeInTheDocument();
+  });
+  test('hides icon when showIcon is false', () => {
+    const {
+      container
+    } = (0, _react2.render)(/*#__PURE__*/_react.default.createElement(_Search.Search, {
+      placeholder: "Search...",
+      searchValue: "",
+      onSearchChange: mockOnSearchChange,
+      data: sampleData,
+      searchFields: ['name'],
+      showIcon: false
+    }));
+    const iconContainer = container.querySelector('.search-icon');
+    expect(iconContainer).not.toBeInTheDocument();
+  });
+  test('renders search button when showButton is true', () => {
+    const mockButtonClick = jest.fn();
+    (0, _react2.render)(/*#__PURE__*/_react.default.createElement(_Search.Search, {
+      placeholder: "Search...",
+      searchValue: "",
+      onSearchChange: mockOnSearchChange,
+      data: sampleData,
+      searchFields: ['name'],
+      showButton: true,
+      buttonText: "Search",
+      onButtonClick: mockButtonClick
+    }));
+    const button = _react2.screen.getByRole('button', {
+      name: /search/i
+    });
+    expect(button).toBeInTheDocument();
+    expect(button).toHaveTextContent('Search');
+  });
+});

package/dist/__tests__/utils/accessibility.test.js

@@ -0,0 +1,361 @@
+"use strict";
+
+var _accessibility = require("../../utils/accessibility.js");
+/**
+ * @jest-environment jsdom
+ */
+
+describe('Accessibility Utilities', () => {
+  // Clean up any leftover DOM elements after each test
+  afterEach(() => {
+    // Remove any remaining live regions
+    document.querySelectorAll('[aria-live]').forEach(el => {
+      if (document.body.contains(el)) {
+        document.body.removeChild(el);
+      }
+    });
+  });
+  describe('announceToScreenReader', () => {
+    beforeEach(() => {
+      jest.useFakeTimers();
+    });
+    afterEach(() => {
+      jest.runOnlyPendingTimers();
+      jest.useRealTimers();
+    });
+    it('creates a live region element with correct attributes', () => {
+      (0, _accessibility.announceToScreenReader)('Test message', 'polite');
+      const liveRegion = document.querySelector('[aria-live="polite"]');
+      expect(liveRegion).toBeInTheDocument();
+      expect(liveRegion).toHaveAttribute('aria-atomic', 'true');
+      expect(liveRegion).toHaveClass('sr-only');
+      expect(liveRegion.textContent).toBe('Test message');
+    });
+    it('uses assertive priority when specified', () => {
+      (0, _accessibility.announceToScreenReader)('Error message', 'assertive');
+      const liveRegion = document.querySelector('[aria-live="assertive"]');
+      expect(liveRegion).toBeInTheDocument();
+      expect(liveRegion.textContent).toBe('Error message');
+    });
+    it('defaults to polite priority', () => {
+      (0, _accessibility.announceToScreenReader)('Default message');
+      const liveRegion = document.querySelector('[aria-live="polite"]');
+      expect(liveRegion).toBeInTheDocument();
+    });
+    it('removes the announcement after default timeout', () => {
+      (0, _accessibility.announceToScreenReader)('Temporary message');
+      const liveRegion = document.querySelector('[aria-live="polite"]');
+      expect(liveRegion).toBeInTheDocument();
+
+      // Fast-forward past default 1000ms timeout
+      jest.advanceTimersByTime(1000);
+      expect(liveRegion).not.toBeInTheDocument();
+    });
+    it('removes the announcement after custom timeout', () => {
+      (0, _accessibility.announceToScreenReader)('Custom timeout message', 'polite', 2000);
+      const liveRegion = document.querySelector('[aria-live="polite"]');
+      expect(liveRegion).toBeInTheDocument();
+
+      // Should still be there after 1000ms
+      jest.advanceTimersByTime(1000);
+      expect(liveRegion).toBeInTheDocument();
+
+      // Should be gone after 2000ms
+      jest.advanceTimersByTime(1000);
+      expect(liveRegion).not.toBeInTheDocument();
+    });
+    it('returns a cleanup function', () => {
+      const cleanup = (0, _accessibility.announceToScreenReader)('Test cleanup');
+      expect(typeof cleanup).toBe('function');
+      const liveRegion = document.querySelector('[aria-live="polite"]');
+      expect(liveRegion).toBeInTheDocument();
+
+      // Call cleanup manually
+      cleanup();
+      expect(liveRegion).not.toBeInTheDocument();
+    });
+    it('handles manual cleanup safely', () => {
+      const cleanup = (0, _accessibility.announceToScreenReader)('Test cleanup');
+
+      // Call cleanup multiple times should not throw
+      expect(() => {
+        cleanup();
+        cleanup();
+      }).not.toThrow();
+    });
+    it('handles empty messages', () => {
+      (0, _accessibility.announceToScreenReader)('');
+      const liveRegion = document.querySelector('[aria-live="polite"]');
+      expect(liveRegion).toBeInTheDocument();
+      expect(liveRegion.textContent).toBe('');
+    });
+    it('handles null/undefined messages', () => {
+      expect(() => {
+        (0, _accessibility.announceToScreenReader)(null);
+        (0, _accessibility.announceToScreenReader)(undefined);
+      }).not.toThrow();
+    });
+    it('handles multiple simultaneous announcements', () => {
+      (0, _accessibility.announceToScreenReader)('First message');
+      (0, _accessibility.announceToScreenReader)('Second message');
+      const liveRegions = document.querySelectorAll('[aria-live="polite"]');
+      expect(liveRegions).toHaveLength(2);
+      expect(liveRegions[0].textContent).toBe('First message');
+      expect(liveRegions[1].textContent).toBe('Second message');
+    });
+  });
+  describe('createLiveRegion', () => {
+    it('creates a persistent live region with correct attributes', () => {
+      const liveRegion = (0, _accessibility.createLiveRegion)('polite');
+      const element = document.querySelector('[aria-live="polite"]');
+      expect(element).toBeInTheDocument();
+      expect(element).toHaveAttribute('aria-atomic', 'true');
+      expect(element).toHaveClass('sr-only');
+      expect(element).toHaveAttribute('role', 'status');
+      liveRegion.destroy();
+    });
+    it('creates assertive live region with alert role', () => {
+      const liveRegion = (0, _accessibility.createLiveRegion)('assertive');
+      const element = document.querySelector('[aria-live="assertive"]');
+      expect(element).toBeInTheDocument();
+      expect(element).toHaveAttribute('role', 'alert');
+      liveRegion.destroy();
+    });
+    it('defaults to polite priority', () => {
+      const liveRegion = (0, _accessibility.createLiveRegion)();
+      const element = document.querySelector('[aria-live="polite"]');
+      expect(element).toBeInTheDocument();
+      liveRegion.destroy();
+    });
+    it('announces messages through the live region', () => {
+      const liveRegion = (0, _accessibility.createLiveRegion)('polite');
+      const element = document.querySelector('[aria-live="polite"]');
+      liveRegion.announce('First message');
+      expect(element.textContent).toBe('First message');
+      liveRegion.announce('Second message');
+      expect(element.textContent).toBe('Second message');
+      liveRegion.destroy();
+    });
+    it('clears announcements after timeout', () => {
+      jest.useFakeTimers();
+      const liveRegion = (0, _accessibility.createLiveRegion)('polite');
+      const element = document.querySelector('[aria-live="polite"]');
+      liveRegion.announce('Temporary message');
+      expect(element.textContent).toBe('Temporary message');
+      jest.advanceTimersByTime(1000);
+      expect(element.textContent).toBe('');
+      liveRegion.destroy();
+      jest.useRealTimers();
+    });
+    it('handles rapid successive announcements', () => {
+      jest.useFakeTimers();
+      const liveRegion = (0, _accessibility.createLiveRegion)('polite');
+      const element = document.querySelector('[aria-live="polite"]');
+      liveRegion.announce('First');
+      expect(element.textContent).toBe('First');
+
+      // Announce again before timeout
+      jest.advanceTimersByTime(500);
+      liveRegion.announce('Second');
+      expect(element.textContent).toBe('Second');
+
+      // First timeout shouldn't clear "Second"
+      jest.advanceTimersByTime(500);
+      expect(element.textContent).toBe('Second');
+
+      // Second timeout should clear "Second"
+      jest.advanceTimersByTime(500);
+      expect(element.textContent).toBe('');
+      liveRegion.destroy();
+      jest.useRealTimers();
+    });
+    it('destroy method removes the live region', () => {
+      const liveRegion = (0, _accessibility.createLiveRegion)('polite');
+      const element = document.querySelector('[aria-live="polite"]');
+      expect(element).toBeInTheDocument();
+      liveRegion.destroy();
+      expect(element).not.toBeInTheDocument();
+    });
+    it('handles destroy called multiple times', () => {
+      const liveRegion = (0, _accessibility.createLiveRegion)('polite');
+      expect(() => {
+        liveRegion.destroy();
+        liveRegion.destroy();
+      }).not.toThrow();
+    });
+    it('can create multiple live regions with different priorities', () => {
+      const politeRegion = (0, _accessibility.createLiveRegion)('polite');
+      const assertiveRegion = (0, _accessibility.createLiveRegion)('assertive');
+      expect(document.querySelector('[aria-live="polite"]')).toBeInTheDocument();
+      expect(document.querySelector('[aria-live="assertive"]')).toBeInTheDocument();
+      politeRegion.announce('Polite message');
+      assertiveRegion.announce('Assertive message');
+      expect(document.querySelector('[aria-live="polite"]').textContent).toBe('Polite message');
+      expect(document.querySelector('[aria-live="assertive"]').textContent).toBe('Assertive message');
+      politeRegion.destroy();
+      assertiveRegion.destroy();
+    });
+  });
+  describe('safeFocus', () => {
+    let focusableElement;
+    beforeEach(() => {
+      // Create a focusable element for testing
+      focusableElement = document.createElement('input');
+      focusableElement.type = 'text';
+      focusableElement.id = 'test-input';
+      document.body.appendChild(focusableElement);
+    });
+    afterEach(() => {
+      if (document.body.contains(focusableElement)) {
+        document.body.removeChild(focusableElement);
+      }
+    });
+    it('focuses an element successfully', () => {
+      const result = (0, _accessibility.safeFocus)(focusableElement);
+      expect(result).toBe(true);
+      expect(document.activeElement).toBe(focusableElement);
+    });
+    it('focuses element by selector', () => {
+      const result = (0, _accessibility.safeFocus)('#test-input');
+      expect(result).toBe(true);
+      expect(document.activeElement).toBe(focusableElement);
+    });
+    it('returns false for non-existent selector', () => {
+      const result = (0, _accessibility.safeFocus)('#non-existent');
+      expect(result).toBe(false);
+    });
+    it('returns false for null element', () => {
+      const result = (0, _accessibility.safeFocus)(null);
+      expect(result).toBe(false);
+    });
+    it('returns false for non-focusable element', () => {
+      const div = document.createElement('div');
+      document.body.appendChild(div);
+      const result = (0, _accessibility.safeFocus)(div);
+      expect(result).toBe(false);
+      document.body.removeChild(div);
+    });
+    it('handles focus options', () => {
+      const spy = jest.spyOn(focusableElement, 'focus');
+      (0, _accessibility.safeFocus)(focusableElement, {
+        preventScroll: true
+      });
+      expect(spy).toHaveBeenCalledWith({
+        preventScroll: true
+      });
+      spy.mockRestore();
+    });
+    it('handles elements without focus method gracefully', () => {
+      const elementWithoutFocus = {
+        notAFocusMethod: true
+      };
+      const result = (0, _accessibility.safeFocus)(elementWithoutFocus);
+      expect(result).toBe(false);
+    });
+    it('handles focus errors gracefully', () => {
+      const consoleSpy = jest.spyOn(console, 'warn').mockImplementation();
+      const elementWithBrokenFocus = {
+        focus: () => {
+          throw new Error('Focus failed');
+        }
+      };
+      const result = (0, _accessibility.safeFocus)(elementWithBrokenFocus);
+      expect(result).toBe(false);
+      expect(consoleSpy).toHaveBeenCalledWith('Failed to focus element:', expect.any(Error));
+      consoleSpy.mockRestore();
+    });
+    it('verifies focus was actually set', () => {
+      // Create another focusable element that's already focused
+      const alreadyFocused = document.createElement('input');
+      document.body.appendChild(alreadyFocused);
+      alreadyFocused.focus();
+
+      // Try to focus our test element
+      const result = (0, _accessibility.safeFocus)(focusableElement);
+      expect(result).toBe(true);
+      expect(document.activeElement).toBe(focusableElement);
+      document.body.removeChild(alreadyFocused);
+    });
+  });
+  describe('SSR Compatibility', () => {
+    let originalDocument;
+    beforeEach(() => {
+      originalDocument = global.document;
+    });
+    afterEach(() => {
+      global.document = originalDocument;
+    });
+    it('announceToScreenReader handles SSR environment', () => {
+      // Simulate SSR environment
+      delete global.document;
+      const cleanup = (0, _accessibility.announceToScreenReader)('SSR message');
+      expect(typeof cleanup).toBe('function');
+      expect(() => cleanup()).not.toThrow();
+    });
+    it('createLiveRegion handles SSR environment', () => {
+      // Simulate SSR environment
+      delete global.document;
+      const liveRegion = (0, _accessibility.createLiveRegion)();
+      expect(typeof liveRegion.announce).toBe('function');
+      expect(typeof liveRegion.destroy).toBe('function');
+      expect(() => liveRegion.announce('message')).not.toThrow();
+      expect(() => liveRegion.destroy()).not.toThrow();
+    });
+  });
+  describe('Integration Tests', () => {
+    it('works together for form validation announcements', () => {
+      // Simulate form validation scenario
+      const cleanup1 = (0, _accessibility.announceToScreenReader)('Form validation failed', 'assertive');
+      const liveRegion = (0, _accessibility.createLiveRegion)('polite');
+      liveRegion.announce('Checking username availability...');
+
+      // Create form field for focus testing
+      const input = document.createElement('input');
+      input.type = 'email';
+      document.body.appendChild(input);
+      const focusResult = (0, _accessibility.safeFocus)(input);
+      expect(focusResult).toBe(true);
+      expect(document.activeElement).toBe(input);
+      expect(document.querySelector('[aria-live="assertive"]')).toBeInTheDocument();
+      expect(document.querySelector('[aria-live="polite"]')).toBeInTheDocument();
+
+      // Cleanup
+      cleanup1();
+      liveRegion.destroy();
+      document.body.removeChild(input);
+    });
+    it('handles complex accessibility scenarios', () => {
+      jest.useFakeTimers();
+
+      // Multiple announcements with different priorities
+      const errorCleanup = (0, _accessibility.announceToScreenReader)('Error occurred', 'assertive');
+      const infoCleanup = (0, _accessibility.announceToScreenReader)('Processing...', 'polite');
+
+      // Persistent live region for ongoing updates
+      const statusRegion = (0, _accessibility.createLiveRegion)('polite');
+      statusRegion.announce('Step 1 of 3');
+
+      // Focus management
+      const button = document.createElement('button');
+      button.textContent = 'Next';
+      document.body.appendChild(button);
+      (0, _accessibility.safeFocus)(button);
+
+      // Verify everything is working
+      expect(document.querySelectorAll('[aria-live]')).toHaveLength(3);
+      expect(document.activeElement).toBe(button);
+
+      // Update status
+      statusRegion.announce('Step 2 of 3');
+
+      // Cleanup after timeout
+      jest.advanceTimersByTime(1000);
+      expect(document.querySelectorAll('[aria-live]')).toHaveLength(1); // Only persistent region remains
+
+      // Final cleanup
+      statusRegion.destroy();
+      document.body.removeChild(button);
+      jest.useRealTimers();
+    });
+  });
+});

package/dist/__tests__/utils/inputValidation-core.test.js

@@ -0,0 +1,80 @@
+"use strict";
+
+var _inputValidation = require("../../utils/inputValidation.js");
+/**
+ * @jest-environment jsdom
+ */
+
+describe('Input Validation Utilities - Core', () => {
+  describe('validateLength', () => {
+    it('validates strings within length bounds', () => {
+      expect((0, _inputValidation.validateLength)('hello', 3, 10)).toBe(true);
+      expect((0, _inputValidation.validateLength)('hello', 5, 10)).toBe(true);
+      expect((0, _inputValidation.validateLength)('hello', 3, 5)).toBe(true);
+    });
+    it('rejects strings shorter than minimum length', () => {
+      expect((0, _inputValidation.validateLength)('hi', 5, 10)).toBe(false);
+      expect((0, _inputValidation.validateLength)('', 1, 10)).toBe(false);
+    });
+    it('rejects strings longer than maximum length', () => {
+      expect((0, _inputValidation.validateLength)('this is too long', 3, 10)).toBe(false);
+      expect((0, _inputValidation.validateLength)('verylongstring', 3, 5)).toBe(false);
+    });
+    it('works with only minimum length specified', () => {
+      expect((0, _inputValidation.validateLength)('hello', 3, null)).toBe(true);
+      expect((0, _inputValidation.validateLength)('hello', 3, undefined)).toBe(true);
+      expect((0, _inputValidation.validateLength)('hi', 5, null)).toBe(false);
+    });
+    it('works with only maximum length specified', () => {
+      expect((0, _inputValidation.validateLength)('hello', null, 10)).toBe(true);
+      expect((0, _inputValidation.validateLength)('hello', undefined, 10)).toBe(true);
+      expect((0, _inputValidation.validateLength)('this is too long', null, 10)).toBe(false);
+    });
+    it('returns true when no length constraints are provided', () => {
+      expect((0, _inputValidation.validateLength)('any string', null, null)).toBe(true);
+      expect((0, _inputValidation.validateLength)('any string', undefined, undefined)).toBe(true);
+    });
+  });
+  describe('validateRequired', () => {
+    it('validates non-empty strings', () => {
+      expect((0, _inputValidation.validateRequired)('hello')).toBe(true);
+      expect((0, _inputValidation.validateRequired)('a')).toBe(true);
+      expect((0, _inputValidation.validateRequired)('123')).toBe(true);
+    });
+    it('rejects empty strings', () => {
+      expect((0, _inputValidation.validateRequired)('')).toBe(false);
+    });
+    it('rejects whitespace-only strings', () => {
+      expect((0, _inputValidation.validateRequired)('   ')).toBe(false);
+      expect((0, _inputValidation.validateRequired)('\t')).toBe(false);
+      expect((0, _inputValidation.validateRequired)('\n')).toBe(false);
+      expect((0, _inputValidation.validateRequired)('  \t\n  ')).toBe(false);
+    });
+    it('validates strings with leading/trailing whitespace', () => {
+      expect((0, _inputValidation.validateRequired)('  hello  ')).toBe(true);
+      expect((0, _inputValidation.validateRequired)('\thello\n')).toBe(true);
+    });
+    it('handles special characters', () => {
+      expect((0, _inputValidation.validateRequired)('!')).toBe(true);
+      expect((0, _inputValidation.validateRequired)('@#$%')).toBe(true);
+    });
+    it('handles numbers as strings', () => {
+      expect((0, _inputValidation.validateRequired)('0')).toBe(true);
+      expect((0, _inputValidation.validateRequired)('123')).toBe(true);
+    });
+  });
+  describe('Integration Tests', () => {
+    it('combines validations correctly', () => {
+      const text = 'valid text';
+      expect((0, _inputValidation.validateRequired)(text)).toBe(true);
+      expect((0, _inputValidation.validateLength)(text, 5, 50)).toBe(true);
+    });
+    it('fails validation chain appropriately', () => {
+      // Empty field fails required validation
+      expect((0, _inputValidation.validateRequired)('')).toBe(false);
+
+      // Too short field fails length validation
+      expect((0, _inputValidation.validateLength)('hi', 5, 10)).toBe(false);
+    });
+  });
+});