@abstraks-dev/ui-library 1.1.26 → 1.1.28

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

@@ -0,0 +1,123 @@
+"use strict";
+
+var _validation = require("../../utils/validation.js");
+/**
+ * @jest-environment jsdom
+ */
+
+describe('Validation Utilities - Core Functions', () => {
+  describe('validateEmail', () => {
+    it('validates basic email addresses', () => {
+      expect((0, _validation.validateEmail)('user@example.com')).toBe(true);
+      expect((0, _validation.validateEmail)('test@domain.org')).toBe(true);
+    });
+    it('rejects invalid email addresses', () => {
+      expect((0, _validation.validateEmail)('invalid-email')).toBe(false);
+      expect((0, _validation.validateEmail)('@example.com')).toBe(false);
+      expect((0, _validation.validateEmail)('')).toBe(false);
+      expect((0, _validation.validateEmail)(null)).toBe(false);
+    });
+  });
+  describe('validatePhone', () => {
+    it('validates basic phone numbers', () => {
+      expect((0, _validation.validatePhone)('1234567890')).toBe(true);
+      expect((0, _validation.validatePhone)('+1234567890')).toBe(true);
+    });
+    it('rejects invalid phone numbers', () => {
+      expect((0, _validation.validatePhone)('abc')).toBe(false);
+      expect((0, _validation.validatePhone)('')).toBe(false);
+      expect((0, _validation.validatePhone)(null)).toBe(false);
+      expect((0, _validation.validatePhone)('0123456789')).toBe(false); // starts with 0
+    });
+  });
+  describe('validateUrl', () => {
+    it('validates basic URLs', () => {
+      expect((0, _validation.validateUrl)('https://example.com')).toBe(true);
+      expect((0, _validation.validateUrl)('http://example.com')).toBe(true);
+    });
+    it('rejects invalid URLs', () => {
+      expect((0, _validation.validateUrl)('example.com')).toBe(false);
+      expect((0, _validation.validateUrl)('invalid-url')).toBe(false);
+      expect((0, _validation.validateUrl)('')).toBe(false);
+      expect((0, _validation.validateUrl)(null)).toBe(false);
+    });
+  });
+  describe('validatePasswordStrength', () => {
+    it('validates strong passwords', () => {
+      // Test with known good pattern
+      expect((0, _validation.validatePasswordStrength)('Password123!')).toBe(true);
+    });
+    it('rejects weak passwords', () => {
+      expect((0, _validation.validatePasswordStrength)('password')).toBe(false);
+      expect((0, _validation.validatePasswordStrength)('123456')).toBe(false);
+      expect((0, _validation.validatePasswordStrength)('')).toBe(false);
+      expect((0, _validation.validatePasswordStrength)(null)).toBe(false);
+    });
+  });
+  describe('validateField', () => {
+    it('validates required fields', () => {
+      const rules = {
+        required: true
+      };
+      expect((0, _validation.validateField)('test', rules, 'username')).toBeNull();
+      expect((0, _validation.validateField)('', rules, 'username')).toBe('username is required');
+    });
+    it('validates email fields', () => {
+      const rules = {
+        email: true
+      };
+      expect((0, _validation.validateField)('user@example.com', rules, 'email')).toBeNull();
+      expect((0, _validation.validateField)('invalid-email', rules, 'email')).toBe('Please enter a valid email address');
+    });
+    it('validates minimum length', () => {
+      const rules = {
+        minLength: 5
+      };
+      expect((0, _validation.validateField)('hello', rules, 'username')).toBeNull();
+      expect((0, _validation.validateField)('hi', rules, 'username')).toBe('username must be at least 5 characters');
+    });
+    it('validates maximum length', () => {
+      const rules = {
+        maxLength: 10
+      };
+      expect((0, _validation.validateField)('hello', rules, 'username')).toBeNull();
+      expect((0, _validation.validateField)('this is too long', rules, 'username')).toBe('username must not exceed 10 characters');
+    });
+    it('handles multiple validation rules', () => {
+      const rules = {
+        required: true,
+        minLength: 3
+      };
+      expect((0, _validation.validateField)('', rules, 'field')).toBe('field is required');
+      expect((0, _validation.validateField)('ab', rules, 'field')).toBe('field must be at least 3 characters');
+      expect((0, _validation.validateField)('abc', rules, 'field')).toBeNull();
+    });
+  });
+  describe('VALIDATION_PATTERNS', () => {
+    it('contains expected patterns', () => {
+      expect(_validation.VALIDATION_PATTERNS).toHaveProperty('email');
+      expect(_validation.VALIDATION_PATTERNS).toHaveProperty('phone');
+      expect(_validation.VALIDATION_PATTERNS).toHaveProperty('url');
+      expect(_validation.VALIDATION_PATTERNS).toHaveProperty('strongPassword');
+    });
+    it('patterns are RegExp objects', () => {
+      Object.values(_validation.VALIDATION_PATTERNS).forEach(pattern => {
+        expect(pattern).toBeInstanceOf(RegExp);
+      });
+    });
+  });
+  describe('Error Handling', () => {
+    it('handles null and undefined inputs', () => {
+      expect((0, _validation.validateEmail)(null)).toBe(false);
+      expect((0, _validation.validatePhone)(undefined)).toBe(false);
+      expect((0, _validation.validateUrl)(null)).toBe(false);
+      expect((0, _validation.validatePasswordStrength)(undefined)).toBe(false);
+    });
+    it('handles non-string inputs', () => {
+      expect((0, _validation.validateEmail)(123)).toBe(false);
+      expect((0, _validation.validatePhone)({})).toBe(false);
+      expect((0, _validation.validateUrl)([])).toBe(false);
+      expect((0, _validation.validatePasswordStrength)(123)).toBe(false);
+    });
+  });
+});

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

@@ -0,0 +1,362 @@
+"use strict";
+
+var _validation = require("../../utils/validation.js");
+/**
+ * @jest-environment jsdom
+ */
+
+describe('Validation Utilities', () => {
+  describe('Email Validation', () => {
+    describe('validateEmail', () => {
+      it('validates basic email addresses', () => {
+        const validEmails = ['user@example.com', 'test.email@domain.co.uk', 'user+tag@subdomain.example.org', 'user_name@example-domain.com', '123@numbers.com'];
+        validEmails.forEach(email => {
+          expect((0, _validation.validateEmail)(email)).toBe(true);
+        });
+      });
+      it('rejects invalid email addresses', () => {
+        const invalidEmails = ['invalid-email', '@example.com', 'user@', 'user@.com', 'user@com', 'user@example.', 'user.example.com', 'user@ex ample.com', '', null, undefined, 123];
+        invalidEmails.forEach(email => {
+          expect((0, _validation.validateEmail)(email)).toBe(false);
+        });
+      });
+      it('handles strict mode validation', () => {
+        // Basic mode should pass these
+        const basicValidEmails = ['user@example.com', 'test@domain.org'];
+        basicValidEmails.forEach(email => {
+          expect((0, _validation.validateEmail)(email, false)).toBe(true);
+          expect((0, _validation.validateEmail)(email, true)).toBe(true);
+        });
+
+        // Edge cases that might differ between strict and basic
+        const edgeCaseEmails = ['user@sub.domain.com', 'test.email@example.co.uk'];
+        edgeCaseEmails.forEach(email => {
+          expect((0, _validation.validateEmail)(email, false)).toBe(true);
+          expect((0, _validation.validateEmail)(email, true)).toBe(true);
+        });
+      });
+      it('trims whitespace before validation', () => {
+        expect((0, _validation.validateEmail)('  user@example.com  ')).toBe(true);
+        expect((0, _validation.validateEmail)('\tuser@example.com\n')).toBe(true);
+      });
+      it('handles non-string inputs', () => {
+        expect((0, _validation.validateEmail)(null)).toBe(false);
+        expect((0, _validation.validateEmail)(undefined)).toBe(false);
+        expect((0, _validation.validateEmail)(123)).toBe(false);
+        expect((0, _validation.validateEmail)({})).toBe(false);
+        expect((0, _validation.validateEmail)([])).toBe(false);
+      });
+    });
+    describe('EMAIL_REGEX patterns', () => {
+      it('EMAIL_REGEX matches basic email format', () => {
+        expect(_validation.EMAIL_REGEX.test('user@example.com')).toBe(true);
+        expect(_validation.EMAIL_REGEX.test('invalid-email')).toBe(false);
+      });
+      it('EMAIL_REGEX_STRICT is more comprehensive', () => {
+        expect(_validation.EMAIL_REGEX_STRICT.test('user@example.com')).toBe(true);
+        expect(_validation.EMAIL_REGEX_STRICT.test('invalid-email')).toBe(false);
+      });
+    });
+  });
+  describe('Phone Validation', () => {
+    describe('validatePhone', () => {
+      it('validates basic phone numbers', () => {
+        const validPhones = ['+1234567890', '1234567890', '+12345678901234', '9876543210'];
+        validPhones.forEach(phone => {
+          expect((0, _validation.validatePhone)(phone)).toBe(true);
+        });
+      });
+      it('rejects invalid phone numbers', () => {
+        const invalidPhones = ['123',
+        // too short
+        'abc123', '++123456', '+',
+        // just plus
+        '0123456789',
+        // starts with 0
+        null, undefined, 123];
+        invalidPhones.forEach(phone => {
+          expect((0, _validation.validatePhone)(phone)).toBe(false);
+        });
+      });
+      it('strips formatting characters before validation', () => {
+        const formattedPhones = ['(123) 456-7890', '123-456-7890', '123 456 7890'];
+        formattedPhones.forEach(phone => {
+          // These will be stripped to '1234567890' which is valid
+          expect((0, _validation.validatePhone)(phone)).toBe(true);
+        });
+      });
+      it('handles non-string inputs', () => {
+        expect((0, _validation.validatePhone)(null)).toBe(false);
+        expect((0, _validation.validatePhone)(undefined)).toBe(false);
+        expect((0, _validation.validatePhone)(123456789)).toBe(false);
+        expect((0, _validation.validatePhone)({})).toBe(false);
+      });
+    });
+  });
+  describe('URL Validation', () => {
+    describe('validateUrl', () => {
+      it('validates valid URLs', () => {
+        const validUrls = ['https://example.com', 'http://example.com', 'https://www.example.com', 'http://subdomain.example.org', 'https://example.com/path', 'https://example.com/path?query=value', 'https://example.com/path#anchor', 'https://example.com:8080'];
+        validUrls.forEach(url => {
+          expect((0, _validation.validateUrl)(url)).toBe(true);
+        });
+      });
+      it('rejects invalid URLs', () => {
+        const invalidUrls = ['example.com', 'ftp://example.com', 'invalid-url', 'https://', 'http://', '', null, undefined, 123, 'javascript:alert(1)'];
+        invalidUrls.forEach(url => {
+          expect((0, _validation.validateUrl)(url)).toBe(false);
+        });
+      });
+      it('trims whitespace before validation', () => {
+        expect((0, _validation.validateUrl)('  https://example.com  ')).toBe(true);
+        expect((0, _validation.validateUrl)('\thttps://example.com\n')).toBe(true);
+      });
+      it('handles non-string inputs', () => {
+        expect((0, _validation.validateUrl)(null)).toBe(false);
+        expect((0, _validation.validateUrl)(undefined)).toBe(false);
+        expect((0, _validation.validateUrl)(123)).toBe(false);
+        expect((0, _validation.validateUrl)({})).toBe(false);
+      });
+    });
+  });
+  describe('Password Strength Validation', () => {
+    describe('validatePasswordStrength', () => {
+      it('validates strong passwords', () => {
+        const strongPasswords = ['Password123!', 'MyStr0ng@Pass', 'C0mplex#Password', 'Secure123$', 'Strong&Pass1'];
+        strongPasswords.forEach(password => {
+          expect((0, _validation.validatePasswordStrength)(password)).toBe(true);
+        });
+      });
+      it('rejects weak passwords', () => {
+        const weakPasswords = ['password',
+        // no uppercase, number, special char
+        'PASSWORD',
+        // no lowercase, number, special char
+        '12345678',
+        // no letters, special char
+        'Password',
+        // no number, special char
+        'Password123',
+        // no special char
+        'Pass1!',
+        // too short (6 chars)
+        '',
+        // empty
+        'Pass!' // too short, missing requirements
+        ];
+        weakPasswords.forEach(password => {
+          expect((0, _validation.validatePasswordStrength)(password)).toBe(false);
+        });
+      });
+      it('requires minimum 8 characters', () => {
+        expect((0, _validation.validatePasswordStrength)('Pass1!')).toBe(false); // 6 chars
+        expect((0, _validation.validatePasswordStrength)('Pass12!')).toBe(false); // 7 chars
+        expect((0, _validation.validatePasswordStrength)('Pass123!')).toBe(true); // 8 chars
+      });
+      it('requires uppercase letter', () => {
+        expect((0, _validation.validatePasswordStrength)('password123!')).toBe(false);
+        expect((0, _validation.validatePasswordStrength)('Password123!')).toBe(true);
+      });
+      it('requires lowercase letter', () => {
+        expect((0, _validation.validatePasswordStrength)('PASSWORD123!')).toBe(false);
+        expect((0, _validation.validatePasswordStrength)('Password123!')).toBe(true);
+      });
+      it('requires number', () => {
+        expect((0, _validation.validatePasswordStrength)('Password!')).toBe(false);
+        expect((0, _validation.validatePasswordStrength)('Password1!')).toBe(true);
+      });
+      it('requires special character', () => {
+        expect((0, _validation.validatePasswordStrength)('Password123')).toBe(false);
+        expect((0, _validation.validatePasswordStrength)('Password123!')).toBe(true);
+      });
+      it('handles non-string inputs', () => {
+        expect((0, _validation.validatePasswordStrength)(null)).toBe(false);
+        expect((0, _validation.validatePasswordStrength)(undefined)).toBe(false);
+        expect((0, _validation.validatePasswordStrength)(123)).toBe(false);
+        expect((0, _validation.validatePasswordStrength)({})).toBe(false);
+      });
+    });
+  });
+  describe('Generic Field Validation', () => {
+    describe('validateField', () => {
+      it('validates required fields', () => {
+        const rules = {
+          required: true
+        };
+        expect((0, _validation.validateField)('test', rules, 'username')).toBeNull();
+        expect((0, _validation.validateField)('', rules, 'username')).toBe('username is required');
+        expect((0, _validation.validateField)('   ', rules, 'username')).toBe('username is required');
+        expect((0, _validation.validateField)(null, rules, 'username')).toBe('username is required');
+        expect((0, _validation.validateField)(undefined, rules, 'username')).toBe('username is required');
+      });
+      it('skips validation for empty non-required fields', () => {
+        const rules = {
+          email: true,
+          minLength: 5
+        };
+        expect((0, _validation.validateField)('', rules, 'email')).toBeNull();
+        expect((0, _validation.validateField)('   ', rules, 'email')).toBeNull();
+      });
+      it('validates email fields', () => {
+        const rules = {
+          email: true
+        };
+        expect((0, _validation.validateField)('user@example.com', rules, 'email')).toBeNull();
+        expect((0, _validation.validateField)('invalid-email', rules, 'email')).toBe('Please enter a valid email address');
+      });
+      it('validates email fields with strict mode', () => {
+        const rules = {
+          email: true,
+          strict: true
+        };
+        expect((0, _validation.validateField)('user@example.com', rules, 'email')).toBeNull();
+        expect((0, _validation.validateField)('invalid-email', rules, 'email')).toBe('Please enter a valid email address');
+      });
+      it('validates phone fields', () => {
+        const rules = {
+          phone: true
+        };
+        expect((0, _validation.validateField)('1234567890', rules, 'phone')).toBeNull();
+        expect((0, _validation.validateField)('invalid-phone', rules, 'phone')).toBe('Please enter a valid phone number');
+      });
+      it('validates URL fields', () => {
+        const rules = {
+          url: true
+        };
+        expect((0, _validation.validateField)('https://example.com', rules, 'website')).toBeNull();
+        expect((0, _validation.validateField)('invalid-url', rules, 'website')).toBe('Please enter a valid URL');
+      });
+      it('validates password strength', () => {
+        const rules = {
+          strongPassword: true
+        };
+        expect((0, _validation.validateField)('Password123!', rules, 'password')).toBeNull();
+        expect((0, _validation.validateField)('weak', rules, 'password')).toBe('Password must contain at least 8 characters with uppercase, lowercase, number, and special character');
+      });
+      it('validates minimum length', () => {
+        const rules = {
+          minLength: 5
+        };
+        expect((0, _validation.validateField)('hello', rules, 'username')).toBeNull();
+        expect((0, _validation.validateField)('hi', rules, 'username')).toBe('username must be at least 5 characters');
+      });
+      it('validates maximum length', () => {
+        const rules = {
+          maxLength: 10
+        };
+        expect((0, _validation.validateField)('hello', rules, 'username')).toBeNull();
+        expect((0, _validation.validateField)('this is too long', rules, 'username')).toBe('username must not exceed 10 characters');
+      });
+      it('validates pattern matching', () => {
+        const rules = {
+          pattern: /^[a-zA-Z]+$/
+        };
+        expect((0, _validation.validateField)('hello', rules, 'name')).toBeNull();
+        expect((0, _validation.validateField)('hello123', rules, 'name')).toBe('name format is invalid');
+      });
+      it('validates pattern with custom message', () => {
+        const rules = {
+          pattern: /^[a-zA-Z]+$/,
+          patternMessage: 'Only letters allowed'
+        };
+        expect((0, _validation.validateField)('hello123', rules, 'name')).toBe('Only letters allowed');
+      });
+      it('validates multiple rules in correct order', () => {
+        const rules = {
+          required: true,
+          email: true,
+          minLength: 10
+        };
+
+        // Required takes precedence
+        expect((0, _validation.validateField)('', rules, 'email')).toBe('email is required');
+
+        // Email validation before length
+        expect((0, _validation.validateField)('invalid', rules, 'email')).toBe('Please enter a valid email address');
+
+        // Length validation after email
+        expect((0, _validation.validateField)('a@b.co', rules, 'email')).toBe('email must be at least 10 characters');
+
+        // Valid email with sufficient length
+        expect((0, _validation.validateField)('user@example.com', rules, 'email')).toBeNull();
+      });
+      it('returns null for no rules', () => {
+        expect((0, _validation.validateField)('anything', null, 'field')).toBeNull();
+        expect((0, _validation.validateField)('anything', undefined, 'field')).toBeNull();
+        expect((0, _validation.validateField)('anything', {}, 'field')).toBeNull();
+      });
+      it('combines required with other validations correctly', () => {
+        const rules = {
+          required: true,
+          minLength: 3
+        };
+        expect((0, _validation.validateField)('', rules, 'field')).toBe('field is required');
+        expect((0, _validation.validateField)('ab', rules, 'field')).toBe('field must be at least 3 characters');
+        expect((0, _validation.validateField)('abc', rules, 'field')).toBeNull();
+      });
+    });
+  });
+  describe('VALIDATION_PATTERNS', () => {
+    it('contains expected patterns', () => {
+      expect(_validation.VALIDATION_PATTERNS).toHaveProperty('email');
+      expect(_validation.VALIDATION_PATTERNS).toHaveProperty('phone');
+      expect(_validation.VALIDATION_PATTERNS).toHaveProperty('url');
+      expect(_validation.VALIDATION_PATTERNS).toHaveProperty('postalCode');
+      expect(_validation.VALIDATION_PATTERNS).toHaveProperty('creditCard');
+      expect(_validation.VALIDATION_PATTERNS).toHaveProperty('strongPassword');
+    });
+    it('patterns are RegExp objects', () => {
+      Object.values(_validation.VALIDATION_PATTERNS).forEach(pattern => {
+        expect(pattern).toBeInstanceOf(RegExp);
+      });
+    });
+    it('postal code pattern works correctly', () => {
+      const validPostalCodes = ['12345', 'AB1 2CD', 'M5V 3L9', '90210-1234'];
+      const invalidPostalCodes = ['1', '12', '1234567890123', ''];
+      validPostalCodes.forEach(code => {
+        expect(_validation.VALIDATION_PATTERNS.postalCode.test(code)).toBe(true);
+      });
+      invalidPostalCodes.forEach(code => {
+        expect(_validation.VALIDATION_PATTERNS.postalCode.test(code)).toBe(false);
+      });
+    });
+    it('credit card pattern works correctly', () => {
+      const validCards = ['1234567890123456', '4111111111111111', '5555555555554444'];
+      const invalidCards = ['123456789012', '12345678901234567890', 'abcd1234567890123', ''];
+      validCards.forEach(card => {
+        expect(_validation.VALIDATION_PATTERNS.creditCard.test(card)).toBe(true);
+      });
+      invalidCards.forEach(card => {
+        expect(_validation.VALIDATION_PATTERNS.creditCard.test(card)).toBe(false);
+      });
+    });
+  });
+  describe('Edge Cases and Error Handling', () => {
+    it('handles empty string inputs consistently', () => {
+      expect((0, _validation.validateEmail)('')).toBe(false);
+      expect((0, _validation.validatePhone)('')).toBe(false);
+      expect((0, _validation.validateUrl)('')).toBe(false);
+      expect((0, _validation.validatePasswordStrength)('')).toBe(false);
+    });
+    it('handles whitespace-only inputs', () => {
+      expect((0, _validation.validateEmail)('   ')).toBe(false);
+      expect((0, _validation.validatePhone)('   ')).toBe(false);
+      expect((0, _validation.validateUrl)('   ')).toBe(false);
+      expect((0, _validation.validatePasswordStrength)('   ')).toBe(false);
+    });
+    it('handles very long inputs gracefully', () => {
+      const veryLongString = 'a'.repeat(10000);
+      expect(() => (0, _validation.validateEmail)(veryLongString)).not.toThrow();
+      expect(() => (0, _validation.validatePhone)(veryLongString)).not.toThrow();
+      expect(() => (0, _validation.validateUrl)(veryLongString)).not.toThrow();
+      expect(() => (0, _validation.validatePasswordStrength)(veryLongString)).not.toThrow();
+    });
+    it('handles special characters in inputs', () => {
+      const specialChars = '!@#$%^&*()_+-=[]{}|;:,.<>?';
+      expect(() => (0, _validation.validateEmail)(specialChars)).not.toThrow();
+      expect(() => (0, _validation.validatePhone)(specialChars)).not.toThrow();
+      expect(() => (0, _validation.validateUrl)(specialChars)).not.toThrow();
+      expect(() => (0, _validation.validatePasswordStrength)(specialChars)).not.toThrow();
+    });
+  });
+});

package/dist/components/Alert.js

@@ -0,0 +1,104 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.Alert = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _propTypes = require("prop-types");
+var _icons = require("../icons");
+var _ssrSafeId = require("../utils/ssrSafeId");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+/**
+ * Alert - A stateless, accessible alert component for displaying messages
+ *
+ * Features:
+ * - Multiple types (success, error, warning, info)
+ * - Dismissible with close button
+ * - Accessible with proper ARIA attributes
+ * - Icon support
+ * - Custom message content
+ * - Visibility control
+ *
+ * @component
+ * @example
+ * <Alert
+ *   type="success"
+ *   message="Operation completed successfully!"
+ *   isVisible={true}
+ *   onClose={() => setAlertVisible(false)}
+ *   isDismissible={true}
+ * />
+ */
+const Alert = exports.Alert = /*#__PURE__*/(0, _react.forwardRef)(({
+  // Core props
+  id,
+  className = '',
+  // Content props
+  type = 'info',
+  message,
+  children,
+  icon,
+  // Behavior props
+  isVisible = true,
+  isDismissible = true,
+  onClose,
+  // Accessibility props
+  ariaLabel,
+  role = 'alert',
+  // Additional props
+  ...rest
+}, ref) => {
+  const stableId = (0, _ssrSafeId.useStableId)(id);
+  if (!isVisible) {
+    return null;
+  }
+  const handleClose = () => {
+    if (onClose && typeof onClose === 'function') {
+      onClose();
+    }
+  };
+  const combinedClassName = ['ui-alert', `ui-alert--${type}`, isDismissible && 'ui-alert--dismissible', className].filter(Boolean).join(' ');
+  return /*#__PURE__*/_react.default.createElement("div", _extends({
+    ref: ref,
+    id: stableId,
+    className: combinedClassName,
+    role: role,
+    "aria-label": ariaLabel
+  }, rest), icon && /*#__PURE__*/_react.default.createElement("div", {
+    className: "ui-alert__icon"
+  }, icon), /*#__PURE__*/_react.default.createElement("div", {
+    className: "ui-alert__content"
+  }, message && /*#__PURE__*/_react.default.createElement("div", {
+    className: "ui-alert__message"
+  }, message), children && /*#__PURE__*/_react.default.createElement("div", {
+    className: "ui-alert__children"
+  }, children)), isDismissible && onClose && /*#__PURE__*/_react.default.createElement("button", {
+    className: "ui-alert__close",
+    onClick: handleClose,
+    "aria-label": "Close alert",
+    type: "button"
+  }, /*#__PURE__*/_react.default.createElement(_icons.Close, {
+    dimensions: 16
+  })));
+});
+Alert.displayName = 'Alert';
+Alert.propTypes = {
+  // Core props
+  id: _propTypes.string,
+  className: _propTypes.string,
+  // Content props
+  type: (0, _propTypes.oneOf)(['success', 'error', 'warning', 'info']),
+  message: _propTypes.node,
+  children: _propTypes.node,
+  icon: _propTypes.node,
+  // Behavior props
+  isVisible: _propTypes.bool,
+  isDismissible: _propTypes.bool,
+  onClose: _propTypes.func,
+  // Accessibility props
+  ariaLabel: _propTypes.string,
+  role: _propTypes.string
+};
+var _default = exports.default = Alert;