@fileverse-dev/ddoc 3.0.55 → 3.0.56-patch-2

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

@@ -1,8 +1,10 @@
 import { default as React } from 'react';
 import { Editor } from '@tiptap/react';
 import { IpfsImageFetchPayload, IpfsImageUploadResponse } from '../types';
+import { Tab } from './tabs/utils/tab-utils';
 
-declare const TiptapToolBar: ({ editor, onError, zoomLevel, setZoomLevel, isNavbarVisible, setIsNavbarVisible, ipfsImageUploadFn, onMarkdownExport, onMarkdownImport, onPdfExport, onHtmlExport, onTxtExport, onDocxImport, isLoading, ipfsImageFetchFn, fetchV1ImageFn, isConnected, }: {
+import * as Y from 'yjs';
+declare const TiptapToolBar: ({ editor, onError, zoomLevel, setZoomLevel, isNavbarVisible, setIsNavbarVisible, ipfsImageUploadFn, onMarkdownExport, onMarkdownImport, onPdfExport, onHtmlExport, onTxtExport, onDocxImport, isLoading, ipfsImageFetchFn, fetchV1ImageFn, isConnected, tabs, ydoc, onRegisterExportTrigger, }: {
     editor: Editor | null;
     onError?: (errorString: string) => void;
     zoomLevel: string;
@@ -23,5 +25,8 @@ declare const TiptapToolBar: ({ editor, onError, zoomLevel, setZoomLevel, isNavb
         file: File;
     }>;
     isConnected?: boolean;
+    tabs: Tab[];
+    ydoc: Y.Doc;
+    onRegisterExportTrigger?: ((trigger: ((format?: string, name?: string) => void) | null) => void) | undefined;
 }) => import("react/jsx-runtime").JSX.Element;
 export default TiptapToolBar;

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

@@ -6,7 +6,7 @@ import { IpfsImageFetchPayload, IpfsImageUploadResponse } from '../types';
 export interface IEditorToolElement {
     icon: any;
     title: string;
-    onClick: () => void;
+    onClick: (name?: string) => void;
     isActive: boolean;
     group?: string;
     isNew?: boolean;
@@ -55,7 +55,7 @@ export declare const IMG_UPLOAD_SETTINGS: {
         errorMsg: string;
     };
 };
-export declare const useEditorToolbar: ({ editor, onError, ipfsImageUploadFn, onMarkdownExport, onMarkdownImport, onPdfExport, onHtmlExport, onTxtExport, ipfsImageFetchFn, onDocxImport, fetchV1ImageFn, isConnected, }: {
+export declare const useEditorToolbar: ({ editor, onError, ipfsImageUploadFn, onMarkdownExport, onMarkdownImport, onPdfExport, onHtmlExport, onTxtExport, ipfsImageFetchFn, onDocxImport, fetchV1ImageFn, }: {
     editor: Editor | null;
     onError?: (errorString: string) => void;
     ipfsImageUploadFn?: (file: File) => Promise<IpfsImageUploadResponse>;

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

@@ -0,0 +1,22 @@
+interface ExportFormatOption {
+    id: string;
+    label: string;
+}
+interface ExportTabOption {
+    id: string;
+    label: string;
+}
+interface ExportAsModalProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onExport?: (data: {
+        format: string;
+        tab: string;
+    }) => void;
+    formatOptions: ExportFormatOption[];
+    tabOptions: ExportTabOption[];
+    initialFormat?: string;
+    initialTab?: string;
+}
+export declare const ExportAsModal: ({ open, onOpenChange, onExport, formatOptions, tabOptions, initialFormat, initialTab, }: ExportAsModalProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/package/components/import-export-button.d.ts

@@ -1,10 +1,17 @@
 import { IEditorToolElement } from './editor-utils';
+import { Editor } from '@tiptap/react';
+import { Tab } from './tabs/utils/tab-utils';
 
-declare const ImportExportButton: ({ fileExportsOpen, setFileExportsOpen, exportOptions, importOptions, setDropdownOpen, }: {
+import * as Y from 'yjs';
+declare const ImportExportButton: ({ fileExportsOpen, setFileExportsOpen, exportOptions, importOptions, setDropdownOpen, editor, tabs, ydoc, onRegisterExportTrigger, }: {
     fileExportsOpen: boolean;
     setFileExportsOpen: React.Dispatch<React.SetStateAction<boolean>>;
     exportOptions: (IEditorToolElement | null)[];
     importOptions: (IEditorToolElement | null)[];
     setDropdownOpen: React.Dispatch<React.SetStateAction<boolean>>;
+    editor: Editor | null;
+    tabs: Tab[];
+    ydoc: Y.Doc;
+    onRegisterExportTrigger?: ((trigger: ((format?: string, name?: string) => void) | null) => void) | undefined;
 }) => import("react/jsx-runtime").JSX.Element;
 export { ImportExportButton };

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

@@ -1,4 +1,4 @@
 import { CommentContextType, CommentProviderProps } from './types';
 
-export declare const CommentProvider: ({ children, editor, initialComments, setInitialComments, username, setUsername, activeCommentId, setActiveCommentId, focusCommentWithActiveId, onNewComment, onCommentReply, ensResolutionUrl, onResolveComment, onUnresolveComment, onDeleteComment, isConnected, connectViaWallet, isLoading, connectViaUsername, isDDocOwner, onInlineComment, onComment, setCommentDrawerOpen, }: CommentProviderProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CommentProvider: ({ children, editor, ydoc, initialComments, setInitialComments, username, setUsername, activeCommentId, setActiveCommentId, activeTabId, focusCommentWithActiveId, onNewComment, onCommentReply, ensResolutionUrl, onResolveComment, onUnresolveComment, onDeleteComment, isConnected, connectViaWallet, isLoading, connectViaUsername, isDDocOwner, onInlineComment, onComment, setCommentDrawerOpen, }: CommentProviderProps) => import("react/jsx-runtime").JSX.Element;
 export declare const useComments: () => CommentContextType;

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

@@ -1,9 +1,10 @@
 import { Editor } from '@tiptap/react';
 import { IComment } from '../../../extensions/comment';
 import { SetStateAction } from 'react';
-import { CommentAccountProps } from '../../../types';
+import { CommentAccountProps, CommentMutationMeta } from '../../../types';
 import { EnsStatus } from '../types';
 
+import * as Y from 'yjs';
 export interface CommentContextType extends CommentAccountProps {
     comments: IComment[];
     setComments: React.Dispatch<SetStateAction<IComment[]>>;
@@ -50,6 +51,7 @@ export interface CommentContextType extends CommentAccountProps {
     isCommentActive: boolean;
     isCommentResolved: boolean;
     ensResolutionUrl: string;
+    activeTabId: string;
     onCommentReply?: (activeCommentId: string, reply: IComment) => void;
     onComment?: () => void;
     setCommentDrawerOpen?: React.Dispatch<React.SetStateAction<boolean>>;
@@ -67,17 +69,19 @@ export interface CommentContextType extends CommentAccountProps {
 export interface CommentProviderProps extends CommentAccountProps {
     children: React.ReactNode;
     editor: Editor;
+    ydoc: Y.Doc;
     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;
+    onNewComment?: (newComment: IComment, meta?: CommentMutationMeta) => void;
+    onResolveComment?: (activeCommentId: string, meta?: CommentMutationMeta) => void;
+    onUnresolveComment?: (activeCommentId: string, meta?: CommentMutationMeta) => void;
+    onDeleteComment?: (activeCommentId: string, meta?: CommentMutationMeta) => void;
     username: string | null;
     setUsername?: React.Dispatch<SetStateAction<string>>;
     activeCommentId: string | null;
     setActiveCommentId: React.Dispatch<React.SetStateAction<string | null>>;
+    activeTabId: string;
     focusCommentWithActiveId: (id: string) => void;
     ensResolutionUrl: string;
     onInlineComment?: () => void;

package/dist/package/components/preview-export-trigger.d.ts

@@ -0,0 +1,24 @@
+import { Editor } from '@tiptap/react';
+import { Tab } from './tabs/utils/tab-utils';
+import { DdocProps } from '../types';
+
+import * as Y from 'yjs';
+interface PreviewModeExportTriggerProps {
+    editor: Editor | null;
+    ydoc: Y.Doc;
+    tabs: Tab[];
+    onRegisterExportTrigger?: (trigger: ((format?: string, name?: string) => void) | null) => void;
+    onError?: (errorString: string) => void;
+    ipfsImageUploadFn?: DdocProps['ipfsImageUploadFn'];
+    onMarkdownExport?: DdocProps['onMarkdownExport'];
+    onMarkdownImport?: DdocProps['onMarkdownImport'];
+    onPdfExport?: DdocProps['onPdfExport'];
+    onHtmlExport?: DdocProps['onHtmlExport'];
+    onTxtExport?: DdocProps['onTxtExport'];
+    ipfsImageFetchFn?: DdocProps['ipfsImageFetchFn'];
+    onDocxImport?: DdocProps['onDocxImport'];
+    fetchV1ImageFn?: DdocProps['fetchV1ImageFn'];
+    isConnected?: DdocProps['isConnected'];
+}
+declare const PreviewModeExportTrigger: ({ editor, ydoc, tabs, onRegisterExportTrigger, onError, ipfsImageUploadFn, onMarkdownExport, onMarkdownImport, onPdfExport, onHtmlExport, onTxtExport, ipfsImageFetchFn, onDocxImport, fetchV1ImageFn, isConnected, }: PreviewModeExportTriggerProps) => import("react/jsx-runtime").JSX.Element;
+export { PreviewModeExportTrigger };

package/dist/package/components/tabs/confirm-delete-modal.d.ts

@@ -0,0 +1,19 @@
+import { ReactNode } from 'react';
+
+interface IConfirmDeleteModalProps {
+    onClose: () => void;
+    onConfirm: () => void;
+    isOpen: boolean;
+    documentTitle: string;
+    isLoading: boolean;
+    text?: string | ReactNode;
+    title?: string;
+    overlayClasses?: string;
+    noOverlay?: boolean;
+    primaryLabel?: string;
+    secondaryLabel?: string;
+    hasCloseIcon?: boolean;
+    hideTitleIcon?: boolean;
+}
+export declare const ConfirmDeleteModal: ({ onClose, onConfirm, isOpen, isLoading, title, overlayClasses, noOverlay, hasCloseIcon, primaryLabel, hideTitleIcon, }: IConfirmDeleteModalProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/package/components/tabs/document-mobile-tab-panel.d.ts

@@ -0,0 +1,27 @@
+import { Dispatch, SetStateAction } from 'react';
+import { DocumentOutlineProps } from '../toc/types';
+import { Tab } from './utils/tab-utils';
+
+export interface DocumentMobileTabPanelProps {
+    tabs: Tab[];
+    setTabs: Dispatch<SetStateAction<Tab[]>>;
+    activeTabId: string;
+    setActiveTabId: (id: string) => void;
+    editor: DocumentOutlineProps['editor'];
+    items: DocumentOutlineProps['items'];
+    setItems: DocumentOutlineProps['setItems'];
+    orientation?: DocumentOutlineProps['orientation'];
+    renameTab: (tabId: string, payload: {
+        newName?: string;
+        emoji?: string;
+    }) => void;
+    createTab: () => void;
+    duplicateTab: (tabId: string) => void;
+    deleteTab?: (tabId: string) => void;
+    tabCommentCounts: Record<string, number>;
+    isPreviewMode: boolean;
+    tabConfig?: DocumentOutlineProps['tabConfig'];
+    isVersionHistoryMode: boolean;
+    isConnected?: boolean;
+}
+export declare const DocumentMobileTabPanel: ({ tabs, activeTabId, setActiveTabId, editor, items, setItems, orientation, renameTab, createTab, duplicateTab, deleteTab, tabCommentCounts, isPreviewMode, tabConfig, isVersionHistoryMode, isConnected, }: DocumentMobileTabPanelProps) => import("react/jsx-runtime").JSX.Element;

package/dist/package/components/tabs/document-tabs-sidebar.d.ts

@@ -0,0 +1,60 @@
+import { default as React } from 'react';
+import { DocumentOutlineProps } from '../toc/types';
+import { Tab } from './utils/tab-utils';
+import { Editor } from '@tiptap/core';
+
+import * as Y from 'yjs';
+export interface DocumentTabsSidebarProps {
+    tabs: Tab[];
+    setTabs: React.Dispatch<React.SetStateAction<Tab[]>>;
+    activeTabId: string;
+    setActiveTabId: (id: string) => void;
+    showTOC: DocumentOutlineProps['showTOC'];
+    setShowTOC: DocumentOutlineProps['setShowTOC'];
+    hasToC: DocumentOutlineProps['hasToC'];
+    isPreviewMode: DocumentOutlineProps['isPreviewMode'];
+    editor: DocumentOutlineProps['editor'];
+    items: DocumentOutlineProps['items'];
+    setItems: DocumentOutlineProps['setItems'];
+    orientation?: DocumentOutlineProps['orientation'];
+    createTab: () => void;
+    renameTab: (tabId: string, payload: {
+        newName?: string;
+        emoji?: string;
+    }) => void;
+    duplicateTab: (tabId: string) => void;
+    orderTab: (destinationTabId: string, activeTabId: string) => void;
+    ydoc: Y.Doc;
+    tabCommentCounts: Record<string, number>;
+    tabSectionContainer?: HTMLElement;
+    isVersionHistoryMode?: boolean;
+    tabConfig?: DocumentOutlineProps['tabConfig'];
+    deleteTab?: (tabId: string) => void;
+    isConnected?: boolean;
+}
+export declare const DocumentTabsSidebar: ({ tabSectionContainer, ...rest }: DocumentTabsSidebarProps) => import("react/jsx-runtime").JSX.Element | null;
+export declare const TabSidebar: ({ tabs, activeTabId, setActiveTabId, showTOC, setShowTOC, hasToC, isPreviewMode, editor, items, setItems, orientation, createTab, renameTab, duplicateTab, orderTab, tabCommentCounts, isVersionHistoryMode, tabConfig, deleteTab, isConnected, }: DocumentTabsSidebarProps) => import("react/jsx-runtime").JSX.Element;
+export declare const DdocTab: ({ tab, tabIndex, tabCount, handleEmojiChange, handleNameChange, onClick, editor, tocItem, setTocItems, orientation, activeTabId, duplicateTab, commentCount, moveTabUp, moveTabDown, isPreviewMode, isVersionHistoryMode, tabConfig, onDelete, showOutline, onShowOutlineChange, isConnected, }: {
+    tab: Tab;
+    tabIndex: number;
+    tabCount: number;
+    handleNameChange: (tabId: string, nextName: string, nextEmoji?: string) => void;
+    handleEmojiChange: (tabId: string, nextEmoji: string) => void;
+    onClick: () => void;
+    editor: Editor;
+    tocItem: DocumentOutlineProps["items"];
+    setTocItems: DocumentOutlineProps["setItems"];
+    orientation: DocumentOutlineProps["orientation"];
+    activeTabId: string;
+    duplicateTab: (tabId: string) => void;
+    commentCount: number;
+    moveTabUp: () => void;
+    moveTabDown: () => void;
+    isPreviewMode: boolean;
+    isVersionHistoryMode?: boolean;
+    tabConfig?: DocumentOutlineProps["tabConfig"];
+    onDelete?: (tab: Tab) => void;
+    showOutline: boolean;
+    onShowOutlineChange: (value: boolean) => void;
+    isConnected?: boolean;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/package/components/tabs/tab-emoji-picker.d.ts

@@ -0,0 +1,16 @@
+import { EmojiPickerListCategoryHeaderProps, EmojiPickerListEmojiProps, EmojiPickerListRowProps, EmojiPicker as EmojiPickerPrimitive } from 'frimousse';
+
+export declare const TabEmojiPicker: ({ emoji, setEmoji, isEditing, openPickerTrigger, disableEmoji, }: {
+    emoji: string;
+    setEmoji: (emoji: string) => void;
+    isEditing: boolean;
+    openPickerTrigger?: number;
+    disableEmoji: boolean;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare function EmojiPicker({ className, ...props }: React.ComponentProps<typeof EmojiPickerPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+export declare function EmojiPickerSearch({ className, ...props }: React.ComponentProps<typeof EmojiPickerPrimitive.Search>): import("react/jsx-runtime").JSX.Element;
+export declare function EmojiPickerRow({ children, ...props }: EmojiPickerListRowProps): import("react/jsx-runtime").JSX.Element;
+export declare function EmojiPickerEmoji({ emoji, className, ...props }: EmojiPickerListEmojiProps): import("react/jsx-runtime").JSX.Element;
+export declare function EmojiPickerCategoryHeader({ category, ...props }: EmojiPickerListCategoryHeaderProps): import("react/jsx-runtime").JSX.Element;
+export declare function EmojiPickerContent({ className, ...props }: React.ComponentProps<typeof EmojiPickerPrimitive.Viewport>): import("react/jsx-runtime").JSX.Element;
+export declare function EmojiPickerFooter({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;

package/dist/package/components/tabs/tab-item.d.ts

@@ -0,0 +1,58 @@
+import { ComponentProps, HTMLAttributes } from 'react';
+import { LucideIcon } from '@fileverse/ui';
+
+export interface TabItemProps {
+    tabId: string;
+    name: string;
+    emoji: string;
+    commentCount?: number;
+    onNameChange: (name: string, emoji?: string) => void;
+    onEmojiChange: (emoji: string) => void;
+    onClick: () => void;
+    isActive: boolean;
+    onDuplicate?: (id: string) => void;
+    dragHandleProps?: HTMLAttributes<HTMLDivElement>;
+    hideContentMenu?: boolean;
+    showOutline?: boolean;
+    handleShowOutline?: (value: boolean) => void;
+    canMoveUp?: boolean;
+    canMoveDown?: boolean;
+    onMoveUp?: () => void;
+    onMoveDown?: () => void;
+    isPreviewMode: boolean;
+    isVersionHistoryMode?: boolean;
+    onCopyLink?: () => void;
+    onDelete?: () => void;
+    isConnected?: boolean;
+}
+interface SortableTabItemProps extends Omit<TabItemProps, 'dragHandleProps'> {
+    id: string;
+}
+interface TabContextMenuItem {
+    id: string;
+    label: string;
+    icon: ComponentProps<typeof LucideIcon>['name'];
+    onSelect?: () => void;
+    visible?: boolean;
+    closeOnSelect?: boolean;
+    textClassName?: string;
+    iconStroke?: string;
+    tooltipText?: string;
+    disabled?: boolean;
+}
+interface TabContextMenuProps {
+    sections: TabContextMenuItem[][];
+    popoverSide?: 'top' | 'bottom';
+    popoverClassName?: string;
+}
+export declare const SortableTabItem: (props: SortableTabItemProps) => import("react/jsx-runtime").JSX.Element;
+export declare const TabItem: ({ tabId, name, emoji, commentCount, onNameChange, onEmojiChange, onClick, isActive, onDuplicate, dragHandleProps, hideContentMenu, showOutline, handleShowOutline, canMoveUp, canMoveDown, onMoveUp, onMoveDown, isPreviewMode, isVersionHistoryMode, onCopyLink, onDelete, isConnected, }: TabItemProps) => import("react/jsx-runtime").JSX.Element;
+export declare const TabDragPreview: ({ name, emoji, }: {
+    name: string;
+    emoji: string;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const TabContextMenuAction: ({ item, }: {
+    item: TabContextMenuItem;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const TabContextMenu: ({ sections, popoverSide, popoverClassName, }: TabContextMenuProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/package/components/tabs/utils/tab-utils.d.ts

@@ -0,0 +1,21 @@
+import * as Y from 'yjs';
+export interface Tab {
+    id: string;
+    name: string;
+    emoji: string | null;
+}
+export declare const DEFAULT_TAB_ID = "default";
+export declare const DEFAULT_TAB_NAME = "Tab 1";
+export declare function deriveTabsFromEncodedState(yjsEncodedState: string, doc: Y.Doc, options?: {
+    createDefaultTabIfMissing?: boolean;
+}): {
+    tabList: Tab[];
+    activeTabId: string;
+};
+export declare function getTabsYdocNodes(doc: Y.Doc): {
+    root: Y.Map<unknown>;
+    order: Y.Array<string>;
+    tabs: Y.Map<Y.Map<string | null>>;
+    activeTab: Y.Text;
+};
+export declare function cloneFragmentContent(fragment: Y.XmlFragment): (Y.XmlElement | Y.XmlText)[];

package/dist/package/components/toc/document-outline-toc-panel.d.ts

@@ -0,0 +1,5 @@
+import { DocumentOutlineProps } from './types';
+
+type DocumentOutlineTOCPanelProps = Pick<DocumentOutlineProps, 'editor' | 'hasToC' | 'items' | 'setItems' | 'showTOC' | 'setShowTOC' | 'isPreviewMode' | 'orientation'>;
+export declare const DocumentOutlineTOCPanel: ({ editor, hasToC, items, setItems, showTOC, setShowTOC, isPreviewMode, orientation, }: DocumentOutlineTOCPanelProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/package/components/toc/document-outline.d.ts

@@ -1,3 +1,3 @@
 import { DocumentOutlineProps } from './types';
 
-export declare const DocumentOutline: ({ editor, hasToC, items, setItems, showTOC, setShowTOC, isPreviewMode, orientation, }: DocumentOutlineProps) => import("react/jsx-runtime").JSX.Element;
+export declare const DocumentOutline: ({ editor, hasToC, items, setItems, showTOC, setShowTOC, isPreviewMode, orientation, tabs, setTabs, activeTabId, setActiveTabId, createTab, renameTab, duplicateTab, orderTab, ydoc, tabCommentCounts, tabSectionContainer, isVersionHistoryMode, tabConfig, deleteTab, isConnected, }: DocumentOutlineProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+
+export declare const MemorizedToC: React.MemoExoticComponent<React.MemoExoticComponent<({ items, editor, setItems, orientation }: import('./types').ToCProps) => import("react/jsx-runtime").JSX.Element>>;

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

@@ -1,6 +1,8 @@
 import { Editor } from '@tiptap/react';
-import { SetStateAction } from 'react';
+import { default as React, Dispatch, SetStateAction } from 'react';
+import { Tab } from '../tabs/utils/tab-utils';
 
+import * as Y from 'yjs';
 export interface ToCItemType {
     id: string;
     level: number;
@@ -27,7 +29,28 @@ export interface DocumentOutlineProps {
     items: ToCItemType[];
     setItems: (items: ToCItemType[] | ((prev: ToCItemType[]) => ToCItemType[])) => void;
     showTOC: boolean | undefined;
-    setShowTOC: React.Dispatch<SetStateAction<boolean>> | undefined;
+    setShowTOC: Dispatch<SetStateAction<boolean>> | undefined;
     isPreviewMode: boolean;
     orientation?: 'portrait' | 'landscape';
+    tabs: Tab[];
+    setTabs: Dispatch<SetStateAction<Tab[]>>;
+    activeTabId: string;
+    setActiveTabId: (id: string) => void;
+    createTab: () => void;
+    renameTab: (tabId: string, payload: {
+        newName?: string;
+        emoji?: string;
+    }) => void;
+    duplicateTab: (tabId: string) => void;
+    orderTab: (destinationTabId: string, activeTabId: string) => void;
+    ydoc: Y.Doc;
+    tabCommentCounts: Record<string, number>;
+    tabSectionContainer?: HTMLElement;
+    isVersionHistoryMode?: boolean;
+    tabConfig?: {
+        onCopyTabLink?: (tabId: string) => void;
+        defaultTabId?: string;
+    };
+    deleteTab?: (tabId: string) => void;
+    isConnected?: boolean;
 }

package/dist/package/extensions/comment/comment.d.ts

@@ -47,6 +47,7 @@ export interface CommentStorage {
 }
 export interface IComment {
     id?: string;
+    tabId?: string;
     username?: string;
     reactions?: {
         count: number;

package/dist/package/hooks/use-ddoc-export.d.ts

@@ -0,0 +1,24 @@
+import { Editor } from '@tiptap/react';
+import { IEditorToolElement } from '../components/editor-utils';
+import { Tab } from '../components/tabs/utils/tab-utils';
+
+import * as Y from 'yjs';
+interface UseDdocExportArgs {
+    editor: Editor | null;
+    tabs: Tab[];
+    ydoc: Y.Doc;
+    exportOptions: (IEditorToolElement | null)[];
+}
+declare const useDdocExport: ({ editor, tabs, ydoc, exportOptions, }: UseDdocExportArgs) => {
+    getOptionFormat: (title: string) => "" | "md" | "pdf" | "html" | "txt";
+    formatSelectOptions: {
+        id: string;
+        label: string;
+    }[];
+    handleExport: ({ format, tab, name }: {
+        format: string;
+        tab: string;
+        name?: string;
+    }) => void;
+};
+export { useDdocExport };

package/dist/package/hooks/use-tab-editor.d.ts

@@ -0,0 +1,62 @@
+import { Dispatch, MutableRefObject, SetStateAction } from 'react';
+import { DdocProps } from '../types';
+import { AnyExtension, Editor } from '@tiptap/react';
+import { ToCItemType } from '../components/toc/types';
+import { IConnectConf } from '../sync-local/useSyncMachine';
+
+import * as Y from 'yjs';
+interface UseTabEditorArgs {
+    ydoc: Y.Doc;
+    isVersionMode?: boolean;
+    hasTabState?: boolean;
+    versionId?: string;
+    isPreviewMode?: boolean;
+    initialContent: DdocProps['initialContent'];
+    enableCollaboration?: boolean;
+    collabConfig?: DdocProps['collabConfig'];
+    isReady?: boolean;
+    awareness?: any;
+    disableInlineComment?: boolean;
+    onCommentInteraction?: DdocProps['onCommentInteraction'];
+    onError?: DdocProps['onError'];
+    ipfsImageUploadFn?: DdocProps['ipfsImageUploadFn'];
+    metadataProxyUrl?: string;
+    onCopyHeadingLink?: DdocProps['onCopyHeadingLink'];
+    ipfsImageFetchFn?: DdocProps['ipfsImageFetchFn'];
+    fetchV1ImageFn?: DdocProps['fetchV1ImageFn'];
+    isConnected?: boolean;
+    activeModel?: DdocProps['activeModel'];
+    maxTokens?: number;
+    isAIAgentEnabled?: boolean;
+    setCharacterCount?: DdocProps['setCharacterCount'];
+    setWordCount?: DdocProps['setWordCount'];
+    setIsContentLoading: Dispatch<SetStateAction<boolean>>;
+    setIsCollabContentLoading: Dispatch<SetStateAction<boolean>>;
+    unFocused?: boolean;
+    zoomLevel?: string;
+    isPresentationMode?: boolean;
+    onInvalidContentError?: DdocProps['onInvalidContentError'];
+    ignoreCorruptedData?: boolean;
+    onCollaboratorChange?: DdocProps['onCollaboratorChange'];
+    onConnect: (connectConfig: IConnectConf) => void;
+    hasCollabContentInitialised?: boolean;
+    initialiseYjsIndexedDbProvider: () => Promise<void>;
+    externalExtensions?: Record<string, AnyExtension>;
+    isContentLoading?: boolean;
+    activeTabId: string;
+    theme?: 'dark' | 'light';
+    editorRef?: MutableRefObject<Editor | null>;
+}
+export declare const useTabEditor: ({ ydoc, isVersionMode, hasTabState, versionId, isPreviewMode, initialContent, enableCollaboration, collabConfig, isReady, awareness, disableInlineComment, onCommentInteraction, onError, ipfsImageUploadFn, metadataProxyUrl, onCopyHeadingLink, ipfsImageFetchFn, fetchV1ImageFn, isConnected, activeModel, maxTokens, isAIAgentEnabled, setCharacterCount, setWordCount, setIsContentLoading, setIsCollabContentLoading, unFocused, zoomLevel, isPresentationMode, onInvalidContentError, ignoreCorruptedData, onCollaboratorChange, onConnect, hasCollabContentInitialised, initialiseYjsIndexedDbProvider, externalExtensions, isContentLoading, activeTabId, theme, editorRef, }: UseTabEditorArgs) => {
+    editor: Editor | null;
+    ref: import('react').RefObject<HTMLDivElement>;
+    slides: string[];
+    setSlides: Dispatch<SetStateAction<string[]>>;
+    tocItems: ToCItemType[];
+    setTocItems: Dispatch<SetStateAction<ToCItemType[]>>;
+    activeCommentId: string | null;
+    setActiveCommentId: Dispatch<SetStateAction<string | null>>;
+    focusCommentWithActiveId: (id: string) => void;
+    isContentLoading: boolean | undefined;
+};
+export {};

package/dist/package/hooks/use-tab-manager.d.ts

@@ -0,0 +1,32 @@
+import { Editor } from '@tiptap/react';
+import { DdocProps } from '../types';
+import { Tab } from '../components/tabs/utils/tab-utils';
+import * as Y from 'yjs';
+interface UseTabManagerArgs {
+    ydoc: Y.Doc;
+    initialContent: DdocProps['initialContent'];
+    enableCollaboration: DdocProps['enableCollaboration'];
+    isDDocOwner: boolean;
+    createDefaultTabIfMissing: boolean;
+    shouldSyncActiveTab: boolean;
+    defaultTabId?: string;
+    onVersionHistoryActiveTabChange?: (tabId: string | null) => void;
+    getEditor?: () => Editor | null;
+}
+export declare const getNewTabId: () => string;
+export declare const useTabManager: ({ ydoc, initialContent, enableCollaboration, isDDocOwner, createDefaultTabIfMissing, shouldSyncActiveTab, defaultTabId, onVersionHistoryActiveTabChange, getEditor, }: UseTabManagerArgs) => {
+    tabs: Tab[];
+    hasTabState: boolean;
+    activeTabId: string;
+    setTabs: import('react').Dispatch<import('react').SetStateAction<Tab[]>>;
+    setActiveTabId: (id: string) => void;
+    createTab: () => string;
+    deleteTab: (tabId: string) => void;
+    renameTab: (tabId: string, { newName, emoji }: {
+        newName?: string;
+        emoji?: string;
+    }) => void;
+    duplicateTab: (tabId: string) => string | undefined;
+    orderTab: (destinationTabId: string, movedTabId: string) => void;
+};
+export {};

package/dist/package/hooks/use-tab-metadata-history.d.ts

@@ -0,0 +1,14 @@
+import * as Y from 'yjs';
+interface ApplyRenameArgs {
+    tabId: string;
+    newName?: string;
+    emoji?: string;
+}
+export declare const useTabMetadataHistory: (ydoc: Y.Doc) => {
+    applyRename: ({ tabId, newName, emoji }: ApplyRenameArgs) => {
+        tabNotFound: boolean;
+    };
+    undo: () => boolean;
+    redo: () => boolean;
+};
+export {};

package/dist/package/hooks/use-yjs-setup.d.ts

@@ -0,0 +1,27 @@
+import { JSONContent } from '@tiptap/react';
+import { DdocProps } from '../types';
+import * as Y from 'yjs';
+interface UseYjsSetupArgs {
+    onChange?: (updatedDocContent: string | JSONContent, updateChunk: string) => void;
+    enableIndexeddbSync?: boolean;
+    ddocId?: string;
+    enableCollaboration?: boolean;
+    onIndexedDbError?: (error: Error) => void;
+    onCollabError?: DdocProps['onCollabError'];
+    onCollaborationConnectCallback?: DdocProps['onCollaborationConnectCallback'];
+    onCollaborationCommit?: DdocProps['onCollaborationCommit'];
+    onFetchCommitContent?: DdocProps['onFetchCommitContent'];
+    onCollabSessionTermination?: () => void;
+    onUnMergedUpdates?: (state: boolean) => void;
+}
+export declare const useYjsSetup: ({ onChange, enableIndexeddbSync, ddocId, enableCollaboration, onIndexedDbError, onCollabError, onCollaborationConnectCallback, onCollaborationCommit, onFetchCommitContent, onCollabSessionTermination, onUnMergedUpdates, }: UseYjsSetupArgs) => {
+    ydoc: Y.Doc;
+    onConnect: (connectConfig: import('../sync-local/useSyncMachine').IConnectConf) => void;
+    isReady: boolean;
+    terminateSession: () => void;
+    awareness: any;
+    hasCollabContentInitialised: boolean;
+    initialiseYjsIndexedDbProvider: () => Promise<void>;
+    refreshYjsIndexedDbProvider: () => Promise<void>;
+};
+export {};

package/dist/package/sync-local/useSyncMachine.d.ts

@@ -1,6 +1,6 @@
 import { SyncMachineContext } from '.';
 
-interface IConnectConf {
+export interface IConnectConf {
     username?: string;
     roomKey: string;
     roomId: string;
@@ -36,4 +36,3 @@ export declare const useSyncMachine: (config: Partial<SyncMachineContext>) => {
         data: any;
     }, import('xstate').BaseActionObject, import('xstate').ServiceMap>>;
 };
-export {};