jetpack / jetpack_vendor / automattic / jetpack-search / src / class-helper.php

class-helper.php in Jetpack – WP Security, Backup, Speed, & Growth 16.3-a.7, at jetpack_vendor/automattic/jetpack-search/src/class-helper.php

1,322 lines 41.6 KB

Raw Download Zip

1	<?php
2	/**
3	* Helper class providing various static utility functions for use in Search.
4	*
5	* @package automattic/jetpack-search
6	*/
7
8	namespace Automattic\Jetpack\Search;
9
10	use Automattic\Jetpack\Status;
11	use GP_Locales;
12	use Jetpack; // TODO: Remove this once migrated.
13
14	if ( ! defined( 'ABSPATH' ) ) {
15	exit( 0 );
16	}
17
18	/**
19	* Various helper functions for reuse throughout the Jetpack Search code.
20	*/
21	class Helper {
22
23	/**
24	* The search widget's base ID.
25	*
26	* @since 5.8.0
27	* @var string
28	*/
29	const FILTER_WIDGET_BASE = 'jetpack-search-filters';
30
31	/**
32	* Create a URL for the current search that doesn't include the "paged" parameter.
33	*
34	* @since 5.8.0
35	*
36	* @return string The search URL.
37	*/
38	public static function get_search_url() {
39	// WordPress search doesn't use nonces.
40	$query_args = stripslashes_deep( $_GET ); //phpcs:ignore WordPress.Security.NonceVerification.Recommended
41
42	// Handle the case where a permastruct is being used, such as /search/{$query}.
43	if ( ! isset( $query_args['s'] ) ) {
44	$query_args['s'] = get_search_query();
45	}
46
47	if ( isset( $query_args['paged'] ) ) {
48	unset( $query_args['paged'] );
49	}
50
51	$query = http_build_query( $query_args );
52
53	return home_url( "?{$query}" );
54	}
55
56	/**
57	* Wraps add_query_arg() with the URL defaulting to the current search URL.
58	*
59	* @see add_query_arg()
60	*
61	* @since 5.8.0
62	*
63	* @param string\|array $key Either a query variable key, or an associative array of query variables.
64	* @param string $value Optional. A query variable value.
65	* @param bool\|string $url Optional. A URL to act upon. Defaults to the current search URL.
66	*
67	* @return string New URL query string (unescaped).
68	*/
69	public static function add_query_arg( $key, $value = false, $url = false ) {
70	$url = empty( $url ) ? self::get_search_url() : $url;
71	if ( is_array( $key ) ) {
72	return add_query_arg( $key, $url );
73	}
74
75	return add_query_arg( $key, $value, $url );
76	}
77
78	/**
79	* Wraps remove_query_arg() with the URL defaulting to the current search URL.
80	*
81	* @see remove_query_arg()
82	*
83	* @since 5.8.0
84	*
85	* @param string\|array $key Query key or keys to remove.
86	* @param bool\|string $url Optional. A URL to act upon. Defaults to the current search URL.
87	*
88	* @return string New URL query string (unescaped).
89	*/
90	public static function remove_query_arg( $key, $url = false ) {
91	$url = empty( $url ) ? self::get_search_url() : $url;
92
93	return remove_query_arg( $key, $url );
94	}
95
96	/**
97	* Returns the name of the search widget's option.
98	*
99	* @since 5.8.0
100	*
101	* @return string The search widget option name.
102	*/
103	public static function get_widget_option_name() {
104	return sprintf( 'widget_%s', self::FILTER_WIDGET_BASE );
105	}
106
107	/**
108	* Returns the search widget instances from the widget's option.
109	*
110	* @since 5.8.0
111	*
112	* @return array The widget options.
113	*/
114	public static function get_widgets_from_option() {
115	$widget_options = get_option( self::get_widget_option_name(), array() );
116
117	// We don't need this.
118	if ( ! empty( $widget_options ) && isset( $widget_options['_multiwidget'] ) ) {
119	unset( $widget_options['_multiwidget'] );
120	}
121
122	return $widget_options;
123	}
124
125	/**
126	* Returns the widget ID (widget base plus the numeric ID).
127	*
128	* @param int $number The widget's numeric ID.
129	*
130	* @return string The widget's numeric ID prefixed with the search widget base.
131	*/
132	public static function build_widget_id( $number ) {
133	return sprintf( '%s-%d', self::FILTER_WIDGET_BASE, $number );
134	}
135
136	/**
137	* Wrapper for is_active_widget() with the other parameters automatically supplied.
138	*
139	* @see is_active_widget()
140	*
141	* @since 5.8.0
142	*
143	* @param int $widget_id Widget ID.
144	*
145	* @return bool Whether the widget is active or not.
146	*/
147	public static function is_active_widget( $widget_id ) {
148	return (bool) is_active_widget( false, $widget_id, self::FILTER_WIDGET_BASE, true );
149	}
150
151	/**
152	* Returns an array of the filters from all active search widgets.
153	*
154	* @since 5.8.0
155	*
156	* @param array\|null $allowed_widget_ids array of allowed widget IDs.
157	*
158	* @return array Active filters.
159	*/
160	public static function get_filters_from_widgets( $allowed_widget_ids = null ) {
161	$filters = array();
162
163	$widget_options = self::get_widgets_from_option();
164	if ( empty( $widget_options ) ) {
165	return $filters;
166	}
167
168	foreach ( (array) $widget_options as $number => $settings ) {
169	$widget_id = self::build_widget_id( $number );
170	if ( ! self::is_active_widget( $widget_id ) \|\| empty( $settings['filters'] ) ) {
171	continue;
172	}
173	if ( isset( $allowed_widget_ids ) && ! in_array( $widget_id, $allowed_widget_ids, true ) ) {
174	continue;
175	}
176
177	foreach ( (array) $settings['filters'] as $widget_filter ) {
178	$widget_filter['widget_id'] = $widget_id;
179
180	if ( empty( $widget_filter['name'] ) ) {
181	$widget_filter['name'] = self::generate_widget_filter_name( $widget_filter );
182	}
183
184	$type = $widget_filter['type'] ?? '';
185
186	// If this is a product_attribute filter with no specific attribute, expand it to all global attributes.
187	if ( 'product_attribute' === $type && empty( $widget_filter['attribute'] ) ) {
188	$filters = self::expand_product_attribute_filters( $widget_filter, $filters );
189	} else {
190	$key = sprintf( '%s_%d', $type, count( $filters ) );
191	$filters[ $key ] = $widget_filter;
192	}
193	}
194	}
195
196	return $filters;
197	}
198
199	/**
200	* Expands a product_attribute filter into individual filters for each attribute.
201	*
202	* @since 5.8.0
203	*
204	* @param array $widget_filter The filter configuration.
205	* @param array $filters The existing filters array.
206	* @return array The filters array with expanded product attribute filters.
207	*/
208	private static function expand_product_attribute_filters( $widget_filter, $filters ) {
209	if ( ! function_exists( 'wc_get_attribute_taxonomies' ) \|\| ! function_exists( 'wc_attribute_taxonomy_name' ) ) {
210	return $filters;
211	}
212
213	$product_attributes = wc_get_attribute_taxonomies();
214	$included_attributes = isset( $widget_filter['included_attributes'] ) ? (array) $widget_filter['included_attributes'] : array();
215
216	// If no attributes are explicitly included, show all attributes (backward compatibility).
217	// Also optimize by treating "all selected" the same as "none selected" to avoid O(n²) in_array() checks.
218	$show_all = empty( $included_attributes ) \|\| count( $included_attributes ) === count( $product_attributes );
219
220	foreach ( $product_attributes as $attribute ) {
221	$attribute_name = wc_attribute_taxonomy_name( $attribute->attribute_name );
222
223	if ( ! $show_all && ! in_array( $attribute_name, $included_attributes, true ) ) {
224	continue;
225	}
226
227	$key = sprintf( 'product_attribute_%d', count( $filters ) );
228	$expanded_filter = $widget_filter;
229	$expanded_filter['attribute'] = $attribute_name;
230	$expanded_filter['name'] = $attribute->attribute_label;
231	unset( $expanded_filter['included_attributes'] );
232	$filters[ $key ] = $expanded_filter;
233	}
234
235	return $filters;
236	}
237
238	/**
239	* Get the localized default label for a date filter.
240	*
241	* @since 5.8.0
242	*
243	* @param string $type Date type, either year or month.
244	* @param bool $is_updated Whether the filter was updated or not (adds "Updated" to the end).
245	*
246	* @return string The filter label.
247	*/
248	public static function get_date_filter_type_name( $type, $is_updated = false ) {
249	switch ( $type ) {
250	case 'year':
251	$string = ( $is_updated )
252	? esc_html_x( 'Year Updated', 'label for filtering posts', 'jetpack-search-pkg' )
253	: esc_html_x( 'Year', 'label for filtering posts', 'jetpack-search-pkg' );
254	break;
255	case 'month':
256	default:
257	$string = ( $is_updated )
258	? esc_html_x( 'Month Updated', 'label for filtering posts', 'jetpack-search-pkg' )
259	: esc_html_x( 'Month', 'label for filtering posts', 'jetpack-search-pkg' );
260	break;
261	}
262
263	return $string;
264	}
265
266	/**
267	* Creates a default name for a filter. Used when the filter label is blank.
268	*
269	* @since 5.8.0
270	*
271	* @param array $widget_filter The filter to generate the title for.
272	*
273	* @return string The suggested filter name.
274	*/
275	public static function generate_widget_filter_name( $widget_filter ) {
276	$name = '';
277
278	if ( ! isset( $widget_filter['type'] ) ) {
279	return $name;
280	}
281
282	switch ( $widget_filter['type'] ) {
283	case 'post_type':
284	$name = _x( 'Post Types', 'label for filtering posts', 'jetpack-search-pkg' );
285	break;
286
287	case 'author':
288	$name = _x( 'Authors', 'label for filtering posts', 'jetpack-search-pkg' );
289	break;
290
291	case 'blog_id':
292	$name = _x( 'Blogs', 'label for filtering posts', 'jetpack-search-pkg' );
293	break;
294
295	case 'date_histogram':
296	$modified_fields = array(
297	'post_modified',
298	'post_modified_gmt',
299	);
300	switch ( $widget_filter['interval'] ) {
301	case 'year':
302	$name = self::get_date_filter_type_name(
303	'year',
304	in_array( $widget_filter['field'], $modified_fields, true )
305	);
306	break;
307	case 'month':
308	default:
309	$name = self::get_date_filter_type_name(
310	'month',
311	in_array( $widget_filter['field'], $modified_fields, true )
312	);
313	break;
314	}
315	break;
316
317	case 'taxonomy':
318	$tax = get_taxonomy( $widget_filter['taxonomy'] );
319	if ( ! $tax ) {
320	break;
321	}
322
323	if ( isset( $tax->label ) ) {
324	$name = $tax->label;
325	} elseif ( isset( $tax->labels ) && isset( $tax->labels->name ) ) {
326	$name = $tax->labels->name;
327	}
328	break;
329
330	case 'product_attribute':
331	$name = _x( 'Product Attributes', 'label for filtering posts', 'jetpack-search-pkg' );
332	break;
333
334	}
335
336	return $name;
337	}
338
339	/**
340	* Whether we should rerun a search in the customizer preview or not.
341	*
342	* @since 5.8.0
343	*
344	* @return bool
345	*/
346	public static function should_rerun_search_in_customizer_preview() {
347	// Only update when in a customizer preview and data is being posted.
348	// Check for $_POST removes an extra update when the customizer loads.
349	//
350	// Note: We use $GLOBALS['wp_customize'] here instead of is_customize_preview() to support unit tests.
351	return isset( $GLOBALS['wp_customize'] ) && $GLOBALS['wp_customize']->is_preview() && ! empty( $_POST ); // phpcs:ignore
352	}
353
354	/**
355	* Since PHP's built-in array_diff() works by comparing the values that are in array 1 to the other arrays,
356	* if there are less values in array 1, it's possible to get an empty diff where one might be expected.
357	*
358	* @since 5.8.0
359	*
360	* @param array $array_1 The first array.
361	* @param array $array_2 The second array.
362	*
363	* @return array
364	*/
365	public static function array_diff( $array_1, $array_2 ) {
366	// If the array counts are the same, then the order doesn't matter. If the count of
367	// $array_1 is higher than $array_2, that's also fine. If the count of $array_2 is higher,
368	// we need to swap the array order though.
369	if ( count( $array_1 ) !== count( $array_2 ) && count( $array_2 ) > count( $array_1 ) ) {
370	$temp = $array_1;
371	$array_1 = $array_2;
372	$array_2 = $temp;
373	}
374
375	// Disregard keys.
376	return array_values( array_diff( $array_1, $array_2 ) );
377	}
378
379	/**
380	* Given the widget instance, will return true when selected post types differ from searchable post types.
381	*
382	* @since 5.8.0
383	*
384	* @param array $post_types An array of post types.
385	*
386	* @return bool
387	*/
388	public static function post_types_differ_searchable( $post_types ) {
389	if ( empty( $post_types ) ) {
390	return false;
391	}
392
393	$searchable_post_types = get_post_types( array( 'exclude_from_search' => false ) );
394	$diff_of_searchable = self::array_diff( $searchable_post_types, (array) $post_types );
395
396	return ! empty( $diff_of_searchable );
397	}
398
399	/**
400	* Given the array of post types, will return true when these differ from the current search query.
401	*
402	* @since 5.8.0
403	*
404	* @param array $post_types An array of post types.
405	*
406	* @return bool
407	*/
408	public static function post_types_differ_query( $post_types ) {
409	if ( empty( $post_types ) ) {
410	return false;
411	}
412
413	// phpcs:disable WordPress.Security.NonceVerification.Recommended -- WordPress search doesn't use nonces.
414	// phpcs:disable WordPress.Security.ValidatedSanitizedInput -- Sanitization happens at the end.
415	if ( empty( $_GET['post_type'] ) ) {
416	$post_types_from_query = array();
417	} elseif ( is_array( $_GET['post_type'] ) ) {
418	$post_types_from_query = $_GET['post_type'];
419	} else {
420	$post_types_from_query = explode( ',', $_GET['post_type'] );
421	}
422	// phpcs:enable WordPress.Security.NonceVerification.Recommended, WordPress.Security.ValidatedSanitizedInput
423
424	$post_types_from_query = array_map( 'sanitize_key', $post_types_from_query );
425
426	$diff_query = self::array_diff( (array) $post_types, $post_types_from_query );
427
428	return ! empty( $diff_query );
429	}
430
431	/**
432	* Determine what Tracks value should be used when updating a widget.
433	*
434	* @since 5.8.0
435	*
436	* @param mixed $old_value The old option value.
437	* @param mixed $new_value The new option value.
438	*
439	* @return array\|false False if the widget wasn't updated, otherwise an array of the Tracks action and widget properties.
440	*/
441	public static function get_widget_tracks_value( $old_value, $new_value ) {
442	$old_value = (array) $old_value;
443	if ( isset( $old_value['_multiwidget'] ) ) {
444	unset( $old_value['_multiwidget'] );
445	}
446
447	$new_value = (array) $new_value;
448	if ( isset( $new_value['_multiwidget'] ) ) {
449	unset( $new_value['_multiwidget'] );
450	}
451
452	$old_keys = array_keys( $old_value );
453	$new_keys = array_keys( $new_value );
454
455	if ( count( $new_keys ) > count( $old_keys ) ) { // This is the case for a widget being added.
456	$diff = self::array_diff( $new_keys, $old_keys );
457	$action = 'widget_added';
458	$widget = empty( $diff ) \|\| ! isset( $new_value[ $diff[0] ] )
459	? false
460	: $new_value[ $diff[0] ];
461	} elseif ( count( $old_keys ) > count( $new_keys ) ) { // This is the case for a widget being deleted.
462	$diff = self::array_diff( $old_keys, $new_keys );
463	$action = 'widget_deleted';
464	$widget = empty( $diff ) \|\| ! isset( $old_value[ $diff[0] ] )
465	? false
466	: $old_value[ $diff[0] ];
467	} else {
468	$action = 'widget_updated';
469	$widget = false;
470
471	// This is a bit crazy. Since there can be multiple widgets stored in a single option,
472	// we need to diff the old and new values to figure out which widget was updated.
473	foreach ( $new_value as $key => $new_instance ) {
474	if ( ! isset( $old_value[ $key ] ) ) {
475	continue;
476	}
477	$old_instance = $old_value[ $key ];
478
479	// First, let's test the keys of each instance.
480	$diff = self::array_diff( array_keys( $new_instance ), array_keys( $old_instance ) );
481	if ( ! empty( $diff ) ) {
482	$widget = $new_instance;
483	break;
484	}
485
486	// Next, lets's loop over each value and compare it.
487	foreach ( $new_instance as $k => $v ) {
488	if ( is_scalar( $v ) && (string) $v !== (string) $old_instance[ $k ] ) {
489	$widget = $new_instance;
490	break;
491	}
492
493	if ( 'filters' === $k ) {
494	if ( ! is_countable( $new_instance['filters'] ) \|\| ! is_countable( $old_instance['filters'] ) ) {
495	continue;
496	}
497
498	if ( count( $new_instance['filters'] ) !== count( $old_instance['filters'] ) ) {
499	$widget = $new_instance;
500	break;
501	}
502
503	foreach ( $v as $filter_key => $new_filter_value ) {
504	$diff = self::array_diff( $new_filter_value, $old_instance['filters'][ $filter_key ] );
505	if ( ! empty( $diff ) ) {
506	$widget = $new_instance;
507	break;
508	}
509	}
510	}
511	}
512	}
513	}
514
515	if ( empty( $widget ) ) {
516	return false;
517	}
518
519	return array(
520	'action' => $action,
521	'widget' => self::get_widget_properties_for_tracks( $widget ),
522	);
523	}
524
525	/**
526	* Creates the widget properties for sending to Tracks.
527	*
528	* @since 5.8.0
529	*
530	* @param array $widget The widget instance.
531	*
532	* @return array The widget properties.
533	*/
534	public static function get_widget_properties_for_tracks( $widget ) {
535	$sanitized = array();
536
537	foreach ( (array) $widget as $key => $value ) {
538	if ( '_multiwidget' === $key ) {
539	continue;
540	}
541
542	if ( is_scalar( $value ) ) {
543	$key = str_replace( '-', '_', sanitize_key( $key ) );
544	$key = "widget_{$key}";
545	$sanitized[ $key ] = $value;
546	}
547	}
548
549	$filters_properties = ! empty( $widget['filters'] )
550	? self::get_filter_properties_for_tracks( $widget['filters'] )
551	: array();
552
553	return array_merge( $sanitized, $filters_properties );
554	}
555
556	/**
557	* Creates the filter properties for sending to Tracks.
558	*
559	* @since 5.8.0
560	*
561	* @param array $filters An array of filters.
562	*
563	* @return array The filter properties.
564	*/
565	public static function get_filter_properties_for_tracks( $filters ) {
566	if ( empty( $filters ) ) {
567	return $filters;
568	}
569
570	$filters_properties = array(
571	'widget_filter_count' => count( $filters ),
572	);
573
574	foreach ( $filters as $filter ) {
575	if ( empty( $filter['type'] ) ) {
576	continue;
577	}
578
579	$key = sprintf( 'widget_filter_type_%s', $filter['type'] );
580	if ( isset( $filters_properties[ $key ] ) ) {
581	++$filters_properties[ $key ];
582	} else {
583	$filters_properties[ $key ] = 1;
584	}
585	}
586
587	return $filters_properties;
588	}
589
590	/**
591	* Gets the active post types given a set of filters.
592	*
593	* @since 5.8.0
594	*
595	* @param array $filters The active filters for the current query.
596	*
597	* @return array The active post types.
598	*/
599	public static function get_active_post_types( $filters ) {
600	$active_post_types = array();
601
602	foreach ( $filters as $item ) {
603	if ( ( 'post_type' === $item['type'] ) && isset( $item['query_vars']['post_type'] ) ) {
604	$active_post_types[] = $item['query_vars']['post_type'];
605	}
606	}
607
608	return $active_post_types;
609	}
610
611	/**
612	* Sets active to false on all post type buckets.
613	*
614	* @since 5.8.0
615	*
616	* @param array $filters The available filters for the current query.
617	*
618	* @return array The filters for the current query with modified active field.
619	*/
620	public static function remove_active_from_post_type_buckets( $filters ) {
621	$modified = $filters;
622	foreach ( $filters as $key => $filter ) {
623	if ( 'post_type' === $filter['type'] && ! empty( $filter['buckets'] ) ) {
624	foreach ( $filter['buckets'] as $k => $bucket ) {
625	$bucket['active'] = false;
626	$modified[ $key ]['buckets'][ $k ] = $bucket;
627	}
628	}
629	}
630
631	return $modified;
632	}
633
634	/**
635	* Given a url and an array of post types, will ensure that the post types are properly applied to the URL as args.
636	*
637	* @since 5.8.0
638	*
639	* @param string $url The URL to add post types to.
640	* @param array $post_types An array of post types that should be added to the URL.
641	*
642	* @return string The URL with added post types.
643	*/
644	public static function add_post_types_to_url( $url, $post_types ) {
645	$url = self::remove_query_arg( 'post_type', $url );
646	if ( empty( $post_types ) ) {
647	return $url;
648	}
649
650	$url = self::add_query_arg(
651	'post_type',
652	implode( ',', $post_types ),
653	$url
654	);
655
656	return $url;
657	}
658
659	/**
660	* Since we provide support for the widget restricting post types by adding the selected post types as
661	* active filters, if removing a post type filter would result in there no longer be post_type args in the URL,
662	* we need to be sure to add them back.
663	*
664	* @since 5.8.0
665	*
666	* @param array $filters An array of possible filters for the current query.
667	* @param array $post_types The post types to ensure are on the link.
668	*
669	* @return array The updated array of filters with post typed added to the remove URLs.
670	*/
671	public static function ensure_post_types_on_remove_url( $filters, $post_types ) {
672	$modified = $filters;
673
674	foreach ( (array) $filters as $filter_key => $filter ) {
675	if ( 'post_type' !== $filter['type'] \|\| empty( $filter['buckets'] ) ) {
676	$modified[ $filter_key ] = $filter;
677	continue;
678	}
679
680	foreach ( (array) $filter['buckets'] as $bucket_key => $bucket ) {
681	if ( empty( $bucket['remove_url'] ) ) {
682	continue;
683	}
684
685	$parsed = wp_parse_url( $bucket['remove_url'] );
686	if ( ! $parsed ) {
687	continue;
688	}
689
690	$query = array();
691	if ( ! empty( $parsed['query'] ) ) {
692	wp_parse_str( $parsed['query'], $query );
693	}
694
695	if ( empty( $query['post_type'] ) ) {
696	$modified[ $filter_key ]['buckets'][ $bucket_key ]['remove_url'] = self::add_post_types_to_url(
697	$bucket['remove_url'],
698	$post_types
699	);
700	}
701	}
702	}
703
704	return $modified;
705	}
706
707	/**
708	* Wraps a WordPress filter called "jetpack_search_disable_widget_filters" that allows
709	* developers to disable filters supplied by the search widget. Useful if filters are
710	* being defined at the code level.
711	*
712	* @since 5.8.0
713	*
714	* @return bool
715	*/
716	public static function are_filters_by_widget_disabled() {
717	/**
718	* Allows developers to disable filters being set by widget, in favor of manually
719	* setting filters via `Classic_Search::set_filters()`.
720	*
721	* @module search
722	*
723	* @since 5.7.0
724	*
725	* @param bool false
726	*/
727	return apply_filters( 'jetpack_search_disable_widget_filters', false );
728	}
729
730	/**
731	* Returns the maximum posts per page for a search query.
732	*
733	* @since 5.8.0
734	*
735	* @return int
736	*/
737	public static function get_max_posts_per_page() {
738	return Options::site_has_vip_index() ? 1000 : 100;
739	}
740
741	/**
742	* Resolves the effective results-per-page value for the Search 3.0 blocks.
743	*
744	* `$override` is the author-set `resultsPerPage` block attribute; `0` (or
745	* any non-positive value) means "use the site's `posts_per_page` Reading
746	* setting." A non-positive Reading setting (e.g. `-1`, "show all") falls
747	* back to 10 rather than clamping down to a single result. Either way the
748	* result is capped at `get_max_posts_per_page()`.
749	*
750	* @param int $override Author override, or 0 to use the site default.
751	* @return int Clamped, always-positive results-per-page value.
752	*/
753	public static function resolve_results_per_page( $override = 0 ) {
754	$value = $override > 0 ? (int) $override : (int) get_option( 'posts_per_page' );
755	if ( $value <= 0 ) {
756	$value = 10;
757	}
758	return min( $value, self::get_max_posts_per_page() );
759	}
760
761	/**
762	* Returns the maximum offset for a search query.
763	*
764	* @since 5.8.0
765	*
766	* @return int
767	*/
768	public static function get_max_offset() {
769	return Options::site_has_vip_index() ? 9000 : 1000;
770	}
771
772	/**
773	* Returns the maximum offset for a search query.
774	*
775	* @since 8.4.0
776	* @param string $locale A potentially valid locale string.
777	*
778	* @return bool
779	*/
780	public static function is_valid_locale( $locale ) {
781	if ( ! class_exists( 'GP_Locales' ) ) {
782	// Assume locale to be valid if we can't check with GlotPress.
783	return true;
784	}
785	return false !== GP_Locales::by_field( 'wp_locale', $locale );
786	}
787
788	/**
789	* Get the version number to use when loading the file. Allows us to bypass cache when developing.
790	*
791	* @since 8.6.0
792	* @param string $file Path of the file we are looking for.
793	* @return string $script_version Version number.
794	*/
795	public static function get_asset_version( $file ) {
796	return Package::is_development_version() && file_exists( Package::get_installed_path() . $file )
797	? filemtime( Package::get_installed_path() . $file )
798	: Package::VERSION;
799	}
800
801	/**
802	* Generates a customizer settings ID for a given post type.
803	*
804	* @since 8.8.0
805	* @param object $post_type Post type object returned from get_post_types.
806	* @return string $customizer_id Customizer setting ID.
807	*/
808	public static function generate_post_type_customizer_id( $post_type ) {
809	return Options::OPTION_PREFIX . 'disable_post_type_' . $post_type->name;
810	}
811
812	/**
813	* Generates an array of post types associated with their customizer IDs.
814	*
815	* @since 8.8.0
816	* @return array $ids Post type => post type customizer ID object.
817	*/
818	public static function generate_post_type_customizer_ids() {
819	return array_map(
820	array( 'self', 'generate_post_type_customizer_id' ),
821	get_post_types( array( 'exclude_from_search' => false ), 'objects' )
822	);
823	}
824
825	/**
826	* Sanitizes a checkbox value for writing to the database.
827	*
828	* @since 8.9.0
829	*
830	* @param mixed $value from the customizer form.
831	* @return string either '0' or '1'.
832	*/
833	public static function sanitize_checkbox_value( $value ) {
834	return true === $value ? '1' : '0';
835	}
836
837	/**
838	* Sanitizes a checkbox value for rendering the Customizer.
839	*
840	* @since 8.9.0
841	*
842	* @param mixed $value from the database.
843	* @return boolean
844	*/
845	public static function sanitize_checkbox_value_for_js( $value ) {
846	return '1' === $value;
847	}
848
849	/**
850	* Passes all options to the JS app.
851	*/
852	public static function generate_initial_javascript_state() {
853	$widget_options = self::get_widgets_from_option();
854	if ( is_array( $widget_options ) ) {
855	$widget_options = end( $widget_options );
856	}
857
858	$overlay_widget_ids = is_active_sidebar( Instant_Search::INSTANT_SEARCH_SIDEBAR ) ?
859	wp_get_sidebars_widgets()[ Instant_Search::INSTANT_SEARCH_SIDEBAR ] : array();
860	$filters = self::get_filters_from_widgets();
861	$widgets = array();
862	$widgets_outside_overlay = array();
863	foreach ( $filters as $key => &$filter ) {
864	$filter['filter_id'] = $key;
865
866	if ( in_array( $filter['widget_id'], $overlay_widget_ids, true ) ) {
867	if ( ! isset( $widgets[ $filter['widget_id'] ] ) ) {
868	$widgets[ $filter['widget_id'] ]['filters'] = array();
869	$widgets[ $filter['widget_id'] ]['widget_id'] = $filter['widget_id'];
870	}
871	$widgets[ $filter['widget_id'] ]['filters'][] = $filter;
872	} else {
873	if ( ! isset( $widgets_outside_overlay[ $filter['widget_id'] ] ) ) {
874	$widgets_outside_overlay[ $filter['widget_id'] ]['filters'] = array();
875	$widgets_outside_overlay[ $filter['widget_id'] ]['widget_id'] = $filter['widget_id'];
876	}
877	$widgets_outside_overlay[ $filter['widget_id'] ]['filters'][] = $filter;
878	}
879	}
880	unset( $filter );
881
882	$has_non_search_widgets = false;
883	foreach ( $overlay_widget_ids as $overlay_widget_id ) {
884	if ( strpos( $overlay_widget_id, self::FILTER_WIDGET_BASE ) === false ) {
885	$has_non_search_widgets = true;
886	break;
887	}
888	}
889
890	$post_type_objs = get_post_types( array( 'exclude_from_search' => false ), 'objects' );
891	$post_type_labels = array();
892	foreach ( $post_type_objs as $key => $obj ) {
893	$post_type_labels[ $key ] = array(
894	'singular_name' => $obj->labels->singular_name,
895	'name' => $obj->labels->name,
896	);
897	}
898
899	$prefix = Options::OPTION_PREFIX;
900	$posts_per_page = (int) get_option( 'posts_per_page' );
901	if ( ( $posts_per_page > 20 ) \|\| ( $posts_per_page <= 0 ) ) {
902	$posts_per_page = 20;
903	}
904
905	$excluded_post_types = get_option( $prefix . 'excluded_post_types' ) ? explode( ',', get_option( $prefix . 'excluded_post_types', '' ) ) : array();
906	$post_types = array_values(
907	get_post_types(
908	array(
909	'exclude_from_search' => false,
910	'public' => true,
911	)
912	)
913	);
914	$unexcluded_post_types = array_diff( $post_types, $excluded_post_types );
915	// NOTE: If all post types are being excluded, ignore the option value.
916	if ( array() === $unexcluded_post_types ) {
917	$excluded_post_types = array();
918	}
919
920	$is_wpcom = static::is_wpcom();
921	$is_private_site = ( new Status() )->is_private_site();
922	$is_jetpack_photon_enabled = method_exists( 'Jetpack', 'is_module_active' ) && Jetpack::is_module_active( 'photon' );
923
924	$options = array(
925	'overlayOptions' => array(
926	'colorTheme' => get_option( $prefix . 'color_theme', 'light' ),
927	'enableInfScroll' => get_option( $prefix . 'inf_scroll', '1' ) === '1',
928	'enableFilteringOpensOverlay' => get_option( $prefix . 'filtering_opens_overlay', '1' ) === '1',
929	'enablePostDate' => get_option( $prefix . 'show_post_date', '1' ) === '1',
930	'enableProductPrice' => get_option( $prefix . 'show_product_price', '1' ) === '1',
931	'enableSort' => get_option( $prefix . 'enable_sort', '1' ) === '1',
932	'highlightColor' => get_option( $prefix . 'highlight_color', '#FFC' ),
933	'overlayTrigger' => get_option( $prefix . 'overlay_trigger', Options::DEFAULT_OVERLAY_TRIGGER ),
934	'resultFormat' => get_option( $prefix . 'result_format', Options::RESULT_FORMAT_MINIMAL ),
935	'showPoweredBy' => ( new Plan() )->is_free_plan() \|\| ( get_option( $prefix . 'show_powered_by', '1' ) === '1' ),
936
937	// These options require kicking off a new search.
938	'defaultSort' => get_option( $prefix . 'default_sort', 'relevance' ),
939	'excludedPostTypes' => $excluded_post_types,
940
941	// Fallback image options
942	'fallbackImageUrl' => get_option( $prefix . 'fallback_image_url', '' ),
943	'enableFallbackImage' => get_option( $prefix . 'enable_fallback_image', '0' ) === '1',
944	),
945
946	// core config.
947	'homeUrl' => home_url(),
948	'locale' => str_replace( '_', '-', self::is_valid_locale( get_locale() ) ? get_locale() : 'en_US' ),
949	'postsPerPage' => $posts_per_page,
950	'siteId' => self::get_wpcom_site_id(),
951	'searchSuggestionsEnabled' => (bool) get_option( 'jetpack_search_suggestions_enabled', false ),
952	'postTypes' => $post_type_labels,
953	'webpackPublicPath' => plugins_url( '/build/instant-search/', __DIR__ ),
954	'isPhotonEnabled' => ( $is_wpcom \|\| $is_jetpack_photon_enabled ) && ! $is_private_site,
955	'isFreePlan' => ( new Plan() )->is_free_plan(),
956
957	// config values related to private site support.
958	'apiRoot' => esc_url_raw( rest_url() ),
959	'apiNonce' => wp_create_nonce( 'wp_rest' ),
960	'isPrivateSite' => $is_private_site,
961	'isWpcom' => $is_wpcom,
962
963	// widget info.
964	'hasOverlayWidgets' => is_countable( $overlay_widget_ids ) && count( $overlay_widget_ids ) > 0,
965	'widgets' => array_values( $widgets ),
966	'widgetsOutsideOverlay' => array_values( $widgets_outside_overlay ),
967	'hasNonSearchWidgets' => $has_non_search_widgets,
968	/**
969	* Whether to prevent tracking cookie reset. More information `pbmxuV-39H-p2`.
970	*
971	* @module search
972	*
973	* @since 0.41.0
974	*
975	* @param bool Prevent cookie reset for automattic sites as default value.
976	*/
977	'preventTrackingCookiesReset' => apply_filters( 'jetpack_instant_search_prevent_tracking_cookies_reset', function_exists( 'is_automattic' ) && is_automattic() ),
978
979	/**
980	* Whether to disable Tracks and TrainTracks analytics.
981	*
982	* This can be enabled via URL parameter (?disable_tracking=1) for testing,
983	* or via the filter for permanent configuration. Useful for debugging issues
984	* where tracking may interfere with search functionality, such as Safari's
985	* advanced tracking protection.
986	*
987	* @module search
988	*
989	* @since 0.56.0
990	*
991	* @param bool $disable_tracking Whether to disable tracking. Default false.
992	*/
993	'disableTracking' => self::is_tracking_disabled() \|\| apply_filters( 'jetpack_instant_search_disable_tracking', false ),
994	'aiAnswersEnabled' => AI_Answers::is_enabled(),
995	'aiMasterEnabled' => AI_Answers::is_master_enabled(),
996	);
997
998	/**
999	* Customize Instant Search Options.
1000	*
1001	* @module search
1002	*
1003	* @since 7.7.0
1004	*
1005	* @param array $options Array of parameters used in Instant Search queries.
1006	*/
1007	return apply_filters( 'jetpack_instant_search_options', $options );
1008	}
1009
1010	/**
1011	* Default highlight fields when `highlightFields` is unset in
1012	* `jetpack_instant_search_options`. Matches instant search's JS default.
1013	*
1014	* @since 7.4.0
1015	*/
1016	const DEFAULT_INSTANT_SEARCH_HIGHLIGHT_FIELDS = array( 'title', 'content', 'comments' );
1017
1018	/**
1019	* Fields added to API `fields` when searching additional blogs.
1020	*
1021	* @since 7.4.0
1022	*/
1023	const MULTISITE_SEARCH_FIELD_NAMES = array( 'author', 'blog_name', 'blog_icon_url', 'blog_id' );
1024
1025	/**
1026	* Read Instant Search query-customization options from a filtered options array.
1027	*
1028	* @since 7.4.0
1029	*
1030	* @param array $options Raw `jetpack_instant_search_options` value.
1031	* @return array Query options with keys:
1032	* `highlightPhraseOnly`, `highlightFilterStopwords`, `highlightFields`,
1033	* `additionalBlogIds`, `adminQueryFilter`, and `customResults`.
1034	*/
1035	public static function parse_instant_search_query_options( array $options ): array {
1036	$highlight_phrase_only = ! empty( $options['highlightPhraseOnly'] );
1037
1038	// The v1.3 API rejects requests combining `highlight_filter_stopwords` with
1039	// `highlight_phrase_only` (phrase-only wins server-side) — drop the stopword
1040	// list so requests stay valid when a filter sets both.
1041	$stopwords = array();
1042	if ( ! $highlight_phrase_only && ! empty( $options['highlightFilterStopwords'] ) && is_array( $options['highlightFilterStopwords'] ) ) {
1043	$stopwords = array_values(
1044	array_filter(
1045	$options['highlightFilterStopwords'],
1046	static function ( $word ) {
1047	return is_string( $word ) && '' !== $word;
1048	}
1049	)
1050	);
1051	}
1052
1053	$highlight_fields = null;
1054	if ( ! empty( $options['highlightFields'] ) && is_array( $options['highlightFields'] ) ) {
1055	$highlight_fields = array_values(
1056	array_filter(
1057	$options['highlightFields'],
1058	static function ( $field ) {
1059	return is_string( $field ) && '' !== $field;
1060	}
1061	)
1062	);
1063	if ( array() === $highlight_fields ) {
1064	$highlight_fields = null;
1065	}
1066	}
1067
1068	$additional_blog_ids = array();
1069	if ( ! empty( $options['additionalBlogIds'] ) && is_array( $options['additionalBlogIds'] ) ) {
1070	$additional_blog_ids = array_values( $options['additionalBlogIds'] );
1071	}
1072
1073	$admin_query_filter = null;
1074	if ( ! empty( $options['adminQueryFilter'] ) && is_array( $options['adminQueryFilter'] ) ) {
1075	$admin_query_filter = $options['adminQueryFilter'];
1076	}
1077
1078	$custom_results = array();
1079	if ( ! empty( $options['customResults'] ) && is_array( $options['customResults'] ) ) {
1080	foreach ( $options['customResults'] as $rule ) {
1081	if ( ! is_array( $rule ) ) {
1082	continue;
1083	}
1084	$pattern = isset( $rule['pattern'] ) && is_string( $rule['pattern'] ) ? $rule['pattern'] : '';
1085	$ids = isset( $rule['ids'] ) && is_array( $rule['ids'] ) ? array_values( $rule['ids'] ) : array();
1086	if ( '' === $pattern \|\| array() === $ids ) {
1087	continue;
1088	}
1089	$custom_results[] = array(
1090	'pattern' => $pattern,
1091	'ids' => $ids,
1092	);
1093	}
1094	}
1095
1096	return array(
1097	'highlightPhraseOnly' => $highlight_phrase_only,
1098	'highlightFilterStopwords' => $stopwords,
1099	'highlightFields' => $highlight_fields,
1100	'additionalBlogIds' => $additional_blog_ids,
1101	'adminQueryFilter' => $admin_query_filter,
1102	'customResults' => $custom_results,
1103	);
1104	}
1105
1106	/**
1107	* Read Instant Search query-customization options via `jetpack_instant_search_options`.
1108	*
1109	* Passing an empty array into the filter matches `Filter_Static::read_raw_entries()`
1110	* — callbacks only add keys.
1111	*
1112	* @since 7.4.0
1113	*
1114	* @return array Query options with keys:
1115	* `highlightPhraseOnly`, `highlightFilterStopwords`, `highlightFields`,
1116	* `additionalBlogIds`, `adminQueryFilter`, and `customResults`.
1117	*/
1118	public static function get_instant_search_query_options(): array {
1119	$options = apply_filters( 'jetpack_instant_search_options', array() );
1120	if ( ! is_array( $options ) ) {
1121	$options = array();
1122	}
1123
1124	return self::parse_instant_search_query_options( $options );
1125	}
1126
1127	/**
1128	* Merge Instant Search query-customization options into v1.3 API args.
1129	*
1130	* Shared by Inline Search (Theme) and any server-side v1.3 callers.
1131	*
1132	* @since 7.4.0
1133	*
1134	* @param array $api_query_args API query arguments.
1135	* @param array\|null $options Filtered `jetpack_instant_search_options` value. Defaults to `generate_initial_javascript_state()`.
1136	* @return array
1137	*/
1138	public static function apply_instant_search_query_options_to_api_args( array $api_query_args, ?array $options = null ): array {
1139	if ( null === $options ) {
1140	$options = self::generate_initial_javascript_state();
1141	}
1142	if ( ! is_array( $options ) ) {
1143	return $api_query_args;
1144	}
1145
1146	$query_options = self::parse_instant_search_query_options( $options );
1147
1148	if ( null !== $query_options['adminQueryFilter'] ) {
1149	$api_query_args['filter'] = array(
1150	'bool' => array(
1151	'filter' => $api_query_args['filter'] ?? array(),
1152	'must' => $query_options['adminQueryFilter'],
1153	),
1154	);
1155	}
1156
1157	if ( $query_options['highlightPhraseOnly'] ) {
1158	$api_query_args['highlight_phrase_only'] = true;
1159	}
1160
1161	if ( ! empty( $query_options['highlightFilterStopwords'] ) ) {
1162	$api_query_args['highlight_filter_stopwords'] = $query_options['highlightFilterStopwords'];
1163	}
1164
1165	if ( null !== $query_options['highlightFields'] ) {
1166	$api_query_args['highlight_fields'] = $query_options['highlightFields'];
1167	$api_query_args['highlight'] = array(
1168	'fields' => $query_options['highlightFields'],
1169	);
1170	}
1171
1172	if ( ! empty( $query_options['additionalBlogIds'] ) ) {
1173	$api_query_args['additional_blog_ids'] = $query_options['additionalBlogIds'];
1174	$fields = isset( $api_query_args['fields'] ) && is_array( $api_query_args['fields'] )
1175	? $api_query_args['fields']
1176	: array();
1177	$api_query_args['fields'] = array_values(
1178	array_unique( array_merge( $fields, self::MULTISITE_SEARCH_FIELD_NAMES ) )
1179	);
1180	}
1181
1182	$matched_custom_results = self::resolve_instant_search_custom_results(
1183	(string) ( $api_query_args['query'] ?? '' ),
1184	$query_options['customResults']
1185	);
1186	if ( null !== $matched_custom_results ) {
1187	$api_query_args['custom_results'] = $matched_custom_results;
1188	}
1189
1190	return $api_query_args;
1191	}
1192
1193	/**
1194	* Resolve `customResults` post IDs for a search query.
1195	*
1196	* Mirrors instant search's exact / `regex:` pattern matching.
1197	*
1198	* @since 7.4.0
1199	*
1200	* @param string $query Current search query.
1201	* @param array $custom_results Normalized custom-results rules.
1202	* @return array<int, int\|string>\|null
1203	*/
1204	public static function resolve_instant_search_custom_results( string $query, array $custom_results ): ?array {
1205	if ( array() === $custom_results ) {
1206	return null;
1207	}
1208
1209	foreach ( $custom_results as $rule ) {
1210	$pattern = $rule['pattern'];
1211	$ids = $rule['ids'];
1212	if ( 0 === strpos( $pattern, 'regex:' ) ) {
1213	// Escape the delimiter so patterns containing `/` (e.g. `regex:docs/.*`) stay valid PCRE.
1214	$regex = '/^' . str_replace( '/', '\/', substr( $pattern, strlen( 'regex:' ) ) ) . '$/';
1215	if ( @preg_match( $regex, $query ) ) { // phpcs:ignore WordPress.PHP.NoSilencedErrors.Discouraged -- Invalid user regex should be skipped, not fatal.
1216	return $ids;
1217	}
1218	} elseif ( $query === $pattern ) {
1219	return $ids;
1220	}
1221	}
1222
1223	return null;
1224	}
1225
1226	/**
1227	* Returns true if the site is a WordPress.com simple site, i.e. the code runs on WPCOM.
1228	*/
1229	public static function is_wpcom() {
1230	return defined( 'IS_WPCOM' ) && constant( 'IS_WPCOM' );
1231	}
1232
1233	/**
1234	* Prints the Instant Search sidebar.
1235	*/
1236	public static function print_instant_search_sidebar() {
1237	?>
1238	<div class="jetpack-instant-search__widget-area" style="display: none">
1239	<?php if ( is_active_sidebar( Instant_Search::INSTANT_SEARCH_SIDEBAR ) ) { ?>
1240	<?php dynamic_sidebar( Instant_Search::INSTANT_SEARCH_SIDEBAR ); ?>
1241	<?php } ?>
1242	</div>
1243	<?php
1244	}
1245
1246	/**
1247	* Gets all of the active plugins via site options.
1248	* Forked from Jetpack::get_active_plugins from the Jetpack plugin.
1249	*
1250	* @return string[]
1251	*/
1252	public static function get_active_plugins() {
1253	// active_plugins plugins as values.
1254	$active_plugins = (array) get_option( 'active_plugins', array() );
1255
1256	// active_sitewide_plugins stores plugins as keys.
1257	if ( is_multisite() ) {
1258	$network_plugins = array_keys( get_site_option( 'active_sitewide_plugins', array() ) );
1259	if ( $network_plugins ) {
1260	$active_plugins = array_merge( $active_plugins, $network_plugins );
1261	}
1262	}
1263
1264	sort( $active_plugins );
1265	return array_unique( $active_plugins );
1266	}
1267
1268	/**
1269	* Get the current site's WordPress.com ID.
1270	*
1271	* @return int Blog ID.
1272	*/
1273	public static function get_wpcom_site_id() {
1274	// Returns local blog ID for a multi-site network.
1275	if ( defined( 'IS_WPCOM' ) && constant( 'IS_WPCOM' ) ) {
1276	return \get_current_blog_id();
1277	}
1278
1279	// Returns cache site ID.
1280	return \Jetpack_Options::get_option( 'id' );
1281	}
1282
1283	/**
1284	* Returns true if the free_plan is set to not empty in URL, which is used for testing purpose.
1285	*/
1286	public static function is_forced_free_plan() {
1287	// phpcs:ignore WordPress.Security.NonceVerification.Recommended, WordPress.Security.ValidatedSanitizedInput.InputNotSanitized, WordPress.Security.ValidatedSanitizedInput.MissingUnslash
1288	return isset( $_GET['free_plan'] ) && $_GET['free_plan'];
1289	}
1290
1291	/**
1292	* Returns true if the new_pricing_202210 is set to not empty in URL for testing purpose.
1293	*/
1294	public static function is_forced_new_pricing_202208() {
1295	$referrer = wp_get_referer();
1296	// phpcs:ignore WordPress.Security.NonceVerification.Recommended, WordPress.Security.ValidatedSanitizedInput.InputNotSanitized, WordPress.Security.ValidatedSanitizedInput.MissingUnslash
1297	return ( isset( $_GET['new_pricing_202208'] ) && $_GET['new_pricing_202208'] ) \|\| $referrer && strpos( $referrer, 'new_pricing_202208=1' ) !== false;
1298	}
1299
1300	/**
1301	* Returns true if tracking should be disabled via URL parameter, which is used for testing purposes.
1302	*
1303	* @since 0.56.0
1304	*
1305	* @return bool
1306	*/
1307	public static function is_tracking_disabled() {
1308	// phpcs:ignore WordPress.Security.NonceVerification.Recommended, WordPress.Security.ValidatedSanitizedInput.InputNotSanitized, WordPress.Security.ValidatedSanitizedInput.MissingUnslash
1309	return isset( $_GET['disable_tracking'] ) && $_GET['disable_tracking'];
1310	}
1311
1312	/**
1313	* Enqueue the WordPress.com Tracks library that drains `window._tkq` and
1314	* sends the queued events. Shared by Instant Search and the Search blocks so
1315	* the handle, src, and cache-busting version live in one place. Callers own
1316	* the decision of whether to load it (e.g. the `is_tracking_disabled()` gate).
1317	*/
1318	public static function enqueue_tracks_script() {
1319	wp_enqueue_script( 'jp-tracks', '//stats.wp.com/w.js', array(), gmdate( 'YW' ), true );
1320	}
1321	}
1322