1 files changed, 401 insertions, 0 deletions

diff --git a/node_modules/montage-user/montage.js b/node_modules/montage-user/montage.js
new file mode 100755
index 00000000..cee1f27a
--- /dev/null
+++ b/node_modules/montage-user/montage.js
@@ -0,0 +1,401 @@
+/* <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> */
+
+if (typeof window !== "undefined") {
+
+    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();
+
+        // Platform dependent
+        platform.bootstrap(function (Require, Promise, URL) {
+            var params = platform.getParams();
+            var config = platform.getConfig();
+
+            // setup the reel loader
+            config.makeLoader = function (config) {
+                return exports.ReelLoader(config,
+                    Require.DefaultLoaderConstructor(config));
+            };
+
+            // setup serialization compiler
+            config.makeCompiler = function (config) {
+                return exports.TemplateCompiler(config,
+                    exports.SerializationCompiler(config,
+                        Require.DefaultCompilerConstructor(config)));
+            };
+
+            var location = URL.resolve(config.location, params["package"] || ".");
+
+            Require.PackageSandbox(params.montageBase, config)
+            .then(function (montageRequire) {
+                montageRequire.inject("core/promise", Promise);
+                montageRequire.inject("core/shim/timeers", {});
+
+                // install the linter, which loads on the first error
+                config.lint = function (module) {
+                    montageRequire.async("core/jshint")
+                    .then(function (JSHINT) {
+                        if (!JSHINT.JSHINT(module.text)) {
+                            console.warn("JSHint Error: "+module.location);
+                            JSHINT.JSHINT.errors.forEach(function(error) {
+                                if (error) {
+                                    console.warn("Problem at line "+error.line+" character "+error.character+": "+error.reason);
+                                    if (error.evidence) {
+                                        console.warn("    " + error.evidence);
+                                    }
+                                }
+                            });
+                        }
+                    });
+                };
+
+                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, compile) {
+        return function(module) {
+            compile(module);
+            if (!module.factory)
+                return;
+            var defaultFactory = module.factory;
+            module.factory = function(require, exports, module) {
+                defaultFactory.call(this, require, exports, module);
+                for (var symbol in exports) {
+                    var object = exports[symbol];
+                    // avoid attempting to reinitialize an aliased property
+                    if (object.hasOwnProperty("_montage_metadata")) {
+                        object._montage_metadata.aliases.push(symbol);
+                        object._montage_metadata.objectName = symbol;
+                    } else if (!Object.isSealed(object)) {
+                        Object.defineProperty(
+                            object,
+                            "_montage_metadata",
+                            {
+                                value: {
+                                    require: require,
+                                    moduleId: module.id,
+                                    objectName: symbol,
+                                    aliases: [symbol],
+                                    isInstance: false
+                                }
+                            }
+                        );
+                    }
+                }
+            };
+            return module;
+        };
+    };
+
+    /**
+     * 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, load) {
+        return function (id, module) {
+            var match = reelExpression.exec(id);
+            if (match) {
+                module.redirect = id + "/" + match[1];
+                return module;
+            } else {
+                return load(id, module);
+            }
+        };
+    };
+
+    /**
+     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, compile) {
+        return function(module) {
+            if (!module.location)
+                return;
+            var root = module.location.match(/(.*\/)?(?=[^\/]+\.html$)/);
+            if (root) {
+                module.dependencies = module.dependencies || [];
+                module.exports = {
+                    root: root,
+                    content: module.text
+                };
+                return module;
+            } else {
+                compile(module);
+            }
+        };
+    };
+
+    // Bootstrapping for multiple-platforms
+
+    exports.getPlatform = function () {
+        if (typeof window !== "undefined" && window && window.document) {
+            return browser;
+        } else if (typeof process !== "undefined") {
+            return require("./node.js");
+        } else {
+            throw new Error("Platform not supported.");
+        }
+    };
+
+    var urlModuleFactory = function (require, exports) {
+        var baseElement = document.createElement("base");
+        baseElement.href = "";
+        document.querySelector("head").appendChild(baseElement);
+        var relativeElement = document.createElement("a");
+        exports.resolve = function (base, relative) {
+            base = String(base);
+            if (!/^[\w\-]+:/.test(base)) {
+                throw new Error("Can't resolve from a relative location: " + JSON.stringify(base) + " " + JSON.stringify(relative));
+            }
+            var restore = baseElement.href;
+            baseElement.href = base;
+            relativeElement.href = relative;
+            var resolved = relativeElement.href;
+            baseElement.href = restore;
+            return resolved;
+        };
+    };
+
+    var browser = {
+