@tomgiee/tsdp 1.0.0

package/dist/tests/unit/utils/format-validators.test.js

@@ -0,0 +1,224 @@
+"use strict";
+/**
+ * Tests for format-validators.ts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const format_validators_1 = require("../../../src/utils/format-validators");
+describe('format-validators', () => {
+    describe('Email Format Validation', () => {
+        describe('isValidEmailFormat', () => {
+            it('should validate plain email addresses (addr-spec)', () => {
+                expect((0, format_validators_1.isValidEmailFormat)('user@example.com')).toBe(true);
+                expect((0, format_validators_1.isValidEmailFormat)('j.doe@example.com')).toBe(true);
+                expect((0, format_validators_1.isValidEmailFormat)('test@sub.domain.org')).toBe(true);
+                expect((0, format_validators_1.isValidEmailFormat)('user+tag@example.com')).toBe(true);
+            });
+            it('should validate email with comment format (address-and-comment)', () => {
+                expect((0, format_validators_1.isValidEmailFormat)('j.doe@example.com (Jane Doe)')).toBe(true);
+                expect((0, format_validators_1.isValidEmailFormat)('user@example.com (Display Name)')).toBe(true);
+                expect((0, format_validators_1.isValidEmailFormat)('test@example.org (Test User 123)')).toBe(true);
+            });
+            it('should validate display name with email format (dispname-and-address)', () => {
+                expect((0, format_validators_1.isValidEmailFormat)('Jane Doe <j.doe@example.com>')).toBe(true);
+                expect((0, format_validators_1.isValidEmailFormat)('John Smith <john@example.org>')).toBe(true);
+                expect((0, format_validators_1.isValidEmailFormat)('Display Name <user@domain.com>')).toBe(true);
+            });
+            it('should reject invalid email formats', () => {
+                expect((0, format_validators_1.isValidEmailFormat)('')).toBe(false);
+                expect((0, format_validators_1.isValidEmailFormat)('invalid')).toBe(false);
+                expect((0, format_validators_1.isValidEmailFormat)('invalid@')).toBe(false);
+                expect((0, format_validators_1.isValidEmailFormat)('@example.com')).toBe(false);
+                expect((0, format_validators_1.isValidEmailFormat)('user@@example.com')).toBe(false);
+            });
+            it('should reject malformed comment format', () => {
+                expect((0, format_validators_1.isValidEmailFormat)('user@example.com (')).toBe(false);
+                expect((0, format_validators_1.isValidEmailFormat)('user@example.com ()')).toBe(false);
+            });
+            it('should reject malformed display name format', () => {
+                expect((0, format_validators_1.isValidEmailFormat)('<user@example.com>')).toBe(false);
+                expect((0, format_validators_1.isValidEmailFormat)('Name <>')).toBe(false);
+            });
+            it('should handle RFC 8866 examples', () => {
+                // From RFC 8866 Section 5.6
+                expect((0, format_validators_1.isValidEmailFormat)('j.doe@example.com (Jane Doe)')).toBe(true);
+                expect((0, format_validators_1.isValidEmailFormat)('Jane Doe <j.doe@example.com>')).toBe(true);
+            });
+        });
+        describe('parseEmailComponents', () => {
+            it('should parse plain email address', () => {
+                const result = (0, format_validators_1.parseEmailComponents)('user@example.com');
+                expect(result).toEqual({ email: 'user@example.com' });
+            });
+            it('should parse email with comment', () => {
+                const result = (0, format_validators_1.parseEmailComponents)('j.doe@example.com (Jane Doe)');
+                expect(result).toEqual({
+                    email: 'j.doe@example.com',
+                    displayName: 'Jane Doe',
+                });
+            });
+            it('should parse display name with email', () => {
+                const result = (0, format_validators_1.parseEmailComponents)('Jane Doe <j.doe@example.com>');
+                expect(result).toEqual({
+                    email: 'j.doe@example.com',
+                    displayName: 'Jane Doe',
+                });
+            });
+            it('should return null for invalid format', () => {
+                expect((0, format_validators_1.parseEmailComponents)('')).toBe(null);
+                expect((0, format_validators_1.parseEmailComponents)('invalid')).toBe(null);
+            });
+        });
+    });
+    describe('Phone Format Validation', () => {
+        describe('isValidPhoneFormat', () => {
+            it('should validate plain phone numbers', () => {
+                expect((0, format_validators_1.isValidPhoneFormat)('+1 617 555-6011')).toBe(true);
+                expect((0, format_validators_1.isValidPhoneFormat)('+44 20 7946 0958')).toBe(true);
+                expect((0, format_validators_1.isValidPhoneFormat)('1-800-555-1234')).toBe(true);
+                expect((0, format_validators_1.isValidPhoneFormat)('5551234')).toBe(true);
+            });
+            it('should validate phone with optional plus', () => {
+                expect((0, format_validators_1.isValidPhoneFormat)('+1 555 1234')).toBe(true);
+                expect((0, format_validators_1.isValidPhoneFormat)('1 555 1234')).toBe(true);
+            });
+            it('should validate phone with comment format', () => {
+                expect((0, format_validators_1.isValidPhoneFormat)('+1 617 555-6011 (Jane Doe)')).toBe(true);
+                expect((0, format_validators_1.isValidPhoneFormat)('+1-555-1234 (Office)')).toBe(true);
+            });
+            it('should validate display name with phone format', () => {
+                expect((0, format_validators_1.isValidPhoneFormat)('Jane Doe <+1 617 555-6011>')).toBe(true);
+                expect((0, format_validators_1.isValidPhoneFormat)('Office <+1-800-555-1234>')).toBe(true);
+            });
+            it('should reject invalid phone formats', () => {
+                expect((0, format_validators_1.isValidPhoneFormat)('')).toBe(false);
+                expect((0, format_validators_1.isValidPhoneFormat)('abc')).toBe(false);
+                expect((0, format_validators_1.isValidPhoneFormat)('+')).toBe(false);
+                expect((0, format_validators_1.isValidPhoneFormat)('+abc')).toBe(false);
+            });
+            it('should reject phone with invalid characters', () => {
+                expect((0, format_validators_1.isValidPhoneFormat)('+1 (555) 123-4567')).toBe(false); // parentheses not allowed in phone
+                expect((0, format_validators_1.isValidPhoneFormat)('+1.555.1234')).toBe(false); // dots not allowed
+            });
+            it('should handle RFC 8866 example', () => {
+                // From RFC 8866 Section 5.6
+                expect((0, format_validators_1.isValidPhoneFormat)('+1 617 555-6011')).toBe(true);
+            });
+        });
+        describe('parsePhoneComponents', () => {
+            it('should parse plain phone number', () => {
+                const result = (0, format_validators_1.parsePhoneComponents)('+1 617 555-6011');
+                expect(result).toEqual({ phone: '+1 617 555-6011' });
+            });
+            it('should parse phone with comment', () => {
+                const result = (0, format_validators_1.parsePhoneComponents)('+1 617 555-6011 (Jane Doe)');
+                expect(result).toEqual({
+                    phone: '+1 617 555-6011',
+                    displayName: 'Jane Doe',
+                });
+            });
+            it('should parse display name with phone', () => {
+                const result = (0, format_validators_1.parsePhoneComponents)('Jane Doe <+1 617 555-6011>');
+                expect(result).toEqual({
+                    phone: '+1 617 555-6011',
+                    displayName: 'Jane Doe',
+                });
+            });
+            it('should return null for invalid format', () => {
+                expect((0, format_validators_1.parsePhoneComponents)('')).toBe(null);
+                expect((0, format_validators_1.parsePhoneComponents)('invalid')).toBe(null);
+            });
+        });
+    });
+    describe('URI Format Validation', () => {
+        describe('isValidURIReference', () => {
+            it('should validate absolute URIs with common schemes', () => {
+                expect((0, format_validators_1.isValidURIReference)('http://example.com')).toBe(true);
+                expect((0, format_validators_1.isValidURIReference)('https://example.com/path')).toBe(true);
+                expect((0, format_validators_1.isValidURIReference)('ftp://ftp.example.com/file.txt')).toBe(true);
+                expect((0, format_validators_1.isValidURIReference)('mailto:user@example.com')).toBe(true);
+            });
+            it('should validate URIs with query strings and fragments', () => {
+                expect((0, format_validators_1.isValidURIReference)('http://example.com?query=value')).toBe(true);
+                expect((0, format_validators_1.isValidURIReference)('https://example.com/path?a=1&b=2')).toBe(true);
+                expect((0, format_validators_1.isValidURIReference)('http://example.com#section')).toBe(true);
+                expect((0, format_validators_1.isValidURIReference)('https://example.com/path?query=1#fragment')).toBe(true);
+            });
+            it('should validate URIs with ports and authentication', () => {
+                expect((0, format_validators_1.isValidURIReference)('http://example.com:8080')).toBe(true);
+                expect((0, format_validators_1.isValidURIReference)('https://example.com:443/path')).toBe(true);
+                expect((0, format_validators_1.isValidURIReference)('http://user:pass@example.com')).toBe(true);
+                expect((0, format_validators_1.isValidURIReference)('http://user@example.com:8080/path')).toBe(true);
+            });
+            it('should validate relative references', () => {
+                expect((0, format_validators_1.isValidURIReference)('/path/to/resource')).toBe(true);
+                expect((0, format_validators_1.isValidURIReference)('/path?query=1')).toBe(true);
+                expect((0, format_validators_1.isValidURIReference)('path/to/file')).toBe(true);
+                expect((0, format_validators_1.isValidURIReference)('../parent/file')).toBe(true);
+                expect((0, format_validators_1.isValidURIReference)('./current/file')).toBe(true);
+            });
+            it('should validate URIs with percent-encoding', () => {
+                expect((0, format_validators_1.isValidURIReference)('http://example.com/path%20with%20spaces')).toBe(true);
+                expect((0, format_validators_1.isValidURIReference)('https://example.com/path?q=%E2%9C%93')).toBe(true);
+                expect((0, format_validators_1.isValidURIReference)('/path/%2F%2F')).toBe(true);
+            });
+            it('should validate URIs with IPv6 addresses', () => {
+                expect((0, format_validators_1.isValidURIReference)('http://[::1]/')).toBe(true);
+                expect((0, format_validators_1.isValidURIReference)('http://[2001:db8::1]:8080/path')).toBe(true);
+            });
+            it('should reject empty input', () => {
+                expect((0, format_validators_1.isValidURIReference)('')).toBe(false);
+                expect((0, format_validators_1.isValidURIReference)('   ')).toBe(false);
+            });
+            it('should reject URIs with spaces', () => {
+                expect((0, format_validators_1.isValidURIReference)('http://example.com/path with spaces')).toBe(false);
+                expect((0, format_validators_1.isValidURIReference)('http://example .com')).toBe(false);
+            });
+            it('should reject URIs with invalid characters', () => {
+                expect((0, format_validators_1.isValidURIReference)('http://example.com/<script>')).toBe(false);
+                expect((0, format_validators_1.isValidURIReference)('http://example.com/path"quoted"')).toBe(false);
+                expect((0, format_validators_1.isValidURIReference)('http://example.com/path\\backslash')).toBe(false);
+            });
+            it('should reject invalid percent-encoding', () => {
+                expect((0, format_validators_1.isValidURIReference)('http://example.com/%')).toBe(false);
+                expect((0, format_validators_1.isValidURIReference)('http://example.com/%2')).toBe(false);
+                expect((0, format_validators_1.isValidURIReference)('http://example.com/%GG')).toBe(false);
+                expect((0, format_validators_1.isValidURIReference)('http://example.com/%2Z')).toBe(false);
+            });
+            it('should reject invalid schemes', () => {
+                expect((0, format_validators_1.isValidURIReference)('1http://example.com')).toBe(false); // starts with digit
+                expect((0, format_validators_1.isValidURIReference)('-http://example.com')).toBe(false); // starts with hyphen
+            });
+            it('should handle RFC 8866 example URIs', () => {
+                // Common URIs in SDP
+                expect((0, format_validators_1.isValidURIReference)('http://www.example.com/session')).toBe(true);
+                expect((0, format_validators_1.isValidURIReference)('https://conference.example.org/meeting/12345')).toBe(true);
+            });
+        });
+        describe('parseURIComponents', () => {
+            it('should parse URI with scheme', () => {
+                const result = (0, format_validators_1.parseURIComponents)('http://example.com/path');
+                expect(result).toEqual({
+                    scheme: 'http',
+                    rest: '//example.com/path',
+                });
+            });
+            it('should parse relative reference', () => {
+                const result = (0, format_validators_1.parseURIComponents)('/path/to/resource');
+                expect(result).toEqual({
+                    rest: '/path/to/resource',
+                });
+            });
+            it('should parse https URI', () => {
+                const result = (0, format_validators_1.parseURIComponents)('https://example.com:8080/path?query=1');
+                expect(result).toEqual({
+                    scheme: 'https',
+                    rest: '//example.com:8080/path?query=1',
+                });
+            });
+            it('should return null for invalid URI', () => {
+                expect((0, format_validators_1.parseURIComponents)('')).toBe(null);
+                expect((0, format_validators_1.parseURIComponents)('http://example.com/path with space')).toBe(null);
+            });
+        });
+    });
+});

package/dist/tests/unit/utils/line-reader.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Tests for line-reader.ts
+ */
+export {};
+//# sourceMappingURL=line-reader.test.d.ts.map

package/dist/tests/unit/utils/line-reader.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"line-reader.test.d.ts","sourceRoot":"","sources":["../../../../tests/unit/utils/line-reader.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/tests/unit/utils/line-reader.test.js

@@ -0,0 +1,157 @@
+"use strict";
+/**
+ * Tests for line-reader.ts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const line_reader_1 = require("../../../src/utils/line-reader");
+describe('line-reader', () => {
+    describe('splitLines', () => {
+        it('should split lines with CRLF', () => {
+            const input = 'v=0\r\no=jdoe 123 456 IN IP4 192.168.1.1\r\ns=Test';
+            const lines = (0, line_reader_1.splitLines)(input);
+            expect(lines).toEqual(['v=0', 'o=jdoe 123 456 IN IP4 192.168.1.1', 's=Test']);
+        });
+        it('should split lines with LF only', () => {
+            const input = 'v=0\no=jdoe 123 456 IN IP4 192.168.1.1\ns=Test';
+            const lines = (0, line_reader_1.splitLines)(input);
+            expect(lines).toEqual(['v=0', 'o=jdoe 123 456 IN IP4 192.168.1.1', 's=Test']);
+        });
+        it('should split lines with CR only', () => {
+            const input = 'v=0\ro=jdoe 123 456 IN IP4 192.168.1.1\rs=Test';
+            const lines = (0, line_reader_1.splitLines)(input);
+            expect(lines).toEqual(['v=0', 'o=jdoe 123 456 IN IP4 192.168.1.1', 's=Test']);
+        });
+        it('should handle mixed line endings', () => {
+            const input = 'v=0\r\no=test\ns=name\rc=IN IP4 0.0.0.0';
+            const lines = (0, line_reader_1.splitLines)(input);
+            expect(lines).toEqual(['v=0', 'o=test', 's=name', 'c=IN IP4 0.0.0.0']);
+        });
+        it('should handle empty input', () => {
+            const lines = (0, line_reader_1.splitLines)('');
+            expect(lines).toEqual([]);
+        });
+        it('should handle input without trailing newline', () => {
+            const input = 'v=0\r\ns=Test';
+            const lines = (0, line_reader_1.splitLines)(input);
+            expect(lines).toEqual(['v=0', 's=Test']);
+        });
+    });
+    describe('parseLine', () => {
+        it('should parse valid SDP line', () => {
+            const result = (0, line_reader_1.parseLine)('v=0');
+            expect(result).toEqual({ type: 'v', value: '0' });
+        });
+        it('should parse line with value containing =', () => {
+            const result = (0, line_reader_1.parseLine)('a=rtpmap:0 PCMU/8000');
+            expect(result).toEqual({ type: 'a', value: 'rtpmap:0 PCMU/8000' });
+        });
+        it('should parse line with empty value', () => {
+            const result = (0, line_reader_1.parseLine)('i=');
+            expect(result).toEqual({ type: 'i', value: '' });
+        });
+        it('should return null for empty line', () => {
+            const result = (0, line_reader_1.parseLine)('');
+            expect(result).toBeNull();
+        });
+        it('should return null for line without =', () => {
+            const result = (0, line_reader_1.parseLine)('invalid');
+            expect(result).toBeNull();
+        });
+        it('should return null for line too short', () => {
+            const result = (0, line_reader_1.parseLine)('v');
+            expect(result).toBeNull();
+        });
+    });
+    describe('parseLines', () => {
+        it('should parse multiple SDP lines', () => {
+            const input = 'v=0\r\no=jdoe 123 456 IN IP4 192.168.1.1\r\ns=Test Session';
+            const parsed = (0, line_reader_1.parseLines)(input);
+            expect(parsed).toHaveLength(3);
+            expect(parsed[0]).toEqual({ type: 'v', value: '0', lineNumber: 1 });
+            expect(parsed[1]).toEqual({
+                type: 'o',
+                value: 'jdoe 123 456 IN IP4 192.168.1.1',
+                lineNumber: 2,
+            });
+            expect(parsed[2]).toEqual({ type: 's', value: 'Test Session', lineNumber: 3 });
+        });
+        it('should skip empty lines', () => {
+            const input = 'v=0\r\n\r\ns=Test';
+            const parsed = (0, line_reader_1.parseLines)(input);
+            expect(parsed).toHaveLength(2);
+            expect(parsed[0].type).toBe('v');
+            expect(parsed[1].type).toBe('s');
+        });
+        it('should skip invalid lines', () => {
+            const input = 'v=0\r\ninvalid line\r\ns=Test';
+            const parsed = (0, line_reader_1.parseLines)(input);
+            expect(parsed).toHaveLength(2);
+        });
+    });
+    describe('joinLines', () => {
+        it('should join lines with CRLF', () => {
+            const lines = ['v=0', 'o=jdoe 123 456 IN IP4 192.168.1.1', 's=Test'];
+            const result = (0, line_reader_1.joinLines)(lines);
+            expect(result).toBe('v=0\r\no=jdoe 123 456 IN IP4 192.168.1.1\r\ns=Test\r\n');
+        });
+        it('should handle empty array', () => {
+            const result = (0, line_reader_1.joinLines)([]);
+            expect(result).toBe('\r\n');
+        });
+        it('should handle single line', () => {
+            const result = (0, line_reader_1.joinLines)(['v=0']);
+            expect(result).toBe('v=0\r\n');
+        });
+    });
+    describe('formatLine', () => {
+        it('should format SDP line', () => {
+            const result = (0, line_reader_1.formatLine)('v', '0');
+            expect(result).toBe('v=0');
+        });
+        it('should format line with complex value', () => {
+            const result = (0, line_reader_1.formatLine)('o', 'jdoe 123 456 IN IP4 192.168.1.1');
+            expect(result).toBe('o=jdoe 123 456 IN IP4 192.168.1.1');
+        });
+        it('should throw for invalid type', () => {
+            expect(() => (0, line_reader_1.formatLine)('vv', '0')).toThrow('must be single character');
+            expect(() => (0, line_reader_1.formatLine)('', '0')).toThrow('must be single character');
+        });
+    });
+    describe('isValidLineType', () => {
+        it('should validate valid line types', () => {
+            expect((0, line_reader_1.isValidLineType)('v')).toBe(true);
+            expect((0, line_reader_1.isValidLineType)('o')).toBe(true);
+            expect((0, line_reader_1.isValidLineType)('s')).toBe(true);
+            expect((0, line_reader_1.isValidLineType)('i')).toBe(true);
+            expect((0, line_reader_1.isValidLineType)('u')).toBe(true);
+            expect((0, line_reader_1.isValidLineType)('e')).toBe(true);
+            expect((0, line_reader_1.isValidLineType)('p')).toBe(true);
+            expect((0, line_reader_1.isValidLineType)('c')).toBe(true);
+            expect((0, line_reader_1.isValidLineType)('b')).toBe(true);
+            expect((0, line_reader_1.isValidLineType)('t')).toBe(true);
+            expect((0, line_reader_1.isValidLineType)('r')).toBe(true);
+            expect((0, line_reader_1.isValidLineType)('z')).toBe(true);
+            expect((0, line_reader_1.isValidLineType)('k')).toBe(true);
+            expect((0, line_reader_1.isValidLineType)('a')).toBe(true);
+            expect((0, line_reader_1.isValidLineType)('m')).toBe(true);
+        });
+        it('should reject invalid line types', () => {
+            expect((0, line_reader_1.isValidLineType)('x')).toBe(false);
+            expect((0, line_reader_1.isValidLineType)('V')).toBe(false);
+            expect((0, line_reader_1.isValidLineType)('1')).toBe(false);
+            expect((0, line_reader_1.isValidLineType)('')).toBe(false);
+        });
+    });
+    describe('getLineTypeName', () => {
+        it('should return display names for valid types', () => {
+            expect((0, line_reader_1.getLineTypeName)('v')).toBe('version');
+            expect((0, line_reader_1.getLineTypeName)('o')).toBe('origin');
+            expect((0, line_reader_1.getLineTypeName)('s')).toBe('session name');
+            expect((0, line_reader_1.getLineTypeName)('c')).toBe('connection');
+            expect((0, line_reader_1.getLineTypeName)('m')).toBe('media');
+        });
+        it('should return unknown for invalid types', () => {
+            expect((0, line_reader_1.getLineTypeName)('x')).toBe('unknown');
+        });
+    });
+});

package/dist/tests/unit/utils/time-converter.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Tests for time-converter.ts
+ */
+export {};
+//# sourceMappingURL=time-converter.test.d.ts.map

package/dist/tests/unit/utils/time-converter.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-converter.test.d.ts","sourceRoot":"","sources":["../../../../tests/unit/utils/time-converter.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/tests/unit/utils/time-converter.test.js

@@ -0,0 +1,190 @@
+"use strict";
+/**
+ * Tests for time-converter.ts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const time_converter_1 = require("../../../src/utils/time-converter");
+describe('time-converter', () => {
+    describe('parseTypedTime', () => {
+        it('should parse seconds (no suffix)', () => {
+            const time = (0, time_converter_1.parseTypedTime)('3600');
+            expect(time.value).toBe(3600);
+            expect(time.unit).toBe('seconds');
+        });
+        it('should parse seconds (explicit s suffix)', () => {
+            const time = (0, time_converter_1.parseTypedTime)('30s');
+            expect(time.value).toBe(30);
+            expect(time.unit).toBe('seconds');
+        });
+        it('should parse minutes', () => {
+            const time = (0, time_converter_1.parseTypedTime)('120m');
+            expect(time.value).toBe(120);
+            expect(time.unit).toBe('minutes');
+        });
+        it('should parse hours', () => {
+            const time = (0, time_converter_1.parseTypedTime)('3h');
+            expect(time.value).toBe(3);
+            expect(time.unit).toBe('hours');
+        });
+        it('should parse days', () => {
+            const time = (0, time_converter_1.parseTypedTime)('7d');
+            expect(time.value).toBe(7);
+            expect(time.unit).toBe('days');
+        });
+        it('should throw for empty input', () => {
+            expect(() => (0, time_converter_1.parseTypedTime)('')).toThrow('Empty time value');
+        });
+        it('should throw for invalid format', () => {
+            expect(() => (0, time_converter_1.parseTypedTime)('abc')).toThrow('Invalid time format');
+            expect(() => (0, time_converter_1.parseTypedTime)('10x')).toThrow('Invalid time format');
+        });
+        it('should parse negative values (for timezone offsets)', () => {
+            const time = (0, time_converter_1.parseTypedTime)('-1h');
+            expect(time.value).toBe(-1);
+            expect(time.unit).toBe('hours');
+            const time2 = (0, time_converter_1.parseTypedTime)('-3600');
+            expect(time2.value).toBe(-3600);
+            expect(time2.unit).toBe('seconds');
+        });
+    });
+    describe('serializeTypedTime', () => {
+        it('should serialize seconds (no suffix)', () => {
+            const result = (0, time_converter_1.serializeTypedTime)({ value: 3600, unit: 'seconds' });
+            expect(result).toBe('3600');
+        });
+        it('should serialize minutes', () => {
+            const result = (0, time_converter_1.serializeTypedTime)({ value: 120, unit: 'minutes' });
+            expect(result).toBe('120m');
+        });
+        it('should serialize hours', () => {
+            const result = (0, time_converter_1.serializeTypedTime)({ value: 3, unit: 'hours' });
+            expect(result).toBe('3h');
+        });
+        it('should serialize days', () => {
+            const result = (0, time_converter_1.serializeTypedTime)({ value: 7, unit: 'days' });
+            expect(result).toBe('7d');
+        });
+    });
+    describe('typedTimeToSeconds', () => {
+        it('should convert seconds', () => {
+            expect((0, time_converter_1.typedTimeToSeconds)({ value: 30, unit: 'seconds' })).toBe(30);
+        });
+        it('should convert minutes to seconds', () => {
+            expect((0, time_converter_1.typedTimeToSeconds)({ value: 2, unit: 'minutes' })).toBe(120);
+        });
+        it('should convert hours to seconds', () => {
+            expect((0, time_converter_1.typedTimeToSeconds)({ value: 1, unit: 'hours' })).toBe(3600);
+        });
+        it('should convert days to seconds', () => {
+            expect((0, time_converter_1.typedTimeToSeconds)({ value: 1, unit: 'days' })).toBe(86400);
+        });
+    });
+    describe('secondsToTypedTime', () => {
+        it('should convert to days when evenly divisible', () => {
+            const time = (0, time_converter_1.secondsToTypedTime)(86400);
+            expect(time.value).toBe(1);
+            expect(time.unit).toBe('days');
+        });
+        it('should convert to hours when evenly divisible', () => {
+            const time = (0, time_converter_1.secondsToTypedTime)(7200);
+            expect(time.value).toBe(2);
+            expect(time.unit).toBe('hours');
+        });
+        it('should convert to minutes when evenly divisible', () => {
+            const time = (0, time_converter_1.secondsToTypedTime)(180);
+            expect(time.value).toBe(3);
+            expect(time.unit).toBe('minutes');
+        });
+        it('should keep as seconds when not evenly divisible', () => {
+            const time = (0, time_converter_1.secondsToTypedTime)(45);
+            expect(time.value).toBe(45);
+            expect(time.unit).toBe('seconds');
+        });
+        it('should handle zero', () => {
+            const time = (0, time_converter_1.secondsToTypedTime)(0);
+            expect(time.value).toBe(0);
+            expect(time.unit).toBe('days');
+        });
+        it('should throw for negative', () => {
+            expect(() => (0, time_converter_1.secondsToTypedTime)(-1)).toThrow('Time cannot be negative');
+        });
+    });
+    describe('addTypedTimes', () => {
+        it('should add times with same unit', () => {
+            const a = { value: 10, unit: 'minutes' };
+            const b = { value: 20, unit: 'minutes' };
+            const result = (0, time_converter_1.addTypedTimes)(a, b);
+            expect((0, time_converter_1.typedTimeToSeconds)(result)).toBe(1800); // 30 minutes
+        });
+        it('should add times with different units', () => {
+            const a = { value: 1, unit: 'hours' };
+            const b = { value: 30, unit: 'minutes' };
+            const result = (0, time_converter_1.addTypedTimes)(a, b);
+            expect((0, time_converter_1.typedTimeToSeconds)(result)).toBe(5400); // 90 minutes = 1.5 hours
+        });
+    });
+    describe('compareTypedTimes', () => {
+        it('should compare equal times', () => {
+            const a = { value: 60, unit: 'seconds' };
+            const b = { value: 1, unit: 'minutes' };
+            expect((0, time_converter_1.compareTypedTimes)(a, b)).toBe(0);
+        });
+        it('should detect when a < b', () => {
+            const a = { value: 30, unit: 'seconds' };
+            const b = { value: 1, unit: 'minutes' };
+            expect((0, time_converter_1.compareTypedTimes)(a, b)).toBeLessThan(0);
+        });
+        it('should detect when a > b', () => {
+            const a = { value: 2, unit: 'minutes' };
+            const b = { value: 60, unit: 'seconds' };
+            expect((0, time_converter_1.compareTypedTimes)(a, b)).toBeGreaterThan(0);
+        });
+    });
+    describe('typedTimesEqual', () => {
+        it('should detect equal times with same unit', () => {
+            const a = { value: 60, unit: 'minutes' };
+            const b = { value: 60, unit: 'minutes' };
+            expect((0, time_converter_1.typedTimesEqual)(a, b)).toBe(true);
+        });
+        it('should detect equal times with different units', () => {
+            const a = { value: 60, unit: 'seconds' };
+            const b = { value: 1, unit: 'minutes' };
+            expect((0, time_converter_1.typedTimesEqual)(a, b)).toBe(true);
+        });
+        it('should detect unequal times', () => {
+            const a = { value: 30, unit: 'seconds' };
+            const b = { value: 1, unit: 'minutes' };
+            expect((0, time_converter_1.typedTimesEqual)(a, b)).toBe(false);
+        });
+    });
+    describe('normalizeTypedTime', () => {
+        it('should normalize to larger unit when possible', () => {
+            const time = { value: 120, unit: 'minutes' };
+            const normalized = (0, time_converter_1.normalizeTypedTime)(time);
+            expect(normalized.value).toBe(2);
+            expect(normalized.unit).toBe('hours');
+        });
+        it('should normalize seconds to hours', () => {
+            const time = { value: 3600, unit: 'seconds' };
+            const normalized = (0, time_converter_1.normalizeTypedTime)(time);
+            expect(normalized.value).toBe(1);
+            expect(normalized.unit).toBe('hours');
+        });
+        it('should keep original unit if not divisible', () => {
+            const time = { value: 45, unit: 'seconds' };
+            const normalized = (0, time_converter_1.normalizeTypedTime)(time);
+            expect(normalized.value).toBe(45);
+            expect(normalized.unit).toBe('seconds');
+        });
+    });
+    describe('round-trip', () => {
+        it('should round-trip parse and serialize', () => {
+            const inputs = ['7d', '3h', '120m', '3600'];
+            inputs.forEach(input => {
+                const parsed = (0, time_converter_1.parseTypedTime)(input);
+                const serialized = (0, time_converter_1.serializeTypedTime)(parsed);
+                expect(serialized).toBe(input);
+            });
+        });
+    });
+});

package/dist/tests/unit/validator/media-validator.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Tests for media-validator.ts
+ */
+export {};
+//# sourceMappingURL=media-validator.test.d.ts.map

package/dist/tests/unit/validator/media-validator.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"media-validator.test.d.ts","sourceRoot":"","sources":["../../../../tests/unit/validator/media-validator.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}