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

'use strict';

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

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

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; }; }();

function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

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

/**
 * ClassMetadataStore is responsible for maintaining extension metadata
 * including type/capability info
 */
var ClassMetadataStore = function () {
    function ClassMetadataStore() {
        _classCallCheck(this, ClassMetadataStore);
    }

    _createClass(ClassMetadataStore, [{
        key: 'init',
        value: function init(classMetadataProvider) {
            /**
             * Type info cache
             */
            this.classMetadata = {};

            /**
             * Fetch function for the classMetadata
             */
            this.classMetadataProvider = classMetadataProvider;

            /**
             * Onload callbacks cache. Used to ensure we don't
             * issue multiple in-parallel requests for the same
             * class metadata.
             */
            this.classMetadataOnloadCallbacks = {};
        }

        /**
         * Gets the type/capability info for the given data type
         */

    }, {
        key: 'getClassMetadata',
        value: function getClassMetadata(type, onload) {
            var _this = this;

            var classMeta = this.classMetadata[type];
            if (classMeta) {
                return onload(classMeta);
            }

            var callbacks = this.classMetadataOnloadCallbacks[type];
            if (!callbacks) {
                // This is the first request for this type. Initialise the
                // callback cache and then issue the request to
                // the classMetadataProvider.
                callbacks = this.classMetadataOnloadCallbacks[type] = [onload];
                this.classMetadataProvider(type, function (data) {
                    classMeta = _this.classMetadata[type] = JSON.parse(JSON.stringify(data));
                    classMeta.classes = classMeta.classes || [];
                    // Make sure the type itself is in the list
                    if (classMeta.classes.indexOf(type) < 0) {
                        classMeta.classes = [type].concat(_toConsumableArray(classMeta.classes));
                    }
                    delete _this.classMetadataOnloadCallbacks[type];

                    // Notify all callbacks
                    for (var i = 0; i < callbacks.length; i++) {
                        try {
                            callbacks[i](classMeta);
                        } catch (e) {
                            console.error('Unexpected Error in ClassMetadataStore onload callback function.', e);
                        }
                    }
                });
            } else {
                // We already have an inflight request to get class metadata info about
                // the requested type, so nothing to do except store the onload callback.
                callbacks.push(onload);
            }
        }
    }, {
        key: 'dataType',
        value: function dataType(_dataType) {
            var _this2 = this;

            return function (extensions, onload) {
                if (_dataType && (typeof _dataType === 'undefined' ? 'undefined' : _typeof(_dataType)) === 'object' && '_class' in _dataType) {
                    // handle the common API incoming data
                    _dataType = _dataType._class;
                }

                _this2.getClassMetadata(_dataType, function (currentTypeInfo) {
                    // prevent returning extensions for the given type
                    // when a more specific extension is found
                    var matchingExtensions = [];
                    eachType: for (var typeIndex = 0; typeIndex < currentTypeInfo.classes.length; typeIndex++) {
                        // currentTypeInfo.classes is ordered by java hierarchy, including
                        // and beginning with the current data type
                        var type = currentTypeInfo.classes[typeIndex];
                        for (var i = 0; i < extensions.length; i++) {
                            var extension = extensions[i];
                            if (type === extension.dataType) {
                                matchingExtensions.push(extension);
                            }
                        }
                        // if we have this specific type handled, don't
                        // proceed to parent types
                        if (matchingExtensions.length > 0) {
                            break eachType;
                        }
                    }
                    onload(matchingExtensions);
                });
            };
        }

        /**
         * Returns a filtering function to only return untyped extensions
         */

    }, {
        key: 'untyped',
        value: function untyped() {
            return function (extensions, onload) {
                // exclude typed extensions when types not requested
                extensions = extensions.filter(function (m) {
                    return !('dataType' in m);
                });
                onload(extensions);
            };
        }
    }]);

    return ClassMetadataStore;
}();

exports.default = ClassMetadataStore;