@fileverse-dev/ddoc 3.0.96-zustand-21 → 3.0.96-zustand-24

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

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

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

@@ -1,3 +1,3 @@
 import { CommentDrawerProps } from './types';
 
-export declare const CommentDrawer: ({ isOpen, onClose, isNavbarVisible, isPresentationMode, activeCommentId, isPreviewMode, }: CommentDrawerProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CommentDrawer: ({ isOpen, onClose, isNavbarVisible, isPresentationMode, activeCommentId, activeTabId, isPreviewMode, tabs, }: CommentDrawerProps) => import("react/jsx-runtime").JSX.Element;

package/dist/package/components/inline-comment/comment-floating-layout.d.ts

@@ -1,19 +1,19 @@
 export declare const FLOATING_COMMENT_CARD_GAP = 12;
-export declare const enum FloatingLayoutDirtyFlag {
+export declare const enum FloatingLayoutInvalidationFlag {
     None = 0,
     Anchor = 1,
     Viewport = 2,
     Height = 4,
     Visibility = 8
 }
-export interface FloatingLayoutItemInput {
-    itemId: string;
+export interface FloatingCardLayoutInput {
+    floatingCardId: string;
     anchorTop: number | null;
     height: number;
     isVisible: boolean;
     isMeasured: boolean;
-    previousTranslateY: number | null;
-    dirtyFlags: FloatingLayoutDirtyFlag;
+    lastCommittedTranslateY: number | null;
+    invalidationFlags: FloatingLayoutInvalidationFlag;
 }
 export interface FloatingLayoutResult {
     placements: Map<string, {
@@ -22,8 +22,10 @@ export interface FloatingLayoutResult {
     }>;
     stopIndex: number;
 }
-export declare const computeFloatingCommentLayout: ({ items, dirtyStartIndex, gap, }: {
-    items: FloatingLayoutItemInput[];
-    dirtyStartIndex: number;
+export declare const roundFloatingTranslateY: (translateY: number | null) => number | null;
+export declare const computeFloatingCommentLayout: ({ floatingCards, recomputeStartIndex, lastInvalidatedIndex, gap, }: {
+    floatingCards: FloatingCardLayoutInput[];
+    recomputeStartIndex: number;
+    lastInvalidatedIndex: number;
     gap?: number;
 }) => FloatingLayoutResult;

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

@@ -1,3 +1,3 @@
 import { CommentSectionProps } from './types';
 
-export declare const CommentSection: ({ activeCommentId, isNavbarVisible, isPresentationMode, }: CommentSectionProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CommentSection: ({ activeCommentId, isNavbarVisible, isPresentationMode, isMobile, comments: commentsProp, commentType, tabNameById, selectedTabLabel, showComposeInput, onCommentFocus, onReset, }: CommentSectionProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -4,23 +4,22 @@ import { CommentStoreState } from '../../../stores/comment-store';
 import { CommentStoreProviderProps } from '../../../stores/comment-store-provider';
 import { CommentAccountProps } from '../../../types';
 
-export interface CommentFloatingBaseItem {
-    itemId: string;
+export interface CommentFloatingBaseCard {
+    floatingCardId: string;
     selectedText: string;
-    isOpen: boolean;
     isFocused: boolean;
 }
-export interface CommentFloatingDraftItem extends CommentFloatingBaseItem {
+export interface CommentFloatingDraftCard extends CommentFloatingBaseCard {
     type: 'draft';
     draftId: string;
     draftText: string;
     isAuthPending: boolean;
 }
-export interface CommentFloatingThreadItem extends CommentFloatingBaseItem {
+export interface CommentFloatingThreadCard extends CommentFloatingBaseCard {
     type: 'thread';
     commentId: string;
 }
-export type CommentFloatingItem = CommentFloatingDraftItem | CommentFloatingThreadItem;
+export type CommentFloatingCard = CommentFloatingDraftCard | CommentFloatingThreadCard;
 export interface InlineCommentData {
     highlightedTextContent?: string;
     inlineCommentText: string;
@@ -32,7 +31,7 @@ export interface EnsEntry {
 }
 export type EnsCache = Record<string, EnsEntry>;
 export type CommentProviderProps = CommentStoreProviderProps;
-export type CommentContextType = Pick<CommentStoreState, 'activeComment' | 'activeCommentIndex' | 'activeComments' | 'activeTabId' | 'addComment' | 'blurFloatingItem' | 'cancelFloatingDraft' | 'closeFloatingItem' | 'comment' | 'connectViaUsername' | 'connectViaWallet' | 'createFloatingDraft' | 'deleteComment' | 'deleteReply' | 'ensCache' | 'floatingItems' | 'focusCommentInEditor' | 'focusFloatingItem' | 'getEnsStatus' | 'handleAddReply' | 'handleCommentChange' | 'handleCommentKeyDown' | 'handleCommentSubmit' | 'handleInlineComment' | 'handleInput' | 'handleReplyChange' | 'handleReplyKeyDown' | 'handleReplySubmit' | 'inlineCommentData' | 'isBubbleMenuSuppressed' | 'isCommentActive' | 'isCommentOpen' | 'isCommentResolved' | 'isConnected' | 'isDDocOwner' | 'isDesktopFloatingEnabled' | 'isLoading' | 'onComment' | 'onNextComment' | 'onPrevComment' | 'openFloatingThread' | 'openReplyId' | 'reply' | 'resolveComment' | 'setComment' | 'setCommentDrawerOpen' | 'setInlineCommentData' | 'setIsBubbleMenuSuppressed' | 'setOpenReplyId' | 'setReply' | 'setShowResolved' | 'setUsername' | 'selectedText' | 'showResolved' | 'submitFloatingDraft' | 'toggleResolved' | 'unresolveComment' | 'updateFloatingDraftText' | 'username'> & {
+export type CommentContextType = Pick<CommentStoreState, 'activeComment' | 'activeCommentIndex' | 'activeComments' | 'activeTabId' | 'addComment' | 'blurFloatingCard' | 'cancelFloatingDraft' | 'closeFloatingCard' | 'comment' | 'connectViaUsername' | 'connectViaWallet' | 'createFloatingDraft' | 'deleteComment' | 'deleteReply' | 'ensCache' | 'floatingCards' | 'focusCommentInEditor' | 'focusFloatingCard' | 'getEnsStatus' | 'handleAddReply' | 'handleCommentChange' | 'handleCommentKeyDown' | 'handleCommentSubmit' | 'handleInlineComment' | 'handleInput' | 'handleReplyChange' | 'handleReplyKeyDown' | 'handleReplySubmit' | 'inlineCommentData' | 'isBubbleMenuSuppressed' | 'isCommentActive' | 'isCommentOpen' | 'isCommentResolved' | 'isConnected' | 'isDDocOwner' | 'isDesktopFloatingEnabled' | 'isLoading' | 'onComment' | 'onNextComment' | 'onPrevComment' | 'openFloatingThread' | 'openReplyId' | 'reply' | 'resolveComment' | 'setComment' | 'setCommentDrawerOpen' | 'setInlineCommentData' | 'setIsBubbleMenuSuppressed' | 'setOpenReplyId' | 'setReply' | 'setShowResolved' | 'setUsername' | 'selectedText' | 'showResolved' | 'submitFloatingDraft' | 'toggleResolved' | 'unresolveComment' | 'updateFloatingDraftText' | 'username'> & {
     comments: IComment[];
     commentsSectionRef: RefObject<HTMLDivElement>;
     dropdownRef: RefObject<HTMLDivElement>;

package/dist/package/components/inline-comment/delete-confirm-overlay.d.ts

@@ -1,7 +1,10 @@
-export declare const DeleteConfirmOverlay: ({ isVisible, title, onCancel, onConfirm, className, }: {
+export declare const DeleteConfirmOverlay: ({ isVisible, title, onCancel, onConfirm, className, heading, description, confirmLabel, }: {
     isVisible: boolean;
     title: string;
     onCancel: () => void;
     onConfirm: () => void;
     className?: string;
+    heading?: string;
+    description?: string;
+    confirmLabel?: string;
 }) => import("react/jsx-runtime").JSX.Element | null;

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

@@ -1,2 +1,5 @@
-declare const EmptyComments: () => import("react/jsx-runtime").JSX.Element;
+declare const EmptyComments: ({ commentType, handleReset, }: {
+    commentType: string;
+    handleReset?: () => void;
+}) => import("react/jsx-runtime").JSX.Element;
 export { EmptyComments };

package/dist/package/components/inline-comment/floating-comment-layout-utils.d.ts

@@ -0,0 +1,78 @@
+import { Editor } from '@tiptap/react';
+import { FloatingLayoutInvalidationFlag, FloatingCardLayoutInput } from './comment-floating-layout';
+import { CommentFloatingCard } from './context/types';
+
+export type AnchorType = 'draft' | 'thread';
+export interface CachedAnchorRect {
+    top: number;
+    height: number;
+    scrollTop: number;
+    containerTop: number;
+}
+export interface AnchorRecord {
+    floatingCardId: string;
+    anchorId: string;
+    anchorType: AnchorType;
+    elements: HTMLElement[];
+    pmPos: number | null;
+    anchorVersion: number;
+    cachedRect: CachedAnchorRect | null;
+    lastSeenEditorRoot: HTMLElement | null;
+    missingSinceDocVersion: number | null;
+    missingSinceCycle: number | null;
+}
+export interface FloatingCardRuntimeState {
+    floatingCardId: string;
+    anchorPosition: number | null;
+    anchorVersion: number;
+    anchorTop: number | null;
+    anchorHeight: number;
+    height: number;
+    isMeasured: boolean;
+    isInViewport: boolean;
+    translateY: number | null;
+    lastCommittedTranslateY: number | null;
+    lastCommittedVisible: boolean;
+    needsTransformSync: boolean;
+    invalidationFlags: FloatingLayoutInvalidationFlag;
+}
+export declare const FLOATING_VIEWPORT_BUFFER_MULTIPLIER = 1;
+export declare const getAnchorIdentity: (floatingCard: CommentFloatingCard) => {
+    anchorId: string;
+    anchorType: "draft";
+} | {
+    anchorId: string;
+    anchorType: "thread";
+};
+export declare const getAnchorElements: ({ editorRoot, anchorId, anchorType, }: {
+    editorRoot: HTMLElement;
+    anchorId: string;
+    anchorType: AnchorType;
+}) => HTMLElement[];
+export declare const getAnchorStartPos: (editor: Editor, elements: HTMLElement[]) => null;
+export declare const getEditorRoot: (editor: Editor) => HTMLElement | null;
+export declare const areAnchorElementsEqual: (previousElements: HTMLElement[], nextElements: HTMLElement[]) => boolean;
+export declare const isAnchorEntryValid: (entry: AnchorRecord, editorRoot: HTMLElement) => boolean;
+export declare const getCachedAnchorRect: ({ cachedRect, scrollTop, containerTop, }: {
+    cachedRect: CachedAnchorRect;
+    scrollTop: number;
+    containerTop: number;
+}) => {
+    top: number;
+    height: number;
+};
+export declare const getRect: ({ elements, viewportTop, viewportBottom, }: {
+    elements: HTMLElement[];
+    viewportTop: number;
+    viewportBottom: number;
+}) => DOMRect | null;
+export declare const reconcileOrderedFloatingCardIds: ({ previousOrderedFloatingCardIds, nextFloatingCards, getPos, }: {
+    previousOrderedFloatingCardIds: string[];
+    nextFloatingCards: CommentFloatingCard[];
+    getPos: (floatingCardId: string) => number | null;
+}) => {
+    orderedFloatingCardIds: string[];
+    firstChangedIndex: number | null;
+};
+export declare const areFloatingCardIdListsEqual: (a: string[], b: string[]) => boolean;
+export declare const toFloatingCardLayoutInput: (floatingCardState: FloatingCardRuntimeState) => FloatingCardLayoutInput;

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

@@ -2,6 +2,7 @@ import { BubbleMenuProps } from '@tiptap/react/menus';
 import { Editor } from '@tiptap/react';
 import { IComment } from '../../extensions/comment';
 import { SetStateAction } from 'react';
+import { Tab } from '../tabs/utils/tab-utils';
 
 export interface UseCommentActionsProps {
     editor: Editor;
@@ -31,7 +32,9 @@ export interface CommentDrawerProps {
     isNavbarVisible: boolean;
     isPresentationMode: boolean;
     activeCommentId: string | null;
+    activeTabId: string;
     isPreviewMode: boolean;
+    tabs: Tab[];
 }
 export interface CommentCardProps extends IComment {
     comment?: string;
@@ -47,6 +50,7 @@ export interface CommentCardProps extends IComment {
     version?: string;
     emptyComment?: boolean;
     isFocused?: boolean;
+    isCommentDrawerContext?: boolean;
 }
 export type CommentBubbleMenuProps = Omit<BubbleMenuProps, 'children'> & {
     zoomLevel: string;
@@ -67,6 +71,15 @@ export interface CommentSectionProps {
     activeCommentId: string | null;
     isNavbarVisible?: boolean;
     isPresentationMode?: boolean;
+    isMobile?: boolean;
+    comments?: IComment[];
+    commentType?: 'all' | 'active' | 'resolved';
+    sectionLabel?: string;
+    tabNameById?: Record<string, string>;
+    selectedTabLabel?: string;
+    showComposeInput?: boolean;
+    onCommentFocus?: (commentId: string, tabId?: string) => void;
+    onReset?: () => void;
 }
 export interface UserDisplayProps {
     username: string;

package/dist/package/components/inline-comment/use-anchor-registry.d.ts

@@ -0,0 +1,33 @@
+import { MutableRefObject } from 'react';
+import { Editor } from '@tiptap/react';
+import { FloatingLayoutInvalidationFlag } from './comment-floating-layout';
+import { CommentFloatingCard } from './context/types';
+import { AnchorRecord, FloatingCardRuntimeState } from './floating-comment-layout-utils';
+
+interface SyncAnchorsArgs {
+    currentCycle: number;
+    currentDocVersion: number;
+    editor: Editor;
+    editorRoot: HTMLElement;
+    editorWrapperNode: HTMLDivElement | null;
+    floatingCards: CommentFloatingCard[];
+    getFloatingCardRuntimeState: (floatingCardId: string) => FloatingCardRuntimeState;
+    markFloatingCardInvalidated: (floatingCardId: string, flag: FloatingLayoutInvalidationFlag) => void;
+    markRecomputeFromIndex: (recomputeFromIndex: number) => void;
+    getOrderedFloatingCardIndex: (floatingCardId: string) => number | null;
+}
+interface SyncAnchorsResult {
+    activeFloatingCards: CommentFloatingCard[];
+    activeFloatingCardMap: Map<string, CommentFloatingCard>;
+    floatingCardIdsToClose: Set<string>;
+    shouldScheduleFollowUp: boolean;
+}
+export interface UseAnchorRegistryResult {
+    anchorRegistryRef: MutableRefObject<Map<string, AnchorRecord>>;
+    queueAnchorRefresh: (floatingCardId: string) => void;
+    queueAnchorRefreshForCards: (floatingCards: CommentFloatingCard[]) => void;
+    resetAnchorRegistry: () => void;
+    syncAnchors: (args: SyncAnchorsArgs) => SyncAnchorsResult;
+}
+export declare const useAnchorRegistry: () => UseAnchorRegistryResult;
+export {};

package/dist/package/components/inline-comment/use-comment-list-container.d.ts

@@ -0,0 +1,17 @@
+import { RefObject } from 'react';
+import { Editor } from '@tiptap/react';
+import { CommentFloatingCard } from './context/types';
+
+export interface UseCommentListContainerProps {
+    editor: Editor;
+    editorWrapperRef: RefObject<HTMLDivElement>;
+    scrollContainerRef: RefObject<HTMLDivElement>;
+    isHidden: boolean;
+}
+export interface UseCommentListContainerResult {
+    floatingCardListContainerRef: RefObject<HTMLDivElement>;
+    mountedFloatingCards: CommentFloatingCard[];
+    registerCardNode: (floatingCardId: string, node: HTMLDivElement | null) => void;
+    shouldRender: boolean;
+}
+export declare const useCommentListContainer: ({ editor, editorWrapperRef, scrollContainerRef, isHidden, }: UseCommentListContainerProps) => UseCommentListContainerResult;

package/dist/package/components/inline-comment/use-floating-card-state.d.ts

@@ -0,0 +1,34 @@
+import { MutableRefObject } from 'react';
+import { FloatingLayoutInvalidationFlag, FloatingCardLayoutInput } from './comment-floating-layout';
+import { CommentFloatingCard } from './context/types';
+import { FloatingCardRuntimeState } from './floating-comment-layout-utils';
+
+interface SyncMountedFloatingCardIdsResult {
+    didChange: boolean;
+    previousMountedFloatingCardIds: Set<string>;
+}
+export interface UseFloatingCardStateResult {
+    floatingCardStateRef: MutableRefObject<Map<string, FloatingCardRuntimeState>>;
+    orderedFloatingCardIdsRef: MutableRefObject<string[]>;
+    heightMeasurementQueueRef: MutableRefObject<Set<string>>;
+    layoutBoundaryRef: MutableRefObject<{
+        recomputeFromIndex: number;
+    }>;
+    mountedFloatingCardIdsRef: MutableRefObject<string[]>;
+    mountedFloatingCardIds: string[];
+    getFloatingCardRuntimeState: (floatingCardId: string) => FloatingCardRuntimeState;
+    getOrderedFloatingCardIndex: (floatingCardId: string) => number | null;
+    markRecomputeFromIndex: (recomputeFromIndex: number) => void;
+    markFloatingCardInvalidated: (floatingCardId: string, flag: FloatingLayoutInvalidationFlag) => void;
+    reconcileFloatingCardOrder: (nextFloatingCards: CommentFloatingCard[]) => {
+        orderedFloatingCardIds: string[];
+        firstChangedIndex: number | null;
+    };
+    pruneFloatingCardRuntimeState: (activeFloatingCardIds: Set<string>) => void;
+    syncMountedFloatingCardIds: (nextMountedFloatingCardIds: string[]) => SyncMountedFloatingCardIdsResult;
+    clearInvalidationFlagsThroughIndex: (stopIndex: number) => void;
+    getFloatingCardLayoutInputs: () => FloatingCardLayoutInput[];
+    resetFloatingCardState: () => void;
+}
+export declare const useFloatingCardState: () => UseFloatingCardStateResult;
+export {};

package/dist/package/components/inline-comment/use-floating-comment-card-layout.d.ts

@@ -0,0 +1,23 @@
+import { RefObject } from 'react';
+import { Editor } from '@tiptap/react';
+import { CommentFloatingCard } from './context/types';
+
+interface UseFloatingCommentCardLayoutProps {
+    blurFloatingCard: (floatingCardId: string) => void;
+    closeFloatingCard: (floatingCardId: string) => void;
+    editor: Editor;
+    editorWrapperRef: RefObject<HTMLDivElement>;
+    floatingCardIdsKey: string;
+    floatingCards: CommentFloatingCard[];
+    focusedFloatingCardId: string | null;
+    isDesktopFloatingEnabled: boolean;
+    isHidden: boolean;
+    scrollContainerRef: RefObject<HTMLDivElement>;
+}
+interface UseFloatingCommentCardLayoutResult {
+    floatingCardListContainerRef: RefObject<HTMLDivElement>;
+    mountedFloatingCardIds: string[];
+    registerCardNode: (floatingCardId: string, node: HTMLDivElement | null) => void;
+}
+export declare const useFloatingCommentCardLayout: ({ blurFloatingCard, closeFloatingCard, editor, editorWrapperRef, floatingCardIdsKey, floatingCards, focusedFloatingCardId, isDesktopFloatingEnabled, isHidden, scrollContainerRef, }: UseFloatingCommentCardLayoutProps) => UseFloatingCommentCardLayoutResult;
+export {};

package/dist/package/components/inline-comment/use-floating-comment-card-state.d.ts

@@ -0,0 +1,13 @@
+import { CommentFloatingCard } from './context/types';
+
+interface UseFloatingCommentCardStateResult {
+    blurFloatingCard: (floatingCardId: string) => void;
+    closeFloatingCard: (floatingCardId: string) => void;
+    floatingCardIdsKey: string;
+    floatingCardMap: Map<string, CommentFloatingCard>;
+    floatingCards: CommentFloatingCard[];
+    focusedFloatingCardId: string | null;
+    isDesktopFloatingEnabled: boolean;
+}
+export declare const useFloatingCommentCardState: () => UseFloatingCommentCardStateResult;
+export {};

package/dist/package/components/inline-comment/use-floating-layout-engine.d.ts

@@ -0,0 +1,26 @@
+import { RefObject } from 'react';
+import { Editor } from '@tiptap/react';
+import { CommentFloatingCard } from './context/types';
+import { UseAnchorRegistryResult } from './use-anchor-registry';
+import { UseFloatingCardStateResult } from './use-floating-card-state';
+
+interface UseFloatingLayoutEngineProps {
+    blurFloatingCard: (floatingCardId: string) => void;
+    closeFloatingCard: (floatingCardId: string) => void;
+    editor: Editor;
+    editorWrapperRef: RefObject<HTMLDivElement>;
+    floatingCardIdsKey: string;
+    floatingCards: CommentFloatingCard[];
+    focusedFloatingCardId: string | null;
+    isDesktopFloatingEnabled: boolean;
+    isHidden: boolean;
+    scrollContainerRef: RefObject<HTMLDivElement>;
+    anchorRegistry: UseAnchorRegistryResult;
+    floatingCardState: UseFloatingCardStateResult;
+}
+export interface UseFloatingLayoutEngineResult {
+    floatingCardListContainerRef: RefObject<HTMLDivElement>;
+    registerCardNode: (floatingCardId: string, node: HTMLDivElement | null) => void;
+}
+export declare const useFloatingLayoutEngine: ({ blurFloatingCard, closeFloatingCard, editor, editorWrapperRef, floatingCardIdsKey, floatingCards, focusedFloatingCardId, isDesktopFloatingEnabled, isHidden, scrollContainerRef, anchorRegistry, floatingCardState, }: UseFloatingLayoutEngineProps) => UseFloatingLayoutEngineResult;
+export {};

package/dist/package/stores/comment-store-provider.d.ts

@@ -9,6 +9,7 @@ export interface CommentStoreProviderProps {
     children: React.ReactNode;
     editor: Editor | null;
     ydoc: Y.Doc;
+    isFocusMode?: boolean;
     setActiveCommentId: (id: string | null) => void;
     focusCommentWithActiveId: (id: string) => void;
     setInitialComments?: React.Dispatch<React.SetStateAction<IComment[]>>;
@@ -34,7 +35,7 @@ export interface CommentStoreProviderProps {
     isDDocOwner?: boolean;
     setUsername?: React.Dispatch<React.SetStateAction<string>>;
 }
-export declare const CommentStoreProvider: ({ children, editor, ydoc, setActiveCommentId, focusCommentWithActiveId, setInitialComments, onNewComment, onCommentReply, onResolveComment, onUnresolveComment, onDeleteComment, onInlineComment, onComment, setCommentDrawerOpen, connectViaWallet, connectViaUsername, ensResolutionUrl, commentAnchorsRef, initialCommentAnchors, setUsername: setUsernameProp, initialComments, username, activeCommentId, activeTabId, isConnected, isLoading, isDDocOwner, }: CommentStoreProviderProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CommentStoreProvider: ({ children, editor, ydoc, isFocusMode, setActiveCommentId, focusCommentWithActiveId, setInitialComments, onNewComment, onCommentReply, onResolveComment, onUnresolveComment, onDeleteComment, onInlineComment, onComment, setCommentDrawerOpen, connectViaWallet, connectViaUsername, ensResolutionUrl, commentAnchorsRef, initialCommentAnchors, setUsername: setUsernameProp, initialComments, username, activeCommentId, activeTabId, isConnected, isLoading, isDDocOwner, }: CommentStoreProviderProps) => import("react/jsx-runtime").JSX.Element;
 interface CommentRefsContextType {
     commentsSectionRef: React.RefObject<HTMLDivElement>;
     replySectionRef: React.RefObject<HTMLDivElement>;

package/dist/package/stores/comment-store.d.ts

@@ -1,7 +1,7 @@
 import { Editor } from '@tiptap/react';
 import { default as React } from 'react';
 import { CommentAnchor } from '../extensions/comment/comment-decoration-plugin';
-import { CommentFloatingItem, EnsCache, InlineCommentData } from '../components/inline-comment/context/types';
+import { CommentFloatingCard, EnsCache, InlineCommentData } from '../components/inline-comment/context/types';
 import { EnsStatus } from '../components/inline-comment/types';
 import { IComment } from '../extensions/comment';
 import { CommentMutationMeta, CommentMutationType } from '../types';
@@ -27,7 +27,7 @@ export interface CommentExternalDeps {
     ensResolutionUrl: string;
     commentAnchorsRef?: React.MutableRefObject<CommentAnchor[]>;
 }
-type FloatingItemsUpdater = React.SetStateAction<CommentFloatingItem[]>;
+type FloatingCardsUpdater = React.SetStateAction<CommentFloatingCard[]>;
 type InlineCommentDataUpdater = Partial<InlineCommentData> | ((prev: InlineCommentData) => Partial<InlineCommentData> | InlineCommentData);
 export interface CommentStoreState {
     initialComments: IComment[];
@@ -55,7 +55,8 @@ export interface CommentStoreState {
     isCommentOpen: boolean;
     isBubbleMenuSuppressed: boolean;
     inlineCommentData: InlineCommentData;
-    floatingItems: CommentFloatingItem[];
+    floatingCards: CommentFloatingCard[];
+    mobileDraftId: string | null;
     isDesktopFloatingEnabled: boolean;
     ensCache: EnsCache;
     inProgressFetch: string[];
@@ -89,8 +90,8 @@ export interface CommentStoreState {
     setIsCommentOpen: (open: boolean) => void;
     setIsBubbleMenuSuppressed: (suppressed: boolean) => void;
     setInlineCommentData: (data: InlineCommentDataUpdater) => void;
-    setFloatingItems: (items: FloatingItemsUpdater) => void;
-    clearFloatingItems: () => void;
+    setFloatingCards: (floatingCards: FloatingCardsUpdater) => void;
+    clearFloatingCards: () => void;
     setIsDesktopFloatingEnabled: (enabled: boolean) => void;
     toggleResolved: () => void;
     handleInput: (e: React.FormEvent<HTMLTextAreaElement>, content: string) => void;
@@ -107,11 +108,11 @@ export interface CommentStoreState {
     cancelFloatingDraft: (draftId: string) => void;
     submitFloatingDraft: (draftId: string) => void;
     openFloatingThread: (commentId: string) => void;
-    closeFloatingItem: (itemId: string) => void;
-    blurFloatingItem: (itemId: string) => void;
-    focusFloatingItem: (itemId: string) => void;
-    pruneFloatingItems: () => void;
-    syncFloatingThreadWithActiveComment: () => void;
+    closeFloatingCard: (floatingCardId: string) => void;
+    blurFloatingCard: (floatingCardId: string) => void;
+    focusFloatingCard: (floatingCardId: string) => void;
+    removeInvalidFloatingCards: () => void;
+    syncFloatingThreadCardWithActiveComment: () => void;
     submitPendingFloatingDrafts: () => void;
     resolveComment: (commentId: string) => void;
     unresolveComment: (commentId: string) => void;