@tiptap/react 2.13.0 → 2.14.1

package/dist/index.js

@@ -1208,9 +1208,46 @@ function isClassComponent(Component) {
  * @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
@@ -1279,26 +1316,18 @@ class ReactRenderer {
         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);