@fileverse-dev/ddoc 2.1.7-patch-4 → 2.1.7-soucemaps-patch-1

package/dist/package/common/carousel.d.ts

@@ -0,0 +1,22 @@
+import { default as React } from 'react';
+import { default as useEmblaCarousel, UseEmblaCarouselType } from 'embla-carousel-react';
+
+type CarouselApi = UseEmblaCarouselType[1];
+type UseCarouselParameters = Parameters<typeof useEmblaCarousel>;
+type CarouselOptions = UseCarouselParameters[0];
+type CarouselPlugin = UseCarouselParameters[1];
+type CarouselProps = {
+    opts?: CarouselOptions;
+    plugins?: CarouselPlugin;
+    orientation?: 'horizontal' | 'vertical';
+    setApi?: (api: CarouselApi) => void;
+};
+declare const Carousel: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & CarouselProps & React.RefAttributes<HTMLDivElement>>;
+declare const CarouselContent: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CarouselItem: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CarouselIndicator: React.ForwardRefExoticComponent<React.ButtonHTMLAttributes<HTMLButtonElement> & {
+    index: number;
+} & React.RefAttributes<HTMLButtonElement>>;
+declare const CarouselPrevious: React.ForwardRefExoticComponent<React.ButtonHTMLAttributes<HTMLButtonElement> & React.RefAttributes<HTMLButtonElement>>;
+declare const CarouselNext: React.ForwardRefExoticComponent<React.ButtonHTMLAttributes<HTMLButtonElement> & React.RefAttributes<HTMLButtonElement>>;
+export { type CarouselApi, Carousel, CarouselContent, CarouselItem, CarouselIndicator, CarouselPrevious, CarouselNext, };

package/dist/package/common/dropdown.d.ts

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+
+export declare const DropdownCategoryTitle: ({ children, }: {
+    children: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const DropdownButton: ({ children, isActive, onClick, disabled, className, }: {
+    children: React.ReactNode;
+    isActive?: boolean;
+    onClick?: () => void;
+    disabled?: boolean;
+    className?: string;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/package/common/surface.d.ts

@@ -0,0 +1,7 @@
+import { HTMLProps } from 'react';
+
+export type SurfaceProps = HTMLProps<HTMLDivElement> & {
+    withShadow?: boolean;
+    withBorder?: boolean;
+};
+export declare const Surface: import('react').ForwardRefExoticComponent<Omit<SurfaceProps, "ref"> & import('react').RefAttributes<HTMLDivElement>>;

package/dist/package/common/toolbar-button.d.ts

@@ -0,0 +1,10 @@
+declare const ToolbarButton: import('react').ForwardRefExoticComponent<{
+    icon: string;
+    isActive: boolean;
+    onClick: () => void;
+    tooltip?: string;
+    classNames?: string;
+    disabled?: boolean;
+    size?: "sm" | "md" | "lg";
+} & import('react').RefAttributes<HTMLButtonElement>>;
+export default ToolbarButton;

package/dist/package/common/toolbar.d.ts

@@ -0,0 +1,13 @@
+import { HTMLProps } from 'react';
+
+export type ToolbarWrapperProps = {
+    shouldShowContent?: boolean;
+    isVertical?: boolean;
+} & HTMLProps<HTMLDivElement>;
+export type ToolbarDividerProps = {
+    horizontal?: boolean;
+} & HTMLProps<HTMLDivElement>;
+export declare const Toolbar: {
+    Wrapper: import('react').ForwardRefExoticComponent<Omit<ToolbarWrapperProps, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+    Divider: import('react').ForwardRefExoticComponent<Omit<ToolbarDividerProps, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+};

package/dist/package/common/types.d.ts

@@ -0,0 +1,19 @@
+import { default as React } from 'react';
+import { Editor as CoreEditor } from '@tiptap/core';
+import { Editor } from '@tiptap/react';
+import { EditorState } from '@tiptap/pm/state';
+import { EditorView } from '@tiptap/pm/view';
+
+export interface MenuProps {
+    editor: Editor;
+    appendTo?: React.RefObject<any>;
+    shouldHide?: boolean;
+}
+export interface ShouldShowProps {
+    editor?: CoreEditor;
+    view: EditorView;
+    state?: EditorState;
+    oldState?: EditorState;
+    from?: number;
+    to?: number;
+}

package/dist/package/components/color-selector.d.ts

@@ -0,0 +1,14 @@
+import { Editor } from '@tiptap/core';
+import { Dispatch, FC, SetStateAction } from 'react';
+
+export interface BubbleColorMenuItem {
+    name: string;
+    color: string;
+}
+interface ColorSelectorProps {
+    editor: Editor;
+    isOpen: boolean;
+    setIsOpen: Dispatch<SetStateAction<boolean>>;
+}
+export declare const ColorSelector: FC<ColorSelectorProps>;
+export {};

package/dist/package/components/editor-bubble-menu/node-selector.d.ts

@@ -0,0 +1,3 @@
+import { NodeSelectorProps } from './types';
+
+export declare const NodeSelector: ({ editor, elementRef }: NodeSelectorProps) => import("react/jsx-runtime").JSX.Element;

package/dist/package/components/editor-bubble-menu/props.d.ts

@@ -0,0 +1,60 @@
+import { Editor } from '@tiptap/core';
+import { EditorBubbleMenuProps } from './types';
+
+export declare const bubbleMenuProps: (props: EditorBubbleMenuProps) => {
+    tippyOptions: {
+        moveTransition: string;
+        duration: number;
+        animation: string;
+        zIndex: number;
+        appendTo: () => HTMLElement | null;
+        popperOptions: {
+            strategy: string;
+            modifiers: ({
+                name: string;
+                options: {
+                    fallbackPlacements: string[];
+                    altAxis?: undefined;
+                    tether?: undefined;
+                };
+            } | {
+                name: string;
+                options: {
+                    altAxis: boolean;
+                    tether: boolean;
+                    fallbackPlacements?: undefined;
+                };
+            })[];
+        };
+    };
+    className?: string | undefined;
+    editor: import('@tiptap/extension-bubble-menu').BubbleMenuPluginProps["editor"] | null;
+    pluginKey?: string | import('prosemirror-state').PluginKey<any> | undefined;
+    updateDelay?: number | undefined;
+    shouldShow?: ((props: {
+        editor: Editor;
+        element: HTMLElement;
+        view: import('prosemirror-view').EditorView;
+        state: import('prosemirror-state').EditorState;
+        oldState?: import('prosemirror-state').EditorState;
+        from: number;
+        to: number;
+    }) => boolean) | null | undefined;
+    activeCommentId: string | null;
+    isPreviewMode: boolean;
+    disableInlineComment: boolean;
+    onError?: (errorString: string) => void;
+    zoomLevel: string;
+    setIsCommentSectionOpen?: (isOpen: boolean) => void;
+    inlineCommentData?: import('../../types').InlineCommentData;
+    setInlineCommentData?: React.Dispatch<React.SetStateAction<import('../../types').InlineCommentData>>;
+    walletAddress?: string;
+    username?: string;
+    onInlineComment?: () => void;
+    commentDrawerOpen?: boolean;
+    setCommentDrawerOpen?: React.Dispatch<import('react').SetStateAction<boolean>>;
+    isCollabDocumentPublished?: boolean | undefined;
+};
+export declare const shouldShow: ({ editor }: {
+    editor: Editor;
+}) => boolean;

package/dist/package/components/editor-bubble-menu/types.d.ts

@@ -0,0 +1,30 @@
+import { BubbleMenuProps, Editor } from '@tiptap/react';
+import { SetStateAction } from 'react';
+import { InlineCommentData } from '../../types';
+
+export interface BubbleMenuItem {
+    name: string;
+    isActive: () => boolean;
+    command: () => void;
+    icon: any;
+}
+export type EditorBubbleMenuProps = Omit<BubbleMenuProps, 'children'> & {
+    activeCommentId: string | null;
+    isPreviewMode: boolean;
+    disableInlineComment: boolean;
+    onError?: (errorString: string) => void;
+    zoomLevel: string;
+    setIsCommentSectionOpen?: (isOpen: boolean) => void;
+    inlineCommentData?: InlineCommentData;
+    setInlineCommentData?: React.Dispatch<React.SetStateAction<InlineCommentData>>;
+    walletAddress?: string;
+    username?: string;
+    onInlineComment?: () => void;
+    commentDrawerOpen?: boolean;
+    setCommentDrawerOpen?: React.Dispatch<SetStateAction<boolean>>;
+    isCollabDocumentPublished?: boolean | undefined;
+};
+export interface NodeSelectorProps {
+    editor: Editor;
+    elementRef: React.RefObject<HTMLDivElement>;
+}

package/dist/package/components/editor-utils.d.ts

@@ -0,0 +1,119 @@
+import { default as React, Dispatch, SetStateAction } from 'react';
+import { IEditorTool } from '../hooks/use-visibility';
+import { Editor } from '@tiptap/react';
+
+interface IEditorToolElement {
+    icon: any;
+    title: string;
+    onClick: () => void;
+    isActive: boolean;
+    group?: string;
+}
+export declare const fonts: {
+    title: string;
+    value: string;
+    command: (editor: Editor) => void;
+}[];
+export declare const ERR_MSG_MAP: {
+    IMAGE_SIZE: string;
+};
+export declare const IMG_UPLOAD_SETTINGS: {
+    Extended: {
+        maxSize: number;
+        errorMsg: string;
+    };
+    Base: {
+        maxSize: number;
+        errorMsg: string;
+    };
+};
+export declare const useEditorToolbar: ({ editor, onError, secureImageUploadUrl, onMarkdownExport, onMarkdownImport, onPdfExport, }: {
+    editor: Editor;
+    onError?: (errorString: string) => void;
+    secureImageUploadUrl?: string;
+    onMarkdownExport?: () => void;
+    onMarkdownImport?: () => void;
+    onPdfExport?: () => void;
+}) => {
+    undoRedoTools: (IEditorToolElement | null)[];
+    toolbar: (IEditorToolElement | null)[];
+    markdownOptions: (IEditorToolElement | null)[];
+    pdfExportOption: (IEditorToolElement | null)[];
+    bottomToolbar: (IEditorToolElement | null)[];
+    toolRef: React.RefObject<HTMLDivElement>;
+    toolVisibility: IEditorTool;
+    setToolVisibility: React.Dispatch<React.SetStateAction<IEditorTool>>;
+    isExportModalOpen: boolean;
+    setIsExportModalOpen: React.Dispatch<React.SetStateAction<boolean>>;
+    fileExportsOpen: boolean;
+    setFileExportsOpen: React.Dispatch<React.SetStateAction<boolean>>;
+};
+export declare const TextHighlighter: ({ editor, setVisibility, elementRef, }: {
+    editor: Editor;
+    elementRef: React.RefObject<HTMLDivElement>;
+    setVisibility: Dispatch<SetStateAction<IEditorTool>>;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const EditorFontFamily: ({ elementRef, editor, setToolVisibility, }: {
+    elementRef: React.RefObject<HTMLDivElement>;
+    editor: Editor;
+    setToolVisibility: Dispatch<SetStateAction<IEditorTool>>;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const EditorAlignment: ({ elementRef, editor, setToolVisibility, }: {
+    elementRef: React.RefObject<HTMLDivElement>;
+    editor: Editor;
+    setToolVisibility: Dispatch<SetStateAction<IEditorTool>>;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const EditorList: ({ elementRef, editor, setToolVisibility, }: {
+    elementRef: React.RefObject<HTMLDivElement>;
+    editor: Editor;
+    setToolVisibility: Dispatch<SetStateAction<IEditorTool>>;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const LinkPopup: ({ elementRef, editor, setToolVisibility, bubbleMenu, setIsLinkPopupOpen, onError, }: {
+    elementRef: React.RefObject<HTMLDivElement>;
+    editor: Editor;
+    setToolVisibility: Dispatch<SetStateAction<IEditorTool>>;
+    bubbleMenu?: boolean;
+    setIsLinkPopupOpen?: Dispatch<SetStateAction<boolean>>;
+    onError?: (errorString: string) => void;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const InlineCommentPopup: ({ elementRef, editor, setIsCommentSectionOpen, setIsInlineCommentOpen, inlineCommentData, setInlineCommentData, onInlineComment, }: {
+    elementRef: React.RefObject<HTMLDivElement>;
+    editor: Editor;
+    setIsCommentSectionOpen: Dispatch<SetStateAction<boolean>>;
+    setIsInlineCommentOpen: Dispatch<SetStateAction<boolean>>;
+    inlineCommentData: {
+        highlightedTextContent: string;
+        inlineCommentText: string;
+        handleClick: boolean;
+    };
+    setInlineCommentData: (data: {
+        highlightedTextContent?: string;
+        inlineCommentText?: string;
+        handleClick?: boolean;
+    }) => void;
+    onInlineComment?: () => void;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const ScriptsPopup: ({ elementRef, editor, }: {
+    elementRef: React.RefObject<HTMLDivElement>;
+    editor: Editor;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const TextColor: ({ editor, setVisibility, elementRef, }: {
+    editor: Editor;
+    elementRef: React.RefObject<HTMLDivElement>;
+    setVisibility: Dispatch<SetStateAction<IEditorTool>>;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const TextHeading: ({ editor, setVisibility, elementRef, }: {
+    editor: Editor;
+    elementRef: React.RefObject<HTMLDivElement>;
+    setVisibility: Dispatch<SetStateAction<IEditorTool>>;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const TextFormatingPopup: ({ editor, isOpen, setIsOpen, setToolVisibility, }: {
+    editor: Editor;
+    isOpen: boolean;
+    setIsOpen: (open: boolean) => void;
+    setToolVisibility: Dispatch<SetStateAction<IEditorTool>>;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const TextColorPicker: ({ editor }: {
+    editor: Editor;
+}) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/package/components/inline-comment/comment-card.d.ts

@@ -0,0 +1,4 @@
+import { CommentCardProps } from './types';
+
+export declare const CommentCard: ({ username, selectedContent, comment, createdAt, replies, onResolve, onDelete, onUnresolve, isResolved, isDropdown, activeCommentId, id, isDisabled, isCommentOwner, version, emptyComment, }: CommentCardProps) => import("react/jsx-runtime").JSX.Element;
+export declare const UserDisplaySkeleton: () => import("react/jsx-runtime").JSX.Element;

package/dist/package/components/inline-comment/comment-dropdown.d.ts

@@ -0,0 +1,3 @@
+import { CommentDropdownProps } from './types';
+
+export declare const CommentDropdown: ({ activeCommentId, initialComment, isBubbleMenu, selectedContent, isDisabled, isCommentOwner, }: CommentDropdownProps) => import("react/jsx-runtime").JSX.Element | null;

package/dist/package/components/inline-comment/comment-section.d.ts

@@ -0,0 +1,3 @@
+import { CommentSectionProps } from './types';
+
+export declare const CommentSection: ({ activeCommentId, isNavbarVisible, isPresentationMode, }: CommentSectionProps) => import("react/jsx-runtime").JSX.Element;

package/dist/package/components/inline-comment/comment-username.d.ts

@@ -0,0 +1,4 @@
+import { CommentUsernameProps } from './context/types';
+
+declare const CommentUsername: ({ username, setUsername, isNavbarVisible, isConnected, connectViaUsername, connectViaWallet, isLoading, }: CommentUsernameProps) => import("react/jsx-runtime").JSX.Element;
+export { CommentUsername };

package/dist/package/components/inline-comment/context/types.d.ts

@@ -0,0 +1,86 @@
+import { Editor } from '@tiptap/react';
+import { IComment } from '../../../extensions/comment';
+import { SetStateAction } from 'react';
+import { CommentAccountProps } from '../../../types';
+
+export interface CommentContextType extends CommentAccountProps {
+    comments: IComment[];
+    setComments: React.Dispatch<SetStateAction<IComment[]>>;
+    editor: Editor;
+    username?: string | null;
+    setUsername?: React.Dispatch<SetStateAction<string>>;
+    showResolved: boolean;
+    setShowResolved: (show: boolean) => void;
+    resolveComment: (commentId: string) => void;
+    unresolveComment: (commentId: string) => void;
+    deleteComment: (commentId: string) => void;
+    handleAddReply: (activeCommentId: string, replyContent: string, onCommentReply: (activeCommentId: string, reply: IComment) => void) => void;
+    focusCommentInEditor: (commentId: string) => void;
+    handleReplyChange: (event: React.ChangeEvent<HTMLTextAreaElement>) => void;
+    handleCommentChange: (event: React.ChangeEvent<HTMLTextAreaElement>) => void;
+    handleCommentKeyDown: (event: React.KeyboardEvent<HTMLTextAreaElement>) => void;
+    handleReplySubmit: () => void;
+    toggleResolved: () => void;
+    openReplyId: string | null;
+    setOpenReplyId: (id: string | null) => void;
+    handleReplyKeyDown: (event: React.KeyboardEvent<HTMLTextAreaElement>) => void;
+    commentsSectionRef: React.RefObject<HTMLDivElement>;
+    replySectionRef: React.RefObject<HTMLDivElement>;
+    addComment: (content?: string) => void;
+    handleCommentSubmit: () => void;
+    reply: string;
+    setReply: React.Dispatch<React.SetStateAction<string>>;
+    comment: string;
+    setComment: React.Dispatch<React.SetStateAction<string>>;
+    onPrevComment: () => void;
+    onNextComment: () => void;
+    activeCommentIndex: number;
+    activeComment: IComment | undefined;
+    selectedText: string;
+    isCommentOpen: boolean;
+    handleInlineComment: () => void;
+    portalRef: React.RefObject<HTMLDivElement>;
+    buttonRef: React.RefObject<HTMLDivElement>;
+    dropdownRef: React.RefObject<HTMLDivElement>;
+    activeComments: IComment[];
+    handleInput: (e: React.FormEvent<HTMLTextAreaElement>, content: string) => void;
+    isCommentActive: boolean;
+    isCommentResolved: boolean;
+    ensResolutionUrl: string;
+    onCommentReply?: (activeCommentId: string, reply: IComment) => void;
+    onComment?: () => void;
+    setCommentDrawerOpen?: React.Dispatch<React.SetStateAction<boolean>>;
+    inlineCommentData: {
+        inlineCommentText: string;
+        handleClick: boolean;
+    };
+    setInlineCommentData: React.Dispatch<React.SetStateAction<{
+        inlineCommentText: string;
+        handleClick: boolean;
+    }>>;
+}
+export interface CommentProviderProps extends CommentAccountProps {
+    children: React.ReactNode;
+    editor: Editor;
+    initialComments?: IComment[];
+    setInitialComments?: React.Dispatch<SetStateAction<IComment[]>>;
+    onCommentReply?: (activeCommentId: string, reply: IComment) => void;
+    onNewComment?: (newComment: IComment) => void;
+    onResolveComment?: (activeCommentId: string) => void;
+    onUnresolveComment?: (activeCommentId: string) => void;
+    onDeleteComment?: (activeCommentId: string) => void;
+    username: string | null;
+    setUsername?: React.Dispatch<SetStateAction<string>>;
+    activeCommentId: string | null;
+    setActiveCommentId: React.Dispatch<React.SetStateAction<string | null>>;
+    focusCommentWithActiveId: (id: string) => void;
+    ensResolutionUrl: string;
+    onInlineComment?: () => void;
+    onComment?: () => void;
+    setCommentDrawerOpen?: React.Dispatch<React.SetStateAction<boolean>>;
+}
+export interface CommentUsernameProps extends CommentAccountProps {
+    username?: string | null;
+    setUsername?: React.Dispatch<SetStateAction<string>>;
+    isNavbarVisible?: boolean;
+}

package/dist/package/components/inline-comment/empty-comments.d.ts

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

package/dist/package/components/inline-comment/types.d.ts

@@ -0,0 +1,70 @@
+import { BubbleMenuProps, Editor } from '@tiptap/react';
+import { IComment } from '../../extensions/comment';
+import { SetStateAction } from 'react';
+
+export interface UseCommentActionsProps {
+    editor: Editor;
+    comments: IComment[];
+    setComments: (comments: IComment[]) => void;
+}
+export interface CommentDropdownProps {
+    editor: Editor;
+    onSubmit: (content: string) => string;
+    onClose: () => void;
+    setComments?: (comments: IComment[]) => void;
+    comments?: IComment[];
+    username?: string;
+    walletAddress?: string;
+    activeCommentId?: string;
+    commentDrawerOpen?: boolean;
+    setCommentDrawerOpen?: React.Dispatch<SetStateAction<boolean>>;
+    initialComment?: string;
+    isBubbleMenu?: boolean;
+    selectedContent?: string;
+    isDisabled?: boolean;
+    isCommentOwner?: boolean;
+}
+export interface CommentDrawerProps {
+    isOpen: boolean;
+    onClose: () => void;
+    isNavbarVisible: boolean;
+    isPresentationMode: boolean;
+    activeCommentId: string | null;
+    isPreviewMode: boolean;
+}
+export interface CommentCardProps extends IComment {
+    comment?: string;
+    onResolve?: (commentId: string) => void;
+    onDelete?: (commentId: string) => void;
+    onUnresolve?: (commentId: string) => void;
+    isResolved?: boolean;
+    isDropdown?: boolean;
+    activeCommentId?: string;
+    isDisabled?: boolean;
+    isCommentOwner?: boolean;
+    version?: string;
+    emptyComment?: boolean;
+}
+export type CommentBubbleMenuProps = Omit<BubbleMenuProps, 'children'> & {
+    zoomLevel: string;
+};
+export interface CommentReplyProps {
+    reply: string;
+    username: string;
+    createdAt: Date;
+    isLast: boolean;
+}
+export interface EnsStatus {
+    name: string;
+    isEns: boolean;
+    isLoading: boolean;
+}
+export interface CommentSectionProps {
+    activeCommentId: string | null;
+    isNavbarVisible?: boolean;
+    isPresentationMode?: boolean;
+}
+export interface UserDisplayProps {
+    ensStatus: EnsStatus;
+    createdAt: Date | undefined;
+}

package/dist/package/components/link-preview-card.d.ts

@@ -0,0 +1,12 @@
+export interface LinkPreviewData {
+    image: string;
+    title: string;
+    description: string;
+    favicon: string;
+    link: string;
+}
+export declare const LinkPreviewCard: ({ link, metadataProxyUrl, hoverEvent, }: {
+    link: string;
+    metadataProxyUrl: string;
+    hoverEvent: EventTarget;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/package/components/presentation-mode/preview-panel.d.ts

@@ -0,0 +1,7 @@
+interface PreviewPanelProps {
+    slides: string[];
+    currentSlide: number;
+    setCurrentSlide: (index: number) => void;
+}
+export declare const PreviewPanel: ({ slides, currentSlide, setCurrentSlide, }: PreviewPanelProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/package/components/secure-image.d.ts

@@ -0,0 +1,13 @@
+type Props = {
+    encryptedKey: string;
+    url: string;
+    iv: string;
+    privateKey: string;
+    alt?: string;
+    width?: string;
+    height?: string;
+    className?: string;
+    caption?: string;
+};
+export declare const SecureImage: import('react').ForwardRefExoticComponent<Props & import('react').RefAttributes<HTMLImageElement>>;
+export {};

package/dist/package/components/tag-input.d.ts

@@ -0,0 +1,12 @@
+export interface TagProps {
+    name: string;
+    color: string;
+}
+export interface TagInputProps {
+    tags: TagProps[];
+    selectedTags: TagProps[];
+    onAddTag: (tag: TagProps) => void;
+    isPreviewMode: boolean;
+}
+declare const TagInput: ({ tags, selectedTags, onAddTag, isPreviewMode, }: TagInputProps) => import("react/jsx-runtime").JSX.Element | null;
+export { TagInput };

package/dist/package/components/toc/toc.d.ts

@@ -0,0 +1,5 @@
+import { ToCProps, ToCItemProps } from './types';
+
+export declare const ToCItem: ({ item, onItemClick, index, }: ToCItemProps) => import("react/jsx-runtime").JSX.Element;
+export declare const ToCEmptyState: () => import("react/jsx-runtime").JSX.Element;
+export declare const ToC: ({ items, editor, setItems }: ToCProps) => import("react/jsx-runtime").JSX.Element;

package/dist/package/components/toc/types.d.ts

@@ -0,0 +1,30 @@
+import { Editor } from '@tiptap/react';
+import { SetStateAction } from 'react';
+
+export interface ToCItemType {
+    id: string;
+    level: number;
+    textContent: string;
+    itemIndex: number;
+    isActive?: boolean;
+}
+export type ToCProps = {
+    items: ToCItemType[];
+    setItems: (items: ToCItemType[] | ((prev: ToCItemType[]) => ToCItemType[])) => void;
+    editor: Editor;
+};
+export type ToCItemProps = {
+    item: ToCItemType;
+    onItemClick: (e: React.MouseEvent, id: string) => void;
+    onItemRemove: (e: React.MouseEvent, id: string) => void;
+    index: number;
+};
+export interface DocumentOutlineProps {
+    editor: Editor;
+    hasToC: boolean;
+    items: ToCItemType[];
+    setItems: (items: ToCItemType[] | ((prev: ToCItemType[]) => ToCItemType[])) => void;
+    showTOC: boolean | undefined;
+    setShowTOC: React.Dispatch<SetStateAction<boolean>> | undefined;
+    isPreviewMode: boolean;
+}

package/dist/package/components/utils-modal.d.ts

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+
+interface UtilsModalProps {
+    title: string;
+    content: React.ReactNode;
+    isOpen?: boolean;
+    setIsOpen?: (open: boolean) => void;
+    contentClassName?: string;
+    onCloseAutoFocus?: () => void;
+}
+declare const UtilsModal: ({ title, content, isOpen, setIsOpen, contentClassName, onCloseAutoFocus, }: UtilsModalProps) => import("react/jsx-runtime").JSX.Element;
+export default UtilsModal;

package/dist/package/extensions/action-button/action-button-node-view.d.ts

@@ -0,0 +1,3 @@
+import { NodeViewProps } from '@tiptap/core';
+
+export declare const ActionButtonNodeView: ({ node, editor, getPos, deleteNode, }: NodeViewProps) => import("react/jsx-runtime").JSX.Element;

package/dist/package/extensions/action-button/action-button.d.ts

@@ -0,0 +1,16 @@
+import { Node } from '@tiptap/core';
+
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        actionButton: {
+            /**
+             * Toggle a actionButton
+             */
+            setActionButton: (option?: string) => ReturnType;
+        };
+    }
+}
+export interface ActionButtonOptions {
+    HTMLAttributes: Record<string, any>;
+}
+export declare const actionButton: Node<ActionButtonOptions, any>;

package/dist/package/extensions/action-button/modal.d.ts

@@ -0,0 +1,8 @@
+import { Editor } from '@tiptap/core';
+import { Dispatch, SetStateAction } from 'react';
+
+export declare const Modal: ({ editor, setShowModal, node, }: {
+    editor?: Editor;
+    setShowModal: Dispatch<SetStateAction<boolean>>;
+    node: any;
+}) => import("react/jsx-runtime").JSX.Element;