You need to enable JavaScript to run this app. Angular跨组件按钮触发mat-expansion-panel展开的实现方法
优惠活动
大模型
产品
解决方案
定价
更多

Angular跨组件按钮触发mat-expansion-panel展开的实现方法

Angular跨组件触发mat-expansion-panel展开的实现方案

问题描述

作为Angular开发新手,计划在搜索/筛选栏位置增加一个按钮,点击按钮即可触发托管在其他独立组件中的mat-expansion-panel展开逻辑,暂不明确这类跨组件交互的合理架构设计方式。

现有代码片段

按钮关联的HTML代码

<input *ngIf="!(isMobile$ | async) && (isOnline$ | async)"
  #filterTextInput
  id="filter-text-input"
  class="numeric-input"
  type="text"
  [value]="itemFilterText$ | async"
  autocomplete="off"
  placeholder="{{'HEADER.SEARCH.PLACEHOLDER' | translate}}"
  attr.aria-label="{{'HEADER.SEARCH.PLACEHOLDER' | translate }}"
  (keyup.enter)="searchForValue(searchString.value)" />
<button mat-raised-button (click)="togglePanel">Open</button>

承载交互逻辑的TypeScript代码

import { Component, OnInit, Output, EventEmitter, ViewChildren, QueryList, ElementRef, ChangeDetectionStrategy } from '@angular/core';
import { Worksheet, StorageArea, WorksheetItem, CountableItem, CountingUnit, ConversionUnit } from 'src/app/models';
import { StorageAreaUtilsService } from 'src/app/services/storage-area-utils.service';
import { Store } from '@ngrx/store';
import { AppState } from 'src/app/store/reducers';
import { first, filter, map, flatMap } from 'rxjs/operators';
import { SetStorageAreaExpandStatus, PatchStorageArea, GetAllCustomItemDataAttempt } from 'src/app/store/actions/worksheets.actions';
import { combineLatest, Observable } from 'rxjs';
import { PageEvent, MatPaginator } from '@angular/material';
import { InventoryConstants } from 'src/app/inventory-constants';
import { GetMeasurementUnitsAttempt } from 'src/app/store/actions/addItems.actions';
import { InventoryValueService } from 'src/app/services/inventory-value.service';

@Component({
  selector: 'app-storage-area-item-panel',
  templateUrl: './storage-area-item-panel.component.html',
  styleUrls: ['./storage-area-item-panel.component.scss'],
  changeDetection: ChangeDetectionStrategy.OnPush
})

export class StorageAreaItemPanelComponent implements OnInit {
  worksheet$ = this.store.select(state => {
    return state.worksheets.worksheets[state.worksheets.selected];
  });
  currentLang$ = this.store.select(state => state.layout.language);
  isMobile$ = this.store.select(state => state.layout.isMobile);
  inventoryItems$ = this.store.select(state => state.inventoryItems.inventoryItems);
  itemFilterText$ = this.store.select(state => state.worksheets.itemFilterText);
  assignedStorageAreas$: Observable<StorageArea[]>;
  unAssignedStorageArea$: Observable<StorageArea>;
  pricingPermissions = InventoryConstants.INVENTORY_ROLE_PERMISSIONS.pricing;
  standardUnits$ = this.store.select(state => state.addItems.measurementUnits).pipe(
    map(units => {
      return units.filter(unit => unit.measurementType === 'weight');
    })
  );
  customItemData$ = this.store.select(state => state.worksheets.customItemData);
  standardCountingUnits$ = this.store.select(state => state.worksheets.countingUnits);
  customCountingUnits$ = this.customItemData$.pipe(
    map(data => {
      const itemUnits: CountingUnit[] = [];
      data.forEach(datum => {
        datum.countingUnits.forEach(unit => {
          if (unit.custom) {
            itemUnits.push({
              itemId: datum.itemId,
              unit: { unitType: 'CUSTOM', unitId: unit.custom.id } as ConversionUnit,
              customUnit: unit
            } as CountingUnit);
          }
        });
      });
      return itemUnits;
    }));
  countingUnits$ = combineLatest(this.standardCountingUnits$, this.customCountingUnits$).pipe(
    map(response => {
      return [].concat(...response);
    }));

  @Output() afterExpand = new EventEmitter();

  storageAreaPaging: { [s: string]: number };

  @ViewChildren('storageAreaPaginator')
  paginators: QueryList<MatPaginator>;
  @ViewChildren('storageAreaPaginatorIndexPlaceholder')
  paginatorsDOM: QueryList<ElementRef>;

  constructor(
    private store: Store<AppState>,
    private storageAreaUtils: StorageAreaUtilsService,
    private inventoryValueService: InventoryValueService
  ) {
    this.storageAreaPaging = {};
  }

  ngOnInit() {
    this.store.dispatch(new GetMeasurementUnitsAttempt());
    this.store.dispatch(new GetAllCustomItemDataAttempt());
    this.expandPanels();
    this.assignedStorageAreas$ = this.storageAreaUtils.getStorageAreasMinusUnassigned(this.worksheet$);
    this.unAssignedStorageArea$ = this.storageAreaUtils.getUnassignedStorageArea(this.worksheet$);
  }

  onLastItemEnter(storageArea?: StorageArea) {
    const pageSize = 10;
    if (storageArea) {
      let pageIndex = this.storageAreaPaging[storageArea.id] / pageSize;
      if (!pageIndex) {
        pageIndex = 0;
      }
      if ((pageIndex + 1) * pageSize < storageArea.worksheetItems.length) {
        this.storageAreaPaging[storageArea.id] = (pageIndex + 1) * pageSize;
        const paginatorIndex = this.paginatorsDOM.toArray().findIndex(element => {
          return element.nativeElement.id === `paginator-${storageArea.id}`;
        });
        const paginator = this.paginators.toArray()[paginatorIndex];
        paginator.nextPage();
      }
    } else {
      this.unAssignedStorageArea$.pipe(first()).subscribe(unassigned => {
        let pageIndex = this.storageAreaPaging[unassigned.id] / pageSize;
        if (!pageIndex) {
          pageIndex = 0;
        }
        if ((pageIndex + 1) * pageSize < unassigned.worksheetItems.length) {
          this.storageAreaPaging[unassigned.id] = (pageIndex + 1) * pageSize;
          const paginator = this.paginators.toArray()[0];
          paginator.nextPage();
        }
      });
    }
  }

  onPageClick(event: PageEvent, storageAreaId?: string) {
    if (storageAreaId) {
      this.storageAreaPaging[storageAreaId] = event.pageIndex * event.pageSize;
    } else {
      this.unAssignedStorageArea$.pipe(first()).subscribe(unassigned => {
        this.storageAreaPaging[unassigned.id] = event.pageIndex * event.pageSize;
      });
    }
  }

  getCurrentPageByStorageAreaId(storageAreaId: string, offsetToAdd: number = 0) {
    return this.storageAreaPaging[storageAreaId] ? this.storageAreaPaging[storageAreaId] + offsetToAdd : 0 + offsetToAdd;
  }

  getTranslation(name: string) {
    return this.storageAreaUtils.getTranslation(name);
  }

  getRowItemCount(storageArea: StorageArea) {
    return this.storageAreaUtils.getRowItemCount(storageArea);
  }

  getWorksheetId(): Observable<string> {
    return this.worksheet$.pipe(
      filter(ws => !!ws),
      map((ws: Worksheet) => ws.id)
    );
  }

  // expands the first panel with items if desktop, expands all if mobile
  expandPanels() {
    combineLatest(this.isMobile$, this.worksheet$).pipe(
      filter(([isMobile, ws]) => {
        if (ws && ws.storageAreas) {
          return true;
        } else {
           return false;
        }
      }),
      first()
    ).subscribe(([isMobile, ws]) => {
      if (isMobile) {
        ws.storageAreas.forEach((area: StorageArea) => {
          if (area.expandStatus !== true) {
            this.store.dispatch(new SetStorageAreaExpandStatus({ status: true, areaId: area.id }));
          }
        });
      } else if (ws.storageAreas) {
        const firstStorageAreaWithRowItems: StorageArea = ws.storageAreas.find(stArea => {
          return stArea.worksheetItems.length > 0;
        });
        if (firstStorageAreaWithRowItems
          && firstStorageAreaWithRowItems.expandStatus !== true) {
            this.store.dispatch(new SetStorageAreaExpandStatus({ status: true, areaId: firstStorageAreaWithRowItems.id }));
        }
      }
    });
  }

  fireSetStorageAreaExpandStatus(event: Event, area: StorageArea) {
    if (area !== null) {
      this.store.dispatch(new SetStorageAreaExpandStatus({
        status: !area.expandStatus,
        areaId: area.id
      }));
    } else if (area === null) {
      this.unAssignedStorageArea$
        .pipe(first()).subscribe(unassigned => {
          this.store.dispatch(new SetStorageAreaExpandStatus({
            status: !unassigned.expandStatus,
            areaId: unassigned.id
          }));
        });
    }
  }

  /** Filters general items to only the items contained in the given storage area
   * @param area: the storage area to filter by
   */
  filterInventoryItemsByArea(area: StorageArea): Observable<{ [s: string]: CountableItem }> {
    return this.inventoryItems$.pipe(
      filter(() => !!area && !!area.worksheetItems),
      map((items) => {
        return Object.keys(items)
          .filter(id => {
            return area.worksheetItems.some(rowItem => rowItem.itemId === id);
          })
          .reduce((acc, id) => {
            acc[id] = items[id];
            return acc;
          }, {});
      })
    );
  }

  filterStorageAreaItemsByFilterText(area: StorageArea): Observable<WorksheetItem[]> {
    return combineLatest(this.itemFilterText$, this.inventoryItems$, this.currentLang$)
      .pipe(
        map(([text, invItems, lang]) => {
          if (area.worksheetItems) {
            return this.getSortedWorksheetItems(area).filter(workItem => {
              const countableItem = invItems[workItem.itemId];
              if (countableItem) {
                if (countableItem.Item) {
                  // the item exists and contains the search text in the name, brand, or item SKU
                  return ((countableItem.Item.description
                          .find(localValue => localValue.languageCode === lang) !== undefined
                        && countableItem.Item.description
                          .find(localValue => localValue.languageCode === lang).value
                        && countableItem.Item.description
                          .find(localValue => localValue.languageCode === lang).value.toLowerCase().includes(text.toLowerCase()))
                      || (countableItem.Item.brand
                          .find(localValue => localValue.languageCode === lang) !== undefined
                        && countableItem.Item.brand
                          .find(localValue => localValue.languageCode === lang).value
                        && countableItem.Item.brand
                          .find(localValue => localValue.languageCode === lang).value.toLowerCase().includes(text.toLowerCase()))
                      || workItem.itemId.includes(text));
                } else if (countableItem.customItem) {
                  return (countableItem.customItem.description.toLowerCase().includes(text.toLowerCase())
                    || countableItem.customItem.supplierId.toLowerCase().includes(text.toLowerCase())
                    || workItem.itemId.includes(text));
                } else if (countableItem.generalItem) {
                return (countableItem.generalItem.description.toLowerCase().includes(text.toLowerCase())
                  || workItem.itemId.includes(text));
                }
              } else { // Item info is missing...
                return workItem.itemId.includes(text);
              }
            });
          } else {
            return [];
          }
        })
      );
  }

  panelOpenState: boolean = false;

togglePanel() {
    this.panelOpenState = !this.panelOpenState
}

实现方案

现有代码存在的核心问题:当前写在组件里的panelOpenState本地变量和基础版toggglePanel方法完全无效,按钮所在组件和实际渲染mat-expansion-panel的独立组件没有直接的状态连通,本地状态的改动根本无法传递到面板组件上。

方案核心优势:项目已经接入NgRx全局状态管理,完全不需要引入@Output传值、ViewChild查询、公共服务订阅这类容易产生强耦合的跨组件通信方式,直接复用现有状态链路即可实现需求,改动成本最低。

  • 第一步:删除组件里无效的panelOpenState属性和原有的本地状态修改逻辑
  • 第二步:完全复用现有SetStorageAreaExpandStatusaction的状态更新链路,改造toggglePanel方法,让点击按钮时统一更新所有存储区域的展开状态
  • 第三步:所有托管mat-expansion-panel的独立组件,保持从NgRx store读取对应存储区域的expandStatus绑定到面板的expanded输入属性,不需要维护本地展开状态

改造后的toggglePanel方法示例:

togglePanel() {
  combineLatest(this.isMobile$, this.worksheet$).pipe(
    filter(([isMobile, ws]) => !!ws?.storageAreas?.length),
    first()
  ).subscribe(([isMobile, ws]) => {
    // 统一判断当前状态,切换所有面板的展开值
    const hasAnyExpanded = ws.storageAreas.some(area => area.expandStatus === true);
    const targetStatus = !hasAnyExpanded;
    // 批量更新所有已分配存储区域的展开状态
    ws.storageAreas.forEach(area => {
      this.store.dispatch(new SetStorageAreaExpandStatus({
        status: targetStatus,
        areaId: area.id
      }));
    });
    // 同步更新未分配存储区域的展开状态
    this.unAssignedStorageArea$.pipe(first()).subscribe(unassigned => {
      this.store.dispatch(new SetStorageAreaExpandStatus({
        status: targetStatus,
        areaId: unassigned.id
      }));
    });
  });
}

这种实现下,不管面板组件和按钮组件的层级有多远,只要所有面板的展开状态都从统一的store读取,按钮点击触发的状态更新就会自动传递到所有面板,不存在组件间的强耦合。


内容的提问来源于stack exchange,提问作者rskybsn

相关产品推荐
方舟 Agent Plan

超全模态模型 × Harness 升级,最新支持 Deepseek-V4.1-Flash、GLM-5.3 系列、Doubao-Seedream-5.0-pro、Kimi-K3 (部分), 限时 9.9 元起

最近更新时间:2026.11.09 15:06:07