First commit of Ninja to ninja-internal

Signed-off-by: Valerio Virgillito <rmwh84@motorola.com>

1 files changed, 362 insertions, 0 deletions

diff --git a/node_modules/montage/montage.js b/node_modules/montage/montage.js
new file mode 100755
index 00000000..07975ae8
--- /dev/null
+++ b/node_modules/montage/montage.js
@@ -0,0 +1,362 @@
+/* <copyright>
+ This file contains proprietary software owned by Motorola Mobility, Inc.<br/>
+ No rights, expressed or implied, whatsoever to this software are provided by Motorola Mobility, Inc. hereunder.<br/>
+ (c) Copyright 2011 Motorola Mobility, Inc.  All Rights Reserved.
+ </copyright> */
+
+document._montageTiming = {}
+document._montageTiming.loadStartTime = Date.now();
+
+// Give a threshold before we decide we need to show the bootstrapper progress
+// Applications that use our loader will interact with this timeout
+// and class name to coordinate a nice loading experience. Applications that do not will
+// just go about business as usual and draw their content as soon as possible.
+window.addEventListener("DOMContentLoaded", function() {
+    var bootstrappingDelay = 1000;
+    document._montageStartBootstrappingTimeout = setTimeout(function() {
+        document._montageStartBootstrappingTimeout = null;
+
+        var root = document.documentElement;
+        if(!!root.classList) {
+            root.classList.add("montage-app-bootstrapping");
+        } else {
+            root.className = root.className + " montage-app-bootstrapping";
+        }
+
+        document._montageTiming.bootstrappingStartTime = Date.now();
+    }, bootstrappingDelay);
+});
+
+(function (definition) {
+    if (typeof require !== "undefined") {
+        // CommonJS / NodeJS
+        definition(require, exports, module);
+    } else {
+        // <script>
+        definition({}, {}, {});
+    }
+})(function (require, exports, module) {
+
+    // The global context object, works for the browser and for node.
+    // XXX Will not work in strict mode
+    var global = (function() {
+        return this;
+    })();
+
+    /**
+     * Initializes Montage and creates the application singleton if necessary.
+     * @param options
+     * @param callback
+     */
+    exports.initMontage = function () {
+        var platform = exports.getPlatform();
+        var params = platform.getParams();
+        var config = platform.getConfig();
+
+        // Platform dependent
+        platform.loadCJS(function (CJS, Q, URL) {
+
+            // setup the reel loader
+            config.makeLoader = function (config) {
+                return exports.ReelLoader(config,
+                    CJS.DefaultLoaderConstructor(config));
+            };
+
+            // setup serialization compiler
+            config.makeCompiler = function (config) {
+                return exports.TemplateCompiler(config,
+                    exports.SerializationCompiler(config,
+                        CJS.DefaultCompilerConstructor(config)));
+            };
+
+            var location = URL.resolve(window.location, params["package"] || ".");
+
+            CJS.PackageSandbox(params.montageBase, config)
+            .then(function (montageRequire) {
+                montageRequire.config.modules["core/promise"] = {exports: Q};
+                montageRequire.config.modules["core/url"] = {exports: URL};
+                montageRequire.config.modules["core/shim/timers"] = {exports: {}};
+                return montageRequire.loadPackage(location)
+                .then(function (applicationRequire) {
+                    global.require = applicationRequire;
+                    global.montageRequire = montageRequire;
+                    platform.initMontage(montageRequire, applicationRequire, params);
+                })
+            })
+            .end();
+
+        });
+
+    };
+
+    /**
+     Adds "_montage_metadata" property to all objects and function attached to
+     the exports object.
+     @see Compiler middleware in require/require.js
+     @param config
+     @param compiler
+     */
+    exports.SerializationCompiler = function(config, compiler) {
+        return function(def) {
+            def = compiler(def);
+            var defaultFactory = def.factory;
+            def.factory = function(require, exports, module) {
+                defaultFactory.call(this, require, exports, module);
+                for (var symbol in exports) {
+                    // avoid attempting to reinitialize an aliased property
+                    if (
+                        Object.prototype.hasOwnProperty.call(
+                            exports[symbol],
+                            "_montage_metadata"
+                        )
+                    ) {
+                        exports[symbol]._montage_metadata.aliases.push(symbol);
+                        exports[symbol]._montage_metadata.objectName = symbol;
+                    } else if (!Object.isSealed(exports[symbol])) {
+                        Object.defineProperty(
+                            exports[symbol],
+                            "_montage_metadata",
+                            {
+                                value: {
+                                    require: require,
+                                    moduleId: module.id,
+                                    objectName: symbol,
+                                    aliases: [symbol],
+                                    isInstance: false
+                                }
+                            }
+                        );
+                    }
+                }
+            };
+            return def;
+        };
+    };
+
+    /**
+     * Allows reel directories to load the contained eponymous JavaScript
+     * module.
+     * @see Loader middleware in require/require.js
+     * @param config
+     * @param loader the next loader in the chain
+     */
+    var reelExpression = /([^\/]+)\.reel$/;
+    exports.ReelLoader = function (config, loader) {
+        return function (id, callback) {
+            var match = reelExpression.exec(id);
+            if (match) {
+                return loader(id + "/" + match[1], callback);
+            } else {
+                return loader(id, callback);
+            }
+        };
+    };
+
+    /**
+     Allows the reel's html file to be loaded via require.
+     @see Compiler middleware in require/require.js
+     @param config
+     @param compiler
+     */
+    exports.TemplateCompiler = function(config, compiler) {
+        return function(def) {
+            var root = def.path.match(/(.*\/)?(?=[^\/]+\.html$)/);
+            if (root) {
+                def.dependencies = def.dependencies || [];
+                var originalFactory = def.factory;
+                def.factory = function(require, exports, module) {
+                    if (originalFactory) {
+                        originalFactory(require, exports, module);
+                    }
+                    // Use module.exports in case originalFactory changed it.
+                    module.exports.root = module.exports.root || root;
+                    module.exports.content = module.exports.content || def.text;
+                };
+                return def;
+            } else {
+                return compiler(def);
+            }
+        };
+    };
+
+    // Bootstrapping for multiple-platforms
+
+    exports.getPlatform = function () {
+        if (typeof window !== "undefined" && window && window.document) {
+            return browser;
+        } else {
+            throw new Error("Platform not supported.");
+        }
+    };
+
+    var browser = {
+
+        getConfig: function() {
+            return {
+                lib: ".",
+                base: window.location,
+                // Disable XHR loader for file://
+                xhr: window.location.protocol.indexOf("file:") !== 0
+            };
+        },
+
+        getParams: function() {
+            var i, j,
+                match,
+                script,
+                attr,
+                name;
+            if (!this._params) {
+                this._params = {};
+                // Find the <script> that loads us, so we can divine our
+                // parameters from its attributes.
+                var scripts = document.getElementsByTagName("script");
+                for (i = 0; i < scripts.length; i++) {
+                    script = scripts[i];
+                    if (script.src && (match = script.src.match(/^(.*)montage.js(?:[\?\.]|$)/i))) {
+                        this._params.montageBase = match[1];
+                        if (script.dataset) {
+                            for (name in script.dataset) {
+                                this._params[name] = script.dataset[name];
+                            }
+                        } else if (script.attributes) {
+                            for (j = 0; j < script.attributes.length; j++) {
+                                attr = script.attributes[j];
+                                match = attr.name.match(/^data-(.*)$/);
+                                if (match) {
+                                    this._params[match[1]] = attr.value;
+                                }
+                            }
+                        }
+                        // Permits multiple montage.js <scripts>; by