smartrte-core 0.2.1 → 1.0.0-beta.2

package/dist/foundation/surface/index.js

@@ -0,0 +1,3 @@
+export * from "./types.js";
+export { createSubtreeRenderer, FoundationSubtreeRenderer } from "./renderer.js";
+export { createInputPipeline, FoundationInputPipeline } from "./input.js";

package/dist/foundation/surface/input.d.ts

@@ -0,0 +1,127 @@
+import { type FoundationEditor } from "../editor.js";
+import type { CanonicalInputPipeline, CanonicalSubtreeRenderer } from "./types.js";
+import type { CanonicalInputPipelineOptions } from "./types.js";
+export declare class FoundationInputPipeline implements CanonicalInputPipeline {
+    readonly editor: FoundationEditor;
+    readonly renderer: CanonicalSubtreeRenderer;
+    private readonly root;
+    private readonly options;
+    private composition;
+    private readonly unhandled;
+    private readonly ownerDocument;
+    private destroyed;
+    private internalDrag;
+    private tableDragAnchor;
+    private trackChanges;
+    constructor(editor: FoundationEditor, renderer: CanonicalSubtreeRenderer, root: HTMLElement, options?: CanonicalInputPipelineOptions);
+    get unhandledInputTypes(): readonly string[];
+    private beforeInputListener;
+    private keyDownListener;
+    private compositionStartListener;
+    private compositionUpdateListener;
+    private compositionEndListener;
+    private tableMouseDownListener;
+    private tableMouseUpListener;
+    private clickListener;
+    private selectionChangeListener;
+    private pasteListener;
+    private copyListener;
+    private cutListener;
+    private dragStartListener;
+    private dropListener;
+    private cellFromNode;
+    private payloadFromTransfer;
+    private writeTransfer;
+    private selectionForPoint;
+    private commitClipboard;
+    handleCopy(event: ClipboardEvent): void;
+    handleCut(event: ClipboardEvent): void;
+    handlePaste(event: ClipboardEvent): void;
+    private handleDragStart;
+    handleDrop(event: DragEvent): void;
+    private commit;
+    private commandContext;
+    private commitStructuralResult;
+    /** First content-bearing child of a table cell, or the cell itself if somehow childless. */
+    private firstOwnerOf;
+    /**
+     * Tab/Shift+Tab cell-to-cell navigation (Phase 11 Tier 2 - previously
+     * "Tables own Tab navigation" was just a bare `return`, a genuinely
+     * missing feature, not a missing test). `grid.anchors` is already in
+     * reading order, so stepping ±1 through it is next/previous cell;
+     * stepping past the last cell appends a row via insertTableRowCommand and
+     * lands in its first cell, matching the reference precedent Tab already
+     * uses for a list item with no legal indent - always claim the key.
+     */
+    private handleTableTab;
+    /**
+     * Every prefix of a valid SmartPos.path addresses a real ancestor node
+     * (the same property ownerAt already relies on), so walking path prefixes
+     * from longest to shortest finds the nearest enclosing table_cell/table
+     * without any DOM lookup - the model-level equivalent of cellFromNode,
+     * usable from a plain SmartPos rather than a DOM event target.
+     */
+    private tableAncestorsAt;
+    /**
+     * Shift+Arrow rectangular cell-selection expansion (Phase 11 Tier 2 -
+     * previously no table-grid branch existed anywhere in arrow-key handling
+     * at all). Returns false when not applicable (anchor/head aren't both in
+     * the same table), letting the caller fall through to ordinary text-range
+     * arrow handling unchanged. Steps from the head cell's own top-left
+     * anchor corner - a reasonable v1 simplification for merged-cell edges,
+     * matching the existing renderer projection's own merge-snapping
+     * (surface/renderer.ts's syncCellSelectionProjection already snaps
+     * whatever rect the model selection implies through merged cells on
+     * render, so this does not need to duplicate that snapping here).
+     */
+    private handleTableShiftArrow;
+    private replaceSelection;
+    /**
+     * Ambient track-changes mode (Phase 12a §2.3 follow-up, 2026-08-25):
+     * typed text becomes a real, live "insert"-kind suggestion mark instead
+     * of a plain insertText, and content it replaces is marked "delete"
+     * instead of actually removed - the same reviewable-suggestion contract
+     * as the explicit Suggest deletion/Suggest insertion toolbar actions,
+     * just applied automatically to ordinary typing. Scoped to a selection
+     * that's collapsed or fully within one inline owner; returns null for a
+     * selection crossing multiple paragraphs, so the caller falls through to
+     * the real (non-suggested) path - proposing a delete that spans several
+     * paragraphs plus an insert needs per-owner handling this pass doesn't
+     * build (see docs/PHASE_ROADMAP_8B_12B.md's Phase 12a status note).
+     */
+    private suggestReplaceSelection;
+    /**
+     * True exactly when queueRangeDeletion's own same-parent forward-sibling
+     * path can handle this range (see its cross-parent/type/order checks,
+     * which this mirrors) - i.e. the two endpoints are different children of
+     * the very same parent, with compatible owner types, in forward order.
+     * Deliberately does not attempt to be more permissive than
+     * queueRangeDeletion itself; anything this returns false for keeps
+     * falling through to structuralDeletionPlan exactly as before.
+     */
+    private canMergeAsSiblings;
+    private deleteRange;
+    /**
+     * Block atoms have no legal internal caret. When the browser reports a
+     * structural boundary beside one (including a node selection's head), move
+     * to the nearest editable block instead of manufacturing a position inside
+     * the atom. If the atom is at a container edge, create the empty paragraph
+     * that gives the user a real line to continue typing on.
+     */
+    private moveFromStructuralBoundary;
+    private insertParagraph;
+    private insertLineBreak;
+    private deleteByInputType;
+    private deleteAcrossBlock;
+    handleBeforeInput(event: InputEvent): void;
+    private moveCaret;
+    handleKeyDown(event: KeyboardEvent): void;
+    handleCompositionStart(_event: CompositionEvent): void;
+    /** DOM remains authoritative; updates are intentionally observed, not rendered. */
+    handleCompositionUpdate(_event: CompositionEvent): void;
+    handleCompositionEnd(_event: CompositionEvent): void;
+    setTrackChanges(enabled: boolean, authorId?: string): void;
+    syncSelectionFromDom(): void;
+    destroy(): void;
+}
+export declare const createInputPipeline: (editor: FoundationEditor, renderer: CanonicalSubtreeRenderer, root: HTMLElement, options?: CanonicalInputPipelineOptions) => CanonicalInputPipeline;