@vibe-forge/tsconfigs 0.7.2 → 0.8.0

package/dist/apps/client/src/hooks/chat/use-chat-session-messages.js

@@ -0,0 +1,262 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import { useSWRConfig } from 'swr';
+import { getSessionMessages } from '#~/api.js';
+import { connectionManager } from '#~/connectionManager.js';
+const applyMessageEvent = (currentMessages, data) => {
+    if (data.type !== 'message')
+        return currentMessages;
+    const exists = currentMessages.find((msg) => msg.id === data.message.id);
+    if (exists != null) {
+        return currentMessages.map((msg) => (msg.id === data.message.id ? data.message : msg));
+    }
+    return [...currentMessages, data.message];
+};
+const applyToolResultEvent = (currentMessages, data) => {
+    if (data.type !== 'tool_result')
+        return currentMessages;
+    const status = data.isError === true ? 'error' : 'success';
+    return currentMessages.map((msg) => {
+        if (msg.toolCall != null && msg.toolCall.id === data.toolCallId) {
+            return {
+                ...msg,
+                toolCall: {
+                    ...msg.toolCall,
+                    status,
+                    output: data.output
+                }
+            };
+        }
+        return msg;
+    });
+};
+export function useChatSessionMessages({ session, modelForQuery, permissionMode, adapter, setInteractionRequest }) {
+    const { t } = useTranslation();
+    const { mutate } = useSWRConfig();
+    const [messages, setMessages] = useState([]);
+    const [sessionInfo, setSessionInfo] = useState(null);
+    const [isReady, setIsReady] = useState(false);
+    const [connectionError, setConnectionError] = useState(null);
+    const [retryCount, setRetryCount] = useState(0);
+    const isInitialLoadRef = useRef(true);
+    const lastConnectedModelRef = useRef(undefined);
+    const lastConnectedPermissionModeRef = useRef(undefined);
+    const lastConnectedAdapterRef = useRef(undefined);
+    const expectedCloseRef = useRef(false);
+    const retryConnection = useCallback(() => {
+        if (session?.id == null || session.id === '')
+            return;
+        expectedCloseRef.current = true;
+        setConnectionError(null);
+        connectionManager.close(session.id);
+        setRetryCount((count) => count + 1);
+    }, [session?.id]);
+    useEffect(() => {
+        setMessages([]);
+        setSessionInfo(null);
+        setIsReady(false);
+        setConnectionError(null);
+        setInteractionRequest(null);
+        isInitialLoadRef.current = true;
+        if (session?.id == null || session.id === '') {
+            setIsReady(true);
+            lastConnectedModelRef.current = undefined;
+            lastConnectedPermissionModeRef.current = undefined;
+            lastConnectedAdapterRef.current = undefined;
+            return;
+        }
+        let isDisposed = false;
+        const fetchHistory = async () => {
+            try {
+                const res = await getSessionMessages(session.id);
+                if (isDisposed)
+                    return;
+                const events = res.messages;
+                if (res.session) {
+                    const updatedSession = res.session;
+                    void mutate('/api/sessions', (prev) => {
+                        if (prev?.sessions == null)
+                            return prev;
+                        const newSessions = prev.sessions.map((s) => s.id === updatedSession.id ? { ...s, ...updatedSession } : s);
+                        return { ...prev, sessions: newSessions };
+                    }, false);
+                }
+                if (res.interaction) {
+                    setInteractionRequest(res.interaction);
+                }
+                let currentMessages = [];
+                let currentSessionInfo = null;
+                for (const data of events) {
+                    currentMessages = applyMessageEvent(currentMessages, data);
+                    currentMessages = applyToolResultEvent(currentMessages, data);
+                    if (data.type === 'session_info') {
+                        if (data.info != null && data.info.type !== 'summary') {
+                            currentSessionInfo = data.info;
+                        }
+                    }
+                }
+                setMessages(currentMessages);
+                setSessionInfo(currentSessionInfo);
+                setTimeout(() => {
+                    if (isDisposed)
+                        return;
+                    setIsReady(true);
+                    isInitialLoadRef.current = false;
+                }, 100);
+            }
+            catch (err) {
+                console.error('Failed to fetch history messages:', err);
+            }
+        };
+        void fetchHistory();
+        return () => {
+            isDisposed = true;
+        };
+    }, [mutate, session?.id, setInteractionRequest]);
+    useEffect(() => {
+        if (session?.id == null || session.id === '') {
+            return;
+        }
+        let isDisposed = false;
+        let cleanup;
+        const normalizedModel = modelForQuery ?? '';
+        const modelChanged = modelForQuery != null &&
+            lastConnectedModelRef.current != null &&
+            normalizedModel !== lastConnectedModelRef.current &&
+            session?.status !== 'running';
+        const normalizedPermissionMode = permissionMode ?? '';
+        const permissionModeChanged = permissionMode != null &&
+            lastConnectedPermissionModeRef.current != null &&
+            normalizedPermissionMode !== lastConnectedPermissionModeRef.current &&
+            session?.status !== 'running';
+        const normalizedAdapter = adapter ?? '';
+        const adapterChanged = adapter != null &&
+            lastConnectedAdapterRef.current != null &&
+            normalizedAdapter !== lastConnectedAdapterRef.current &&
+            session?.status !== 'running';
+        if (modelChanged || permissionModeChanged || adapterChanged) {
+            expectedCloseRef.current = true;
+            setConnectionError(null);
+            connectionManager.send(session.id, { type: 'terminate_session' });
+            connectionManager.close(session.id);
+        }
+        lastConnectedModelRef.current = normalizedModel;
+        lastConnectedPermissionModeRef.current = normalizedPermissionMode;
+        lastConnectedAdapterRef.current = normalizedAdapter;
+        const timer = setTimeout(() => {
+            if (isDisposed)
+                return;
+            const connectionParams = {};
+            if (modelForQuery) {
+                connectionParams.model = modelForQuery;
+            }
+            if (permissionMode) {
+                connectionParams.permissionMode = permissionMode;
+            }
+            if (adapter) {
+                connectionParams.adapter = adapter;
+            }
+            cleanup = connectionManager.connect(session.id, {
+                onOpen() {
+                    expectedCloseRef.current = false;
+                    setConnectionError(null);
+                },
+                onMessage(data) {
+                    if (isDisposed)
+                        return;
+                    if (data.type === 'error') {
+                        setConnectionError(data.data?.message ?? data.message ?? 'Unknown error');
+                        return;
+                    }
+                    if (data.type === 'session_updated') {
+                        void mutate('/api/sessions', (prev) => {
+                            if (prev?.sessions == null)
+                                return prev;
+                            const updatedSession = data.session;
+                            if ('isDeleted' in updatedSession && updatedSession.isDeleted) {
+                                return {
+                                    ...prev,
+                                    sessions: prev.sessions.filter((s) => s.id !== updatedSession.id)
+                                };
+                            }
+                            const typedUpdatedSession = updatedSession;
+                            const newSessions = prev.sessions.map((s) => s.id === typedUpdatedSession.id ? { ...s, ...typedUpdatedSession } : s);
+                            if (!newSessions.some((s) => s.id === typedUpdatedSession.id) && !('isDeleted' in updatedSession)) {
+                                newSessions.unshift(typedUpdatedSession);
+                            }
+                            return { ...prev, sessions: newSessions };
+                        }, false);
+                        return;
+                    }
+                    if (data.type === 'message') {
+                        setMessages((current) => applyMessageEvent(current, data));
+                        return;
+                    }
+                    if (data.type === 'session_info') {
+                        if (data.info != null && data.info.type === 'summary') {
+                            void mutate('/api/sessions');
+                        }
+                        else {
+                            setSessionInfo(data.info ?? null);
+                            if (isInitialLoadRef.current) {
+                                setTimeout(() => {
+                                    if (isDisposed)
+                                        return;
+                                    if (isInitialLoadRef.current) {
+                                        setIsReady(true);
+                                        isInitialLoadRef.current = false;
+                                    }
+                                }, 100);
+                            }
+                        }
+                        return;
+                    }
+                    if (data.type === 'tool_result') {
+                        setMessages((current) => applyToolResultEvent(current, data));
+                        return;
+                    }
+                    if (data.type === 'interaction_request') {
+                        setInteractionRequest({ id: data.id, payload: data.payload });
+                    }
+                },
+                onError() {
+                    if (isDisposed)
+                        return;
+                    setConnectionError(t('chat.connectionError'));
+                },
+                onClose() {
+                    if (isDisposed)
+                        return;
+                    if (expectedCloseRef.current) {
+                        expectedCloseRef.current = false;
+                        return;
+                    }
+                    setConnectionError((current) => current ?? t('chat.connectionClosed'));
+                }
+            }, Object.keys(connectionParams).length > 0 ? connectionParams : undefined);
+        }, (modelChanged || permissionModeChanged || adapterChanged) ? 200 : 100);
+        return () => {
+            isDisposed = true;
+            clearTimeout(timer);
+            cleanup?.();
+        };
+    }, [
+        adapter,
+        modelForQuery,
+        mutate,
+        permissionMode,
+        retryCount,
+        session?.id,
+        session?.status,
+        setInteractionRequest,
+        t
+    ]);
+    return {
+        messages,
+        setMessages,
+        sessionInfo,
+        isReady,
+        connectionError,
+        retryConnection
+    };
+}

package/dist/apps/client/src/hooks/chat/use-chat-session.d.ts

@@ -0,0 +1,38 @@
+import type { Session } from '@vibe-forge/core';
+export declare function useChatSession({ session }: {
+    session?: Session;
+}): {
+    messages: import("@vibe-forge/types").ChatMessage[];
+    sessionInfo: import("@vibe-forge/types").SessionInfo | null;
+    interactionRequest: {
+        id: string;
+        payload: import("@vibe-forge/types").AskUserQuestionParams;
+    } | null;
+    isReady: boolean;
+    connectionError: string | null;
+    retryConnection: () => void;
+    isThinking: boolean;
+    activeView: import("../../components/chat/ChatHeader").ChatHeaderView;
+    setActiveView: (view: import("../../components/chat/ChatHeader").ChatHeaderView) => void;
+    handleInteractionResponse: (id: string, data: string | string[]) => void;
+    setMessages: import("react").Dispatch<import("react").SetStateAction<import("@vibe-forge/types").ChatMessage[]>>;
+    placeholder: string | undefined;
+    modelOptions: import("./use-chat-model-adapter-selection").ModelSelectGroup[];
+    selectedModel: string | undefined;
+    modelForQuery: string | undefined;
+    setSelectedModel: (value?: string) => void;
+    permissionMode: import("./use-chat-permission-mode").PermissionMode;
+    setPermissionMode: (value?: string) => void;
+    permissionModeOptions: {
+        value: import("./use-chat-permission-mode").PermissionMode;
+        label: import("react").ReactNode;
+    }[];
+    selectedAdapter: string | undefined;
+    setSelectedAdapter: (value?: string) => void;
+    adapterOptions: {
+        value: string;
+        label: import("react").ReactNode;
+    }[];
+    hasAvailableModels: boolean;
+    modelUnavailable: boolean;
+};

package/dist/apps/client/src/hooks/chat/use-chat-session.js

@@ -0,0 +1,83 @@
+import { useEffect, useRef } from 'react';
+import { useTranslation } from 'react-i18next';
+import { useChatInteraction } from './use-chat-interaction';
+import { useChatModelAdapterSelection } from './use-chat-model-adapter-selection';
+import { useChatPermissionMode } from './use-chat-permission-mode';
+import { useChatSessionMessages } from './use-chat-session-messages';
+import { useChatView } from './use-chat-view';
+export function useChatSession({ session }) {
+    const { t } = useTranslation();
+    const { adapterOptions, applySessionSelection, selectedAdapter, selectedModel, selectedModelWithService, setSelectedModel, setSelectedAdapter, modelOptions, hasAvailableModels } = useChatModelAdapterSelection({
+        adapterLocked: session?.id != null
+    });
+    const { permissionMode, setPermissionMode, permissionModeOptions } = useChatPermissionMode();
+    const { activeView, setActiveView } = useChatView();
+    const { interactionRequest, setInteractionRequest, handleInteractionResponse } = useChatInteraction({
+        sessionId: session?.id
+    });
+    const { messages, setMessages, sessionInfo, isReady, connectionError, retryConnection } = useChatSessionMessages({
+        session,
+        modelForQuery: selectedModelWithService,
+        permissionMode,
+        adapter: selectedAdapter,
+        setInteractionRequest
+    });
+    const lastObservedSessionRef = useRef(null);
+    const isThinking = session?.status === 'running';
+    useEffect(() => {
+        if (session?.id == null || session.id === '') {
+            lastObservedSessionRef.current = null;
+            return;
+        }
+        const previous = lastObservedSessionRef.current;
+        const sessionChanged = previous?.id !== session.id;
+        if (sessionChanged || previous?.model !== session.model || previous?.adapter !== session.adapter) {
+            applySessionSelection({
+                model: session.model,
+                adapter: session.adapter
+            });
+        }
+        if (sessionChanged || previous?.permissionMode !== session.permissionMode) {
+            setPermissionMode(session.permissionMode);
+        }
+        lastObservedSessionRef.current = {
+            id: session.id,
+            model: session.model,
+            permissionMode: session.permissionMode,
+            adapter: session.adapter
+        };
+    }, [
+        session?.adapter,
+        session?.id,
+        session?.model,
+        session?.permissionMode,
+        applySessionSelection,
+        setPermissionMode,
+    ]);
+    return {
+        messages,
+        sessionInfo,
+        interactionRequest,
+        isReady,
+        connectionError,
+        retryConnection,
+        isThinking,
+        activeView,
+        setActiveView,
+        handleInteractionResponse,
+        setMessages,
+        placeholder: !session?.id ? t('chat.newSessionPlaceholder') : undefined,
+        modelOptions,
+        selectedModel,
+        modelForQuery: selectedModelWithService,
+        setSelectedModel,
+        permissionMode,
+        setPermissionMode,
+        permissionModeOptions,
+        selectedAdapter,
+        setSelectedAdapter,
+        adapterOptions,
+        hasAvailableModels,
+        modelUnavailable: !hasAvailableModels
+    };
+}

package/dist/apps/client/src/hooks/chat/use-chat-view.d.ts

@@ -0,0 +1,5 @@
+import type { ChatHeaderView } from '#~/components/chat/ChatHeader.js';
+export declare function useChatView(): {
+    activeView: ChatHeaderView;
+    setActiveView: (view: ChatHeaderView) => void;
+};

package/dist/apps/client/src/hooks/chat/use-chat-view.js

@@ -0,0 +1,32 @@
+import { useCallback, useEffect } from 'react';
+import { useQueryParams } from '#~/hooks/useQueryParams.js';
+const normalizeView = (value) => {
+    if (value === 'timeline' || value === 'settings' || value === 'history') {
+        return value;
+    }
+    return 'history';
+};
+export function useChatView() {
+    const { values: queryValues, update: updateQuery } = useQueryParams({
+        keys: ['view'],
+        defaults: {
+            view: 'history'
+        },
+        omit: {
+            view: (value) => value === 'history'
+        }
+    });
+    const activeView = normalizeView(queryValues.view);
+    const setActiveView = useCallback((view) => {
+        updateQuery({ view });
+    }, [updateQuery]);
+    useEffect(() => {
+        if (activeView !== queryValues.view) {
+            updateQuery({ view: activeView });
+        }
+    }, [activeView, queryValues.view, updateQuery]);
+    return {
+        activeView,
+        setActiveView
+    };
+}

package/dist/apps/client/src/hooks/use-app-preferences.d.ts

@@ -0,0 +1,12 @@
+import { theme } from 'antd';
+interface AppPreferences {
+    isDarkMode: boolean;
+    themeConfig: {
+        algorithm: typeof theme.darkAlgorithm | typeof theme.defaultAlgorithm;
+        token: {
+            colorPrimary: string;
+        };
+    };
+}
+export declare function useAppPreferences(): AppPreferences;
+export {};

package/dist/apps/client/src/hooks/use-app-preferences.js

@@ -0,0 +1,33 @@
+import { theme } from 'antd';
+import { useAtomValue } from 'jotai';
+import { useEffect, useMemo } from 'react';
+import { useTranslation } from 'react-i18next';
+import useSWR from 'swr';
+import { getConfig } from '#~/api';
+import { themeAtom } from '#~/store';
+export function useAppPreferences() {
+    const { i18n } = useTranslation();
+    const themeMode = useAtomValue(themeAtom);
+    const { data: configRes } = useSWR('/api/config', getConfig);
+    const interfaceLanguage = configRes?.sources?.merged?.general?.interfaceLanguage;
+    const isDarkMode = themeMode === 'dark' ||
+        (themeMode === 'system' && window.matchMedia('(prefers-color-scheme: dark)').matches);
+    useEffect(() => {
+        document.documentElement.classList.toggle('dark', isDarkMode);
+    }, [isDarkMode]);
+    useEffect(() => {
+        if (interfaceLanguage && i18n.language !== interfaceLanguage) {
+            void i18n.changeLanguage(interfaceLanguage);
+        }
+    }, [i18n, interfaceLanguage]);
+    const themeConfig = useMemo(() => ({
+        algorithm: isDarkMode ? theme.darkAlgorithm : theme.defaultAlgorithm,
+        token: {
+            colorPrimary: isDarkMode ? '#3b82f6' : '#000000'
+        }
+    }), [isDarkMode]);
+    return {
+        isDarkMode,
+        themeConfig
+    };
+}

package/dist/apps/client/src/hooks/use-session-subscription.d.ts

@@ -0,0 +1 @@
+export declare function useSessionSubscription(): void;

package/dist/apps/client/src/hooks/use-session-subscription.js

@@ -0,0 +1,83 @@
+import { useEffect } from 'react';
+import { useSWRConfig } from 'swr';
+import { createSocket } from '#~/ws.js';
+const isDeletedSessionUpdate = (update) => {
+    return 'isDeleted' in update && update.isDeleted;
+};
+const sortSessions = (sessions) => {
+    return [...sessions].sort((a, b) => {
+        const starredDelta = Number(b.isStarred === true) - Number(a.isStarred === true);
+        if (starredDelta !== 0)
+            return starredDelta;
+        return (b.createdAt ?? 0) - (a.createdAt ?? 0);
+    });
+};
+const mergeSessionList = (prev, updatedSession, filter) => {
+    if (prev?.sessions == null)
+        return prev;
+    if (isDeletedSessionUpdate(updatedSession)) {
+        return {
+            ...prev,
+            sessions: prev.sessions.filter((session) => session.id !== updatedSession.id)
+        };
+    }
+    const session = updatedSession;
+    const shouldInclude = filter === 'archived'
+        ? session.isArchived === true
+        : session.isArchived !== true;
+    const existing = prev.sessions.find((session) => session.id === updatedSession.id);
+    if (!shouldInclude) {
+        return {
+            ...prev,
+            sessions: prev.sessions.filter((session) => session.id !== updatedSession.id)
+        };
+    }
+    const nextSessions = existing
+        ? prev.sessions.map((currentSession) => currentSession.id === updatedSession.id ? { ...currentSession, ...session } : currentSession)
+        : [session, ...prev.sessions];
+    return {
+        ...prev,
+        sessions: sortSessions(nextSessions)
+    };
+};
+export function useSessionSubscription() {
+    const { mutate } = useSWRConfig();
+    useEffect(() => {
+        let disposed = false;
+        let socket;
+        let reconnectTimer;
+        const connect = () => {
+            if (disposed)
+                return;
+            socket = createSocket({
+                onMessage: (data) => {
+                    if (data.type !== 'session_updated')
+                        return;
+                    const updatedSession = data.session;
+                    void mutate('/api/sessions', (prev) => {
+                        return mergeSessionList(prev, updatedSession, 'active');
+                    }, false);
+                    void mutate('/api/sessions/archived', (prev) => {
+                        return mergeSessionList(prev, updatedSession, 'archived');
+                    }, false);
+                },
+                onClose: () => {
+                    if (disposed)
+                        return;
+                    reconnectTimer = setTimeout(connect, 1000);
+                },
+                onError: () => {
+                    socket?.close();
+                }
+            }, { subscribe: 'sessions' });
+        };
+        connect();
+        return () => {
+            disposed = true;
+            if (reconnectTimer) {
+                clearTimeout(reconnectTimer);
+            }
+            socket?.close();
+        };
+    }, [mutate]);
+}

package/dist/apps/client/src/hooks/use-sidebar-navigation.d.ts

@@ -0,0 +1,8 @@
+import type { Session } from '@vibe-forge/core';
+export declare function useSidebarNavigation(): {
+    activeSessionId: string | undefined;
+    handleDeletedSession: (deletedId: string, nextId?: string) => void;
+    handleSelectSession: (session: Session, _isNew?: boolean) => void;
+    showSidebar: boolean;
+    sidebarWidth: number;
+};

package/dist/apps/client/src/hooks/use-sidebar-navigation.js

@@ -0,0 +1,28 @@
+import { useAtomValue } from 'jotai';
+import { useCallback } from 'react';
+import { matchPath, useLocation, useNavigate } from 'react-router-dom';
+import { sidebarWidthAtom } from '#~/store';
+const SESSION_ROUTE_PATTERN = '/session/:sessionId';
+export function useSidebarNavigation() {
+    const navigate = useNavigate();
+    const location = useLocation();
+    const sidebarWidth = useAtomValue(sidebarWidthAtom);
+    const sessionMatch = matchPath({ path: SESSION_ROUTE_PATTERN, end: true }, location.pathname);
+    const activeSessionId = sessionMatch?.params.sessionId;
+    const showSidebar = location.pathname === '/' || activeSessionId != null;
+    const handleSelectSession = useCallback((session, _isNew) => {
+        void navigate(session.id === '' ? '/' : `/session/${session.id}`);
+    }, [navigate]);
+    const handleDeletedSession = useCallback((deletedId, nextId) => {
+        if (activeSessionId !== deletedId)
+            return;
+        void navigate(nextId ? `/session/${nextId}` : '/');
+    }, [activeSessionId, navigate]);
+    return {
+        activeSessionId,
+        handleDeletedSession,
+        handleSelectSession,
+        showSidebar,
+        sidebarWidth
+    };
+}

package/dist/apps/client/src/hooks/useGlobalShortcut.d.ts

@@ -0,0 +1,6 @@
+export declare const useGlobalShortcut: ({ shortcut, enabled, isMac, onTrigger }: {
+    shortcut?: string;
+    enabled?: boolean;
+    isMac: boolean;
+    onTrigger: (event: KeyboardEvent) => void;
+}) => void;

package/dist/apps/client/src/hooks/useGlobalShortcut.js

@@ -0,0 +1,15 @@
+import { useEffect } from 'react';
+import { isShortcutMatch } from '../utils/shortcutUtils';
+export const useGlobalShortcut = ({ shortcut, enabled = true, isMac, onTrigger }) => {
+    useEffect(() => {
+        if (!enabled)
+            return;
+        const handleKeyDown = (event) => {
+            if (isShortcutMatch(event, shortcut, isMac)) {
+                onTrigger(event);
+            }
+        };
+        window.addEventListener('keydown', handleKeyDown);
+        return () => window.removeEventListener('keydown', handleKeyDown);
+    }, [enabled, isMac, onTrigger, shortcut]);
+};

package/dist/apps/client/src/hooks/useQueryParams.d.ts

@@ -0,0 +1,12 @@
+type QueryParamKey<T> = Extract<keyof T, string>;
+interface QueryParamConfig<T extends Record<string, string>> {
+    keys: QueryParamKey<T>[];
+    defaults?: Partial<T>;
+    omit?: Partial<Record<QueryParamKey<T>, (value: string) => boolean>>;
+}
+export declare const useQueryParams: <T extends Record<string, string>>({ keys, defaults, omit }: QueryParamConfig<T>) => {
+    values: T;
+    update: (patch: Partial<T>) => void;
+    searchParams: URLSearchParams;
+};
+export {};

package/dist/apps/client/src/hooks/useQueryParams.js

@@ -0,0 +1,38 @@
+import { useCallback, useMemo } from 'react';
+import { useSearchParams } from 'react-router-dom';
+export const useQueryParams = ({ keys, defaults, omit }) => {
+    const [searchParams, setSearchParams] = useSearchParams();
+    const keySet = useMemo(() => new Set(keys), [keys]);
+    const values = useMemo(() => {
+        return keys.reduce((acc, key) => {
+            const raw = searchParams.get(key);
+            const fallback = defaults?.[key] ?? '';
+            acc[key] = (raw ?? fallback);
+            return acc;
+        }, {});
+    }, [defaults, keys, searchParams]);
+    const update = useCallback((patch) => {
+        const nextParams = new URLSearchParams();
+        const merged = keys.reduce((acc, key) => {
+            const raw = searchParams.get(key);
+            const fallback = defaults?.[key] ?? '';
+            acc[key] = (raw ?? fallback);
+            return acc;
+        }, {});
+        Object.assign(merged, patch);
+        keys.forEach((key) => {
+            const value = merged[key] ?? '';
+            const shouldOmit = value === '' || (omit?.[key] ? omit[key](value) : false);
+            if (!shouldOmit)
+                nextParams.set(key, value);
+        });
+        for (const [key, value] of searchParams.entries()) {
+            if (!keySet.has(key))
+                nextParams.append(key, value);
+        }
+        if (nextParams.toString() !== searchParams.toString()) {
+            setSearchParams(nextParams, { replace: true });
+        }
+    }, [defaults, keySet, keys, omit, searchParams, setSearchParams]);
+    return { values, update, searchParams };
+};

package/dist/apps/client/src/i18n.d.ts

@@ -0,0 +1,2 @@
+import i18n from 'i18next';
+export default i18n;