There are 2 different things. `--target` simply means which version of ECMAScript you&#39;re using to code. `--module` simply means which module system you&amp;#39;re using such as `commonjs` for Node or ES module for all that supports it and what not.

**A more detailed explanation is here : https://stackoverflow.com/questions/41993811/understanding-target-and-module-in-tsconfig** 

---

See also: https://stackoverflow.com/questions/41993811/understanding-target-and-module-in-tsconfig.

Here is a quote from the documentation [on compiler options](https://www.typescriptlang.org/docs/handbook/compiler-options.html):

&gt; __--target__
&gt; 
&gt; Specify ECMAScript target version: &#39;es3&#39; (default), &#39;es5&#39;, or &#39;es6&#39;.
&gt; 
&gt; __--module__
&gt; 
&gt; Specify module code generation: &#39;none&#39;, &#39;commonjs&#39;, &#39;amd&#39;, &#39;system&#39;, &#39;umd&#39;, &#39;es6&#39;, or &#39;es2015&#39;.
&gt; 
&gt; - Only &#39;amd&#39; and &#39;system&#39; can be used in conjunction with --outFile.
&gt; - &#39;es6&#39; and &#39;es2015&#39; values may be used when targeting ES5 or lower.



The &quot;target&quot; property is used to specify the JavaScript version your TypeScript code will eventually compile into. The &quot;module&quot; property specifies the type of the module syntax your compiled (TS--&gt;JS) code will use. For instance if you set the module property to &quot;commonJS&quot;, your compiled code will use &quot;require/module.exports&quot; to import/export. The module property will not however affect the rest of the compiled code. For the sake of clarity, please refer this answer: https://stackoverflow.com/a/61215252/8659116

This is the code I have:

    public class StupidClass {
        static {
            System.out.println(&quot;Stupid class loaded!&quot;);
        }
    }

And the tests I have, which I run **separately**.

    import org.junit.Test;
    
    public class StupidTest {
        @Test
        public void foo() throws ClassNotFoundException {
            final Class&lt;?&gt; stupidClass = Class.forName(&quot;StupidClass&quot;);
            System.out.println(stupidClass.getSimpleName());
        }
    
        @Test
        public void bar() throws ClassNotFoundException {
            final Class&lt;StupidClass&gt; stupidClassClass = StupidClass.class;
            System.out.println(stupidClassClass.getSimpleName());
        }
    }

When I run test **foo** I will see:

    Stupid class loaded!
    StupidClass

But when I run the test **bar** all I see is:

    StupidClass

Quoting from [this][1] page..

&gt; Class objects are constructed automatically by the Java Virtual
&gt; Machine as classes are loaded and by calls to the defineClass method
&gt; in the class loader.

So my understanding is, in test bar, Stupid class is loaded, otherwise I would have seen a null I guess? So Class object is created because class itself is loaded..

And now quoting from [this][2] page  

&gt; Static initialization blocks are run when the JVM (class loader - to
&gt; be specific) loads StaticClass (which occurs the first time it is
&gt; referenced in code).

So I am expecting to see the &quot;Stupid class loaded!&quot; text in test bar as well, but I am not.

Also quoting from [Thinking in Java][3]

&gt; Each of the classes Candy, Gum, and Cookie has a static clause that is
&gt; executed as the class is loaded for the first time.

which is not very accurate it seems..

What am I missing?


  [1]: http://docs.oracle.com/javase/8/docs/api/java/lang/Class.html
  [2]: https://stackoverflow.com/questions/9130461/when-is-the-static-block-of-a-class-executed
  [3]: https://www.amazon.com/Thinking-Java-4th-Bruce-Eckel/dp/0131872486

Why does .class not invoke the static block in a Class?

What is the proper annotation since `@SpringApplicationConfiguration` and `@WebIntegration` are deprecated as of Spring Boot Framework 1.4?  I&#39;m trying to play around with unit testing.


What is the proper annotation since @SpringApplicationConfiguration, @WebIntegration, is deprecated in Spring Boot Framework?

Trying to have some basic understanding about module and target.  

I would like to know the difference between module and target compile options in a typical tsconfig.json

&lt;pre&gt;
{
    &quot;compilerOptions&quot;: {
    	&quot;module&quot;: &quot;es6&quot;,
        &quot;sourceMap&quot;: true,
        &quot;target&quot;: &quot;es6&quot;
    }
}
&lt;/pre&gt;

What happens if I provide the following options:

module: commonjs, target: es6

module: es6, target: commonjs

module: commonjs, target: commonjs

TypeScript Compile Options: module vs target

Trying to have some basic understanding about module and target.
I would like to know the difference between module and target compile options in a typical tsconfig.json
<pre>{
"compilerOptions": {
"module": "es6",
"sourceMap": true,
"target": "es6"
}
}
</pre>
What happens if I provide the following options:
module: commonjs, target: es6
module: es6, target: commonjs
module: commonjs, target: commonjs

Since typescript 2.0 RC (or even beta?) it is possible to use number literal types, as in `type t = 1 | 2;`. Is it possible to restrict a type to a number range, e.g. 0-255, without writing out 256 numbers in the type?

In my case, a library accepts color values for a palette from 0-255, and I&#39;d prefer to only name a few but restrict it to 0-255:

    const enum paletteColor {
      someColor = 25,
      someOtherColor = 133
    }
    declare function libraryFunc(color: paletteColor | 0-255); //would need to use 0|1|2|...

Is it possible to restrict number to a certain range

Please help me in order to copy the object into another object using angular 2?

In angular, I used angular.copy() to copy objects to the loose reference of the old objects. But, when I used the same in angular 2 getting below error:

&gt;Error: angular is not defined. 

angular2: how to copy object into another object

I would like to udpate my application view, triggered by events from service.

One of my services injects the ChangeDetectorRef. Compilation works, but I am getting an error in the browser when the App is bootstrapped: `No provider for ChangeDetectorRef!`.

I thought I needed to add it to my AppModule, but I can&#39;t find any documentation that suggests it is in a module that I can import there. I tried adding the class itself to the import array, but that caused an error. I also got an error trying to add it to the providers array in the module. Here is a simplified version of my service:

    import {Injectable, ChangeDetectorRef } from &#39;@angular/core&#39;;
    
    @Injectable()
    export class MyService {
      private count: number = 0;
      constructor(private ref: ChangeDetectorRef){}

      increment() {
        this.count++;
        this.ref.detectChanges();
    }

And the app module:

    import { NgModule } from &#39;@angular/core&#39;;
    import { BrowserModule } from &#39;@angular/platform-browser&#39;;

    import { AppComponent } from &#39;./app.component&#39;;

    import { MyService } from &#39;./my.service&#39;;

    @NgModule({
      imports: [ BrowserModule ],
      declarations: [ AppComponent ],
      providers: [ MyService ],
      booststrap: [ AppComponent ]
    })
    export AppModule {}

**UPDATE**

&lt;strike&gt;I have since tried removing my use of ChangeDetectorRef, and I still have the same problem. I am guessing there is something wrong about how I updated my System JS config.&lt;/strike&gt;

I originally created the app with angular-cli, and was trying to update Angular on my own since they had not updated that. With the final release of Angular 2.0.0 they have updated angular-cli to use the latest version of angular. So I am going to try using their upgrade procedures and hopefully that goes better.

**Update 2**

The webpack/angular-cli update went well. I have the app building now with Angular 2.0.0 in and angular-cli 1.0.0-beta14. I still get the same error in the browser. I tried removing the _ChangeDetectorRef_ from the service, but I didn&#39;t really. I had it in two services. If I remove it from both services, then my app loads fine, and works well, except for where I was trying to use _ChangeDetectorRef_. Once I add it back in one of the files,  the browser has complains about not being able to find a provider for it.

I tried importing it in my _module_, but it is not a _module_, so the transpiler complains. I tried listing it a a _provider_ in my module, but it does not have a provide property, so the transpiler complains. similar issues if I try putting it in the _declarations_ array.

Trigger update of component view from service - No Provider for ChangeDetectorRef

Why is the .ts file extension used in Angular 2?

Why does Angular 2 use the .ts file extension?

`ng-container` is mentioned in the [official documentation][1] but I&#39;m still trying to understand how it works and what are use cases.

It is particularly mentioned in [`ngPlural`][2] and [`ngSwitch`][3] directives.

Does `&lt;ng-container&gt;` do the same thing as `&lt;template&gt;` or does it depend on whether a directive was written to use one of them?

Are

&lt;!-- language: lang-html --&gt;

    &lt;ng-container *ngPluralCase=&quot;&#39;=0&#39;&quot;&gt;there is nothing&lt;/ng-container&gt;

and

&lt;!-- language: lang-html --&gt;

    &lt;template [ngPluralCase]=&quot;&#39;=0&#39;&quot;&gt;there is nothing&lt;/template&gt;

supposed to be the same?

How do we choose one of them?

How can `&lt;ng-container&gt;` be used in a custom directive?

  [1]: https://angular.io/guide/structural-directives#ng-container
  [2]: https://angular.io/api/common/NgPlural
  [3]: https://angular.io/api/common/NgSwitch


&lt;ng-container&gt; vs &lt;template&gt;

I&#39;m currently working on a ReactJS project which uses Webpack2 and TypeScript. Everything works perfectly apart from one thing - I can&#39;t a find a way to move interfaces that I&#39;ve written myself into separate files so that they are visible to the whole application.

For prototyping purposes I initially had interfaces defined in files that use them but eventually I started adding some that were needed in multiple classes and that&#39;s when all the problems started. No matter what changes I make to my `tsconfig.json` and no matter where I put the files my IDE and Webpack both complain about not being able to find names (*&quot;Could not find name &#39;IMyInterface&#39;&quot;*). 

Here&#39;s my current `tsconfig.json` file:

```json
{
  &quot;compilerOptions&quot;: {
    &quot;baseUrl&quot;: &quot;src&quot;,
    &quot;outDir&quot;: &quot;build/dist&quot;,
    &quot;module&quot;: &quot;commonjs&quot;,
    &quot;target&quot;: &quot;es5&quot;,
    &quot;lib&quot;: [
      &quot;es6&quot;,
      &quot;dom&quot;
    ],
    &quot;typeRoots&quot;: [
      &quot;./node_modules/@types&quot;,
      &quot;./typings&quot;
    ],
    &quot;sourceMap&quot;: true,
    &quot;allowJs&quot;: true,
    &quot;jsx&quot;: &quot;react&quot;,
    &quot;moduleResolution&quot;: &quot;node&quot;,
    &quot;rootDir&quot;: &quot;src&quot;,
    &quot;forceConsistentCasingInFileNames&quot;: true,
    &quot;noImplicitReturns&quot;: true,
    &quot;noImplicitThis&quot;: true,
    &quot;noImplicitAny&quot;: false,
    &quot;strictNullChecks&quot;: true,
    &quot;suppressImplicitAnyIndexErrors&quot;: true,
    &quot;noUnusedLocals&quot;: true
  },
  &quot;exclude&quot;: [
    &quot;node_modules&quot;,
    &quot;build&quot;,
    &quot;scripts&quot;,
    &quot;acceptance-tests&quot;,
    &quot;webpack&quot;,
    &quot;jest&quot;,
    &quot;src/setupTests.ts&quot;
  ],
  &quot;types&quot;: [
    &quot;typePatches&quot;
  ]
}
```

As you can see, my `tsconfig.json` is in the root of the project directory, all source is in `./src`, I placed my custom `.d.ts` files in `./typings` and included it in `typeRoots`.

I tested it with TypeScript 2.1.6 and 2.2.0 and neither works.

One way of getting it all to work is to move my `typings` directory into `src` and then `import {IMyInterface} from &#39;typings/blah&#39;` but that doesn&#39;t feel right to me as it&#39;s not something I need to use. I want those interfaces to just be &#39;magically&#39; available throughout my application.

Here&#39;s a sample `app.d.ts` file:

```typescript
interface IAppStateProps {}
interface IAppDispatchProps {}
interface IAppProps extends IAppStateProps, IAppDispatchProps {}
```

Do I need to `export` them or maybe `declare`? I hope I don&#39;t have to wrap them in a namespace?!

## Update (October 2020)

Seeing how this question is still surprisingly popular I wanted to explain the solution in more detail.

Firstly, what could and should be confusing to people is that the interface example I gave at the end of my question actually doesn&#39;t have any `export` keywords even though I&#39;m almost certain I did have them in my files at the time of asking the question. I believe I didn&#39;t include them in the question thinking they didn&#39;t make any difference, whether they were there or not. Well, it turns out that it&#39;s not true and the `export` keyword is exactly what makes or breaks you being able to just &quot;use&quot; the interfaces versus having to explicitly `import` them.

So, the way it works in TypeScript is as follows:

If you want an interface/type that you can simply use without having to import it in the consuming module said interface must reside in a `.ts` or ideally a `.d.ts` file **without any imports or exports being present in the same file**. This is of utmost importance because as soon as you are exporting at least one thing from the same file it becomes a module and everything that is in that module must be subsequently imported by consumers.

To give you an example let&#39;s assume you want to have a type called `Dictionary` that you want to be able to use without importing. The way to declare it would be as follows:

```typescript
// types.d.ts
interface Dictionary {}
interface Foo {}
interface Bar {}
```

To use it you simply do:

```typescript
// consumer.ts
const dict: Dictionary = {};
```

However, it will no longer work if for some reason **any** of the interfaces/types in that file are exported, e.g.:

```typescript 
// types.d.ts
interface Dictionary {}
interface Foo {}
export interface Bar {}
```

It will also not work if there are imports in that file:

```typescript
// types.d.ts
import { OtherType } from &#39;other-library&#39;;

interface Dictionary {}
interface Foo extends OtherType {}
interface Bar {}
```

If that is the case the only way to be able to use the `Dictionary` type would be to also export it and then import it in the consumer:

```typescript
// types.d.ts
export interface Dictionary {}
interface Foo {}
export interface Bar {}

// consumer.ts
import { Dictionary } from &#39;./types&#39;;

const dict: Dictionary = {};
```

#### `--isolatedModules`

There is an additional quirk to keep in mind when using the `isolatedModules` modules flag in TypeScript, which, importantly, is enabled by default (and cannot be disabled) when using Create React App - `.ts` files MUST export at least one thing as otherwise you will be getting the *&quot;All files must be modules when the &#39;--isolatedModules&#39; flag is provided.&quot;* error. That means that putting the `Dictionary` interface in a `types.ts` files without the export keyword won&#39;t work. It must either be an export from a `.ts` file of be a declaration without the export in a `.d.ts` file:

```typescript
// types.d.ts
interface Dictionary {}        // works
export interface Dictionary {} // works

// types.ts
interface Dictionary {}        // doesn&#39;t work with --isolatedModules enabled
export interface Dictionary {} // works

```

N.B.  
As @dtabuenc mentions in his answer ambient modules (`.d.ts` files) are discoraged and my correction shouldn&#39;t be taken as advice. It&#39;s just an attempt at explaining how normal modules and ambient modules work in TypeScript.

Content Type	Original Author	Original Content on Stackoverflow
Question	user203687	View Question on Stackoverflow
Solution 1 - Typescript	motss	View Answer on Stackoverflow
Solution 2 - Typescript	Paleo	View Answer on Stackoverflow
Solution 3 - Typescript	Vijay Joshua Nadar	View Answer on Stackoverflow

TypeScript Compile Options: module vs target

Typescript Problem Overview

Typescript Solutions

Solution 1 - Typescript

Solution 2 - Typescript

Solution 3 - Typescript

What is the proper annotation since @SpringApplicationConfiguration, @WebIntegration, is deprecated in Spring Boot Framework?

Why does .class not invoke the static block in a Class?

Attributions