@regardio/js 0.2.0

package/dist/intl/language-detector.js

@@ -0,0 +1,114 @@
+import { parseAcceptLanguage } from 'intl-parse-accept-language';
+import { getClientLocales } from './locale';
+export class LanguageDetectorLingui {
+    detector;
+    options;
+    constructor(options) {
+        this.options = options;
+        this.detector = new LanguageDetector(this.options.detection);
+    }
+    async getLocale(request) {
+        return await this.detector.detect(request);
+    }
+}
+export class LanguageDetector {
+    options;
+    constructor(options) {
+        this.options = options;
+        this.isSessionOnly(this.options);
+        this.isCookieOnly(this.options);
+    }
+    async detect(request) {
+        const order = this.options.order ?? ['urlPath', 'cookie', 'session', 'searchParams', 'header'];
+        for (const method of order) {
+            let locale = null;
+            if (method === 'urlPath') {
+                locale = this.fromUrlPath(request);
+            }
+            if (method === 'searchParams') {
+                locale = this.fromSearchParams(request);
+            }
+            if (method === 'cookie') {
+                locale = await this.fromCookie(request);
+            }
+            if (method === 'session') {
+                locale = await this.fromSessionStorage(request);
+            }
+            if (method === 'header') {
+                locale = this.fromHeader(request);
+            }
+            if (locale)
+                return locale;
+        }
+        return this.options.fallbackLanguage;
+    }
+    isSessionOnly(options) {
+        if (options.order?.length === 1 && options.order[0] === 'session' && !options.sessionStorage) {
+            throw new Error('You need a sessionStorage if you want to only get the locale from the session');
+        }
+    }
+    isCookieOnly(options) {
+        if (options.order?.length === 1 && options.order[0] === 'cookie' && !options.cookie) {
+            throw new Error('You need a cookie if you want to only get the locale from the cookie');
+        }
+    }
+    fromUrlPath(request) {
+        const url = new URL(request.url);
+        const pathSegments = url.pathname.split('/').filter(Boolean);
+        if (pathSegments.length > 0) {
+            const firstSegment = pathSegments[0];
+            if (firstSegment) {
+                return this.fromSupported(firstSegment);
+            }
+        }
+        return null;
+    }
+    fromSearchParams(request) {
+        const url = new URL(request.url);
+        if (!url.searchParams.has(this.options.searchParamKey ?? 'lng')) {
+            return null;
+        }
+        return this.fromSupported(url.searchParams.get(this.options.searchParamKey ?? 'lng'));
+    }
+    async fromCookie(request) {
+        if (!this.options.cookie)
+            return null;
+        const cookie = this.options.cookie;
+        try {
+            const lng = await cookie.parse(request.headers.get('Cookie'));
+            if (typeof lng !== 'string' || !lng)
+                return null;
+            return this.fromSupported(lng);
+        }
+        catch (_error) {
+            return null;
+        }
+    }
+    async fromSessionStorage(request) {
+        if (!this.options.sessionStorage)
+            return null;
+        const session = await this.options.sessionStorage.getSession(request.headers.get('Cookie'));
+        const lng = session.get(this.options.sessionKey ?? 'lng');
+        if (!lng)
+            return null;
+        return this.fromSupported(lng);
+    }
+    fromHeader(request) {
+        const locales = getClientLocales(request);
+        if (!locales)
+            return null;
+        if (Array.isArray(locales))
+            return this.fromSupported(locales.join(','));
+        return this.fromSupported(locales);
+    }
+    fromSupported(language) {
+        if (!language)
+            return this.options.fallbackLanguage;
+        const languageStr = Array.isArray(language) ? language.join(',') : language;
+        const parsed = parseAcceptLanguage(languageStr, {
+            ignoreWildcard: true,
+            validate: (locale) => (this.options.supportedLanguages.includes(locale) ? locale : null),
+        });
+        return parsed[0] || this.options.fallbackLanguage;
+    }
+}

package/dist/intl/language-detector.test.d.ts

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

package/dist/intl/language-detector.test.d.ts.map

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

package/dist/intl/language-detector.test.js

@@ -0,0 +1,186 @@
+import { describe, expect, test, vi } from 'vitest';
+import { LanguageDetector, LanguageDetectorLingui } from './language-detector';
+describe('LanguageDetector', () => {
+    const defaultOptions = {
+        fallbackLanguage: 'en',
+        supportedLanguages: ['en', 'de'],
+    };
+    describe('detect', () => {
+        test('should detect language from search params', async () => {
+            const detector = new LanguageDetector(defaultOptions);
+            const request = new Request('https://example.com?lng=de');
+            const language = await detector.detect(request);
+            expect(language).toBe('de');
+        });
+        test('should detect language from cookie', async () => {
+            const mockCookie = {
+                isSigned: false,
+                name: 'lng',
+                parse: vi.fn(() => Promise.resolve('de')),
+                secrets: ['secret'],
+                serialize: vi.fn(() => Promise.resolve('serialized-cookie')),
+            };
+            const detector = new LanguageDetector({
+                ...defaultOptions,
+                cookie: mockCookie,
+            });
+            const request = new Request('https://example.com', {
+                headers: {
+                    cookie: 'lng=de',
+                },
+            });
+            const language = await detector.detect(request);
+            expect(language).toBe('de');
+        });
+        test('should detect language from session', async () => {
+            const mockSession = {
+                commitSession: vi.fn(() => Promise.resolve('')),
+                destroySession: vi.fn(() => Promise.resolve('')),
+                getSession: vi.fn(() => Promise.resolve({
+                    data: { lng: 'de' },
+                    flash: vi.fn(() => { }),
+                    get: (key) => (key === 'lng' ? 'de' : undefined),
+                    has: (key) => key === 'lng',
+                    id: '123',
+                    set: vi.fn(() => { }),
+                    unset: vi.fn(() => { }),
+                })),
+            };
+            const detector = new LanguageDetector({
+                ...defaultOptions,
+                sessionStorage: mockSession,
+            });
+            const request = new Request('https://example.com');
+            const language = await detector.detect(request);
+            expect(language).toBe('de');
+        });
+        test('should detect language from Accept-Language header', async () => {
+            const detector = new LanguageDetector(defaultOptions);
+            const request = new Request('https://example.com', {
+                headers: {
+                    'accept-language': 'de,en;q=0.9,en;q=0.8',
+                },
+            });
+            const language = await detector.detect(request);
+            expect(language).toBe('de');
+        });
+        test('should fall back to default language when no supported language is found', async () => {
+            const detector = new LanguageDetector(defaultOptions);
+            const request = new Request('https://example.com', {
+                headers: {
+                    'accept-language': 'fr-FR,es-ES;q=0.9',
+                },
+            });
+            const language = await detector.detect(request);
+            expect(language).toBe('en');
+        });
+        test('should handle cookie parsing error', async () => {
+            const mockCookie = {
+                isSigned: false,
+                name: 'lng',
+                parse: vi.fn(() => Promise.reject(new Error('Cookie parsing failed'))),
+                secrets: ['secret'],
+                serialize: vi.fn(() => Promise.resolve('serialized-cookie')),
+            };
+            const detector = new LanguageDetector({
+                ...defaultOptions,
+                cookie: mockCookie,
+            });
+            const request = new Request('https://example.com', {
+                headers: {
+                    cookie: 'lng=de',
+                },
+            });
+            const language = await detector.detect(request);
+            expect(language).toBe('en');
+        });
+        test('should handle multiple language preferences in session', async () => {
+            const mockSession = {
+                commitSession: vi.fn(() => Promise.resolve('')),
+                destroySession: vi.fn(() => Promise.resolve('')),
+                getSession: vi.fn(() => Promise.resolve({
+                    data: { lng: ['de', 'en'] },
+                    flash: vi.fn(() => { }),
+                    get: (key) => (key === 'lng' ? ['de', 'en'] : undefined),
+                    has: (key) => key === 'lng',
+                    id: '123',
+                    set: vi.fn(() => { }),
+                    unset: vi.fn(() => { }),
+                })),
+            };
+            const detector = new LanguageDetector({
+                ...defaultOptions,
+                sessionStorage: mockSession,
+            });
+            const request = new Request('https://example.com');
+            const language = await detector.detect(request);
+            expect(language).toBe('de');
+        });
+        test('should handle invalid language code in search params', async () => {
+            const detector = new LanguageDetector(defaultOptions);
+            const request = new Request('https://example.com?lng=invalid-code');
+            const language = await detector.detect(request);
+            expect(language).toBe('en');
+        });
+    });
+    describe('language detection from header', () => {
+        test('should return first supported language from Accept-Language header', async () => {
+            const detector = new LanguageDetector(defaultOptions);
+            const request = new Request('https://example.com', {
+                headers: {
+                    'accept-language': 'fr-FR,de;q=0.9,en;q=0.8',
+                },
+            });
+            const language = await detector.detect(request);
+            expect(language).toBe('de');
+        });
+        test('should return fallback language when no supported language in header', async () => {
+            const detector = new LanguageDetector(defaultOptions);
+            const request = new Request('https://example.com', {
+                headers: {
+                    'accept-language': 'fr-FR,es-ES;q=0.9',
+                },
+            });
+            const language = await detector.detect(request);
+            expect(language).toBe(defaultOptions.fallbackLanguage);
+        });
+    });
+    describe('language detection from search params', () => {
+        test('should return language from URL search params', async () => {
+            const detector = new LanguageDetector(defaultOptions);
+            const request = new Request('https://example.com?lng=de');
+            const language = await detector.detect(request);
+            expect(language).toBe('de');
+        });
+        test('should return fallback language when no language param exists', async () => {
+            const detector = new LanguageDetector(defaultOptions);
+            const request = new Request('https://example.com');
+            const language = await detector.detect(request);
+            expect(language).toBe(defaultOptions.fallbackLanguage);
+        });
+    });
+});
+describe('LanguageDetectorLingui', () => {
+    const defaultOptions = {
+        detection: {
+            fallbackLanguage: 'en',
+            supportedLanguages: ['en', 'de'],
+        },
+    };
+    test('should detect language using underlying LanguageDetector', async () => {
+        const detector = new LanguageDetectorLingui(defaultOptions);
+        const request = new Request('https://example.com?lng=de');
+        const language = await detector.getLocale(request);
+        expect(language).toBe('de');
+    });
+    test('should fall back to default language when no supported language found', async () => {
+        const detector = new LanguageDetectorLingui(defaultOptions);
+        const request = new Request('https://example.com', {
+            headers: {
+                'accept-language': 'fr-FR,es-ES;q=0.9',
+            },
+        });
+        const language = await detector.getLocale(request);
+        expect(language).toBe('en');
+    });
+});

package/dist/intl/locale.d.ts

@@ -0,0 +1,4 @@
+export type Locales = string | string[] | undefined;
+export declare function getClientLocales(headers: Headers): Locales;
+export declare function getClientLocales(request: Request): Locales;
+//# sourceMappingURL=locale.d.ts.map

package/dist/intl/locale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"locale.d.ts","sourceRoot":"","sources":["../../src/intl/locale.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,OAAO,GAAG,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC;AAiBpD,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC;AAC5D,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC"}

package/dist/intl/locale.js

@@ -0,0 +1,22 @@
+import { parseAcceptLanguage } from 'intl-parse-accept-language';
+export function getClientLocales(requestOrHeaders) {
+    const headers = getHeaders(requestOrHeaders);
+    const acceptLanguage = headers.get('Accept-Language');
+    if (!acceptLanguage)
+        return undefined;
+    const locales = parseAcceptLanguage(acceptLanguage, {
+        ignoreWildcard: true,
+        validate: Intl.DateTimeFormat.supportedLocalesOf,
+    });
+    if (locales.length === 0)
+        return undefined;
+    if (locales.length === 1)
+        return locales[0];
+    return locales;
+}
+function getHeaders(requestOrHeaders) {
+    if (requestOrHeaders instanceof Request) {
+        return requestOrHeaders.headers;
+    }
+    return requestOrHeaders;
+}

package/dist/intl/locale.test.d.ts

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

package/dist/intl/locale.test.d.ts.map

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

package/dist/intl/locale.test.js

@@ -0,0 +1,75 @@
+import { describe, expect, test } from 'vitest';
+import { getClientLocales } from './locale';
+describe('getClientLocales', () => {
+    describe('with Request object', () => {
+        test('should return undefined when Accept-Language header is missing', () => {
+            const request = new Request('https://example.com');
+            expect(getClientLocales(request)).toBeUndefined();
+        });
+        test('should return single locale when only one is provided', () => {
+            const request = new Request('https://example.com', {
+                headers: { 'Accept-Language': 'en-US' },
+            });
+            expect(getClientLocales(request)).toBe('en-US');
+        });
+        test('should return array of locales sorted by quality', () => {
+            const request = new Request('https://example.com', {
+                headers: { 'Accept-Language': 'en-US,de;q=0.9,fr;q=0.8' },
+            });
+            const result = getClientLocales(request);
+            expect(Array.isArray(result)).toBe(true);
+            expect(result).toContain('en-US');
+            expect(result).toContain('de');
+        });
+        test('should return undefined for invalid locales', () => {
+            const request = new Request('https://example.com', {
+                headers: { 'Accept-Language': 'invalid-locale-xyz' },
+            });
+            expect(getClientLocales(request)).toBeUndefined();
+        });
+        test('should ignore wildcard (*)', () => {
+            const request = new Request('https://example.com', {
+                headers: { 'Accept-Language': '*' },
+            });
+            expect(getClientLocales(request)).toBeUndefined();
+        });
+    });
+    describe('with Headers object', () => {
+        test('should return undefined when Accept-Language header is missing', () => {
+            const headers = new Headers();
+            expect(getClientLocales(headers)).toBeUndefined();
+        });
+        test('should return single locale when only one is provided', () => {
+            const headers = new Headers({ 'Accept-Language': 'de-DE' });
+            expect(getClientLocales(headers)).toBe('de-DE');
+        });
+        test('should return array of locales sorted by quality', () => {
+            const headers = new Headers({ 'Accept-Language': 'fr-FR,en;q=0.9,de;q=0.8' });
+            const result = getClientLocales(headers);
+            expect(Array.isArray(result)).toBe(true);
+            expect(result).toContain('fr-FR');
+        });
+    });
+    describe('quality value handling', () => {
+        test('should prioritize higher quality values', () => {
+            const request = new Request('https://example.com', {
+                headers: { 'Accept-Language': 'de;q=0.5,en;q=0.9' },
+            });
+            const result = getClientLocales(request);
+            expect(Array.isArray(result)).toBe(true);
+            if (Array.isArray(result)) {
+                expect(result[0]).toBe('en');
+            }
+        });
+        test('should handle locales without explicit quality (default q=1)', () => {
+            const request = new Request('https://example.com', {
+                headers: { 'Accept-Language': 'en,de;q=0.9' },
+            });
+            const result = getClientLocales(request);
+            expect(Array.isArray(result)).toBe(true);
+            if (Array.isArray(result)) {
+                expect(result[0]).toBe('en');
+            }
+        });
+    });
+});

package/dist/time/time.d.ts

@@ -0,0 +1,39 @@
+export declare function timeAgo(input: Date | string): string;
+export declare const oneWeekFromNow: () => Date;
+export declare const oneDayFromNow: () => Date;
+export declare const oneMinuteFromNow: () => Date;
+export declare function friendlyDuration(minutes: number | null, locale: string, short?: boolean): {
+    key: string;
+    vars: {
+        hours: string;
+        minutes: string;
+        count?: undefined;
+        value?: undefined;
+    };
+} | {
+    key: string;
+    vars: {
+        hours: string;
+        minutes?: undefined;
+        count?: undefined;
+        value?: undefined;
+    };
+} | {
+    key: string;
+    vars: {
+        minutes: string;
+        hours?: undefined;
+        count?: undefined;
+        value?: undefined;
+    };
+} | {
+    key: string;
+    vars: {
+        count: number;
+        value: string;
+        hours?: undefined;
+        minutes?: undefined;
+    };
+} | null;
+export declare const dateTimeInUnix: (date: number) => number;
+//# sourceMappingURL=time.d.ts.map

package/dist/time/time.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time.d.ts","sourceRoot":"","sources":["../../src/time/time.ts"],"names":[],"mappings":"AAEA,wBAAgB,OAAO,CAAC,KAAK,EAAE,IAAI,GAAG,MAAM,UAuB3C;AAED,eAAO,MAAM,cAAc,YAI1B,CAAC;AAEF,eAAO,MAAM,aAAa,YAIzB,CAAC;AAEF,eAAO,MAAM,gBAAgB,YAI5B,CAAC;AAEF,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,UAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SA4GrF;AAED,eAAO,MAAM,cAAc,GAAI,MAAM,MAAM,WAE1C,CAAC"}

package/dist/time/time.js

@@ -0,0 +1,132 @@
+export function timeAgo(input) {
+    const date = new Date(input);
+    const formatter = new Intl.RelativeTimeFormat('en');
+    const ranges = {
+        days: 3600 * 24,
+        hours: 3600,
+        minutes: 60,
+        months: 3600 * 24 * 30,
+        seconds: 1,
+        weeks: 3600 * 24 * 7,
+        years: 3600 * 24 * 365,
+    };
+    const secondsElapsed = (date.getTime() - Date.now()) / 1000;
+    for (const key of Object.keys(ranges)) {
+        if (ranges[key] < Math.abs(secondsElapsed)) {
+            const delta = secondsElapsed / ranges[key];
+            return formatter.format(Math.round(delta), key);
+        }
+    }
+    return 'Just now';
+}
+export const oneWeekFromNow = () => {
+    const now = new Date();
+    return new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000);
+};
+export const oneDayFromNow = () => {
+    const now = new Date();
+    return new Date(now.getTime() + 1 * 24 * 60 * 60 * 1000);
+};
+export const oneMinuteFromNow = () => {
+    const now = new Date();
+    return new Date(now.getTime() + 1 * 60 * 1000);
+};
+export function friendlyDuration(minutes, locale, short = false) {
+    const numberFormatter = new Intl.NumberFormat(locale);
+    if (!minutes) {
+        return null;
+    }
+    if (short) {
+        if (minutes > 120) {
+            const hours = Math.floor(minutes / 60);
+            const remainingMinutes = minutes % 60;
+            if (remainingMinutes > 0) {
+                return {
+                    key: 'common:duration.hoursAndMinutesShort',
+                    vars: {
+                        hours: numberFormatter.format(hours),
+                        minutes: numberFormatter.format(remainingMinutes),
+                    },
+                };
+            }
+            return {
+                key: 'common:duration.hoursShort',
+                vars: { hours: numberFormatter.format(hours) },
+            };
+        }
+        return {
+            key: 'common:duration.minutesShort',
+            vars: { minutes: numberFormatter.format(minutes) },
+        };
+    }
+    if (minutes >= 525600) {
+        const years = Math.floor(minutes / 525600);
+        return {
+            key: 'common:duration.years',
+            vars: {
+                count: years,
+                value: numberFormatter.format(years),
+            },
+        };
+    }
+    if (minutes >= 43200) {
+        const months = Math.floor(minutes / 43200);
+        return {
+            key: 'common:duration.months',
+            vars: {
+                count: months,
+                value: numberFormatter.format(months),
+            },
+        };
+    }
+    if (minutes >= 10080) {
+        const weeks = Math.floor(minutes / 10080);
+        return {
+            key: 'common:duration.weeks',
+            vars: {
+                count: weeks,
+                value: numberFormatter.format(weeks),
+            },
+        };
+    }
+    if (minutes >= 1440) {
+        const days = Math.floor(minutes / 1440);
+        return {
+            key: 'common:duration.days',
+            vars: {
+                count: days,
+                value: numberFormatter.format(days),
+            },
+        };
+    }
+    if (minutes >= 240) {
+        const hours = Math.floor(minutes / 60);
+        const remainingMinutes = minutes % 60;
+        if (remainingMinutes > 0) {
+            return {
+                key: 'common:duration.hoursAndMinutes',
+                vars: {
+                    hours: numberFormatter.format(hours),
+                    minutes: numberFormatter.format(remainingMinutes),
+                },
+            };
+        }
+        return {
+            key: 'common:duration.hours',
+            vars: {
+                count: hours,
+                value: numberFormatter.format(hours),
+            },
+        };
+    }
+    return {
+        key: 'common:duration.minutes',
+        vars: {
+            count: minutes,
+            value: numberFormatter.format(minutes),
+        },
+    };
+}
+export const dateTimeInUnix = (date) => {
+    return Math.floor(date / 1000);
+};

package/dist/time/time.test.d.ts

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

package/dist/time/time.test.d.ts.map

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