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

package/dist/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/ui/AnimatedChevron.d.ts

@@ -0,0 +1,6 @@
+import type { SVGProps } from 'react';
+interface Props extends SVGProps<SVGSVGElement> {
+    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,31 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+const AnimatedChevron = ({ expanded, style, ...props })=>/*#__PURE__*/ jsxs("svg", {
+        xmlns: "http://www.w3.org/2000/svg",
+        width: "24",
+        height: "24",
+        viewBox: "0 0 24 24",
+        fill: "none",
+        stroke: "currentColor",
+        strokeWidth: "1.5",
+        strokeLinecap: "round",
+        strokeLinejoin: "round",
+        role: "img",
+        "aria-label": "Chevron",
+        style: {
+            transition: 'transform 0.2s ease-in-out',
+            transform: expanded ? 'rotate(-180deg)' : 'rotate(0deg)',
+            ...style
+        },
+        ...props,
+        children: [
+            /*#__PURE__*/ jsx("path", {
+                stroke: "none",
+                d: "M0 0h24v24H0z",
+                fill: "none"
+            }),
+            /*#__PURE__*/ jsx("path", {
+                d: "M6 9l6 6l6 -6"
+            })
+        ]
+    });
+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 "../functions/getCookie.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, {
+        h: height,
+        autoScroll: true,
+        radius: "md",
+        children: [
+            /*#__PURE__*/ jsx(RichTextEditor.Content, {}),
+            /*#__PURE__*/ jsx(ScrollArea.ScrollButton, {})
+        ]
+    });
+export { Content };

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

@@ -0,0 +1,17 @@
+import type { Editor } from '@tiptap/react';
+import type { EditorProps } from './types';
+interface EditorContext {
+    editor: Editor | null;
+    editable?: boolean;
+    setEditable: (value: boolean) => void;
+    disabledToolbar: boolean;
+    setDisabledToolbar: (value: boolean) => void;
+    focused: boolean;
+    setFocused: (value: boolean) => void;
+    editedByUser: boolean;
+    setEditedByUser: (value: boolean) => void;
+}
+declare const EditorContext: import("react").Context<EditorContext | null>;
+export declare const Provider: ({ children, initialContent, initialEditable, initialDisabledToolbar, onChange, }: EditorProps) => import("react/jsx-runtime").JSX.Element;
+export declare const useEditor: () => EditorContext;
+export {};

package/dist/ui/editor/Provider.js

@@ -0,0 +1,80 @@
+import { jsx } from "react/jsx-runtime";
+import { Link, 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 { createContext, useContext, useEffect, useState } from "react";
+const EditorContext = /*#__PURE__*/ createContext(null);
+const Provider = ({ children, initialContent, initialEditable = true, initialDisabledToolbar, onChange })=>{
+    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: initialContent,
+        onUpdate: ({ editor })=>{
+            onChange?.(editor.getHTML());
+        },
+        editable: initialEditable
+    });
+    const [editable, setEditable] = useState(initialEditable);
+    const [disabledToolbar, setDisabledToolbar] = useState(!!initialDisabledToolbar);
+    const [editedByUser, setEditedByUser] = useState(true);
+    const [focused, setFocused] = useState(false);
+    useEffect(()=>{
+        editor?.on('focus', ()=>setFocused(true));
+        editor?.on('blur', ()=>setFocused(false));
+        editor?.on('update', ({ transaction })=>{
+            if (transaction.docChanged && focused) setEditedByUser(true);
+            if (transaction.docChanged && !focused) setEditedByUser(false);
+        });
+    }, [
+        editor,
+        focused
+    ]);
+    const value = {
+        editor,
+        editable,
+        setEditable,
+        disabledToolbar,
+        setDisabledToolbar,
+        editedByUser,
+        setEditedByUser,
+        focused,
+        setFocused
+    };
+    return /*#__PURE__*/ jsx(EditorContext.Provider, {
+        value: value,
+        children: children
+    });
+};
+const Provider_useEditor = ()=>{
+    const context = useContext(EditorContext);
+    if (!context) throw new Error('useEditor must be used within EditorProvider');
+    return context;
+};
+export { Provider, Provider_useEditor as useEditor };

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

@@ -0,0 +1,2 @@
+import { type RichTextEditorProps } from '@mantine/tiptap';
+export declare const Root: ({ children, classNames, ...props }: Omit<RichTextEditorProps, "editor">) => import("react/jsx-runtime").JSX.Element;

package/dist/ui/editor/Root.js

@@ -0,0 +1,18 @@
+import { jsx } from "react/jsx-runtime";
+import { RichTextEditor } from "@mantine/tiptap";
+import { useEditor } from "./Provider.js";
+const Root = ({ children, classNames, ...props })=>{
+    const { editor } = useEditor();
+    return /*#__PURE__*/ jsx(RichTextEditor, {
+        editor: 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,156 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Loader } from "@mantine/core";
+import { RichTextEditor } from "@mantine/tiptap";
+import { useEditor } from "./Provider.js";
+const Toolbar = ({ saving, children })=>{
+    const { editor, disabledToolbar } = useEditor();
+    return disabledToolbar ? 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__*/ jsxs("svg", {
+                            xmlns: "http://www.w3.org/2000/svg",
+                            width: "16",
+                            height: "16",
+                            viewBox: "0 0 16 16",
+                            fill: "none",
+                            stroke: "currentColor",
+                            strokeWidth: "1.5",
+                            strokeLinecap: "round",
+                            strokeLinejoin: "round",
+                            role: "img",
+                            "aria-label": "Saved",
+                            children: [
+                                /*#__PURE__*/ jsx("path", {
+                                    stroke: "none",
+                                    d: "M0 0h24v24H0z",
+                                    fill: "none"
+                                }),
+                                /*#__PURE__*/ jsx("path", {
+                                    d: "M5 12l5 5l10 -10"
+                                })
+                            ]
+                        })
+                    })
+                ]
+            })
+        ]
+    });
+};
+export { Toolbar };

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

@@ -0,0 +1,12 @@
+export declare const Editor: {
+    Root: ({ children, classNames, ...props }: Omit<import("@mantine/tiptap").RichTextEditorProps, "editor">) => 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;
+    Provider: ({ children, initialContent, initialEditable, initialDisabledToolbar, onChange, }: import("./types").EditorProps) => import("react/jsx-runtime").JSX.Element;
+};
+export { useEditor } from './Provider';

package/dist/ui/editor/index.js

@@ -0,0 +1,11 @@
+import { Content } from "./Content.js";
+import { Provider, useEditor } from "./Provider.js";
+import { Root } from "./Root.js";
+import { Toolbar } from "./Toolbar.js";
+const Editor = {
+    Root: Root,
+    Content: Content,
+    Toolbar: Toolbar,
+    Provider: Provider
+};
+export { Editor, useEditor };

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

@@ -0,0 +1,7 @@
+export interface EditorProps {
+    children: React.ReactNode;
+    initialContent?: string;
+    initialEditable?: boolean;
+    initialDisabledToolbar?: boolean;
+    onChange?: (value: string) => void;
+}

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;