@douyinfe/semi-foundation 2.93.0 → 2.94.1

package/upload/foundation.ts

@@ -88,8 +88,10 @@ export interface UploadAdapter<P = Record<string, any>, S = Record<string, any>>
     notifyPreviewClick: (file: any) => void;
     notifyDrop: (e: any, files: Array<File>, fileList: Array<BaseFileItem>) => void;
     notifyAcceptInvalid: (invalidFiles: Array<File>) => void;
-    registerPastingHandler: (cb?: (params?: any) => void) => void;
+    registerPastingHandler: (cb?: (params?: KeyboardEvent | ClipboardEvent) => void) => void;
     unRegisterPastingHandler: () => void;
+    registerPasteEventHandler: (cb?: (params?: ClipboardEvent) => void) => void;
+    unRegisterPasteEventHandler: () => void;
     isMac: () => boolean;
     notifyPastingError: (error: Error | PermissionStatus) => void
     // notifyPasting: () => void; 
@@ -103,6 +105,11 @@ class UploadFoundation<P = Record<string, any>, S = Record<string, any>> extends
      * when _createURL is called multiple times in a sync loop.
      */
     _localUrls: Record<string, string> = {};
+    /**
+     * Flag to prevent duplicate handling of paste events.
+     * When paste event is successfully handled, we ignore the subsequent keydown event.
+     */
+    _pasteHandled: boolean = false;
     constructor(adapter: UploadAdapter<P, S>) {
         super({ ...adapter });
     }
@@ -1024,41 +1031,91 @@ class UploadFoundation<P = Record<string, any>, S = Record<string, any>> extends
     }
 
     handlePasting(e: any) {
+        const { addOnPasting } = this.getProps();
+        if (!addOnPasting) {
+            return;
+        }
+
+        // Try to read from native paste event (clipboardData) first as fallback
+        if (e.type === 'paste' && e.clipboardData && e.clipboardData.items) {
+            const items = e.clipboardData.items;
+            const files: File[] = [];
+            
+            for (let i = 0; i < items.length; i++) {
+                const item = items[i];
+                // Check if the item is a file (image, etc.)
+                if (item.kind === 'file') {
+                    const file = item.getAsFile();
+                    if (file) {
+                        files.push(file);
+                    }
+                }
+            }
+
+            if (files.length > 0) {
+                e.preventDefault();
+                this.handleChange(files);
+                // Mark that paste event has been handled to prevent duplicate handling by keydown event
+                this._pasteHandled = true;
+                // Reset the flag after a short delay to allow future paste operations
+                setTimeout(() => {
+                    this._pasteHandled = false;
+                }, 100);
+                return;
+            }
+        }
+
+        // Fallback to navigator.clipboard for keyboard events (keydown with Ctrl/Cmd+V)
+        // Skip if paste event has already been handled
+        if (this._pasteHandled) {
+            this._pasteHandled = false;
+            return;
+        }
+
         const isMac = this._adapter.isMac();
         const isCombineKeydown = isMac ? e.metaKey : e.ctrlKey;
-        const { addOnPasting } = this.getProps();
-        if (addOnPasting) {
-            if (isCombineKeydown && e.code === 'KeyV') {
-                // https://github.com/microsoft/TypeScript/issues/33923
-                const permissionName = 'clipboard-read' as PermissionName;
-                // The main thread should not be blocked by clipboard, so callback writing is required here. No await here
-                navigator.permissions
-                    .query({ name: permissionName })
-                    .then(result => {
-                        if (result.state === 'granted' || result.state === 'prompt') {
-                            // user has authorized or will authorize
-                            navigator.clipboard.read().then(clipboardItems => {
-                                // Process the data read from the pasteboard
-                                // Check the returned data type to determine if it is image data, and process accordingly
-                                this.readFileFromClipboard(clipboardItems);
-                            });
-                        } else {
-                            this._adapter.notifyPastingError(result);
-                        }
-                    })
-                    .catch(error => {
-                        this._adapter.notifyPastingError(error);
-                    });
+        
+        if (isCombineKeydown && e.code === 'KeyV') {
+            // Check if navigator.clipboard is available
+            if (!navigator.clipboard || typeof navigator.clipboard.read !== 'function') {
+                return;
             }
+
+            // https://github.com/microsoft/TypeScript/issues/33923
+            const permissionName = 'clipboard-read' as PermissionName;
+            // The main thread should not be blocked by clipboard, so callback writing is required here. No await here
+            navigator.permissions
+                .query({ name: permissionName })
+                .then(result => {
+                    if (result.state === 'granted' || result.state === 'prompt') {
+                        // user has authorized or will authorize
+                        navigator.clipboard.read().then(clipboardItems => {
+                            // Process the data read from the pasteboard
+                            // Check the returned data type to determine if it is image data, and process accordingly
+                            this.readFileFromClipboard(clipboardItems);
+                        }).catch(error => {
+                            this._adapter.notifyPastingError(error);
+                        });
+                    } else {
+                        this._adapter.notifyPastingError(result);
+                    }
+                })
+                .catch(error => {
+                    this._adapter.notifyPastingError(error);
+                });
         }
     }
 
     bindPastingHandler(): void {
+        // Register keyboard event handler (keydown with Ctrl/Cmd+V)
         this._adapter.registerPastingHandler((event) => this.handlePasting(event));
+        // Register native paste event handler as fallback
+        this._adapter.registerPasteEventHandler((event) => this.handlePasting(event));
     }
 
     unbindPastingHandler() {
         this._adapter.unRegisterPastingHandler();
+        this._adapter.unRegisterPasteEventHandler();
     }
 }
 

package/utils/escapeHtml.ts

@@ -0,0 +1,94 @@
+/**
+ * Escape HTML angle brackets in markdown text, preserving code blocks and inline code.
+ * 
+ * In `format='md'` mode, @mdx-js/mdx uses `rehypeRemoveRaw` which strips all raw HTML nodes.
+ * This causes user-typed HTML-like content (e.g. `<AgentChat />`) to silently disappear.
+ * By escaping `<` to `&lt;` outside of code spans/blocks, the markdown parser treats them
+ * as literal text instead of HTML tags.
+ */
+export function escapeHtmlInMarkdown(text: string): string {
+    const lines = text.split('\n');
+    const result: string[] = [];
+    let fenceChar: string | null = null;
+    let fenceLen = 0;
+
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+
+        if (fenceChar !== null) {
+            // Inside a fenced code block — check for closing fence
+            result.push(line);
+            const trimmed = line.trimEnd();
+            if (
+                trimmed.length >= fenceLen &&
+                trimmed[0] === fenceChar &&
+                trimmed === fenceChar.repeat(trimmed.length)
+            ) {
+                fenceChar = null;
+            }
+        } else {
+            // Check if this line opens a fenced code block
+            const fenceMatch = line.match(/^(`{3,}|~{3,})/);
+            if (fenceMatch) {
+                fenceChar = fenceMatch[1][0];
+                fenceLen = fenceMatch[1].length;
+                result.push(line);
+            } else {
+                result.push(escapeAngleBracketsOutsideInlineCode(line));
+            }
+        }
+    }
+
+    return result.join('\n');
+}
+
+/**
+ * Escape `<` to `&lt;` in a single line, but preserve content inside inline code spans.
+ */
+function escapeAngleBracketsOutsideInlineCode(line: string): string {
+    const parts: string[] = [];
+    let i = 0;
+
+    while (i < line.length) {
+        if (line[i] === '`') {
+            // Count opening backticks
+            let count = 0;
+            const start = i;
+            while (i < line.length && line[i] === '`') {
+                count++;
+                i++;
+            }
+            // Find matching closing backticks (exact same count)
+            const closer = '`'.repeat(count);
+            const closeIdx = line.indexOf(closer, i);
+            if (closeIdx !== -1) {
+                parts.push(line.slice(start, closeIdx + count));
+                i = closeIdx + count;
+            } else {
+                // No matching close — treat backticks as regular text, escape any `<`
+                parts.push(line.slice(start, i).replace(/</g, '&lt;'));
+            }
+        } else if (line[i] === '<') {
+            parts.push('&lt;');
+            i++;
+        } else {
+            // Collect a run of non-special characters at once
+            const next = line.indexOf('<', i);
+            const nextBt = line.indexOf('`', i);
+            let end: number;
+            if (next === -1 && nextBt === -1) {
+                end = line.length;
+            } else if (next === -1) {
+                end = nextBt;
+            } else if (nextBt === -1) {
+                end = next;
+            } else {
+                end = Math.min(next, nextBt);
+            }
+            parts.push(line.slice(i, end));
+            i = end;
+        }
+    }
+
+    return parts.join('');
+}

package/utils/object.ts

@@ -66,7 +66,9 @@ function cleanup(obj: ObjectType, path: string[], pull = true) {
     // }
 
     // Delete object if its empty
-    if (Array.isArray(target) && target.every(e => e == null)) {
+    // Only delete array if it's not empty AND all elements are null/undefined
+    // This prevents empty arrays from being deleted (issue #2834)
+    if (Array.isArray(target) && target.length > 0 && target.every(e => e == null)) {
         lodashUnset(obj, path);
     } else if (isEmptyObject(target)) {
         lodashUnset(obj, path);