I suspect this is expected behavior, although I'd agree it's not super intuitive

According to the `tsconfig` docs on [Types > What does this affect?][1]

> This option does not affect how `@types/*` are included in your application code, for example if you had the above > `compilerOptions` example with code like:
> 
> ```ts
> import * as moment from "moment";
> moment().format("MMMM Do YYYY, h:mm:ss a");
> ```
> 
> The `moment` import would be fully typed.
> 
> When you have this option set, by not including a module in the types array it:
> 
> * Will not add globals to your project (e.g process in node, or expect in Jest)
> * Will not have exports appear as auto-import recommendations

[1]: https://www.typescriptlang.org/tsconfig#what-does-this-affect

## Current Setup

Here is my directory structure:

```bash
root
├──typings/           # currently empty
├──package.json
├──package-lock.json
├──tsconfig.json
└──main.ts
```


Here is my `tsconfig.json`:

```json
{
    "compilerOptions": {
        "typeRoots": [
            "./typings"
        ],
        "types": ["Phaser"]  
    }    
}
```

Here is my `main.ts` file:

```ts
let countdownNumber: Phaser.GameObjects.BitmapText;
```

Then I've run the following command in terminal:

```bash
tsc --traceResolution
```

I am trying to use `Phaser` as a global variable in my `main.ts` file.

### Expected behavior:

What should happen is `Phaser` shouldn't get resolved because compiler should start looking into my custom folder `typings`.  


### Actual behavior:

Somehow it still gets resolved. And this is what it prints: 

> Type reference directive 'Phaser' was successfully resolved to '/Applications/XAMPP/xamppfiles/htdocs/phasertest/node_modules/Phaser/types/phaser.d.ts' with Package ID 'phaser/types/phaser.d.ts@3.22.0', primary: false. 

I don't know how it finds it since in my `typeRoots`, I don't have `node_modules` specified. 

### What I have tried:

I tried to exclude `node_modules` folder, I thought maybe they still get compiled and that's why this happens, but I couldn't make `exclude` work with any of the following:

* `"exclude": ["node_modules/*"]`
* `"exclude": ["./node_modules/*"]`
* `"exclude": ["./node_modules"]`

but none of these worked. 

TypeScript config typeRoots and types not working properly

First of all, this function:
```typescript
const fetchData = <T,>(): T[] => {
    const arr: T[] = []
    arr.push(2) // error
    arr.push('str') // error

    return arr
}

```
is hard to use.

Since non of your arguments are not related to `T`, TS will not allow you to `push` any value to the `arr`. Of course, you can use type assertion `as`, but it is very unsafe:
```typescript
const fetchData = <T,>(): T[] => {
    const arr: T[] = []
    arr.push('str' as any as T) // error

    return arr
}

const emptyStringArray = fetchData<number>(); // number[]
emptyStringArray[0].toExponential() // runtime error
```
Related [question/answer][1], [my article][2]

The answer is easy and simple: it is impossible in this case to separate `T` from function definition without workarounds. 

Here you have simplest way:
```typescript
const fetchData = <T,>() => {
  const arr: T[] = []
  return arr
}
```
However, if you want to mutate your array inside `fetchData`,  this function signature is not useful. This function is not allowed to do anything with `arr`. All you can do is to return `arr` without any mutations.

In order to mutate this list, you need create higher order function and during calling `fetchData` provide explicit generic argument:
```typescript
type FetchData = <T>() => T[]
const fetchData: FetchData = () => []

const higherOrder = <T,>(elem: T) => {
  const arr = fetchData<T>();
  arr.push(elem)

  return arr
}



const test = higherOrder('str'); // ok, string[]
const test2 = higherOrder(42); // ok, number[]

```
 [Playground][3]


  [1]: https://stackoverflow.com/questions/69187022/why-cant-the-generic-interface-in-ts-infer-the-type-correctly/69188596#69188596
  [2]: https://catchts.com/infer-arguments#generic_constraints
  [3]: https://tsplay.dev/N7K24N

I can define and use a generic function like this:

```ts
const fetchData = <T>(): T[] => {
  const arr: T[] = []
  // if stuff push to arr
  return arr
}

const emptyStringArray = fetchData<string>();
```

However, in my actual scenario, I have a lot of params and would like to separate out the typings and function assignment.

I've attempted to write like this:

```ts
type IFetchData = <T>() => T[]

const fetchData2: IFetchData = () => {
  const arr: T[] = []
  // if stuff push to arr
  return arr
}

const emptyStringArray = fetchData2<string>();
```

However, now the function definition doesn't recognize the `T` as an available type.

> Cannot find name 'T'.

I've tried a lot of different configurations on where to put the `<T>`, but nothing seems to work - any ideas?

### [Demo in TS Playground][5]

---

### Related Questions

* [How to create a generic type alias for a generic function?][1]
* [Generic function type alias][2]
* [Function with Generic Return Type][3]
* [Type of generic function][4]

[1]: https://stackoverflow.com/q/62720954/1366033
[2]: https://stackoverflow.com/q/58770087/1366033
[3]: https://stackoverflow.com/q/60178347/1366033
[4]: https://stackoverflow.com/q/48425137/1366033 

[5]: https://www.typescriptlang.org/play?jsx=0#code/LAKAxg9gdgzgLgAgGYFM5gBYBECGccIC8CAPACoB8AFAJQBcCZA2gLpEUIDeoCCksiHACchDZm2KseCAPQyEASyQJ4AVyTKADqpgYEcCAmFDpQtKqFQjI0AF9Q-eAhQBbTXACeAZThCFUAHMAQREcDwBGImQ0TFx8Eng-QOoaAG5QDJBPTRQEAEkAMRjsPAJichT2RilwaCdUdBL8ACYGQuK4soRaKu4QXkdBETFWKJreOUVlNQ0EbV19Q2NTc0trExB7EAc6xFd3b19-YNCPZqiG2NLmhKPk2nTtkCA