@alauda-fe/common
Version:
Alauda frontend team common codes.
87 lines • 9.44 kB
JavaScript
/**
* @packageDocumentation
* @module translate
*/
import { Injectable } from '@angular/core';
import { Subject } from 'rxjs';
import * as i0 from "@angular/core";
/**
* 相对时间管理器服务
*
* 用于优化大量相对时间显示的性能，通过共享定时器避免创建过多独立计时器。
* 当页面存在大量相对时间显示时，使用统一的刷新频率来批量更新所有实例。
*/
export class RelativeTimeManagerService {
constructor() {
this.refreshSubjects = new Map();
this.timers = new Map();
}
/**
* 获取指定刷新间隔的 Subject
* 多个 pipe 实例可以共享同一个刷新频率
*/
getRefreshSubject(interval) {
let subject = this.refreshSubjects.get(interval);
if (!subject) {
subject = new Subject();
this.refreshSubjects.set(interval, subject);
this.startTimer(interval);
}
return subject;
}
/**
* 释放指定间隔的订阅
* 当没有 pipe 实例使用时，自动清理定时器
*/
releaseRefreshSubject(interval) {
const subject = this.refreshSubjects.get(interval);
if (subject && !subject.observed) {
this.stopTimer(interval);
subject.complete();
this.refreshSubjects.delete(interval);
}
}
startTimer(interval) {
if (this.timers.has(interval)) {
return; // 定时器已存在
}
const timerId = window.setInterval(() => {
const subject = this.refreshSubjects.get(interval);
if (subject?.observed) {
subject.next();
}
else {
// 没有订阅者时自动清理
this.stopTimer(interval);
if (subject) {
subject.complete();
this.refreshSubjects.delete(interval);
}
}
}, interval);
this.timers.set(interval, timerId);
}
stopTimer(interval) {
const timerId = this.timers.get(interval);
if (timerId !== undefined) {
clearInterval(timerId);
this.timers.delete(interval);
}
}
ngOnDestroy() {
// 清理所有定时器和 subjects
this.timers.forEach(timerId => clearInterval(timerId));
this.timers.clear();
this.refreshSubjects.forEach(subject => subject.complete());
this.refreshSubjects.clear();
}
static { this.ɵfac = function RelativeTimeManagerService_Factory(t) { return new (t || RelativeTimeManagerService)(); }; }
static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: RelativeTimeManagerService, factory: RelativeTimeManagerService.ɵfac, providedIn: 'root' }); }
}
(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(RelativeTimeManagerService, [{
type: Injectable,
args: [{
providedIn: 'root',
}]
}], null, null); })();
//# sourceMappingURL=data:application/json;base64,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