fix(distinctUntilKeyChanged): improved key typing with keyof T (#3988)

* fix(distinctUntilKeyChanged): correct signatures
* chore(distinctUntilKeyChanged): nail down key's typing with keyof T

Author: imcotton

compat/operator/distinctUntilKeyChanged.ts

@@ -3,8 +3,8 @@ import { Observable } from 'rxjs';
 import{distinctUntilKeyChangedashigherOrder}from'rxjs/operators';
 
 /* tslint:disable:max-line-length */
-exportfunctiondistinctUntilKeyChanged<T>(this: Observable<T>,key: string): Observable<T>;
-exportfunctiondistinctUntilKeyChanged<T,K>(this: Observable<T>,key: string,compare: (x: K,y: K)=>boolean): Observable<T>;
+exportfunctiondistinctUntilKeyChanged<T>(this: Observable<T>,key: keyofT): Observable<T>;
+exportfunctiondistinctUntilKeyChanged<T,KextendskeyofT>(this: Observable<T>,key: K,compare: (x: T[K],y: T[K])=>boolean): Observable<T>;
 /* tslint:enable:max-line-length */
 
 /**
@@ -64,6 +64,7 @@ export function distinctUntilKeyChanged<T, K>(this: Observable<T>, key: string,
  * @method distinctUntilKeyChanged
  * @owner Observable
  */
-exportfunctiondistinctUntilKeyChanged<T>(this: Observable<T>,key: string,compare?: (x: T,y: T)=>boolean): Observable<T>{
-returnhigherOrder<T,T>(key,compare)(this);
+// tslint:disable-next-line:max-line-length
+exportfunctiondistinctUntilKeyChanged<T,KextendskeyofT>(this: Observable<T>,key: K,compare?: (x: T[K],y: T[K])=>boolean): Observable<T>{
+returnhigherOrder<T,K>(key,compare)(this);
 }

spec-dtslint/operators/distinctUntilKeyChanged-spec.ts

@@ -0,0 +1,20 @@
+import{of}from'rxjs';
+import{distinctUntilKeyChanged}from'rxjs/operators';
+
+constsample={name: 'foobar',num: 42};
+
+it('should enforce key set',()=>{
+consto=of(sample).pipe(distinctUntilKeyChanged('something'));// $ExpectError
+});
+
+it('should enforce key set with compare',()=>{
+consto=of(sample).pipe(distinctUntilKeyChanged('something',()=>true));// $ExpectError
+});
+
+it("should enforce compare's type",()=>{
+consto=of(sample).pipe(distinctUntilKeyChanged('name',(a: number,b: number)=>true));// $ExpectError
+});
+
+it("should enforce key set and compare's type",()=>{
+consto=of(sample).pipe(distinctUntilKeyChanged('something',(a: number,b: number)=>true));// $ExpectError
+});

spec/operators/distinctUntilKeyChanged-spec.ts

@@ -185,7 +185,7 @@ describe('distinctUntilKeyChanged operator', () => {
 conste1subs='^ !';
 constexpected='--a--------------|';
 
-expectObservable((<any>e1).pipe(distinctUntilKeyChanged('val',()=>true))).toBe(expected,values);
+expectObservable(e1.pipe(distinctUntilKeyChanged('val',()=>true))).toBe(expected,values);
 expectSubscriptions(e1.subscriptions).toBe(e1subs);
 });
 
@@ -195,7 +195,7 @@ describe('distinctUntilKeyChanged operator', () => {
 conste1subs='^ !';
 constexpected='--a--a--a--a--a--a--|';
 
-expectObservable((<any>e1).pipe(distinctUntilKeyChanged('val',()=>false))).toBe(expected,values);
+expectObservable(e1.pipe(distinctUntilKeyChanged('val',()=>false))).toBe(expected,values);
 expectSubscriptions(e1.subscriptions).toBe(e1subs);
 });
 
@@ -206,7 +206,7 @@ describe('distinctUntilKeyChanged operator', () => {
 constexpected='--a-----c-----e--|';
 constselector=(x: number,y: number)=>y%2===0;
 
-expectObservable((<any>e1).pipe(distinctUntilKeyChanged('val',selector))).toBe(expected,values);
+expectObservable(e1.pipe(distinctUntilKeyChanged('val',selector))).toBe(expected,values);
 expectSubscriptions(e1.subscriptions).toBe(e1subs);
 });
 
@@ -222,7 +222,7 @@ describe('distinctUntilKeyChanged operator', () => {
 returnx===y;
 };
 
-expectObservable((<any>e1).pipe(distinctUntilKeyChanged('val',selector))).toBe(expected,values);
+expectObservable(e1.pipe(distinctUntilKeyChanged('val',selector))).toBe(expected,values);
 expectSubscriptions(e1.subscriptions).toBe(e1subs);
 });
 });

src/internal/operators/distinctUntilKeyChanged.ts

@@ -2,8 +2,8 @@ import { distinctUntilChanged } from './distinctUntilChanged';
 import{MonoTypeOperatorFunction}from'../types';
 
 /* tslint:disable:max-line-length */
-exportfunctiondistinctUntilKeyChanged<T>(key: string): MonoTypeOperatorFunction<T>;
-exportfunctiondistinctUntilKeyChanged<T,K>(key: string,compare: (x: K,y: K)=>boolean): MonoTypeOperatorFunction<T>;
+exportfunctiondistinctUntilKeyChanged<T>(key: keyofT): MonoTypeOperatorFunction<T>;
+exportfunctiondistinctUntilKeyChanged<T,KextendskeyofT>(key: K,compare: (x: T[K],y: T[K])=>boolean): MonoTypeOperatorFunction<T>;
 /* tslint:enable:max-line-length */
 
 /**
@@ -70,6 +70,6 @@ export function distinctUntilKeyChanged<T, K>(key: string, compare: (x: K, y: K)
  * @method distinctUntilKeyChanged
  * @owner Observable
  */
-exportfunctiondistinctUntilKeyChanged<T>(key: string,compare?: (x: T,y: T)=>boolean): MonoTypeOperatorFunction<T>{
+exportfunctiondistinctUntilKeyChanged<T,KextendskeyofT>(key: K,compare?: (x: T[K],y: T[K])=>boolean): MonoTypeOperatorFunction<T>{
 returndistinctUntilChanged((x: T,y: T)=>compare ? compare(x[key],y[key]) : x[key]===y[key]);
 }