1/******/ (() => { // webpackBootstrap 2/******/ "use strict"; 3/******/ var __webpack_modules__ = ({ 4 5/***/ "./assets/src/js/utils.js" 6/*!********************************!*\ 7 !*** ./assets/src/js/utils.js ***! 8 \********************************/ 9(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 10 11__webpack_require__.r(__webpack_exports__); 12/* harmony export */ __webpack_require__.d(__webpack_exports__, { 13/* harmony export */ debounce: () => (/* binding */ debounce), 14/* harmony export */ eventHandlers: () => (/* binding */ eventHandlers), 15/* harmony export */ fullScreenView: () => (/* binding */ fullScreenView), 16/* harmony export */ getDataOfForm: () => (/* binding */ getDataOfForm), 17/* harmony export */ getFieldKeysOfForm: () => (/* binding */ getFieldKeysOfForm), 18/* harmony export */ listenElementCreated: () => (/* binding */ listenElementCreated), 19/* harmony export */ listenElementViewed: () => (/* binding */ listenElementViewed), 20/* harmony export */ lpAddQueryArgs: () => (/* binding */ lpAddQueryArgs), 21/* harmony export */ lpAjaxParseJsonOld: () => (/* binding */ lpAjaxParseJsonOld), 22/* harmony export */ lpClassName: () => (/* binding */ lpClassName), 23/* harmony export */ lpFetchAPI: () => (/* binding */ lpFetchAPI), 24/* harmony export */ lpGetCurrentURLNoParam: () => (/* binding */ lpGetCurrentURLNoParam), 25/* harmony export */ lpOnElementReady: () => (/* binding */ lpOnElementReady), 26/* harmony export */ lpSetLoadingEl: () => (/* binding */ lpSetLoadingEl), 27/* harmony export */ lpShowHideEl: () => (/* binding */ lpShowHideEl), 28/* harmony export */ mergeDataWithDatForm: () => (/* binding */ mergeDataWithDatForm), 29/* harmony export */ toggleCollapse: () => (/* binding */ toggleCollapse), 30/* harmony export */ toggleEnable: () => (/* binding */ toggleEnable) 31/* harmony export */ }); 32/** 33 * Utils functions 34 * 35 * @param url 36 * @param data 37 * @param functions 38 * @since 4.2.5.1 39 * @version 1.0.7 40 */ 41const lpClassName = { 42 hidden: 'lp-hidden', 43 loading: 'loading', 44 elCollapse: 'lp-collapse', 45 elSectionToggle: '.lp-section-toggle', 46 elTriggerToggle: '.lp-trigger-toggle', 47 elBtnFullScreen: '.lp-btn-full-screen-view', 48 elFullScreen: 'lp-full-screen-view', 49 elBtnFullScreenClose: 'lp-full-screen-view__close' 50}; 51const lpFetchAPI = (url, data = {}, functions = {}) => { 52 if ('function' === typeof functions.before) { 53 functions.before(); 54 } 55 fetch(url, { 56 method: 'GET', 57 ...data 58 }).then(response => response.json()).then(response => { 59 if ('function' === typeof functions.success) { 60 functions.success(response); 61 } 62 }).catch(err => { 63 if ('function' === typeof functions.error) { 64 functions.error(err); 65 } 66 }).finally(() => { 67 if ('function' === typeof functions.completed) { 68 functions.completed(); 69 } 70 }); 71}; 72 73/** 74 * Get current URL without params. 75 * 76 * @since 4.2.5.1 77 */ 78const lpGetCurrentURLNoParam = () => { 79 let currentUrl = window.location.href; 80 const hasParams = currentUrl.includes('?'); 81 if (hasParams) { 82 currentUrl = currentUrl.split('?')[0]; 83 } 84 return currentUrl; 85}; 86const lpAddQueryArgs = (endpoint, args) => { 87 const url = new URL(endpoint); 88 Object.keys(args).forEach(arg => { 89 url.searchParams.set(arg, args[arg]); 90 }); 91 return url; 92}; 93 94/** 95 * Listen element viewed. 96 * 97 * @param el 98 * @param callback 99 * @since 4.2.5.8 100 */ 101const listenElementViewed = (el, callback) => { 102 const observerSeeItem = new IntersectionObserver(function (entries) { 103 for (const entry of entries) { 104 if (entry.isIntersecting) { 105 callback(entry); 106 } 107 } 108 }); 109 observerSeeItem.observe(el); 110}; 111 112/** 113 * Listen element created. 114 * 115 * @param callback 116 * @since 4.2.5.8 117 */ 118const listenElementCreated = callback => { 119 const observerCreateItem = new MutationObserver(function (mutations) { 120 mutations.forEach(function (mutation) { 121 if (mutation.addedNodes) { 122 mutation.addedNodes.forEach(function (node) { 123 if (node.nodeType === 1) { 124 callback(node); 125 } 126 }); 127 } 128 }); 129 }); 130 observerCreateItem.observe(document, { 131 childList: true, 132 subtree: true 133 }); 134 // End. 135}; 136 137/** 138 * Listen element created. 139 * 140 * @param selector 141 * @param callback 142 * @since 4.2.7.1 143 */ 144const lpOnElementReady = (selector, callback) => { 145 const element = document.querySelector(selector); 146 if (element) { 147 callback(element); 148 return; 149 } 150 const observer = new MutationObserver((mutations, obs) => { 151 const element = document.querySelector(selector); 152 if (element) { 153 obs.disconnect(); 154 callback(element); 155 } 156 }); 157 observer.observe(document.documentElement, { 158 childList: true, 159 subtree: true 160 }); 161}; 162 163// Parse JSON from string with content include LP_AJAX_START. 164const lpAjaxParseJsonOld = data => { 165 if (typeof data !== 'string') { 166 return data; 167 }
168 const m = String.raw({ 169 raw: data 170 }).match(/<-- LP_AJAX_START -->(.*)<-- LP_AJAX_END -->/s); 171 try { 172 if (m) { 173 data = JSON.parse(m[1].replace(/(?:\r\n|\r|\n)/g, '')); 174 } else { 175 data = JSON.parse(data); 176 } 177 } catch (e) { 178 data = {}; 179 } 180 return data; 181}; 182 183// status 0: hide, 1: show 184const lpShowHideEl = (el, status = 0) => { 185 if (!el) { 186 return; 187 } 188 if (!status) { 189 el.classList.add(lpClassName.hidden); 190 } else { 191 el.classList.remove(lpClassName.hidden); 192 } 193}; 194 195// status 0: hide, 1: show 196const lpSetLoadingEl = (el, status) => { 197 if (!el) { 198 return; 199 } 200 if (!status) { 201 el.classList.remove(lpClassName.loading); 202 } else { 203 el.classList.add(lpClassName.loading); 204 } 205}; 206 207// Toggle collapse section 208const toggleCollapse = (e, target, elTriggerClassName = '', elsExclude = [], callback) => { 209 if (!elTriggerClassName) { 210 elTriggerClassName = lpClassName.elTriggerToggle; 211 } 212 213 // Exclude elements, which should not trigger the collapse toggle 214 if (elsExclude && elsExclude.length > 0) { 215 for (const elExclude of elsExclude) { 216 if (target.closest(elExclude)) { 217 return; 218 } 219 } 220 } 221 const elTrigger = target.closest(elTriggerClassName); 222 if (!elTrigger) { 223 return; 224 } 225 226 //console.log( 'elTrigger', elTrigger ); 227 228 const elSectionToggle = elTrigger.closest(`${lpClassName.elSectionToggle}`); 229 if (!elSectionToggle) { 230 return; 231 } 232 elSectionToggle.classList.toggle(`${lpClassName.elCollapse}`); 233 if ('function' === typeof callback) { 234 callback(elSectionToggle); 235 } 236}; 237 238// Get data of form 239const getDataOfForm = form => { 240 const dataSend = {}; 241 const formData = new FormData(form); 242 for (const pair of formData.entries()) { 243 const key = pair[0];
244 const value = formData.getAll(key); 245 if (!dataSend.hasOwnProperty(key)) { 246 // Convert value array to string. 247 dataSend[key] = value.join(','); 248 } 249 } 250 return dataSend; 251}; 252 253// Get field keys of form 254const getFieldKeysOfForm = form => { 255 const keys = []; 256 const elements = form.elements; 257 for (let i = 0; i < elements.length; i++) { 258 const name = elements[i].name; 259 if (name && !keys.includes(name)) { 260 keys.push(name); 261 } 262 } 263 return keys; 264}; 265 266// Merge data handle with data form. 267const mergeDataWithDatForm = (elForm, dataHandle) => { 268 const dataForm = getDataOfForm(elForm); 269 const keys = getFieldKeysOfForm(elForm); 270 keys.forEach(key => { 271 if (!dataForm.hasOwnProperty(key)) { 272 delete dataHandle[key]; 273 } else if (dataForm[key][0] === '') { 274 delete dataForm[key]; 275 delete dataHandle[key]; 276 } 277 }); 278 dataHandle = { 279 ...dataHandle, 280 ...dataForm 281 }; 282 return dataHandle; 283}; 284 285/** 286 * Event trigger 287 * For each list of event handlers, listen event on document. 288 * 289 * eventName: 'click', 'change', ... 290 * eventHandlers = [ { selector: '.lp-button', callBack: function(){}, class: object } ] 291 * 292 * @param eventName 293 * @param eventHandlers 294 */ 295const eventHandlers = (eventName, eventHandlers) => { 296 document.addEventListener(eventName, e => { 297 const target = e.target; 298 let args = { 299 e, 300 target 301 }; 302 eventHandlers.forEach(eventHandler => { 303 args = { 304 ...args, 305 ...eventHandler 306 }; 307 308 //console.log( args ); 309 310 // Check condition before call back 311 if (eventHandler.conditionBeforeCallBack) { 312 if (eventHandler.conditionBeforeCallBack(args) !== true) { 313 return; 314 } 315 } 316 317 // Special check for keydown event with checkIsEventEnter = true 318 if (eventName === 'keydown' && eventHandler.checkIsEventEnter) { 319 if (e.key !== 'Enter') { 320 return; 321 } 322 } 323 if (target.closest(eventHandler.selector)) { 324 if (eventHandler.class) { 325 // Call method of class, function callBack will understand exactly {this} is class object. 326 eventHandler.class[eventHandler.callBack](args); 327 } else { 328 // For send args is objected, {this} is eventHandler object, not class object. 329 eventHandler.callBack(args); 330 } 331 } 332 }); 333 }); 334}; 335 336/** 337 * Debounce - delays function execution until after `wait` ms of inactivity. 338 * 339 * Each call resets the timer. Only the last call in a burst executes. 340 * 341 * USE CASES: 342 * - Search inputs, form validation, window resize 343 * - Multiple elements need independent timers 344 * - When you need to call with different arguments 345 * 346 * EXAMPLES: 347 * const debouncedSearch = debounce( (query) => fetchResults(query), 300 ); 348 * searchInput.addEventListener('input', (e) => debouncedSearch(e.target.value)); 349 * 350 * const debouncedResize = debounce( recalculateLayout, 250 ); 351 * window.addEventListener('resize', debouncedResize); 352 * 353 * â ï¸ Create ONCE outside event handlers, not inside. 354 * 355 * @param {Function} func - Function to debounce (can be anonymous) 356 * @param {number} wait - Milliseconds to wait (default: 500) 357 * @return {Function} Debounced wrapper function 358 * @since 4.3.7 359 * @version 1.0.0 360 */ 361const debounce = (func, wait = 500) => { 362 let timer; 363 return args => { 364 clearTimeout(timer); 365 timer = setTimeout(() => func(args), wait); 366 }; 367}; 368 369/** 370 * Initialize lp-toggle-enable components. 371 * 372 * Finds all `.lp-toggle-enable` elements and wires up toggle behavior. 373 * Reads initial state from `data-enabled` attribute ("true"/"false"). 374 * Calls `data-on-toggle` callback (if provided via options) on state change. 375 * 376 * HTML structure: 377 * <label class="lp-toggle-enable" data-enabled="true"> 378 * <input type="checkbox" class="lp-toggle-enable__input" /> 379 * <span class="lp-toggle-enable__track"></span> 380 * </label> 381 * 382 * @param {string} selector CSS selector for toggle elements (default: '.lp-toggle-enable') 383 * @param {Function} onToggle Optional callback( el, isEnabled ) called on state change 384 * @since 4.4.5 385 * @version 1.0.0 386 */ 387window.lpToggleEnableInit = 0; 388const toggleEnable = (onToggle = null) => { 389 if (window.lpToggleEnableInit) { 390 return; 391 } 392 window.lpToggleEnableInit = 1; 393 const selector = '.lp-toggle-enable'; 394 const updateUI = (toggle, isEnabled) => {
395 toggle.classList.toggle('is-enabled', isEnabled); 396 const input = toggle.querySelector('.lp-toggle-enable__input'); 397 if (input) { 398 input.checked = isEnabled; 399 input.value = isEnabled ? '1' : '0'; 400 } 401 }; 402 403 // Delegate click handling via eventHandlers. 404 eventHandlers('click', [{ 405 selector, 406 callBack: args => { 407 const { 408 e, 409 target 410 } = args; 411 const toggle = target.closest(selector); 412 if (!toggle || toggle.classList.contains('is-disabled')) { 413 return; 414 } 415 e.preventDefault(); 416 const isEnabled = !toggle.classList.contains('is-enabled'); 417 updateUI(toggle, isEnabled); 418 if ('function' === typeof onToggle) { 419 onToggle(toggle, isEnabled); 420 } 421 } 422 }]); 423}; 424 425/** 426 * Initialize custom fullscreen view buttons. 427 * 428 * Delegates clicks on `.lp-btn-full-screen-view` buttons to 429 * `lpToggleFullscreenView`. Reads the `data-target` attribute to find the 430 * target element. Falls back to the button's parent element when 431 * `data-target` is not provided. 432 * 433 * @since 4.4.5 434 * @version 1.0.0 435 */ 436window.lpFullScreenViewInit = 0; 437const fullScreenView = () => { 438 if (window.lpFullScreenViewInit) { 439 return; 440 } 441 window.lpFullScreenViewInit = 1; 442 let lastScrollY = 0; 443 const lpToggleFullscreenView = (elTarget, elBtnFullScreen = null) => { 444 const isFullscreen = elTarget.classList.contains(lpClassName.elFullScreen); 445 if (isFullscreen) { 446 elTarget.classList.remove(lpClassName.elFullScreen); 447 document.documentElement.classList.remove('lp-full-screen-active'); 448 window.scrollTo(0, lastScrollY); 449 } else { 450 lastScrollY = window.scrollY; 451 elTarget.classList.add(lpClassName.elFullScreen); 452 document.documentElement.classList.add('lp-full-screen-active'); 453 } 454 if (!isFullscreen) { 455 if (!elTarget.querySelector(`.${lpClassName.elBtnFullScreenClose}`)) { 456 const closeButton = document.createElement('button'); 457 closeButton.type = 'button'; 458 closeButton.className = lpClassName.elBtnFullScreenClose; 459 closeButton.setAttribute('aria-label', 'Close'); 460 closeButton.innerHTML = lpData.i18n.closeButtonFullScreen || 'Close ×'; 461 closeButton.addEventListener('click', e => { 462 e.preventDefault(); 463 lpToggleFullscreenView(elTarget); 464 }); 465 elTarget.appendChild(closeButton); 466 } 467 } else { 468 const closeButton = elTarget.querySelector(`.${lpClassName.elBtnFullScreenClose}`); 469 if (closeButton) { 470 closeButton.remove(); 471 } 472 } 473 }; 474 eventHandlers('click', [{ 475 selector: lpClassName.elBtnFullScreen, 476 callBack: args => { 477 const { 478 e, 479 target 480 } = args; 481 const elBtnFullScreen = target.closest(lpClassName.elBtnFullScreen); 482 if (!elBtnFullScreen) { 483 console.log('No full screen button found'); 484 return; 485 } 486 e.preventDefault(); 487 let elTarget = null; 488 const targetSelector = elBtnFullScreen.dataset.targetFullscreen; 489 console.log(targetSelector); 490 if (targetSelector) { 491 elTarget = document.querySelector(targetSelector); 492 } 493 if (!elTarget) { 494 console.log('No target element found'); 495 return; 496 } 497 lpToggleFullscreenView(elTarget, elBtnFullScreen); 498 } 499 }]); 500}; 501 502/***/ } 503 504/******/ }); 505/************************************************************************/ 506/******/ // The module cache 507/******/ var __webpack_module_cache__ = {}; 508/******/ 509/******/ // The require function 510/******/ function __webpack_require__(moduleId) { 511/******/ // Check if module is in cache 512/******/ var cachedModule = __webpack_module_cache__[moduleId]; 513/******/ if (cachedModule !== undefined) { 514/******/ return cachedModule.exports; 515/******/ } 516/******/ // Create a new module (and put it into the cache) 517/******/ var module = __webpack_module_cache__[moduleId] = { 518/******/ // no module.id needed 519/******/ // no module.loaded needed 520/******/ exports: {} 521/******/ }; 522/******/ 523/******/ // Execute the module function 524/******/ if (!(moduleId in __webpack_modules__)) { 525/******/ delete __webpack_module_cache__[moduleId]; 526/******/ var e = new Error("Cannot find module '" + moduleId + "'"); 527/******/ e.code = 'MODULE_NOT_FOUND'; 528/******/ throw e; 529/******/ } 530/******/ __webpack_modules__[moduleId](module, module.exports, __webpack_require__); 531/******/ 532/******/ // Return the exports of the module 533/******/ return module.exports; 534/******/ } 535/******/ 536/************************************************************************/ 537/******/ /* webpack/runtime/define property getters */ 538/******/ (() => { 539/******/ // define getter functions for harmony exports 540/******/ __webpack_require__.d = (exports, definition) => { 541/******/ for(var key in definition) { 542/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) { 543/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] }); 544/******/ } 545/******/ } 546/******/ }; 547/******/ })(); 548/******/ 549/******/ /* webpack/runtime/hasOwnProperty shorthand */ 550/******/ (() => { 551/******/ __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop)) 552/******/ })(); 553/******/ 554/******/ /* webpack/runtime/make namespace object */ 555/******/ (() => { 556/******/ // define __esModule on exports 557/******/ __webpack_require__.r = (exports) => { 558/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { 559/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); 560/******/ } 561/******/ Object.defineProperty(exports, '__esModule', { value: true }); 562/******/ }; 563/******/ })(); 564/******/ 565/************************************************************************/ 566var __webpack_exports__ = {}; 567// This entry needs to be wrapped in an IIFE because it needs to be isolated against other modules in the chunk. 568(() => { 569/*!***********************************!*\ 570 !*** ./assets/src/js/loadAJAX.js ***! 571 \***********************************/ 572__webpack_require__.r(__webpack_exports__); 573/* harmony export */ __webpack_require__.d(__webpack_exports__, { 574/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 575/* harmony export */ }); 576/* harmony import */ var lpAssetsJsPath_utils_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! lpAssetsJsPath/utils.js */ "./assets/src/js/utils.js"); 577/** 578 * Load all you need via AJAX 579 * 580 * @since 4.2.5.7 581 * @version 1.1.1 582 */ 583 584 585 586// Handle general parameter in the Frontend and Backend 587let lpSettings = {}; 588if ('undefined' !== typeof lpDataAdmin) { 589 lpSettings = lpDataAdmin; 590} else if ('undefined' !== typeof lpData) { 591 lpSettings = lpData; 592} 593// End Handle general parameter in the Frontend and Backend 594 595const lpAJAX = () => { 596 const classLPTarget = '.lp-target';
597 const urlCurrent = lpAssetsJsPath_utils_js__WEBPACK_IMPORTED_MODULE_0__.lpGetCurrentURLNoParam(); 598 return { 599 autoLoadAPIs: () => { 600 console.log('autoLoadAPIs'); 601 }, 602 fetchAPI: (url, params, callBack) => { 603 const option = { 604 headers: {} 605 }; 606 if (0 !== parseInt(lpSettings.user_id)) { 607 option.headers['X-WP-Nonce'] = lpSettings.nonce; 608 } 609 if ('undefined' !== typeof params.args.method_request) { 610 option.method = params.args.method_request; 611 } else { 612 option.method = 'POST'; 613 } 614 615 //params.args = { ...params.args, ...lpData.urlParams }; 616 617 if ('POST' === option.method) { 618 option.body = JSON.stringify(params); 619 option.headers['Content-Type'] = 'application/json'; 620 } else { 621 params.args = JSON.stringify(params.args); 622 params.callback = JSON.stringify(params.callback); 623 url = lpAssetsJsPath_utils_js__WEBPACK_IMPORTED_MODULE_0__.lpAddQueryArgs(url, params); 624 } 625 lpAssetsJsPath_utils_js__WEBPACK_IMPORTED_MODULE_0__.lpFetchAPI(url, option, callBack); 626 }, 627 fetchAJAX: (params, callBack) => { 628 let urlAjax = lpSettings.lpAjaxUrl; 629 630 // Set param id_url for identify. 631 if (params.hasOwnProperty('args') && params.args.hasOwnProperty('id_url')) { 632 urlAjax = lpAssetsJsPath_utils_js__WEBPACK_IMPORTED_MODULE_0__.lpAddQueryArgs(urlAjax, { 633 id_url: params.args.id_url 634 }); 635 } else if (params.hasOwnProperty('id_url')) { 636 urlAjax = lpAssetsJsPath_utils_js__WEBPACK_IMPORTED_MODULE_0__.lpAddQueryArgs(urlAjax, { 637 id_url: params.id_url 638 }); 639 } 640 // Set param lang here if exits, for detect translate 641 if (lpSettings.urlParams.hasOwnProperty('lang')) { 642 urlAjax = lpAssetsJsPath_utils_js__WEBPACK_IMPORTED_MODULE_0__.lpAddQueryArgs(urlAjax, { 643 lang: lpSettings.urlParams.lang 644 }); 645 } 646 const action = params.hasOwnProperty('action') ? params.action : 'load_content_via_ajax'; 647 const isGet = params.hasOwnProperty('method_request') && 'GET' === String(params.method_request).toUpperCase(); 648 let dataSend; 649 if (isGet) { 650 // Don't send method_request back to server; keep URL shorter. 651 const paramsForSend = { 652 ...params 653 }; 654 delete paramsForSend.method_request; 655 urlAjax = lpAssetsJsPath_utils_js__WEBPACK_IMPORTED_MODULE_0__.lpAddQueryArgs(urlAjax, { 656 nonce: lpSettings.nonce, 657 'lp-load-ajax': action, 658 data: JSON.stringify(paramsForSend) 659 }); 660 dataSend = { 661 method: 'GET', 662 headers: {} 663 }; 664 } else { 665 const formData = new FormData(); 666 formData.append('nonce', lpSettings.nonce); 667 formData.append('lp-load-ajax', action); 668 formData.append('data', JSON.stringify(params)); 669 dataSend = { 670 method: 'POST', 671 headers: {}, 672 body: formData 673 }; 674 } 675 if (0 !== parseInt(lpSettings.user_id)) { 676 dataSend.headers['X-WP-Nonce'] = lpSettings.nonce; 677 } 678 lpAssetsJsPath_utils_js__WEBPACK_IMPORTED_MODULE_0__.lpFetchAPI(urlAjax, dataSend, callBack); 679 }, 680 getElements: () => { 681 // Finds all elements with the class '.lp-load-ajax-element' 682 const elements = document.querySelectorAll('.lp-load-ajax-element:not(.loaded)'); 683 //console.log( 'getElements', elements ); 684 if (elements.length) { 685 elements.forEach(element => { 686 //console.log( 'Element handing', element ); 687 const elTarget = element.querySelector(`${classLPTarget}`); 688 if (!elTarget) { 689 return; 690 } 691 const dataObj = JSON.parse(elTarget.dataset.send); 692 const dataSend = { 693 ...dataObj 694 }; 695 const elLoadingFirst = element.querySelector('.loading-first'); 696 const callBack = { 697 success: response => { 698 const { 699 status, 700 message, 701 data 702 } = response; 703 if ('success' === status) { 704 elTarget.innerHTML = data.content; 705 } else if ('error' === status) { 706 elTarget.innerHTML = message; 707 } 708 }, 709 error: error => { 710 console.log(error); 711 }, 712 completed: () => { 713 if (typeof wp !== 'undefined' && wp.hooks) { 714 wp.hooks.doAction('lp-ajax-completed', element, dataSe
714nd); 715 } 716 window.lpAJAXG.getElements(); 717 //console.log( 'completed' ); 718 if (elLoadingFirst) { 719 elLoadingFirst.remove(); 720 } 721 } 722 }; 723 724 // Call via AJAX 725 window.lpAJAXG.fetchAJAX(dataSend, callBack); 726 element.classList.add('loaded'); 727 }); 728 } 729 }, 730 clickNumberPage: (e, target) => { 731 const btnNumber = target.closest('.page-numbers:not(.disabled)'); 732 if (!btnNumber) { 733 return; 734 } 735 736 // Check btnNumber is tag a 737 if (btnNumber.tagName.toLowerCase() !== 'a') { 738 return; 739 } 740 const elLPTarget = btnNumber.closest(`${classLPTarget}`); 741 if (!elLPTarget) { 742 return; 743 } 744 e.preventDefault(); 745 const dataObj = JSON.parse(elLPTarget.dataset.send); 746 const dataSend = { 747 ...dataObj 748 }; 749 if (!dataSend.args.hasOwnProperty('paged')) { 750 dataSend.args.paged = 1; 751 } 752 if (btnNumber.classList.contains('prev')) { 753 dataSend.args.paged--; 754 } else if (btnNumber.classList.contains('next')) { 755 dataSend.args.paged++; 756 } else { 757 const pagedNumber = parseInt(btnNumber.textContent); 758 if (isNaN(pagedNumber) || pagedNumber < 1) { 759 return; 760 } 761 dataSend.args.paged = pagedNumber; 762 } 763 elLPTarget.dataset.send = JSON.stringify(dataSend); 764 765 // Set url params to reload page. 766 if (!dataSend.args.hasOwnProperty('enableUpdateParamsUrl') || dataSend.args.enableUpdateParamsUrl) { 767 lpSettings.urlParams.paged = dataSend.args.paged; 768 window.history.pushState({}, '', lpAssetsJsPath_utils_js__WEBPACK_IMPORTED_MODULE_0__.lpAddQueryArgs(urlCurrent, lpSettings.urlParams)); 769 } 770 // End. 771 772 // Show loading 773 window.lpAJAXG.showHideLoading(elLPTarget, 1); 774 // End 775 776 // Scroll to archive element 777 if (!dataSend.args.hasOwnProperty('enableScrollToView') || dataSend.args.enableScrollToView) { 778 const elLPTargetY = elLPTarget.getBoundingClientRect().top + window.scrollY - 100; 779 window.scrollTo({ 780 top: elLPTargetY 781 }); 782 } 783 const callBack = { 784 success: response => { 785 //console.log( 'response', response ); 786 const { 787 status, 788 message, 789 data 790 } = response; 791 elLPTarget.innerHTML = data.content || ''; 792 }, 793 error: error => { 794 console.log(error); 795 }, 796 completed: () => { 797 //console.log( 'completed' ); 798 window.lpAJAXG.showHideLoading(elLPTarget, 0); 799 } 800 }; 801 window.lpAJAXG.fetchAJAX(dataSend, callBack); 802 }, 803 getDataSetCurrent: elLPTarget => { 804 return JSON.parse(elLPTarget.dataset.send); 805 }, 806 setDataSetCurrent: (elLPTarget, dataSend) => { 807 return elLPTarget.dataset.send = JSON.stringify(dataSend); 808 }, 809 showHideLoading: (elLPTarget, status) => { 810 const elLoading = elLPTarget.nextElementSibling?.querySelector('.lp-loading-change'); 811 if (elLoading) { 812 lpAssetsJsPath_utils_js__WEBPACK_IMPORTED_MODULE_0__.lpShowHideEl(elLoading, status); 813 } 814 } 815 }; 816}; 817window.lpAJAXG = lpAJAX(); 818window.lpAJAXG.getElements(); 819 820// Events 821document.addEventListener('click', function (e) { 822 const target = e.target; 823 window.lpAJAXG.clickNumberPage(e, target); 824}); 825 826// Listen element created 827lpAssetsJsPath_utils_js__WEBPACK_IMPORTED_MODULE_0__.listenElementCreated(node => { 828 if (node.classList.contains('lp-load-ajax-element')) { 829 //console.log( 'Element created', node ); 830 window.lpAJAXG.getElements(); 831 } 832}); 833 834// Listen element ready 835lpAssetsJsPath_utils_js__WEBPACK_IMPORTED_MODULE_0__.lpOnElementReady('.lp-load-ajax-element', element => { 836 //console.log( 'Element ready', element ); 837 window.lpAJAXG.getElements(); 838}); 839 840// Case 2: readystatechange, find all elements with the class '.lp-load-ajax-element' not have class 'loaded' 841document.addEventListener('readystatechange', event => { 842 //console.log( 'readystatechange' ); 843 window.lpAJAXG.getElements(); 844}); 845 846// Case 3: DOMContentLoaded, find all elements with the class '.lp-load-ajax-element' not have class 'loaded' 847document.addEventListener('DOMContentLoaded', () => { 848 //console.log( 'DOMContentLoaded' ); 849 window.lpAJAXG.getElements(); 850}); 851/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (lpAJAX); 852})(); 853 854/******/ })() 855; 856//# sourceMappingURL=loadAJAX.js.map
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.