Setting up ASP.NET Core in Visual Studio 2017 with npm, webpack, and TypeScript: Part II
Tags: visualstudio2017, aspnetcore, node, webpack
Published: 2017-04-17 08:11:50

---
title: "Setting up ASP.NET Core in Visual Studio 2017 with npm, webpack, and TypeScript: Part II"
published: true
description: 
tags: Visual Studio 2017, ASP.NET Core, node.js, webpack
canonical_url: http://leruplund.dk/2017/04/15/setting-up-asp-net-core-in-visual-studio-2017-with-npm-webpack-and-typescript-part-ii/
series: asp-net-core-with-npm-webpack-typescript
---

<em>This post first appeared on my personal [blog](http://leruplund.dk/2017/04/15/setting-up-asp-net-core-in-visual-studio-2017-with-npm-webpack-and-typescript-part-ii/).</em>

<em>Example code on [Github](https://github.com/t4rzsan/aspnet-core-with-webpack/tree/master).</em>

This is the second part in my small series on ASP.NET Core and the coolest of the cool JavaScript libraries out there, except that they are probably already outdated by the time I finish writing this.

In [part I][1] we took a look on how to install npm and webpack into our ASP.NET Core project.  In this part we will set up TypeScript.  Visual Studio (VS) will compile TypeScript for you automatically but we will disable that feature and let webpack do the TypeScript build just for the fun of it.

**Set up TypeScript**
Start by installing TypeScript using npm (this is all described on in [webpack's documentation][2]):

```npm install --save-dev typescript ts-loader```

Notice how package.json is updated with typescript and ts-loader.  You may be wondering what [ts-loader][3] is.  I know I was.  It is a "TypeScript loader for webpack" which really does not say much but it is the thing that makes webpack take care of our TypeScript code.

While we are at it let's install [Knockout.js][4] which we will use for building view models in TypeScript.

```npm install --save-dev knockout @types/knockout```

By using @types we tell npm to install the typings for Knockout as well.  I tend to think of typings being to TypeScript what header-files are to C++.  The typings go into the node_modules folder as everything else.

Next we need to create a configuration file for TypeScript.  Right-click your project node in VS solution explorer and click "Add New Item".  Search for "json" in the templates dialog and choose "TypeScript JSON Configuration File".  The file must be name "tsconfig.json".  Change the contents so that it looks something like this:

```
{
  "compilerOptions": {
    "outDir": "./wwwroot/build/",
    "noImplicitAny": false,
    "noEmitOnError": true,
    "removeComments": false,
    "sourceMap": true,
    "target": "es5",
    "module": "commonjs",
    "moduleResolution": "node",
    "compileOnSave": true
  },
  "exclude": [
    "node_modules",
    "wwwroot"
  ]
}
```

Notice that I have told the TypeScript loader to put the generated .js files in the folder "wwwroot/build", and that I have told it to resolve any 3rd party modules by using ["node"][5] (i.e. it will look in the "node_modules" folder).

**Test TypeScript build**
Let us test that we can build TypeScript files.  By default VS will build what ever .ts files you add to the project.  Start by creating af Script folder in your project next to the wwwroot folder.  Add a TypeScript a file named "myviewmodel.ts" to the folder.  We will create a Knockout view model class so start by importing Knockout to the .ts file by adding the following line at the top.
```
import * as ko from "knockout"
```

Note how VS IntelliSense kicks in as you type.  Very cool.  Above we set "modeResolution" to "node" so that the TypeScript loader knows to look in node_modules to find Knockout.  Now lets add a view model with two observable fields using the Knockout TypeScript definitions.  The last line applies the Knockout bindings to the view.

```
import * as ko from "knockout"

class MyViewModel {
    firstname: KnockoutObservable<string>;
    lastname: KnockoutObservable<string>;

    constructor(firstname: string, lastname: string) {
        this.firstname = ko.observable(firstname);
        this.lastname = ko.observable(lastname);
    }
}

ko.applyBindings(new MyViewModel("Jakob", "Christensen"));

```

Now if you build your project in VS, you will see a new folder underneath "wwwroot/build" with the compiled .js file.

**Set up the webpack TypeScript load**
Instead of letting VS do the TypeScript build we want webpack to do it and we already installed ts-loader to do it for us.  Why would we want to do that now that VS can do it for us?  I like to do it because I prefer to keep everything front-end-ish together.  So, webpack does the build, the bundling, the code splitting, etc.

Now, add a file called webpack.config.js to your project at the project root.  Paste the following into the file.
```
var path = require('path');

module.exports = {
    entry: {
        site: [
            './wwwroot/js/site.js', 
            './scripts/myviewmodel.ts']
    },
    output: {
        filename: 'bundle.js',
        path: path.resolve(__dirname, 'wwwroot/dist/')
    },
    module: {
        rules: [
            {
                test: /\.tsx?$/,
                loader: 'ts-loader',
                exclude: /node_modules/,
            },
        ]
    },
    resolve: {
        extensions: [".tsx", ".ts", ".js"]
    }
};
```

This configures webpack to compile the .ts files.  It also instructs webpack to take the compiled .js file and bundle it together with some other site.js file that we might have in our project and put it all into a file called bundle.js places in "wwwroot/dist".  This is the file you want to reference in your HTML files.  By the way, the compiled .js files will no longer end up in the "wwwroot/build" folder so you can delete that.

**Webpack build**
To build and bundle, first edit your package.json so that the build block looks like this.

```
  "scripts": {
    "build": "webpack"
  },
```

Then remove the line containing "compileOnSave" from tsconfig.json.

Finally, go to the cmd prompt and run the following npm command from your project folder.

```npm run build```

You should now see the file bundle.js in "wwwroot/dist".

Of course you don't want to go to the cmd prompt every time you have changed something in your .ts files, so we want VS to run the npm build.  Fortunately, the ever-present Mads Kristensen has created a VS [extension][6] that does it for you.  After installing the extension you can see the npm custom build task in Visual Studio's Task Runner Explorer.  Right-click "build" to tell VS to run the build task before or after your normal VS build.

<img src="http://leruplund.dk/wp-content/uploads/2017/04/Task-Explorer-1024x283.png" alt="" width="1008" height="279" class="alignnone size-large wp-image-153" />

This will add a line to the package.json file.

```
"-vs-binding":{"BeforeBuild":["build"]}
```

**Cleaning up**
As I said above, VS automatically picks up .ts files and builds.  You don't want that when using webpack.  To disable the VS build, right-click your project in Solution Explorer and choose "Edit [your project name].csproj".  Add the following line under the ```<PropertyGroup>``` element.

```
<PropertyGroup>
    <!-- ... -->
    <TypeScriptCompileBlock>true</TypeScriptCompileBlock>
</PropertyGroup>
```

Also, you might want to remove bower.json and bundleconfig.json if present, as package.json and webpack.config.js replace them.  As far as I know bundleconfig.json works with another Mads Kristensen extension to bundle .js files.

That's it.  Now it is up to you to take fully advantage of webpack for [code splitting][7] and [uglifying][8] and [what not][9].

[1]: https://dev.to/t4rzsan/setting-up-aspnet-core-in-visual-studio-2017-with-npm-webpack-and-typescript-part-i
[2]: https://webpack.js.org/guides/webpack-and-typescript/
[3]: https://github.com/TypeStrong/ts-loader
[4]: http://knockoutjs.com/
[5]: https://www.typescriptlang.org/docs/handbook/module-resolution.html#node
[6]: https://marketplace.visualstudio.com/items?itemName=MadsKristensen.NPMTaskRunner
[7]: https://webpack.js.org/guides/code-splitting-libraries/
[8]: http://stackoverflow.com/questions/25956937/how-to-build-minified-and-uncompressed-bundle-with-webpack
[9]: https://dev.to/alflennik/the-fine-art-of-the-webpack-2-config