@fileverse-dev/ddoc 3.1.7 → 3.1.8

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

@@ -1,5 +1,7 @@
 import { Editor } from '@tiptap/core';
 
+export declare const isSelectionInsideEditor: (editor: Editor) => boolean;
 export declare const shouldShow: ({ editor }: {
     editor: Editor;
 }) => boolean;
+export declare const shouldShowIgnoringFocus: (editor: Editor) => boolean;

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

@@ -1,4 +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 CommentCard: (props: 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, onTabChange, isPreviewMode, tabs, isCollaborationEnabled, }: CommentDrawerProps) => import("react/jsx-runtime").JSX.Element;

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

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

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

@@ -0,0 +1 @@
+export { CommentFloatingContainer } from './floating-comment';

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

@@ -0,0 +1,34 @@
+export declare const FLOATING_COMMENT_CARD_GAP = 8;
+export declare const enum FloatingLayoutInvalidationFlag {
+    None = 0,
+    Anchor = 1,
+    Viewport = 2,
+    Height = 4,
+    Visibility = 8
+}
+export interface FloatingCardLayoutInput {
+    floatingCardId: string;
+    anchorTop: number | null;
+    height: number;
+    isVisible: boolean;
+    isMeasured: boolean;
+    lastCommittedTranslateY: number | null;
+    invalidationFlags: FloatingLayoutInvalidationFlag;
+}
+export interface FloatingLayoutResult {
+    placements: Map<string, {
+        translateY: number | null;
+        isVisible: boolean;
+    }>;
+    stopIndex: number;
+    usedFocusedLayout: boolean;
+}
+export declare const roundFloatingTranslateY: (translateY: number | null) => number | null;
+export declare const computeFloatingCommentLayout: ({ floatingCards, recomputeStartIndex, firstInvalidatedIndex, lastInvalidatedIndex, gap, focusedFloatingCardId, }: {
+    floatingCards: FloatingCardLayoutInput[];
+    recomputeStartIndex: number;
+    firstInvalidatedIndex?: number;
+    lastInvalidatedIndex: number;
+    gap?: number;
+    focusedFloatingCardId?: string | null;
+}) => FloatingLayoutResult;

package/dist/package/components/inline-comment/comment-input-field.d.ts

@@ -0,0 +1,4 @@
+export declare const CommentInputField: ({ tabId, isCollaborationEnabled, }: {
+    tabId?: string;
+    isCollaborationEnabled: boolean;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/package/components/inline-comment/comment-reply-input.d.ts

@@ -0,0 +1,8 @@
+interface CommentReplyInputProps {
+    commentId: string;
+    commentUsername?: string;
+    replyCount: number;
+    isCollaborationEnabled: boolean;
+}
+export declare const CommentReplyInput: ({ commentId, replyCount, isCollaborationEnabled, }: CommentReplyInputProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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, newCommentTabId, showNewCommentInput, onCommentFocus, onReset, isCollaborationEnabled, }: CommentSectionProps) => import("react/jsx-runtime").JSX.Element;

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

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

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

@@ -0,0 +1 @@
+export declare const FLOATING_CARD_WIDTH = 300;

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

@@ -1,100 +1,57 @@
-import { Editor } from '@tiptap/react';
+import { Dispatch, RefObject, SetStateAction } from 'react';
 import { IComment } from '../../../extensions/comment';
-import { SetStateAction } from 'react';
-import { CommentAccountProps, CommentMutationMeta } from '../../../types';
-import { EnsStatus } from '../types';
+import { CommentStoreState } from '../../../stores/comment-store';
+import { CommentStoreProviderProps } from '../../../stores/comment-store-provider';
+import { CommentAccountProps } from '../../../types';
 
-import * as Y from 'yjs';
-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;
+export interface CommentFloatingBaseCard {
+    floatingCardId: string;
     selectedText: string;
-    isCommentOpen: boolean;
-    isBubbleMenuSuppressed: boolean;
-    setIsBubbleMenuSuppressed: React.Dispatch<React.SetStateAction<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;
-    activeTabId: 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;
-    }>>;
-    getEnsStatus: (walletAddress: string, setEnsStatus: React.Dispatch<React.SetStateAction<EnsStatus>>) => void;
-    ensCache: EnsCache;
+    isFocused: boolean;
 }
-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, 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;
-    onComment?: () => void;
-    setCommentDrawerOpen?: React.Dispatch<React.SetStateAction<boolean>>;
+export type InlineDraftLocation = 'drawer' | 'floating';
+export interface InlineCommentDraft {
+    draftId: string;
+    tabId: string;
+    selectedText: string;
+    text: string;
+    location: InlineDraftLocation;
+    isAuthPending: boolean;
 }
-export interface CommentUsernameProps extends CommentAccountProps {
-    username?: string | null;
-    setUsername?: React.Dispatch<SetStateAction<string>>;
-    isNavbarVisible?: boolean;
+export interface CommentFloatingDraftCard extends CommentFloatingBaseCard {
+    type: 'draft';
+    draftId: string;
+}
+export interface CommentFloatingThreadCard extends CommentFloatingBaseCard {
+    type: 'thread';
+    commentId: string;
+}
+export type CommentFloatingCard = CommentFloatingDraftCard | CommentFloatingThreadCard;
+export interface InlineCommentData {
+    highlightedTextContent?: string;
+    inlineCommentText: string;
+    handleClick: boolean;
 }
 export interface EnsEntry {
     name: string;
     isEns: boolean;
 }
 export type EnsCache = Record<string, EnsEntry>;
+export type CommentProviderProps = CommentStoreProviderProps;
+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>;
+    buttonRef: RefObject<HTMLDivElement>;
+    portalRef: RefObject<HTMLDivElement>;
+    replySectionRef: RefObject<HTMLDivElement>;
+    editor: CommentStoreProviderProps['editor'];
+    ensResolutionUrl: string;
+    onCommentReply?: CommentStoreProviderProps['onCommentReply'];
+    setComments?: Dispatch<SetStateAction<IComment[]>>;
+};
+export interface CommentUsernameProps extends CommentAccountProps {
+    username?: string | null;
+    setUsername?: Dispatch<SetStateAction<string>>;
+    isNavbarVisible?: boolean;
+}

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

@@ -0,0 +1,10 @@
+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/comment-floating-container.d.ts

@@ -0,0 +1,3 @@
+import { CommentFloatingContainerProps } from './types';
+
+export declare const CommentFloatingContainer: ({ editor, editorWrapperRef, scrollContainerRef, tabName, isHidden, isCollaborationEnabled, }: CommentFloatingContainerProps) => import("react/jsx-runtime").JSX.Element | null;

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

@@ -0,0 +1,3 @@
+import { DraftFloatingCardProps } from './types';
+
+export declare const DraftFloatingCard: ({ draft, isHidden, registerCardNode, }: DraftFloatingCardProps) => import("react/jsx-runtime").JSX.Element | null;

package/dist/package/components/inline-comment/floating-comment/floating-auth-prompt.d.ts

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

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

@@ -0,0 +1,3 @@
+import { FloatingCardShellProps } from './types';
+
+export declare const FloatingCardShell: import('react').ForwardRefExoticComponent<FloatingCardShellProps & import('react').RefAttributes<HTMLDivElement>>;

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

@@ -0,0 +1 @@
+export { CommentFloatingContainer } from './comment-floating-container';

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

@@ -0,0 +1,3 @@
+import { ThreadFloatingCardProps } from './types';
+
+export declare const ThreadFloatingCard: ({ thread, comment, tabName, isHidden, registerCardNode, isCollaborationEnabled, }: ThreadFloatingCardProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,34 @@
+import { Editor } from '@tiptap/react';
+import { ReactNode, RefObject } from 'react';
+import { IComment } from '../../../extensions/comment';
+import { CommentFloatingDraftCard, CommentFloatingThreadCard } from '../context/types';
+
+export type RegisterCardNode = (floatingCardId: string, node: HTMLDivElement | null) => void;
+export interface CommentFloatingContainerProps {
+    editor: Editor;
+    editorWrapperRef: RefObject<HTMLDivElement>;
+    scrollContainerRef: RefObject<HTMLDivElement>;
+    tabName: string;
+    isHidden: boolean;
+    isCollaborationEnabled?: boolean;
+}
+export interface FloatingCardShellProps {
+    floatingCardId: string;
+    isHidden: boolean;
+    isFocused: boolean;
+    onFocus: () => void;
+    children: ReactNode;
+}
+export interface DraftFloatingCardProps {
+    draft: CommentFloatingDraftCard;
+    isHidden: boolean;
+    registerCardNode: RegisterCardNode;
+}
+export interface ThreadFloatingCardProps {
+    thread: CommentFloatingThreadCard;
+    comment: IComment | undefined;
+    tabName: string;
+    isHidden: boolean;
+    registerCardNode: RegisterCardNode;
+    isCollaborationEnabled?: boolean;
+}

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/resize-inline-comment-textarea.d.ts

@@ -0,0 +1 @@
+export declare const resizeInlineCommentTextarea: (textarea: HTMLTextAreaElement, maxHeight?: number) => void;

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,13 +32,19 @@ export interface CommentDrawerProps {
     isNavbarVisible: boolean;
     isPresentationMode: boolean;
     activeCommentId: string | null;
+    activeTabId: string;
+    onTabChange?: (tabId: string) => void;
     isPreviewMode: boolean;
+    tabs: Tab[];
+    isCollaborationEnabled: boolean;
 }
 export interface CommentCardProps extends IComment {
     comment?: string;
     onResolve?: (commentId: string) => void;
     onDelete?: (commentId: string) => void;
+    onRequestDelete?: (commentId: string) => void;
     onUnresolve?: (commentId: string) => void;
+    onFocusRequest?: () => void;
     isResolved?: boolean;
     isDropdown?: boolean;
     activeCommentId?: string;
@@ -45,15 +52,21 @@ export interface CommentCardProps extends IComment {
     isCommentOwner?: boolean;
     version?: string;
     emptyComment?: boolean;
+    isFocused?: boolean;
+    isCommentDrawerContext?: boolean;
 }
 export type CommentBubbleMenuProps = Omit<BubbleMenuProps, 'children'> & {
     zoomLevel: string;
 };
 export interface CommentReplyProps {
+    commentId: string;
+    replyId: string;
     reply: string;
     username: string;
     createdAt: Date;
     isLast: boolean;
+    isThreadResolved?: boolean;
+    isCommentDrawerContext?: boolean;
 }
 export interface EnsStatus {
     name: string;
@@ -63,6 +76,17 @@ 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;
+    newCommentTabId?: string;
+    showNewCommentInput?: boolean;
+    onCommentFocus?: (commentId: string, tabId?: string) => void;
+    onReset?: () => void;
+    isCollaborationEnabled: boolean;
 }
 export interface UserDisplayProps {
     username: string;

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

@@ -0,0 +1,34 @@
+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;
+    markFloatingCardOrderDirty: () => 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-card.d.ts

@@ -0,0 +1,29 @@
+import { MouseEvent } from 'react';
+import { IComment } from '../../extensions/comment';
+import { CommentCardProps } from './types';
+
+export declare const useCommentCard: ({ username, comment, replies, onResolve, onRequestDelete, onUnresolve, onFocusRequest, isResolved, isDropdown, isCommentDrawerContext, activeCommentId, id, isFocused, }: CommentCardProps) => {
+    commentsContainerRef: import('react').RefObject<HTMLDivElement>;
+    displayedComment: string | undefined;
+    displayedReplies: IComment[];
+    dropdownRef: import('react').RefObject<HTMLDivElement>;
+    ensStatus: import('./types').EnsStatus;
+    focusCardIfNeeded: () => void;
+    handleCommentExpandClick: (event: MouseEvent<HTMLButtonElement>) => void;
+    handleReplyToggleClick: (event: MouseEvent<HTMLElement>) => void;
+    handleRequestEditClick: () => void;
+    handleRequestDeleteClick: () => void;
+    handleResolveClick: (event: MouseEvent<HTMLButtonElement>) => void;
+    handleUnresolveClick: () => void;
+    isBelow1280px: boolean;
+    isCardActive: boolean;
+    isCommentExpanded: boolean;
+    isCommentMobileFocused: boolean;
+    isCommentTruncated: boolean;
+    replyToggleLabel: string;
+    shouldShowReplyThread: boolean;
+    shouldShowReplyToggle: boolean;
+    shouldShowResolvedMobileReplyCount: boolean;
+    showAllReplies: boolean;
+    visibleReplies: IComment[];
+};

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-ens-status.d.ts

@@ -0,0 +1,3 @@
+import { EnsStatus } from './types';
+
+export declare const useEnsStatus: (walletAddressOrName?: string | null) => EnsStatus;

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

@@ -0,0 +1,36 @@
+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[]>;
+    orderDirtyRef: MutableRefObject<boolean>;
+    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;
+    markFloatingCardOrderDirty: () => 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 {};