É possível passar opções para importações do ES6?

Como você traduz isso:

var x = require('module')(someoptions);

para ES6?

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

Portanto, 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 monádicas , poderá fazer algo como

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

Com o novo importoperador , 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 estática.

Conceito

Aqui está minha solução usando 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 classdeclarações. Isso é usado em uma estrutura isomórfica que estou escrevendo, portanto, funcionará com um transpiler no navegador e no node.js (eu uso Babelcom 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á exibido fooem um console

EDITAR

Exemplo do mundo real

Para um exemplo do mundo real, estou usando isso para passar em um espaço para nome para acessar outras classes e instâncias em uma estrutura. Como estamos simplesmente criando uma função e passando o objeto como argumento, podemos usá-la 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, automagicalno meu caso, dado que é uma estrutura inteira, mas essencialmente é isso que está acontecendo:

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

Eu espero que isso ajude!

Com base na resposta da @ Bergi para usar o módulo de depuração usando es6, seria o seguinte

// original
var debug = require('debug')('http');

// ES6
import * as Debug from 'debug';
const debug = Debug('http');

// Use in your code as normal
debug('Hello World!');

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

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

Você só precisa adicionar essas 2 linhas.

import xModule from 'module';
const x = xModule('someOptions');

Cheguei a esse segmento procurando algo semelhante e gostaria de propor uma espécie de solução, pelo menos em alguns casos (mas veja Observação abaixo).

Caso de uso

Eu tenho um módulo, que está executando alguma lógica de instanciação imediatamente após o carregamento. Eu não gosto de chamar essa lógica init fora do módulo (que é o mesmo que call new SomeClass(p1, p2)or new ((p1, p2) => class SomeClass { ... p1 ... p2 ... })and similar).

Eu gosto que essa lógica de inicialização seja executada uma vez, como um fluxo de instanciação singular, mas uma vez por algum contexto parametrizado específico.

Exemplo

service.js tem em seu escopo muito básico:

let context = null;                  // meanwhile i'm just leaving this as is
console.log('initialized in context ' + (context ? context : 'root'));

O módulo A faz:

import * as S from 'service.js';     // console has now "initialized in context root"

O módulo B faz:

import * as S from 'service.js';     // console stays unchanged! module's script runs only once

Até aí tudo bem: o serviço está disponível para os dois módulos, mas foi inicializado apenas uma vez.

Problema

Como fazê-lo funcionar como outra instância e se iniciar novamente em outro contexto, digamos no Módulo C?

Solução?

Isto é o que estou pensando: use parâmetros de consulta. No serviço, adicionamos o seguinte:

let context = new URL(import.meta.url).searchParams.get('context');

O módulo C faria:

import * as S from 'service.js?context=special';

o módulo será reimportado, sua lógica básica de inicialização será executada e veremos no console:

initialized in context special

Observação: eu mesmo aconselho a não praticar muito essa abordagem, mas a deixo como último recurso. Por quê? O módulo importado mais de uma vez é mais uma exceção do que uma regra, portanto, é um comportamento um tanto inesperado e, como tal, pode confundir um consumidor ou até quebrar seus próprios paradigmas 'singleton', se houver.

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

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

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

Na linha acima, uma sequência é passada para o módulo que é importado, para construção. Veja como você faria o mesmo no ES6

import {depurar como depuração} de 'debug' const debug = Debug ('http');

Espero que isto seja útil a alguém.