A note about terminology: It’s important to note that in TypeScript 1.5, the nomenclature has changed. “Internal modules” are now “namespaces”. “External modules” are now simply “modules”, as to align with ECMAScript 2015’s terminology, (namely that module X { is equivalent to the now-preferred namespace X {).

Introduction

This post outlines the various ways to organize your code using namespaces (previously “internal modules”) in TypeScript. As we alluded in our note about terminology, “internal modules” are now referred to as “namespaces”. Additionally, anywhere the module keyword was used when declaring an internal module, the namespace keyword can and should be used instead. This avoids confusing new users by overloading them with similarly named terms.

First steps

Let’s start with the program we’ll be using as our example throughout this page. We’ve written a small set of simplistic string validators, as you might write to check a user’s input on a form in a webpage or check the format of an externally-provided data file.

Validators in a single file

  1. ts
    interface StringValidator {
  2.   isAcceptable(s: string): boolean;
  3. }
  5. let lettersRegexp = /^[A-Za-z]+$/;
  6. let numberRegexp = /^[0-9]+$/;
  8. class LettersOnlyValidator implements StringValidator {
  9.   isAcceptable(s: string) {
  10.     return lettersRegexp.test(s);
  11.   }
  12. }
  14. class ZipCodeValidator implements StringValidator {
  15.   isAcceptable(s: string) {
  16.     return s.length === 5 && numberRegexp.test(s);
  17.   }
  18. }
  20. // Some samples to try
  21. let strings = ["Hello", "98052", "101"];
  23. // Validators to use
  24. let validators: { [s: string]: StringValidator } = {};
  25. validators["ZIP code"] = new ZipCodeValidator();
  26. validators["Letters only"] = new LettersOnlyValidator();
  28. // Show whether each string passed each validator
  29. for (let s of strings) {
  30.   for (let name in validators) {
  31.     let isMatch = validators[name].isAcceptable(s);
  32.     console.log(`'${s}' ${isMatch ? "matches" : "does not match"} '${name}'.`);
  33.   }
  34. }

Namespacing

As we add more validators, we’re going to want to have some kind of organization scheme so that we can keep track of our types and not worry about name collisions with other objects. Instead of putting lots of different names into the global namespace, let’s wrap up our objects into a namespace.

In this example, we’ll move all validator-related entities into a namespace called Validation. Because we want the interfaces and classes here to be visible outside the namespace, we preface them with export. Conversely, the variables lettersRegexp and numberRegexp are implementation details, so they are left unexported and will not be visible to code outside the namespace. In the test code at the bottom of the file, we now need to qualify the names of the types when used outside the namespace, e.g. Validation.LettersOnlyValidator.

Namespaced Validators

  1. ts
    namespace Validation {
  2.   export interface StringValidator {
  3.     isAcceptable(s: string): boolean;
  4.   }
  6.   const lettersRegexp = /^[A-Za-z]+$/;
  7.   const numberRegexp = /^[0-9]+$/;
  9.   export class LettersOnlyValidator implements StringValidator {
  10.     isAcceptable(s: string) {
  11.       return lettersRegexp.test(s);
  12.     }
  13.   }
  15.   export class ZipCodeValidator implements StringValidator {
  16.     isAcceptable(s: string) {
  17.       return s.length === 5 && numberRegexp.test(s);
  18.     }
  19.   }
  20. }
  22. // Some samples to try
  23. let strings = ["Hello", "98052", "101"];
  25. // Validators to use
  26. let validators: { [s: string]: Validation.StringValidator } = {};
  27. validators["ZIP code"] = new Validation.ZipCodeValidator();
  28. validators["Letters only"] = new Validation.LettersOnlyValidator();
  30. // Show whether each string passed each validator
  31. for (let s of strings) {
  32.   for (let name in validators) {
  33.     console.log(
  34.       `"${s}" - ${
  35.         validators[name].isAcceptable(s) ? "matches" : "does not match"
  36.       } ${name}`
  37.     );
  38.   }
  39. }

Splitting Across Files

As our application grows, we’ll want to split the code across multiple files to make it easier to maintain.

Multi-file namespaces

Here, we’ll split our Validation namespace across many files. Even though the files are separate, they can each contribute to the same namespace and can be consumed as if they were all defined in one place. Because there are dependencies between files, we’ll add reference tags to tell the compiler about the relationships between the files. Our test code is otherwise unchanged.

Validation.ts
  1. ts
    namespace Validation {
  2.   export interface StringValidator {
  3.     isAcceptable(s: string): boolean;
  4.   }
  5. }
LettersOnlyValidator.ts
  1. ts
    /// <reference path="Validation.ts" />
  2. namespace Validation {
  3.   const lettersRegexp = /^[A-Za-z]+$/;
  4.   export class LettersOnlyValidator implements StringValidator {
  5.     isAcceptable(s: string) {
  6.       return lettersRegexp.test(s);
  7.     }
  8.   }
  9. }
ZipCodeValidator.ts
  1. ts
    /// <reference path="Validation.ts" />
  2. namespace Validation {
  3.   const numberRegexp = /^[0-9]+$/;
  4.   export class ZipCodeValidator implements StringValidator {
  5.     isAcceptable(s: string) {
  6.       return s.length === 5 && numberRegexp.test(s);
  7.     }
  8.   }
  9. }
Test.ts
  1. ts
    /// <reference path="Validation.ts" />
  2. /// <reference path="LettersOnlyValidator.ts" />
  3. /// <reference path="ZipCodeValidator.ts" />
  5. // Some samples to try
  6. let strings = ["Hello", "98052", "101"];
  8. // Validators to use
  9. let validators: { [s: string]: Validation.StringValidator } = {};
  10. validators["ZIP code"] = new Validation.ZipCodeValidator();
  11. validators["Letters only"] = new Validation.LettersOnlyValidator();
  13. // Show whether each string passed each validator
  14. for (let s of strings) {
  15.   for (let name in validators) {
  16.     console.log(
  17.       `"${s}" - ${
  18.         validators[name].isAcceptable(s) ? "matches" : "does not match"
  19.       } ${name}`
  20.     );
  21.   }
  22. }

Once there are multiple files involved, we’ll need to make sure all of the compiled code gets loaded. There are two ways of doing this.

First, we can use concatenated output using the --outFile flag to compile all of the input files into a single JavaScript output file:

  1. tsc --outFile sample.js Test.ts

The compiler will automatically order the output file based on the reference tags present in the files. You can also specify each file individually:

  1. tsc --outFile sample.js Validation.ts LettersOnlyValidator.ts ZipCodeValidator.ts Test.ts

Alternatively, we can use per-file compilation (the default) to emit one JavaScript file for each input file. If multiple JS files get produced, we’ll need to use <script> tags on our webpage to load each emitted file in the appropriate order, for example:

MyTestPage.html (excerpt)
  1. html
    <script src="Validation.js" type="text/javascript" />
  2. <script src="LettersOnlyValidator.js" type="text/javascript" />
  3. <script src="ZipCodeValidator.js" type="text/javascript" />
  4. <script src="Test.js" type="text/javascript" />

Aliases

Another way that you can simplify working with namespaces is to use import q = x.y.z to create shorter names for commonly-used objects. Not to be confused with the import x = require("name") syntax used to load modules, this syntax simply creates an alias for the specified symbol. You can use these sorts of imports (commonly referred to as aliases) for any kind of identifier, including objects created from module imports.

  1. ts
    namespace Shapes {
  2.   export namespace Polygons {
  3.     export class Triangle {}
  4.     export class Square {}
  5.   }
  6. }
  8. import polygons = Shapes.Polygons;
  9. let sq = new polygons.Square(); // Same as 'new Shapes.Polygons.Square()'

Notice that we don’t use the require keyword; instead we assign directly from the qualified name of the symbol we’re importing. This is similar to using var, but also works on the type and namespace meanings of the imported symbol. Importantly, for values, import is a distinct reference from the original symbol, so changes to an aliased var will not be reflected in the original variable.

Working with Other JavaScript Libraries

To describe the shape of libraries not written in TypeScript, we need to declare the API that the library exposes. Because most JavaScript libraries expose only a few top-level objects, namespaces are a good way to represent them.

We call declarations that don’t define an implementation “ambient”. Typically these are defined in .d.ts files. If you’re familiar with C/C++, you can think of these as .h files. Let’s look at a few examples.

Ambient Namespaces

The popular library D3 defines its functionality in a global object called d3. Because this library is loaded through a <script> tag (instead of a module loader), its declaration uses namespaces to define its shape. For the TypeScript compiler to see this shape, we use an ambient namespace declaration. For example, we could begin writing it as follows:

D3.d.ts (simplified excerpt)
  1. ts
    declare namespace D3 {
  2.   export interface Selectors {
  3.     select: {
  4.       (selector: string): Selection;
  5.       (element: EventTarget): Selection;
  6.     };
  7.   }
  9.   export interface Event {
  10.     x: number;
  11.     y: number;
  12.   }
  14.   export interface Base extends Selectors {
  15.     event: Event;
  16.   }
  17. }
  19. declare var d3: D3.Base;