--- /dev/null
+/*! jQuery UI - v1.12.1+0b7246b6eeadfa9e2696e22f3230f6452f8129dc - 2020-02-20
+ * http://jqueryui.com
+ * Includes: widget.js
+ * Copyright jQuery Foundation and other contributors; Licensed MIT */
+
+/* global define, require */
+/* eslint-disable no-param-reassign, new-cap, jsdoc/require-jsdoc */
+
+(function (factory) {
+ 'use strict';
+ if (typeof define === 'function' && define.amd) {
+ // AMD. Register as an anonymous module.
+ define(['jquery'], factory);
+ } else if (typeof exports === 'object') {
+ // Node/CommonJS
+ factory(require('jquery'));
+ } else {
+ // Browser globals
+ factory(window.jQuery);
+ }
+})(function ($) {
+ ('use strict');
+
+ $.ui = $.ui || {};
+
+ $.ui.version = '1.12.1';
+
+ /*!
+ * jQuery UI Widget 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+ //>>label: Widget
+ //>>group: Core
+ //>>description: Provides a factory for creating stateful widgets with a common API.
+ //>>docs: http://api.jqueryui.com/jQuery.widget/
+ //>>demos: http://jqueryui.com/widget/
+
+ // Support: jQuery 1.9.x or older
+ // $.expr[ ":" ] is deprecated.
+ if (!$.expr.pseudos) {
+ $.expr.pseudos = $.expr[':'];
+ }
+
+ // Support: jQuery 1.11.x or older
+ // $.unique has been renamed to $.uniqueSort
+ if (!$.uniqueSort) {
+ $.uniqueSort = $.unique;
+ }
+
+ var widgetUuid = 0;
+ var widgetHasOwnProperty = Array.prototype.hasOwnProperty;
+ var widgetSlice = Array.prototype.slice;
+
+ $.cleanData = (function (orig) {
+ return function (elems) {
+ var events, elem, i;
+ // eslint-disable-next-line eqeqeq
+ for (i = 0; (elem = elems[i]) != null; i++) {
+ // Only trigger remove when necessary to save time
+ events = $._data(elem, 'events');
+ if (events && events.remove) {
+ $(elem).triggerHandler('remove');
+ }
+ }
+ orig(elems);
+ };
+ })($.cleanData);
+
+ $.widget = function (name, base, prototype) {
+ var existingConstructor, constructor, basePrototype;
+
+ // ProxiedPrototype allows the provided prototype to remain unmodified
+ // so that it can be used as a mixin for multiple widgets (#8876)
+ var proxiedPrototype = {};
+
+ var namespace = name.split('.')[0];
+ name = name.split('.')[1];
+ var fullName = namespace + '-' + name;
+
+ if (!prototype) {
+ prototype = base;
+ base = $.Widget;
+ }
+
+ if ($.isArray(prototype)) {
+ prototype = $.extend.apply(null, [{}].concat(prototype));
+ }
+
+ // Create selector for plugin
+ $.expr.pseudos[fullName.toLowerCase()] = function (elem) {
+ return !!$.data(elem, fullName);
+ };
+
+ $[namespace] = $[namespace] || {};
+ existingConstructor = $[namespace][name];
+ constructor = $[namespace][name] = function (options, element) {
+ // Allow instantiation without "new" keyword
+ if (!this._createWidget) {
+ return new constructor(options, element);
+ }
+
+ // Allow instantiation without initializing for simple inheritance
+ // must use "new" keyword (the code above always passes args)
+ if (arguments.length) {
+ this._createWidget(options, element);
+ }
+ };
+
+ // Extend with the existing constructor to carry over any static properties
+ $.extend(constructor, existingConstructor, {
+ version: prototype.version,
+
+ // Copy the object used to create the prototype in case we need to
+ // redefine the widget later
+ _proto: $.extend({}, prototype),
+
+ // Track widgets that inherit from this widget in case this widget is
+ // redefined after a widget inherits from it
+ _childConstructors: []
+ });
+
+ basePrototype = new base();
+
+ // We need to make the options hash a property directly on the new instance
+ // otherwise we'll modify the options hash on the prototype that we're
+ // inheriting from
+ basePrototype.options = $.widget.extend({}, basePrototype.options);
+ $.each(prototype, function (prop, value) {
+ if (!$.isFunction(value)) {
+ proxiedPrototype[prop] = value;
+ return;
+ }
+ proxiedPrototype[prop] = (function () {
+ function _super() {
+ return base.prototype[prop].apply(this, arguments);
+ }
+
+ function _superApply(args) {
+ return base.prototype[prop].apply(this, args);
+ }
+
+ return function () {
+ var __super = this._super;
+ var __superApply = this._superApply;
+ var returnValue;
+
+ this._super = _super;
+ this._superApply = _superApply;
+
+ returnValue = value.apply(this, arguments);
+
+ this._super = __super;
+ this._superApply = __superApply;
+
+ return returnValue;
+ };
+ })();
+ });
+ constructor.prototype = $.widget.extend(
+ basePrototype,
+ {
+ // TODO: remove support for widgetEventPrefix
+ // always use the name + a colon as the prefix, e.g., draggable:start
+ // don't prefix for widgets that aren't DOM-based
+ widgetEventPrefix: existingConstructor
+ ? basePrototype.widgetEventPrefix || name
+ : name
+ },
+ proxiedPrototype,
+ {
+ constructor: constructor,
+ namespace: namespace,
+ widgetName: name,
+ widgetFullName: fullName
+ }
+ );
+
+ // If this widget is being redefined then we need to find all widgets that
+ // are inheriting from it and redefine all of them so that they inherit from
+ // the new version of this widget. We're essentially trying to replace one
+ // level in the prototype chain.
+ if (existingConstructor) {
+ $.each(existingConstructor._childConstructors, function (i, child) {
+ var childPrototype = child.prototype;
+
+ // Redefine the child widget using the same prototype that was
+ // originally used, but inherit from the new version of the base
+ $.widget(
+ childPrototype.namespace + '.' + childPrototype.widgetName,
+ constructor,
+ child._proto
+ );
+ });
+
+ // Remove the list of existing child constructors from the old constructor
+ // so the old child constructors can be garbage collected
+ delete existingConstructor._childConstructors;
+ } else {
+ base._childConstructors.push(constructor);
+ }
+
+ $.widget.bridge(name, constructor);
+
+ return constructor;
+ };
+
+ $.widget.extend = function (target) {
+ var input = widgetSlice.call(arguments, 1);
+ var inputIndex = 0;
+ var inputLength = input.length;
+ var key;
+ var value;
+
+ for (; inputIndex < inputLength; inputIndex++) {
+ for (key in input[inputIndex]) {
+ value = input[inputIndex][key];
+ if (
+ widgetHasOwnProperty.call(input[inputIndex], key) &&
+ value !== undefined
+ ) {
+ // Clone objects
+ if ($.isPlainObject(value)) {
+ target[key] = $.isPlainObject(target[key])
+ ? $.widget.extend({}, target[key], value)
+ : // Don't extend strings, arrays, etc. with objects
+ $.widget.extend({}, value);
+
+ // Copy everything else by reference
+ } else {
+ target[key] = value;
+ }
+ }
+ }
+ }
+ return target;
+ };
+
+ $.widget.bridge = function (name, object) {
+ var fullName = object.prototype.widgetFullName || name;
+ $.fn[name] = function (options) {
+ var isMethodCall = typeof options === 'string';
+ var args = widgetSlice.call(arguments, 1);
+ var returnValue = this;
+
+ if (isMethodCall) {
+ // If this is an empty collection, we need to have the instance method
+ // return undefined instead of the jQuery instance
+ if (!this.length && options === 'instance') {
+ returnValue = undefined;
+ } else {
+ this.each(function () {
+ var methodValue;
+ var instance = $.data(this, fullName);
+
+ if (options === 'instance') {
+ returnValue = instance;
+ return false;
+ }
+
+ if (!instance) {
+ return $.error(
+ 'cannot call methods on ' +
+ name +
+ ' prior to initialization; ' +
+ "attempted to call method '" +
+ options +
+ "'"
+ );
+ }
+
+ if (!$.isFunction(instance[options]) || options.charAt(0) === '_') {
+ return $.error(
+ "no such method '" +
+ options +
+ "' for " +
+ name +
+ ' widget instance'
+ );
+ }
+
+ methodValue = instance[options].apply(instance, args);
+
+ if (methodValue !== instance && methodValue !== undefined) {
+ returnValue =
+ methodValue && methodValue.jquery
+ ? returnValue.pushStack(methodValue.get())
+ : methodValue;
+ return false;
+ }
+ });
+ }
+ } else {
+ // Allow multiple hashes to be passed on init
+ if (args.length) {
+ options = $.widget.extend.apply(null, [options].concat(args));
+ }
+
+ this.each(function () {
+ var instance = $.data(this, fullName);
+ if (instance) {
+ instance.option(options || {});
+ if (instance._init) {
+ instance._init();
+ }
+ } else {
+ $.data(this, fullName, new object(options, this));
+ }
+ });
+ }
+
+ return returnValue;
+ };
+ };
+
+ $.Widget = function (/* options, element */) {};
+ $.Widget._childConstructors = [];
+
+ $.Widget.prototype = {
+ widgetName: 'widget',
+ widgetEventPrefix: '',
+ defaultElement: '<div>',
+
+ options: {
+ classes: {},
+ disabled: false,
+
+ // Callbacks
+ create: null
+ },
+
+ _createWidget: function (options, element) {
+ element = $(element || this.defaultElement || this)[0];
+ this.element = $(element);
+ this.uuid = widgetUuid++;
+ this.eventNamespace = '.' + this.widgetName + this.uuid;
+
+ this.bindings = $();
+ this.hoverable = $();
+ this.focusable = $();
+ this.classesElementLookup = {};
+
+ if (element !== this) {
+ $.data(element, this.widgetFullName, this);
+ this._on(true, this.element, {
+ remove: function (event) {
+ if (event.target === element) {
+ this.destroy();
+ }
+ }
+ });
+ this.document = $(
+ element.style
+ ? // Element within the document
+ element.ownerDocument
+ : // Element is window or document
+ element.document || element
+ );
+ this.window = $(
+ this.document[0].defaultView || this.document[0].parentWindow
+ );
+ }
+
+ this.options = $.widget.extend(
+ {},
+ this.options,
+ this._getCreateOptions(),
+ options
+ );
+
+ this._create();
+
+ if (this.options.disabled) {
+ this._setOptionDisabled(this.options.disabled);
+ }
+
+ this._trigger('create', null, this._getCreateEventData());
+ this._init();
+ },
+
+ _getCreateOptions: function () {
+ return {};
+ },
+
+ _getCreateEventData: $.noop,
+
+ _create: $.noop,
+
+ _init: $.noop,
+
+ destroy: function () {
+ var that = this;
+
+ this._destroy();
+ $.each(this.classesElementLookup, function (key, value) {
+ that._removeClass(value, key);
+ });
+
+ // We can probably remove the unbind calls in 2.0
+ // all event bindings should go through this._on()
+ this.element.off(this.eventNamespace).removeData(this.widgetFullName);
+ this.widget().off(this.eventNamespace).removeAttr('aria-disabled');
+
+ // Clean up events and states
+ this.bindings.off(this.eventNamespace);
+ },
+
+ _destroy: $.noop,
+
+ widget: function () {
+ return this.element;
+ },
+
+ option: function (key, value) {
+ var options = key;
+ var parts;
+ var curOption;
+ var i;
+
+ if (arguments.length === 0) {
+ // Don't return a reference to the internal hash
+ return $.widget.extend({}, this.options);
+ }
+
+ if (typeof key === 'string') {
+ // Handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }
+ options = {};
+ parts = key.split('.');
+ key = parts.shift();
+ if (parts.length) {
+ curOption = options[key] = $.widget.extend({}, this.options[key]);
+ for (i = 0; i < parts.length - 1; i++) {
+ curOption[parts[i]] = curOption[parts[i]] || {};
+ curOption = curOption[parts[i]];
+ }
+ key = parts.pop();
+ if (arguments.length === 1) {
+ return curOption[key] === undefined ? null : curOption[key];
+ }
+ curOption[key] = value;
+ } else {
+ if (arguments.length === 1) {
+ return this.options[key] === undefined ? null : this.options[key];
+ }
+ options[key] = value;
+ }
+ }
+
+ this._setOptions(options);
+
+ return this;
+ },
+
+ _setOptions: function (options) {
+ var key;
+
+ for (key in options) {
+ this._setOption(key, options[key]);
+ }
+
+ return this;
+ },
+
+ _setOption: function (key, value) {
+ if (key === 'classes') {
+ this._setOptionClasses(value);
+ }
+
+ this.options[key] = value;
+
+ if (key === 'disabled') {
+ this._setOptionDisabled(value);
+ }
+
+ return this;
+ },
+
+ _setOptionClasses: function (value) {
+ var classKey, elements, currentElements;
+
+ for (classKey in value) {
+ currentElements = this.classesElementLookup[classKey];
+ if (
+ value[classKey] === this.options.classes[classKey] ||
+ !currentElements ||
+ !currentElements.length
+ ) {
+ continue;
+ }
+
+ // We are doing this to create a new jQuery object because the _removeClass() call
+ // on the next line is going to destroy the reference to the current elements being
+ // tracked. We need to save a copy of this collection so that we can add the new classes
+ // below.
+ elements = $(currentElements.get());
+ this._removeClass(currentElements, classKey);
+
+ // We don't use _addClass() here, because that uses this.options.classes
+ // for generating the string of classes. We want to use the value passed in from
+ // _setOption(), this is the new value of the classes option which was passed to
+ // _setOption(). We pass this value directly to _classes().
+ elements.addClass(
+ this._classes({
+ element: elements,
+ keys: classKey,
+ classes: value,
+ add: true
+ })
+ );
+ }
+ },
+
+ _setOptionDisabled: function (value) {
+ this._toggleClass(
+ this.widget(),
+ this.widgetFullName + '-disabled',
+ null,
+ !!value
+ );
+
+ // If the widget is becoming disabled, then nothing is interactive
+ if (value) {
+ this._removeClass(this.hoverable, null, 'ui-state-hover');
+ this._removeClass(this.focusable, null, 'ui-state-focus');
+ }
+ },
+
+ enable: function () {
+ return this._setOptions({ disabled: false });
+ },
+
+ disable: function () {
+ return this._setOptions({ disabled: true });
+ },
+
+ _classes: function (options) {
+ var full = [];
+ var that = this;
+
+ options = $.extend(
+ {
+ element: this.element,
+ classes: this.options.classes || {}
+ },
+ options
+ );
+
+ function bindRemoveEvent() {
+ options.element.each(function (_, element) {
+ var isTracked = $.map(that.classesElementLookup, function (elements) {
+ return elements;
+ }).some(function (elements) {
+ return elements.is(element);
+ });
+
+ if (!isTracked) {
+ that._on($(element), {
+ remove: '_untrackClassesElement'
+ });
+ }
+ });
+ }
+
+ function processClassString(classes, checkOption) {
+ var current, i;
+ for (i = 0; i < classes.length; i++) {
+ current = that.classesElementLookup[classes[i]] || $();
+ if (options.add) {
+ bindRemoveEvent();
+ current = $(
+ $.uniqueSort(current.get().concat(options.element.get()))
+ );
+ } else {
+ current = $(current.not(options.element).get());
+ }
+ that.classesElementLookup[classes[i]] = current;
+ full.push(classes[i]);
+ if (checkOption && options.classes[classes[i]]) {
+ full.push(options.classes[classes[i]]);
+ }
+ }
+ }
+
+ if (options.keys) {
+ processClassString(options.keys.match(/\S+/g) || [], true);
+ }
+ if (options.extra) {
+ processClassString(options.extra.match(/\S+/g) || []);
+ }
+
+ return full.join(' ');
+ },
+
+ _untrackClassesElement: function (event) {
+ var that = this;
+ $.each(that.classesElementLookup, function (key, value) {
+ if ($.inArray(event.target, value) !== -1) {
+ that.classesElementLookup[key] = $(value.not(event.target).get());
+ }
+ });
+
+ this._off($(event.target));
+ },
+
+ _removeClass: function (element, keys, extra) {
+ return this._toggleClass(element, keys, extra, false);
+ },
+
+ _addClass: function (element, keys, extra) {
+ return this._toggleClass(element, keys, extra, true);
+ },
+
+ _toggleClass: function (element, keys, extra, add) {
+ add = typeof add === 'boolean' ? add : extra;
+ var shift = typeof element === 'string' || element === null,
+ options = {
+ extra: shift ? keys : extra,
+ keys: shift ? element : keys,
+ element: shift ? this.element : element,
+ add: add
+ };
+ options.element.toggleClass(this._classes(options), add);
+ return this;
+ },
+
+ _on: function (suppressDisabledCheck, element, handlers) {
+ var delegateElement;
+ var instance = this;
+
+ // No suppressDisabledCheck flag, shuffle arguments
+ if (typeof suppressDisabledCheck !== 'boolean') {
+ handlers = element;
+ element = suppressDisabledCheck;
+ suppressDisabledCheck = false;
+ }
+
+ // No element argument, shuffle and use this.element
+ if (!handlers) {
+ handlers = element;
+ element = this.element;
+ delegateElement = this.widget();
+ } else {
+ element = delegateElement = $(element);
+ this.bindings = this.bindings.add(element);
+ }
+
+ $.each(handlers, function (event, handler) {
+ function handlerProxy() {
+ // Allow widgets to customize the disabled handling
+ // - disabled as an array instead of boolean
+ // - disabled class as method for disabling individual parts
+ if (
+ !suppressDisabledCheck &&
+ (instance.options.disabled === true ||
+ $(this).hasClass('ui-state-disabled'))
+ ) {
+ return;
+ }
+ return (
+ typeof handler === 'string' ? instance[handler] : handler
+ ).apply(instance, arguments);
+ }
+
+ // Copy the guid so direct unbinding works
+ if (typeof handler !== 'string') {
+ handlerProxy.guid = handler.guid =
+ handler.guid || handlerProxy.guid || $.guid++;
+ }
+
+ var match = event.match(/^([\w:-]*)\s*(.*)$/);
+ var eventName = match[1] + instance.eventNamespace;
+ var selector = match[2];
+
+ if (selector) {
+ delegateElement.on(eventName, selector, handlerProxy);
+ } else {
+ element.on(eventName, handlerProxy);
+ }
+ });
+ },
+
+ _off: function (element, eventName) {
+ eventName =
+ (eventName || '').split(' ').join(this.eventNamespace + ' ') +
+ this.eventNamespace;
+ element.off(eventName);
+
+ // Clear the stack to avoid memory leaks (#10056)
+ this.bindings = $(this.bindings.not(element).get());
+ this.focusable = $(this.focusable.not(element).get());
+ this.hoverable = $(this.hoverable.not(element).get());
+ },
+
+ _delay: function (handler, delay) {
+ var instance = this;
+ function handlerProxy() {
+ return (
+ typeof handler === 'string' ? instance[handler] : handler
+ ).apply(instance, arguments);
+ }
+ return setTimeout(handlerProxy, delay || 0);
+ },
+
+ _hoverable: function (element) {
+ this.hoverable = this.hoverable.add(element);
+ this._on(element, {
+ mouseenter: function (event) {
+ this._addClass($(event.currentTarget), null, 'ui-state-hover');
+ },
+ mouseleave: function (event) {
+ this._removeClass($(event.currentTarget), null, 'ui-state-hover');
+ }
+ });
+ },
+
+ _focusable: function (element) {
+ this.focusable = this.focusable.add(element);
+ this._on(element, {
+ focusin: function (event) {
+ this._addClass($(event.currentTarget), null, 'ui-state-focus');
+ },
+ focusout: function (event) {
+ this._removeClass($(event.currentTarget), null, 'ui-state-focus');
+ }
+ });
+ },
+
+ _trigger: function (type, event, data) {
+ var prop, orig;
+ var callback = this.options[type];
+
+ data = data || {};
+ event = $.Event(event);
+ event.type = (
+ type === this.widgetEventPrefix ? type : this.widgetEventPrefix + type
+ ).toLowerCase();
+
+ // The original event may come from any element
+ // so we need to reset the target on the new event
+ event.target = this.element[0];
+
+ // Copy original event properties over to the new event
+ orig = event.originalEvent;
+ if (orig) {
+ for (prop in orig) {
+ if (!(prop in event)) {
+ event[prop] = orig[prop];
+ }
+ }
+ }
+
+ this.element.trigger(event, data);
+ return !(
+ ($.isFunction(callback) &&
+ callback.apply(this.element[0], [event].concat(data)) === false) ||
+ event.isDefaultPrevented()
+ );
+ }
+ };
+
+ $.each({ show: 'fadeIn', hide: 'fadeOut' }, function (method, defaultEffect) {
+ $.Widget.prototype['_' + method] = function (element, options, callback) {
+ if (typeof options === 'string') {
+ options = { effect: options };
+ }
+
+ var hasOptions;
+ var effectName = !options
+ ? method
+ : options === true || typeof options === 'number'
+ ? defaultEffect
+ : options.effect || defaultEffect;
+
+ options = options || {};
+ if (typeof options === 'number') {
+ options = { duration: options };
+ }
+
+ hasOptions = !$.isEmptyObject(options);
+ options.complete = callback;
+
+ if (options.delay) {
+ element.delay(options.delay);
+ }
+
+ if (hasOptions && $.effects && $.effects.effect[effectName]) {
+ element[method](options);
+ } else if (effectName !== method && element[effectName]) {
+ element[effectName](options.duration, options.easing, callback);
+ } else {
+ element.queue(function (next) {
+ $(this)[method]();
+ if (callback) {
+ callback.call(element[0]);
+ }
+ next();
+ });
+ }
+ };
+ });
+});
fnp / redakcja.git / blobdiff