Support AMD (Asynchronous Module Definition) in require!

[pioneer]

It's worth for require! to support other module systems than RequireJS, such as AMD, as TypeScript does. Switching between CommonJS and AMD can be provided via compiler commandline options, for example. Some pieces of code that might be with require! and AMD support, using Dojo Toolkit:

Simple example:

# Livescript:
require! {
    dojo/dom
    dojo/dom-ready!
}
dom.by-id \helloworld .innerHTML = "Hello New World!"

# Javascript:
require(["dojo/dom", "dojo/domReady!"], function(dom, domReady){
  dom.byId("helloworld").innerHTML = "Hello New World!";
});

Require with parameters:

# Livescript
require! app, app/routes, {baseUrl: '', packages: [\dojo, \dijit, \dojox]}
# some code goes here

# Javascript:
require({baseUrl: "", packages: ["dojo", "dijit", "dojox"]},
    ["app", "app/routes"],
    function(app, routes) {
        // some code goes here
    }
);

or

# Livescript:
require! {
    "dojo/_base/declare"
    "dijit/_WidgetBase"
    "dijit/_TemplatedMixin"
    template: "dojo/text!./templates/SomeWidget.html"

   {
    base-url: ''
    packages: [\dojo, \dijit, \dojox,
               { name: \app, location: \app, map: {} }]
   }
}

# some code goes here

# Javascript:
require({
    baseUrl: "",
    packages: ["dojo", "dijit", "dojox",
               { name: "app", location: "app", map: {} }]
}, [
    "dojo/_base/declare",
    "dijit/_WidgetBase",
    "dijit/_TemplatedMixin",
    "dojo/text!./templates/SomeWidget.html"
], function(declare, _WidgetBase, _TemplatedMixin, template) {
    // some code goes here
});

Define:

# Livescript:
define! {
  "dojo/_base/declare"
  "dijit/_WidgetBase"
  "dijit/_TemplatedMixin"
  template: "dojo/text!./templates/SomeWidget.html"
}

export! declare [_WidgetBase, _TemplatedMixin], {
    template-string: template
    #  your custom code goes here
}

# Javascript:
define([
    "dojo/_base/declare",
    "dijit/_WidgetBase",
    "dijit/_TemplatedMixin",
    "dojo/text!./templates/SomeWidget.html"
], function(declare, _WidgetBase, _TemplatedMixin, template) {
    return declare([_WidgetBase, _TemplatedMixin], {
        templateString: template,
        // your custom code goes here
    });
});

[vendethiel]

I really think this is going too far.
Ls already supports node-specific features (export from coco, altough useful in the browser and require!) and supporting a library itself is for me a no-go.

-1

[pioneer]

According to http://requirejs.org/docs/whyamd.html#amdtoday, AMD isn't just Dojo-specific.

[vendethiel]

True. But the syntax isn't always the same - require.js AFAIK doesn't return declare(....
Plus it dors not change my point : it's library-specific.

[pioneer]

Sorry, it looks like my idea can be misunderstood. I suggested not to return declare, but just add export! keyword that should be compiled to return in case of AMD (though I think this feature is to be discussed).

[vendethiel]

Whoops

[pioneer]

It seems this commit closes satyr/coco#195, but not the current issue.

[kennknowles]

Any word on this? Some great libraries are being written in LiveScript that I would like to use in browser-based projects, which for me means AMD-based projects, but I am not sure how to proceed.

[gkz]

I think the best solution is to use something like https://github.com/substack/node-browserify

ie. write it like it's a node project, and then use a tool to turn it into something that works in the browser

[michaelficarra]

I recommend https://github.com/michaelficarra/commonjs-everywhere, it plays very nicely with LiveScript and other compile-to-JS languages.

[tiye]

It would be nice if LiveScript works with commonjs-everywhere and with SourceMap support.
Reading code compiled from LiveScript is harder than from CoffeeScript.

[mehcode]

Just to throw something else in here. We write LiveScript commonjs modules then use grunt and https://github.com/anodynos/uRequire to convert them into AMD. The setup works great.

[vendethiel]

Going to close for now. Feel free to bump if you have any idea for a good implementation that'd work without breaking anything else and without adding a lot of code