@octane-xplat/richtext 0.9.0 → 0.11.0

package/platforms/ios/src/XplatAztecEditor.swift

@@ -0,0 +1,357 @@
+import Aztec
+import Foundation
+import UIKit
+
+/// NativeScript-facing facade over AztecEditor-iOS `TextView`.
+///
+/// Every member reachable from JavaScript is `@objc`-visible and uses only
+/// ObjC-representable types (String, Bool, NSNumber, NSArray, blocks), so the
+/// NativeScript metadata generator sees the whole surface. The leaf drives
+/// this view directly; block properties carry the event callbacks.
+///
+/// `placeholder` and sub/superscript toggles are wrapper-built: Aztec exposes
+/// no native API for either. `taskList` and text alignment have no Aztec-iOS
+/// equivalent at all — `applyFormat`/`isFormatActive` report them as
+/// unsupported instead of faking a result.
+@objcMembers
+public final class XplatAztecEditorView: UIView, UITextViewDelegate {
+
+	/// FormattingIdentifier rawValue -> leaf format name. Aztec's identifier
+	/// map has no entries for `pre`, sub/superscript, task lists, or
+	/// alignment; those are checked at the attribute level below or honestly
+	/// reported as unsupported.
+	private static let identifierFormats: [String: String] = [
+		"bold": "bold",
+		"italic": "italic",
+		"underline": "underline",
+		"strikethrough": "strikethrough",
+		"code": "code",
+		"blockquote": "blockquote",
+		"orderedlist": "orderedList",
+		"unorderedlist": "bulletList",
+		"mark": "highlight",
+		"p": "paragraph",
+		"header1": "heading1",
+		"header2": "heading2",
+		"header3": "heading3",
+		"header4": "heading4",
+		"header5": "heading5",
+		"header6": "heading6",
+		"horizontalruler": "horizontalRule",
+		"link": "link",
+	]
+
+	public let textView = TextView(
+		defaultFont: UIFont.preferredFont(forTextStyle: .body),
+		defaultMissingImage: UIImage())
+	private let placeholderLabel = UILabel()
+
+	// MARK: - JS callbacks
+
+	public var onTextChange: (() -> Void)?
+	public var onSelectionChange: ((NSNumber, NSNumber, NSArray) -> Void)?
+	public var onFocus: (() -> Void)?
+	public var onBlur: (() -> Void)?
+
+	public override init(frame: CGRect) {
+		super.init(frame: frame)
+		textView.delegate = self
+		textView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+		addSubview(textView)
+
+		placeholderLabel.textColor = .secondaryLabel
+		placeholderLabel.font = textView.font
+		placeholderLabel.numberOfLines = 1
+		placeholderLabel.isUserInteractionEnabled = false
+		addSubview(placeholderLabel)
+		updatePlaceholderVisibility()
+	}
+
+	@available(*, unavailable)
+	public required init?(coder: NSCoder) {
+		fatalError("init(coder:) is not supported")
+	}
+
+	public override func layoutSubviews() {
+		super.layoutSubviews()
+		textView.frame = bounds
+		let inset = textView.textContainerInset
+		let padding = textView.textContainer.lineFragmentPadding
+		placeholderLabel.frame = CGRect(
+			x: inset.left + padding,
+			y: inset.top,
+			width: max(0, bounds.width - inset.left - inset.right - padding * 2),
+			height: placeholderLabel.font.lineHeight)
+	}
+
+	// MARK: - Props
+
+	public var placeholder: String? {
+		get { placeholderLabel.text }
+		set {
+			placeholderLabel.text = newValue
+			updatePlaceholderVisibility()
+		}
+	}
+
+	public var editable: Bool {
+		get { textView.isEditable }
+		set { textView.isEditable = newValue }
+	}
+
+	private func updatePlaceholderVisibility() {
+		let hasText = textView.textStorage.length > 0
+		placeholderLabel.isHidden = hasText || (placeholderLabel.text ?? "").isEmpty
+	}
+
+	// MARK: - Document
+
+	public func getHTML() -> String {
+		textView.getHTML(prettify: false)
+	}
+
+	public func setHTML(_ html: String) {
+		textView.setHTML(html)
+		updatePlaceholderVisibility()
+	}
+
+	// MARK: - Formats
+
+	/// Returns false for formats this engine cannot apply (`taskList`,
+	/// `align*`, `link` — the link API is `linkTo`) and unknown names.
+	public func applyFormat(_ format: String) -> Bool {
+		let range = textView.selectedRange
+		switch format {
+		case "bold": textView.toggleBold(range: range)
+		case "italic": textView.toggleItalic(range: range)
+		case "underline": textView.toggleUnderline(range: range)
+		case "strikethrough": textView.toggleStrikethrough(range: range)
+		case "code": textView.toggleCode(range: range)
+		case "blockquote": textView.toggleBlockquote(range: range)
+		case "bulletList": textView.toggleUnorderedList(range: range)
+		case "orderedList": textView.toggleOrderedList(range: range)
+		case "codeBlock": textView.togglePre(range: range)
+		case "paragraph": textView.toggleHeader(.none, range: range)
+		case "heading1": textView.toggleHeader(.h1, range: range)
+		case "heading2": textView.toggleHeader(.h2, range: range)
+		case "heading3": textView.toggleHeader(.h3, range: range)
+		case "heading4": textView.toggleHeader(.h4, range: range)
+		case "heading5": textView.toggleHeader(.h5, range: range)
+		case "heading6": textView.toggleHeader(.h6, range: range)
+		case "highlight": textView.toggleMark(range: range, color: nil, resetColor: true)
+		case "horizontalRule": textView.replaceWithHorizontalRuler(at: range)
+		case "subscript": toggleBaselineOffset(-4, in: range)
+		case "superscript": toggleBaselineOffset(4, in: range)
+		default: return false
+		}
+		return true
+	}
+
+	public func isFormatActive(_ format: String) -> Bool {
+		activeFormatSet().contains(format)
+	}
+
+	public func activeFormats() -> [String] {
+		activeFormatSet().sorted()
+	}
+
+	private func activeFormatSet() -> Set<String> {
+		var out = Set<String>()
+		for identifier in textView.formattingIdentifiersSpanningRange(textView.selectedRange) {
+			if let name = XplatAztecEditorView.identifierFormats[identifier.rawValue] {
+				out.insert(name)
+			}
+		}
+		let attributeSets = activeAttributeSets()
+		if !attributeSets.isEmpty {
+			if attributeSets.allSatisfy(hasPreProperty) { out.insert("codeBlock") }
+			if attributeSets.allSatisfy({ baselineOffset(of: $0) > 0 }) { out.insert("superscript") }
+			if attributeSets.allSatisfy({ baselineOffset(of: $0) < 0 }) { out.insert("subscript") }
+		}
+		return out
+	}
+
+	/// The attribute dictionaries the identifier check would consult:
+	/// typing attributes on an empty document, the attributes at the caret
+	/// for a collapsed selection, every run in the selection otherwise.
+	private func activeAttributeSets() -> [[NSAttributedString.Key: Any]] {
+		let storage = textView.textStorage
+		let range = textView.selectedRange
+		guard storage.length > 0 else { return [textView.typingAttributes] }
+		if range.length == 0 {
+			let index = min(range.location, storage.length - 1)
+			return [storage.attributes(at: index, effectiveRange: nil)]
+		}
+		var sets: [[NSAttributedString.Key: Any]] = []
+		storage.enumerateAttributes(in: range, options: []) { attributes, _, _ in
+			sets.append(attributes)
+		}
+		return sets
+	}
+
+	private func hasPreProperty(_ attributes: [NSAttributedString.Key: Any]) -> Bool {
+		guard let style = attributes[.paragraphStyle] as? ParagraphStyle else { return false }
+		// HTMLPre is module-internal to Aztec — match the property by type name.
+		return style.hasProperty { String(describing: Swift.type(of: $0)) == "HTMLPre" }
+	}
+
+	private func baselineOffset(of attributes: [NSAttributedString.Key: Any]) -> Int {
+		(attributes[.baselineOffset] as? NSNumber)?.intValue ?? 0
+	}
+
+	/// Aztec-iOS has no public sub/superscript toggle — apply or clear
+	/// `.baselineOffset` directly; the HTML converter serializes it back as
+	/// `<sub>`/`<sup>`. Collapsed selections toggle the typing attributes.
+	private func toggleBaselineOffset(_ offset: Int, in range: NSRange) {
+		let storage = textView.textStorage
+		if range.length == 0 || storage.length == 0 {
+			var attributes = textView.typingAttributes
+			let current = baselineOffset(of: attributes)
+			attributes[.baselineOffset] = current == offset ? nil : NSNumber(value: offset)
+			textView.typingAttributes = attributes
+			return
+		}
+		guard range.location + range.length <= storage.length else { return }
+
+		let original = storage.attributedSubstring(from: range)
+		let restoredRange = NSRange(location: range.location, length: range.length)
+		textView.undoManager?.registerUndo(withTarget: textView) { target in
+			target.textStorage.replaceCharacters(in: restoredRange, with: original)
+			target.delegate?.textViewDidChange?(target)
+		}
+
+		storage.beginEditing()
+		storage.enumerateAttribute(.baselineOffset, in: range, options: []) { value, subrange, _ in
+			let current = (value as? NSNumber)?.intValue ?? 0
+			if current == offset {
+				storage.removeAttribute(.baselineOffset, range: subrange)
+			} else {
+				storage.addAttribute(.baselineOffset, value: NSNumber(value: offset), range: subrange)
+			}
+		}
+		storage.endEditing()
+		textViewDidChange(textView)
+	}
+
+	// MARK: - Links
+
+	public func linkTo(_ urlString: String, anchor: String?) -> Bool {
+		guard let url = URL(string: urlString) else { return false }
+		textView.setLink(url, title: anchor ?? urlString, inRange: textView.selectedRange)
+		return true
+	}
+
+	public func removeLink() {
+		textView.removeLink(inRange: textView.selectedRange)
+	}
+
+	// MARK: - History
+
+	public func undo() {
+		textView.undoManager?.undo()
+	}
+
+	public func redo() {
+		textView.undoManager?.redo()
+	}
+
+	// MARK: - Structural commands
+
+	/// Block split at the caret — Aztec's `insertText` runs the same
+	/// paragraph/list handling as a real Enter keystroke. A non-collapsed
+	/// selection is deleted first, matching the leaf contract.
+	public func split() -> Bool {
+		let range = textView.selectedRange
+		guard range.location != NSNotFound,
+			range.location + range.length <= textView.textStorage.length
+		else { return false }
+		if range.length > 0 {
+			textView.deleteBackward()
+		}
+		textView.insertText("\n")
+		return true
+	}
+
+	/// Merge into the previous block — Backspace at a collapsed caret that
+	/// sits directly after a `\n` boundary, matching the leaf contract.
+	public func join() -> Bool {
+		let range = textView.selectedRange
+		guard range.length == 0, range.location > 0,
+			range.location <= textView.textStorage.length
+		else { return false }
+		let text = textView.textStorage.string as NSString
+		guard text.character(at: range.location - 1) == 0x000A else { return false }
+		textView.deleteBackward()
+		return true
+	}
+
+	/// `increaseIndent` nests a list item under its previous sibling or
+	/// deepens a blockquote; on plain blocks Aztec falls back to a `\t`
+	/// insert, so indent is available whenever the view can edit.
+	public func canIndent() -> Bool {
+		textView.isEditable
+	}
+
+	public func indent() -> Bool {
+		guard canIndent() else { return false }
+		textView.increaseIndent()
+		return true
+	}
+
+	/// `decreaseIndent` only acts on list/blockquote typing attributes —
+	/// there is no plain-block outdent, so report availability up front.
+	public func canOutdent() -> Bool {
+		guard textView.isEditable else { return false }
+		guard let style = textView.typingAttributes[.paragraphStyle] as? ParagraphStyle else {
+			return false
+		}
+		// TextList/Blockquote/HTMLLi are module-internal to Aztec.
+		return style.hasProperty {
+			let name = String(describing: Swift.type(of: $0))
+			return name == "TextList" || name == "Blockquote" || name == "HTMLLi"
+		}
+	}
+
+	public func outdent() -> Bool {
+		guard canOutdent() else { return false }
+		textView.decreaseIndent()
+		return true
+	}
+
+	// MARK: - Focus
+
+	public func focus() {
+		_ = textView.becomeFirstResponder()
+	}
+
+	public func blur() {
+		_ = textView.resignFirstResponder()
+	}
+
+	public func focused() -> Bool {
+		textView.isFirstResponder
+	}
+
+	// MARK: - UITextViewDelegate
+
+	public func textViewDidChange(_ textView: UITextView) {
+		updatePlaceholderVisibility()
+		onTextChange?()
+	}
+
+	public func textViewDidChangeSelection(_ textView: UITextView) {
+		let range = self.textView.selectedRange
+		onSelectionChange?(
+			NSNumber(value: range.location),
+			NSNumber(value: range.location + range.length),
+			activeFormats() as NSArray)
+	}
+
+	public func textViewDidBeginEditing(_ textView: UITextView) {
+		onFocus?()
+	}
+
+	public func textViewDidEndEditing(_ textView: UITextView) {
+		onBlur?()
+	}
+}

package/platforms/macos/include/XplatEditorHost.h

@@ -0,0 +1 @@
+#import <AppKit/AppKit.h>

package/platforms/macos/src/XplatEditorHost.swift

@@ -0,0 +1,63 @@
+import AppKit
+import WebKit
+
+// One isolated, local document per editor. No general app/service bridge.
+private final class EditorChannel: NSObject, WKScriptMessageHandler, WKNavigationDelegate {
+    var dispatch: ((String) -> Void)?
+    func userContentController(_: WKUserContentController, didReceive message: WKScriptMessage) {
+        guard message.frameInfo.isMainFrame, let body = message.body as? String else { return }
+        dispatch?(body)
+    }
+    func webView(_: WKWebView, decidePolicyFor action: WKNavigationAction,
+                 decisionHandler: @escaping (WKNavigationActionPolicy) -> Void) {
+        decisionHandler(action.request.url?.absoluteString == "about:blank" ? .allow : .cancel)
+    }
+}
+
+@objc(XplatEditorHost)
+public final class XplatEditorHost: NSObject {
+    private let webView: WKWebView
+    private let channel = EditorChannel()
+    private var disposed = false
+    @objc public override init() {
+        let config = WKWebViewConfiguration()
+        config.websiteDataStore = .nonPersistent()
+        webView = WKWebView(frame: .zero, configuration: config)
+        super.init()
+        config.userContentController.add(channel, name: "editor")
+        webView.navigationDelegate = channel
+        webView.autoresizingMask = [.width, .height]
+    }
+    @objc public func attach(to parent: NSView) {
+        webView.frame = parent.bounds
+        parent.addSubview(webView)
+    }
+    @objc public func installDispatcher(_ dispatch: @escaping (String) -> Void) {
+        channel.dispatch = dispatch
+    }
+    @objc public func load(_ html: String) {
+        guard !disposed else { return }
+        webView.loadHTMLString(html, baseURL: nil)
+    }
+    @objc public func deliver(_ packet: String) {
+        guard !disposed,
+              let data = try? JSONSerialization.data(withJSONObject: [packet]),
+              let literal = String(data: data, encoding: .utf8) else { return }
+        webView.evaluateJavaScript("window.__xplatEditorReceive?.(\(literal)[0])") { [weak self] _, error in
+            if let error {
+                let body = ["event": "error", "message": error.localizedDescription]
+                if let data = try? JSONSerialization.data(withJSONObject: body),
+                   let text = String(data: data, encoding: .utf8) { self?.channel.dispatch?(text) }
+            }
+        }
+    }
+    @objc public func dispose() {
+        guard !disposed else { return }
+        disposed = true
+        channel.dispatch = nil
+        webView.stopLoading()
+        webView.configuration.userContentController.removeScriptMessageHandler(forName: "editor")
+        webView.navigationDelegate = nil
+        webView.removeFromSuperview()
+    }
+}

package/src/BrowserEditor.web.ts

@@ -0,0 +1,107 @@
+import { Editor } from '@tiptap/core'
+import StarterKit from '@tiptap/starter-kit'
+import { installEditorDocument } from './browser-transport.web'
+
+let editor: Editor | undefined
+let current: any
+let lastHTML: string | undefined
+let lastJSON: string | undefined
+let lastHTMLInput: string | undefined
+const command: Record<string, (chain: any) => any> = {
+	bold: (c) => c.toggleBold(),
+	italic: (c) => c.toggleItalic(),
+	underline: (c) => c.toggleUnderline(),
+	strikethrough: (c) => c.toggleStrike(),
+	code: (c) => c.toggleCode(),
+	blockquote: (c) => c.toggleBlockquote(),
+	bulletList: (c) => c.toggleBulletList(),
+	orderedList: (c) => c.toggleOrderedList(),
+	codeBlock: (c) => c.toggleCodeBlock(),
+	horizontalRule: (c) => c.setHorizontalRule(),
+	paragraph: (c) => c.setParagraph(),
+}
+
+for (let level = 1; level <= 6; level++) {
+	command['heading' + level] = (c) => c.toggleHeading({ level })
+}
+
+installEditorDocument((props) => {
+	current = props
+	if (!editor) {
+		const element = document.createElement('div')
+		document.body.append(element)
+		editor = new Editor({
+			element,
+			extensions: [StarterKit],
+			content: props.value ?? '',
+			editable: props.editable !== false,
+			autofocus: props.autofocus ?? false,
+			onUpdate: ({ editor: e }) => {
+				lastHTML = e.getHTML()
+				current.onChange?.(lastHTML)
+			},
+			onSelectionUpdate: ({ editor: e }) =>
+				current.onSelectionChange?.({
+					start: e.state.selection.from,
+					end: e.state.selection.to,
+					active: [],
+				}),
+			onFocus: () => current.onFocus?.(),
+			onBlur: () => current.onBlur?.(),
+		})
+
+		lastHTMLInput = JSON.stringify([props.json !== undefined, props.value])
+		const e = editor
+		props.ref({
+			getHTML: () => e.getHTML(),
+			setHTML: (html: string) => e.commands.setContent(html),
+			getJSON: () => e.getJSON(),
+			setJSON: (doc: any) => e.commands.setContent(doc),
+			apply: (format: string) => {
+				command[format]?.(e.chain().focus()).run()
+			},
+			linkTo: (url: string, anchor?: string) =>
+				anchor
+					? e
+							.chain()
+							.focus()
+							.insertContent({
+								type: 'text',
+								text: anchor,
+								marks: [{ type: 'link', attrs: { href: url } }],
+							})
+							.run()
+					: e.chain().focus().extendMarkRange('link').setLink({ href: url }).run(),
+			removeLink: () => e.chain().focus().unsetLink().run(),
+			isActive: (format: string) =>
+				format.startsWith('heading')
+					? e.isActive('heading', { level: Number(format.slice(7)) })
+					: e.isActive(format === 'strikethrough' ? 'strike' : format),
+			undo: () => e.commands.undo(),
+			redo: () => e.commands.redo(),
+			focus: () => e.commands.focus(),
+			blur: () => e.commands.blur(),
+			isFocused: () => e.isFocused,
+		})
+	}
+
+	if (props.json !== undefined) {
+		const stamp = JSON.stringify(props.json)
+		if (stamp !== lastJSON && stamp !== JSON.stringify(editor.getJSON())) {
+			editor.commands.setContent(props.json)
+		}
+
+		lastJSON = stamp
+	} else {
+		const stamp = JSON.stringify([false, props.value])
+		if (stamp !== lastHTMLInput && props.value !== undefined && props.value !== lastHTML) {
+			editor.commands.setContent(props.value)
+		}
+
+		lastHTMLInput = stamp
+	}
+
+	editor.setEditable(props.editable !== false)
+	editor.view.dom.dataset.placeholder = props.placeholder ?? ''
+	editor.view.dom.setAttribute('aria-label', props.placeholder ?? 'Rich text editor')
+})

package/src/Editor.macos.tsx

@@ -0,0 +1,9 @@
+/** @jsxImportSource @octane-xplat/macos-renderer */
+import type { RichTextEditorProps } from './types'
+import browser from '../dist/macos/browser.js'
+import { NativeEditor } from './NativeEditor.macos'
+
+/** AppKit mounts the local editor engine in WKWebView. */
+export function RichTextEditor(props: RichTextEditorProps) {
+	return <NativeEditor {...props} browser={browser} />
+}

package/src/NativeEditor.macos.tsx

@@ -0,0 +1,81 @@
+/** @jsxImportSource @octane-xplat/macos-renderer */
+import { useCallback, useEffect, useImperativeHandle, useRef, useState } from 'octane'
+import type { RichTextEditorProps } from './types'
+import { createEditorSession } from './host-session.macos'
+
+declare const XplatEditorHost: { alloc(): { init(): any } }
+
+type HostProps = RichTextEditorProps & {
+	browser: string
+	json?: any
+	onJSONReady?: (ready: boolean) => void
+	onJSONChange?: (doc: any) => void
+}
+
+/** Internal shared AppKit/WKWebView surface, owned by the editor leaf. */
+export function NativeEditor(props: HostProps) {
+	const latest = useRef(props)
+	latest.current = props
+	const session = useRef<ReturnType<typeof createEditorSession> | null>(null)
+	const [handle, setHandle] = useState<any>(null)
+	useImperativeHandle(props.ref, () => handle, [handle])
+	const attach = useCallback((parent: any) => {
+		session.current?.dispose()
+		session.current = null
+		if (!parent) {
+			setHandle(null)
+			return
+		}
+
+		const native = XplatEditorHost.alloc().init()
+		const next = createEditorSession(
+			(packet) => native.deliver(packet),
+			native,
+			() => latest.current,
+		)
+
+		session.current = next
+		native.installDispatcher((packet: string) => next.receive(packet))
+		native.attachTo(parent)
+		native.load(props.browser)
+		setHandle(next.handle)
+	}, [])
+
+	useEffect(() => {
+		session.current?.update({
+			value: props.value,
+			json: props.json,
+			placeholder: props.placeholder,
+			editable: props.editable,
+			autofocus: props.autofocus,
+		})
+	}, [handle, props.value, props.json, props.placeholder, props.editable, props.autofocus])
+
+	useEffect(
+		() => () => {
+			session.current?.dispose()
+			session.current = null
+		},
+		[],
+	)
+
+	return (
+		<flexboxlayout
+			id={props.id}
+			className={props.className}
+			style={props.style}
+			row={props.row}
+			col={props.col}
+			rowSpan={props.rowSpan}
+			colSpan={props.colSpan}
+			dock={props.dock}
+			left={props.left}
+			top={props.top}
+			flexGrow={props.flexGrow}
+			flexShrink={props.flexShrink}
+			alignSelf={props.alignSelf}
+			order={props.order}
+			ref={attach}
+		/>
+	)
+}

package/src/RichTextEditor.android.tsrx

@@ -1,5 +1,5 @@
 /** @jsxImportSource @nativescript-community/octane */
-import { useCallback, useEffect, useRef } from 'octane'
+import { useImperativeHandle, useCallback, useEffect, useRef } from 'octane'
 import { View } from '@nativescript/core'
 import { registerElement } from '@nativescript-community/octane'
 import type { Attributes } from '@nativescript-community/octane/intrinsics'
@@ -96,6 +96,8 @@ export function RichTextEditor(props: RichTextEditorProps) @{
 
 	// Stable identity — an inline closure re-fires ref(null)/ref(v) per
 	// render, which would bounce host.current around the effects below.
+	useImperativeHandle(props.ref, () => handle(editor()), []);
+
 	const bindHost = useCallback((v: any) => {
 		host.current = v
 	}, [])
@@ -176,6 +178,45 @@ export function RichTextEditor(props: RichTextEditorProps) @{
 		},
 		undo: () => e.undo(),
 		redo: () => e.redo(),
+		split: () => {
+			const selStart = e.getSelectionStart()
+			const selEnd = e.getSelectionEnd()
+			if (selStart < 0 || selEnd < 0) return false
+			const start = Math.min(selStart, selEnd)
+			const end = Math.max(selStart, selEnd)
+			const text = e.getText()
+			if (end > String(text).length) return false
+			if (end > start) text.delete(start, end)
+			text.insert(start, '\n')
+			e.setSelection(start + 1)
+			emitChange()
+			return true
+		},
+		join: () => {
+			const start = e.getSelectionStart()
+			if (start <= 0 || e.getSelectionEnd() !== start) return false
+			const text = e.getText()
+			const s = String(text)
+			if (start > s.length || s.charAt(start - 1) !== '\n') return false
+			text.delete(start - 1, start)
+			e.setSelection(start - 1)
+			emitChange()
+			return true
+		},
+		indent: () => {
+			if (!e.isIndentAvailable()) return false
+			e.indent()
+			emitChange()
+			return true
+		},
+		outdent: () => {
+			if (!e.isOutdentAvailable()) return false
+			e.outdent()
+			emitChange()
+			return true
+		},
+		canIndent: () => Boolean(e.isIndentAvailable()),
+		canOutdent: () => Boolean(e.isOutdentAvailable()),
 		focus: () => {
 			e.requestFocus()
 			showKeyboard(e)
@@ -233,7 +274,6 @@ export function RichTextEditor(props: RichTextEditorProps) @{
 		}
 
 		if (props.android) Object.assign(e, props.android)
-		props.bind?.(handle(e))
 		props.onReady?.()
 	}, [])