@harbour-enterprises/superdoc 1.9.0-next.1 → 1.9.0-next.2

package/dist/super-editor/src/core/presentation-editor/selection/SelectionHelpers.d.ts

@@ -1,113 +0,0 @@
-import { FlowBlock } from '@superdoc/contracts';
-/**
- * Determines if a character is considered part of a word for selection purposes.
- *
- * This function uses a Unicode-aware regex to test whether a character should be
- * included in word-based selection operations. It supports international characters
- * and common punctuation used within words.
- *
- * @param char - The character to test (typically a single character string)
- * @returns True if the character is a word character, false otherwise
- *
- * @remarks
- * Word character definition:
- * - Unicode letters in any language (Latin, Cyrillic, CJK, etc.)
- * - Unicode digits in any script
- * - Apostrophes and quotation marks (for contractions)
- * - Underscores, tildes, and hyphens
- *
- * Non-word characters include:
- * - Whitespace (spaces, tabs, newlines)
- * - Most punctuation (periods, commas, semicolons, etc.)
- * - Empty strings
- *
- * This function is used by word boundary detection logic to determine where
- * words start and end during double-click selection and word-based navigation.
- *
- * @example
- * ```typescript
- * isWordCharacter('a');  // true (letter)
- * isWordCharacter('5');  // true (digit)
- * isWordCharacter("'");  // true (apostrophe for contractions)
- * isWordCharacter(' ');  // false (whitespace)
- * isWordCharacter('.');  // false (punctuation)
- * isWordCharacter('');   // false (empty string)
- * isWordCharacter('文'); // true (Unicode letter - Chinese character)
- * ```
- */
-export declare function isWordCharacter(char: string): boolean;
-/**
- * Calculates extended selection boundaries based on the selection mode.
- *
- * This function expands a selection range to align with word or paragraph boundaries,
- * depending on the specified mode. It handles both forward and backward selections
- * correctly, ensuring the selection extends in the expected direction.
- *
- * @param blocks - Array of layout blocks containing text content
- * @param anchor - The anchor position (where selection started)
- * @param head - The head position (current selection endpoint)
- * @param mode - Selection extension mode: 'char', 'word', or 'para'
- * @returns Object with selAnchor and selHead representing the extended selection range
- *
- * @remarks
- * Selection modes:
- * - 'char': Character-level selection (no extension) - returns input positions unchanged
- * - 'word': Extends to word boundaries using findWordBoundaries
- * - 'para': Extends to paragraph boundaries using findParagraphBoundaries
- *
- * Forward selection (head >= anchor):
- * - Anchor extends to the start of its containing unit (word/paragraph)
- * - Head extends to the end of its containing unit
- * - This expands the selection to include complete units
- *
- * Backward selection (head < anchor):
- * - Anchor extends to the end of its containing unit
- * - Head extends to the start of its containing unit
- * - This maintains the backward direction while expanding to complete units
- *
- * Fallback behavior:
- * - If boundary finding fails (returns null), falls back to character mode
- * - Returns original positions if mode is 'char'
- * - Gracefully handles invalid positions
- *
- * This function is typically called during:
- * - Double-click (word mode)
- * - Triple-click (paragraph mode)
- * - Shift+arrow key navigation with word/paragraph modifiers
- * - Drag extension in word/paragraph selection modes
- *
- * @example
- * ```typescript
- * // Double-click on a word: extend to full word
- * const wordSelection = calculateExtendedSelection(
- *   blocks,
- *   clickPos,
- *   clickPos,
- *   'word'
- * );
- * // Result: { selAnchor: wordStart, selHead: wordEnd }
- *
- * // Triple-click: extend to full paragraph
- * const paraSelection = calculateExtendedSelection(
- *   blocks,
- *   clickPos,
- *   clickPos,
- *   'para'
- * );
- * // Result: { selAnchor: paraStart, selHead: paraEnd }
- *
- * // Character-level selection (no extension)
- * const charSelection = calculateExtendedSelection(
- *   blocks,
- *   anchor,
- *   head,
- *   'char'
- * );
- * // Result: { selAnchor: anchor, selHead: head }
- * ```
- */
-export declare function calculateExtendedSelection(blocks: FlowBlock[], anchor: number, head: number, mode: 'char' | 'word' | 'para'): {
-    selAnchor: number;
-    selHead: number;
-};
-//# sourceMappingURL=SelectionHelpers.d.ts.map

package/dist/super-editor/src/core/presentation-editor/selection/SelectionHelpers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SelectionHelpers.d.ts","sourceRoot":"","sources":["../../../../../../../super-editor/src/core/presentation-editor/selection/SelectionHelpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAoBrD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAKrD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqEG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,SAAS,EAAE,EACnB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAC7B;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CA6BxC"}

package/dist/super-editor/src/core/presentation-editor/selection/SelectionSyncCoordinator.d.ts

@@ -1,185 +0,0 @@
-import { EventEmitter } from '../../EventEmitter.js';
-/**
- * Payload emitted with the 'render' event when selection rendering should occur.
- */
-export type SelectionSyncRenderPayload = {
-    /** The current document epoch at render time */
-    docEpoch: number;
-    /** The layout epoch that was painted and is now available for rendering */
-    layoutEpoch: number;
-};
-/**
- * Event map for SelectionSyncCoordinator events.
- */
-export type SelectionSyncEventMap = {
-    /** Emitted when conditions are safe for selection rendering (layout caught up to document) */
-    render: [SelectionSyncRenderPayload];
-};
-/**
- * Abstraction for scheduling animation frame callbacks.
- *
- * @remarks
- * Allows dependency injection for testing and non-browser environments.
- */
-export type SelectionSyncScheduler = {
-    /** Schedules a callback to run before the next repaint */
-    requestAnimationFrame: (cb: FrameRequestCallback) => number;
-    /** Cancels a previously scheduled animation frame callback */
-    cancelAnimationFrame: (handle: number) => void;
-};
-/**
- * Coordinates selection rendering to ensure it only occurs when layout has caught up to the document state.
- *
- * @remarks
- * This class solves a fundamental synchronization problem: the layout engine paints asynchronously,
- * so the DOM may represent a stale document epoch. Selection rendering (highlights, carets, cursors)
- * must only occur when the layout reflects the current document, otherwise positions will be incorrect.
- *
- * The coordinator tracks two epochs:
- * - docEpoch: The current document version (increments on each transaction)
- * - layoutEpoch: The document version currently painted in the DOM
- *
- * Selection rendering is only safe when: layoutEpoch >= docEpoch && !layoutUpdating
- *
- * Key behaviors:
- * - Render requests are debounced using requestAnimationFrame
- * - Rendering is blocked while layout is updating (onLayoutStart/onLayoutComplete lifecycle)
- * - Rendering is blocked when layout is behind the document (layoutEpoch < docEpoch)
- * - The 'render' event is emitted when conditions become safe for rendering
- *
- * Typical usage pattern:
- * 1. Call setDocEpoch() when the document changes
- * 2. Call onLayoutStart() when layout computation begins
- * 3. Call onLayoutComplete() when layout painting finishes
- * 4. Call requestRender() when selection changes
- * 5. Listen to 'render' event to actually render selection overlays
- *
- * The coordinator ensures that render events only fire when it's safe, preventing visual
- * glitches from stale position data.
- */
-export declare class SelectionSyncCoordinator extends EventEmitter<SelectionSyncEventMap> {
-    #private;
-    /**
-     * Creates a new SelectionSyncCoordinator.
-     *
-     * @param options - Configuration options
-     * @param options.scheduler - Custom scheduler for animation frames (useful for testing), defaults to platform scheduler
-     */
-    constructor(options?: {
-        scheduler?: SelectionSyncScheduler;
-    });
-    /**
-     * Gets the current document epoch.
-     *
-     * @returns The document epoch (increments on each document-changing transaction)
-     */
-    getDocEpoch(): number;
-    /**
-     * Gets the current layout epoch.
-     *
-     * @returns The epoch of the document version currently painted in the DOM
-     */
-    getLayoutEpoch(): number;
-    /**
-     * Checks if a layout update is currently in progress.
-     *
-     * @returns True if between onLayoutStart() and onLayoutComplete(), false otherwise
-     */
-    isLayoutUpdating(): boolean;
-    /**
-     * Updates the document epoch and triggers conditional rendering.
-     *
-     * @param epoch - The new document epoch (must be finite and non-negative)
-     *
-     * @remarks
-     * When the document epoch changes:
-     * 1. Any scheduled render is cancelled (layout will be out of sync)
-     * 2. If layout has already caught up, rendering is rescheduled
-     *
-     * Calling with the same epoch as the current value is a no-op.
-     * Invalid epoch values are silently ignored.
-     */
-    setDocEpoch(epoch: number): void;
-    /**
-     * Notifies the coordinator that layout computation has started.
-     *
-     * @remarks
-     * Marks the layout as updating and cancels any scheduled renders, since the DOM
-     * is about to change and current position data will be stale.
-     *
-     * Safe to call multiple times (e.g., if layouts overlap) - subsequent calls are ignored
-     * until onLayoutComplete() is called.
-     */
-    onLayoutStart(): void;
-    /**
-     * Notifies the coordinator that layout painting has completed.
-     *
-     * @param layoutEpoch - The document epoch that was just painted to the DOM
-     *
-     * @remarks
-     * Marks the layout as no longer updating, records the new layout epoch, and attempts
-     * to schedule rendering if conditions are now safe.
-     *
-     * If the layoutEpoch is invalid (not a finite non-negative number), it is ignored and
-     * the previous layoutEpoch value is retained.
-     *
-     * This method is the primary trigger for selection rendering - if there's a pending
-     * render request and layoutEpoch >= docEpoch, a render event will be scheduled.
-     */
-    onLayoutComplete(layoutEpoch: number): void;
-    /**
-     * Notifies the coordinator that layout was aborted without completing.
-     *
-     * @remarks
-     * Marks the layout as no longer updating (without updating layoutEpoch) and attempts
-     * to schedule rendering if conditions are safe.
-     *
-     * Use this when layout computation is cancelled or fails partway through.
-     */
-    onLayoutAbort(): void;
-    /**
-     * Requests that selection rendering occur when conditions become safe.
-     *
-     * @param options - Rendering options
-     * @param options.immediate - If true, attempts to render immediately (synchronously) if safe, defaults to false
-     *
-     * @remarks
-     * Marks a render as pending and schedules it to occur on the next animation frame if
-     * conditions are safe (layout not updating, layoutEpoch >= docEpoch).
-     *
-     * If options.immediate is true, also attempts a synchronous render before scheduling.
-     * Use immediate rendering sparingly, as it can cause multiple renders per frame.
-     *
-     * Multiple calls are coalesced - only one render will occur per animation frame.
-     */
-    requestRender(options?: {
-        immediate?: boolean;
-    }): void;
-    /**
-     * Attempts to render selection immediately (synchronously) if conditions are safe.
-     *
-     * @remarks
-     * If there's a pending render request and conditions are safe (layout not updating,
-     * layoutEpoch >= docEpoch), this method:
-     * 1. Cancels any scheduled asynchronous render
-     * 2. Clears the pending flag
-     * 3. Emits the 'render' event synchronously
-     *
-     * If no render is pending or conditions are not safe, this is a no-op.
-     *
-     * Use this for immediate selection updates in response to user actions (e.g., click
-     * handlers) where waiting for the next animation frame would cause noticeable lag.
-     */
-    flushNow(): void;
-    /**
-     * Permanently tears down the coordinator, cancelling pending renders and removing all listeners.
-     *
-     * @remarks
-     * After calling destroy(), this instance should not be used again. All scheduled renders
-     * are cancelled and all event listeners are removed.
-     *
-     * Safe to call multiple times.
-     */
-    destroy(): void;
-}
-//# sourceMappingURL=SelectionSyncCoordinator.d.ts.map

package/dist/super-editor/src/core/presentation-editor/selection/SelectionSyncCoordinator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SelectionSyncCoordinator.d.ts","sourceRoot":"","sources":["../../../../../../../super-editor/src/core/presentation-editor/selection/SelectionSyncCoordinator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAErD;;GAEG;AACH,MAAM,MAAM,0BAA0B,GAAG;IACvC,gDAAgD;IAChD,QAAQ,EAAE,MAAM,CAAC;IACjB,2EAA2E;IAC3E,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAClC,8FAA8F;IAC9F,MAAM,EAAE,CAAC,0BAA0B,CAAC,CAAC;CACtC,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,0DAA0D;IAC1D,qBAAqB,EAAE,CAAC,EAAE,EAAE,oBAAoB,KAAK,MAAM,CAAC;IAC5D,8DAA8D;IAC9D,oBAAoB,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;CAChD,CAAC;AA4CF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,qBAAa,wBAAyB,SAAQ,YAAY,CAAC,qBAAqB,CAAC;;IAU/E;;;;;OAKG;gBACS,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,sBAAsB,CAAA;KAAE;IAK5D;;;;OAIG;IACH,WAAW,IAAI,MAAM;IAIrB;;;;OAIG;IACH,cAAc,IAAI,MAAM;IAIxB;;;;OAIG;IACH,gBAAgB,IAAI,OAAO;IAI3B;;;;;;;;;;;;OAYG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAQhC;;;;;;;;;OASG;IACH,aAAa,IAAI,IAAI;IAMrB;;;;;;;;;;;;;;OAcG;IACH,gBAAgB,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;IAQ3C;;;;;;;;OAQG;IACH,aAAa,IAAI,IAAI;IAKrB;;;;;;;;;;;;;;OAcG;IACH,aAAa,CAAC,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI;IAQtD;;;;;;;;;;;;;;OAcG;IACH,QAAQ,IAAI,IAAI;IAShB;;;;;;;;OAQG;IACH,OAAO,IAAI,IAAI;CAqChB"}

package/dist/super-editor/src/core/presentation-editor/selection/SelectionVirtualizationPins.d.ts

@@ -1,20 +0,0 @@
-import { FlowBlock, Layout, Measure } from '@superdoc/contracts';
-export type SelectionLike = {
-    from: number;
-    to: number;
-    anchor?: number;
-    head?: number;
-};
-export declare function computeSelectionVirtualizationPins(options: {
-    layout: Layout;
-    blocks: FlowBlock[];
-    measures: Measure[];
-    selection: SelectionLike | null;
-    docSize: number | null;
-    includeDragBuffer: boolean;
-    isDragging: boolean;
-    dragAnchorPageIndex: number | null;
-    dragLastHitPageIndex: number | null;
-    extraPages?: number[];
-}): number[];
-//# sourceMappingURL=SelectionVirtualizationPins.d.ts.map

package/dist/super-editor/src/core/presentation-editor/selection/SelectionVirtualizationPins.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SelectionVirtualizationPins.d.ts","sourceRoot":"","sources":["../../../../../../../super-editor/src/core/presentation-editor/selection/SelectionVirtualizationPins.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAGtE,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,wBAAgB,kCAAkC,CAAC,OAAO,EAAE;IAC1D,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,SAAS,EAAE,aAAa,GAAG,IAAI,CAAC;IAChC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,iBAAiB,EAAE,OAAO,CAAC;IAC3B,UAAU,EAAE,OAAO,CAAC;IACpB,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,oBAAoB,EAAE,MAAM,GAAG,IAAI,CAAC;IACpC,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;CACvB,GAAG,MAAM,EAAE,CA2CX"}

package/dist/super-editor/src/core/presentation-editor/tables/TableCaretDomGeometry.d.ts

@@ -1,14 +0,0 @@
-import { TableBlock, TableFragment, TableMeasure } from '@superdoc/contracts';
-export type TableCaretLayoutRect = {
-    pageIndex: number;
-    x: number;
-    y: number;
-    height: number;
-};
-export type ComputeTableCaretLayoutRectDeps = {
-    viewportHost: HTMLElement;
-    visibleHost: HTMLElement;
-    zoom: number;
-};
-export declare function computeTableCaretLayoutRectFromDom({ viewportHost, visibleHost, zoom }: ComputeTableCaretLayoutRectDeps, pos: number, _fragment: TableFragment, _tableBlock: TableBlock, _tableMeasure: TableMeasure, pageIndex: number): TableCaretLayoutRect | null;
-//# sourceMappingURL=TableCaretDomGeometry.d.ts.map

package/dist/super-editor/src/core/presentation-editor/tables/TableCaretDomGeometry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"TableCaretDomGeometry.d.ts","sourceRoot":"","sources":["../../../../../../../super-editor/src/core/presentation-editor/tables/TableCaretDomGeometry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAEnF,MAAM,MAAM,oBAAoB,GAAG;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAE/F,MAAM,MAAM,+BAA+B,GAAG;IAC5C,YAAY,EAAE,WAAW,CAAC;IAC1B,WAAW,EAAE,WAAW,CAAC;IACzB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,wBAAgB,kCAAkC,CAChD,EAAE,YAAY,EAAE,WAAW,EAAE,IAAI,EAAE,EAAE,+BAA+B,EACpE,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,aAAa,EACxB,WAAW,EAAE,UAAU,EACvB,aAAa,EAAE,YAAY,EAC3B,SAAS,EAAE,MAAM,GAChB,oBAAoB,GAAG,IAAI,CA0E7B"}

package/dist/super-editor/src/core/presentation-editor/tables/TableSelectionUtilities.d.ts

@@ -1,158 +0,0 @@
-import { Node as ProseMirrorNode } from 'prosemirror-model';
-import { FlowBlock, Layout, Measure } from '@superdoc/contracts';
-import { PageGeometryHelper, TableHitResult } from '@superdoc/layout-bridge';
-/**
- * Calculates the ProseMirror document position for a table cell identified by a hit test result.
- *
- * This function traverses the ProseMirror document tree to locate the table node corresponding
- * to the hit result, then navigates through the table structure (accounting for colspan) to find
- * the exact position of the target cell.
- *
- * @param tableHit - Hit test result containing the table block ID and cell coordinates
- * @param doc - ProseMirror document node to search within
- * @param blocks - Array of layout blocks used to locate the target table
- * @returns The document position at the start of the target cell, or null if not found
- *
- * @remarks
- * This function handles several edge cases:
- * - Validates all input parameters and cell indices for safety
- * - Accounts for colspan when calculating logical column positions
- * - Returns null if the table or cell cannot be located
- * - Logs warnings for invalid inputs to aid debugging
- *
- * The position returned is at the start of the cell node (before any cell content).
- * Table structure: table > tableRow > tableCell
- *
- * @example
- * ```typescript
- * const tableHit = hitTestTable(layout, blocks, measures, x, y, ...);
- * if (tableHit) {
- *   const cellPos = getCellPosFromTableHit(tableHit, doc, blocks);
- *   if (cellPos !== null) {
- *     // Use cellPos to create a selection or perform operations
- *   }
- * }
- * ```
- */
-export declare function getCellPosFromTableHit(tableHit: TableHitResult, doc: ProseMirrorNode | null, blocks: FlowBlock[]): number | null;
-/**
- * Retrieves the ProseMirror document position for the start of a table identified by a hit test result.
- *
- * This function locates the table node in the document by matching the table block ID from the
- * hit test result against the layout blocks array.
- *
- * @param tableHit - Hit test result containing the table block ID
- * @param doc - ProseMirror document node to search within
- * @param blocks - Array of layout blocks used to locate the target table
- * @returns The document position at the start of the table node, or null if not found
- *
- * @remarks
- * Unlike getCellPosFromTableHit, this function returns the position of the table node itself,
- * not a specific cell within it. This is useful for operations that need to reference the
- * entire table structure.
- *
- * The position returned is at the start of the table node (before the first row).
- *
- * @example
- * ```typescript
- * const tableHit = hitTestTable(layout, blocks, measures, x, y, ...);
- * if (tableHit) {
- *   const tablePos = getTablePosFromHit(tableHit, doc, blocks);
- *   if (tablePos !== null) {
- *     const tableNode = doc.nodeAt(tablePos);
- *     // Perform table-level operations
- *   }
- * }
- * ```
- */
-export declare function getTablePosFromHit(tableHit: TableHitResult, doc: ProseMirrorNode | null, blocks: FlowBlock[]): number | null;
-/**
- * Determines whether cell selection mode should be used based on the current drag state and position.
- *
- * This function implements the state machine logic for transitioning between regular text selection
- * and table cell selection during pointer interactions. It handles cases where the user drags within
- * a table, across cell boundaries, or outside the table entirely.
- *
- * @param currentTableHit - Current hit test result, or null if pointer is outside any table
- * @param cellAnchor - The cell where the drag started, or null if not dragging from a table cell
- * @param cellDragMode - Current drag mode state: 'none', 'pending', or 'active'
- * @returns True if cell selection should be used, false for regular text selection
- *
- * @remarks
- * The function implements the following logic:
- * - Returns false if no cell anchor exists (drag didn't start in a table)
- * - Returns true if drag mode is active and pointer is outside any table (preserves last cell selection)
- * - Returns true if drag mode is active and pointer is in a different table (preserves last cell selection)
- * - Returns true if the pointer has crossed a cell boundary within the same table
- * - Returns true if drag mode is active and pointer is still in the same cell
- * - Returns false otherwise (same cell, pending mode)
- *
- * This enables a smooth user experience where cell selection activates when crossing cell boundaries
- * and persists when dragging outside the table.
- *
- * @example
- * ```typescript
- * if (shouldUseCellSelection(currentTableHit, cellAnchor, cellDragMode)) {
- *   // Use CellSelection for multi-cell selection
- *   const cellSelection = createCellSelection(...);
- * } else {
- *   // Use TextSelection for normal selection
- *   const textSelection = createTextSelection(...);
- * }
- * ```
- */
-export declare function shouldUseCellSelection(currentTableHit: TableHitResult | null, cellAnchor: {
-    tableBlockId: string;
-    cellRowIndex: number;
-    cellColIndex: number;
-} | null, cellDragMode: 'none' | 'pending' | 'active'): boolean;
-/**
- * Performs hit testing to determine which table cell (if any) is at the given coordinates.
- *
- * This function combines page-level hit testing with table fragment hit testing to accurately
- * identify the table cell at a specific point in the document. It handles multi-page tables,
- * page virtualization, and provides fallback logic when geometry helpers are unavailable.
- *
- * @param layout - Current layout state containing pages and fragments
- * @param blocks - Array of layout blocks (tables, paragraphs, etc.)
- * @param measures - Array of measurement data corresponding to blocks
- * @param normalizedX - X coordinate in document space (not page-relative)
- * @param normalizedY - Y coordinate in document space (not page-relative)
- * @param configuredPageHeight - Configured page height from layout options
- * @param pageGapFallback - Gap between pages when layout.pageGap is not available
- * @param geometryHelper - Optional helper for efficient page geometry queries
- * @returns Hit test result with table block ID and cell coordinates, or null if no table hit
- *
- * @remarks
- * The function performs a two-stage hit test:
- * 1. Identify which page contains the coordinates (using geometryHelper or manual scan)
- * 2. Convert to page-relative coordinates and delegate to hitTestTableFragment
- *
- * The geometryHelper (when available) provides optimized page lookups for better performance.
- * If unavailable, the function falls back to a linear scan through all pages.
- *
- * Coordinate systems:
- * - Input coordinates (normalizedX, normalizedY) are in document space (absolute from top)
- * - Converted to page-relative coordinates before table fragment hit testing
- * - Page heights and gaps account for multi-page layout
- *
- * @example
- * ```typescript
- * const tableHit = hitTestTable(
- *   layout,
- *   blocks,
- *   measures,
- *   event.clientX,
- *   event.clientY,
- *   792,
- *   20,
- *   geometryHelper
- * );
- *
- * if (tableHit) {
- *   console.log(`Hit cell [${tableHit.cellRowIndex}, ${tableHit.cellColIndex}]`);
- * }
- * ```
- */
-export declare function hitTestTable(layout: Layout | null, blocks: FlowBlock[], measures: Measure[], normalizedX: number, normalizedY: number, configuredPageHeight: number, pageGapFallback: number, geometryHelper: PageGeometryHelper | null): TableHitResult | null;
-//# sourceMappingURL=TableSelectionUtilities.d.ts.map

package/dist/super-editor/src/core/presentation-editor/tables/TableSelectionUtilities.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"TableSelectionUtilities.d.ts","sourceRoot":"","sources":["../../../../../../../super-editor/src/core/presentation-editor/tables/TableSelectionUtilities.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,IAAI,IAAI,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACjE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AACtE,OAAO,EAEL,KAAK,kBAAkB,EAEvB,KAAK,cAAc,EACpB,MAAM,yBAAyB,CAAC;AAEjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,cAAc,EACxB,GAAG,EAAE,eAAe,GAAG,IAAI,EAC3B,MAAM,EAAE,SAAS,EAAE,GAClB,MAAM,GAAG,IAAI,CA+Gf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,cAAc,EACxB,GAAG,EAAE,eAAe,GAAG,IAAI,EAC3B,MAAM,EAAE,SAAS,EAAE,GAClB,MAAM,GAAG,IAAI,CAuBf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,sBAAsB,CACpC,eAAe,EAAE,cAAc,GAAG,IAAI,EACtC,UAAU,EAAE;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,EACvF,YAAY,EAAE,MAAM,GAAG,SAAS,GAAG,QAAQ,GAC1C,OAAO,CAyBT;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,MAAM,GAAG,IAAI,EACrB,MAAM,EAAE,SAAS,EAAE,EACnB,QAAQ,EAAE,OAAO,EAAE,EACnB,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,EACnB,oBAAoB,EAAE,MAAM,EAC5B,eAAe,EAAE,MAAM,EACvB,cAAc,EAAE,kBAAkB,GAAG,IAAI,GACxC,cAAc,GAAG,IAAI,CAyCvB"}