autonomic-cooperative/divi
Archived
0
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

version 4.13.0

Browse Source
This commit is contained in:
naomi
2021-12-07 11:08:05 +00:00
commit cb26d2c0c4
1285 changed files with 254735 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

731
includes/builder/module/helpers/OptionTemplate.php Normal file
View File

@ -0,0 +1,731 @@
<?php
/**
* Option Templates helper methods.
*
* @since 3.28
*
* Class ET_Builder_Module_Helper_OptionTemplate
*/
class ET_Builder_Module_Helper_OptionTemplate {
private $map = array();
private $templates = array();
private $data = array();
private $cache = array();
private $tab_slug_map = array();
public $template_prefix = '%t';
protected static $_ = null;
public static function instance() {
static $instance;
return $instance ? $instance : $instance = new self();
}
private function __construct() {
self::$_ = ET_Core_Data_Utils::instance();
}
private function uniq( $prefix, $content ) {
$key = md5( $prefix . serialize( $content ) );
if ( isset( $this->map[ $key ] ) ) {
return $this->map[ $key ];
}
return ( $this->map[ $key ] = $this->template_prefix . $key );
}
/**
* Determine whether option template is enabled on current request or not
*
* @since 3.28
*
* @return bool
*/
public function is_enabled() {
// Option template tends to be enabled on most request to speed up performance
$status = true;
// Option template is disabled on:
// 1. AJAX request for fetching classic builder (BB)'s module data. BB data is shipped as
// optimized template markup which is rendered on server then sent as string. Hence
// Option Template's sent-config-rebuild-on-js won't be usable for BB
// 2. BB's editing page. BB edit page scans for field dependency and generates visibility
// setting on `window.et_pb_module_field_dependencies` variable for field depency thus
// actual field should be rendered here instead of templateId
if ( et_builder_is_loading_bb_data() || et_builder_is_bb_page() ) {
$status = false;
}
/**
* Filters option template status
*
* @since 3.28
*
* @param bool $status
*/
return apply_filters( 'et_builder_option_template_is_active', $status );
}
/**
* Determine whether given field name is option template field based on its first two characters
*
* @since 3.28
*
* @return bool
*/
public function is_option_template_field( $field_name = '' ) {
return $this->template_prefix === substr( $field_name, 0, 2 );
}
public function has( $key ) {
return isset( $this->templates[ $key ] );
}
public function add( $key, $template ) {
$fields_template = array_merge( $template, et_pb_responsive_options()->create( $template ) );
// Populate tab_slug of given template because advance fields can be rendered on any tab
foreach ( $fields_template as $field_name => $field ) {
if ( isset( $field['tab_slug'] ) ) {
$tab_slug = '' === $field['tab_slug'] ? 'advanced' : $field['tab_slug'];
if ( ! isset( $this->tab_slug_map[ $tab_slug ] ) ) {
$this->tab_slug_map[ $tab_slug ] = array( $key );
continue;
}
if ( ! in_array( $key, $this->tab_slug_map[ $tab_slug ] ) ) {
$this->tab_slug_map[ $tab_slug ][] = $key;
}
}
}
$this->templates[ $key ] = $fields_template;
}
public function create( $key, $config, $return_template_id = false ) {
$data = array( $key, $config );
$id = $this->uniq( $key, $data );
// Alternative, this will save the values directly in the Module $this->unprocessed_fields
// instead of this Calls $this->data and hence require a simpler logic.
// Theoretically it should require more memory but blackfire begs to differ.
$this->data[ $id ] = $data;
// Return as template id instead of id => key if needed
if ( $return_template_id ) {
return $id;
}
return array( $id => $key );
}
/**
* Create placeholders for template's params
*
* @return string[]
*/
public function placeholders( $config, $idx = 1, $path = array() ) {
$placeholders = array();
foreach ( $config as $key => $value ) {
if ( is_array( $value ) ) {
// Prepend current key as path so placeholder later can correctly fetch correct
// value from template data using dot notation path (both lodash get() or utils's
// array_get() support this).
$path[] = $key;
$value = $this->placeholders( $value, $idx, $path );
} else {
// Prepend dot notation path as prefix if needed
$prefix = empty( $path ) ? '' : implode( '.', $path ) . '.';
$value = "%%{$prefix}{$key}%%";
}
$placeholders[ $key ] = $value;
$idx++;
}
return $placeholders;
}
/**
* Get module's data
*
* @return array[]
*/
public function all() {
return $this->data;
}
/**
* Get templates
*
* @since 3.28
*
* @return array
*/
public function templates() {
return $this->templates;
}
/**
* Set `$this->data` property from external source (ie: static field definition cache).
*
* @since 3.28
*
* @param array $cached_data
*/
public function set_data( $cached_data = array() ) {
$this->data = wp_parse_args(
$cached_data,
$this->data
);
}
/**
* Set `$this->templates` property from external source (ie: static field definition cache).
*
* @since 3.28
*
* @param array $cached_template
*/
public function set_templates( $cached_templates = array() ) {
$this->templates = wp_parse_args(
$cached_templates,
$this->templates
);
}
/**
* Set `$this->tab_slug_map` from external source (ie: static field definition cache).
*
* @since 3.29
*
* @param array $cached_tab_slug_map
*/
public function set_tab_slug_map( $cached_tab_slug_map = array() ) {
$this->tab_slug_map = wp_parse_args(
$cached_tab_slug_map,
$this->tab_slug_map
);
}
/**
* Get template data based on given template id
*
* @since 3.28
*
* @param string $template_id
*
* @return array
*/
public function get_data( $template_id = '' ) {
return isset( $this->data[ $template_id ] ) ? $this->data[ $template_id ] : array();
}
/**
* Get template based on given template type
*
* @since 3.28
*
* @param string $type
*
* @return array
*/
public function get_template( $type = '' ) {
return isset( $this->templates[ $type ] ) ? $this->templates[ $type ] : array();
}
/**
* Get hashed cache key based on params given
*
* @since 3.28
*
* @param mixed $params
*
* @return string
*/
public function get_cache_key( $params ) {
$params = is_string( $params ) ? $params : serialize( $params );
return md5( $params );
}
/**
* Get cached value
* Return null if no cached value found
*
* @since 3.28
*
* @param string $name
* @param string $key
*
* @return mixed
*/
public function get_cache( $name, $key ) {
if (
! empty( $this->cache )
&& ! empty( $this->cache[ $name ] )
&& ! empty( $this->cache[ $name ][ $key ] )
) {
return $this->cache[ $name ][ $key ];
}
return null;
}
/**
* Set value to be cached
*
* @since 3.28
*
* @param string $name
* @param string $key
* @param mixed $value
*
* @return void
*/
public function set_cache( $name, $key, $value ) {
self::$_->array_set( $this->cache, "{$name}.{$key}", $value );
}
/**
* Get placeholder of given template
*
* @since 3.28
*
* @param string $template
*
* @return array|bool
*/
public function get_template_placeholder( $template ) {
// Check for cached result first for faster performance
$cache_name = 'template_placeholder';
$cache_key = $this->get_cache_key( $template );
$cache = $this->get_cache( $cache_name, $cache_key );
if ( ! is_null( $cache ) ) {
return $cache;
}
preg_match( '/(?<=%%).*(?=%%)/', $template, $placeholder );
// Cache result
$this->set_cache( $cache_name, $cache_key, $placeholder );
return $placeholder;
}
/**
* Get tab slug maps
*
* @since 3.29
*
* @return array
*/
public function get_tab_slug_map() {
return $this->tab_slug_map;
}
public function is_template_inside_tab( $tab_name, $template_type ) {
// Template which has `%%tab_slug%%` tab_slug can exist on any tab
if ( in_array( $template_type, self::$_->array_get( $this->tab_slug_map, '%%tab_slug%%', array() ) ) ) {
return true;
}
if ( in_array( $template_type, self::$_->array_get( $this->tab_slug_map, $tab_name, array() ) ) ) {
return true;
}
return false;
}
public function rebuild_string_placeholder( $template, $data = array(), $settings = array() ) {
// Placeholder settings
$default_settings = array(
'suffix' => '',
'remove_suffix_if_empty' => false,
);
$placeholder_settings = wp_parse_args( $settings, $default_settings );
// Check for cached result first for faster performance
$cache_name = 'string_placeholder';
$cache_key = $this->get_cache_key( array( $template, $data, $placeholder_settings ) );
$cache = $this->get_cache( $cache_name, $cache_key );
if ( ! is_null( $cache ) ) {
return $cache;
}
// Get placeholder
$placeholder = is_string( $template ) ? $this->get_template_placeholder( $template ) : false;
// If found, replace placeholder with correct value from data
if ( is_array( $placeholder ) && isset( $placeholder[0] ) ) {
// Get placeholder replacement
$replacement = ! empty( $data[1] ) && ! empty( $data[1][ $placeholder[0] ] ) ? $data[1][ $placeholder[0] ] : '';
// Pass null as empty string; null as attribute affect builder differently.
// Attribute with empty string will be omitted later.
if ( is_null( $replacement ) ) {
$replacement = '';
}
// If placeholder is identical to template, return replacement early. This also
// handles the case where replacement as array type
if ( "%%{$placeholder[0]}%%" === $template ) {
// Cache result
$this->set_cache( $cache_name, $cache_key, $replacement );
return $replacement;
}
// Get placeholder suffix
$has_suffix = '' === $replacement && $placeholder_settings['remove_suffix_if_empty'];
$suffix = $has_suffix ? $placeholder_settings['suffix'] : '';
// Make sure replacement is string before proceed;
if ( is_string( $replacement ) ) {
$rebuilt_string = str_replace( "%%{$placeholder[0]}%%{$suffix}", $replacement, $template );
// Cache result
$this->set_cache( $cache_name, $cache_key, $rebuilt_string );
return $rebuilt_string;
}
}
// Cache result
$this->set_cache( $cache_name, $cache_key, $template );
return $template;
}
public function rebuild_preset_placeholder( $template, $data = array(), $settings = array() ) {
// Check for cached result first for faster performance
$cache_name = 'preset_placeholder';
$cache_key = $this->get_cache_key( array( $template, $data, $settings ) );
$cache = $this->get_cache( $cache_name, $cache_key );
if ( ! is_null( $cache ) ) {
return $cache;
}
$rebuild_attr = array();
foreach ( $template as $preset_attr_key => $preset_attr_value ) {
// Object inside preset array mostly contains fields attribute which its object key
// contains placeholder while its object value contains actual value without placeholder.
if ( is_array( $preset_attr_value ) ) {
$rebuilt_preset_attr_object = array();
foreach ( $preset_attr_value as $name => $value ) {
$object_item_name = $this->rebuild_string_placeholder( $name, $data, $settings );
$rebuilt_preset_attr_object[ $object_item_name ] = $value;
}
$rebuild_attr[ $preset_attr_key ] = $rebuilt_preset_attr_object;
continue;
}
$rebuild_attr[ $preset_attr_key ] = $preset_attr_value;
}
// Cache result
$this->set_cache( $cache_name, $cache_key, $rebuild_attr );
return $rebuild_attr;
}
public function rebuild_composite_structure_placeholder( $template_type, $template, $data = array() ) {
// Check for cached result first for faster performance
$cache_name = 'composite_structure_placeholder';
$cache_key = $this->get_cache_key( array( $template_type, $template, $data ) );
$cache = $this->get_cache( $cache_name, $cache_key );
if ( ! is_null( $cache ) ) {
return $cache;
}
$rebuilt_composite_structure_field = $template;
// Replaces placeholder with actual value on border's nested composite structure fields
if ( 'border' === $template_type ) {
// Reset `controls` attribute output
$rebuilt_composite_structure_field['controls'] = array();
// Loop composite structure's original `controls` from template
foreach ( $template['controls'] as $field_name => $field ) {
$rebuilt_field_name = $this->rebuild_string_placeholder( $field_name, $data );
$rebuilt_field = $field;
// Loop field on composite structure controls
foreach ( $rebuilt_field as $attr_name => $attr_value ) {
$settings = array(
'suffix' => 'label' === $attr_name ? ' ' : '',
'remove_suffix_if_empty' => 'label' === $attr_name,
);
$rebuilt_field[ $attr_name ] = $this->rebuild_string_placeholder( $attr_value, $data, $settings );
}
$rebuilt_composite_structure_field['controls'][ $rebuilt_field_name ] = $rebuilt_field;
}
}
// Cache result
$this->set_cache( $cache_name, $cache_key, $rebuilt_composite_structure_field );
return $rebuilt_composite_structure_field;
}
public function rebuild_field_attr_value( $attr_name, $attr_value, $template_data ) {
// Check for cached result first for faster performance
$cache_name = 'field_attr_value';
$cache_key = $this->get_cache_key( array( $attr_name, $attr_value, $template_data ) );
$cache = $this->get_cache( $cache_name, $cache_key );
if ( ! is_null( $cache ) ) {
return $cache;
}
$template_type = ! empty( $template_data[0] ) ? $template_data[0] : '';
$prefix = ! empty( $template_data[1]['prefix'] ) && ! empty( $template_data[1]['prefix'] ) ? $template_data[1]['prefix'] : '';
// Certain advanced field (ie. Text Shadow) automatically adds underscore
$auto_add_prefix_underscore = isset( $template_data[0] ) && 'text_shadow' === $template_data[0] && '' === $prefix;
// 1. Field attribute value's type is string
if ( is_string( $attr_value ) ) {
$placeholder_has_space_suffix = 'label' === $attr_name && in_array( $template_type, array( 'border', 'text_shadow' ) );
$settings = array(
'suffix' => $placeholder_has_space_suffix ? ' ' : '',
'remove_suffix_if_empty' => $placeholder_has_space_suffix ? true : false,
);
$rebuilt_placeholder = $this->rebuild_string_placeholder( $attr_value, $template_data, $settings );
// Cache result
$this->set_cache( $cache_name, $cache_key, $rebuilt_placeholder );
return $rebuilt_placeholder;
}
// 2. Field attribute value's type is array (sequential)
if ( is_array( $attr_value ) && isset( $attr_value[0] ) ) {
$rebuild_attr_value = array();
foreach ( $attr_value as $array_value ) {
// Array consists of string is most likely used for defining field relationship
// such as `show_if` attribute; Replace prefix and suffix placeholder with
// placeholder replacement also consider that text_shadow advanced field
// automatically adds underscore after prefix so it needs to be adjusted as well
if ( is_string( $array_value ) ) {
$settings = array(
'suffix' => '_',
'remove_suffix_if_empty' => $auto_add_prefix_underscore,
);
$rebuild_attr_value[] = $this->rebuild_string_placeholder( $array_value, $template_data, $settings );
} elseif ( 'presets' === $attr_name ) {
// Handle preset attribute specifically due to how it is structured
$settings = array(
'suffix' => '_',
'remove_suffix_if_empty' => $auto_add_prefix_underscore,
);
$rebuild_attr_value[] = $this->rebuild_preset_placeholder( $array_value, $template_data, $settings );
} else {
// Non string and `presets` attribute less likely contains placeholder
$rebuild_attr_value[] = $array_value;
}
}
// Cache result
$this->set_cache( $cache_name, $cache_key, $rebuild_attr_value );
return $rebuild_attr_value;
}
// 3. Field attribute value's type is array (associative)
if ( is_array( $attr_value ) && ! isset( $attr_value[0] ) ) {
$attr_object = array();
// Loop existing attrValue and populate the rebuilt result on `attrObject`.
foreach ( $attr_value as $item_key => $item_value ) {
$attr_object_key = $this->rebuild_string_placeholder( $item_key, $template_data );
// Replaces placeholder with actual value on border's nested composite structure fields
if ( 'composite_structure' === $attr_name ) {
$item_value = $this->rebuild_composite_structure_placeholder( $template_type, $item_value, $template_data );
}
$attr_object[ $attr_object_key ] = $item_value;
}
// Cache result
$this->set_cache( $cache_name, $cache_key, $attr_object );
return $attr_object;
}
// Cache result
$this->set_cache( $cache_name, $cache_key, $attr_value );
// 4. Unknown attribute value type; directly pass it
return $attr_value;
}
public function rebuild_field_template( $template_id, $parent_template_id = false ) {
// Check for cached result first for faster performance
$cache_name = 'field_template';
$cache_key = $parent_template_id ? "{$template_id}-inherits-{$parent_template_id}" : $template_id;
$cache = $this->get_cache( $cache_name, $cache_key );
if ( ! is_null( $cache ) ) {
return $cache;
}
$fields = array();
$template_data = $this->get_data( $template_id );
// No fields will be found without template data. Return early;
if ( empty( $template_data ) ) {
return $fields;
}
$template_type = ! empty( $template_data[0] ) ? $template_data[0] : '';
$template_settings = ! empty( $template_data[1] ) ? $template_data[1] : array();
$prefix = ! empty( $template_settings['prefix'] ) ? $template_settings['prefix'] : '';
$parent_template_data = false;
// If rebuilt parent template is inside another templateId (ie. Text Shadow inside Font)
// its placeholder is passed for data; The expected structure becomes
// `[templateType, parentTemplateSettings]` instead of `[templateType, templateSettings]`;
// Thus get parent template's settings and use it
if ( $parent_template_id ) {
$parent_template_data = $this->get_data( $parent_template_id );
$parent_template_settings = ! empty( $parent_template_data[1] ) ? $parent_template_data[1] : true;
$template_settings_inherits_from_parant = array();
foreach ( $template_settings as $name => $value ) {
$placeholder = $this->get_template_placeholder( $value );
if ( is_array( $placeholder ) && isset( $placeholder[0] ) ) {
$template_settings_inherits_from_parant[ $name ] = self::$_->array_get(
$parent_template_settings,
$placeholder[0],
$value
);
}
}
$parent_template_data = array(
$template_type,
$template_settings_inherits_from_parant,
);
}
// Get fields template for given template type
$fields_template = $this->get_template( $template_type );
// Loop fields template and replace placeholder with actual value
foreach ( $fields_template as $field_name_template => $field_template ) {
// Certain advanced field (ie. Text Shadow) automatically adds underscore
// Related template type needs to be adjusted
$remove_suffix_if_empty = 'text_shadow' === $template_type && '' === $prefix;
// Replace field attribute name's placeholder
$field_template_data = $parent_template_id ? $parent_template_data : $template_data;
$field_name = $this->rebuild_string_placeholder(
$field_name_template,
$field_template_data,
array(
'remove_suffix_if_empty' => $remove_suffix_if_empty,
// placeholder's suffix, not placeholder named %%suffix%%
'suffix' => '_',
)
);
// Replace field attribute value's placeholder
$field = array();
if ( is_array( $field_template ) ) {
foreach ( $field_template as $attr_name => $attr_value ) {
$rebuilt_attr_value = $this->rebuild_field_attr_value(
$attr_name,
$attr_value,
$field_template_data
);
// Omit attribute with empty value: existance of attribute even with empty
// string value is handled differently in many field (ie, `show_if`)
if ( '' === $rebuilt_attr_value ) {
continue;
}
$field[ $attr_name ] = $rebuilt_attr_value;
}
} else {
$fields = array_merge(
$fields,
$this->rebuild_field_template( $field_name_template, $template_id )
);
}
// `name` attribute is dynamically added based on field's array key
$field['name'] = $field_name;
// Populate rebuilt field
$fields[ $field_name ] = $field;
}
// Cache result
$this->set_cache( $cache_name, $cache_key, $fields );
return $fields;
}
public function rebuild_default_props( $template_id ) {
// Check for cached result first for faster performance
$cache_name = 'default_props';
$cache_key = $template_id;
$cache = $this->get_cache( $cache_name, $cache_key );
if ( ! is_null( $cache ) ) {
return $cache;
}
$default_props = array();
$rebuilt_fields = $this->rebuild_field_template( $template_id );
foreach ( $rebuilt_fields as $field_name => $field ) {
$value = '';
if ( isset( $field['composite_type'], $field['composite_structure'] ) ) {
require_once ET_BUILDER_DIR . 'module/field/attribute/composite/Parser.php';
$composite_atts = ET_Builder_Module_Field_Attribute_Composite_Parser::parse( $field['composite_type'], $field['composite_structure'] );
$default_props = array_merge( $default_props, $composite_atts );
} else {
if ( isset( $field['default_on_front'] ) ) {
$value = $field['default_on_front'];
} elseif ( isset( $field['default'] ) ) {
$value = $field['default'];
}
$default_props[ $field_name ] = $value;
}
}
// Cache result
$this->set_cache( $cache_name, $cache_key, $default_props );
return $default_props;
}
}