superdesk-ui-framework 6.1.0-dev1 → 7.0.0-dev-hg0

package/app/scripts/helpers/modal.helper.js

@@ -1,464 +0,0 @@
-/* eslint-disable */
-
-angular.module('superdesk-ui.helper.modal', []).factory('$$stackedMap', () => ({
-    createNew: function createNew() {
-        var stack = [];
-
-        return {
-            add: function add(key, value) {
-                stack.push({
-                    key: key,
-                    value: value
-                });
-            },
-            get: function get(key) {
-                for (var i = 0; i < stack.length; i++) {
-                    if (key == stack[i].key) {
-                        return stack[i];
-                    }
-                }
-            },
-            keys: function keys() {
-                var keys = [];
-
-                for (var i = 0; i < stack.length; i++) {
-                    keys.push(stack[i].key);
-                }
-                return keys;
-            },
-            top: function top() {
-                return stack[stack.length - 1];
-            },
-            remove: function remove(key) {
-                var idx = -1;
-
-                for (var i = 0; i < stack.length; i++) {
-                    if (key == stack[i].key) {
-                        idx = i;
-                        break;
-                    }
-                }
-                return stack.splice(idx, 1)[0];
-            },
-            removeTop: function removeTop() {
-                return stack.splice(stack.length - 1, 1)[0];
-            },
-            length: function length() {
-                return stack.length;
-            }
-        };
-    }
-}))
-
-/**
- * A helper directive for the $modal service. It creates a backdrop element.
- */
-    .directive('modalBackdrop', ['$animate', '$modalStack', function($animate, $modalStack) {
-        return {
-            restrict: 'EA',
-            replace: true,
-            template: require('../../template/backdrop.html'),
-            compile: function compile(tElement, tAttrs) {
-                tElement.addClass(tAttrs.backdropClass);
-                return linkFn;
-            }
-        };
-        function linkFn(scope, element, attrs) {
-            if (attrs.modalInClass) {
-                $animate.addClass(element, attrs.modalInClass);
-                scope.$on($modalStack.NOW_CLOSING_EVENT, (e, setIsAsync) => {
-                    var done = setIsAsync();
-
-                    $animate.removeClass(element, attrs.modalInClass).then(done);
-                });
-            }
-        }
-    }])
-    .directive('modalWindow', ['$modalStack', '$q', '$animate', function($modalStack, $q, $animate) {
-        return {
-            restrict: 'EA',
-            scope: {
-                index: '@'
-            },
-            replace: true,
-            transclude: true,
-//            templateUrl: function templateUrl(tElement, tAttrs) {
-//                return tAttrs.templateUrl || '../app/template/window.html';
-//            },
-            template: require('../../template/window.html'),
-            link: function link(scope, element, attrs) {
-                element.addClass(attrs.windowClass || '');
-                scope.size = attrs.size;
-                scope.close = function(evt) {
-                    var modal = $modalStack.getTop();
-
-                    if (modal && modal.value.backdrop && modal.value.backdrop != 'static' && evt.target === evt.currentTarget) {
-                        evt.preventDefault();
-                        evt.stopPropagation();
-                        $modalStack.dismiss(modal.key, 'backdrop click');
-                    }
-                };
-                // This property is only added to the scope for the purpose of detecting when this directive is rendered.
-                // We can detect that by using this property in the template associated with this directive and then use
-                // {@link Attribute#$observe} on it. For more details please see {@link TableColumnResize}.
-                scope.$isRendered = true;
-                // Deferred object that will be resolved when this modal is render.
-                var modalRenderDeferObj = $q.defer();
-                // Observe function will be called on next digest cycle after compilation, ensuring that the DOM is ready.
-                // In order to use this way of finding whether DOM is ready, we need to observe a scope property used in modal's template.
-
-                attrs.$observe('modalRender', (value) => {
-                    if (value == 'true') {
-                        modalRenderDeferObj.resolve();
-                    }
-                });
-                modalRenderDeferObj.promise.then(() => {
-                    if (attrs.modalInClass) {
-                        $animate.addClass(element, attrs.modalInClass);
-                        scope.$on($modalStack.NOW_CLOSING_EVENT, (e, setIsAsync) => {
-                            var done = setIsAsync();
-
-                            $animate.removeClass(element, attrs.modalInClass).then(done);
-                        });
-                    }
-
-                    var inputsWithAutofocus = element[0].querySelectorAll('[autofocus]');
-                    /**
-                * Auto-focusing of a freshly-opened modal element causes any child elements
-                * with the autofocus attribute to lose focus. This is an issue on touch
-                * based devices which will show and then hide the onscreen keyboard.
-                * Attempts to refocus the autofocus element via JavaScript will not reopen
-                * the onscreen keyboard. Fixed by updated the focusing logic to only autofocus
-                * the modal element if the modal does not contain an autofocus element.
-                */
-
-                    if (inputsWithAutofocus.length) {
-                        inputsWithAutofocus[0].focus();
-                    } else {
-                        element[0].focus();
-                    }
-
-                    // Notify {@link $modalStack} that modal is rendered.
-                    var modal = $modalStack.getTop();
-
-                    if (modal) {
-                        $modalStack.modalRendered(modal.key);
-                    }
-                });
-            }
-        };
-    }])
-    .directive('modalAnimationClass', [function() {
-        return {
-            compile: function compile(tElement, tAttrs) {
-                if (tAttrs.modalAnimation) {
-                    tElement.addClass(tAttrs.modalAnimationClass);
-                }
-            }
-        };
-    }])
-    .directive('modalTransclude', () => ({
-        link: function link($scope, $element, $attrs, controller, $transclude) {
-            $transclude($scope.$parent, (clone) => {
-                $element.empty();
-                $element.append(clone);
-            });
-        }
-    }))
-    .factory('$modalStack', ['$animate', '$timeout', '$document', '$compile', '$rootScope', '$q', '$$stackedMap', function($animate, $timeout, $document, $compile, $rootScope, $q, $$stackedMap) {
-        var OPENED_MODAL_CLASS = 'modal-open';
-        var backdropDomEl, backdropScope;
-        var openedWindows = $$stackedMap.createNew();
-        var $modalStack = {
-            NOW_CLOSING_EVENT: 'modal.stack.now-closing'
-        };
-
-        function backdropIndex() {
-            var topBackdropIndex = -1;
-            var opened = openedWindows.keys();
-
-            for (var i = 0; i < opened.length; i++) {
-                if (openedWindows.get(opened[i]).value.backdrop) {
-                    topBackdropIndex = i;
-                }
-            }
-            return topBackdropIndex;
-        }
-
-        $rootScope.$watch(backdropIndex, (newBackdropIndex) => {
-            if (backdropScope) {
-                backdropScope.index = newBackdropIndex;
-            }
-        });
-        function removeModalWindow(modalInstance, elementToReceiveFocus) {
-            var body = $document.find('body').eq(0);
-            var modalWindow = openedWindows.get(modalInstance).value;
-            // clean up the stack
-
-            openedWindows.remove(modalInstance);
-            removeAfterAnimate(modalWindow.modalDomEl, modalWindow.modalScope, () => {
-                body.toggleClass(OPENED_MODAL_CLASS, openedWindows.length() > 0);
-                checkRemoveBackdrop();
-            });
-            // move focus to specified element if available, or else to body
-            if (elementToReceiveFocus && elementToReceiveFocus.focus) {
-                elementToReceiveFocus.focus();
-            } else {
-                body.focus();
-            }
-        }
-
-        function checkRemoveBackdrop() {
-        // remove backdrop if no longer needed
-            if (backdropDomEl && backdropIndex() == -1) {
-                var backdropScopeRef = backdropScope;
-
-                removeAfterAnimate(backdropDomEl, backdropScope, () => {
-                    backdropScopeRef = null;
-                });
-                backdropDomEl = undefined;
-                backdropScope = undefined;
-            }
-        }
-
-        function removeAfterAnimate(domEl, scope, done) {
-            var asyncDeferred;
-            var asyncPromise = null;
-            var setIsAsync = function setIsAsync() {
-                if (!asyncDeferred) {
-                    asyncDeferred = $q.defer();
-                    asyncPromise = asyncDeferred.promise;
-                }
-
-                return function asyncDone() {
-                    asyncDeferred.resolve();
-                };
-            };
-
-            scope.$broadcast($modalStack.NOW_CLOSING_EVENT, setIsAsync);
-            // Note that it's intentional that asyncPromise might be null.
-            // That's when setIsAsync has not been called during the
-            // NOW_CLOSING_EVENT broadcast.
-            return $q.when(asyncPromise).then(afterAnimating);
-            function afterAnimating() {
-                if (afterAnimating.done) {
-                    return;
-                }
-                afterAnimating.done = true;
-                domEl.remove();
-                scope.$destroy();
-                if (done) {
-                    done();
-                }
-            }
-        }
-
-        $document.bind('keydown', (evt) => {
-            var modal;
-
-            if (evt.which === 27) {
-                modal = openedWindows.top();
-                if (modal && modal.value.keyboard) {
-                    evt.preventDefault();
-                    $rootScope.$apply(() => {
-                        $modalStack.dismiss(modal.key, 'escape key press');
-                    });
-                }
-            }
-        });
-        $modalStack.open = function(modalInstance, modal) {
-            var modalOpener = $document[0].activeElement;
-
-            openedWindows.add(modalInstance, {
-                deferred: modal.deferred,
-                renderDeferred: modal.renderDeferred,
-                modalScope: modal.scope,
-                backdrop: modal.backdrop,
-                keyboard: modal.keyboard
-            });
-            var body = $document.find('body').eq(0),
-                currBackdropIndex = backdropIndex();
-
-            if (currBackdropIndex >= 0 && !backdropDomEl) {
-                backdropScope = $rootScope.$new(true);
-                backdropScope.index = currBackdropIndex;
-                var angularBackgroundDomEl = angular.element('<div modal-backdrop="modal-backdrop"></div>');
-
-                angularBackgroundDomEl.attr('backdrop-class', modal.backdropClass);
-                if (modal.animation) {
-                    angularBackgroundDomEl.attr('modal-animation', 'true');
-                }
-                backdropDomEl = $compile(angularBackgroundDomEl)(backdropScope);
-                body.append(backdropDomEl);
-            }
-
-            var angularDomEl = angular.element('<div modal-window="modal-window"></div>');
-
-            angularDomEl.attr({
-                'template-url': modal.windowTemplateUrl,
-                'window-class': modal.windowClass,
-                size: modal.size,
-                index: openedWindows.length() - 1,
-                animate: 'animate'
-            }).html(modal.content);
-            if (modal.animation) {
-                angularDomEl.attr('modal-animation', 'true');
-            }
-
-            var modalDomEl = $compile(angularDomEl)(modal.scope);
-
-            openedWindows.top().value.modalDomEl = modalDomEl;
-            openedWindows.top().value.modalOpener = modalOpener;
-            body.append(modalDomEl);
-            body.addClass(OPENED_MODAL_CLASS);
-        };
-        function broadcastClosing(modalWindow, resultOrReason, closing) {
-            return !modalWindow.value.modalScope.$broadcast('modal.closing', resultOrReason, closing).defaultPrevented;
-        }
-
-        $modalStack.close = function(modalInstance, result) {
-            var modalWindow = openedWindows.get(modalInstance);
-
-            if (modalWindow && broadcastClosing(modalWindow, result, true)) {
-                modalWindow.value.deferred.resolve(result);
-                removeModalWindow(modalInstance, modalWindow.value.modalOpener);
-                return true;
-            }
-            return !modalWindow;
-        };
-        $modalStack.dismiss = function(modalInstance, reason) {
-            var modalWindow = openedWindows.get(modalInstance);
-
-            if (modalWindow && broadcastClosing(modalWindow, reason, false)) {
-                modalWindow.value.deferred.reject(reason);
-                removeModalWindow(modalInstance, modalWindow.value.modalOpener);
-                return true;
-            }
-            return !modalWindow;
-        };
-        $modalStack.dismissAll = function(reason) {
-            var topModal = this.getTop();
-
-            while (topModal && this.dismiss(topModal.key, reason)) {
-                topModal = this.getTop();
-            }
-        };
-        $modalStack.getTop = function() {
-            return openedWindows.top();
-        };
-        $modalStack.modalRendered = function(modalInstance) {
-            var modalWindow = openedWindows.get(modalInstance);
-
-            if (modalWindow) {
-                modalWindow.value.renderDeferred.resolve();
-            }
-        };
-        return $modalStack;
-    }])
-    .provider('$modal', () => {
-        var $modalProvider = {
-            options: {
-                animation: true,
-                backdrop: true, // can also be false or 'static'
-                keyboard: true
-            },
-            $get: ['$injector', '$rootScope', '$q', '$templateRequest', '$controller', '$modalStack', function($injector, $rootScope, $q, $templateRequest, $controller, $modalStack) {
-                var $modal = {};
-
-                function getTemplatePromise(options) {
-                    return options.template ? $q.when(options.template) : $templateRequest(angular.isFunction(options.templateUrl) ? options.templateUrl() : options.templateUrl);
-                }
-
-                function getResolvePromises(resolves) {
-                    var promisesArr = [];
-
-                    angular.forEach(resolves, (value) => {
-                        if (angular.isFunction(value) || angular.isArray(value)) {
-                            promisesArr.push($q.when($injector.invoke(value)));
-                        }
-                    });
-                    return promisesArr;
-                }
-
-                $modal.open = function(modalOptions) {
-                    var modalResultDeferred = $q.defer();
-                    var modalOpenedDeferred = $q.defer();
-                    var modalRenderDeferred = $q.defer();
-                    // prepare an instance of a modal to be injected into controllers and returned to a caller
-                    var modalInstance = {
-                        result: modalResultDeferred.promise,
-                        opened: modalOpenedDeferred.promise,
-                        rendered: modalRenderDeferred.promise,
-                        close: function close(result) {
-                            return $modalStack.close(modalInstance, result);
-                        },
-                        dismiss: function dismiss(reason) {
-                            return $modalStack.dismiss(modalInstance, reason);
-                        }
-                    };
-                    // merge and clean up options
-
-                    modalOptions = angular.extend({}, $modalProvider.options, modalOptions);
-                    modalOptions.resolve = modalOptions.resolve || {};
-                    // verify options
-                    if (!modalOptions.template && !modalOptions.templateUrl) {
-                        throw new Error('One of template or templateUrl options is required.');
-                    }
-
-                    var templateAndResolvePromise = $q.all([getTemplatePromise(modalOptions)].concat(getResolvePromises(modalOptions.resolve)));
-
-                    templateAndResolvePromise.then(function resolveSuccess(tplAndVars) {
-                        var modalScope = (modalOptions.scope || $rootScope).$new();
-
-                        modalScope.$close = modalInstance.close;
-                        modalScope.$dismiss = modalInstance.dismiss;
-                        var ctrlInstance,
-                            ctrlLocals = {};
-                        var resolveIter = 1;
-                        // controllers
-
-                        if (modalOptions.controller) {
-                            ctrlLocals.$scope = modalScope;
-                            ctrlLocals.$modalInstance = modalInstance;
-                            angular.forEach(modalOptions.resolve, (value, key) => {
-                                ctrlLocals[key] = tplAndVars[resolveIter++];
-                            });
-                            ctrlInstance = $controller(modalOptions.controller, ctrlLocals);
-                            if (modalOptions.controllerAs) {
-                                if (modalOptions.bindToController) {
-                                    angular.extend(modalScope, ctrlInstance);
-                                } else {
-                                    modalScope[modalOptions.controllerAs] = ctrlInstance;
-                                }
-                            }
-                        }
-
-                        $modalStack.open(modalInstance, {
-                            scope: modalScope,
-                            deferred: modalResultDeferred,
-                            renderDeferred: modalRenderDeferred,
-                            content: tplAndVars[0],
-                            animation: modalOptions.animation,
-                            backdrop: modalOptions.backdrop,
-                            keyboard: modalOptions.keyboard,
-                            backdropClass: modalOptions.backdropClass,
-                            windowClass: modalOptions.windowClass,
-                            windowTemplateUrl: modalOptions.windowTemplateUrl,
-                            size: modalOptions.size
-                        });
-                    }, function resolveError(reason) {
-                        modalResultDeferred.reject(reason);
-                    });
-                    templateAndResolvePromise.then(() => {
-                        modalOpenedDeferred.resolve(true);
-                    }, (reason) => {
-                        modalOpenedDeferred.reject(reason);
-                    });
-                    return modalInstance;
-                };
-                return $modal;
-            }]
-        };
-
-        return $modalProvider;
-    });

package/app/scripts/helpers/position.helper.js

@@ -1,155 +0,0 @@
-/* eslint-disable */
-
-angular.module('superdesk-ui.helper.position', [])
-
-/**
- * A set of utility methods that can be use to retrieve position of DOM elements.
- * It is meant to be used where we need to absolute-position DOM elements in
- * relation to other, existing elements (this is the case for tooltips, popovers,
- * typeahead suggestions etc.).
- */
-.factory('$position', ['$document', '$window', function($document, $window) {
-    function getStyle(el, cssprop) {
-        if (el.currentStyle) {
-        // IE
-            return el.currentStyle[cssprop];
-        } else if ($window.getComputedStyle) {
-            return $window.getComputedStyle(el)[cssprop];
-        }
-        // finally try and get inline style
-        return el.style[cssprop];
-    }
-
-    /**
-* Checks if a given element is statically positioned
-* @param element - raw DOM element
-*/
-    function isStaticPositioned(element) {
-        return (getStyle(element, 'position') || 'static') === 'static';
-    }
-
-    /**
-* returns the closest, non-statically positioned parentOffset of a given element
-* @param element
-*/
-    var parentOffsetEl = function parentOffsetEl(element) {
-        var docDomEl = $document[0];
-        var offsetParent = element.offsetParent || docDomEl;
-
-        while (offsetParent && offsetParent !== docDomEl && isStaticPositioned(offsetParent)) {
-            offsetParent = offsetParent.offsetParent;
-        }
-        return offsetParent || docDomEl;
-    };
-
-    return {
-    /**
-     * Provides read-only equivalent of jQuery's position function:
-     * http://api.jquery.com/position/
-     */
-        position: function position(element) {
-            var elBCR = this.offset(element);
-            var offsetParentBCR = {top: 0, left: 0};
-            var offsetParentEl = parentOffsetEl(element[0]);
-
-            if (offsetParentEl != $document[0]) {
-                offsetParentBCR = this.offset(angular.element(offsetParentEl));
-                offsetParentBCR.top += offsetParentEl.clientTop - offsetParentEl.scrollTop;
-                offsetParentBCR.left += offsetParentEl.clientLeft - offsetParentEl.scrollLeft;
-            }
-
-            var boundingClientRect = element[0].getBoundingClientRect();
-
-            return {
-                width: boundingClientRect.width || element.prop('offsetWidth'),
-                height: boundingClientRect.height || element.prop('offsetHeight'),
-                top: elBCR.top - offsetParentBCR.top,
-                left: elBCR.left - offsetParentBCR.left
-            };
-        },
-
-        /**
-    * Provides read-only equivalent of jQuery's offset function:
-    * http://api.jquery.com/offset/
-    */
-        offset: function offset(element) {
-            var boundingClientRect = element[0].getBoundingClientRect();
-
-            return {
-                width: boundingClientRect.width || element.prop('offsetWidth'),
-                height: boundingClientRect.height || element.prop('offsetHeight'),
-                top: boundingClientRect.top + ($window.pageYOffset || $document[0].documentElement.scrollTop),
-                left: boundingClientRect.left + ($window.pageXOffset || $document[0].documentElement.scrollLeft)
-            };
-        },
-
-        /**
-    * Provides coordinates for the targetEl in relation to hostEl
-    */
-        positionElements: function positionElements(hostEl, targetEl, positionStr, appendToBody) {
-            var positionStrParts = positionStr.split('-');
-            var pos0 = positionStrParts[0],
-                pos1 = positionStrParts[1] || 'center';
-
-            var hostElPos, targetElWidth, targetElHeight, targetElPos;
-
-            hostElPos = appendToBody ? this.offset(hostEl) : this.position(hostEl);
-
-            targetElWidth = targetEl.prop('offsetWidth');
-            targetElHeight = targetEl.prop('offsetHeight');
-
-            var shiftWidth = {
-                center: function center() {
-                    return hostElPos.left + hostElPos.width / 2 - targetElWidth / 2;
-                },
-                left: function left() {
-                    return hostElPos.left;
-                },
-                right: function right() {
-                    return hostElPos.left + hostElPos.width;
-                }
-            };
-
-            var shiftHeight = {
-                center: function center() {
-                    return hostElPos.top + hostElPos.height / 2 - targetElHeight / 2;
-                },
-                top: function top() {
-                    return hostElPos.top;
-                },
-                bottom: function bottom() {
-                    return hostElPos.top + hostElPos.height;
-                }
-            };
-
-            switch (pos0) {
-            case 'right':
-                targetElPos = {
-                    top: shiftHeight[pos1](),
-                    left: shiftWidth[pos0]()
-                };
-                break;
-            case 'left':
-                targetElPos = {
-                    top: shiftHeight[pos1](),
-                    left: hostElPos.left - targetElWidth
-                };
-                break;
-            case 'bottom':
-                targetElPos = {
-                    top: shiftHeight[pos0](),
-                    left: shiftWidth[pos1]()
-                };
-                break;
-            default:
-                targetElPos = {
-                    top: hostElPos.top - targetElHeight,
-                    left: shiftWidth[pos1]()
-                };
-                break;
-            }
-
-            return targetElPos;
-        }
-    };
-}]);