https://decibelclinic.com/wp-content/themes/decibel/assets/js/function.js

1(function($) {
2    "use strict";
3
4    var $window = $(window);
5    var $body = $('body');
6
7    /* Slick library JS */
8    var
9        defaults = {
10            label: 'MENU',
11            duplicate: true,
12            duration: 200,
13            easingOpen: 'swing',
14            easingClose: 'swing',
15            closedSymbol: '►',
16            openedSymbol: '▼',
17            prependTo: 'body',
18            appendTo: '',
19            parentTag: 'a',
20            closeOnClick: false,
21            allowParentLinks: false,
22            nestedParentLinks: true,
23            showChildren: false,
24            removeIds: true,
25            removeClasses: false,
26            removeStyles: false,
27            brand: '',
28            animations: 'jquery',
29            init: function() {},
30            beforeOpen: function() {},
31            beforeClose: function() {},
32            afterOpen: function() {},
33            afterClose: function() {}
34        },
35        mobileMenu = 'slicknav',
36        prefix = 'slicknav',
37        Keyboard = {
38            DOWN: 40,
39            ENTER: 13,
40            ESCAPE: 27,
41            LEFT: 37,
42            RIGHT: 39,
43            SPACE: 32,
44            TAB: 9,
45            UP: 38,
46        };
47
48    function Plugin(element, options) {
49        this.element = element;
50
51        // jQuery has an extend method which merges the contents of two or
52        // more objects, storing the result in the first object. The first object
53        // is generally empty as we don't want to alter the default options for
54        // future instances of the plugin
55        this.settings = $.extend({}, defaults, options);
56
57        // Don't remove IDs by default if duplicate is false
58        if (!this.settings.duplicate && !options.hasOwnProperty("removeIds")) {
59            this.settings.removeIds = false;
60        }
61
62        this._defaults = defaults;
63        this._name = mobileMenu;
64
65        this.init();
66    }
67
68    Plugin.prototype.init = function() {
69        var $this = this,
70            menu = $(this.element),
71            settings = this.settings,
72            iconClass,
73            menuBar;
74
75        // clone menu if needed
76        if (settings.duplicate) {
77            $this.mobileNav = menu.clone();
78        } else {
79            $this.mobileNav = menu;
80        }
81
82        // remove IDs if set
83        if (settings.removeIds) {
84            $this.mobileNav.removeAttr('id');
85            $this.mobileNav.find('*').each(function(i, e) {
86                $(e).removeAttr('id');
87            });
88        }
89
90        // remove classes if set
91        if (settings.removeClasses) {
92            $this.mobileNav.removeAttr('class');
93            $this.mobileNav.find('*').each(function(i, e) {
94                $(e).removeAttr('class');
95            });
96        }
97
98        // remove styles if set
99        if (settings.removeStyles) {
100            $this.mobileNav.removeAttr('style');
101            $this.mobileNav.find('*').each(function(i, e) {
102                $(e).removeAttr('style');
103            });
104        }
105
106        // styling class for the button
107        iconClass = prefix + '_icon';
108
109        if (settings.label === '') {
110            iconClass += ' ' + prefix + '_no-text';
111        }
112
113        if (settings.parentTag == 'a') {
114            settings.parentTag = 'a href="#"';
115        }
116
117        // create menu bar
118        $this.mobileNav.attr('class', prefix + '_nav');
119        menuBar = $('<div class="' + prefix + '_menu"></div>');
120        if (settings.brand !== '') {
121            var brand = $('<div class="' + prefix + '_brand">' + settings.brand + '</div>');
122            $(menuBar).append(brand);
123        }
124        $this.btn = $(
125            ['<' + settings.parentTag + ' aria-haspopup="true" role="button" tabindex="0" class="' + prefix + '_btn ' + prefix + '_collapsed">',
126                '<span class="' + prefix + '_menutxt">' + settings.label + '</span>',
127                '<span class="' + iconClass + '">',
128                '<span class="' + prefix + '_icon-bar"></span>',
129                '<span class="' + prefix + '_icon-bar"></span>',
130                '<span class="' + prefix + '_icon-bar"></span>',
131                '</span>',
132                '</' + settings.parentTag + '>'
133            ].join('')
134        );
135        $('.navbar-toggle').append($this.btn);
136        if (settings.appendTo !== '') {
137            $(settings.appendTo).append(menuBar);
138        } else {
139            $(settings.prependTo).prepend(menuBar);
140        }
141        menuBar.append($this.mobileNav);
142
143        // iterate over structure adding additional structure
144        var items = $this.mobileNav.find('li');
145        $(items).each(function() {
146            var item = $(this),
147                data = {};
148            data.children = item.children('ul').attr('role', 'menu');
149            item.data('menu', data);
150
151            // if a list item has a nested menu
152            if (data.children.length > 0) {
153
154                // select all text before the child menu
155                // check for anchors
156
157                var a = item.contents(),
158                    containsAnchor = false,
159                    nodes = [];
160
161                $(a).each(function() {
162                    if (!$(this).is('ul')) {
163                        nodes.push(this);
164                    } else {
165                        return false;
166                    }
167
168                    if ($(this).is("a")) {
169                        containsAnchor = true;
170                    }
171                });
172
173                var wrapElement = $(
174                    '<' + settings.parentTag + ' role="menuitem" aria-haspopup="true" tabindex="-1" class="' + prefix + '_item"/>'
175                );
176
177                // wrap item text with tag and add classes unless we are separating parent links
178                if ((!settings.allowParentLinks || settings.nestedParentLinks) || !containsAnchor) {
179                    var $wrap = $(nodes).wrapAll(wrapElement).parent();
180                    $wrap.addClass(prefix + '_row');
181                } else
182                    $(nodes).wrapAll('<span class="' + prefix + '_parent-link ' + prefix + '_row"/>').parent();
183
184                if (!settings.showChildren) {
185                    item.addClass(prefix + '_collapsed');
186                } else {
187                    item.addClass(prefix + '_open');
188                }
189
190                item.addClass(prefix + '_parent');
191
192                // create parent arrow. wrap with link if parent links and separating
193                var arrowElement = $('<span class="' + prefix + '_arrow">' + (settings.showChildren ? settings.openedSymbol : settings.closedSymbol) + '</span>');
194

387            data.arrow.html(settings.openedSymbol);
388            data.parent.removeClass(prefix + '_collapsed');
389            data.parent.addClass(prefix + '_open');
390            data.parent.addClass(prefix + '_animating');
391            $this._visibilityToggle(data.ul, data.parent, true, el);
392        } else {
393            data.arrow.html(settings.closedSymbol);
394            data.parent.addClass(prefix + '_collapsed');
395            data.parent.removeClass(prefix + '_open');
396            data.parent.addClass(prefix + '_animating');
397            $this._visibilityToggle(data.ul, data.parent, true, el);
398        }
399    };
400
401    // toggle actual visibility and accessibility tags
402    Plugin.prototype._visibilityToggle = function(el, parent, animate, trigger, init) {
403        var $this = this;
404        var settings = $this.settings;
405        var items = $this._getActionItems(el);
406        var duration = 0;
407        if (animate) {
408            duration = settings.duration;
409        }
410
411        function afterOpen(trigger, parent) {
412            $(trigger).removeClass(prefix + '_animating');
413            $(parent).removeClass(prefix + '_animating');
414
415            //Fire afterOpen callback
416            if (!init) {
417                settings.afterOpen(trigger);
418            }
419        }
420
421        function afterClose(trigger, parent) {
422            el.attr('aria-hidden', 'true');
423            items.attr('tabindex', '-1');
424            $this._setVisAttr(el, true);
425            el.hide(); //jQuery 1.7 bug fix
426
427            $(trigger).removeClass(prefix + '_animating');
428            $(parent).removeClass(prefix + '_animating');
429
430            //Fire init or afterClose callback
431            if (!init) {
432                settings.afterClose(trigger);
433            } else if (trigger == 'init') {
434                settings.init();
435            }
436        }
437
438        if (el.hasClass(prefix + '_hidden')) {
439            el.removeClass(prefix + '_hidden');
440            //Fire beforeOpen callback
441            if (!init) {
442                settings.beforeOpen(trigger);
443            }
444            if (settings.animations === 'jquery') {
445                el.stop(true, true).slideDown(duration, settings.easingOpen, function() {
446                    afterOpen(trigger, parent);
447                });
448            } else if (settings.animations === 'velocity') {
449                el.velocity("finish").velocity("slideDown", {
450                    duration: duration,
451                    easing: settings.easingOpen,
452                    complete: function() {
453                        afterOpen(trigger, parent);
454                    }
455                });
456            }
457            el.attr('aria-hidden', 'false');
458            items.attr('tabindex', '0');
459            $this._setVisAttr(el, false);
460        } else {
461            el.addClass(prefix + '_hidden');
462
463            //Fire init or beforeClose callback
464            if (!init) {
465                settings.beforeClose(trigger);
466            }
467
468            if (settings.animations === 'jquery') {
469                el.stop(true, true).slideUp(duration, this.settings.easingClose, function() {
470                    afterClose(trigger, parent)
471                });
472            } else if (settings.animations === 'velocity') {
473
474                el.velocity("finish").velocity("slideUp", {
475                    duration: duration,
476                    easing: settings.easingClose,
477                    complete: function() {
478                        afterClose(trigger, parent);
479                    }
480                });
481            }
482        }
483    };
484
485    // set attributes of element and children based on visibility
486    Plugin.prototype._setVisAttr = function(el, hidden) {
487        var $this = this;
488
489        // select all parents that aren't hidden
490        var nonHidden = el.children('li').children('ul').not('.' + prefix + '_hidden');
491
492        // iterate over all items setting appropriate tags
493        if (!hidden) {
494            nonHidden.each(function() {
495                var ul = $(this);
496                ul.attr('aria-hidden', 'false');
497                var items = $this._getActionItems(ul);
498                items.attr('tabindex', '0');
499                $this._setVisAttr(ul, hidden);
500            });
501        } else {
502            nonHidden.each(function() {
503                var ul = $(this);
504                ul.attr('aria-hidden', 'true');
505                var items = $this._getActionItems(ul);
506                items.attr('tabindex', '-1');
507                $this._setVisAttr(ul, hidden);
508            });
509        }
510    };
511
512    // get all 1st level items that are clickable
513    Plugin.prototype._getActionItems = function(el) {
514        var data = el.data("menu");
515        if (!data) {
516            data = {};
517            var items = el.children('li');
518            var anchors = items.find('a');
519            data.links = anchors.add(items.find('.' + prefix + '_item'));
520            el.data('menu', data);
521        }
522        return data.links;
523    };
524
525    Plugin.prototype._outlines = function(state) {
526        if (!state) {
527            $('.' + prefix + '_item, .' + prefix + '_btn').css('outline', 'none');
528        } else {
529            $('.' + prefix + '_item, .' + prefix + '_btn').css('outline', '');
530        }
531    };
532
533    Plugin.prototype.toggle = function() {
534        var $this = this;
535        $this._menuToggle();
536    };
537
538    Plugin.prototype.open = function() {
539        var $this = this;
540        if ($this.btn.hasClass(prefix + '_collapsed')) {
541            $this._menuToggle();
542        }
543    };
544
545    Plugin.prototype.close = function() {
546        var $this = this;
547        if ($this.btn.hasClass(prefix + '_open')) {
548            $this._menuToggle();
549        }
550    };
551
552    $.fn[mobileMenu] = function(options) {
553        var args = arguments;
554
555        // Is the first parameter an object (options), or was omitted, instantiate a new instance
556        if (options === undefined || typeof options === 'object') {
557            return this.each(function() {
558
559                // Only allow the plugin to be instantiated once due to methods
560                if (!$.data(this, 'plugin_' + mobileMenu)) {
561
562                    // if it has no instance, create a new one, pass options to our plugin constructor,
563                    // and store the plugin instance in the elements jQuery data object.
564                    $.data(this, 'plugin_' + mobileMenu, new Plugin(this, options));
565                }
566            });
567
568            // If is a string and doesn't start with an underscore or 'init' function, treat this as a call to a public method.
569        } else if (typeof options === 'string' && options[0] !== '_' && options !== 'init') {
570
571            // Cache the method call to make it possible to return a value
572            var returns;
573
574            this.each(function() {
575                var instance = $.data(this, 'plugin_' + mobileMenu);
576
577                // Tests that there's already a plugin-instance and checks that the requested public method exists
578                if (instance instanceof Plugin && typeof instance[options] === 'function') {
579
580                    // Call the method of our plugin instance, and pass it the supplied arguments.
581                    returns = instance[options].apply(instance, Array.prototype.slice.call(args, 1));
582                }
583            });
584
585            // If the earlier cached method gives a value back return the value, otherwise return this to preserve chainability.
586            return returns !== undefined ? returns : this;
587        }
588    };
589    /* End Slick library  */
590
591
592    /* Preloader Effect */
593    $window.on('load', function() {
594        $(".preloader").fadeOut(600);
595    });