• Classes
• Modules
• Everything

 /*jshint expr:true, maxlen:200, onevar:false */
 
 /**
 Provides `Plugin.Tree.Lazy`, a plugin for `Tree.Openable` that makes it easy to
 lazily load and populate the contents of tree nodes the first time they're
 opened.
 
 @module tree
 @submodule tree-lazy
 **/
 
 /**
 A plugin for `Tree.Openable` that makes it easy to lazily load and populate the
 contents of tree nodes the first time they're opened.
 
 ### Example
 
 YUI().use('jsonp', 'tree-openable', 'tree-lazy', function (Y) {
 var Tree = Y.Base.create('openableTree', Y.Tree, [Y.Tree.Openable]),
 tree = new Tree();
 
 tree.plug(Y.Plugin.Tree.Lazy, {
 
 // Custom function that Plugin.Tree.Lazy will call when it needs to
 // load the children for a node.
 load: function (node, callback) {
 // Request the data for this node's children via JSONP.
 Y.jsonp('http://example.com/api/data?callback={callback}', function (data) {
 // If we didn't get any data back, treat this as an error.
 if (!data) {
 callback(new Error('No data!'));
 return;
 }
 
 // Append the children to the node (assume `data.children` is
 // an array of child node data for the sake of this example).
 node.append(data.children);
 
 // Call the callback function to tell Plugin.Tree.Lazy that
 // we're done loading data.
 callback();
 });
 }
 
 });
 });
 
 @class Plugin.Tree.Lazy
 @param {Object} config Config object.
 
 @param {Function} config.load Custom `load()` function that will be called
 when a node's children need to be loaded. This function must call the
 provided callback to indicate completion.
 
 @param {Function} config.load.callback Callback function. The custom
 `load()` function must call this callback to indicate completion.
 
 @param {Error} [config.load.callback.err] Error object. If provided,
 the load action will be considered a failure, and an `error`
 event will be fired. Omit this argument (or set it to `null`) to
 indicate success.
 
 @extends Plugin.Base
 @constructor
 **/
 
 /**
 Fired just before the custom `load()` method is called to load child nodes for a
 node.
 
 Calling `preventDefault()` on this event's facade will cancel the load action
 and prevent the `load()` method from being called.
 
 @event beforeLoad
 @param {Tree.Node} node Tree node whose children will be loaded.
 @preventable _defBeforeLoadFn
 **/
 var EVT_BEFORE_LOAD = 'beforeLoad';
 
 /**
 Fired when the `load()` method indicates there was an error loading child nodes.
 
 @event error
 @param {Error} error Error provided by the `load()` method.
 @param {String} src Source of the error (defaults to "load").
 **/
 var EVT_ERROR = 'error';
 
 /**
 Fired after child nodes have finished loading and have been added to the tree.
 
 @event load
 @param {Tree.Node} node Tree node whose children have been loaded.
 **/
 var EVT_LOAD = 'load';
 
 Y.namespace('Plugin.Tree').Lazy = Y.Base.create('lazyTreePlugin', Y.Plugin.Base, [], {
 // -- Lifecycle Methods ----------------------------------------------------
 initializer: function (config) {
 this._host = config.host;
 
 if (config.load) {
 this.load = config.load;
 }
 
 // Make sure we've been plugged into a Tree that mixes in the
 // Tree.Openable extension.
 if (!this._host.openNode) {
 Y.log("Plugin.Tree.Lazy was plugged into a Tree that doesn't mix in the Tree.Openable extension. This probably won't do you much good.", 'warn', 'tree-lazy');
 }
 
 this._published = {};
 this._attachEvents();
 },
 
 // -- Public Methods -------------------------------------------------------
 load: function (node, callback) {
 callback(new Error('Plugin.Tree.Lazy: Please provide a custom `load` method when instantiating this plugin.'));
 },
 
 // -- Protected Methods ----------------------------------------------------
 _attachEvents: function () {
 this.onHostEvent('open', this._onOpen);
 },
 
 // -- Protected Event Handlers ---------------------------------------------
 _onOpen: function (e) {
 var node = e.node;
 
 // Nothing to do if this node can't have children or if its children
 // have already been (or are already being) loaded.
 if (!node.canHaveChildren || node.state.loaded || node.state.loading) {
 return;
 }
 
 if (!this._published[EVT_BEFORE_LOAD]) {
 this._published[EVT_BEFORE_LOAD] = this.publish(EVT_BEFORE_LOAD, {
 defaultFn: this._defLoadingFn
 });
 }
 
 this.fire(EVT_BEFORE_LOAD, {node: node});
 },
 
 // -- Default Event Handlers -----------------------------------------------
 _defLoadingFn: function (e) {
 var node = e.node,
 self = this;
 
 node.state.loading = true;
 
 this.load(node, function (err) {
 delete node.state.loading;
 
 if (err) {
 self.fire(EVT_ERROR, {
 error: err,
 src : 'load'
 });
 
 return;
 }
 
 node.state.loaded = true;
 
 self.fire(EVT_LOAD, {node: node});
 });
 }
 }, {
 NS: 'lazy'
 });