Typescript: export all functions in a namespace

Since TC39/ecma 262 the feature you probably need was merged. So now you can export the module itself like this:

// module.ts

export interface Foo{
    bar: string;
}

export function A(){
  // implementation
}

export function B(){
  // implementation
}

export * as MyModule from './module';

And then use it like a module that contains his own context:

import { MyModule } from './module';

type MyType = MyModule.Foo;

MyModule.A();
MyModule.B();

It seems to me it depends on TS version and Webpack if you are using it.

• Webpack 5 and TS v4.1.2 works good.
• Vite js - works good too. Did not check tree-shaking yet, but looks it should work fine.

UPDATE:

In the case above everything is good, however, the aggregating module exports itself and if you try to check this with madge --circular [directory] it will show that there is a circular dependency.

So, in order to avoid this we can follow Mmdn web docs and add intermediate file like barrel.ts

├── src
│   ├── main.js
│   ├── myModule
│   │   ├── functionA.js
│   │   ├── functionB.js
│   │   ├── barrel.js
│   │   ├── index.js

// -- myModule/functionA.js --
export function A(){
  return 'this is module A' 
}
  
// -- myModule/functionB.js --
export function B(){
  return 'this is module B' 
}

// -- myModule/barrel.js --
export * from "./functionA.js";
export * from "./functionB.js";

// -- myModule/index.js
export * as MyModule from './barrel.js';

// -- main.js --
import { MyModule } from "./myModule";
console.log(MyModule.A); // this is module A
console.log(MyModule.B); // this is module B

Caveats aside, depending on your project, one can accomplish this export utilizing a layer of indirection.

./utils/internal/utils.ts

export function utilOne(){}
export function utilTwo(){}

./utils/utils.ts

import * as utils from './internal/utils';
export utils;

./test.ts

import { utils } from './utils/utils';

utils.utilOne();

Caveats:

As noted, this is a questionable practice, and the desire to namespace may be indicative of a code-smell. It may also negatively impact the tree-shakability of your library and resulting projects.

Note: This structure is inspired by RxJS.

Use an actual namespace:

namespace Utils {
  export function utilOne(){}
  export function utilTwo(){}
}

export default Utils;

You can then import it as:

import utils from "./Utils";
// ...
utils.utilOne();