refactor(types): move types to each matcher

package.json

@@ -90,5 +90,5 @@
     "test:jest": "jest",
     "test:local": "karma start karma/base.conf.js --browsers Chrome"
   },
-  "types": "./jasmine-matchers.d.ts"
+  "types": "dist/index.d.ts"
 }

src/toBeAfter.ts

@@ -1,2 +1,17 @@
 import { toBeBefore } from './toBeBefore';
-export const toBeAfter = (otherDate, actual) => toBeBefore(actual, otherDate);
+
+export type ToBeAfter = (
+  otherDate: Date,
+  expectationFailOutput?: any
+) => boolean;
+
+declare global {
+  namespace jasmine {
+    interface Matchers<T> {
+      toBeAfter: ToBeAfter;
+    }
+  }
+}
+
+export const toBeAfter: ToBeAfter = (otherDate, actual) =>
+  toBeBefore(actual, otherDate);

src/toBeArray.ts

@@ -1,2 +1,13 @@
 import { is } from './lib/is';
-export const toBeArray = is.Array;
+
+export type ToBeArray = (expectationFailOutput?: any) => boolean;
+
+declare global {
+  namespace jasmine {
+    interface Matchers<T> {
+      toBeArray: ToBeArray;
+    }
+  }
+}
+
+export const toBeArray: ToBeArray = is.Array;

src/toBeArrayOfBooleans.ts

@@ -1,5 +1,16 @@
 import { every } from './lib/every';
 import { toBeArray } from './toBeArray';
 import { toBeBoolean } from './toBeBoolean';
-export const toBeArrayOfBooleans = (actual) =>
+
+export type ToBeArrayOfBooleans = (expectationFailOutput?: any) => boolean;
+
+declare global {
+  namespace jasmine {
+    interface Matchers<T> {
+      toBeArrayOfBooleans: ToBeArrayOfBooleans;
+    }
+  }
+}
+
+export const toBeArrayOfBooleans: ToBeArrayOfBooleans = (actual) =>
   toBeArray(actual) && every(actual, toBeBoolean);

src/toBeArrayOfNumbers.ts

@@ -1,5 +1,16 @@
 import { every } from './lib/every';
 import { toBeArray } from './toBeArray';
 import { toBeNumber } from './toBeNumber';
-export const toBeArrayOfNumbers = (actual) =>
+
+export type ToBeArrayOfNumbers = (expectationFailOutput?: any) => boolean;
+
+declare global {
+  namespace jasmine {
+    interface Matchers<T> {
+      toBeArrayOfNumbers: ToBeArrayOfNumbers;
+    }
+  }
+}
+
+export const toBeArrayOfNumbers: ToBeArrayOfNumbers = (actual) =>
   toBeArray(actual) && every(actual, toBeNumber);

src/toBeArrayOfObjects.ts

@@ -1,5 +1,16 @@
 import { every } from './lib/every';
 import { toBeArray } from './toBeArray';
 import { toBeObject } from './toBeObject';
-export const toBeArrayOfObjects = (actual) =>
+
+export type ToBeArrayOfObjects = (expectationFailOutput?: any) => boolean;
+
+declare global {
+  namespace jasmine {
+    interface Matchers<T> {
+      toBeArrayOfObjects: ToBeArrayOfObjects;
+    }
+  }
+}
+
+export const toBeArrayOfObjects: ToBeArrayOfObjects = (actual) =>
   toBeArray(actual) && every(actual, toBeObject);

src/toBeArrayOfSize.ts

@@ -1,3 +1,17 @@
 import { toBeArray } from './toBeArray';
-export const toBeArrayOfSize = (size, actual) =>
+
+export type ToBeArrayOfSize = (
+  size: number,
+  expectationFailOutput?: any
+) => boolean;
+
+declare global {
+  namespace jasmine {
+    interface Matchers<T> {
+      toBeArrayOfSize: ToBeArrayOfSize;
+    }
+  }
+}
+
+export const toBeArrayOfSize: ToBeArrayOfSize = (size, actual) =>
   toBeArray(actual) && actual.length === size;

src/toBeArrayOfStrings.ts

@@ -1,5 +1,16 @@
 import { every } from './lib/every';
 import { toBeArray } from './toBeArray';
 import { toBeString } from './toBeString';
-export const toBeArrayOfStrings = (actual) =>
+
+export type ToBeArrayOfStrings = (expectationFailOutput?: any) => boolean;
+
+declare global {
+  namespace jasmine {
+    interface Matchers<T> {
+      toBeArrayOfStrings: ToBeArrayOfStrings;
+    }
+  }
+}
+
+export const toBeArrayOfStrings: ToBeArrayOfStrings = (actual) =>
   toBeArray(actual) && every(actual, toBeString);

src/toBeBefore.ts

@@ -1,6 +1,19 @@
 import { toBeDate } from './toBeDate';
 
-export const toBeBefore = (otherDate, actual) =>
+export type ToBeBefore = (
+  otherDate: Date,
+  expectationFailOutput?: any
+) => boolean;
+
+declare global {
+  namespace jasmine {
+    interface Matchers<T> {
+      toBeBefore: ToBeBefore;
+    }
+  }
+}
+
+export const toBeBefore: ToBeBefore = (otherDate, actual) =>
   toBeDate(actual) &&
   toBeDate(otherDate) &&
   actual.getTime() < otherDate.getTime();

src/toBeBoolean.ts

@@ -1,2 +1,13 @@
 import { is } from './lib/is';
-export const toBeBoolean = is.Boolean;
+
+export type ToBeBoolean = (expectationFailOutput?: any) => boolean;
+
+declare global {
+  namespace jasmine {
+    interface Matchers<T> {
+      toBeBoolean: ToBeBoolean;
+    }
+  }
+}
+
+export const toBeBoolean: ToBeBoolean = is.Boolean;

src/toBeCalculable.ts

@@ -1,3 +1,13 @@
+export type ToBeCalculable = (expectationFailOutput?: any) => boolean;
+
+declare global {
+  namespace jasmine {
+    interface Matchers<T> {
+      toBeCalculable: ToBeCalculable;
+    }
+  }
+}
+
 export function toBeCalculable(actual) {
   return !isNaN(actual * 2);
 }

src/toBeDate.ts

@@ -1,2 +1,13 @@
 import { is } from './lib/is';
-export const toBeDate = is.Date;
+
+export type ToBeDate = (expectationFailOutput?: any) => boolean;
+
+declare global {
+  namespace jasmine {
+    interface Matchers<T> {
+      toBeDate: ToBeDate;
+    }
+  }
+}
+
+export const toBeDate: ToBeDate = is.Date;

src/toBeEmptyArray.ts

@@ -1,2 +1,14 @@
 import { toBeArrayOfSize } from './toBeArrayOfSize';
-export const toBeEmptyArray = (actual) => toBeArrayOfSize(0, actual);
+
+export type ToBeEmptyArray = (expectationFailOutput?: any) => boolean;
+
+declare global {
+  namespace jasmine {
+    interface Matchers<T> {
+      toBeEmptyArray: ToBeEmptyArray;
+    }
+  }
+}
+
+export const toBeEmptyArray: ToBeEmptyArray = (actual) =>
+  toBeArrayOfSize(0, actual);

src/toBeEmptyObject.ts

@@ -1,4 +1,15 @@
 import { is } from './lib/is';
 import { keys } from './lib/keys';
-export const toBeEmptyObject = (actual) =>
+
+export type ToBeEmptyObject = (expectationFailOutput?: any) => boolean;
+
+declare global {
+  namespace jasmine {
+    interface Matchers<T> {
+      toBeEmptyObject: ToBeEmptyObject;
+    }
+  }
+}
+
+export const toBeEmptyObject: ToBeEmptyObject = (actual) =>
   is.Object(actual) && keys(actual).length === 0;

src/toBeEmptyString.ts

@@ -1 +1,11 @@
-export const toBeEmptyString = (actual) => actual === '';
+export type ToBeEmptyString = (expectationFailOutput?: any) => boolean;
+
+declare global {
+  namespace jasmine {
+    interface Matchers<T> {
+      toBeEmptyString: ToBeEmptyString;
+    }
+  }
+}
+
+export const toBeEmptyString: ToBeEmptyString = (actual) => actual === '';

src/toBeEvenNumber.ts

@@ -1,3 +1,14 @@
 import { toBeNumber } from './toBeNumber';
-export const toBeEvenNumber = (actual) =>
+
+export type ToBeEvenNumber = (expectationFailOutput?: any) => boolean;
+
+declare global {
+  namespace jasmine {
+    interface Matchers<T> {
+      toBeEvenNumber: ToBeEvenNumber;
+    }
+  }
+}
+
+export const toBeEvenNumber: ToBeEvenNumber = (actual) =>
   toBeNumber(actual) && actual % 2 === 0;

src/toBeFalse.ts

@@ -1,2 +1,14 @@
 import { is } from './lib/is';
-export const toBeFalse = (actual) => actual === false || is.False(actual);
+
+export type ToBeFalse = (expectationFailOutput?: any) => boolean;
+
+declare global {
+  namespace jasmine {
+    interface Matchers<T> {
+      toBeFalse: ToBeFalse;
+    }
+  }
+}
+
+export const toBeFalse: ToBeFalse = (actual) =>
+  actual === false || is.False(actual);

src/toBeFunction.ts

@@ -1,2 +1,13 @@
 import { is } from './lib/is';
-export const toBeFunction = is.Function;
+
+export type ToBeFunction = (expectationFailOutput?: any) => boolean;
+
+declare global {
+  namespace jasmine {
+    interface Matchers<T> {
+      toBeFunction: ToBeFunction;
+    }
+  }
+}
+
+export const toBeFunction: ToBeFunction = is.Function;

src/toBeGreaterThanOrEqualTo.ts

@@ -1,4 +1,19 @@
 import { toBeNumber } from './toBeNumber';
 
-export const toBeGreaterThanOrEqualTo = (otherNumber, actual) =>
-  toBeNumber(actual) && actual >= otherNumber;
+export type ToBeGreaterThanOrEqualTo = (
+  otherNumber: number,
+  expectationFailOutput?: any
+) => boolean;
+
+declare global {
+  namespace jasmine {
+    interface Matchers<T> {
+      toBeGreaterThanOrEqualTo: ToBeGreaterThanOrEqualTo;
+    }
+  }
+}
+
+export const toBeGreaterThanOrEqualTo: ToBeGreaterThanOrEqualTo = (
+  otherNumber,
+  actual
+) => toBeNumber(actual) && actual >= otherNumber;