@rolder/kit 3.0.0-alpha-4 → 3.0.0-alpha-5

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 "../functions/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 "../functions/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 "../functions/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 };

package/dist/app/defaultTheme.d.ts

@@ -0,0 +1,141 @@
+export declare const defaultTheme: {
+    focusRing?: "auto" | "always" | "never" | undefined;
+    scale?: number | undefined;
+    fontSmoothing?: boolean | undefined;
+    white?: string | undefined;
+    black?: string | undefined;
+    colors?: {
+        [x: string & {}]: import("@mantine/core").MantineColorsTuple | undefined;
+        dark?: import("@mantine/core").MantineColorsTuple | undefined;
+        blue?: import("@mantine/core").MantineColorsTuple | undefined;
+        cyan?: import("@mantine/core").MantineColorsTuple | undefined;
+        gray?: import("@mantine/core").MantineColorsTuple | undefined;
+        green?: import("@mantine/core").MantineColorsTuple | undefined;
+        indigo?: import("@mantine/core").MantineColorsTuple | undefined;
+        lime?: import("@mantine/core").MantineColorsTuple | undefined;
+        orange?: import("@mantine/core").MantineColorsTuple | undefined;
+        pink?: import("@mantine/core").MantineColorsTuple | undefined;
+        red?: import("@mantine/core").MantineColorsTuple | undefined;
+        teal?: import("@mantine/core").MantineColorsTuple | undefined;
+        violet?: import("@mantine/core").MantineColorsTuple | undefined;
+        yellow?: import("@mantine/core").MantineColorsTuple | undefined;
+        grape?: import("@mantine/core").MantineColorsTuple | undefined;
+    } | undefined;
+    primaryShade?: import("@mantine/core").MantineColorShade | {
+        light?: import("@mantine/core").MantineColorShade | undefined;
+        dark?: import("@mantine/core").MantineColorShade | undefined;
+    } | undefined;
+    primaryColor?: string | undefined;
+    variantColorResolver?: import("@mantine/core").VariantColorsResolver | undefined;
+    autoContrast?: boolean | undefined;
+    luminanceThreshold?: number | undefined;
+    fontFamily?: string | undefined;
+    fontFamilyMonospace?: string | undefined;
+    headings?: {
+        fontFamily?: string | undefined;
+        fontWeight?: string | undefined;
+        textWrap?: "balance" | "nowrap" | "wrap" | "stable" | "pretty" | undefined;
+        sizes?: {
+            h1?: {
+                fontSize?: string | undefined;
+                fontWeight?: string | undefined;
+                lineHeight?: string | undefined;
+            } | undefined;
+            h2?: {
+                fontSize?: string | undefined;
+                fontWeight?: string | undefined;
+                lineHeight?: string | undefined;
+            } | undefined;
+            h3?: {
+                fontSize?: string | undefined;
+                fontWeight?: string | undefined;
+                lineHeight?: string | undefined;
+            } | undefined;
+            h4?: {
+                fontSize?: string | undefined;
+                fontWeight?: string | undefined;
+                lineHeight?: string | undefined;
+            } | undefined;
+            h5?: {
+                fontSize?: string | undefined;
+                fontWeight?: string | undefined;
+                lineHeight?: string | undefined;
+            } | undefined;
+            h6?: {
+                fontSize?: string | undefined;
+                fontWeight?: string | undefined;
+                lineHeight?: string | undefined;
+            } | undefined;
+        } | undefined;
+    } | undefined;
+    radius?: {
+        [x: string & {}]: string | undefined;
+        xs?: string | undefined;
+        sm?: string | undefined;
+        md?: string | undefined;
+        lg?: string | undefined;
+        xl?: string | undefined;
+    } | undefined;
+    defaultRadius?: import("@mantine/core").MantineRadius | undefined;
+    spacing?: {
+        [x: number]: string | undefined;
+        [x: string & {}]: string | undefined;
+        xs?: string | undefined;
+        sm?: string | undefined;
+        md?: string | undefined;
+        lg?: string | undefined;
+        xl?: string | undefined;
+    } | undefined;
+    fontSizes?: {
+        [x: string & {}]: string | undefined;
+        xs?: string | undefined;
+        sm?: string | undefined;
+        md?: string | undefined;
+        lg?: string | undefined;
+        xl?: string | undefined;
+    } | undefined;
+    lineHeights?: {
+        [x: string & {}]: string | undefined;
+        xs?: string | undefined;
+        sm?: string | undefined;
+        md?: string | undefined;
+        lg?: string | undefined;
+        xl?: string | undefined;
+    } | undefined;
+    breakpoints?: {
+        [x: string & {}]: string | undefined;
+        xs?: string | undefined;
+        sm?: string | undefined;
+        md?: string | undefined;
+        lg?: string | undefined;
+        xl?: string | undefined;
+    } | undefined;
+    shadows?: {
+        [x: string & {}]: string | undefined;
+        xs?: string | undefined;
+        sm?: string | undefined;
+        md?: string | undefined;
+        lg?: string | undefined;
+        xl?: string | undefined;
+    } | undefined;
+    respectReducedMotion?: boolean | undefined;
+    cursorType?: "default" | "pointer" | undefined;
+    defaultGradient?: {
+        from?: string | undefined;
+        to?: string | undefined;
+        deg?: number | undefined;
+    } | undefined;
+    activeClassName?: string | undefined;
+    focusClassName?: string | undefined;
+    components?: {
+        [x: string]: {
+            classNames?: any;
+            styles?: any;
+            vars?: any;
+            defaultProps?: any;
+        } | undefined;
+    } | undefined;
+    other?: {
+        [x: string]: any;
+    } | undefined;
+};

package/dist/app/defaultTheme.js

@@ -0,0 +1,24 @@
+import { Modal, createTheme } from "@mantine/core";
+const defaultTheme = createTheme({
+    components: {
+        Modal: Modal.extend({
+            defaultProps: {
+                centered: true,
+                padding: 'lg'
+            }
+        }),
+        ModalTitle: Modal.Title.extend({
+            defaultProps: {
+                pr: 24
+            }
+        }),
+        ModalCloseButton: Modal.CloseButton.extend({
+            defaultProps: {
+                pos: 'absolute',
+                top: 4,
+                right: 4
+            }
+        })
+    }
+});
+export { defaultTheme };

package/dist/app/index.d.ts

@@ -0,0 +1,3 @@
+export * from './DefaultApp';
+export * from './defaultRequestMiddlewares';
+export * from './defaultTheme';

package/dist/app/index.js

@@ -0,0 +1,3 @@
+export * from "./DefaultApp.js";
+export * from "./defaultRequestMiddlewares.js";
+export * from "./defaultTheme.js";

package/dist/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export * from './useMutation';
+export * from './useMutationWithInvalidate';

package/dist/hooks/index.js

@@ -0,0 +1,2 @@
+export * from "./useMutation.js";
+export * from "./useMutationWithInvalidate.js";

package/dist/hooks/useMutation.d.ts

@@ -0,0 +1,4 @@
+import { type UseMutationOptions } from '@tanstack/react-query';
+export declare const useMutation: <T, K = void>(fn: ({ data }: {
+    data: T;
+}) => Promise<K>, options?: Omit<UseMutationOptions<K, Error, T>, "mutationFn">) => import("@tanstack/react-query").UseMutationResult<K, Error, T, unknown>;

package/dist/hooks/useMutation.js

@@ -0,0 +1,8 @@
+import { useMutation } from "@tanstack/react-query";
+const useMutation_useMutation = (fn, options)=>useMutation({
+        mutationFn: (data)=>fn({
+                data
+            }),
+        ...options
+    });
+export { useMutation_useMutation as useMutation };

package/dist/hooks/useMutationWithInvalidate.d.ts

@@ -0,0 +1,4 @@
+import { type UseMutationOptions } from '@tanstack/react-query';
+export declare const useMutationWithInvalidate: <T, K = void>(fn: ({ data }: {
+    data: T;
+}) => Promise<K>, queryKey: string[], options?: Omit<UseMutationOptions<K, Error, T>, "mutationFn" | "onSettled">) => import("@tanstack/react-query").UseMutationResult<K, Error, T, unknown>;

package/dist/hooks/useMutationWithInvalidate.js

@@ -0,0 +1,16 @@
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+const useMutationWithInvalidate = (fn, queryKey, options)=>{
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (data)=>fn({
+                data
+            }),
+        onSettled: async (_, error)=>{
+            if (!error && queryKey.length) await queryClient.invalidateQueries({
+                queryKey
+            });
+        },
+        ...options
+    });
+};
+export { useMutationWithInvalidate };

package/dist/index.d.ts

@@ -1,2 +1,5 @@
+export * from './app';
 export * from './functions';
+export * from './hooks';
+export * from './surreal';
 export * from './ui';

package/dist/index.js

@@ -1,2 +1,5 @@
+export * from "./app/index.js";
 export * from "./functions/index.js";
+export * from "./hooks/index.js";
+export * from "./surreal/index.js";
 export * from "./ui/index.js";

package/dist/surreal/connection.d.ts

@@ -0,0 +1,9 @@
+import { type CodecOptions, Surreal } from 'surrealdb';
+export declare const getDB: (params?: {
+    url?: string;
+    namespace?: string;
+    database?: string;
+    username?: string;
+    password?: string;
+    codecOptions?: CodecOptions;
+} | undefined) => Promise<Surreal>;

package/dist/surreal/connection.js

@@ -0,0 +1,49 @@
+import { createServerOnlyFn } from "@tanstack/react-start";
+import { getCookie } from "@tanstack/react-start/server";
+import { DateTime, Surreal } from "surrealdb";
+let db = null;
+const getDB = createServerOnlyFn(async (params = {})=>{
+    if (db?.isConnected) return db;
+    const locale = getCookie('locale') || 'ru-RU';
+    const timeZone = getCookie('tz') || 'UTC';
+    const instance = new Surreal({
+        codecOptions: params.codecOptions || {
+            valueDecodeVisitor (value) {
+                if (value instanceof DateTime) return new Date(value.toDate()).toLocaleDateString(locale, {
+                    hour: 'numeric',
+                    minute: 'numeric',
+                    timeZone
+                });
+                return value;
+            }
+        }
+    });
+    try {
+        const url = params.url || process.env.SURREALDB_URL;
+        if (!url) throw new Error('Missing required SurrealDB URL');
+        const namespace = params.namespace || process.env.SURREALDB_NAMESPACE;
+        if (!namespace) throw new Error('Missing required SurrealDB namespace');
+        const database = params.database || process.env.SURREALDB_DATABASE;
+        if (!database) throw new Error('Missing required SurrealDB database');
+        const username = params.username || process.env.SURREALDB_USERNAME;
+        const password = params.password || process.env.SURREALDB_PASSWORD;
+        if (username && password) await instance.connect(url, {
+            authentication: {
+                username,
+                password
+            }
+        });
+        else await instance.connect(url);
+        await instance.use({
+            namespace,
+            database
+        });
+        db = instance;
+        return instance;
+    } catch (error) {
+        console.error('Failed to connect to SurrealDB:', error);
+        db = null;
+        throw error;
+    }
+});
+export { getDB };

package/dist/surreal/deafaultCrud.d.ts

@@ -0,0 +1,2 @@
+export declare const surrealDeleteFn: import("@tanstack/start-client-core").RequiredFetcher<undefined, (data: string) => string, Promise<void>>;
+export declare const surrealUnsubscribeFn: import("@tanstack/start-client-core").RequiredFetcher<undefined, (data: string) => string, Promise<void>>;

package/dist/surreal/deafaultCrud.js

@@ -0,0 +1,18 @@
+import { createServerFn } from "@tanstack/react-start";
+import { getDB } from "./connection.js";
+import { deserialize } from "./deserialize.js";
+const surrealDeleteFn = createServerFn({
+    method: 'POST'
+}).inputValidator((data)=>data).handler(async ({ data })=>{
+    const db = await getDB();
+    const id = deserialize(data);
+    await db.delete(id);
+});
+const surrealUnsubscribeFn = createServerFn({
+    method: 'POST'
+}).inputValidator((data)=>data).handler(async ({ data })=>{
+    const db = await getDB();
+    const live = await db.liveOf(data);
+    await live.kill();
+});
+export { surrealDeleteFn, surrealUnsubscribeFn };

package/dist/surreal/deserialize.d.ts

@@ -0,0 +1,17 @@
+import { RecordId } from 'surrealdb';
+/**
+ * Type that converts specified string paths to RecordId, others stay as their original types
+ */
+type DeserializeResult<T, IdPaths extends string = never> = T extends string ? RecordId<string> : T extends (infer U)[] ? U extends object ? {
+    [K in keyof U]: K extends IdPaths ? RecordId<string> : U[K];
+}[] : DeserializeResult<U, IdPaths>[] : T extends object ? T extends Date ? T : {
+    [K in keyof T]: K extends IdPaths ? RecordId<string> : T[K];
+} : T;
+/**
+ * Deserializes DTO back to SurrealDB Record recursively based on specified ID paths
+ */
+export declare function deserialize<T, K extends keyof T & string>(dto: T[], idPaths: K[]): DeserializeResult<T, K>[];
+export declare function deserialize<T, K extends keyof T & string>(dto: T, idPaths: K[]): DeserializeResult<T, K>;
+export declare function deserialize<T>(dto: T[]): DeserializeResult<T>[];
+export declare function deserialize<T>(dto: T): DeserializeResult<T>;
+export {};

package/dist/surreal/deserialize.js

@@ -0,0 +1,46 @@
+import { RecordId } from "surrealdb";
+const extractTableName = (str)=>{
+    const match = str.match(/^([^:]+):/);
+    return match ? match[1] : null;
+};
+const isRecordIdFormat = (str)=>/^[^:]+:.+$/.test(str);
+function deserialize(dto, idPaths) {
+    if (Array.isArray(dto)) return dto.map((item)=>convertStringsToRecordIds(item, idPaths || []));
+    return convertStringsToRecordIds(dto, idPaths || []);
+}
+const convertStringsToRecordIds = (obj, idPaths, currentPath = '')=>{
+    if (null == obj) return obj;
+    if (Array.isArray(obj)) {
+        if (idPaths.includes(currentPath)) return obj.map((item)=>{
+            if ('string' == typeof item && isRecordIdFormat(item)) {
+                const tableName = extractTableName(item);
+                if (tableName) return new RecordId(tableName, item.split(':')[1]);
+            }
+            return item;
+        });
+        return obj.map((item, index)=>convertStringsToRecordIds(item, idPaths, `${currentPath}[${index}]`));
+    }
+    if ('object' == typeof obj && !(obj instanceof Date)) {
+        const result = {};
+        for (const [key, value] of Object.entries(obj)){
+            const fieldPath = currentPath ? `${currentPath}.${key}` : key;
+            if ('string' == typeof value) {
+                const shouldConvert = idPaths.includes(fieldPath) && isRecordIdFormat(value);
+                if (shouldConvert) {
+                    const tableName = extractTableName(value);
+                    if (tableName) result[key] = new RecordId(tableName, value.split(':')[1]);
+                    else result[key] = value;
+                } else result[key] = value;
+            } else result[key] = convertStringsToRecordIds(value, idPaths, fieldPath);
+        }
+        return result;
+    }
+    if ('string' == typeof obj) {
+        if (0 === idPaths.length && isRecordIdFormat(obj)) {
+            const tableName = extractTableName(obj);
+            if (tableName) return new RecordId(tableName, obj.split(':')[1]);
+        }
+    }
+    return obj;
+};
+export { deserialize };

package/dist/surreal/encryption.d.ts

@@ -0,0 +1,8 @@
+declare class Encryption {
+    private key;
+    constructor(secretHash: string);
+    encrypt(text: string): string;
+    decrypt(encryptedText: string): string;
+}
+export declare const encryptionFn: (secretHash: string) => Encryption;
+export {};

package/dist/surreal/encryption.js

@@ -0,0 +1,28 @@
+import { createCipheriv, createDecipheriv, randomBytes } from "node:crypto";
+import { createServerOnlyFn } from "@tanstack/react-start";
+class Encryption {
+    key;
+    constructor(secretHash){
+        this.key = Buffer.from(secretHash, 'hex');
+    }
+    encrypt(text) {
+        const algorithm = 'aes-256-cbc';
+        const iv = randomBytes(16);
+        const cipher = createCipheriv(algorithm, this.key, iv);
+        let encrypted = cipher.update(text, 'utf8', 'hex');
+        encrypted += cipher.final('hex');
+        return `${iv.toString('hex')}:${encrypted}`;
+    }
+    decrypt(encryptedText) {
+        const algorithm = 'aes-256-cbc';
+        const parts = encryptedText.split(':');
+        const iv = Buffer.from(parts[0], 'hex');
+        const encrypted = parts[1];
+        const decipher = createDecipheriv(algorithm, this.key, iv);
+        let decrypted = decipher.update(encrypted, 'hex', 'utf8');
+        decrypted += decipher.final('utf8');
+        return decrypted;
+    }
+}
+const encryptionFn = createServerOnlyFn((secretHash)=>new Encryption(secretHash));
+export { encryptionFn };

package/dist/surreal/index.d.ts

@@ -0,0 +1,4 @@
+export { getDB } from './connection';
+export * from './deafaultCrud';
+export { deserialize } from './deserialize';
+export { encryptionFn } from './encryption';

package/dist/surreal/index.js

@@ -0,0 +1,5 @@
+import { getDB } from "./connection.js";
+import { deserialize } from "./deserialize.js";
+import { encryptionFn } from "./encryption.js";
+export * from "./deafaultCrud.js";
+export { deserialize, encryptionFn, getDB };

package/dist/ui/error/DefaultError.d.ts

@@ -0,0 +1,2 @@
+import type { ErrorComponentProps } from '@tanstack/react-router';
+export declare const DefaultError: ({ error }: ErrorComponentProps) => import("react/jsx-runtime").JSX.Element;

package/dist/ui/error/DefaultError.js

@@ -0,0 +1,62 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Button, Group, Stack, Title } from "@mantine/core";
+import { rootRouteId, useMatch, useRouter } from "@tanstack/react-router";
+import { RouterLink } from "../routerLink/index.js";
+const DefaultError = ({ error })=>{
+    const router = useRouter();
+    const isRoot = useMatch({
+        strict: false,
+        select: (state)=>state.id === rootRouteId
+    });
+    return /*#__PURE__*/ jsxs(Stack, {
+        align: "center",
+        justify: "center",
+        gap: 0,
+        ta: "center",
+        h: "100vh",
+        children: [
+            /*#__PURE__*/ jsx(Title, {
+                textWrap: "balance",
+                size: 65,
+                children: "Произошла ошибка!"
+            }),
+            error.message && /*#__PURE__*/ jsx(Title, {
+                order: 3,
+                ml: 4,
+                textWrap: "balance",
+                c: "var(--mantine-color-error)",
+                children: error.message
+            }),
+            /*#__PURE__*/ jsxs(Group, {
+                children: [
+                    /*#__PURE__*/ jsx(Button, {
+                        mt: "xl",
+                        size: "lg",
+                        variant: "light",
+                        onClick: ()=>{
+                            router.invalidate();
+                        },
+                        children: "Попробовать еще раз"
+                    }),
+                    isRoot ? /*#__PURE__*/ jsx(RouterLink.Button, {
+                        to: "/",
+                        mt: "xl",
+                        size: "lg",
+                        radius: "md",
+                        children: "На главную"
+                    }) : /*#__PURE__*/ jsx(Button, {
+                        mt: "xl",
+                        radius: "md",
+                        size: "lg",
+                        onClick: (e)=>{
+                            e.preventDefault();
+                            router.history.back();
+                        },
+                        children: "Назад"
+                    })
+                ]
+            })
+        ]
+    });
+};
+export { DefaultError };

package/dist/ui/error/DefaultNotFound.d.ts

@@ -0,0 +1 @@
+export declare const DefaultNotFound: () => import("react/jsx-runtime").JSX.Element;

package/dist/ui/error/DefaultNotFound.js

@@ -0,0 +1,37 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Stack, Text, Title } from "@mantine/core";
+import { RouterLink } from "../routerLink/index.js";
+const DefaultNotFound = ()=>/*#__PURE__*/ jsxs(Stack, {
+        align: "center",
+        justify: "center",
+        gap: 0,
+        ta: "center",
+        h: "100vh",
+        children: [
+            /*#__PURE__*/ jsx(Text, {
+                c: "dimmed",
+                fw: "bold",
+                children: "404"
+            }),
+            /*#__PURE__*/ jsx(Title, {
+                textWrap: "balance",
+                size: 65,
+                children: "Страница не найдена"
+            }),
+            /*#__PURE__*/ jsx(Title, {
+                order: 3,
+                ml: 4,
+                textWrap: "balance",
+                c: "dimmed",
+                children: "Извините, но здесь нет страницы. Возможно она перемещена."
+            }),
+            /*#__PURE__*/ jsx(RouterLink.Button, {
+                to: "/",
+                mt: "xl",
+                size: "lg",
+                radius: "md",
+                children: "На главную"
+            })
+        ]
+    });
+export { DefaultNotFound };

package/dist/ui/error/defaultErrorNotification.d.ts

@@ -0,0 +1 @@
+export declare const defaultErrorNotification: (error: Error) => string;

package/dist/ui/error/defaultErrorNotification.js

@@ -0,0 +1,8 @@
+import { notifications } from "@mantine/notifications";
+const defaultErrorNotification = (error)=>notifications.show({
+        title: 'Системная ошибка',
+        message: error.message,
+        color: 'red',
+        autoClose: false
+    });
+export { defaultErrorNotification };

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

@@ -0,0 +1,3 @@
+export * from './DefaultError';
+export * from './DefaultNotFound';
+export * from './defaultErrorNotification';

package/dist/ui/error/index.js

@@ -0,0 +1,3 @@
+export * from "./DefaultError.js";
+export * from "./DefaultNotFound.js";
+export * from "./defaultErrorNotification.js";

package/dist/ui/index.d.ts

@@ -1,7 +1,7 @@
 export * from './AnimatedChevron';
 export * from './editor';
+export * from './error';
 export * from './form';
-export * from './hoverActionIcon';
 export * from './hoverPaper';
 export * from './JsonInput';
 export * from './routerLink';

package/dist/ui/index.js

@@ -1,7 +1,7 @@
 export * from "./AnimatedChevron.js";
 export * from "./editor/index.js";
+export * from "./error/index.js";
 export * from "./form/index.js";
-export * from "./hoverActionIcon/index.js";
 export * from "./hoverPaper/index.js";
 export * from "./JsonInput.js";
 export * from "./routerLink/index.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rolder/kit",
-  "version": "3.0.0-alpha-4",
+  "version": "3.0.0-alpha-5",
   "type": "module",
   "exports": {
     ".": {
@@ -18,7 +18,7 @@
     "check": "biome check --write && tsc --noEmit"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.3.8",
+    "@biomejs/biome": "2.3.11",
     "@rsbuild/plugin-react": "^1.4.2",
     "@rslib/core": "^0.19.2",
     "@types/react": "^19.2.8",
@@ -46,11 +46,15 @@
     "@mantine/core": "^8.3.11",
     "@mantine/hooks": "^8.3.11",
     "@mantine/tiptap": "^8.3.11",
+    "@mantine/notifications": "^8.3.11",
     "@tanstack/react-router": "1.147.3",
     "@tanstack/react-form": "1.27.7",
     "@tanstack/react-start": "^1.149.1",
+    "@tanstack/react-query": "^5.90.16",
     "zod": "^4.3.5",
-    "js-cookie": "^3.0.5"
+    "js-cookie": "^3.0.5",
+    "nanostores": "^1.1.0",
+    "surrealdb": "^2.0.0-alpha.16"
   },
   "trustedDependencies": [
     "core-js",

package/dist/ui/hoverActionIcon/HoverActionIcon.d.ts

@@ -1,6 +0,0 @@
-import { type ActionIconProps, type ElementProps } from '@mantine/core';
-interface Props extends ActionIconProps, ElementProps<'button', keyof ActionIconProps> {
-    hovered?: boolean;
-}
-export declare const HoverActionIcon: ({ hovered, classNames, ...props }: Props) => import("react/jsx-runtime").JSX.Element;
-export {};

package/dist/ui/hoverActionIcon/HoverActionIcon.js

@@ -1,14 +0,0 @@
-import { jsx } from "react/jsx-runtime";
-import { ActionIcon } from "@mantine/core";
-import styles_module from "./styles.module.js";
-const HoverActionIcon = ({ hovered, classNames, ...props })=>/*#__PURE__*/ jsx(ActionIcon, {
-        classNames: {
-            root: styles_module.root,
-            ...classNames
-        },
-        mod: {
-            hovered
-        },
-        ...props
-    });
-export { HoverActionIcon };

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

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

package/dist/ui/hoverActionIcon/index.js

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

package/dist/ui/hoverActionIcon/styles.module.js

@@ -1,5 +0,0 @@
-import "./styles_module.css";
-const styles_module = {
-    root: "root-Ao1xe7"
-};
-export { styles_module as default };

package/dist/ui/hoverActionIcon/styles_module.css

@@ -1,10 +0,0 @@
-.root-Ao1xe7 {
-  opacity: 0;
-  transition: opacity .2s ease-in-out;
-
-  &[data-hovered] {
-    opacity: 1;
-    transition: opacity .2s ease-in-out;
-  }
-}
-