@sobree/core 0.1.27 → 0.1.28

package/dist/editor/internal/readbackMerge.d.ts

@@ -0,0 +1,27 @@
+import { Block } from '../../doc/types';
+/**
+ * Merge a freshly DOM-serialised body into the previous AST body, preserving
+ * everything the contentEditable DOM can't represent.
+ *
+ * The DOM is a LOSSY projection of the AST: it carries run text and inline
+ * marks (bold, colour, font), but NOT block-level properties — paragraph
+ * spacing / indent / borders, table style-id / look / cell margins,
+ * section-break targets. A text edit changes a block's CONTENT, never those
+ * properties, so re-deriving the whole AST from the DOM on every keystroke
+ * silently strips them — the document degrades a little with each edit and
+ * falls apart on the first re-render (undo / redo / remote).
+ *
+ * So we keep each previous block and overlay only the re-read content: runs
+ * for a paragraph, cell content for a table. Properties survive.
+ *
+ * Matching a re-read block to its previous block is by stable id (the
+ * renderer's `data-block-id`), resolved by the caller — so properties
+ * survive structural edits too (Enter / Backspace / paste / reorder), not
+ * just same-length typing. A re-read block with no prior match (a freshly
+ * inserted block) keeps the DOM block as-is. Falls back to the DOM block
+ * whenever kinds or nested shape diverge: structure is the one thing the
+ * DOM IS authoritative about.
+ */
+export declare function mergeReadbackBlocks(next: readonly Block[], resolvePrev: (index: number) => Block | undefined): Block[];
+/** Positional convenience wrapper: match each block to `prev[i]`. */
+export declare function mergeReadbackPreservingProps(prev: readonly Block[], next: readonly Block[]): Block[];

package/dist/editor/view/docSerialize/block.d.ts

@@ -10,6 +10,17 @@ export interface BlockSerializeContext {
         numId: number;
         ordered: boolean;
     } | null;
+    /**
+     * Running count of section breaks seen so far (across all hosts). The Nth
+     * section break transitions to section N — matching the renderer's
+     * order-based section assignment — so the count IS the break's
+     * `toSectionIndex`. Reconstructing it is load-bearing: the renderer reads
+     * a break's page-break-vs-continuous behaviour from `sections[toSectionIndex]`,
+     * so a wrong index (e.g. a hardcoded 0) makes a continuous break re-render
+     * as a forced page break, exploding the layout on the next re-render
+     * (undo/redo/remote).
+     */
+    sectionBreaks: number;
     /**
      * Capture each paragraph's effective base run style (from the rendered
      * `<p>`'s inline font) into `ParagraphProperties.runDefaults`.
@@ -25,5 +36,15 @@ export interface BlockSerializeContext {
      * styles, which must stay style-linked across edits.
      */
     captureRunDefaults?: boolean;
+    /**
+     * Optional sink for each emitted block's source DOM element (or `null`
+     * for a bare text node), kept strictly parallel to the returned blocks.
+     * The editor reads each element's stable `data-block-id` to match a
+     * re-read block back to its previous AST block — so block-level
+     * properties (spacing, table style, …) survive a read-back across plain
+     * typing AND structural edits, where positional matching can't. Left
+     * unset for callers that don't need provenance (frame read-back, tests).
+     */
+    sources?: (HTMLElement | null)[];
 }
 export declare function blocksFromNodes(nodes: readonly Node[], ctx: BlockSerializeContext): Block[];

package/dist/editor/view/docSerialize/index.d.ts

@@ -15,3 +15,15 @@ export interface SerializeHostsOptions {
     captureRunDefaults?: boolean;
 }
 export declare function serializeHostsToDocument(hosts: readonly HTMLElement[], options?: SerializeHostsOptions): SobreeDocument;
+/**
+ * Like {@link serializeHostsToDocument}, but also returns each block's
+ * source DOM element (parallel to `document.body`, `null` for bare text
+ * nodes). The editor reads each element's stable `data-block-id` to match a
+ * re-read block back to its previous AST block — so block-level properties
+ * the contentEditable DOM can't carry survive the read-back across plain
+ * typing AND structural edits (Enter / Backspace / paste / reorder).
+ */
+export declare function serializeHostsWithSources(hosts: readonly HTMLElement[], options?: SerializeHostsOptions): {
+    document: SobreeDocument;
+    sources: (HTMLElement | null)[];
+};