@octane-xplat/tiptap 0.0.1 → 0.10.0

package/src/TiptapEditor.tsrx

@@ -0,0 +1,109 @@
+/** @jsxImportSource @nativescript-community/octane */
+import { useState, useImperativeHandle, useCallback, useEffect, useRef } from 'octane'
+import { RichTextEditor, supported as leafSupported } from '@octane-xplat/richtext'
+import type { RichTextEditorHandle } from '@octane-xplat/richtext'
+import type { TiptapEditorHandle, TiptapEditorProps } from './types'
+import { ensureJSONBridge, htmlToJSON, jsonBridgeReady, jsonToHTML } from './json-bridge'
+
+export const supported = leafSupported
+
+/** Unified editor facade, native half. Rendering/editing run through the
+ *  Aztec leaf; the tiptap document model (schema, generateJSON,
+ *  renderToHTMLString) handles JSON interchange on top of it. */
+export function TiptapEditor(props: TiptapEditorProps) @{
+	const inner = useRef<RichTextEditorHandle | null>(null)
+	const [exposedHandle, setHandle] = useState<TiptapEditorHandle | null>(null)
+	useImperativeHandle<TiptapEditorHandle | null>(props.ref, () => exposedHandle, [exposedHandle])
+	const jsonReady = useRef(false)
+	const lastJSON = useRef<string | undefined>(undefined)
+
+	const bindHost = useCallback((h: RichTextEditorHandle | null) => {
+		inner.current = h
+
+		setHandle((previous) => previous?.native === h?.native ? previous : h ? ({
+			getHTML: () => h.getHTML(),
+			setHTML: (html: string) => h.setHTML(html),
+			getJSON: () => (jsonBridgeReady() ? htmlToJSON(h.getHTML()) : null),
+			setJSON: (doc) => {
+				const html = jsonBridgeReady() ? jsonToHTML(doc) : null
+				if (html != null) {
+					lastJSON.current = JSON.stringify(doc)
+					h.setHTML(html)
+				}
+			},
+			apply: (format) => h.apply(format),
+			linkTo: (url, anchor) => h.linkTo(url, anchor),
+			removeLink: () => h.removeLink(),
+			isActive: (format) => h.isActive(format),
+			undo: () => h.undo(),
+			redo: () => h.redo(),
+			focus: () => h.focus(),
+			blur: () => h.blur(),
+			isFocused: () => h.isFocused(),
+			native: h.native,
+		} satisfies TiptapEditorHandle) : null)
+	}, [])
+
+	// The bridge loads once per process — dynamic imports of the DOM-free
+	// tiptap slices, plus the zeed-dom parse shim.
+	useEffect(() => {
+		ensureJSONBridge().then((ok) => {
+			jsonReady.current = ok
+			props.onJSONReady?.(ok)
+		})
+	}, [])
+
+	// `json` prop → editor content, when the bridge is up and the doc wasn't
+	// emitted by the editor itself.
+	useEffect(() => {
+		if (!props.json || !jsonBridgeReady() || !inner.current) return
+		const stamp = JSON.stringify(props.json)
+		if (stamp === lastJSON.current) return
+		const html = jsonToHTML(props.json)
+		if (html != null) {
+			lastJSON.current = stamp
+			inner.current.setHTML(html)
+		}
+	}, [props.json])
+
+	const emitJSON = () => {
+		if (!inner.current || !jsonBridgeReady()) return
+		const doc = htmlToJSON(inner.current.getHTML())
+		if (doc) {
+			lastJSON.current = JSON.stringify(doc)
+			props.onJSONChange?.(doc)
+		}
+	}
+
+	<RichTextEditor
+		id={props.id}
+		className={props.className}
+		style={props.style}
+		value={props.value}
+		placeholder={props.placeholder}
+		editable={props.editable}
+		autofocus={props.autofocus}
+		onReady={props.onReady}
+		onChange={(html) => {
+			props.onChange?.(html)
+			emitJSON()
+		}}
+		onSelectionChange={props.onSelectionChange}
+		onFocus={props.onFocus}
+		onBlur={props.onBlur}
+		ref={bindHost}
+		android={props.android}
+		ios={props.ios}
+		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}
+	/>;
+}

package/src/TiptapEditor.web.tsrx

@@ -0,0 +1,155 @@
+import { useImperativeHandle, useEffect, useRef } from 'octane'
+import { EditorContent, useEditor } from '@octanejs/tiptap'
+import StarterKit from '@tiptap/starter-kit'
+import type { TiptapEditorHandle, TiptapEditorProps, TiptapFormat } from './types'
+
+export const supported = true
+
+type WebFormat = Exclude<TiptapFormat, 'link' | 'taskList' | 'highlight' | 'subscript' | 'superscript' | 'alignLeft' | 'alignCenter' | 'alignRight'>
+
+const COMMAND: Record<WebFormat, (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(),
+	heading1: (c) => c.toggleHeading({ level: 1 }),
+	heading2: (c) => c.toggleHeading({ level: 2 }),
+	heading3: (c) => c.toggleHeading({ level: 3 }),
+	heading4: (c) => c.toggleHeading({ level: 4 }),
+	heading5: (c) => c.toggleHeading({ level: 5 }),
+	heading6: (c) => c.toggleHeading({ level: 6 }),
+}
+
+const ACTIVE_OF: [TiptapFormat, string, any?][] = [
+	['bold', 'bold'],
+	['italic', 'italic'],
+	['underline', 'underline'],
+	['strikethrough', 'strike'],
+	['code', 'code'],
+	['blockquote', 'blockquote'],
+	['bulletList', 'bulletList'],
+	['orderedList', 'orderedList'],
+	['codeBlock', 'codeBlock'],
+	['link', 'link'],
+	['heading1', 'heading', { level: 1 }],
+	['heading2', 'heading', { level: 2 }],
+	['heading3', 'heading', { level: 3 }],
+	['heading4', 'heading', { level: 4 }],
+	['heading5', 'heading', { level: 5 }],
+	['heading6', 'heading', { level: 6 }],
+	['paragraph', 'paragraph'],
+]
+
+function activeFormats(editor: any): TiptapFormat[] {
+	const out: TiptapFormat[] = []
+	for (const [name, kind, attrs] of ACTIVE_OF) {
+		if (editor.isActive(kind, attrs)) out.push(name)
+	}
+
+	return out
+}
+
+/** Unified editor facade, web half — a thin adapter over the published
+ *  `@octanejs/tiptap` binding (useEditor + EditorContent + StarterKit). */
+export function TiptapEditor(props: TiptapEditorProps) @{
+	const lastEmitted = useRef<string | undefined>(undefined)
+	const lastJSON = useRef<string | undefined>(undefined)
+	const lastHTMLInput = useRef(JSON.stringify([props.json !== undefined, props.value]))
+	const lastJSONInput = useRef(JSON.stringify(props.json))
+	const bound = useRef<TiptapEditorHandle | undefined>(undefined)
+
+	const editor = useEditor({
+		extensions: [StarterKit],
+		content: (props.json ?? props.value ?? '') as any,
+		editable: props.editable !== false,
+		autofocus: props.autofocus ?? false,
+		onCreate: () => props.onReady?.(),
+		onUpdate: ({ editor: e }: any) => {
+			const html = e.getHTML()
+			lastEmitted.current = html
+			props.onChange?.(html)
+			const doc = e.getJSON()
+			lastJSON.current = JSON.stringify(doc)
+			props.onJSONChange?.(doc)
+		},
+		onFocus: () => props.onFocus?.(),
+		onBlur: () => props.onBlur?.(),
+		onSelectionUpdate: ({ editor: e }: any) =>
+			props.onSelectionChange?.({
+				start: e.state.selection.from,
+				end: e.state.selection.to,
+				active: activeFormats(e),
+			}),
+	})
+
+	// External `value` changes push setContent; editor-emitted HTML is skipped
+	// (the transaction already owns the doc).
+	useEffect(() => {
+		if (!editor) return
+		const stamp = JSON.stringify([props.json !== undefined, props.value])
+		if (stamp === lastHTMLInput.current) return
+		lastHTMLInput.current = stamp
+		if (props.value === undefined || props.json !== undefined) return
+		if (props.value === lastEmitted.current) return
+		editor.commands.setContent(props.value)
+	}, [editor, props.value, props.json])
+
+	useEffect(() => {
+		if (!editor) return
+		const stamp = JSON.stringify(props.json)
+		if (stamp === lastJSONInput.current) return
+		lastJSONInput.current = stamp
+		if (props.json === undefined || stamp === lastJSON.current) return
+		editor.commands.setContent(props.json as any)
+	}, [editor, props.json])
+
+	useEffect(() => {
+		if (!editor) return
+		editor.setEditable(props.editable !== false)
+	}, [editor, props.editable])
+
+	// The handle rebinds whenever the editor instance appears — stable
+	// afterward (useEditor keeps the instance identity).
+	useImperativeHandle<TiptapEditorHandle | null>(props.ref, () => {
+		if (!editor) return null
+		const e: any = editor
+		bound.current = {
+			getHTML: () => e.getHTML(),
+			setHTML: (html: string) => e.commands.setContent(html),
+			getJSON: () => e.getJSON(),
+			setJSON: (doc) => e.commands.setContent(doc),
+			apply: (format) => {
+				const run = COMMAND[format as WebFormat]
+				if (run) run(e.chain().focus()).run()
+			},
+			linkTo: (url, anchor) => {
+				if (anchor != null && anchor !== '') {
+					e.chain().focus().insertContent({ type: 'text', text: anchor, marks: [{ type: 'link', attrs: { href: url } }] }).run()
+				} else {
+					e.chain().focus().extendMarkRange('link').setLink({ href: url }).run()
+				}
+			},
+			removeLink: () => e.chain().focus().unsetLink().run(),
+			isActive: (format) => activeFormats(e).includes(format),
+			undo: () => e.commands.undo(),
+			redo: () => e.commands.redo(),
+			focus: () => e.commands.focus(),
+			blur: () => e.commands.blur(),
+			isFocused: () => e.isFocused,
+			native: e,
+		}
+
+		return bound.current
+	}, [editor])
+
+	<div className={['vx-richtext', props.className]} style={props.style}>
+		<EditorContent editor={editor} />
+	</div>
+}

package/src/browser-entry.web.tsx

@@ -0,0 +1,5 @@
+import { createRoot } from 'octane'
+import { TiptapEditor } from './TiptapEditor.web.tsrx'
+import { installEditorDocument } from '@octane-xplat/richtext/browser-transport'
+const root = createRoot(document.getElementById('root')!)
+installEditorDocument((props) => root.render(<TiptapEditor {...props} />))

package/src/index.macos.ts

@@ -0,0 +1,13 @@
+export { TiptapEditor } from './Editor.macos'
+/** The AppKit/WKWebView backend is implemented. */
+export const supported = true
+export type * from './types'
+
+/** The local bundle includes its JSON model; wait for onReady before reading a document. */
+export async function ensureJSONBridge(): Promise<boolean> {
+	return true
+}
+
+export function jsonBridgeReady(): boolean {
+	return true
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export { TiptapEditor, supported } from './TiptapEditor.tsrx'
+export { ensureJSONBridge, jsonBridgeReady } from './json-bridge'
+export type * from './types'

package/src/index.web.ts

@@ -0,0 +1,12 @@
+export { TiptapEditor, supported } from './TiptapEditor.web.tsrx'
+export type * from './types'
+
+/** Web needs no lazy bridge — tiptap is in the bundle already. Kept for
+ *  call-site parity with the native entry. */
+export function ensureJSONBridge(): Promise<boolean> {
+	return Promise.resolve(true)
+}
+
+export function jsonBridgeReady(): boolean {
+	return true
+}

package/src/json-bridge.ts

@@ -0,0 +1,124 @@
+/** Lazy tiptap document-model bridge for native runtimes. The DOM-free
+ *  slices (@tiptap/core schema + generateJSON, @tiptap/static-renderer,
+ *  zeed-dom as the parser host) load on demand — on a runtime that can't
+ *  host them the bridge settles to unavailable and callers get null/no-op.
+ *
+ *  Import behavior was proven by the demos probe (see packages/demos
+ *  TiptapProbe): all four modules load cleanly on both NS engines; the
+ *  failure mode left is a future version or bundler regression, which the
+ *  catch below degrades instead of crashing. */
+
+import type { TiptapJSON } from './types'
+
+interface Bridge {
+	generateJSON: (html: string, extensions: any[]) => any
+	renderToHTMLString: (options: { extensions: any[]; content: any }) => string
+	extensions: any[]
+}
+
+let bridge: Bridge | null | undefined
+
+/** zeed-dom's classList is a plain {contains,add,remove} object; tiptap's
+ *  codeBlock parseHTML spreads it. Wrap the VElement getter so it hands back
+ *  an iterable array that keeps the mutation methods. */
+function patchClassList(VElement: any): void {
+	const proto = VElement?.prototype
+	if (!proto) {
+		throw new Error('VElement.prototype unavailable')
+	}
+
+	const desc = Object.getOwnPropertyDescriptor(proto, 'classList')
+	if (!desc?.get) {
+		throw new Error('classList is not a prototype getter')
+	}
+
+	if ((desc.get as any).__xplatPatched) {
+		return
+	}
+
+	const patched = function (this: any) {
+		const cl = desc.get!.call(this)
+		if (cl && typeof cl[Symbol.iterator] !== 'function') {
+			const tokens = String(this.getAttribute('class') ?? '')
+				.split(/\s+/)
+				.filter(Boolean)
+
+			return Object.assign(tokens, cl)
+		}
+
+		return cl
+	}
+
+	;(patched as any).__xplatPatched = true
+	Object.defineProperty(proto, 'classList', {
+		configurable: true,
+		get: patched,
+		set: desc.set,
+	})
+}
+
+/** Install the minimal parse globals generateJSON's elementFromString
+ *  reads. Only installs when the host lacks them, so a real DOM (web
+ *  target) is never clobbered. */
+function installDomShim(zeed: any): void {
+	const g = globalThis as any
+	if (g.window?.DOMParser) {
+		return
+	}
+
+	class ZeedDOMParser {
+		parseFromString(html: string) {
+			const doc = zeed.createHTMLDocument()
+			doc.body.innerHTML = html
+			return doc
+		}
+	}
+
+	g.window = { DOMParser: ZeedDOMParser }
+	g.document = zeed.createHTMLDocument()
+}
+
+export async function ensureJSONBridge(): Promise<boolean> {
+	if (bridge !== undefined) {
+		return bridge !== null
+	}
+
+	try {
+		const [core, sk, sr, zeed] = await Promise.all([
+			import('@tiptap/core'),
+			import('@tiptap/starter-kit'),
+			import('@tiptap/static-renderer'),
+			import('zeed-dom'),
+		])
+
+		patchClassList(zeed.VElement)
+		installDomShim(zeed)
+		const StarterKit = (sk as any).default ?? (sk as any).StarterKit
+
+		bridge = {
+			generateJSON: core.generateJSON,
+			renderToHTMLString: sr.renderToHTMLString,
+			extensions: [StarterKit],
+		}
+
+		return true
+	} catch {
+		bridge = null
+		return false
+	}
+}
+
+/** HTML → doc JSON through tiptap's own parseHTML rules. Null when the
+ *  bridge hasn't loaded (call ensureJSONBridge first / check `ready`). */
+export function htmlToJSON(html: string): TiptapJSON | null {
+	return (bridge?.generateJSON(html, bridge.extensions) as TiptapJSON | undefined) ?? null
+}
+
+/** Doc JSON → HTML via tiptap's own renderHTML rules (no DOM). */
+export function jsonToHTML(doc: TiptapJSON): string | null {
+	return bridge?.renderToHTMLString({ extensions: bridge.extensions, content: doc }) ?? null
+}
+
+export function jsonBridgeReady(): boolean {
+	return bridge != null
+}

package/src/types.ts

@@ -0,0 +1,102 @@
+import type { Octane } from 'octane/jsx-runtime'
+
+/** Format vocabulary shared by the web (tiptap StarterKit) and native
+ *  (Aztec) backends. On web, starter-kit covers everything except
+ *  taskList/highlight/subscript/superscript/align* — those no-op there and
+ *  map to Aztec formats on Android. */
+export type TiptapFormat =
+	| 'bold'
+	| 'italic'
+	| 'underline'
+	| 'strikethrough'
+	| 'code'
+	| 'blockquote'
+	| 'bulletList'
+	| 'orderedList'
+	| 'taskList'
+	| 'codeBlock'
+	| 'horizontalRule'
+	| 'highlight'
+	| 'subscript'
+	| 'superscript'
+	| 'paragraph'
+	| 'heading1'
+	| 'heading2'
+	| 'heading3'
+	| 'heading4'
+	| 'heading5'
+	| 'heading6'
+	| 'alignLeft'
+	| 'alignCenter'
+	| 'alignRight'
+	| 'link'
+
+/** Tiptap document JSON (`{ type: 'doc', content: [...] }`). Opaque here —
+ *  callers round-trip through tiptap's own schema on both platforms. */
+export type TiptapJSON = { type: string; content?: unknown[] } & Record<string, unknown>
+
+export interface TiptapEditorHandle {
+	/** AppKit: returns the latest WebKit snapshot; commands are asynchronous. */
+	getHTML(): string
+	/** Web: `commands.setContent` (undo-aware). Native: Aztec `fromHtml` —
+	 *  resets undo history. */
+	setHTML(html: string): void
+	/** Doc JSON, or null while the native schema modules are still loading /
+	 *  on a runtime that can't host them (`json` flag). Web is always ready. */
+	/** AppKit: latest live engine JSON snapshot; null before onReady. */
+	getJSON(): TiptapJSON | null
+	setJSON(doc: TiptapJSON): void
+	apply(format: TiptapFormat): void
+	linkTo(url: string, anchor?: string): void
+	removeLink(): void
+	isActive(format: TiptapFormat): boolean
+	undo(): void
+	redo(): void
+	focus(): void
+	blur(): void
+	isFocused(): boolean
+	/** The platform surface — a tiptap `Editor` on web, `AztecText` on
+	 *  Android. */
+	/** AppKit: the XplatEditorHost transport, not the browser engine instance. */
+	native: any
+}
+
+export interface TiptapEditorProps {
+	id?: string
+	className?: string
+	style?: any
+	/** Document HTML. Seed at mount; external changes re-push (web: via
+	 *  setContent, preserving the diff loop the editor emitted is skipped). */
+	value?: string
+	/** Document JSON. Takes precedence over `value` when both arrive. On
+	 *  native it waits for the schema modules (see `onJSONReady`). */
+	json?: TiptapJSON
+	placeholder?: string
+	editable?: boolean
+	autofocus?: boolean
+	onReady?: () => void
+	/** Fires once when the native JSON bridge settles — `true` if the
+	 *  DOM-free tiptap modules loaded, `false` on runtimes that can't host
+	 *  them (JSON calls then no-op / return null). Never fires on web. */
+	/** AppKit: fires true with mounted engine readiness; no headless conversion bridge. */
+	onJSONReady?: (ready: boolean) => void
+	onChange?: (html: string) => void
+	onJSONChange?: (doc: TiptapJSON) => void
+	onSelectionChange?: (event: { start: number; end: number; active: TiptapFormat[] }) => void
+	onFocus?: () => void
+	onBlur?: () => void
+	ref?: Octane.Ref<TiptapEditorHandle>
+	android?: Record<string, any>
+	ios?: Record<string, any>
+	row?: number | string
+	col?: number | string
+	rowSpan?: number
+	colSpan?: number
+	dock?: 'left' | 'top' | 'right' | 'bottom'
+	left?: number
+	top?: number
+	flexGrow?: number
+	flexShrink?: number
+	alignSelf?: 'auto' | 'flex-start' | 'flex-end' | 'center' | 'stretch' | 'baseline'
+	order?: number
+}

package/types/index.d.ts

@@ -0,0 +1,8 @@
+import type { UniversalComponent } from 'octane/universal'
+import type { TiptapEditorProps, TiptapJSON } from './types'
+
+export declare const TiptapEditor: UniversalComponent<TiptapEditorProps>
+export declare const supported: boolean
+export declare function ensureJSONBridge(): Promise<boolean>
+export declare function jsonBridgeReady(): boolean
+export type * from './types'

package/types/index.macos.d.ts

@@ -0,0 +1,7 @@
+import type { UniversalComponent } from 'octane/universal'
+import type { TiptapEditorProps } from '../src/types'
+export declare const TiptapEditor: UniversalComponent<TiptapEditorProps>
+export declare const supported: boolean
+export type * from '../src/types'
+export declare function ensureJSONBridge(): Promise<boolean>
+export declare function jsonBridgeReady(): boolean

package/types/types.d.ts

@@ -0,0 +1,80 @@
+import type { Octane } from 'octane/jsx-runtime';
+/** Format vocabulary shared by the web (tiptap StarterKit) and native
+ *  (Aztec) backends. On web, starter-kit covers everything except
+ *  taskList/highlight/subscript/superscript/align* — those no-op there and
+ *  map to Aztec formats on Android. */
+export type TiptapFormat = 'bold' | 'italic' | 'underline' | 'strikethrough' | 'code' | 'blockquote' | 'bulletList' | 'orderedList' | 'taskList' | 'codeBlock' | 'horizontalRule' | 'highlight' | 'subscript' | 'superscript' | 'paragraph' | 'heading1' | 'heading2' | 'heading3' | 'heading4' | 'heading5' | 'heading6' | 'alignLeft' | 'alignCenter' | 'alignRight' | 'link';
+/** Tiptap document JSON (`{ type: 'doc', content: [...] }`). Opaque here —
+ *  callers round-trip through tiptap's own schema on both platforms. */
+export type TiptapJSON = {
+    type: string;
+    content?: unknown[];
+} & Record<string, unknown>;
+export interface TiptapEditorHandle {
+    /** AppKit: returns the latest WebKit snapshot; commands are asynchronous. */
+    getHTML(): string;
+    /** Web: `commands.setContent` (undo-aware). Native: Aztec `fromHtml` —
+     *  resets undo history. */
+    setHTML(html: string): void;
+    /** Doc JSON, or null while the native schema modules are still loading /
+     *  on a runtime that can't host them (`json` flag). Web is always ready. */
+    /** AppKit: latest live engine JSON snapshot; null before onReady. */
+    getJSON(): TiptapJSON | null;
+    setJSON(doc: TiptapJSON): void;
+    apply(format: TiptapFormat): void;
+    linkTo(url: string, anchor?: string): void;
+    removeLink(): void;
+    isActive(format: TiptapFormat): boolean;
+    undo(): void;
+    redo(): void;
+    focus(): void;
+    blur(): void;
+    isFocused(): boolean;
+    /** The platform surface — a tiptap `Editor` on web, `AztecText` on
+     *  Android. */
+    /** AppKit: the XplatEditorHost transport, not the browser engine instance. */
+    native: any;
+}
+export interface TiptapEditorProps {
+    id?: string;
+    className?: string;
+    style?: any;
+    /** Document HTML. Seed at mount; external changes re-push (web: via
+     *  setContent, preserving the diff loop the editor emitted is skipped). */
+    value?: string;
+    /** Document JSON. Takes precedence over `value` when both arrive. On
+     *  native it waits for the schema modules (see `onJSONReady`). */
+    json?: TiptapJSON;
+    placeholder?: string;
+    editable?: boolean;
+    autofocus?: boolean;
+    onReady?: () => void;
+    /** Fires once when the native JSON bridge settles — `true` if the
+     *  DOM-free tiptap modules loaded, `false` on runtimes that can't host
+     *  them (JSON calls then no-op / return null). Never fires on web. */
+    /** AppKit: fires true with mounted engine readiness; no headless conversion bridge. */
+    onJSONReady?: (ready: boolean) => void;
+    onChange?: (html: string) => void;
+    onJSONChange?: (doc: TiptapJSON) => void;
+    onSelectionChange?: (event: {
+        start: number;
+        end: number;
+        active: TiptapFormat[];
+    }) => void;
+    onFocus?: () => void;
+    onBlur?: () => void;
+    ref?: Octane.Ref<TiptapEditorHandle>;
+    android?: Record<string, any>;
+    ios?: Record<string, any>;
+    row?: number | string;
+    col?: number | string;
+    rowSpan?: number;
+    colSpan?: number;
+    dock?: 'left' | 'top' | 'right' | 'bottom';
+    left?: number;
+    top?: number;
+    flexGrow?: number;
+    flexShrink?: number;
+    alignSelf?: 'auto' | 'flex-start' | 'flex-end' | 'center' | 'stretch' | 'baseline';
+    order?: number;
+}

package/index.d.ts

@@ -1 +0,0 @@
-export {}

package/index.js

@@ -1,2 +0,0 @@
-// Reservation stub; implementation will arrive in a later release.
-module.exports = {}