@regardio/js 0.3.0 → 0.4.0

package/dist/time/time.test.js

@@ -1,202 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
-import { dateTimeInUnix, friendlyDuration, oneDayFromNow, oneMinuteFromNow, oneWeekFromNow, timeAgo, } from './time';
-describe('timeAgo', () => {
-    beforeEach(() => {
-        vi.useFakeTimers();
-        vi.setSystemTime(new Date('2024-01-15T12:00:00Z'));
-    });
-    afterEach(() => {
-        vi.useRealTimers();
-    });
-    test('should return "Just now" for very recent times', () => {
-        const now = new Date();
-        expect(timeAgo(now)).toBe('Just now');
-    });
-    test('should handle seconds ago', () => {
-        const date = new Date(Date.now() - 30 * 1000);
-        expect(timeAgo(date)).toMatch(/seconds? ago/);
-    });
-    test('should handle minutes ago', () => {
-        const date = new Date(Date.now() - 5 * 60 * 1000);
-        expect(timeAgo(date)).toMatch(/minutes? ago/);
-    });
-    test('should handle hours ago', () => {
-        const date = new Date(Date.now() - 3 * 60 * 60 * 1000);
-        expect(timeAgo(date)).toMatch(/hours? ago/);
-    });
-    test('should handle days ago', () => {
-        const date = new Date(Date.now() - 2 * 24 * 60 * 60 * 1000);
-        expect(timeAgo(date)).toMatch(/days? ago/);
-    });
-    test('should handle weeks ago', () => {
-        const date = new Date(Date.now() - 2 * 7 * 24 * 60 * 60 * 1000);
-        expect(timeAgo(date)).toMatch(/days? ago/);
-    });
-    test('should handle months ago', () => {
-        const date = new Date(Date.now() - 60 * 24 * 60 * 60 * 1000);
-        expect(timeAgo(date)).toMatch(/days? ago/);
-    });
-    test('should handle years ago', () => {
-        const date = new Date(Date.now() - 400 * 24 * 60 * 60 * 1000);
-        expect(timeAgo(date)).toMatch(/days? ago/);
-    });
-    test('should accept string input', () => {
-        const dateString = new Date(Date.now() - 5 * 60 * 1000).toISOString();
-        expect(timeAgo(dateString)).toMatch(/minutes? ago/);
-    });
-    test('should handle future dates', () => {
-        const futureDate = new Date(Date.now() + 5 * 60 * 1000);
-        expect(timeAgo(futureDate)).toMatch(/in \d+ minutes?/);
-    });
-});
-describe('oneWeekFromNow', () => {
-    beforeEach(() => {
-        vi.useFakeTimers();
-        vi.setSystemTime(new Date('2024-01-15T12:00:00Z'));
-    });
-    afterEach(() => {
-        vi.useRealTimers();
-    });
-    test('should return a date 7 days from now', () => {
-        const result = oneWeekFromNow();
-        const expected = new Date('2024-01-22T12:00:00Z');
-        expect(result.getTime()).toBe(expected.getTime());
-    });
-});
-describe('oneDayFromNow', () => {
-    beforeEach(() => {
-        vi.useFakeTimers();
-        vi.setSystemTime(new Date('2024-01-15T12:00:00Z'));
-    });
-    afterEach(() => {
-        vi.useRealTimers();
-    });
-    test('should return a date 1 day from now', () => {
-        const result = oneDayFromNow();
-        const expected = new Date('2024-01-16T12:00:00Z');
-        expect(result.getTime()).toBe(expected.getTime());
-    });
-});
-describe('oneMinuteFromNow', () => {
-    beforeEach(() => {
-        vi.useFakeTimers();
-        vi.setSystemTime(new Date('2024-01-15T12:00:00Z'));
-    });
-    afterEach(() => {
-        vi.useRealTimers();
-    });
-    test('should return a date 1 minute from now', () => {
-        const result = oneMinuteFromNow();
-        const expected = new Date('2024-01-15T12:01:00Z');
-        expect(result.getTime()).toBe(expected.getTime());
-    });
-});
-describe('friendlyDuration', () => {
-    test('should return null for null input', () => {
-        expect(friendlyDuration(null, 'en')).toBeNull();
-    });
-    test('should return null for 0 minutes', () => {
-        expect(friendlyDuration(0, 'en')).toBeNull();
-    });
-    describe('short format', () => {
-        test('should format minutes under 120 as minutes', () => {
-            const result = friendlyDuration(70, 'en', true);
-            expect(result).toEqual({
-                key: 'common:duration.minutesShort',
-                vars: { minutes: '70' },
-            });
-        });
-        test('should format hours and minutes for durations over 120 minutes', () => {
-            const result = friendlyDuration(150, 'en', true);
-            expect(result).toEqual({
-                key: 'common:duration.hoursAndMinutesShort',
-                vars: { hours: '2', minutes: '30' },
-            });
-        });
-        test('should format hours only when no remaining minutes', () => {
-            const result = friendlyDuration(180, 'en', true);
-            expect(result).toEqual({
-                key: 'common:duration.hoursShort',
-                vars: { hours: '3' },
-            });
-        });
-    });
-    describe('long format', () => {
-        test('should format minutes for durations under 240 minutes', () => {
-            const result = friendlyDuration(120, 'en');
-            expect(result).toEqual({
-                key: 'common:duration.minutes',
-                vars: { count: 120, value: '120' },
-            });
-        });
-        test('should format hours for durations 240+ minutes', () => {
-            const result = friendlyDuration(240, 'en');
-            expect(result).toEqual({
-                key: 'common:duration.hours',
-                vars: { count: 4, value: '4' },
-            });
-        });
-        test('should format hours and minutes when there are remaining minutes', () => {
-            const result = friendlyDuration(270, 'en');
-            expect(result).toEqual({
-                key: 'common:duration.hoursAndMinutes',
-                vars: { hours: '4', minutes: '30' },
-            });
-        });
-        test('should format days for durations 1440+ minutes', () => {
-            const result = friendlyDuration(1440, 'en');
-            expect(result).toEqual({
-                key: 'common:duration.days',
-                vars: { count: 1, value: '1' },
-            });
-        });
-        test('should format weeks for durations 10080+ minutes', () => {
-            const result = friendlyDuration(10080, 'en');
-            expect(result).toEqual({
-                key: 'common:duration.weeks',
-                vars: { count: 1, value: '1' },
-            });
-        });
-        test('should format months for durations 43200+ minutes', () => {
-            const result = friendlyDuration(43200, 'en');
-            expect(result).toEqual({
-                key: 'common:duration.months',
-                vars: { count: 1, value: '1' },
-            });
-        });
-        test('should format years for durations 525600+ minutes', () => {
-            const result = friendlyDuration(525600, 'en');
-            expect(result).toEqual({
-                key: 'common:duration.years',
-                vars: { count: 1, value: '1' },
-            });
-        });
-    });
-    describe('locale formatting', () => {
-        test('should use locale-specific number formatting', () => {
-            const result = friendlyDuration(1500, 'de-DE', true);
-            expect(result).toEqual({
-                key: 'common:duration.hoursShort',
-                vars: { hours: '25' },
-            });
-        });
-    });
-});
-describe('dateTimeInUnix', () => {
-    test('should convert milliseconds to seconds', () => {
-        expect(dateTimeInUnix(1000)).toBe(1);
-        expect(dateTimeInUnix(1500)).toBe(1);
-        expect(dateTimeInUnix(2000)).toBe(2);
-    });
-    test('should handle 0', () => {
-        expect(dateTimeInUnix(0)).toBe(0);
-    });
-    test('should handle large timestamps', () => {
-        const timestamp = 1705320000000;
-        expect(dateTimeInUnix(timestamp)).toBe(1705320000);
-    });
-    test('should floor the result', () => {
-        expect(dateTimeInUnix(1999)).toBe(1);
-        expect(dateTimeInUnix(2001)).toBe(2);
-    });
-});

package/dist/validation/invariant.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"invariant.d.ts","sourceRoot":"","sources":["../../src/validation/invariant.ts"],"names":[],"mappings":"AAeA,wBAAgB,SAAS,CAAC,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,CAAC,MAAM,MAAM,CAAC,GAAG,OAAO,CAAC,SAAS,CAIjG;AAiBD,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,OAAO,EAClB,OAAO,EAAE,MAAM,GAAG,CAAC,MAAM,MAAM,CAAC,EAChC,YAAY,CAAC,EAAE,YAAY,GAC1B,OAAO,CAAC,SAAS,CAOnB"}

package/dist/validation/invariant.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=invariant.test.d.ts.map

package/dist/validation/invariant.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"invariant.test.d.ts","sourceRoot":"","sources":["../../src/validation/invariant.test.ts"],"names":[],"mappings":""}

package/dist/validation/invariant.test.js

@@ -1,110 +0,0 @@
-import { describe, expect, test } from 'vitest';
-import { invariant, invariantResponse } from './invariant';
-describe('invariant', () => {
-    test('should not throw when condition is truthy', () => {
-        expect(() => invariant(true, 'error')).not.toThrow();
-        expect(() => invariant(1, 'error')).not.toThrow();
-        expect(() => invariant('string', 'error')).not.toThrow();
-        expect(() => invariant({}, 'error')).not.toThrow();
-        expect(() => invariant([], 'error')).not.toThrow();
-    });
-    test('should throw Error when condition is falsy', () => {
-        expect(() => invariant(false, 'test error')).toThrow(Error);
-        expect(() => invariant(false, 'test error')).toThrow('test error');
-    });
-    test('should throw for various falsy values', () => {
-        expect(() => invariant(null, 'null error')).toThrow('null error');
-        expect(() => invariant(undefined, 'undefined error')).toThrow('undefined error');
-        expect(() => invariant(0, 'zero error')).toThrow('zero error');
-        expect(() => invariant('', 'empty string error')).toThrow('empty string error');
-        expect(() => invariant(Number.NaN, 'NaN error')).toThrow('NaN error');
-    });
-    test('should accept message as a function', () => {
-        expect(() => invariant(false, () => 'lazy error')).toThrow('lazy error');
-    });
-    test('should not call message function when condition is truthy', () => {
-        let called = false;
-        invariant(true, () => {
-            called = true;
-            return 'error';
-        });
-        expect(called).toBe(false);
-    });
-    test('should work as type assertion', () => {
-        const value = 'hello';
-        invariant(value !== null, 'value is null');
-        expect(value.toUpperCase()).toBe('HELLO');
-    });
-});
-describe('invariantResponse', () => {
-    test('should not throw when condition is truthy', () => {
-        expect(() => invariantResponse(true, 'error')).not.toThrow();
-        expect(() => invariantResponse(1, 'error')).not.toThrow();
-        expect(() => invariantResponse('string', 'error')).not.toThrow();
-    });
-    test('should throw Response when condition is falsy', () => {
-        expect(() => invariantResponse(false, 'test error')).toThrow();
-    });
-    test('should throw Response with status 400 by default', async () => {
-        let thrownError;
-        try {
-            invariantResponse(false, 'bad request');
-        }
-        catch (error) {
-            thrownError = error;
-        }
-        expect(thrownError).toBeInstanceOf(Response);
-        const response = thrownError;
-        expect(response.status).toBe(400);
-        expect(await response.text()).toBe('bad request');
-    });
-    test('should accept custom responseInit', () => {
-        let thrownError;
-        try {
-            invariantResponse(false, 'not found', { status: 404 });
-        }
-        catch (error) {
-            thrownError = error;
-        }
-        expect(thrownError).toBeInstanceOf(Response);
-        const response = thrownError;
-        expect(response.status).toBe(404);
-    });
-    test('should accept custom headers in responseInit', () => {
-        let thrownError;
-        try {
-            invariantResponse(false, 'error', {
-                headers: { 'X-Custom-Header': 'value' },
-            });
-        }
-        catch (error) {
-            thrownError = error;
-        }
-        const response = thrownError;
-        expect(response.headers.get('X-Custom-Header')).toBe('value');
-    });
-    test('should accept message as a function', async () => {
-        let thrownError;
-        try {
-            invariantResponse(false, () => 'lazy error');
-        }
-        catch (error) {
-            thrownError = error;
-        }
-        const response = thrownError;
-        expect(await response.text()).toBe('lazy error');
-    });
-    test('should not call message function when condition is truthy', () => {
-        let called = false;
-        invariantResponse(true, () => {
-            called = true;
-            return 'error';
-        });
-        expect(called).toBe(false);
-    });
-    test('should work as type assertion', () => {
-        const value = 'hello';
-        invariantResponse(value !== null, 'value is null');
-        expect(value.toUpperCase()).toBe('HELLO');
-    });
-});

package/dist/validation/verify-file-accept.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"verify-file-accept.d.ts","sourceRoot":"","sources":["../../src/validation/verify-file-accept.ts"],"names":[],"mappings":"AAOA,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAGlE"}

package/dist/validation/verify-file-accept.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=verify-file-accept.test.d.ts.map

package/dist/validation/verify-file-accept.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"verify-file-accept.test.d.ts","sourceRoot":"","sources":["../../src/validation/verify-file-accept.test.ts"],"names":[],"mappings":""}

package/dist/validation/verify-file-accept.test.js

@@ -1,71 +0,0 @@
-import { describe, expect, test } from 'vitest';
-import { verifyAccept } from './verify-file-accept';
-describe('verifyAccept', () => {
-    describe('exact mime type matching', () => {
-        test('should return true for exact match', () => {
-            expect(verifyAccept('image/png', 'image/png')).toBe(true);
-            expect(verifyAccept('image/jpeg', 'image/jpeg')).toBe(true);
-            expect(verifyAccept('application/pdf', 'application/pdf')).toBe(true);
-        });
-        test('should return false for non-matching mime type', () => {
-            expect(verifyAccept('image/png', 'image/jpeg')).toBe(false);
-            expect(verifyAccept('video/mp4', 'audio/mp3')).toBe(false);
-        });
-    });
-    describe('wildcard matching', () => {
-        test('should match wildcard for same type', () => {
-            expect(verifyAccept('image/png', 'image/*')).toBe(true);
-            expect(verifyAccept('image/jpeg', 'image/*')).toBe(true);
-            expect(verifyAccept('image/gif', 'image/*')).toBe(true);
-        });
-        test('should match audio wildcard', () => {
-            expect(verifyAccept('audio/mp3', 'audio/*')).toBe(true);
-            expect(verifyAccept('audio/wav', 'audio/*')).toBe(true);
-        });
-        test('should match video wildcard', () => {
-            expect(verifyAccept('video/mp4', 'video/*')).toBe(true);
-            expect(verifyAccept('video/webm', 'video/*')).toBe(true);
-        });
-        test('should not match wildcard for different type', () => {
-            expect(verifyAccept('video/mp4', 'image/*')).toBe(false);
-            expect(verifyAccept('audio/mp3', 'video/*')).toBe(false);
-        });
-    });
-    describe('multiple accept types', () => {
-        test('should match any of multiple exact types', () => {
-            expect(verifyAccept('image/png', 'image/png,image/jpeg')).toBe(true);
-            expect(verifyAccept('image/jpeg', 'image/png,image/jpeg')).toBe(true);
-        });
-        test('should match with mixed exact and wildcard', () => {
-            expect(verifyAccept('image/png', 'audio/*,video/*,image/png')).toBe(true);
-            expect(verifyAccept('audio/mp3', 'audio/*,video/*,image/png')).toBe(true);
-            expect(verifyAccept('video/mp4', 'audio/*,video/*,image/png')).toBe(true);
-        });
-        test('should return false when no match in multiple types', () => {
-            expect(verifyAccept('application/pdf', 'image/*,video/*')).toBe(false);
-        });
-    });
-    describe('whitespace handling', () => {
-        test('should handle spaces after commas', () => {
-            expect(verifyAccept('image/png', 'image/png, image/jpeg')).toBe(true);
-            expect(verifyAccept('image/jpeg', 'image/png, image/jpeg')).toBe(true);
-        });
-        test('should handle multiple spaces', () => {
-            expect(verifyAccept('image/png', 'image/png,  image/jpeg,   video/*')).toBe(true);
-        });
-    });
-    describe('edge cases', () => {
-        test('should handle application types', () => {
-            expect(verifyAccept('application/json', 'application/*')).toBe(true);
-            expect(verifyAccept('application/xml', 'application/*')).toBe(true);
-        });
-        test('should handle text types', () => {
-            expect(verifyAccept('text/plain', 'text/*')).toBe(true);
-            expect(verifyAccept('text/html', 'text/*')).toBe(true);
-        });
-        test('should handle single accept value', () => {
-            expect(verifyAccept('image/png', 'image/png')).toBe(true);
-            expect(verifyAccept('image/png', 'image/*')).toBe(true);
-        });
-    });
-});