1 files changed, 1122 insertions, 0 deletions

diff --git a/node_modules/montage/core/core.js b/node_modules/montage/core/core.js
new file mode 100755
index 00000000..b665f591
--- /dev/null
+++ b/node_modules/montage/core/core.js
@@ -0,0 +1,1122 @@
+/* <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> */
+/**
+ @module montage/core/core
+ @requires montage/core/shim
+ @requires montage/core/uuid
+ @requires montage/core/event/binding
+ @requires montage/core/event/event-manager
+ */
+require("core/shim");
+
+/**
+ @external Object
+ */
+
+/* Ecmascript 5 Methods. Should be external as WebKit doesn't need it, and loaded automatically */
+if (!Object.create) {
+    Object._creator = function _ObjectCreator() {
+        this.__proto__ = _ObjectCreator.prototype;
+    };
+    Object.create = function(o, properties) {
+        this._creator.prototype = o || Object.prototype;
+        //Still needs to add properties....
+        return new this._creator;
+    };
+
+    Object.getPrototypeOf = function(o) {
+        return o.__proto__;
+    };
+}
+
+/**
+ @class module:montage/core/core.Montage
+ */
+var M = exports.Montage = Object.create(Object.prototype);
+
+/**
+     Creates a new Montage object.
+     @function module:montage/core/core.Montage.create
+     @param {Object} aPrototype The prototype object to create the new object from. If not specified, the prototype is the Montage prototype.
+     @param {Object} [propertyDescriptor] An object that contains the initial properties and values for the new object.
+     @returns The new object
+     @example
+     <caption>Creating a "empty" Montage object, using Montage as the prototype</caption>
+     var alpha = Montage.create();
+     @example
+     <caption>Creating a new Montage component with a property descriptor object.</caption>
+     var Button = Montage.create(Component , {
+        state: {
+            value: null
+        }
+     });
+     */
+Object.defineProperty(M, "create", {
+    configurable: true,
+    value: function(aPrototype, propertyDescriptor) {
+        if (!propertyDescriptor) {
+
+            var newObject = Object.create(typeof aPrototype === "undefined" ? this : aPrototype);
+
+            if (typeof newObject.didCreate === "function") {
+                newObject.didCreate();
+            }
+
+            if (newObject._dependenciesForProperty) {
+                newObject._dependencyListeners = {};
+            }
+
+            return newObject;
+        } else {
+            var result = Object.create(aPrototype);
+            M.defineProperties(result, propertyDescriptor);
+            return result;
+        }
+    }
+});
+
+var extendedPropertyAttributes = ["serializable", "modify"];
+
+// Extended property attributes, the property name format is "_" + attributeName + "AttributeProperties"
+/**
+@member external:Object#extendedPropertyAttributes
+*/
+extendedPropertyAttributes.forEach(function(name) {
+    Object.defineProperty(Object.prototype, "_" + name + "AttributeProperties", {
+        enumerable: false,
+        configurable: false,
+        writable: false,
+        value: {}
+    });
+});
+
+/**
+     Defines a property on a Montage object.
+     @function module:montage/core/core.Montage.defineProperty
+     @param {Object} obj The object on which to define the property.
+     @param {String} prop The name of the property to define, or modify.
+     @param {Object} descriptor A descriptor object that defines the properties being defined or modified.
+     @example
+     Montage.defineProperty(Object.prototype, "_eventListenerDescriptors", {
+     enumerable: false,
+     serializable: true,
+     value: null,
+     writable: true
+     });
+     */
+Object.defineProperty(M, "defineProperty", {
+
+    value: function(obj, prop, descriptor) {
+        var dependencies = descriptor.dependencies;
+        //reset defaults appropriately for framework.
+        if ("__proto__" in descriptor) {
+            descriptor.__proto__ = ("value" in descriptor ? (typeof descriptor.value === "function" ? _defaultFunctionValueProperty : _defaultObjectValueProperty) : _defaultAccessorProperty);
+        } else {
+            var defaults;
+            if ("value" in descriptor) {
+                if (typeof descriptor.value === "function") {
+                    defaults = _defaultFunctionValueProperty;
+                } else {
+                    defaults = _defaultObjectValueProperty;
+                }
+            } else {
+                defaults = _defaultAccessorProperty;
+            }
+            for (var key in defaults) {
+                if (!(key in descriptor)) {
+                    descriptor[key] = defaults[key];
+                }
+            }
+        }
+
+
+        if (!descriptor.hasOwnProperty("enumerable") && prop.charAt(0) === "_") {
+            descriptor.enumerable = false;
+        }
+        if (dependencies) {
+            var i = 0,
+                independentProperty;
+
+            for (; (independentProperty = dependencies[i]); i++) {
+                M.addDependencyToProperty(obj, independentProperty, prop);
+            }
+
+        }
+
+        if ("serializable" in descriptor) {
+            // get the _serializableAttributeProperties property or creates it through the entire chain if missing.
+            getAttributeProperties(obj, "serializable")[prop] = descriptor.serializable;
+        }
+
+        if ("modify" in descriptor) {
+            getAttributeProperties(obj, "modify")[prop] = descriptor.modify;
+        }
+
+        //this is added to enable value properties with [] or Objects that are new for every instance
+        if (descriptor.distinct === true && typeof descriptor.value === "object") {
+            (function(internalProperty, value) {
+                Object.defineProperty(obj, internalProperty, {
+                    enumerable: false,
+                    configurable: true,
+                    writable: true,
+                    value: null
+                });
+                if (value.constructor === Object && Object.getPrototypeOf(value) === Object.prototype) {
+                    // we have an object literal {...}
+                    if (Object.keys(value).length !== 0) {
+                        Object.defineProperty(obj, prop, {
+                            configurable: true,
+                            get: function() {
+                                //Special case for object to copy the values
+                                var returnValue = this[internalProperty];
+                                if (!returnValue) {
+                                    var k;
+                                    returnValue = {};
+                                    for (k in value) {
+                                        returnValue[k] = value[k];
+                                    }
+                                    this[internalProperty] = returnValue;
+                                }
+                                return returnValue;
+                            },
+                            set: function(value) {
+                                this[internalProperty] = value;
+                            }
+                        });
+                    } else {
+                        Object.defineProperty(obj, prop, {
+                            configurable: true,
+                            get: function() {
+                                return this[internalProperty] || (this[internalProperty] = {});
+                            },
+                            set: function(value) {
+                                this[internalProperty] = value;
+                            }
+                        });
+                    }
+
+                } else if ((value.__proto__ || Object.getPrototypeOf(value)) === __cached__arrayProto) {
+                    // we have an array literal [...]
+                    if (value.length !== 0) {
+                        Object.defineProperty(obj, prop, {
+                            configurable: true,
+                            get: function() {
+                                //Special case for object to copy the values
+                                var returnValue = this[internalProperty];
+                                if (!returnValue) {
+                                    var i, k;
+                                    returnValue = [];
+                                    for (i = 0; typeof (k = value[i]) !== "undefined"; i++) {
+                                        returnValue[i] = k;
+                                    }
+                                    this[internalProperty] = returnValue;
+                                }
+                                return returnValue;
+                            },
+                            set: function(value) {
+                                this[internalProperty] = value;
+                            }
+                        });
+
+                    } else {
+                        Object.defineProperty(obj, prop, {
+                            configurable: true,
+                            get: function() {
+                                //Special case for array as isArray fails
+                                //Object.prototype.toString.call(Object.create([].__proto)) !== "[object Array]"
+                                return this[internalProperty] || (this[internalProperty] = []);
+