truerte-react 0.0.3

package/lib/cjs/main/ts/components/Editor.d.ts

@@ -0,0 +1,171 @@
+/**
+ * Official TrueRTE React component
+ * Copyright (c) 2022 Ephox Corporation DBA Tiny Technologies, Inc.
+ * Copyright (c) 2024 TrueRTE contributors
+ * Licensed under the MIT license (https://github.com/truerte/truerte-react/blob/main/LICENSE.TXT)
+ */
+import * as React from 'react';
+import { IEvents } from '../Events';
+import type { Editor as TrueRTEEditor, TrueRTE } from 'truerte';
+type OmitStringIndexSignature<T> = {
+    [K in keyof T as string extends K ? never : K]: T[K];
+};
+interface DoNotUse<T extends string> {
+    __brand: T;
+}
+type OmittedInitProps = 'selector' | 'target' | 'readonly';
+type EditorOptions = Parameters<TrueRTE['init']>[0];
+export type InitOptions = Omit<OmitStringIndexSignature<EditorOptions>, OmittedInitProps> & {
+    selector?: DoNotUse<'selector prop is handled internally by the component'>;
+    target?: DoNotUse<'target prop is handled internally by the component'>;
+    readonly?: DoNotUse<'readonly prop is overridden by the component, use the `disabled` prop instead'>;
+} & {
+    [key: string]: unknown;
+};
+export type Version = `${'1'}${'' | `.${number}` | `.${number}.${number}`}`;
+export type EditorInstanceRef = React.Ref<TrueRTEEditor | null>;
+export interface IProps {
+    /**
+     * @see {@link https://www.truerte.org/docs/truerte/1/react-ref/#id React Tech Ref - id}
+     * @description The ID of the element to render the editor into.
+     */
+    id: string;
+    /**
+     * @see {@link https://www.truerte.org/docs/truerte/1/react-ref/#inline React Tech Ref - inline}
+     * @description Whether the editor should be rendered inline. Equivalent to the `inline` option in TrueRTE.
+     */
+    inline: boolean;
+    /**
+     * @see {@link https://www.truerte.org/docs/truerte/1/react-ref/#initialvalue React Tech Ref - initialValue}
+     * @description The initial HTML content of the editor.
+     *
+     * IMPORTANT: Ensure that this is **not** updated by `onEditorChange` or the editor will be unusable.
+     */
+    initialValue: string;
+    /**
+     * @see {@link https://www.truerte.org/docs/truerte/1/react-ref/#oneditorchange React Tech Ref - onEditorChange}
+     * @description Used to store the state of the editor outside the component. Typically used for controlled components.
+     * @param a The current HTML content of the editor.
+     * @param editor The TrueRTE editor instance.
+     * @returns void
+     */
+    onEditorChange: (a: string, editor: TrueRTEEditor) => void;
+    /**
+     * @see {@link https://www.truerte.org/docs/truerte/1/react-ref/#value React Tech Ref - value}
+     * @description The current HTML content of the editor. Typically used for controlled components.
+     */
+    value: string;
+    /**
+     * @see {@link https://www.truerte.org/docs/truerte/1/react-ref/#init React Tech Ref - init}
+     * @description Additional settings passed to `truerte.init()` when initializing the editor.
+     */
+    init: InitOptions;
+    /**
+     * @see {@link https://www.truerte.org/docs/truerte/1/react-ref/#tagname React Tech Ref - tagName}
+     * @description The tag name of the element to render the editor into. Only valid when `inline` is `true`.
+     */
+    tagName: string;
+    /**
+     * @see {@link https://www.truerte.org/docs/truerte/1/react-ref/#tabIndex React Tech Ref - tabIndex}
+     * @description The tab index of the element that the editor wraps.
+     */
+    tabIndex: number;
+    /**
+     * @description The TrueRTE version to use when loading from jsDelivr CDN. By default, version 1
+     * (that is, the latest minor and patch release of the major version 1) will be used.
+     * For more info about the possible version formats, see the {@link https://www.jsdelivr.com/documentation#id-npm jsDelivr documentation}.
+     */
+    cdnVersion: Version;
+    /**
+     * @see {@link https://www.truerte.org/docs/truerte/1/react-ref/#plugins React Tech Ref - plugins}
+     * @description The plugins to load into the editor. Equivalent to the `plugins` option in TrueRTE.
+     */
+    plugins: NonNullable<EditorOptions['plugins']>;
+    /**
+     * @see {@link https://www.truerte.org/docs/truerte/1/react-ref/#toolbar React Tech Ref - toolbar}
+     * @description The toolbar to load into the editor. Equivalent to the `toolbar` option in TrueRTE.
+     */
+    toolbar: NonNullable<EditorOptions['toolbar']>;
+    /**
+     * @see {@link https://www.truerte.org/docs/truerte/1/react-ref/#disabled React Tech Ref - disabled}
+     * @description Whether the editor should be "disabled" (read-only).
+     */
+    disabled: boolean;
+    /**
+     * @see {@link https://www.truerte.org/docs/truerte/1/react-ref/#textareaname React Tech Ref - textareaName}
+     * @description Set the `name` attribute of the `textarea` element used for the editor in forms. Only valid in iframe mode.
+     */
+    textareaName: string;
+    /**
+     * @description Optional external ref that receives the underlying TrueRTE editor instance.
+     * Use this for imperative control from outside the component.
+     */
+    editorRef: EditorInstanceRef;
+    /**
+     * @description The URL of the TrueRTE script to lazy load.
+     */
+    truerteScriptSrc: string;
+    /**
+     * @description When true, automatically configures `icons: 'truerte-lucide'`
+     * unless you explicitly provide `init.icons` or `init.icons_url`.
+     */
+    useLucideIcons: boolean;
+    /**
+     * @see {@link https://www.truerte.org/docs/truerte/1/react-ref/#rollback React Tech Ref - rollback}
+     * @description The number of milliseconds to wait before reverting to the previous value when the editor's content changes.
+     */
+    rollback: number | false;
+    /**
+     * @see {@link https://www.truerte.org/docs/truerte/1/react-ref/#scriptloading React Tech Ref - scriptLoading}
+     * @description Options for how the TrueRTE script should be loaded.
+     * @property async Whether the script should be loaded with the `async` attribute.
+     * @property defer Whether the script should be loaded with the `defer` attribute.
+     * @property delay The number of milliseconds to wait before loading the script.
+     */
+    scriptLoading: {
+        async?: boolean;
+        defer?: boolean;
+        delay?: number;
+    };
+}
+export interface IAllProps extends Partial<IProps>, Partial<IEvents> {
+}
+/**
+ * @see {@link https://www.truerte.org/docs/truerte/1/react-ref/ TrueRTE React Technical Reference}
+ */
+export declare class Editor extends React.Component<IAllProps> {
+    static defaultProps: Partial<IAllProps>;
+    editor?: TrueRTEEditor;
+    private id;
+    private elementRef;
+    private inline;
+    private currentContent?;
+    private boundHandlers;
+    private rollbackTimer;
+    private valueCursor;
+    constructor(props: Partial<IAllProps>);
+    private get view();
+    componentDidUpdate(prevProps: Partial<IAllProps>): void;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    render(): React.ReactElement<{
+        ref: React.RefObject<HTMLElement | null>;
+        id: string;
+        tabIndex: number | undefined;
+    }, string | React.JSXElementConstructor<any>>;
+    getEditor(): TrueRTEEditor | undefined;
+    private beforeInputEvent;
+    private renderInline;
+    private renderIframe;
+    private getScriptSources;
+    private getInitialValue;
+    private bindHandlers;
+    private rollbackChange;
+    private handleBeforeInput;
+    private handleBeforeInputSpecial;
+    private handleEditorChange;
+    private handleEditorChangeSpecial;
+    private assignEditorRef;
+    private initialise;
+}
+export {};

package/lib/cjs/main/ts/components/Editor.js

@@ -0,0 +1,358 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Editor = void 0;
+/**
+ * Official TrueRTE React component
+ * Copyright (c) 2022 Ephox Corporation DBA Tiny Technologies, Inc.
+ * Copyright (c) 2024 TrueRTE contributors
+ * Licensed under the MIT license (https://github.com/truerte/truerte-react/blob/main/LICENSE.TXT)
+ */
+const React = require("react");
+const ScriptLoader2_1 = require("../ScriptLoader2");
+const TrueRTE_1 = require("../TrueRTE");
+const Utils_1 = require("../Utils");
+const Uuid_1 = require("../Uuid");
+const changeEvents = 'change keyup compositionend setcontent CommentChange';
+/**
+ * @see {@link https://www.truerte.org/docs/truerte/1/react-ref/ TrueRTE React Technical Reference}
+ */
+class Editor extends React.Component {
+    constructor(props) {
+        var _a, _b, _c;
+        super(props);
+        this.rollbackTimer = undefined;
+        this.valueCursor = undefined;
+        this.rollbackChange = () => {
+            const editor = this.editor;
+            const value = this.props.value;
+            if (editor && value && value !== this.currentContent) {
+                editor.undoManager.ignore(() => {
+                    editor.setContent(value);
+                    // only restore cursor on inline editors when they are focused
+                    // as otherwise it will cause a focus grab
+                    if (this.valueCursor && (!this.inline || editor.hasFocus())) {
+                        try {
+                            editor.selection.moveToBookmark(this.valueCursor);
+                        }
+                        catch (e) { /* ignore */ }
+                    }
+                });
+            }
+            this.rollbackTimer = undefined;
+        };
+        this.handleBeforeInput = (_evt) => {
+            if (this.props.value !== undefined && this.props.value === this.currentContent && this.editor) {
+                if (!this.inline || this.editor.hasFocus()) {
+                    try {
+                        // getBookmark throws exceptions when the editor has not been focused
+                        // possibly only in inline mode but I'm not taking chances
+                        this.valueCursor = this.editor.selection.getBookmark(3);
+                    }
+                    catch (e) { /* ignore */ }
+                }
+            }
+        };
+        this.handleBeforeInputSpecial = (evt) => {
+            if (evt.key === 'Enter' || evt.key === 'Backspace' || evt.key === 'Delete') {
+                this.handleBeforeInput(evt);
+            }
+        };
+        this.handleEditorChange = (_evt) => {
+            const editor = this.editor;
+            if (editor && editor.initialized) {
+                const newContent = editor.getContent();
+                if (this.props.value !== undefined && this.props.value !== newContent && this.props.rollback !== false) {
+                    // start a timer and revert to the value if not applied in time
+                    if (!this.rollbackTimer) {
+                        this.rollbackTimer = window.setTimeout(this.rollbackChange, typeof this.props.rollback === 'number' ? this.props.rollback : 200);
+                    }
+                }
+                if (newContent !== this.currentContent) {
+                    this.currentContent = newContent;
+                    if ((0, Utils_1.isFunction)(this.props.onEditorChange)) {
+                        this.props.onEditorChange(newContent, editor);
+                    }
+                }
+            }
+        };
+        this.handleEditorChangeSpecial = (evt) => {
+            if (evt.key === 'Backspace' || evt.key === 'Delete') {
+                this.handleEditorChange(evt);
+            }
+        };
+        this.assignEditorRef = (editorRef, editor) => {
+            if (editorRef === undefined || editorRef === null) {
+                return;
+            }
+            if (typeof editorRef === 'function') {
+                editorRef(editor);
+            }
+            else {
+                editorRef.current = editor;
+            }
+        };
+        this.initialise = (attempts = 0) => {
+            var _a, _b, _c, _d, _e, _f;
+            const target = this.elementRef.current;
+            if (!target) {
+                return; // Editor has been unmounted
+            }
+            if (!target.isConnected) {
+                // this is probably someone trying to help by rendering us offscreen
+                // but we can't do that because the editor iframe must be in the document
+                // in order to have state
+                // TODO: how will this do when we use web component?
+                if (attempts === 0) {
+                    // we probably just need to wait for the current events to be processed
+                    setTimeout(() => this.initialise(1), 1);
+                }
+                else if (attempts < 100) {
+                    // wait for ten seconds, polling every tenth of a second
+                    setTimeout(() => this.initialise(attempts + 1), 100);
+                }
+                else {
+                    // give up, at this point it seems that more polling is unlikely to help
+                    throw new Error('truerte can only be initialised when in a document');
+                }
+                return;
+            }
+            const truerte = (0, TrueRTE_1.getTrueRTE)(this.view);
+            if (!truerte) {
+                throw new Error('truerte should have been loaded into global scope');
+            }
+            const resolvedPlugins = (0, Utils_1.mergePlugins)((_a = this.props.init) === null || _a === void 0 ? void 0 : _a.plugins, this.props.plugins);
+            const hasExplicitIconConfig = ((_b = this.props.init) === null || _b === void 0 ? void 0 : _b.icons) !== undefined || ((_c = this.props.init) === null || _c === void 0 ? void 0 : _c.icons_url) !== undefined;
+            const resolvedIconPack = this.props.useLucideIcons === true && !hasExplicitIconConfig
+                ? 'truerte-lucide'
+                : (_d = this.props.init) === null || _d === void 0 ? void 0 : _d.icons;
+            const finalInit = Object.assign(Object.assign({}, this.props.init), { selector: undefined, target, readonly: this.props.disabled, inline: this.inline, plugins: resolvedPlugins, icons: resolvedIconPack, toolbar: (_e = this.props.toolbar) !== null && _e !== void 0 ? _e : (_f = this.props.init) === null || _f === void 0 ? void 0 : _f.toolbar, setup: (editor) => {
+                    this.editor = editor;
+                    this.assignEditorRef(this.props.editorRef, editor);
+                    this.bindHandlers({});
+                    // When running in inline mode the editor gets the initial value
+                    // from the innerHTML of the element it is initialized on.
+                    // However we don't want to take on the responsibility of sanitizing
+                    // to remove XSS in the react integration so we have a chicken and egg
+                    // problem... We avoid it by sneaking in a set content before the first
+                    // "official" setContent and using TrueRTE to do the sanitization.
+                    if (this.inline && !(0, Utils_1.isTextareaOrInput)(target)) {
+                        editor.once('PostRender', (_evt) => {
+                            editor.setContent(this.getInitialValue(), { no_events: true });
+                        });
+                    }
+                    if (this.props.init && (0, Utils_1.isFunction)(this.props.init.setup)) {
+                        this.props.init.setup(editor);
+                    }
+                }, init_instance_callback: (editor) => {
+                    var _a, _b;
+                    // check for changes that happened since truerte.init() was called
+                    const initialValue = this.getInitialValue();
+                    this.currentContent = (_a = this.currentContent) !== null && _a !== void 0 ? _a : editor.getContent();
+                    if (this.currentContent !== initialValue) {
+                        this.currentContent = initialValue;
+                        // same as resetContent in TrueRTE 5
+                        editor.setContent(initialValue);
+                        editor.undoManager.clear();
+                        editor.undoManager.add();
+                        editor.setDirty(false);
+                    }
+                    const disabled = (_b = this.props.disabled) !== null && _b !== void 0 ? _b : false;
+                    (0, Utils_1.setMode)(this.editor, disabled ? 'readonly' : 'design');
+                    // ensure existing init_instance_callback is called
+                    if (this.props.init && (0, Utils_1.isFunction)(this.props.init.init_instance_callback)) {
+                        this.props.init.init_instance_callback(editor);
+                    }
+                } });
+            if (!this.inline) {
+                target.style.visibility = '';
+            }
+            if ((0, Utils_1.isTextareaOrInput)(target)) {
+                target.value = this.getInitialValue();
+            }
+            truerte.init(finalInit);
+        };
+        this.id = this.props.id || (0, Uuid_1.uuid)('truerte-react');
+        this.elementRef = React.createRef();
+        this.inline = (_c = (_a = this.props.inline) !== null && _a !== void 0 ? _a : (_b = this.props.init) === null || _b === void 0 ? void 0 : _b.inline) !== null && _c !== void 0 ? _c : false;
+        this.boundHandlers = {};
+    }
+    get view() {
+        var _a, _b;
+        return (_b = (_a = this.elementRef.current) === null || _a === void 0 ? void 0 : _a.ownerDocument.defaultView) !== null && _b !== void 0 ? _b : window;
+    }
+    componentDidUpdate(prevProps) {
+        var _a, _b, _c;
+        if (this.props.editorRef !== prevProps.editorRef) {
+            this.assignEditorRef(prevProps.editorRef, null);
+            this.assignEditorRef(this.props.editorRef, (_a = this.editor) !== null && _a !== void 0 ? _a : null);
+        }
+        if (this.rollbackTimer) {
+            clearTimeout(this.rollbackTimer);
+            this.rollbackTimer = undefined;
+        }
+        if (this.editor) {
+            this.bindHandlers(prevProps);
+            if (this.editor.initialized) {
+                this.currentContent = (_b = this.currentContent) !== null && _b !== void 0 ? _b : this.editor.getContent();
+                if (typeof this.props.initialValue === 'string' && this.props.initialValue !== prevProps.initialValue) {
+                    // same as resetContent in TinyMCE 5 – TODO what does this mean for TrueRTE?
+                    this.editor.setContent(this.props.initialValue);
+                    this.editor.undoManager.clear();
+                    this.editor.undoManager.add();
+                    this.editor.setDirty(false);
+                }
+                else if (typeof this.props.value === 'string' && this.props.value !== this.currentContent) {
+                    const localEditor = this.editor;
+                    localEditor.undoManager.transact(() => {
+                        // inline editors grab focus when restoring selection
+                        // so we don't try to keep their selection unless they are currently focused
+                        let cursor;
+                        if (!this.inline || localEditor.hasFocus()) {
+                            try {
+                                // getBookmark throws exceptions when the editor has not been focused
+                                // possibly only in inline mode but I'm not taking chances
+                                cursor = localEditor.selection.getBookmark(3);
+                            }
+                            catch (e) { /* ignore */ }
+                        }
+                        const valueCursor = this.valueCursor;
+                        localEditor.setContent(this.props.value);
+                        if (!this.inline || localEditor.hasFocus()) {
+                            for (const bookmark of [cursor, valueCursor]) {
+                                if (bookmark) {
+                                    try {
+                                        localEditor.selection.moveToBookmark(bookmark);
+                                        this.valueCursor = bookmark;
+                                        break;
+                                    }
+                                    catch (e) { /* ignore */ }
+                                }
+                            }
+                        }
+                    });
+                }
+                if (this.props.disabled !== prevProps.disabled) {
+                    const disabled = (_c = this.props.disabled) !== null && _c !== void 0 ? _c : false;
+                    (0, Utils_1.setMode)(this.editor, disabled ? 'readonly' : 'design');
+                }
+            }
+        }
+    }
+    componentDidMount() {
+        var _a, _b, _c, _d, _e;
+        if ((0, TrueRTE_1.getTrueRTE)(this.view) !== null) {
+            this.initialise();
+        }
+        else if (Array.isArray(this.props.truerteScriptSrc) && this.props.truerteScriptSrc.length === 0) {
+            (_b = (_a = this.props).onScriptsLoadError) === null || _b === void 0 ? void 0 : _b.call(_a, new Error('No `truerte` global is present but the `truerteScriptSrc` prop was an empty array.'));
+        }
+        else if ((_c = this.elementRef.current) === null || _c === void 0 ? void 0 : _c.ownerDocument) {
+            const successHandler = () => {
+                var _a, _b;
+                (_b = (_a = this.props).onScriptsLoad) === null || _b === void 0 ? void 0 : _b.call(_a);
+                this.initialise();
+            };
+            const errorHandler = (err) => {
+                var _a, _b;
+                (_b = (_a = this.props).onScriptsLoadError) === null || _b === void 0 ? void 0 : _b.call(_a, err);
+            };
+            ScriptLoader2_1.ScriptLoader.loadList(this.elementRef.current.ownerDocument, this.getScriptSources(), (_e = (_d = this.props.scriptLoading) === null || _d === void 0 ? void 0 : _d.delay) !== null && _e !== void 0 ? _e : 0, successHandler, errorHandler);
+        }
+    }
+    componentWillUnmount() {
+        const editor = this.editor;
+        if (editor) {
+            editor.off(changeEvents, this.handleEditorChange);
+            editor.off(this.beforeInputEvent(), this.handleBeforeInput);
+            editor.off('keypress', this.handleEditorChangeSpecial);
+            editor.off('keydown', this.handleBeforeInputSpecial);
+            editor.off('NewBlock', this.handleEditorChange);
+            Object.keys(this.boundHandlers).forEach((eventName) => {
+                editor.off(eventName, this.boundHandlers[eventName]);
+            });
+            this.boundHandlers = {};
+            editor.remove();
+            this.editor = undefined;
+        }
+        this.assignEditorRef(this.props.editorRef, null);
+    }
+    render() {
+        return this.inline ? this.renderInline() : this.renderIframe();
+    }
+    getEditor() {
+        return this.editor;
+    }
+    beforeInputEvent() {
+        return (0, Utils_1.isBeforeInputEventAvailable)() ? 'beforeinput SelectionChange' : 'SelectionChange';
+    }
+    renderInline() {
+        const { tagName = 'div' } = this.props;
+        return React.createElement(tagName, {
+            ref: this.elementRef,
+            id: this.id,
+            tabIndex: this.props.tabIndex
+        });
+    }
+    renderIframe() {
+        return React.createElement('textarea', {
+            ref: this.elementRef,
+            style: { visibility: 'hidden' },
+            name: this.props.textareaName,
+            id: this.id,
+            tabIndex: this.props.tabIndex
+        });
+    }
+    getScriptSources() {
+        var _a, _b;
+        const async = (_a = this.props.scriptLoading) === null || _a === void 0 ? void 0 : _a.async;
+        const defer = (_b = this.props.scriptLoading) === null || _b === void 0 ? void 0 : _b.defer;
+        if (this.props.truerteScriptSrc !== undefined) {
+            if (typeof this.props.truerteScriptSrc === 'string') {
+                return [{ src: this.props.truerteScriptSrc, async, defer }];
+            }
+        }
+        // fallback to jsDelivr CDN when the truerteScriptSrc is not specified
+        // `cdnVersion` is in `defaultProps`, so it's always defined.
+        const cdnLink = `https://cdn.jsdelivr.net/npm/truerte@${this.props.cdnVersion}/truerte.min.js`;
+        return [{ src: cdnLink, async, defer }];
+    }
+    getInitialValue() {
+        if (typeof this.props.initialValue === 'string') {
+            return this.props.initialValue;
+        }
+        else if (typeof this.props.value === 'string') {
+            return this.props.value;
+        }
+        else {
+            return '';
+        }
+    }
+    bindHandlers(prevProps) {
+        if (this.editor !== undefined) {
+            // typescript chokes trying to understand the type of the lookup function
+            (0, Utils_1.configHandlers)(this.editor, prevProps, this.props, this.boundHandlers, (key) => this.props[key]);
+            // check if we should monitor editor changes
+            const isValueControlled = (p) => p.onEditorChange !== undefined || p.value !== undefined;
+            const wasControlled = isValueControlled(prevProps);
+            const nowControlled = isValueControlled(this.props);
+            if (!wasControlled && nowControlled) {
+                this.editor.on(changeEvents, this.handleEditorChange);
+                this.editor.on(this.beforeInputEvent(), this.handleBeforeInput);
+                this.editor.on('keydown', this.handleBeforeInputSpecial);
+                this.editor.on('keyup', this.handleEditorChangeSpecial);
+                this.editor.on('NewBlock', this.handleEditorChange);
+            }
+            else if (wasControlled && !nowControlled) {
+                this.editor.off(changeEvents, this.handleEditorChange);
+                this.editor.off(this.beforeInputEvent(), this.handleBeforeInput);
+                this.editor.off('keydown', this.handleBeforeInputSpecial);
+                this.editor.off('keyup', this.handleEditorChangeSpecial);
+                this.editor.off('NewBlock', this.handleEditorChange);
+            }
+        }
+    }
+}
+exports.Editor = Editor;
+Editor.defaultProps = {
+    cdnVersion: '1',
+};

package/lib/cjs/main/ts/index.d.ts

@@ -0,0 +1,2 @@
+import { Editor, EditorInstanceRef, IAllProps, IProps, InitOptions } from './components/Editor';
+export { Editor, IAllProps, IProps, InitOptions, EditorInstanceRef };

package/lib/cjs/main/ts/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Editor = void 0;
+const Editor_1 = require("./components/Editor");
+Object.defineProperty(exports, "Editor", { enumerable: true, get: function () { return Editor_1.Editor; } });

package/lib/es2015/main/ts/EventNames.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Official TrueRTE React component
+ * Copyright (c) 2026 TrueRTE contributors
+ * Licensed under the MIT license (https://github.com/truerte/truerte-react/blob/main/LICENSE.TXT)
+ */
+export declare const nativeEvents: readonly ["BeforePaste", "Blur", "Click", "CompositionEnd", "CompositionStart", "CompositionUpdate", "ContextMenu", "Copy", "Cut", "Dblclick", "Drag", "DragDrop", "DragEnd", "DragGesture", "DragOver", "Drop", "Focus", "FocusIn", "FocusOut", "Input", "KeyDown", "KeyPress", "KeyUp", "MouseDown", "MouseEnter", "MouseLeave", "MouseMove", "MouseOut", "MouseOver", "MouseUp", "Paste", "SelectionChange"];
+export declare const customEvents: readonly ["Activate", "AddUndo", "BeforeAddUndo", "BeforeExecCommand", "BeforeGetContent", "BeforeRenderUI", "BeforeSetContent", "Change", "ClearUndos", "CommentChange", "Deactivate", "Dirty", "ExecCommand", "GetContent", "Hide", "IconsLoadError", "Init", "LanguageLoadError", "LoadContent", "ModelLoadError", "NodeChange", "ObjectResizeStart", "ObjectResized", "ObjectSelected", "PluginLoadError", "PostProcess", "PostRender", "PreProcess", "ProgressState", "Redo", "Remove", "Reset", "ResizeEditor", "SaveContent", "SetAttrib", "SetContent", "Show", "SkinLoadError", "Submit", "ThemeLoadError", "Undo", "VisualAid"];
+export declare const validEvents: readonly ["BeforePaste", "Blur", "Click", "CompositionEnd", "CompositionStart", "CompositionUpdate", "ContextMenu", "Copy", "Cut", "Dblclick", "Drag", "DragDrop", "DragEnd", "DragGesture", "DragOver", "Drop", "Focus", "FocusIn", "FocusOut", "Input", "KeyDown", "KeyPress", "KeyUp", "MouseDown", "MouseEnter", "MouseLeave", "MouseMove", "MouseOut", "MouseOver", "MouseUp", "Paste", "SelectionChange", "Activate", "AddUndo", "BeforeAddUndo", "BeforeExecCommand", "BeforeGetContent", "BeforeRenderUI", "BeforeSetContent", "Change", "ClearUndos", "CommentChange", "Deactivate", "Dirty", "ExecCommand", "GetContent", "Hide", "IconsLoadError", "Init", "LanguageLoadError", "LoadContent", "ModelLoadError", "NodeChange", "ObjectResizeStart", "ObjectResized", "ObjectSelected", "PluginLoadError", "PostProcess", "PostRender", "PreProcess", "ProgressState", "Redo", "Remove", "Reset", "ResizeEditor", "SaveContent", "SetAttrib", "SetContent", "Show", "SkinLoadError", "Submit", "ThemeLoadError", "Undo", "VisualAid"];

package/lib/es2015/main/ts/EventNames.js

@@ -0,0 +1,84 @@
+/**
+ * Official TrueRTE React component
+ * Copyright (c) 2026 TrueRTE contributors
+ * Licensed under the MIT license (https://github.com/truerte/truerte-react/blob/main/LICENSE.TXT)
+ */
+export const nativeEvents = [
+    'BeforePaste',
+    'Blur',
+    'Click',
+    'CompositionEnd',
+    'CompositionStart',
+    'CompositionUpdate',
+    'ContextMenu',
+    'Copy',
+    'Cut',
+    'Dblclick',
+    'Drag',
+    'DragDrop',
+    'DragEnd',
+    'DragGesture',
+    'DragOver',
+    'Drop',
+    'Focus',
+    'FocusIn',
+    'FocusOut',
+    'Input',
+    'KeyDown',
+    'KeyPress',
+    'KeyUp',
+    'MouseDown',
+    'MouseEnter',
+    'MouseLeave',
+    'MouseMove',
+    'MouseOut',
+    'MouseOver',
+    'MouseUp',
+    'Paste',
+    'SelectionChange',
+];
+export const customEvents = [
+    'Activate',
+    'AddUndo',
+    'BeforeAddUndo',
+    'BeforeExecCommand',
+    'BeforeGetContent',
+    'BeforeRenderUI',
+    'BeforeSetContent',
+    'Change',
+    'ClearUndos',
+    'CommentChange',
+    'Deactivate',
+    'Dirty',
+    'ExecCommand',
+    'GetContent',
+    'Hide',
+    'IconsLoadError',
+    'Init',
+    'LanguageLoadError',
+    'LoadContent',
+    'ModelLoadError',
+    'NodeChange',
+    'ObjectResizeStart',
+    'ObjectResized',
+    'ObjectSelected',
+    'PluginLoadError',
+    'PostProcess',
+    'PostRender',
+    'PreProcess',
+    'ProgressState',
+    'Redo',
+    'Remove',
+    'Reset',
+    'ResizeEditor',
+    'SaveContent',
+    'SetAttrib',
+    'SetContent',
+    'Show',
+    'SkinLoadError',
+    'Submit',
+    'ThemeLoadError',
+    'Undo',
+    'VisualAid',
+];
+export const validEvents = [...nativeEvents, ...customEvents];