@regardio/js 0.2.0

package/LICENSE

@@ -0,0 +1,9 @@
+# The MIT License (MIT)
+
+Copyright © 2025 Regardio
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,156 @@
+# @regardio/js
+
+> **TypeScript utilities for Regardio applications**
+
+A collection of lightweight, tree-shakeable utility functions for common tasks
+like HTTP handling, internationalization, time formatting, and validation.
+
+## Installation
+
+```bash
+pnpm add @regardio/js
+```
+
+## Modules
+
+### async/delay
+
+Promise-based delay utility.
+
+```ts
+import { delay } from '@regardio/js/async/delay';
+
+await delay(1000); // Wait 1 second
+```
+
+### browser/base64
+
+URL-safe base64 to Uint8Array conversion (useful for Web Push).
+
+```ts
+import { urlBase64ToUint8Array } from '@regardio/js/browser/base64';
+
+const bytes = urlBase64ToUint8Array(vapidPublicKey);
+```
+
+### format/bytes
+
+Human-readable byte formatting.
+
+```ts
+import { formatBytes } from '@regardio/js/format/bytes';
+
+formatBytes(1500000); // "1.5 MB"
+```
+
+### format/measure
+
+Performance measurement with logging.
+
+```ts
+import { measure } from '@regardio/js/format/measure';
+
+const result = await measure('fetchData', async () => {
+  return await fetch('/api/data');
+});
+// Logs: "fetchData took 123ms"
+```
+
+### http/cookie
+
+Browser cookie get/set helpers.
+
+```ts
+import { getCookieValue, setCookieValue } from '@regardio/js/http/cookie';
+
+setCookieValue('theme', 'dark', { path: '/', secure: true });
+const theme = getCookieValue('theme');
+```
+
+### http/domain
+
+Domain extraction from requests (proxy-aware).
+
+```ts
+import { createDomain } from '@regardio/js/http/domain';
+
+const domain = createDomain(request); // "https://example.com"
+```
+
+### http/request-helpers
+
+URL cleaning utilities.
+
+```ts
+import { getCleanUrl } from '@regardio/js/http/request-helpers';
+
+getCleanUrl(request); // URL without search params
+```
+
+### intl/language-detector
+
+Server-side language detection for i18n (works with Lingui).
+
+```ts
+import { LanguageDetector } from '@regardio/js/intl/language-detector';
+
+const detector = new LanguageDetector({
+  supportedLanguages: ['en', 'de'],
+  fallbackLanguage: 'en',
+});
+
+const locale = await detector.detect(request);
+```
+
+### intl/locale
+
+Client locale extraction from Accept-Language header.
+
+```ts
+import { getClientLocales } from '@regardio/js/intl/locale';
+
+const locales = getClientLocales(request); // ['en-US', 'de']
+```
+
+### time/time
+
+Time formatting utilities.
+
+```ts
+import { timeAgo, friendlyDuration, oneWeekFromNow } from '@regardio/js/time/time';
+
+timeAgo(new Date('2024-01-01')); // "3 months ago"
+friendlyDuration(150, 'en', true); // { key: 'common:duration.hoursAndMinutesShort', vars: {...} }
+const expires = oneWeekFromNow();
+```
+
+### validation/invariant
+
+Runtime assertion utilities.
+
+```ts
+import { invariant, invariantResponse } from '@regardio/js/validation/invariant';
+
+invariant(user, 'User not found'); // Throws Error if falsy
+invariantResponse(user, 'User not found', { status: 404 }); // Throws Response if falsy
+```
+
+### validation/verify-file-accept
+
+MIME type validation for file uploads.
+
+```ts
+import { verifyAccept } from '@regardio/js/validation/verify-file-accept';
+
+verifyAccept('image/png', 'image/*'); // true
+verifyAccept('video/mp4', 'image/*'); // false
+```
+
+## License
+
+**MIT License** - Free to use in commercial and open source projects.
+
+---
+
+*Part of the [Regardio Ensemble](https://regard.io/ensemble) toolkit for
+collective well-being.*

package/dist/async/delay.d.ts

@@ -0,0 +1,2 @@
+export declare function delay(ms: number): Promise<unknown>;
+//# sourceMappingURL=delay.d.ts.map

package/dist/async/delay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delay.d.ts","sourceRoot":"","sources":["../../src/async/delay.ts"],"names":[],"mappings":"AAIA,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,oBAI/B"}

package/dist/async/delay.js

@@ -0,0 +1,5 @@
+export function delay(ms) {
+    return new Promise((resolve) => {
+        return setTimeout(resolve, ms);
+    });
+}

package/dist/async/delay.test.d.ts

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

package/dist/async/delay.test.d.ts.map

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

package/dist/async/delay.test.js

@@ -0,0 +1,35 @@
+import { describe, expect, test, vi } from 'vitest';
+import { delay } from './delay';
+describe('delay', () => {
+    test('should return a promise', () => {
+        const result = delay(0);
+        expect(result).toBeInstanceOf(Promise);
+    });
+    test('should resolve after the specified time', async () => {
+        vi.useFakeTimers();
+        const promise = delay(100);
+        vi.advanceTimersByTime(100);
+        await expect(promise).resolves.toBeUndefined();
+        vi.useRealTimers();
+    });
+    test('should not resolve before the specified time', async () => {
+        vi.useFakeTimers();
+        let resolved = false;
+        delay(100).then(() => {
+            resolved = true;
+        });
+        vi.advanceTimersByTime(50);
+        expect(resolved).toBe(false);
+        vi.advanceTimersByTime(50);
+        await Promise.resolve();
+        expect(resolved).toBe(true);
+        vi.useRealTimers();
+    });
+    test('should work with 0ms delay', async () => {
+        vi.useFakeTimers();
+        const promise = delay(0);
+        vi.advanceTimersByTime(0);
+        await expect(promise).resolves.toBeUndefined();
+        vi.useRealTimers();
+    });
+});

package/dist/browser/base64.d.ts

@@ -0,0 +1,2 @@
+export declare const urlBase64ToUint8Array: (base64String: string) => Uint8Array;
+//# sourceMappingURL=base64.d.ts.map

package/dist/browser/base64.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base64.d.ts","sourceRoot":"","sources":["../../src/browser/base64.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,qBAAqB,GAAI,cAAc,MAAM,KAAG,UAW5D,CAAC"}

package/dist/browser/base64.js

@@ -0,0 +1,10 @@
+export const urlBase64ToUint8Array = (base64String) => {
+    const padding = '='.repeat((4 - (base64String.length % 4)) % 4);
+    const base64 = (base64String + padding).replace(/-/g, '+').replace(/_/g, '/');
+    const rawData = window.atob(base64);
+    const outputArray = new Uint8Array(rawData.length);
+    for (let i = 0; i < rawData.length; ++i) {
+        outputArray[i] = rawData.charCodeAt(i);
+    }
+    return outputArray;
+};

package/dist/format/bytes.d.ts

@@ -0,0 +1,2 @@
+export declare function formatBytes(bytes: number, decimals?: number): string;
+//# sourceMappingURL=bytes.d.ts.map

package/dist/format/bytes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytes.d.ts","sourceRoot":"","sources":["../../src/format/bytes.ts"],"names":[],"mappings":"AAAA,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,SAAI,UAetD"}

package/dist/format/bytes.js

@@ -0,0 +1,10 @@
+export function formatBytes(bytes, decimals = 2) {
+    if (!+bytes) {
+        return '0 Bytes';
+    }
+    const k = 1000;
+    const dm = decimals < 0 ? 0 : decimals;
+    const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${Number.parseFloat((bytes / k ** i).toFixed(dm))} ${sizes[i]}`;
+}

package/dist/format/bytes.test.d.ts

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

package/dist/format/bytes.test.d.ts.map

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

package/dist/format/bytes.test.js

@@ -0,0 +1,49 @@
+import { describe, expect, test } from 'vitest';
+import { formatBytes } from './bytes';
+describe('formatBytes', () => {
+    test('should return "0 Bytes" for 0', () => {
+        expect(formatBytes(0)).toBe('0 Bytes');
+    });
+    test('should return "0 Bytes" for NaN', () => {
+        expect(formatBytes(Number.NaN)).toBe('0 Bytes');
+    });
+    test('should format bytes correctly', () => {
+        expect(formatBytes(1)).toBe('1 Bytes');
+        expect(formatBytes(500)).toBe('500 Bytes');
+        expect(formatBytes(999)).toBe('999 Bytes');
+    });
+    test('should format kilobytes correctly (base 10)', () => {
+        expect(formatBytes(1000)).toBe('1 KB');
+        expect(formatBytes(1500)).toBe('1.5 KB');
+        expect(formatBytes(999000)).toBe('999 KB');
+    });
+    test('should format megabytes correctly', () => {
+        expect(formatBytes(1000000)).toBe('1 MB');
+        expect(formatBytes(1500000)).toBe('1.5 MB');
+        expect(formatBytes(999000000)).toBe('999 MB');
+    });
+    test('should format gigabytes correctly', () => {
+        expect(formatBytes(1000000000)).toBe('1 GB');
+        expect(formatBytes(1500000000)).toBe('1.5 GB');
+    });
+    test('should format terabytes correctly', () => {
+        expect(formatBytes(1000000000000)).toBe('1 TB');
+    });
+    test('should format petabytes correctly', () => {
+        expect(formatBytes(1000000000000000)).toBe('1 PB');
+    });
+    test('should respect custom decimal places', () => {
+        expect(formatBytes(1234, 0)).toBe('1 KB');
+        expect(formatBytes(1234, 1)).toBe('1.2 KB');
+        expect(formatBytes(1234, 2)).toBe('1.23 KB');
+        expect(formatBytes(1234, 3)).toBe('1.234 KB');
+    });
+    test('should handle negative decimal places as 0', () => {
+        expect(formatBytes(1234, -1)).toBe('1 KB');
+        expect(formatBytes(1234, -5)).toBe('1 KB');
+    });
+    test('should handle large numbers', () => {
+        expect(formatBytes(1e21)).toBe('1 ZB');
+        expect(formatBytes(1e24)).toBe('1 YB');
+    });
+});

package/dist/format/measure.d.ts

@@ -0,0 +1,2 @@
+export declare function measure<Result>(key: string, callback: () => Result | Promise<Result>): Promise<Result>;
+//# sourceMappingURL=measure.d.ts.map

package/dist/format/measure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"measure.d.ts","sourceRoot":"","sources":["../../src/format/measure.ts"],"names":[],"mappings":"AAAA,wBAAsB,OAAO,CAAC,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,mBAc1F"}

package/dist/format/measure.js

@@ -0,0 +1,14 @@
+export async function measure(key, callback) {
+    const start = Date.now();
+    try {
+        let result = callback();
+        if (result instanceof Promise) {
+            result = await result;
+        }
+        return result;
+    }
+    finally {
+        const end = Date.now();
+        console.log(`${key} took ${end - start}ms`);
+    }
+}

package/dist/format/measure.test.d.ts

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

package/dist/format/measure.test.d.ts.map

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

package/dist/format/measure.test.js

@@ -0,0 +1,50 @@
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
+import { measure } from './measure';
+describe('measure', () => {
+    beforeEach(() => {
+        vi.spyOn(console, 'log').mockImplementation(() => { });
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    test('should return the result of a synchronous callback', async () => {
+        const result = await measure('test', () => 42);
+        expect(result).toBe(42);
+    });
+    test('should return the result of an async callback', async () => {
+        const result = await measure('test', async () => 'async result');
+        expect(result).toBe('async result');
+    });
+    test('should log the execution time with the key', async () => {
+        vi.spyOn(Date, 'now').mockReturnValueOnce(1000).mockReturnValueOnce(1050);
+        await measure('myOperation', () => 'result');
+        expect(console.log).toHaveBeenCalledWith('myOperation took 50ms');
+    });
+    test('should log even if the callback throws', async () => {
+        vi.spyOn(Date, 'now').mockReturnValueOnce(1000).mockReturnValueOnce(1100);
+        await expect(measure('failingOp', () => {
+            throw new Error('test error');
+        })).rejects.toThrow('test error');
+        expect(console.log).toHaveBeenCalledWith('failingOp took 100ms');
+    });
+    test('should log even if async callback rejects', async () => {
+        vi.spyOn(Date, 'now').mockReturnValueOnce(1000).mockReturnValueOnce(1200);
+        await expect(measure('asyncFail', () => {
+            return Promise.reject(new Error('async error'));
+        })).rejects.toThrow('async error');
+        expect(console.log).toHaveBeenCalledWith('asyncFail took 200ms');
+    });
+    test('should handle callbacks returning undefined', async () => {
+        const result = await measure('voidOp', () => undefined);
+        expect(result).toBeUndefined();
+    });
+    test('should handle callbacks returning null', async () => {
+        const result = await measure('nullOp', () => null);
+        expect(result).toBeNull();
+    });
+    test('should handle callbacks returning objects', async () => {
+        const obj = { foo: 'bar', num: 123 };
+        const result = await measure('objectOp', () => obj);
+        expect(result).toEqual(obj);
+    });
+});

package/dist/http/cookie.d.ts

@@ -0,0 +1,9 @@
+export declare function setCookieValue(name: string, value: string, options?: {
+    expires?: Date;
+    path?: string;
+    sameSite?: string;
+    secure?: boolean;
+    domain?: string;
+}): void;
+export declare function getCookieValue(name: string): string | null;
+//# sourceMappingURL=cookie.d.ts.map

package/dist/http/cookie.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cookie.d.ts","sourceRoot":"","sources":["../../src/http/cookie.ts"],"names":[],"mappings":"AAMA,wBAAgB,cAAc,CAC5B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,OAAO,GAAE;IACP,OAAO,CAAC,EAAE,IAAI,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;CACZ,GACL,IAAI,CAuCN;AAOD,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAe1D"}

package/dist/http/cookie.js

@@ -0,0 +1,46 @@
+export function setCookieValue(name, value, options = {}) {
+    if (typeof window === 'undefined') {
+        console.warn('Cannot set cookie on server side');
+        return;
+    }
+    let cookieString = `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
+    if (options.expires) {
+        cookieString += `; expires=${options.expires.toUTCString()}`;
+    }
+    if (options.path) {
+        cookieString += `; path=${options.path}`;
+    }
+    if (options.sameSite) {
+        cookieString += `; SameSite=${options.sameSite}`;
+    }
+    if (options.secure) {
+        cookieString += '; Secure';
+    }
+    if (options.domain) {
+        cookieString += `; domain=${options.domain}`;
+    }
+    try {
+        document.cookie = cookieString;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            console.error(`Failed to set cookie '${name}':`, error.message);
+        }
+        else {
+            console.error(`Failed to set cookie '${name}': Unknown error`);
+        }
+    }
+}
+export function getCookieValue(name) {
+    if (typeof window === 'undefined') {
+        console.warn('Cannot get cookie on server side');
+        return null;
+    }
+    const value = `; ${document.cookie}`;
+    const parts = value.split(`; ${name}=`);
+    if (parts.length === 2) {
+        const cookieValue = parts.pop()?.split(';').shift();
+        return cookieValue ? decodeURIComponent(cookieValue) : null;
+    }
+    return null;
+}

package/dist/http/domain.d.ts

@@ -0,0 +1,2 @@
+export declare const createDomain: (request: Request) => string;
+//# sourceMappingURL=domain.d.ts.map

package/dist/http/domain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain.d.ts","sourceRoot":"","sources":["../../src/http/domain.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,YAAY,GAAI,SAAS,OAAO,KAAG,MAmB/C,CAAC"}

package/dist/http/domain.js

@@ -0,0 +1,13 @@
+export const createDomain = (request) => {
+    const headers = request.headers;
+    const maybeProto = headers.get('x-forwarded-proto');
+    const maybeHost = headers.get('host');
+    const url = new URL(request.url);
+    if (maybeProto) {
+        return `${maybeProto}://${maybeHost ?? url.host}`;
+    }
+    if (url.hostname === 'localhost') {
+        return `http://${url.host}`;
+    }
+    return `https://${url.host}`;
+};

package/dist/http/domain.test.d.ts

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

package/dist/http/domain.test.d.ts.map

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

package/dist/http/domain.test.js

@@ -0,0 +1,29 @@
+import { describe, expect, test } from 'vitest';
+import { createDomain } from './domain';
+describe('createDomain', () => {
+    test('handles request behind proxy with x-forwarded-proto', () => {
+        const request = new Request('http://example.com', {
+            headers: {
+                host: 'example.com',
+                'x-forwarded-proto': 'https',
+            },
+        });
+        expect(createDomain(request)).toBe('https://example.com');
+    });
+    test('handles localhost development environment', () => {
+        const request = new Request('http://localhost:3000/path');
+        expect(createDomain(request)).toBe('http://localhost:3000');
+    });
+    test('handles production environment', () => {
+        const request = new Request('https://production.com/path');
+        expect(createDomain(request)).toBe('https://production.com');
+    });
+    test('uses URL host when x-forwarded-proto exists but host header is missing', () => {
+        const request = new Request('http://example.com', {
+            headers: {
+                'x-forwarded-proto': 'https',
+            },
+        });
+        expect(createDomain(request)).toBe('https://example.com');
+    });
+});

package/dist/http/request-helpers.d.ts

@@ -0,0 +1,2 @@
+export declare function getCleanUrl(request: Request): string;
+//# sourceMappingURL=request-helpers.d.ts.map

package/dist/http/request-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-helpers.d.ts","sourceRoot":"","sources":["../../src/http/request-helpers.ts"],"names":[],"mappings":"AAAA,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,UAQ3C"}

package/dist/http/request-helpers.js

@@ -0,0 +1,7 @@
+export function getCleanUrl(request) {
+    const url = new URL(request.url);
+    url.searchParams.forEach((_, key) => {
+        url.searchParams.delete(key);
+    });
+    return url.toString();
+}

package/dist/http/request-helpers.test.d.ts

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

package/dist/http/request-helpers.test.d.ts.map

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

package/dist/http/request-helpers.test.js

@@ -0,0 +1,37 @@
+import { describe, expect, test } from 'vitest';
+import { getCleanUrl } from './request-helpers';
+describe('getCleanUrl', () => {
+    test('should return URL without search params', () => {
+        const request = new Request('https://example.com/path?foo=bar');
+        expect(getCleanUrl(request)).toBe('https://example.com/path');
+    });
+    test('should return URL unchanged if no search params', () => {
+        const request = new Request('https://example.com/path');
+        expect(getCleanUrl(request)).toBe('https://example.com/path');
+    });
+    test('should preserve the path', () => {
+        const request = new Request('https://example.com/some/deep/path?param=value');
+        expect(getCleanUrl(request)).toBe('https://example.com/some/deep/path');
+    });
+    test('should preserve the hash', () => {
+        const request = new Request('https://example.com/path?foo=bar#section');
+        const result = getCleanUrl(request);
+        expect(result).toBe('https://example.com/path#section');
+    });
+    test('should handle root path', () => {
+        const request = new Request('https://example.com/?foo=bar');
+        expect(getCleanUrl(request)).toBe('https://example.com/');
+    });
+    test('should handle multiple search params', () => {
+        const request = new Request('https://example.com/page?a=1&a=2&a=3');
+        expect(getCleanUrl(request)).toBe('https://example.com/page');
+    });
+    test('should handle URL with port', () => {
+        const request = new Request('https://example.com:8080/path?foo=bar');
+        expect(getCleanUrl(request)).toBe('https://example.com:8080/path');
+    });
+    test('should handle localhost', () => {
+        const request = new Request('http://localhost:3000/api?debug=true');
+        expect(getCleanUrl(request)).toBe('http://localhost:3000/api');
+    });
+});

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

@@ -0,0 +1,33 @@
+import type { Cookie, SessionStorage } from 'react-router';
+export interface LanguageDetectorOption {
+    supportedLanguages: string[];
+    fallbackLanguage: string;
+    cookie?: Cookie;
+    sessionStorage?: SessionStorage;
+    sessionKey?: string;
+    searchParamKey?: string;
+    order?: Array<'urlPath' | 'searchParams' | 'cookie' | 'session' | 'header'>;
+}
+export interface LanguageDetectorLinguiOptions {
+    detection: LanguageDetectorOption;
+}
+export declare class LanguageDetectorLingui {
+    private detector;
+    private options;
+    constructor(options: LanguageDetectorLinguiOptions);
+    getLocale(request: Request): Promise<string>;
+}
+export declare class LanguageDetector {
+    private options;
+    constructor(options: LanguageDetectorOption);
+    detect(request: Request): Promise<string>;
+    private isSessionOnly;
+    private isCookieOnly;
+    private fromUrlPath;
+    private fromSearchParams;
+    private fromCookie;
+    private fromSessionStorage;
+    private fromHeader;
+    private fromSupported;
+}
+//# sourceMappingURL=language-detector.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"language-detector.d.ts","sourceRoot":"","sources":["../../src/intl/language-detector.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAG3D,MAAM,WAAW,sBAAsB;IAMrC,kBAAkB,EAAE,MAAM,EAAE,CAAC;IAM7B,gBAAgB,EAAE,MAAM,CAAC;IAKzB,MAAM,CAAC,EAAE,MAAM,CAAC;IAMhB,cAAc,CAAC,EAAE,cAAc,CAAC;IAMhC,UAAU,CAAC,EAAE,MAAM,CAAC;IAOpB,cAAc,CAAC,EAAE,MAAM,CAAC;IAWxB,KAAK,CAAC,EAAE,KAAK,CAAC,SAAS,GAAG,cAAc,GAAG,QAAQ,GAAG,SAAS,GAAG,QAAQ,CAAC,CAAC;CAC7E;AAED,MAAM,WAAW,6BAA6B;IAC5C,SAAS,EAAE,sBAAsB,CAAC;CACnC;AAED,qBAAa,sBAAsB;IACjC,OAAO,CAAC,QAAQ,CAAmB;IACnC,OAAO,CAAC,OAAO,CAAgC;gBAEnC,OAAO,EAAE,6BAA6B;IAgBrC,SAAS,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC;CAG1D;AAOD,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,OAAO,CAAyB;gBAE5B,OAAO,EAAE,sBAAsB;IAM9B,MAAM,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC;IAgCtD,OAAO,CAAC,aAAa;IAQrB,OAAO,CAAC,YAAY;IAMpB,OAAO,CAAC,WAAW;IAenB,OAAO,CAAC,gBAAgB;YAQV,UAAU;YAcV,kBAAkB;IAYhC,OAAO,CAAC,UAAU;IAUlB,OAAO,CAAC,aAAa;CAYtB"}