Using `import type` statement to fix circular dependency reference error

Question

Let's say I have two files, A.js and B.js. Both need references to each other like this.

A.js

import { B } from "b"

export class A {
  constructor(public name: string) {}
}

let b = new B();
b.print(new A("This is a random name"));

B.js

import { A } from "a"

export class B {
  print(a: A) {
    console.log(a.name);
  }
}

The example above will create a circular reference which currently does not work in the JavaScript runtime I'm using. The file B.js really only need the type information, not the actual export object). I want the type from A.js to get static type checking. Is this possible?

Answer 1

This is now directly possible in TypeScript 2.9.

type MyType = import('mymodule').MyType;
const myValue: import('mymodule').MyType;

Answer 2

UPDATE: this answer is likely to become obsolete as soon as TypeScript 3.8 is released

You don't need to do anything special to import only type information from module a.

Typescript will do it for you - if the only thing module b needs form a is type information, compiled file b.js will not have require("./a") statement, that is, it will not have runtime dependency on a. Quote from typescript handbook:

The compiler detects whether each module is used in the emitted JavaScript. If a module identifier is only ever used as part of a type annotations and never as an expression, then no require call is emitted for that module.

I just tried that:

file a.ts

import { B } from "./b"

export class A {
    constructor(public name: string) {}
}

let b = new B();
b.print(new A("This is a random name"));

file b.ts

import { A } from './a';

export class B {
    print(a: A) {
        console.log(a.name);
    }
}

compile them together

tsc a.ts b.ts

Here is resulting b.js:

"use strict";
var B = (function () {
    function B() {
    }
    B.prototype.print = function (a) {
        console.log(a.name);
    };
    return B;
}());
exports.B = B;

see? there is no require("./a"), unlike a.js which contains

var b_1 = require("./b");

Most likely, the example code you posted in your question is incomplete, and real b module has runtime dependency on a - find out where it is and get rid of that, and you won't have this problem.

Answer 3

As of TypeScript 3.8, use import type:

import type { SomeThing } from "./some-module.js";

export type { SomeThing };

Reference:

https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-8.html#type-only-imports-exports