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/******/ const __webpack_module_cache__ = {}; 508/******/ 509/******/ // The require function 510/******/ function __webpack_require__(moduleId) { 511/******/ // Check if module is in cache 512/******/ const 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/******/ const 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/******/ const 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/value functions for harmony exports 540/******/ __webpack_require__.d = (exports, definition) => { 541/******/ if(Array.isArray(definition)) { 542/******/ var i = 0; 543/******/ while(i < definition.length) { 544/******/ var key = definition[i++]; 545/******/ var binding = definition[i++]; 546/******/ if(!__webpack_require__.o(exports, key)) { 547/******/ if(binding === 0) { 548/******/ Object.defineProperty(exports, key, { enumerable: true, value: definition[i++] }); 549/******/ } else { 550/******/ Object.defineProperty(exports, key, { enumerable: true, get: binding }); 551/******/ } 552/******/ } else if(binding === 0) { i++; } 553/******/ } 554/******/ } else { 555/******/ for(var key in definition) { 556/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) { 557/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] }); 558/******/ } 559/******/ } 560/******/ } 561/******/ }; 562/******/ })(); 563/******/ 564/******/ /* webpack/runtime/hasOwnProperty shorthand */ 565/******/ (() => { 566/******/ __webpack_require__.o = (obj, prop) => (Object.hasOwn(obj, prop)) 567/******/ })(); 568/******/ 569/******/ /* webpack/runtime/make namespace object */ 570/******/ (() => { 571/******/ // define __esModule on exports 572/******/ __webpack_require__.r = (exports) => { 573/******/ if(Symbol.toStringTag) { 574/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); 575/******/ } 576/******/ Object.defineProperty(exports, '__esModule', { value: true }); 577/******/ }; 578/******/ })(); 579/******/ 580/************************************************************************/ 581let __webpack_exports__ = {}; 582// This entry needs to be wrapped in an IIFE because it needs to be isolated against other modules in the chunk. 583(() => { 584/*!***********************************!*\ 585 !*** ./assets/src/js/loadAJAX.js ***! 586 \***********************************/ 587__webpack_require__.r(__webpack_exports__); 588/* harmony export */ __webpack_require__.d(__webpack_exports__, { 589/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 590/* harmony export */ }); 591/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./utils.js */ "./assets/src/js/utils.js"); 592/** 593 * Load all you need via AJAX 594 * 595 * @since 4.2.5.7 596 * @version 1.1.0 597 */ 598 599 600 601// Handle general parameter in the Frontend and Backend 602let lpSettings = {}; 603if ('undefined' !== typeof lpDataAdmin) { 604 lpSettings = lpDataAdmin; 605} else if ('undefined' !== typeof lpData) { 606 lpSettings = lpData; 607} 608// End Handle general parameter in the Frontend and Backend 609 610const lpAJAX = () => { 611 const classLPTarget = '.lp-target';
612 const urlCurrent = (0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.lpGetCurrentURLNoParam)(); 613 return { 614 autoLoadAPIs: () => { 615 console.log('autoLoadAPIs'); 616 }, 617 fetchAPI: (url, params, callBack) => { 618 const option = { 619 headers: {} 620 }; 621 if (0 !== parseInt(lpSettings.user_id)) { 622 option.headers['X-WP-Nonce'] = lpSettings.nonce; 623 } 624 if ('undefined' !== typeof params.args.method_request) { 625 option.method = params.args.method_request; 626 } else { 627 option.method = 'POST'; 628 } 629 630 //params.args = { ...params.args, ...lpData.urlParams }; 631 632 if ('POST' === option.method) { 633 option.body = JSON.stringify(params); 634 option.headers['Content-Type'] = 'application/json'; 635 } else { 636 params.args = JSON.stringify(params.args); 637 params.callback = JSON.stringify(params.callback); 638 url = (0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.lpAddQueryArgs)(url, params); 639 } 640 ;(0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.lpFetchAPI)(url, option, callBack); 641 }, 642 fetchAJAX: (params, callBack) => { 643 let urlAjax = lpSettings.lpAjaxUrl; 644 645 // Set param id_url for identify. 646 if (params.hasOwnProperty('args') && params.args.hasOwnProperty('id_url')) { 647 urlAjax = (0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.lpAddQueryArgs)(urlAjax, { 648 id_url: params.args.id_url 649 }); 650 } else if (params.hasOwnProperty('id_url')) { 651 urlAjax = (0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.lpAddQueryArgs)(urlAjax, { 652 id_url: params.id_url 653 }); 654 } 655 // Set param lang here if exits, for detect translate 656 if (lpSettings.urlParams.hasOwnProperty('lang')) { 657 urlAjax = (0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.lpAddQueryArgs)(urlAjax, { 658 lang: lpSettings.urlParams.lang 659 }); 660 } 661 const formData = new FormData(); 662 const action = params.hasOwnProperty('action') ? params.action : 'load_content_via_ajax'; 663 formData.append('nonce', lpSettings.nonce); 664 formData.append('lp-load-ajax', action); 665 formData.append('data', JSON.stringify(params)); 666 const dataSend = { 667 method: 'POST', 668 headers: {}, 669 body: formData 670 }; 671 if (0 !== parseInt(lpSettings.user_id)) { 672 dataSend.headers['X-WP-Nonce'] = lpSettings.nonce; 673 } 674 ;(0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.lpFetchAPI)(urlAjax, dataSend, callBack); 675 }, 676 getElements: () => { 677 // Finds all elements with the class '.lp-load-ajax-element' 678 const elements = document.querySelectorAll('.lp-load-ajax-element:not(.loaded)'); 679 //console.log( 'getElements', elements ); 680 if (elements.length) { 681 elements.forEach(element => { 682 //console.log( 'Element handing', element ); 683 const elTarget = element.querySelector(`${classLPTarget}`); 684 if (!elTarget) { 685 return; 686 } 687 const dataObj = JSON.parse(elTarget.dataset.send); 688 const dataSend = { 689 ...dataObj 690 }; 691 const elLoadingFirst = element.querySelector('.loading-first'); 692 const callBack = { 693 success: response => { 694 const { 695 status, 696 message, 697 data 698 } = response; 699 if ('success' === status) { 700 elTarget.innerHTML = data.content; 701 } else if ('error' === status) { 702 elTarget.innerHTML = message; 703 } 704 }, 705 error: error => { 706 console.log(error); 707 }, 708 completed: () => { 709 if (typeof wp !== 'undefined' && wp.hooks) { 710 wp.hooks.doAction('lp-ajax-completed', element, dataSend); 711 } 712 window.lpAJAXG.getElements(); 713 //console.log( 'completed' ); 714 if (elLoadingFirst) { 715 elLoadingFirst.remove(); 716 } 717 } 718 }; 719 720 // Call via AJAX 721 window.lpAJAXG.fetchAJAX(dataSend, callBack); 722 element.classList.add('loaded'); 723 }); 724 } 725 }, 726 clickNumberPage: (e, target) => {
727 const btnNumber = target.closest('.page-numbers:not(.disabled)'); 728 if (!btnNumber) { 729 return; 730 } 731 732 // Check btnNumber is tag a 733 if (btnNumber.tagName.toLowerCase() !== 'a') { 734 return; 735 } 736 const elLPTarget = btnNumber.closest(`${classLPTarget}`); 737 if (!elLPTarget) { 738 return; 739 } 740 e.preventDefault(); 741 const dataObj = JSON.parse(elLPTarget.dataset.send); 742 const dataSend = { 743 ...dataObj 744 }; 745 if (!dataSend.args.hasOwnProperty('paged')) { 746 dataSend.args.paged = 1; 747 } 748 if (btnNumber.classList.contains('prev')) { 749 dataSend.args.paged--; 750 } else if (btnNumber.classList.contains('next')) { 751 dataSend.args.paged++; 752 } else { 753 const pagedNumber = parseInt(btnNumber.textContent); 754 if (isNaN(pagedNumber) || pagedNumber < 1) { 755 return; 756 } 757 dataSend.args.paged = pagedNumber; 758 } 759 elLPTarget.dataset.send = JSON.stringify(dataSend); 760 761 // Set url params to reload page. 762 if (!dataSend.args.hasOwnProperty('enableUpdateParamsUrl') || dataSend.args.enableUpdateParamsUrl) { 763 lpSettings.urlParams.paged = dataSend.args.paged; 764 window.history.pushState({}, '', (0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.lpAddQueryArgs)(urlCurrent, lpSettings.urlParams)); 765 } 766 // End. 767 768 // Show loading 769 window.lpAJAXG.showHideLoading(elLPTarget, 1); 770 // End 771 772 // Scroll to archive element 773 if (!dataSend.args.hasOwnProperty('enableScrollToView') || dataSend.args.enableScrollToView) { 774 const elLPTargetY = elLPTarget.getBoundingClientRect().top + window.scrollY - 100; 775 window.scrollTo({ 776 top: elLPTargetY 777 }); 778 } 779 const callBack = { 780 success: response => { 781 //console.log( 'response', response ); 782 const { 783 status, 784 message, 785 data 786 } = response; 787 elLPTarget.innerHTML = data.content || ''; 788 }, 789 error: error => { 790 console.log(error); 791 }, 792 completed: () => { 793 //console.log( 'completed' ); 794 window.lpAJAXG.showHideLoading(elLPTarget, 0); 795 } 796 }; 797 window.lpAJAXG.fetchAJAX(dataSend, callBack); 798 }, 799 getDataSetCurrent: elLPTarget => { 800 return JSON.parse(elLPTarget.dataset.send); 801 }, 802 setDataSetCurrent: (elLPTarget, dataSend) => { 803 return elLPTarget.dataset.send = JSON.stringify(dataSend); 804 }, 805 showHideLoading: (elLPTarget, status) => { 806 const elLoading = elLPTarget.nextElementSibling?.querySelector('.lp-loading-change'); 807 if (elLoading) { 808 (0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.lpShowHideEl)(elLoading, status); 809 } 810 } 811 }; 812}; 813window.lpAJAXG = lpAJAX(); 814window.lpAJAXG.getElements(); 815 816// Events 817document.addEventListener('click', function (e) { 818 const target = e.target; 819 window.lpAJAXG.clickNumberPage(e, target); 820}); 821 822// Listen element created 823(0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.listenElementCreated)(node => { 824 if (node.classList.contains('lp-load-ajax-element')) { 825 //console.log( 'Element created', node ); 826 window.lpAJAXG.getElements(); 827 } 828}); 829 830// Listen element ready 831(0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.lpOnElementReady)('.lp-load-ajax-element', element => { 832 //console.log( 'Element ready', element ); 833 window.lpAJAXG.getElements(); 834}); 835 836// Case 2: readystatechange, find all elements with the class '.lp-load-ajax-element' not have class 'loaded' 837document.addEventListener('readystatechange', event => { 838 //console.log( 'readystatechange' ); 839 window.lpAJAXG.getElements(); 840}); 841 842// Case 3: DOMContentLoaded, find all elements with the class '.lp-load-ajax-element' not have class 'loaded' 843document.addEventListener('DOMContentLoaded', () => { 844 //console.log( 'DOMContentLoaded' ); 845 window.lpAJAXG.getElements(); 846}); 847/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (lpAJAX); 848})(); 849 850/******/ })() 851; 852//# 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.