Version 3.18.1
Show:

File: node/js/node-pluginhost.js

            /**
             * @module node
             * @submodule node-pluginhost
             */
            
            /**
             * Registers plugins to be instantiated at the class level (plugins
             * which should be plugged into every instance of Node by default).
             *
             * @method plug
             * @static
             * @for Node
             * @param {Function | Array} plugin Either the plugin class, an array of plugin classes or an array of objects (with fn and cfg properties defined)
             * @param {Object} config (Optional) If plugin is the plugin class, the configuration for the plugin
             */
            Y.Node.plug = function() {
                var args = Y.Array(arguments);
                args.unshift(Y.Node);
                Y.Plugin.Host.plug.apply(Y.Base, args);
                return Y.Node;
            };
            
            /**
             * Unregisters any class level plugins which have been registered by the Node
             *
             * @method unplug
             * @static
             *
             * @param {Function | Array} plugin The plugin class, or an array of plugin classes
             */
            Y.Node.unplug = function() {
                var args = Y.Array(arguments);
                args.unshift(Y.Node);
                Y.Plugin.Host.unplug.apply(Y.Base, args);
                return Y.Node;
            };
            
            Y.mix(Y.Node, Y.Plugin.Host, false, null, 1);
            
            // run PluginHost constructor on cached Node instances
            Y.Object.each(Y.Node._instances, function (node) {
                Y.Plugin.Host.apply(node);
            });
            
            // allow batching of plug/unplug via NodeList
            // doesn't use NodeList.importMethod because we need real Nodes (not tmpNode)
            /**
             * Adds a plugin to each node in the NodeList.
             * This will instantiate the plugin and attach it to the configured namespace on each node
             * @method plug
             * @for NodeList
             * @param P {Function | Object |Array} Accepts the plugin class, or an
             * object with a "fn" property specifying the plugin class and
             * a "cfg" property specifying the configuration for the Plugin.
             * <p>
             * Additionally an Array can also be passed in, with the above function or
             * object values, allowing the user to add multiple plugins in a single call.
             * </p>
             * @param config (Optional) If the first argument is the plugin class, the second argument
             * can be the configuration for the plugin.
             * @chainable
             */
            Y.NodeList.prototype.plug = function() {
                var args = arguments;
                Y.NodeList.each(this, function(node) {
                    Y.Node.prototype.plug.apply(Y.one(node), args);
                });
                return this;
            };
            
            /**
             * Removes a plugin from all nodes in the NodeList. This will destroy the
             * plugin instance and delete the namespace each node.
             * @method unplug
             * @for NodeList
             * @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.
             * @chainable
             */
            Y.NodeList.prototype.unplug = function() {
                var args = arguments;
                Y.NodeList.each(this, function(node) {
                    Y.Node.prototype.unplug.apply(Y.one(node), args);
                });
                return this;
            };