es6 - javascript modules

compatible con CommonJS y AMD

Question

¿Existe alguna manera de crear una micro biblioteca de JavaScript (una biblioteca que no tenga dependencias) que admita todos los formatos de módulos siguientes?

• Definición de módulo asíncrono
• CommonJS
• exponer las exportaciones de la biblioteca como un objeto de espacio de nombres global (sin cargador)

Answer 1

Aquí hay una lista de varios formatos de módulos compatibles .

Sospecho que lo que estás buscando es lo que llaman " commonjsStrict.js "

Answer 2

Esto se basa en la respuesta de Nijikokun. Dado que RequireJS desalienta el uso de nombres de módulos explícitos, esto se ha omitido en esta versión. El segundo argumento para el cargador describe las dependencias. Pase [] si no necesita cargar ninguno.

var loader = function(name, dependencies, definition) {
  if (typeof module === ''object'' && module && module.exports) {
      dependencies = dependencies.map(require);
      module.exports = definition.apply(context, dependencies);
  } else if (typeof require === ''function'') {
    define(dependencies, definition);
  } else {
    window[name] = definition();
  }
};

loader(''app'', [''jquery'', ''moment''], function($, moment) {
   // do your thing
   return something;
}

Answer 3

He resuelto este problema exacto y logré soportar fácilmente:

• Dojo AMD (haciendo referencia a las especificaciones RequireJS)
• jQuery (en $ / jQuery.fn. [your_library_here])
• node.js usando vanilla require (''path_to.js'')
• Ventana del navegador. [Your_library_here]

Está usando una combinación de inyección de dependencia e IIFE para hacer el trabajo.

Vea abajo:

/*global jQuery:false, window:false */
// # A method of loading a basic library in AMD, Node.JS require(), jQuery and Javascript''s plain old window namespace.
(function(exporterFunction) {
exporterFunction(''cll'',
    function(a,b) {
        return a+b;
    }
);
})(
    (function() { // Gets an exportFunction to normalize Node / Dojo / jQuery / window.*

        if ((typeof module != ''undefined'') && (module.exports)) { // Node Module
            return function(library_name,what_was_exported) {
                module.exports = what_was_exported;
                return;
            };
        }
        if (typeof define != ''undefined'' && define.hasOwnProperty(''amd'') && define.amd) { // Dojo AMD
            return function(library_name,what_was_exported) {
                define(function() {
                    return what_was_exported;
                });
            };
        }
        if (typeof jQuery === ''function'') { // jQuery Plugin
            return function(library_name,source) {
                jQuery.fn[library_name] = source;
                return;
            };
        }
        if (typeof window != ''undefined'') { // Fall down to attaching to window...
            return function(library_name,what_was_exported) {
                window[library_name] = what_was_exported;
            };
        }

    })(),
    (function() { 
        // ## Other Parameters Here
        // You could add parameters to the wrapping function, to include extra 
        // functionalilty which is dependant upon the environment... See 
        // https://github.com/forbesmyester/me_map_reduce for ideas.
        return ''this_could_be_more_arguments_to_the_main_function''; 
    })()
);

Public Gist disponible en https://gist.github.com/forbesmyester/5293746

Answer 4

Sí, y le debo esta respuesta a ded y sus impresionantes módulos:

(function(name, definition) {
    if (typeof module != ''undefined'') module.exports = definition();
    else if (typeof define == ''function'' && typeof define.amd == ''object'') define(definition);
    else this[name] = definition();
}(''mod'', function() {
    //This is the code you would normally have inside define() or add to module.exports
    return {
        sayHi: function(name) {
            console.log(''Hi '' + name + ''!'');
        }
    };
}));

Esto puede ser usado:

1. en AMD (por ejemplo, con requireJS):

   requirejs([''mod''], function(mod) {
       mod.sayHi(''Marc'');
   });

2. en commonJS (por ejemplo, nodeJS):

   var mod = require(''./mod'');
   mod.sayHi(''Marc'');

3. globalmente (por ejemplo, en HTML):

   <script src="mod.js"></script>
   <script>mod.sayHi(''Marc'');</script>

Este método necesita más publicidad, si jQuery y co. comenzó a usarlo, ¡la vida sería mucho más fácil!

Answer 5

Solo para actualizar un poco sobre esta respuesta con respecto a @marc también doy crédito a ded y lo he actualizado un poco para estar con las últimas actualizaciones:

(function (name, definition, context, dependencies) {
  if (typeof context[''module''] !== ''undefined'' && context[''module''][''exports'']) { if (dependencies && context[''require'']) { for (var i = 0; i < dependencies.length; i++) context[dependencies[i]] = context[''require''](dependencies[i]); } context[''module''][''exports''] = definition.apply(context); }
  else if (typeof context[''define''] !== ''undefined'' && context[''define''] === ''function'' && context[''define''][''amd'']) { define(name, (dependencies || []), definition); }
  else { context[name] = definition(); }
})(''events'', function () {
  // Insert code here
  return {
    sayHi: function(name) {
      console.log(''Hi '' + name + ''!'');
    }
  };
}, (this || {}));

El objeto al final es una referencia al alcance padre o al actual, digamos que tienes un paquete que estás escribiendo y esto es solo una parte del pastel, bueno, ese contexto podría ser un objeto espaciado entre nombres y esto es solo una rebanada de ese pastel.

Además, si desea tener dependencias, hay un parámetro opcional al final de su alcance que admite una matriz, en este caso el parámetro de definición puede utilizar cada dependencia como argumento. Además, las dependencias enumeradas en una matriz se requerirán dentro de la plataforma node-js para su comodidad.

Consulte: https://gist.github.com/Nijikokun/5192472 para obtener un ejemplo real.

Answer 6

uRequire , Universal Module & Resource Converter es la herramienta que hace exactamente eso.

• Principalmente convierte AMD y CommonJS en script UMD / AMD / CommonJS / Plain (no se requiere cargador AMD) .

• Permite la exportación declarativa de módulos, con un noConflict() .

• Puede manipular módulos (inyectar / reemplazar / eliminar dependencias O código) a medida que los construye.

• ¡Convierte de coffeescript, coco, Livescript, icedCoffeescript y puede agregar sus propias conversiones en líneas únicas!