Conceito

Aqui está a minha solução usando o ES6

Muito em linha com a resposta do @Bergi, este é o "modelo" que eu uso ao criar importações que precisam de parâmetros passados ​​para declarações de class . Isso é usado em uma estrutura isomórfica que estou escrevendo, portanto, funcionará com um transpilador no navegador e no node.js (eu uso o Babel com o Webpack ):

./MyClass.js

export default (Param1, Param2) => class MyClass {
    constructor(){
        console.log( Param1 );
    }
}

./main.js

import MyClassFactory from './MyClass.js';

let MyClass = MyClassFactory('foo', 'bar');

let myInstance = new MyClass();

O acima será gerado foo em um console

EDITAR

Exemplo do mundo real

Para um exemplo do mundo real, estou usando isso para passar em um namespace para acessar outras classes e instâncias dentro de uma estrutura. Como estamos simplesmente criando uma função e passando o objeto como um argumento, podemos usá-lo com nossa declaração de classe likeso:

export default (UIFramework) => class MyView extends UIFramework.Type.View {
    getModels() {
        // ...
        UIFramework.Models.getModelsForView( this._models );
        // ...
    }
}

A importação é um pouco mais complicada e automagical no meu caso, dado que é um framework inteiro, mas essencialmente é isso que está acontecendo:

// ...
getView( viewName ){
    //...
    const ViewFactory = require(viewFileLoc);
    const View = ViewFactory(this);
    return new View();
}
// ...

Eu espero que isso ajude!

Aqui está minha opinião sobre esta questão usando o módulo de depuração como um exemplo;

Na página npm deste módulo, você tem isto:

var debug = require ('debug') ('http')

Na linha acima, uma string é passada para o módulo que é importado para construir. Veja como você faria o mesmo no ES6

import {debug como Debug} from 'debug' const debug = Depurar ('http');

Espero que isto seja útil a alguém.

Eu acredito que você pode usar os carregadores de módulos es6. http://babeljs.io/docs/learn-es6/

System.import("lib/math").then(function(m) {
  m(youroptionshere);
});

Não há como fazer isso com uma única declaração de import , ela não permite invocações.

Então você não chamaria isso diretamente, mas basicamente você pode fazer exatamente o mesmo que o commonjs faz com as exportações padrão:

// module.js
export default function(options) {
    return {
        // actual module
    }
}

// main.js
import m from 'module';
var x = m(someoptions);

Como alternativa, se você usar um carregador de módulo que suporte promessas monadic , poderá fazer algo como

System.import('module').ap(someoptions).then(function(x) {
    …
});

Com o novo 2ality.com/2017/01/import-operator.html ele pode se tornar

const promise = import('module').then(m => m(someoptions));

ou

const x = (await import('module'))(someoptions)

no entanto, você provavelmente não deseja uma importação dinâmica, mas uma estática.