Adding plugins

Author: Pete Romano

async.js

@@ -0,0 +1,42 @@
+/** @license
+ * RequireJS plugin for async dependency load like JSONP and Google Maps
+ * Author: Miller Medeiros
+ * Version: 0.1.1 (2011/11/17)
+ * Released under the MIT license
+ */
+define(function(){
+
+    var DEFAULT_PARAM_NAME = 'callback',
+        _uid = 0;
+
+    function injectScript(src){
+        var s, t;
+        s = document.createElement('script'); s.type = 'text/javascript'; s.async = true; s.src = src;
+        t = document.getElementsByTagName('script')[0]; t.parentNode.insertBefore(s,t);
+    }
+
+    function formatUrl(name, id){
+        var paramRegex = /!(.+)/,
+            url = name.replace(paramRegex, ''),
+            param = (paramRegex.test(name))? name.replace(/.+!/, '') : DEFAULT_PARAM_NAME;
+        url += (url.indexOf('?') < 0)? '?' : '&';
+        return url + param +'='+ id;
+    }
+
+    function uid() {
+        _uid += 1;
+        return '__async_req_'+ _uid +'__';
+    }
+
+    return{
+        load : function(name, req, onLoad, config){
+            if(config.isBuild){
+                onLoad(null); //avoid errors on the optimizer
+            }else{
+                var id = uid();
+                window[id] = onLoad; //create a global variable that stores onLoad so callback function can define new module after async load
+                injectScript(formatUrl(name, id));
+            }
+        }
+    };
+});

css.js

@@ -0,0 +1,156 @@
+/*
+ * css! loader plugin
+ * Allows for loading stylesheets with the 'css!' syntax.
+ *
+ * External stylesheets supported.
+ * 
+ * '!' suffix skips load checking
+ *
+ */
+define(['./normalize'], function(normalize) {
+  if (typeof window == 'undefined')
+    return { load: function(n, r, load){ load() } };
+  
+  var head = document.getElementsByTagName('head')[0];
+  
+  
+  /* XHR code - copied from RequireJS text plugin */
+  var progIds = ['Msxml2.XMLHTTP', 'Microsoft.XMLHTTP', 'Msxml2.XMLHTTP.4.0'];
+  var get = function(url, callback, errback) {
+  
+    var xhr, i, progId;
+    if (typeof XMLHttpRequest !== 'undefined')
+      xhr = new XMLHttpRequest();
+    else if (typeof ActiveXObject !== 'undefined')
+      for (i = 0; i < 3; i += 1) {
+        progId = progIds[i];
+        try {
+          xhr = new ActiveXObject(progId);
+        }
+        catch (e) {}
+  
+        if (xhr) {
+          progIds = [progId];  // so faster next time
+          break;
+        }
+      }
+    
+    xhr.open('GET', url, requirejs.inlineRequire ? false : true);
+  
+    xhr.onreadystatechange = function (evt) {
+      var status, err;
+      //Do not explicitly handle errors, those should be
+      //visible via console output in the browser.
+      if (xhr.readyState === 4) {
+        status = xhr.status;
+        if (status > 399 && status < 600) {
+          //An http 4xx or 5xx error. Signal an error.
+          err = new Error(url + ' HTTP status: ' + status);
+          err.xhr = xhr;
+          errback(err);
+        }
+        else
+          callback(xhr.responseText);
+      }
+    };
+    
+    xhr.send(null);
+  }
+  
+  //main api object
+  var cssAPI = {};
+  
+  cssAPI.pluginBuilder = './css-builder';
+  
+  //<style> tag creation
+  var stylesheet = document.createElement('style');
+  stylesheet.type = 'text/css';
+  head.appendChild(stylesheet);
+  
+  if (stylesheet.styleSheet)
+    cssAPI.inject = function(css) {
+      stylesheet.styleSheet.cssText += css;
+    }
+  else
+    cssAPI.inject = function(css) {
+      stylesheet.appendChild(document.createTextNode(css));
+    }
+
+  cssAPI.inspect = function() {
+    if (stylesheet.styleSheet)
+      return stylesheet.styleSheet.cssText;
+    else if (stylesheet.innerHTML)
+      return stylesheet.innerHTML;
+  }
+  
+  var instantCallbacks = {};
+  cssAPI.normalize = function(name, normalize) {
+    var instantCallback;
+    if (name.substr(name.length - 1, 1) == '!')
+      instantCallback = true;
+    if (instantCallback)
+      name = name.substr(0, name.length - 1);
+    if (name.substr(name.length - 4, 4) == '.css')
+      name = name.substr(0, name.length - 4);
+    
+    name = normalize(name);
+    
+    if (instantCallback)
+      instantCallbacks[name] = instantCallback;
+    
+    return name;
+  }
+  
+  cssAPI.load = function(cssId, req, load, config, parse) {
+    var instantCallback = instantCallbacks[cssId];
+    if (instantCallback)
+      delete instantCallbacks[cssId];
+    
+    var fileUrl = cssId;
+    
+    if (fileUrl.substr(fileUrl.length - 4, 4) != '.css' && !parse)
+      fileUrl += '.css';
+    
+    fileUrl = req.toUrl(fileUrl);
+    
+    //external url -> add as a <link> tag to load. onload support not reliable so not provided
+    if (fileUrl.substr(0, 7) == 'http://' || fileUrl.substr(0, 8) == 'https://') {
+      if (parse)
+        throw 'Cannot preprocess external css.';
+      var link = document.createElement('link');
+      link.type = 'text/css';
+      link.rel = 'stylesheet';
+      link.href = fileUrl;
+      head.appendChild(link);
+      
+      //only instant callback due to onload not being reliable
+      load(cssAPI);
+    }
+    //internal url -> download and inject into <style> tag
+    else {
+      get(fileUrl, function(css) {
+        if (parse)
+          css = parse(css);
+          
+        var pathname = window.location.pathname.split('/');
+        pathname.pop();
+        pathname = pathname.join('/') + '/';
+
+        //make file url absolute
+        if (fileUrl.substr(0, 1) != '/')
+          fileUrl = '/' + normalize.convertURIBase(fileUrl, pathname, '/');
+        
+        css = normalize(css, fileUrl, pathname);
+
+        cssAPI.inject(css);
+          
+        if (!instantCallback)
+          load(cssAPI);
+      });
+      if (instantCallback)
+        load(cssAPI);
+    }
+  }
+  
+  return cssAPI;
+});

depend.js

@@ -0,0 +1,27 @@
+/** @license
+ * Plugin to load JS files that have dependencies but aren't wrapped into
+ * `define` calls.
+ * Author: Miller Medeiros
+ * Version: 0.1.0 (2011/12/13)
+ * Released under the MIT license
+ */
+define(function () {
+
+    var rParts = /^(.*)\[([^\]]*)\]$/;
+
+    return {
+
+        //example: depend!bar[jquery,lib/foo]
+        load : function(name, req, onLoad, config){
+            var parts = rParts.exec(name);
+
+            req(parts[2].split(','), function(){
+                req([parts[1]], function(mod){
+                    onLoad(mod);
+                });
+            });
+        }
+
+    };
+
+});

font.js

@@ -0,0 +1,45 @@
+/** @license
+ * RequireJS plugin for loading web fonts using the WebFont Loader
+ * Author: Miller Medeiros
+ * Version: 0.2.0 (2011/12/06)
+ * Released under the MIT license
+ */
+define(['propertyParser'], function (propertyParser) {
+
+    var rParts = /^([^,]+),([^\|]+)\|?/;
+
+    function parseName(name) {
+        var data = {},
+            vendors = name.split('|'),
+            n = vendors.length,
+            match;
+
+        while (n--) {
+            match = rParts.exec(vendors[n]);
+            data[ match[1] ] = propertyParser.parseProperties(match[2]);
+        }
+        return data;
+    }
+
+    // API
+    return {
+
+        //example: font!google,families:[Tangerine,Cantarell,Yanone Kaffeesatz:700]
+        load : function(name, req, onLoad, config){
+            if (config.isBuild) {
+                onLoad(null); //avoid errors on the optimizer
+            } else {
+                var data = parseName(name);
+                data.active = onLoad;
+                data.inactive = function(){
+                    onLoad(false);
+                };
+                req([(document.location.protocol === 'https:'? 'https' : 'http') +'://ajax.googleapis.com/ajax/libs/webfont/1/webfont.js'], function(){
+                    WebFont.load(data);
+                });
+            }
+        }
+
+    };
+
+});

goog.js

@@ -0,0 +1,38 @@
+/** @license
+ * RequireJS plugin for loading Google Ajax API modules thru `google.load`
+ * Author: Miller Medeiros
+ * Version: 0.2.0 (2011/12/06)
+ * Released under the MIT license
+ */
+define(['async', 'propertyParser'], function (async, propertyParser) {
+
+    var rParts = /^([^,]+)(?:,([^,]+))?(?:,(.+))?/;
+
+    function parseName(name){
+        var match = rParts.exec(name),
+            data = {
+                moduleName : match[1],
+                version : match[2] || '1'
+            };
+        data.settings = propertyParser.parseProperties(match[3]);
+        return data;
+    }
+
+    return {
+        load : function(name, req, onLoad, config){
+            if (config.isBuild) {
+                onLoad(null); //avoid errors on the optimizer
+            } else {
+                var data = parseName(name),
+                    settings = data.settings;
+
+                settings.callback = onLoad;
+
+                req(['async!'+ (document.location.protocol === 'https:'? 'https' : 'http') +'://www.google.com/jsapi'], function(){
+                    google.load(data.moduleName, data.version, settings);
+                });
+            }
+        }
+    };
+
+});