oasis-editor 0.0.1

package/dist/ui/app/useCanvasSurfaceHitResolver.d.ts

@@ -0,0 +1,16 @@
+import { Accessor } from '../../solid-js';
+import { EditorLayoutParagraph, EditorState } from '../../../../core/model.js';
+import { SurfaceHit } from '../../../canvas/CanvasHitTestService.js';
+
+export declare function createCanvasSurfaceHitResolver(deps: {
+    state: Accessor<EditorState>;
+    surfaceRef: Accessor<HTMLDivElement | null>;
+    viewportRef: Accessor<HTMLElement | null>;
+    measuredBlockHeights: Accessor<Record<string, number>>;
+    measuredParagraphLayouts: Accessor<Record<string, EditorLayoutParagraph>>;
+    layoutMode: Accessor<"fast" | "wordParity">;
+}): {
+    resolveSurfaceHitAtPoint: (clientX: number, clientY: number, _context?: {
+        forDrag?: boolean;
+    }) => SurfaceHit | null;
+};

package/dist/ui/app/useEditorAppState.d.ts

@@ -0,0 +1,11 @@
+import { EditorDocument, EditorState } from '../../../../core/model.js';
+
+export declare function createEditorAppState(options: {
+    initialDocument?: EditorDocument;
+    initialState?: EditorState;
+}): {
+    state: EditorState;
+    setStateSignal: import('../../solid-js').Setter<EditorState>;
+    commitState: (next: EditorState) => void;
+    getStateSnapshot: () => EditorState;
+};

package/dist/ui/app/useEditorContextMenuClipboard.d.ts

@@ -0,0 +1,33 @@
+import { EditorState } from '../../../../core/model.js';
+import { ContextMenuItem } from '../../../components/ContextMenu/ContextMenu.js';
+import { EditorLogger } from '../../../../utils/logger.js';
+
+interface ContextMenuState {
+    isOpen: boolean;
+    x: number;
+    y: number;
+}
+export interface EditorContextMenuClipboardDeps {
+    state: () => EditorState;
+    isReadOnly: () => boolean;
+    logger: EditorLogger;
+    setContextMenu: (state: ContextMenuState) => void;
+    clearPreferredColumn: () => void;
+    resetTransactionGrouping: () => void;
+    applyTransactionalState: (producer: (current: EditorState) => EditorState, options?: {
+        mergeKey?: string;
+    }) => void;
+    applyTableAwareParagraphEdit: (state: EditorState, edit: (state: EditorState) => EditorState) => EditorState;
+    focusInput: () => void;
+    promptForLink: () => void;
+    openFontDialog: () => void;
+}
+export declare function createEditorContextMenuClipboard(deps: EditorContextMenuClipboardDeps): {
+    buildContextMenuItems: () => ContextMenuItem[];
+    closeContextMenu: () => void;
+    handleEditorContextMenu: (event: MouseEvent) => void;
+    programmaticCopy: () => Promise<void>;
+    programmaticCut: () => Promise<void>;
+    programmaticPaste: () => Promise<void>;
+};
+export {};

package/dist/ui/app/useEditorDialogs.d.ts

@@ -0,0 +1,38 @@
+import { FontDialogInitialValues } from '../../../components/Dialogs/FontDialog.js';
+
+export declare function createEditorDialogs(): {
+    linkDialog: import('../../solid-js').Accessor<{
+        isOpen: boolean;
+        initialHref: string;
+    }>;
+    setLinkDialog: import('../../solid-js').Setter<{
+        isOpen: boolean;
+        initialHref: string;
+    }>;
+    imageAltDialog: import('../../solid-js').Accessor<{
+        isOpen: boolean;
+        initialAlt: string;
+    }>;
+    setImageAltDialog: import('../../solid-js').Setter<{
+        isOpen: boolean;
+        initialAlt: string;
+    }>;
+    contextMenu: import('../../solid-js').Accessor<{
+        isOpen: boolean;
+        x: number;
+        y: number;
+    }>;
+    setContextMenu: import('../../solid-js').Setter<{
+        isOpen: boolean;
+        x: number;
+        y: number;
+    }>;
+    fontDialog: import('../../solid-js').Accessor<{
+        isOpen: boolean;
+        initial: FontDialogInitialValues;
+    }>;
+    setFontDialog: import('../../solid-js').Setter<{
+        isOpen: boolean;
+        initial: FontDialogInitialValues;
+    }>;
+};

package/dist/ui/app/useEditorFocus.d.ts

@@ -0,0 +1,11 @@
+export declare function createEditorFocusController(): {
+    focused: import('../../solid-js').Accessor<boolean>;
+    setFocused: import('../../solid-js').Setter<boolean>;
+    focusInput: () => void;
+    focusInputAfterPointerSelection: () => void;
+    viewportRef: HTMLDivElement | undefined;
+    surfaceRef: HTMLDivElement | undefined;
+    textareaRef: HTMLTextAreaElement | undefined;
+    importInputRef: HTMLInputElement | undefined;
+    imageInputRef: HTMLInputElement | undefined;
+};

package/dist/ui/app/useEditorFontOptions.d.ts

@@ -0,0 +1,17 @@
+import { EditorState } from '../../../../core/model.js';
+import { ToolbarStyleState } from '../../../toolbarStyleState.js';
+
+export interface EditorFontOptionsContext {
+    state: () => EditorState;
+    toolbarStyleState: () => ToolbarStyleState;
+}
+/**
+ * Owns the font-family / font-size option lists offered by the toolbar and font
+ * dialog, including the lazily-loaded local font catalogue. Keeps the local-font
+ * permission probe and its cache signal out of the composition root.
+ */
+export declare function createEditorFontOptions(ctx: EditorFontOptionsContext): {
+    computeFontFamilyOptions: () => string[];
+    computeFontSizeOptions: () => number[];
+    loadLocalFontFamilyOptions: () => Promise<void>;
+};

package/dist/ui/app/useEditorInteractionWiring.d.ts

@@ -0,0 +1,64 @@
+import { EditorState } from '../../../../core/model.js';
+import { EditorLogger } from '../../../../utils/logger.js';
+import { createEditorClipboardController } from '../../../../app/controllers/useEditorClipboard.js';
+import { createEditorTableResize } from '../../../../app/controllers/useEditorTableResize.js';
+import { createEditorTableDrag } from '../../../../app/controllers/useEditorTableDrag.js';
+import { createEditorSurfaceEvents } from '../../../../app/controllers/useEditorSurfaceEvents.js';
+import { createEditorTextInput } from '../../../../app/controllers/useEditorTextInput.js';
+import { createEditorTextDrag } from '../../../../app/controllers/useEditorTextDrag.js';
+import { createEditorNavigation } from '../../../../app/controllers/useEditorNavigation.js';
+import { createEditorRevisionController } from '../../../../app/controllers/useEditorRevision.js';
+import { createEditorTableOperations } from '../../../../app/controllers/useEditorTableOperations.js';
+import { createEditorImageOperations } from '../../../../app/controllers/useEditorImageOperations.js';
+import { createEditorStyleController } from '../../../../app/controllers/useEditorStyle.js';
+
+type TableDragParams = Parameters<typeof createEditorTableDrag>[0];
+type TextDragParams = Parameters<typeof createEditorTextDrag>[0];
+type NavigationParams = Parameters<typeof createEditorNavigation>[0];
+type ClipboardParams = Parameters<typeof createEditorClipboardController>[0];
+/**
+ * Shared kernel + heavy operation controllers consumed by the interaction
+ * (gesture / input / clipboard / navigation) cluster. The heavy controllers
+ * (`tableOps`, `imageOps`, `styleController`) and the surface resolvers are
+ * cross-cutting and stay owned by the composition root; this hook only wires
+ * the pointer/keyboard interaction controllers on top of them.
+ */
+export interface EditorInteractionWiringContext {
+    state: EditorState;
+    applyState: NavigationParams["applyState"];
+    applyTransactionalState: TextDragParams["applyTransactionalState"];
+    isReadOnly: TextDragParams["isReadOnly"];
+    logger: EditorLogger;
+    focusInput: TableDragParams["focusInput"];
+    focusInputAfterPointerSelection: TextDragParams["focusInputAfterPointerSelection"];
+    clearPreferredColumn: TextDragParams["clearPreferredColumn"];
+    resetTransactionGrouping: TextDragParams["resetTransactionGrouping"];
+    surfaceRef: () => HTMLDivElement | undefined;
+    viewportRef: () => HTMLDivElement | undefined;
+    caretBox: NavigationParams["caretBox"];
+    preferredColumnX: NavigationParams["preferredColumnX"];
+    setPreferredColumnX: NavigationParams["setPreferredColumnX"];
+    resolveSurfaceHitAtPoint: TextDragParams["resolveSurfaceHitAtPoint"];
+    resolvePositionAtSurfacePoint: TableDragParams["resolvePositionAtSurfacePoint"];
+    tableOps: ReturnType<typeof createEditorTableOperations>;
+    imageOps: ReturnType<typeof createEditorImageOperations>;
+    styleController: ReturnType<typeof createEditorStyleController>;
+    getForcePlainTextPaste: () => boolean;
+    setForcePlainTextPaste: (value: boolean) => void;
+    insertImageFromFile: ClipboardParams["insertImageFromFile"];
+}
+export interface EditorInteractionWiring {
+    tableResize: ReturnType<typeof createEditorTableResize>;
+    tableDrag: ReturnType<typeof createEditorTableDrag>;
+    revisionController: ReturnType<typeof createEditorRevisionController>;
+    textDrag: ReturnType<typeof createEditorTextDrag>;
+    surfaceEvents: ReturnType<typeof createEditorSurfaceEvents>;
+    textInput: ReturnType<typeof createEditorTextInput>;
+    navigation: ReturnType<typeof createEditorNavigation>;
+    handleCopy: ReturnType<typeof createEditorClipboardController>["handleCopy"];
+    handleCut: ReturnType<typeof createEditorClipboardController>["handleCut"];
+    handlePaste: ReturnType<typeof createEditorClipboardController>["handlePaste"];
+    handleDrop: ReturnType<typeof createEditorClipboardController>["handleDrop"];
+}
+export declare function useEditorInteractionWiring(ctx: EditorInteractionWiringContext): EditorInteractionWiring;
+export {};

package/dist/ui/app/useEditorRuntimeBootstrap.d.ts

@@ -0,0 +1,33 @@
+import { createEditorEssentialsRuntimePlugin } from '../../createEditorEssentialsPlugin.js';
+import { useEditorRuntimePlugins } from '../../useEditorRuntimePlugins.js';
+import { createRuntimeCommandHost } from '../../createRuntimeCommandHost.js';
+
+type EssentialsPluginDeps = Parameters<typeof createEditorEssentialsRuntimePlugin>[0];
+type RuntimePluginsConfig = Parameters<typeof useEditorRuntimePlugins>[0];
+type RuntimeCommandHostConfig = Parameters<typeof createRuntimeCommandHost>[0];
+type RuntimeCommandHost = ReturnType<typeof createRuntimeCommandHost>;
+/**
+ * Bootstraps the plugin runtime: it builds the Essentials plugin, registers all
+ * runtime plugins / the toolbar registry, spins up the command host and owns the
+ * runtime's mount (initialize) and cleanup (dispose) lifecycle. The composition
+ * root only feeds the already-built controllers in and consumes the host facade.
+ */
+export interface EditorRuntimeBootstrapContext {
+    essentials: EssentialsPluginDeps;
+    externalPlugins: RuntimePluginsConfig["externalPlugins"];
+    customizeToolbar: RuntimePluginsConfig["customizeToolbar"];
+    initialDocument: RuntimeCommandHostConfig["initialDocument"];
+    focusEditor: RuntimeCommandHostConfig["focusEditor"];
+    logger: RuntimeCommandHostConfig["logger"];
+    onReady: RuntimeCommandHostConfig["onReady"];
+    onSettled: RuntimeCommandHostConfig["onSettled"];
+}
+export interface EditorRuntimeBootstrap {
+    toolbarRegistry: ReturnType<typeof useEditorRuntimePlugins>["toolbarRegistry"];
+    runtimeReady: RuntimeCommandHost["runtimeReady"];
+    runtimeEditor: RuntimeCommandHost["runtimeEditor"];
+    commandStateOf: RuntimeCommandHost["commandStateOf"];
+    toolbarHost: RuntimeCommandHost["toolbarHost"];
+}
+export declare function useEditorRuntimeBootstrap(ctx: EditorRuntimeBootstrapContext): EditorRuntimeBootstrap;
+export {};

package/dist/ui/app/useEditorRuntimePlugins.d.ts

@@ -0,0 +1,14 @@
+import { OasisPlugin } from '../../../../core/plugin.js';
+import { ToolbarRegistry } from '../../../components/Toolbar/registry/ToolbarRegistry.js';
+
+export interface EditorRuntimePluginsOptions {
+    essentialsPlugin: OasisPlugin;
+    externalPlugins?: OasisPlugin[];
+    customizeToolbar?: (registry: ToolbarRegistry) => void;
+}
+export interface EditorRuntimePlugins {
+    runtimePlugins: OasisPlugin[];
+    toolbarRegistry: ToolbarRegistry;
+    dispose: () => void;
+}
+export declare function useEditorRuntimePlugins(options: EditorRuntimePluginsOptions): EditorRuntimePlugins;

package/dist/ui/app/useEditorTransactions.d.ts

@@ -0,0 +1,20 @@
+import { EditorState } from '../../../../core/model.js';
+import { EditorHistoryState, EditorTransactionOptions } from '../../../editorHistory.js';
+import { LayoutInvalidation } from '../../../../app/controllers/useEditorLayout.js';
+
+export interface EditorTransactionsContext {
+    stateSnapshot: () => EditorState;
+    commitState: (state: EditorState) => void;
+    cloneState: (state: EditorState) => EditorState;
+    applyLayoutInvalidation: (invalidation: LayoutInvalidation) => void;
+}
+export declare function useEditorTransactions(ctx: EditorTransactionsContext): {
+    undoStack: import('../../solid-js').Accessor<EditorState[]>;
+    redoStack: import('../../solid-js').Accessor<EditorState[]>;
+    applyTransactionalState: (producer: (current: EditorState) => EditorState, options?: EditorTransactionOptions) => void;
+    applyHistoryState: (nextState: EditorState) => void;
+    resetTransactionGrouping: () => void;
+    updateHistoryState: (updater: (current: EditorHistoryState) => EditorHistoryState) => void;
+    getHistoryState: () => EditorHistoryState;
+    clearHistory: () => void;
+};

package/dist/ui/app/useEditorUiOptions.d.ts

@@ -0,0 +1,24 @@
+import { InlineShell } from '../../../shells/InlineShell.js';
+import { OasisEditorAppDocumentProps, OasisEditorAppUiProps, OasisEditorLoadingOptions } from '../../../OasisEditorAppProps.js';
+
+export interface EditorUiOptionsContext {
+    ui: () => OasisEditorAppUiProps;
+    documentOptions: () => OasisEditorAppDocumentProps;
+}
+/**
+ * Resolves the editor's UI/document option accessors, applying defaults in one
+ * place so the composition root doesn't carry a dozen `?? default` getters.
+ */
+export declare function createEditorUiOptions(ctx: EditorUiOptionsContext): {
+    showChrome: () => boolean;
+    showTitleBar: () => boolean;
+    showMenubar: () => boolean;
+    showToolbar: () => boolean;
+    showOutline: () => boolean;
+    layoutMode: () => "fast" | "wordParity";
+    isReadOnly: () => boolean;
+    useComposedShell: () => boolean;
+    loadingOptions: () => OasisEditorLoadingOptions | undefined;
+    loadingLabel: () => string;
+    shellComponent: () => typeof InlineShell;
+};

package/dist/ui/app/useFontDialogBridge.d.ts

@@ -0,0 +1,31 @@
+import { EditorSelection, EditorState } from '../../../../core/model.js';
+import { FontDialogApplyValues, FontDialogInitialValues } from '../../../components/Dialogs/FontDialog.js';
+import { ToolbarStyleState } from '../../../toolbarStyleState.js';
+
+interface FontDialogState {
+    isOpen: boolean;
+    initial: FontDialogInitialValues;
+}
+export interface FontDialogBridgeDeps {
+    toolbarStyleState: () => ToolbarStyleState;
+    selection: () => EditorSelection;
+    isReadOnly: () => boolean;
+    loadLocalFontFamilyOptions: () => Promise<void>;
+    setFontDialog: (state: FontDialogState) => void;
+    setContextMenu: (state: {
+        isOpen: boolean;
+        x: number;
+        y: number;
+    }) => void;
+    clearPreferredColumn: () => void;
+    resetTransactionGrouping: () => void;
+    applyTransactionalState: (producer: (current: EditorState) => EditorState, options?: {
+        mergeKey?: string;
+    }) => void;
+    focusInput: () => void;
+}
+export declare function createFontDialogBridge(deps: FontDialogBridgeDeps): {
+    openFontDialog: () => void;
+    applyFontDialogValues: (values: FontDialogApplyValues, original: FontDialogInitialValues) => void;
+};
+export {};

package/dist/ui/canvas/CanvasDebug.d.ts

@@ -0,0 +1,125 @@
+import { SurfaceHit } from '../../CanvasHitTestService.js';
+import { CanvasLayoutSnapshot, CanvasSnapshotParagraph } from '../../CanvasLayoutSnapshot.js';
+import { EditorEditingZone, EditorState } from '../../../../core/model.js';
+
+export interface CanvasDebugMissEvent {
+    timestamp: number;
+    reason: string;
+    clientX: number;
+    clientY: number;
+}
+export interface CanvasDebugHitSnapshot {
+    timestamp: number;
+    zone: SurfaceHit["zone"];
+    paragraphId: string;
+    paragraphOffset: number;
+    source: SurfaceHit["source"];
+    missReason?: string;
+    resolvedFromParagraph: boolean;
+}
+export interface CanvasDebugLayoutSnapshot {
+    surfaceRect: {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    };
+    pages: Array<{
+        index: number;
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+        bodyTop: number;
+        bodyBottom: number;
+    }>;
+    paragraphs: Array<{
+        paragraphId: string;
+        paragraphIndex: number;
+        zone: CanvasSnapshotParagraph["zone"];
+        pageIndex: number;
+        startOffset: number;
+        endOffset: number;
+        textLength: number;
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+        lines: Array<{
+            startOffset: number;
+            endOffset: number;
+            top: number;
+            height: number;
+            slots: Array<{
+                offset: number;
+                left: number;
+                top: number;
+                height: number;
+            }>;
+        }>;
+        tableCell?: {
+            tableId: string;
+            rowIndex: number;
+            cellIndex: number;
+            left: number;
+            top: number;
+            width: number;
+            height: number;
+        };
+    }>;
+    inlineImages: Array<{
+        paragraphId: string;
+        paragraphIndex: number;
+        zone: EditorEditingZone;
+        pageIndex: number;
+        startOffset: number;
+        endOffset: number;
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    }>;
+    unsupportedRegions: Array<{
+        pageIndex: number;
+        zone: EditorEditingZone;
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+        reason: string;
+    }>;
+}
+export interface OasisCanvasDebugApi {
+    getLastHit: () => CanvasDebugHitSnapshot | null;
+    getLayoutSnapshot: () => CanvasDebugLayoutSnapshot | null;
+    getSelection: () => CanvasDebugSelectionSnapshot | null;
+    getMissEvents: () => CanvasDebugMissEvent[];
+    clearMissEvents: () => void;
+}
+declare global {
+    interface Window {
+        __oasisCanvasDebug?: OasisCanvasDebugApi;
+    }
+}
+export interface CanvasDebugSelectionSnapshot {
+    anchor: {
+        paragraphId: string;
+        runId: string;
+        offset: number;
+    };
+    focus: {
+        paragraphId: string;
+        runId: string;
+        offset: number;
+    };
+    activeZone: EditorEditingZone;
+    activeSectionIndex: number;
+}
+export declare function syncCanvasDebugApiVisibility(): void;
+export declare function recordCanvasDebugHit(hit: SurfaceHit | null): void;
+export declare function recordCanvasDebugLayoutSnapshot(snapshot: CanvasLayoutSnapshot | null): void;
+export declare function recordCanvasDebugSelection(state: EditorState): void;
+export declare function recordCanvasDebugMissEvent(reason: string, details: {
+    clientX: number;
+    clientY: number;
+}): void;

package/dist/ui/canvas/CanvasGeometry.d.ts

@@ -0,0 +1,35 @@
+import { EditorPosition } from '../../../../core/model.js';
+import { CanvasLayoutSnapshot, CanvasSnapshotParagraph } from '../../CanvasLayoutSnapshot.js';
+
+export interface CanvasRectLike {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+    width: number;
+    height: number;
+}
+export interface CanvasCharRect {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+    height: number;
+}
+export declare function getParagraphEntries(snapshot: CanvasLayoutSnapshot, paragraphId: string): CanvasSnapshotParagraph[];
+export declare function getParagraphRectFromSnapshot(snapshot: CanvasLayoutSnapshot, paragraphId: string, boundary?: "start" | "end"): CanvasRectLike | null;
+export declare function getCaretRectFromSnapshot(snapshot: CanvasLayoutSnapshot, position: EditorPosition, paragraphOffset: number): CanvasRectLike | null;
+/**
+ * Equivalent to the legacy `collectParagraphCharRects` but derived entirely
+ * from the canvas snapshot. Returns one rect per visual character slot in
+ * paragraph order (across page splits when a paragraph spans multiple pages).
+ */
+export declare function collectParagraphCharRectsFromSnapshot(snapshot: CanvasLayoutSnapshot, paragraphId: string): CanvasCharRect[];
+/**
+ * Resolves the absolute viewport `y` for the first/last line of a paragraph
+ * (used by Outline / DocumentShell scroll-to-paragraph).
+ */
+export declare function getParagraphScrollAnchor(snapshot: CanvasLayoutSnapshot, paragraphId: string): {
+    left: number;
+    top: number;
+} | null;

package/dist/ui/canvas/CanvasHitTestService.d.ts

@@ -0,0 +1,37 @@
+import { EditorEditingZone, EditorPosition, EditorState } from '../../../../core/model.js';
+import { CanvasLayoutSnapshot } from '../../CanvasLayoutSnapshot.js';
+
+export interface SurfaceHitImage {
+    paragraphId: string;
+    paragraphOffset: number;
+    startOffset: number;
+    endOffset: number;
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+export interface SurfaceHit {
+    zone: EditorEditingZone;
+    footnoteId?: string;
+    paragraphId: string;
+    paragraphOffset: number;
+    position: EditorPosition;
+    source: "canvas-layout";
+    missReason?: string;
+    resolvedFromParagraph: boolean;
+    tableCellAnchorPosition?: EditorPosition;
+    caretViewport?: {
+        left: number;
+        top: number;
+        height: number;
+    };
+    image?: SurfaceHitImage;
+}
+export interface ResolveCanvasHitOptions {
+    snapshot: CanvasLayoutSnapshot;
+    state: EditorState;
+    clientX: number;
+    clientY: number;
+}
+export declare function resolveCanvasSurfaceHitAtPoint(options: ResolveCanvasHitOptions): SurfaceHit | null;

package/dist/ui/canvas/CanvasLayoutSnapshot.d.ts

@@ -0,0 +1,93 @@
+import { EditorEditingZone, EditorLayoutParagraph, EditorParagraphNode, EditorPosition, EditorState } from '../../../../core/model.js';
+import { CanvasUnsupportedReason } from '../../CanvasTableLayout.js';
+
+export interface CanvasSnapshotSlot {
+    offset: number;
+    left: number;
+    top: number;
+    height: number;
+}
+export interface CanvasSnapshotLine {
+    startOffset: number;
+    endOffset: number;
+    top: number;
+    height: number;
+    slots: CanvasSnapshotSlot[];
+}
+export interface CanvasSnapshotTableCellInfo {
+    tableId: string;
+    rowIndex: number;
+    cellIndex: number;
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    anchorPosition: EditorPosition;
+}
+export interface CanvasSnapshotParagraph {
+    paragraph: EditorParagraphNode;
+    paragraphId: string;
+    paragraphIndex: number;
+    zone: EditorEditingZone;
+    footnoteId?: string;
+    pageIndex: number;
+    startOffset: number;
+    endOffset: number;
+    textLength: number;
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    lines: CanvasSnapshotLine[];
+    tableCell?: CanvasSnapshotTableCellInfo;
+}
+export interface CanvasSnapshotInlineImage {
+    paragraphId: string;
+    paragraphIndex: number;
+    zone: EditorEditingZone;
+    footnoteId?: string;
+    pageIndex: number;
+    startOffset: number;
+    endOffset: number;
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+export interface CanvasSnapshotPage {
+    index: number;
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    bodyTop: number;
+    bodyBottom: number;
+    footerTop?: number;
+    footnoteTop?: number;
+    footnoteSeparatorTop?: number;
+}
+export interface CanvasLayoutSnapshot {
+    surfaceRect: DOMRect;
+    pages: CanvasSnapshotPage[];
+    paragraphs: CanvasSnapshotParagraph[];
+    paragraphsById: Map<string, CanvasSnapshotParagraph[]>;
+    inlineImages: CanvasSnapshotInlineImage[];
+    unsupportedRegions: Array<{
+        pageIndex: number;
+        zone: EditorEditingZone;
+        footnoteId?: string;
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+        reason: CanvasUnsupportedReason;
+    }>;
+}
+export interface BuildCanvasLayoutSnapshotOptions {
+    surface: HTMLElement;
+    state: EditorState;
+    measuredBlockHeights?: Record<string, number>;
+    measuredParagraphLayouts?: Record<string, EditorLayoutParagraph>;
+    layoutMode?: "fast" | "wordParity";
+}
+export declare function buildCanvasLayoutSnapshot(options: BuildCanvasLayoutSnapshotOptions): CanvasLayoutSnapshot | null;

package/dist/ui/canvas/CanvasSelectionGeometry.d.ts

@@ -0,0 +1,20 @@
+import { EditorState } from '../../../../core/model.js';
+import { CaretBox, InputBox, SelectionBox } from '../../../editorUiTypes.js';
+import { CanvasLayoutSnapshot } from '../../CanvasLayoutSnapshot.js';
+
+export interface SelectedImageSelectionBox {
+    paragraphId: string;
+    startOffset: number;
+    endOffset: number;
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+export interface CanvasSelectionGeometryResult {
+    selectionBoxes: SelectionBox[];
+    caretBox: CaretBox;
+    inputBox: InputBox;
+    selectedImageBox: SelectedImageSelectionBox | null;
+}
+export declare function computeCanvasSelectionGeometry(snapshot: CanvasLayoutSnapshot, state: EditorState): CanvasSelectionGeometryResult;