| @@ -1,0 +1,373 @@ | ||
| 1 | +<?php | |
| 2 | +namespace ABlocks\Classes; | |
| 3 | + | |
| 4 | +if ( ! defined( 'ABSPATH' ) ) { | |
| 5 | + exit; | |
| 6 | +} | |
| 7 | + | |
| 8 | +use \ABlocks\Helper; | |
| 9 | +use \ABlocks\Assets; | |
| 10 | + | |
| 11 | +abstract class BlockBaseAbstract { | |
| 12 | + | |
| 13 | + protected $namespace = 'ablocks'; | |
| 14 | + | |
| 15 | + protected $assets_url = ABLOCKS_ASSETS_URL; | |
| 16 | + | |
| 17 | + protected $assets_path = ABLOCKS_ASSETS_PATH; | |
| 18 | + | |
| 19 | + protected $blocks_dir_path = ABLOCKS_BLOCKS_DIR_PATH; | |
| 20 | + | |
| 21 | + protected $parent_block_name = ''; | |
| 22 | + | |
| 23 | + protected $is_skip_inner_block = false; | |
| 24 | + | |
| 25 | + protected $block_name = ''; | |
| 26 | + | |
| 27 | + protected $style_depends = []; | |
| 28 | + protected $script_depends = []; | |
| 29 | + | |
| 30 | + protected $animation_settings = []; | |
| 31 | + | |
| 32 | + public function __construct( $keep_silent = false ) { | |
| 33 | + if ( $this->is_enabled_block() && ! $keep_silent ) { | |
| 34 | + add_action( 'init', array( $this, 'register_block' ), 20 ); | |
| 35 | + add_action( 'ablocks/before_render_' . $this->block_name . '_block_content', array( $this, 'enqueue_block_specific_static_assets' ) ); | |
| 36 | + } | |
| 37 | + } | |
| 38 | + | |
| 39 | + public function is_enabled_block() { | |
| 40 | + global $ablocks_blocks; | |
| 41 | + $block_name = ! empty( $this->parent_block_name ) ? $this->parent_block_name : $this->block_name; | |
| 42 | + if ( isset( $ablocks_blocks->{$block_name} ) ) { | |
| 43 | + return (bool) $ablocks_blocks->{$block_name}; | |
| 44 | + } | |
| 45 | + return false; | |
| 46 | + } | |
| 47 | + | |
| 48 | + public function register_block() { | |
| 49 | + $block_path = $this->assets_path . 'build/blocks/' . $this->block_name . '/block.json'; | |
| 50 | + $args = [ | |
| 51 | + 'render_callback' => array( $this, 'render_callback' ), | |
| 52 | + ]; | |
| 53 | + if ( isset( $metadata['usesContext'] ) ) { | |
| 54 | + $args['usesContext'] = $metadata['usesContext']; | |
| 55 | + } | |
| 56 | + if ( isset( $metadata['providesContext'] ) ) { | |
| 57 | + $args['providesContext'] = $metadata['providesContext']; | |
| 58 | + } | |
| 59 | + if ( $this->is_skip_inner_block ) { | |
| 60 | + $args['skip_inner_blocks'] = $this->is_skip_inner_block; | |
| 61 | + } | |
| 62 | + register_block_type( $block_path, $args ); | |
| 63 | + } | |
| 64 | + | |
| 65 | + public function get_attributes() { | |
| 66 | + $block_attributes = include $this->blocks_dir_path . $this->block_name . '/attributes.php'; | |
| 67 | + return apply_filters( 'ablocks/register_block_attributes', $block_attributes, $this->block_name, $this->parent_block_name ); | |
| 68 | + } | |
| 69 | + | |
| 70 | + private function get_block_class( $css_class ) { | |
| 71 | + $classes = array(); | |
| 72 | + if ( $css_class ) { | |
| 73 | + if ( ! is_array( $css_class ) ) { | |
| 74 | + $css_class = preg_split( '#\s+#', $css_class ); | |
| 75 | + } | |
| 76 | + $classes = array_map( 'esc_attr', $css_class ); | |
| 77 | + } else { | |
| 78 | + // Ensure that we always coerce class to being an array. | |
| 79 | + $css_class = array(); | |
| 80 | + } | |
| 81 | + | |
| 82 | + return 'class="' . esc_attr( implode( ' ', $classes ) ) . '"'; | |
| 83 | + } | |
| 84 | + private function get_block_data_settings_attributes( $settings ) { | |
| 85 | + if ( ! is_array( $settings ) || empty( $settings['animationType'] ) || $settings['animationType'] !== 'none' ) { | |
| 86 | + return ''; | |
| 87 | + } | |
| 88 | + | |
| 89 | + // Sanitize each setting in the array | |
| 90 | + $sanitized_settings = array_map( 'esc_attr', $settings ); | |
| 91 | + // Encode sanitized settings to JSON and escape it for safe output | |
| 92 | + return sprintf( 'data-settings="%s"', esc_attr( wp_json_encode( $sanitized_settings ) ) ); | |
| 93 | + } | |
| 94 | + private function get_dynamic_block_wrap( $attributes, $content, $block_instance ) { | |
| 95 | + $block_id = ( isset( $attributes['block_id'] ) ? $attributes['block_id'] : '' ); | |
| 96 | + $animation = ( isset( $attributes['_animation'] ) ? $attributes['_animation'] : [] ); | |
| 97 | + $block_class_args = array( 'ablocks-block', 'ablocks-block-' . $block_id, 'ablocks-block--' . $this->block_name ); | |
| 98 | + $has_transform = (bool) ( isset( $attributes['_transform']['isApplied'] ) ? $attributes['_transform']['isApplied'] : false ); | |
| 99 | + | |
| 100 | + if ( count( $animation ) && ( | |
| 101 | + ( ! empty( $animation['animationType'] ) && $animation['animationType'] !== 'none' ) || | |
| 102 | + ( ! empty( $animation['animationTypeTablet'] ) && $animation['animationTypeTablet'] !== 'none' ) || | |
| 103 | + ( ! empty( $animation['animationTypeMobile'] ) && $animation['animationTypeMobile'] !== 'none' ) | |
| 104 | + ) | |
| 105 | + ) { | |
| 106 | + array_push( $block_class_args, 'ablocks-invisible' ); | |
| 107 | + } | |
| 108 | + | |
| 109 | + if ( $has_transform ) { | |
| 110 | + array_push( $block_class_args, 'ablocks-has-block-container' ); | |
| 111 | + } | |
| 112 | + | |
| 113 | + ob_start(); | |
| 114 | + ?> | |
| 115 | + <div <?php echo $this->get_block_class( $block_class_args ) . $this->get_block_data_settings_attributes( $animation ); // phpcs:ignore WordPress.Security.EscapeOutput.OutputNotEscaped ?>> | |
| 116 | + <?php | |
| 117 | + if ( $has_transform ) : | |
| 118 | + ?> | |
| 119 | + <div class="ablocks-block-container"> | |
| 120 | + <?php | |
| 121 | + // phpcs:ignore WordPress.Security.EscapeOutput.OutputNotEscaped | |
| 122 | + echo $this->render_block_content( $attributes, $content, $block_instance ); | |
| 123 | + ?> | |
| 124 | + </div> | |
| 125 | + <?php | |
| 126 | + else : | |
| 127 | + // phpcs:ignore WordPress.Security.EscapeOutput.OutputNotEscaped | |
| 128 | + echo $this->render_block_content( $attributes, $content, $block_instance ); | |
| 129 | + endif; | |
| 130 | + ?> | |
| 131 | + </div> | |
| 132 | + <?php | |
| 133 | + return ob_get_clean(); | |
| 134 | + } | |
| 135 | + | |
| 136 | + | |
| 137 | + public function render_block_content( $attributes, $content, $block_instance ) { | |
| 138 | + return $content; | |
| 139 | + } | |
| 140 | + | |
| 141 | + public function render_callback( $attributes, $content, $block_instance ) { | |
| 142 | + $block_name = $block_instance->name; | |
| 143 | + do_action( 'ablocks/before_render_' . explode( '/', $block_name )[1] . '_block_content', $block_name ); | |
| 144 | + do_action( 'ablocks/render_callback', $block_name, $attributes ); | |
| 145 | + | |
| 146 | + // Animation CSS is no longer a global dependency (see get_style_depends). | |
| 147 | + // In the fallback path (asset-generation off) enqueue it only when this | |
| 148 | + // block actually animates, so pages without animation never load it. | |
| 149 | + $this->maybe_enqueue_animate_style( $attributes ); | |
| 150 | + | |
| 151 | + // Dynamic block | |
| 152 | + if ( ! $content || $this->is_skip_inner_block ) { | |
| 153 | + // When called from the editor's ServerSideRender (REST API), RenderContainer (JS) already | |
| 154 | + // provides the outer ablocks-block-{blockId} wrapper via useBlockProps. Including it here | |
| 155 | + // too causes the Advanced-settings CSS selector to match two elements → double border/padding. | |
| 156 | + // Only that preview render (it always sends context=edit): front-end REST endpoints such as the | |
| 157 | + // loop filter re-render blocks into the page, where the wrapper and its scoped styles are needed. | |
| 158 | + // phpcs:ignore WordPress.Security.NonceVerification.Recommended | |
| 159 | + if ( defined( 'REST_REQUEST' ) && REST_REQUEST && 'edit' === ( $_REQUEST['context'] ?? '' ) ) { | |
| 160 | + ob_start(); | |
| 161 | + echo $this->render_block_content( $attributes, $content, $block_instance ); | |
| 162 | + $content = ob_get_clean(); | |
| 163 | + } else { | |
| 164 | + $content = $this->get_dynamic_block_wrap( $attributes, $content, $block_instance ); | |
| 165 | + } | |
| 166 | + } | |
| 167 | + | |
| 168 | + // Static Block but control render from php | |
| 169 | + $content = apply_filters( 'ablocks/get_render_block_content', $content, $attributes, $block_instance ); | |
| 170 | + if ( ! $content ) { | |
| 171 | + return $content; | |
| 172 | + } | |
| 173 | + | |
| 174 | + // Pure Static block | |
| 175 | + if ( apply_filters( 'ablocks/is_allow_block_inline_assets', ( ! is_admin() || defined( 'DOING_AJAX' ) && DOING_AJAX ) && ! Helper::is_enabled_assets_generation() ) ) { | |
| 176 | + | |
| 177 | + $build_css = '<style>' . $this->build_css( $attributes ) . '</style>'; | |
| 178 | + | |
| 179 | + return $build_css . $content; | |
| 180 | + } | |
| 181 | + | |
| 182 | + return $content; | |
| 183 | + } | |
| 184 | + | |
| 185 | + /** | |
| 186 | + * file_exists + filemtime for a per-block asset, memoized per request so | |
| 187 | + * repeated instances of the same block don't re-stat the same file. | |
| 188 | + * Returns the mtime (cache-bust version) or false when the file is missing. | |
| 189 | + */ | |
| 190 | + private static $asset_version_cache = []; | |
| 191 | + private function cached_asset_version( $path ) { | |
| 192 | + if ( ! array_key_exists( $path, self::$asset_version_cache ) ) { | |
| 193 | + self::$asset_version_cache[ $path ] = file_exists( $path ) ? filemtime( $path ) : false; | |
| 194 | + } | |
| 195 | + return self::$asset_version_cache[ $path ]; | |
| 196 | + } | |
| 197 | + | |
| 198 | + /** | |
| 199 | + * Enqueue the animate.css library only when a block actually uses an | |
| 200 | + * animation, and only in the fallback (per-block) asset path — with | |
| 201 | + * asset-generation on, the combined generator bakes it in on demand instead. | |
| 202 | + */ | |
| 203 | + private function maybe_enqueue_animate_style( $attributes ) { | |
| 204 | + if ( is_admin() || Helper::is_enabled_assets_generation() ) { | |
| 205 | + return; | |
| 206 | + } | |
| 207 | + $animation_type = isset( $attributes['_animation']['animationType'] ) ? $attributes['_animation']['animationType'] : ''; | |
| 208 | + if ( ! empty( $animation_type ) && 'none' !== $animation_type ) { | |
| 209 | + wp_enqueue_style( 'ablocks-animate-style' ); | |
| 210 | + } | |
| 211 | + } | |
| 212 | + | |
| 213 | + private function enqueue_static_assets( $block_name ) { | |
| 214 | + // Library | |
| 215 | + if ( count( $this->get_style_depends() ) ) { | |
| 216 | + foreach ( $this->get_style_depends() as $style_handler ) { | |
| 217 | + wp_enqueue_style( $style_handler ); | |
| 218 | + } | |
| 219 | + } | |
| 220 | + | |
| 221 | + // Library | |
| 222 | + if ( count( $this->get_script_depends() ) ) { | |
| 223 | + foreach ( $this->get_script_depends() as $script_handler ) { | |
| 224 | + wp_enqueue_script( $script_handler ); | |
| 225 | + } | |
| 226 | + } | |
| 227 | + | |
| 228 | + // block static css | |
| 229 | + $style_version = $this->cached_asset_version( $this->assets_path . 'build/blocks/' . $block_name . '/style.css' ); | |
| 230 | + if ( false !== $style_version ) { | |
| 231 | + wp_enqueue_style( 'ablocks-' . $block_name . '-block-static-style', $this->assets_url . 'build/blocks/' . $block_name . '/style.css', array(), $style_version, 'all' ); | |
| 232 | + } | |
| 233 | + | |
| 234 | + $script_loading_strategy = \ABlocks\Helper::get_script_loading_strategy(); | |
| 235 | + $args = [ 'strategy' => $script_loading_strategy ]; | |
| 236 | + | |
| 237 | + if ( false !== $this->cached_asset_version( $this->assets_path . 'build/blocks/' . $block_name . '/view.js' ) && ! wp_script_is( 'ablocks-' . $block_name . '-block-static-script', 'enqueued' ) ) { | |
| 238 | + $dependencies = include $this->assets_path . 'build/blocks/' . $block_name . '/view.asset.php'; | |
| 239 | + // Depend on the shared data-only handle so ABlocksGlobal is printed | |
| 240 | + // before this script runs, without each block carrying its own copy. | |
| 241 | + $deps = array_values( array_unique( array_merge( array( 'ablocks-globals' ), $dependencies['dependencies'] ) ) ); | |
| 242 | + wp_enqueue_script( | |
| 243 | + 'ablocks-' . $block_name . '-block-static-script', | |
| 244 | + $this->assets_url . 'build/blocks/' . $block_name . '/view.js', | |
| 245 | + $deps, | |
| 246 | + $dependencies['version'], | |
| 247 | + $args | |
| 248 | + ); | |
| 249 | + Assets::localize_globals_once(); | |
| 250 | + } | |
| 251 | + | |
| 252 | + } | |
| 253 | + | |
| 254 | + public function enqueue_block_static_assets() { | |
| 255 | + if ( ! is_admin() && ! Helper::is_enabled_assets_generation() ) { | |
| 256 | + $this->enqueue_static_assets( $this->block_name ); | |
| 257 | + }//end if | |
| 258 | + } | |
| 259 | + public function enqueue_block_specific_static_assets( $block_name ) { | |
| 260 | + if ( ! is_admin() && ! Helper::is_enabled_assets_generation() ) { | |
| 261 | + $this->enqueue_static_assets( explode( '/', $block_name )[1] ); | |
| 262 | + }//end if | |
| 263 | + } | |
| 264 | + | |
| 265 | + public function get_static_css() { | |
| 266 | + if ( file_exists( $this->assets_path . 'build/blocks/' . $this->block_name . '/style.css' ) ) { | |
| 267 | + // phpcs:ignore WordPress.WP.AlternativeFunctions.file_get_contents_file_get_contents | |
| 268 | + $has_static_css = file_get_contents( $this->assets_path . 'build/blocks/' . $this->block_name . '/style.css' ); | |
| 269 | + if ( $has_static_css ) { | |
| 270 | + // A block's style.css doubles as its editorStyle, so it can carry | |
| 271 | + // editor-chrome rules (.block-editor-*, .editor-styles-wrapper …) | |
| 272 | + // that never match on the front end. Strip them from the frontend | |
| 273 | + // static CSS (this getter feeds the combined/inline page CSS; the | |
| 274 | + // editor loads style.css directly via block.json). | |
| 275 | + return self::strip_editor_only_css( $has_static_css ); | |
| 276 | + } | |
| 277 | + } | |
| 278 | + return ''; | |
| 279 | + } | |
| 280 | + | |
| 281 | + /** | |
| 282 | + * Remove rules whose selector is entirely editor-chrome (every | |
| 283 | + * comma-separated part references an editor-only class), leaving mixed and | |
| 284 | + * front-end rules untouched. Brace-aware so @media blocks stay intact. | |
| 285 | + */ | |
| 286 | + private static $editor_css_cache = []; | |
| 287 | + public static function strip_editor_only_css( $css ) { | |
| 288 | + $key = md5( $css ); | |
| 289 | + if ( isset( self::$editor_css_cache[ $key ] ) ) { | |
| 290 | + return self::$editor_css_cache[ $key ]; | |
| 291 | + } | |
| 292 | + $markers = [ '.block-editor-', '.editor-styles-wrapper', '.block-list-appender', '.components-base-control', '.block-editor-block-variation-picker', '.block-editor-button-block-appender' ]; | |
| 293 | + | |
| 294 | + $out = ''; | |
| 295 | + $len = strlen( $css ); | |
| 296 | + $i = 0; | |
| 297 | + $buf = ''; | |
| 298 | + while ( $i < $len ) { | |
| 299 | + $ch = $css[ $i ]; | |
| 300 | + $buf .= $ch; | |
| 301 | + if ( '{' === $ch ) { | |
| 302 | + $prelude = trim( substr( $buf, 0, -1 ) ); | |
| 303 | + $depth = 1; | |
| 304 | + $i++; | |
| 305 | + while ( $i < $len && $depth > 0 ) { | |
| 306 | + $c = $css[ $i ]; | |
| 307 | + $buf .= $c; | |
| 308 | + if ( '{' === $c ) { | |
| 309 | + $depth++; | |
| 310 | + } elseif ( '}' === $c ) { | |
| 311 | + $depth--; | |
| 312 | + } | |
| 313 | + $i++; | |
| 314 | + } | |
| 315 | + $drop = false; | |
| 316 | + if ( '' !== $prelude && '@' !== $prelude[0] ) { | |
| 317 | + $parts = array_map( 'trim', explode( ',', $prelude ) ); | |
| 318 | + $drop = true; | |
| 319 | + foreach ( $parts as $part ) { | |
| 320 | + // Drop :not(...) negations first — a selector like | |
| 321 | + // ":not(.block-editor-block-list__block) .foo" is a FRONT-END | |
| 322 | + // rule (applies everywhere except the editor), NOT editor | |
| 323 | + // chrome, so the marker inside :not() must not count. | |
| 324 | + $positive = preg_replace( '/:not\([^)]*\)/', '', $part ); | |
| 325 | + $is_editor = false; | |
| 326 | + foreach ( $markers as $m ) { | |
| 327 | + if ( false !== strpos( $positive, $m ) ) { | |
| 328 | + $is_editor = true; | |
| 329 | + break; | |
| 330 | + } | |
| 331 | + } | |
| 332 | + if ( ! $is_editor ) { | |
| 333 | + $drop = false; // a front-end part exists — keep the rule | |
| 334 | + break; | |
| 335 | + } | |
| 336 | + } | |
| 337 | + } | |
| 338 | + if ( ! $drop ) { | |
| 339 | + $out .= $buf; | |
| 340 | + } | |
| 341 | + $buf = ''; | |
| 342 | + continue; | |
| 343 | + } | |
| 344 | + $i++; | |
| 345 | + } | |
| 346 | + $out .= $buf; | |
| 347 | + | |
| 348 | + self::$editor_css_cache[ $key ] = $out; | |
| 349 | + return $out; | |
| 350 | + } | |
| 351 | + public function get_static_js() { | |
| 352 | + if ( file_exists( $this->assets_path . 'build/blocks/' . $this->block_name . '/view.js' ) ) { | |
| 353 | + // phpcs:ignore WordPress.WP.AlternativeFunctions.file_get_contents_file_get_contents | |
| 354 | + $has_static_js = file_get_contents( $this->assets_path . 'build/blocks/' . $this->block_name . '/view.js' ); | |
| 355 | + if ( $has_static_js ) { | |
| 356 | + return $has_static_js; | |
| 357 | + } | |
| 358 | + } | |
| 359 | + return ''; | |
| 360 | + } | |
| 361 | + public function get_style_depends() { | |
| 362 | + // NOTE: 'ablocks-animate-style' is intentionally NOT included here. Animation | |
| 363 | + // CSS is heavy and most blocks don't animate, so it's added on demand only: | |
| 364 | + // the combined generator adds it when a block's _animation attribute is set | |
| 365 | + // (AssetsGenerator::recursive_block_parser), and the fallback render path | |
| 366 | + // enqueues it per-block via maybe_enqueue_animate_style(). | |
| 367 | + return apply_filters( 'ablocks/block_style_depends', array_merge( $this->style_depends, array( 'ablocks-frontend-google-fonts', 'ablocks-common-style' ) ) ); | |
| 368 | + } | |
| 369 | + public function get_script_depends() { | |
| 370 | + return apply_filters( 'ablocks/block_script_depends', array_merge( $this->script_depends, array( 'ablocks-common-script' ) ) ); | |
| 371 | + } | |
| 372 | + abstract public function build_css( $attributes); | |
| 373 | +} | |
