fimo 0.2.4 → 0.2.5-experimental.1782327181771

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

@@ -0,0 +1,177 @@
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import translationsPlugin from './translations';
+let scratch = null;
+let activePlugin = null;
+const originalFimoApiToken = process.env.FIMO_API_TOKEN;
+const pluginContext = {
+    addWatchFile: vi.fn(),
+    meta: {},
+    error: (error) => {
+        throw error;
+    },
+    info: () => undefined,
+    warn: () => undefined,
+    debug: () => undefined,
+};
+afterEach(() => {
+    if (activePlugin && typeof activePlugin.closeBundle === 'function') {
+        activePlugin.closeBundle.call(pluginContext);
+        activePlugin = null;
+    }
+    if (scratch) {
+        rmSync(scratch, { recursive: true, force: true });
+        scratch = null;
+    }
+    if (originalFimoApiToken === undefined) {
+        delete process.env.FIMO_API_TOKEN;
+    }
+    else {
+        process.env.FIMO_API_TOKEN = originalFimoApiToken;
+    }
+    vi.unstubAllGlobals();
+    vi.clearAllMocks();
+});
+function createProjectRoot() {
+    scratch = mkdtempSync(join(tmpdir(), 'fimo-translations-plugin-'));
+    writeFileSync(join(scratch, 'fimo-config.json'), JSON.stringify({ i18n: { defaultLocale: 'es', locales: ['es'] } }, null, 2));
+    writeFileSync(join(scratch, '.env'), 'VITE_API_URL=https://tenant.example.test\n');
+    return scratch;
+}
+function createPlugin(root, command) {
+    const plugin = translationsPlugin();
+    activePlugin = plugin;
+    if (typeof plugin.configResolved === 'function') {
+        plugin.configResolved.call(pluginContext, { root, command });
+    }
+    return plugin;
+}
+async function buildStart(plugin) {
+    if (typeof plugin.buildStart !== 'function') {
+        throw new Error('Expected buildStart hook');
+    }
+    await plugin.buildStart.call(pluginContext, {});
+}
+async function loadTranslations(plugin) {
+    if (typeof plugin.resolveId !== 'function' || typeof plugin.load !== 'function') {
+        throw new Error('Expected resolveId/load hooks');
+    }
+    const id = await plugin.resolveId.call(pluginContext, 'virtual:translations', undefined, {});
+    if (typeof id !== 'string') {
+        throw new Error('Expected virtual translations module id');
+    }
+    const result = await plugin.load.call(pluginContext, id, {});
+    if (typeof result !== 'string') {
+        throw new Error('Expected virtual translations source');
+    }
+    return result;
+}
+function createDevServer() {
+    return {
+        watcher: { add: vi.fn() },
+        moduleGraph: {
+            getModuleById: vi.fn(() => null),
+            idToModuleMap: new Map(),
+        },
+        ws: { send: vi.fn() },
+    };
+}
+function mockLabels(labels) {
+    const fetchMock = vi.fn(async () => jsonResponse({ data: { labels, updatedAt: '2026-06-24T00:00:00.000Z' } }));
+    vi.stubGlobal('fetch', fetchMock);
+    return fetchMock;
+}
+function jsonResponse(body) {
+    return {
+        ok: true,
+        json: async () => body,
+    };
+}
+async function waitFor(condition) {
+    const deadline = Date.now() + 1000;
+    while (Date.now() < deadline) {
+        if (condition()) {
+            return;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+    throw new Error('Timed out waiting for condition');
+}
+describe('translationsPlugin', () => {
+    it('does not block dev startup on the initial label fetch', async () => {
+        const root = createProjectRoot();
+        const fetchMock = mockLabels({ headline: 'Hola' });
+        const plugin = createPlugin(root, 'serve');
+        await buildStart(plugin);
+        expect(fetchMock).not.toHaveBeenCalled();
+        const source = await loadTranslations(plugin);
+        expect(source).toContain('export const translations = {};');
+        expect(source).toContain('export const locale = "es";');
+    });
+    it('invalidates the dev page when background labels arrive', async () => {
+        const root = createProjectRoot();
+        mockLabels({ headline: 'Hola' });
+        const plugin = createPlugin(root, 'serve');
+        await buildStart(plugin);
+        const server = createDevServer();
+        if (typeof plugin.configureServer !== 'function') {
+            throw new Error('Expected configureServer hook');
+        }
+        plugin.configureServer.call(pluginContext, server);
+        await waitFor(() => server.ws.send.mock.calls.length > 0);
+        expect(server.ws.send).toHaveBeenCalledWith({ type: 'full-reload', path: '*' });
+        const source = await loadTranslations(plugin);
+        expect(source).toContain('"headline":"Hola"');
+    });
+    it('discovers the events URL from tenant runtime config when env is absent', async () => {
+        const root = createProjectRoot();
+        const projectId = '11111111-1111-4111-8111-111111111111';
+        writeFileSync(join(root, '.fimo.settings.json'), JSON.stringify({ projectId, apiUrl: 'https://api.example.test' }));
+        process.env.FIMO_API_TOKEN = 'test-api-token';
+        const socketUrls = [];
+        vi.stubGlobal('WebSocket', class {
+            onopen = null;
+            onmessage = null;
+            onclose = null;
+            onerror = null;
+            constructor(url) {
+                socketUrls.push(url);
+            }
+            close() { }
+        });
+        vi.stubGlobal('fetch', vi.fn(async (input) => {
+            const url = new URL(input.toString());
+            if (url.pathname === '/labels') {
+                return jsonResponse({ data: { labels: {}, updatedAt: null } });
+            }
+            if (url.pathname === '/runtime-config') {
+                return jsonResponse({ data: { eventsServerUrl: 'https://events.example.test' } });
+            }
+            if (url.pathname === '/api/auth/one-time-token/generate') {
+                return jsonResponse({ data: { token: 'event-token' } });
+            }
+            return { ok: false, json: async () => ({}) };
+        }));
+        const plugin = createPlugin(root, 'serve');
+        await buildStart(plugin);
+        const server = createDevServer();
+        if (typeof plugin.configureServer !== 'function') {
+            throw new Error('Expected configureServer hook');
+        }
+        plugin.configureServer.call(pluginContext, server);
+        await waitFor(() => socketUrls.length > 0);
+        expect(socketUrls[0]).toContain(`wss://events.example.test/parties/events/${projectId}`);
+        expect(socketUrls[0]).toContain('authToken=event-token');
+    });
+    it('still waits for labels during production builds', async () => {
+        const root = createProjectRoot();
+        const fetchMock = mockLabels({ headline: 'Hola' });
+        const plugin = createPlugin(root, 'build');
+        await buildStart(plugin);
+        expect(fetchMock).toHaveBeenCalled();
+        const source = await loadTranslations(plugin);
+        expect(source).toContain('"headline":"Hola"');
+    });
+});

package/dist/cli/bundle.json

@@ -1,8 +1,8 @@
 {
   "bundled": true,
   "bundler": "esbuild",
-  "bundledAt": "2026-06-24T17:45:46.869Z",
-  "cliVersion": "0.2.4",
+  "bundledAt": "2026-06-24T18:53:10.760Z",
+  "cliVersion": "0.2.5-experimental.1782327181771",
   "external": [
     "oxc-parser",
     "fsevents"