Implement cancelled state uploads manager

src/elements/content-uploader/ContentUploader.tsx

@@ -966,19 +966,31 @@ class ContentUploader extends Component<ContentUploaderProps, State> {
      */
     updateViewAndCollection(items: UploadItem[], callback?: () => void) {
         const {
+            enableModernizedUploads,
             isPartialUploadEnabled,
             isResumableUploadsEnabled,
             onComplete,
             useUploadsManager,
         }: ContentUploaderProps = this.props;
-        const someUploadIsInProgress = items.some(uploadItem => uploadItem.status !== STATUS_COMPLETE);
+        // When the modernized flow is on, canceled items are kept in the list
+        // but treated as terminal so they do not block completion logic. The
+        // legacy view/state machine sees canceled items as non-COMPLETE which
+        // would otherwise stall progress and emit a stale success notification.
+        const isTerminalForModernized = (uploadItem: UploadItem) =>
+            enableModernizedUploads && uploadItem.status === STATUS_CANCELED;
+        const someUploadIsInProgress = items.some(
+            uploadItem => uploadItem.status !== STATUS_COMPLETE && !isTerminalForModernized(uploadItem),
+        );
         const someUploadHasFailed = items.some(uploadItem => uploadItem.status === STATUS_ERROR);
         const allItemsArePending = !items.some(uploadItem => uploadItem.status !== STATUS_PENDING);
         const noFileIsPendingOrInProgress = items.every(
             uploadItem => uploadItem.status !== STATUS_PENDING && uploadItem.status !== STATUS_IN_PROGRESS,
         );
         const areAllItemsFinished = items.every(
-            uploadItem => uploadItem.status === STATUS_COMPLETE || uploadItem.status === STATUS_ERROR,
+            uploadItem =>
+                uploadItem.status === STATUS_COMPLETE ||
+                uploadItem.status === STATUS_ERROR ||
+                isTerminalForModernized(uploadItem),
         );
         const uploadItemsStatus = isResumableUploadsEnabled ? areAllItemsFinished : noFileIsPendingOrInProgress;
 
@@ -1012,7 +1024,13 @@ class ContentUploader extends Component<ContentUploaderProps, State> {
             if (this.isAutoExpanded) {
                 this.resetUploadManagerExpandState();
             } // Else manually expanded so don't close
-            onComplete(items);
+            // In the modernized flow, suppress the completion notification
+            // when no item actually finished successfully (e.g. user canceled
+            // every upload). This prevents a misleading "upload complete" toast.
+            const hasCompletedItem = items.some(uploadItem => uploadItem.status === STATUS_COMPLETE);
+            if (!enableModernizedUploads || hasCompletedItem) {
+                onComplete(items);
+            }
         }
 
         const state: Partial<State> = {

src/elements/content-uploader/__tests__/ContentUploader.test.js

@@ -927,6 +927,59 @@ describe('elements/content-uploader/ContentUploader', () => {
                 expect(complete.api.cancel).not.toHaveBeenCalled();
             });
 
+            test('updateViewAndCollection should not fire onComplete when all items are canceled (modernized)', () => {
+                const onComplete = jest.fn();
+                const wrapper = getWrapper({
+                    enableModernizedUploads: true,
+                    useUploadsManager: true,
+                    onComplete,
+                });
+                const instance = wrapper.instance();
+                const canceled = { status: 'canceled' };
+                instance.updateViewAndCollection([{ ...canceled, file: { name: 'a' } }, { ...canceled, file: { name: 'b' } }]);
+                expect(onComplete).not.toHaveBeenCalled();
+            });
+
+            test('updateViewAndCollection should fire onComplete when at least one item completes (modernized)', () => {
+                const onComplete = jest.fn();
+                const wrapper = getWrapper({
+                    enableModernizedUploads: true,
+                    useUploadsManager: true,
+                    onComplete,
+                });
+                const instance = wrapper.instance();
+                instance.updateViewAndCollection([
+                    { status: STATUS_COMPLETE, file: { name: 'a' } },
+                    { status: 'canceled', file: { name: 'b' } },
+                ]);
+                expect(onComplete).toHaveBeenCalled();
+            });
+
+            test('updateViewAndCollection should treat canceled items as terminal (modernized)', () => {
+                const wrapper = getWrapper({
+                    enableModernizedUploads: true,
+                    useUploadsManager: true,
+                });
+                const instance = wrapper.instance();
+                instance.updateViewAndCollection([
+                    { status: STATUS_COMPLETE, file: { name: 'a' } },
+                    { status: 'canceled', file: { name: 'b' } },
+                ]);
+                expect(wrapper.state('view')).not.toBe(VIEW_UPLOAD_IN_PROGRESS);
+            });
+
+            test('updateViewAndCollection should preserve legacy behavior when modernized flag is off', () => {
+                const onComplete = jest.fn();
+                const wrapper = getWrapper({
+                    enableModernizedUploads: false,
+                    useUploadsManager: true,
+                    onComplete,
+                });
+                const instance = wrapper.instance();
+                instance.updateViewAndCollection([{ status: STATUS_COMPLETE, file: { name: 'a' } }]);
+                expect(onComplete).toHaveBeenCalled();
+            });
+
             test('handleRetryAllUploads should restart errored and canceled items', () => {
                 const wrapper = getWrapper({ enableModernizedUploads: true });
                 const errored = {