@nuraly/lumenjs 0.1.3 → 0.2.0

package/dist/runtime/communication.js

@@ -0,0 +1,228 @@
+/**
+ * Client-side communication SDK.
+ * Connects to the server via Socket.io and provides a clean API for chat, typing, and presence.
+ */
+let _socket = null;
+let _handlers = new Map();
+function emit(event, data) {
+    if (!_socket)
+        throw new Error('Communication not connected. Call connectChat() first.');
+    _socket.emit(`nk:${event}`, data);
+}
+function addHandler(event, handler) {
+    let set = _handlers.get(event);
+    if (!set) {
+        set = new Set();
+        _handlers.set(event, set);
+    }
+    set.add(handler);
+}
+function removeHandler(event, handler) {
+    _handlers.get(event)?.delete(handler);
+}
+/**
+ * Connect to the communication socket.
+ * Must be called before using any other functions.
+ */
+export async function connectChat(params) {
+    if (_socket)
+        return;
+    const { io } = await import('socket.io-client');
+    _socket = io('/nk/messages', {
+        path: '/__nk_socketio/',
+        query: { ...params, __params: JSON.stringify(params || {}) },
+    });
+    _socket.on('nk:data', (data) => {
+        if (data?.event) {
+            const handlers = _handlers.get(data.event);
+            if (handlers) {
+                for (const h of handlers)
+                    h(data.data);
+            }
+        }
+    });
+}
+/** Join a conversation room to receive messages */
+export function joinConversation(conversationId) {
+    emit('conversation:join', { conversationId });
+}
+/** Leave a conversation room */
+export function leaveConversation(conversationId) {
+    emit('conversation:leave', { conversationId });
+}
+/** Send a message */
+export function sendMessage(conversationId, content, type = 'text') {
+    emit('message:send', { conversationId, content, type });
+}
+/** Mark a message as read */
+export function markRead(conversationId, messageId) {
+    emit('message:read', { conversationId, messageId });
+}
+/** React to a message with an emoji (toggle) */
+export function reactToMessage(messageId, conversationId, emoji) {
+    emit('message:react', { messageId, conversationId, emoji });
+}
+/** Edit a message */
+export function editMessage(messageId, conversationId, content) {
+    emit('message:edit', { messageId, conversationId, content });
+}
+/** Delete a message */
+export function deleteMessage(messageId, conversationId) {
+    emit('message:delete', { messageId, conversationId });
+}
+/** Listen for reaction updates */
+export function onReactionUpdate(handler) {
+    addHandler('message:reaction-update', handler);
+    return () => removeHandler('message:reaction-update', handler);
+}
+/** Listen for message edits */
+export function onMessageUpdated(handler) {
+    addHandler('message:updated', handler);
+    return () => removeHandler('message:updated', handler);
+}
+/** Listen for message deletions */
+export function onMessageDeleted(handler) {
+    addHandler('message:deleted', handler);
+    return () => removeHandler('message:deleted', handler);
+}
+/** Upload a file (returns attachment metadata) */
+export async function uploadFile(file, filename, encrypted = false) {
+    const res = await fetch('/__nk_comm/upload', {
+        method: 'POST',
+        headers: {
+            'Content-Type': file.type || 'application/octet-stream',
+            'X-Filename': filename,
+            ...(encrypted ? { 'X-Encrypted': '1' } : {}),
+        },
+        body: file,
+    });
+    if (!res.ok)
+        throw new Error(`Upload failed: ${res.status}`);
+    return res.json();
+}
+/** Fetch link previews for a text */
+export async function fetchLinkPreviews(text) {
+    const res = await fetch('/__nk_comm/link-preview', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ text }),
+    });
+    if (!res.ok)
+        return [];
+    const data = await res.json();
+    return data.previews || [];
+}
+/** Start typing indicator */
+export function startTyping(conversationId) {
+    emit('typing:start', { conversationId });
+}
+/** Stop typing indicator */
+export function stopTyping(conversationId) {
+    emit('typing:stop', { conversationId });
+}
+/** Update presence status */
+export function updatePresence(status) {
+    emit('presence:update', { status });
+}
+/** Listen for new messages */
+export function onMessage(handler) {
+    addHandler('message:new', handler);
+    return () => removeHandler('message:new', handler);
+}
+/** Listen for typing updates */
+export function onTyping(handler) {
+    addHandler('typing:update', handler);
+    return () => removeHandler('typing:update', handler);
+}
+/** Listen for presence changes */
+export function onPresence(handler) {
+    addHandler('presence:changed', handler);
+    return () => removeHandler('presence:changed', handler);
+}
+/** Listen for read receipts */
+export function onReadReceipt(handler) {
+    addHandler('read-receipt:update', handler);
+    return () => removeHandler('read-receipt:update', handler);
+}
+// ── Calls ─────────────────────────────────────────────────────────
+/** Listen for incoming calls */
+export function onIncomingCall(handler) {
+    addHandler('call:incoming', handler);
+    return () => removeHandler('call:incoming', handler);
+}
+/** Listen for call state changes (initiating, ringing, connecting, connected, ended) */
+export function onCallStateChanged(handler) {
+    addHandler('call:state-changed', handler);
+    return () => removeHandler('call:state-changed', handler);
+}
+/** Listen for participants joining a call */
+export function onParticipantJoined(handler) {
+    addHandler('call:participant-joined', handler);
+    return () => removeHandler('call:participant-joined', handler);
+}
+/** Listen for participants leaving a call */
+export function onParticipantLeft(handler) {
+    addHandler('call:participant-left', handler);
+    return () => removeHandler('call:participant-left', handler);
+}
+/** Listen for media changes (mute/unmute/screenshare) */
+export function onMediaChanged(handler) {
+    addHandler('call:media-changed', handler);
+    return () => removeHandler('call:media-changed', handler);
+}
+/** Initiate an audio or video call */
+export function initiateCall(conversationId, type, calleeIds) {
+    emit('call:initiate', { conversationId, type, calleeIds });
+}
+/** Respond to an incoming call */
+export function respondToCall(callId, action) {
+    emit('call:respond', { callId, action });
+}
+/** Hang up an active call */
+export function hangup(callId, reason = 'completed') {
+    emit('call:hangup', { callId, reason });
+}
+/** Toggle audio/video/screenshare during a call */
+export function toggleMedia(callId, opts) {
+    emit('call:media-toggle', { callId, ...opts });
+}
+// ── WebRTC Signaling ──────────────────────────────────────────────
+/** Send SDP offer to a peer */
+export function sendOffer(callId, toUserId, sdp) {
+    emit('signal:offer', { callId, fromUserId: '', toUserId, type: 'offer', sdp });
+}
+/** Send SDP answer to a peer */
+export function sendAnswer(callId, toUserId, sdp) {
+    emit('signal:answer', { callId, fromUserId: '', toUserId, type: 'answer', sdp });
+}
+/** Send ICE candidate to a peer */
+export function sendIceCandidate(callId, toUserId, candidate, sdpMLineIndex, sdpMid) {
+    emit('signal:ice-candidate', { callId, fromUserId: '', toUserId, candidate, sdpMLineIndex, sdpMid });
+}
+/** Listen for SDP offers from peers */
+export function onSignalOffer(handler) {
+    addHandler('signal:offer', handler);
+    return () => removeHandler('signal:offer', handler);
+}
+/** Listen for SDP answers from peers */
+export function onSignalAnswer(handler) {
+    addHandler('signal:answer', handler);
+    return () => removeHandler('signal:answer', handler);
+}
+/** Listen for ICE candidates from peers */
+export function onIceCandidate(handler) {
+    addHandler('signal:ice-candidate', handler);
+    return () => removeHandler('signal:ice-candidate', handler);
+}
+/** Disconnect from communication socket */
+export function disconnect() {
+    if (_socket) {
+        _socket.disconnect();
+        _socket = null;
+        _handlers.clear();
+    }
+}
+/** Check if connected */
+export function isConnected() {
+    return _socket?.connected ?? false;
+}

package/dist/runtime/error-boundary.d.ts

@@ -0,0 +1,23 @@
+/**
+ * <nk-error-boundary> — Client-side error boundary for Lit/web component pages.
+ *
+ * Wraps page content via <slot>. If a child throws during render or in an
+ * event handler, catches the error and displays a fallback UI.
+ *
+ * Usage:
+ *   <nk-error-boundary>
+ *     <my-page></my-page>
+ *   </nk-error-boundary>
+ *
+ * Attributes:
+ *   fallback-message — Custom message shown on error (default: "Something went wrong")
+ */
+declare class NkErrorBoundary extends HTMLElement {
+    private hasError;
+    private caughtError;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private handleError;
+    private showFallback;
+    private recover;
+}

package/dist/runtime/error-boundary.js

@@ -0,0 +1,120 @@
+"use strict";
+/**
+ * <nk-error-boundary> — Client-side error boundary for Lit/web component pages.
+ *
+ * Wraps page content via <slot>. If a child throws during render or in an
+ * event handler, catches the error and displays a fallback UI.
+ *
+ * Usage:
+ *   <nk-error-boundary>
+ *     <my-page></my-page>
+ *   </nk-error-boundary>
+ *
+ * Attributes:
+ *   fallback-message — Custom message shown on error (default: "Something went wrong")
+ */
+class NkErrorBoundary extends HTMLElement {
+    constructor() {
+        super(...arguments);
+        this.hasError = false;
+        this.caughtError = null;
+        this.handleError = (event) => {
+            event.stopPropagation();
+            this.showFallback(event.error || new Error(event.message));
+        };
+    }
+    connectedCallback() {
+        // Listen for unhandled errors from slotted children
+        this.addEventListener('error', this.handleError);
+        // Create a slot for normal content
+        if (!this.shadowRoot) {
+            const shadow = this.attachShadow({ mode: 'open' });
+            shadow.innerHTML = `
+        <style>
+          :host { display: contents; }
+          .nk-error-fallback {
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            justify-content: center;
+            padding: 2rem;
+            min-height: 200px;
+            font-family: system-ui, -apple-system, sans-serif;
+            color: #dc2626;
+            text-align: center;
+          }
+          .nk-error-fallback h2 {
+            margin: 0 0 0.5rem;
+            font-size: 1.25rem;
+            font-weight: 600;
+          }
+          .nk-error-fallback p {
+            margin: 0 0 1rem;
+            color: #6b7280;
+            font-size: 0.875rem;
+          }
+          .nk-error-fallback button {
+            padding: 0.5rem 1rem;
+            border: 1px solid #d1d5db;
+            border-radius: 0.375rem;
+            background: white;
+            color: #374151;
+            font-size: 0.875rem;
+            cursor: pointer;
+          }
+          .nk-error-fallback button:hover {
+            background: #f9fafb;
+          }
+          .nk-error-hidden { display: none; }
+        </style>
+        <slot></slot>
+        <div class="nk-error-fallback nk-error-hidden">
+          <h2></h2>
+          <p></p>
+          <button>Try again</button>
+        </div>
+      `;
+            const button = shadow.querySelector('button');
+            button.addEventListener('click', () => this.recover());
+        }
+    }
+    disconnectedCallback() {
+        this.removeEventListener('error', this.handleError);
+    }
+    showFallback(error) {
+        this.hasError = true;
+        this.caughtError = error;
+        const shadow = this.shadowRoot;
+        if (!shadow)
+            return;
+        const slot = shadow.querySelector('slot');
+        const fallback = shadow.querySelector('.nk-error-fallback');
+        const message = this.getAttribute('fallback-message') || 'Something went wrong';
+        slot.classList.add('nk-error-hidden');
+        fallback.classList.remove('nk-error-hidden');
+        fallback.querySelector('h2').textContent = message;
+        fallback.querySelector('p').textContent = error.message || 'An unexpected error occurred.';
+        // Dispatch custom event for external error tracking
+        this.dispatchEvent(new CustomEvent('nk-error', {
+            bubbles: true,
+            composed: true,
+            detail: { error },
+        }));
+    }
+    recover() {
+        this.hasError = false;
+        this.caughtError = null;
+        const shadow = this.shadowRoot;
+        if (!shadow)
+            return;
+        const slot = shadow.querySelector('slot');
+        const fallback = shadow.querySelector('.nk-error-fallback');
+        fallback.classList.add('nk-error-hidden');
+        slot.classList.remove('nk-error-hidden');
+        // Re-trigger the current route to re-render
+        window.dispatchEvent(new PopStateEvent('popstate'));
+    }
+}
+if (!customElements.get('nk-error-boundary')) {
+    customElements.define('nk-error-boundary', NkErrorBoundary);
+}

package/dist/runtime/i18n.d.ts

@@ -1,6 +1,11 @@
 /**
  * LumenJS i18n runtime — provides translation lookup, locale management,
  * and translation loading for both SSR and client-side navigation.
+ *
+ * State is stored on globalThis so that it survives Vite's SSR module
+ * invalidation. During dev SSR, page and layout modules may each get a
+ * separate copy of this module after cache invalidation — globalThis
+ * ensures they all read from the same translation map.
  */
 /**
  * Look up a translation key. Returns the translated string, or the key itself
@@ -31,7 +36,7 @@ export declare function initI18n(config: {
 }, locale: string, trans: Record<string, string>): void;
 /**
  * Load translations for a locale from the server and swap them in.
- * Used during client-side locale switches.
+ * Used during client-side locale switches and HMR updates.
  */
 export declare function loadTranslations(locale: string): Promise<void>;
 /**

package/dist/runtime/i18n.js

@@ -1,31 +1,38 @@
 /**
  * LumenJS i18n runtime — provides translation lookup, locale management,
  * and translation loading for both SSR and client-side navigation.
+ *
+ * State is stored on globalThis so that it survives Vite's SSR module
+ * invalidation. During dev SSR, page and layout modules may each get a
+ * separate copy of this module after cache invalidation — globalThis
+ * ensures they all read from the same translation map.
  */
-let currentLocale = 'en';
-let translations = {};
-let i18nConfig = null;
+const G = globalThis;
+if (!G.__nk_i18n) {
+    G.__nk_i18n = { locale: 'en', translations: {}, config: null };
+}
+const state = G.__nk_i18n;
 /**
  * Look up a translation key. Returns the translated string, or the key itself
  * if no translation is found.
  */
 export function t(key) {
-    return translations[key] ?? key;
+    return state.translations[key] ?? key;
 }
 /** Returns the current locale. */
 export function getLocale() {
-    return currentLocale;
+    return state.locale;
 }
 /** Returns the i18n config, or null if i18n is not enabled. */
 export function getI18nConfig() {
-    return i18nConfig;
+    return state.config;
 }
 /**
  * Switch to a new locale. Navigates to the same pathname under the new
  * locale prefix and sets the `nk-locale` cookie.
  */
 export function setLocale(locale) {
-    if (!i18nConfig || !i18nConfig.locales.includes(locale))
+    if (!state.config || !state.config.locales.includes(locale))
         return;
     document.cookie = `nk-locale=${locale};path=/;max-age=${60 * 60 * 24 * 365};SameSite=Lax`;
     const pathname = stripLocalePrefix(location.pathname);
@@ -37,13 +44,13 @@ export function setLocale(locale) {
  * Called during hydration (from SSR data) or on first load.
  */
 export function initI18n(config, locale, trans) {
-    i18nConfig = config;
-    currentLocale = locale;
-    translations = trans;
+    state.config = config;
+    state.locale = locale;
+    state.translations = trans;
 }
 /**
  * Load translations for a locale from the server and swap them in.
- * Used during client-side locale switches.
+ * Used during client-side locale switches and HMR updates.
  */
 export async function loadTranslations(locale) {
     const res = await fetch(`/__nk_i18n/${locale}.json`);
@@ -51,8 +58,22 @@ export async function loadTranslations(locale) {
         console.error(`[i18n] Failed to load translations for locale "${locale}"`);
         return;
     }
-    translations = await res.json();
-    currentLocale = locale;
+    state.translations = await res.json();
+    state.locale = locale;
+}
+/**
+ * Register the HMR reload handler on the global scope.
+ * The i18n Vite plugin injects an inline script that calls this function
+ * when a locale file changes — ensuring translations are updated in this
+ * module instance (not a duplicate created by Vite's cache-busting).
+ */
+if (typeof window !== 'undefined') {
+    window.__lumenjs_i18n_reload = async (locale) => {
+        if (locale !== state.locale)
+            return false;
+        await loadTranslations(locale);
+        return true;
+    };
 }
 /**
  * Strip the locale prefix from a pathname.
@@ -60,10 +81,10 @@ export async function loadTranslations(locale) {
  *   /about    → /about
  */
 export function stripLocalePrefix(pathname) {
-    if (!i18nConfig)
+    if (!state.config)
         return pathname;
-    for (const loc of i18nConfig.locales) {
-        if (loc === i18nConfig.defaultLocale && !i18nConfig.prefixDefault)
+    for (const loc of state.config.locales) {
+        if (loc === state.config.defaultLocale && !state.config.prefixDefault)
             continue;
         if (pathname === `/${loc}` || pathname.startsWith(`/${loc}/`)) {
             return pathname.slice(loc.length + 1) || '/';
@@ -77,9 +98,9 @@ export function stripLocalePrefix(pathname) {
  *   (en, /about) → /about        (when prefixDefault=false)
  */
 export function buildLocalePath(locale, pathname) {
-    if (!i18nConfig)
+    if (!state.config)
         return pathname;
-    if (locale === i18nConfig.defaultLocale && !i18nConfig.prefixDefault) {
+    if (locale === state.config.defaultLocale && !state.config.prefixDefault) {
         return pathname;
     }
     return `/${locale}${pathname === '/' ? '' : pathname}` || `/${locale}`;
@@ -89,12 +110,12 @@ export function buildLocalePath(locale, pathname) {
  * Returns the locale and the pathname with the prefix stripped.
  */
 export function detectLocaleFromPath(pathname) {
-    if (!i18nConfig)
+    if (!state.config)
         return { locale: 'en', pathname };
-    for (const loc of i18nConfig.locales) {
+    for (const loc of state.config.locales) {
         if (pathname === `/${loc}` || pathname.startsWith(`/${loc}/`)) {
             return { locale: loc, pathname: pathname.slice(loc.length + 1) || '/' };
         }
     }
-    return { locale: i18nConfig.defaultLocale, pathname };
+    return { locale: state.config.defaultLocale, pathname };
 }

package/dist/runtime/island.d.ts

@@ -0,0 +1,16 @@
+/**
+ * <nk-island> — Islands Architecture hydration wrapper.
+ *
+ * Strategies:
+ *   client:load    — import module immediately on page load
+ *   client:visible — import module when the element scrolls into view
+ *   client:idle    — import module when the browser is idle (requestIdleCallback)
+ *   client:media   — import module when a media query matches (value = query string)
+ *
+ * The `import` attribute specifies the module path to load.
+ */
+declare class NkIsland extends HTMLElement {
+    private _loaded;
+    connectedCallback(): void;
+    private _hydrate;
+}

package/dist/runtime/island.js

@@ -0,0 +1,80 @@
+"use strict";
+/**
+ * <nk-island> — Islands Architecture hydration wrapper.
+ *
+ * Strategies:
+ *   client:load    — import module immediately on page load
+ *   client:visible — import module when the element scrolls into view
+ *   client:idle    — import module when the browser is idle (requestIdleCallback)
+ *   client:media   — import module when a media query matches (value = query string)
+ *
+ * The `import` attribute specifies the module path to load.
+ */
+class NkIsland extends HTMLElement {
+    constructor() {
+        super(...arguments);
+        this._loaded = false;
+    }
+    connectedCallback() {
+        const importPath = this.getAttribute('import');
+        if (!importPath || this._loaded)
+            return;
+        if (this.hasAttribute('client:load')) {
+            this._hydrate(importPath);
+        }
+        else if (this.hasAttribute('client:visible')) {
+            const observer = new IntersectionObserver((entries) => {
+                if (entries[0]?.isIntersecting) {
+                    observer.disconnect();
+                    this._hydrate(importPath);
+                }
+            }, { rootMargin: '200px' });
+            observer.observe(this);
+        }
+        else if (this.hasAttribute('client:idle')) {
+            const cb = () => this._hydrate(importPath);
+            if ('requestIdleCallback' in window) {
+                window.requestIdleCallback(cb);
+            }
+            else {
+                setTimeout(cb, 200);
+            }
+        }
+        else if (this.hasAttribute('client:media')) {
+            const query = this.getAttribute('client:media') || '';
+            const mql = window.matchMedia(query);
+            const handler = () => {
+                if (mql.matches) {
+                    mql.removeEventListener('change', handler);
+                    this._hydrate(importPath);
+                }
+            };
+            if (mql.matches) {
+                this._hydrate(importPath);
+            }
+            else {
+                mql.addEventListener('change', handler);
+            }
+        }
+    }
+    _hydrate(importPath) {
+        if (this._loaded)
+            return;
+        this._loaded = true;
+        // Check global island registry (populated by pages with island imports)
+        const registry = window.__nk_islands;
+        const loader = registry?.[importPath];
+        const promise = loader
+            ? loader()
+            : import(/* @vite-ignore */ importPath);
+        promise.then(() => {
+            this.setAttribute('data-hydrated', '');
+            this.dispatchEvent(new Event('island-hydrated', { bubbles: true, composed: true }));
+        }).catch((err) => {
+            console.error(`[nk-island] Failed to load module: ${importPath}`, err);
+        });
+    }
+}
+if (!customElements.get('nk-island')) {
+    customElements.define('nk-island', NkIsland);
+}

package/dist/runtime/router-data.d.ts

@@ -1,3 +1,6 @@
+export declare function getCachedLoaderData(key: string): any | undefined;
+export declare function prefetchLoaderData(pathname: string, params: Record<string, string>): Promise<any>;
+export declare function prefetchLayoutLoaderData(dir: string): Promise<any>;
 export declare function fetchLoaderData(pathname: string, params: Record<string, string>): Promise<any>;
 export declare function fetchLayoutLoaderData(dir: string): Promise<any>;
 export declare function connectSubscribe(pathname: string, params: Record<string, string>): EventSource;