Import/export false positive between namespace and variable

[unional]

export namespace testType { ... }

export const testType = { ... }

Results in: error Multiple exports of name 'testType' import/export

Here is an example: https://github.com/unional/type-plus/blob/main/type-plus/ts/testing/test_type.ts

[ljharb]

That still seems like a problem - which one does import { testType } point to?

I realize that import type { testType } is unambiguous, but that’s not the problem case.

[unional]

Namespace by itself does not produce a value. So there is not conflict and should work together.

Types, values, and namespaces are 3 different structures and they can co-exist:

https://www.typescriptlang.org/docs/handbook/declaration-files/deep-dive.html

[ljharb]

right - but import can import either a type or a value, so which one would it be importing in this case?

[ljharb]

I do see that the docs explicitly say you can export a type and a value with the same name, so that's something we should technically allow, despite it seeming like a horrifically bad pattern for readability and clarity.

[unional]

but import can import either a type or a value

It's actually 3 (technically 4):

• type
• value
• namespace (TS namespace or module namespace object)

It's actually a pretty good way to organize the code IMO.

So that instead of:

export type FooParam1 = {}
export type FooParam2 = {}
export type FooResult = { complex1: FooComplex, complex2: FooComplex2 }
export type FooComplex1 = {}
export type FooComplex2 = {}

export function foo(a: FooParam1, b: FooParam2): FooResult { ... }

You can do it like:

export namespace foo {
  export type Param1 = {}
  export type Param2 = {}
  export type Result = { complex1: Complex1, complex2: Complex2 }
  export type Complex1 = {}
  export type Complex2 = {}
}

export function foo(a: foo.Param1, b: foo.Param2): foo.Result { ... }

So that during consumption, you won't load of all those extra types:

import { foo, FooParams1, ... } from './foo.js'

export function wrapper(a: FooParam1) {
  return foo(a)
}

// vs
import { foo } from './foo.js'

export function wrapper(a: foo.Param1) {
  return foo(a)
}

Think of it as a way to "tuck" the extra types under the object/function.