Passer des options à ES6 module importations

Concept

Voici ma solution à l'aide ES6

Très bien en ligne avec @Bergi la réponse, c'est le "modèle" - je utiliser lors de la création d'importations qui ont besoin de paramètres passés pour class déclarations. Il est utilisé sur une isomorphe cadre que je suis en train d'écrire, il en sera de travailler avec un transpiler dans le navigateur et dans node.js (j'utilise Babel avec 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();

Ci-dessus seront de sortie foo dans une console

MODIFIER

L'Exemple Du Monde Réel

Pour un exemple concret, je suis en utilisant ce passer dans un espace de noms pour accéder à d'autres classes et les instances à l'intérieur d'un cadre. Parce que nous sommes tout simplement la création d'une fonction et de passer l'objet en tant qu'argument, nous pouvons l'utiliser avec notre déclaration de classe likeso:

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

L'importation est un peu plus compliqué et automagical dans mon cas, étant donné que c'est un framework, mais essentiellement, c'est ce qui se passe:

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

J'espère que cela aide!

Je crois que vous pouvez utiliser es6 module de chargeurs.
http://babeljs.io/docs/learn-es6/

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

J'ai atterri sur ce fil à la recherche pour un peu similaire et souhaitez proposer un mieux, à mon humble avis, au moins dans certains cas, la solution (ou de comprendre pourquoi il n'est pas si).

Cas d'utilisation

J'ai un module, c'est l'exécution de certains instanciation logique immédiatement après le chargement. Je ne pas appelle init logique à l'extérieur du module (qui est le même que l'appel de new SomeClass(p1, p2) ou new ((p1, p2) => class SomeClass { ... p1 ... p2 ... }), et autres).

Je n'aime que ce init logique sera exécuté une fois, une sorte de singulier instanciation de flux, mais une fois par certains paramétrées contexte.

Exemple

service.js a à sa base très étendue:

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

Module n':

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

Module B n':

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

So far So good: le service est disponible pour les deux modules, mais a été initialisé qu'une seule fois.

Problème

Comment le faire fonctionner comme une autre instance et l'initialisation de nouveau dans un autre contexte, par exemple dans le Module C?

Solution?

C'est ce que je suis en train de réfléchir: utiliser les paramètres de requête. Dans le service que nous aimerions ajouter les éléments suivants:

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

Module C ferait:

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

le module sera ré-importé, c'est init de base de la logique, et nous allons voir dans la console:

initialized in context special