@openeditor/react-native-prose-editor 0.0.2

package/app.plugin.js

@@ -0,0 +1,62 @@
+const path = require('path');
+const { createRequire } = require('module');
+
+const pkg = require('./package.json');
+
+const PACKAGING_EXCLUDES_PROPERTY = 'android.packagingOptions.excludes';
+const LEGACY_JNA_ABI_EXCLUDES = [
+  '**/armeabi/libjnidispatch.so',
+  '**/mips/libjnidispatch.so',
+  '**/mips64/libjnidispatch.so',
+];
+
+function requireExpoConfigPlugins() {
+  try {
+    return require('expo/config-plugins');
+  } catch (error) {
+    if (error.code !== 'MODULE_NOT_FOUND') {
+      throw error;
+    }
+
+    const appRequire = createRequire(path.join(process.cwd(), 'package.json'));
+    return appRequire('expo/config-plugins');
+  }
+}
+
+function mergeCommaList(value, additions) {
+  const values = (value || '')
+    .split(',')
+    .map((item) => item.trim())
+    .filter(Boolean);
+
+  return Array.from(new Set([...values, ...additions])).join(',');
+}
+
+function withOpenEditorReactNativeProseEditor(config) {
+  const { withGradleProperties } = requireExpoConfigPlugins();
+
+  return withGradleProperties(config, (config) => {
+    const existing = config.modResults.find(
+      (property) => property.type === 'property' && property.key === PACKAGING_EXCLUDES_PROPERTY
+    );
+    const value = mergeCommaList(existing && existing.value, LEGACY_JNA_ABI_EXCLUDES);
+
+    if (existing) {
+      existing.value = value;
+    } else {
+      config.modResults.push({
+        type: 'property',
+        key: PACKAGING_EXCLUDES_PROPERTY,
+        value,
+      });
+    }
+
+    return config;
+  });
+}
+
+module.exports = requireExpoConfigPlugins().createRunOncePlugin(
+  withOpenEditorReactNativeProseEditor,
+  pkg.name,
+  pkg.version
+);

package/dist/EditorTheme.d.ts

@@ -0,0 +1,113 @@
+export type EditorFontWeight = 'normal' | 'bold' | '100' | '200' | '300' | '400' | '500' | '600' | '700' | '800' | '900';
+export type EditorFontStyle = 'normal' | 'italic';
+export interface EditorMentionTheme {
+    textColor?: string;
+    backgroundColor?: string;
+    borderColor?: string;
+    borderWidth?: number;
+    borderRadius?: number;
+    fontWeight?: EditorFontWeight;
+    popoverBackgroundColor?: string;
+    popoverBorderColor?: string;
+    popoverBorderWidth?: number;
+    popoverBorderRadius?: number;
+    popoverShadowColor?: string;
+    optionTextColor?: string;
+    optionSecondaryTextColor?: string;
+    optionHighlightedBackgroundColor?: string;
+    optionHighlightedTextColor?: string;
+}
+export interface EditorTextStyle {
+    fontFamily?: string;
+    fontSize?: number;
+    fontWeight?: EditorFontWeight;
+    fontStyle?: EditorFontStyle;
+    color?: string;
+    lineHeight?: number;
+    spacingAfter?: number;
+}
+export interface EditorLinkTheme {
+    fontFamily?: string;
+    fontSize?: number;
+    fontWeight?: EditorFontWeight;
+    fontStyle?: EditorFontStyle;
+    color?: string;
+    backgroundColor?: string;
+    underline?: boolean;
+}
+export interface EditorHeadingTheme {
+    h1?: EditorTextStyle;
+    h2?: EditorTextStyle;
+    h3?: EditorTextStyle;
+    h4?: EditorTextStyle;
+    h5?: EditorTextStyle;
+    h6?: EditorTextStyle;
+}
+export interface EditorListTheme {
+    indent?: number;
+    baseIndentMultiplier?: number;
+    itemSpacing?: number;
+    markerColor?: string;
+    markerScale?: number;
+}
+export interface EditorHorizontalRuleTheme {
+    color?: string;
+    thickness?: number;
+    verticalMargin?: number;
+}
+export interface EditorBlockquoteTheme {
+    text?: EditorTextStyle;
+    indent?: number;
+    borderColor?: string;
+    borderWidth?: number;
+    markerGap?: number;
+}
+export interface EditorCodeBlockTheme {
+    text?: EditorTextStyle;
+    backgroundColor?: string;
+    borderRadius?: number;
+    paddingHorizontal?: number;
+    paddingVertical?: number;
+}
+export type EditorToolbarAppearance = 'custom' | 'native';
+export interface EditorToolbarTheme {
+    appearance?: EditorToolbarAppearance;
+    height?: number;
+    backgroundColor?: string;
+    borderColor?: string;
+    borderWidth?: number;
+    borderRadius?: number;
+    marginTop?: number;
+    showTopBorder?: boolean;
+    keyboardOffset?: number;
+    horizontalInset?: number;
+    separatorColor?: string;
+    buttonColor?: string;
+    buttonActiveColor?: string;
+    buttonDisabledColor?: string;
+    buttonActiveBackgroundColor?: string;
+    buttonBorderRadius?: number;
+}
+export interface EditorContentInsets {
+    top?: number;
+    right?: number;
+    bottom?: number;
+    left?: number;
+}
+export interface EditorTheme {
+    text?: EditorTextStyle;
+    paragraph?: EditorTextStyle;
+    blockquote?: EditorBlockquoteTheme;
+    codeBlock?: EditorCodeBlockTheme;
+    headings?: EditorHeadingTheme;
+    list?: EditorListTheme;
+    horizontalRule?: EditorHorizontalRuleTheme;
+    mentions?: EditorMentionTheme;
+    links?: EditorLinkTheme;
+    toolbar?: EditorToolbarTheme;
+    placeholderColor?: string;
+    backgroundColor?: string;
+    borderRadius?: number;
+    contentInsets?: EditorContentInsets;
+}
+export declare function serializeEditorTheme(theme?: EditorTheme): string | undefined;

package/dist/EditorTheme.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeEditorTheme = serializeEditorTheme;
+function stripUndefined(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => stripUndefined(item)).filter((item) => item !== undefined);
+    }
+    if (value != null && typeof value === 'object') {
+        const entries = Object.entries(value)
+            .map(([key, entryValue]) => [key, stripUndefined(entryValue)])
+            .filter(([, entryValue]) => entryValue !== undefined);
+        if (entries.length === 0) {
+            return undefined;
+        }
+        return Object.fromEntries(entries);
+    }
+    if (typeof value === 'number' && !Number.isFinite(value)) {
+        return undefined;
+    }
+    return value;
+}
+function serializeEditorTheme(theme) {
+    if (!theme)
+        return undefined;
+    const cleaned = stripUndefined(theme);
+    if (!cleaned || typeof cleaned !== 'object')
+        return undefined;
+    return JSON.stringify(cleaned);
+}

package/dist/EditorToolbar.d.ts

@@ -0,0 +1,191 @@
+import React from 'react';
+import type { ActiveState, HistoryState } from './NativeEditorBridge';
+import type { EditorMentionTheme, EditorToolbarTheme } from './EditorTheme';
+import type { MentionSuggestion } from './addons';
+export type EditorToolbarListType = 'bulletList' | 'orderedList';
+export type EditorToolbarHeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
+export type EditorToolbarCommand = 'indentList' | 'outdentList' | 'undo' | 'redo';
+export type EditorToolbarGroupPresentation = 'expand' | 'menu';
+export type EditorToolbarItemPlacement = 'start' | 'scroll' | 'end';
+export type EditorToolbarDefaultIconId = 'bold' | 'italic' | 'underline' | 'strike' | 'link' | 'image' | 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'blockquote' | 'bulletList' | 'orderedList' | 'indentList' | 'outdentList' | 'lineBreak' | 'horizontalRule' | 'undo' | 'redo';
+export interface EditorToolbarSFSymbolIcon {
+    type: 'sfSymbol';
+    name: string;
+}
+export interface EditorToolbarMaterialIcon {
+    type: 'material';
+    name: string;
+}
+export type EditorToolbarIcon = {
+    type: 'default';
+    id: EditorToolbarDefaultIconId;
+} | {
+    type: 'glyph';
+    text: string;
+} | {
+    type: 'platform';
+    ios?: EditorToolbarSFSymbolIcon;
+    android?: EditorToolbarMaterialIcon;
+    fallbackText?: string;
+};
+export type EditorToolbarLeafItem = {
+    type: 'mark';
+    mark: string;
+    label: string;
+    icon: EditorToolbarIcon;
+    key?: string;
+    placement?: EditorToolbarItemPlacement;
+} | {
+    type: 'link';
+    label: string;
+    icon: EditorToolbarIcon;
+    key?: string;
+    placement?: EditorToolbarItemPlacement;
+} | {
+    type: 'image';
+    label: string;
+    icon: EditorToolbarIcon;
+    key?: string;
+    placement?: EditorToolbarItemPlacement;
+} | {
+    type: 'heading';
+    level: EditorToolbarHeadingLevel;
+    label: string;
+    icon: EditorToolbarIcon;
+    key?: string;
+    placement?: EditorToolbarItemPlacement;
+} | {
+    type: 'blockquote';
+    label: string;
+    icon: EditorToolbarIcon;
+    key?: string;
+    placement?: EditorToolbarItemPlacement;
+} | {
+    type: 'list';
+    listType: EditorToolbarListType;
+    label: string;
+    icon: EditorToolbarIcon;
+    key?: string;
+    placement?: EditorToolbarItemPlacement;
+} | {
+    type: 'command';
+    command: EditorToolbarCommand;
+    label: string;
+    icon: EditorToolbarIcon;
+    key?: string;
+    placement?: EditorToolbarItemPlacement;
+} | {
+    type: 'node';
+    nodeType: string;
+    label: string;
+    icon: EditorToolbarIcon;
+    key?: string;
+    placement?: EditorToolbarItemPlacement;
+} | {
+    type: 'action';
+    key: string;
+    label: string;
+    icon: EditorToolbarIcon;
+    isActive?: boolean;
+    isDisabled?: boolean;
+    placement?: EditorToolbarItemPlacement;
+};
+export type EditorToolbarGroupChildItem = EditorToolbarLeafItem;
+export interface EditorToolbarGroupItem {
+    type: 'group';
+    key: string;
+    label: string;
+    icon: EditorToolbarIcon;
+    presentation?: EditorToolbarGroupPresentation;
+    placement?: EditorToolbarItemPlacement;
+    items: readonly EditorToolbarGroupChildItem[];
+}
+export type EditorToolbarItem = EditorToolbarLeafItem | EditorToolbarGroupItem | {
+    type: 'separator';
+    key?: string;
+    placement?: EditorToolbarItemPlacement;
+};
+export interface EditorToolbarFrame {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface EditorToolbarMentionState {
+    ownerId: number;
+    trigger: string;
+    suggestions: readonly MentionSuggestion[];
+    theme?: EditorMentionTheme;
+    suggestionThemes?: Readonly<Record<string, EditorMentionTheme | undefined>>;
+    onSelectSuggestion: (suggestion: MentionSuggestion) => void;
+}
+export declare function isEditorToolbarFocusPreservationActive(): boolean;
+export declare function setActiveEditorToolbarFrameOwnerForEditor(ownerId: number, isActive: boolean): void;
+export declare function useEditorToolbarFrames(ownerId: number): readonly EditorToolbarFrame[];
+export declare function setEditorToolbarMentionState(ownerId: number, state: Omit<EditorToolbarMentionState, 'ownerId'> | null): void;
+export declare function _setEditorToolbarFrameForTests(id: number, frame: EditorToolbarFrame | null, ownerId?: number | null): void;
+export declare function _resetEditorToolbarFrameRegistryForTests(): void;
+export declare function _beginEditorToolbarInteractionForTests(): void;
+export declare function _endEditorToolbarInteractionForTests(): void;
+export declare const DEFAULT_EDITOR_TOOLBAR_ITEMS: readonly EditorToolbarItem[];
+export interface EditorToolbarProps {
+    /** Currently active marks and nodes from the Rust engine. */
+    activeState: ActiveState;
+    /** Current undo/redo availability. */
+    historyState: HistoryState;
+    /** Toggle bold mark. */
+    onToggleBold: () => void;
+    /** Toggle italic mark. */
+    onToggleItalic: () => void;
+    /** Toggle underline mark. */
+    onToggleUnderline: () => void;
+    /** Toggle strikethrough mark. */
+    onToggleStrike: () => void;
+    /** Toggle bullet list. */
+    onToggleBulletList?: () => void;
+    /** Toggle blockquote wrapping. */
+    onToggleBlockquote?: () => void;
+    /** Toggle ordered list. */
+    onToggleOrderedList?: () => void;
+    /** Indent the current list item. */
+    onIndentList?: () => void;
+    /** Outdent the current list item. */
+    onOutdentList?: () => void;
+    /** Insert horizontal rule. */
+    onInsertHorizontalRule?: () => void;
+    /** Insert inline hard break. */
+    onInsertLineBreak?: () => void;
+    /** Undo the last operation. */
+    onUndo: () => void;
+    /** Redo the last undone operation. */
+    onRedo: () => void;
+    /** Generic mark toggle handler used by configurable mark buttons. */
+    onToggleMark?: (mark: string) => void;
+    /** Generic list toggle handler used by configurable list buttons. */
+    onToggleListType?: (listType: EditorToolbarListType) => void;
+    /** Generic heading toggle handler used by configurable heading buttons. */
+    onToggleHeading?: (level: EditorToolbarHeadingLevel) => void;
+    /** Generic node insertion handler used by configurable node buttons. */
+    onInsertNodeType?: (nodeType: string) => void;
+    /** Generic command handler used by configurable command buttons. */
+    onRunCommand?: (command: EditorToolbarCommand) => void;
+    /** Generic action handler for arbitrary JS-defined toolbar buttons. */
+    onToolbarAction?: (key: string) => void;
+    /** Link button handler used by first-class link toolbar items. */
+    onRequestLink?: () => void;
+    /** Image button handler used by first-class image toolbar items. */
+    onRequestImage?: () => void;
+    /** Displayed toolbar items, in order. Defaults to the built-in toolbar. */
+    toolbarItems?: readonly EditorToolbarItem[];
+    /** Optional theme overrides for toolbar chrome and button colors. */
+    theme?: EditorToolbarTheme;
+    /** Whether to render the built-in top separator line. */
+    showTopBorder?: boolean;
+    /**
+     * Keep NativeRichTextEditor focused when this toolbar is rendered outside
+     * the editor wrapper. Defaults to true.
+     */
+    preserveEditorFocus?: boolean;
+}
+export declare function EditorToolbar({ activeState, historyState, onToggleBold, onToggleItalic, onToggleUnderline, onToggleStrike, onToggleBulletList, onToggleHeading, onToggleBlockquote, onToggleOrderedList, onIndentList, onOutdentList, onInsertHorizontalRule, onInsertLineBreak, onUndo, onRedo, onToggleMark, onToggleListType, onInsertNodeType, onRunCommand, onToolbarAction, onRequestLink, onRequestImage, toolbarItems, theme, showTopBorder, preserveEditorFocus, }: EditorToolbarProps): React.JSX.Element;
+export {};