react-native-enriched-markdown-scaffold 0.7.4-scaffold.9 → 1.0.2-scaffold.2

package/android/src/main/java/com/swmansion/enriched/markdown/input/MarkdownClipboard.kt

@@ -0,0 +1,42 @@
+package com.swmansion.enriched.markdown.input
+
+import android.content.ClipData
+import android.content.ClipDescription
+import android.content.ClipboardManager
+import android.content.Context
+import android.os.PersistableBundle
+
+/**
+ * Clipboard round-trip for markdown content, mirroring iOS's dual pasteboard
+ * representation: the clip's item text stays clean plain text for external
+ * paste targets, while the markdown source travels in the description extras
+ * under a vendor MIME type so our paste can restore formatting and block
+ * ranges. External clips (no vendor MIME) keep pasting as plain text.
+ */
+object MarkdownClipboard {
+  const val MIME_TYPE = "text/vnd.com.swmansion.enriched-markdown"
+  private const val EXTRA_MARKDOWN = "com.swmansion.enriched-markdown.markdown"
+
+  fun newMarkdownClip(
+    markdown: String,
+    plainText: String,
+  ): ClipData {
+    val clip =
+      ClipData(
+        ClipDescription("Markdown", arrayOf(MIME_TYPE, ClipDescription.MIMETYPE_TEXT_PLAIN)),
+        ClipData.Item(plainText),
+      )
+    clip.description.extras = PersistableBundle().apply { putString(EXTRA_MARKDOWN, markdown) }
+    return clip
+  }
+
+  /** Returns the clipboard's markdown, or null if the clip wasn't created by [newMarkdownClip]. */
+  fun markdownFromClipboard(context: Context): String? {
+    val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as? ClipboardManager ?: return null
+    val clip = clipboard.primaryClip ?: return null
+    if (!clip.description.hasMimeType(MIME_TYPE)) return null
+    return clip.description.extras
+      ?.getString(EXTRA_MARKDOWN)
+      ?.takeIf { it.isNotEmpty() }
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/input/editing/BlockEditCoordinator.kt

@@ -0,0 +1,196 @@
+package com.swmansion.enriched.markdown.input.editing
+
+import android.text.Editable
+import com.swmansion.enriched.markdown.input.formatting.BlockStore
+import com.swmansion.enriched.markdown.input.model.BlockRange
+import com.swmansion.enriched.markdown.input.model.BlockType
+import com.swmansion.enriched.markdown.input.model.MAX_LIST_DEPTH
+
+/**
+ * Encapsulates block-editing operations: toggling block types, adjusting
+ * list depth, and querying the block at a given position. The view delegates
+ * here and applies UI-level consequences (formatting, anchor sync, cursor
+ * size, typing attributes) based on the returned result.
+ *
+ * All mutating methods normalize stores to line bounds before returning, so
+ * the caller can re-stamp block spans immediately.
+ */
+class BlockEditCoordinator(
+  private val blockStore: BlockStore,
+) {
+  // ── Queries ──────────────────────────────────────────────────────────
+
+  fun blockAtPosition(
+    text: CharSequence,
+    pos: Int,
+  ): BlockRange? {
+    val lineStart = lineStartOf(text, pos)
+    return blockStore.blockStartingAt(lineStart)
+  }
+
+  fun listBlockAtPosition(
+    text: CharSequence,
+    pos: Int,
+  ): BlockRange? = blockAtPosition(text, pos)?.takeIf { it.type in BlockType.LIST_ITEMS }
+
+  fun listBlockAtLineStart(lineStart: Int): BlockRange? = blockStore.blockStartingAt(lineStart)?.takeIf { it.type in BlockType.LIST_ITEMS }
+
+  fun headingLevelAtPosition(
+    text: CharSequence,
+    pos: Int,
+  ): Int {
+    val block = blockAtPosition(text, pos) ?: return 0
+    return if (block.type in BlockType.HEADINGS) block.level else 0
+  }
+
+  fun listStateAtPosition(
+    text: CharSequence,
+    pos: Int,
+    type: BlockType,
+  ): Pair<Boolean, Int> {
+    val block = listBlockAtPosition(text, pos) ?: return false to 0
+    return if (block.type == type) true to block.level else false to 0
+  }
+
+  // ── Mutations ────────────────────────────────────────────────────────
+
+  /**
+   * Toggles [type] at [level] on the paragraphs the selection touches.
+   * Returns true when the block was already active (i.e. it was turned off).
+   */
+  fun toggleBlock(
+    text: Editable,
+    type: BlockType,
+    level: Int,
+    selStart: Int,
+    selEnd: Int,
+  ): Boolean {
+    val existing = blockAtPosition(text, selStart)
+    val wasActive = existing != null && existing.type == type && existing.level == level
+
+    if (wasActive) {
+      blockStore.removeBlock(selStart, selEnd, text)
+    } else {
+      forEachLine(text, selStart, selEnd) { ls, le ->
+        blockStore.setBlock(type, level, ls, le, text)
+      }
+    }
+    blockStore.normalizeToLineBounds(text)
+    return wasActive
+  }
+
+  /**
+   * Toggles a list of [type] on the selection: turns lines into depth-0
+   * items (switching list type keeps each line's depth) or clears them back
+   * to plain paragraphs when the cursor line already carries [type].
+   * Returns true when the list was turned off.
+   */
+  fun toggleList(
+    text: Editable,
+    type: BlockType,
+    cursorPos: Int,
+    selStart: Int,
+    selEnd: Int,
+  ): Boolean {
+    val turningOff = listBlockAtPosition(text, cursorPos)?.type == type
+    if (turningOff) {
+      forEachLine(text, selStart, selEnd) { ls, le ->
+        blockStore.removeBlock(ls, le, text)
+      }
+    } else {
+      forEachLine(text, selStart, selEnd) { ls, le ->
+        val existing = listBlockAtLineStart(ls)
+        blockStore.setBlock(type, existing?.level ?: 0, ls, le, text)
+      }
+    }
+    blockStore.normalizeToLineBounds(text)
+    return turningOff
+  }
+
+  enum class DepthChangeResult {
+    /** Depth was adjusted on the existing list item(s). */
+    CHANGED,
+
+    /** No list existed; a new unordered list was started (delta > 0 only). */
+    STARTED_LIST,
+
+    /** Outdented at depth 0 — the list marker was removed. */
+    EXITED_LIST,
+
+    /** Nothing happened (e.g. outdent on a heading or plain paragraph). */
+    NO_OP,
+  }
+
+  /**
+   * Adjusts list depth by [delta] on the selected lines. When the cursor
+   * is on a plain paragraph and delta > 0, starts a new unordered list.
+   * When outdenting at depth 0, removes the list marker.
+   *
+   * Returns the action taken so the view can apply the appropriate UI effects.
+   */
+  fun changeDepth(
+    text: Editable,
+    cursorPos: Int,
+    selStart: Int,
+    selEnd: Int,
+    delta: Int,
+  ): DepthChangeResult {
+    val cursorBlock = listBlockAtPosition(text, cursorPos)
+    if (cursorBlock == null) {
+      if (delta > 0 && blockAtPosition(text, cursorPos) == null) {
+        toggleList(text, BlockType.UNORDERED_LIST_ITEM, cursorPos, selStart, selEnd)
+        return DepthChangeResult.STARTED_LIST
+      }
+      return DepthChangeResult.NO_OP
+    }
+    if (delta < 0 && cursorBlock.level == 0) {
+      toggleList(text, cursorBlock.type, cursorPos, selStart, selEnd)
+      return DepthChangeResult.EXITED_LIST
+    }
+
+    forEachLine(text, selStart, selEnd) { ls, _ ->
+      val block = listBlockAtLineStart(ls)
+      if (block != null) {
+        val newDepth = (block.level + delta).coerceIn(0, MAX_LIST_DEPTH)
+        blockStore.setBlock(block.type, newDepth, ls, ls, text)
+      }
+    }
+    blockStore.normalizeToLineBounds(text)
+    return DepthChangeResult.CHANGED
+  }
+
+  // ── Line utilities ───────────────────────────────────────────────────
+
+  fun lineStartOf(
+    text: CharSequence,
+    pos: Int,
+  ): Int {
+    var s = pos.coerceIn(0, text.length)
+    while (s > 0 && !text[s - 1].isLineBreak()) s--
+    return s
+  }
+
+  fun lineEndOf(
+    text: CharSequence,
+    pos: Int,
+  ): Int {
+    var e = pos.coerceIn(0, text.length)
+    while (e < text.length && !text[e].isLineBreak()) e++
+    return e
+  }
+
+  private inline fun forEachLine(
+    text: CharSequence,
+    selStart: Int,
+    selEnd: Int,
+    action: (lineStart: Int, lineEnd: Int) -> Unit,
+  ) {
+    var cursor = lineStartOf(text, selStart)
+    while (cursor <= text.length) {
+      val le = lineEndOf(text, cursor)
+      action(cursor, le)
+      if (le >= selEnd) break
+      cursor = le + 1
+    }
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/input/editing/ClipboardCoordinator.kt

@@ -0,0 +1,73 @@
+package com.swmansion.enriched.markdown.input.editing
+
+import android.text.Editable
+import com.swmansion.enriched.markdown.input.detection.DetectorPipeline
+import com.swmansion.enriched.markdown.input.formatting.BlockStore
+import com.swmansion.enriched.markdown.input.formatting.FormattingStore
+import com.swmansion.enriched.markdown.input.formatting.InputFormatter
+import com.swmansion.enriched.markdown.input.formatting.MarkdownSerializer
+import com.swmansion.enriched.markdown.input.math.MathChipController
+import com.swmansion.enriched.markdown.input.model.BlockRange
+import com.swmansion.enriched.markdown.input.model.FormattingRange
+
+class ClipboardCoordinator(
+  private val formattingStore: FormattingStore,
+  private val blockStore: BlockStore,
+  private val detectorPipeline: DetectorPipeline,
+  private val formatter: InputFormatter,
+) {
+  fun allRangesForSerialization(editable: Editable?): List<FormattingRange> {
+    if (editable == null) return formattingStore.allRanges
+    val transient = detectorPipeline.allTransientFormattingRanges(editable)
+    if (transient.isEmpty()) return formattingStore.allRanges
+    return formattingStore.allRanges + transient
+  }
+
+  fun serializeFullDocument(
+    text: String,
+    editable: Editable?,
+    chips: List<MathChipController.ChipInfo> = emptyList(),
+  ): String =
+    MarkdownSerializer.serialize(text, chips, allRangesForSerialization(editable), blockStore.allRanges) { block ->
+      formatter.handlerForBlock(block.type)?.markdownLinePrefix(block) ?: ""
+    }
+
+  fun serializeSelectedRange(
+    fullText: String,
+    selStart: Int,
+    selEnd: Int,
+    editable: Editable?,
+    chips: List<MathChipController.ChipInfo> = emptyList(),
+  ): String? {
+    if (selStart >= selEnd) return null
+    val selectedText = fullText.substring(selStart, selEnd)
+
+    val clippedRanges = mutableListOf<FormattingRange>()
+    for (range in allRangesForSerialization(editable)) {
+      if (range.end <= selStart || range.start >= selEnd) continue
+      val clippedStart = maxOf(range.start, selStart)
+      val clippedEnd = minOf(range.end, selEnd)
+      clippedRanges.add(FormattingRange(range.type, clippedStart - selStart, clippedEnd - selStart, range.url))
+    }
+
+    val clippedBlockRanges = mutableListOf<BlockRange>()
+    for (block in blockStore.allRanges) {
+      if (block.end <= selStart || block.start >= selEnd) continue
+      val clippedStart = maxOf(block.start, selStart)
+      val clippedEnd = minOf(block.end, selEnd)
+      clippedBlockRanges.add(BlockRange(block.type, clippedStart - selStart, clippedEnd - selStart, block.level))
+    }
+
+    // A chip is a single character, so it is cleanly inside or outside the selection;
+    // rebase the survivors onto the substring like the ranges above. Copying part of
+    // a document must serialize its formulas, not the bare placeholder char.
+    val clippedChips =
+      chips
+        .filter { it.position in selStart until selEnd }
+        .map { it.copy(position = it.position - selStart) }
+
+    return MarkdownSerializer.serialize(selectedText, clippedChips, clippedRanges, clippedBlockRanges) { block ->
+      formatter.handlerForBlock(block.type)?.markdownLinePrefix(block) ?: ""
+    }
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/input/editing/EditContext.kt

@@ -0,0 +1,19 @@
+package com.swmansion.enriched.markdown.input.editing
+
+import com.swmansion.enriched.markdown.input.model.StyleType
+
+/**
+ * Immutable snapshot of everything the [EditPipeline] needs to process a single
+ * text change. Built by the view from its pre-/post-edit state, then handed to
+ * [EditPipeline.processTextChange].
+ */
+data class EditContext(
+  val editStart: Int,
+  val deletedLength: Int,
+  val insertedLength: Int,
+  val preEditText: String,
+  val preEditSelectionStart: Int,
+  val preEditSelectionEnd: Int,
+  val pendingStyles: Set<StyleType>,
+  val pendingStyleRemovals: Set<StyleType>,
+)

package/android/src/main/java/com/swmansion/enriched/markdown/input/editing/EditPipeline.kt

@@ -0,0 +1,248 @@
+package com.swmansion.enriched.markdown.input.editing
+
+import android.text.Editable
+import com.swmansion.enriched.markdown.input.detection.DetectorPipeline
+import com.swmansion.enriched.markdown.input.formatting.BlockStore
+import com.swmansion.enriched.markdown.input.formatting.FormattingStore
+import com.swmansion.enriched.markdown.input.formatting.InputFormatter
+import com.swmansion.enriched.markdown.input.layout.InputEventEmitter
+import com.swmansion.enriched.markdown.input.model.BlockType
+import com.swmansion.enriched.markdown.input.model.FormattingRange
+
+/**
+ * Zero-width space: anchors an empty bullet line so the marker draws and the
+ * caret indents (Android won't apply a LeadingMarginSpan's indent to an empty
+ * paragraph). Stripped during serialization, so it never reaches the Markdown output.
+ */
+internal const val ZWSP = '\u200B'
+
+internal fun Char.isLineBreak(): Boolean = this == '\n' || this == '\r' || this == '\u0085' || this == '\u2028' || this == '\u2029'
+
+/**
+ * View-specific operations the [EditPipeline] delegates back to its host.
+ * Implemented by [EnrichedMarkdownTextInputView][com.swmansion.enriched.markdown.input.EnrichedMarkdownTextInputView].
+ */
+interface EditPipelineHost {
+  val editable: Editable?
+  val emitMarkdown: Boolean
+
+  fun syncEmptyListAnchor(restamp: Boolean): Boolean
+
+  fun forceScrollToSelection()
+
+  fun syncCursorSizeWithBlock()
+
+  fun updateActiveMention()
+
+  fun runAsATransaction(block: () -> Unit)
+
+  fun setViewSelection(position: Int)
+}
+
+/**
+ * Orchestrates the per-keystroke edit pipeline: store adjustment, block
+ * continuation, formatting, detection, and event emission.
+ *
+ * Phases run in a fixed order — each phase's postcondition is the next phase's
+ * precondition. New block types add behavior to [continueBlocks] (via their
+ * handler's [continuesOnNewline][com.swmansion.enriched.markdown.input.styles.BlockHandler.continuesOnNewline])
+ * without touching this pipeline.
+ */
+class EditPipeline(
+  private val formattingStore: FormattingStore,
+  private val blockStore: BlockStore,
+  private val formatter: InputFormatter,
+  private val detectorPipeline: DetectorPipeline,
+  private val eventEmitter: InputEventEmitter,
+  private val host: EditPipelineHost,
+) {
+  /**
+   * Main entry point — called once per user-driven text change. The [context]
+   * captures the edit parameters and pre-edit state as an immutable snapshot.
+   */
+  fun processTextChange(context: EditContext) {
+    adjustStores(context)
+    pruneOrphanedAnchors()
+    continueBlocks(context)
+    host.editable?.let { blockStore.normalizeToLineBounds(it) }
+    applyPendingStyles(context)
+
+    // Settle the ZWSP anchor BEFORE stamping spans, so block formatting runs
+    // exactly once over the final text/ranges — otherwise a pre-ZWSP and
+    // post-ZWSP span would both land on the empty line ("double bullet" bug).
+    val anchorChanged = host.syncEmptyListAnchor(restamp = false)
+    val touchedNewline = anchorChanged || editTouchedNewline(context)
+
+    applyInlineFormatting()
+    applyBlockFormatting(touchedNewline, context.editStart, context.insertedLength)
+    detectLinks(context)
+
+    host.forceScrollToSelection()
+    host.syncCursorSizeWithBlock()
+
+    eventEmitter.emitChangeText()
+    if (host.emitMarkdown) eventEmitter.emitChangeMarkdown()
+    host.updateActiveMention()
+    eventEmitter.emitCaretRectChangeIfNeeded()
+  }
+
+  private fun adjustStores(context: EditContext) {
+    formattingStore.adjustForEdit(context.editStart, context.deletedLength, context.insertedLength)
+    blockStore.adjustForEdit(context.editStart, context.deletedLength, context.insertedLength)
+  }
+
+  /**
+   * Drops anchored blocks (headings, list items) no longer anchored at a line
+   * start (e.g. Backspace merged their line into the previous one). Must run
+   * BEFORE [BlockStore.normalizeToLineBounds] so a merged range is judged on
+   * its unsnapped anchor.
+   *
+   * Internal so the view's [adjustStoresForEdit][com.swmansion.enriched.markdown.input.EnrichedMarkdownTextInputView]
+   * helper (used by programmatic text-mutation paths) can call it too.
+   */
+  internal fun pruneOrphanedAnchors() {
+    val editable = host.editable ?: return
+    val orphans =
+      blockStore.allRanges.filter { range ->
+        range.type in BlockType.ANCHORED && !isAtLineStart(editable, range.start)
+      }
+    for (orphan in orphans) {
+      blockStore.removeBlock(orphan.start, orphan.start, editable)
+    }
+  }
+
+  /**
+   * After a newline insertion, continues a block whose handler reports
+   * [continuesOnNewline][com.swmansion.enriched.markdown.input.styles.BlockHandler.continuesOnNewline]
+   * onto the new line as a sibling at the same depth, or exits the block when
+   * the emptied item gets a second Enter.
+   */
+  private fun continueBlocks(context: EditContext) {
+    val editable = host.editable ?: return
+    if (context.deletedLength != 0 || context.insertedLength <= 0) return
+    val insertedEnd = (context.editStart + context.insertedLength).coerceAtMost(editable.length)
+    val insertedNewline = (context.editStart until insertedEnd).any { editable[it] == '\n' }
+    if (!insertedNewline) return
+
+    val prevLineEnd = context.editStart
+    var prevLineStart = prevLineEnd
+    while (prevLineStart > 0 && editable[prevLineStart - 1] != '\n') prevLineStart--
+
+    val prevBlock = blockStore.blockStartingAt(prevLineStart) ?: return
+    val handler = formatter.handlerForBlock(prevBlock.type) ?: return
+    if (!handler.continuesOnNewline) return
+
+    val prevContentLength = (prevLineStart until prevLineEnd).count { editable[it] != ZWSP }
+    if (prevContentLength == 0) {
+      // Exit: clear the block AND delete the just-inserted newline so the empty
+      // item collapses in place instead of leaving an extra indented blank line.
+      blockStore.removeBlock(prevLineStart, prevLineEnd, editable)
+      val newlineEnd = (context.editStart + context.insertedLength).coerceAtMost(editable.length)
+      host.runAsATransaction { editable.delete(context.editStart, newlineEnd) }
+      blockStore.adjustForEdit(context.editStart, context.insertedLength, 0)
+      host.setViewSelection(prevLineStart.coerceAtMost(editable.length))
+      return
+    }
+
+    val newLineStart = (context.editStart + context.insertedLength).coerceAtMost(editable.length)
+    blockStore.setBlock(prevBlock.type, prevBlock.level, newLineStart, newLineStart, editable)
+  }
+
+  private fun applyPendingStyles(context: EditContext) {
+    if (context.insertedLength == 0) return
+    if (context.pendingStyles.isEmpty() && context.pendingStyleRemovals.isEmpty()) return
+
+    val rangeStart =
+      if (context.preEditSelectionStart != context.preEditSelectionEnd) {
+        context.preEditSelectionStart
+      } else {
+        context.editStart
+      }
+    val rangeEnd = rangeStart + context.insertedLength
+
+    // Skip applying pending styles when the insertion is only line breaks —
+    // a phantom range over a bare newline corrupts isStyleActive() at the boundary.
+    val currentText = host.editable
+    val insertedHasGlyphContent =
+      currentText != null &&
+        rangeEnd <= currentText.length &&
+        (rangeStart until rangeEnd).any { !currentText[it].isLineBreak() }
+
+    if (insertedHasGlyphContent) {
+      for (style in context.pendingStyles) {
+        formattingStore.addRange(FormattingRange(style, rangeStart, rangeEnd))
+      }
+    }
+
+    for (style in context.pendingStyleRemovals) {
+      formattingStore.removeType(style, rangeStart, rangeEnd)
+    }
+  }
+
+  private fun applyInlineFormatting() {
+    val editable = host.editable ?: return
+    formatter.applyFormatting(editable, formattingStore.allRanges)
+  }
+
+  private fun applyBlockFormatting(
+    touchedNewline: Boolean,
+    editStart: Int,
+    insertedLength: Int,
+  ) {
+    val editable = host.editable ?: return
+    if (touchedNewline) {
+      formatter.applyBlockFormatting(editable, blockStore.allRanges)
+    } else {
+      applyBlockFormattingScopedToEdit(editable, editStart, insertedLength)
+    }
+  }
+
+  private fun applyBlockFormattingScopedToEdit(
+    editable: Editable,
+    editStart: Int,
+    insertedLength: Int,
+  ) {
+    val length = editable.length
+    val rawStart = editStart.coerceIn(0, length)
+    val rawEnd = (editStart + insertedLength).coerceIn(rawStart, length)
+
+    var lineStart = rawStart
+    while (lineStart > 0 && editable[lineStart - 1] != '\n') lineStart--
+    var lineEnd = rawEnd
+    while (lineEnd < length && editable[lineEnd] != '\n') lineEnd++
+
+    formatter.applyBlockFormatting(editable, blockStore.allRanges, lineStart, lineEnd)
+  }
+
+  private fun detectLinks(context: EditContext) {
+    val editable = host.editable ?: return
+    val currentText = editable.toString()
+    detectorPipeline.processTextChange(editable, currentText, context.editStart, context.insertedLength)
+  }
+
+  /**
+   * True when the edit inserted or deleted a line break (so block spans may
+   * need to move across lines). Checks the inserted run in the current text
+   * and the deleted run in the pre-edit text.
+   */
+  private fun editTouchedNewline(context: EditContext): Boolean {
+    val editable = host.editable
+    if (editable != null && context.insertedLength > 0) {
+      val end = (context.editStart + context.insertedLength).coerceAtMost(editable.length)
+      if ((context.editStart until end).any { editable[it].isLineBreak() }) return true
+    }
+    if (context.deletedLength > 0) {
+      val end = (context.editStart + context.deletedLength).coerceAtMost(context.preEditText.length)
+      if ((context.editStart until end).any { context.preEditText[it].isLineBreak() }) return true
+    }
+    return false
+  }
+
+  private fun isAtLineStart(
+    editable: CharSequence,
+    pos: Int,
+  ): Boolean {
+    if (pos < 0 || pos > editable.length) return false
+    return pos == 0 || editable[pos - 1].isLineBreak()
+  }
+}

package/android/src/main/java/com/swmansion/enriched/markdown/input/editing/EditSession.kt

@@ -0,0 +1,52 @@
+package com.swmansion.enriched.markdown.input.editing
+
+enum class EditPhase {
+  Idle,
+  Processing,
+  Importing,
+  ManagingAnchors,
+}
+
+/**
+ * Tracks the current editing phase and exposes computed suppression queries.
+ * Replaces the scattered boolean flags (`isProcessingTextChange`,
+ * `isDuringTransaction`, `blockEmitting`, `isManagingAnchor`) that previously
+ * guarded re-entrant code paths in the view.
+ */
+class EditSession {
+  var phase: EditPhase = EditPhase.Idle
+    private set
+
+  var isTextChanging: Boolean = false
+  var didTextChangeRecently: Boolean = false
+
+  val shouldSuppressTextWatcher: Boolean
+    get() = phase != EditPhase.Idle
+
+  val shouldSuppressEvents: Boolean
+    get() = phase == EditPhase.Importing
+
+  val shouldSuppressAnchorSync: Boolean
+    get() = phase == EditPhase.ManagingAnchors
+
+  fun enter(newPhase: EditPhase) {
+    phase = newPhase
+  }
+
+  fun exit() {
+    phase = EditPhase.Idle
+  }
+
+  fun <T> scoped(
+    newPhase: EditPhase,
+    block: () -> T,
+  ): T {
+    val previous = phase
+    phase = newPhase
+    try {
+      return block()
+    } finally {
+      phase = previous
+    }
+  }
+}