@domternal/react 0.5.1 → 0.6.0

package/README.md

@@ -3,13 +3,13 @@
 [![Version](https://img.shields.io/npm/v/@domternal/react.svg)](https://www.npmjs.com/package/@domternal/react)
 [![MIT License](https://img.shields.io/badge/License-MIT-blue.svg)](https://github.com/domternal/domternal/blob/main/LICENSE)
 
-A lightweight, extensible rich text editor toolkit built on <u>[ProseMirror](https://prosemirror.net/)</u>. Framework-agnostic headless core with first-class Angular and React support.  
+A lightweight, extensible rich text editor toolkit built on <u>[ProseMirror](https://prosemirror.net/)</u>. Framework-agnostic headless core with first-class Angular, React, and Vue support.  
 Use it headless with vanilla JS/TS, add the built-in toolbar and theme, or drop in ready-made framework components. Fully tree-shakeable, import only what you use, unused extensions are stripped from your bundle.
 
 ## Links
 
 <u>[Website](https://domternal.dev)</u> &nbsp;&nbsp;&nbsp;•&nbsp;&nbsp;&nbsp; <u>[Documentation](https://domternal.dev/v1/introduction)</u>  
-<u>[StackBlitz (Angular)](https://stackblitz.com/edit/domternal-angular-full-example)</u> &nbsp;&nbsp;&nbsp;•&nbsp;&nbsp;&nbsp; <u>[StackBlitz (React)](https://stackblitz.com/edit/domternal-react-full-example)</u> &nbsp;&nbsp;&nbsp;•&nbsp;&nbsp;&nbsp; <u>[StackBlitz (Vanilla TS)](https://stackblitz.com/edit/domternal-vanilla-full-example)</u> 
+<u>[StackBlitz (Angular)](https://stackblitz.com/edit/domternal-angular-full-example)</u> &nbsp;&nbsp;&nbsp;•&nbsp;&nbsp;&nbsp; <u>[StackBlitz (React)](https://stackblitz.com/edit/domternal-react-full-example)</u> &nbsp;&nbsp;&nbsp;•&nbsp;&nbsp;&nbsp; <u>[StackBlitz (Vue)](https://stackblitz.com/edit/domternal-vue-full-example)</u> &nbsp;&nbsp;&nbsp;•&nbsp;&nbsp;&nbsp; <u>[StackBlitz (Vanilla TS)](https://stackblitz.com/edit/domternal-vanilla-full-example)</u> 
 
 ## Features
 
@@ -18,13 +18,14 @@ See <u>[Packages & Bundle Size](https://domternal.dev/v1/packages)</u> for a ful
 - **Headless core** - use with any framework or vanilla JS/TS
 - **Angular components** - editor, toolbar, bubble menu, floating menu, emoji picker (signals, OnPush, zoneless-ready)
 - **React components** - composable `Domternal` component, toolbar, bubble menu, floating menu, emoji picker, custom node views (React 18+)
-- **57 extensions across 11 packages** - 23 nodes, 9 marks, and 25 behavior extensions
+- **Vue components** - composable `Domternal` component, `useEditor`/`useEditorState` composables, toolbar, bubble menu, floating menu, emoji picker, custom node views (Vue 3.3+)
+- **57 extensions across 12 packages** - 23 nodes, 9 marks, and 25 behavior extensions
 - **140+ chainable commands** - `editor.chain().focus().toggleBold().run()`
 - **Full table support** - cell merging, column resize, row/column controls, cell toolbar, all free and MIT licensed
 - **Tree-shakeable** - import only what you use, your bundler strips the rest
 - **~38 KB gzipped** (own code), <u>[~108 KB total](https://domternal.dev/v1/packages)</u> with ProseMirror
 - **TypeScript first** - 100% typed, zero `any`
-- **6,400+ tests** - 2,677 unit tests and 3,793 E2E tests across 80 Playwright specs
+- **8,500+ tests** - 2,677 unit tests and 5,800+ E2E tests across 120+ Playwright specs
 - **Light and dark theme** - 70+ CSS custom properties for full visual control
 - **Inline styles export** - `getHTML({ styled: true })` produces inline CSS ready for email clients, CMS, and Google Docs
 - **SSR helpers** - `generateHTML`, `generateJSON`, `generateText` for server-side rendering

package/dist/index.d.ts

@@ -1,33 +1,467 @@
-export { useEditor, DEFAULT_EXTENSIONS } from './useEditor.js';
-export type { UseEditorOptions } from './useEditor.js';
-export { useEditorState } from './useEditorState.js';
-export type { EditorState } from './useEditorState.js';
-export { useCurrentEditor, EditorProvider } from './EditorContext.js';
-export type { EditorProviderProps } from './EditorContext.js';
-export { Domternal } from './Domternal.js';
-export type { DomternalProps } from './Domternal.js';
-export { DomternalEditor } from './DomternalEditor.js';
-export type { DomternalEditorProps, DomternalEditorRef } from './DomternalEditor.js';
-export { EditorContent } from './EditorContent.js';
-export type { EditorContentProps } from './EditorContent.js';
-export { DomternalToolbar } from './toolbar/DomternalToolbar.js';
-export type { DomternalToolbarProps } from './toolbar/DomternalToolbar.js';
-export { DomternalBubbleMenu } from './bubble-menu/DomternalBubbleMenu.js';
-export type { DomternalBubbleMenuProps } from './bubble-menu/DomternalBubbleMenu.js';
-export { DomternalFloatingMenu } from './DomternalFloatingMenu.js';
-export type { DomternalFloatingMenuProps } from './DomternalFloatingMenu.js';
-export { DomternalEmojiPicker } from './emoji-picker/DomternalEmojiPicker.js';
-export type { DomternalEmojiPickerProps } from './emoji-picker/DomternalEmojiPicker.js';
-export type { EmojiPickerItem } from './emoji-picker/useEmojiPicker.js';
-export { ReactNodeViewRenderer } from './node-views/ReactNodeViewRenderer.js';
-export type { ReactNodeViewProps, ReactNodeViewRendererOptions } from './node-views/ReactNodeViewRenderer.js';
-export { NodeViewWrapper } from './node-views/NodeViewWrapper.js';
-export type { NodeViewWrapperProps } from './node-views/NodeViewWrapper.js';
-export { NodeViewContent } from './node-views/NodeViewContent.js';
-export type { NodeViewContentProps } from './node-views/NodeViewContent.js';
-export { useReactNodeView } from './node-views/ReactNodeViewContext.js';
-export { Editor } from '@domternal/core';
-export type { Content, AnyExtension, FocusPosition, JSONContent } from '@domternal/core';
-export { generateHTML, generateJSON, generateText } from '@domternal/core';
-export type { GenerateHTMLOptions, GenerateJSONOptions, GenerateTextOptions } from '@domternal/core';
-//# sourceMappingURL=index.d.ts.map
+import * as react from 'react';
+import { DependencyList, ReactNode, HTMLAttributes, Ref, ElementType, RefCallback } from 'react';
+import { AnyExtension, Content, FocusPosition, Editor, JSONContent, IconSet, ToolbarLayoutEntry, BubbleMenuOptions, FloatingMenuOptions } from '@domternal/core';
+export { AnyExtension, Content, Editor, FocusPosition, GenerateHTMLOptions, GenerateJSONOptions, GenerateTextOptions, JSONContent, generateHTML, generateJSON, generateText } from '@domternal/core';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+
+declare const DEFAULT_EXTENSIONS: AnyExtension[];
+interface UseEditorOptions {
+    /** Custom extensions to add to the editor. */
+    extensions?: AnyExtension[];
+    /** Initial editor content (HTML string or JSON). */
+    content?: Content;
+    /** Whether the editor is editable. @default true */
+    editable?: boolean;
+    /** Where to autofocus on mount. @default false */
+    autofocus?: FocusPosition;
+    /** Output format for content comparison. @default 'html' */
+    outputFormat?: 'html' | 'json';
+    /**
+     * Set to false to delay editor creation to useEffect (SSR-safe).
+     * When false, the editor will be null during server-side rendering
+     * and created only after the component mounts in the browser.
+     * @default true
+     */
+    immediatelyRender?: boolean;
+    /** Called when the editor instance is created. */
+    onCreate?: (editor: Editor) => void;
+    /** Called when the document content changes. */
+    onUpdate?: (props: {
+        editor: Editor;
+    }) => void;
+    /** Called when the selection changes without content change. */
+    onSelectionChange?: (props: {
+        editor: Editor;
+    }) => void;
+    /** Called when the editor gains focus. */
+    onFocus?: (props: {
+        editor: Editor;
+        event: FocusEvent;
+    }) => void;
+    /** Called when the editor loses focus. */
+    onBlur?: (props: {
+        editor: Editor;
+        event: FocusEvent;
+    }) => void;
+    /** Called before the editor is destroyed. */
+    onDestroy?: () => void;
+}
+/**
+ * Core hook for creating and managing a Domternal editor instance.
+ *
+ * @param options - Editor configuration
+ * @param deps - Optional dependency array. When any value changes, the editor
+ *   is destroyed and recreated (content is preserved). Useful for dynamic
+ *   configuration that requires a full editor rebuild.
+ *
+ * @example
+ * ```tsx
+ * const { editor, editorRef } = useEditor({ extensions, content });
+ * return <div className="dm-editor"><div ref={editorRef} /></div>;
+ * ```
+ *
+ * @example SSR-safe usage (Next.js)
+ * ```tsx
+ * const { editor, editorRef } = useEditor({
+ *   extensions,
+ *   content,
+ *   immediatelyRender: false,
+ * });
+ * ```
+ *
+ * @example With deps for forced recreation
+ * ```tsx
+ * const { editor, editorRef } = useEditor({ extensions, content }, [locale]);
+ * // Editor is recreated when locale changes
+ * ```
+ */
+declare function useEditor(options?: UseEditorOptions, deps?: DependencyList): {
+    editor: Editor | null;
+    editorRef: react.RefObject<HTMLDivElement | null>;
+};
+
+/**
+ * Full editor state returned when no selector is provided.
+ */
+interface EditorState {
+    htmlContent: string;
+    jsonContent: JSONContent | null;
+    isEmpty: boolean;
+    isFocused: boolean;
+    isEditable: boolean;
+}
+/**
+ * Subscribe to editor state changes.
+ *
+ * **Overload 1 - Full state:**
+ * ```tsx
+ * const { htmlContent, isEmpty } = useEditorState(editor);
+ * ```
+ *
+ * **Overload 2 - Selector (granular, avoids unnecessary re-renders):**
+ * ```tsx
+ * const isBold = useEditorState(editor, (ed) => ed.isActive('bold'));
+ * ```
+ */
+declare function useEditorState(editor: Editor | null): EditorState;
+declare function useEditorState<T>(editor: Editor | null, selector: (editor: Editor) => T): T | undefined;
+
+interface EditorContextValue {
+    editor: Editor | null;
+}
+interface EditorProviderProps {
+    /** The editor instance to provide to descendants. */
+    editor: Editor | null;
+    children: ReactNode;
+}
+/**
+ * Provides an editor instance to all descendant components via React Context.
+ *
+ * Components like DomternalToolbar, DomternalBubbleMenu, DomternalFloatingMenu,
+ * and DomternalEmojiPicker will automatically use this editor when no explicit
+ * `editor` prop is passed.
+ *
+ * @example
+ * ```tsx
+ * const { editor } = useEditor({ extensions, content });
+ *
+ * <EditorProvider editor={editor}>
+ *   <DomternalToolbar />
+ *   <EditorContent editor={editor} />
+ *   <DomternalBubbleMenu contexts={{ text: ['bold', 'italic'] }} />
+ * </EditorProvider>
+ * ```
+ */
+declare function EditorProvider({ editor, children }: EditorProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Access the editor instance from the nearest EditorProvider.
+ *
+ * @returns `{ editor }` where editor may be null if the provider has no editor yet.
+ * @throws If used outside of an EditorProvider (optional - returns null editor instead).
+ */
+declare function useCurrentEditor(): EditorContextValue;
+
+interface DomternalToolbarProps {
+    /** The editor instance. If omitted, uses EditorProvider context. */
+    editor?: Editor;
+    /** Custom icon set. When provided, only these icons are used (no defaultIcons fallback). */
+    icons?: IconSet;
+    /** Custom toolbar layout. */
+    layout?: ToolbarLayoutEntry[];
+}
+declare function DomternalToolbar({ editor: editorProp, icons, layout }: DomternalToolbarProps): react_jsx_runtime.JSX.Element | null;
+
+interface DomternalBubbleMenuProps {
+    /** The editor instance. If omitted, uses EditorProvider context. */
+    editor?: Editor;
+    /** Custom visibility function. */
+    shouldShow?: BubbleMenuOptions['shouldShow'];
+    /** Position relative to selection. @default 'top' */
+    placement?: 'top' | 'bottom';
+    /** Pixel offset from selection. @default 8 */
+    offset?: number;
+    /** Debounce delay in ms. @default 0 */
+    updateDelay?: number;
+    /** Fixed item names, e.g. ['bold', 'italic', 'code']. */
+    items?: string[];
+    /** Context-aware: map context names to item arrays, true for all, or null to disable. */
+    contexts?: Record<string, string[] | true | null>;
+    /** Additional content rendered after buttons. */
+    children?: React.ReactNode;
+}
+declare function DomternalBubbleMenu({ editor: editorProp, shouldShow, placement, offset, updateDelay, items, contexts, children, }: DomternalBubbleMenuProps): react_jsx_runtime.JSX.Element;
+
+interface DomternalFloatingMenuProps {
+    /** The editor instance. If omitted, uses EditorProvider context. */
+    editor?: Editor;
+    /** Custom visibility function. */
+    shouldShow?: FloatingMenuOptions['shouldShow'];
+    /** Pixel offset from trigger. @default 0 */
+    offset?: number;
+    /** Content to render inside the floating menu. */
+    children?: React.ReactNode;
+}
+declare function DomternalFloatingMenu({ editor: editorProp, shouldShow, offset, children, }: DomternalFloatingMenuProps): react_jsx_runtime.JSX.Element;
+
+interface EmojiPickerItem {
+    emoji: string;
+    name: string;
+    group: string;
+}
+
+interface DomternalEmojiPickerProps {
+    /** The editor instance. If omitted, uses EditorProvider context. */
+    editor?: Editor;
+    /** Array of emoji items with emoji, name, and group. */
+    emojis: EmojiPickerItem[];
+}
+declare function DomternalEmojiPicker({ editor: editorProp, emojis }: DomternalEmojiPickerProps): react_jsx_runtime.JSX.Element;
+
+interface DomternalProps extends UseEditorOptions {
+    /** Optional dependency array for forced editor recreation. */
+    deps?: DependencyList;
+    children: ReactNode;
+}
+/**
+ * Composable root component that creates an editor and provides it to all
+ * subcomponents via context. No need to pass `editor` prop to children.
+ *
+ * @example
+ * ```tsx
+ * <Domternal extensions={[Bold, Italic]} content="<p>Hello</p>">
+ *   <Domternal.Toolbar />
+ *   <Domternal.Content />
+ *   <Domternal.BubbleMenu contexts={{ text: ['bold', 'italic'] }} />
+ *   <Domternal.EmojiPicker emojis={emojis} />
+ * </Domternal>
+ * ```
+ *
+ * @example SSR-safe with loading state
+ * ```tsx
+ * <Domternal extensions={extensions} immediatelyRender={false}>
+ *   <Domternal.Loading>Loading editor...</Domternal.Loading>
+ *   <Domternal.Toolbar />
+ *   <Domternal.Content />
+ * </Domternal>
+ * ```
+ */
+declare function Domternal({ children, deps, ...options }: DomternalProps): react_jsx_runtime.JSX.Element;
+declare namespace Domternal {
+    var Content: typeof DomternalContent;
+    var Loading: typeof DomternalLoading;
+    var Toolbar: typeof DomternalToolbarSub;
+    var BubbleMenu: typeof DomternalBubbleMenuSub;
+    var FloatingMenu: typeof DomternalFloatingMenuSub;
+    var EmojiPicker: typeof DomternalEmojiPickerSub;
+}
+/** Renders the editor content area. Mounts the editor view DOM from context. */
+declare function DomternalContent({ className }: {
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+declare namespace DomternalContent {
+    var displayName: string;
+}
+/** Renders children only while editor is not yet ready (SSR loading state). */
+declare function DomternalLoading({ children }: {
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element | null;
+declare namespace DomternalLoading {
+    var displayName: string;
+}
+/** Toolbar subcomponent. Uses editor from context automatically. */
+declare function DomternalToolbarSub(props: Omit<DomternalToolbarProps, 'editor'>): react_jsx_runtime.JSX.Element;
+declare namespace DomternalToolbarSub {
+    var displayName: string;
+}
+/** BubbleMenu subcomponent. Uses editor from context automatically. */
+declare function DomternalBubbleMenuSub(props: Omit<DomternalBubbleMenuProps, 'editor'>): react_jsx_runtime.JSX.Element;
+declare namespace DomternalBubbleMenuSub {
+    var displayName: string;
+}
+/** FloatingMenu subcomponent. Uses editor from context automatically. */
+declare function DomternalFloatingMenuSub(props: Omit<DomternalFloatingMenuProps, 'editor'>): react_jsx_runtime.JSX.Element;
+declare namespace DomternalFloatingMenuSub {
+    var displayName: string;
+}
+/** EmojiPicker subcomponent. Uses editor from context automatically. */
+declare function DomternalEmojiPickerSub(props: Omit<DomternalEmojiPickerProps, 'editor'>): react_jsx_runtime.JSX.Element;
+declare namespace DomternalEmojiPickerSub {
+    var displayName: string;
+}
+
+interface DomternalEditorProps extends Omit<UseEditorOptions, 'outputFormat'> {
+    /** Additional CSS class for the .dm-editor wrapper. */
+    className?: string;
+    /** Output format for onChange. @default 'html' */
+    outputFormat?: 'html' | 'json';
+    /** Controlled value. When provided, editor content syncs to this value. */
+    value?: Content;
+    /** Called when content changes (controlled mode). */
+    onChange?: (value: string | JSONContent) => void;
+    /** Additional content rendered inside the dm-editor wrapper. */
+    children?: React.ReactNode;
+}
+interface DomternalEditorRef {
+    editor: Editor | null;
+    htmlContent: string;
+    jsonContent: JSONContent | null;
+    isEmpty: boolean;
+    isFocused: boolean;
+    isEditable: boolean;
+}
+/**
+ * All-in-one editor component with integrated state management and context.
+ *
+ * Wraps children with EditorProvider automatically, so toolbar, bubble menu,
+ * and emoji picker components can access the editor via context.
+ *
+ * @example
+ * ```tsx
+ * const editorRef = useRef<DomternalEditorRef>(null);
+ *
+ * <DomternalEditor
+ *   ref={editorRef}
+ *   extensions={[Bold, Italic, Heading]}
+ *   content="<p>Hello</p>"
+ *   onUpdate={({ editor }) => console.log(editor.getHTML())}
+ * />
+ * ```
+ *
+ * @example Controlled mode
+ * ```tsx
+ * const [html, setHtml] = useState('<p>Hello</p>');
+ * <DomternalEditor value={html} onChange={setHtml} outputFormat="html" />
+ * ```
+ */
+declare const DomternalEditor: react.ForwardRefExoticComponent<DomternalEditorProps & react.RefAttributes<DomternalEditorRef>>;
+
+interface EditorContentProps extends HTMLAttributes<HTMLDivElement> {
+    /** The editor instance to render. */
+    editor: Editor | null;
+    /** Ref to the underlying div element. */
+    innerRef?: Ref<HTMLDivElement>;
+}
+/**
+ * Renders the ProseMirror editor view into a div element.
+ *
+ * Use this with `useEditor` for a flexible, decoupled pattern where the
+ * editor hook and rendering are separated:
+ *
+ * @example
+ * ```tsx
+ * const { editor } = useEditor({ extensions, content });
+ * return <EditorContent editor={editor} className="my-editor" />;
+ * ```
+ */
+declare function EditorContent({ editor, innerRef, ...htmlProps }: EditorContentProps): react_jsx_runtime.JSX.Element;
+
+/** ProseMirror node shape passed to node views. */
+interface PMNode {
+    type: {
+        name: string;
+        spec: {
+            group?: string;
+        };
+    };
+    attrs: Record<string, unknown>;
+    textContent: string;
+    nodeSize: number;
+}
+/**
+ * Props passed to custom React node view components.
+ */
+interface ReactNodeViewProps {
+    /** The editor instance. */
+    editor: Editor;
+    /** The ProseMirror node being rendered. */
+    node: PMNode;
+    /** Whether this node is selected via NodeSelection. */
+    selected: boolean;
+    /** Get the document position of this node. */
+    getPos: () => number;
+    /** Update the node's attributes. */
+    updateAttributes: (attrs: Record<string, unknown>) => void;
+    /** Delete this node from the document. */
+    deleteNode: () => void;
+    /** The extension that created this node view (name, options). Injected by core. */
+    extension: {
+        name: string;
+        options: Record<string, unknown>;
+    };
+    /** ProseMirror decorations applied to this node. */
+    decorations: unknown[];
+}
+interface ReactNodeViewRendererOptions {
+    /** Wrapper element tag. @default 'div' for block, 'span' for inline */
+    as?: string;
+    /** Additional CSS class on the wrapper element. */
+    className?: string;
+    /** Tag for the content DOM element. Set to null for no editable content. @default 'div' */
+    contentDOMElement?: string | null;
+}
+/**
+ * Converts a React component into a ProseMirror NodeView constructor.
+ *
+ * Returns a function matching ProseMirror's native `(node, view, getPos, decorations)` signature.
+ * The editor and extension context are automatically injected by core via `__domternalContext`.
+ *
+ * @example
+ * ```ts
+ * const ImageExtension = Image.extend({
+ *   addNodeView() {
+ *     return ReactNodeViewRenderer(ImageComponent);
+ *   }
+ * });
+ * ```
+ *
+ * @example Accessing extension options in the component
+ * ```tsx
+ * function ImageComponent({ node, extension, decorations }: ReactNodeViewProps) {
+ *   const maxWidth = extension.options.maxWidth as number;
+ *   return <NodeViewWrapper><img src={node.attrs.src} style={{ maxWidth }} /></NodeViewWrapper>;
+ * }
+ * ```
+ */
+declare function ReactNodeViewRenderer(component: React.ComponentType<ReactNodeViewProps>, options?: ReactNodeViewRendererOptions): (node: PMNode, _view: unknown, getPos: () => number, decorations: unknown[]) => ReactNodeView;
+interface ReactNodeViewInit {
+    editor: Editor;
+    node: PMNode;
+    getPos: () => number;
+    decorations: unknown[];
+    extension: {
+        name: string;
+        options: Record<string, unknown>;
+    };
+}
+declare class ReactNodeView {
+    dom: HTMLElement;
+    contentDOM: HTMLElement | null;
+    private root;
+    private component;
+    private editor;
+    private node;
+    private getPos;
+    private decorations;
+    private extension;
+    private selected;
+    constructor(component: React.ComponentType<ReactNodeViewProps>, init: ReactNodeViewInit, options: ReactNodeViewRendererOptions);
+    private render;
+    update(node: PMNode, decorations: unknown[]): boolean;
+    selectNode(): void;
+    deselectNode(): void;
+    destroy(): void;
+    ignoreMutation(mutation: MutationRecord): boolean;
+    stopEvent(): boolean;
+}
+
+interface NodeViewWrapperProps extends HTMLAttributes<HTMLElement> {
+    /** The HTML element type to render. @default 'div' */
+    as?: ElementType;
+}
+/**
+ * Container component for custom React node views.
+ * Handles drag events and marks the element as a node view wrapper.
+ */
+declare function NodeViewWrapper({ as: Tag, style, ...props }: NodeViewWrapperProps): react_jsx_runtime.JSX.Element;
+
+interface NodeViewContentProps extends HTMLAttributes<HTMLElement> {
+    /** The HTML element type to render. @default 'div' */
+    as?: ElementType;
+}
+/**
+ * Placeholder for editable nested content within a custom React node view.
+ * ProseMirror manages the content DOM inside this element.
+ */
+declare function NodeViewContent({ as: Tag, style, ...props }: NodeViewContentProps): react_jsx_runtime.JSX.Element;
+
+interface ReactNodeViewContextValue {
+    onDragStart: (event: DragEvent) => void;
+    nodeViewContentRef: RefCallback<HTMLElement>;
+}
+/**
+ * Access node view internals from within a custom React node view component.
+ * Used by NodeViewWrapper and NodeViewContent.
+ */
+declare function useReactNodeView(): ReactNodeViewContextValue;
+
+export { DEFAULT_EXTENSIONS, Domternal, DomternalBubbleMenu, type DomternalBubbleMenuProps, DomternalEditor, type DomternalEditorProps, type DomternalEditorRef, DomternalEmojiPicker, type DomternalEmojiPickerProps, DomternalFloatingMenu, type DomternalFloatingMenuProps, type DomternalProps, DomternalToolbar, type DomternalToolbarProps, EditorContent, type EditorContentProps, EditorProvider, type EditorProviderProps, type EditorState, type EmojiPickerItem, NodeViewContent, type NodeViewContentProps, NodeViewWrapper, type NodeViewWrapperProps, type ReactNodeViewProps, ReactNodeViewRenderer, type ReactNodeViewRendererOptions, type UseEditorOptions, useCurrentEditor, useEditor, useEditorState, useReactNodeView };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@domternal/react",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "React components for Domternal editor",
   "author": "https://github.com/ThomasNowHere",
   "license": "MIT",
@@ -21,16 +21,21 @@
   "peerDependencies": {
     "react": ">=18",
     "react-dom": ">=18",
-    "@domternal/core": ">=0.5.0"
+    "@domternal/core": ">=0.6.0"
   },
   "devDependencies": {
+    "@domternal/core": "workspace:*",
     "@types/react": "^19.0.0",
     "@types/react-dom": "^19.0.0",
     "react": "^19.1.0",
     "react-dom": "^19.1.0",
     "tsup": "^8.5.1",
-    "typescript": "~5.9.3",
-    "@domternal/core": "0.5.1"
+    "typescript": "~5.9.3"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit"
   },
   "keywords": [
     "react",
@@ -47,10 +52,5 @@
   "bugs": {
     "url": "https://github.com/domternal/domternal/issues"
   },
-  "homepage": "https://domternal.dev",
-  "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
-    "typecheck": "tsc --noEmit"
-  }
-}
+  "homepage": "https://domternal.dev"
+}