frostney / udefine

[Deprecated] Define a module as an AMD module and handle it as if it's an UMD module

udefine

This library is deprecated. For alternatives, please use a bundler like Webpack or browserify.

Define an UMD module like an AMD module and use it (almost) anywhere

This repository is deprecated and will not be updated any more. While it may have been a valid option three years ago (and we used it in production), you may want to use Webpack or rollup today. If you wish to maintain it further, contact me and I'll happily transfer the repository over to your account.

Why would you need it?

• You are writing that needs to available in Node.js, AMD and/or as global objects
• You need some kind of basic dependency resolution for your modules

Features

• Provides a handy function wrapper for UMD modules
• Same fuction signature as AMD modules
• No need for boilerplate definitions
• Less than 0.6 kB minified and gzipped (might increase a bit, but I'll keep it under 1kb)

Usage

(function(root) {
  // This definition only needs to be done once, not per module
  root.udefine.globals.jquery = this.jQuery;
})(this);

udefine('mymodule', ['jquery'], function($) {
  $.fn.myModule = function() { /* ... */ };
});

If an AMD module loader like RequireJS has been integrated and configured, it will resolve through the AMD loader.

Alright, that's really great for jQuery modules. But what if you want to bind a module the global namespace if there is no AMD or CommonJS? Just define where the module should be injected to and udefine will do the rest:

udefine.configure(function(root) {
  udefine.inject['myothermodule'] = {
    root: root,
    name: 'myOtherModule'
  };  
});

udefine('myothermodule', function() {
  return {
    a: function() { return 5; },
    b: 2
  };
});

// root.myOtherModule now is an object with the properties a and b.
// (In a non-AMD or non-CommonJS environment.)

CommonJS pitfalls
If using module.exports for exporting your modules on CommonJS, it does not export correctly on udefine 0.8.x. (Exporting with exports using the injection API works though.) To counteract this behavior, you would need a bit of boilerplate code:

(function() {
  udefine.configure(function(root) {
    this.globals(function() {
      udefine.inject['mycoolmodule'] = {
        root: root,
        name: 'myCoolModule'
      };  
    });
  });


  udefine('mycoolmodule', function() {
    return {
      a: function() { return 5; },
      b: 2
    };
  });

  if (udefine.env.commonjs) {
    udefine.require('mycoolmodule', function(myCoolModule) {
      module.exports = myCoolModule;
    });
  }

}).call(this);

// root.myOtherModule now is an object with the properties a and b.
// (In a non-AMD or non-CommonJS environment.)

udefine is not and does not replace a module loader. It is primarily intended for developers who want their library to target AMD modules, CommonJS modules and/or the classic way of binding object to the global window object.

For more examples, take a look at the examples folder.

License
This is public domain. See UNLICENSE.md for more information.

udefine's Issues

Don't mix platform and transport

udefine.env property currently mixes the platform (Node.js, browser) with the transport system (CommonJS, AMD, global). Separate them.

Support CommonJS styled things in the browser

This would be amazing. One module to conquer 'em all. 🍰

Failsafe for older browsers

Some browsers (IE 9) seem to be quite picky when you leave off the dependency parameter (in conjunction with RequireJS). May be implement a failsafe, from

define.apply this,arguments

to

define.call this, name, deps, factory

Allow module wrapper

Allow a better integration for Node.js modules that export its data through module.exports.

Don't put namespaced modules on the window object

Yeah, it's evil, I know.

Allow weak dependencies

Allow for dependencies which don't necessarily need to be resolved

define('mymodule', ['weak:jquery'], function($) {
  // If jquery symbol is available, $ is the jQuery, else it's undefined without throwing an error
});

Modules on the global object don't resolve themselves correctly

When binding to the global object: While udefine does for work for single module libraries or modules, it doesn't resolve modules if they are not in the correct order