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

package/dist/tanstackFunctions/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/tanstackFunctions/surreal/encryption.d.ts

@@ -0,0 +1,6 @@
+type EncryptionInstance = {
+    encrypt(text: string): string;
+    decrypt(encryptedText: string): string;
+};
+export declare const encryptionFn: (secretHash: string) => EncryptionInstance;
+export {};

package/dist/tanstackFunctions/surreal/encryption.js

@@ -0,0 +1,30 @@
+import { createCipheriv, createDecipheriv, randomBytes } from "node:crypto";
+import { createServerOnlyFn } from "@tanstack/react-start";
+const encryptionFn = createServerOnlyFn((secretHash)=>{
+    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;
+        }
+    }
+    return new Encryption(secretHash);
+});
+export { encryptionFn };

package/dist/tanstackFunctions/surreal/index.d.ts

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

package/dist/tanstackFunctions/surreal/index.js

@@ -0,0 +1,4 @@
+export * from "./connection.js";
+export * from "./deafaultCrud.js";
+export * from "./deserialize.js";
+export * from "./encryption.js";

package/dist/ui/AnimatedChevron.d.ts

@@ -0,0 +1,6 @@
+import { type IconProps } from '@tabler/icons-react';
+interface Props extends IconProps {
+    expanded?: boolean;
+}
+export declare const AnimatedChevron: ({ expanded, style, ...props }: Props) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/ui/AnimatedChevron.js

@@ -0,0 +1,13 @@
+import { jsx } from "react/jsx-runtime";
+import { IconChevronDown } from "@tabler/icons-react";
+const AnimatedChevron = ({ expanded, style, ...props })=>/*#__PURE__*/ jsx(IconChevronDown, {
+        strokeWidth: 1.5,
+        "data-expanded": expanded,
+        style: {
+            transition: 'transform 0.2s ease-in-out',
+            transform: expanded ? 'rotate(180deg)' : 'rotate(0deg)',
+            ...style
+        },
+        ...props
+    });
+export { AnimatedChevron };

package/dist/ui/JsonInput.d.ts

@@ -0,0 +1,2 @@
+import { type ReactCodeMirrorProps } from '@uiw/react-codemirror';
+export declare const JsonInput: (props: ReactCodeMirrorProps) => import("react/jsx-runtime").JSX.Element;

package/dist/ui/JsonInput.js

@@ -0,0 +1,45 @@
+import { jsx } from "react/jsx-runtime";
+import { indentSelection } from "@codemirror/commands";
+import { json, jsonParseLinter } from "@codemirror/lang-json";
+import { linter } from "@codemirror/lint";
+import { keymap } from "@codemirror/view";
+import { vscodeDark, vscodeLight } from "@uiw/codemirror-theme-vscode";
+import react_codemirror from "@uiw/react-codemirror";
+import { getCookie } from "../tanstackFunctions/index.js";
+const formatJson = (view)=>{
+    try {
+        const text = view.state.doc.toString();
+        const parsed = JSON.parse(text);
+        const formatted = JSON.stringify(parsed, null, 2);
+        view.dispatch({
+            changes: {
+                from: 0,
+                to: view.state.doc.length,
+                insert: formatted
+            }
+        });
+        return true;
+    } catch (_) {
+        return indentSelection(view);
+    }
+};
+const extensions = [
+    json(),
+    linter(jsonParseLinter()),
+    keymap.of([
+        {
+            key: 'Mod-Shift-f',
+            run: formatJson
+        }
+    ])
+];
+const JsonInput = (props)=>{
+    const colorScheme = getCookie('colorScheme');
+    return /*#__PURE__*/ jsx(react_codemirror, {
+        height: "280px",
+        theme: 'light' === colorScheme ? vscodeLight : vscodeDark,
+        extensions: extensions,
+        ...props
+    });
+};
+export { JsonInput };

package/dist/ui/RouterLink.d.ts

@@ -0,0 +1,16 @@
+import { type ActionIconProps, type AnchorProps, type ButtonProps, type UnstyledButtonProps } from '@mantine/core';
+import { type LinkComponent } from '@tanstack/react-router';
+interface MantineAnchorProps extends Omit<AnchorProps, 'href'> {
+}
+interface MantineButtonProps extends Omit<ButtonProps, 'href'> {
+}
+interface MantineActionIconProps extends Omit<ActionIconProps, 'href'> {
+}
+interface MantineUnstyledButtonProps extends Omit<UnstyledButtonProps, 'href'> {
+}
+export declare const RouterLink: LinkComponent<import("react").ForwardRefExoticComponent<MantineAnchorProps & import("react").RefAttributes<HTMLAnchorElement>>> & {
+    Button: LinkComponent<import("react").ForwardRefExoticComponent<MantineButtonProps & import("react").RefAttributes<HTMLButtonElement>>>;
+    ActionIcon: LinkComponent<import("react").ForwardRefExoticComponent<MantineActionIconProps & import("react").RefAttributes<HTMLButtonElement>>>;
+    UnstyledButton: LinkComponent<import("react").ForwardRefExoticComponent<MantineUnstyledButtonProps & import("react").RefAttributes<HTMLButtonElement>>>;
+};
+export {};

package/dist/ui/RouterLink.js

@@ -0,0 +1,36 @@
+import { jsx } from "react/jsx-runtime";
+import { ActionIcon, Anchor, Button, UnstyledButton } from "@mantine/core";
+import { createLink } from "@tanstack/react-router";
+import { forwardRef } from "react";
+const MantineLinkComponent = /*#__PURE__*/ forwardRef(({ classNames, ...props }, ref)=>/*#__PURE__*/ jsx(Anchor, {
+        ref: ref,
+        classNames: {
+            root: 'rolder-router-link-root',
+            ...classNames
+        },
+        c: "inherit",
+        underline: "never",
+        ...props
+    }));
+const MantineButtonComponent = /*#__PURE__*/ forwardRef((props, ref)=>/*#__PURE__*/ jsx(Button, {
+        ref: ref,
+        ...props
+    }));
+const MantineActionIconComponent = /*#__PURE__*/ forwardRef((props, ref)=>/*#__PURE__*/ jsx(ActionIcon, {
+        ref: ref,
+        ...props
+    }));
+const MantineUnstyledButtonComponent = /*#__PURE__*/ forwardRef((props, ref)=>/*#__PURE__*/ jsx(UnstyledButton, {
+        ref: ref,
+        ...props
+    }));
+const RouterLinkBase = createLink(MantineLinkComponent);
+const RouterLinkButton = createLink(MantineButtonComponent);
+const RouterLinkActionIcon = createLink(MantineActionIconComponent);
+const RouterLinkUnstyledButton = createLink(MantineUnstyledButtonComponent);
+const RouterLink = Object.assign(RouterLinkBase, {
+    Button: RouterLinkButton,
+    ActionIcon: RouterLinkActionIcon,
+    UnstyledButton: RouterLinkUnstyledButton
+});
+export { RouterLink };

package/dist/ui/editor/Content.d.ts

@@ -0,0 +1,3 @@
+export declare const Content: ({ height }: {
+    height: string;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/ui/editor/Content.js

@@ -0,0 +1,13 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { RichTextEditor } from "@mantine/tiptap";
+import { ScrollArea } from "../scrollArea/index.js";
+const Content = ({ height })=>/*#__PURE__*/ jsxs(ScrollArea.Root, {
+        height: height,
+        autoScroll: true,
+        radius: "md",
+        children: [
+            /*#__PURE__*/ jsx(RichTextEditor.Content, {}),
+            /*#__PURE__*/ jsx(ScrollArea.ScrollButton, {})
+        ]
+    });
+export { Content };

package/dist/ui/editor/Root.d.ts

@@ -0,0 +1,8 @@
+import { type RichTextEditorProps } from '@mantine/tiptap';
+import { type EditorOptions } from '@tiptap/react';
+export interface EditorProps extends RichTextEditorProps {
+    editable?: boolean;
+    disabledToolbar?: boolean;
+    onUpdate: EditorOptions['onUpdate'];
+}
+export declare const Root: ({ children, classNames, content, editable, disabledToolbar, onUpdate, editor: customEditor, ...props }: EditorProps) => import("react/jsx-runtime").JSX.Element;

package/dist/ui/editor/Root.js

@@ -0,0 +1,55 @@
+import { jsx } from "react/jsx-runtime";
+import { Link, RichTextEditor, getTaskListExtension } from "@mantine/tiptap";
+import extension_highlight from "@tiptap/extension-highlight";
+import extension_placeholder from "@tiptap/extension-placeholder";
+import { TableKit } from "@tiptap/extension-table";
+import extension_task_item from "@tiptap/extension-task-item";
+import extension_task_list from "@tiptap/extension-task-list";
+import extension_text_align from "@tiptap/extension-text-align";
+import { useEditor } from "@tiptap/react";
+import starter_kit from "@tiptap/starter-kit";
+import { useEffect } from "react";
+import { setDisabledToolbar } from "./store.js";
+const Root = ({ children, classNames, content, editable = true, disabledToolbar, onUpdate, editor: customEditor, ...props })=>{
+    useEffect(()=>setDisabledToolbar(disabledToolbar || false));
+    const editor = useEditor({
+        shouldRerenderOnTransaction: false,
+        immediatelyRender: false,
+        extensions: [
+            starter_kit.configure({
+                link: false
+            }),
+            extension_placeholder.configure({
+                placeholder: 'Документ пуст'
+            }),
+            Link,
+            extension_highlight,
+            extension_text_align.configure({
+                types: [
+                    'heading',
+                    'paragraph'
+                ]
+            }),
+            getTaskListExtension(extension_task_list),
+            extension_task_item.configure({
+                nested: true
+            }),
+            TableKit
+        ],
+        content,
+        onUpdate,
+        editable
+    });
+    return /*#__PURE__*/ jsx(RichTextEditor, {
+        editor: customEditor || editor,
+        classNames: {
+            root: 'rolder-editor-root',
+            content: 'rolder-editor-content',
+            toolbar: 'rolder-editor-toolbar',
+            ...classNames
+        },
+        ...props,
+        children: children
+    });
+};
+export { Root };

package/dist/ui/editor/Toolbar.d.ts

@@ -0,0 +1,5 @@
+import type { ReactNode } from 'react';
+export declare const Toolbar: ({ saving, children, }: {
+    saving?: boolean;
+    children?: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element | null;

package/dist/ui/editor/Toolbar.js

@@ -0,0 +1,138 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Loader } from "@mantine/core";
+import { RichTextEditor } from "@mantine/tiptap";
+import { IconCheck } from "@tabler/icons-react";
+import { getDisabledToolbar, useEditor } from "./store.js";
+const Toolbar = ({ saving, children })=>{
+    const editor = useEditor();
+    return getDisabledToolbar() ? null : /*#__PURE__*/ jsxs(RichTextEditor.Toolbar, {
+        sticky: true,
+        children: [
+            /*#__PURE__*/ jsxs(RichTextEditor.ControlsGroup, {
+                children: [
+                    /*#__PURE__*/ jsx(RichTextEditor.Bold, {
+                        disabled: !editor?.isEditable
+                    }),
+                    /*#__PURE__*/ jsx(RichTextEditor.Italic, {
+                        disabled: !editor?.isEditable
+                    }),
+                    /*#__PURE__*/ jsx(RichTextEditor.Underline, {
+                        disabled: !editor?.isEditable
+                    }),
+                    /*#__PURE__*/ jsx(RichTextEditor.Strikethrough, {
+                        disabled: !editor?.isEditable
+                    }),
+                    /*#__PURE__*/ jsx(RichTextEditor.ClearFormatting, {
+                        disabled: !editor?.isEditable
+                    }),
+                    /*#__PURE__*/ jsx(RichTextEditor.Highlight, {
+                        disabled: !editor?.isEditable
+                    }),
+                    /*#__PURE__*/ jsx(RichTextEditor.Code, {
+                        disabled: !editor?.isEditable
+                    })
+                ]
+            }),
+            /*#__PURE__*/ jsxs(RichTextEditor.ControlsGroup, {
+                children: [
+                    /*#__PURE__*/ jsx(RichTextEditor.H1, {
+                        disabled: !editor?.isEditable
+                    }),
+                    /*#__PURE__*/ jsx(RichTextEditor.H2, {
+                        disabled: !editor?.isEditable
+                    }),
+                    /*#__PURE__*/ jsx(RichTextEditor.H3, {
+                        disabled: !editor?.isEditable
+                    }),
+                    /*#__PURE__*/ jsx(RichTextEditor.H4, {
+                        disabled: !editor?.isEditable
+                    })
+                ]
+            }),
+            /*#__PURE__*/ jsxs(RichTextEditor.ControlsGroup, {
+                children: [
+                    /*#__PURE__*/ jsx(RichTextEditor.Blockquote, {
+                        disabled: !editor?.isEditable
+                    }),
+                    /*#__PURE__*/ jsx(RichTextEditor.Hr, {
+                        disabled: !editor?.isEditable
+                    }),
+                    /*#__PURE__*/ jsx(RichTextEditor.BulletList, {
+                        disabled: !editor?.isEditable
+                    }),
+                    /*#__PURE__*/ jsx(RichTextEditor.OrderedList, {
+                        disabled: !editor?.isEditable
+                    })
+                ]
+            }),
+            /*#__PURE__*/ jsxs(RichTextEditor.ControlsGroup, {
+                children: [
+                    /*#__PURE__*/ jsx(RichTextEditor.TaskList, {
+                        disabled: !editor?.isEditable
+                    }),
+                    /*#__PURE__*/ jsx(RichTextEditor.TaskListLift, {
+                        disabled: !editor?.isEditable
+                    }),
+                    /*#__PURE__*/ jsx(RichTextEditor.TaskListSink, {
+                        disabled: !editor?.isEditable
+                    })
+                ]
+            }),
+            /*#__PURE__*/ jsxs(RichTextEditor.ControlsGroup, {
+                children: [
+                    /*#__PURE__*/ jsx(RichTextEditor.Link, {
+                        disabled: !editor?.isEditable
+                    }),
+                    /*#__PURE__*/ jsx(RichTextEditor.Unlink, {
+                        disabled: !editor?.isEditable
+                    })
+                ]
+            }),
+            /*#__PURE__*/ jsxs(RichTextEditor.ControlsGroup, {
+                children: [
+                    /*#__PURE__*/ jsx(RichTextEditor.AlignLeft, {
+                        disabled: !editor?.isEditable
+                    }),
+                    /*#__PURE__*/ jsx(RichTextEditor.AlignCenter, {
+                        disabled: !editor?.isEditable
+                    }),
+                    /*#__PURE__*/ jsx(RichTextEditor.AlignJustify, {
+                        disabled: !editor?.isEditable
+                    }),
+                    /*#__PURE__*/ jsx(RichTextEditor.AlignRight, {
+                        disabled: !editor?.isEditable
+                    })
+                ]
+            }),
+            /*#__PURE__*/ jsxs(RichTextEditor.ControlsGroup, {
+                children: [
+                    /*#__PURE__*/ jsx(RichTextEditor.Undo, {
+                        disabled: !editor?.isEditable
+                    }),
+                    /*#__PURE__*/ jsx(RichTextEditor.Redo, {
+                        disabled: !editor?.isEditable
+                    })
+                ]
+            }),
+            /*#__PURE__*/ jsxs(RichTextEditor.ControlsGroup, {
+                ml: "auto",
+                children: [
+                    children,
+                    /*#__PURE__*/ jsx(RichTextEditor.Control, {
+                        ml: "10px",
+                        style: {
+                            cursor: 'default'
+                        },
+                        children: saving ? /*#__PURE__*/ jsx(Loader, {
+                            size: 14
+                        }) : /*#__PURE__*/ jsx(IconCheck, {
+                            stroke: 1.5,
+                            size: 16
+                        })
+                    })
+                ]
+            })
+        ]
+    });
+};
+export { Toolbar };

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

@@ -0,0 +1,11 @@
+export declare const Editor: {
+    Root: ({ children, classNames, content, editable, disabledToolbar, onUpdate, editor: customEditor, ...props }: import("./Root").EditorProps) => import("react/jsx-runtime").JSX.Element;
+    Content: ({ height }: {
+        height: string;
+    }) => import("react/jsx-runtime").JSX.Element;
+    Toolbar: ({ saving, children, }: {
+        saving?: boolean;
+        children?: import("react").ReactNode;
+    }) => import("react/jsx-runtime").JSX.Element | null;
+};
+export * from './store';

package/dist/ui/editor/index.js

@@ -0,0 +1,10 @@
+import { Content } from "./Content.js";
+import { Root } from "./Root.js";
+import { Toolbar } from "./Toolbar.js";
+export * from "./store.js";
+const Editor = {
+    Root: Root,
+    Content: Content,
+    Toolbar: Toolbar
+};
+export { Editor };

package/dist/ui/editor/store.d.ts

@@ -0,0 +1,6 @@
+import type { Editor } from '@tiptap/react';
+export declare const getEditor: () => Editor | null;
+export declare const useEditor: () => Editor | null;
+export declare const setEditor: (editor: Editor) => void;
+export declare const getDisabledToolbar: () => boolean;
+export declare const setDisabledToolbar: (disabled: boolean) => void;

package/dist/ui/editor/store.js

@@ -0,0 +1,10 @@
+import { useStore } from "@nanostores/react";
+import { atom } from "nanostores";
+const $editor = atom(null);
+const getEditor = ()=>$editor.get();
+const useEditor = ()=>useStore($editor);
+const setEditor = (editor)=>$editor.set(editor);
+const $disabledToolbar = atom(false);
+const getDisabledToolbar = ()=>$disabledToolbar.get();
+const setDisabledToolbar = (disabled)=>$disabledToolbar.set(disabled);
+export { getDisabledToolbar, getEditor, setDisabledToolbar, setEditor, useEditor };

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.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.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/Forbidden.d.ts

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

package/dist/ui/error/Forbidden.js

@@ -0,0 +1,32 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Stack, Title } from "@mantine/core";
+import { RouterLink } from "../RouterLink.js";
+const Forbidden = ()=>/*#__PURE__*/ jsxs(Stack, {
+        align: "center",
+        justify: "center",
+        gap: 0,
+        ta: "center",
+        h: "100vh",
+        children: [
+            /*#__PURE__*/ jsx(Title, {
+                textWrap: "balance",
+                size: 65,
+                children: "Доступ запрещен!"
+            }),
+            /*#__PURE__*/ jsx(Title, {
+                order: 3,
+                ml: 4,
+                textWrap: "balance",
+                c: "var(--mantine-color-error)",
+                children: "У вас нет доступа к этой странице"
+            }),
+            /*#__PURE__*/ jsx(RouterLink.Button, {
+                to: "/",
+                mt: "xl",
+                size: "lg",
+                radius: "md",
+                children: "На главную"
+            })
+        ]
+    });
+export { Forbidden };

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 };