@rolder/kit 3.0.0-alpha.17 → 3.0.0-alpha.19

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

@@ -0,0 +1,14 @@
+import { File } from "./File.js";
+import { Footer } from "./Footer.js";
+import { Root } from "./Root.js";
+import { Submit } from "./Submit.js";
+import { Textarea } from "./Textarea.js";
+export * from "./types.js";
+const PromptInput = {
+    Root: Root,
+    Textarea: Textarea,
+    Footer: Footer,
+    Submit: Submit,
+    File: File
+};
+export { PromptInput };

package/dist/ai/ui/promptInput/types.d.ts

@@ -0,0 +1,11 @@
+export type Accept = 'text' | 'image' | 'pdf' | 'excel' | 'word';
+export interface PromptInputProps {
+    children: React.ReactNode;
+    onSubmit: ({ text, file }: {
+        text: string;
+        file?: File;
+    }) => void;
+    submiting: boolean;
+    uploading: boolean;
+    accept?: Accept[];
+}

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

@@ -34,7 +34,7 @@ export declare const defaultTheme: {
     headings?: {
         fontFamily?: string | undefined;
         fontWeight?: string | undefined;
-        textWrap?: "wrap" | "nowrap" | "balance" | "pretty" | "stable" | undefined;
+        textWrap?: "balance" | "nowrap" | "wrap" | "stable" | "pretty" | undefined;
         sizes?: {
             h1?: {
                 fontSize?: string | undefined;

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 './ai';
 export * from './app';
 export * from './functions';
+export * from './hooks';
+export * from './ui';

package/dist/index.js

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

package/dist/styles.css

@@ -0,0 +1,74 @@
+.rolder-prompt-input-root {
+  background-color: light-dark(var(--mantine-color-white), var(--mantine-color-dark-6));
+
+  &:focus-within {
+    border-color: var(--mantine-primary-color-filled);
+    border-color: var(--mantine-primary-color-filled);
+    outline: none;
+  }
+}
+
+.rolder-prompt-input-textarea {
+  border: 0;
+  border-radius: 8px;
+  overflow: hidden;
+}
+
+.rolder-prompt-input-file-action-action {
+  color: light-dark(var(--mantine-color-gray-7), var(--mantine-color-dark-1));
+
+  &[data-disabled] {
+    color: light-dark(var(--mantine-color-gray-5), var(--mantine-color-dark-3));
+  }
+}
+
+.rolder-editor-root {
+  --editor-border-color: light-dark(var(--mantine-color-gray-3), var(--mantine-color-dark-4));
+  border: rem(1px) solid var(--editor-border-color);
+  border-radius: var(--mantine-radius-md);
+}
+
+.rolder-editor-content {
+  border-radius: var(--mantine-radius-md);
+}
+
+.rolder-editor-toolbar {
+  border-color: var(--editor-border-color);
+  border-top-left-radius: var(--mantine-radius-md);
+  border-top-right-radius: var(--mantine-radius-md);
+}
+
+.rolder-hover-paper-root {
+  transition: background-color .2s ease-in-out;
+
+  &:hover {
+    background-color: light-dark(var(--mantine-color-gray-0), var(--mantine-color-dark-6));
+    cursor: pointer;
+    transition: background-color .2s ease-in-out;
+  }
+
+  &[data-disabled] {
+    background-color: unset;
+    cursor: default;
+  }
+}
+
+.rolder-router-link-root {
+  color: inherit;
+  text-decoration: none;
+}
+
+.rolder-scroll-area-viewport {
+  border-radius: var(--radius);
+}
+
+.rolder-scroll-area-content {
+  width: 100%;
+  height: 100%;
+}
+
+.rolder-scroll-area-scrollbar {
+  border-top-right-radius: var(--radius);
+  border-bottom-right-radius: var(--radius);
+}
+

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 "../functions/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, {
+        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,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 { 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__*/ jsx(IconCheck, {
+                            stroke: 1.5,
+                            size: 16
+                        })
+                    })
+                ]
+            })
+        ]
+    });
+};
+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';