Com o ES6, posso importar várias exportações de um arquivo como este:

import {ThingA, ThingB, ThingC} from 'lib/things';

No entanto, gosto da organização de ter um módulo por arquivo. Acabo com importações como esta:

import ThingA from 'lib/things/ThingA';
import ThingB from 'lib/things/ThingB';
import ThingC from 'lib/things/ThingC';

Eu adoraria poder fazer isso:

import {ThingA, ThingB, ThingC} from 'lib/things/*';

ou algo semelhante, com a convenção entendida de que cada arquivo contém uma exportação padrão e que cada módulo tem o mesmo nome que seu arquivo.

Isso é possível?

Eu não acho que isso seja possível, mas após a resolução dos nomes dos módulos depende dos carregadores de módulos, pode haver uma implementação do carregador que suporte isso.

Até então, você poderia usar um "arquivo de módulo" intermediário lib/things/index.jsque continha apenas

export * from 'ThingA';
export * from 'ThingB';
export * from 'ThingC';

e isso permitiria que você fizesse

import {ThingA, ThingB, ThingC} from 'lib/things';

Apenas uma variação do tema já fornecida na resposta, mas e quanto a isso:

Em um Thing,

export default function ThingA () {}

In things/index.js,

export {default as ThingA} from './ThingA'
export {default as ThingB} from './ThingB'
export {default as ThingC} from './ThingC'

Então, para consumir todas as coisas em outro lugar,

import * as things from './things'
things.ThingA()

Ou para consumir apenas algumas coisas,

import {ThingA,ThingB} from './things'

As respostas atuais sugerem uma solução alternativa, mas me incomodou por que isso não existe, então eu criei um babelplugin que faz isso.

Instale-o usando:

npm i --save-dev babel-plugin-wildcard

adicione-o ao seu .babelrccom:

{
    "plugins": ["wildcard"]
}

consulte o repositório para obter informações detalhadas sobre a instalação

Isso permite que você faça isso:

import * as Things from './lib/things';

// Do whatever you want with these :D
Things.ThingA;
Things.ThingB;
Things.ThingC;

novamente, o repositório contém mais informações sobre o que exatamente ele faz, mas evita a criação de index.jsarquivos e também acontece no tempo de compilação para evitar fazer readdirs em tempo de execução.

Também com uma versão mais recente, você pode fazer exatamente como no seu exemplo:

 import { ThingsA, ThingsB, ThingsC } from './lib/things/*';

funciona da mesma maneira que acima.

Great gugly muglys! Isso foi mais difícil do que precisava ser.

Exportar um padrão simples

Esta é uma grande oportunidade de usar propagação ( ...em { ...Matters, ...Contacts }abaixo:

// imports/collections/Matters.js
export default {           // default export
  hello: 'World',
  something: 'important',
};

// imports/collections/Contacts.js
export default {           // default export
  hello: 'Moon',
  email: '[email protected]',
};

// imports/collections/index.js
import Matters from './Matters';      // import default export as var 'Matters'
import Contacts from './Contacts';

export default {  // default export
  ...Matters,     // spread Matters, overwriting previous properties
  ...Contacts,    // spread Contacts, overwriting previosu properties
};

// imports/test.js
import collections from './collections';  // import default export as 'collections'

console.log(collections);

Em seguida, para executar o código compilado babel na linha de comando (na raiz do projeto /):

$ npm install --save-dev @babel/core @babel/cli @babel/preset-env @babel/node 
(trimmed)

$ npx babel-node --presets @babel/preset-env imports/test.js 
{ hello: 'Moon',
  something: 'important',
  email: '[email protected]' }

Exportar um padrão semelhante a uma árvore

Se você preferir não substituir as propriedades, altere:

// imports/collections/index.js
import Matters from './Matters';     // import default as 'Matters'
import Contacts from './Contacts';

export default {   // export default
  Matters,
  Contacts,
};

E a saída será:

$ npx babel-node --presets @babel/preset-env imports/test.js
{ Matters: { hello: 'World', something: 'important' },
  Contacts: { hello: 'Moon', email: '[email protected]' } }

Exportar várias exportações nomeadas sem padrão

Se você é dedicado ao DRY , a sintaxe das importações também muda:

// imports/collections/index.js

// export default as named export 'Matters'
export { default as Matters } from './Matters';  
export { default as Contacts } from './Contacts'; 

Isso cria 2 exportações nomeadas sem exportação padrão. Então mude:

// imports/test.js
import { Matters, Contacts } from './collections';

console.log(Matters, Contacts);

E a saída:

$ npx babel-node --presets @babel/preset-env imports/test.js
{ hello: 'World', something: 'important' } { hello: 'Moon', email: '[email protected]' }

Importar todas as exportações nomeadas

// imports/collections/index.js

// export default as named export 'Matters'
export { default as Matters } from './Matters';
export { default as Contacts } from './Contacts';

// imports/test.js

// Import all named exports as 'collections'
import * as collections from './collections';

console.log(collections);  // interesting output
console.log(collections.Matters, collections.Contacts);

Observe a desestruturação import { Matters, Contacts } from './collections'; no exemplo anterior.

$ npx babel-node --presets @babel/preset-env imports/test.js
{ Matters: [Getter], Contacts: [Getter] }
{ hello: 'World', something: 'important' } { hello: 'Moon', email: '[email protected]' }

Na prática

Dados esses arquivos de origem:

/myLib/thingA.js
/myLib/thingB.js
/myLib/thingC.js

Criar um /myLib/index.jspara agrupar todos os arquivos anula o propósito de importação / exportação. Seria mais fácil tornar tudo global em primeiro lugar do que tornar tudo global via importação / exportação via "arquivos de wrapper" index.js.

Se você deseja um arquivo específico, import thingA from './myLib/thingA';em seus próprios projetos.

Criar um "arquivo wrapper" com exportações para o módulo só faz sentido se você estiver empacotando para npm ou em um projeto de várias equipes com vários anos.

Chegou tão longe? Veja os documentos para mais detalhes.

Além disso, sim, para o Stackoverflow finalmente suportando três `s como marcação de cerca de código.

Você pode usar async import ():

import fs = require('fs');

e depois:

fs.readdir('./someDir', (err, files) => {
 files.forEach(file => {
  const module = import('./' + file).then(m =>
    m.callSomeMethod();
  );
  // or const module = await import('file')
  });
});

Semelhante à pergunta aceita, mas permite escalar sem a necessidade de adicionar um novo módulo ao arquivo de índice cada vez que você cria um:

./modules/moduleA.js

export const example = 'example';
export const anotherExample = 'anotherExample';

./modules/index.js

// require all modules on the path and with the pattern defined
const req = require.context('./', true, /.js$/);

const modules = req.keys().map(req);

// export all modules
module.exports = modules;

./example.js

import { example, anotherExample } from './modules'

Eu os usei algumas vezes (em particular para criar objetos maciços que dividem os dados em muitos arquivos (por exemplo, nós AST)). Para construí-los, criei um pequeno script (que acabei de adicionar ao npm para que todos os outros pode usá-lo).

Uso (atualmente você precisará usar o babel para usar o arquivo de exportação):

$ npm install -g folder-module
$ folder-module my-cool-module/

Gera um arquivo contendo:

export {default as foo} from "./module/foo.js"
export {default as default} from "./module/default.js"
export {default as bar} from "./module/bar.js"
...etc

Então você pode apenas consumir o arquivo:

import * as myCoolModule from "my-cool-module.js"
myCoolModule.foo()

Apenas uma outra abordagem para a resposta de @ Bergi

// lib/things/index.js
import ThingA from './ThingA';
import ThingB from './ThingB';
import ThingC from './ThingC';

export default {
 ThingA,
 ThingB,
 ThingC
}

Usos

import {ThingA, ThingB, ThingC} from './lib/things';

Você também pode usar o exigir:

const moduleHolder = []

function loadModules(path) {
  let stat = fs.lstatSync(path)
  if (stat.isDirectory()) {
    // we have a directory: do a tree walk
    const files = fs.readdirSync(path)
    let f,
      l = files.length
    for (var i = 0; i < l; i++) {
      f = pathModule.join(path, files[i])
      loadModules(f)
    }
  } else {
    // we have a file: load it
    var controller = require(path)
    moduleHolder.push(controller)
  }
}

Em seguida, use o moduleHolder com controladores carregados dinamicamente:

  loadModules(DIR) 
  for (const controller of moduleHolder) {
    controller(app, db)
  }

Não é exatamente isso que você pediu, mas, com esse método, eu posso iterar componentsListnos meus outros arquivos e usar funções como as componentsList.map(...)que eu acho bastante úteis!

import StepOne from './StepOne';
import StepTwo from './StepTwo';
import StepThree from './StepThree';
import StepFour from './StepFour';
import StepFive from './StepFive';
import StepSix from './StepSix';
import StepSeven from './StepSeven';
import StepEight from './StepEight';

const componentsList= () => [
  { component: StepOne(), key: 'step1' },
  { component: StepTwo(), key: 'step2' },
  { component: StepThree(), key: 'step3' },
  { component: StepFour(), key: 'step4' },
  { component: StepFive(), key: 'step5' },
  { component: StepSix(), key: 'step6' },
  { component: StepSeven(), key: 'step7' },
  { component: StepEight(), key: 'step8' }
];

export default componentsList;

Se você estiver usando o webpack. Isso importa arquivos automaticamente e exporta como API namespace da .

Portanto, não é necessário atualizar a cada adição de arquivo.

import camelCase from "lodash-es";
const requireModule = require.context("./", false, /\.js$/); // 
const api = {};

requireModule.keys().forEach(fileName => {
  if (fileName === "./index.js") return;
  const moduleName = camelCase(fileName.replace(/(\.\/|\.js)/g, ""));
  api[moduleName] = {
    ...requireModule(fileName).default
  };
});

export default api;

Para usuários do Typecript;

import { camelCase } from "lodash-es"
const requireModule = require.context("./folderName", false, /\.ts$/)

interface LooseObject {
  [key: string]: any
}

const api: LooseObject = {}

requireModule.keys().forEach(fileName => {
  if (fileName === "./index.ts") return
  const moduleName = camelCase(fileName.replace(/(\.\/|\.ts)/g, ""))
  api[moduleName] = {
    ...requireModule(fileName).default,
  }
})

export default api

Consegui tirar da abordagem do usuário atilkan e modificá-la um pouco:

Para usuários do Typecript;

require.context('@/folder/with/modules', false, /\.ts$/).keys().forEach((fileName => {
    import('@/folder/with/modules' + fileName).then((mod) => {
            (window as any)[fileName] = mod[fileName];
            const module = new (window as any)[fileName]();

            // use module
});

}));

se você não exportar o padrão em A, B, C, mas apenas exportar {}, é possível fazer isso

// things/A.js
export function A() {}

// things/B.js
export function B() {}

// things/C.js
export function C() {}

// foo.js
import * as Foo from ./thing
Foo.A()
Foo.B()
Foo.C()