forwards compatibility for TS2.7 (#384)

agubler · web-flow · commit 99a4bd0c2884 · 2018-03-16T14:51:15.000Z
diff --git a/package-lock.json b/package-lock.json
diff --git a/src/DateObject.ts b/src/DateObject.ts
@@ -95,87 +95,78 @@ export default class DateObject implements DateProperties {
 			);
 		}
 
-		Object.defineProperty(this, '_date', {
-			configurable: true,
-			enumerable: false,
-			value: _date,
-			writable: true
-		});
-
+		this._date = _date;
 		const self = this;
-		Object.defineProperty(this, 'utc', {
-			value: {
-				get isLeapYear(this: DateObject): boolean {
-					return isLeapYear(this.year);
-				},
-				get daysInMonth(this: DateObject): number {
-					const month = this.month;
-
-					if (month === 2 && this.isLeapYear) {
-						return 29;
-					}
-					return days[month];
-				},
-
-				get year(): number {
-					return self._date.getUTCFullYear();
-				},
-				set year(year: number) {
-					self._date.setUTCFullYear(year);
-				},
-
-				get month(): number {
-					return self._date.getUTCMonth() + 1;
-				},
-				set month(month: number) {
-					self._date.setUTCMonth(month - 1);
-				},
-
-				get dayOfMonth(): number {
-					return self._date.getUTCDate();
-				},
-				set dayOfMonth(day: number) {
-					self._date.setUTCDate(day);
-				},
-
-				get hours(): number {
-					return self._date.getUTCHours();
-				},
-				set hours(hours: number) {
-					self._date.setUTCHours(hours);
-				},
-
-				get minutes(): number {
-					return self._date.getUTCMinutes();
-				},
-				set minutes(minutes: number) {
-					self._date.setUTCMinutes(minutes);
-				},
-
-				get seconds(): number {
-					return self._date.getUTCSeconds();
-				},
-				set seconds(seconds: number) {
-					self._date.setUTCSeconds(seconds);
-				},
-
-				get milliseconds(): number {
-					return self._date.getUTCMilliseconds();
-				},
-				set milliseconds(milliseconds: number) {
-					self._date.setUTCMilliseconds(milliseconds);
-				},
-
-				get dayOfWeek(): number {
-					return self._date.getUTCDay();
-				},
-
-				toString: function(): string {
-					return self._date.toUTCString();
+		this.utc = {
+			get isLeapYear(this: DateObject): boolean {
+				return isLeapYear(this.year);
+			},
+			get daysInMonth(this: DateObject): number {
+				const month = this.month;
+
+				if (month === 2 && this.isLeapYear) {
+					return 29;
 				}
+				return days[month];
+			},
+
+			get year(): number {
+				return self._date.getUTCFullYear();
+			},
+			set year(year: number) {
+				self._date.setUTCFullYear(year);
+			},
+
+			get month(): number {
+				return self._date.getUTCMonth() + 1;
+			},
+			set month(month: number) {
+				self._date.setUTCMonth(month - 1);
+			},
+
+			get dayOfMonth(): number {
+				return self._date.getUTCDate();
+			},
+			set dayOfMonth(day: number) {
+				self._date.setUTCDate(day);
+			},
+
+			get hours(): number {
+				return self._date.getUTCHours();
 			},
-			enumerable: true
-		});
+			set hours(hours: number) {
+				self._date.setUTCHours(hours);
+			},
+
+			get minutes(): number {
+				return self._date.getUTCMinutes();
+			},
+			set minutes(minutes: number) {
+				self._date.setUTCMinutes(minutes);
+			},
+
+			get seconds(): number {
+				return self._date.getUTCSeconds();
+			},
+			set seconds(seconds: number) {
+				self._date.setUTCSeconds(seconds);
+			},
+
+			get milliseconds(): number {
+				return self._date.getUTCMilliseconds();
+			},
+			set milliseconds(milliseconds: number) {
+				self._date.setUTCMilliseconds(milliseconds);
+			},
+
+			get dayOfWeek(): number {
+				return self._date.getUTCDay();
+			},
+
+			toString: function(): string {
+				return self._date.toUTCString();
+			}
+		} as any;
 	}
 
 	get isLeapYear(): boolean {
diff --git a/src/Evented.ts b/src/Evented.ts
@@ -37,6 +37,10 @@ export type EventedCallback<T = EventType, E extends EventObject<T> = EventObjec
 	(event: E): boolean | void;
 };
 
+export interface CustomEventTypes<T extends EventObject<any> = EventObject<any>> {
+	[index: string]: T;
+}
+
 /**
  * A type which is either a targeted event listener or an array of listeners
  * @template T The type of target for the events
@@ -49,12 +53,15 @@ export type EventedCallbackOrArray<T = EventType, E extends EventObject<T> = Eve
 /**
  * Event Class
  */
-export class Evented<M extends {} = {}, T = EventType, O extends EventObject<T> = EventObject<T>> extends Destroyable {
+export class Evented<
+	M extends CustomEventTypes = {},
+	T = EventType,
+	O extends EventObject<T> = EventObject<T>
+> extends Destroyable {
 	// The following member is purely so TypeScript remembers the type of `M` when extending so
 	// that the utilities in `on.ts` will work https://github.com/Microsoft/TypeScript/issues/20348
 	// tslint:disable-next-line
 	protected __typeMap__?: M;
-
 	/**
 	 * map of listeners keyed by event type
 	 */
diff --git a/src/QueuingEvented.ts b/src/QueuingEvented.ts
@@ -1,6 +1,6 @@
 import { Handle, EventObject, EventType } from './interfaces';
 import Map from '@dojo/shim/Map';
-import Evented, { isGlobMatch, EventedCallbackOrArray } from './Evented';
+import Evented, { CustomEventTypes, isGlobMatch, EventedCallbackOrArray } from './Evented';
 
 /**
  * An implementation of the Evented class that queues up events when no listeners are
@@ -9,11 +9,11 @@ import Evented, { isGlobMatch, EventedCallbackOrArray } from './Evented';
  *
  * @property maxEvents  The number of events to queue before old events are discarded. If zero (default), an unlimited number of events is queued.
  */
-class QueuingEvented<M extends {} = {}, T = EventType, O extends EventObject<T> = EventObject<T>> extends Evented<
-	M,
-	T,
-	O
-> {
+class QueuingEvented<
+	M extends CustomEventTypes = {},
+	T = EventType,
+	O extends EventObject<T> = EventObject<T>
+> extends Evented<M, T, O> {
 	private _queue: Map<string | symbol, EventObject[]> = new Map();
 
 	public maxEvents = 0;
diff --git a/src/Scheduler.ts b/src/Scheduler.ts
@@ -18,10 +18,10 @@ export interface KwArgs {
 
 export default class Scheduler {
 	protected readonly _boundDispatch: () => void;
-	protected _deferred: QueueItem[] | null;
+	protected _deferred: QueueItem[] | null = null;
 	protected _isProcessing: boolean;
 	protected readonly _queue: QueueItem[];
-	protected _task: Handle | null;
+	protected _task: Handle | null = null;
 
 	/**
 	 * Determines whether any callbacks registered during should be added to the current batch (`false`)
diff --git a/src/UrlSearchParams.ts b/src/UrlSearchParams.ts
@@ -47,7 +47,7 @@ export default class UrlSearchParams {
 	 * UrlSearchParams.
 	 */
 	constructor(input?: string | ParamList | UrlSearchParams) {
-		let list: ParamList;
+		let list: ParamList = {};
 
 		if (input instanceof UrlSearchParams) {
 			// Copy the incoming UrlSearchParam's internal list
@@ -69,11 +69,9 @@ export default class UrlSearchParams {
 		} else if (typeof input === 'string') {
 			// Parse the incoming string as a query string
 			list = parseQueryString(input);
-		} else {
-			list = {};
 		}
 
-		Object.defineProperty(this, '_list', { value: list });
+		this._list = list as Hash<string[] | undefined>;
 	}
 
 	/**
diff --git a/src/async/Task.ts b/src/async/Task.ts
@@ -194,7 +194,7 @@ export default class Task<T> extends ExtensiblePromise<T> {
 	/**
 	 * The finally callback for this Task (if it was created by a call to `finally`).
 	 */
-	private _finally: () => void;
+	private _finally: undefined | (() => void);
 
 	/**
 	 * The state of the task
@@ -269,7 +269,7 @@ export default class Task<T> extends ExtensiblePromise<T> {
 
 		const runFinally = () => {
 			try {
-				return this._finally();
+				return this._finally && this._finally();
 			} catch (error) {
 				// Any errors in a `finally` callback are completely ignored during cancelation
 			}
diff --git a/src/on.ts b/src/on.ts
@@ -1,6 +1,6 @@
 import { Handle, EventObject } from './interfaces';
 import { createHandle, createCompositeHandle } from './lang';
-import Evented from './Evented';
+import Evented, { CustomEventTypes } from './Evented';
 
 export interface EventCallback<O = EventObject<string>> {
 	(event: O): void;
@@ -23,10 +23,12 @@ interface DOMEventObject extends EventObject {
  * @return Boolean indicating if preventDefault was called on the event object (only relevant for DOM events;
  *     always false for other event emitters)
  */
-export function emit<M, T, O extends EventObject<T> = EventObject<T>, K extends keyof M = keyof M>(
-	target: Evented<M, T, O>,
-	event: M[K]
-): boolean;
+export function emit<
+	M extends CustomEventTypes,
+	T,
+	O extends EventObject<T> = EventObject<T>,
+	K extends keyof M = keyof M
+>(target: Evented<M, T, O>, event: M[K]): boolean;
 export function emit<T, O extends EventObject<T> = EventObject<T>>(target: Evented<any, T, O>, event: O): boolean;
 export function emit<O extends EventObject<string> = EventObject<string>>(
 	target: EventTarget | EventEmitter,
@@ -78,11 +80,12 @@ export function emit(target: any, event: EventObject<any>): boolean {
  * @param capture Whether the listener should be registered in the capture phase (DOM events only)
  * @return A handle which will remove the listener when destroy is called
  */
-export default function on<M, T, K extends keyof M = keyof M, O extends EventObject<T> = EventObject<T>>(
-	target: Evented<M, T, O>,
-	type: K | K[],
-	listener: EventCallback<M[K]>
-): Handle;
+export default function on<
+	M extends CustomEventTypes,
+	T,
+	K extends keyof M = keyof M,
+	O extends EventObject<T> = EventObject<T>
+>(target: Evented<M, T, O>, type: K | K[], listener: EventCallback<M[K]>): Handle;
 export default function on<T, O extends EventObject<T> = EventObject<T>>(
 	target: Evented<any, T, O>,
 	type: T | T[],
@@ -141,11 +144,12 @@ export default function on(target: any, type: any, listener: any, capture?: bool
  * @param capture Whether the listener should be registered in the capture phase (DOM events only)
  * @return A handle which will remove the listener when destroy is called
  */
-export function once<M, T, K extends keyof M = keyof M, O extends EventObject<T> = EventObject<T>>(
-	target: Evented<M, T, O>,
-	type: K | K[],
-	listener: EventCallback<M[K]>
-): Handle;
+export function once<
+	M extends CustomEventTypes,
+	T,
+	K extends keyof M = keyof M,
+	O extends EventObject<T> = EventObject<T>
+>(target: Evented<M, T, O>, type: K | K[], listener: EventCallback<M[K]>): Handle;
 export function once<T, O extends EventObject<T> = EventObject<T>>(
 	target: Evented<any, T, O>,
 	type: T | T[],
@@ -182,11 +186,12 @@ export interface PausableHandle extends Handle {
  * @param capture Whether the listener should be registered in the capture phase (DOM events only)
  * @return A handle with additional pause and resume methods; the listener will never fire when paused
  */
-export function pausable<M, T, K extends keyof M = keyof M, O extends EventObject<T> = EventObject<T>>(
-	target: Evented<M, T, O>,
-	type: K | K[],
-	listener: EventCallback<M[K]>
-): PausableHandle;
+export function pausable<
+	M extends CustomEventTypes,
+	T,
+	K extends keyof M = keyof M,
+	O extends EventObject<T> = EventObject<T>
+>(target: Evented<M, T, O>, type: K | K[], listener: EventCallback<M[K]>): PausableHandle;
 export function pausable<T, O extends EventObject<T> = EventObject<T>>(
 	target: Evented<any, T, O>,
 	type: T | T[],
diff --git a/src/request/Response.ts b/src/request/Response.ts
@@ -15,7 +15,7 @@ abstract class Response implements ResponseInterface {
 	abstract readonly statusText: string;
 	abstract readonly url: string;
 	abstract readonly bodyUsed: boolean;
-	readonly requestOptions: RequestOptions;
+	abstract readonly requestOptions: RequestOptions;
 
 	abstract readonly download: Observable<number>;
 	abstract readonly data: Observable<any>;
diff --git a/tests/unit/Evented.ts b/tests/unit/Evented.ts
@@ -1,10 +1,15 @@
 const { registerSuite } = intern.getInterface('object');
 const { assert } = intern.getPlugin('chai');
-import { Evented } from '../../src/Evented';
+import { Evented, CustomEventTypes } from '../../src/Evented';
+import { EventObject } from '../../src/interfaces';
 
-interface FooBarEvents {
-	foo: { type: 'foo' };
-	bar: { type: 'bar' };
+interface FooBarEvents extends CustomEventTypes {
+	foo: R;
+	bar: R;
+}
+
+interface R extends EventObject<string> {
+	value: number;
 }
 
 registerSuite('Evented', {
@@ -22,7 +27,7 @@ registerSuite('Evented', {
 				eventStack.push(event.type);
 			});
 
-			evented.emit({ type: 'foo' });
+			evented.emit<'foo'>({ type: 'foo', value: 1 });
 			evented.emit({ type: 'bar' });
 
 			handle.destroy();
diff --git a/tests/unit/compare.ts b/tests/unit/compare.ts
