@canvist/react-native 0.0.0 → 0.2.0

package/CanvistReactNative.podspec

@@ -0,0 +1,31 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name = "CanvistReactNative"
+  s.version = package["version"]
+  s.summary = package["description"]
+  s.homepage = package["homepage"]
+  s.license = { type: package["license"] }
+  s.author = { "Ifiok Jr." => "support@canvist.dev" }
+  s.source = { git: "https://github.com/canvist/canvist.git", tag: "v#{s.version}" }
+
+  s.platforms = { ios: "17.0" }
+  s.source_files = "ios/**/*.{h,mm}"
+  s.private_header_files = "ios/**/*.h"
+
+  # The native editor and its hosting (`CanvistHostView`, `CanvistHostCalls`):
+  # `platforms/apple/Canvist.podspec` in the canvist repository, which the
+  # app's Podfile points at.
+  s.dependency "Canvist", s.version.to_s
+  # Set before `install_modules_dependencies`, which adds its own settings to
+  # these: no Intel simulator slice, like `Canvist`, and `Canvist-Swift.h`,
+  # which a static Swift pod does not put on its dependents' search paths.
+  s.pod_target_xcconfig = {
+    "EXCLUDED_ARCHS[sdk=iphonesimulator*]" => "x86_64",
+    "HEADER_SEARCH_PATHS" => '"$(PODS_CONFIGURATION_BUILD_DIR)/Canvist/Swift Compatibility Header"',
+  }
+
+  install_modules_dependencies(s)
+end

package/android/build.gradle

@@ -0,0 +1,50 @@
+// The React Native glue for canvist's Android editor (`io.github.ifiokjr:canvist-android`).
+import groovy.json.JsonSlurper
+
+buildscript {
+  ext.getExtOrDefault = { name, fallback ->
+    rootProject.ext.has(name) ? rootProject.ext.get(name) : fallback
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion', '2.2.0')}"
+  }
+}
+
+apply plugin: "com.android.library"
+if (project.extensions.findByName("kotlin") == null) {
+  apply plugin: "kotlin-android"
+}
+apply plugin: "com.facebook.react"
+
+// The editor is released in step with this package, so they share a version.
+def canvistVersion = new JsonSlurper().parse(file("../package.json")).version
+
+android {
+  namespace "io.github.ifiokjr.canvist.reactnative"
+  compileSdkVersion getExtOrDefault("compileSdkVersion", 36)
+
+  defaultConfig {
+    minSdkVersion getExtOrDefault("minSdkVersion", 24)
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
+  }
+
+  sourceSets {
+    main.java.srcDirs += "src/main/kotlin"
+  }
+}
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  implementation "io.github.ifiokjr:canvist-android:${canvistVersion}"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" />

package/android/src/main/kotlin/io/github/ifiokjr/canvist/reactnative/CanvistEditorEvent.kt

@@ -0,0 +1,32 @@
+package io.github.ifiokjr.canvist.reactnative
+
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+
+/** One of the view's events, with its payload. */
+internal class CanvistEditorEvent(
+    surfaceId: Int,
+    viewId: Int,
+    private val name: String,
+    private val payload: WritableMap,
+) : Event<CanvistEditorEvent>(surfaceId, viewId) {
+    override fun getEventName() = name
+
+    override fun getEventData() = payload
+
+    companion object {
+        const val READY = "topEditorReady"
+        const val CHANGE = "topEditorChange"
+        const val FOCUS = "topEditorFocus"
+        const val ERROR = "topEditorError"
+
+        /** The JavaScript prop each event calls. */
+        val registrations =
+            mapOf(
+                READY to "onEditorReady",
+                CHANGE to "onEditorChange",
+                FOCUS to "onEditorFocus",
+                ERROR to "onEditorError",
+            )
+    }
+}

package/android/src/main/kotlin/io/github/ifiokjr/canvist/reactnative/CanvistEditorViewManager.kt

@@ -0,0 +1,145 @@
+package io.github.ifiokjr.canvist.reactnative
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.viewmanagers.CanvistEditorViewManagerDelegate
+import com.facebook.react.viewmanagers.CanvistEditorViewManagerInterface
+import io.github.ifiokjr.canvist.CanvistHostView
+import io.github.ifiokjr.canvist.EditorChange
+
+/**
+ * The Fabric view manager for `CanvistEditorView`. The editor starts once a
+ * view's first props have all arrived; later changes to `extensions` and
+ * `content` have no effect, as the JavaScript API documents.
+ */
+@ReactModule(name = CanvistEditorViewManager.NAME)
+class CanvistEditorViewManager :
+    SimpleViewManager<CanvistHostView>(),
+    CanvistEditorViewManagerInterface<CanvistHostView> {
+    private val delegate = CanvistEditorViewManagerDelegate(this)
+
+    /** Props of views whose editors have not started yet. */
+    private val pending = HashMap<CanvistHostView, StartProps>()
+
+    override fun getDelegate(): ViewManagerDelegate<CanvistHostView> = delegate
+
+    override fun getName() = NAME
+
+    override fun createViewInstance(context: ThemedReactContext): CanvistHostView = CanvistHostView(context).apply { listener = Events }
+
+    override fun setEditorId(
+        view: CanvistHostView,
+        value: String?,
+    ) {
+        pending.getOrPut(view, ::StartProps).editorId = value
+    }
+
+    override fun setExtensions(
+        view: CanvistHostView,
+        value: ReadableArray?,
+    ) {
+        val names = value?.toArrayList()?.filterIsInstance<String>() ?: emptyList()
+        pending.getOrPut(view, ::StartProps).extensions = names
+    }
+
+    override fun setContentFormat(
+        view: CanvistHostView,
+        value: String?,
+    ) {
+        pending.getOrPut(view, ::StartProps).format = value
+    }
+
+    override fun setContent(
+        view: CanvistHostView,
+        value: String?,
+    ) {
+        pending.getOrPut(view, ::StartProps).content = value
+    }
+
+    override fun setFontSize(
+        view: CanvistHostView,
+        value: Float,
+    ) {
+        view.fontSize = value
+    }
+
+    override fun onAfterUpdateTransaction(view: CanvistHostView) {
+        super.onAfterUpdateTransaction(view)
+        val props = pending.remove(view) ?: return
+        val editorId = props.editorId?.takeIf { it.isNotEmpty() } ?: return
+        view.start(editorId, props.extensions, props.format?.ifEmpty { null }, props.content?.ifEmpty { null })
+    }
+
+    override fun onDropViewInstance(view: CanvistHostView) {
+        pending.remove(view)
+        view.stop()
+        super.onDropViewInstance(view)
+    }
+
+    override fun focus(view: CanvistHostView) = view.focusEditor()
+
+    override fun blur(view: CanvistHostView) = view.blurEditor()
+
+    override fun getExportedCustomDirectEventTypeConstants(): Map<String, Any> =
+        CanvistEditorEvent.registrations.mapValues { (_, prop) -> mapOf("registrationName" to prop) }
+
+    private class StartProps {
+        var editorId: String? = null
+        var extensions: List<String> = emptyList()
+        var format: String? = null
+        var content: String? = null
+    }
+
+    /** Sends each host's reports to JavaScript as the view's events. */
+    private object Events : CanvistHostView.Listener {
+        override fun onReady(
+            view: CanvistHostView,
+            editorId: String,
+        ) = dispatch(view, CanvistEditorEvent.READY) { putString("editorId", editorId) }
+
+        override fun onChange(
+            view: CanvistHostView,
+            change: EditorChange,
+        ) = dispatch(view, CanvistEditorEvent.CHANGE) {
+            putBoolean("document", change.document)
+            putBoolean("selection", change.selection)
+            putBoolean("composition", change.composition)
+        }
+
+        override fun onFocusChange(
+            view: CanvistHostView,
+            focused: Boolean,
+        ) = dispatch(view, CanvistEditorEvent.FOCUS) { putBoolean("focused", focused) }
+
+        override fun onError(
+            view: CanvistHostView,
+            code: String,
+            message: String,
+        ) = dispatch(view, CanvistEditorEvent.ERROR) {
+            putString("code", code)
+            putString("message", message)
+        }
+
+        private fun dispatch(
+            view: CanvistHostView,
+            name: String,
+            payload: WritableMap.() -> Unit,
+        ) {
+            val context = view.context as? ReactContext ?: return
+            val dispatcher = UIManagerHelper.getEventDispatcherForReactTag(context, view.id) ?: return
+            val data = Arguments.createMap().apply(payload)
+            dispatcher.dispatchEvent(CanvistEditorEvent(UIManagerHelper.getSurfaceId(view), view.id, name, data))
+        }
+    }
+
+    companion object {
+        const val NAME = "CanvistEditorView"
+    }
+}

package/android/src/main/kotlin/io/github/ifiokjr/canvist/reactnative/CanvistEditorsModule.kt

@@ -0,0 +1,81 @@
+package io.github.ifiokjr.canvist.reactnative
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.annotations.ReactModule
+import io.github.ifiokjr.canvist.Command
+import io.github.ifiokjr.canvist.HostedEditors
+import io.github.ifiokjr.canvist.docFormat
+import io.github.ifiokjr.canvist.selectRangeJson
+import io.github.ifiokjr.canvist.selectionJson
+
+/**
+ * The `CanvistEditors` TurboModule: synchronous calls, on the JavaScript
+ * thread, into the editors [HostedEditors] finds by `editorId`. A failure
+ * throws with `[canvist:<code>] <reason>` as its message, which React Native
+ * rethrows in JavaScript.
+ */
+@ReactModule(name = CanvistEditorsModule.NAME)
+class CanvistEditorsModule(
+    context: ReactApplicationContext,
+) : NativeCanvistEditorsSpec(context) {
+    override fun getName() = NAME
+
+    override fun run(
+        editorId: String,
+        name: String,
+        args: String,
+    ): Boolean = HostedEditors.call(editorId) { it.run(Command(name, args)) }
+
+    override fun can(
+        editorId: String,
+        name: String,
+        args: String,
+    ): Boolean = HostedEditors.call(editorId) { it.can(Command(name, args)) }
+
+    override fun query(
+        editorId: String,
+        name: String,
+        args: String,
+    ): String = HostedEditors.call(editorId) { it.query(name, args) }
+
+    override fun load(
+        editorId: String,
+        format: String,
+        content: String,
+    ): Boolean =
+        HostedEditors.call(editorId) {
+            it.load(docFormat(format), content)
+            true
+        }
+
+    override fun exportDocument(
+        editorId: String,
+        format: String,
+    ): String = HostedEditors.call(editorId) { it.export(docFormat(format)) }
+
+    override fun selection(editorId: String): String = HostedEditors.call(editorId) { it.selectionJson() }
+
+    override fun select(
+        editorId: String,
+        range: String,
+    ): Boolean = HostedEditors.call(editorId) { it.selectRangeJson(range) }
+
+    override fun selectAll(editorId: String): Boolean = HostedEditors.call(editorId) { it.selectAll() }
+
+    override fun insertText(
+        editorId: String,
+        text: String,
+    ): Boolean = HostedEditors.call(editorId) { it.insertText(text) }
+
+    override fun undo(editorId: String): Boolean = HostedEditors.call(editorId) { it.undo() }
+
+    override fun redo(editorId: String): Boolean = HostedEditors.call(editorId) { it.redo() }
+
+    override fun canUndo(editorId: String): Boolean = HostedEditors.call(editorId) { it.canUndo() }
+
+    override fun canRedo(editorId: String): Boolean = HostedEditors.call(editorId) { it.canRedo() }
+
+    companion object {
+        const val NAME = "CanvistEditors"
+    }
+}

package/android/src/main/kotlin/io/github/ifiokjr/canvist/reactnative/CanvistReactNativePackage.kt

@@ -0,0 +1,33 @@
+package io.github.ifiokjr.canvist.reactnative
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import com.facebook.react.uimanager.ViewManager
+
+/** canvist's editor view and the module that calls into its editors. */
+class CanvistReactNativePackage : BaseReactPackage() {
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> = listOf(CanvistEditorViewManager())
+
+    override fun getModule(
+        name: String,
+        reactContext: ReactApplicationContext,
+    ): NativeModule? = if (name == CanvistEditorsModule.NAME) CanvistEditorsModule(reactContext) else null
+
+    override fun getReactModuleInfoProvider() =
+        ReactModuleInfoProvider {
+            mapOf(
+                CanvistEditorsModule.NAME to
+                    ReactModuleInfo(
+                        name = CanvistEditorsModule.NAME,
+                        className = CanvistEditorsModule.NAME,
+                        canOverrideExistingModule = false,
+                        needsEagerInit = false,
+                        isCxxModule = false,
+                        isTurboModule = true,
+                    ),
+            )
+        }
+}

package/dist/CanvistEditorViewNativeComponent.d.ts

@@ -0,0 +1,52 @@
+/**
+ * The Fabric component spec for the native editor view: React Native's
+ * codegen reads this file to generate the iOS and Android glue, so it keeps
+ * to the shapes codegen understands.
+ *
+ * @module
+ */
+import type * as React from "react";
+import type { CodegenTypes, HostComponent, ViewProps } from "react-native";
+/** What changed, after every change to the document or selection. */
+export type EditorChangeEvent = Readonly<{
+    document: boolean;
+    selection: boolean;
+    composition: boolean;
+}>;
+/** The view gained or lost focus. */
+export type EditorFocusEvent = Readonly<{
+    focused: boolean;
+}>;
+/** The view could not create or load its editor. */
+export type EditorErrorEvent = Readonly<{
+    code: string;
+    message: string;
+}>;
+/** The view is ready for calls through the `CanvistEditors` module. */
+export type EditorReadyEvent = Readonly<{
+    editorId: string;
+}>;
+export interface NativeProps extends ViewProps {
+    /** The key the `CanvistEditors` module finds this view's editor by. */
+    editorId: string;
+    /** The extensions to register, by name. Read when the view is created. */
+    extensions: ReadonlyArray<string>;
+    /** The format of `content`. Read when the view is created. */
+    contentFormat?: string;
+    /** The document to start with. Read when the view is created. */
+    content?: string;
+    /** The body text size before the user's text size setting; 0 is the platform's default. */
+    fontSize?: CodegenTypes.WithDefault<CodegenTypes.Float, 0>;
+    onEditorReady?: CodegenTypes.DirectEventHandler<EditorReadyEvent>;
+    onEditorChange?: CodegenTypes.DirectEventHandler<EditorChangeEvent>;
+    onEditorFocus?: CodegenTypes.DirectEventHandler<EditorFocusEvent>;
+    onEditorError?: CodegenTypes.DirectEventHandler<EditorErrorEvent>;
+}
+export type CanvistEditorViewType = HostComponent<NativeProps>;
+interface NativeCommands {
+    focus: (viewRef: React.ElementRef<CanvistEditorViewType>) => void;
+    blur: (viewRef: React.ElementRef<CanvistEditorViewType>) => void;
+}
+export declare const Commands: NativeCommands;
+declare const _default: HostComponent<NativeProps>;
+export default _default;

package/dist/NativeCanvistEditors.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The TurboModule spec for calls into a view's editor. Every method is
+ * synchronous on the JavaScript thread, so commands and queries answer at
+ * once, as they do on the web. Methods return a value even when there is
+ * nothing to say, because React Native runs `void` methods asynchronously.
+ *
+ * Failures throw with `[canvist:<code>] <reason>` in the message.
+ *
+ * @module
+ */
+import type { TurboModule } from "react-native";
+export interface Spec extends TurboModule {
+    run(editorId: string, name: string, args: string): boolean;
+    can(editorId: string, name: string, args: string): boolean;
+    query(editorId: string, name: string, args: string): string;
+    /** Returns `true`. */
+    load(editorId: string, format: string, content: string): boolean;
+    exportDocument(editorId: string, format: string): string;
+    selection(editorId: string): string;
+    /** Returns whether the selection moved. */
+    select(editorId: string, range: string): boolean;
+    /** Returns whether the selection moved. */
+    selectAll(editorId: string): boolean;
+    insertText(editorId: string, text: string): boolean;
+    undo(editorId: string): boolean;
+    redo(editorId: string): boolean;
+    canUndo(editorId: string): boolean;
+    canRedo(editorId: string): boolean;
+}
+declare const _default: Spec;
+export default _default;

package/dist/bridge.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The bridge from the typed editor to one native view: synchronous calls
+ * through the `CanvistEditors` TurboModule, and focus through the view's
+ * commands.
+ *
+ * @module
+ */
+import type { NativeBridge } from "@canvist/headless/native";
+import type * as React from "react";
+import { type CanvistEditorViewType } from "./CanvistEditorViewNativeComponent.ts";
+import type { Spec } from "./NativeCanvistEditors.ts";
+/** The mounted native view, as React refers to it. */
+export type EditorViewInstance = React.ElementRef<CanvistEditorViewType>;
+/**
+ * A bridge to the editor `editorId` names through `module`, focusing the
+ * view `view` returns. Focus calls do nothing once the view is gone.
+ */
+export declare function nativeBridge(module: Spec, editorId: string, view: () => EditorViewInstance | null): NativeBridge;

package/dist/editor.d.ts

@@ -0,0 +1,91 @@
+/**
+ * The editor component and hooks.
+ *
+ * @module
+ */
+import type { CanvistError, Content, StarterKit } from "@canvist/headless";
+import { NativeEditor } from "@canvist/headless/native";
+import { type ReactElement, type Ref } from "react";
+import type { ViewProps } from "react-native";
+import { type EditorViewInstance } from "./bridge.ts";
+import { type NativeProps } from "./CanvistEditorViewNativeComponent.ts";
+/** The extensions the native editors compile in: TipTap's StarterKit, or some of it. */
+export type NativeExtensions = readonly StarterKit[number][];
+/**
+ * A native editor whose commands, queries, and documents are typed from
+ * the extensions `E`, with the same API as `@canvist/web`'s editor.
+ */
+export type Editor<E extends NativeExtensions> = NativeEditor<E>;
+/** Options for {@link useCanvistEditor} and {@link CanvistEditor}. */
+export interface EditorOptions<E extends NativeExtensions> {
+    /** The extensions to register: every StarterKit extension by default. Read once. */
+    readonly extensions?: E;
+    /** The document to start with: one empty paragraph by default. Read once. */
+    readonly content?: Content<E>;
+    /** The body text size before the user's text size setting; the platform's body size by default. */
+    readonly fontSize?: number;
+    /** Called when the view could not create its editor or load `content`. */
+    readonly onError?: (error: CanvistError) => void;
+}
+/** Props for {@link CanvistView}: what {@link useCanvistEditor} returns, plus the view's own. */
+export interface CanvistViewProps extends NativeProps {
+    readonly ref?: Ref<EditorViewInstance>;
+}
+/** What {@link useCanvistEditor} returns. */
+export interface CanvistEditorHandle<E extends NativeExtensions> {
+    /** The editor, once the view has created it; `null` before that. */
+    readonly editor: Editor<E> | null;
+    /** Spread onto a {@link CanvistView}, alongside its style and accessibility props. */
+    readonly props: CanvistViewProps;
+}
+/**
+ * The native editor view. Render it with the props {@link useCanvistEditor}
+ * returns; give it a size, as it scrolls its own document.
+ */
+export declare const CanvistView: import("react-native").HostComponent<NativeProps>;
+/**
+ * Create an editor in the {@link CanvistView} you spread `props` onto.
+ * `extensions` and `content` are read when the view is created; later
+ * changes to them have no effect.
+ *
+ * ```tsx
+ * function Notes() {
+ * 	const { editor, props } = useCanvistEditor({ extensions: [bold, heading] });
+ *
+ * 	return (
+ * 		<>
+ * 			<Button title="Bold" onPress={() => editor?.commands.toggleBold()} />
+ * 			<CanvistView {...props} style={{ flex: 1 }} />
+ * 		</>
+ * 	);
+ * }
+ * ```
+ */
+export declare function useCanvistEditor<const E extends NativeExtensions = StarterKit>(options?: EditorOptions<E>): CanvistEditorHandle<E>;
+/**
+ * Read `select(editor)` and re-render whenever it changes: after any edit,
+ * selection change, or change of focus. `select` must return a primitive
+ * or a value that stays the same object while nothing changed, as with
+ * `useSyncExternalStore`. Until the editor exists, the value is `fallback`.
+ */
+export declare function useEditorState<E extends NativeExtensions, T>(editor: Editor<E> | null, select: (editor: Editor<E>) => T, fallback: T): T;
+/** Props for {@link CanvistEditor}: the editor's options and the view's. */
+export interface CanvistEditorProps<E extends NativeExtensions> extends EditorOptions<E>, ViewProps {
+    /** Called once the editor is ready. */
+    readonly onReady?: (editor: Editor<E>) => void;
+    /** Called after every change to the document, the selection, or focus. */
+    readonly onUpdate?: (editor: Editor<E>) => void;
+}
+/**
+ * A native canvist editor: the iOS or Android `CanvistView`. Give it a
+ * size, as it scrolls its own document.
+ *
+ * ```tsx
+ * <CanvistEditor
+ * 	content={{ format: "markdown", input: "# Notes" }}
+ * 	onUpdate={(editor) => save(editor.export("markdown"))}
+ * 	style={{ flex: 1 }}
+ * />
+ * ```
+ */
+export declare function CanvistEditor<const E extends NativeExtensions = StarterKit>(props: CanvistEditorProps<E>): ReactElement;

package/dist/mod.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The canvist rich-text editor for React Native.
+ *
+ * `CanvistEditor` shows the native iOS or Android editor: canvist's Rust
+ * engine, painted natively and edited through the platform's own text
+ * input, not a WebView. Commands, queries, and documents are typed from the
+ * extensions you register, with the same API as `@canvist/web`: calling a
+ * command you did not register is a type error. Calls are synchronous.
+ *
+ * ```tsx
+ * import { CanvistEditor, bold, heading } from "@canvist/react-native";
+ *
+ * <CanvistEditor
+ * 	extensions={[bold, heading]}
+ * 	content={{ format: "markdown", input: "# Notes" }}
+ * 	onReady={(editor) => editor.commands.toggleHeading({ level: 2 })}
+ * 	style={{ flex: 1 }}
+ * />
+ * ```
+ *
+ * @module
+ */
+export type { CanvistError, CommandName, CommandParams, Commands, Content, DocJson, ErrorCode, ExtensionDescriptor, Extensions, Format, Position, Queries, QueryName, QueryParams, QueryResult, Range, Registered, StarterKit, } from "@canvist/headless";
+export * from "@canvist/headless/extensions";
+export { isCanvistError } from "@canvist/headless/native";
+export type { EditorChangeEvent, EditorErrorEvent, EditorFocusEvent, } from "./CanvistEditorViewNativeComponent.ts";
+export { CanvistEditor, type CanvistEditorHandle, type CanvistEditorProps, CanvistView, type CanvistViewProps, type Editor, type EditorOptions, type NativeExtensions, useCanvistEditor, useEditorState, } from "./editor.tsx";

package/ios/CanvistEditorComponentView.h

@@ -0,0 +1,10 @@
+#import <React/RCTViewComponentView.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// The Fabric component view for `CanvistEditorView`: hosts a `CanvistView`
+/// and turns its changes into events.
+@interface CanvistEditorComponentView : RCTViewComponentView
+@end
+
+NS_ASSUME_NONNULL_END