File: /var/www/vhosts/ensaco.es/httpdocs/wp-content/plugins/bb-plugin/classes/class-fl-builder-fonts.php
<?php
/**
* Helper class for font settings.
*
* @class FLBuilderFonts
* @since 1.6.3
*/
final class FLBuilderFonts {
/**
* An array of fonts / weights.
* @var array
*/
private static $fonts = array();
private static $enqueued_google_fonts_done = false;
public static $preload_fa5 = array();
/**
* @since 1.9.5
* @return void
*/
static public function init() {
add_filter( 'the_content', __CLASS__ . '::combine_google_fonts', 11 );
add_action( 'wp_enqueue_scripts', __CLASS__ . '::combine_google_fonts', 10000 );
add_action( 'wp_enqueue_scripts', __CLASS__ . '::enqueue_google_fonts', 9999 );
add_filter( 'wp_resource_hints', __CLASS__ . '::resource_hints', 10, 2 );
add_action( 'wp_head', array( __CLASS__, 'preload' ), 5 );
add_action( 'fl_builder_cache_cleared', array( __CLASS__, 'clear_transient' ), 11 );
}
static public function clear_transient() {
delete_transient( 'fl_builder_google_json' );
}
static public function preload() {
$fa_version = FLBuilder::get_fa5_version();
$icons = array(
'foundation-icons' => array(
'https://cdnjs.cloudflare.com/ajax/libs/foundicons/3.0.0/foundation-icons.woff',
),
'font-awesome-5' => array(),
);
foreach ( array_unique( FLBuilderFonts::$preload_fa5 ) as $type ) {
switch ( $type ) {
case 'fas':
$icons['font-awesome-5'][] = FLBuilder::plugin_url() . 'fonts/fontawesome/' . $fa_version . '/webfonts/fa-solid-900.woff2';
break;
case 'far':
$icons['font-awesome-5'][] = FLBuilder::plugin_url() . 'fonts/fontawesome/' . $fa_version . '/webfonts/fa-regular-400.woff2';
break;
case 'fab':
$icons['font-awesome-5'][] = FLBuilder::plugin_url() . 'fonts/fontawesome/' . $fa_version . '/webfonts/fa-brands-400.woff2';
break;
}
}
// if using pro cdn do not preload as we have no idea what the url will be.
if ( get_option( '_fl_builder_enable_fa_pro', false ) || apply_filters( 'fl_enable_fa5_pro', false ) || empty( $icons['font-awesome-5'] ) ) {
unset( $icons['font-awesome-5'] );
}
foreach ( $icons as $key => $preloads ) {
if ( wp_style_is( $key, 'enqueued' ) ) {
foreach ( $preloads as $url ) {
printf( '<link rel="preload" href="%s" as="font" type="font/woff2" crossorigin="anonymous">' . "\n", $url );
}
}
}
}
/**
* Renders the JavasCript variable for font settings dropdowns.
*
* @since 1.6.3
* @return void
*/
static public function js() {
/**
* @see fl_builder_font_families_default
*/
$default = json_encode( apply_filters( 'fl_builder_font_families_default', FLBuilderFontFamilies::$default ) );
/**
* @see fl_builder_font_families_system
*/
$system = json_encode( apply_filters( 'fl_builder_font_families_system', FLBuilderFontFamilies::$system ) );
/**
* @see fl_builder_font_families_google
*/
$google = json_encode( apply_filters( 'fl_builder_font_families_google', self::prepare_google_fonts( FLBuilderFontFamilies::google() ) ) );
echo 'var FLBuilderFontFamilies = { default: ' . $default . ', system: ' . $system . ', google: ' . $google . ' };';
}
static public function prepare_google_fonts( $fonts ) {
foreach ( $fonts as $family => $variants ) {
foreach ( $variants as $k => $variant ) {
if ( 'italic' == $variant || 'i' == substr( $variant, -1 ) ) {
unset( $fonts[ $family ][ $k ] );
}
}
}
return $fonts;
}
/**
* Renders a list of all available fonts.
*
* @since 1.6.3
* @param string $font The current selected font.
* @return void
*/
static public function display_select_font( $font ) {
$system_fonts = apply_filters( 'fl_builder_font_families_system', FLBuilderFontFamilies::$system );
$google_fonts = apply_filters( 'fl_builder_font_families_google', FLBuilderFontFamilies::google() );
$recent_fonts = get_option( 'fl_builder_recent_fonts', array() );
// Check if font is valid
foreach ( $recent_fonts as $name => $variants ) {
if ( ! array_key_exists( $name, $google_fonts ) && ! array_key_exists( $name, $system_fonts ) ) {
unset( $recent_fonts[ $name ] );
}
}
echo '<option value="Default" ' . selected( 'Default', $font, false ) . '>' . __( 'Default', 'fl-builder' ) . '</option>';
if ( is_array( $recent_fonts ) && ! empty( $recent_fonts ) ) {
echo '<optgroup label="Recently Used" class="recent-fonts">';
foreach ( $recent_fonts as $name => $variants ) {
if ( 'Default' == $name ) {
continue;
}
echo '<option value="' . $name . '">' . $name . '</option>';
}
}
echo '<optgroup label="System">';
foreach ( $system_fonts as $name => $variants ) {
echo '<option value="' . $name . '" ' . selected( $name, $font, false ) . '>' . $name . '</option>';
}
echo '<optgroup label="Google">';
foreach ( $google_fonts as $name => $variants ) {
echo '<option value="' . $name . '" ' . selected( $name, $font, false ) . '>' . $name . '</option>';
}
}
/**
* Renders a list of all available weights for a selected font.
*
* @since 1.6.3
* @param string $font The current selected font.
* @param string $weight The current selected weight.
* @return void
*/
static public function display_select_weight( $font, $weight ) {
if ( 'Default' == $font ) {
echo '<option value="default" selected="selected">' . __( 'Default', 'fl-builder' ) . '</option>';
} else {
$system_fonts = apply_filters( 'fl_builder_font_families_system', FLBuilderFontFamilies::$system );
$google_fonts = apply_filters( 'fl_builder_font_families_google', FLBuilderFontFamilies::google() );
if ( array_key_exists( $font, $system_fonts ) ) {
foreach ( $system_fonts[ $font ]['weights'] as $variant ) {
echo '<option value="' . $variant . '" ' . selected( $variant, $weight, false ) . '>' . FLBuilderFonts::get_weight_string( $variant ) . '</option>';
}
} else {
foreach ( $google_fonts[ $font ] as $variant ) {
echo '<option value="' . $variant . '" ' . selected( $variant, $weight, false ) . '>' . FLBuilderFonts::get_weight_string( $variant ) . '</option>';
}
}
}
}
/**
* Returns a font weight name for a respective weight.
*
* @since 1.6.3
* @param string $weight The selected weight.
* @return string The weight name.
*/
static public function get_weight_string( $weight ) {
$weight_string = self::get_font_weight_strings();
return $weight_string[ $weight ];
}
/**
* Return font weight strings.
*/
static public function get_font_weight_strings() {
/**
* Array of font weights
* @see fl_builder_font_weight_strings
*/
return apply_filters( 'fl_builder_font_weight_strings', array(
'default' => __( 'Default', 'fl-builder' ),
'regular' => __( 'Regular', 'fl-builder' ),
'italic' => __( 'Italic', 'fl-builder' ),
'100' => __( 'Thin', 'fl-builder' ),
'100i' => __( 'Thin Italic', 'fl-builder' ),
'100italic' => __( 'Thin Italic', 'fl-builder' ),
'200' => __( 'Extra-Light', 'fl-builder' ),
'200i' => __( 'Extra-Light Italic', 'fl-builder' ),
'200italic' => __( 'Extra-Light Italic', 'fl-builder' ),
'300' => __( 'Light', 'fl-builder' ),
'300i' => __( 'Light Italic', 'fl-builder' ),
'300italic' => __( 'Light Italic', 'fl-builder' ),
'400' => __( 'Normal', 'fl-builder' ),
'400i' => __( 'Normal Italic', 'fl-builder' ),
'400italic' => __( 'Normal Italic', 'fl-builder' ),
'500' => __( 'Medium', 'fl-builder' ),
'500i' => __( 'Medium Italic', 'fl-builder' ),
'500italic' => __( 'Medium Italic', 'fl-builder' ),
'600' => __( 'Semi-Bold', 'fl-builder' ),
'600i' => __( 'Semi-Bold Italic', 'fl-builder' ),
'600italic' => __( 'Semi-Bold Italic', 'fl-builder' ),
'700' => __( 'Bold', 'fl-builder' ),
'700i' => __( 'Bold Italic', 'fl-builder' ),
'700italic' => __( 'Bold Italic', 'fl-builder' ),
'800' => __( 'Extra-Bold', 'fl-builder' ),
'800i' => __( 'Extra-Bold Italic', 'fl-builder' ),
'800italic' => __( 'Extra-Bold Italic', 'fl-builder' ),
'900' => __( 'Ultra-Bold', 'fl-builder' ),
'900i' => __( 'Ultra-Bold Italic', 'fl-builder' ),
'900italic' => __( 'Ultra-Bold Italic', 'fl-builder' ),
) );
}
/**
* Helper function to render css styles for a selected font.
*
* @since 1.6.3
* @param array $font An array with font-family and weight.
* @return void
*/
static public function font_css( $font ) {
$system_fonts = apply_filters( 'fl_builder_font_families_system', FLBuilderFontFamilies::$system );
$google = FLBuilderFontFamilies::get_google_fallback( $font['family'] );
$css = '';
if ( array_key_exists( $font['family'], $system_fonts ) ) {
$css .= 'font-family: "' . $font['family'] . '",' . $system_fonts[ $font['family'] ]['fallback'] . ';';
} elseif ( $google ) {
$css .= 'font-family: "' . $font['family'] . '", ' . $google . ';';
} else {
$css .= 'font-family: "' . $font['family'] . '", sans-serif;';
}
if ( 'regular' == $font['weight'] ) {
$css .= 'font-weight: normal;';
} else {
if ( 'i' == substr( $font['weight'], -1 ) ) {
$css .= 'font-weight: ' . substr( $font['weight'], 0, -1 ) . ';';
$css .= 'font-style: italic;';
} elseif ( 'italic' == $font['weight'] ) {
$css .= 'font-style: italic;';
} else {
$css .= 'font-weight: ' . $font['weight'] . ';';
}
}
echo $css;
}
/**
* Add fonts to the $font array for global styles.
*
* @return void
*/
static public function add_fonts_for_global_css( $settings ) {
$google = FLBuilderFontFamilies::google();
$fields = array(
'text_typography',
'h1_typography',
'h2_typography',
'h3_typography',
'h4_typography',
'h5_typography',
'h6_typography',
'link_typography',
'button_typography',
);
foreach ( $fields as $field ) {
if ( empty( $settings->{ $field } ) ) {
continue;
}
$font = $settings->{ $field }['font_family'];
$weight = isset( $settings->{ $field }['font_weight'] ) && '' !== $settings->{ $field }['font_weight'] ? $settings->{ $field }['font_weight'] : '400';
// handle google italics.
if ( isset( $google[ $font ] ) ) {
$selected_weight = $weight;
$italic = ( isset( $settings->{ $field }['font_style'] ) ) ? $settings->{ $field }['font_style'] : '';
if ( ! $italic && count( $google[ $font ] ) === 1 && 'italic' === $google[ $font ][0] ) {
$italic = 'italic';
}
if ( in_array( $selected_weight . 'i', $google[ $font ] ) && 'italic' == $italic ) {
$weight = $selected_weight . 'i';
}
if ( ( '400' == $selected_weight || 'regular' == $selected_weight ) && 'italic' == $italic && in_array( 'italic', $google[ $font ] ) ) {
$weight = '400i';
}
}
if ( 'Molle' === $settings->{ $field }['font_family'] ) {
$weight = 'i';
}
self::add_font( array(
'family' => $settings->{ $field }['font_family'],
'weight' => $weight,
) );
}
}
/**
* Add fonts to the $font array for a module.
*
* @since 1.6.3
* @param object $module The respective module.
* @return void
*/
static public function add_fonts_for_module( $module ) {
$fields = FLBuilderModel::get_settings_form_fields( $module->form );
// needed for italics.
$google = FLBuilderFontFamilies::google();
$bold = false;
if ( $module instanceof FLRichTextModule || $module instanceof FLListModule ) {
$bold = true;
}
foreach ( $fields as $name => $field ) {
if ( 'font' == $field['type'] && isset( $module->settings->$name ) ) {
self::add_font( $module->settings->$name );
} elseif ( 'typography' == $field['type'] && ! empty( $module->settings->$name ) && isset( $module->settings->{ $name }['font_family'] ) ) {
$fname = $module->settings->{ $name }['font_family'];
$weight = isset( $module->settings->{ $name }['font_weight'] ) && '' !== $module->settings->{ $name }['font_weight'] ? $module->settings->{ $name }['font_weight'] : '400';
// handle google italics.
if ( isset( $google[ $fname ] ) ) {
$selected_weight = $weight;
$italic = ( isset( $module->settings->{ $name }['font_style'] ) ) ? $module->settings->{ $name }['font_style'] : '';
if ( ! $italic && count( $google[ $fname ] ) === 1 && 'italic' === $google[ $fname ][0] ) {
$italic = 'italic';
}
if ( in_array( $selected_weight . 'i', $google[ $fname ] ) && 'italic' == $italic ) {
$weight = $selected_weight . 'i';
}
if ( ( '400' == $selected_weight || 'regular' == $selected_weight ) && 'italic' == $italic && in_array( 'italic', $google[ $fname ] ) ) {
$weight = '400i';
}
}
if ( 'Molle' === $module->settings->{ $name }['font_family'] ) {
$weight = 'i';
}
self::add_font( array(
'family' => $module->settings->{ $name }['font_family'],
'weight' => $weight,
), $bold );
} elseif ( isset( $field['form'] ) ) {
$form = FLBuilderModel::$settings_forms[ $field['form'] ];
self::add_fonts_for_nested_module_form( $module, $form['tabs'], $name );
}
}
}
/**
* Add fonts to the $font array for a nested module form.
*
* @since 1.8.6
* @access private
* @param object $module The module to add for.
* @param array $form The nested form.
* @param string $setting The nested form setting key.
* @return void
*/
static private function add_fonts_for_nested_module_form( $module, $form, $setting ) {
$fields = FLBuilderModel::get_settings_form_fields( $form );
foreach ( $fields as $name => $field ) {
if ( 'font' == $field['type'] && isset( $module->settings->$setting ) ) {
foreach ( $module->settings->$setting as $key => $val ) {
if ( isset( $val->$name ) ) {
self::add_font( (array) $val->$name );
} elseif ( $name == $key && ! empty( $val ) ) {
self::add_font( (array) $val );
}
}
}
}
}
/**
* Enqueue the stylesheet for fonts.
*
* @since 1.6.3
* @return void
*/
static public function enqueue_styles() {
return false;
}
/**
* @since 2.1.3
*/
static public function enqueue_google_fonts() {
/**
* Google fonts domain
* @see fl_builder_google_fonts_domain
*/
$google_fonts_domain = apply_filters( 'fl_builder_google_fonts_domain', 'https://fonts.googleapis.com/' );
$google_url = $google_fonts_domain . 'css?family=';
/**
* Allow users to control what fonts are enqueued by modules.
* Returning array() will disable all enqueues.
* @see fl_builder_google_fonts_pre_enqueue
* @link https://docs.wpbeaverbuilder.com/beaver-builder/developer/how-to-tips/load-google-fonts-locally-gdpr
*/
if ( count( apply_filters( 'fl_builder_google_fonts_pre_enqueue', self::$fonts ) ) > 0 ) {
foreach ( self::$fonts as $family => $weights ) {
$google_url .= $family . ':' . implode( ',', $weights ) . '|';
}
$google_url = substr( $google_url, 0, -1 );
if ( true === apply_filters( 'fl_enable_google_fonts_enqueue', true ) ) {
wp_enqueue_style( 'fl-builder-google-fonts-' . md5( $google_url ), $google_url, array() );
}
self::$fonts = array();
}
}
/**
* Adds data to the $fonts array for a font to be rendered.
*
* @since 1.6.3
* @param array $font an array with the font family and weight to add.
* @return void
*/
static public function add_font( $font, $bold = false ) {
$recent_fonts_db = get_option( 'fl_builder_recent_fonts', array() );
$recent_fonts = array();
if ( is_array( $font ) && isset( $font['family'] ) && isset( $font['weight'] ) && 'Default' != $font['family'] ) {
$system_fonts = apply_filters( 'fl_builder_font_families_system', FLBuilderFontFamilies::$system );
// check if is a Google Font
if ( ! array_key_exists( $font['family'], $system_fonts ) ) {
// check if font family is already added
if ( array_key_exists( $font['family'], self::$fonts ) ) {
// check if the weight is already added
if ( ! in_array( $font['weight'], self::$fonts[ $font['family'] ] ) ) {
self::$fonts[ $font['family'] ][] = $font['weight'];
}
} else {
// adds a new font and weight
self::$fonts[ $font['family'] ] = array( $font['weight'] );
}
if ( $bold ) {
self::$fonts[ $font['family'] ][] = ( strstr( $font['weight'], 'i' ) ) ? '700i' : '700';
}
self::$fonts[ $font['family'] ] = array_unique( self::$fonts[ $font['family'] ] );
}
if ( ! isset( $recent_fonts_db[ $font['family'] ] ) ) {
$recent_fonts[ $font['family'] ] = $font['weight'];
}
}
$recent = array_merge( (array) $recent_fonts, (array) $recent_fonts_db );
if ( isset( $_GET['fl_builder'] ) && ! empty( $recent ) && serialize( $recent ) !== serialize( $recent_fonts_db ) ) {
FLBuilderUtils::update_option( 'fl_builder_recent_fonts', array_slice( $recent, -11 ), true );
}
}
/**
* Combines all enqueued google font HTTP calls into one URL.
*
* @since 1.9.5
* @return void
*/
static public function combine_google_fonts( $content = false ) {
global $wp_styles;
// Check for any enqueued `fonts.googleapis.com` from BB theme or plugin
if ( isset( $wp_styles->queue ) ) {
/**
* @see fl_builder_combine_google_fonts_domain
*/
$google_fonts_domain = apply_filters( 'fl_builder_combine_google_fonts_domain', '//fonts.googleapis.com/css' );
$enqueued_google_fonts = array();
$families = array();
$subsets = array();
$font_args = array();
// Collect all enqueued google fonts
foreach ( $wp_styles->queue as $key => $handle ) {
if ( ! isset( $wp_styles->registered[ $handle ] ) || strpos( $handle, 'fl-builder-google-fonts-' ) === false ) {
continue;
}
$style_src = $wp_styles->registered[ $handle ]->src;
if ( strpos( $style_src, 'fonts.googleapis.com/css' ) !== false ) {
$url = wp_parse_url( $style_src );
if ( is_string( $url['query'] ) ) {
parse_str( $url['query'], $parsed_url );
if ( isset( $parsed_url['family'] ) ) {
// Collect all subsets
if ( isset( $parsed_url['subset'] ) ) {
$subsets[] = urlencode( trim( $parsed_url['subset'] ) );
}
$font_families = explode( '|', $parsed_url['family'] );
foreach ( $font_families as $parsed_font ) {
$get_font = explode( ':', $parsed_font );
// Extract the font data
if ( isset( $get_font[0] ) && ! empty( $get_font[0] ) ) {
$family = $get_font[0];
$weights = isset( $get_font[1] ) && ! empty( $get_font[1] ) ? explode( ',', $get_font[1] ) : array();
// Combine weights if family has been enqueued
if ( isset( $enqueued_google_fonts[ $family ] ) && $weights != $enqueued_google_fonts[ $family ]['weights'] ) {
$combined_weights = array_merge( $weights, $enqueued_google_fonts[ $family ]['weights'] );
$enqueued_google_fonts[ $family ]['weights'] = array_unique( $combined_weights );
} else {
$enqueued_google_fonts[ $family ] = array(
'handle' => $handle,
'family' => $family,
'weights' => $weights,
);
}
// Remove enqueued google font style, so we would only have one HTTP request.
wp_dequeue_style( $handle );
}
}
}
}
}
}
// Start combining all enqueued google fonts
if ( count( $enqueued_google_fonts ) > 0 ) {
foreach ( $enqueued_google_fonts as $family => $data ) {
// Collect all family and weights
if ( ! empty( $data['weights'] ) ) {
$families[] = $family . ':' . implode( ',', $data['weights'] );
} else {
$families[] = $family;
}
}
if ( ! empty( $families ) ) {
$font_args['family'] = implode( '|', $families );
if ( ! empty( $subsets ) ) {
$font_args['subset'] = implode( ',', $subsets );
}
/**
* Array of extra args passed to google fonts.
* @see fl_builder_google_font_args
*/
$font_args = apply_filters( 'fl_builder_google_font_args', $font_args );
$src = add_query_arg( $font_args, $google_fonts_domain );
// Enqueue google fonts into one URL request
wp_enqueue_style(
'fl-builder-google-fonts-' . md5( $src ),
$src,
array()
);
self::$enqueued_google_fonts_done = true;
// Clears data
$enqueued_google_fonts = array();
}
}
}
return $content;
}
/**
* Preconnect to fonts.gstatic.com to speed up google fonts.
* @since 2.1.5
*/
static public function resource_hints( $urls, $relation_type ) {
if ( true == self::$enqueued_google_fonts_done && 'preconnect' === $relation_type ) {
$urls[] = array(
'href' => 'https://fonts.gstatic.com',
'crossorigin',
);
}
return $urls;
}
/**
* Find font fallback, used by FLBuilderCSS
* @since 2.2
*/
static public function get_font_fallback( $font_family ) {
$fallback = 'sans-serif';
$default = apply_filters( 'fl_builder_font_families_default', FLBuilderFontFamilies::$default );
$system = apply_filters( 'fl_builder_font_families_system', FLBuilderFontFamilies::$system );
$google = apply_filters( 'fl_builder_font_families_google', FLBuilderFontFamilies::google() );
foreach ( $default as $font => $data ) {
if ( $font_family == $font && isset( $data['fallback'] ) ) {
$fallback = $data['fallback'];
}
}
foreach ( $system as $font => $data ) {
if ( $font_family == $font && isset( $data['fallback'] ) ) {
$fallback = $data['fallback'];
}
}
foreach ( $google as $font => $data ) {
if ( $font_family == $font ) {
$fallback = FLBuilderFontFamilies::get_google_fallback( $font );
}
}
return $fallback;
}
}
FLBuilderFonts::init();
/**
* Font info class for system and Google fonts.
*
* @class FLFontFamilies
* @since 1.6.3
*/
// phpcs:ignore Generic.Files.OneObjectStructurePerFile.MultipleFound
final class FLBuilderFontFamilies {
/**
* Cache for google fonts
*/
static private $_google_json = array();
static private $_google_fonts = false;
static private $_google_run = 0;
/**
* Array with a list of default font weights.
* @var array
*/
static public $default = array(
'Default' => array(
'default',
'100',
'200',
'300',
'400',
'500',
'600',
'700',
'800',
'900',
),
);
/**
* Array with a list of system fonts.
* @var array
*/
static public $system = array(
'Helvetica' => array(
'fallback' => 'Verdana, Arial, sans-serif',
'weights' => array(
'300',
'400',
'700',
),
),
'Verdana' => array(
'fallback' => 'Helvetica, Arial, sans-serif',
'weights' => array(
'300',
'400',
'700',
),
),
'Arial' => array(
'fallback' => 'Helvetica, Verdana, sans-serif',
'weights' => array(
'300',
'400',
'700',
),
),
'Times' => array(
'fallback' => 'Georgia, serif',
'weights' => array(
'300',
'400',
'700',
),
),
'Georgia' => array(
'fallback' => 'Times, serif',
'weights' => array(
'300',
'400',
'700',
),
),
'Courier' => array(
'fallback' => 'monospace',
'weights' => array(
'300',
'400',
'700',
),
),
);
/**
* Parse fonts.json to get all possible Google fonts.
* @since 1.10.7
* @return array
*/
public static function google() {
if ( false !== self::$_google_fonts ) {
return self::$_google_fonts;
}
$fonts = array();
$json = self::_get_json();
foreach ( $json as $k => $font ) {
$name = key( $font );
foreach ( $font[ $name ]['variants'] as $key => $variant ) {
if ( 'italic' !== $variant ) {
if ( stristr( $variant, 'italic' ) ) {
$font[ $name ]['variants'][ $key ] = str_replace( 'talic', '', $variant );
}
}
if ( 'regular' == $variant ) {
$font[ $name ]['variants'][ $key ] = '400';
}
}
$fonts[ $name ] = $font[ $name ]['variants'];
}
// only cache after 1st run to save rams.
if ( self::$_google_run > 0 ) {
self::$_google_fonts = $fonts;
}
self::$_google_run++;
return $fonts;
}
/**
* @since 2.1.5
*/
static private function _get_json() {
if ( ! empty( self::$_google_json ) ) {
$json = self::$_google_json;
} else {
$json = self::try_cached_google();
if ( ! $json ) {
$json = (array) json_decode( file_get_contents( trailingslashit( FL_BUILDER_DIR ) . 'json/fonts.json' ), true );
}
self::$_google_json = $json;
}
/**
* Filter raw google json data
* @see fl_builder_get_google_json
*/
return apply_filters( 'fl_builder_get_google_json', $json );
}
static public function try_cached_google() {
// Check if enabled
if ( ! get_option( '_fl_builder_google_auto' ) ) {
return false;
}
if ( false === ( $json = get_transient( 'fl_builder_google_json' ) ) ) { // phpcs:ignore Generic.CodeAnalysis.AssignmentInCondition.Found, WordPress.CodeAnalysis.AssignmentInCondition.Found,Squiz.PHP.DisallowMultipleAssignments.FoundInControlStructure
try {
$response = wp_remote_get( 'https://updates.wpbeaverbuilder.com/fonts.json', array(
'headers' => array(
'Accept' => 'application/json',
),
) );
if ( ( ! is_wp_error( $response ) ) && ( 200 === wp_remote_retrieve_response_code( $response ) ) ) {
$body = json_decode( $response['body'] );
if ( json_last_error() === JSON_ERROR_NONE && isset( $body->items ) ) {
$json = array();
foreach ( $body->items as $font ) {
$fallback = 'sans-serif';
if ( 'sans-serif' === $font->category || 'serif' === $font->category || 'monospace' === $font->category || 'handwriting' === $font->category ) {
if ( 'handwriting' === $font->category ) {
$fallback = 'cursive';
} else {
$fallback = $font->category;
}
}
$json[] = array(
$font->family => array(
'variants' => $font->variants,
'fallback' => $fallback,
),
);
}
set_transient( 'fl_builder_google_json', $json, 604800 );
}
}
} catch ( Exception $ex ) {
return false; // TODO load default json here into transient?
}
}
return $json;
}
/**
* @since 2.1.5
*/
static public function get_google_fallback( $font ) {
$json = self::_get_json();
foreach ( $json as $k => $google ) {
$name = key( $google );
if ( $name == $font ) {
return $google[ $name ]['fallback'];
}
}
return false;
}
}