1"use strict"; 2 3// Class definition 4var KTBlockUI = function(element, options) { 5 ////////////////////////////// 6 // ** Private variables ** // 7 ////////////////////////////// 8 var the = this; 9 10 if ( typeof element === "undefined" || element === null ) { 11 return; 12 } 13 14 // Default options 15 var defaultOptions = { 16 zIndex: false, 17 overlayClass: '', 18 overflow: 'hidden', 19 message: '<span class="spinner-border text-primary"></span>' 20 }; 21 22 //////////////////////////// 23 // ** Private methods ** // 24 //////////////////////////// 25 26 var _construct = function() { 27 if ( KTUtil.data(element).has('blockui') ) { 28 the = KTUtil.data(element).get('blockui'); 29 } else { 30 _init(); 31 } 32 } 33 34 var _init = function() { 35 // Variables 36 the.options = KTUtil.deepExtend({}, defaultOptions, options); 37 the.element = element; 38 the.overlayElement = null; 39 the.blocked = false; 40 the.positionChanged = false; 41 the.overflowChanged = false; 42 43 // Bind Instance 44 KTUtil.data(the.element).set('blockui', the); 45 } 46 47 var _block = function() { 48 if ( KTEventHandler.trigger(the.element, 'kt.blockui.block', the) === false ) { 49 return; 50 } 51 52 var isPage = (the.element.tagName === 'BODY'); 53 54 var position = KTUtil.css(the.element, 'position'); 55 var overflow = KTUtil.css(the.element, 'overflow'); 56 var zIndex = isPage ? 10000 : 1; 57 58 if (the.options.zIndex > 0) { 59 zIndex = the.options.zIndex; 60 } else { 61 if (KTUtil.css(the.element, 'z-index') != 'auto') { 62 zIndex = KTUtil.css(the.element, 'z-index'); 63 } 64 } 65 66 the.element.classList.add('blockui'); 67 68 if (position === "absolute" || position === "relative" || position === "fixed") { 69 KTUtil.css(the.element, 'position', 'relative'); 70 the.positionChanged = true; 71 } 72 73 if (the.options.overflow === 'hidden' && overflow === 'visible') { 74 KTUtil.css(the.element, 'overflow', 'hidden'); 75 the.overflowChanged = true; 76 } 77 78 the.overlayElement = document.createElement('DIV'); 79 the.overlayElement.setAttribute('class', 'blockui-overlay ' + the.options.overlayClass); 80 81 the.overlayElement.innerHTML = the.options.message; 82 83 KTUtil.css(the.overlayElement, 'z-index', zIndex); 84 85 the.element.append(the.overlayElement); 86 the.blocked = true; 87 88 KTEventHandler.trigger(the.element, 'kt.blockui.after.blocked', the) === false 89 } 90 91 var _release = function() { 92 if ( KTEventHandler.trigger(the.element, 'kt.blockui.release', the) === false ) { 93 return; 94 } 95 96 the.element.classList.add('blockui'); 97 98 if (the.positionChanged) { 99 KTUtil.css(the.element, 'position', ''); 100 } 101 102 if (the.overflowChanged) { 103 KTUtil.css(the.element, 'overflow', ''); 104 } 105 106 if (the.overlayElement) { 107 KTUtil.remove(the.overlayElement); 108 } 109 110 the.blocked = false; 111 112 KTEventHandler.trigger(the.element, 'kt.blockui.released', the); 113 } 114 115 var _isBlocked = function() { 116 return the.blocked; 117 } 118 119 var _destroy = function() { 120 KTUtil.data(the.element).remove('blockui'); 121 } 122 123 // Construct class 124 _construct(); 125 126 /////////////////////// 127 // ** Public API ** // 128 /////////////////////// 129 130 // Plugin API 131 the.block = function() { 132 _block(); 133 } 134 135 the.release = function() { 136 _release(); 137 } 138 139 the.isBlocked = function() { 140 return _isBlocked(); 141 } 142 143 the.destroy = function() { 144 return _destroy(); 145 } 146 147 // Event API 148 the.on = function(name, handler) { 149 return KTEventHandler.on(the.element, name, handler); 150 } 151 152 the.one = function(name, handler) { 153 return KTEventHandler.one(the.element, name, handler); 154 } 155 156 the.off = function(name) { 157 return KTEventHandler.off(the.element, name); 158 } 159 160 the.trigger = function(name, event) { 161 return KTEventHandler.trigger(the.element, name, event, the, event); 162 } 163}; 164 165// Static methods 166KTBlockUI.getInstance = function(element) { 167 if (element !== null && KTUtil.data(element).has('blockui')) { 168 return KTUtil.data(element).get('blockui'); 169 } else { 170 return null; 171 } 172} 173 174// Webpack support 175if (typeof module !== 'undefined' && typeof module.exports !== 'undefined') { 176 module.exports = KTBlockUI; 177} 178"use strict";
179// DOCS: https://javascript.info/cookie 180 181// Class definition 182var KTCookie = function() { 183 return { 184 // returns the cookie with the given name, 185 // or undefined if not found 186 get: function(name) { 187 var matches = document.cookie.match(new RegExp( 188 "(?:^|; )" + name.replace(/([\.$?*|{}\(\)\[\]\\\/\+^])/g, '\\$1') + "=([^;]*)" 189 )); 190 191 return matches ? decodeURIComponent(matches[1]) : null; 192 }, 193 194 // Please note that a cookie value is encoded, 195 // so getCookie uses a built-in decodeURIComponent function to decode it. 196 set: function(name, value, options) { 197 if ( typeof options === "undefined" || options === null ) { 198 options = {}; 199 } 200 201 options = Object.assign({}, { 202 path: '/' 203 }, options); 204 205 if ( options.expires instanceof Date ) { 206 options.expires = options.expires.toUTCString(); 207 } 208 209 var updatedCookie = encodeURIComponent(name) + "=" + encodeURIComponent(value); 210 211 for ( var optionKey in options ) { 212 if ( options.hasOwnProperty(optionKey) === false ) { 213 continue; 214 } 215 216 updatedCookie += "; " + optionKey; 217 var optionValue = options[optionKey]; 218 219 if ( optionValue !== true ) { 220 updatedCookie += "=" + optionValue; 221 } 222 } 223 224 document.cookie = updatedCookie; 225 }, 226 227 // To remove a cookie, we can call it with a negative expiration date: 228 remove: function(name) { 229 this.set(name, "", { 230 'max-age': -1 231 }); 232 } 233 } 234}(); 235 236// Webpack support 237if (typeof module !== 'undefined' && typeof module.exports !== 'undefined') { 238 module.exports = KTCookie; 239} 240 241"use strict"; 242 243// Class definition 244var KTDialer = function(element, options) { 245 //////////////////////////// 246 // ** Private variables ** // 247 //////////////////////////// 248 var the = this; 249 250 if (!element) { 251 return; 252 } 253 254 // Default options 255 var defaultOptions = { 256 min: null, 257 max: null, 258 step: 1, 259 decimals: 0, 260 prefix: "", 261 suffix: "" 262 }; 263 264 //////////////////////////// 265 // ** Private methods ** // 266 //////////////////////////// 267 268 // Constructor 269 var _construct = function() { 270 if ( KTUtil.data(element).has('dialer') === true ) { 271 the = KTUtil.data(element).get('dialer'); 272 } else { 273 _init(); 274 } 275 } 276 277 // Initialize 278 var _init = function() { 279 // Variables 280 the.options = KTUtil.deepExtend({}, defaultOptions, options); 281 282 // Elements 283 the.element = element; 284 the.incElement = the.element.querySelector('[data-kt-dialer-control="increase"]'); 285 the.decElement = the.element.querySelector('[data-kt-dialer-control="decrease"]'); 286 the.inputElement = the.element.querySelector('input[type]'); 287 288 // Set Values 289 if (_getOption('decimals')) { 290 the.options.decimals = parseInt(_getOption('decimals')); 291 } 292 293 if (_getOption('prefix')) { 294 the.options.prefix = _getOption('prefix'); 295 } 296 297 if (_getOption('suffix')) { 298 the.options.suffix = _getOption('suffix'); 299 } 300 301 if (_getOption('step')) { 302 the.options.step = parseFloat(_getOption('step')); 303 } 304 305 if (_getOption('min')) { 306 the.options.min = parseFloat(_getOption('min')); 307 } 308 309 if (_getOption('max')) { 310 the.options.max = parseFloat(_getOption('max')); 311 } 312 313 the.value = parseFloat(the.inputElement.value.replace(/[^\d.]/g, '')); 314 315 _setValue(); 316 317 // Event Handlers 318 _handlers(); 319 320 // Bind Instance 321 KTUtil.data(the.element).set('dialer', the); 322 } 323 324 // Handlers 325 var _handlers = function() { 326 KTUtil.addEvent(the.incElement, 'click', function(e) { 327 e.preventDefault(); 328 329 _increase(); 330 }); 331 332 KTUtil.addEvent(the.decElement, 'click', function(e) { 333 e.preventDefault(); 334 335 _decrease(); 336 }); 337 338 KTUtil.addEvent(the.inputElement, 'input', function(e) { 339 e.preventDefault(); 340 341 _setValue(); 342 }); 343 } 344 345 // Event handlers 346 var _increase = function() { 347 // Trigger "after.dialer" event 348 KTEventHandler.trigger(the.element, 'kt.dialer.increase', the); 349 350 the.inputElement.value = the.value + the.options.step; 351 _setValue(); 352 353 // Trigger "before.dialer" event 354 KTEventHandler.trigger(the.element, 'kt.dialer.increased', the); 355 356 return the; 357 } 358 359 var _decrease = function() { 360 // Trigger "after.dialer" event 361 KTEventHandler.trigger(the.element, 'kt.dialer.decrease', the); 362 363 the.inputElement.value = the.value - the.options.step; 364 365 _setValue(); 366 367 // Trigger "before.dialer" event 368 KTEventHandler.trigger(the.element, 'kt.dialer.decreased', the); 369 370 return the; 371 } 372 373 // Set Input Value 374 var _setValue = function(value) { 375 // Trigger "after.dialer" event 376 KTEventHandler.trigger(the.element, 'kt.dialer.change', the); 377 378 if (value !== undefined) { 379 the.value = value; 380 } else { 381 the.value = _parse(the.inputElement.value); 382 } 383 384 if (the.options.min !== null && the.value < the.options.min) { 385 the.value = the.options.min; 386 } 387 388 if (the.options.max !== null && the.value > the.options.max) { 389 the.value = the.options.max; 390 } 391 392 the.inputElement.value = _format(the.value); 393 394 // Trigger input change event 395 the.inputElement.dispatchEvent(new Event('change')); 396 397 // Trigger "after.dialer" event 398 KTEventHandler.trigger(the.element, 'kt.dialer.changed', the); 399 } 400 401 var _parse = function(val) { 402 val = val
403 .replace(/[^0-9.-]/g, '') // remove chars except number, hyphen, point. 404 .replace(/(\..*)\./g, '$1') // remove multiple points. 405 .replace(/(?!^)-/g, '') // remove middle hyphen. 406 .replace(/^0+(\d)/gm, '$1'); // remove multiple leading zeros. <-- I added this. 407 408 val = parseFloat(val); 409 410 if (isNaN(val)) { 411 val = 0; 412 } 413 414 return val; 415 } 416 417 // Format 418 var _format = function(val){ 419 return the.options.prefix + parseFloat(val).toFixed(the.options.decimals) + the.options.suffix; 420 } 421 422 // Get option 423 var _getOption = function(name) { 424 if ( the.element.hasAttribute('data-kt-dialer-' + name) === true ) { 425 var attr = the.element.getAttribute('data-kt-dialer-' + name); 426 var value = attr; 427 428 return value; 429 } else { 430 return null; 431 } 432 } 433 434 var _destroy = function() { 435 KTUtil.data(the.element).remove('dialer'); 436 } 437 438 // Construct class 439 _construct(); 440 441 /////////////////////// 442 // ** Public API ** // 443 /////////////////////// 444 445 // Plugin API 446 the.setMinValue = function(value) { 447 the.options.min = value; 448 } 449 450 the.setMaxValue = function(value) { 451 the.options.max = value; 452 } 453 454 the.setValue = function(value) { 455 _setValue(value); 456 } 457 458 the.getValue = function() { 459 return the.inputElement.value; 460 } 461 462 the.update = function() { 463 _setValue(); 464 } 465 466 the.increase = function() { 467 return _increase(); 468 } 469 470 the.decrease = function() { 471 return _decrease(); 472 } 473 474 the.getElement = function() { 475 return the.element; 476 } 477 478 the.destroy = function() { 479 return _destroy(); 480 } 481 482 // Event API 483 the.on = function(name, handler) { 484 return KTEventHandler.on(the.element, name, handler); 485 } 486 487 the.one = function(name, handler) { 488 return KTEventHandler.one(the.element, name, handler); 489 } 490 491 the.off = function(name) { 492 return KTEventHandler.off(the.element, name); 493 } 494 495 the.trigger = function(name, event) { 496 return KTEventHandler.trigger(the.element, name, event, the, event); 497 } 498}; 499 500// Static methods 501KTDialer.getInstance = function(element) { 502 if ( element !== null && KTUtil.data(element).has('dialer') ) { 503 return KTUtil.data(element).get('dialer'); 504 } else { 505 return null; 506 } 507} 508 509// Create instances 510KTDialer.createInstances = function(selector = '[data-kt-dialer="true"]') { 511 // Get instances 512 var elements = document.body.querySelectorAll(selector); 513 514 if ( elements && elements.length > 0 ) { 515 for (var i = 0, len = elements.length; i < len; i++) { 516 // Initialize instances 517 new KTDialer(elements[i]); 518 } 519 } 520} 521 522// Global initialization 523KTDialer.init = function() { 524 KTDialer.createInstances(); 525}; 526 527// On document ready 528if (document.readyState === 'loading') { 529 document.addEventListener('DOMContentLoaded', KTDialer.init); 530} else { 531 KTDialer.init(); 532} 533 534// Webpack support 535if (typeof module !== 'undefined' && typeof module.exports !== 'undefined') { 536 module.exports = KTDialer; 537} 538"use strict"; 539 540// Class definition 541var KTDrawer = function(element, options) { 542 ////////////////////////////// 543 // ** Private variables ** // 544 ////////////////////////////// 545 var the = this; 546 var body = document.getElementsByTagName("BODY")[0]; 547 548 if ( typeof element === "undefined" || element === null ) { 549 return; 550 } 551 552 // Default options 553 var defaultOptions = { 554 overlay: true, 555 direction: 'end', 556 baseClass: 'drawer', 557 overlayClass: 'drawer-overlay' 558 }; 559 560 //////////////////////////// 561 // ** Private methods ** // 562 //////////////////////////// 563 564 var _construct = function() { 565 if ( KTUtil.data(element).has('drawer') ) { 566 the = KTUtil.data(element).get('drawer'); 567 } else { 568 _init(); 569 } 570 } 571 572 var _init = function() { 573 // Variables 574 the.options = KTUtil.deepExtend({}, defaultOptions, options); 575 the.uid = KTUtil.getUniqueId('drawer'); 576 the.element = element; 577 the.overlayElement = null; 578 the.name = the.element.getAttribute('data-kt-drawer-name'); 579 the.shown = false;
580 the.lastWidth; 581 the.toggleElement = null; 582 583 // Set initialized 584 the.element.setAttribute('data-kt-drawer', 'true'); 585 586 // Event Handlers 587 _handlers(); 588 589 // Update Instance 590 _update(); 591 592 // Bind Instance 593 KTUtil.data(the.element).set('drawer', the); 594 } 595 596 var _handlers = function() { 597 var togglers = _getOption('toggle'); 598 var closers = _getOption('close'); 599 600 if ( togglers !== null && togglers.length > 0 ) { 601 KTUtil.on(body, togglers, 'click', function(e) { 602 e.preventDefault(); 603 604 the.toggleElement = this; 605 _toggle(); 606 }); 607 } 608 609 if ( closers !== null && closers.length > 0 ) { 610 KTUtil.on(body, closers, 'click', function(e) { 611 e.preventDefault(); 612 613 the.closeElement = this; 614 _hide(); 615 }); 616 } 617 } 618 619 var _toggle = function() { 620 if ( KTEventHandler.trigger(the.element, 'kt.drawer.toggle', the) === false ) { 621 return; 622 } 623 624 if ( the.shown === true ) { 625 _hide(); 626 } else { 627 _show(); 628 } 629 630 KTEventHandler.trigger(the.element, 'kt.drawer.toggled', the); 631 } 632 633 var _hide = function() { 634 if ( KTEventHandler.trigger(the.element, 'kt.drawer.hide', the) === false ) { 635 return; 636 } 637 638 the.shown = false; 639 640 _deleteOverlay(); 641 642 body.removeAttribute('data-kt-drawer-' + the.name, 'on'); 643 body.removeAttribute('data-kt-drawer'); 644 645 KTUtil.removeClass(the.element, the.options.baseClass + '-
645on'); 646 647 if ( the.toggleElement !== null ) { 648 KTUtil.removeClass(the.toggleElement, 'active'); 649 } 650 651 KTEventHandler.trigger(the.element, 'kt.drawer.after.hidden', the) === false 652 } 653 654 var _show = function() { 655 if ( KTEventHandler.trigger(the.element, 'kt.drawer.show', the) === false ) { 656 return; 657 } 658 659 the.shown = true; 660 661 _createOverlay(); 662 body.setAttribute('data-kt-drawer-' + the.name, 'on'); 663 body.setAttribute('data-kt-drawer', 'on'); 664 665 KTUtil.addClass(the.element, the.options.baseClass + '-on'); 666 667 if ( the.toggleElement !== null ) { 668 KTUtil.addClass(the.toggleElement, 'active'); 669 } 670 671 KTEventHandler.trigger(the.element, 'kt.drawer.shown', the); 672 } 673 674 var _update = function() { 675 var width = _getWidth(); 676 var direction = _getOption('direction'); 677 678 // Reset state 679 if ( KTUtil.hasClass(the.element, the.options.baseClass + '-on') === true && String(body.getAttribute('data-kt-drawer-' + the.name + '-')) === 'on' ) { 680 the.shown = true; 681 } else { 682 the.shown = false; 683 } 684 685 // Activate/deactivate 686 if ( _getOption('activate') === true ) { 687 KTUtil.addClass(the.element, the.options.baseClass); 688 KTUtil.addClass(the.element, the.options.baseClass + '-' + direction); 689 KTUtil.css(the.element, 'width', width, true); 690 691 the.lastWidth = width; 692 } else { 693 KTUtil.css(the.element, 'width', ''); 694 695 KTUtil.removeClass(the.element, the.options.baseClass); 696 KTUtil.removeClass(the.element, the.options.baseClass + '-' + direction); 697 698 _hide(); 699 } 700 } 701 702 var _createOverlay = function() { 703 if ( _getOption('overlay') === true ) { 704 the.overlayElement = document.createElement('DIV'); 705 706 KTUtil.css(the.overlayElement, 'z-index', KTUtil.css(the.element, 'z-index') - 1); // update 707 708 body.append(the.overlayElement); 709 710 KTUtil.addClass(the.overlayElement, _getOption('overlay-class')); 711 712 KTUtil.addEvent(the.overlayElement, 'click', function(e) { 713 e.preventDefault(); 714 _hide(); 715 }); 716 } 717 } 718 719 var _deleteOverlay = function() { 720 if ( the.overlayElement !== null ) { 721 KTUtil.remove(the.overlayElement); 722 } 723 } 724 725 var _getOption = function(name) { 726 if ( the.element.hasAttribute('data-kt-drawer-' + name) === true ) { 727 var attr = the.element.getAttribute('data-kt-drawer-' + name); 728 var value = KTUtil.getResponsiveValue(attr); 729 730 if ( value !== null && String(value) === 'true' ) { 731 value = true; 732 } else if ( value !== null && String(value) === 'false' ) { 733 value = false; 734 } 735 736 return value; 737 } else { 738 var optionName = KTUtil.snakeToCamel(name); 739 740 if ( the.options[optionName] ) { 741 return KTUtil.getResponsiveValue(the.options[optionName]); 742 } else { 743 return null; 744 } 745 } 746 } 747 748 var _getWidth = function() { 749 var width = _getOption('width'); 750 751 if ( width === 'auto') { 752 width = KTUtil.css(the.element, 'width'); 753 } 754 755 return width; 756 } 757 758 var _destroy = function() { 759 KTUtil.data(the.element).remove('drawer'); 760 } 761 762 // Construct class 763 _construct(); 764 765 /////////////////////// 766 // ** Public API ** // 767 /////////////////////// 768 769 // Plugin API 770 the.toggle = function() { 771 return _toggle(); 772 } 773 774 the.show = function() { 775 return _show(); 776 } 777 778 the.hide = function() { 779 return _hide(); 780 } 781 782 the.isShown = function() { 783 return the.shown; 784 } 785 786 the.update = function() { 787 _update(); 788 } 789 790 the.goElement = function() { 791 return the.element; 792 } 793 794 the.destroy = function() { 795 return _destroy(); 796 } 797 798 // Event API 799 the.on = function(name, handler) { 800 return KTEventHandler.on(the.element, name, handler); 801 } 802 803 the.one = function(name, handler) { 804 return KTEventHandler.one(the.element, name, handler); 805 } 806 807 the.off = function(name) { 808 return KTEventHandler.off(the.element, name); 809 } 810 811 the.trigger = function(name, event) { 812 return KTEventHandler.trigger(the.element, name, event, the, event); 813 } 814}; 815 816// Static methods 817KTDrawer.getInstance = function(element) { 818 if (element !== null && KTUtil.data(element).has('drawer')) { 819 return KTUtil.data(element).get('drawer'); 820 } else { 821 return null; 822 } 823} 824 825// Hide all drawers and skip one if provided 826KTDrawer.hideAll = function(skip = null, selector = '[data-kt-drawer="true"]') { 827 var items = document.querySelectorAll(selector); 828 829 if (items && items.length > 0) { 830 for (var i = 0, len = items.length; i < len; i++) { 831 var item = items[i]; 832 var drawer = KTDrawer.getInstance(item); 833 834 if (!drawer) { 835 continue; 836 } 837 838 if ( skip ) { 839 if ( item !== skip ) { 840 drawer.hide(); 841 } 842 } else { 843 drawer.hide(); 844 } 845 } 846 } 847} 848 849// Update all drawers 850KTDrawer.updateAll = function(selector = '[data-kt-drawer="true"]') { 851 var items = document.querySelectorAll(selector); 852 853 if (items && items.length > 0) { 854 for (var i = 0, len = items.length; i < len; i++) { 855 var item = items[i]; 856 var drawer = KTDrawer.getInstance(item); 857 858 if (drawer) {
859 drawer.update();; 860 } 861 } 862 } 863} 864 865// Create instances 866KTDrawer.createInstances = function(selector = '[data-kt-drawer="true"]') { 867 var body = document.getElementsByTagName("BODY")[0]; 868 869 // Initialize Menus 870 var elements = body.querySelectorAll(selector); 871 var drawer; 872 873 if ( elements && elements.length > 0 ) { 874 for (var i = 0, len = elements.length; i < len; i++) { 875 drawer = new KTDrawer(elements[i]); 876 } 877 } 878} 879 880// Toggle instances 881KTDrawer.handleShow = function() { 882 // External drawer toggle handler 883 KTUtil.on(document.body, '[data-kt-drawer-show="true"][data-kt-drawer-target]', 'click', function(e) { 884 var element = document.querySelector(this.getAttribute('data-kt-drawer-target')); 885 886 if (element) { 887 KTDrawer.getInstance(element).show(); 888 } 889 }); 890} 891 892// Dismiss instances 893KTDrawer.handleDismiss = function() { 894 // External drawer toggle handler 895 KTUtil.on(document.body, '[data-kt-drawer-dismiss="true"]', 'click', function(e) { 896 var element = this.closest('[data-kt-drawer="true"]'); 897 898 if (element) { 899 var drawer = KTDrawer.getInstance(element); 900 if (drawer.isShown()) { 901 drawer.hide(); 902 } 903 } 904 }); 905} 906 907// Window resize Handling 908window.addEventListener('resize', function() { 909 var timer; 910 var body = document.getElementsByTagName("BODY")[0]; 911 912 KTUtil.throttle(timer, function() { 913 // Locate and update drawer instances on window resize 914 var elements = body.querySelectorAll('[data-kt-drawer="true"]'); 915 916 if ( elements && elements.length > 0 ) { 917 for (var i = 0, len = elements.length; i < len; i++) { 918 var drawer = KTDrawer.getInstance(elements[i]); 919 if (drawer) { 920 drawer.update(); 921 } 922 } 923 } 924 }, 200); 925}); 926 927// Global initialization 928KTDrawer.init = function() { 929 KTDrawer.createInstances(); 930 KTDrawer.handleShow(); 931 KTDrawer.handleDismiss(); 932}; 933 934// On document ready 935if (document.readyState === 'loading') { 936 document.addEventListener('DOMContentLoaded', KTDrawer.init); 937} else { 938 KTDrawer.init(); 939} 940 941// Webpack support 942if (typeof module !== 'undefined' && typeof module.exports !== 'undefined') { 943 module.exports = KTDrawer; 944} 945"use strict"; 946 947// Class definition 948var KTEventHandler = function() { 949 //////////////////////////// 950 // ** Private Variables ** // 951 //////////////////////////// 952 var _handlers = {}; 953 954 //////////////////////////// 955 // ** Private Methods ** // 956 //////////////////////////// 957 var _triggerEvent = function(element, name, target, e) { 958 if ( KTUtil.data(element).has(name) === true ) { 959 var handlerId = KTUtil.data(element).get(name); 960 961 if ( _handlers[name] && _handlers[name][handlerId] ) { 962 var handler = _handlers[name][handlerId]; 963 964 if ( handler.name === name ) { 965 if ( handler.one == true ) { 966 if ( handler.fired == false ) { 967 _handlers[name][handlerId].fired = true; 968 969 return handler.callback.call(this, target, e); 970 } 971 } else { 972 return handler.callback.call(this, target, e); 973 } 974 } 975 } 976 } 977 978 return null; 979 } 980 981 var _addEvent = function(element, name, callback, one) { 982 var handlerId = KTUtil.getUniqueId('event'); 983 984 KTUtil.data(element).set(name, handlerId); 985 986 if ( !_handlers[name] ) { 987 _handlers[name] = {}; 988 } 989 990 _handlers[name][handlerId] = { 991 name: name, 992 callback: callback, 993 one: one, 994 fired: false 995 }; 996 } 997 998 var _removeEvent = function(element, name) { 999 var handlerId = KTUtil.data(element).get(name); 1000 1001 if (_handlers[name] && _handlers[name][handlerId]) { 1002 delete _handlers[name][handlerId]; 1003 } 1004 } 1005
1006 //////////////////////////// 1007 // ** Public Methods ** // 1008 //////////////////////////// 1009 return { 1010 trigger: function(element, name, target, e) { 1011 return _triggerEvent(element, name, target, e); 1012 }, 1013 1014 on: function(element, name, handler) { 1015 return _addEvent(element, name, handler); 1016 }, 1017 1018 one: function(element, name, handler) { 1019 return _addEvent(element, name, handler, true); 1020 }, 1021 1022 off: function(element, name) { 1023 return _removeEvent(element, name); 1024 }, 1025 1026 debug: function() { 1027 for (var b in _handlers) { 1028 if ( _handlers.hasOwnProperty(b) ) console.log(b); 1029 } 1030 } 1031 } 1032}(); 1033 1034// Webpack support 1035if (typeof module !== 'undefined' && typeof module.exports !== 'undefined') { 1036 module.exports = KTEventHandler; 1037} 1038 1039"use strict"; 1040 1041// Class definition 1042var KTFeedback = function(options) { 1043 //////////////////////////// 1044 // ** Private Variables ** // 1045 //////////////////////////// 1046 var the = this; 1047 var body = document.getElementsByTagName("BODY")[0]; 1048 1049 // Default options 1050 var defaultOptions = { 1051 'width' : 100, 1052 'placement' : 'top-center', 1053 'content' : '', 1054 'type': 'popup' 1055 }; 1056 1057 //////////////////////////// 1058 // ** Private methods ** // 1059 //////////////////////////// 1060 1061 var _construct = function() { 1062 _init(); 1063 } 1064 1065 var _init = function() { 1066 // Variables 1067 the.options = KTUtil.deepExtend({}, defaultOptions, options); 1068 the.uid = KTUtil.getUniqueId('feedback'); 1069 the.element; 1070 the.shown = false; 1071 1072 // Event Handlers 1073 _handlers(); 1074 1075 // Bind Instance 1076 KTUtil.data(the.element).set('feedback', the); 1077 } 1078 1079 var _handlers = function() { 1080 KTUtil.addEvent(the.element, 'click', function(e) { 1081 e.preventDefault(); 1082 1083 _go(); 1084 }); 1085 } 1086 1087 var _show = function() { 1088 if ( KTEventHandler.trigger(the.element, 'kt.feedback.show', the) === false ) { 1089 return; 1090 } 1091 1092 if ( the.options.type === 'popup') { 1093 _showPopup(); 1094 } 1095 1096 KTEventHandler.trigger(the.element, 'kt.feedback.shown', the); 1097 1098 return the; 1099 } 1100 1101 var _hide = function() { 1102 if ( KTEventHandler.trigger(the.element, 'kt.feedback.hide', the) === false ) { 1103 return; 1104 } 1105 1106 if ( the.options.type === 'popup') { 1107 _hidePopup(); 1108 } 1109 1110 the.shown = false; 1111 1112 KTEventHandler.trigger(the.element, 'kt.feedback.hidden', the); 1113 1114 return the; 1115 } 1116 1117 var _showPopup = function() { 1118 the.element = document.createElement("DIV"); 1119 1120 KTUtil.addClass(the.element, 'feedback feedback-popup'); 1121 KTUtil.setHTML(the.element, the.options.content); 1122 1123 if (the.options.placement == 'top-center') { 1124 _setPopupTopCenterPosition(); 1125 } 1126 1127 body.appendChild(the.element); 1128 1129 KTUtil.addClass(the.element, 'feedback-shown'); 1130 1131 the.shown = true; 1132 } 1133 1134 var _setPopupTopCenterPosition = function() { 1135 var width = KTUtil.getResponsiveValue(the.options.width); 1136 var height = KTUtil.css(the.element, 'height'); 1137 1138 KTUtil.addClass(the.element, 'feedback-top-center'); 1139 1140 KTUtil.css(the.element, 'width', width); 1141 KTUtil.css(the.element, 'left', '50%'); 1142 KTUtil.css(the.element, 'top', '-' + height); 1143 } 1144 1145 var _hidePopup = function() { 1146 the.element.remove(); 1147 } 1148 1149 var _destroy = function() { 1150 KTUtil.data(the.element).remove('feedback'); 1151 } 1152 1153 // Construct class 1154 _construct(); 1155 1156 /////////////////////// 1157 // ** Public API ** // 1158 /////////////////////// 1159 1160 // Plugin API 1161 the.show = function() { 1162 return _show(); 1163 } 1164 1165 the.hide = function() { 1166 return _hide(); 1167 } 1168 1169 the.isShown = function() { 1170 return the.shown; 1171 } 1172 1173 the.getElement = function() { 1174 return the.element; 1175 } 1176 1177 the.destroy = function() { 1178 return _destroy(); 1179 } 1180 1181 // Event API 1182 the.on = function(name, handler) { 1183 return KTEventHandler.on(the.element, name, handler); 1184 } 1185 1186 the.one = function(name, handler) { 1187 return KTEventHandler.one(the.element, name, handler); 1188 } 1189 1190 the.off = function(name) { 1191 return KTEventHandler.off(the.element, name); 1192 } 1193 1194 the.trigger = function(name, event) { 1195 return KTEventHandler.trigger(the.element, name, event, the, event); 1196 } 1197}; 1198 1199// Webpack support 1200if (typeof module !== 'undefined' && typeof module.exports !== 'undefined') { 1201 module.exports = KTFeedback; 1202} 1203 1204"use strict"; 1205 1206// Class definition 1207var KTImageInput = function(element, options) {
1208 //////////////////////////// 1209 // ** Private Variables ** // 1210 //////////////////////////// 1211 var the = this; 1212 1213 if ( typeof element === "undefined" || element === null ) { 1214 return; 1215 } 1216 1217 // Default Options 1218 var defaultOptions = { 1219 1220 }; 1221 1222 //////////////////////////// 1223 // ** Private Methods ** // 1224 //////////////////////////// 1225 1226 var _construct = function() { 1227 if ( KTUtil.data(element).has('image-input') === true ) { 1228 the = KTUtil.data(element).get('image-input'); 1229 } else { 1230 _init(); 1231 } 1232 } 1233 1234 var _init = function() { 1235 // Variables 1236 the.options = KTUtil.deepExtend({}, defaultOptions, options); 1237 the.uid = KTUtil.getUniqueId('image-input'); 1238 1239 // Elements 1240 the.element = element; 1241 the.inputElement = KTUtil.find(element, 'input[type="file"]'); 1242 the.wrapperElement = KTUtil.find(element, '.image-input-wrapper'); 1243 the.cancelElement = KTUtil.find(element, '[data-kt-image-input-action="cancel"]'); 1244 the.removeElement = KTUtil.find(element, '[data-kt-image-input-action="remove"]'); 1245 the.hiddenElement = KTUtil.find(element, 'input[type="hidden"]'); 1246 the.src = KTUtil.css(the.wrapperElement, 'backgroundImage'); 1247 1248 // Set initialized 1249 the.element.setAttribute('data-kt-image-input', 'true'); 1250 1251 // Event Handlers 1252 _handlers(); 1253 1254 // Bind Instance 1255 KTUtil.data(the.element).set('image-input', the); 1256 } 1257 1258 // Init Event Handlers 1259 var _handlers = function() { 1260 KTUtil.addEvent(the.inputElement, 'change', _change); 1261 KTUtil.addEvent(the.cancelElement, 'click', _cancel); 1262 KTUtil.addEvent(the.removeElement, 'click', _remove); 1263 } 1264 1265 // Event Handlers 1266 var _change = function(e) { 1267 e.preventDefault(); 1268 1269 if ( the.inputElement !== null && the.inputElement.files && the.inputElement.files[0] ) { 1270 // Fire change event 1271 if ( KTEventHandler.trigger(the.element, 'kt.imageinput.change', the) === false ) { 1272 return; 1273 } 1274 1275 var reader = new FileReader(); 1276 1277 reader.onload = function(e) { 1278 KTUtil.css(the.wrapperElement, 'background-image', 'url('+ e.target.result +')'); 1279 } 1280 1281 reader.readAsDataURL(the.inputElement.files[0]); 1282 1283 the.element.classList.add('image-input-changed'); 1284 the.element.classList.remove('image-input-empty'); 1285 1286 // Fire removed event 1287 KTEventHandler.trigger(the.element, 'kt.imageinput.changed', the); 1288 } 1289 } 1290 1291 var _cancel = function(e) { 1292 e.preventDefault(); 1293 1294 // Fire cancel event 1295 if ( KTEventHandler.trigger(the.element, 'kt.imageinput.cancel', the) === false ) { 1296 return; 1297 } 1298 1299 the.element.classList.remove('image-input-changed'); 1300 the.element.classList.remove('image-input-empty'); 1301 1302 if (the.src === 'none') { 1303 KTUtil.css(the.wrapperElement, 'background-image', ''); 1304 the.element.classList.add('image-input-empty'); 1305 } else { 1306 KTUtil.css(the.wrapperElement, 'background-image', the.src); 1307 } 1308 1309 the.inputElement.value = ""; 1310 1311 if ( the.hiddenElement !== null ) { 1312 the.hiddenElement.value = "0"; 1313 } 1314 1315 // Fire canceled event 1316 KTEventHandler.trigger(the.element, 'kt.imageinput.canceled', the); 1317 } 1318 1319 var _remove = function(e) { 1320 e.preventDefault(); 1321 1322 // Fire remove event 1323 if ( KTEventHandler.trigger(the.element, 'kt.imageinput.remove', the) === false ) { 1324 return; 1325 } 1326 1327 the.element.classList.remove('image-input-changed'); 1328 the.element.classList.add('image-input-empty'); 1329 1330 KTUtil.css(the.wrapperElement, 'background-image', "none"); 1331 the.inputElement.value = ""; 1332 1333 if ( the.hiddenElement !== null ) { 1334 the.hiddenElement.value = "1"; 1335 } 1336 1337 // Fire removed event 1338 KTEventHandler.trigger(the.element, 'kt.imageinput.removed', the); 1339 } 1340 1341 var _destroy = function() { 1342 KTUtil.data(the.element).remove('image-input'); 1343 } 1344 1345 // Construct Class 1346 _construct(); 1347
1348 /////////////////////// 1349 // ** Public API ** // 1350 /////////////////////// 1351 1352 // Plugin API 1353 the.getInputElement = function() { 1354 return the.inputElement; 1355 } 1356 1357 the.goElement = function() { 1358 return the.element; 1359 } 1360 1361 the.destroy = function() { 1362 return _destroy(); 1363 } 1364 1365 // Event API 1366 the.on = function(name, handler) { 1367 return KTEventHandler.on(the.element, name, handler); 1368 } 1369 1370 the.one = function(name, handler) { 1371 return KTEventHandler.one(the.element, name, handler); 1372 } 1373 1374 the.off = function(name) { 1375 return KTEventHandler.off(the.element, name); 1376 } 1377 1378 the.trigger = function(name, event) { 1379 return KTEventHandler.trigger(the.element, name, event, the, event); 1380 } 1381}; 1382 1383// Static methods 1384KTImageInput.getInstance = function(element) { 1385 if ( element !== null && KTUtil.data(element).has('image-input') ) { 1386 return KTUtil.data(element).get('image-input'); 1387 } else { 1388 return null; 1389 } 1390} 1391 1392// Create instances 1393KTImageInput.createInstances = function(selector = '[data-kt-image-input]') { 1394 // Initialize Menus 1395 var elements = document.querySelectorAll(selector); 1396 1397 if ( elements && elements.length > 0 ) { 1398 for (var i = 0, len = elements.length; i < len; i++) { 1399 new KTImageInput(elements[i]); 1400 } 1401 } 1402} 1403 1404// Global initialization 1405KTImageInput.init = function() { 1406 KTImageInput.createInstances(); 1407}; 1408 1409// On document ready 1410if (document.readyState === 'loading') { 1411 document.addEventListener('DOMContentLoaded', KTImageInput.init); 1412} else { 1413 KTImageInput.init(); 1414} 1415 1416// Webpack Support 1417if (typeof module !== 'undefined' && typeof module.exports !== 'undefined') { 1418 module.exports = KTImageInput; 1419} 1420 1421"use strict"; 1422 1423// Class definition 1424var KTMenu = function(element, options) { 1425 //////////////////////////// 1426 // ** Private Variables ** // 1427 //////////////////////////// 1428 var the = this; 1429 1430 if ( typeof element === "undefined" || element === null ) { 1431 return; 1432 } 1433 1434 // Default Options 1435 var defaultOptions = { 1436 dropdown: { 1437 hoverTimeout: 200, 1438 zindex: 105 1439 }, 1440 1441 accordion: { 1442 slideSpeed: 250, 1443 expand: false 1444 } 1445 }; 1446 1447 //////////////////////////// 1448 // ** Private Methods ** // 1449 //////////////////////////// 1450 1451 var _construct = function() { 1452 if ( KTUtil.data(element).has('menu') === true ) { 1453 the = KTUtil.data(element).get('menu'); 1454 } else { 1455 _init(); 1456 } 1457 } 1458 1459 var _init = function() { 1460 the.options = KTUtil.deepExtend({}, defaultOptions, options); 1461 the.uid = KTUtil.getUniqueId('menu'); 1462 the.element = element; 1463 the.triggerElement; 1464 1465 // Set initialized 1466 the.element.setAttribute('data-kt-menu', 'true'); 1467 1468 _setTriggerElement(); 1469 _update(); 1470 1471 KTUtil.data(the.element).set('menu', the); 1472 } 1473 1474 var _destroy = function() { // todo 1475 1476 } 1477 1478 // Event Handlers 1479 // Toggle handler 1480 var _click = function(element, e) { 1481 e.preventDefault(); 1482 1483 var item = _getItemElement(element); 1484 1485 if ( _getItemOption(item, 'trigger') !== 'click' ) { 1486 return; 1487 } 1488 1489 if ( _getItemOption(item, 'toggle') === false ) { 1490 _show(item); 1491 } else { 1492 _toggle(item); 1493 } 1494 } 1495 1496 // Link handler 1497 var _link = function(element, e) { 1498 if ( KTEventHandler.trigger(the.element, 'kt.menu.link.click', the) === false ) { 1499 return; 1500 } 1501 1502 // Dismiss all shown dropdowns 1503 KTMenu.hideDropdowns(); 1504 1505 KTEventHandler.trigger(the.element, 'kt.menu.link.clicked', the); 1506 } 1507 1508 // Dismiss handler 1509 var _dismiss = function(element, e) { 1510 var item = _getItemElement(element); 1511 var items = _getItemChildElements(item); 1512 1513 if ( item !== null && _getItemSubType(item) === 'dropdown') { 1514 _hide(item); // hide items dropdown 1515 // Hide all child elements as well 1516 1517 if ( items.length > 0 ) { 1518 for (var i = 0, len = items.length; i < len; i++) { 1519 if ( items[i] !== null && _getItemSubType(items[i]) === 'dropdown') { 1520 _hide(tems[i]); 1521 } 1522 } 1523 } 1524 } 1525 } 1526 1527 // Mouseover handle 1528 var _mouseover = function(element, e) { 1529 var item = _getItemElement(element); 1530 1531 if ( item === null ) { 1532 return; 1533 } 1534 1535 if ( _getItemOption(item, 'trigger') !== 'hover' ) { 1536 return; 1537 } 1538
1539 if ( KTUtil.data(item).get('hover') === '1' ) { 1540 clearTimeout(KTUtil.data(item).get('timeout')); 1541 KTUtil.data(item).remove('hover'); 1542 KTUtil.data(item).remove('timeout'); 1543 } 1544 1545 _show(item); 1546 } 1547 1548 // Mouseout handle 1549 var _mouseout = function(element, e) { 1550 var item = _getItemElement(element); 1551 1552 if ( item === null ) { 1553 return; 1554 } 1555 1556 if ( _getItemOption(item, 'trigger') !== 'hover' ) { 1557 return; 1558 } 1559 1560 var timeout = setTimeout(function() { 1561 if ( KTUtil.data(item).get('hover') === '1' ) { 1562 _hide(item); 1563 } 1564 }, the.options.dropdown.hoverTimeout); 1565 1566 KTUtil.data(item).set('hover', '1'); 1567 KTUtil.data(item).set('timeout', timeout); 1568 } 1569 1570 // Toggle item sub 1571 var _toggle = function(item) { 1572 if ( !item ) { 1573 item = the.triggerElement; 1574 } 1575 1576 if ( _isItemSubShown(item) === true ) { 1577 _hide(item); 1578 } else { 1579 _show(item); 1580 } 1581 } 1582 1583 // Show item sub 1584 var _show = function(item) { 1585 if ( !item ) { 1586 item = the.triggerElement; 1587 } 1588 1589 if ( _isItemSubShown(item) === true ) { 1590 return; 1591 } 1592 1593 if ( _getItemSubType(item) === 'dropdown' ) { 1594 _showDropdown(item); // // show current dropdown 1595 } else if ( _getItemSubType(item) === 'accordion' ) { 1596 _showAccordion(item); 1597 } 1598 1599 // Remember last submenu type 1600 KTUtil.data(item).set('type', _getItemSubType(item)); // updated 1601 } 1602 1603 // Hide item sub 1604 var _hide = function(item) { 1605 if ( !item ) { 1606 item = the.triggerElement; 1607 } 1608 1609 if ( _isItemSubShown(item) === false ) { 1610 return; 1611 } 1612 1613 if ( _getItemSubType(item) === 'dropdown' ) { 1614 _hideDropdown(item); 1615 } else if ( _getItemSubType(item) === 'accordion' ) { 1616 _hideAccordion(item); 1617 } 1618 } 1619 1620 // Reset item state classes if item sub type changed 1621 var _reset = function(item) { 1622 if ( _hasItemSub(item) === false ) { 1623 return; 1624 } 1625 1626 var sub = _getItemSubElement(item); 1627 1628 // Reset sub state if sub type is changed during the window resize 1629 if ( KTUtil.data(item).has('type') && KTUtil.data(item).get('type') !== _getItemSubType(item) ) { // updated 1630 KTUtil.removeClass(item, 'hover'); 1631 KTUtil.removeClass(item, 'show'); 1632 KTUtil.removeClass(sub, 'show'); 1633 } // updated 1634 } 1635 1636 // Update all item state classes if item sub type changed 1637 var _update = function() { 1638 var items = the.element.querySelectorAll('.menu-item[data-kt-menu-trigger]'); 1639 1640 if ( items && items.length > 0 ) { 1641 for (var i = 0, len = items.length; i < len; i++) { 1642 _reset(items[i]); 1643 } 1644 } 1645 } 1646 1647 // Set external trigger element 1648 var _setTriggerElement = function() { 1649 var target = document.querySelector('[data-kt-menu-target="# ' + the.element.getAttribute('id') + '"]'); 1650 1651 if ( target !== null ) { 1652 the.triggerElement = target; 1653 } else if ( the.element.closest('[data-kt-menu-trigger]') ) { 1654 the.triggerElement = the.element.closest('[data-kt-menu-trigger]'); 1655 } else if ( the.element.parentNode && KTUtil.child(the.element.parentNode, '[data-kt-menu-trigger]')) { 1656 the.triggerElement = KTUtil.child(the.element.parentNode, '[data-kt-menu-trigger]'); 1657 } 1658 1659 if ( the.triggerElement ) { 1660 KTUtil.data(the.triggerElement).set('menu', the); 1661 } 1662 } 1663 1664 // Test if menu has external trigger element 1665 var _isTriggerElement = function(item) { 1666 return ( the.triggerElement === item ) ? true : false; 1667 } 1668 1669 // Test if item's sub is shown 1670 var _isItemSubShown = function(item) { 1671 var sub = _getItemSubElement(item); 1672 1673 if ( sub !== null ) { 1674 if ( _getItemSubType(item) === 'dropdown' ) {
1675 if ( KTUtil.hasClass(sub, 'show') === true && sub.hasAttribute('data-popper-placement') === true ) { 1676 return true; 1677 } else { 1678 return false; 1679 } 1680 } else { 1681 return KTUtil.hasClass(item, 'show'); 1682 } 1683 } else { 1684 return false; 1685 } 1686 } 1687 1688 // Test if item dropdown is permanent 1689 var _isItemDropdownPermanent = function(item) { 1690 return _getItemOption(item, 'permanent') === true ? true : false; 1691 } 1692 1693 // Test if item's parent is shown 1694 var _isItemParentShown = function(item) { 1695 return KTUtil.parents(item, '.menu-item.show').length > 0; 1696 } 1697 1698 // Test of it is item sub element 1699 var _isItemSubElement = function(item) { 1700 return KTUtil.hasClass(item, 'menu-sub'); 1701 } 1702 1703 // Test if item has sub 1704 var _hasItemSub = function(item) { 1705 return (KTUtil.hasClass(item, 'menu-item') && item.hasAttribute('data-kt-menu-trigger')); 1706 } 1707 1708 // Get link element 1709 var _getItemLinkElement = function(item) { 1710 return KTUtil.child(item, '.menu-link'); 1711 } 1712 1713 // Get toggle element 1714 var _getItemToggleElement = function(item) { 1715 if ( the.triggerElement ) { 1716 return the.triggerElement; 1717 } else { 1718 return _getItemLinkElement(item); 1719 } 1720 } 1721 1722 // Get item sub element 1723 var _getItemSubElement = function(item) { 1724 if ( _isTriggerElement(item) === true ) { 1725 return the.element; 1726 } if ( item.classList.contains('menu-sub') === true ) { 1727 return item; 1728 } else if ( KTUtil.data(item).has('sub') ) { 1729 return KTUtil.data(item).get('sub'); 1730 } else { 1731 return KTUtil.child(item, '.menu-sub'); 1732 } 1733 } 1734 1735 // Get item sub type 1736 var _getItemSubType = function(element) { 1737 var sub = _getItemSubElement(element); 1738 1739 if ( sub && parseInt(KTUtil.css(sub, 'z-index')) > 0 ) { 1740 return "dropdown"; 1741 } else { 1742 return "accordion"; 1743 } 1744 } 1745 1746 // Get item element 1747 var _getItemElement = function(element) { 1748 var item, sub; 1749 1750 // Element is the external trigger element 1751 if (_isTriggerElement(element) ) { 1752 return element; 1753 } 1754 1755 // Element has item toggler attribute 1756 if ( element.hasAttribute('data-kt-menu-trigger') ) { 1757 return element; 1758 } 1759 1760 // Element has item DOM reference in it's data storage 1761 if ( KTUtil.data(element).has('item') ) { 1762 return KTUtil.data(element).get('item'); 1763 } 1764 1765 // Item is parent of element 1766 if ( (item = element.closest('.menu-item[data-kt-menu-trigger]')) ) { 1767 return item; 1768 } 1769 1770 // Element's parent has item DOM reference in it's data storage 1771 if ( (sub = element.closest('.menu-sub')) ) { 1772 if ( KTUtil.data(sub).has('item') === true ) { 1773 return KTUtil.data(sub).get('item') 1774 } 1775 } 1776 } 1777 1778 // Get item parent element 1779 var _getItemParentElement = function(item) { 1780 var sub = item.closest('.menu-sub'); 1781 var parentItem; 1782 1783 if ( KTUtil.data(sub).has('item') ) { 1784 return KTUtil.data(sub).get('item'); 1785 } 1786 1787 if ( sub && (parentItem = sub.closest('.menu-item[data-kt-menu-trigger]')) ) { 1788 return parentItem; 1789 } 1790 1791 return null; 1792 } 1793 1794 // Get item parent elements 1795 var _getItemParentElements = function(item) { 1796 var parents = []; 1797 var parent; 1798 var i = 0; 1799 1800 do { 1801 parent = _getItemParentElement(item); 1802 1803 if ( parent ) { 1804 parents.push(parent); 1805 item = parent; 1806 } 1807 1808 i++; 1809 } while (parent !== null && i < 20); 1810 1811 if ( the.triggerElement ) { 1812 parents.unshift(the.triggerElement); 1813 } 1814 1815 return parents; 1816 } 1817 1818 // Get item child element 1819 var _getItemChildElement = function(item) { 1820 var selector = item; 1821 var element; 1822
1823 if ( KTUtil.data(item).get('sub') ) { 1824 selector = KTUtil.data(item).get('sub'); 1825 } 1826 1827 if ( selector !== null ) { 1828 //element = selector.querySelector('.show.menu-item[data-kt-menu-trigger]'); 1829 element = selector.querySelector('.menu-item[data-kt-menu-trigger]'); 1830 1831 if ( element ) { 1832 return element; 1833 } else { 1834 return null; 1835 } 1836 } else { 1837 return null; 1838 } 1839 } 1840 1841 // Get item child elements 1842 var _getItemChildElements = function(item) { 1843 var children = []; 1844 var child; 1845 var i = 0; 1846 1847 do { 1848 child = _getItemChildElement(item); 1849 1850 if ( child ) { 1851 children.push(child); 1852 item = child; 1853 } 1854 1855 i++; 1856 } while (child !== null && i < 20); 1857 1858 return children; 1859 } 1860 1861 // Show item dropdown 1862 var _showDropdown = function(item) { 1863 // Handle dropdown show event 1864 if ( KTEventHandler.trigger(the.element, 'kt.menu.dropdown.show', item) === false ) { 1865 return; 1866 } 1867 1868 // Hide all currently shown dropdowns except current one 1869 KTMenu.hideDropdowns(item); 1870 1871 var toggle = _isTriggerElement(item) ? item : _getItemLinkElement(item); 1872 var sub = _getItemSubElement(item); 1873 1874 var width = _getItemOption(item, 'width'); 1875 var height = _getItemOption(item, 'height'); 1876 1877 var zindex = the.options.dropdown.zindex; // update 1878 var parentZindex = KTUtil.getHighestZindex(item); // update 1879 1880 // Apply a new z-index if dropdown's toggle element or it's parent has greater z-index // update 1881 if ( parentZindex !== null && parentZindex >= zindex ) { 1882 zindex = parentZindex + 1; 1883 } 1884 1885 if ( zindex > 0 ) { 1886 KTUtil.css(sub, 'z-index', zindex); 1887 } 1888 1889 if ( width !== null ) { 1890 KTUtil.css(sub, 'width', width); 1891 } 1892 1893 if ( height !== null ) { 1894 KTUtil.css(sub, 'height', height); 1895 } 1896 1897 KTUtil.css(sub, 'display', ''); 1898 KTUtil.css(sub, 'overflow', ''); 1899 1900 // Init popper(new) 1901 _initDropdownPopper(item, sub); 1902 1903 KTUtil.addClass(item, 'show'); 1904 KTUtil.addClass(item, 'menu-dropdown'); 1905 KTUtil.addClass(sub, 'show'); 1906 1907 // Append the sub the the root of the menu 1908 if ( _getItemOption(item, 'overflow') === true ) { 1909 document.body.appendChild(sub); 1910 KTUtil.data(item).set('sub', sub); 1911 KTUtil.data(sub).set('item', item); 1912 KTUtil.data(sub).set('menu', the); 1913 } else { 1914 KTUtil.data(sub).set('item', item); 1915 } 1916 1917 // Handle dropdown shown event 1918 KTEventHandler.trigger(the.element, 'kt.menu.dropdown.shown', item); 1919 } 1920 1921 // Hide item dropdown 1922 var _hideDropdown = function(item) { 1923 // Handle dropdown hide event 1924 if ( KTEventHandler.trigger(the.element, 'kt.menu.dropdown.hide', item) === false ) { 1925 return; 1926 } 1927 1928 var sub = _getItemSubElement(item); 1929 1930 KTUtil.css(sub, 'z-index', ''); 1931 KTUtil.css(sub, 'width', ''); 1932 KTUtil.css(sub, 'height', ''); 1933 1934 KTUtil.removeClass(item, 'show'); 1935 KTUtil.removeClass(item, 'menu-dropdown'); 1936 KTUtil.removeClass(sub, 'show'); 1937 1938 // Append the sub back to it's parent 1939 if ( _getItemOption(item, 'overflow') === true ) { 1940 if (item.classList.contains('menu-item')) { 1941 item.appendChild(sub); 1942 } else { 1943 KTUtil.insertAfter(the.element, item); 1944 } 1945 1946 KTUtil.data(item).remove('sub'); 1947 KTUtil.data(sub).remove('item'); 1948 KTUtil.data(sub).remove('menu'); 1949 } 1950 1951 // Destroy popper(new) 1952 _destroyDropdownPopper(item); 1953 1954 // Handle dropdown hidden event 1955 KTEventHandler.trigger(the.element, 'kt.menu.dropdown.hidden', item); 1956 } 1957 1958 // Init dropdown popper(new) 1959 var _initDropdownPopper = function(item, sub) { 1960 // Setup popper instance 1961 var reference; 1962 var attach = _getItemOption(item, 'attach'); 1963 1964 if ( attach ) { 1965 if ( attach === 'parent') { 1966 reference = item.parentNode; 1967 } else { 1968 reference = document.querySelector(attach); 1969 } 1970 } else { 1971 reference = item; 1972 } 1973 1974 var popper = Popper.createPopper(reference, sub, _getDropdownPopperConfig(item)); 1975 KTUtil.data(item).set('popper', popper); 1976 } 1977 1978 // Destroy dropdown popper(new) 1979 var _destroyDropdownPopper = function(item) {
1980 if ( KTUtil.data(item).has('popper') === true ) { 1981 KTUtil.data(item).get('popper').destroy(); 1982 KTUtil.data(item).remove('popper'); 1983 } 1984 } 1985 1986 // Prepare popper config for dropdown(see: https://popper.js.org/docs/v2/) 1987 var _getDropdownPopperConfig = function(item) { 1988 // Placement 1989 var placement = _getItemOption(item, 'placement'); 1990 if (!placement) { 1991 placement = 'right'; 1992 } 1993 1994 // Offset 1995 var offsetValue = _getItemOption(item, 'offset'); 1996 var offset = offsetValue ? offsetValue.split(",") : []; 1997 1998 // Strategy 1999 var strategy = _getItemOption(item, 'overflow') === true ? 'absolute' : 'fixed'; 2000 2001 var altAxis = _getItemOption(item, 'flip') !== false ? true : false; 2002 2003 var popperConfig = { 2004 placement: placement, 2005 strategy: strategy, 2006 modifiers: [{ 2007 name: 'offset', 2008 options: { 2009 offset: offset 2010 } 2011 }, { 2012 name: 'preventOverflow', 2013 options: { 2014 altAxis: altAxis 2015 } 2016 }, { 2017 name: 'flip', 2018 options: { 2019 flipVariations: false 2020 } 2021 }] 2022 }; 2023 2024 return popperConfig; 2025 } 2026 2027 // Show item accordion 2028 var _showAccordion = function(item) { 2029 if ( KTEventHandler.trigger(the.element, 'kt.menu.accordion.show', item) === false ) { 2030 return; 2031 } 2032 2033 if ( the.options.accordion.expand === false ) { 2034 _hideAccordions(item); 2035 } 2036 2037 var sub = _getItemSubElement(item); 2038 2039 if ( KTUtil.data(item).has('popper') === true ) { 2040 _hideDropdown(item); 2041 } 2042 2043 KTUtil.addClass(item, 'hover'); // updateWW 2044 2045 KTUtil.addClass(item, 'showing'); 2046 2047 KTUtil.slideDown(sub, the.options.accordion.slideSpeed, function() { 2048 KTUtil.removeClass(item, 'showing'); 2049 KTUtil.addClass(item, 'show'); 2050 KTUtil.addClass(sub, 'show'); 2051 2052 KTEventHandler.trigger(the.element, 'kt.menu.accordion.shown', item); 2053 }); 2054 } 2055 2056 // Hide item accordion 2057 var _hideAccordion = function(item) { 2058 if ( KTEventHandler.trigger(the.element, 'kt.menu.accordion.hide', item) === false ) { 2059 return; 2060 } 2061 2062 var sub = _getItemSubElement(item); 2063 2064 KTUtil.addClass(item, 'hiding'); 2065 2066 KTUtil.slideUp(sub, the.options.accordion.slideSpeed, function() { 2067 KTUtil.removeClass(item, 'hiding'); 2068 KTUtil.removeClass(item, 'show'); 2069 KTUtil.removeClass(sub, 'show'); 2070 2071 KTUtil.removeClass(item, 'hover'); // update 2072 2073 KTEventHandler.trigger(the.element, 'kt.menu.accordion.hidden', item); 2074 }); 2075 } 2076 2077 // Hide all shown accordions of item 2078 var _hideAccordions = function(item) { 2079 var itemsToHide = KTUtil.findAll(the.element, '.show[data-kt-menu-trigger]'); 2080 var itemToHide; 2081 2082 if (itemsToHide && itemsToHide.length > 0) { 2083 for (var i = 0, len = itemsToHide.length; i < len; i++) { 2084 itemToHide = itemsToHide[i]; 2085 2086 if ( _getItemSubType(itemToHide) === 'accordion' && itemToHide !== item && item.contains(itemToHide) === false && itemToHide.contains(item) === false ) { 2087 _hideAccordion(itemToHide); 2088 } 2089 } 2090 } 2091 } 2092 2093 // Get item option(through html attributes) 2094 var _getItemOption = function(item, name) { 2095 var attr; 2096 var value = null; 2097 2098 if ( item && item.hasAttribute('data-kt-menu-' + name) ) { 2099 attr = item.getAttribute('data-kt-menu-' + name); 2100 value = KTUtil.getResponsiveValue(attr); 2101 2102 if ( value !== null && String(value) === 'true' ) { 2103 value = true; 2104 } else if ( value !== null && String(value) === 'false' ) { 2105 value = false; 2106 } 2107 } 2108 2109 return value; 2110 } 2111 2112 var _destroy = function() { 2113 KTUtil.data(the.element).remove('menu'); 2114 } 2115 2116 // Construct Class 2117 _construct(); 2118
2119 /////////////////////// 2120 // ** Public API ** // 2121 /////////////////////// 2122 2123 // Event Handlers 2124 the.click = function(element, e) { 2125 return _click(element, e); 2126 } 2127 2128 the.link = function(element, e) { 2129 return _link(element, e); 2130 } 2131 2132 the.dismiss = function(element, e) { 2133 return _dismiss(element, e); 2134 } 2135 2136 the.mouseover = function(element, e) { 2137 return _mouseover(element, e); 2138 } 2139 2140 the.mouseout = function(element, e) { 2141 return _mouseout(element, e); 2142 } 2143 2144 // General Methods 2145 the.getItemTriggerType = function(item) { 2146 return _getItemOption(item, 'trigger'); 2147 } 2148 2149 the.getItemSubType = function(element) { 2150 return _getItemSubType(element); 2151 } 2152 2153 the.show = function(item) { 2154 return _show(item); 2155 } 2156 2157 the.hide = function(item) { 2158 return _hide(item); 2159 } 2160 2161 the.reset = function(item) { 2162 return _reset(item); 2163 } 2164 2165 the.update = function() { 2166 return _update(); 2167 } 2168 2169 the.getElement = function() { 2170 return the.element; 2171 } 2172 2173 the.getItemLinkElement = function(item) { 2174 return _getItemLinkElement(item); 2175 } 2176 2177 the.getItemToggleElement = function(item) { 2178 return _getItemToggleElement(item); 2179 } 2180 2181 the.getItemSubElement = function(item) { 2182 return _getItemSubElement(item); 2183 } 2184 2185 the.getItemParentElements = function(item) { 2186 return _getItemParentElements(item); 2187 } 2188 2189 the.isItemSubShown = function(item) { 2190 return _isItemSubShown(item); 2191 } 2192 2193 the.isItemParentShown = function(item) { 2194 return _isItemParentShown(item); 2195 } 2196 2197 the.getTriggerElement = function() { 2198 return the.triggerElement; 2199 } 2200 2201 the.isItemDropdownPermanent = function(item) { 2202 return _isItemDropdownPermanent(item); 2203 } 2204 2205 the.destroy = function() { 2206 return _destroy(); 2207 } 2208 2209 // Accordion Mode Methods 2210 the.hideAccordions = function(item) { 2211 return _hideAccordions(item); 2212 } 2213 2214 // Event API 2215 the.on = function(name, handler) { 2216 return KTEventHandler.on(the.element, name, handler); 2217 } 2218 2219 the.one = function(name, handler) { 2220 return KTEventHandler.one(the.element, name, handler); 2221 } 2222 2223 the.off = function(name) { 2224 return KTEventHandler.off(the.element, name); 2225 } 2226}; 2227 2228// Get KTMenu instance by element 2229KTMenu.getInstance = function(element) { 2230 var menu; 2231 var item; 2232 2233 // Element has menu DOM reference in it's DATA storage 2234 if ( KTUtil.data(element).has('menu') ) { 2235 return KTUtil.data(element).get('menu'); 2236 } 2237 2238 // Element has .menu parent 2239 if ( menu = element.closest('.menu') ) { 2240 if ( KTUtil.data(menu).has('menu') ) { 2241 return KTUtil.data(menu).get('menu'); 2242 } 2243 } 2244 2245 // Element has a parent with DOM reference to .menu in it's DATA storage 2246 if ( KTUtil.hasClass(element, 'menu-link') ) { 2247 var sub = element.closest('.menu-sub'); 2248 2249 if ( KTUtil.data(sub).has('menu') ) { 2250 return KTUtil.data(sub).get('menu'); 2251 } 2252 } 2253 2254 return null; 2255} 2256 2257// Hide all dropdowns and skip one if provided 2258KTMenu.hideDropdowns = function(skip) { 2259 var items = document.querySelectorAll('.show.menu-dropdown[data-kt-menu-trigger]'); 2260 2261 if (items && items.length > 0) { 2262 for (var i = 0, len = items.length; i < len; i++) { 2263 var item = items[i]; 2264 var menu = KTMenu.getInstance(item); 2265 2266 if ( menu && menu.getItemSubType(item) === 'dropdown' ) { 2267 if ( skip ) { 2268 if ( menu.getItemSubElement(item).contains(skip) === false && item.contains(skip) === false && item !== skip ) { 2269 menu.hide(item); 2270 } 2271 } else { 2272 menu.hide(item); 2273 } 2274 } 2275 } 2276 } 2277} 2278 2279// Update all dropdowns popover instances 2280KTMenu.updateDropdowns = function() { 2281 var items = document.querySelectorAll('.show.menu-dropdown[data-kt-menu-trigger]'); 2282 2283 if (items && items.length > 0) { 2284 for (var i = 0, len = items.length; i < len; i++) { 2285 var item = items[i]; 2286
2287 if ( KTUtil.data(item).has('popper') ) { 2288 KTUtil.data(item).get('popper').forceUpdate(); 2289 } 2290 } 2291 } 2292} 2293 2294// Global handlers 2295KTMenu.initGlobalHandlers = function() { 2296 // Dropdown handler 2297 document.addEventListener("click", function(e) { 2298 var items = document.querySelectorAll('.show.menu-dropdown[data-kt-menu-trigger]'); 2299 var menu; 2300 var item; 2301 var sub; 2302 var menuObj; 2303 2304 if ( items && items.length > 0 ) { 2305 for ( var i = 0, len = items.length; i < len; i++ ) { 2306 item = items[i]; 2307 menuObj = KTMenu.getInstance(item); 2308 2309 if (menuObj && menuObj.getItemSubType(item) === 'dropdown') { 2310 menu = menuObj.getElement(); 2311 sub = menuObj.getItemSubElement(item); 2312 2313 if ( item === e.target || item.contains(e.target) ) { 2314 continue; 2315 } 2316 2317 if ( sub === e.target || sub.contains(e.target) ) { 2318 continue; 2319 } 2320 2321 menuObj.hide(item); 2322 } 2323 } 2324 } 2325 }); 2326 2327 // Sub toggle handler(updated) 2328 KTUtil.on(document.body, '.menu-item[data-kt-menu-trigger] > .menu-link, [data-kt-menu-trigger]:not(.menu-item):not([data-kt-menu-trigger="auto"])', 'click', function(e) { 2329 var menu = KTMenu.getInstance(this); 2330 2331 if ( menu !== null ) { 2332 return menu.click(this, e); 2333 } 2334 }); 2335 2336 // Link handler 2337 KTUtil.on(document.body, '.menu-item:not([data-kt-menu-trigger]) > .menu-link', 'click', function(e) { 2338 var menu = KTMenu.getInstance(this); 2339 2340 if ( menu !== null ) { 2341 return menu.link(this, e); 2342 } 2343 }); 2344 2345 // Dismiss handler 2346 KTUtil.on(document.body, '[data-kt-menu-dismiss="true"]', 'click', function(e) { 2347 var menu = KTMenu.getInstance(this); 2348 2349 if ( menu !== null ) { 2350 return menu.dismiss(this, e); 2351 } 2352 }); 2353 2354 // Mouseover handler 2355 KTUtil.on(document.body, '[data-kt-menu-trigger], .menu-sub', 'mouseover', function(e) { 2356 var menu = KTMenu.getInstance(this); 2357 2358 if ( menu !== null && menu.getItemSubType(this) === 'dropdown' ) { 2359 return menu.mouseover(this, e); 2360 } 2361 }); 2362 2363 // Mouseout handler 2364 KTUtil.on(document.body, '[data-kt-menu-trigger], .menu-sub', 'mouseout', function(e) { 2365 var menu = KTMenu.getInstance(this); 2366 2367 if ( menu !== null && menu.getItemSubType(this) === 'dropdown' ) { 2368 return menu.mouseout(this, e); 2369 } 2370 }); 2371 2372 // Resize handler 2373 window.addEventListener('resize', function() { 2374 var menu; 2375 var timer; 2376 2377 KTUtil.throttle(timer, function() { 2378 // Locate and update Offcanvas instances on window resize 2379 var elements = document.querySelectorAll('[data-kt-menu="true"]'); 2380 2381 if ( elements && elements.length > 0 ) { 2382 for (var i = 0, len = elements.length; i < len; i++) { 2383 menu = KTMenu.getInstance(elements[i]); 2384 if (menu) { 2385 menu.update(); 2386 } 2387 } 2388 } 2389 }, 200); 2390 }); 2391} 2392 2393// Global instances 2394KTMenu.createInstances = function(selector = '[data-kt-menu="true"]') { 2395 // Initialize menus 2396 var elements = document.querySelectorAll(selector); 2397 if ( elements && elements.length > 0 ) { 2398 for (var i = 0, len = elements.length; i < len; i++) { 2399 new KTMenu(elements[i]); 2400 } 2401 } 2402} 2403 2404// Global initialization 2405KTMenu.init = function() { 2406 // Global Event Handlers 2407 KTMenu.initGlobalHandlers(); 2408 2409 // Lazy Initialization 2410 KTMenu.createInstances(); 2411}; 2412 2413// On document ready 2414if (document.readyState === 'loading') { 2415 document.addEventListener('DOMContentLoaded', KTMenu.init); 2416} else { 2417 KTMenu.init(); 2418} 2419 2420// Webpack support 2421if (typeof module !== 'undefined' && typeof module.exports !== 'undefined') { 2422 module.exports = KTMenu; 2423} 2424 2425"use strict"; 2426 2427// Class definition 2428var KTPasswordMeter = function(element, options) {
2429 //////////////////////////// 2430 // ** Private variables ** // 2431 //////////////////////////// 2432 var the = this; 2433 2434 if (!element) { 2435 return; 2436 } 2437 2438 // Default Options 2439 var defaultOptions = { 2440 minLength: 8, 2441 checkUppercase: true, 2442 checkLowercase: true, 2443 checkDigit: true, 2444 checkChar: true, 2445 scoreHighlightClass: 'active' 2446 }; 2447 2448 //////////////////////////// 2449 // ** Private methods ** // 2450 //////////////////////////// 2451 2452 // Constructor 2453 var _construct = function() { 2454 if ( KTUtil.data(element).has('password-meter') === true ) { 2455 the = KTUtil.data(element).get('password-meter'); 2456 } else { 2457 _init(); 2458 } 2459 } 2460 2461 // Initialize 2462 var _init = function() { 2463 // Variables 2464 the.options = KTUtil.deepExtend({}, defaultOptions, options); 2465 the.score = 0; 2466 the.checkSteps = 5; 2467 2468 // Elements 2469 the.element = element; 2470 the.inputElement = the.element.querySelector('input[type]'); 2471 the.visibilityElement = the.element.querySelector('[data-kt-password-meter-control="visibility"]'); 2472 the.highlightElement = the.element.querySelector('[data-kt-password-meter-control="highlight"]'); 2473 2474 // Set initialized 2475 the.element.setAttribute('data-kt-password-meter', 'true'); 2476 2477 // Event Handlers 2478 _handlers(); 2479 2480 // Bind Instance 2481 KTUtil.data(the.element).set('password-meter', the); 2482 } 2483 2484 // Handlers 2485 var _handlers = function() { 2486 the.inputElement.addEventListener('input', function() { 2487 _check(); 2488 }); 2489 2490 if (the.visibilityElement) { 2491 the.visibilityElement.addEventListener('click', function() { 2492 _visibility(); 2493 }); 2494 } 2495 } 2496 2497 // Event handlers 2498 var _check = function() { 2499 var score = 0; 2500 var checkScore = _getCheckScore(); 2501 2502 if (_checkLength() === true) { 2503 score = score + checkScore; 2504 } 2505 2506 if (the.options.checkUppercase === true && _checkLowercase() === true) { 2507 score = score + checkScore; 2508 } 2509 2510 if (the.options.checkLowercase === true && _checkUppercase() === true ) { 2511 score = score + checkScore; 2512 } 2513 2514 if (the.options.checkDigit === true && _checkDigit() === true ) { 2515 score = score + checkScore; 2516 } 2517 2518 if (the.options.checkChar === true && _checkChar() === true ) { 2519 score = score + checkScore; 2520 } 2521 2522 the.score = score; 2523 2524 _highlight(); 2525 } 2526 2527 var _checkLength = function() { 2528 return the.inputElement.value.length >= the.options.minLength; // 20 score 2529 } 2530 2531 var _checkLowercase = function() { 2532 return /[a-z]/.test(the.inputElement.value); // 20 score 2533 } 2534 2535 var _checkUppercase = function() { 2536 return /[A-Z]/.test(the.inputElement.value); // 20 score 2537 } 2538 2539 var _checkDigit = function() { 2540 return /[0-9]/.test(the.inputElement.value); // 20 score 2541 } 2542 2543 var _checkChar = function() { 2544 return /[~`!#$%\^&*+=\-\[\]\\';,/{}|\\":<>\?]/g.test(the.inputElement.value); // 20 score 2545 } 2546 2547 var _getCheckScore = function() { 2548 var count = 1; 2549 2550 if (the.options.checkUppercase === true) { 2551 count++; 2552 } 2553 2554 if (the.options.checkLowercase === true) { 2555 count++; 2556 } 2557 2558 if (the.options.checkDigit === true) { 2559 count++; 2560 } 2561 2562 if (the.options.checkChar === true) { 2563 count++; 2564 } 2565 2566 the.checkSteps = count; 2567 2568 return 100 / the.checkSteps; 2569 } 2570 2571 var _highlight = function() { 2572 var items = [].slice.call(the.highlightElement.querySelectorAll('div')); 2573 var total = items.length; 2574 var index = 0; 2575 var checkScore = _getCheckScore(); 2576 var score = _getScore(); 2577 2578 items.map(function (item) { 2579 index++; 2580 2581 if ( (checkScore * index * (the.checkSteps / total)) <= score ) { 2582 item.classList.add('active'); 2583 } else { 2584 item.classList.remove('active'); 2585 } 2586 }); 2587 } 2588 2589 var _visibility = function() { 2590 var visibleIcon = the.visibilityElement.querySelector('i:not(.d-none), .svg-icon:not(.d-none)'); 2591 var hiddenIcon = the.visibilityElement.querySelector('i.d-none, .svg-icon.d-none'); 2592 2593 if (the.inputElement.getAttribute('type').toLowerCase() === 'password' ) { 2594 the.inputElement.setAttribute('type', 'text'); 2595 } else { 2596 the.inputElement.setAttribute('type', 'password'); 2597 } 2598 2599 visibleIcon.classList.add('d-none'); 2600 hiddenIcon.classList.remove('d-none'); 2601 2602 the.inputElement.focus(); 2603 } 2604 2605 var _reset = function() { 2606 the.score = 0; 2607 2608 _highlight(); 2609 } 2610 2611 // Gets current password score 2612 var _getScore = function() { 2613 return the.score; 2614 } 2615 2616 var _destroy = function() { 2617 KTUtil.data(the.element).remove('password-meter'); 2618 } 2619 2620 // Construct class 2621 _construct(); 2622
2623 /////////////////////// 2624 // ** Public API ** // 2625 /////////////////////// 2626 2627 // Plugin API 2628 the.check = function() { 2629 return _check(); 2630 } 2631 2632 the.getScore = function() { 2633 return _getScore(); 2634 } 2635 2636 the.reset = function() { 2637 return _reset(); 2638 } 2639 2640 the.destroy = function() { 2641 return _destroy(); 2642 } 2643}; 2644 2645// Static methods 2646KTPasswordMeter.getInstance = function(element) { 2647 if ( element !== null && KTUtil.data(element).has('password-meter') ) { 2648 return KTUtil.data(element).get('password-meter'); 2649 } else { 2650 return null; 2651 } 2652} 2653 2654// Create instances 2655KTPasswordMeter.createInstances = function(selector = '[data-kt-password-meter]') { 2656 // Get instances 2657 var elements = document.body.querySelectorAll(selector); 2658 2659 if ( elements && elements.length > 0 ) { 2660 for (var i = 0, len = elements.length; i < len; i++) { 2661 // Initialize instances 2662 new KTPasswordMeter(elements[i]); 2663 } 2664 } 2665} 2666 2667// Global initialization 2668KTPasswordMeter.init = function() { 2669 KTPasswordMeter.createInstances(); 2670}; 2671 2672// On document ready 2673if (document.readyState === 'loading') { 2674 document.addEventListener('DOMContentLoaded', KTPasswordMeter.init); 2675} else { 2676 KTPasswordMeter.init(); 2677} 2678 2679// Webpack support 2680if (typeof module !== 'undefined' && typeof module.exports !== 'undefined') { 2681 module.exports = KTPasswordMeter; 2682} 2683"use strict"; 2684 2685// Class definition 2686var KTScroll = function(element, options) { 2687 //////////////////////////// 2688 // ** Private Variables ** // 2689 //////////////////////////// 2690 var the = this; 2691 var body = document.getElementsByTagName("BODY")[0]; 2692 2693 if (!element) { 2694 return; 2695 } 2696 2697 // Default options 2698 var defaultOptions = { 2699 saveState: true 2700 }; 2701 2702 //////////////////////////// 2703 // ** Private Methods ** // 2704 //////////////////////////// 2705 2706 var _construct = function() { 2707 if ( KTUtil.data(element).has('scroll') ) { 2708 the = KTUtil.data(element).get('scroll'); 2709 } else { 2710 _init(); 2711 } 2712 } 2713 2714 var _init = function() { 2715 // Variables 2716 the.options = KTUtil.deepExtend({}, defaultOptions, options); 2717 2718 // Elements 2719 the.element = element; 2720 the.id = the.element.getAttribute('id'); 2721 2722 // Set initialized 2723 the.element.setAttribute('data-kt-scroll', 'true'); 2724 2725 // Update 2726 _update(); 2727 2728 // Bind Instance 2729 KTUtil.data(the.element).set('scroll', the); 2730 } 2731 2732 var _setupHeight = function() { 2733 var heightType = _getHeightType(); 2734 var height = _getHeight(); 2735 2736 // Set height 2737 if ( height !== null && height.length > 0 ) { 2738 KTUtil.css(the.element, heightType, height); 2739 } else { 2740 KTUtil.css(the.element, heightType, ''); 2741 } 2742 } 2743 2744 var _setupState = function () { 2745 if ( _getOption('save-state') === true && typeof KTCookie !== 'undefined' && the.id ) { 2746 if ( KTCookie.get(the.id + 'st') ) { 2747 var pos = parseInt(KTCookie.get(the.id + 'st')); 2748 2749 if ( pos > 0 ) { 2750 the.element.scrollTop = pos; 2751 } 2752 } 2753 } 2754 } 2755 2756 var _setupScrollHandler = function() { 2757 if ( _getOption('save-state') === true && typeof KTCookie !== 'undefined' && the.id ) { 2758 the.element.addEventListener('scroll', _scrollHandler); 2759 } else { 2760 the.element.removeEventListener('scroll', _scrollHandler); 2761 } 2762 } 2763 2764 var _destroyScrollHandler = function() { 2765 the.element.removeEventListener('scroll', _scrollHandler); 2766 } 2767 2768 var _resetHeight = function() { 2769 KTUtil.css(the.element, _getHeightType(), ''); 2770 } 2771 2772 var _scrollHandler = function () { 2773 KTCookie.set(the.id + 'st', the.element.scrollTop); 2774 } 2775 2776 var _update = function() { 2777 // Activate/deactivate 2778 if ( _getOption('activate') === true || the.element.hasAttribute('data-kt-scroll-activate') === false ) { 2779 _setupHeight(); 2780 _setupScrollHandler(); 2781 _setupState(); 2782 } else { 2783 _resetHeight() 2784 _destroyScrollHandler(); 2785 } 2786 } 2787 2788 var _getHeight = function() { 2789 var height = _getOption(_getHeightType()); 2790 2791 if ( height instanceof Function ) { 2792 return height.call(); 2793 } else if ( height !== null && typeof height === 'string' && height.toLowerCase() === 'auto' ) { 2794 return _getAutoHeight(); 2795 } else { 2796 return height; 2797 } 2798 } 2799 2800 var _getAutoHeight = function() { 2801 var height = KTUtil.getViewPort().height; 2802 2803 var dependencies = _getOption('dependencies'); 2804 var wrappers = _getOption('wrappers'); 2805 var offset = _getOption('offset'); 2806 2807 // Height dependencies
2808 if ( dependencies !== null ) { 2809 var elements = document.querySelectorAll(dependencies); 2810 2811 if ( elements && elements.length > 0 ) { 2812 for ( var i = 0, len = elements.length; i < len; i++ ) { 2813 var element = elements[i]; 2814 2815 if ( KTUtil.visible(element) === false ) { 2816 continue; 2817 } 2818 2819 height = height - parseInt(KTUtil.css(element, 'height')); 2820 height = height - parseInt(KTUtil.css(element, 'margin-top')); 2821 height = height - parseInt(KTUtil.css(element, 'margin-bottom')); 2822 2823 if (KTUtil.css(element, 'border-top')) { 2824 height = height - parseInt(KTUtil.css(element, 'border-top')); 2825 } 2826 2827 if (KTUtil.css(element, 'border-bottom')) { 2828 height = height - parseInt(KTUtil.css(element, 'border-bottom')); 2829 } 2830 } 2831 } 2832 } 2833 2834 // Wrappers 2835 if ( wrappers !== null ) { 2836 var elements = document.querySelectorAll(wrappers); 2837 if ( elements && elements.length > 0 ) { 2838 for ( var i = 0, len = elements.length; i < len; i++ ) { 2839 var element = elements[i]; 2840 2841 if ( KTUtil.visible(element) === false ) { 2842 continue; 2843 } 2844 2845 height = height - parseInt(KTUtil.css(element, 'margin-top')); 2846 height = height - parseInt(KTUtil.css(element, 'margin-bottom')); 2847 height = height - parseInt(KTUtil.css(element, 'padding-top')); 2848 height = height - parseInt(KTUtil.css(element, 'padding-bottom')); 2849 2850 if (KTUtil.css(element, 'border-top')) { 2851 height = height - parseInt(KTUtil.css(element, 'border-top')); 2852 } 2853 2854 if (KTUtil.css(element, 'border-bottom')) { 2855 height = height - parseInt(KTUtil.css(element, 'border-bottom')); 2856 } 2857 } 2858 } 2859 } 2860 2861 // Custom offset 2862 if ( offset !== null && typeof offset !== 'object') { 2863 height = height - parseInt(offset); 2864 } 2865 2866 height = height - parseInt(KTUtil.css(the.element, 'margin-top')); 2867 height = height - parseInt(KTUtil.css(the.element, 'margin-bottom')); 2868 2869 if (KTUtil.css(element, 'border-top')) { 2870 height = height - parseInt(KTUtil.css(element, 'border-top')); 2871 } 2872 2873 if (KTUtil.css(element, 'border-bottom')) { 2874 height = height - parseInt(KTUtil.css(element, 'border-bottom')); 2875 } 2876 2877 height = String(height) + 'px'; 2878 2879 return height; 2880 } 2881 2882 var _getOption = function(name) { 2883 if ( the.element.hasAttribute('data-kt-scroll-' + name) === true ) { 2884 var attr = the.element.getAttribute('data-kt-scroll-' + name); 2885 2886 var value = KTUtil.getResponsiveValue(attr); 2887 2888 if ( value !== null && String(value) === 'true' ) { 2889 value = true; 2890 } else if ( value !== null && String(value) === 'false' ) { 2891 value = false; 2892 } 2893 2894 return value; 2895 } else { 2896 var optionName = KTUtil.snakeToCamel(name); 2897 2898 if ( the.options[optionName] ) { 2899 return KTUtil.getResponsiveValue(the.options[optionName]); 2900 } else { 2901 return null; 2902 } 2903 } 2904 } 2905 2906 var _getHeightType = function() { 2907 if (_getOption('height')) { 2908 return 'height'; 2909 } if (_getOption('min-height')) { 2910 return 'min-height'; 2911 } if (_getOption('max-height')) { 2912 return 'max-height'; 2913 } 2914 } 2915 2916 var _destroy = function() { 2917 KTUtil.data(the.element).remove('scroll'); 2918 } 2919 2920 // Construct Class 2921 _construct(); 2922 2923 /////////////////////// 2924 // ** Public API ** // 2925 /////////////////////// 2926 2927 the.update = function() { 2928 return _update(); 2929 } 2930 2931 the.getHeight = function() { 2932 return _getHeight(); 2933 } 2934 2935 the.getElement = function() { 2936 return the.element; 2937 } 2938 2939 the.destroy = function() { 2940 return _destroy(); 2941 } 2942}; 2943 2944// Static methods 2945KTScroll.getInstance = function(element) { 2946 if ( element !== null && KTUtil.data(element).has('scroll') ) { 2947 return KTUtil.data(element).get('scroll'); 2948 } else { 2949 return null; 2950 } 2951} 2952 2953// Create instances 2954KTScroll.createInstances = function(selector = '[data-kt-scroll="true"]') { 2955 var body = document.getElementsByTagName("BODY")[0]; 2956 2957 // Initialize Menus 2958 var elements = body.querySelectorAll(selector); 2959 2960 if ( elements && elements.length > 0 ) { 2961 for (var i = 0, len = elements.length; i < len; i++) { 2962 new KTScroll(elements[i]); 2963 } 2964 } 2965} 2966 2967// Window resize handling 2968window.addEventListener('resize', function() { 2969 var timer; 2970 var body = document.getElementsByTagName("BODY")[0]; 2971 2972 KTUtil.throttle(timer, function() { 2973 // Locate and update Offcanvas instances on window resize 2974 var elements = body.querySelectorAll('[data-kt-scroll="true"]'); 2975 2976 if ( elements && elements.length > 0 ) { 2977 for (var i = 0, len = elements.length; i < len; i++) { 2978 var scroll = KTScroll.getInstance(elements[i]); 2979 if (scroll) {
2980 scroll.update(); 2981 } 2982 } 2983 } 2984 }, 200); 2985}); 2986 2987// Global initialization 2988KTScroll.init = function() { 2989 KTScroll.createInstances(); 2990}; 2991 2992// On document ready 2993if (document.readyState === 'loading') { 2994 document.addEventListener('DOMContentLoaded', KTScroll.init); 2995} else { 2996 KTScroll.init(); 2997} 2998 2999// Webpack Support 3000if (typeof module !== 'undefined' && typeof module.exports !== 'undefined') { 3001 module.exports = KTScroll; 3002} 3003 3004"use strict"; 3005 3006// Class definition 3007var KTScrolltop = function(element, options) { 3008 //////////////////////////// 3009 // ** Private variables ** // 3010 //////////////////////////// 3011 var the = this; 3012 var body = document.getElementsByTagName("BODY")[0]; 3013 3014 if ( typeof element === "undefined" || element === null ) { 3015 return; 3016 } 3017 3018 // Default options 3019 var defaultOptions = { 3020 offset: 300, 3021 speed: 600 3022 }; 3023 3024 //////////////////////////// 3025 // ** Private methods ** // 3026 //////////////////////////// 3027 3028 var _construct = function() { 3029 if (KTUtil.data(element).has('scrolltop')) { 3030 the = KTUtil.data(element).get('scrolltop'); 3031 } else { 3032 _init(); 3033 } 3034 } 3035 3036 var _init = function() { 3037 // Variables 3038 the.options = KTUtil.deepExtend({}, defaultOptions, options); 3039 the.uid = KTUtil.getUniqueId('scrolltop'); 3040 the.element = element; 3041 3042 // Set initialized 3043 the.element.setAttribute('data-kt-scrolltop', 'true'); 3044 3045 // Event Handlers 3046 _handlers(); 3047 3048 // Bind Instance 3049 KTUtil.data(the.element).set('scrolltop', the); 3050 } 3051 3052 var _handlers = function() { 3053 var timer; 3054 3055 window.addEventListener('scroll', function() { 3056 KTUtil.throttle(timer, function() { 3057 _scroll(); 3058 }, 200); 3059 }); 3060 3061 KTUtil.addEvent(the.element, 'click', function(e) { 3062 e.preventDefault(); 3063 3064 _go(); 3065 }); 3066 } 3067 3068 var _scroll = function() { 3069 var offset = parseInt(_getOption('offset')); 3070 3071 var pos = KTUtil.getScrollTop(); // current vertical position 3072 3073 if ( pos > offset ) { 3074 if ( body.hasAttribute('data-kt-scrolltop') === false ) { 3075 body.setAttribute('data-kt-scrolltop', 'on'); 3076 } 3077 } else { 3078 if ( body.hasAttribute('data-kt-scrolltop') === true ) { 3079 body.removeAttribute('data-kt-scrolltop'); 3080 } 3081 } 3082 } 3083 3084 var _go = function() { 3085 var speed = parseInt(_getOption('speed')); 3086 3087 KTUtil.scrollTop(0, speed); 3088 } 3089 3090 var _getOption = function(name) { 3091 if ( the.element.hasAttribute('data-kt-scrolltop-' + name) === true ) { 3092 var attr = the.element.getAttribute('data-kt-scrolltop-' + name); 3093 var value = KTUtil.getResponsiveValue(attr); 3094 3095 if ( value !== null && String(value) === 'true' ) { 3096 value = true; 3097 } else if ( value !== null && String(value) === 'false' ) { 3098 value = false; 3099 } 3100 3101 return value; 3102 } else { 3103 var optionName = KTUtil.snakeToCamel(name); 3104 3105 if ( the.options[optionName] ) { 3106 return KTUtil.getResponsiveValue(the.options[optionName]); 3107 } else { 3108 return null; 3109 } 3110 } 3111 } 3112 3113 var _destroy = function() { 3114 KTUtil.data(the.element).remove('scrolltop'); 3115 } 3116 3117 // Construct class 3118 _construct(); 3119 3120 /////////////////////// 3121 // ** Public API ** // 3122 /////////////////////// 3123 3124 // Plugin API 3125 the.go = function() { 3126 return _go(); 3127 } 3128 3129 the.getElement = function() { 3130 return the.element; 3131 } 3132 3133 the.destroy = function() { 3134 return _destroy(); 3135 } 3136}; 3137 3138// Static methods 3139KTScrolltop.getInstance = function(element) { 3140 if (element && KTUtil.data(element).has('scrolltop')) { 3141 return KTUtil.data(element).get('scrolltop'); 3142 } else { 3143 return null; 3144 } 3145} 3146 3147// Create instances 3148KTScrolltop.createInstances = function(selector = '[data-kt-scrolltop="true"]') { 3149 var body = document.getElementsByTagName("BODY")[0]; 3150 3151 // Initialize Menus 3152 var elements = body.querySelectorAll(selector); 3153 var scrolltop; 3154 3155 if ( elements && elements.length > 0 ) { 3156 for (var i = 0, len = elements.length; i < len; i++) { 3157 scrolltop = new KTScrolltop(elements[i]); 3158 } 3159 } 3160} 3161 3162// Global initialization 3163KTScrolltop.init = function() { 3164 KTScrolltop.createInstances(); 3165}; 3166 3167// On document ready 3168if (document.readyState === 'loading') { 3169 document.addEventListener('DOMContentLoaded', KTScrolltop.init); 3170} else { 3171 KTScrolltop.init(); 3172} 3173 3174// Webpack support 3175if (typeof module !== 'undefined' && typeof module.exports !== 'undefined') { 3176 module.exports = KTScrolltop; 3177} 3178 3179"use strict"; 3180 3181// Class definition 3182var KTSearch = function(element, options) {
3183 //////////////////////////// 3184 // ** Private variables ** // 3185 //////////////////////////// 3186 var the = this; 3187 3188 if (!element) { 3189 return; 3190 } 3191 3192 // Default Options 3193 var defaultOptions = { 3194 minLength: 2, // Miniam text lenght to query search 3195 keypress: true, // Enable search on keypress 3196 enter: true, // Enable search on enter key press 3197 layout: 'menu', // Use 'menu' or 'inline' layout options to display search results 3198 responsive: null, // Pass integer value or bootstrap compatible breakpoint key(sm,md,lg,xl,xxl) to enable reponsive form mode for device width below the breakpoint value 3199 showOnFocus: true // Always show menu on input focus 3200 }; 3201 3202 //////////////////////////// 3203 // ** Private methods ** // 3204 //////////////////////////// 3205 3206 // Construct 3207 var _construct = function() { 3208 if ( KTUtil.data(element).has('search') === true ) { 3209 the = KTUtil.data(element).get('search'); 3210 } else { 3211 _init(); 3212 } 3213 } 3214 3215 // Init 3216 var _init = function() { 3217 // Variables 3218 the.options = KTUtil.deepExtend({}, defaultOptions, options); 3219 the.processing = false; 3220 3221 // Elements 3222 the.element = element; 3223 the.contentElement = _getElement('content'); 3224 the.formElement = _getElement('form'); 3225 the.inputElement = _getElement('input'); 3226 the.spinnerElement = _getElement('spinner'); 3227 the.clearElement = _getElement('clear'); 3228 the.toggleElement = _getElement('toggle'); 3229 the.submitElement = _getElement('submit'); 3230 the.toolbarElement = _getElement('toolbar'); 3231 3232 the.resultsElement = _getElement('results'); 3233 the.suggestionElement = _getElement('suggestion'); 3234 the.emptyElement = _getElement('empty'); 3235 3236 // Set initialized 3237 the.element.setAttribute('data-kt-search', 'true'); 3238 3239 // Layout 3240 the.layout = _getOption('layout'); 3241 3242 // Menu 3243 if ( the.layout === 'menu' ) { 3244 the.menuObject = new KTMenu(the.contentElement); 3245 } else { 3246 the.menuObject = null; 3247 } 3248 3249 // Update 3250 _update(); 3251 3252 // Event Handlers 3253 _handlers(); 3254 3255 // Bind Instance 3256 KTUtil.data(the.element).set('search', the); 3257 } 3258 3259 // Handlera 3260 var _handlers = function() { 3261 // Focus 3262 // the.inputElement.addEventListener('focus', _focus); 3263 3264 // Blur 3265 // the.inputElement.addEventListener('blur', _blur); 3266 3267 // Keypress 3268 if ( _getOption('keypress') === true ) { 3269 // the.inputElement.addEventListener('input', _input); 3270 } 3271 3272 // Submit 3273 if ( the.submitElement ) { 3274 the.submitElement.addEventListener('click', _search); 3275 } 3276 3277 // Enter 3278 if ( _getOption('enter') === true ) { 3279 the.inputElement.addEventListener('keypress', _enter); 3280 } 3281 3282 // Clear 3283 if ( the.clearElement ) { 3284 the.clearElement.addEventListener('click', _clear); 3285 } 3286 3287 // Menu 3288 if ( the.menuObject ) { 3289 // Toggle menu 3290 if ( the.toggleElement ) { 3291 the.toggleElement.addEventListener('click', _show); 3292 3293 the.menuObject.on('kt.menu.dropdown.show', function(item) { 3294 if (KTUtil.visible(the.toggleElement)) { 3295 the.toggleElement.classList.add('active'); 3296 the.toggleElement.classList.add('show'); 3297 } 3298 }); 3299 3300 the.menuObject.on('kt.menu.dropdown.hide', function(item) { 3301 if (KTUtil.visible(the.toggleElement)) { 3302 the.toggleElement.classList.remove('active'); 3303 the.toggleElement.classList.remove('show'); 3304 } 3305 }); 3306 } 3307 3308 // the.menuObject.on('kt.menu.dropdown.shown', function() { 3309 // the.inputElement.focus(); 3310 // }); 3311 } 3312
3313 // Window resize handling 3314 window.addEventListener('resize', function() { 3315 var timer; 3316 3317 KTUtil.throttle(timer, function() { 3318 _update(); 3319 }, 200); 3320 }); 3321 } 3322 3323 // Focus 3324 var _focus = function() { 3325 the.element.classList.add('focus'); 3326 3327 if ( _getOption('show-on-focus') === true || the.inputElement.value.length >= minLength ) { 3328 _show(); 3329 } 3330 } 3331 3332 // Blur 3333 var _blur = function() { 3334 the.element.classList.remove('focus'); 3335 } 3336 3337 // Enter 3338 var _enter = function(e) { 3339 var key = e.charCode || e.keyCode || 0; 3340 3341 if (key == 13) { 3342 e.preventDefault(); 3343 3344 _search(); 3345 } 3346 } 3347 3348 // Input 3349 var _input = function() { 3350 if ( _getOption('min-length') ) { 3351 var minLength = parseInt(_getOption('min-length')); 3352 3353 if ( the.inputElement.value.length >= minLength ) { 3354 _search(); 3355 } else if ( the.inputElement.value.length === 0 ) { 3356 _clear(); 3357 } 3358 } 3359 } 3360 3361 // Search 3362 var _search = function() { 3363 if (the.processing === false) { 3364 // Show search spinner 3365 if (the.spinnerElement) { 3366 the.spinnerElement.classList.remove("d-none"); 3367 } 3368 3369 // Hide search clear button 3370 if (the.clearElement) { 3371 the.clearElement.classList.add("d-none"); 3372 } 3373 3374 // Hide search toolbar 3375 if (the.toolbarElement && the.formElement.contains(the.toolbarElement)) { 3376 the.toolbarElement.classList.add("d-none"); 3377 } 3378 3379 // Focus input 3380 the.inputElement.focus(); 3381 3382 the.processing = true; 3383 KTEventHandler.trigger(the.element, 'kt.search.process', the); 3384 } 3385 } 3386 3387 // Complete 3388 var _complete = function() { 3389 if (the.spinnerElement) { 3390 the.spinnerElement.classList.add("d-none"); 3391 } 3392 3393 // Show search toolbar 3394 if (the.clearElement) { 3395 the.clearElement.classList.remove("d-none"); 3396 } 3397 3398 if ( the.inputElement.value.length === 0 ) { 3399 _clear(); 3400 } 3401 3402 // Focus input 3403 the.inputElement.focus(); 3404 3405 _show(); 3406 3407 the.processing = false; 3408 } 3409 3410 // Clear 3411 var _clear = function() { 3412 if ( KTEventHandler.trigger(the.element, 'kt.search.clear', the) === false ) { 3413 return; 3414 } 3415 3416 // Clear and focus input 3417 the.inputElement.value = ""; 3418 the.inputElement.focus(); 3419 3420 // Hide clear icon 3421 if (the.clearElement) { 3422 the.clearElement.classList.add("d-none"); 3423 } 3424 3425 // Show search toolbar 3426 if (the.toolbarElement && the.formElement.contains(the.toolbarElement)) { 3427 the.toolbarElement.classList.remove("d-none"); 3428 } 3429 3430 // Hide menu 3431 if ( _getOption('show-on-focus') === false ) { 3432 _hide(); 3433 } 3434 3435 KTEventHandler.trigger(the.element, 'kt.search.cleared', the); 3436 } 3437 3438 // Update 3439 var _update = function() { 3440 // Handle responsive form 3441 if (the.layout === 'menu') { 3442 var responsiveFormMode = _getResponsiveFormMode(); 3443 3444 if ( responsiveFormMode === 'on' && the.contentElement.contains(the.formElement) === false ) { 3445 the.contentElement.prepend(the.formElement); 3446 the.formElement.classList.remove('d-none'); 3447 } else if ( responsiveFormMode === 'off' && the.contentElement.contains(the.formElement) === true ) { 3448 the.element.prepend(the.formElement); 3449 the.formElement.classList.add('d-none'); 3450 } 3451 } 3452 } 3453 3454 // Show menu 3455 var _show = function() { 3456 if ( the.menuObject ) { 3457 _update(); 3458 3459 the.menuObject.show(the.element); 3460 } 3461 } 3462 3463 // Hide menu 3464 var _hide = function() { 3465 if ( the.menuObject ) { 3466 _update(); 3467 3468 the.menuObject.hide(the.element); 3469 } 3470 } 3471 3472 // Get option 3473 var _getOption = function(name) {
3474 if ( the.element.hasAttribute('data-kt-search-' + name) === true ) { 3475 var attr = the.element.getAttribute('data-kt-search-' + name); 3476 var value = KTUtil.getResponsiveValue(attr); 3477 3478 if ( value !== null && String(value) === 'true' ) { 3479 value = true; 3480 } else if ( value !== null && String(value) === 'false' ) { 3481 value = false; 3482 } 3483 3484 return value; 3485 } else { 3486 var optionName = KTUtil.snakeToCamel(name); 3487 3488 if ( the.options[optionName] ) { 3489 return KTUtil.getResponsiveValue(the.options[optionName]); 3490 } else { 3491 return null; 3492 } 3493 } 3494 } 3495 3496 // Get element 3497 var _getElement = function(name) { 3498 return the.element.querySelector('[data-kt-search-element="' + name + '"]'); 3499 } 3500 3501 // Check if responsive form mode is enabled 3502 var _getResponsiveFormMode = function() { 3503 var responsive = _getOption('responsive'); 3504 var width = KTUtil.getViewPort().width; 3505 3506 if (!responsive) { 3507 return null; 3508 } 3509 3510 var breakpoint = KTUtil.getBreakpoint(responsive); 3511 3512 if (!breakpoint ) { 3513 breakpoint = parseInt(responsive); 3514 } 3515 3516 if (width < breakpoint) { 3517 return "on"; 3518 } else { 3519 return "off"; 3520 } 3521 } 3522 3523 var _destroy = function() { 3524 KTUtil.data(the.element).remove('search'); 3525 } 3526 3527 // Construct class 3528 _construct(); 3529 3530 /////////////////////// 3531 // ** Public API ** // 3532 /////////////////////// 3533 3534 // Plugin API 3535 the.show = function() { 3536 return _show(); 3537 } 3538 3539 the.hide = function() { 3540 return _hide(); 3541 } 3542 3543 the.update = function() { 3544 return _update(); 3545 } 3546 3547 the.search = function() { 3548 return _search(); 3549 } 3550 3551 the.complete = function() { 3552 return _complete(); 3553 } 3554 3555 the.clear = function() { 3556 return _clear(); 3557 } 3558 3559 the.isProcessing = function() { 3560 return the.processing; 3561 } 3562 3563 the.getQuery = function() { 3564 return the.inputElement.value; 3565 } 3566 3567 the.getMenu = function() { 3568 return the.menuObject; 3569 } 3570 3571 the.getFormElement = function() { 3572 return the.formElement; 3573 } 3574 3575 the.getInputElement = function() { 3576 return the.inputElement; 3577 } 3578 3579 the.getContentElement = function() { 3580 return the.contentElement; 3581 } 3582 3583 the.getElement = function() { 3584 return the.element; 3585 } 3586 3587 the.destroy = function() { 3588 return _destroy(); 3589 } 3590 3591 // Event API 3592 the.on = function(name, handler) { 3593 return KTEventHandler.on(the.element, name, handler); 3594 } 3595 3596 the.one = function(name, handler) { 3597 return KTEventHandler.one(the.element, name, handler); 3598 } 3599 3600 the.off = function(name) { 3601 return KTEventHandler.off(the.element, name); 3602 } 3603}; 3604 3605// Static methods 3606KTSearch.getInstance = function(element) { 3607 if ( element !== null && KTUtil.data(element).has('search') ) { 3608 return KTUtil.data(element).get('search'); 3609 } else { 3610 return null; 3611 } 3612} 3613 3614// Webpack support 3615if (typeof module !== 'undefined' && typeof module.exports !== 'undefined') { 3616 module.exports = KTSearch; 3617} 3618 3619"use strict"; 3620 3621// Class definition 3622var KTStepper = function(element, options) { 3623 ////////////////////////////// 3624 // ** Private variables ** // 3625 ////////////////////////////// 3626 var the = this; 3627 var body = document.getElementsByTagName("BODY")[0]; 3628 3629 if ( typeof element === "undefined" || element === null ) { 3630 return; 3631 } 3632 3633 // Default Options 3634 var defaultOptions = { 3635 startIndex: 1, 3636 animation: false, 3637 animationSpeed: '0.3s', 3638 animationNextClass: 'animate__animated animate__slideInRight animate__fast', 3639 animationPreviousClass: 'animate__animated animate__slideInLeft animate__fast' 3640 }; 3641 3642 //////////////////////////// 3643 // ** Private methods ** // 3644 //////////////////////////// 3645 3646 var _construct = function() {
3647 if ( KTUtil.data(element).has('stepper') === true ) { 3648 the = KTUtil.data(element).get('stepper'); 3649 } else { 3650 _init(); 3651 } 3652 } 3653 3654 var _init = function() { 3655 the.options = KTUtil.deepExtend({}, defaultOptions, options); 3656 the.uid = KTUtil.getUniqueId('stepper'); 3657 3658 the.element = element; 3659 3660 // Set initialized 3661 the.element.setAttribute('data-kt-stepper', 'true'); 3662 3663 // Elements 3664 the.steps = KTUtil.findAll(the.element, '[data-kt-stepper-element="nav"]'); 3665 the.btnNext = KTUtil.find(the.element, '[data-kt-stepper-action="next"]'); 3666 the.btnPrevious = KTUtil.find(the.element, '[data-kt-stepper-action="previous"]'); 3667 the.btnSubmit = KTUtil.find(the.element, '[data-kt-stepper-action="submit"]'); 3668 3669 // Variables 3670 the.totalStepsNumber = the.steps.length; 3671 the.passedStepIndex = 0; 3672 the.currentStepIndex = 1; 3673 the.clickedStepIndex = 0; 3674 3675 // Set Current Step 3676 if ( the.options.startIndex > 1 ) { 3677 _goTo(the.options.startIndex); 3678 } 3679 3680 // Event Handlers 3681 KTUtil.addEvent(the.btnNext, 'click', function(e) { 3682 e.preventDefault(); 3683 3684 KTEventHandler.trigger(the.element, 'kt.stepper.next', the); 3685 }); 3686 3687 KTUtil.addEvent(the.btnPrevious, 'click', function(e) { 3688 e.preventDefault(); 3689 3690 KTEventHandler.trigger(the.element, 'kt.stepper.previous', the); 3691 }); 3692 3693 KTUtil.on(the.element, '[data-kt-stepper-action="step"]', 'click', function(e) { 3694 e.preventDefault(); 3695 3696 if ( the.steps && the.steps.length > 0 ) { 3697 for (var i = 0, len = the.steps.length; i < len; i++) { 3698 if ( the.steps[i] === this ) { 3699 the.clickedStepIndex = i + 1; 3700 3701 KTEventHandler.trigger(the.element, 'kt.stepper.click', the); 3702 3703 return; 3704 } 3705 } 3706 } 3707 }); 3708 3709 // Bind Instance 3710 KTUtil.data(the.element).set('stepper', the); 3711 } 3712 3713 var _goTo = function(index) { 3714 // Trigger "change" event 3715 KTEventHandler.trigger(the.element, 'kt.stepper.change', the); 3716 3717 // Skip if this step is already shown 3718 if ( index === the.currentStepIndex || index > the.totalStepsNumber || index < 0 ) { 3719 return; 3720 } 3721 3722 // Validate step number 3723 index = parseInt(index); 3724 3725 // Set current step 3726 the.passedStepIndex = the.currentStepIndex; 3727 the.currentStepIndex = index; 3728 3729 // Refresh elements 3730 _refreshUI(); 3731 3732 // Trigger "changed" event 3733 KTEventHandler.trigger(the.element, 'kt.stepper.changed', the); 3734 3735 return the; 3736 } 3737 3738 var _goNext = function() { 3739 return _goTo( _getNextStepIndex() ); 3740 } 3741 3742 var _goPrevious = function() { 3743 return _goTo( _getPreviousStepIndex() ); 3744 } 3745 3746 var _goLast = function() { 3747 return _goTo( _getLastStepIndex() ); 3748 } 3749 3750 var _goFirst = function() { 3751 return _goTo( _getFirstStepIndex() ); 3752 } 3753 3754 var _refreshUI = function() { 3755 var state = ''; 3756 3757 if ( _isLastStep() ) { 3758 state = 'last'; 3759 } else if ( _isFirstStep() ) { 3760 state = 'first'; 3761 } else { 3762 state = 'between'; 3763 } 3764 3765 // Set state class 3766 KTUtil.removeClass(the.element, 'last'); 3767 KTUtil.removeClass(the.element, 'first'); 3768 KTUtil.removeClass(the.element, 'between'); 3769 3770 KTUtil.addClass(the.element, state); 3771 3772 // Step Items 3773 var elements = KTUtil.findAll(the.element, '[data-kt-stepper-element="nav"], [data-kt-stepper-element="content"], [data-kt-stepper-element="info"]'); 3774 3775 if ( elements && elements.length > 0 ) { 3776 for (var i = 0, len = elements.length; i < len; i++) { 3777 var element = elements[i]; 3778 var index = KTUtil.index(element) + 1; 3779 3780 KTUtil.removeClass(element, 'current'); 3781 KTUtil.removeClass(element, 'completed'); 3782 KTUtil.removeClass(element, 'pending'); 3783 3784 if ( index == the.currentStepIndex ) { 3785 KTUtil.addClass(element, 'current'); 3786 3787 if ( the.options.animation !== false && element.getAttribute('data-kt-stepper-element') == 'content' ) { 3788 KTUtil.css(element, 'animationDuration', the.options.animationSpeed); 3789 3790 var animation = _getStepDirection(the.passedStepIndex) === 'previous' ? the.options.animationPreviousClass : the.options.animationNextClass; 3791 KTUtil.animateClass(element, animation); 3792 } 3793 } else { 3794 if ( index < the.currentStepIndex ) { 3795 KTUtil.addClass(element, 'completed'); 3796 } else { 3797 KTUtil.addClass(element, 'pending'); 3798 } 3799 } 3800 } 3801 } 3802 } 3803 3804 var _isLastStep = function() { 3805 return the.currentStepIndex === the.totalStepsNumber; 3806 } 3807 3808 var _isFirstStep = function() { 3809 return the.currentStepIndex === 1; 3810 } 3811 3812 var _isBetweenStep = function() { 3813 return _isLastStep() === false && _isFirstStep() === false; 3814 } 3815 3816 var _getNextStepIndex = function() { 3817 if ( the.totalStepsNumber >= ( the.currentStepIndex + 1 ) ) { 3818 return the.currentStepIndex + 1; 3819 } else { 3820 return the.totalStepsNumber; 3821 } 3822 } 3823 3824 var _getPreviousStepIndex = function() { 3825 if ( ( the.currentStepIndex - 1 ) > 1 ) { 3826 return the.currentStepIndex - 1; 3827 } else { 3828 return 1; 3829 } 3830 } 3831 3832 var _getFirstStepIndex = function(){ 3833 return 1; 3834 } 3835 3836 var _getLastStepIndex = function() { 3837 return the.totalStepsNumber; 3838 } 3839 3840 var _getTotalStepsNumber = function() { 3841 return the.totalStepsNumber; 3842 } 3843 3844 var _getStepDirection = function(index) { 3845 if ( index > the.currentStepIndex ) { 3846 return 'next'; 3847 } else { 3848 return 'previous'; 3849 } 3850 } 3851 3852 var _getStepContent = function(index) { 3853 var content = KTUtil.findAll(the.element, '[data-kt-stepper-element="content"]'); 3854 3855 if ( content[index-1] ) { 3856 return content[index-1]; 3857 } else { 3858 return false;
3859 } 3860 } 3861 3862 var _destroy = function() { 3863 KTUtil.data(the.element).remove('stepper'); 3864 } 3865 3866 // Construct Class 3867 _construct(); 3868 3869 /////////////////////// 3870 // ** Public API ** // 3871 /////////////////////// 3872 3873 // Plugin API 3874 the.getElement = function(index) { 3875 return the.element; 3876 } 3877 3878 the.goTo = function(index) { 3879 return _goTo(index); 3880 } 3881 3882 the.goPrevious = function() { 3883 return _goPrevious(); 3884 } 3885 3886 the.goNext = function() { 3887 return _goNext(); 3888 } 3889 3890 the.goFirst = function() { 3891 return _goFirst(); 3892 } 3893 3894 the.goLast = function() { 3895 return _goLast(); 3896 } 3897 3898 the.getCurrentStepIndex = function() { 3899 return the.currentStepIndex; 3900 } 3901 3902 the.getNextStepIndex = function() { 3903 return the.nextStepIndex; 3904 } 3905 3906 the.getPassedStepIndex = function() { 3907 return the.passedStepIndex; 3908 } 3909 3910 the.getClickedStepIndex = function() { 3911 return the.clickedStepIndex; 3912 } 3913 3914 the.getPreviousStepIndex = function() { 3915 return the.PreviousStepIndex; 3916 } 3917 3918 the.destroy = function() { 3919 return _destroy(); 3920 } 3921 3922 // Event API 3923 the.on = function(name, handler) { 3924 return KTEventHandler.on(the.element, name, handler); 3925 } 3926 3927 the.one = function(name, handler) { 3928 return KTEventHandler.one(the.element, name, handler); 3929 } 3930 3931 the.off = function(name) { 3932 return KTEventHandler.off(the.element, name); 3933 } 3934 3935 the.trigger = function(name, event) { 3936 return KTEventHandler.trigger(the.element, name, event, the, event); 3937 } 3938}; 3939 3940// Static methods 3941KTStepper.getInstance = function(element) { 3942 if ( element !== null && KTUtil.data(element).has('stepper') ) { 3943 return KTUtil.data(element).get('stepper'); 3944 } else { 3945 return null; 3946 } 3947} 3948 3949// Webpack support 3950if (typeof module !== 'undefined' && typeof module.exports !== 'undefined') { 3951 module.exports = KTStepper; 3952} 3953 3954"use strict"; 3955 3956// Class definition 3957var KTSticky = function(element, options) { 3958 //////////////////////////// 3959 // ** Private Variables ** // 3960 //////////////////////////// 3961 var the = this; 3962 var body = document.getElementsByTagName("BODY")[0]; 3963 3964 if ( typeof element === "undefined" || element === null ) { 3965 return; 3966 } 3967 3968 // Default Options 3969 var defaultOptions = { 3970 offset: 200, 3971 releaseOffset: 0, 3972 reverse: false, 3973 animation: true, 3974 animationSpeed: '0.3s', 3975 animationClass: 'animation-slide-in-down' 3976 }; 3977 //////////////////////////// 3978 // ** Private Methods ** // 3979 //////////////////////////// 3980 3981 var _construct = function() { 3982 if ( KTUtil.data(element).has('sticky') === true ) { 3983 the = KTUtil.data(element).get('sticky'); 3984 } else { 3985 _init(); 3986 } 3987 } 3988 3989 var _init = function() { 3990 the.element = element; 3991 the.options = KTUtil.deepExtend({}, defaultOptions, options); 3992 the.uid = KTUtil.getUniqueId('sticky'); 3993 the.name = the.element.getAttribute('data-kt-sticky-name'); 3994 the.attributeName = 'data-kt-sticky-' + the.name; 3995 the.eventTriggerState = true; 3996 the.lastScrollTop = 0; 3997 the.scrollHandler; 3998 3999 // Set initialized 4000 the.element.setAttribute('data-kt-sticky', 'true'); 4001 4002 // Event Handlers 4003 window.addEventListener('scroll', _scroll); 4004 4005 // Initial Launch 4006 _scroll(); 4007 4008 // Bind Instance 4009 KTUtil.data(the.element).set('sticky', the); 4010 } 4011 4012 var _scroll = function(e) { 4013 var offset = _getOption('offset'); 4014 var releaseOffset = _getOption('release-offset'); 4015 var reverse = _getOption('reverse'); 4016 var st; 4017 var attrName; 4018 var diff; 4019 4020 // Exit if false 4021 if ( offset === false ) { 4022 return; 4023 } 4024 4025 offset = parseInt(offset); 4026 releaseOffset = releaseOffset ? parseInt(releaseOffset) : 0; 4027 st = KTUtil.getScrollTop(); 4028 diff = document.documentElement.scrollHeight - window.innerHeight - KTUtil.getScrollTop(); 4029 4030 if ( reverse === true ) { // Release on reverse scroll mode 4031 if ( st > offset && (releaseOffset === 0 || releaseOffset < diff)) { 4032 if ( body.hasAttribute(the.attributeName) === false) { 4033 _enable(); 4034 body.setAttribute(the.attributeName, 'on'); 4035 } 4036 4037 if ( the.eventTriggerState === true ) { 4038 KTEventHandler.trigger(the.element, 'kt.sticky.on', the); 4039 KTEventHandler.trigger(the.element, 'kt.sticky.change', the); 4040 4041 the.eventTriggerState = false;
4042 } 4043 } else { // Back scroll mode 4044 if ( body.hasAttribute(the.attributeName) === true) { 4045 _disable(); 4046 body.removeAttribute(the.attributeName); 4047 } 4048 4049 if ( the.eventTriggerState === false ) { 4050 KTEventHandler.trigger(the.element, 'kt.sticky.off', the); 4051 KTEventHandler.trigger(the.element, 'kt.sticky.change', the); 4052 the.eventTriggerState = true; 4053 } 4054 } 4055 4056 the.lastScrollTop = st; 4057 } else { // Classic scroll mode 4058 if ( st > offset && (releaseOffset === 0 || releaseOffset < diff)) { 4059 if ( body.hasAttribute(the.attributeName) === false) { 4060 _enable(); 4061 body.setAttribute(the.attributeName, 'on'); 4062 } 4063 4064 if ( the.eventTriggerState === true ) { 4065 KTEventHandler.trigger(the.element, 'kt.sticky.on', the); 4066 KTEventHandler.trigger(the.element, 'kt.sticky.change', the); 4067 the.eventTriggerState = false; 4068 } 4069 } else { // back scroll mode 4070 if ( body.hasAttribute(the.attributeName) === true ) { 4071 _disable(); 4072 body.removeAttribute(the.attributeName); 4073 } 4074 4075 if ( the.eventTriggerState === false ) { 4076 KTEventHandler.trigger(the.element, 'kt.sticky.off', the); 4077 KTEventHandler.trigger(the.element, 'kt.sticky.change', the); 4078 the.eventTriggerState = true; 4079 } 4080 } 4081 } 4082 4083 if (releaseOffset > 0) { 4084 if ( diff < releaseOffset ) { 4085 the.element.setAttribute('data-kt-sticky-released', 'true'); 4086 } else { 4087 the.element.removeAttribute('data-kt-sticky-released'); 4088 } 4089 } 4090 } 4091 4092 var _enable = function(update) { 4093 var top = _getOption('top'); 4094 var left = _getOption('left'); 4095 var right = _getOption('right'); 4096 var width = _getOption('width'); 4097 var zindex = _getOption('zindex'); 4098 4099 if ( update !== true && _getOption('animation') === true ) { 4100 KTUtil.css(the.element, 'animationDuration', _getOption('animationSpeed')); 4101 KTUtil.animateClass(the.element, 'animation ' + _getOption('animationClass')); 4102 } 4103 4104 if ( zindex !== null ) { 4105 KTUtil.css(the.element, 'z-index', zindex); 4106 KTUtil.css(the.element, 'position', 'fixed'); 4107 } 4108 4109 if ( top !== null ) { 4110 KTUtil.css(the.element, 'top', top); 4111 } 4112 4113 if ( width !== null ) { 4114 if (width['target']) { 4115 var targetElement = document.querySelector(width['target']); 4116 if (targetElement) { 4117 width = KTUtil.css(targetElement, 'width'); 4118 } 4119 } 4120 4121 KTUtil.css(the.element, 'width', width); 4122 } 4123 4124 if ( left !== null ) { 4125 if ( String(left).toLowerCase() === 'auto' ) { 4126 var offsetLeft = KTUtil.offset(the.element).left; 4127 4128 if ( offsetLeft > 0 ) { 4129 KTUtil.css(the.element, 'left', String(offsetLeft) + 'px'); 4130 } 4131 } 4132 } 4133 } 4134 4135 var _disable = function() { 4136 KTUtil.css(the.element, 'top', ''); 4137 KTUtil.css(the.element, 'width', ''); 4138 KTUtil.css(the.element, 'left', ''); 4139 KTUtil.css(the.element, 'right', ''); 4140 KTUtil.css(the.element, 'z-index', ''); 4141 KTUtil.css(the.element, 'position', ''); 4142 } 4143 4144 var _getOption = function(name) { 4145 if ( the.element.hasAttribute('data-kt-sticky-' + name) === true ) { 4146 var attr = the.element.getAttribute('data-kt-sticky-' + name); 4147 var value = KTUtil.getResponsiveValue(attr); 4148 4149 if ( value !== null && String(value) === 'true' ) { 4150 value = true; 4151 } else if ( value !== null && String(value) === 'false' ) { 4152 value = false;
4153 } 4154 4155 return value; 4156 } else { 4157 var optionName = KTUtil.snakeToCamel(name); 4158 4159 if ( the.options[optionName] ) { 4160 return KTUtil.getResponsiveValue(the.options[optionName]); 4161 } else { 4162 return null; 4163 } 4164 } 4165 } 4166 4167 var _destroy = function() { 4168 window.removeEventListener('scroll', _scroll); 4169 KTUtil.data(the.element).remove('sticky'); 4170 } 4171 4172 // Construct Class 4173 _construct(); 4174 4175 /////////////////////// 4176 // ** Public API ** // 4177 /////////////////////// 4178 4179 // Methods 4180 the.update = function() { 4181 if ( body.hasAttribute(the.attributeName) === true ) { 4182 _disable(); 4183 body.removeAttribute(the.attributeName); 4184 _enable(true); 4185 body.setAttribute(the.attributeName, 'on'); 4186 } 4187 } 4188 4189 the.destroy = function() { 4190 return _destroy(); 4191 } 4192 4193 // Event API 4194 the.on = function(name, handler) { 4195 return KTEventHandler.on(the.element, name, handler); 4196 } 4197 4198 the.one = function(name, handler) { 4199 return KTEventHandler.one(the.element, name, handler); 4200 } 4201 4202 the.off = function(name) { 4203 return KTEventHandler.off(the.element, name); 4204 } 4205 4206 the.trigger = function(name, event) { 4207 return KTEventHandler.trigger(the.element, name, event, the, event); 4208 } 4209}; 4210 4211// Static methods 4212KTSticky.getInstance = function(element) { 4213 if ( element !== null && KTUtil.data(element).has('sticky') ) { 4214 return KTUtil.data(element).get('sticky'); 4215 } else { 4216 return null; 4217 } 4218} 4219 4220// Create instances 4221KTSticky.createInstances = function(selector = '[data-kt-sticky="true"]') { 4222 var body = document.getElementsByTagName("BODY")[0]; 4223 4224 // Initialize Menus 4225 var elements = body.querySelectorAll(selector); 4226 var sticky; 4227 4228 if ( elements && elements.length > 0 ) { 4229 for (var i = 0, len = elements.length; i < len; i++) { 4230 sticky = new KTSticky(elements[i]); 4231 } 4232 } 4233} 4234 4235// Window resize handler 4236window.addEventListener('resize', function() { 4237 var timer; 4238 var body = document.getElementsByTagName("BODY")[0]; 4239 4240 KTUtil.throttle(timer, function() { 4241 // Locate and update Offcanvas instances on window resize 4242 var elements = body.querySelectorAll('[data-kt-sticky="true"]'); 4243 4244 if ( elements && elements.length > 0 ) { 4245 for (var i = 0, len = elements.length; i < len; i++) { 4246 var sticky = KTSticky.getInstance(elements[i]); 4247 if (sticky) { 4248 sticky.update(); 4249 } 4250 } 4251 } 4252 }, 200); 4253}); 4254 4255// Global initialization 4256KTSticky.init = function() { 4257 KTSticky.createInstances(); 4258}; 4259 4260// On document ready 4261if (document.readyState === 'loading') { 4262 document.addEventListener('DOMContentLoaded', KTSticky.init); 4263} else { 4264 KTSticky.init(); 4265} 4266 4267// Webpack support 4268if (typeof module !== 'undefined' && typeof module.exports !== 'undefined') { 4269 module.exports = KTSticky; 4270} 4271 4272"use strict"; 4273 4274// Class definition 4275var KTSwapper = function(element, options) { 4276 //////////////////////////// 4277 // ** Private Variables ** // 4278 //////////////////////////// 4279 var the = this; 4280 4281 if ( typeof element === "undefined" || element === null ) { 4282 return; 4283 } 4284 4285 // Default Options 4286 var defaultOptions = { 4287 mode: 'append' 4288 }; 4289 4290 //////////////////////////// 4291 // ** Private Methods ** // 4292 //////////////////////////// 4293 4294 var _construct = function() { 4295 if ( KTUtil.data(element).has('swapper') === true ) { 4296 the = KTUtil.data(element).get('swapper'); 4297 } else { 4298 _init(); 4299 } 4300 } 4301 4302 var _init = function() { 4303 the.element = element; 4304 the.options = KTUtil.deepExtend({}, defaultOptions, options); 4305 4306 // Set initialized 4307 the.element.setAttribute('data-kt-swapper', 'true'); 4308 4309 // Initial update 4310 _update(); 4311 4312 // Bind Instance 4313 KTUtil.data(the.element).set('swapper', the); 4314 } 4315 4316 var _update = function(e) { 4317 var parentSelector = _getOption('parent'); 4318 4319 var mode = _getOption('mode'); 4320 var parentElement = parentSelector ? document.querySelector(parentSelector) : null; 4321 4322 4323 if (parentElement && element.parentNode !== parentElement) { 4324 if (mode === 'prepend') {
4325 parentElement.prepend(element); 4326 } else if (mode === 'append') { 4327 parentElement.append(element); 4328 } 4329 } 4330 } 4331 4332 var _getOption = function(name) { 4333 if ( the.element.hasAttribute('data-kt-swapper-' + name) === true ) { 4334 var attr = the.element.getAttribute('data-kt-swapper-' + name); 4335 var value = KTUtil.getResponsiveValue(attr); 4336 4337 if ( value !== null && String(value) === 'true' ) { 4338 value = true; 4339 } else if ( value !== null && String(value) === 'false' ) { 4340 value = false; 4341 } 4342 4343 return value; 4344 } else { 4345 var optionName = KTUtil.snakeToCamel(name); 4346 4347 if ( the.options[optionName] ) { 4348 return KTUtil.getResponsiveValue(the.options[optionName]); 4349 } else { 4350 return null; 4351 } 4352 } 4353 } 4354 4355 var _destroy = function() { 4356 KTUtil.data(the.element).remove('swapper'); 4357 } 4358 4359 // Construct Class 4360 _construct(); 4361 4362 /////////////////////// 4363 // ** Public API ** // 4364 /////////////////////// 4365 4366 // Methods 4367 the.update = function() { 4368 _update(); 4369 } 4370 4371 the.destroy = function() { 4372 return _destroy(); 4373 } 4374 4375 // Event API 4376 the.on = function(name, handler) { 4377 return KTEventHandler.on(the.element, name, handler); 4378 } 4379 4380 the.one = function(name, handler) { 4381 return KTEventHandler.one(the.element, name, handler); 4382 } 4383 4384 the.off = function(name) { 4385 return KTEventHandler.off(the.element, name); 4386 } 4387 4388 the.trigger = function(name, event) { 4389 return KTEventHandler.trigger(the.element, name, event, the, event); 4390 } 4391}; 4392 4393// Static methods 4394KTSwapper.getInstance = function(element) { 4395 if ( element !== null && KTUtil.data(element).has('swapper') ) { 4396 return KTUtil.data(element).get('swapper'); 4397 } else { 4398 return null; 4399 } 4400} 4401 4402// Create instances 4403KTSwapper.createInstances = function(selector = '[data-kt-swapper="true"]') { 4404 // Initialize Menus 4405 var elements = document.querySelectorAll(selector); 4406 var swapper; 4407 4408 if ( elements && elements.length > 0 ) { 4409 for (var i = 0, len = elements.length; i < len; i++) { 4410 swapper = new KTSwapper(elements[i]); 4411 } 4412 } 4413} 4414 4415// Window resize handler 4416window.addEventListener('resize', function() { 4417 var timer; 4418 4419 KTUtil.throttle(timer, function() { 4420 // Locate and update Offcanvas instances on window resize 4421 var elements = document.querySelectorAll('[data-kt-swapper="true"]'); 4422 4423 if ( elements && elements.length > 0 ) { 4424 for (var i = 0, len = elements.length; i < len; i++) { 4425 var swapper = KTSwapper.getInstance(elements[i]); 4426 if (swapper) { 4427 swapper.update(); 4428 } 4429 } 4430 } 4431 }, 200); 4432}); 4433 4434// Global initialization 4435KTSwapper.init = function() { 4436 KTSwapper.createInstances(); 4437}; 4438 4439// On document ready 4440if (document.readyState === 'loading') { 4441 document.addEventListener('DOMContentLoaded', KTSwapper.init); 4442} else { 4443 KTSwapper.init(); 4444} 4445 4446// Webpack support 4447if (typeof module !== 'undefined' && typeof module.exports !== 'undefined') { 4448 module.exports = KTSwapper; 4449} 4450 4451"use strict"; 4452 4453// Class definition 4454var KTToggle = function(element, options) { 4455 //////////////////////////// 4456 // ** Private variables ** // 4457 //////////////////////////// 4458 var the = this; 4459 var body = document.getElementsByTagName("BODY")[0]; 4460 4461 if (!element) { 4462 return; 4463 } 4464 4465 // Default Options 4466 var defaultOptions = { 4467 saveState: true 4468 }; 4469 4470 //////////////////////////// 4471 // ** Private methods ** // 4472 //////////////////////////// 4473 4474 var _construct = function() { 4475 if ( KTUtil.data(element).has('toggle') === true ) { 4476 the = KTUtil.data(element).get('toggle'); 4477 } else { 4478 _init(); 4479 } 4480 } 4481 4482 var _init = function() { 4483 // Variables 4484 the.options = KTUtil.deepExtend({}, defaultOptions, options); 4485 the.uid = KTUtil.getUniqueId('toggle'); 4486 4487 // Elements 4488 the.element = element; 4489 4490 the.target = document.querySelector(the.element.getAttribute('data-kt-toggle-target')) ? document.querySelector(the.element.getAttribute('data-kt-toggle-target')) : the.element; 4491 the.state = the.element.hasAttribute('data-kt-toggle-state') ? the.element.getAttribute('data-kt-toggle-state') : ''; 4492 the.attribute = 'data-kt-' + the.element.getAttribute('data-kt-toggle-name'); 4493 4494 // Event Handlers 4495 _handlers(); 4496 4497 // Bind Instance 4498 KTUtil.data(the.element).set('toggle', the); 4499 } 4500 4501 var _handlers = function() { 4502 KTUtil.addEvent(the.element, 'click', function(e) { 4503 e.preventDefault(); 4504 4505 _toggle(); 4506 }); 4507 } 4508 4509 // Event handlers 4510 var _toggle = function() { 4511 // Trigger "after.toggle" event 4512 KTEventHandler.trigger(the.element, 'kt.toggle.change', the); 4513 4514 if ( _isEnabled() ) { 4515 _disable(); 4516 } else { 4517 _enable(); 4518 } 4519 4520 // Trigger "before.toggle" event 4521 KTEventHandler.trigger(the.element, 'kt.toggle.changed', the); 4522 4523 return the; 4524 } 4525 4526 var _enable = function() { 4527 if ( _isEnabled() === true ) { 4528 return; 4529 } 4530 4531 KTEventHandler.trigger(the.element, 'kt.toggle.enable', the); 4532 4533 the.target.setAttribute(the.attribute, 'on'); 4534 4535 if (the.state.length > 0) { 4536 the.element.classList.add(the.state); 4537 } 4538 4539 if ( typeof KTCookie !== 'undefined' && the.options.saveState === true ) { 4540 KTCookie.set(the.attribute, 'on'); 4541 } 4542 4543 KTEventHandler.trigger(the.element, 'kt.toggle.enabled', the); 4544 4545 return the; 4546 } 4547 4548 var _disable = function() { 4549 if ( _isEnabled() === false ) { 4550 return; 4551 } 4552 4553 KTEventHandler.trigger(the.element, 'kt.toggle.disable', the); 4554 4555 the.target.removeAttribute(the.attribute); 4556 4557 if (the.state.length > 0) { 4558 the.element.classList.remove(the.state); 4559 } 4560 4561 if ( typeof KTCookie !== 'undefined' && the.options.saveState === true ) { 4562 KTCookie.remove(the.attribute); 4563 } 4564 4565 KTEventHandler.trigger(the.element, 'kt.toggle.disabled', the); 4566 4567 return the; 4568 } 4569 4570 var _isEnabled = function() { 4571 return (String(the.target.getAttribute(the.attribute)).toLowerCase() === 'on'); 4572 } 4573 4574 var _destroy = function() { 4575 KTUtil.data(the.element).remove('toggle'); 4576 } 4577 4578 // Construct class 4579 _construct(); 4580
4581 /////////////////////// 4582 // ** Public API ** // 4583 /////////////////////// 4584 4585 // Plugin API 4586 the.toggle = function() { 4587 return _toggle(); 4588 } 4589 4590 the.enable = function() { 4591 return _enable(); 4592 } 4593 4594 the.disable = function() { 4595 return _disable(); 4596 } 4597 4598 the.isEnabled = function() { 4599 return _isEnabled(); 4600 } 4601 4602 the.goElement = function() { 4603 return the.element; 4604 } 4605 4606 the.destroy = function() { 4607 return _destroy(); 4608 } 4609 4610 // Event API 4611 the.on = function(name, handler) { 4612 return KTEventHandler.on(the.element, name, handler); 4613 } 4614 4615 the.one = function(name, handler) { 4616 return KTEventHandler.one(the.element, name, handler); 4617 } 4618 4619 the.off = function(name) { 4620 return KTEventHandler.off(the.element, name); 4621 } 4622 4623 the.trigger = function(name, event) { 4624 return KTEventHandler.trigger(the.element, name, event, the, event); 4625 } 4626}; 4627 4628// Static methods 4629KTToggle.getInstance = function(element) { 4630 if ( element !== null && KTUtil.data(element).has('toggle') ) { 4631 return KTUtil.data(element).get('toggle'); 4632 } else { 4633 return null; 4634 } 4635} 4636 4637// Create instances 4638KTToggle.createInstances = function(selector = '[data-kt-toggle]') { 4639 var body = document.getElementsByTagName("BODY")[0]; 4640 4641 // Get instances 4642 var elements = body.querySelectorAll(selector); 4643 4644 if ( elements && elements.length > 0 ) { 4645 for (var i = 0, len = elements.length; i < len; i++) { 4646 // Initialize instances 4647 new KTToggle(elements[i]); 4648 } 4649 } 4650} 4651 4652// Global initialization 4653KTToggle.init = function() { 4654 KTToggle.createInstances(); 4655}; 4656 4657// On document ready 4658if (document.readyState === 'loading') { 4659 document.addEventListener('DOMContentLoaded', KTToggle.init); 4660} else { 4661 KTToggle.init(); 4662} 4663 4664// Webpack support 4665if (typeof module !== 'undefined' && typeof module.exports !== 'undefined') { 4666 module.exports = KTToggle; 4667} 4668"use strict"; 4669 4670/** 4671 * @class KTUtil base utilize class that privides helper functions 4672 */ 4673 4674// Polyfills 4675 4676// Element.matches() polyfill 4677if (!Element.prototype.matches) { 4678 Element.prototype.matches = function(s) { 4679 var matches = (this.document || this.ownerDocument).querySelectorAll(s), 4680 i = matches.length; 4681 while (--i >= 0 && matches.item(i) !== this) {} 4682 return i > -1; 4683 }; 4684} 4685 4686/** 4687 * Element.closest() polyfill 4688 * https://developer.mozilla.org/en-US/docs/Web/API/Element/closest#Polyfill 4689 */ 4690if (!Element.prototype.closest) { 4691 Element.prototype.closest = function (s) { 4692 var el = this; 4693 var ancestor = this; 4694 if (!document.documentElement.contains(el)) return null; 4695 do { 4696 if (ancestor.matches(s)) return ancestor; 4697 ancestor = ancestor.parentElement; 4698 } while (ancestor !== null); 4699 return null; 4700 }; 4701} 4702 4703/** 4704 * ChildNode.remove() polyfill 4705 * https://gomakethings.com/removing-an-element-from-the-dom-the-es6-way/ 4706 * @author Chris Ferdinandi 4707 * @license MIT 4708 */ 4709(function (elem) { 4710 for (var i = 0; i < elem.length; i++) { 4711 if (!window[elem[i]] || 'remove' in window[elem[i]].prototype) continue; 4712 window[elem[i]].prototype.remove = function () { 4713 this.parentNode.removeChild(this); 4714 }; 4715 } 4716})(['Element', 'CharacterData', 'DocumentType']); 4717 4718 4719// 4720// requestAnimationFrame polyfill by Erik Möller. 4721// With fixes from Paul Irish and Tino Zijdel 4722// 4723// http://paulirish.com/2011/requestanimationframe-for-smart-animating/ 4724// http://my.opera.com/emoller/blog/2011/12/20/requestanimationframe-for-smart-er-animating 4725// 4726// MIT license 4727// 4728(function() { 4729 var lastTime = 0; 4730 var vendors = ['webkit', 'moz']; 4731 for (var x = 0; x < vendors.length && !window.requestAnimationFrame; ++x) { 4732 window.requestAnimationFrame = window[vendors[x] + 'RequestAnimationFrame']; 4733 window.cancelAnimationFrame = 4734 window[vendors[x] + 'CancelAnimationFrame'] || window[vendors[x] + 'CancelRequestAnimationFrame']; 4735 } 4736 4737 if (!window.requestAnimationFrame) 4738 window.requestAnimationFrame = function(callback) { 4739 var currTime = new Date().getTime(); 4740 var timeToCall = Math.max(0, 16 - (currTime - lastTime)); 4741 var id = window.setTimeout(function() { 4742 callback(currTime + timeToCall); 4743 }, timeToCall); 4744 lastTime = currTime + timeToCall; 4745 return id; 4746 }; 4747 4748 if (!window.cancelAnimationFrame) 4749 window.cancelAnimationFrame = function(id) { 4750 clearTimeout(id); 4751 }; 4752}()); 4753 4754// Source: https://github.com/jserz/js_piece/blob/master/DOM/ParentNode/prepend()/prepend().md 4755(function(arr) { 4756 arr.forEach(function(item) { 4757 if (item.hasOwnProperty('prepend')) { 4758 return; 4759 } 4760 Object.defineProperty(item, 'prepend', { 4761 configurable: true, 4762 enumerable: true, 4763 writable: true, 4764 value: function prepend() { 4765 var argArr = Array.prototype.slice.call(arguments), 4766 docFrag = document.createDocumentFragment(); 4767 4768 argArr.forEach(function(argItem) { 4769 var isNode = argItem instanceof Node; 4770 docFrag.appendChild(isNode ? argItem : document.createTextNode(String(argItem))); 4771 }); 4772 4773 this.insertBefore(docFrag, this.firstChild); 4774 } 4775 }); 4776 }); 4777})([Element.prototype, Document.prototype, DocumentFragment.prototype]); 4778 4779// getAttributeNames 4780if (Element.prototype.getAttributeNames == undefined) { 4781 Element.prototype.getAttributeNames = function () { 4782 var attributes = this.attributes; 4783 var length = attributes.length; 4784 var result = new Array(length); 4785 for (var i = 0; i < length; i++) { 4786 result[i] = attributes[i].name; 4787 } 4788 return result; 4789 }; 4790} 4791 4792// Global variables 4793window.KTUtilElementDataStore = {}; 4794window.KTUtilElementDataStoreID = 0; 4795window.KTUtilDelegatedEventHandlers = {}; 4796 4797var KTUtil = function() { 4798 var resizeHandlers = []; 4799 4800 /** 4801 * Handle window resize event with some 4802 * delay to attach event handlers upon resize complete 4803 */ 4804 var _windowResizeHandler = function() { 4805 var _runResizeHandlers = function() { 4806 // reinitialize other subscribed elements 4807 for (var i = 0; i < resizeHandlers.length; i++) { 4808 var each = resizeHandlers[i]; 4809 each.call(); 4810 } 4811 }; 4812 4813 var timer; 4814 4815 window.addEventListener('resize', function() { 4816 KTUtil.throttle(timer, function() { 4817 _runResizeHandlers(); 4818 }, 200); 4819 }); 4820 }; 4821 4822 return { 4823 /** 4824 * Class main initializer. 4825 * @param {object} settings. 4826 * @returns null 4827 */ 4828 //main function to initiate the theme 4829 init: function(settings) { 4830 _windowResizeHandler(); 4831 }, 4832 4833 /** 4834 * Adds window resize event handler. 4835 * @param {function} callback function. 4836 */ 4837 addResizeHandler: function(callback) { 4838 resizeHandlers.push(callback); 4839 }, 4840 4841 /** 4842 * Removes window resize event handler. 4843 * @param {function} callback function. 4844 */ 4845 removeResizeHandler: function(callback) { 4846 for (var i = 0; i < resizeHandlers.length; i++) { 4847 if (callback === resizeHandlers[i]) { 4848 delete resizeHandlers[i]; 4849 } 4850 } 4851 }, 4852 4853 /** 4854 * Trigger window resize handlers. 4855 */ 4856 runResizeHandlers: function() { 4857 _runResizeHandlers(); 4858 }, 4859 4860 resize: function() { 4861 if (typeof(Event) === 'function') { 4862 // modern browsers 4863 window.dispatchEvent(new Event('resize')); 4864 } else { 4865 // for IE and other old browsers 4866 // causes deprecation warning on modern browsers 4867 var evt = window.document.createEvent('UIEvents'); 4868 evt.initUIEvent('resize', true, false, window, 0); 4869 window.dispatchEvent(evt); 4870 } 4871 }, 4872 4873 /** 4874 * Get GET parameter value from URL. 4875 * @param {string} paramName Parameter name. 4876 * @returns {string} 4877 */ 4878 getURLParam: function(paramName) { 4879 var searchString = window.location.search.substring(1), 4880 i, val, params = searchString.split("&"); 4881 4882 for (i = 0; i < params.length; i++) { 4883 val = params[i].split("="); 4884 if (val[0] == paramName) { 4885 return unescape(val[1]); 4886 } 4887 } 4888 4889 return null; 4890 }, 4891 4892 /** 4893 * Checks whether current device is mobile touch. 4894 * @returns {boolean} 4895 */ 4896 isMobileDevice: function() { 4897 var test = (this.getViewPort().width < this.getBreakp
4897oint('lg') ? true : false); 4898 4899 if (test === false) { 4900 // For use within normal web clients 4901 test = navigator.userAgent.match(/iPad/i) != null; 4902 } 4903 4904 return test; 4905 }, 4906 4907 /** 4908 * Checks whether current device is desktop. 4909 * @returns {boolean} 4910 */ 4911 isDesktopDevice: function() { 4912 return KTUtil.isMobileDevice() ? false : true; 4913 }, 4914 4915 /** 4916 * Gets browser window viewport size. Ref: 4917 * http://andylangton.co.uk/articles/javascript/get-viewport-size-javascript/ 4918 * @returns {object} 4919 */ 4920 getViewPort: function() { 4921 var e = window, 4922 a = 'inner'; 4923 if (!('innerWidth' in window)) { 4924 a = 'client'; 4925 e = document.documentElement || document.body; 4926 } 4927 4928 return { 4929 width: e[a + 'Width'], 4930 height: e[a + 'Height'] 4931 }; 4932 }, 4933 4934 /** 4935 * Checks whether given device mode is currently activated. 4936 * @param {string} mode Responsive mode name(e.g: desktop, 4937 * desktop-and-tablet, tablet, tablet-and-mobile, mobile) 4938 * @returns {boolean} 4939 */ 4940 isBreakpointUp: function(mode) { 4941 var width = this.getViewPort().width; 4942 var breakpoint = this.getBreakpoint(mode); 4943 4944 return (width >= breakpoint); 4945 }, 4946 4947 isBreakpointDown: function(mode) { 4948 var width = this.getViewPort().width; 4949 var breakpoint = this.getBreakpoint(mode); 4950 4951 return (width < breakpoint); 4952 }, 4953 4954 getViewportWidth: function() { 4955 return this.getViewPort().width; 4956 }, 4957 4958 /** 4959 * Generates unique ID for give prefix. 4960 * @param {string} prefix Prefix for generated ID 4961 * @returns {boolean} 4962 */ 4963 getUniqueId: function(prefix) { 4964 return prefix + Math.floor(Math.random() * (new Date()).getTime()); 4965 }, 4966 4967 /** 4968 * Gets window width for give breakpoint mode. 4969 * @param {string} mode Responsive mode name(e.g: xl, lg, md, sm) 4970 * @returns {number} 4971 */ 4972 getBreakpoint: function(breakpoint) { 4973 var value = this.getCssVariableValue('--bs-' + breakpoint); 4974 4975 if ( value ) { 4976 value = parseInt(value.trim()); 4977 } 4978 4979 return value; 4980 }, 4981 4982 /** 4983 * Checks whether object has property matchs given key path. 4984 * @param {object} obj Object contains values paired with given key path 4985 * @param {string} keys Keys path seperated with dots 4986 * @returns {object} 4987 */ 4988 isset: function(obj, keys) { 4989 var stone; 4990 4991 keys = keys || ''; 4992 4993 if (keys.indexOf('[') !== -1) { 4994 throw new Error('Unsupported object path notation.'); 4995 } 4996 4997 keys = keys.split('.'); 4998 4999 do { 5000 if (obj === undefined) { 5001 return false; 5002 } 5003 5004 stone = keys.shift(); 5005 5006 if (!obj.hasOwnProperty(stone)) { 5007 return false; 5008 } 5009 5010 obj = obj[stone]; 5011 5012 } while (keys.length); 5013 5014 return true; 5015 }, 5016 5017 /** 5018 * Gets highest z-index of the given element parents 5019 * @param {object} el jQuery element object 5020 * @returns {number} 5021 */ 5022 getHighestZindex: function(el) { 5023 var position, value; 5024 5025 while (el && el !== document) { 5026 // Ignore z-index if position is set to a value where z-index is ignored by the browser 5027 // This makes behavior of this function consistent across browsers 5028 // WebKit always returns auto if the element is positioned 5029 position = KTUtil.css(el, 'position'); 5030 5031 if (position === "absolute" || position === "relative" || position === "fixed") { 5032 // IE returns 0 when zIndex is not specified 5033 // other browsers return a string 5034 // we ignore the case of nested elements with an explicit value of 0 5035 // <div style="z-index: -10;"><div style="z-index: 0;"></div></div> 5036 value = parseInt(KTUtil.css(el, 'z-index')); 5037 5038 if (!isNaN(value) && value !== 0) { 5039 return value; 5040 } 5041 } 5042 5043 el = el.parentNode; 5044 } 5045 5046 return 1; 5047 }, 5048 5049 /** 5050 * Checks whether the element has any parent with fixed positionfreg 5051 * @param {object} el jQuery element object 5052 * @returns {boolean} 5053 */ 5054 hasFixedPositionedParent: function(el) { 5055 var position; 5056 5057 while (el && el !== document) { 5058 position = KTUtil.css(el, 'position'); 5059 5060 if (position === "fixed") { 5061 return true; 5062 } 5063 5064 el = el.parentNode; 5065 } 5066 5067 return false;
5068 }, 5069 5070 /** 5071 * Simulates delay 5072 */ 5073 sleep: function(milliseconds) { 5074 var start = new Date().getTime(); 5075 for (var i = 0; i < 1e7; i++) { 5076 if ((new Date().getTime() - start) > milliseconds) { 5077 break; 5078 } 5079 } 5080 }, 5081 5082 /** 5083 * Gets randomly generated integer value within given min and max range 5084 * @param {number} min Range start value 5085 * @param {number} max Range end value 5086 * @returns {number} 5087 */ 5088 getRandomInt: function(min, max) { 5089 return Math.floor(Math.random() * (max - min + 1)) + min; 5090 }, 5091 5092 /** 5093 * Checks whether Angular library is included 5094 * @returns {boolean} 5095 */ 5096 isAngularVersion: function() { 5097 return window.Zone !== undefined ? true : false; 5098 }, 5099 5100 // Deep extend: $.extend(true, {}, objA, objB); 5101 deepExtend: function(out) { 5102 out = out || {}; 5103 5104 for (var i = 1; i < arguments.length; i++) { 5105 var obj = arguments[i]; 5106 if (!obj) continue; 5107 5108 for (var key in obj) { 5109 if (!obj.hasOwnProperty(key)) { 5110 continue; 5111 } 5112 5113 // based on https://javascriptweblog.wordpress.com/2011/08/08/fixing-the-javascript-typeof-operator/ 5114 if ( Object.prototype.toString.call(obj[key]) === '[object Object]' ) { 5115 out[key] = KTUtil.deepExtend(out[key], obj[key]); 5116 continue; 5117 } 5118 5119 out[key] = obj[key]; 5120 } 5121 } 5122 5123 return out; 5124 }, 5125 5126 // extend: $.extend({}, objA, objB); 5127 extend: function(out) { 5128 out = out || {}; 5129 5130 for (var i = 1; i < arguments.length; i++) { 5131 if (!arguments[i]) 5132 continue; 5133 5134 for (var key in arguments[i]) { 5135 if (arguments[i].hasOwnProperty(key)) 5136 out[key] = arguments[i][key]; 5137 } 5138 } 5139 5140 return out; 5141 }, 5142 5143 getBody: function() { 5144 return document.getElementsByTagName('body')[0]; 5145 }, 5146 5147 /** 5148 * Checks whether the element has given classes 5149 * @param {object} el jQuery element object 5150 * @param {string} Classes string 5151 * @returns {boolean} 5152 */ 5153 hasClasses: function(el, classes) { 5154 if (!el) { 5155 return; 5156 } 5157 5158 var classesArr = classes.split(" "); 5159 5160 for (var i = 0; i < classesArr.length; i++) { 5161 if (KTUtil.hasClass(el, KTUtil.trim(classesArr[i])) == false) { 5162 return false; 5163 } 5164 } 5165 5166 return true; 5167 }, 5168 5169 hasClass: function(el, className) { 5170 if (!el) { 5171 return; 5172 } 5173 5174 return el.classList ? el.classList.contains(className) : new RegExp('\\b' + className + '\\b').test(el.className); 5175 }, 5176 5177 addClass: function(el, className) { 5178 if (!el || typeof className === 'undefined') { 5179 return; 5180 } 5181 5182 var classNames = className.split(' '); 5183 5184 if (el.classList) { 5185 for (var i = 0; i < classNames.length; i++) { 5186 if (classNames[i] && classNames[i].length > 0) { 5187 el.classList.add(KTUtil.trim(classNames[i])); 5188 } 5189 } 5190 } else if (!KTUtil.hasClass(el, className)) { 5191 for (var x = 0; x < classNames.length; x++) { 5192 el.className += ' ' + KTUtil.trim(classNames[x]); 5193 } 5194 } 5195 }, 5196 5197 removeClass: function(el, className) { 5198 if (!el || typeof className === 'undefined') { 5199 return; 5200 } 5201 5202 var classNames = className.split(' '); 5203 5204 if (el.classList) { 5205 for (var i = 0; i < classNames.length; i++) { 5206 el.classList.remove(KTUtil.trim(classNames[i])); 5207 } 5208 } else if (KTUtil.hasClass(el, className)) { 5209 for (var x = 0; x < classNames.length; x++) { 5210 el.className = el.className.replace(new RegExp('\\b' + KTUtil.trim(classNames[x]) + '\\b', 'g'), ''); 5211 } 5212 } 5213 }, 5214 5215 triggerCustomEvent: function(el, eventName, data) { 5216 var event; 5217 if (window.CustomEvent) { 5218 event = new CustomEvent(eventName, { 5219 detail: data 5220 }); 5221 } else { 5222 event = document.createEvent('CustomEvent'); 5223 event.initCustomEvent(eventName, true, true, data); 5224 } 5225 5226 el.dispatchEvent(event); 5227 }, 5228 5229 triggerEvent: function(node, eventName) { 5230 // Make sure we use the ownerDocument from the provided node to avoid cross-window problems 5231 var doc; 5232 5233 if (node.ownerDocument) { 5234 doc = node.ownerDocument; 5235 } else if (node.nodeType == 9) { 5236 // the node may be the document itself, nodeType 9 = DOCUMENT_NODE 5237 doc = node; 5238 } else { 5239 throw new Error("Invalid node passed to fireEvent: " + node.id); 5240 } 5241
5242 if (node.dispatchEvent) { 5243 // Gecko-style approach (now the standard) takes more work 5244 var eventClass = ""; 5245 5246 // Different events have different event classes. 5247 // If this switch statement can't map an eventName to an eventClass, 5248 // the event firing is going to fail. 5249 switch (eventName) { 5250 case "click": // Dispatching of 'click' appears to not work correctly in Safari. Use 'mousedown' or 'mouseup' instead. 5251 case "mouseenter": 5252 case "mouseleave": 5253 case "mousedown": 5254 case "mouseup": 5255 eventClass = "MouseEvents"; 5256 break; 5257 5258 case "focus": 5259 case "change": 5260 case "blur": 5261 case "select": 5262 eventClass = "HTMLEvents"; 5263 break; 5264 5265 default: 5266 throw "fireEvent: Couldn't find an event class for event '" + eventName + "'."; 5267 break; 5268 } 5269 var event = doc.createEvent(eventClass); 5270 5271 var bubbles = eventName == "change" ? false : true; 5272 event.initEvent(eventName, bubbles, true); // All events created as bubbling and cancelable. 5273 5274 event.synthetic = true; // allow detection of synthetic events 5275 // The second parameter says go ahead with the default action 5276 node.dispatchEvent(event, true); 5277 } else if (node.fireEvent) { 5278 // IE-old school style 5279 var event = doc.createEventObject(); 5280 event.synthetic = true; // allow detection of synthetic events 5281 node.fireEvent("on" + eventName, event); 5282 } 5283 }, 5284 5285 index: function( el ){ 5286 var c = el.parentNode.children, i = 0; 5287 for(; i < c.length; i++ ) 5288 if( c[i] == el ) return i; 5289 }, 5290 5291 trim: function(string) { 5292 return string.trim(); 5293 }, 5294 5295 eventTriggered: function(e) { 5296 if (e.currentTarget.dataset.triggered) { 5297 return true; 5298 } else { 5299 e.currentTarget.dataset.triggered = true; 5300 5301 return false; 5302 } 5303 }, 5304 5305 remove: function(el) { 5306 if (el && el.parentNode) { 5307 el.parentNode.removeChild(el); 5308 } 5309 }, 5310 5311 find: function(parent, query) { 5312 if ( parent !== null) { 5313 return parent.querySelector(query); 5314 } else { 5315 return null; 5316 } 5317 }, 5318 5319 findAll: function(parent, query) { 5320 if ( parent !== null ) { 5321 return parent.querySelectorAll(query); 5322 } else { 5323 return null; 5324 } 5325 }, 5326 5327 insertAfter: function(el, referenceNode) { 5328 return referenceNode.parentNode.insertBefore(el, referenceNode.nextSibling); 5329 }, 5330 5331 parents: function(elem, selector) { 5332 // Set up a parent array 5333 var parents = []; 5334 5335 // Push each parent element to the array 5336 for ( ; elem && elem !== document; elem = elem.parentNode ) { 5337 if (selector) { 5338 if (elem.matches(selector)) { 5339 parents.push(elem); 5340 } 5341 continue; 5342 } 5343 parents.push(elem); 5344 } 5345 5346 // Return our parent array 5347 return parents; 5348 }, 5349 5350 children: function(el, selector, log) { 5351 if (!el || !el.childNodes) { 5352 return null; 5353 } 5354 5355 var result = [], 5356 i = 0, 5357 l = el.childNodes.length; 5358 5359 for (var i; i < l; ++i) { 5360 if (el.childNodes[i].nodeType == 1 && KTUtil.matches(el.childNodes[i], selector, log)) { 5361 result.push(el.childNodes[i]); 5362 } 5363 } 5364 5365 return result; 5366 }, 5367 5368 child: function(el, selector, log) { 5369 var children = KTUtil.children(el, selector, log); 5370 5371 return children ? children[0] : null; 5372 }, 5373 5374 matches: function(el, selector, log) { 5375 var p = Element.prototype; 5376 var f = p.matches || p.webkitMatchesSelector || p.mozMatchesSelector || p.msMatchesSelector || function(s) { 5377 return [].indexOf.call(document.querySelectorAll(s), this) !== -1; 5378 }; 5379 5380 if (el && el.tagName) { 5381 return f.call(el, selector); 5382 } else { 5383 return false;
5384 } 5385 }, 5386 5387 data: function(el) { 5388 return { 5389 set: function(name, data) { 5390 if (!el) { 5391 return; 5392 } 5393 5394 if (el.customDataTag === undefined) { 5395 window.KTUtilElementDataStoreID++; 5396 el.customDataTag = window.KTUtilElementDataStoreID; 5397 } 5398 5399 if (window.KTUtilElementDataStore[el.customDataTag] === undefined) { 5400 window.KTUtilElementDataStore[el.customDataTag] = {}; 5401 } 5402 5403 window.KTUtilElementDataStore[el.customDataTag][name] = data; 5404 }, 5405 5406 get: function(name) { 5407 if (!el) { 5408 return; 5409 } 5410 5411 if (el.customDataTag === undefined) { 5412 return null; 5413 } 5414 5415 return this.has(name) ? window.KTUtilElementDataStore[el.customDataTag][name] : null; 5416 }, 5417 5418 has: function(name) { 5419 if (!el) { 5420 return false; 5421 } 5422 5423 if (el.customDataTag === undefined) { 5424 return false; 5425 } 5426 5427 return (window.KTUtilElementDataStore[el.customDataTag] && window.KTUtilElementDataStore[el.customDataTag][name]) ? true : false; 5428 }, 5429 5430 remove: function(name) { 5431 if (el && this.has(name)) { 5432 delete window.KTUtilElementDataStore[el.customDataTag][name]; 5433 } 5434 } 5435 }; 5436 }, 5437 5438 outerWidth: function(el, margin) { 5439 var width; 5440 5441 if (margin === true) { 5442 width = parseFloat(el.offsetWidth); 5443 width += parseFloat(KTUtil.css(el, 'margin-left')) + parseFloat(KTUtil.css(el, 'margin-right')); 5444 5445 return parseFloat(width); 5446 } else { 5447 width = parseFloat(el.offsetWidth); 5448 5449 return width; 5450 } 5451 }, 5452 5453 offset: function(el) { 5454 var rect, win; 5455 5456 if ( !el ) { 5457 return; 5458 } 5459 5460 // Return zeros for disconnected and hidden (display: none) elements (gh-2310) 5461 // Support: IE <=11 only 5462 // Running getBoundingClientRect on a 5463 // disconnected node in IE throws an error 5464 5465 if ( !el.getClientRects().length ) { 5466 return { top: 0, left: 0 }; 5467 } 5468 5469 // Get document-relative position by adding viewport scroll to viewport-relative gBCR 5470 rect = el.getBoundingClientRect(); 5471 win = el.ownerDocument.defaultView; 5472 5473 return { 5474 top: rect.top + win.pageYOffset, 5475 left: rect.left + win.pageXOffset, 5476 right: window.innerWidth - (el.offsetLeft + el.offsetWidth) 5477 }; 5478 }, 5479 5480 height: function(el) { 5481 return KTUtil.css(el, 'height'); 5482 }, 5483 5484 outerHeight: function(el, withMargin) { 5485 var height = el.offsetHeight; 5486 var style; 5487 5488 if (typeof withMargin !== 'undefined' && withMargin === true) { 5489 style = getComputedStyle(el); 5490 height += parseInt(style.marginTop) + parseInt(style.marginBottom); 5491 5492 return height; 5493 } else { 5494 return height; 5495 } 5496 }, 5497 5498 visible: function(el) { 5499 return !(el.offsetWidth === 0 && el.offsetHeight === 0); 5500 }, 5501 5502 attr: function(el, name, value) { 5503 if (el == undefined) { 5504 return; 5505 } 5506 5507 if (value !== undefined) { 5508 el.setAttribute(name, value); 5509 } else { 5510 return el.getAttribute(name); 5511 } 5512 }, 5513 5514 hasAttr: function(el, name) { 5515 if (el == undefined) { 5516 return; 5517 } 5518 5519 return el.getAttribute(name) ? true : false;
5520 }, 5521 5522 removeAttr: function(el, name) { 5523 if (el == undefined) { 5524 return; 5525 } 5526 5527 el.removeAttribute(name); 5528 }, 5529 5530 animate: function(from, to, duration, update, easing, done) { 5531 /** 5532 * TinyAnimate.easings 5533 * Adapted from jQuery Easing 5534 */ 5535 var easings = {}; 5536 var easing; 5537 5538 easings.linear = function(t, b, c, d) { 5539 return c * t / d + b; 5540 }; 5541 5542 easing = easings.linear; 5543 5544 // Early bail out if called incorrectly 5545 if (typeof from !== 'number' || 5546 typeof to !== 'number' || 5547 typeof duration !== 'number' || 5548 typeof update !== 'function') { 5549 return; 5550 } 5551 5552 // Create mock done() function if necessary 5553 if (typeof done !== 'function') { 5554 done = function() {}; 5555 } 5556 5557 // Pick implementation (requestAnimationFrame | setTimeout) 5558 var rAF = window.requestAnimationFrame || function(callback) { 5559 window.setTimeout(callback, 1000 / 50); 5560 }; 5561 5562 // Animation loop 5563 var canceled = false; 5564 var change = to - from; 5565 5566 function loop(timestamp) { 5567 var time = (timestamp || +new Date()) - start; 5568 5569 if (time >= 0) { 5570 update(easing(time, from, change, duration)); 5571 } 5572 if (time >= 0 && time >= duration) { 5573 update(to); 5574 done(); 5575 } else { 5576 rAF(loop); 5577 } 5578 } 5579 5580 update(from); 5581 5582 // Start animation loop 5583 var start = window.performance && window.performance.now ? window.performance.now() : +new Date(); 5584 5585 rAF(loop); 5586 }, 5587 5588 actualCss: function(el, prop, cache) { 5589 var css = ''; 5590 5591 if (el instanceof HTMLElement === false) { 5592 return; 5593 } 5594 5595 if (!el.getAttribute('kt-hidden-' + prop) || cache === false) { 5596 var value; 5597 5598 // the element is hidden so: 5599 // making the el block so we can meassure its height but still be hidden 5600 css = el.style.cssText; 5601 el.style.cssText = 'position: absolute; visibility: hidden; display: block;'; 5602 5603 if (prop == 'width') { 5604 value = el.offsetWidth; 5605 } else if (prop == 'height') { 5606 value = el.offsetHeight; 5607 } 5608 5609 el.style.cssText = css; 5610 5611 // store it in cache 5612 el.setAttribute('kt-hidden-' + prop, value); 5613 5614 return parseFloat(value); 5615 } else { 5616 // store it in cache 5617 return parseFloat(el.getAttribute('kt-hidden-' + prop)); 5618 } 5619 }, 5620 5621 actualHeight: function(el, cache) { 5622 return KTUtil.actualCss(el, 'height', cache); 5623 }, 5624 5625 actualWidth: function(el, cache) { 5626 return KTUtil.actualCss(el, 'width', cache); 5627 }, 5628 5629 getScroll: function(element, method) { 5630 // The passed in `method` value should be 'Top' or 'Left' 5631 method = 'scroll' + method; 5632 return (element == window || element == document) ? ( 5633 self[(method == 'scrollTop') ? 'pageYOffset' : 'pageXOffset'] || 5634 (browserSupportsBoxModel && document.documentElement[method]) || 5635 document.body[method] 5636 ) : element[method]; 5637 }, 5638 5639 css: function(el, styleProp, value, important) { 5640 if (!el) { 5641 return; 5642 } 5643 5644 if (value !== undefined) { 5645 if ( important === true ) { 5646 el.style.setProperty(styleProp, value, 'important'); 5647 } else { 5648 el.style[styleProp] = value; 5649 } 5650 } else { 5651 var defaultView = (el.ownerDocument || document).defaultView; 5652 5653 // W3C standard way: 5654 if (defaultView && defaultView.getComputedStyle) { 5655 // sanitize property name to css notation 5656 // (hyphen separated words eg. font-Size) 5657 styleProp = styleProp.replace(/([A-Z])/g, "-$1").toLowerCase(); 5658 5659 return defaultView.getComputedStyle(el, null).getPropertyValue(styleProp); 5660 } else if (el.currentStyle) { // IE 5661 // sanitize property name to camelCase 5662 styleProp = styleProp.replace(/\-(\w)/g, function(str, letter) { 5663 return letter.toUpperCase(); 5664 }); 5665 5666 value = el.currentStyle[styleProp]; 5667 5668 // convert other units to pixels on IE 5669 if (/^\d+(em|pt|%|ex)?$/i.test(value)) { 5670 return (function(value) { 5671 var oldLeft = el.style.left, oldRsLeft = el.runtimeStyle.left; 5672 5673 el.runtimeStyle.left = el.currentStyle.left; 5674 el.style.left = value || 0; 5675 value = el.style.pixelLeft + "px"; 5676 el.style.left = oldLeft; 5677 el.runtimeStyle.left = oldRsLeft; 5678 5679 return value; 5680 })(value); 5681 } 5682 5683 return value; 5684 } 5685 } 5686 }, 5687 5688 slide: function(el, dir, speed, callback, recalcMaxHeight) { 5689 if (!el || (dir == 'up' && KTUtil.visible(el) === false) || (dir == 'down' && KTUtil.visible(el) === true)) { 5690 return; 5691 } 5692 5693 speed = (speed ? speed : 600); 5694 var calcHeight = KTUtil.actualHeight(el); 5695 var calcPaddingTop = false;
5696 var calcPaddingBottom = false; 5697 5698 if (KTUtil.css(el, 'padding-top') && KTUtil.data(el).has('slide-padding-top') !== true) { 5699 KTUtil.data(el).set('slide-padding-top', KTUtil.css(el, 'padding-top')); 5700 } 5701 5702 if (KTUtil.css(el, 'padding-bottom') && KTUtil.data(el).has('slide-padding-bottom') !== true) { 5703 KTUtil.data(el).set('slide-padding-bottom', KTUtil.css(el, 'padding-bottom')); 5704 } 5705 5706 if (KTUtil.data(el).has('slide-padding-top')) { 5707 calcPaddingTop = parseInt(KTUtil.data(el).get('slide-padding-top')); 5708 } 5709 5710 if (KTUtil.data(el).has('slide-padding-bottom')) { 5711 calcPaddingBottom = parseInt(KTUtil.data(el).get('slide-padding-bottom')); 5712 } 5713 5714 if (dir == 'up') { // up 5715 el.style.cssText = 'display: block; overflow: hidden;'; 5716 5717 if (calcPaddingTop) { 5718 KTUtil.animate(0, calcPaddingTop, speed, function(value) { 5719 el.style.paddingTop = (calcPaddingTop - value) + 'px'; 5720 }, 'linear'); 5721 } 5722 5723 if (calcPaddingBottom) { 5724 KTUtil.animate(0, calcPaddingBottom, speed, function(value) { 5725 el.style.paddingBottom = (calcPaddingBottom - value) + 'px'; 5726 }, 'linear'); 5727 } 5728 5729 KTUtil.animate(0, calcHeight, speed, function(value) { 5730 el.style.height = (calcHeight - value) + 'px'; 5731 }, 'linear', function() { 5732 el.style.height = ''; 5733 el.style.display = 'none'; 5734 5735 if (typeof callback === 'function') { 5736 callback(); 5737 } 5738 }); 5739 5740 5741 } else if (dir == 'down') { // down 5742 el.style.cssText = 'display: block; overflow: hidden;'; 5743 5744 if (calcPaddingTop) { 5745 KTUtil.animate(0, calcPaddingTop, speed, function(value) {// 5746 el.style.paddingTop = value + 'px'; 5747 }, 'linear', function() { 5748 el.style.paddingTop = ''; 5749 }); 5750 } 5751 5752 if (calcPaddingBottom) { 5753 KTUtil.animate(0, calcPaddingBottom, speed, function(value) { 5754 el.style.paddingBottom = value + 'px'; 5755 }, 'linear', function() { 5756 el.style.paddingBottom = ''; 5757 }); 5758 } 5759 5760 KTUtil.animate(0, calcHeight, speed, function(value) { 5761 el.style.height = value + 'px'; 5762 }, 'linear', function() { 5763 el.style.height = ''; 5764 el.style.display = ''; 5765 el.style.overflow = ''; 5766 5767 if (typeof callback === 'function') { 5768 callback(); 5769 } 5770 }); 5771 } 5772 }, 5773 5774 slideUp: function(el, speed, callback) { 5775 KTUtil.slide(el, 'up', speed, callback); 5776 }, 5777 5778 slideDown: function(el, speed, callback) { 5779 KTUtil.slide(el, 'down', speed, callback); 5780 }, 5781 5782 show: function(el, display) { 5783 if (typeof el !== 'undefined') { 5784 el.style.display = (display ? display : 'block'); 5785 } 5786 }, 5787 5788 hide: function(el) { 5789 if (typeof el !== 'undefined') { 5790 el.style.display = 'none'; 5791 } 5792 }, 5793 5794 addEvent: function(el, type, handler, one) { 5795 if (typeof el !== 'undefined' && el !== null) { 5796 el.addEventListener(type, handler); 5797 } 5798 }, 5799 5800 removeEvent: function(el, type, handler) { 5801 if (el !== null) { 5802 el.removeEventListener(type, handler); 5803 } 5804 }, 5805 5806 on: function(element, selector, event, handler) { 5807 if ( element === null ) { 5808 return; 5809 } 5810 5811 var eventId = KTUtil.getUniqueId('event'); 5812 5813 window.KTUtilDelegatedEventHandlers[eventId] = function(e) { 5814 var targets = element.querySelectorAll(selector); 5815 var target = e.target; 5816 5817 while ( target && target !== element ) { 5818 for ( var i = 0, j = targets.length; i < j; i++ ) { 5819 if ( target === targets[i] ) { 5820 handler.call(target, e); 5821 } 5822 } 5823 5824 target = target.parentNode; 5825 } 5826 } 5827 5828 KTUtil.addEvent(element, event, window.KTUtilDelegatedEventHandlers[eventId]); 5829 5830 return eventId; 5831 }, 5832 5833 off: function(element, event, eventId) { 5834 if (!element || !window.KTUtilDelegatedEventHandlers[eventId]) { 5835 return; 5836 } 5837 5838 KTUtil.removeEvent(element, event, window.KTUtilDelegatedEventHandlers[eventId]); 5839 5840 delete window.KTUtilDelegatedEventHandlers[eventId]; 5841 }, 5842 5843 one: function onetime(el, type, callback) { 5844 el.addEventListener(type, function callee(e) { 5845 // remove event 5846 if (e.target && e.target.removeEventListener) { 5847 e.target.removeEventListener(e.type, callee); 5848 } 5849
5850 // need to verify from https://themeforest.net/author_dashboard#comment_23615588 5851 if (el && el.removeEventListener) { 5852 e.currentTarget.removeEventListener(e.type, callee); 5853 } 5854 5855 // call handler 5856 return callback(e); 5857 }); 5858 }, 5859 5860 hash: function(str) { 5861 var hash = 0, 5862 i, chr; 5863 5864 if (str.length === 0) return hash; 5865 for (i = 0; i < str.length; i++) { 5866 chr = str.charCodeAt(i); 5867 hash = ((hash << 5) - hash) + chr; 5868 hash |= 0; // Convert to 32bit integer 5869 } 5870 5871 return hash; 5872 }, 5873 5874 animateClass: function(el, animationName, callback) { 5875 var animation; 5876 var animations = { 5877 animation: 'animationend', 5878 OAnimation: 'oAnimationEnd', 5879 MozAnimation: 'mozAnimationEnd', 5880 WebkitAnimation: 'webkitAnimationEnd', 5881 msAnimation: 'msAnimationEnd', 5882 }; 5883 5884 for (var t in animations) { 5885 if (el.style[t] !== undefined) { 5886 animation = animations[t]; 5887 } 5888 } 5889 5890 KTUtil.addClass(el, animationName); 5891 5892 KTUtil.one(el, animation, function() { 5893 KTUtil.removeClass(el, animationName); 5894 }); 5895 5896 if (callback) { 5897 KTUtil.one(el, animation, callback); 5898 } 5899 }, 5900 5901 transitionEnd: function(el, callback) { 5902 var transition; 5903 var transitions = { 5904 transition: 'transitionend', 5905 OTransition: 'oTransitionEnd', 5906 MozTransition: 'mozTransitionEnd', 5907 WebkitTransition: 'webkitTransitionEnd', 5908 msTransition: 'msTransitionEnd' 5909 }; 5910 5911 for (var t in transitions) { 5912 if (el.style[t] !== undefined) { 5913 transition = transitions[t]; 5914 } 5915 } 5916 5917 KTUtil.one(el, transition, callback); 5918 }, 5919 5920 animationEnd: function(el, callback) { 5921 var animation; 5922 var animations = { 5923 animation: 'animationend', 5924 OAnimation: 'oAnimationEnd', 5925 MozAnimation: 'mozAnimationEnd', 5926 WebkitAnimation: 'webkitAnimationEnd', 5927 msAnimation: 'msAnimationEnd' 5928 }; 5929 5930 for (var t in animations) { 5931 if (el.style[t] !== undefined) { 5932 animation = animations[t]; 5933 } 5934 } 5935 5936 KTUtil.one(el, animation, callback); 5937 }, 5938 5939 animateDelay: function(el, value) { 5940 var vendors = ['webkit-', 'moz-', 'ms-', 'o-', '']; 5941 for (var i = 0; i < vendors.length; i++) { 5942 KTUtil.css(el, vendors[i] + 'animation-delay', value); 5943 } 5944 }, 5945 5946 animateDuration: function(el, value) { 5947 var vendors = ['webkit-', 'moz-', 'ms-', 'o-', '']; 5948 for (var i = 0; i < vendors.length; i++) { 5949 KTUtil.css(el, vendors[i] + 'animation-duration', value); 5950 } 5951 }, 5952 5953 scrollTo: function(target, offset, duration) { 5954 var duration = duration ? duration : 500; 5955 var targetPos = target ? KTUtil.offset(target).top : 0; 5956 var scrollPos = window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop || 0; 5957 var from, to; 5958 5959 if (offset) { 5960 targetPos = targetPos - offset; 5961 } 5962 5963 from = scrollPos; 5964 to = targetPos; 5965 5966 KTUtil.animate(from, to, duration, function(value) { 5967 document.documentElement.scrollTop = value; 5968 document.body.parentNode.scrollTop = value; 5969 document.body.scrollTop = value; 5970 }); //, easing, done 5971 }, 5972 5973 scrollTop: function(offset, duration) { 5974 KTUtil.scrollTo(null, offset, duration); 5975 }, 5976 5977 isArray: function(obj) { 5978 return obj && Array.isArray(obj); 5979 }, 5980 5981 isEmpty: function(obj) { 5982 for (var prop in obj) { 5983 if (obj.hasOwnProperty(prop)) { 5984 return false;
5985 } 5986 } 5987 5988 return true; 5989 }, 5990 5991 numberString: function(nStr) { 5992 nStr += ''; 5993 var x = nStr.split('.'); 5994 var x1 = x[0]; 5995 var x2 = x.length > 1 ? '.' + x[1] : ''; 5996 var rgx = /(\d+)(\d{3})/; 5997 while (rgx.test(x1)) { 5998 x1 = x1.replace(rgx, '$1' + ',' + '$2'); 5999 } 6000 return x1 + x2; 6001 }, 6002 6003 isRTL: function() { 6004 return (document.querySelector('html').getAttribute("direction") === 'rtl'); 6005 }, 6006 6007 snakeToCamel: function(s){ 6008 return s.replace(/(\-\w)/g, function(m){return m[1].toUpperCase();}); 6009 }, 6010 6011 filterBoolean: function(val) { 6012 // Convert string boolean 6013 if (val === true || val === 'true') { 6014 return true; 6015 } 6016 6017 if (val === false || val === 'false') { 6018 return false; 6019 } 6020 6021 return val; 6022 }, 6023 6024 setHTML: function(el, html) { 6025 el.innerHTML = html; 6026 }, 6027 6028 getHTML: function(el) { 6029 if (el) { 6030 return el.innerHTML; 6031 } 6032 }, 6033 6034 getDocumentHeight: function() { 6035 var body = document.body; 6036 var html = document.documentElement; 6037 6038 return Math.max( body.scrollHeight, body.offsetHeight, html.clientHeight, html.scrollHeight, html.offsetHeight ); 6039 }, 6040 6041 getScrollTop: function() { 6042 return (document.scrollingElement || document.documentElement).scrollTop; 6043 }, 6044 6045 colorLighten: function(color, amount) { 6046 const addLight = function(color, amount){ 6047 let cc = parseInt(color,16) + amount; 6048 let c = (cc > 255) ? 255 : (cc); 6049 c = (c.toString(16).length > 1 ) ? c.toString(16) : `0${c.toString(16)}`; 6050 return c; 6051 } 6052 6053 color = (color.indexOf("#")>=0) ? color.substring(1,color.length) : color; 6054 amount = parseInt((255*amount)/100); 6055 6056 return color = `#${addLight(color.substring(0,2), amount)}${addLight(color.substring(2,4), amount)}${addLight(color.substring(4,6), amount)}`; 6057 }, 6058 6059 colorDarken: function(color, amount) { 6060 const subtractLight = function(color, amount){ 6061 let cc = parseInt(color,16) - amount; 6062 let c = (cc < 0) ? 0 : (cc); 6063 c = (c.toString(16).length > 1 ) ? c.toString(16) : `0${c.toString(16)}`; 6064 6065 return c; 6066 } 6067 6068 color = (color.indexOf("#")>=0) ? color.substring(1,color.length) : color; 6069 amount = parseInt((255*amount)/100); 6070 6071 return color = `#${subtractLight(color.substring(0,2), amount)}${subtractLight(color.substring(2,4), amount)}${subtractLight(color.substring(4,6), amount)}`; 6072 }, 6073 6074 // Throttle function: Input as function which needs to be throttled and delay is the time interval in milliseconds 6075 throttle: function (timer, func, delay) { 6076 // If setTimeout is already scheduled, no need to do anything 6077 if (timer) { 6078 return; 6079 } 6080 6081 // Schedule a setTimeout after delay seconds 6082 timer = setTimeout(function () { 6083 func(); 6084 6085 // Once setTimeout function execution is finished, timerId = undefined so that in <br> 6086 // the next scroll event function execution can be scheduled by the setTimeout 6087 timer = undefined; 6088 }, delay); 6089 }, 6090 6091 // Debounce function: Input as function which needs to be debounced and delay is the debounced time in milliseconds 6092 debounce: function (timer, func, delay) { 6093 // Cancels the setTimeout method execution 6094 clearTimeout(timer) 6095 6096 // Executes the func after delay time. 6097 timer = setTimeout(func, delay); 6098 }, 6099 6100 parseJson: function(value) { 6101 if (typeof value === 'string') { 6102 value = value.replace(/'/g, "\""); 6103 6104 var jsonStr = value.replace(/(\w+:)|(\w+ :)/g, function(matched) { 6105 return '"' + matched.substring(0, matched.length - 1) + '":'; 6106 }); 6107 6108 try { 6109 value = JSON.parse(jsonStr); 6110 } catch(e) { } 6111 } 6112 6113 return value; 6114 }, 6115 6116 getResponsiveValue: function(value, defaultValue) { 6117 var width = this.getViewPort().width; 6118 var result; 6119 6120 value = KTUtil.parseJson(value); 6121 6122 if (typeof value === 'object') { 6123 var resultKey;
6124 var resultBreakpoint = -1; 6125 var breakpoint; 6126 6127 for (var key in value) { 6128 if (key === 'default') { 6129 breakpoint = 0; 6130 } else { 6131 breakpoint = this.getBreakpoint(key) ? this.getBreakpoint(key) : parseInt(key); 6132 } 6133 6134 if (breakpoint <= width && breakpoint > resultBreakpoint) { 6135 resultKey = key; 6136 resultBreakpoint = breakpoint; 6137 } 6138 } 6139 6140 if (resultKey) { 6141 result = value[resultKey]; 6142 } else { 6143 result = value; 6144 } 6145 } else { 6146 result = value; 6147 } 6148 6149 return result; 6150 }, 6151 6152 each: function(array, callback) { 6153 return [].slice.call(array).map(callback); 6154 }, 6155 6156 getSelectorMatchValue: function(value) { 6157 var result = null; 6158 value = KTUtil.parseJson(value); 6159 6160 if ( typeof value === 'object' ) { 6161 // Match condition 6162 if ( value['match'] !== undefined ) { 6163 var selector = Object.keys(value['match'])[0]; 6164 value = Object.values(value['match'])[0]; 6165 6166 if ( document.querySelector(selector) !== null ) { 6167 result = value; 6168 } 6169 } 6170 } else { 6171 result = value; 6172 } 6173 6174 return result; 6175 }, 6176 6177 getConditionalValue: function(value) { 6178 var value = KTUtil.parseJson(value); 6179 var result = KTUtil.getResponsiveValue(value); 6180 6181 if ( result !== null && result['match'] !== undefined ) { 6182 result = KTUtil.getSelectorMatchValue(result); 6183 } 6184 6185 if ( result === null && value !== null && value['default'] !== undefined ) { 6186 result = value['default']; 6187 } 6188 6189 return result; 6190 }, 6191 6192 getCssVariableValue: function(variableName) { 6193 var hex = getComputedStyle(document.documentElement).getPropertyValue(variableName); 6194 if ( hex && hex.length > 0 ) { 6195 hex = hex.trim(); 6196 } 6197 6198 return hex; 6199 }, 6200 6201 isInViewport: function(element) { 6202 var rect = element.getBoundingClientRect(); 6203 6204 return ( 6205 rect.top >= 0 && 6206 rect.left >= 0 && 6207 rect.bottom <= (window.innerHeight || document.documentElement.clientHeight) && 6208 rect.right <= (window.innerWidth || document.documentElement.clientWidth) 6209 ); 6210 }, 6211 6212 onDOMContentLoaded: function(callback) { 6213 if (document.readyState === 'loading') { 6214 document.addEventListener('DOMContentLoaded', callback); 6215 } else { 6216 callback(); 6217 } 6218 }, 6219 6220 inIframe: function() { 6221 try { 6222 return window.self !== window.top; 6223 } catch (e) { 6224 return true; 6225 } 6226 }, 6227 6228 isHexColor(code) { 6229 return /^#[0-9A-F]{6}$/i.test(code); 6230 } 6231 } 6232}(); 6233 6234// Webpack support 6235if (typeof module !== 'undefined' && typeof module.exports !== 'undefined') { 6236 module.exports = KTUtil; 6237} 6238"use strict"; 6239 6240// Class definition 6241var KTApp = function () { 6242 var select2FocusFixInitialized = false; 6243 6244 var initPageLoader = function () { 6245 // CSS3 Transitions only after page load(.page-loading class added to body tag and remove with JS on page load) 6246 KTUtil.removeClass(document.body, 'page-loading'); 6247 } 6248 6249 var initBootstrapTooltip = function (el, options) { 6250 var delay = {}; 6251 6252 // Handle delay options 6253 if (el.hasAttribute('data-bs-delay-hide')) { 6254 delay['hide'] = el.getAttribute('data-bs-delay-hide'); 6255 } 6256 6257 if (el.hasAttribute('data-bs-delay-show')) { 6258 delay['show'] = el.getAttribute('data-bs-delay-show'); 6259 } 6260 6261 if (delay) { 6262 options['delay'] = delay; 6263 } 6264 6265 // Check dismiss options 6266 if (el.hasAttribute('data-bs-dismiss') && el.getAttribute('data-bs-dismiss') == 'click') { 6267 options['dismiss'] = 'click'; 6268 } 6269 6270 // Initialize popover 6271 var tp = new bootstrap.Tooltip(el, options); 6272 6273 // Handle dismiss 6274 if (options['dismiss'] && options['dismiss'] === 'click') { 6275 // Hide popover on element click 6276 el.addEventListener("click", function (e) { 6277 tp.hide(); 6278 }); 6279 } 6280 6281 return tp; 6282 } 6283 6284 var initBootstrapTooltips = function (el, options) { 6285 var tooltipTriggerList = [].slice.call(document.querySelectorAll('[data-bs-toggle="tooltip"]')); 6286 6287 var tooltipList = tooltipTriggerList.map(function (tooltipTriggerEl) { 6288 initBootstrapTooltip(tooltipTriggerEl, {}); 6289 }); 6290 } 6291 6292 var initBootstrapPopover = function (el, options) {
6293 var delay = {}; 6294 6295 // Handle delay options 6296 if (el.hasAttribute('data-bs-delay-hide')) { 6297 delay['hide'] = el.getAttribute('data-bs-delay-hide'); 6298 } 6299 6300 if (el.hasAttribute('data-bs-delay-show')) { 6301 delay['show'] = el.getAttribute('data-bs-delay-show'); 6302 } 6303 6304 if (delay) { 6305 options['delay'] = delay; 6306 } 6307 6308 // Handle dismiss option 6309 if (el.getAttribute('data-bs-dismiss') == 'true') { 6310 options['dismiss'] = true; 6311 } 6312 6313 if (options['dismiss'] === true) { 6314 options['template'] = '<div class="popover" role="tooltip"><div class="popover-arrow"></div><span class="popover-dismiss btn btn-icon"><i class="bi bi-x fs-2"></i></span><h3 class="popover-header"></h3><div class="popover-body"></div></div>' 6315 } 6316 6317 // Initialize popover 6318 var popover = new bootstrap.Popover(el, options); 6319 6320 // Handle dismiss click 6321 if (options['dismiss'] === true) { 6322 var dismissHandler = function (e) { 6323 popover.hide(); 6324 } 6325 6326 el.addEventListener('shown.bs.popover', function () { 6327 var dismissEl = document.getElementById(el.getAttribute('aria-describedby')); 6328 dismissEl.addEventListener('click', dismissHandler); 6329 }); 6330 6331 el.addEventListener('hide.bs.popover', function () { 6332 var dismissEl = document.getElementById(el.getAttribute('aria-describedby')); 6333 dismissEl.removeEventListener('click', dismissHandler); 6334 }); 6335 } 6336 6337 return popover; 6338 } 6339 6340 var initBootstrapPopovers = function () { 6341 var popoverTriggerList = [].slice.call(document.querySelectorAll('[data-bs-toggle="popover"]')); 6342 6343 var popoverList = popoverTriggerList.map(function (popoverTriggerEl) { 6344 initBootstrapPopover(popoverTriggerEl, {}); 6345 }); 6346 } 6347 6348 var initBootstrapScrollSpy = function () { 6349 var elements = [].slice.call(document.querySelectorAll('[data-bs-spy="scroll"]')); 6350 6351 elements.map(function (element) { 6352 var sel = element.getAttribute('data-bs-target'); 6353 var scrollContent = document.querySelector(element.getAttribute('data-bs-target')); 6354 var scrollSpy = bootstrap.ScrollSpy.getInstance(scrollContent); 6355 if (scrollSpy) { 6356 scrollSpy.refresh(); 6357 } 6358 }); 6359 } 6360 6361 var initBootstrapToast = function () { 6362 var toastElList = [].slice.call(document.querySelectorAll('.toast')); 6363 var toastList = toastElList.map(function (toastEl) { 6364 return new bootstrap.Toast(toastEl, {}) 6365 }); 6366 } 6367 6368 var initButtons = function () { 6369 var buttonsGroup = [].slice.call(document.querySelectorAll('[data-kt-buttons="true"]')); 6370 6371 buttonsGroup.map(function (group) { 6372 var selector = group.hasAttribute('data-kt-buttons-target') ? group.getAttribute('data-kt-buttons-target') : '.btn'; 6373 6374 // Toggle Handler 6375 KTUtil.on(group, selector, 'click', function (e) { 6376 var buttons = [].slice.call(group.querySelectorAll(selector + '.active')); 6377 6378 buttons.map(function (button) { 6379 button.classList.remove('active'); 6380 }); 6381 6382 this.classList.add('active'); 6383 }); 6384 }); 6385 } 6386 6387 var initDaterangepicker = function() { 6388 // Check if jQuery included 6389 if (typeof jQuery == 'undefined') { 6390 return; 6391 } 6392 6393 // Check if daterangepicker included 6394 if (typeof $.fn.daterangepicker === 'undefined') { 6395 return; 6396 } 6397 6398 var elements = [].slice.call(document.querySelectorAll('[data-kt-daterangepicker="true"]')); 6399 var start = moment().subtract(29, 'days'); 6400 var end = moment(); 6401 6402 elements.map(function (element) { 6403 var display = element.querySelector('div'); 6404 var attrOpens = element.hasAttribute('data-kt-daterangepicker-opens') ? element.getAttribute('data-kt-daterangepicker-opens') : 'left'; 6405 6406 var cb = function(start, end) { 6407 if (display) { 6408 display.innerHTML = start.format('D MMM YYYY') + ' - ' + end.format('D MMM YYYY'); 6409 } 6410 } 6411 6412 $(element).daterangepicker({ 6413 startDate: start, 6414 endDate: end, 6415 opens: attrOpens, 6416 ranges: { 6417 'Today': [moment(), moment()], 6418 'Yesterday': [moment().subtract(1, 'days'), moment().subtract(1, 'days')], 6419 'Last 7 Days': [moment().subtract(6, 'days'), moment()], 6420 'Last 30 Days': [moment().subtract(29, 'days'), moment()], 6421 'This Month': [moment().startOf('month'), moment().endOf('month')], 6422 'Last Month': [moment().subtract(1, 'month').startOf('month'), moment().subtract(1, 'month').endOf('month')] 6423 } 6424 }, cb); 6425 6426 cb(start, end); 6427 }); 6428 } 6429 6430 var initCheck = function () { 6431 // Toggle Handler 6432 KTUtil.on(document.body, '[data-kt-check="true"]', 'change', function (e) { 6433 var check = this; 6434 var targets = document.querySelectorAll(check.getAttribute('data-kt-check-target')); 6435 6436 KTUtil.each(targets, function (target) { 6437 if (target.type == 'checkbox') { 6438 target.checked = check.checked; 6439 } else { 6440 target.classList.toggle('active'); 6441 } 6442 }); 6443 }); 6444 } 6445 6446 var initSelect2 = function () { 6447 // Check if jQuery included 6448 if (typeof jQuery == 'undefined') { 6449 return; 6450 } 6451 6452 // Check if select2 included 6453 if (typeof $.fn.select2 === 'undefined') { 6454 return; 6455 } 6456 6457 var elements = [].slice.call(document.querySelectorAll('[data-control
6457="select2"], [data-kt-select2="true"]')); 6458 6459 elements.map(function (element) { 6460 var options = { 6461 dir: document.body.getAttribute('direction') 6462 }; 6463 6464 if (element.getAttribute('data-hide-search') == 'true') { 6465 options.minimumResultsForSearch = Infinity; 6466 } 6467 6468 $(element).select2(options); 6469 }); 6470 6471 /* 6472 * Hacky fix for a bug in select2 with jQuery 3.6.0's new nested-focus "protection" 6473 * see: https://github.com/select2/select2/issues/5993 6474 * see: https://github.com/jquery/jquery/issues/4382 6475 * 6476 * TODO: Recheck with the select2 GH issue and remove once this is fixed on their side 6477 */ 6478 6479 if (select2FocusFixInitialized === false) { 6480 select2FocusFixInitialized = true; 6481 6482 $(document).on('select2:open', function(e) { 6483 var elements = document.querySelectorAll('.select2-container--open .select2-search__field'); 6484 if (elements.length > 0) { 6485 elements[elements.length - 1].focus(); 6486 } 6487 }); 6488 } 6489 } 6490 6491 var initModal = function() { 6492 // Apply fix for Firefox's known bug with Flatpickr and other inputs focus state 6493 if (navigator.userAgent.toLowerCase().indexOf('firefox') !== -1) { 6494 const allModals = document.querySelectorAll('.modal:not(.initialized)'); 6495 6496 allModals.forEach(modal => { 6497 modal.addEventListener('shown.bs.modal', function() { 6498 bootstrap.Modal.getInstance(this).handleUpdate(); 6499 this.classList.add('initialized'); 6500 alert(2); 6501 }); 6502 }); 6503 } 6504 } 6505 6506 var initAutosize = function () { 6507 var inputs = [].slice.call(document.querySelectorAll('[data-kt-autosize="true"]')); 6508 6509 inputs.map(function (input) { 6510 autosize(input); 6511 }); 6512 } 6513 6514 var initCountUp = function () { 6515 var elements = [].slice.call(document.querySelectorAll('[data-kt-countup="true"]:not(.counted)')); 6516 6517 elements.map(function (element) { 6518 if (KTUtil.isInViewport(element) && KTUtil.visible(element)) { 6519 var options = {}; 6520 6521 var value = element.getAttribute('data-kt-countup-value'); 6522 value = parseFloat(value.replace(/,/g, "")); 6523 6524 if (element.hasAttribute('data-kt-countup-start-val')) { 6525 options.startVal = parseFloat(element.getAttribute('data-kt-countup-start-val')); 6526 } 6527 6528 if (element.hasAttribute('data-kt-countup-duration')) { 6529 options.duration = parseInt(element.getAttribute('data-kt-countup-duration')); 6530 } 6531 6532 if (element.hasAttribute('data-kt-countup-decimal-places')) { 6533 options.decimalPlaces = parseInt(element.getAttribute('data-kt-countup-decimal-places')); 6534 } 6535 6536 if (element.hasAttribute('data-kt-countup-prefix')) { 6537 options.prefix = element.getAttribute('data-kt-countup-prefix'); 6538 } 6539 6540 if (element.hasAttribute('data-kt-countup-separator')) { 6541 options.separator = element.getAttribute('data-kt-countup-separator'); 6542 } 6543 6544 if (element.hasAttribute('data-kt-countup-suffix')) { 6545 options.suffix = element.getAttribute('data-kt-countup-suffix'); 6546 } 6547 6548 var count = new countUp.CountUp(element, value, options); 6549 6550 count.start(); 6551 6552 element.classList.add('counted'); 6553 } 6554 }); 6555 } 6556 6557 var initCountUpTabs = function () { 6558 // Initial call 6559 initCountUp(); 6560 6561 // Window scroll event handler 6562 window.addEventListener('scroll', initCountUp); 6563 6564 // Tabs shown event handler 6565 var tabs = [].slice.call(document.querySelectorAll('[data-kt-countup-tabs="true"][data-bs-toggle="tab"]')); 6566 tabs.map(function (tab) { 6567 tab.addEventListener('shown.bs.tab', initCountUp); 6568 }); 6569 } 6570 6571 var initTinySliders = function () { 6572 // Init Slider 6573 var initSlider = function (el) { 6574 if (!el) { 6575 return; 6576 } 6577 6578 const tnsOptions = {}; 6579 6580 // Convert string boolean 6581 const checkBool = function (val) { 6582 if (val === 'true') { 6583 return true; 6584 } 6585 if (val === 'false') { 6586 return false;
6587 } 6588 return val; 6589 }; 6590 6591 // get extra options via data attributes 6592 el.getAttributeNames().forEach(function (attrName) { 6593 // more options; https://github.com/ganlanyuan/tiny-slider#options 6594 if ((/^data-tns-.*/g).test(attrName)) { 6595 let optionName = attrName.replace('data-tns-', '').toLowerCase().replace(/(?:[\s-])\w/g, function (match) { 6596 return match.replace('-', '').toUpperCase(); 6597 }); 6598 6599 if (attrName === 'data-tns-responsive') { 6600 // fix string with a valid json 6601 const jsonStr = el.getAttribute(attrName).replace(/(\w+:)|(\w+ :)/g, function (matched) { 6602 return '"' + matched.substring(0, matched.length - 1) + '":'; 6603 }); 6604 try { 6605 // convert json string to object 6606 tnsOptions[optionName] = JSON.parse(jsonStr); 6607 } 6608 catch (e) { 6609 } 6610 } 6611 else { 6612 tnsOptions[optionName] = checkBool(el.getAttribute(attrName)); 6613 } 6614 } 6615 }); 6616 6617 const opt = Object.assign({}, { 6618 container: el, 6619 slideBy: 'page', 6620 autoplay: true, 6621 autoplayButtonOutput: false, 6622 }, tnsOptions); 6623 6624 if (el.closest('.tns')) { 6625 KTUtil.addClass(el.closest('.tns'), 'tns-initiazlied'); 6626 } 6627 6628 return tns(opt); 6629 } 6630 6631 // Sliders 6632 const elements = Array.prototype.slice.call(document.querySelectorAll('[data-tns="true"]'), 0); 6633 6634 if (!elements && elements.length === 0) { 6635 return; 6636 } 6637 6638 elements.forEach(function (el) { 6639 initSlider(el); 6640 }); 6641 } 6642 6643 var initSmoothScroll = function () { 6644 if (SmoothScroll) { 6645 6646 new SmoothScroll('a[data-kt-scroll-toggle][href*="#"]', { 6647 speed: 900, 6648 offset: function (anchor, toggle) { 6649 // Integer or Function returning an integer. How far to offset the scrolling anchor location in pixels 6650 // This example is a function, but you could do something as simple as `offset: 25` 6651 6652 // An example returning different values based on whether the clicked link was in the header nav or not 6653 if (anchor.hasAttribute('data-kt-scroll-offset')) { 6654 var val = KTUtil.getResponsiveValue(anchor.getAttribute('data-kt-scroll-offset')); 6655 6656 return val; 6657 } else { 6658 return 0; 6659 } 6660 } 6661 }); 6662 } 6663 } 6664 6665 return { 6666 init: function () { 6667 this.initPageLoader(); 6668 6669 this.initBootstrapTooltips(); 6670 6671 this.initBootstrapPopovers(); 6672 6673 this.initBootstrapScrollSpy(); 6674 6675 this.initDaterangepicker(); 6676 6677 this.initButtons(); 6678 6679 this.initCheck(); 6680 6681 this.initSelect2(); 6682 6683 this.initCountUp(); 6684 6685 this.initCountUpTabs(); 6686 6687 this.initAutosize(); 6688 6689 this.initTinySliders(); 6690 6691 this.initSmoothScroll(); 6692 6693 this.initBootstrapToast(); 6694 }, 6695 6696 initPageLoader: function () { 6697 initPageLoader(); 6698 }, 6699 6700 initDaterangepicker: function() { 6701 initDaterangepicker(); 6702 }, 6703 6704 initBootstrapTooltip: function (el, options) { 6705 return initBootstrapTooltip(el, options); 6706 }, 6707 6708 initBootstrapTooltips: function () { 6709 initBootstrapTooltips(); 6710 }, 6711 6712 initBootstrapModal: function() { 6713 initModal(); 6714 }, 6715 6716 initBootstrapPopovers: function () { 6717 initBootstrapPopovers(); 6718 }, 6719 6720 initBootstrapPopover: function (el, options) { 6721 return initBootstrapPopover(el, options); 6722 }, 6723 6724 initBootstrapScrollSpy: function () { 6725 initBootstrapScrollSpy(); 6726 }, 6727 6728 initBootstrapToast: function () { 6729 initBootstrapToast(); 6730 }, 6731 6732 initButtons: function () { 6733 initButtons(); 6734 }, 6735 6736 initCheck: function () { 6737 initCheck(); 6738 }, 6739 6740 initSelect2: function () { 6741 initSelect2(); 6742 }, 6743 6744 initCountUp: function () { 6745 initCountUp(); 6746 }, 6747 6748 initCountUpTabs: function () { 6749 initCountUpTabs(); 6750 }, 6751 6752 initAutosize: function () { 6753 initAutosize(); 6754 }, 6755 6756 initTinySliders: function () { 6757 initTinySliders(); 6758 }, 6759 6760 initSmoothScroll: function () { 6761 initSmoothScroll(); 6762 }, 6763 6764 isDarkMode: function () { 6765 return document.body.classList.contains('dark-mode'); 6766 } 6767 }; 6768}(); 6769 6770// On document ready 6771KTUtil.onDOMContentLoaded(function () { 6772 KTApp.init(); 6773}); 6774 6775// On window load 6776window.addEventListener("load", function () { 6777 KTApp.initPageLoader(); 6778}); 6779 6780// Webpack support 6781if (typeof module !== 'undefined' && typeof module.exports !== 'undefined') { 6782 module.exports = KTApp; 6783} 6784"use strict"; 6785 6786// Class definition 6787var KTLayoutAside = function () { 6788 // Private variables 6789 var toggle; 6790 var aside; 6791 6792 // Private functions 6793 var handleToggle = function () { 6794 var toggleObj = KTToggle.getInstance(toggle); 6795 6796 // Add a class to prevent aside hover effect after toggle click 6797 toggleObj.on('kt.toggle.change', function() { 6798 aside.classList.add('animating'); 6799 6800 setTimeout(function() { 6801 aside.classList.remove('animating'); 6802 }, 300); 6803 }) 6804 } 6805 6806 // Public methods 6807 return { 6808 init: function () { 6809 // Elements 6810 aside = document.querySelector('#kt_aside'); 6811 toggle = document.querySelector('#kt_aside_toggle'); 6812 6813 if (!aside || !toggle) { 6814 return; 6815 } 6816 6817 handleToggle(); 6818 } 6819 }; 6820}(); 6821 6822// On document ready 6823KTUtil.onDOMContentLoaded(function () { 6824 KTLayoutAside.init(); 6825}); 6826"use strict"; 6827 6828// Class definition 6829var KTLayoutSearch = function() { 6830 // Private variables 6831 var element; 6832 var formElement; 6833 var mainElement; 6834 var resultsElement; 6835 var wrapperElement; 6836 var emptyElement; 6837 6838 var preferencesElement; 6839 var preferencesShowElement; 6840 var preferencesDismissElement; 6841 6842 var advancedOptionsFormElement; 6843 var advancedOptionsFormShowElement; 6844 var advancedOptionsFormCancelElement; 6845 var advancedOptionsFormSearchElement; 6846 6847 var searchObject; 6848 6849 // Private functions 6850 var processs = function(search) { 6851 var timeout = setTimeout(function() { 6852 var number = KTUtil.getRandomInt(1, 3); 6853 6854 // Hide recently viewed 6855 mainElement.classList.add('d-none'); 6856 6857 if (number === 3) { 6858 // Hide results 6859 resultsElement.classList.add('d-none'); 6860 // Show empty message 6861 emptyElement.classList.remove('d-none'); 6862 } else { 6863 // Show results 6864 resultsElement.classList.remove('d-none'); 6865 // Hide empty message 6866 emptyElement.classList.add('d-none'); 6867 } 6868 6869 // Complete search 6870 search.complete(); 6871 }, 1500); 6872 } 6873 6874 var clear = function(search) { 6875 // Show recently viewed 6876 mainElement.classList.remove('d-none'); 6877 // Hide results 6878 resultsElement.classList.add('d-none'); 6879 // Hide empty message 6880 emptyElement.classList.add('d-none'); 6881 } 6882 6883 var handlePreferences = function() { 6884 // Preference show handler 6885// preferencesShowElement.addEventListener('click', function() { 6886 // wrapperElement.classList.add('d-none'); 6887 // preferencesElement.classList.remove('d-none'); 6888 // }); 6889 6890 // Preference dismiss handler 6891 // preferencesDismissElement.addEventListener('click', function() { 6892 // wrapperElement.classList.remove('d-none'); 6893 // preferencesElement.classList.add('d-none'); 6894 // }); 6895 } 6896 6897 var handleAdvancedOptionsForm = function() { 6898 // Show 6899 /* advancedOptionsFormShowElement.addEventListener('click', function() { 6900 wrapperElement.classList.add('d-none'); 6901 advancedOptionsFormElement.classList.remove('d-none'); 6902 }); 6903 6904 // Cancel 6905 advancedOptionsFormCancelElement.addEventListener('click', function() { 6906 wrapperElement.classList.remove('d-none'); 6907 advancedOptionsFormElement.classList.add('d-none'); 6908 }); 6909 6910 // Search 6911 advancedOptionsFormSearchElement.addEventListener('click', function() { 6912 6913 });*/ 6914 } 6915 6916 // Public methods 6917 return { 6918 init: function() { 6919 // Elements 6920 element = document.querySelector('#kt_header_search'); 6921 6922 if (!element) { 6923 return; 6924 } 6925 6926 wrapperElement = element.querySelector('[data-kt-search-element="wrapper"]'); 6927 formElement = element.querySelector('[data-kt-search-element="form"]'); 6928 mainElement = element.querySelector('[data-kt-search-element="main"]'); 6929 resultsElement = element.querySelector('[data-kt-search-element="results"]'); 6930 emptyElement = element.querySelector('[data-kt-search-element="empty"]'); 6931 6932 preferencesElement = element.querySelector('[data-kt-search-element="preferences"]'); 6933 preferencesShowElement = element.querySelector('[data-kt-search-element="preferences-show"]'); 6934 preferencesDismissElement = element.querySelector('[data-kt-search-element="preferences-dismiss"]'); 6935 6936 advancedOptionsFormElement = element.querySelector('[data-kt-search-element="advanced-options-form"]'); 6937 advancedOptionsFormShowElement = element.querySelector('[data-kt-search-element="advanced-options-form-show"]'); 6938 advancedOptionsFormCancelElement = element.querySelector('[data-kt-search-element="advanced-options-form-cancel"]'); 6939 advancedOptionsFormSearchElement = element.querySelector('[data-kt-search-element="advanced-options-form-search"]'); 6940 6941 // Initialize search handler 6942 searchObject = new KTSearch(element); 6943 6944 // Search handler 6945 searchObject.on('kt.search.process', processs); 6946 6947 // Clear handler 6948 searchObject.on('kt.search.clear', clear); 6949 6950 // Custom handlers 6951 handlePreferences(); 6952 handleAdvancedOptionsForm(); 6953 } 6954 }; 6955}(); 6956 6957// On document ready 6958KTUtil.onDOMContentLoaded(function() { 6959 KTLayoutSearch.init(); 6960}); 6961"use strict"; 6962 6963// Class definition 6964var KTLayoutToolbar = function () { 6965 // Private variables 6966 var toolbar; 6967 6968 // Private functions 6969 var initForm = function () { 6970 var rangeSlider = document.querySelector("#kt_toolbar_slider"); 6971 var rangeSliderValueElement = document.querySelector("#kt_toolbar_slider_value"); 6972 6973 if (!rangeSlider) { 6974 return; 6975 } 6976 6977 noUiSlider.create(rangeSlider, { 6978 start: [5], 6979 connect: [true, false], 6980 step: 1, 6981 format: wNumb({ 6982 decimals: 1 6983 }), 6984 range: { 6985 min: [1], 6986 max: [10] 6987 } 6988 }); 6989 6990 rangeSlider.noUiSlider.on("update", function (values, handle) { 6991 rangeSliderValueElement.innerHTML = values[handle]; 6992 }); 6993 6994 var handle = rangeSlider.querySelector(".noUi-handle"); 6995 6996 handle.setAttribute("tabindex", 0); 6997 6998 handle.addEventListener("click", function () { 6999 this.focus(); 7000 }); 7001 7002 handle.addEventListener("keydown", function (event) { 7003 var value = Number(rangeSlider.noUiSlider.get()); 7004 7005 switch (event.which) { 7006 case 37: 7007 rangeSlider.noUiSlider.set(value - 1); 7008 break; 7009 case 39: 7010 rangeSlider.noUiSlider.set(value + 1); 7011 break; 7012 } 7013 }); 7014 } 7015 7016 // Public methods 7017 return { 7018 init: function () { 7019 // Elements 7020 toolbar = document.querySelector('#kt_toolbar'); 7021 7022 if (!toolbar) { 7023 return; 7024 } 7025 7026 initForm(); 7027 } 7028 }; 7029}(); 7030 7031var url = window.location.pathname.split("/"); 7032 7033 $('.menu .mainmenu').each(function(i) { 7034 var th = $(this); 7035 if(th.attr("rel") == "#"+url[1]) 7036 { 7037 th.addClass("show"); 7038 } 7039}); 7040 7041/* 7042// Define variables 7043var initialLocaleCode = "tr"; 7044var localeSelectorEl = document.getElementById("kt_docs_fullcalendar_locale_selector"); 7045var calendarEl = document.getElementById("kt_docs_fullcalendar_locales"); 7046 7047// initialize the calendar -- for more info please visit the official site: https://fullcalendar.io/demos 7048var calendar = new FullCalendar.Calendar(calendarEl, { 7049 headerToolbar: { 7050 left: "prev,next today", 7051 center: "title", 7052 right: "dayGridMonth,timeGridWeek,timeGridDay,listMonth" 7053 }, 7054 initialDate: "2020-09-12", 7055 locale: initialLocaleCode, 7056 buttonIcons: false, // show the prev/next text 7057 weekNumbers: true, 7058 navLinks: true, // can click day/week names to navigate views 7059 editable: true, 7060 dayMaxEvents: true, // allow "more" link when too many events 7061 events: [ 7062 { 7063 title: "All Day Event", 7064 start: "2020-09-01" 7065 }, 7066 { 7067 title: "Long Event", 7068 start: "2020-09-07", 7069 end: "2020-09-10" 7070 }, 7071 { 7072 groupId: 999, 7073 title: "Repeating Event", 7074 start: "2020-09-09T16:00:00" 7075 }, 7076 { 7077 groupId: 999, 7078 title: "Repeating Event", 7079 start: "2020-09-16T16:00:00" 7080 }, 7081 { 7082 title: "Conference", 7083 start: "2020-09-11", 7084 end: "2020-09-13" 7085 }, 7086 { 7087 title: "Meeting", 7088 start: "2020-09-12T10:30:00", 7089 end: "2020-09-12T12:30:00" 7090 }, 7091 { 7092 title: "Lunch", 7093 start: "2020-09-12T12:00:00" 7094 }, 7095 { 7096 title: "Meeting", 7097 start: "2020-09-12T14:30:00" 7098 }, 7099 { 7100 title: "Happy Hour", 7101 start: "2020-09-12T17:30:00" 7102 }, 7103 { 7104 title: "Dinner", 7105 start: "2020-09-12T20:00:00" 7106 }, 7107 { 7108 title: "Birthday Party", 7109 start: "2020-09-13T07:00:00" 7110 }, 7111 { 7112 title: "Click for Google", 7113 url: "http://google.com/", 7114 start: "2020-09-28" 7115 } 7116 ] 7117}); 7118 7119calendar.render(); 7120 7121// build the locale selector"s options
7122calendar.getAvailableLocaleCodes().forEach(function (localeCode) { 7123 var optionEl = document.createElement("option"); 7124 optionEl.value = localeCode; 7125 optionEl.selected = localeCode == initialLocaleCode; 7126 optionEl.innerText = localeCode; 7127 localeSelectorEl.appendChild(optionEl); 7128}); 7129 7130// when the selected option changes, dynamically change the calendar option 7131$(localeSelectorEl).on("change", function () { 7132 if (this.value) { 7133 calendar.setOption("locale", this.value); 7134 } 7135}); 7136 7137calendar.render(); */ 7138 7139 7140 7141
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.