Enhanced PHP File Manager

⬆️ Go Up (..)

📊 Server Information

Server:

Apache

System:

Linux 5.14.0-427.33.1.el9_4.x86_64

PHP Version:

7.4.33

User:

infinio

Directory:

/home/infinio/public_html/moodle/lib/yuilib/3.18.1/pluginhost-base

Free Space:

54.46 GB

🔧 Quick Actions

✏️ Editing: pluginhost-base-debug.js

YUI.add('pluginhost-base', function (Y, NAME) {

/**
     * Provides the augmentable PluginHost interface, which can be added to any class.
     * @module pluginhost
     */

/**
     * Provides the augmentable PluginHost interface, which can be added to any class.
     * @module pluginhost-base
     */

/**
 * 
 * An augmentable class, which provides the augmented class with the ability to host plugins.
 * It adds <a href="#method_plug">plug</a> and <a href="#method_unplug">unplug</a> methods to the augmented class, which can
 * be used to add or remove plugins from instances of the class.
 * 
 *
 * Plugins can also be added through the constructor configuration object passed to the host class' constructor using
 * the "plugins" property. Supported values for the "plugins" property are those defined by the <a href="#method_plug">plug</a> method.
 *
 * For example the following code would add the AnimPlugin and IOPlugin to Overlay (the plugin host):
 * <xmp>
 * var o = new Overlay({plugins: [ AnimPlugin, {fn:IOPlugin, cfg:{section:"header"}}]});
 * </xmp>
 * 
 * 
 * Plug.Host's protected <a href="#method_initPlugins">_initPlugins</a> and <a href="#method_destroyPlugins">_destroyPlugins</a>
 * methods should be invoked by the host class at the appropriate point in the host's lifecyle.
 * 
 *
 * @class Plugin.Host
 */

var L = Y.Lang;

function PluginHost() {
        this._plugins = {};
    }

PluginHost.prototype = {

/**
 * Adds a plugin to the host object. This will instantiate the
 * plugin and attach it to the configured namespace on the host object.
 *
 * @method plug
 * @chainable
 * @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.
 * 
 * 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.
 * 
 * @param config (Optional) If the first argument is the plugin class, the second argument
 * can be the configuration for the plugin.
 * @return {Base} A reference to the host object
 */
 plug: function(Plugin, config) {
 var i, ln, ns;

if (L.isArray(Plugin)) {
 for (i = 0, ln = Plugin.length; i < ln; i++) {
 this.plug(Plugin[i]);
 }
 } else {
 if (Plugin && !L.isFunction(Plugin)) {
 config = Plugin.cfg;
 Plugin = Plugin.fn;
 }

// Plugin should be fn by now
                if (Plugin && Plugin.NS) {
                    ns = Plugin.NS;

config = config || {};
                    config.host = this;

if (this.hasPlugin(ns)) {
                        // Update config
                        if (this[ns].setAttrs) {
                            this[ns].setAttrs(config);
                        }
                        else {
                            Y.log("Attempt to replug an already attached plugin, and we can't setAttrs, because it's not Attribute based: " + ns, "warn", "PluginHost");
                        }
                    } else {
                        // Create new instance
                        this[ns] = new Plugin(config);
                        this._plugins[ns] = Plugin;
                    }
                }
                else {
                    Y.log("Attempt to plug in an invalid plugin. Host:" + this + ", Plugin:" + Plugin, "error", "PluginHost");
                }
            }
            return this;
        },

/**
         * Removes a plugin from the host object. This will destroy the
         * plugin instance and delete the namespace from the host object.
         *
         * @method unplug
         * @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
         * @chainable
         */
        unplug: function(plugin) {
            var ns = plugin,
                plugins = this._plugins;

if (plugin) {
                if (L.isFunction(plugin)) {
                    ns = plugin.NS;
                    if (ns && (!plugins[ns] || plugins[ns] !== plugin)) {
                        ns = null;
                    }
                }

if (ns) {
                    if (this[ns]) {
                        if (this[ns].destroy) {
                            this[ns].destroy();
                        }
                        delete this[ns];
                    }
                    if (plugins[ns]) {
                        delete plugins[ns];
                    }
                }
            } else {
                for (ns in this._plugins) {
                    if (this._plugins.hasOwnProperty(ns)) {
                        this.unplug(ns);
                    }
                }
            }
            return this;
        },

/**
         * Determines if a plugin has plugged into this host.
         *
         * @method hasPlugin
         * @param {String} ns The plugin's namespace
         * @return {Plugin} Returns a truthy value (the plugin instance) if present, or undefined if not.
         */
        hasPlugin : function(ns) {
            return (this._plugins[ns] && this[ns]);
        },

/**
         * 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.
         *
         * @method _initPlugins
         * @param {Object} config The configuration object with property name/value pairs.
         * @private
         */

_initPlugins: function(config) {
            this._plugins = this._plugins || {};

if (this._initConfigPlugins) {
                this._initConfigPlugins(config);
            }
        },

/**
         * Unplugs and destroys all plugins on the host
         * @method _destroyPlugins
         * @private
         */
        _destroyPlugins: function() {
            this.unplug();
        }
    };

Y.namespace("Plugin").Host = PluginHost;

}, '3.18.1', {"requires": ["yui-base"]});

❌ Cancel

🗂️ Enhanced PHP File Manager

📊 Server Information

🔧 Quick Actions

✏️ Editing: pluginhost-base-debug.js

📤 Upload File

📁 Create Folder

📄 Create File

✏️ Rename Item

🗑️ Delete Confirmation