argument stuff.

Author: ffMathy

src/Arguments.ts

@@ -1,27 +1,9 @@
 export class Arg {
-    private constructor(
-        private description: string,
-        private matchingFunction: (arg: any) => boolean
-    ) {
-    }
-
-    matches(arg: any) {
-        return this.matchingFunction(arg);
-    }
-
-    toString() {
-        return this.description;
-    }
-
-    inspect() {
-        return this.description;
-    }
-
     static any()
     static any<T extends 'string'|'number'|'boolean'|'symbol'|'undefined'|'object'|'function'|'array'>(type: T)
-    static any(type?: string): any {
+    static any(type?: string): Argument<any> {
         const description = !type ? '{any arg}' : '{arg matching ' + type + '}';
-        return new Arg(description, x => {
+        return new Argument<any>(description, x => {
             if(typeof type === 'string')
                 return true;
 
@@ -35,8 +17,8 @@ export class Arg {
         });
     }
 
-    static is<T>(predicate: (input: T) => boolean): Arg & T {
-        return new Arg('{arg matching predicate ' + this.toStringify(predicate) + '}', predicate) as any;
+    static is<T>(predicate: (input: T) => boolean): Argument<T> {
+        return new Argument<T>('{arg matching predicate ' + this.toStringify(predicate) + '}', predicate) as any;
     }
 
     private static toStringify(obj: any) {
@@ -48,4 +30,24 @@ export class Arg {
 
         return obj;
     }
+}
+
+export class Argument<T> {
+    constructor(
+        private description: string,
+        private matchingFunction: (arg: T) => boolean
+    ) {
+    }
+
+    matches(arg: T) {
+        return this.matchingFunction(arg);
+    }
+
+    toString() {
+        return this.description;
+    }
+
+    inspect() {
+        return this.description;
+    }
 }

src/Transformations.ts

@@ -1,10 +1,7 @@
-export type FunctionSubstitute<F extends any[], T> = (...args: F) => (T & {
-    returns: (...args: T[]) => void;
-})
+import { Argument } from "./Arguments";
 
-export type PropertySubstitute<T> = T & {
-    returns: (...args: T[]) => void;
-}
+export type FunctionSubstitute<F extends any[], T> = (...args: F) => (T & MockMethodMixin<T>);
+export type PropertySubstitute<T> = T & MockMethodMixin<T>;
 
 export type ObjectSubstitute<T extends Object> = ObjectSubstituteTransformation<T> & {
     received(amount?: number): T;
@@ -14,4 +11,10 @@ type ObjectSubstituteTransformation<T extends Object> = {
     [P in keyof T]:
     T[P] extends (...args: infer F) => infer R ? FunctionSubstitute<F, R> :
     PropertySubstitute<T[P]>;
+}
+
+type MockArgumentInput<T> = T | Argument<T>;
+
+type MockMethodMixin<TReturnType> = {
+    returns: (...args: TReturnType[]) => void;
 }