fimo-vite 0.21.0-experimental.1

package/dist/plugins/sitemap.js

@@ -0,0 +1,73 @@
+import { readFileSync } from 'fs';
+import { resolveFimoConfigPath } from 'fimo/config';
+import { getFimoPaths } from 'fimo/paths';
+function readSeoUrl() {
+    try {
+        const raw = readFileSync(resolveFimoConfigPath(process.cwd()), 'utf-8');
+        const config = JSON.parse(raw);
+        return config.seo?.url;
+    }
+    catch {
+        return undefined;
+    }
+}
+function buildSitemapXml(baseUrl, paths) {
+    const urls = paths
+        .map((path) => {
+        try {
+            return new URL(path, baseUrl).toString();
+        }
+        catch {
+            return undefined;
+        }
+    })
+        .filter((url) => typeof url === 'string');
+    const body = urls.map((url) => `  <url><loc>${url}</loc></url>`).join('\n');
+    return [
+        '<?xml version="1.0" encoding="UTF-8"?>',
+        '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">',
+        body,
+        '</urlset>',
+        '',
+    ].join('\n');
+}
+async function generateSitemap() {
+    const baseUrl = readSeoUrl();
+    if (!baseUrl) {
+        return undefined;
+    }
+    const fimoPaths = await getFimoPaths();
+    const paths = fimoPaths.map((p) => p.path);
+    return buildSitemapXml(baseUrl, paths);
+}
+export default function sitemapPlugin() {
+    return {
+        name: 'fimo:sitemap',
+        configureServer(server) {
+            server.middlewares.use(async (req, res, next) => {
+                if (req.url?.split('?')[0] !== '/sitemap.xml') {
+                    next();
+                    return;
+                }
+                const xml = await generateSitemap();
+                if (!xml) {
+                    next();
+                    return;
+                }
+                res.setHeader('Content-Type', 'application/xml; charset=utf-8');
+                res.end(xml);
+            });
+        },
+        async generateBundle() {
+            const xml = await generateSitemap();
+            if (!xml) {
+                return;
+            }
+            this.emitFile({
+                type: 'asset',
+                fileName: 'sitemap.xml',
+                source: xml,
+            });
+        },
+    };
+}

package/dist/plugins/translations.d.ts

@@ -0,0 +1,11 @@
+import type { Plugin } from 'vite';
+interface LabelBundle {
+    dictionaries: Record<string, Record<string, string>>;
+    defaultLocale: string;
+    locales: string[];
+    updatedAt: string | null;
+}
+export default function translationsPlugin(): Plugin;
+export declare function loadLabelBundle(rootDir: string): Promise<LabelBundle>;
+export {};
+//# sourceMappingURL=translations.d.ts.map

package/dist/plugins/translations.js

@@ -0,0 +1,600 @@
+import { Buffer } from 'node:buffer';
+import { createHash } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { getConfigServer, getFimoDefaultLocale, getFimoLocales, resolveFimoConfigPath } from 'fimo/config';
+import { CURRENT_PROJECT_LAYOUT, LEGACY_PROJECT_LAYOUT } from 'fimo/project-layout';
+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 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;
+    };
+    const refreshLabelsAndInvalidateIfChanged = async () => {
+        const before = serializeBundle(bundle);
+        const next = await refreshLabels();
+        if (serializeBundle(next) !== before) {
+            invalidateLabels();
+        }
+    };
+    const invalidateLabels = () => {
+        if (!devServer) {
+            return;
+        }
+        for (const mod of findVirtualTranslationModules(devServer)) {
+            devServer.moduleGraph.invalidateModule(mod);
+        }
+        devServer.ws.send({
+            type: 'custom',
+            event: 'fimo:labels-updated',
+            data: labelUpdatePayload(bundle),
+        });
+    };
+    const emitContentUpdate = (payload) => {
+        if (!devServer) {
+            return;
+        }
+        devServer.ws.send({
+            type: 'custom',
+            event: 'fimo:content-updated',
+            data: payload,
+        });
+    };
+    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',
+        configResolved(config) {
+            rootDir = config.root;
+            command = config.command;
+        },
+        async buildStart() {
+            bundle = emptyLabelBundle(rootDir);
+            this.addWatchFile(resolveFimoConfigPath(rootDir));
+            this.addWatchFile(join(rootDir, '.env'));
+            this.addWatchFile(join(rootDir, '.env.local'));
+            if (command === 'build') {
+                await refreshLabels();
+            }
+        },
+        configureServer(server) {
+            devServer = server;
+            closed = false;
+            server.watcher.add([resolveFimoConfigPath(rootDir), join(rootDir, '.env'), join(rootDir, '.env.local')]);
+            void refreshLabelsAndInvalidateIfChanged().catch(() => undefined);
+            startFallbackPolling();
+            void connectEvents();
+        },
+        resolveId(id) {
+            if (id === VIRTUAL_ID) {
+                return RESOLVED_ID;
+            }
+            return null;
+        },
+        async load(id) {
+            if (id !== RESOLVED_ID) {
+                return null;
+            }
+            const current = command === 'serve' ? bundle : await refreshLabels();
+            const dictionaries = JSON.stringify(current.dictionaries);
+            const defaultLabels = JSON.stringify(current.dictionaries[current.defaultLocale] ?? {});
+            return [
+                `export const dictionaries = ${dictionaries};`,
+                `export const labelsByLocale = dictionaries;`,
+                `export const translations = ${defaultLabels};`,
+                `export const labels = translations;`,
+                `export const defaultLocale = ${JSON.stringify(current.defaultLocale)};`,
+                `export const locale = defaultLocale;`,
+                `export const locales = ${JSON.stringify(current.locales)};`,
+                `export const updatedAt = ${JSON.stringify(current.updatedAt)};`,
+                `export const signature = ${JSON.stringify(labelSignature(current))};`,
+            ].join('\n');
+        },
+        async handleHotUpdate(ctx) {
+            const watched = new Set([resolveFimoConfigPath(rootDir), join(rootDir, '.env'), join(rootDir, '.env.local')]);
+            if (!watched.has(ctx.file)) {
+                return;
+            }
+            await refreshLabels();
+            const modules = findVirtualTranslationModules(ctx.server);
+            if (modules.length > 0) {
+                for (const mod of modules) {
+                    ctx.server.moduleGraph.invalidateModule(mod);
+                }
+                return modules;
+            }
+            return [];
+        },
+        closeBundle() {
+            closed = true;
+            eventConnectionAttempt += 1;
+            closeEventSockets();
+            devServer = null;
+            if (reconnectTimer) {
+                clearTimeout(reconnectTimer);
+                reconnectTimer = undefined;
+            }
+            if (refreshTimer) {
+                clearTimeout(refreshTimer);
+                refreshTimer = undefined;
+            }
+            stopFallbackPolling();
+        },
+    };
+    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;
+        }
+        const runtimeConfig = await loadRuntimeConfig(apiUrl);
+        if (!callbacks.isActive()) {
+            return;
+        }
+        const eventsUrl = runtimeConfig.eventsServerUrl ?? undefined;
+        if (!eventsUrl) {
+            return;
+        }
+        const settings = await readProjectSettings(root);
+        if (!callbacks.isActive()) {
+            return;
+        }
+        if (!settings.projectId) {
+            return;
+        }
+        const WebSocketCtor = globalThis.WebSocket;
+        if (!WebSocketCtor) {
+            return;
+        }
+        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;
+                }
+                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;
+                    }
+                    openSockets.add(socket);
+                    if (openSockets.size === rooms.length) {
+                        callbacks.onConnected();
+                    }
+                };
+                socket.onmessage = (event) => {
+                    if (!callbacks.isActive()) {
+                        return;
+                    }
+                    const raw = typeof event.data === 'string' ? event.data : '';
+                    if (!raw) {
+                        return;
+                    }
+                    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);
+            }
+        }
+        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) {
+    if (!payload || typeof payload !== 'object') {
+        return { changes: [] };
+    }
+    const source = payload;
+    const changes = Array.isArray(source.changes)
+        ? source.changes
+            .filter((change) => Boolean(change) && typeof change === 'object')
+            .map((change) => ({
+            action: typeof change.action === 'string' ? change.action : undefined,
+            contentType: typeof change.contentType === 'string' ? change.contentType : undefined,
+            documentId: typeof change.documentId === 'string' ? change.documentId : undefined,
+            id: typeof change.id === 'string' ? change.id : undefined,
+            locale: typeof change.locale === 'string' ? change.locale : undefined,
+        }))
+        : [];
+    return {
+        changes,
+        updatedAt: typeof source.updatedAt === 'string' ? source.updatedAt : undefined,
+    };
+}
+function serializeBundle(bundle) {
+    return JSON.stringify({
+        dictionaries: bundle.dictionaries,
+        defaultLocale: bundle.defaultLocale,
+        locales: bundle.locales,
+    });
+}
+function emptyLabelBundle(rootDir) {
+    const config = getConfigServer(rootDir);
+    const defaultLocale = getFimoDefaultLocale(config);
+    const locales = getFimoLocales(config);
+    return {
+        dictionaries: Object.fromEntries(locales.map((locale) => [locale, {}])),
+        defaultLocale,
+        locales,
+        updatedAt: null,
+    };
+}
+function findVirtualTranslationModules(server) {
+    const direct = server.moduleGraph.getModuleById(RESOLVED_ID);
+    const matches = new Set(direct ? [direct] : []);
+    for (const mod of server.moduleGraph.idToModuleMap.values()) {
+        if (mod.id?.includes('virtual:translations')) {
+            matches.add(mod);
+        }
+    }
+    return [...matches];
+}
+function labelSignature(bundle) {
+    return Buffer.from(serializeBundle(bundle)).toString('base64');
+}
+function labelUpdatePayload(bundle) {
+    return {
+        ...bundle,
+        signature: labelSignature(bundle),
+    };
+}
+export async function loadLabelBundle(rootDir) {
+    const config = getConfigServer(rootDir);
+    const defaultLocale = getFimoDefaultLocale(config);
+    const locales = getFimoLocales(config);
+    const env = await readProjectEnv(rootDir);
+    const apiUrl = env.VITE_API_URL;
+    if (!apiUrl) {
+        return {
+            dictionaries: Object.fromEntries(locales.map((locale) => [locale, {}])),
+            defaultLocale,
+            locales,
+            updatedAt: null,
+        };
+    }
+    try {
+        const loaded = await Promise.all(locales.map((locale) => fetchLabelDictionary(apiUrl, locale).catch(() => ({ locale, labels: {}, updatedAt: null }))));
+        const updatedAtValues = loaded
+            .map((entry) => entry.updatedAt)
+            .filter((value) => typeof value === 'string')
+            .sort();
+        const updatedAt = updatedAtValues[updatedAtValues.length - 1];
+        return {
+            dictionaries: Object.fromEntries(loaded.map((entry) => [entry.locale, entry.labels])),
+            defaultLocale,
+            locales,
+            updatedAt: updatedAt ?? null,
+        };
+    }
+    catch {
+        return {
+            dictionaries: Object.fromEntries(locales.map((locale) => [locale, {}])),
+            defaultLocale,
+            locales,
+            updatedAt: null,
+        };
+    }
+}
+async function fetchLabelDictionary(apiUrl, locale) {
+    const url = new URL('/labels', apiUrl);
+    url.searchParams.set('locale', locale);
+    const response = await fetchWithTimeout(url, LABEL_FETCH_TIMEOUT_MS);
+    if (!response.ok) {
+        return { locale, labels: {}, updatedAt: null };
+    }
+    const body = (await response.json());
+    if (Array.isArray(body.data)) {
+        return {
+            locale,
+            labels: Object.fromEntries(body.data.map((row) => [row.key, row.value ?? row.defaultValue ?? ''])),
+            updatedAt: null,
+        };
+    }
+    return {
+        locale,
+        labels: body.data?.labels ?? {},
+        updatedAt: body.data?.updatedAt ?? null,
+    };
+}
+async function loadRuntimeConfig(apiUrl) {
+    try {
+        const response = await fetchWithTimeout(new URL('/runtime-config', apiUrl), 2000);
+        if (!response.ok) {
+            return {};
+        }
+        const body = await response.json();
+        return parseRuntimeConfig(body);
+    }
+    catch {
+        return {};
+    }
+}
+function parseRuntimeConfig(body) {
+    if (!body || typeof body !== 'object') {
+        return {};
+    }
+    const envelopeData = body.data;
+    const source = envelopeData && typeof envelopeData === 'object' ? envelopeData : body;
+    const eventsServerUrl = source.eventsServerUrl;
+    return {
+        eventsServerUrl: typeof eventsServerUrl === 'string' ? eventsServerUrl : undefined,
+    };
+}
+async function fetchWithTimeout(url, timeoutMs) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        return await fetch(url, { signal: controller.signal });
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+async function readProjectEnv(rootDir) {
+    const values = {
+        ...(await readEnvFile(join(rootDir, '.env'))),
+        ...(await readEnvFile(join(rootDir, '.env.local'))),
+    };
+    for (const key of ['VITE_API_URL']) {
+        if (process.env[key]) {
+            values[key] = process.env[key];
+        }
+    }
+    return values;
+}
+async function readEnvFile(filePath) {
+    try {
+        const content = await readFile(filePath, 'utf8');
+        const values = {};
+        for (const line of content.split(/\r?\n/)) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#')) {
+                continue;
+            }
+            const index = trimmed.indexOf('=');
+            if (index === -1) {
+                continue;
+            }
+            const key = trimmed.slice(0, index).trim();
+            const value = trimmed
+                .slice(index + 1)
+                .trim()
+                .replace(/^['"]|['"]$/g, '');
+            values[key] = value;
+        }
+        return values;
+    }
+    catch {
+        return {};
+    }
+}
+async function readProjectSettings(rootDir) {
+    for (const relativePath of [CURRENT_PROJECT_LAYOUT.project, LEGACY_PROJECT_LAYOUT.project]) {
+        try {
+            const raw = await readFile(join(rootDir, relativePath), 'utf8');
+            return JSON.parse(raw);
+        }
+        catch {
+            continue;
+        }
+    }
+    return {};
+}
+function deriveEventsRooms(projectId, tenantApiUrl) {
+    const rooms = new Set([projectId]);
+    try {
+        const firstLabel = new URL(tenantApiUrl).hostname.split('.')[0];
+        if (firstLabel.startsWith(`${projectId}-`)) {
+            rooms.add(`${projectId}:${firstLabel.slice(projectId.length + 1)}`);
+        }
+    }
+    catch {
+        return [...rooms];
+    }
+    return [...rooms];
+}
+async function generateOneTimeToken(apiUrl) {
+    const bearer = process.env.FIMO_API_TOKEN?.trim() || (await readStoredToken(apiUrl));
+    if (!bearer) {
+        throw new Error('Not signed in to Fimo.');
+    }
+    const response = await fetch(new URL('/api/auth/one-time-token/generate', apiUrl), {
+        method: 'GET',
+        headers: {
+            Authorization: `Bearer ${bearer}`,
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to generate events auth token: ${response.status}`);
+    }
+    const body = (await response.json());
+    const token = body.token ?? body.data?.token;
+    if (!token) {
+        throw new Error('Events auth token response did not include a token.');
+    }
+    return token;
+}
+async function readStoredToken(apiUrl) {
+    const configDir = join(process.env.XDG_CONFIG_HOME || join(homedir(), '.config'), 'fimo');
+    const credentialsFile = join(configDir, 'credentials', credentialsFilename(apiUrl));
+    try {
+        const raw = await readFile(credentialsFile, 'utf8');
+        const parsed = JSON.parse(raw);
+        return parsed.access_token ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function credentialsFilename(apiUrl) {
+    const normalized = normalizeApiUrl(apiUrl);
+    let hostLabel = 'unknown';
+    try {
+        hostLabel = new URL(normalized).host
+            .replace(/:/g, '-')
+            .replace(/[^a-zA-Z0-9.-]+/g, '-')
+            .replace(/^[.-]+|[.-]+$/g, '')
+            .toLowerCase();
+    }
+    catch {
+        hostLabel = 'unknown';
+    }
+    return `${hostLabel || 'unknown'}-${createHash('sha256').update(normalized).digest('hex').slice(0, 6)}.json`;
+}
+function normalizeApiUrl(input) {
+    const trimmed = input.trim();
+    try {
+        const url = new URL(trimmed);
+        const pathname = url.pathname.replace(/\/+$/, '');
+        return `${url.protocol}//${url.host}${pathname}`;
+    }
+    catch {
+        return trimmed.replace(/\/+$/, '');
+    }
+}

package/dist/runtime/overlay-hmr.d.ts

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