How to export Class and Type

[musicode]

src/
  - foo.ts
  - index.ts

foo.ts

type Bar = {

}
export class Foo {
  bar: Bar
}

index.ts

import { Foo } from './foo'

export class Index {
  person: Foo
}

output

export declare type Bar = {};
declare class Foo {
	bar: Bar;
}
export declare class Index {
	person: Foo;
}

export {};

There are two issues:

1. Foo is not exported.
2. Bar is exported.

why? I am very confused.

[timocov]

Hi,

Foo is not exported.

Foo is a class. Classes, functions and variables affect JS code, so in that case you didn't export that class from your JS code (from entry-point), why declaration file should export it? You need to export that class explicitly from entry module.

Bar is exported.

In opposite to classes/functions/variables types/interfaces doesn't affect JS code and might be exported without any problem or affecting something.

[musicode]

I want to control the accessibility, in my example, I hope Bar type is not exported, because I will never use it outside. but Foo class maybe used outside.

What can I do for that?

[timocov]

but Foo class maybe used outside.

In this case, as I said, you need to export it from your entry-point explicitly.

Just add export { Foo }; to index.ts.

I want to control the accessibility, in my example, I hope Bar type is not exported, because I will never use it outside

You export class Foo with field of that type (Bar), you need to export that type so user of your declarations can define variable with that type.
Currently all nodes, which doesn't affect JS code exported by default because they are used in your declarations and can be used by user. If we export classes/functions/variables (in case you don't have that export), we'll get incorrect declaration, so user can import class/variable/function and it will be compiled, but you'll get run-time ReferenceError, because JS code doesn't have that exports.

[musicode]

In this case, as I said, you need to export it from your entry-point explicitly.
Just add export { Foo }; to index.ts.

I agree with you, but how about a default export in index.ts:

import { Foo } from './foo'

export default class Index {
  foo: Foo
}
export {
  Foo
}

output

exports.Foo = Foo;
exports.default = Index;
Object.defineProperty(exports, '__esModule', { value: true });

But I only need Index in Javascript.

[timocov]

Can you please show what do you want to achieve (provide both JS and TS declaration)?

[musicode]

foo.ts

// Bar is a internal type and hope not be exported
type Bar = { }

// Foo is a helper class and maybe used by outside
export class Foo {
  bar: Bar
}

main.ts

import { Foo } from './foo'
// This is the main class for the library
export default class Main {
  Foo: Foo
}

run tsc, the .d.ts files is emited.

foo.d.ts

declare type Bar = {};
export declare class Foo {
    bar: Bar;
}
export {};

main.d.ts

import { Foo } from './foo';
export default class Main {
    Foo: Foo;
}

run dts-bundle-generator, the single .d.ts is emited.

export declare type Bar = {};
declare class Foo {
	bar: Bar;
}
export default class Main {
	Foo: Foo;
}
export {};

I want to use the Main class and Foo class like below.

import Main from 'main'
new Main()
new Main.Foo()

// how to import Foo type?
function doSomething(a: Foo) {

}

I just write ts code, the .d.ts files is emited by tsc, not by myself.

so, how can I achieve?

[timocov]

// how to import Foo type?

function doSomething(a: Main['Foo']) {} should work.

According your case: if want to export type, I believe you need to export interface or something to be able to use it. If your d.ts will export class Foo, then somebody case import it in the way:

import { Foo } from 'main';
new Foo(); // ReferenceError here, because there is no Foo.

[musicode]

function doSomething(a: Main['Foo']) {} should work.

I think Main['Foo'] is tedious, Foo is more cool.

foo.d.ts export Foo class, but the single .d.ts emited by dts-bundle-generator does't export it.

why?

[musicode]

I find exporting .d.ts files is the hardest part of typescript.

I really don't know how to export the type I want.

[timocov]

foo.d.ts export Foo class, but the single .d.ts emited by dts-bundle-generator does't export it.
why?

Because it's foo.ts, not index.ts?

I really don't know how to export the type I want.

You need to understand, that name Foo isn't just type of class Foo, it's class constructor too. Class constructor can be called and used in the code (not only in types).

You want to export type of class Foo (which cannot be called and used in the code).

I think Main['Foo'] is tedious, Foo is more cool.

You can try to export that type with name Foo from your index.ts file (but I believe you don't need to have importing Foo to avoid names confusing).

[musicode]

@timocov Thank you.