Your IP : 10.10.0.253
<?php
/**
* @package SP Page Builder
* @author JoomShaper http://www.joomshaper.com
* @copyright Copyright (c) 2010 - 2025 JoomShaper
* @license http://www.gnu.org/licenses/gpl-2.0.html GNU/GPLv2 or later
*/
//no direct access
defined('_JEXEC') or die('Restricted access');
use Joomla\CMS\Component\ComponentHelper;
use Joomla\CMS\Factory;
use Joomla\CMS\Filesystem\Folder;
use Joomla\CMS\Filesystem\Path;
use Joomla\CMS\HTML\HTMLHelper;
use Joomla\CMS\Plugin\PluginHelper;
use Joomla\CMS\Uri\Uri;
require_once JPATH_ROOT . '/components/com_sppagebuilder/builder/classes/base.php';
class SppagebuilderHelperSite
{
/**
* Addon structures
*
* @var array
*/
private static $addonFieldStructures = [];
/**
* Column settings structure
*
* @var array
*/
private static $columnFieldStructures = [];
/**
* Section/row settings structure
*
* @var array
*/
private static $sectionFieldStructures = [];
/**
* Section field types
*
* @var array
*/
private static $sectionFieldTypes = [];
/**
* Column field types
*
* @var array
*/
private static $columnFieldTypes = [];
/**
* The fields types
*
* @var array
*/
private static $addonFieldTypes = [];
/**
* Check if the data come from the version 3 or bellow.
*
* @var boolean
*/
private static $isLegacyData = false;
private static function getAddonGlobalFieldStructures()
{
$structures = [];
$globalSettings = SpPgaeBuilderBase::addonOptions();
foreach ($globalSettings as $setting) {
$structures = array_merge($structures, $setting);
}
return $structures;
}
/**
* Load the addon structure from the admin.php files.
*
* @return void
*/
private static function prepareAddonFieldStructures()
{
self::loadLanguage();
SpPgaeBuilderBase::loadAddons();
$addons = SpAddonsConfig::$addons;
$globalStructures = self::getAddonGlobalFieldStructures();
foreach ($addons as &$addon) {
$addon = AddonsHelper::modernizeAddonStructure($addon);
$addon['addon_name'] = preg_replace('/^sp_/i', '', $addon['addon_name']);
$addon['settings'] = array_merge($addon['settings'], $globalStructures);
}
unset($addon);
self::$addonFieldStructures = $addons;
}
private static function prepareSectionFieldStructures()
{
$sectionSettings = SpPgaeBuilderBase::getRowGlobalSettings();
foreach ($sectionSettings as $setting) {
self::$sectionFieldStructures = array_merge(self::$sectionFieldStructures, $setting);
}
}
private static function prepareColumnFieldStructures()
{
$columnSettings = SpPgaeBuilderBase::getColumnGlobalSettings();
foreach ($columnSettings as $setting) {
self::$columnFieldStructures = array_merge(self::$columnFieldStructures, $setting);
}
}
/**
* Predict the column's fill style if it is fit in a single line
* or multiple line.
*
* @param array $columns The columns array.
*
* @return stdClass The fit value after prediction.
* @since 4.0.0
*/
private static function predictColumnFillStyle(array $columns): stdClass
{
$fitObject = (object) ['xl' => false, 'lg' => false, 'md' => false, 'sm' => false, 'xs' => false];
foreach (['xl', 'lg', 'md', 'sm', 'xs'] as $key) {
$total = 0;
foreach ($columns as $column) {
$width = self::getColumnWidth($column);
$total += (float) $width->$key;
}
if ($total <= 100) {
$fitObject->$key = true;
}
}
return $fitObject;
}
/**
* Generate the column widths from the columns class_name property.
*
* @param stdClass $column The column object.
*
* @return stdClass The generated width object for multiple device.
* @since 4.0.0
*/
public static function getColumnWidth(stdClass $column): stdClass
{
$width = (object) ['xl' => '100%', 'lg' => '100%', 'md' => '100%', 'sm' => '100%', 'xs' => '100%'];
$size = (int) \substr($column->class_name, 7);
$value = self::calculateColumnPercent($size);
$width->xl = $value;
if (!empty($column->class_name) && empty($column->settings->sm_col)) {
$width->lg = $value;
}
if (!empty($column->settings->sm_col)) {
$smSize = (int) \substr($column->settings->sm_col, 7);
$width->lg = self::calculateColumnPercent($smSize);
$width->md = self::calculateColumnPercent($smSize);
}
if (!empty($column->settings->xs_col)) {
$xsSize = (int) \substr($column->settings->xs_col, 7);
$width->sm = self::calculateColumnPercent($xsSize);
$width->xs = self::calculateColumnPercent($xsSize);
}
return $width;
}
private static function isValidWidthValue($width)
{
return preg_match("@^\d+(\.\d+)?%$@", $width);
}
public static function purifyColumnWidth($width)
{
$defaultDevice = SpPgaeBuilderBase::$defaultDevice;
$smallDevices = ['sm', 'xs'];
if (\is_object($width)) {
$deviceData = $width->$defaultDevice;
foreach ($width as $device => $value) {
if (!self::isValidWidthValue($value)) {
if (\in_array($device, $smallDevices)) {
$width->$device = '100%';
} else {
$width->$device = !empty($deviceData) ? $deviceData : '100%';
}
}
}
}
return $width;
}
/**
* Calculate the column percentage from the column size.
*
* @param int $size The size value ranged from 1 to 12.
*
* @return string The percentage value w.r.t the the size.
* @since 4.0.0
*/
private static function calculateColumnPercent(int $size): string
{
return ((100 / 12) * (int) $size) . '%';
}
// Generate unique id
public static function nanoid(int $size = 21): string
{
$urlAlphabet = "ModuleSymbhasOwnPr-0123456789ABCDEFGHNRVfgctiUvz_KqYTJkLxpZXIjQW";
$id = "";
$i = $size;
while ($i--) {
$id .= $urlAlphabet[rand(0, 63) | 0];
}
return $id;
}
// Generate unique id
public static function numberNanoid(int $size = 21): string
{
$urlAlphabet = "0123456789";
$id = "";
$i = $size;
while ($i--) {
$id .= $urlAlphabet[rand(0, 9) | 0];
}
return intval($id);
}
private static function parseRow(array &$rows, \stdClass &$row)
{
if (isset($row->settings)) {
$row->settings = self::shiftResponsiveSettings($row->settings);
}
if (!empty($row->columns)) {
if (!isset($row->settings->fit_columns)) {
$row->settings->fit_columns = self::predictColumnFillStyle($row->columns);
}
foreach ($row->columns as $i => &$column) {
/** Predict the width from the column class name for the old layouts. */
if (!isset($column->width)) {
$width = self::getColumnWidth($column);
$column->width = $width;
}
if (\is_array($column->settings)) {
$column->settings = (object) $column->settings;
}
if (!isset($column->settings->width)) {
$width = !empty($column->width) ? $column->width : self::getColumnWidth($column);
$column->settings->width = $width;
if (isset($column->settings->width->unit)) {
unset($column->settings->width->unit);
}
}
$column->settings->width = self::purifyColumnWidth($column->settings->width);
if (isset($column->settings)) {
$column
->settings = self::shiftResponsiveSettings($column->settings);
}
if (!empty($column->addons)) {
foreach ($column->addons as $j => &$addon) {
if (isset($addon->settings)) {
$addon->settings = self::shiftResponsiveSettings($addon->settings);
}
// migrate image layouts addon
if (isset($addon->name) && $addon->name === 'image_layouts') {
$addonSettings = $addon->settings;
$isBtnUrlExist = property_exists($addonSettings, 'btn_url');
$isButtonUrlExist = property_exists($addonSettings, 'button_url');
$isBtnTargetExist = property_exists($addonSettings, 'btn_target');
if (!$isButtonUrlExist && $isBtnUrlExist) {
$addonSettings->button_url = [
'type' => 'url',
'url' => $addonSettings->btn_url,
'new_tab' => $isBtnTargetExist ? $addonSettings->btn_target : false,
];
}
$isBtnTextExist = property_exists($addonSettings, 'btn_text');
$isButtonTextExist = property_exists($addonSettings, 'button_text');
if (!$isButtonTextExist && $isBtnTextExist) {
$addonSettings->button_text = $addonSettings->btn_text;
}
$isBtnTypeExist = property_exists($addonSettings, 'btn_type');
$isButtonTypeExist = property_exists($addonSettings, 'button_type');
if (!$isButtonTypeExist && $isBtnTypeExist) {
$addonSettings->button_type = $addonSettings->btn_type;
}
$isBtnShapeExist = property_exists($addonSettings, 'btn_shape');
$isButtonShapeExist = property_exists($addonSettings, 'button_shape');
if (!$isButtonShapeExist && $isBtnShapeExist) {
$addonSettings->button_shape = $addonSettings->btn_shape;
}
$isBtnSizeExist = property_exists($addonSettings, 'btn_size');
$isButtonSizeExist = property_exists($addonSettings, 'button_size');
if (!$isButtonSizeExist && $isBtnSizeExist) {
$addonSettings->button_size = $addonSettings->btn_size;
}
$isBtnColorExist = property_exists($addonSettings, 'btn_color');
$isButtonColorExist = property_exists($addonSettings, 'button_color');
if (!$isButtonColorExist && $isBtnColorExist) {
$addonSettings->button_color = $addonSettings->btn_color;
}
$isBtnColorHoverExist = property_exists($addonSettings, 'btn_color_hover');
$isButtonColorHoverExist = property_exists($addonSettings, 'button_color_hover');
if (!$isButtonColorHoverExist && $isBtnColorHoverExist) {
$addonSettings->button_color_hover = $addonSettings->btn_color_hover;
}
$isBtnAppearanceExist = property_exists($addonSettings, 'btn_appearance');
$isButtonAppearanceExist = property_exists($addonSettings, 'button_appearance');
if (!$isButtonAppearanceExist && $isBtnAppearanceExist) {
$addonSettings->button_appearance = $addonSettings->btn_appearance;
}
$isBtnBackgroundColorExist = property_exists($addonSettings, 'btn_background_color');
$isButtonBackgroundColorExist = property_exists($addonSettings, 'button_background_color');
if (!$isButtonBackgroundColorExist && $isBtnBackgroundColorExist) {
$addonSettings->button_background_color = $addonSettings->btn_background_color;
}
$isBtnBackgroundColorHoverExist = property_exists($addonSettings, 'btn_background_color_hover');
$isButtonBackgroundColorHoverExist = property_exists($addonSettings, 'button_background_color_hover');
if (!$isButtonBackgroundColorHoverExist && $isBtnBackgroundColorHoverExist) {
$addonSettings->button_background_color_hover = $addonSettings->btn_background_color_hover;
}
$isBtnBackgroundGradientExist = property_exists($addonSettings, 'btn_background_gradient');
$isButtonBackgroundGradientExist = property_exists($addonSettings, 'button_background_gradient');
if (!$isButtonBackgroundGradientExist && $isBtnBackgroundGradientExist) {
$addonSettings->button_background_gradient = $addonSettings->btn_background_gradient;
}
$isBtnBackgroundGradientHoverExist = property_exists($addonSettings, 'btn_background_gradient_hover');
$isButtonBackgroundGradientHoverExist = property_exists($addonSettings, 'button_background_gradient_hover');
if (!$isButtonBackgroundGradientHoverExist && $isBtnBackgroundGradientHoverExist) {
$addonSettings->button_background_gradient_hover = $addonSettings->btn_background_gradient_hover;
}
}
/** Migrate the slideshow items. */
if (isset($addon->name) && $addon->name === 'js_slideshow') {
if (!empty($addon->settings->slideshow_items)) {
foreach ($addon->settings->slideshow_items as $x => &$slideshowItem) {
if (isset($slideshowItem->slider_overlay_options) && $slideshowItem->slider_overlay_options === 'gradient_overaly') {
$slideshowItem->slider_overlay_options = 'gradient_overlay';
}
if (isset($slideshowItem->slider_bg_gradient_overlay) && !isset($slideshowItem->slider_bg_gradient_overlay->type)) {
$slideshowItem->slider_bg_gradient_overlay->type = 'linear';
}
$slideshowItem = self::shiftResponsiveSettings($slideshowItem);
if (!empty($slideshowItem->slideshow_inner_items)) {
foreach ($slideshowItem->slideshow_inner_items as $y => &$innerItem) {
$innerItem = self::shiftResponsiveSettings($innerItem);
}
unset($innerItem);
}
}
unset($slideshowItem);
}
}
/** Migrate the responsive settings for the repeatable items. */
if (isset($addon->name) && \in_array($addon->name, ['accordion', 'tab'])) {
$repeatableKey = 'sp_' . $addon->name . '_item';
if (!empty($addon->settings->$repeatableKey)) {
foreach ($addon->settings->$repeatableKey as &$itemSetting) {
$itemSetting = self::shiftResponsiveSettings($itemSetting);
}
unset($itemSetting);
}
}
if (isset($addon->name) && \in_array($addon->name, ['accordion', 'tab'])) {
list($outerRows, $_addon) = self::migrateDeepAddon($addon, 'sp_' . $addon->name . '_item', $row, $column);
$addon = $_addon;
array_push($rows, ...$outerRows);
}
if (isset($addon->name) && $addon->name === 'table_advanced') {
$nodeId = self::generateUUID();
if (isset($addon->settings->sp_table_advanced_item)) {
foreach ($addon->settings->sp_table_advanced_item as $th => $thead) {
if (isset($thead->content) && !\is_array($thead->content)) {
$thead = ['id' => $nodeId++, 'name' => 'text_block', 'visibility' => true, 'reference_id' => $addon->id, 'settings' => ['text' => $thead->content]];
$thead = \json_decode(\json_encode($thead));
$addon
->settings
->sp_table_advanced_item[$th]
->content = [];
$addon
->settings
->sp_table_advanced_item[$th]
->content[] = $thead;
} elseif (isset($thead->content) && \is_array($thead->content)) {
$contents = [];
foreach ($thead->content as $content) {
$content->reference_id = $addon->id;
$contents[] = $content;
}
$addon
->settings
->sp_table_advanced_item[$th]
->content = $contents;
}
}
}
foreach ($addon->settings->table_advanced_item as $r => $tRow) {
if (isset($tRow->table_advanced_item)) {
foreach ($tRow->table_advanced_item as $c => $tCell) {
if (isset($tCell->content) && !\is_array($tCell->content)) {
$td = ['id' => $nodeId++, 'name' => 'text_block', 'visibility' => true, 'reference_id' => $addon->id, 'settings' => ['text' => $tCell->content]];
$td = \json_decode(\json_encode($td));
$addon
->settings
->table_advanced_item[$r]
->table_advanced_item[$c]
->content = [];
$addon
->settings
->table_advanced_item[$r]
->table_advanced_item[$c]
->content[] = $td;
} elseif (isset($tCell->content) && \is_array($tCell->content)) {
$contents = [];
foreach ($tCell->content as &$content) {
$content->reference_id = $addon->id;
$contents[] = $content;
}
$addon
->settings
->table_advanced_item[$r]
->table_advanced_item[$c]
->content = $contents;
unset($content);
}
}
}
}
}
if (isset($addon->type) && $addon->type === 'inner_row') {
$addon->id = self::nanoid();
$nestedRowAddon = new \stdClass;
$nestedRowAddon->type = 'nested_row';
$nestedRowAddon->name = 'row';
$nestedRowAddon->id = $addon->id;
$addon->parent = new \stdClass;
$addon->parent->rowId = $row->id;
$addon->parent->columnId = $column->id;
$rows[] = $addon;
$addon = $nestedRowAddon;
}
}
unset($addon);
}
}
unset($column);
}
}
/**
* sanitize import json for making the old data valid for the data structure.
*
* @param string $text The json text of the page builder data.
*
* @return string The sanitized text.
*
* @since 4.0.0
*/
public static function sanitizeImportJSON(string $text): string
{
$rows = json_decode($text);
if (is_string($rows)) {
$rows = json_decode($rows);
}
if (!empty($rows)) {
foreach ($rows as $key => &$row) {
self::parseRow($rows, $row);
}
unset($row);
} else {
return $text;
}
return json_encode($rows);
}
private static $defaultValueWithUnit = ['value' => '', 'unit' => 'px'];
private static function getDefaultTypographyData()
{
$deviceData = [
'xl' => self::$defaultValueWithUnit,
'lg' => self::$defaultValueWithUnit,
'md' => self::$defaultValueWithUnit,
'sm' => self::$defaultValueWithUnit,
'xs' => self::$defaultValueWithUnit,
];
return (object) [
'font' => '',
'size' => $deviceData,
'line_height' => $deviceData,
'letter_spacing' => $deviceData,
'uppercase' => false,
'italic' => false,
'underline' => false,
'weight' => '',
'type' => 'google',
];
}
private static function isUnitValue($data)
{
return isset($data->value) && isset($data->unit);
}
private static function handleDeviceValues($data, $fieldKey)
{
$deviceData = [
'xl' => self::$defaultValueWithUnit,
'lg' => self::$defaultValueWithUnit,
'md' => self::$defaultValueWithUnit,
'sm' => self::$defaultValueWithUnit,
'xs' => self::$defaultValueWithUnit,
];
$responsiveKeys = ['size', 'line_height', 'letter_spacing'];
$pattern = "@px|rem|em|%@i";
if (in_array($fieldKey, $responsiveKeys)) {
if (\is_object($data)) {
$finalValue = self::$defaultValueWithUnit;
foreach ($data as $device => $value) {
if (self::isUnitValue($value)) {
$finalValue = (array) $value;
$finalValue['value'] = preg_match($pattern, $finalValue['value']) ? (float) $finalValue['value'] : $finalValue['value'];
$finalValue['value'] = (string) $finalValue['value'];
} else {
$finalValue['value'] = $value ?? '';
$finalValue['value'] = preg_match($pattern, $finalValue['value']) ? (float) $finalValue['value'] : $finalValue['value'];
$finalValue['value'] = (string) $finalValue['value'];
}
$deviceData[$device] = $finalValue;
}
} else {
$deviceData['xl']['value'] = preg_match($pattern, $data) ? (float) $data : $data;
$deviceData['xl']['value'] = (string) $deviceData['xl']['value'];
}
if (!empty($deviceData['md']['value']) && empty($deviceData['xl']['value'])) {
$deviceData['xl'] = $deviceData['md'];
}
return (object) $deviceData;
}
return $data;
}
private static function getFieldsWithFallbacks($settings)
{
$fieldArray = [];
if (empty($settings)) {
return $fieldArray;
}
foreach ($settings as $setting) {
if (!empty($setting['fields'])) {
foreach ($setting['fields'] as $fieldName => &$field) {
if (isset($field['type']) && $field['type'] === 'repeatable' && !empty($field['attr'])) {
$field['attr'] = self::getFieldsWithFallbacks($field['attr'] ?? []);
if (!empty($field['attr'])) {
$fieldArray[$fieldName] = $field;
}
}
if (!empty($field['fallbacks'])) {
$fieldArray[$fieldName] = $field;
}
}
unset($field);
}
}
return $fieldArray;
}
private static function getFieldStructureForTypography()
{
$fallbackFields = [];
foreach (self::$addonFieldStructures as &$addon) {
$addonName = $addon['addon_name'];
$fallbackFields[$addonName] = self::getFieldsWithFallbacks($addon['settings'] ?? []);
}
unset($addon);
return $fallbackFields;
}
private static function retrieveFieldTypesFromSettings($settings)
{
$types = [];
foreach ($settings as $group) {
if (!empty($group['fields'])) {
foreach ($group['fields'] as $key => $field) {
$fieldtype = $field['type'] ?? '';
if ($fieldtype === 'repeatable') {
$types[$key] = [
'type' => 'repeatable',
'fields' => self::retrieveFieldTypesFromSettings($field['attr']),
];
} else {
$types[$key] = $fieldtype;
}
}
}
}
return $types;
}
private static function processFieldTypes($type)
{
switch ($type) {
case 'section':
self::$sectionFieldTypes = self::retrieveFieldTypesFromSettings(self::$sectionFieldStructures);
break;
case 'column':
self::$columnFieldTypes = self::retrieveFieldTypesFromSettings(self::$columnFieldStructures);
break;
case 'addon':
foreach (self::$addonFieldStructures as $addon) {
$addonName = $addon['addon_name'];
$addonFieldTypes[$addonName] = self::retrieveFieldTypesFromSettings($addon['settings']);
}
self::$addonFieldTypes = $addonFieldTypes;
break;
}
}
private static function parseResponsiveTypography($data)
{
if (!is_object($data)) {
return $data;
}
$keys = ['letter_spacing', 'size', 'line_height'];
foreach ($keys as $key) {
$typographyItem = $data->$key ?? null;
if (!$typographyItem) {
continue;
}
if (!empty($typographyItem->md->value) && empty($typographyItem->xl->value)) {
$data->$key->xl = clone $typographyItem->md;
}
}
return $data;
}
private static function getFallbackValues($settings, string $fieldName, $field)
{
$fallbacks = $field['fallbacks'] ?? [];
if (!isset($settings->$fieldName)) {
$settings->$fieldName = new stdClass;
$isTypographyField = isset($field['type']) && $field['type'] === 'typography';
if ($isTypographyField) {
$settings->$fieldName = self::getDefaultTypographyData();
}
foreach ($fallbacks as $fieldKey => $referenceKey) {
$fallbackParts = explode('.', $referenceKey, 2);
$masterKey = $fallbackParts[0] ?? null;
$slaveKey = $fallbackParts[1] ?? null;
if (!empty($masterKey) && !empty($slaveKey)) {
$fallbackValue = isset($settings->$masterKey->$slaveKey) ? $settings->$masterKey->$slaveKey : '';
} elseif (!empty($masterKey) && empty($slaveKey)) {
$fallbackValue = isset($settings->$masterKey) ? $settings->$masterKey : '';
}
if ($isTypographyField) {
$settings->$fieldName->$fieldKey = self::handleDeviceValues($fallbackValue, $fieldKey);
} else {
$settings->$fieldName->$fieldKey = $fallbackValue;
}
}
} else {
$settings->$fieldName = self::parseResponsiveTypography($settings->$fieldName);
}
return $settings;
}
/**
* Read the fallback values of the typography fields.
*
* @param stdClass $settings
* @param string $addonName
*
* @return stdClass The modified settings value.
* @since 5.0.0
*/
private static function getTypographyFromFallbacks($settings, $addonName)
{
$fieldStructures = self::getFieldStructureForTypography();
$fieldStructureByAddon = $fieldStructures[$addonName] ?? null;
if (empty($fieldStructureByAddon)) {
return $settings;
}
foreach ($settings as $key => &$setting) {
$field = !empty($fieldStructureByAddon[$key]) ? $fieldStructureByAddon[$key] : [];
if (!empty($field['type']) && $field['type'] === 'repeatable' && !empty($field['attr'])) {
$attributes = $field['attr'];
foreach ($attributes as $fieldName => $attribute) {
$fallbacks = $attribute['fallbacks'] ?? [];
if (is_array($setting) && !empty($setting)) {
foreach ($setting as &$value) {
$value = self::getFallbackValues($value, $fieldName, $attribute);
}
unset($value);
}
}
}
}
unset($setting);
foreach ($fieldStructureByAddon as $fieldName => $field) {
$fallbacks = $field['fallbacks'] ?? [];
if (!empty($fallbacks)) {
$settings = self::getFallbackValues($settings, $fieldName, $field);
}
}
return $settings;
}
private static function reshapeSpacingValues($spacing, $forceModern = false)
{
$isLegacy = self::$isLegacyData && !$forceModern;
$reshapedValue = $isLegacy ? ['', '', '', ''] : ['0px', '0px', '0px', '0px'];
$spacing = \ctype_space((string) $spacing) || $spacing === '' ? [] : explode(' ', $spacing);
$spacing = array_map(function ($value) use ($isLegacy) {
if (!$isLegacy && $value === '') {
return '0px';
}
return $value;
}, $spacing);
$spacing = array_filter($spacing, function ($value) {
return isset($value) && $value !== '';
});
$spacing = array_values($spacing);
$newSpacing = [];
switch (count($spacing)) {
case 0:
$newSpacing = [''];
break;
case 1:
$newSpacing = $isLegacy
? array_fill(0, 4, $spacing[0])
: array_replace($reshapedValue, $spacing);
break;
case 2:
$newSpacing = $isLegacy
? [$spacing[0], $spacing[1], $spacing[0], $spacing[1]]
: array_replace($reshapedValue, $spacing);
break;
case 3:
$newSpacing = $isLegacy
? [$spacing[0], $spacing[1], $spacing[2], $spacing[1]]
: array_replace($reshapedValue, $spacing);
break;
case 4:
$newSpacing = $spacing;
break;
}
return implode(" ", $newSpacing);
}
private static function transformSpacingValues($value, $forceModern = false)
{
if (self::hasMultiDeviceSettings($value)) {
foreach ($value as $device => $deviceData) {
$value->$device = !empty($deviceData) ? self::reshapeSpacingValues($deviceData, $forceModern) : $deviceData;
}
} elseif (is_string($value)) {
$value = self::reshapeSpacingValues($value, $forceModern);
}
return $value;
}
private static function traverseSettingsToFixSpacingAnomalies($settings, $fieldTypes, $forceModern = false)
{
if ($fieldTypes === null) {
return $settings;
}
if (!empty($settings)) {
foreach ($settings as $key => &$value) {
$fieldType = $fieldTypes[$key] ?? null;
if ($fieldType === null || (is_string($fieldType) && !in_array($fieldType, ['padding', 'margin']))) {
continue;
}
if (is_array($fieldType)) {
$repeatableTypes = $fieldType['fields'];
if (is_array($value)) {
foreach ($value as &$repeatableValue) {
$repeatableValue = self::traverseSettingsToFixSpacingAnomalies($repeatableValue, $repeatableTypes, false);
}
}
} else {
$value = self::transformSpacingValues($value, $forceModern);
}
}
unset($value);
}
return $settings;
}
private static function parsingSpacingValues($settings, $type, $addonName = '')
{
if ($type === 'addon' && (empty($addonName) || !isset(self::$addonFieldTypes[$addonName]))) {
return $settings;
}
switch ($type) {
case 'section':
$fieldTypes = self::$sectionFieldTypes;
break;
case 'column':
$fieldTypes = self::$columnFieldTypes;
break;
case 'addon':
$fieldTypes = self::$addonFieldTypes[$addonName];
break;
}
return self::traverseSettingsToFixSpacingAnomalies($settings, $fieldTypes, in_array($type, ['section', 'column']));
}
private static function hasLegacyDataInsideSettings($settings)
{
if (!empty($settings)) {
foreach ($settings as $setting) {
if (self::hasMultiDeviceSettings($setting) && isset($setting->xl)) {
return false;
}
}
}
return true;
}
private static function isLegacyDataStructure($content)
{
foreach ($content as $row) {
$settings = $row->settings;
if (!self::hasLegacyDataInsideSettings($settings)) {
return false;
}
}
return true;
}
public static function prepareSpacingData($text)
{
self::prepareSectionFieldStructures();
self::prepareColumnFieldStructures();
self::prepareAddonFieldStructures();
self::processFieldTypes('section');
self::processFieldTypes('column');
self::processFieldTypes('addon');
$content = is_string($text) ? json_decode($text) : $text;
self::$isLegacyData = self::isLegacyDataStructure($content);
if (!empty($content)) {
foreach ($content as &$section) {
$section->settings = self::parsingSpacingValues($section->settings, 'section');
if (!empty($section->columns)) {
foreach ($section->columns as &$column) {
$column->settings = self::parsingSpacingValues($column->settings, 'column');
if (!empty($column->addons)) {
foreach ($column->addons as &$addon) {
if (!empty($addon->settings)) {
$addon->settings = self::parsingSpacingValues($addon->settings, 'addon', $addon->name ?? '');
}
}
unset($addon);
}
}
unset($column);
}
}
unset($section);
}
return json_encode($content);
}
/**
* sanitize contents for making the old data valid for the data structure.
*
* @param string $text The json text of the page builder data.
*
* @return string The sanitized text.
*
* @since 4.0.0
*/
public static function sanitize(string $text): string
{
if (empty(self::$addonFieldStructures)) {
self::prepareAddonFieldStructures();
}
$rows = json_decode($text);
if (!empty($rows) && $rows !== "[]") {
foreach ($rows as $key => &$row) {
if (isset($rows[$key]->settings)) {
$rows[$key]->settings = self::shiftResponsiveSettings($row->settings);
$rows[$key]->settings = self::fixRowSettings($row->settings);
}
if (!empty($row->columns)) {
if (!isset($row->settings->fit_columns)) {
$row->settings->fit_columns = self::predictColumnFillStyle($row->columns);
}
foreach ($row->columns as $i => &$column) {
/** Predict the width from the column class name for the old layouts. */
if (!isset($column->width)) {
$width = self::getColumnWidth($column);
$column->width = $width;
}
if (\is_array($column->settings)) {
$column->settings = (object) $column->settings;
}
if (!isset($column->settings->width)) {
$width = !empty($column->width) ? $column->width : self::getColumnWidth($column);
$column->settings->width = $width;
if (isset($column->settings->width->unit)) {
unset($column->settings->width->unit);
}
}
$column->settings->width = self::purifyColumnWidth($column->settings->width);
if (isset($rows[$key]->columns[$i]->settings)) {
$rows[$key]
->columns[$i]
->settings = self::shiftResponsiveSettings($rows[$key]->columns[$i]->settings);
}
if (!empty($column->addons)) {
foreach ($column->addons as $j => &$addon) {
if (isset($rows[$key]->columns[$i]->addons[$j]->settings)) {
$rows[$key]
->columns[$i]
->addons[$j]
->settings = self::shiftResponsiveSettings($rows[$key]->columns[$i]->addons[$j]->settings);
if (isset($addon->name) && $addon->name === 'image_layouts') {
$addonSettings = $addon->settings;
$isBtnUrlExist = property_exists($addonSettings, 'btn_url');
$isButtonUrlExist = property_exists($addonSettings, 'button_url');
$isBtnTargetExist = property_exists($addonSettings, 'btn_target');
if (!$isButtonUrlExist && $isBtnUrlExist) {
$addonSettings->button_url = [
'type' => 'url',
'url' => $addonSettings->btn_url,
'new_tab' => $isBtnTargetExist ? $addonSettings->btn_target : false,
];
}
$isBtnTextExist = property_exists($addonSettings, 'btn_text');
$isButtonTextExist = property_exists($addonSettings, 'button_text');
if (!$isButtonTextExist && $isBtnTextExist) {
$addonSettings->button_text = $addonSettings->btn_text;
}
$isBtnTypeExist = property_exists($addonSettings, 'btn_type');
$isButtonTypeExist = property_exists($addonSettings, 'button_type');
if (!$isButtonTypeExist && $isBtnTypeExist) {
$addonSettings->button_type = $addonSettings->btn_type;
}
$isBtnShapeExist = property_exists($addonSettings, 'btn_shape');
$isButtonShapeExist = property_exists($addonSettings, 'button_shape');
if (!$isButtonShapeExist && $isBtnShapeExist) {
$addonSettings->button_shape = $addonSettings->btn_shape;
}
$isBtnSizeExist = property_exists($addonSettings, 'btn_size');
$isButtonSizeExist = property_exists($addonSettings, 'button_size');
if (!$isButtonSizeExist && $isBtnSizeExist) {
$addonSettings->button_size = $addonSettings->btn_size;
}
$isBtnColorExist = property_exists($addonSettings, 'btn_color');
$isButtonColorExist = property_exists($addonSettings, 'button_color');
if (!$isButtonColorExist && $isBtnColorExist) {
$addonSettings->button_color = $addonSettings->btn_color;
}
$isBtnColorHoverExist = property_exists($addonSettings, 'btn_color_hover');
$isButtonColorHoverExist = property_exists($addonSettings, 'button_color_hover');
if (!$isButtonColorHoverExist && $isBtnColorHoverExist) {
$addonSettings->button_color_hover = $addonSettings->btn_color_hover;
}
$isBtnAppearanceExist = property_exists($addonSettings, 'btn_appearance');
$isButtonAppearanceExist = property_exists($addonSettings, 'button_appearance');
if (!$isButtonAppearanceExist && $isBtnAppearanceExist) {
$addonSettings->button_appearance = $addonSettings->btn_appearance;
}
$isBtnBackgroundColorExist = property_exists($addonSettings, 'btn_background_color');
$isButtonBackgroundColorExist = property_exists($addonSettings, 'button_background_color');
if (!$isButtonBackgroundColorExist && $isBtnBackgroundColorExist) {
$addonSettings->button_background_color = $addonSettings->btn_background_color;
}
$isBtnBackgroundColorHoverExist = property_exists($addonSettings, 'btn_background_color_hover');
$isButtonBackgroundColorHoverExist = property_exists($addonSettings, 'button_background_color_hover');
if (!$isButtonBackgroundColorHoverExist && $isBtnBackgroundColorHoverExist) {
$addonSettings->button_background_color_hover = $addonSettings->btn_background_color_hover;
}
$isBtnBackgroundGradientExist = property_exists($addonSettings, 'btn_background_gradient');
$isButtonBackgroundGradientExist = property_exists($addonSettings, 'button_background_gradient');
if (!$isButtonBackgroundGradientExist && $isBtnBackgroundGradientExist) {
$addonSettings->button_background_gradient = $addonSettings->btn_background_gradient;
}
$isBtnBackgroundGradientHoverExist = property_exists($addonSettings, 'btn_background_gradient_hover');
$isButtonBackgroundGradientHoverExist = property_exists($addonSettings, 'button_background_gradient_hover');
if (!$isButtonBackgroundGradientHoverExist && $isBtnBackgroundGradientHoverExist) {
$addonSettings->button_background_gradient_hover = $addonSettings->btn_background_gradient_hover;
}
}
}
if (isset($addon->name) && isset($addon->settings)) {
$addon->settings = self::getTypographyFromFallbacks($addon->settings, $addon->name);
}
/** Migrate the slideshow items. */
if (isset($addon->name) && $addon->name === 'js_slideshow') {
if (!empty($addon->settings->slideshow_items)) {
foreach ($addon->settings->slideshow_items as $x => &$slideshowItem) {
if (isset($slideshowItem->slider_overlay_options) && $slideshowItem->slider_overlay_options === 'gradient_overaly') {
$slideshowItem->slider_overlay_options = 'gradient_overlay';
}
if (isset($slideshowItem->slider_bg_gradient_overlay) && !isset($slideshowItem->slider_bg_gradient_overlay->type)) {
$slideshowItem->slider_bg_gradient_overlay->type = 'linear';
}
$slideshowItem = self::shiftResponsiveSettings($slideshowItem);
if (!empty($slideshowItem->slideshow_inner_items)) {
foreach ($slideshowItem->slideshow_inner_items as $y => &$innerItem) {
$innerItem = self::shiftResponsiveSettings($innerItem);
}
unset($innerItem);
}
}
unset($slideshowItem);
}
}
/** Migrate the responsive settings for the repeatable items. */
if (isset($addon->name) && \in_array($addon->name, ['accordion', 'tab'])) {
$repeatableKey = 'sp_' . $addon->name . '_item';
if (!empty($addon->settings->$repeatableKey)) {
foreach ($rows[$key]->columns[$i]->addons[$j]->settings->$repeatableKey as &$itemSetting) {
$itemSetting = self::shiftResponsiveSettings($itemSetting);
}
unset($itemSetting);
}
}
if (isset($addon->name) && \in_array($addon->name, ['accordion', 'tab'])) {
list($outerRows, $addon) = self::migrateDeepAddon($addon, 'sp_' . $addon->name . '_item', $row, $column);
$rows[$key]->columns[$i]->addons[$j] = $addon;
array_push($rows, ...$outerRows);
}
if (isset($addon->name) && $addon->name === 'table_advanced') {
$nodeId = self::generateUUID();
if (isset($addon->settings->sp_table_advanced_item)) {
foreach ($addon->settings->sp_table_advanced_item as $th => $thead) {
if (isset($thead->content) && !\is_array($thead->content)) {
$thead = ['id' => $nodeId++, 'name' => 'text_block', 'visibility' => true, 'reference_id' => $addon->id, 'settings' => ['text' => $thead->content]];
$thead = \json_decode(\json_encode($thead));
$rows[$key]
->columns[$i]
->addons[$j]
->settings
->sp_table_advanced_item[$th]
->content = [];
$rows[$key]
->columns[$i]
->addons[$j]
->settings
->sp_table_advanced_item[$th]
->content[] = $thead;
} elseif (isset($thead->content) && \is_array($thead->content)) {
$contents = [];
foreach ($thead->content as $content) {
$content->reference_id = $addon->id;
$contents[] = $content;
}
$rows[$key]
->columns[$i]
->addons[$j]
->settings
->sp_table_advanced_item[$th]
->content = $contents;
}
}
}
foreach ($addon->settings->table_advanced_item as $r => $tRow) {
if (isset($tRow->table_advanced_item)) {
foreach ($tRow->table_advanced_item as $c => $tCell) {
if (isset($tCell->content) && !\is_array($tCell->content)) {
$td = ['id' => $nodeId++, 'name' => 'text_block', 'visibility' => true, 'reference_id' => $addon->id, 'settings' => ['text' => $tCell->content]];
$td = \json_decode(\json_encode($td));
$rows[$key]
->columns[$i]
->addons[$j]
->settings
->table_advanced_item[$r]
->table_advanced_item[$c]
->content = [];
$rows[$key]
->columns[$i]
->addons[$j]
->settings
->table_advanced_item[$r]
->table_advanced_item[$c]
->content[] = $td;
} elseif (isset($tCell->content) && \is_array($tCell->content)) {
$contents = [];
foreach ($tCell->content as &$content) {
$content->reference_id = $addon->id;
$contents[] = $content;
}
$rows[$key]
->columns[$i]
->addons[$j]
->settings
->table_advanced_item[$r]
->table_advanced_item[$c]
->content = $contents;
unset($content);
}
}
}
}
}
if (isset($addon->type) && $addon->type === 'inner_row') {
$nestedRowAddon = new \stdClass;
$nestedRowAddon->type = 'nested_row';
$nestedRowAddon->name = 'row';
$nestedRowAddon->id = $addon->id;
$addon->parent = new \stdClass;
$addon->parent->rowId = $row->id;
$addon->parent->columnId = $column->id;
unset($addon->type);
$rows[] = $addon;
$rows[$key]->columns[$i]->addons[$j] = $nestedRowAddon;
}
}
unset($addon);
}
}
unset($column);
}
}
unset($row);
} else {
return $text;
}
return json_encode($rows);
}
public static function fixRowSettings($settings)
{
if (isset($settings->background_type)) {
return $settings;
}
$settings->background_type = 'none';
$keyMap = [
'background_image' => 'image',
'background_color' => 'color',
'background_gradient' => 'gradient',
'background_video' => 'video',
'background_video_mp4' => 'video',
'background_video_ogv' => 'video',
'background_external_video' => 'video',
];
foreach ($keyMap as $key => $value) {
if (!empty($settings->$key)) {
$settings->background_type = $value;
break;
}
}
return $settings;
}
/**
* Migrate the accordion addon to the current structure.
*
* @param \stdClass $addon The accordion addon object.
*
* @return array
* @since 4.0.0
*/
private static function migrateDeepAddon(\stdClass $addon, $key, $row, $column): array
{
$addon = json_decode(json_encode($addon));
$addonCollection = [];
$outerRows = [];
if (!isset($addon->parent) || (isset($addon->parent) && !$addon->parent)) {
$addon->id = self::nanoid();
}
if (isset($addon->settings->$key)) {
foreach ($addon->settings->$key as $itemIndex => $item) {
$addonCollection = [];
if (isset($item->content) && \is_array($item->content)) {
foreach ($item->content as $deepAddon) {
if (isset($deepAddon->type) && $deepAddon->type === 'nested_row') {
continue;
}
$addonCollection[] = $deepAddon;
}
if (\count($addonCollection) > 0) {
$_parent = ['rowId' => $row->id, 'columnId' => $column->id];
$_parent = (object) $_parent;
$row = self::createRow('12', $addonCollection, $_parent);
$row->parent_addon = $addon->id;
$outerRows[] = $row;
$nestedRow = ['type' => 'nested_row', 'id' => $row->id, 'name' => 'row'];
$nestedRow = (object) $nestedRow;
$addon->settings->$key[$itemIndex]->content = [];
$addon->settings->$key[$itemIndex]->content[] = $nestedRow;
}
} else if (isset($item->content) && \is_string($item->content)) {
$textAddon = ['id' => self::nanoid(), 'name' => 'text_block', 'settings' => ['text' => $item->content]];
$addonCollection[] = $textAddon;
$_parent = ['rowId' => $row->id, 'columnId' => $column->id];
$_parent = (object) $_parent;
$row = self::createRow('12', $addonCollection, $_parent);
$row->parent_addon = $addon->id;
$outerRows[] = $row;
$nestedRow = ['type' => 'nested_row', 'id' => $row->id, 'name' => 'row'];
$nestedRow = (object) $nestedRow;
$addon->settings->$key[$itemIndex]->content = [];
$addon->settings->$key[$itemIndex]->content[] = $nestedRow;
}
}
}
return [$outerRows, $addon];
}
/**
* Create Row function
*
* @param string $layout Default layout size
* @param array $addons Addons
* @param mixed $parent Parent row.
*
* @return object
*
* @since 4.0.0
*/
public static function createRow(string $layout = '12', array $addons = [], $parent = null)
{
$rowId = self::nanoid();
$layouts = explode('+', $layout);
$rowDefaultValues = EditorUtils::getSectionSettingsDefaultValues();
$columnDefaultValues = EditorUtils::getColumnSettingsDefaultValues();
$rowDefaultValues = json_decode(json_encode($rowDefaultValues));
$columnDefaultValues = json_decode(json_encode($columnDefaultValues));
$columns = array_map(function ($col) use ($columnDefaultValues, $addons) {
$width = (float) ((100 / (12 / (int) $col))) . '%';
$widthObject = ['xl' => $width, 'lg' => $width, 'md' => $width, 'sm' => '100%', 'xs' => '100%'];
$widthObject = (object) $widthObject;
$columnObject = [
'id' => self::nanoid(),
'class_name' => 'row-column',
'visibility' => true,
'settings' => $columnDefaultValues,
'addons' => $addons,
'width' => $widthObject,
];
return (object) $columnObject;
}, $layouts);
$rowDefaultValues->padding = '5px 0px 5px 0px';
$rowDefaultValues->margin = '0px 0px 0px 0px';
$rowObject = [
'id' => $rowId,
'visibility' => true,
'collapse' => false,
'settings' => $rowDefaultValues,
'layout' => $layout,
'columns' => $columns,
'parent' => $parent ? $parent : false,
];
return (object) $rowObject;
}
/**
* Generate a unique ID by using microtime.
*
* @return integer
* @since 4.0.0
*/
public static function generateUUID(): int
{
return (int) (microtime(true) * 1000);
}
/**
* Shift responsive device settings for with the new device structure.
*
* @param \stdClass $settings The settings value.
*
* @return \stdClass | null
* @since 4.0.0
*/
public static function shiftResponsiveSettings($settings)
{
if (!empty($settings)) {
foreach ($settings as $key => $setting) {
if (\is_object($setting) && isset($setting->md) && !isset($setting->xl)) {
$tmp = (object) ['xl' => '', 'lg' => '', 'md' => '', 'sm' => '', 'xs' => ''];
if (isset($setting->md)) {
$tmp->xl = $setting->md;
}
if (isset($setting->sm)) {
$tmp->lg = $setting->sm;
$tmp->md = $setting->sm;
}
if (isset($setting->xs)) {
$tmp->sm = $setting->xs;
$tmp->xs = $setting->xs;
}
if (isset($setting->unit)) {
$tmp->unit = $setting->unit;
}
$settings->$key = $tmp;
}
}
if (isset($settings->hidden_md) && !isset($settings->hidden_xl)) {
if (isset($settings->hidden_md)) {
$settings->hidden_xl = $settings->hidden_md;
}
if (isset($settings->hidden_sm)) {
$settings->hidden_lg = $settings->hidden_sm;
$settings->hidden_md = $settings->hidden_sm;
}
if (isset($settings->hidden_xs)) {
$settings->hidden_sm = $settings->hidden_xs;
$settings->hidden_xs = $settings->hidden_xs;
}
}
}
return $settings;
}
/**
* Remove sp_ from the addon name
*
* @return void
* @since 4.0.0
*/
public static function sanitize_addon_name($addon_name)
{
$from = '/' . preg_quote('sp_', '/') . '/';
return preg_replace($from, '', $addon_name, 1);
}
/**
* Load Language File
*
* @param boolean $forceLoad
* @return void
*/
public static function loadLanguage($forceLoad = false)
{
$lang = Factory::getLanguage();
/** @var CMSApplication */
$app = Factory::getApplication();
$template = $app->getTemplate();
if ($app->isClient('administrator')) {
$template = self::getTemplate();
}
$com_option = $app->input->get('option', '', 'STR');
$com_view = $app->input->get('view', '', 'STR');
$com_id = $app->input->get('id', 0, 'INT');
if (($com_option == 'com_sppagebuilder' && $com_view == 'form' && $com_id) || $forceLoad) {
$lang->load('com_sppagebuilder', JPATH_ADMINISTRATOR, null, true);
}
// Load template language file
$lang->load('tpl_' . $template, JPATH_SITE, null, true);
self::setPluginsAddonsLanguage();
if (ApplicationHelper::isEasyStoreInstalled() && ApplicationHelper::isProVersion()) {
$lang->load('com_easystore', JPATH_BASE, null, true);
$lang->load('com_easystore', JPATH_ADMINISTRATOR, null, true);
}
if (($com_option === 'com_sppagebuilder' && $com_view !== 'page')) {
require_once JPATH_ROOT . '/administrator/components/com_sppagebuilder/helpers/language.php';
}
}
private static function getTemplate()
{
$db = Factory::getDbo();
$query = $db->getQuery(true);
$query->select('template')
->from($db->quoteName('#__template_styles'))
->where($db->quoteName('client_id') . ' = 0')
->where($db->quoteName('home') . ' = 1');
$db->setQuery($query);
return $db->loadResult();
}
/**
* Load Plugin addons language files.
*
* @return void
*/
private static function setPluginsAddonsLanguage()
{
$path = JPATH_PLUGINS . '/sppagebuilder';
if (!Folder::exists($path)) {
return;
}
$plugins = Folder::folders($path);
if (!count((array) $plugins)) {
return;
}
foreach ($plugins as $plugin) {
if (PluginHelper::isEnabled('sppagebuilder', $plugin)) {
$lang = Factory::getLanguage();
$lang->load('plg_' . $plugin, JPATH_ADMINISTRATOR, null, true);
}
}
}
/**
* Convert Padding Margin Value.
*
* @param string $main_value CSS value
* @param string $type CSS property
*
* @return string
*
* @since 4.0.0
*/
public static function getPaddingMargin($main_value, $type): string
{
$css = '';
$pos = array('top', 'right', 'bottom', 'left');
if (is_string($main_value) && trim($main_value) != "") {
$values = explode(' ', $main_value);
foreach ($values as $key => $value) {
$value = preg_replace('@/s@', '', $value);
if ($value !== "") {
$css .= $type . '-' . $pos[$key] . ': ' . $value . ';';
}
}
}
return $css;
}
public static function getSvgShapes()
{
$shape_path = JPATH_ROOT . '/components/com_sppagebuilder/assets/shapes';
$shapes = Folder::files($shape_path, '.svg');
$shapeArray = array();
if (count((array) $shapes)) {
foreach ($shapes as $shape) {
$shapeArray[str_replace('.svg', '', $shape)] = base64_encode(file_get_contents($shape_path . '/' . $shape));
}
}
return $shapeArray;
}
public static function getSvgShapeCode($shapeName, $invert)
{
if ($invert) {
$shape_path = JPATH_ROOT . '/components/com_sppagebuilder/assets/shapes/' . $shapeName . '-invert.svg';
} else {
$shape_path = JPATH_ROOT . '/components/com_sppagebuilder/assets/shapes/' . $shapeName . '.svg';
}
$shapeCode = '';
if (file_exists($shape_path)) {
$shapeCode = file_get_contents($shape_path);
}
return is_string($shapeCode) ? $shapeCode : '';
}
// Convert json code to plain text
public static function getPrettyText($sections)
{
if (!class_exists('AddonParser')) {
require_once JPATH_ROOT . '/components/com_sppagebuilder/parser/addon-parser.php';
}
if (!class_exists('SpPageBuilderAddonHelper')) {
require_once JPATH_ROOT . '/components/com_sppagebuilder/builder/classes/addon.php';
}
$content = ApplicationHelper::sanitizePageText($sections);
$htmlContent = AddonParser::viewAddons($content, 0, 'none', 1, true, [], true);
$htmlContent = str_replace('><', '> <', $htmlContent);
return trim(strip_tags($htmlContent));
}
public static function addScript($script, $client = 'site', $version = true)
{
$doc = Factory::getDocument();
$script_url = Uri::base(true) . ($client == 'admin' ? '/administrator' : '') . '/components/com_sppagebuilder/assets/js/' . $script;
if ($version) {
$script_url .= '?' . self::getVersion(true);
}
$doc->addScript($script_url);
}
public static function addStylesheet($stylesheet, $client = 'site', $version = true)
{
$doc = Factory::getDocument();
$stylesheet_url = Uri::base(true) . ($client == 'admin' ? '/administrator' : '') . '/components/com_sppagebuilder/assets/css/' . $stylesheet;
if ($version) {
$stylesheet_url .= '?' . self::getVersion(true);
}
$doc->addStylesheet($stylesheet_url);
}
public static function addContainerMaxWidth()
{
$doc = Factory::getDocument();
$params = ComponentHelper::getParams('com_sppagebuilder');
$containerMaxWidth = $params->get('container_max_width', 1320);
$doc->addStyleDeclaration("@media(min-width: 1400px) {.sppb-row-container { max-width: " . $containerMaxWidth . "px; }}");
}
public static function getVersion($md5 = false)
{
$db = Factory::getDbo();
$query = $db->getQuery(true)
->select('e.manifest_cache')
->select($db->quoteName('e.manifest_cache'))
->from($db->quoteName('#__extensions', 'e'))
->where($db->quoteName('e.element') . ' = ' . $db->quote('com_sppagebuilder'));
$db->setQuery($query);
$manifest_cache = json_decode($db->loadResult());
if (isset($manifest_cache->version) && $manifest_cache->version) {
if ($md5) {
return md5($manifest_cache->version);
}
return $manifest_cache->version;
}
return '1.0';
}
/**
* Load Assets form database table.
*
* @return void
*/
public static function loadAssets()
{
$doc = Factory::getDocument();
$db = Factory::getDbo();
$query = $db->getQuery(true)
->select($db->quoteName(array('a.name', 'a.css_path')))
->from($db->quoteName('#__sppagebuilder_assets', 'a'))
->where($db->quoteName('a.published') . ' = 1');
$db->setQuery($query);
$assets = $db->loadObjectList();
if (!empty($assets)) {
foreach ($assets as $asset) {
$asset_url = Uri::base(true) . '/' . $asset->css_path . '?' . self::getVersion(true);
$doc->addStylesheet($asset_url);
}
}
}
/**
* Get the current template name form database.
*
* @return void
*/
public static function getTemplateName()
{
$db = Factory::getDbo();
$query = $db->getQuery(true);
$query->select($db->quoteName(['template']))
->from($db->quoteName('#__template_styles'))
->where($db->quoteName('client_id') . ' = 0')
->where($db->quoteName('home') . ' = 1');
$db->setQuery($query);
return $db->loadObject()->template;
}
/**
* Get installed google fonts from database.
*
* @return array
*/
public static function getInstalledGoogleFonts()
{
$db = Factory::getDbo();
$query = $db->getQuery(true);
$query->select('family_name')
->from($db->quoteName('#__sppagebuilder_fonts'))
->where($db->quoteName('type') . ' = ' . $db->quote('google'));
$db->setQuery($query);
try
{
return $db->loadColumn() ?? [];
} catch (Exception $e) {
return [];
}
}
/**
* Checking multi device settings
*
* @param mixed $value
* @return boolean
*
* @since 5.0.0
*/
public static function hasMultiDeviceSettings($value): bool
{
return isset($value->xl)
|| isset($value->lg)
|| isset($value->md)
|| isset($value->sm)
|| isset($value->xs);
}
/**
* Checking media item
*
* @param mixed $value
* @return boolean
*
* @since 5.0.0
*/
public static function isMediaItemData($value): bool
{
return isset($value->src);
}
/**
* Clean media path
*
* @param string $path
* @return string
*
* @since 5.0.3
*/
public static function cleanPath($path): string
{
$cleanedPath = Path::clean($path);
$cleanedPath = str_replace("/\\", "\\", $cleanedPath);
$cleanedPath = str_replace("\\", "/", $cleanedPath);
return $cleanedPath;
}
public static function classes(array $classNames): string
{
$filteredClassNames = array_filter($classNames, function ($value) {
return (bool) trim(strval($value));
});
return implode(" ", $filteredClassNames);
}
/**
* Initialize the basic settings for the page builder page view
*
* @param $data object
* @return object
*/
public static function initView($data)
{
/** @var CMSApplication */
$app = Factory::getApplication();
$doc = $app->getDocument();
$params = ComponentHelper::getParams('com_sppagebuilder');
if ($params->get('fontawesome', 1)) {SppagebuilderHelperSite::addStylesheet('font-awesome-6.min.css');
SppagebuilderHelperSite::addStylesheet('font-awesome-v4-shims.css');}
if (!$params->get('disableanimatecss', 0)) {
SppagebuilderHelperSite::addStylesheet('animate.min.css');
}
if (!$params->get('disablecss', 0)) {
SppagebuilderHelperSite::addStylesheet('sppagebuilder.css');
SppagebuilderHelperSite::addStylesheet('animate.min.css');
SppagebuilderHelperSite::addContainerMaxWidth();
}
// load font assets form database
SppagebuilderHelperSite::loadAssets();
HTMLHelper::_('jquery.framework');
HTMLHelper::_('script', 'components/com_sppagebuilder/assets/js/jquery.parallax.js', ['version' => SppagebuilderHelperSite::getVersion(true)]);
HTMLHelper::_('script', 'components/com_sppagebuilder/assets/js/es5_interaction.js', ['version' => SppagebuilderHelperSite::getVersion(true)], ['defer' => true]);
HTMLHelper::_('script', 'components/com_sppagebuilder/assets/js/sppagebuilder.js', ['version' => SppagebuilderHelperSite::getVersion(true)], ['defer' => true]);
require_once JPATH_ROOT . '/components/com_sppagebuilder/parser/addon-parser.php';
require_once JPATH_ROOT . '/components/com_sppagebuilder/builder/classes/addon.php';
// Add page css
if (isset($data->css) && $data->css) {
$doc->addStyledeclaration($data->css);
}
$content = $data->content;
return is_string($content) ? json_decode($content) : $content;
}
}