", {
id: "htmlContent",
class: "html-content"
}).html(htmlContent);
var articleTitle = title || $("#bdt-floating-help-center .searchbox__input").val();
$htmlContentElement.prepend($("
", {
id: "contentTitle",
class: "html-content__title"
}).html(articleTitle));
$htmlContentElement.find("a").not('.callout-block a').css({
"color": helpCenterConfig.linkColor
});
$htmlContentElement.insertBefore("#bdt-floating-help-center #listItemsContainer");
$('#floatingHelpCenterPopup').addClass('bdt-content-open');
anchorDataTitleHandler();
}
/**
* Shows no results message
*/
function renderNoResults() {
resetPreviousState();
var $noResultsLabel = $("
", {
id: "noResultTxt",
class: "no-result"
}).html(helpCenterConfig.noResultsLabel);
if ($("#noResultTxt").length === 0) {
$noResultsLabel.insertAfter("#bdt-floating-help-center .searchbox");
}
}
/**
* @param {Object} obj - Object where search has to be performed
* @param {string} key - Attribute Key
* @param {string} value - Value
* @param {boolean} performSearch - Search perform or finding value by key
* @returns {Object} obj - Result filtered object
*/
function findObject(obj, key, value, performSearch) {
value = performSearch === true ? value.toUpperCase() : value;
var results = [];
function recursiveSearch(obj) {
if (!obj || _typeof(obj) !== "object") {
return;
}
if (performSearch) {
if (obj[key] && obj[key].toUpperCase().indexOf(value) > -1) {
results.push(obj);
}
} else {
if (obj[key] === value) {
results.push(obj);
}
}
Object.keys(obj).forEach(function (k) {
recursiveSearch(obj[k]);
});
}
recursiveSearch(obj);
return results;
}
/**
* Helper function for old browsers
*/
function _typeof(obj) {
"@babel/helpers - typeof";
if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
_typeof = function _typeof(obj) {
return typeof obj;
};
} else {
_typeof = function _typeof(obj) {
return obj &&
typeof Symbol === "function" &&
obj.constructor === Symbol &&
obj !== Symbol.prototype ? "symbol" : typeof obj;
};
}
return _typeof(obj);
}
/**
* floating help center window object
* and public functions
*/
return window.floatingHelpCenter = {
init: function () {
$.fn.floatingHelpCenter();
},
toggle: function () {
togglePopup();
},
isOpen: function () {
return $("#bdt-floating-help-centerPopup").hasClass("floating-help-center__popup--active");
}
};
})(jQuery);
// Search icon svg
var searchSVG = '';
// Cross icon svg
var crossSVG = '';
// Resizer icon svg
var resizerSVG = '';
resizerSVG += '';
// back icon svg
var backSVG = '';
// list arrow svg
var listArrowSVG = '';
var externalArrowSVG = '';
floatingHelpCenter.init();
}
jQuery(window).on('elementor/frontend/init', function () {
elementorFrontend.hooks.addAction('frontend/element_ready/bdt-floating-knowledgebase.default', widgetFloatingKnowledgebase);
});
}(jQuery, window.elementorFrontend));
/**
* End Content Switcher widget script
*/
/**
* Start twitter carousel widget script
*/
(function ($, elementor) {
'use strict';
var widgetFbFeedCarousel = function ($scope, $) {
var $fbCarousel = $scope.find('.bdt-facebook-feed-carousel');
if (!$fbCarousel.length) {
return;
}
var $fbCarouselContainer = $fbCarousel.find('.swiper-carousel'),
$settings = $fbCarousel.data('settings');
const Swiper = elementorFrontend.utils.swiper;
initSwiper();
async function initSwiper() {
var swiper = await new Swiper($fbCarouselContainer, $settings); // this is an example
if ($settings.pauseOnHover) {
$($fbCarouselContainer).hover(function () {
(this).swiper.autoplay.stop();
}, function () {
(this).swiper.autoplay.start();
});
}
};
};
jQuery(window).on('elementor/frontend/init', function () {
elementorFrontend.hooks.addAction('frontend/element_ready/bdt-facebook-feed-carousel.default', widgetFbFeedCarousel);
});
}(jQuery, window.elementorFrontend));
/**
* End twitter carousel widget script
*/
;(function ($, elementor) {
$(window).on('elementor/frontend/init', function () {
var ModuleHandler = elementorModules.frontend.handlers.Base;
var BackgroundImageParallaxHandler = ModuleHandler.extend({
bindEvents: function () {
this.run();
},
getDefaultSettings: function () {
return {
orientation: 'left', // Default orientation
};
},
onElementChange: debounce(function (prop) {
if (prop.indexOf('ep_background_image_parallax_') !== -1) {
this.run();
}
}, 400),
settings: function (key) {
return this.getElementSettings('ep_background_image_parallax_' + key);
},
run: function () {
var options = this.getDefaultSettings();
var widgetID = this.$element.data('id');
var images = document.querySelectorAll('.elementor-element-' + widgetID + '.bdt-background-image-parallax-yes img');
// Update options if settings exist
if (this.settings('orientation')) {
options.orientation = this.settings('orientation');
}
//scale
if (this.settings('scale.size')) {
options.scale = this.settings('scale.size');
}
if (this.settings('delay.size')) {
options.delay = this.settings('delay.size');
}
//transition
// if (this.settings('transition')) {
// options.transition = this.settings('transition') || 'cubic-bezier(0,0,0,1)';
// }
//max_transition
// if (this.settings('max_transition')) {
// options.maxTransition = this.settings('max_transition') || 0;
// }
//overflow
if (this.settings('overflow') === 'yes') {
options.overflow = true;
} else {
options.overflow = false;
}
// Apply SimpleParallax to images
if (images.length) {
new SimpleParallax(images, options);
}
},
});
// Add the handler to Elementor widgets
elementorFrontend.hooks.addAction('frontend/element_ready/widget', function ($scope) {
elementorFrontend.elementsHandler.addHandler(BackgroundImageParallaxHandler, {
$element: $scope,
});
});
});
})(jQuery, window.elementorFrontend);
/**
* Shape Builder with GSAP Animation Integration
*
* This module handles the Shape Builder feature with advanced GSAP animations.
*
* Features:
* - Automatic shape positioning within wrappers
* - GSAP-powered animations with multiple trigger types
* - Support for 18 different animation effects
* - Configurable duration, delay, easing, repeat, and yoyo options
*
* Animation Trigger Types:
* - on-load: Animation plays when the page loads
* - on-hover: Animation plays on mouse hover
*
* Available Animations:
* - Fade: fade-in, fade-in-up, fade-in-down, fade-in-left, fade-in-right
* - Zoom: zoom-in, zoom-out
* - Rotate: rotate-in, flip-x, flip-y
* - Motion: bounce, pulse, swing, shake
* - Slide: slide-in-left, slide-in-right, slide-in-up, slide-in-down
*/
jQuery(window).on('elementor/frontend/init', () => {
// Animation presets - centralized configuration
const ANIMATION_PRESETS = {
'fade-in': { opacity: 0 },
'fade-in-up': { opacity: 0, y: 50 },
'fade-in-down': { opacity: 0, y: -50 },
'fade-in-left': { opacity: 0, x: -50 },
'fade-in-right': { opacity: 0, x: 50 },
'zoom-in': { scale: 0 },
'zoom-out': { scale: 2 },
'rotate-in': { rotation: -360 },
'flip-x': { rotationX: 180 },
'flip-y': { rotationY: 180 },
'bounce': { y: -30 },
'pulse': { scale: 0.9 },
'swing': { rotation: 15 },
'shake': { x: -10 },
'slide-in-left': { x: -100 },
'slide-in-right': { x: 100 },
'slide-in-up': { y: 100 },
'slide-in-down': { y: -100 }
};
const MOTION_ANIMATIONS = ['bounce', 'pulse', 'swing', 'shake'];
// Get animation properties from preset
const getAnimationProps = (name) => ANIMATION_PRESETS[name] || { opacity: 0 };
// Build target properties for animation
const buildTargetProps = (fromProps, options = {}) => {
const toProps = {
...options,
transformOrigin: 'center center'
};
// Reset animated properties to their default values
if ('opacity' in fromProps) toProps.opacity = 1;
if ('x' in fromProps) toProps.x = 0;
if ('y' in fromProps) toProps.y = 0;
if ('scale' in fromProps) toProps.scale = 1;
if ('rotation' in fromProps) toProps.rotation = 0;
if ('rotationX' in fromProps) toProps.rotationX = 0;
if ('rotationY' in fromProps) toProps.rotationY = 0;
return toProps;
};
const applyShapeToWrapper = () => {
const shapes = document.querySelectorAll('.bdt-shape-builder');
shapes.forEach(el => {
const wrapperClass = el.dataset.wrapperId;
if (!wrapperClass) return;
const wrapper = document.querySelector(`.${wrapperClass}`);
if (wrapper) {
wrapper.appendChild(el);
}
});
};
// Handle on-load animations with Intersection Observer
const initOnLoadAnimations = () => {
const shapes = document.querySelectorAll('.bdt-shape-builder[data-animation-enabled="true"][data-animation-trigger="on-load"]');
shapes.forEach(el => {
const animationName = el.dataset.animationName;
const duration = parseFloat(el.dataset.animationDuration) || 1;
const delay = parseFloat(el.dataset.animationDelay) || 0;
const easing = el.dataset.animationEasing || 'none';
const repeat = parseInt(el.dataset.animationRepeat) || 0;
const yoyo = el.dataset.animationYoyo;
const viewport = parseFloat(el.dataset.animationViewport) || 0.1;
const fromProps = getAnimationProps(animationName);
const toProps = buildTargetProps(fromProps, { duration, delay, ease: easing, repeat, yoyo });
// Set initial state immediately to prevent flash/jump
gsap.set(el, {
...fromProps,
transformOrigin: 'center center'
});
// Create Intersection Observer for viewport triggering
const observer = new IntersectionObserver((entries) => {
entries.forEach(entry => {
if (entry.isIntersecting) {
gsap.to(el, toProps);
observer.unobserve(el);
}
});
}, {
threshold: viewport,
rootMargin: '0px'
});
observer.observe(el);
});
};
// Handle on-hover animations
const initOnHoverAnimations = () => {
const elements = document.querySelectorAll('.elementor-element[data-settings]');
elements.forEach(parentEl => {
const settingsAttr = parentEl.getAttribute('data-settings');
if (!settingsAttr) return;
let settings;
try {
const decodedSettings = jQuery('').html(settingsAttr).text();
settings = JSON.parse(decodedSettings);
} catch (e) {
return;
}
// Validate shape builder settings
if (!settings.bdt_shape_builder_list || !Array.isArray(settings.bdt_shape_builder_list)) {
return;
}
const hoverShapes = settings.bdt_shape_builder_list.filter(shape =>
shape.shape_builder_animation_popover === 'yes' && shape.animation_trigger_type === 'on-hover'
);
if (hoverShapes.length === 0) return;
const timelines = [];
hoverShapes.forEach(shapeSettings => {
const shapeId = shapeSettings._id;
const shapeEl = parentEl.querySelector(`.bdt-shape-builder.elementor-repeater-item-${shapeId}`);
if (!shapeEl) return;
const animationName = shapeSettings.animation_name || 'fade-in';
const duration = shapeSettings.animation_duration?.size
? parseFloat(shapeSettings.animation_duration.size)
: 1;
const easing = shapeSettings.animation_easing || 'none';
const fromProps = getAnimationProps(animationName);
// Set initial visible state
gsap.set(shapeEl, { opacity: 1 });
// Create paused timeline
const tl = gsap.timeline({ paused: true });
if (MOTION_ANIMATIONS.includes(animationName)) {
// For motion animations - yoyo effect
tl.to(shapeEl, {
...fromProps,
duration: duration / 2,
ease: easing,
yoyo: true,
repeat: 1
});
} else {
// For transition animations
tl.to(shapeEl, {
...fromProps,
duration: duration,
ease: easing
});
}
timelines.push(tl);
});
// Attach hover event listeners
if (timelines.length > 0) {
parentEl.addEventListener('mouseenter', () => {
timelines.forEach(tl => tl.restart());
});
parentEl.addEventListener('mouseleave', () => {
timelines.forEach(tl => tl.reverse());
});
}
});
};
// Initialize animations
const initShapeAnimations = () => {
initOnLoadAnimations();
initOnHoverAnimations();
};
// Initialize shapes and animations
const initShapeBuilder = () => {
applyShapeToWrapper();
initShapeAnimations();
};
// Elementor element hooks - Container, Section, Column, Inner Section
const elementTypes = ['container', 'section', 'column', 'inner-section'];
elementTypes.forEach(type => {
elementorFrontend.hooks.addAction(`frontend/element_ready/${type}`, initShapeBuilder);
});
// Also run once when the page is fully loaded
jQuery(window).on('load', initShapeBuilder);
});