base-base.js revision 64953b0596d07dbee9a9b521ed61c434ce4709b5
394N/A * The base module provides the Base class, which objects requiring managed attributes 394N/A * and custom event support can extend. The base module also provides two ways to reuse 394N/A * code - An augmentable PluginHost interface which provides plugin support 394N/A * (which is augmented to the Base class) and Base.build which provides a way to 394N/A * build custom classes using extensions. 394N/A * An augmentable class, which when added to a "Base" based class, allows 394N/A * the class to support Plugins, providing plug and unplug methods and the ability 394N/A * to add Plugins through the configuration literal passed to the constructor. 394N/A * The PlugHost's _initPlugins and _destroyPlugins should be invoked by the 3817N/A * host class at the appropriate point in the instances lifecyle. This is done 394N/A * by default for Base class, so developers extending base don't need to do 394N/A * anything to get plugin support. 1258N/A * Adds a plugin to the host object. This will instantiate the 394N/A * plugin and attach it to the configured namespace on the host object. 2818N/A * @param p {Function | Object |Array} Accepts the plugin class, or an 2818N/A * object literal with a "fn" property specifying the plugin class and 3817N/A * a "cfg" property specifying the configuration for the Plugin. 3817N/A * Additionally an Array can also be passed in, with the above function or 394N/A * object literal values, allowing the user to add multiple plugins in a single call. 783N/A * @param config (Optional) If the first argument is the plugin class, the second argument 783N/A * can be the configuration for the plugin. 1938N/A * @return {Base} A reference to the host object * Removes a plugin from the host object. This will destroy the * plugin instance and delete the namepsace from the host object. * @param {String | Function} plugin The namespace of the plugin, or the plugin class with the static NS namespace property defined. If not provided, * all registered plugins are unplugged. * @return {Base} A reference to the host object * Determines if a plugin has plugged into this host. * @param The plugin's namespace * @return {boolean} returns true, if the plugin has been plugged into this host, false otherwise. * Initializes static plugins registered on the host (using the * Base.plug static method) and any plugins passed to the * instance through the "plugins" configuration property. * @param {Config} config The configuration object literal for the host. * Unplugs and destroys all plugins on the host * @method _destroyPlugins * Private method used to instantiate and attach plugins to the host * @param {Function} PluginClass The plugin class to instantiate * @param {Object} config The configuration object for the plugin * Unplugs and destroys a plugin already instantiated with the host. * @param {String | Function} plugin The namespace for the plugin, or a plugin class with the static NS property defined. * Registers plugins to be instantiated at the class level (plugins * which should be plugged into every instance of the class by default). * @method PluginHost.plug * @param {Function} hostClass The host class on which to register the plugins * @param {Function | Array} plugin Either the plugin class, an array of plugin classes or and array of object literals (with fn and cfg properties defined) * @param {Object} config (Optional) If plugin is the plugin class, the configuration for the plugin // Cannot plug into Base, since Plugins derive from Base [ will cause infinite recurrsion ] * Unregisters any class level plugins which have been registered by the host class, or any * other class in the hierarchy. * @method PluginHost.unplug * @param {Function} hostClass The host class from which to unregister the plugins * @param {Function | Array} plugin The plugin class, or an array of plugin classes * The base-base submodule provides the Base class and augmentable PluginHost implementation, * without the extension support provided by Base.build. * Provides a base class for which objects requiring managed attributes and * custom event support can extend. The Base class also handles the chaining of * initializer and destructor methods across the hierarchy as part of object construction * and destruction. Additionally, attributes configured through the static * <a href="#property_ATTRS">ATTRS</a> property for each class in the hierarchy will be * <p>The static <a href="#property_NAME">NAME</a> property of each class extending * from Base will be used as the identifier for the class, and is used by Base to prefix * all events fired by instances of that class.</p> * @uses Attribute, Plugin.Host * @param {Object} config Object literal of configuration property name/value pairs * The list of properties which can be configured for * each attribute (e.g. setter, getter, writeOnce, readOnly etc.) * @property Base._ATTR_CFG * The string to be used to identify instances of * this class, for example in prefixing events. * Classes extending Base, should define their own * static NAME property, which should be camelCase by * convention (e.g. MyClass.NAME = "myClass";). * Object literal defining the set of attributes which * will be available for instances of this class, and * how they are configured. See Attribute's <a href="Attribute.html#method_addAttr">addAttr</a> * method for a description of configuration options available * Flag indicating whether or not this object * has been through the init lifecycle phase. * Flag indicating whether or not this object * has been through the destroy lifecycle phase. * Init lifecycle method, invoked during construction. * Fires the init event prior to setting up attributes and * invoking initializers for the class hierarchy. * @param {Object} config Object literal of configuration property name/value pairs * @return {Base} A reference to this object * The string used to identify the class of this object. * @deprecated Use this.constructor.NAME * Lifecycle event for the init phase, fired prior to initialization. * Invoking the preventDefault() method on the event object provided * to subscribers will prevent initialization from occuring. * Subscribers to the "after" momemt of this event, will be notified * after initialization of the object is complete (and therefore * cannot prevent initialization). * @preventable _defInitFn * @param {Event.Facade} e Event object, with a cfg property which * refers to the configuration object literal passed to the constructor. * Destroy lifecycle method. Fires the destroy * event, prior to invoking destructors for the * Subscribers to the destroy * event can invoke preventDefault on the event object, to prevent destruction * @return {Base} A reference to this object * Lifecycle event for the destroy phase, * fired prior to destruction. Invoking the preventDefault * method on the event object provided to subscribers will * prevent destruction from proceeding. * Subscribers to the "after" moment of this event, will be notified * after destruction is complete (and as a result cannot prevent * @preventable _defDestroyFn * @param {Event.Facade} e Event object * Default init event handler * @param {Event.Facade} e Event object, with a cfg property which * refers to the configuration object literal passed to the constructor. * Default destroy event handler * @param {Event.Facade} e Event object * Returns the class hierarchy for this object, with Base being the last class in the array. * @return {Function[]} An array of classes (constructor functions), making up the class hierarchy for this object. * This value is cached the first time the method, or _getAttrCfgs, is invoked. Subsequent invocations return the * Returns an aggregated set of attribute configurations, by traversing the class hierarchy. * @return {Object} The hash of attribute configurations, aggregated across classes in the hierarchy * This value is cached the first time the method, or _getClasses, is invoked. Subsequent invocations return * A helper method used when processing ATTRS across the class hierarchy during * initialization. Returns a disposable object with the attributes defined for * the provided class, extracted from the set of all attributes passed in . * @param {Function} clazz The class for which the desired attributes are required. * @param {Object} allCfgs The set of all attribute configurations for this instance. * Attributes will be removed from this set, if they belong to the filtered class, so * that by the time all classes are processed, allCfgs will be empty. * @return {Object} The set of attributes belonging to the class passed in, in the form * of an object literal with name/cfg pairs. * A helper method used by _getClasses and _getAttrCfgs, which determines both * the array of classes and aggregate set of attribute configurations * across the class hierarchy for the instance. * @method _initHierarchyData * A helper method, used by _initHierarchyData to aggregate * attribute configuration across the instances class hierarchy. * The method will potect the attribute configuration value to protect the statically defined * default value in ATTRS if required (value is an object literal or array or the * attribute configuration has clone set to shallow or deep). * @method _aggregateAttrs * @param {Array} allAttrs An array of ATTRS definitions across classes in the hierarchy * (subclass first, Base last) * @return {Object} The aggregate set of ATTRS definitions for the instance // Protect config passed in // else if (clone === false), don't clone the static default value. // It's intended to be used by reference. * Initializes the class hierarchy for the instance, which includes * initializing attributes for each class defined in the class's * static <a href="#property_ATTRS">ATTRS</a> property and * invoking the initializer method on the prototype of each class in the hierarchy. * @param {Object} userVals Object literal containing configuration name/value pairs * Destroys the class hierarchy for this instance by invoking * the descructor method on the prototype of each class in the hierarchy. * @method _destroyHierarchy * Default toString implementation. Provides the constructor NAME * @return {String} String representation for this object // Straightup augment, no wrapper functions * Alias for <a href="PluginHost.html@method_PluginHost.plug">PluginHost.plug</a>. * Alias for <a href="PluginHost.html@method_PluginHost.unplug">PluginHost.unplug</a>. },
'@VERSION@' ,{
requires:[
'attribute']});