fimo 0.10.0 → 0.10.1-staging.2

package/dist/build/vite/plugins/translations.js

@@ -7,15 +7,25 @@ import { getFimoDefaultLocale, getFimoLocales } from '../../../runtime/i18n/loca
 import { getConfigServer } from '../../../runtime/shared/fimo-config.server.js';
 const VIRTUAL_ID = 'virtual:translations';
 const RESOLVED_ID = '\0' + VIRTUAL_ID;
+const EVENT_RECONNECT_DELAY_MS = 2000;
+const FALLBACK_POLL_INTERVAL_MS = 30_000;
+const LABEL_FETCH_TIMEOUT_MS = 30_000;
 export default function translationsPlugin() {
     let rootDir = process.cwd();
-    let bundle = { dictionaries: { en: {} }, defaultLocale: 'en', locales: ['en'], updatedAt: null };
+    let bundle = {
+        dictionaries: { en: {} },
+        defaultLocale: 'en',
+        locales: ['en'],
+        updatedAt: null,
+    };
     let command = 'build';
     let devServer = null;
     let eventSockets = [];
     let reconnectTimer;
     let refreshTimer;
     let pollTimer;
+    let eventConnectionAttempt = 0;
+    let closed = false;
     const refreshLabels = async () => {
         bundle = await loadLabelBundle(rootDir);
         return bundle;
@@ -51,13 +61,91 @@ export default function translationsPlugin() {
         });
     };
     const scheduleRefresh = () => {
+        if (closed) {
+            return;
+        }
         if (refreshTimer) {
             clearTimeout(refreshTimer);
         }
         refreshTimer = setTimeout(() => {
+            refreshTimer = undefined;
+            if (closed) {
+                return;
+            }
             void refreshLabelsAndInvalidateIfChanged().catch(() => undefined);
         }, 150);
     };
+    const startFallbackPolling = () => {
+        if (closed || pollTimer) {
+            return;
+        }
+        pollTimer = setInterval(() => {
+            void refreshLabelsAndInvalidateIfChanged().catch(() => undefined);
+        }, FALLBACK_POLL_INTERVAL_MS);
+    };
+    const stopFallbackPolling = () => {
+        if (!pollTimer) {
+            return;
+        }
+        clearInterval(pollTimer);
+        pollTimer = undefined;
+    };
+    const closeEventSockets = () => {
+        closeSockets(eventSockets.splice(0));
+    };
+    const scheduleReconnect = (delayMs = EVENT_RECONNECT_DELAY_MS) => {
+        startFallbackPolling();
+        if (closed || reconnectTimer) {
+            return;
+        }
+        reconnectTimer = setTimeout(() => {
+            reconnectTimer = undefined;
+            closeEventSockets();
+            void connectEvents();
+        }, delayMs);
+    };
+    const connectEvents = async () => {
+        if (closed) {
+            return;
+        }
+        const attempt = ++eventConnectionAttempt;
+        const sockets = [];
+        eventSockets = sockets;
+        try {
+            await connectLabelEvents(rootDir, scheduleRefresh, sockets, {
+                isActive: () => !closed && attempt === eventConnectionAttempt,
+                onConnected: () => {
+                    if (closed || attempt !== eventConnectionAttempt) {
+                        return;
+                    }
+                    if (reconnectTimer) {
+                        clearTimeout(reconnectTimer);
+                        reconnectTimer = undefined;
+                    }
+                    stopFallbackPolling();
+                },
+                onDisconnected: () => {
+                    if (closed || attempt !== eventConnectionAttempt) {
+                        return;
+                    }
+                    scheduleReconnect();
+                },
+            });
+            if (closed || attempt !== eventConnectionAttempt) {
+                closeSockets(sockets.splice(0));
+                return;
+            }
+            if (sockets.length === 0) {
+                scheduleReconnect(FALLBACK_POLL_INTERVAL_MS);
+            }
+        }
+        catch {
+            if (!closed && attempt === eventConnectionAttempt) {
+                closeEventSockets();
+                scheduleReconnect(FALLBACK_POLL_INTERVAL_MS);
+            }
+        }
+    };
     return {
         name: 'fimo-virtual-translations',
         enforce: 'pre',
@@ -76,16 +164,11 @@ export default function translationsPlugin() {
         },
         configureServer(server) {
             devServer = server;
+            closed = false;
             server.watcher.add([join(rootDir, 'fimo-config.json'), join(rootDir, '.env'), join(rootDir, '.env.local')]);
             void refreshLabelsAndInvalidateIfChanged().catch(() => undefined);
-            connectLabelEvents(rootDir, scheduleRefresh)
-                .then((sockets) => {
-                eventSockets = sockets;
-            })
-                .catch(() => undefined);
-            pollTimer = setInterval(() => {
-                void refreshLabelsAndInvalidateIfChanged().catch(() => undefined);
-            }, 2000);
+            startFallbackPolling();
+            void connectEvents();
         },
         resolveId(id) {
             if (id === VIRTUAL_ID) {
@@ -128,84 +211,119 @@ export default function translationsPlugin() {
             return [];
         },
         closeBundle() {
-            for (const socket of eventSockets) {
-                socket.close();
-            }
-            eventSockets = [];
+            closed = true;
+            eventConnectionAttempt += 1;
+            closeEventSockets();
+            devServer = null;
             if (reconnectTimer) {
                 clearTimeout(reconnectTimer);
+                reconnectTimer = undefined;
             }
             if (refreshTimer) {
                 clearTimeout(refreshTimer);
+                refreshTimer = undefined;
             }
-            if (pollTimer) {
-                clearInterval(pollTimer);
-            }
+            stopFallbackPolling();
         },
     };
-    async function connectLabelEvents(root, onLabelsChanged) {
+    async function connectLabelEvents(root, onLabelsChanged, sockets, callbacks) {
         const env = await readProjectEnv(root);
+        if (!callbacks.isActive()) {
+            return;
+        }
         const apiUrl = env.VITE_API_URL;
         if (!apiUrl) {
-            return [];
+            return;
         }
         const runtimeConfig = await loadRuntimeConfig(apiUrl);
+        if (!callbacks.isActive()) {
+            return;
+        }
         const eventsUrl = runtimeConfig.eventsServerUrl ?? undefined;
         if (!eventsUrl) {
-            return [];
+            return;
         }
         const settings = await readProjectSettings(root);
+        if (!callbacks.isActive()) {
+            return;
+        }
         if (!settings.projectId) {
-            return [];
+            return;
         }
         const WebSocketCtor = globalThis.WebSocket;
         if (!WebSocketCtor) {
-            return [];
+            return;
         }
-        const sockets = [];
-        for (const room of deriveEventsRooms(settings.projectId, apiUrl)) {
-            const token = await generateOneTimeToken(settings.apiUrl ?? process.env.FIMO_API_URL ?? 'http://localhost:3000');
-            const wsUrl = new URL(`/parties/events/${room}`, eventsUrl.replace(/^http/, 'ws'));
-            wsUrl.searchParams.set('authToken', token);
-            const socket = new WebSocketCtor(wsUrl.toString());
-            socket.onmessage = (event) => {
-                const raw = typeof event.data === 'string' ? event.data : '';
-                if (!raw) {
+        const rooms = deriveEventsRooms(settings.projectId, apiUrl);
+        const openSockets = new Set();
+        try {
+            for (const room of rooms) {
+                const token = await generateOneTimeToken(settings.apiUrl ?? process.env.FIMO_API_URL ?? 'http://localhost:3000');
+                if (!callbacks.isActive()) {
+                    closeSockets(sockets.splice(0));
                     return;
                 }
-                try {
-                    const message = JSON.parse(raw);
-                    if (message.type === 'content:changed') {
-                        emitContentUpdate(parseContentChangePayload(message.payload));
+                const wsUrl = new URL(`/parties/events/${room}`, eventsUrl.replace(/^http/, 'ws'));
+                wsUrl.searchParams.set('authToken', token);
+                const socket = new WebSocketCtor(wsUrl.toString());
+                socket.onopen = () => {
+                    if (!callbacks.isActive()) {
                         return;
                     }
-                    if (message.type !== 'labels:changed') {
+                    openSockets.add(socket);
+                    if (openSockets.size === rooms.length) {
+                        callbacks.onConnected();
+                    }
+                };
+                socket.onmessage = (event) => {
+                    if (!callbacks.isActive()) {
                         return;
                     }
-                    const changedLocales = message.payload?.changes
-                        ?.map((change) => change.locale)
-                        .filter((locale) => typeof locale === 'string') ?? [];
-                    if (changedLocales.length === 0 || changedLocales.some((locale) => bundle.locales.includes(locale))) {
-                        onLabelsChanged();
+                    const raw = typeof event.data === 'string' ? event.data : '';
+                    if (!raw) {
+                        return;
                     }
-                }
-                catch {
-                    return;
-                }
-            };
-            socket.onclose = () => {
-                reconnectTimer = setTimeout(() => {
-                    void connectLabelEvents(root, onLabelsChanged)
-                        .then((nextSockets) => {
-                        eventSockets = nextSockets;
-                    })
-                        .catch(() => undefined);
-                }, 2000);
-            };
-            socket.onerror = () => undefined;
-            sockets.push(socket);
+                    try {
+                        const message = JSON.parse(raw);
+                        if (message.type === 'content:changed') {
+                            emitContentUpdate(parseContentChangePayload(message.payload));
+                            return;
+                        }
+                        if (message.type !== 'labels:changed') {
+                            return;
+                        }
+                        const changedLocales = message.payload?.changes
+                            ?.map((change) => change.locale)
+                            .filter((locale) => typeof locale === 'string') ?? [];
+                        if (changedLocales.length === 0 || changedLocales.some((locale) => bundle.locales.includes(locale))) {
+                            onLabelsChanged();
+                        }
+                    }
+                    catch {
+                        return;
+                    }
+                };
+                socket.onclose = () => {
+                    openSockets.delete(socket);
+                    callbacks.onDisconnected();
+                };
+                socket.onerror = callbacks.onDisconnected;
+                sockets.push(socket);
+            }
         }
-        return sockets;
+        catch (error) {
+            closeSockets(sockets.splice(0));
+            throw error;
+        }
+    }
+}
+function closeSockets(sockets) {
+    for (const socket of sockets) {
+        socket.onopen = null;
+        socket.onmessage = null;
+        socket.onclose = null;
+        socket.onerror = null;
+        socket.close();
     }
 }
 function parseContentChangePayload(payload) {
@@ -306,7 +424,7 @@ export async function loadLabelBundle(rootDir) {
 async function fetchLabelDictionary(apiUrl, locale) {
     const url = new URL('/labels', apiUrl);
     url.searchParams.set('locale', locale);
-    const response = await fetchWithTimeout(url, 4000);
+    const response = await fetchWithTimeout(url, LABEL_FETCH_TIMEOUT_MS);
     if (!response.ok) {
         return { locale, labels: {}, updatedAt: null };
     }

package/dist/cli/bundle.json

@@ -1,7 +1,7 @@
 {
   "bundled": true,
   "bundler": "esbuild",
-  "bundledAt": "2026-07-27T11:53:13.436Z",
+  "bundledAt": "2026-07-28T15:18:08.648Z",
   "cliVersion": "0.10.0",
   "external": [
     "oxc-parser",