wikimedia/mediawiki-extensions-Translate

/* eslint-disable */
/*!
 * Positions elements relative to other elements.
 * Borrowed from jquery.ui.position and updated to remove unused code.
 * Does not pollute the global jQuery or jQuery.ui objects
 * Does not support all options supported by jQuery.ui.position
 * Changes:
 * - The 'using' option is not supported
 * - Only 'collision': 'flip' is supported.
 * - In options, the 'of' parameter must always be provided
 * Upstream commit: https://github.com/jquery/jquery-ui/commit/0df6e658307f8936a477deb9674d643d18a2469b
 */
'use strict';

var cachedScrollbarWidth,
    abs = Math.abs,
    rhorizontal = /left|center|right/,
    rvertical = /top|center|bottom/,
    roffset = /[\+\-]\d+(\.[\d]+)?%?/,
    rposition = /^\w+/,
    rpercent = /%$/;

function getOffsets( offsets, width, height ) {
    return [
        parseFloat( offsets[ 0 ] ) * ( rpercent.test( offsets[ 0 ] ) ? width / 100 : 1 ),
        parseFloat( offsets[ 1 ] ) * ( rpercent.test( offsets[ 1 ] ) ? height / 100 : 1 )
    ];
}

function parseCss( element, property ) {
    return parseInt( $.css( element, property ), 10 ) || 0;
}

function isWindow( obj ) {
    return obj != null && obj === obj.window;
}

function getDimensions( elem ) {
    var raw = elem[ 0 ];
    if ( raw.nodeType === 9 ) {
        return {
            width: elem.width(),
            height: elem.height(),
            offset: { top: 0, left: 0 }
        };
    }
    if ( isWindow( raw ) ) {
        return {
            width: elem.width(),
            height: elem.height(),
            offset: { top: elem.scrollTop(), left: elem.scrollLeft() }
        };
    }
    if ( raw.preventDefault ) {
        return {
            width: 0,
            height: 0,
            offset: { top: raw.pageY, left: raw.pageX }
        };
    }
    return {
        width: elem.outerWidth(),
        height: elem.outerHeight(),
        offset: elem.offset()
    };
}

function scrollbarWidth() {
    if ( cachedScrollbarWidth !== undefined ) {
        return cachedScrollbarWidth;
    }
    var w1, w2,
        div = $( '<div style=' +
            "'display:block;position:absolute;width:200px;height:200px;overflow:hidden;'>" +
            "<div style='height:300px;width:auto;'></div></div>" ),
        innerDiv = div.children()[ 0 ];

    $( 'body' ).append( div );
    w1 = innerDiv.offsetWidth;
    div.css( 'overflow', 'scroll' );

    w2 = innerDiv.offsetWidth;

    if ( w1 === w2 ) {
        w2 = div[ 0 ].clientWidth;
    }

    div.remove();

    return cachedScrollbarWidth = w1 - w2;
}

function getScrollInfo( within ) {
    var overflowX = within.isWindow || within.isDocument ? '' :
            within.element.css( 'overflow-x' ),
        overflowY = within.isWindow || within.isDocument ? '' :
            within.element.css( 'overflow-y' ),
        hasOverflowX = overflowX === 'scroll' ||
            ( overflowX === 'auto' && within.width < within.element[ 0 ].scrollWidth ),
        hasOverflowY = overflowY === 'scroll' ||
            ( overflowY === 'auto' && within.height < within.element[ 0 ].scrollHeight );
    return {
        width: hasOverflowY ? scrollbarWidth() : 0,
        height: hasOverflowX ? scrollbarWidth() : 0
    };
}

function getWithinInfo( element ) {
    var withinElement = $( element || window ),
        isElemWindow = isWindow( withinElement[ 0 ] ),
        isDocument = !!withinElement[ 0 ] && withinElement[ 0 ].nodeType === 9,
        hasOffset = !isElemWindow && !isDocument;
    return {
        element: withinElement,
        isWindow: isElemWindow,
        isDocument: isDocument,
        offset: hasOffset ? $( element ).offset() : { left: 0, top: 0 },
        scrollLeft: withinElement.scrollLeft(),
        scrollTop: withinElement.scrollTop(),
        width: withinElement.outerWidth(),
        height: withinElement.outerHeight()
    };
}

var flip = {
    left: function ( position, data ) {
        var within = data.within,
            withinOffset = within.offset.left + within.scrollLeft,
            outerWidth = within.width,
            offsetLeft = within.isWindow ? within.scrollLeft : within.offset.left,
            collisionPosLeft = position.left - data.collisionPosition.marginLeft,
            overLeft = collisionPosLeft - offsetLeft,
            overRight = collisionPosLeft + data.collisionWidth - outerWidth - offsetLeft,
            myOffset = data.my[ 0 ] === 'left' ?
                -data.elemWidth :
                data.my[ 0 ] === 'right' ?
                    data.elemWidth :
                    0,
            atOffset = data.at[ 0 ] === 'left' ?
                data.targetWidth :
                data.at[ 0 ] === 'right' ?
                    -data.targetWidth :
                    0,
            offset = -2 * data.offset[ 0 ],
            newOverRight,
            newOverLeft;

        if ( overLeft < 0 ) {
            newOverRight = position.left + myOffset + atOffset + offset + data.collisionWidth -
                outerWidth - withinOffset;
            if ( newOverRight < 0 || newOverRight < abs( overLeft ) ) {
                position.left += myOffset + atOffset + offset;
            }
        } else if ( overRight > 0 ) {
            newOverLeft = position.left - data.collisionPosition.marginLeft + myOffset +
                atOffset + offset - offsetLeft;
            if ( newOverLeft > 0 || abs( newOverLeft ) < overRight ) {
                position.left += myOffset + atOffset + offset;
            }
        }
    },
    top: function ( position, data ) {
        var within = data.within,
            withinOffset = within.offset.top + within.scrollTop,
            outerHeight = within.height,
            offsetTop = within.isWindow ? within.scrollTop : within.offset.top,
            collisionPosTop = position.top - data.collisionPosition.marginTop,
            overTop = collisionPosTop - offsetTop,
            overBottom = collisionPosTop + data.collisionHeight - outerHeight - offsetTop,
            top = data.my[ 1 ] === 'top',
            myOffset = top ?
                -data.elemHeight :
                data.my[ 1 ] === 'bottom' ?
                    data.elemHeight :
                    0,
            atOffset = data.at[ 1 ] === 'top' ?
                data.targetHeight :
                data.at[ 1 ] === 'bottom' ?
                    -data.targetHeight :
                    0,
            offset = -2 * data.offset[ 1 ],
            newOverTop,
            newOverBottom;
        if ( overTop < 0 ) {
            newOverBottom = position.top + myOffset + atOffset + offset + data.collisionHeight -
                outerHeight - withinOffset;
            if ( newOverBottom < 0 || newOverBottom < abs( overTop ) ) {
                position.top += myOffset + atOffset + offset;
            }
        } else if ( overBottom > 0 ) {
            newOverTop = position.top - data.collisionPosition.marginTop + myOffset + atOffset +
                offset - offsetTop;
            if ( newOverTop > 0 || abs( newOverTop ) < overBottom ) {
                position.top += myOffset + atOffset + offset;
            }
        }
    }
};

function positionElement( $targetElem, options ) {
    // Make a copy, we don't want to modify arguments
    options = $.extend( {}, options );

    var atOffset, targetWidth, targetHeight, targetOffset, basePosition, dimensions,

        // Make sure string options are treated as CSS selectors
        target = typeof options.of === 'string' ?
            $( document ).find( options.of ) :
            $( options.of ),

        within = getWithinInfo( options.within ),
        scrollInfo = getScrollInfo( within ),
        offsets = {};

    dimensions = getDimensions( target );
    if ( target[ 0 ].preventDefault ) {

        // Force left top to allow flipping
        options.at = 'left top';
    }
    targetWidth = dimensions.width;
    targetHeight = dimensions.height;
    targetOffset = dimensions.offset;

    // Clone to reuse original targetOffset later
    basePosition = $.extend( {}, targetOffset );

    // Force my and at to have valid horizontal and vertical positions
    // if a value is missing or invalid, it will be converted to center
    $.each( [ 'my', 'at' ], function () {
        var pos = ( options[ this ] || '' ).split( ' ' ),
            horizontalOffset,
            verticalOffset;

        if ( pos.length === 1 ) {
            pos = rhorizontal.test( pos[ 0 ] ) ?
                pos.concat( [ 'center' ] ) :
                rvertical.test( pos[ 0 ] ) ?
                    [ 'center' ].concat( pos ) :
                    [ 'center', 'center' ];
        }
        pos[ 0 ] = rhorizontal.test( pos[ 0 ] ) ? pos[ 0 ] : 'center';
        pos[ 1 ] = rvertical.test( pos[ 1 ] ) ? pos[ 1 ] : 'center';

        // Calculate offsets
        horizontalOffset = roffset.exec( pos[ 0 ] );
        verticalOffset = roffset.exec( pos[ 1 ] );
        offsets[ this ] = [
            horizontalOffset ? horizontalOffset[ 0 ] : 0,
            verticalOffset ? verticalOffset[ 0 ] : 0
        ];

        // Reduce to just the positions without the offsets
        options[ this ] = [
            rposition.exec( pos[ 0 ] )[ 0 ],
            rposition.exec( pos[ 1 ] )[ 0 ]
        ];
    } );

    if ( options.at[ 0 ] === 'right' ) {
        basePosition.left += targetWidth;
    } else if ( options.at[ 0 ] === 'center' ) {
        basePosition.left += targetWidth / 2;
    }

    if ( options.at[ 1 ] === 'bottom' ) {
        basePosition.top += targetHeight;
    } else if ( options.at[ 1 ] === 'center' ) {
        basePosition.top += targetHeight / 2;
    }

    atOffset = getOffsets( offsets.at, targetWidth, targetHeight );
    basePosition.left += atOffset[ 0 ];
    basePosition.top += atOffset[ 1 ];

    return $targetElem.each( function () {
        var collisionPosition,
            elem = $( this ),
            elemWidth = elem.outerWidth(),
            elemHeight = elem.outerHeight(),
            marginLeft = parseCss( this, 'marginLeft' ),
            marginTop = parseCss( this, 'marginTop' ),
            collisionWidth = elemWidth + marginLeft + parseCss( this, 'marginRight' ) +
                scrollInfo.width,
            collisionHeight = elemHeight + marginTop + parseCss( this, 'marginBottom' ) +
                scrollInfo.height,
            position = $.extend( {}, basePosition ),
            myOffset = getOffsets( offsets.my, elem.outerWidth(), elem.outerHeight() );

        if ( options.my[ 0 ] === 'right' ) {
            position.left -= elemWidth;
        } else if ( options.my[ 0 ] === 'center' ) {
            position.left -= elemWidth / 2;
        }

        if ( options.my[ 1 ] === 'bottom' ) {
            position.top -= elemHeight;
        } else if ( options.my[ 1 ] === 'center' ) {
            position.top -= elemHeight / 2;
        }

        position.left += myOffset[ 0 ];
        position.top += myOffset[ 1 ];

        collisionPosition = {
            marginLeft: marginLeft,
            marginTop: marginTop
        };

        $.each( [ 'left', 'top' ], function ( i, dir ) {
            flip[ dir ]( position, {
                targetWidth: targetWidth,
                targetHeight: targetHeight,
                elemWidth: elemWidth,
                elemHeight: elemHeight,
                collisionPosition: collisionPosition,
                collisionWidth: collisionWidth,
                collisionHeight: collisionHeight,
                offset: [ atOffset[ 0 ] + myOffset[ 0 ], atOffset[ 1 ] + myOffset[ 1 ] ],
                my: options.my,
                at: options.at,
                within: within,
                elem: elem
            } );
        } );

        elem.offset( position );
    } );
}

module.exports = positionElement;