@tiptap/react 2.13.0 → 2.14.1

package/dist/index.umd.js

@@ -1207,9 +1207,46 @@
 	 * @returns {boolean}
 	 */
 	function isForwardRefComponent(Component) {
-	    var _a;
 	    return !!(typeof Component === 'object'
-	        && ((_a = Component.$$typeof) === null || _a === void 0 ? void 0 : _a.toString()) === 'Symbol(react.forward_ref)');
+	        && Component.$$typeof
+	        && (Component.$$typeof.toString() === 'Symbol(react.forward_ref)'
+	            || Component.$$typeof.description === 'react.forward_ref'));
+	}
+	/**
+	 * Check if a component is a memoized component.
+	 * @param Component
+	 * @returns {boolean}
+	 */
+	function isMemoComponent(Component) {
+	    return !!(typeof Component === 'object'
+	        && Component.$$typeof
+	        && (Component.$$typeof.toString() === 'Symbol(react.memo)' || Component.$$typeof.description === 'react.memo'));
+	}
+	/**
+	 * Check if a component can safely receive a ref prop.
+	 * This includes class components, forwardRef components, and memoized components
+	 * that wrap forwardRef or class components.
+	 * @param Component
+	 * @returns {boolean}
+	 */
+	function canReceiveRef(Component) {
+	    // Check if it's a class component
+	    if (isClassComponent(Component)) {
+	        return true;
+	    }
+	    // Check if it's a forwardRef component
+	    if (isForwardRefComponent(Component)) {
+	        return true;
+	    }
+	    // Check if it's a memoized component
+	    if (isMemoComponent(Component)) {
+	        // For memoized components, check the wrapped component
+	        const wrappedComponent = Component.type;
+	        if (wrappedComponent) {
+	            return isClassComponent(wrappedComponent) || isForwardRefComponent(wrappedComponent);
+	        }
+	    }
+	    return false;
 	}
 	/**
 	 * Check if we're running React 19+ by detecting if function components support ref props
@@ -1278,26 +1315,18 @@
 	        const editor = this.editor;
 	        // Handle ref forwarding with React 18/19 compatibility
 	        const isReact19 = isReact19Plus();
-	        const isClassComp = isClassComponent(Component);
-	        const isForwardRefComp = isForwardRefComponent(Component);
+	        const componentCanReceiveRef = canReceiveRef(Component);
 	        const elementProps = { ...props };
-	        if (!elementProps.ref) {
-	            if (isReact19) {
-	                // React 19: ref is a standard prop for all components
-	                // @ts-ignore - Setting ref prop for React 19 compatibility
-	                elementProps.ref = (ref) => {
-	                    this.ref = ref;
-	                };
-	            }
-	            else if (isClassComp || isForwardRefComp) {
-	                // React 18 and prior: only set ref for class components and forwardRef components
-	                // @ts-ignore - Setting ref prop for React 18 class/forwardRef components
-	                elementProps.ref = (ref) => {
-	                    this.ref = ref;
-	                };
-	            }
-	            // For function components in React 18, we can't use ref - the component won't receive it
-	            // This is a limitation we have to accept for React 18 function components without forwardRef
+	        // Always remove ref if the component cannot receive it (unless React 19+)
+	        if (elementProps.ref && !(isReact19 || componentCanReceiveRef)) {
+	            delete elementProps.ref;
+	        }
+	        // Only assign our own ref if allowed
+	        if (!elementProps.ref && (isReact19 || componentCanReceiveRef)) {
+	            // @ts-ignore - Setting ref prop for compatible components
+	            elementProps.ref = (ref) => {
+	                this.ref = ref;
+	            };
 	        }
 	        this.reactElement = React.createElement(Component, { ...elementProps });
 	        (_a = editor === null || editor === void 0 ? void 0 : editor.contentComponent) === null || _a === void 0 ? void 0 : _a.setRenderer(this.id, this);