@relax.js/core 1.0.3 → 1.0.5

package/docs/http/ServerSentEvents.md

@@ -1,184 +1,184 @@
-# Server-Sent Events
-
-SSE client that dispatches received server events as DOM events.
-
-## Quick Start
-
-```typescript
-import { SSEClient, SSEDataEvent } from 'relaxjs/http';
-
-const sse = new SSEClient('/api/events', {
-    eventTypes: ['user-updated', 'notification']
-});
-
-sse.connect();
-
-document.addEventListener('user-updated', (e: SSEDataEvent) => {
-    console.log('User updated:', e.data);
-});
-
-// When done
-sse.disconnect();
-```
-
-## Configuration
-
-```typescript
-interface SSEOptions {
-    target?: string | Element;      // CSS selector or element (default: document)
-    withCredentials?: boolean;      // Send credentials (default: false)
-    eventTypes?: string[];          // SSE event types to listen for
-    eventFactory?: SSEEventFactory; // Custom event factory
-    onConnect?: (client: SSEClient) => void;
-    onError?: (client: SSEClient, error: Event) => void;
-}
-
-type SSEEventFactory = (eventName: string, data: unknown) => Event;
-```
-
-## Event Types
-
-### Default (message)
-
-Without `eventTypes`, listens to the default `message` event:
-
-```typescript
-// Server sends: data: {"text": "hello"}
-const sse = new SSEClient('/api/events');
-sse.connect();
-
-document.addEventListener('message', (e: SSEDataEvent) => {
-    console.log(e.data); // { text: 'hello' }
-});
-```
-
-### Named Events
-
-With `eventTypes`, listens to specific SSE event types:
-
-```typescript
-// Server sends: event: notification\ndata: {"text": "hello"}
-const sse = new SSEClient('/api/events', {
-    eventTypes: ['notification', 'alert']
-});
-sse.connect();
-
-document.addEventListener('notification', (e: SSEDataEvent) => {
-    console.log(e.data);
-});
-```
-
-## Target Element
-
-Dispatch events to a specific element instead of document:
-
-```typescript
-const sse = new SSEClient('/api/events', {
-    target: '#notifications',
-    eventTypes: ['notification']
-});
-
-sse.connect();
-
-document.querySelector('#notifications')
-    .addEventListener('notification', (e: SSEDataEvent) => {
-        showNotification(e.data);
-    });
-```
-
-## Event Factory
-
-Use `eventFactory` to create custom event instances:
-
-```typescript
-class UserUpdatedEvent extends Event {
-    constructor(public user: User) {
-        super('user-updated', { bubbles: true });
-    }
-}
-
-class OrderCreatedEvent extends Event {
-    constructor(public order: Order) {
-        super('order-created', { bubbles: true });
-    }
-}
-
-const sse = new SSEClient('/api/events', {
-    eventTypes: ['user-updated', 'order-created'],
-    eventFactory: (eventName, data) => {
-        switch (eventName) {
-            case 'user-updated':
-                return new UserUpdatedEvent(data as User);
-            case 'order-created':
-                return new OrderCreatedEvent(data as Order);
-            default:
-                return new SSEDataEvent(eventName, data);
-        }
-    }
-});
-
-sse.connect();
-
-// Now events are properly typed
-document.addEventListener('user-updated', (e: UserUpdatedEvent) => {
-    console.log(e.user);
-});
-```
-
-## Type Registration
-
-Register event types for TypeScript support:
-
-```typescript
-declare global {
-    interface DocumentEventMap {
-        'user-updated': UserUpdatedEvent;
-        'order-created': OrderCreatedEvent;
-    }
-}
-
-// TypeScript now knows the event type
-document.addEventListener('user-updated', (e) => {
-    console.log(e.user); // Typed as User
-});
-```
-
-## Reconnection
-
-EventSource has built-in automatic reconnection. The `onError` callback fires when errors occur, but the browser handles reconnection automatically.
-
-```typescript
-const sse = new SSEClient('/api/events', {
-    onConnect: () => console.log('Connected'),
-    onError: () => console.log('Error (will auto-reconnect)')
-});
-```
-
-## API Reference
-
-### SSEClient
-
-| Method/Property | Description |
-|-----------------|-------------|
-| `connect()` | Establish SSE connection |
-| `disconnect()` | Close connection |
-| `connected` | `boolean` - Current connection state |
-
-### SSEDataEvent
-
-| Property | Type | Description |
-|----------|------|-------------|
-| `type` | `string` | Event name from SSE |
-| `data` | `unknown` | Parsed data (JSON auto-parsed) |
-| `bubbles` | `boolean` | Always `true` |
-
-### Exports
-
-```typescript
-import {
-    SSEClient,
-    SSEOptions,
-    SSEDataEvent,
-    SSEEventFactory
-} from 'relaxjs/http';
-```
+# Server-Sent Events
+
+SSE client that dispatches received server events as DOM events.
+
+## Quick Start
+
+```typescript
+import { SSEClient, SSEDataEvent } from '@relax.js/core/http';
+
+const sse = new SSEClient('/api/events', {
+    eventTypes: ['user-updated', 'notification']
+});
+
+sse.connect();
+
+document.addEventListener('user-updated', (e: SSEDataEvent) => {
+    console.log('User updated:', e.data);
+});
+
+// When done
+sse.disconnect();
+```
+
+## Configuration
+
+```typescript
+interface SSEOptions {
+    target?: string | Element;      // CSS selector or element (default: document)
+    withCredentials?: boolean;      // Send credentials (default: false)
+    eventTypes?: string[];          // SSE event types to listen for
+    eventFactory?: SSEEventFactory; // Custom event factory
+    onConnect?: (client: SSEClient) => void;
+    onError?: (client: SSEClient, error: Event) => void;
+}
+
+type SSEEventFactory = (eventName: string, data: unknown) => Event;
+```
+
+## Event Types
+
+### Default (message)
+
+Without `eventTypes`, listens to the default `message` event:
+
+```typescript
+// Server sends: data: {"text": "hello"}
+const sse = new SSEClient('/api/events');
+sse.connect();
+
+document.addEventListener('message', (e: SSEDataEvent) => {
+    console.log(e.data); // { text: 'hello' }
+});
+```
+
+### Named Events
+
+With `eventTypes`, listens to specific SSE event types:
+
+```typescript
+// Server sends: event: notification\ndata: {"text": "hello"}
+const sse = new SSEClient('/api/events', {
+    eventTypes: ['notification', 'alert']
+});
+sse.connect();
+
+document.addEventListener('notification', (e: SSEDataEvent) => {
+    console.log(e.data);
+});
+```
+
+## Target Element
+
+Dispatch events to a specific element instead of document:
+
+```typescript
+const sse = new SSEClient('/api/events', {
+    target: '#notifications',
+    eventTypes: ['notification']
+});
+
+sse.connect();
+
+document.querySelector('#notifications')
+    .addEventListener('notification', (e: SSEDataEvent) => {
+        showNotification(e.data);
+    });
+```
+
+## Event Factory
+
+Use `eventFactory` to create custom event instances:
+
+```typescript
+class UserUpdatedEvent extends Event {
+    constructor(public user: User) {
+        super('user-updated', { bubbles: true });
+    }
+}
+
+class OrderCreatedEvent extends Event {
+    constructor(public order: Order) {
+        super('order-created', { bubbles: true });
+    }
+}
+
+const sse = new SSEClient('/api/events', {
+    eventTypes: ['user-updated', 'order-created'],
+    eventFactory: (eventName, data) => {
+        switch (eventName) {
+            case 'user-updated':
+                return new UserUpdatedEvent(data as User);
+            case 'order-created':
+                return new OrderCreatedEvent(data as Order);
+            default:
+                return new SSEDataEvent(eventName, data);
+        }
+    }
+});
+
+sse.connect();
+
+// Now events are properly typed
+document.addEventListener('user-updated', (e: UserUpdatedEvent) => {
+    console.log(e.user);
+});
+```
+
+## Type Registration
+
+Register event types for TypeScript support:
+
+```typescript
+declare global {
+    interface DocumentEventMap {
+        'user-updated': UserUpdatedEvent;
+        'order-created': OrderCreatedEvent;
+    }
+}
+
+// TypeScript now knows the event type
+document.addEventListener('user-updated', (e) => {
+    console.log(e.user); // Typed as User
+});
+```
+
+## Reconnection
+
+EventSource has built-in automatic reconnection. The `onError` callback fires when errors occur, but the browser handles reconnection automatically.
+
+```typescript
+const sse = new SSEClient('/api/events', {
+    onConnect: () => console.log('Connected'),
+    onError: () => console.log('Error (will auto-reconnect)')
+});
+```
+
+## API Reference
+
+### SSEClient
+
+| Method/Property | Description |
+|-----------------|-------------|
+| `connect()` | Establish SSE connection |
+| `disconnect()` | Close connection |
+| `connected` | `boolean` - Current connection state |
+
+### SSEDataEvent
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `type` | `string` | Event name from SSE |
+| `data` | `unknown` | Parsed data (JSON auto-parsed) |
+| `bubbles` | `boolean` | Always `true` |
+
+### Exports
+
+```typescript
+import {
+    SSEClient,
+    SSEOptions,
+    SSEDataEvent,
+    SSEEventFactory
+} from '@relax.js/core/http';
+```

package/docs/http/index.md

@@ -1,109 +1,109 @@
-# HTTP, WebSocket & SSE
-
-This module provides HTTP, WebSocket, and Server-Sent Events clients for network communication.
-
-## Available Features
-
-| Feature | Description | Use Case |
-|---------|-------------|----------|
-| [HTTP Client](HttpClient.md#http-client) | Type-safe HTTP functions | REST API calls with JWT handling |
-| [WebSocketClient](HttpClient.md#websocket-client) | WebSocket client with auto-reconnect | Real-time bidirectional messaging |
-| [SSEClient](ServerSentEvents.md) | Server-Sent Events as DOM events | Server push notifications |
-
-## Quick Start
-
-### HTTP Requests
-
-```typescript
-import { configure, get, post } from 'relaxjs/http';
-
-configure({ baseUrl: '/api/v1' });
-
-// GET with query parameters
-const response = await get('/users', { status: 'active' });
-if (response.success) {
-    const users = response.as<User[]>();
-}
-
-// POST with JSON body
-const result = await post('/users', JSON.stringify({ name: 'John' }));
-```
-
-### WebSocket Messaging
-
-```typescript
-import { WebSocketClient } from 'relaxjs/http';
-
-const ws = new WebSocketClient<Message>('wss://api.example.com');
-ws.connect();
-
-// Check connection state
-console.log(ws.connected); // true when connected
-
-// Send (queued if disconnected)
-ws.send({ type: 'chat', text: 'Hello' });
-
-// Receive (rejects if connection closes)
-try {
-    const message = await ws.receive();
-} catch (e) {
-    console.log('Connection closed');
-}
-
-// Disconnect when done
-ws.disconnect();
-```
-
-### Server-Sent Events
-
-```typescript
-import { SSEClient } from 'relaxjs/http';
-
-const sse = new SSEClient('/api/events', {
-    eventTypes: ['user-updated', 'notification']
-});
-sse.connect();
-
-// Events dispatch to document by default
-document.addEventListener('notification', (e: SSEMessageEvent) => {
-    showNotification(e.data);
-});
-
-// Disconnect when done
-sse.disconnect();
-```
-
-## Key Features
-
-### HTTP Client
-
-- Standalone functions (`get`, `post`, `put`, `del`, `request`)
-- Module-wide configuration via `configure()`
-- Automatic base URL prefixing
-- JWT token from localStorage (configurable)
-- Query string building
-- Type-safe response casting
-- Replaceable fetch for testing via `setFetch()`
-
-### WebSocketClient
-
-- Auto-reconnect with exponential backoff
-- Message queuing when disconnected
-- Custom message codecs
-- Type-safe generic messages
-- Connection state tracking
-- Graceful disconnect support
-
-### SSEClient
-
-- Dispatches SSE events as DOM events
-- Configurable target element or document
-- Auto-reconnect with exponential backoff
-- Automatic JSON parsing
-
-## Choosing the Right Tool
-
-- **REST API calls?** → Use `get`, `post`, `put`, `del`
-- **Bidirectional real-time?** → Use `WebSocketClient`
-- **Server push only?** → Use `SSEClient`
-- **Both?** → Use `HttpClient` for requests, `WebSocketClient` or `SSEClient` for subscriptions
+# HTTP, WebSocket & SSE
+
+This module provides HTTP, WebSocket, and Server-Sent Events clients for network communication.
+
+## Available Features
+
+| Feature | Description | Use Case |
+|---------|-------------|----------|
+| [HTTP Client](HttpClient.md#http-client) | Type-safe HTTP functions | REST API calls with JWT handling |
+| [WebSocketClient](HttpClient.md#websocket-client) | WebSocket client with auto-reconnect | Real-time bidirectional messaging |
+| [SSEClient](ServerSentEvents.md) | Server-Sent Events as DOM events | Server push notifications |
+
+## Quick Start
+
+### HTTP Requests
+
+```typescript
+import { configure, get, post } from '@relax.js/core/http';
+
+configure({ baseUrl: '/api/v1' });
+
+// GET with query parameters
+const response = await get('/users', { status: 'active' });
+if (response.success) {
+    const users = response.as<User[]>();
+}
+
+// POST with JSON body
+const result = await post('/users', JSON.stringify({ name: 'John' }));
+```
+
+### WebSocket Messaging
+
+```typescript
+import { WebSocketClient } from '@relax.js/core/http';
+
+const ws = new WebSocketClient<Message>('wss://api.example.com');
+ws.connect();
+
+// Check connection state
+console.log(ws.connected); // true when connected
+
+// Send (queued if disconnected)
+ws.send({ type: 'chat', text: 'Hello' });
+
+// Receive (rejects if connection closes)
+try {
+    const message = await ws.receive();
+} catch (e) {
+    console.log('Connection closed');
+}
+
+// Disconnect when done
+ws.disconnect();
+```
+
+### Server-Sent Events
+
+```typescript
+import { SSEClient } from '@relax.js/core/http';
+
+const sse = new SSEClient('/api/events', {
+    eventTypes: ['user-updated', 'notification']
+});
+sse.connect();
+
+// Events dispatch to document by default
+document.addEventListener('notification', (e: SSEMessageEvent) => {
+    showNotification(e.data);
+});
+
+// Disconnect when done
+sse.disconnect();
+```
+
+## Key Features
+
+### HTTP Client
+
+- Standalone functions (`get`, `post`, `put`, `del`, `request`)
+- Module-wide configuration via `configure()`
+- Automatic base URL prefixing
+- JWT token from localStorage (configurable)
+- Query string building
+- Type-safe response casting
+- Replaceable fetch for testing via `setFetch()`
+
+### WebSocketClient
+
+- Auto-reconnect with exponential backoff
+- Message queuing when disconnected
+- Custom message codecs
+- Type-safe generic messages
+- Connection state tracking
+- Graceful disconnect support
+
+### SSEClient
+
+- Dispatches SSE events as DOM events
+- Configurable target element or document
+- Auto-reconnect with exponential backoff
+- Automatic JSON parsing
+
+## Choosing the Right Tool
+
+- **REST API calls?** → Use `get`, `post`, `put`, `del`
+- **Bidirectional real-time?** → Use `WebSocketClient`
+- **Server push only?** → Use `SSEClient`
+- **Both?** → Use `HttpClient` for requests, `WebSocketClient` or `SSEClient` for subscriptions

package/docs/i18n/i18n.md

@@ -5,7 +5,7 @@ Namespace-based translations with ICU message format, lazy loading, and locale c
 ## Quick Start
 
 ```typescript
-import { setLocale, loadNamespaces, t } from 'relaxjs/i18n';
+import { setLocale, loadNamespaces, t } from '@relax.js/core/i18n';
 
 await setLocale('sv');
 await loadNamespaces(['r-pipes', 'r-validation']);
@@ -106,6 +106,51 @@ t('status', { role: 'editor' });   // "Can edit"
 t('status', { role: 'viewer' });   // "Read only"  (other)
 ```
 
+### Number and Date Formatting
+
+ICU format supports locale-aware number and date formatting:
+
+```json
+{
+    "price": "Price: {amount, number, currency}",
+    "date": "Date: {date, date, medium}"
+}
+```
+
+## Example Translation Files
+
+**`src/i18n/locales/en/r-common.json`**:
+
+```json
+{
+    "welcome": "Welcome to our site!",
+    "greeting": "Hello, {name}!",
+    "items": "{count, plural, =0 {No items} one {# item} other {# items}}",
+    "goodbye": "Goodbye!"
+}
+```
+
+**`src/i18n/locales/en/errors.json`**:
+
+```json
+{
+    "notFound": "Page not found",
+    "unauthorized": "You are not authorized to view this page",
+    "serverError": "An unexpected error occurred"
+}
+```
+
+**`src/i18n/locales/sv/r-common.json`**:
+
+```json
+{
+    "welcome": "Välkommen till vår sida!",
+    "greeting": "Hej, {name}!",
+    "items": "{count, plural, =0 {Inga föremål} one {# föremål} other {# föremål}}",
+    "goodbye": "Hejdå!"
+}
+```
+
 ## Built-in Namespaces
 
 ### r-common
@@ -173,7 +218,7 @@ The event has a typed `locale` property (the normalized locale code) and is regi
 Register a callback for when `t()` encounters a missing key. Useful for development tooling, logging, or collecting untranslated strings:
 
 ```typescript
-import { onMissingTranslation } from 'relaxjs/i18n';
+import { onMissingTranslation } from '@relax.js/core/i18n';
 
 onMissingTranslation((key, namespace, locale) => {
     console.warn(`Missing: ${namespace}:${key} [${locale}]`);
@@ -197,7 +242,7 @@ onMissingTranslation(null);
 The built-in formatter supports interpolation, pluralization, and select. For advanced ICU features (nested arguments, date/time formatting in messages), use an external library:
 
 ```typescript
-import { setMessageFormatter } from 'relaxjs/i18n';
+import { setMessageFormatter } from '@relax.js/core/i18n';
 import { IntlMessageFormat } from 'intl-messageformat';
 
 setMessageFormatter((message, values, locale) => {
@@ -284,7 +329,7 @@ type MissingTranslationHandler = (
 import {
     setLocale, loadNamespaces, t,
     getCurrentLocale, onMissingTranslation,
-} from 'relaxjs/i18n';
+} from '@relax.js/core/i18n';
 
 async function initI18n() {
     // Dev-time missing key logging