refactor(Error): Rewrite custom derived errors with Object.create().

Author: tetsuharuohzeki

src/observable/dom/AjaxObservable.ts

@@ -173,6 +173,52 @@ export class AjaxObservable<T> extends Observable<T> {
   }
 }
 
+/**
+ * A normalized AJAX error.
+ *
+ * @see {@link ajax}
+ *
+ * @class AjaxError
+ */
+export interface AjaxError extends Error {
+  /** @type {XMLHttpRequest} The XHR instance associated with the error */
+  xhr: XMLHttpRequest;
+
+  /** @type {AjaxRequest} The AjaxRequest associated with the error */
+  request: AjaxRequest;
+
+  /** @type {number} The HTTP status code */
+  status: number;
+}
+export interface AjaxErrorConstructor {
+    new(message: string, xhr: XMLHttpRequest, request: AjaxRequest): AjaxError;
+    readonly prototype: AjaxError;
+}
+
+function AjaxErrorCtor(this: AjaxError, message: string, xhr: XMLHttpRequest, request: AjaxRequest): AjaxError {
+  const err = Error.call(this, message);
+  this.message = err.message;
+  this.xhr = xhr;
+  this.request = request;
+  this.status = xhr.status;
+  return this;
+}
+AjaxErrorCtor.prototype = Object.create(Error.prototype);
+AjaxErrorCtor.prototype.constructor = AjaxErrorCtor;
+
+export const AjaxError = AjaxErrorCtor as any as AjaxErrorConstructor;
+
+/**
+ * @see {@link ajax}
+ *
+ * @class AjaxTimeoutError
+ */
+export class AjaxTimeoutError extends AjaxError {
+  constructor(xhr: XMLHttpRequest, request: AjaxRequest) {
+    super('ajax timeout', xhr, request);
+  }
+}
+
 /**
  * We need this JSDoc comment for affecting ESDoc.
  * @ignore
@@ -420,41 +466,4 @@ export class AjaxResponse {
         break;
     }
   }
-}
-
-/**
- * A normalized AJAX error.
- *
- * @see {@link ajax}
- *
- * @class AjaxError
- */
-export class AjaxError extends Error {
-  /** @type {XMLHttpRequest} The XHR instance associated with the error */
-  xhr: XMLHttpRequest;
-
-  /** @type {AjaxRequest} The AjaxRequest associated with the error */
-  request: AjaxRequest;
-
-  /** @type {number} The HTTP status code */
-  status: number;
-
-  constructor(message: string, xhr: XMLHttpRequest, request: AjaxRequest) {
-    super(message);
-    this.message = message;
-    this.xhr = xhr;
-    this.request = request;
-    this.status = xhr.status;
-  }
-}
-
-/**
- * @see {@link ajax}
- *
- * @class AjaxTimeoutError
- */
-export class AjaxTimeoutError extends AjaxError {
-  constructor(xhr: XMLHttpRequest, request: AjaxRequest) {
-    super('ajax timeout', xhr, request);
-  }
-}
+}

src/util/ArgumentOutOfRangeError.ts

@@ -8,11 +8,18 @@
  *
  * @class ArgumentOutOfRangeError
  */
-export class ArgumentOutOfRangeError extends Error {
-  constructor() {
-    const err: any = super('argument out of range');
-    (<any> this).name = err.name = 'ArgumentOutOfRangeError';
-    (<any> this).stack = err.stack;
-    (<any> this).message = err.message;
-  }
+export interface ArgumentOutOfRangeError extends Error {}
+export interface ArgumentOutOfRangeErrorConstructor {
+    new(): ArgumentOutOfRangeError;
+    readonly prototype: ArgumentOutOfRangeError;
 }
+
+function ArgumentOutOfRangeErrorCtor(this: ArgumentOutOfRangeError): ArgumentOutOfRangeError {
+  Error.call(this, 'argument out of range');
+  this.name = 'ArgumentOutOfRangeError';
+  return this;
+}
+ArgumentOutOfRangeErrorCtor.prototype = Object.create(Error.prototype);
+ArgumentOutOfRangeErrorCtor.prototype.constructor = ArgumentOutOfRangeErrorCtor;
+
+export const ArgumentOutOfRangeError = ArgumentOutOfRangeErrorCtor as any as ArgumentOutOfRangeErrorConstructor;

src/util/EmptyError.ts

@@ -8,11 +8,18 @@
  *
  * @class EmptyError
  */
-export class EmptyError extends Error {
-  constructor() {
-    const err: any = super('no elements in sequence');
-    (<any> this).name = err.name = 'EmptyError';
-    (<any> this).stack = err.stack;
-    (<any> this).message = err.message;
-  }
+export interface EmptyError extends Error {}
+export interface EmptyErrorConstructor {
+    new(): EmptyError;
+    readonly prototype: EmptyError;
 }
+
+function EmptyErrorCtor(this: EmptyError): EmptyError {
+  Error.call(this, 'no elements in sequence');
+  this.name = 'EmptyError';
+  return this;
+}
+EmptyErrorCtor.prototype = Object.create(Error.prototype);
+EmptyErrorCtor.prototype.constructor = EmptyErrorCtor;
+
+export const EmptyError = EmptyErrorCtor as any as EmptyErrorConstructor;

src/util/ObjectUnsubscribedError.ts

@@ -7,11 +7,18 @@
  *
  * @class ObjectUnsubscribedError
  */
-export class ObjectUnsubscribedError extends Error {
-  constructor() {
-    const err: any = super('object unsubscribed');
-    (<any> this).name = err.name = 'ObjectUnsubscribedError';
-    (<any> this).stack = err.stack;
-    (<any> this).message = err.message;
-  }
+export interface ObjectUnsubscribedError extends Error {}
+export interface ObjectUnsubscribedErrorConstructor {
+    new(): ObjectUnsubscribedError;
+    readonly prototype: ObjectUnsubscribedError;
 }
+
+function ObjectUnsubscribedErrorCtor(this: ObjectUnsubscribedError): ObjectUnsubscribedError {
+  Error.call(this, 'object unsubscribed');
+  this.name = 'ObjectUnsubscribedError';
+  return this;
+}
+ObjectUnsubscribedErrorCtor.prototype = Object.create(Error.prototype);
+ObjectUnsubscribedErrorCtor.prototype.constructor = ObjectUnsubscribedErrorCtor;
+
+export const ObjectUnsubscribedError = ObjectUnsubscribedErrorCtor as any as ObjectUnsubscribedErrorConstructor;

src/util/TimeoutError.ts

@@ -1,15 +1,20 @@
-/**
- * An error thrown when duetime elapses.
- *
- * @see {@link timeout}
- *
- * @class TimeoutError
- */
-export class TimeoutError extends Error {
-  constructor() {
-    const err: any = super('Timeout has occurred');
-    (<any> this).name = err.name = 'TimeoutError';
-    (<any> this).stack = err.stack;
-    (<any> this).message = err.message;
-  }
-}
+/**
+ * An error thrown when duetime elapses.
+ *
+ * @see {@link timeout}
+ */
+export interface TimeoutError extends Error {}
+export interface TimeoutErrorConstructor {
+    new(): TimeoutError;
+    readonly prototype: TimeoutError;
+}
+
+function TimeoutErrorCtor(this: TimeoutError): TimeoutError {
+  Error.call(this, 'Timeout has occurred');
+  this.name = 'TimeoutError';
+  return this;
+}
+TimeoutErrorCtor.prototype = Object.create(Error.prototype);
+TimeoutErrorCtor.prototype.constructor = TimeoutErrorCtor;
+
+export const TimeoutError = TimeoutErrorCtor as any as TimeoutErrorConstructor;

src/util/UnsubscriptionError.ts

@@ -2,14 +2,25 @@
  * An error thrown when one or more errors have occurred during the
  * `unsubscribe` of a {@link Subscription}.
  */
-export class UnsubscriptionError extends Error {
-  constructor(public errors: any[]) {
-    super();
-    const err: any = Error.call(this, errors ?
-      `${errors.length} errors occurred during unsubscription:
+export interface UnsubscriptionError extends Error {
+  errors: any[];
+}
+export interface UnsubscriptionErrorConstructor {
+    new(errors: any[]): UnsubscriptionError;
+    readonly prototype: UnsubscriptionError;
+}
+
+function UnsubscriptionErrorCtor(this: UnsubscriptionError, errors: any[]): UnsubscriptionError {
+  const err: any = Error.call(this, errors ?
+    `${errors.length} errors occurred during unsubscription:
   ${errors.map((err, i) => `${i + 1}) ${err.toString()}`).join('\n  ')}` : '');
-    (<any> this).name = err.name = 'UnsubscriptionError';
-    (<any> this).stack = err.stack;
-    (<any> this).message = err.message;
-  }
+  this.name = err.name = 'UnsubscriptionError';
+  this.stack = err.stack;
+  this.message = err.message;
+  this.errors = errors;
+  return this;
 }
+UnsubscriptionErrorCtor.prototype = Object.create(Error.prototype);
+UnsubscriptionErrorCtor.prototype.constructor = UnsubscriptionErrorCtor;
+
+export const UnsubscriptionError = UnsubscriptionErrorCtor as any as UnsubscriptionErrorConstructor;