Build your own AI office with Univer Office SDK. Bring editing, calculation, collaboration, and file processing into your product for people and AI agents. Built on an extensible open-source core.
TypeScript boardcollaborationdocdocxexceloffce365officepdfpptpptxpresentationsdksheetslidesspreadsheetuniverwordwordprocessorworkspacexlsx
fix(ui): prevent ribbon updates after disposal (#7883)
Univerad1e08301ba0
diff --git a/packages/ui/src/services/ribbon/__tests__/ribbon.service.spec.ts b/packages/ui/src/services/ribbon/__tests__/ribbon.service.spec.tsindex 96b7d94259..2fa6901d12 100644--- a/packages/ui/src/services/ribbon/__tests__/ribbon.service.spec.ts+++ b/packages/ui/src/services/ribbon/__tests__/ribbon.service.spec.ts@@ -24,6 +24,10 @@ import {ILogService,Injector,IUniverInstanceService,+ LocaleService,+ LocaleType,+ toDisposable,+ Univer,UniverInstanceService,} from '@univerjs/core';import { BehaviorSubject, Observable, Subject } from 'rxjs';@@ -48,6 +52,166 @@ function createInjector(univerInstanceService?: { focused$: BehaviorSubject<stri}describe('DesktopRibbonService', () => {+ it('finishes global disposal when a later owner hides an active contextual tab', () => {+ const univer = new Univer({ locales: { [LocaleType.EN_US]: { title: 'Tools' } }, locale: LocaleType.EN_US, direction: 'ltr' });+ const injector = univer.__getInjector();+ injector.add([IMenuManagerService, { useClass: MenuManagerService }]);+ injector.add([IRibbonService, { useClass: DesktopRibbonService }]);+ const service = injector.get(IRibbonService);+ injector.get(IMenuManagerService).appendRootMenu({+ [MenuManagerPosition.RIBBON]: {+ tools: {+ contextual: true,+ group: {+ command: {+ menuItemFactory: (accessor) => ({ id: 'tools', type: MenuItemType.BUTTON, title: accessor.get(LocaleService).t('title') }),+ },+ },+ },+ },+ });+ service.showContextualTab('tools', { activate: true });+ injector.add(['contextual-tab-owner', { useValue: toDisposable(() => service.hideContextualTab('tools')) }]);+ injector.get('contextual-tab-owner');+ let completed = false;+ injector.onDispose(() => completed = true);++ expect(() => univer.dispose()).not.toThrow();+ expect(completed).toBe(true);+ });++ it('does not rebuild menus or acquire hidden subscriptions during or after disposal', () => {+ const injector = createInjector();+ const service = injector.get(IRibbonService) as DesktopRibbonService;+ const menu = injector.get(IMenuManagerService);+ let factories = 0;+ let subscriptions = 0;+ let unsubscriptions = 0;+ const hidden$ = new Observable<boolean>((subscriber) => {+ subscriptions += 1;+ subscriber.next(false);+ return () => unsubscriptions += 1;+ });+ menu.appendRootMenu({+ [MenuManagerPosition.RIBBON]: {+ tools: {+ contextual: true,+ group: {+ command: {+ menuItemFactory: () => {+ factories += 1;+ return { id: 'tools', type: MenuItemType.BUTTON, hidden$ };+ },+ },+ },+ },+ },+ });+ service.showContextualTab('tools');+ const factoryCount = factories;+ const subscription = service.ribbon$.subscribe((tabs) => {+ if (tabs.length === 0) {+ service.showContextualTab('tools');+ }+ });++ service.dispose();+ service.showContextualTab('tools', { activate: true });+ service.hideContextualTab('tools');+ service.hideAllContextualTabs();+ menu.updateMenuConfig({});+ service.dispose();++ expect(factories).toBe(factoryCount);+ expect(subscriptions).toBe(unsubscriptions);+ subscription.unsubscribe();+ });++ it('keeps UI state unchanged when teardown observers invoke setters during or after disposal', () => {+ const injector = createInjector();+ const service = injector.get(IRibbonService) as DesktopRibbonService;+ const activated: string[] = [];+ const collapsed: string[][] = [];+ const fakeToolbarVisible: boolean[] = [];+ const completed: string[] = [];+ service.activatedTab$.subscribe({+ next: (tab) => activated.push(tab),+ complete: () => completed.push('activated'),+ });+ service.collapsedIds$.subscribe({+ next: (ids) => collapsed.push(ids),+ complete: () => completed.push('collapsed'),+ });+ service.fakeToolbarVisible$.subscribe({+ next: (visible) => fakeToolbarVisible.push(visible),+ complete: () => completed.push('fakeToolbar'),+ });+ service.setActivatedTab(RibbonPosition.INSERT);+ service.setCollapsedIds(['format']);+ service.setFakeToolbarVisible(true);+ const previousActivated = [...activated];+ const previousCollapsed = [...collapsed];+ const previousFakeToolbarVisible = [...fakeToolbarVisible];+ let disposing = false;+ let teardownNotifications = 0;+ service.ribbon$.subscribe((tabs) => {+ if (disposing && tabs.length === 0) {+ teardownNotifications += 1;+ service.setActivatedTab(RibbonPosition.START);+ service.setCollapsedIds([]);+ service.setFakeToolbarVisible(false);+ }+ });++ disposing = true;+ service.dispose();+ service.setActivatedTab(RibbonPosition.START);+ service.setCollapsedIds([]);+ service.setFakeToolbarVisible(false);+ service.dispose();++ expect(teardownNotifications).toBe(1);+ expect(activated).toEqual(previousActivated);+ expect(collapsed).toEqual(previousCollapsed);+ expect(fakeToolbarVisible).toEqual(previousFakeToolbarVisible);+ expect(completed.sort()).toEqual(['activated', 'collapsed', 'fakeToolbar']);+ });++ it('releases hidden subscriptions when disposed synchronously by a ribbon observer', () => {+ const injector = createInjector();+ const service = injector.get(IRibbonService) as DesktopRibbonService;+ let subscriptions = 0;+ let unsubscriptions = 0;+ const hidden$ = new Observable<boolean>((subscriber) => {+ subscriptions += 1;+ subscriber.next(false);+ return () => unsubscriptions += 1;+ });+ injector.get(IMenuManagerService).appendRootMenu({+ [MenuManagerPosition.RIBBON]: {+ tools: {+ contextual: true,+ group: {+ command: {+ menuItemFactory: () => ({ id: 'tools', type: MenuItemType.BUTTON, hidden$ }),+ },+ },+ },+ },+ });+ const subscription = service.ribbon$.subscribe((tabs) => {+ if (tabs.some((tab) => tab.key === 'tools')) {+ service.dispose();+ }+ });++ service.showContextualTab('tools');++ expect(subscriptions).toBeGreaterThan(0);+ expect(unsubscriptions).toBe(subscriptions);+ subscription.unsubscribe();+ });+it('shows contextual ribbon tabs only when requested and restores the last regular tab when hidden', () => {const injector = createInjector();const service = injector.get(IRibbonService);diff --git a/packages/ui/src/services/ribbon/ribbon.service.ts b/packages/ui/src/services/ribbon/ribbon.service.tsindex 75f18a2e4f..1bba281d8e 100644--- a/packages/ui/src/services/ribbon/ribbon.service.ts+++ b/packages/ui/src/services/ribbon/ribbon.service.ts@@ -69,6 +69,10 @@ export class DesktopRibbonService extends Disposable implements IRibbonService {}setActivatedTab(tab: string): void {+ if (this._disposed) {+ return;+ }+if (!this._isContextualTab(tab)) {this._lastNonContextualActivatedTab = tab;}@@ -77,6 +81,10 @@ export class DesktopRibbonService extends Disposable implements IRibbonService {}showContextualTab(tab: string, options?: { activate?: boolean }): void {+ if (this._disposed) {+ return;+ }+this._visibleContextualTabs.add(tab);this._updateRibbon();@@ -86,6 +94,10 @@ export class DesktopRibbonService extends Disposable implements IRibbonService {}hideContextualTab(tab: string): void {+ if (this._disposed) {+ return;+ }+if (!this._visibleContextualTabs.delete(tab)) {return;}@@ -94,6 +106,10 @@ export class DesktopRibbonService extends Disposable implements IRibbonService {}hideAllContextualTabs(): void {+ if (this._disposed) {+ return;+ }+if (this._visibleContextualTabs.size === 0) {return;}@@ -103,10 +119,18 @@ export class DesktopRibbonService extends Disposable implements IRibbonService {}setCollapsedIds(ids: string[]): void {+ if (this._disposed) {+ return;+ }+this._collapsedIds$.next(ids);}setFakeToolbarVisible(visible: boolean): void {+ if (this._disposed) {+ return;+ }+this._fakeToolbarVisible$.next(visible);}@@ -122,6 +146,10 @@ export class DesktopRibbonService extends Disposable implements IRibbonService {}private _updateRibbon() {+ if (this._disposed) {+ return;+ }+const ribbon = this._filterContextualTabs(this._menuManagerService.getMenuByPositionKey(MenuManagerPosition.RIBBON));@@ -192,6 +220,12 @@ export class DesktopRibbonService extends Disposable implements IRibbonService {this._setRibbon(newRibbon);});++ // A synchronous ribbon observer can dispose the service before subscribe returns.+ if (this._disposed) {+ this._hiddenSubscription.unsubscribe();+ this._hiddenSubscription = null;+ }}private _filterContextualTabs(ribbon: IMenuSchema[]): IMenuSchema[] {@@ -236,6 +270,13 @@ export class DesktopRibbonService extends Disposable implements IRibbonService {}override dispose(): void {+ if (this._disposed) {+ return;+ }++ super.dispose();+ this._visibleContextualTabs.clear();+ this._contextualTabs.clear();this._hiddenSubscription?.unsubscribe();this._hiddenSubscription = null;this._ribbon$.next([]);@@ -243,6 +284,5 @@ export class DesktopRibbonService extends Disposable implements IRibbonService {this._activatedTab$.complete();this._collapsedIds$.complete();this._fakeToolbarVisible$.complete();- super.dispose();}}