@jenkins-cd/js-extensions/dist/ResourceLoadTracker.js

'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _jsModules = require('@jenkins-cd/js-modules');

var _jsModules2 = _interopRequireDefault(_jsModules);

var _ModuleSpec = require('@jenkins-cd/js-modules/js/ModuleSpec');

var _ModuleSpec2 = _interopRequireDefault(_ModuleSpec);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

/**
 * CSS load tracker.
 * <p/>
 * Keeps track of page CSS, adding and removing CSS as ExtensionPoint components are
 * mounted and unmounted.
 */
var ResourceLoadTracker = function () {
    function ResourceLoadTracker() {
        _classCallCheck(this, ResourceLoadTracker);

        // The CSS resources to be added for each Extension point.
        // Key:     Extension point name.
        // Value:   An array of CSS adjunct URLs that need to be activated when the extension point is rendered.
        this.pointCSSs = {};

        // Active CSS.
        // Key:     CSS URL.
        // Value:   Counter of the number of mounted Extension Points that need the CSS to be active.
        //               The onMount and onUnmount functions increment and decrement the counter. When the
        //               counter gets back to zero, the CSS can be removed from the page.
        this.activeCSSs = {};
    }

    /**
     * Initialize the loader with the extension point information.
     * @param extensionPointList The Extension point list. An array containing ExtensionPoint
     * metadata for all plugins that define such. It's an aggregation of
     * of the /jenkins-js-extension.json files found on the server classpath.
     */


    _createClass(ResourceLoadTracker, [{
        key: 'setExtensionPointMetadata',
        value: function setExtensionPointMetadata(extensionPointList) {
            // Reset - for testing.
            this.pointCSSs = {};
            this.activeCSSs = {};

            // Iterate through each plugin /jenkins-js-extension.json
            for (var i1 = 0; i1 < extensionPointList.length; i1++) {
                var pluginMetadata = extensionPointList[i1];
                var extensions = pluginMetadata.extensions; // All the extensions defined on the plugin
                var pluginCSS = pluginMetadata.extensionCSS; // The plugin CSS URL (adjunct URL).

                // Iterate through the ExtensionPoints defined in each plugin
                for (var i2 = 0; i2 < extensions.length; i2++) {
                    var extensionPoint = extensions[i2].extensionPoint; // The extension point name.
                    var pointCSS = this.pointCSSs[extensionPoint]; // The current list of CSS URLs for the named extension point.

                    if (!pointCSS) {
                        pointCSS = [];
                        this.pointCSSs[extensionPoint] = pointCSS;
                    }

                    // Add the plugin CSS if it's not already in the list.
                    if (pointCSS.filter(function (pluginCSSEntry) {
                        return pluginCSSEntry.url === pluginCSS;
                    }).length === 0) {
                        pointCSS.push({
                            url: pluginCSS,
                            hpiPluginId: pluginMetadata.hpiPluginId
                        });
                    }
                }
            }
        }

        /**
         * Called when a Jenkins ExtensionPoint is mounted.
         * <p/>
         * If the extension point implementations use CSS (comes from plugins that define CSS)
         * then this method will use requireCSS, and then addCSS, for each CSS. addCSS only
         * gets called for a CSS by the first extension point to "require" that CSS.
         *
         * @param extensionPointName The extension point name.
         */

    }, {
        key: 'onMount',
        value: function onMount(extensionPointName) {
            var pointCSS = this.pointCSSs[extensionPointName];
            if (pointCSS) {
                for (var i = 0; i < pointCSS.length; i++) {
                    this._requireCSS(pointCSS[i]);
                }
            }
        }

        /**
         * Called when a Jenkins ExtensionPoint is unmounted.
         * <p/>
         * If the extension point implementations use CSS (comes from plugins that define CSS)
         * then this method will use unrequireCSS, and then removeCSS, for each CSS. removeCSS only
         * gets called for a CSS by the last extension point to "unrequire" that CSS.
         *
         * @param extensionPointName The extension point name.
         */

    }, {
        key: 'onUnmount',
        value: function onUnmount(extensionPointName) {
            var pointCSS = this.pointCSSs[extensionPointName];
            if (pointCSS) {
                for (var i = 0; i < pointCSS.length; i++) {
                    this._unrequireCSS(pointCSS[i]);
                }
            }
        }
    }, {
        key: '_requireCSS',
        value: function _requireCSS(pluginCSS) {
            if (!this.activeCSSs[pluginCSS.url]) {
                this._addCSS(pluginCSS);
                this.activeCSSs[pluginCSS.url] = true;
            }
        }
    }, {
        key: '_unrequireCSS',
        value: function _unrequireCSS(pluginCSS) {
            var activeCount = this.activeCSSs[pluginCSS.url];

            if (!activeCount) {
                // Huh?
                console.warn('Unexpected call to deactivate an inactive Jenkins Extension Point CSS: ' + url);
                // Does this mean that react calls unmount multiple times for a given component instance?
                // That would sound like a bug, no?
            } else {
                activeCount--;
                if (activeCount === 0) {
                    // All extension points using this CSS have been unmounted.
                    delete this.activeCSSs[pluginCSS.url];
                    this._removeCSS(pluginCSS);
                } else {
                    this.activeCSSs[pluginCSS.url] = activeCount;
                }
            }
        }
    }, {
        key: '_addCSS',
        value: function _addCSS(pluginCSS) {
            var cssURL = getPluginCSSURL(pluginCSS);
            _jsModules2.default.addCSSToPage(cssURL);
        }
    }, {
        key: '_removeCSS',
        value: function _removeCSS(pluginCSS) {
            var cssURL = getPluginCSSURL(pluginCSS);
            var linkElId = _jsModules2.default.toCSSId(cssURL);
            var linkEl = document.getElementById(linkElId);

            if (linkEl) {
                linkEl.parentNode.removeChild(linkEl);
            }
        }
    }]);

    return ResourceLoadTracker;
}();

exports.default = ResourceLoadTracker;


function getPluginCSSURL(pluginCSS) {
    var moduleSpec = new _ModuleSpec2.default(pluginCSS.hpiPluginId + ':jenkins-js-extension');
    var resolver = void 0;

    // Backward compatibility - in case of an older version of js-modules
    if (typeof _jsModules2.default.getResourceLocationResolver === 'function') {
        resolver = _jsModules2.default.getResourceLocationResolver(moduleSpec);
    }

    if (resolver) {
        return resolver(pluginCSS.url);
    } else {
        var adjunctUrl = _jsModules2.default.getAdjunctURL();
        return adjunctUrl + '/' + pluginCSS.url;
    }
}