Advanced

Date observation

How rs-x tracks Date mutations with grouped watchers and emits precise date-part updates.

Detailed notes

DateObserverProxyPairFactory has priority 6 and applies to Date instances.
DateProxyFactory extends GuidKeyedInstanceFactory and groups by (date object + indexWatchRule), so one Date can have multiple scoped observers.
DateProxy wraps setter methods (setFullYear, setMonth, setTime, etc.) and compares timestamp before/after mutation.
When indexWatchRule is set, DateProxy emits only changed date properties that pass the watch rule.
DatePropertyObserverManager builds per-property observers backed by DateProxy + IndexWatchRule.
Dispose unregisters date proxies and unsubscribes property observers safely.

Step 1: select date observer strategy

Code links: DateObserverProxyPairFactory · DatePropertyObserverProxyPairFactory

Date object factory

Full implementation of DateObserverProxyPairFactory.

@Injectable()
export class DateObserverProxyPairFactory implements IDateObserverProxyPairFactory {
  public readonly priority = 6;

  constructor(
    @Inject(RsXStateManagerInjectionTokens.IDateProxyFactory)
    private readonly _dateProxyFactory: IDateProxyFactory,
  ) {}

  public create(
    owner: IDisposableOwner,
    proxyTarget: IProxyTarget<Date>,
  ): IDateOserverProxyPair {
    return this._dateProxyFactory.create({
      owner,
      date: proxyTarget.target,
    }).instance;
  }

  public applies(object: object): boolean {
    return object instanceof Date;
  }

Date property observer factory

Full implementation of DatePropertyObserverProxyPairFactory.

@Injectable()
export class DatePropertyObserverProxyPairFactory
  extends IndexObserverProxyPairFactory<Date, DateProperty>
{
  constructor(
    @Inject(RsXStateManagerInjectionTokens.IObjectObserverProxyPairManager)
    objectObserverManager: IObjectObserverProxyPairManager,
    @Inject(RsXStateManagerInjectionTokens.IDatePropertyObserverManager)
    datePropertyObserverManager: IDatePropertyObserverManager,
    @Inject(RsXCoreInjectionTokens.IErrorLog)
    errorLog: IErrorLog,
    @Inject(RsXCoreInjectionTokens.IGuidFactory)
    guidFactory: IGuidFactory,
    @Inject(RsXCoreInjectionTokens.IIndexValueAccessor)
    datePropertyAccessor: IIndexValueAccessor,
    @Inject(RsXCoreInjectionTokens.IProxyRegistry)
    proxyRegister: IProxyRegistry,
    @Inject(RsXCoreInjectionTokens.IValueMetadata)
    valueMetadata: IValueMetadata,
  ) {
    super(
      objectObserverManager,

Step 2: group ids by date + watch rule

Code links: DateProxyFactory

Grouped id strategy

DateProxyFactory reuses instances by date and indexWatchRule group member.

protected override getGroupId(data: IDateProxyIdData): Date {
  return data.date;
}

protected override getGroupMemberId(
  data: IDateProxyIdData,
): IIndexWatchRule | undefined {
  return data.indexWatchRule;
}

Create DateProxy instance

Full implementation of DateProxyFactory (group id + instance creation).

@Injectable()
export class DateProxyFactory
  extends GuidKeyedInstanceFactory<
    IDateProxyData,
    IDateObserverProxyPair,
    IDateProxyIdData
  >
  implements IDateProxyFactory
{
  constructor(
    @Inject(RsXCoreInjectionTokens.IGuidFactory)
    guidFactory: IGuidFactory,
    @Inject(RsXCoreInjectionTokens.IProxyRegistry)
    private readonly _proxyRegistry: IProxyRegistry,
  ) {
    super(guidFactory);
  }

  protected override getGroupId(data: IDateProxyIdData): Date {
    return data.date;
  }

Step 3: intercept Date setters and emit targeted changes

Code links: DateProxy

Setter metadata mapping

DateProxy maps each Date setter to a logical DateProperty + getter pair.

private readonly _dateSetterMetadata: Map<DateSetterName, ISetterMetaData> =
  new Map([
    ['setFullYear', { name: 'year', getterName: 'getFullYear', setterName: 'setFullYear' }],
    ['setUTCFullYear', { name: 'utcYear', getterName: 'getUTCFullYear', setterName: 'setUTCFullYear' }],
    ['setMonth', { name: 'month', getterName: 'getMonth', setterName: 'setMonth' }],
    ['setTime', { name: 'time', getterName: 'getTime', setterName: 'setTime' }],
  ]);

Setter wrapping and change emission

When timestamp changed, DateProxy emits either one generic change or filtered per-property changes.

return (...args: unknown[]) => {
  const oldTimeStamp = target.getTime();
  const setter = value as (...args: unknown[]) => unknown;
  const result = setter.apply(target, args);
  if (oldTimeStamp !== target.getTime()) {
    this.emitChanges(oldTimeStamp, target, setterMetadata.name);
  }
  return result;
};

Step 4: watch one DateProperty value

Code links: DatePropertyObserverManager

Property-specific IndexWatchRule

DatePropertyObserverManager creates a rule that matches one property on one Date instance.

const indexWatchPredicate = (targetIndex, target, context) =>
  targetIndex === index && target === context;

const indexWatchRule = new IndexWatchRule(this._date, indexWatchPredicate);
const dateObserver = this._dateProxyFactory.create({
  date: this._date,
  indexWatchRule,
}).instance.observer;

Deduplicate property emissions

DatePropertyObserver keeps old value and emits only when the watched property changes.

private onDateChanged = (change: IPropertyChange) => {
  if (change.index !== this.id || change.newValue === this._oldValue) {
    return;
  }

  this.emitChange(change);
  this._oldValue = change.newValue;
};

Step 5: dispose Date observers

Code links: DateProxy + DatePropertyObserver

DateProxy cleanup

Dispose unregisters the Date target from proxy registry.

protected override disposeInternal(): void {
  this._proxyRegistry.unregister(this.value);
  this.target = Type.cast(undefined);
}

DatePropertyObserver cleanup

Property observer dispose releases inner Date observer and subscription.

protected override disposeInternal(): void {
  this._dateObserver.dispose();
  this._dateChangeSubscription.unsubscribe();
}