@rolder/kit 3.0.0-alpha.8 → 3.0.0-alpha.81

package/dist/ai/ui/chat/chatInput/store/input.js

@@ -0,0 +1,81 @@
+import { uploadFile } from "@better-upload/client";
+import { useStore } from "@nanostores/react";
+import { nanoid } from "nanoid";
+import { atom } from "nanostores";
+import { getSignedFileUrlFn } from "../../../../../tanstackFunctions/index.js";
+import { addChatMessage, sendMessage } from "../../store/index.js";
+import { getFile } from "./file.js";
+import { fileErrorNotificaton } from "./fileErrorNotificaton.js";
+import { parseExcel, parseWord } from "./parseFile.js";
+const $text = atom('');
+const getText = ()=>$text.get();
+const useText = ()=>useStore($text);
+const setText = (text)=>$text.set(text);
+const $isComposing = atom(false);
+const getIsComposing = ()=>$isComposing.get();
+const setIsComposing = (isComposing)=>$isComposing.set(isComposing);
+const $onSubmit = atom();
+const getOnSubmit = ()=>$onSubmit.get();
+const setOnSubmit = (onSubmit)=>$onSubmit.set(onSubmit);
+const input_onSubmit = async ()=>{
+    const onSubmit = getOnSubmit();
+    const text = getText();
+    const file = getFile();
+    let fileUIPart;
+    if (file) if ([
+        'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+        'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
+    ].includes(file.type)) {
+        let fileContent;
+        let type;
+        if ('application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' === file.type) {
+            fileContent = await parseExcel(file);
+            type = 'excel';
+        } else if ('application/vnd.openxmlformats-officedocument.wordprocessingml.document' === file.type) {
+            fileContent = await parseWord(file);
+            type = 'word';
+        }
+        if (fileContent && type) addChatMessage({
+            id: `file-${type}-${nanoid()}`,
+            role: 'system',
+            parts: [
+                {
+                    type: 'text',
+                    text: `Пользователь загрузил файл типа "${type}" c содержимым:
+\`\`\`
+${fileContent}
+\`\`\``
+                }
+            ]
+        });
+    } else try {
+        const result = await uploadFile({
+            file,
+            route: 'upload'
+        });
+        const url = await getSignedFileUrlFn({
+            data: {
+                s3Key: result.file.objectInfo.key
+            }
+        });
+        fileUIPart = {
+            id: nanoid(),
+            type: 'file',
+            url,
+            mediaType: file.type,
+            filename: file.name
+        };
+    } catch (error) {
+        fileErrorNotificaton(error);
+    }
+    if (onSubmit) onSubmit({
+        text,
+        file: fileUIPart
+    });
+    sendMessage({
+        text,
+        file: fileUIPart
+    });
+    setText('');
+};
+export { getIsComposing, getOnSubmit, getText, input_onSubmit as onSubmit, setIsComposing, setOnSubmit, setText, useText };

package/dist/ai/ui/chat/chatInput/store/parseFile.d.ts

@@ -0,0 +1,2 @@
+export declare const parseExcel: (file: File) => Promise<string>;
+export declare const parseWord: (file: File) => Promise<string>;

package/dist/ai/ui/chat/chatInput/store/parseFile.js

@@ -0,0 +1,23 @@
+import mammoth from "mammoth";
+import { read, utils } from "xlsx";
+const parseExcel = async (file)=>{
+    const buffer = await file.arrayBuffer();
+    const workbook = read(buffer, {
+        type: 'array',
+        cellDates: true
+    });
+    const sheetName = workbook.SheetNames[0];
+    const worksheet = workbook.Sheets[sheetName];
+    const jsonData = utils.sheet_to_json(worksheet, {
+        dateNF: 'yyyy-mm-dd'
+    });
+    return JSON.stringify(jsonData, null, 2);
+};
+const parseWord = async (file)=>{
+    const arrayBuffer = await file.arrayBuffer();
+    const { value } = await mammoth.convertToHtml({
+        arrayBuffer
+    });
+    return value;
+};
+export { parseExcel, parseWord };

package/dist/ai/ui/chat/index.d.ts

@@ -0,0 +1,13 @@
+export declare const Chat: {
+    Root: ({ chatOptions, ...props }: import("./Root").ChatRootProps) => import("react/jsx-runtime").JSX.Element;
+    Message: import("react").MemoExoticComponent<({ messageId }: {
+        messageId: string;
+    }) => import("react/jsx-runtime").JSX.Element | null>;
+    File: ({ messageId }: {
+        messageId: string;
+    }) => import("react/jsx-runtime").JSX.Element | null;
+    Empty: () => import("react/jsx-runtime").JSX.Element | null;
+    Loader: (props: import("@mantine/core").LoaderProps) => import("react/jsx-runtime").JSX.Element | null;
+};
+export { ChatInput } from './chatInput';
+export * from './store';

package/dist/ai/ui/chat/index.js

@@ -0,0 +1,15 @@
+import { Empty } from "./Empty.js";
+import { File } from "./File.js";
+import { Loader } from "./Loader.js";
+import { Message } from "./Message.js";
+import { Root } from "./Root.js";
+import { ChatInput } from "./chatInput/index.js";
+export * from "./store/index.js";
+const Chat = {
+    Root: Root,
+    Message: Message,
+    File: File,
+    Empty: Empty,
+    Loader: Loader
+};
+export { Chat, ChatInput };

package/dist/ai/ui/chat/store/index.d.ts

@@ -0,0 +1,5 @@
+export * from './messageIds';
+export * from './messagesMap';
+export * from './send';
+export * from './states';
+export * from './useInitChat';

package/dist/ai/ui/chat/store/index.js

@@ -0,0 +1,5 @@
+export * from "./messageIds.js";
+export * from "./messagesMap.js";
+export * from "./send.js";
+export * from "./states.js";
+export * from "./useInitChat.js";

package/dist/ai/ui/chat/store/messageIds.d.ts

@@ -0,0 +1,8 @@
+import type { UIMessage } from 'ai';
+export declare const $chatMessageIds: import("nanostores").PreinitializedWritableAtom<string[]> & object;
+export declare const getChatMessages: <T extends UIMessage>() => T[];
+export declare const useChatMessageIds: () => string[];
+export declare const addChatMessage: (newMessage: UIMessage) => void;
+export declare const setChatMessages: <T extends UIMessage>(messages: T[]) => void;
+export declare const getIsEmpty: () => boolean;
+export declare const useIsEmpty: () => boolean;

package/dist/ai/ui/chat/store/messageIds.js

@@ -0,0 +1,41 @@
+import { useStore } from "@nanostores/react";
+import { atom, computed, onSet } from "nanostores";
+import { $chatMessages } from "./messagesMap.js";
+const $chatMessageIds = atom([]);
+const getChatMessages = ()=>$chatMessageIds.get().map((id)=>$chatMessages.get()[id]);
+const useChatMessageIds = ()=>useStore($chatMessageIds);
+onSet($chatMessageIds, ({ newValue, abort })=>{
+    const currentValue = $chatMessageIds.get();
+    if (currentValue.length === newValue.length && currentValue.every((id, index)=>id === newValue[index])) abort();
+});
+const addChatMessage = (newMessage)=>{
+    $chatMessageIds.set([
+        ...$chatMessageIds.get(),
+        newMessage.id
+    ]);
+    $chatMessages.set({
+        ...$chatMessages.get(),
+        [newMessage.id]: newMessage
+    });
+};
+const setChatMessages = (messages)=>{
+    const newIds = messages.map((msg)=>msg.id);
+    $chatMessageIds.set(newIds);
+    const currentMessages = $chatMessages.get();
+    const lastMessage = messages[messages.length - 1];
+    for(let i = 0; i < messages.length; i++){
+        const msg = messages[i];
+        const currentMsg = currentMessages[msg.id];
+        const isLastMessage = msg === lastMessage;
+        if (currentMsg) if (isLastMessage) $chatMessages.setKey(msg.id, msg);
+        else {
+            const isChanged = JSON.stringify(currentMsg) !== JSON.stringify(msg);
+            if (isChanged) $chatMessages.setKey(msg.id, msg);
+        }
+        else $chatMessages.setKey(msg.id, msg);
+    }
+};
+const $isEmpty = computed($chatMessageIds, (messages)=>0 === messages.length);
+const getIsEmpty = ()=>$isEmpty.get();
+const useIsEmpty = ()=>useStore($isEmpty);
+export { $chatMessageIds, addChatMessage, getChatMessages, getIsEmpty, setChatMessages, useChatMessageIds, useIsEmpty };

package/dist/ai/ui/chat/store/messagesMap.d.ts

@@ -0,0 +1,5 @@
+import type { UIDataTypes, UIMessage, UIMessagePart, UITools } from 'ai';
+export declare const $chatMessages: import("nanostores").PreinitializedMapStore<Record<string, UIMessage<unknown, UIDataTypes, UITools>>> & object;
+export declare const getChatMessage: (messageId: string) => UIMessage<unknown, UIDataTypes, UITools>;
+export declare const useChatMessage: <T extends UIMessage>(messageId: string) => T;
+export declare const useChatMessagePart: <M extends UIMessage, T extends UIMessagePart<UIDataTypes, UITools>>(messageId: string, type?: T["type"]) => T | undefined;

package/dist/ai/ui/chat/store/messagesMap.js

@@ -0,0 +1,15 @@
+import { useStore } from "@nanostores/react";
+import { map } from "nanostores";
+const $chatMessages = map({});
+const getChatMessage = (messageId)=>$chatMessages.get()[messageId];
+const useChatMessage = (messageId)=>useStore($chatMessages, {
+        keys: [
+            messageId
+        ]
+    })[messageId];
+const useChatMessagePart = (messageId, type)=>{
+    const message = useChatMessage(messageId);
+    const part = message?.parts?.find((i)=>i.type === type);
+    return part;
+};
+export { $chatMessages, getChatMessage, useChatMessage, useChatMessagePart };

package/dist/ai/ui/chat/store/send.d.ts

@@ -0,0 +1,14 @@
+import type { FileUIPart } from 'ai';
+export type SendMessage = ({ text, file }: {
+    text: string;
+    file?: FileUIPart;
+}, data?: Record<string, unknown>) => Promise<void>;
+type SendSdkMessage = ({ text, files }: {
+    text: string;
+    files?: FileUIPart[];
+}, { body }: {
+    body?: Record<string, unknown>;
+}) => Promise<void>;
+export declare const setChatSendMessage: (sendMessage: SendSdkMessage) => void;
+export declare const sendMessage: SendMessage;
+export {};

package/dist/ai/ui/chat/store/send.js

@@ -0,0 +1,16 @@
+import { atom } from "nanostores";
+const $chatSendMessage = atom();
+const getChatSendMessage = ()=>$chatSendMessage.get();
+const setChatSendMessage = (sendMessage)=>$chatSendMessage.set(sendMessage);
+const send_sendMessage = async ({ text, file }, data)=>{
+    const files = file ? [
+        file
+    ] : [];
+    await getChatSendMessage()?.({
+        text,
+        files
+    }, {
+        body: data
+    });
+};
+export { send_sendMessage as sendMessage, setChatSendMessage };

package/dist/ai/ui/chat/store/states.d.ts

@@ -0,0 +1,11 @@
+import type { ChatStatus } from 'ai';
+export declare const getChatStatus: () => ChatStatus;
+export declare const setChatStatus: (status: ChatStatus) => void;
+export declare const useChatStatus: () => ChatStatus;
+export declare const getIsLoading: () => boolean;
+export declare const useIsLoading: () => boolean;
+export declare const getIsStreaming: () => boolean;
+export declare const useIsStreaming: () => boolean;
+export declare const getChatError: () => string | undefined;
+export declare const setChatError: (error: string | undefined) => void;
+export declare const useChatError: () => string | undefined;

package/dist/ai/ui/chat/store/states.js

@@ -0,0 +1,17 @@
+import { useStore } from "@nanostores/react";
+import { atom, computed } from "nanostores";
+const $chatStatus = atom('ready');
+const getChatStatus = ()=>$chatStatus.get();
+const setChatStatus = (status)=>$chatStatus.set(status);
+const useChatStatus = ()=>useStore($chatStatus);
+const $isLoading = computed($chatStatus, (status)=>'ready' !== status);
+const getIsLoading = ()=>$isLoading.get();
+const useIsLoading = ()=>useStore($isLoading);
+const $isStreaming = computed($chatStatus, (status)=>'streaming' === status);
+const getIsStreaming = ()=>$isStreaming.get();
+const useIsStreaming = ()=>useStore($isStreaming);
+const $chatError = atom();
+const getChatError = ()=>$chatError.get();
+const setChatError = (error)=>$chatError.set(error);
+const useChatError = ()=>useStore($chatError);
+export { getChatError, getChatStatus, getIsLoading, getIsStreaming, setChatError, setChatStatus, useChatError, useChatStatus, useIsLoading, useIsStreaming };

package/dist/ai/ui/chat/store/useInitChat.d.ts

@@ -0,0 +1,3 @@
+import { type UseChatOptions } from '@ai-sdk/react';
+import type { ChatInit, UIMessage } from 'ai';
+export declare const useInitChat: <T extends UIMessage>(props?: UseChatOptions<T> & ChatInit<T>) => void;

package/dist/ai/ui/chat/store/useInitChat.js

@@ -0,0 +1,40 @@
+import { useChat } from "@ai-sdk/react";
+import { notifications } from "@mantine/notifications";
+import { useEffect } from "react";
+import { setChatMessages } from "./messageIds.js";
+import { setChatSendMessage } from "./send.js";
+import { setChatError, setChatStatus } from "./states.js";
+const useInitChat = (props)=>{
+    const { messages, status, error, sendMessage } = useChat({
+        onError: (e)=>{
+            notifications.show({
+                title: 'Ошибка сервера ИИ',
+                message: e.message,
+                color: 'red',
+                autoClose: false
+            });
+        },
+        ...props
+    });
+    useEffect(()=>{
+        setChatStatus(status);
+    }, [
+        status
+    ]);
+    useEffect(()=>{
+        setChatError(error?.message);
+    }, [
+        error?.message
+    ]);
+    useEffect(()=>{
+        setChatSendMessage(sendMessage);
+    }, [
+        sendMessage
+    ]);
+    useEffect(()=>{
+        setChatMessages(messages);
+    }, [
+        messages
+    ]);
+};
+export { useInitChat };

package/dist/ai/ui/index.d.ts

@@ -0,0 +1 @@
+export * from './chat';

package/dist/ai/ui/index.js

@@ -0,0 +1 @@
+export * from "./chat/index.js";

package/dist/ai/utils/convertFileUIPartBlobToDataURL.d.ts

@@ -0,0 +1,5 @@
+import type { FileUIPart } from 'ai';
+/**
+ * Converts FileUIPart array with blob URLs to data URLs
+ */
+export declare function convertFileUIPartBlobToDataURL(file: FileUIPart): Promise<FileUIPart>;

package/dist/ai/utils/convertFileUIPartBlobToDataURL.js

@@ -0,0 +1,21 @@
+async function blobToDataURL(blobUrl) {
+    const response = await fetch(blobUrl);
+    const blob = await response.blob();
+    return new Promise((resolve, reject)=>{
+        const reader = new FileReader();
+        reader.onload = ()=>resolve(reader.result);
+        reader.onerror = reject;
+        reader.readAsDataURL(blob);
+    });
+}
+async function convertFileUIPartBlobToDataURL(file) {
+    if (file.url.startsWith('blob:')) {
+        const dataUrl = await blobToDataURL(file.url);
+        return {
+            ...file,
+            url: dataUrl
+        };
+    }
+    return file;
+}
+export { convertFileUIPartBlobToDataURL };

package/dist/ai/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './convertFileUIPartBlobToDataURL';
+export * from './parseAiMessagePart';

package/dist/ai/utils/index.js

@@ -0,0 +1,2 @@
+export * from "./convertFileUIPartBlobToDataURL.js";
+export * from "./parseAiMessagePart.js";

package/dist/ai/utils/parseAiMessagePart.d.ts

@@ -0,0 +1,2 @@
+import { type TextUIPart } from 'ai';
+export declare const parseAiMessagePart: <T extends TextUIPart>(part: T) => Promise<T>;

package/dist/ai/utils/parseAiMessagePart.js

@@ -0,0 +1,12 @@
+import { parsePartialJson } from "ai";
+const parseAiMessagePart = async (part)=>{
+    if (!part.text.startsWith('{')) return part;
+    try {
+        const result = await parsePartialJson(part.text);
+        return result?.value || part;
+    } catch (error) {
+        console.error('Error parsing partial JSON:', error);
+        return part;
+    }
+};
+export { parseAiMessagePart };

package/dist/app/AppDefaults.d.ts

@@ -0,0 +1,3 @@
+export declare const AppDefaults: ({ saveColorScheme, }: {
+    saveColorScheme: boolean;
+}) => null;

package/dist/app/AppDefaults.js

@@ -0,0 +1,27 @@
+import { useComputedColorScheme } from "@mantine/core";
+import { useEffect } from "react";
+import { setCookies } from "../tanstackFunctions/index.js";
+const AppDefaults = ({ saveColorScheme })=>{
+    const colorScheme = useComputedColorScheme();
+    useEffect(()=>{
+        const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+        const cookies = [
+            {
+                name: 'tz',
+                value: tz,
+                expires: 365
+            }
+        ];
+        if (saveColorScheme) cookies.push({
+            name: 'colorScheme',
+            value: colorScheme,
+            expires: 365
+        });
+        setCookies(cookies);
+    }, [
+        colorScheme,
+        saveColorScheme
+    ]);
+    return null;
+};
+export { AppDefaults };

package/dist/app/DefaultApp.d.ts

@@ -0,0 +1,6 @@
+import { type MantineProviderProps } from '@mantine/core';
+interface Props extends MantineProviderProps {
+    saveColorScheme?: boolean;
+}
+export declare const DefaultApp: ({ children, saveColorScheme, defaultColorScheme, ...props }: Props) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/app/DefaultApp.js

@@ -0,0 +1,43 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { ColorSchemeScript, MantineProvider } from "@mantine/core";
+import { HeadContent, Scripts } from "@tanstack/react-router";
+import { getCookie } from "../tanstackFunctions/index.js";
+import { AppDefaults } from "./AppDefaults.js";
+import { cookieColorSchemeManager } from "./cookieColorSchemeManager.js";
+import { defaultTheme } from "./defaultTheme.js";
+const colorSchemeManager = cookieColorSchemeManager();
+const DefaultApp = ({ children, saveColorScheme = true, defaultColorScheme = 'auto', ...props })=>{
+    const colorScheme = saveColorScheme ? getCookie('colorScheme', defaultColorScheme) : defaultColorScheme;
+    return /*#__PURE__*/ jsxs("html", {
+        lang: "ru",
+        suppressHydrationWarning: true,
+        children: [
+            /*#__PURE__*/ jsxs("head", {
+                children: [
+                    /*#__PURE__*/ jsx(HeadContent, {}),
+                    /*#__PURE__*/ jsx(ColorSchemeScript, {
+                        defaultColorScheme: colorScheme
+                    })
+                ]
+            }),
+            /*#__PURE__*/ jsxs("body", {
+                children: [
+                    /*#__PURE__*/ jsxs(MantineProvider, {
+                        defaultColorScheme: colorScheme,
+                        theme: defaultTheme,
+                        colorSchemeManager: colorSchemeManager,
+                        ...props,
+                        children: [
+                            /*#__PURE__*/ jsx(AppDefaults, {
+                                saveColorScheme: saveColorScheme
+                            }),
+                            children
+                        ]
+                    }),
+                    /*#__PURE__*/ jsx(Scripts, {})
+                ]
+            })
+        ]
+    });
+};
+export { DefaultApp };

package/dist/app/cookieColorSchemeManager.d.ts

@@ -0,0 +1,6 @@
+import { type MantineColorSchemeManager } from '@mantine/core';
+export interface CookieColorSchemeManager {
+    /** Название куки, `colorScheme` по умолчанию */
+    key?: string;
+}
+export declare const cookieColorSchemeManager: ({ key, }?: CookieColorSchemeManager) => MantineColorSchemeManager;

package/dist/app/cookieColorSchemeManager.js

@@ -0,0 +1,46 @@
+import { isMantineColorScheme } from "@mantine/core";
+import { atom } from "nanostores";
+import { setCookie } from "../tanstackFunctions/index.js";
+const $colorScheme = atom();
+let unsubscribeSystemTheme;
+const cookieColorSchemeManager = ({ key = 'colorScheme' } = {})=>({
+        get: (defaultValue)=>{
+            try {
+                return $colorScheme.get() || defaultValue;
+            } catch  {
+                return defaultValue;
+            }
+        },
+        set: (value)=>{
+            try {
+                setCookie(key, value);
+                $colorScheme.set(value);
+            } catch (error) {
+                console.warn('[cookieColorSchemeManager] Ошибка при сохранении цветовой схемы в куки.', error);
+            }
+        },
+        subscribe: (onUpdate)=>{
+            $colorScheme.listen((newValue)=>{
+                if (isMantineColorScheme(newValue)) {
+                    setCookie(key, newValue);
+                    onUpdate(newValue);
+                }
+            });
+            const mediaQuery = window.matchMedia('(prefers-color-scheme: dark)');
+            const handleSystemThemeChange = ()=>onUpdate('auto');
+            mediaQuery.addEventListener('change', handleSystemThemeChange);
+            unsubscribeSystemTheme = ()=>mediaQuery.removeEventListener('change', handleSystemThemeChange);
+        },
+        unsubscribe: ()=>{
+            $colorScheme.off();
+            if (unsubscribeSystemTheme) {
+                unsubscribeSystemTheme();
+                unsubscribeSystemTheme = void 0;
+            }
+        },
+        clear: ()=>{
+            setCookie(key);
+            $colorScheme.set(void 0);
+        }
+    });
+export { cookieColorSchemeManager };

package/dist/app/defaultRequestMiddlewares.d.ts

@@ -0,0 +1,4 @@
+export declare const defaultRequestMiddlewares: import("@tanstack/start-client-core").RequestMiddlewareAfterServer<{}, undefined, {
+    locale: string;
+    timeZone: string;
+}>[];

package/dist/app/defaultRequestMiddlewares.js

@@ -0,0 +1,24 @@
+import { createMiddleware } from "@tanstack/react-start";
+import { getCookie, getRequestHeader, setCookie } from "@tanstack/react-start/server";
+const defaultRequestMiddlewares_locale = createMiddleware().server(async ({ next })=>{
+    const header = getRequestHeader('accept-language');
+    const headerLocale = header?.split(',')[0] || 'ru-RU';
+    const cookieLocale = getCookie('locale');
+    const cookieTz = getCookie('tz');
+    const locale = cookieLocale || headerLocale;
+    const timeZone = cookieTz || 'UTC';
+    setCookie('locale', locale, {
+        path: '/',
+        maxAge: 31536000
+    });
+    return next({
+        context: {
+            locale,
+            timeZone
+        }
+    });
+});
+const defaultRequestMiddlewares = [
+    defaultRequestMiddlewares_locale
+];
+export { defaultRequestMiddlewares };