ToDo Application: Setup TypeScript Project

There are many ToDo or task management applications out there, written in many programming languages and for almost all the platforms. A ToDo application at its core is the simplest application one can think of. This makes it the right candidate for practicing or brushing up any language’s skills. Which is the same reason, we have picked up this as the center of this tutorial on building an application with TypeScript. This post is second in this series, where we will setup TypeScript project. In case you have not started from the beginning or very beginning (learn typescript), you can do so before continuing here.

Setup TypeScript Project

Before we start setting up our project and begin the development let’s see what we are going to build. Here is the screenshot of the minimal implementation of the application.

Sneak Peek
Application Sneak Peek

Here you are going to build a simple web application which has the capabilities of

  • adding new tasks in the list
  • storing in browsers local storage
  • show the task list with delete and complete actions
  • select tasks to edit them.

So let’s not indulge ourselves on that anymore but setup TypeScript project. I will explain the steps here one by one for each of the component of this project.

jQuery Typings

We will be using jQuery in this application for DOM manipulation and few other simple tasks. The jQuery script will be linked to the HTML after loading dynamically using require.js. Also, for TypeScript compiler and intellisense to recognise the jQuery functions, we are required to have the type definition file for jQuery in our folder and referenced in the TypeScript code files. We will be using definitelytyped repository to get these.

First of all let’s install the typings manager

npm install typings -g

Once you have installed the typings manager globally, its time to install the jQuery typings. For this you have to navigate to the project folder (in case you have not created a folder for your project, its right time to do so now). Open the folder in your favorite terminal and enter the below command.

typings install dt~jquery --save --global

This will create a few files and folders in your project folder as shown below.

Project Folder after installing jQuery Typings

Let’s not go into much details here but just understand that if we reference the index.d.ts from the typings folder into our TypeScript code we will be happy to go.

Bower Components

Next step is to get bower and using that, install jQuery, Bootstrap and Require.JS. Bower is a web package manager which can be used to manage third party library dependencies for your application. You can install bower using the command below (this is installed globally as we did for typings).

npm install bower -g

Once bower is installed, you have to enter the below command in the terminal, while being in your project root.

bower install jquery requirejs bootstrap

After the above command is finished successfully, you should see the below structure of your project folder

image folder structure
Folder structure after installing the bower components

Compiling TypeScript

I am assuming that you have already done the IDE setup as explained here in this post, So its time now to create a tsconfig.json file as per the snippet below.

{
    "compileOnSave": true,
    "compilerOptions": {
        "module": "amd",
        "removeComments": true,
        "outDir": "js",
        "alwaysStrict": true,
        "emitBOM": false,
        "target": "es5"
    }
}

This file tells the compiler that it should compile the TypeScript files as soon as they are saved and output the result into the js folder. Along with that the compiled output will be ES5 compatible and usable by amd module. Let’s create a folder named js and other named ts in our project folder. Create a file main.ts in the ts folder with some simple code in there, just to check if everything is working fine. Here is the outcome of my test.

Compiling TypeScript
Compiling TypeScript

Compiling LESS

I am assuming that you have setup your development environment as suggested in my previous post. We will be however using one more thing in this project and that is LESS as the pre-compiled CSS. LESS can be compiled into CSS so that it can be used by the browsers. We will adding one more package to our Atom editor so that as and when we edit and save the less file, it is compiled into the equivalent CSS.

Please go to your Atom Editor’s settings and navigate to Install tab. Now search for atom-compile-less package and install it. This package will compile your less files into the css files as soon as they are saved.

Create a folder named styles in the root of your project folder and create a new file named main.less in there with the below content (this is just to validate if the less is getting compiled).

a {
    text-decoration: none;
    &:hover {
        text-decoration: underline;
    }
}

Here is something what you should see as the output.

LESS file sample
LESS Compiled into CSS

You will require to enable the auto compile option of this package in its settings page.

In case you are interested in minifying the generated css, there is an option to do so too with this atom package.

At this point, our main project setup is complete and we are ready to write our code for the application. Please let me know in case you have any troubles following this tutorial. I will really appreciate your feedback. It will encourage me to write more such posts and courses. I will take a leave from you now so that I can continue on the next post in this series.

Have a nice day!

TypeScript Tutorial: Using Typings (Chapter 9)

TypeScript can understand JavaScript (respectfully) functions as they are with that old reference syntax. But, it really loves the taste of its own flavours. There are many ways you can use a JavaScript library with TypeScript and make it all work, whereas using Typings it makes yours and TypeScripts life really easy. In this chapter we are going to see what are Typings and how they makes the life of developer easy.

A TypeScript Tutorial for beginners on TypeScript

What are Typings?

Just consider Typings as the interface for TypeScript to understand the vast world of JavaScript. A Typings file includes the definition of all the functions in a JavaScript library. In other words it is defnition of a JavaScript Library consumed by the TypeScript compiler and Intellisense so that they know what a function does and what all properties of an object are.

Why Typings?

Take an example of a library, used and known today to almost every web developer … jQuery. That library is pure JavaScript (In our upcoming chapters in practical use of TypeScript, we will be using jQuery too) and exposes a single variable in the global scope ‘$’. This single variable has the definition of all the functions this library supports.

What if in our application written in TypeScript need to use that library? Well, there is no one stopping you to do that. The only caveat here is that your compiler will not know it and will warn you about that. And your IDE will not help you find the available methods in that library. You will be able to still compile and use the output JS in your program as you know that you have included jQuery as a script tag. Let’s build a smaller example. Say you have a JavaScript library which defines a function like below.

File: jsLib.js

function SayHello (name) {
    console.log("Hello! " + name);
}

and we want to use that function in our TypeScript code like this.

File: testTypings.ts

module tester {
    export var useJSFunction = function() {
        SayHello('Mark');
    }
}
tester.useJSFunction();

If you compile the above code you will see that compiler will complain “not able to find the name ‘SayHello'”. If you include these both files in your web page and run, you will be able to see the output without any issue and your application will run just fine.

Now, you may say when the output is there and your application is running the way it should, what else you need?

Using Typings

Probably you are missing the point here … the core USP of TypeScript … definition of types. Means you and compiler knows what the code should look and behave like. So its time to introduce our library’s definition over here.

File: jsLib.d.ts

declare function SayHello(name:string): any;

and reference this file in the testTypings.ts file.

///<reference path="./jsLib.d.ts" />

module tester {
    export var useJSFunction = function() {
        SayHello('Mark');
    }
}
tester.useJSFunction();

By using Typings makes both you and compiler happy, as you know what you are coding and compiler knows what it is compiling. Below screenshot proves this with the intellisense.

All the definition files are saved with a file extension ‘.d.ts’ and by only being there in the TypeScript project environment, they are automatically available for the compiler and intellisense (We still include the reference for the clarity of the developers).

Getting Type Definitions of the External Libraries

Coming back to the jQuery, this is a huge code and there are hundreds of functions over there. Do you need to convert all those jQuery functions into the type definitions?

The Answer is No! … If you are lucky enough or using a popular library in your project, you can get the definition files from internet. There are npm and bower packages and repositories like DefinitelyTyped or typings, which can help you get your hands on the typings of your favorite library. Once you get the typings, its as simple as including that file in your project along with the js library.

Using Typings makes it possible to work with these libraries as if they are available right there in your project, even if you are including them from CDN later at the client side.

There is More

The intention over here is to keep these tutorials simple as much as possible and help you do an easy transition from JavaScript to TypeScript. If you have searched the web, you might have seen the “include” or “require” syntax. Trust me that’s a different level of talk. We will be talking all about those techniques in our upcoming series on Advanced TypeScript.

With this I am concluding this series here on Beginning with TypeScript. I remember that I have told you all about the practical use of TypeScript at the End of this tutorial. I am not ditching that. In the next post we will start building a simple ToDo Application using TypeScript. Here is the sneak peak of the same.

In case you are interested in that, I would recommend you to subscribe to this blog, so that you are notified as soon as this or any new topic is published here. Hope you enjoyed this little tutorial. Please leave your feedback or any queries you have, below in the comments. I will be really happy to help you out with your queries.

Have a nice day and happy learning!

Go to Beginning with TypeScript Tutorial Index page.

YouTube Channel

Hi All,

I am happy to announce that a new youtube channel has been started with the same intention as of this blog … spread technology awareness. The list of all latest videos can be viewed here. Follow me to … “Let Me Make You Think Like Me”

Follow me :

youtubefacebooktwittergoogleplus

Installing Nokia PC Suite on Windows Server 2003

lost this post some how … sorry.