HOME

Mini Shell 1.0
DIR:/home/cloudtechtree.com/www/wp-content/plugins/js_composer/include/helpers/
Current File : /home/cloudtechtree.com/www/wp-content/plugins/js_composer/include/helpers/helpers_api.php
<?php
if ( ! defined( 'ABSPATH' ) ) {
	die( '-1' );
}

/**
 * @param $attributes
 * @return bool
 * @throws \Exception
 */
function wpb_map( $attributes ) {
	return vc_map( $attributes );
}

/**
 * Lean map shortcodes
 *
 * @param $tag
 * @param null $settings_function
 * @param null $settings_file
 * @since 4.9
 *
 */
function vc_lean_map( $tag, $settings_function = null, $settings_file = null ) {
	WPBMap::leanMap( $tag, $settings_function, $settings_file );
}

/**
 * @param $attributes
 *
 * @return bool
 * @throws \Exception
 * @since 4.2
 */
function vc_map( $attributes ) {
	if ( ! isset( $attributes['base'] ) ) {
		throw new Exception( esc_html__( 'Wrong vc_map object. Base attribute is required', 'js_composer' ) );
	}

	return WPBMap::map( $attributes['base'], $attributes );
}

/**
 * @param $shortcode
 *
 * @since 4.2
 */
function vc_remove_element( $shortcode ) {
	WPBMap::dropShortcode( $shortcode );
}

/**
 * Add new shortcode param.
 *
 * @param $shortcode - tag for shortcode
 * @param $attributes - attribute settings
 * @throws \Exception
 * @since 4.2
 *
 */
function vc_add_param( $shortcode, $attributes ) {
	WPBMap::addParam( $shortcode, $attributes );
}

/**
 * Mass shortcode params adding function
 *
 * @param $shortcode - tag for shortcode
 * @param $attributes - list of attributes arrays
 * @throws \Exception
 * @since 4.3
 *
 */
function vc_add_params( $shortcode, $attributes ) {
	if ( is_array( $attributes ) ) {
		foreach ( $attributes as $attr ) {
			vc_add_param( $shortcode, $attr );
		}
	}
}

/**
 * Shorthand function for WPBMap::modify
 *
 * @param string $name
 * @param string $setting
 * @param string $value
 *
 * @return array|bool
 * @throws \Exception
 * @since 4.2
 */
function vc_map_update( $name = '', $setting = '', $value = '' ) {
	return WPBMap::modify( $name, $setting, $value );
}

/**
 * Shorthand function for WPBMap::mutateParam
 *
 * @param $name
 * @param array $attribute
 *
 * @return bool
 * @throws \Exception
 * @since 4.2
 */
function vc_update_shortcode_param( $name, $attribute = array() ) {
	return WPBMap::mutateParam( $name, $attribute );
}

/**
 * Shorthand function for WPBMap::dropParam
 *
 * @param $name
 * @param $attribute_name
 *
 * @return bool
 * @since 4.2
 */
function vc_remove_param( $name = '', $attribute_name = '' ) {
	return WPBMap::dropParam( $name, $attribute_name );
}

if ( ! function_exists( 'vc_set_as_theme' ) ) {
	/**
	 * Sets plugin as theme plugin.
	 *
	 * @internal param bool $disable_updater - If value is true disables auto updater options.
	 *
	 * @since 4.2
	 */
	function vc_set_as_theme() {
		vc_manager()->setIsAsTheme( true );
	}
}
if ( ! function_exists( 'vc_is_as_theme' ) ) {
	/**
	 * Is VC as-theme-plugin.
	 * @return bool
	 * @since 4.2
	 */
	function vc_is_as_theme() {
		return vc_manager()->isAsTheme();
	}
}
if ( ! function_exists( 'vc_is_updater_disabled' ) ) {
	/**
	 * @return bool
	 * @since 4.2
	 */
	function vc_is_updater_disabled() {
		return vc_manager()->isUpdaterDisabled();

	}
}
if ( ! function_exists( 'vc_default_editor_post_types' ) ) {
	/**
	 * Returns list of default post type.
	 * @return array
	 * @since 4.2
	 */
	function vc_default_editor_post_types() {
		return vc_manager()->editorDefaultPostTypes();
	}
}
if ( ! function_exists( 'vc_set_default_editor_post_types' ) ) {
	/**
	 * Set post types for VC editor.
	 * @param array $list - list of valid post types to set
	 * @since 4.2
	 *
	 */
	function vc_set_default_editor_post_types( array $list ) {
		vc_manager()->setEditorDefaultPostTypes( $list );
	}
}
if ( ! function_exists( ( 'vc_editor_post_types' ) ) ) {
	/**
	 * Returns list of post types where VC editor is enabled.
	 * @return array
	 * @since 4.2
	 */
	function vc_editor_post_types() {
		return vc_manager()->editorPostTypes();
	}
}
if ( ! function_exists( ( 'vc_editor_set_post_types' ) ) ) {
	/**
	 * Set list of post types where VC editor is enabled.
	 * @param array $post_types
	 * @throws \Exception
	 * @since 4.4
	 *
	 */
	function vc_editor_set_post_types( array $post_types ) {
		vc_manager()->setEditorPostTypes( $post_types );
	}
}
if ( ! function_exists( 'vc_mode' ) ) {
	/**
	 * Return current VC mode.
	 * @return string
	 * @see Vc_Mapper::$mode
	 * @since 4.2
	 */
	function vc_mode() {
		return vc_manager()->mode();
	}
}
if ( ! function_exists( 'vc_set_shortcodes_templates_dir' ) ) {
	/**
	 * Sets directory where WPBakery Page Builder should look for template files for content elements.
	 * @param string - full directory path to new template directory with trailing slash
	 * @since 4.2
	 *
	 */
	function vc_set_shortcodes_templates_dir( $dir ) {
		vc_manager()->setCustomUserShortcodesTemplateDir( $dir );
	}
}
if ( ! function_exists( 'vc_shortcodes_theme_templates_dir' ) ) {
	/**
	 * Get custom theme template path
	 * @param $template - filename for template
	 *
	 * @return string
	 * @since 4.2
	 *
	 */
	function vc_shortcodes_theme_templates_dir( $template ) {
		return vc_manager()->getShortcodesTemplateDir( $template );
	}
}

/**
 * @param bool $value
 *
 * @todo check usage.
 *
 * @since 4.3
 */
function set_vc_is_inline( $value = true ) {
	_deprecated_function( 'set_vc_is_inline', '5.2 (will be removed in 5.3)' );
	global $vc_is_inline;
	$vc_is_inline = $value;
}

/**
 * Disable frontend editor for VC
 * @param bool $disable
 * @since 4.3
 *
 */
function vc_disable_frontend( $disable = true ) {
	vc_frontend_editor()->disableInline( $disable );
}

/**
 * Check is front end enabled.
 * @return bool
 * @throws \Exception
 * @since 4.3
 */
function vc_enabled_frontend() {
	return vc_frontend_editor()->frontendEditorEnabled();
}

if ( ! function_exists( 'vc_add_default_templates' ) ) {
	/**
	 * Add custom template in default templates list
	 *
	 * @param array $data | template data (name, content, custom_class, image_path)
	 *
	 * @return bool
	 * @since 4.3
	 */
	function vc_add_default_templates( $data ) {
		return wpbakery()->templatesPanelEditor()->addDefaultTemplates( $data );
	}
}

/**
 * @param $shortcode
 * @param string $field_prefix
 * @param string $group_prefix
 * @param null $change_fields
 * @param null $dependency
 * @return array
 * @throws \Exception
 */
function vc_map_integrate_shortcode( $shortcode, $field_prefix = '', $group_prefix = '', $change_fields = null, $dependency = null ) {
	if ( is_string( $shortcode ) ) {
		$shortcode_data = WPBMap::getShortCode( $shortcode );
	} else {
		$shortcode_data = $shortcode;
	}
	if ( is_array( $shortcode_data ) && ! empty( $shortcode_data ) ) {
		/**
		 * @var WPBakeryShortCodeFishBones $shortcode
		 */
		$params = isset( $shortcode_data['params'] ) && ! empty( $shortcode_data['params'] ) ? $shortcode_data['params'] : false;
		if ( is_array( $params ) && ! empty( $params ) ) {
			$keys = array_keys( $params );
			$count = count( $keys );
			for ( $i = 0; $i < $count; $i ++ ) {
				$param = &$params[ $keys[ $i ] ]; // Note! passed by reference to automatically update data
				if ( isset( $change_fields ) ) {
					$param = vc_map_integrate_include_exclude_fields( $param, $change_fields );
					if ( empty( $param ) ) {
						continue;
					}
				}
				if ( ! empty( $group_prefix ) ) {
					if ( isset( $param['group'] ) ) {
						$param['group'] = $group_prefix . ': ' . $param['group'];
					} else {
						$param['group'] = $group_prefix;
					}
				}
				if ( ! empty( $field_prefix ) && isset( $param['param_name'] ) ) {
					$param['param_name'] = $field_prefix . $param['param_name'];
					if ( isset( $param['dependency'] ) && is_array( $param['dependency'] ) && isset( $param['dependency']['element'] ) ) {
						$param['dependency']['element'] = $field_prefix . $param['dependency']['element'];
					}
					$param = vc_map_integrate_add_dependency( $param, $dependency );

				} elseif ( ! empty( $dependency ) ) {
					$param = vc_map_integrate_add_dependency( $param, $dependency );
				}
				$param['integrated_shortcode'] = is_array( $shortcode ) ? $shortcode['base'] : $shortcode;
				$param['integrated_shortcode_field'] = $field_prefix;
			}
		}

		return is_array( $params ) ? array_filter( $params ) : array();
	}

	return array();
}

/**
 * Used to filter params (include/exclude)
 *
 * @param $param
 * @param $change_fields
 *
 * @return array|null
 * @internal
 *
 */
function vc_map_integrate_include_exclude_fields( $param, $change_fields ) {
	if ( is_array( $change_fields ) ) {
		if ( isset( $change_fields['exclude'] ) && in_array( $param['param_name'], $change_fields['exclude'], true ) ) {
			$param = null;

			return $param; // to prevent group adding to $param
		} elseif ( isset( $change_fields['exclude_regex'] ) ) {
			if ( is_array( $change_fields['exclude_regex'] ) && ! empty( $change_fields['exclude_regex'] ) ) {
				$break_foreach = false;
				foreach ( $change_fields['exclude_regex'] as $regex ) {
					/** @noinspection PhpUsageOfSilenceOperatorInspection */
					// @codingStandardsIgnoreLine
					if ( @preg_match( $regex, null ) ) {
						if ( preg_match( $regex, $param['param_name'] ) ) {
							$param = null;
							$break_foreach = true;
						}
					}
					if ( $break_foreach ) {
						break;
					}
				}
				if ( $break_foreach ) {
					return $param; // to prevent group adding to $param
				}
			} elseif ( is_string( $change_fields['exclude_regex'] ) && strlen( $change_fields['exclude_regex'] ) > 0 ) {
				/** @noinspection PhpUsageOfSilenceOperatorInspection */
				// @codingStandardsIgnoreLine
				if ( @preg_match( $change_fields['exclude_regex'], null ) ) {
					if ( preg_match( $change_fields['exclude_regex'], $param['param_name'] ) ) {
						$param = null;

						return $param; // to prevent group adding to $param
					}
				}
			}
		}

		if ( isset( $change_fields['include_only'] ) && ! in_array( $param['param_name'], $change_fields['include_only'], true ) ) {
			// if we want to enclude only some fields
			$param = null;

			return $param; // to prevent group adding to $param
		} elseif ( isset( $change_fields['include_only_regex'] ) ) {
			if ( is_array( $change_fields['include_only_regex'] ) && ! empty( $change_fields['include_only_regex'] ) ) {
				$break_foreach = false;
				foreach ( $change_fields['include_only_regex'] as $regex ) {
					/** @noinspection PhpUsageOfSilenceOperatorInspection */
					// @codingStandardsIgnoreLine
					if ( false === @preg_match( $regex, null ) ) {
						// Regular expression is invalid, (don't remove @).
					} else {
						if ( ! preg_match( $regex, $param['param_name'] ) ) {
							$param = null;
							$break_foreach = true;
						}
					}
					if ( $break_foreach ) {
						break;
					}
				}
				if ( $break_foreach ) {
					return $param; // to prevent group adding to $param
				}
			} elseif ( is_string( $change_fields['include_only_regex'] ) && strlen( $change_fields['include_only_regex'] ) > 0 ) {
				/** @noinspection PhpUsageOfSilenceOperatorInspection */
				// @codingStandardsIgnoreLine
				if ( false === @preg_match( $change_fields['include_only_regex'], null ) ) {
					// Regular expression is invalid, (don't remove @).
				} else {
					if ( ! preg_match( $change_fields['include_only_regex'], $param['param_name'] ) ) {
						$param = null;

						return $param; // to prevent group adding to $param
					}
				}
			}
		}
	}

	return $param;
}

/**
 * @param $param
 * @param $dependency
 *
 * @return array
 * @internal used to add dependency to existed param
 *
 */
function vc_map_integrate_add_dependency( $param, $dependency ) {
	// activator must be used for all elements who doesn't have 'dependency'
	if ( ! empty( $dependency ) && ( ! isset( $param['dependency'] ) || empty( $param['dependency'] ) ) ) {
		if ( is_array( $dependency ) ) {
			$param['dependency'] = $dependency;
		}
	}

	return $param;
}

/**
 * @param $base_shortcode
 * @param $integrated_shortcode
 * @param string $field_prefix
 * @return array
 * @throws \Exception
 */
function vc_map_integrate_get_params( $base_shortcode, $integrated_shortcode, $field_prefix = '' ) {
	$shortcode_data = WPBMap::getShortCode( $base_shortcode );
	$params = array();
	if ( is_array( $shortcode_data ) && is_array( $shortcode_data['params'] ) && ! empty( $shortcode_data['params'] ) ) {
		foreach ( $shortcode_data['params'] as $param ) {
			if ( is_array( $param ) && isset( $param['integrated_shortcode'] ) && $integrated_shortcode === $param['integrated_shortcode'] ) {
				if ( ! empty( $field_prefix ) ) {
					if ( isset( $param['integrated_shortcode_field'] ) && $field_prefix === $param['integrated_shortcode_field'] ) {
						$params[] = $param;
					}
				} else {
					$params[] = $param;
				}
			}
		}
	}

	return $params;
}

/**
 * @param $base_shortcode
 * @param $integrated_shortcode
 * @param string $field_prefix
 * @return array
 * @throws \Exception
 */
function vc_map_integrate_get_atts( $base_shortcode, $integrated_shortcode, $field_prefix = '' ) {
	$params = vc_map_integrate_get_params( $base_shortcode, $integrated_shortcode, $field_prefix );
	$atts = array();
	if ( is_array( $params ) && ! empty( $params ) ) {
		foreach ( $params as $param ) {
			$value = '';
			if ( isset( $param['value'] ) ) {
				if ( isset( $param['std'] ) ) {
					$value = $param['std'];
				} elseif ( is_array( $param['value'] ) ) {
					reset( $param['value'] );
					$value = current( $param['value'] );
				} else {
					$value = $param['value'];
				}
			}
			$atts[ $param['param_name'] ] = $value;
		}
	}

	return $atts;
}

/**
 * @param $base_shortcode
 * @param $integrated_shortcode
 * @param $atts
 * @param string $field_prefix
 * @return array
 * @throws \Exception
 */
function vc_map_integrate_parse_atts( $base_shortcode, $integrated_shortcode, $atts, $field_prefix = '' ) {
	$params = vc_map_integrate_get_params( $base_shortcode, $integrated_shortcode, $field_prefix );
	$data = array();
	if ( is_array( $params ) && ! empty( $params ) ) {
		foreach ( $params as $param ) {
			$value = '';
			if ( isset( $atts[ $param['param_name'] ] ) ) {
				$value = $atts[ $param['param_name'] ];
			}
			if ( isset( $value ) ) {
				$key = $param['param_name'];
				if ( strlen( $field_prefix ) > 0 ) {
					$key = substr( $key, strlen( $field_prefix ) );
				}
				$data[ $key ] = $value;
			}
		}
	}

	return $data;
}

/**
 * @param bool $label
 * @return mixed|void
 */
function vc_map_add_css_animation( $label = true ) {
	$data = array(
		'type' => 'animation_style',
		'heading' => esc_html__( 'CSS Animation', 'js_composer' ),
		'param_name' => 'css_animation',
		'admin_label' => $label,
		'value' => '',
		'settings' => array(
			'type' => 'in',
			'custom' => array(
				array(
					'label' => esc_html__( 'Default', 'js_composer' ),
					'values' => array(
						esc_html__( 'Top to bottom', 'js_composer' ) => 'top-to-bottom',
						esc_html__( 'Bottom to top', 'js_composer' ) => 'bottom-to-top',
						esc_html__( 'Left to right', 'js_composer' ) => 'left-to-right',
						esc_html__( 'Right to left', 'js_composer' ) => 'right-to-left',
						esc_html__( 'Appear from center', 'js_composer' ) => 'appear',
					),
				),
			),
		),
		'description' => esc_html__( 'Select type of animation for element to be animated when it "enters" the browsers viewport (Note: works only in modern browsers).', 'js_composer' ),
	);

	return apply_filters( 'vc_map_add_css_animation', $data, $label );
}

/**
 * Get settings of the mapped shortcode.
 *
 * @param $tag
 *
 * @return array|null - settings or null if shortcode not mapped
 * @throws \Exception
 * @since 4.4.3
 */
function vc_get_shortcode( $tag ) {
	return WPBMap::getShortCode( $tag );
}

/**
 * Remove all mapped shortcodes and the moment when function is called.
 *
 * @since 4.5
 */
function vc_remove_all_elements() {
	WPBMap::dropAllShortcodes();
}

/**
 * Function to get defaults values for shortcode.
 * @param $tag - shortcode tag
 *
 * @return array - list of param=>default_value
 * @throws \Exception
 * @since 4.6
 *
 */
function vc_map_get_defaults( $tag ) {
	$shortcode = vc_get_shortcode( $tag );
	$params = array();
	if ( is_array( $shortcode ) && isset( $shortcode['params'] ) && ! empty( $shortcode['params'] ) ) {
		$params = vc_map_get_params_defaults( $shortcode['params'] );
	}

	return $params;
}

/**
 * @param $params
 *
 * @return array
 * @since 4.12
 */
function vc_map_get_params_defaults( $params ) {
	$resultParams = array();
	foreach ( $params as $param ) {
		if ( isset( $param['param_name'] ) && 'content' !== $param['param_name'] ) {
			$value = '';
			if ( isset( $param['std'] ) ) {
				$value = $param['std'];
			} elseif ( isset( $param['value'] ) ) {
				if ( is_array( $param['value'] ) ) {
					$value = current( $param['value'] );
					if ( is_array( $value ) ) {
						// in case if two-dimensional array provided (vc_basic_grid)
						$value = current( $value );
					}
					// return first value from array (by default)
				} else {
					$value = $param['value'];
				}
			}
			$resultParams[ $param['param_name'] ] = apply_filters( 'vc_map_get_param_defaults', $value, $param );
		}
	}

	return $resultParams;
}

/**
 * @param $tag - shortcode tag3
 * @param array $atts - shortcode attributes
 *
 * @return array - return merged values with provided attributes (
 *     'a'=>1,'b'=>2 + 'b'=>3,'c'=>4 --> 'a'=>1,'b'=>3 )
 *
 * @throws \Exception
 * @see vc_shortcode_attribute_parse - return union of provided attributes (
 *     'a'=>1,'b'=>2 + 'b'=>3,'c'=>4 --> 'a'=>1,
 *     'b'=>3, 'c'=>4 )
 */
function vc_map_get_attributes( $tag, $atts = array() ) {
	$atts = shortcode_atts( vc_map_get_defaults( $tag ), $atts, $tag );

	return apply_filters( 'vc_map_get_attributes', $atts, $tag );
}

/**
 * @param $name
 * @return mixed|string
 */
function vc_convert_vc_color( $name ) {
	$colors = array(
		'blue' => '#5472d2',
		'turquoise' => '#00c1cf',
		'pink' => '#fe6c61',
		'violet' => '#8d6dc4',
		'peacoc' => '#4cadc9',
		'chino' => '#cec2ab',
		'mulled-wine' => '#50485b',
		'vista-blue' => '#75d69c',
		'orange' => '#f7be68',
		'sky' => '#5aa1e3',
		'green' => '#6dab3c',
		'juicy-pink' => '#f4524d',
		'sandy-brown' => '#f79468',
		'purple' => '#b97ebb',
		'black' => '#2a2a2a',
		'grey' => '#ebebeb',
		'white' => '#ffffff',
	);
	$name = str_replace( '_', '-', $name );
	if ( isset( $colors[ $name ] ) ) {
		return $colors[ $name ];
	}

	return '';
}

/**
 * Extract width/height from string
 *
 * @param string $dimensions WxH
 *
 * @return mixed array(width, height) or false
 * @since 4.7
 *
 */
function vc_extract_dimensions( $dimensions ) {
	$dimensions = str_replace( ' ', '', $dimensions );
	$matches = null;

	if ( preg_match( '/(\d+)x(\d+)/', $dimensions, $matches ) ) {
		return array(
			$matches[1],
			$matches[2],
		);
	}

	return false;
}

/**
 * @param string $asset
 *
 * @return array|string
 */
function vc_get_shared( $asset = '' ) {
	switch ( $asset ) {
		case 'colors':
			$asset = VcSharedLibrary::getColors();
			break;

		case 'colors-dashed':
			$asset = VcSharedLibrary::getColorsDashed();
			break;

		case 'icons':
			$asset = VcSharedLibrary::getIcons();
			break;

		case 'sizes':
			$asset = VcSharedLibrary::getSizes();
			break;

		case 'button styles':
		case 'alert styles':
			$asset = VcSharedLibrary::getButtonStyles();
			break;
		case 'message_box_styles':
			$asset = VcSharedLibrary::getMessageBoxStyles();
			break;
		case 'cta styles':
			$asset = VcSharedLibrary::getCtaStyles();
			break;

		case 'text align':
			$asset = VcSharedLibrary::getTextAlign();
			break;

		case 'cta widths':
		case 'separator widths':
			$asset = VcSharedLibrary::getElementWidths();
			break;

		case 'separator styles':
			$asset = VcSharedLibrary::getSeparatorStyles();
			break;

		case 'separator border widths':
			$asset = VcSharedLibrary::getBorderWidths();
			break;

		case 'single image styles':
			$asset = VcSharedLibrary::getBoxStyles();
			break;

		case 'single image external styles':
			$asset = VcSharedLibrary::getBoxStyles( array(
				'default',
				'round',
			) );
			break;

		case 'toggle styles':
			$asset = VcSharedLibrary::getToggleStyles();
			break;

		case 'animation styles':
			$asset = VcSharedLibrary::getAnimationStyles();
			break;
	}

	return $asset;
}

/**
 * Helper function to register new shortcode attribute hook.
 *
 * @param $name - attribute name
 * @param $form_field_callback - hook, will be called when settings form is shown and attribute added to shortcode
 *     param list
 * @param $script_url - javascript file url which will be attached at the end of settings form.
 *
 * @return bool
 * @since 4.4
 */
function vc_add_shortcode_param( $name, $form_field_callback, $script_url = null ) {
	return WpbakeryShortcodeParams::addField( $name, $form_field_callback, $script_url );
}

/**
 * Call hook for attribute.
 *
 * @param $name - attribute name
 * @param $param_settings - attribute settings from shortcode
 * @param $param_value - attribute value
 * @param $tag - attribute tag
 *
 * @return mixed|string - returns html which will be render in hook
 * @since 4.4
 */
function vc_do_shortcode_param_settings_field( $name, $param_settings, $param_value, $tag ) {
	return WpbakeryShortcodeParams::renderSettingsField( $name, $param_settings, $param_value, $tag );
}