enmi-conf.org: comparison wp/wp-includes/rest-api.php

equal deleted inserted replaced

-:7b1b88e27a20
+:48c4eec2b7e6
 *
 * @since 4.4.0
 * @since 5.1.0 Added a `_doing_it_wrong()` notice when not called on or after the `rest_api_init` hook.
 * @since 5.5.0 Added a `_doing_it_wrong()` notice when the required `permission_callback` argument is not set.
 *
-* @param string $namespace The first URL segment after core prefix. Should be unique to your package/plugin.
+* @param string $route_namespace The first URL segment after core prefix. Should be unique to your package/plugin.
-* @param string $route     The base URL for route you are adding.
+* @param string $route           The base URL for route you are adding.
-* @param array  $args      Optional. Either an array of options for the endpoint, or an array of arrays for
+* @param array  $args            Optional. Either an array of options for the endpoint, or an array of arrays for
-*                          multiple methods. Default empty array.
+*                                multiple methods. Default empty array.
-* @param bool   $override  Optional. If the route already exists, should we override it? True overrides,
+* @param bool   $override        Optional. If the route already exists, should we override it? True overrides,
-*                          false merges (with newer overriding if duplicate keys exist). Default false.
+*                                false merges (with newer overriding if duplicate keys exist). Default false.
 * @return bool True on success, false on error.
 */
-function register_rest_route( $namespace, $route, $args = array(), $override = false ) {
+function register_rest_route( $route_namespace, $route, $args = array(), $override = false ) {
-	if ( empty( $namespace ) ) {
+	if ( empty( $route_namespace ) ) {
 		/*
 		 * Non-namespaced routes are not allowed, with the exception of the main
 		 * and namespace indexes. If you really need to register a
 		 * non-namespaced route, call `WP_REST_Server::register_route` directly.
 		 */
 	} elseif ( empty( $route ) ) {
 		_doing_it_wrong( 'register_rest_route', __( 'Route must be specified.' ), '4.4.0' );
 		return false;
 	}
-	$clean_namespace = trim( $namespace, '/' );
+	$clean_namespace = trim( $route_namespace, '/' );
-	if ( $clean_namespace !== $namespace ) {
+	if ( $clean_namespace !== $route_namespace ) {
 		_doing_it_wrong( __FUNCTION__, __( 'Namespace must not start or end with a slash.' ), '5.4.2' );
 	}
 	if ( ! did_action( 'rest_api_init' ) ) {
 		_doing_it_wrong(
 					'<code>__return_true</code>'
 				),
 				'5.5.0'
 			);
 		}
+		foreach ( $arg_group['args'] as $arg ) {
+			if ( ! is_array( $arg ) ) {
+				_doing_it_wrong(
+					__FUNCTION__,
+					sprintf(
+						/* translators: 1: $args, 2: The REST API route being registered. */
+						__( 'REST API %1$s should be an array of arrays. Non-array value detected for %2$s.' ),
+						'<code>$args</code>',
+						'<code>' . $clean_namespace . '/' . trim( $route, '/' ) . '</code>'
+					),
+					'6.1.0'
+				);
+				break; // Leave the foreach loop once a non-array argument was found.
+			}
+		}
 	}
 	$full_route = '/' . $clean_namespace . '/' . trim( $route, '/' );
 	rest_get_server()->register_route( $clean_namespace, $full_route, $args, $override );
 	return true;
 * to make testing and disabling these filters easier.
 *
 * @since 4.4.0
 */
 function rest_api_default_filters() {
-	if ( defined( 'REST_REQUEST' ) && REST_REQUEST ) {
+	if ( wp_is_serving_rest_request() ) {
 		// Deprecated reporting.
 		add_action( 'deprecated_function_run', 'rest_handle_deprecated_function', 10, 3 );
 		add_filter( 'deprecated_function_trigger_error', '__return_false' );
 		add_action( 'deprecated_argument_run', 'rest_handle_deprecated_argument', 10, 3 );
 		add_filter( 'deprecated_argument_trigger_error', '__return_false' );
 		if ( ! $controller ) {
 			continue;
 		}
-		$controller->register_routes();
+		if ( ! $post_type->late_route_registration ) {
+			$controller->register_routes();
-		if ( post_type_supports( $post_type->name, 'revisions' ) ) {
+		}
-			$revisions_controller = new WP_REST_Revisions_Controller( $post_type->name );
+		$revisions_controller = $post_type->get_revisions_rest_controller();
+		if ( $revisions_controller ) {
 			$revisions_controller->register_routes();
 		}
-		if ( 'attachment' !== $post_type->name ) {
+		$autosaves_controller = $post_type->get_autosave_rest_controller();
-			$autosaves_controller = new WP_REST_Autosaves_Controller( $post_type->name );
+		if ( $autosaves_controller ) {
 			$autosaves_controller->register_routes();
 		}
+		if ( $post_type->late_route_registration ) {
+			$controller->register_routes();
+		}
 	}
 	// Post types.
-	$controller = new WP_REST_Post_Types_Controller;
+	$controller = new WP_REST_Post_Types_Controller();
 	$controller->register_routes();
 	// Post statuses.
-	$controller = new WP_REST_Post_Statuses_Controller;
+	$controller = new WP_REST_Post_Statuses_Controller();
 	$controller->register_routes();
 	// Taxonomies.
-	$controller = new WP_REST_Taxonomies_Controller;
+	$controller = new WP_REST_Taxonomies_Controller();
 	$controller->register_routes();
 	// Terms.
 	foreach ( get_taxonomies( array( 'show_in_rest' => true ), 'object' ) as $taxonomy ) {
 		$controller = $taxonomy->get_rest_controller();
 		$controller->register_routes();
 	}
 	// Users.
-	$controller = new WP_REST_Users_Controller;
+	$controller = new WP_REST_Users_Controller();
 	$controller->register_routes();
 	// Application Passwords
 	$controller = new WP_REST_Application_Passwords_Controller();
 	$controller->register_routes();
 	// Comments.
-	$controller = new WP_REST_Comments_Controller;
+	$controller = new WP_REST_Comments_Controller();
 	$controller->register_routes();
 	$search_handlers = array(
 		new WP_REST_Post_Search_Handler(),
 		new WP_REST_Term_Search_Handler(),
 	// Block Types.
 	$controller = new WP_REST_Block_Types_Controller();
 	$controller->register_routes();
-	// Global Styles.
+	// Settings.
-	$controller = new WP_REST_Global_Styles_Controller;
+	$controller = new WP_REST_Settings_Controller();
 	$controller->register_routes();
-	// Settings.
-	$controller = new WP_REST_Settings_Controller;
-	$controller->register_routes();
 	// Themes.
-	$controller = new WP_REST_Themes_Controller;
+	$controller = new WP_REST_Themes_Controller();
 	$controller->register_routes();
 	// Plugins.
 	$controller = new WP_REST_Plugins_Controller();
 	$controller->register_routes();
 	$controller->register_routes();
 	// Site Editor Export.
 	$controller = new WP_REST_Edit_Site_Export_Controller();
 	$controller->register_routes();
+	// Navigation Fallback.
+	$controller = new WP_REST_Navigation_Fallback_Controller();
+	$controller->register_routes();
+	// Font Collections.
+	$font_collections_controller = new WP_REST_Font_Collections_Controller();
+	$font_collections_controller->register_routes();
 }
 /**
 * Loads the REST API.
 *
 		}
 		$url .= $path;
 	} else {
 		$url = trailingslashit( get_home_url( $blog_id, '', $scheme ) );
-		// nginx only allows HTTP/1.0 methods when redirecting from / to /index.php.
+		/*
-		// To work around this, we manually add index.php to the URL, avoiding the redirect.
+		 * nginx only allows HTTP/1.0 methods when redirecting from / to /index.php.
-		if ( 'index.php' !== substr( $url, 9 ) ) {
+		 * To work around this, we manually add index.php to the URL, avoiding the redirect.
+		 */
+		if ( ! str_ends_with( $url, 'index.php' ) ) {
 			$url .= 'index.php';
 		}
 		$url = add_query_arg( 'rest_route', $path, $url );
 	}
 		 * @since 4.4.0
 		 *
 		 * @param string $class_name The name of the server class. Default 'WP_REST_Server'.
 		 */
 		$wp_rest_server_class = apply_filters( 'wp_rest_server_class', 'WP_REST_Server' );
-		$wp_rest_server       = new $wp_rest_server_class;
+		$wp_rest_server       = new $wp_rest_server_class();
 		/**
 		 * Fires when preparing to serve a REST API request.
 		 *
 		 * Endpoint objects should be created and register their hooks on this action rather
 	if ( $response instanceof WP_REST_Response ) {
 		return $response;
 	}
-	// While WP_HTTP_Response is the base class of WP_REST_Response, it doesn't provide
+	/*
-	// all the required methods used in WP_REST_Server::dispatch().
+	 * While WP_HTTP_Response is the base class of WP_REST_Response, it doesn't provide
+	 * all the required methods used in WP_REST_Server::dispatch().
+	 */
 	if ( $response instanceof WP_HTTP_Response ) {
 		return new WP_REST_Response(
 			$response->get_data(),
 			$response->get_status(),
 			$response->get_headers()
 /**
 * Handles _deprecated_function() errors.
 *
 * @since 4.4.0
 *
-* @param string $function    The function that was called.
+* @param string $function_name The function that was called.
-* @param string $replacement The function that should have been called.
+* @param string $replacement   The function that should have been called.
-* @param string $version     Version.
+* @param string $version       Version.
 */
-function rest_handle_deprecated_function( $function, $replacement, $version ) {
+function rest_handle_deprecated_function( $function_name, $replacement, $version ) {
 	if ( ! WP_DEBUG || headers_sent() ) {
 		return;
 	}
 	if ( ! empty( $replacement ) ) {
 		/* translators: 1: Function name, 2: WordPress version number, 3: New function name. */
-		$string = sprintf( __( '%1$s (since %2$s; use %3$s instead)' ), $function, $version, $replacement );
+		$string = sprintf( __( '%1$s (since %2$s; use %3$s instead)' ), $function_name, $version, $replacement );
 	} else {
 		/* translators: 1: Function name, 2: WordPress version number. */
-		$string = sprintf( __( '%1$s (since %2$s; no alternative available)' ), $function, $version );
+		$string = sprintf( __( '%1$s (since %2$s; no alternative available)' ), $function_name, $version );
 	}
 	header( sprintf( 'X-WP-DeprecatedFunction: %s', $string ) );
 }
 /**
 * Handles _deprecated_argument() errors.
 *
 * @since 4.4.0
 *
-* @param string $function    The function that was called.
+* @param string $function_name The function that was called.
-* @param string $message     A message regarding the change.
+* @param string $message       A message regarding the change.
-* @param string $version     Version.
+* @param string $version       Version.
 */
-function rest_handle_deprecated_argument( $function, $message, $version ) {
+function rest_handle_deprecated_argument( $function_name, $message, $version ) {
 	if ( ! WP_DEBUG || headers_sent() ) {
 		return;
 	}
 	if ( $message ) {
 		/* translators: 1: Function name, 2: WordPress version number, 3: Error message. */
-		$string = sprintf( __( '%1$s (since %2$s; %3$s)' ), $function, $version, $message );
+		$string = sprintf( __( '%1$s (since %2$s; %3$s)' ), $function_name, $version, $message );
 	} else {
 		/* translators: 1: Function name, 2: WordPress version number. */
-		$string = sprintf( __( '%1$s (since %2$s; no alternative available)' ), $function, $version );
+		$string = sprintf( __( '%1$s (since %2$s; no alternative available)' ), $function_name, $version );
 	}
 	header( sprintf( 'X-WP-DeprecatedParam: %s', $string ) );
 }
 /**
 * Handles _doing_it_wrong errors.
 *
 * @since 5.5.0
 *
-* @param string      $function The function that was called.
+* @param string      $function_name The function that was called.
-* @param string      $message  A message explaining what has been done incorrectly.
+* @param string      $message       A message explaining what has been done incorrectly.
-* @param string|null $version  The version of WordPress where the message was added.
+* @param string|null $version       The version of WordPress where the message was added.
 */
-function rest_handle_doing_it_wrong( $function, $message, $version ) {
+function rest_handle_doing_it_wrong( $function_name, $message, $version ) {
 	if ( ! WP_DEBUG || headers_sent() ) {
 		return;
 	}
 	if ( $version ) {
 		/* translators: Developer debugging message. 1: PHP function name, 2: WordPress version number, 3: Explanatory message. */
 		$string = __( '%1$s (since %2$s; %3$s)' );
-		$string = sprintf( $string, $function, $version, $message );
+		$string = sprintf( $string, $function_name, $version, $message );
 	} else {
 		/* translators: Developer debugging message. 1: PHP function name, 2: Explanatory message. */
 		$string = __( '%1$s (%2$s)' );
-		$string = sprintf( $string, $function, $message );
+		$string = sprintf( $string, $function_name, $message );
 	}
 	header( sprintf( 'X-WP-DoingItWrong: %s', $string ) );
 }
 	$origin = get_http_origin();
 	if ( $origin ) {
 		// Requests from file:// and data: URLs send "Origin: null".
 		if ( 'null' !== $origin ) {
-			$origin = esc_url_raw( $origin );
+			$origin = sanitize_url( $origin );
 		}
 		header( 'Access-Control-Allow-Origin: ' . $origin );
 		header( 'Access-Control-Allow-Methods: OPTIONS, GET, POST, PUT, PATCH, DELETE' );
 		header( 'Access-Control-Allow-Credentials: true' );
 		header( 'Vary: Origin', false );
 	}
 	return $array1;
 }
 /**
-* Filters the REST API response to include only a white-listed set of response object fields.
+* Filters the REST API response to include only an allow-listed set of response object fields.
 *
 * @since 4.8.0
 *
 * @param WP_REST_Response $response Current response being served.
 * @param WP_REST_Server   $server   ResponseHandler instance (usually WP_REST_Server).
 	if ( in_array( $field, $fields, true ) ) {
 		return true;
 	}
 	foreach ( $fields as $accepted_field ) {
-		// Check to see if $field is the parent of any item in $fields.
+		/*
-		// A field "parent" should be accepted if "parent.child" is accepted.
+		 * Check to see if $field is the parent of any item in $fields.
-		if ( strpos( $accepted_field, "$field." ) === 0 ) {
+		 * A field "parent" should be accepted if "parent.child" is accepted.
+		 */
+		if ( str_starts_with( $accepted_field, "$field." ) ) {
 			return true;
 		}
-		// Conversely, if "parent" is accepted, all "parent.child" fields
+		/*
-		// should also be accepted.
+		 * Conversely, if "parent" is accepted, all "parent.child" fields
-		if ( strpos( $field, "$accepted_field." ) === 0 ) {
+		 * should also be accepted.
+		 */
+		if ( str_starts_with( $field, "$accepted_field." ) ) {
 			return true;
 		}
 	}
 	return false;
 	printf( '<link rel="https://api.w.org/" href="%s" />', esc_url( $api_root ) );
 	$resource = rest_get_queried_resource_route();
 	if ( $resource ) {
-		printf( '<link rel="alternate" type="application/json" href="%s" />', esc_url( rest_url( $resource ) ) );
+		printf(
+			'<link rel="alternate" title="%1$s" type="application/json" href="%2$s" />',
+			_x( 'JSON', 'REST API resource link name' ),
+			esc_url( rest_url( $resource ) )
+		);
 	}
 }
 /**
 * Sends a Link header for the REST API.
 	if ( empty( $api_root ) ) {
 		return;
 	}
-	header( sprintf( 'Link: <%s>; rel="https://api.w.org/"', esc_url_raw( $api_root ) ), false );
+	header( sprintf( 'Link: <%s>; rel="https://api.w.org/"', sanitize_url( $api_root ) ), false );
 	$resource = rest_get_queried_resource_route();
 	if ( $resource ) {
-		header( sprintf( 'Link: <%s>; rel="alternate"; type="application/json"', esc_url_raw( rest_url( $resource ) ) ), false );
+		header(
+			sprintf(
+				'Link: <%1$s>; rel="alternate"; title="%2$s"; type="application/json"',
+				sanitize_url( rest_url( $resource ) ),
+				_x( 'JSON', 'REST API resource link name' )
+			),
+			false
+		);
 	}
 }
 /**
 * Checks for errors when using cookie-based authentication.
 	// Check the nonce.
 	$result = wp_verify_nonce( $nonce, 'wp_rest' );
 	if ( ! $result ) {
+		add_filter( 'rest_send_nocache_headers', '__return_true', 20 );
 		return new WP_Error( 'rest_cookie_invalid_nonce', __( 'Cookie check failed' ), array( 'status' => 403 ) );
 	}
 	// Send a refreshed nonce in header.
 	rest_get_server()->send_header( 'X-WP-Nonce', wp_create_nonce( 'wp_rest' ) );
 	return $response;
 }
 /**
-* Retrieves the avatar urls in various sizes.
+* Retrieves the avatar URLs in various sizes.
 *
 * @since 4.7.0
 *
 * @see get_avatar_url()
 *
-* @param mixed $id_or_email The Gravatar to retrieve a URL for. Accepts a user_id, gravatar md5 hash,
+* @param mixed $id_or_email The avatar to retrieve a URL for. Accepts a user ID, Gravatar MD5 hash,
 *                           user email, WP_User object, WP_Post object, or WP_Comment object.
-* @return array Avatar URLs keyed by size. Each value can be a URL string or boolean false.
+* @return (string|false)[] Avatar URLs keyed by size. Each value can be a URL string or boolean false.
 */
 function rest_get_avatar_urls( $id_or_email ) {
 	$avatar_sizes = rest_get_avatar_sizes();
 	$urls = array();
 * @since 4.4.0
 *
 * @param string $date      RFC3339 timestamp.
 * @param bool   $force_utc Optional. Whether to force UTC timezone instead of using
 *                          the timestamp's timezone. Default false.
-* @return int Unix timestamp.
+* @return int|false Unix timestamp on success, false on failure.
 */
 function rest_parse_date( $date, $force_utc = false ) {
 	if ( $force_utc ) {
 		$date = preg_replace( '/[+-]\d+:?\d+$/', '+00:00', $date );
 	}
 * Parses a 3 or 6 digit hex color (with #).
 *
 * @since 5.4.0
 *
 * @param string $color 3 or 6 digit hex color (with #).
-* @return string|false
+* @return string|false Color value on success, false on failure.
 */
 function rest_parse_hex_color( $color ) {
 	$regex = '|^#([A-Fa-f0-9]{3}){1,2}$|';
 	if ( ! preg_match( $regex, $color, $matches ) ) {
 		return false;
 *
 * @see rest_parse_date()
 *
 * @param string $date   RFC3339 timestamp.
 * @param bool   $is_utc Whether the provided date should be interpreted as UTC. Default false.
-* @return array|null Local and UTC datetime strings, in MySQL datetime format (Y-m-d H:i:s),
+* @return array|null {
-*                    null on failure.
+*     Local and UTC datetime strings, in MySQL datetime format (Y-m-d H:i:s),
+*     null on failure.
+*
+*     @type string $0 Local datetime string.
+*     @type string $1 UTC datetime string.
+* }
 */
 function rest_get_date_with_gmt( $date, $is_utc = false ) {
 	/*
 	 * Whether or not the original date actually has a timezone string
 	 * changes the way we need to do timezone conversion.
 * @return string|false The valid IP address, otherwise false.
 */
 function rest_is_ip_address( $ip ) {
 	$ipv4_pattern = '/^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/';
-	if ( ! preg_match( $ipv4_pattern, $ip ) && ! Requests_IPv6::check_ipv6( $ip ) ) {
+	if ( ! preg_match( $ipv4_pattern, $ip ) && ! WpOrg\Requests\Ipv6::check_ipv6( $ip ) ) {
 		return false;
 	}
 	return $ip;
 }
 	return is_array( $maybe_object );
 }
 /**
-* Converts an object-like value to an object.
+* Converts an object-like value to an array.
 *
 * @since 5.5.0
 *
 * @param mixed $maybe_object The value being evaluated.
-* @return array Returns the object extracted from the value.
+* @return array Returns the object extracted from the value as an associative array.
 */
 function rest_sanitize_object( $maybe_object ) {
 	if ( '' === $maybe_object ) {
 		return array();
 	}
 /**
 * Gets the best type for a value.
 *
 * @since 5.5.0
 *
-* @param mixed $value The value to check.
+* @param mixed    $value The value to check.
-* @param array $types The list of possible types.
+* @param string[] $types The list of possible types.
 * @return string The best matching type, an empty string if no types match.
 */
 function rest_get_best_type_for_value( $value, $types ) {
 	static $checks = array(
 		'array'   => 'rest_is_array',
 		'boolean' => 'rest_is_boolean',
 		'string'  => 'is_string',
 		'null'    => 'is_null',
 	);
-	// Both arrays and objects allow empty strings to be converted to their types.
+	/*
-	// But the best answer for this type is a string.
+	 * Both arrays and objects allow empty strings to be converted to their types.
+	 * But the best answer for this type is a string.
+	 */
 	if ( '' === $value && in_array( 'string', $types, true ) ) {
 		return 'string';
 	}
 	foreach ( $types as $type ) {
 /**
 * Checks if an array is made up of unique items.
 *
 * @since 5.5.0
 *
-* @param array $array The array to check.
+* @param array $input_array The array to check.
 * @return bool True if the array contains unique items, false otherwise.
 */
-function rest_validate_array_contains_unique_items( $array ) {
+function rest_validate_array_contains_unique_items( $input_array ) {
 	$seen = array();
-	foreach ( $array as $item ) {
+	foreach ( $input_array as $item ) {
 		$stabilized = rest_stabilize_value( $item );
 		$key        = serialize( $stabilized );
 		if ( ! isset( $seen[ $key ] ) ) {
 			$seen[ $key ] = true;
 		if ( is_wp_error( $enum_contains_value ) ) {
 			return $enum_contains_value;
 		}
 	}
-	// The "format" keyword should only be applied to strings. However, for backward compatibility,
+	/*
-	// we allow the "format" keyword if the type keyword was not specified, or was set to an invalid value.
+	 * The "format" keyword should only be applied to strings. However, for backward compatibility,
+	 * we allow the "format" keyword if the type keyword was not specified, or was set to an invalid value.
+	 */
 	if ( isset( $args['format'] )
 		&& ( ! isset( $args['type'] ) || 'string' === $args['type'] || ! in_array( $args['type'], $allowed_types, true ) )
 	) {
 		switch ( $args['format'] ) {
 			case 'hex-color':
 			case 'email':
 				// sanitize_email() validates, which would be unexpected.
 				return sanitize_text_field( $value );
 			case 'uri':
-				return esc_url_raw( $value );
+				return sanitize_url( $value );
 			case 'ip':
 				return sanitize_text_field( $value );
 			case 'uuid':
 * @param array  $memo Reduce accumulator.
 * @param string $path REST API path to preload.
 * @return array Modified reduce accumulator.
 */
 function rest_preload_api_request( $memo, $path ) {
-	// array_reduce() doesn't support passing an array in PHP 5.2,
+	/*
-	// so we need to make sure we start with one.
+	 * array_reduce() doesn't support passing an array in PHP 5.2,
+	 * so we need to make sure we start with one.
+	 */
 	if ( ! is_array( $memo ) ) {
 		$memo = array();
 	}
 	if ( empty( $path ) ) {
 	$response = rest_do_request( $request );
 	if ( 200 === $response->status ) {
 		$server = rest_get_server();
 		/** This filter is documented in wp-includes/rest-api/class-wp-rest-server.php */
 		$response = apply_filters( 'rest_post_dispatch', rest_ensure_response( $response ), $server, $request );
-		$embed  = $request->has_param( '_embed' ) ? rest_parse_embed_param( $request['_embed'] ) : false;
+		$embed    = $request->has_param( '_embed' ) ? rest_parse_embed_param( $request['_embed'] ) : false;
-		$data   = (array) $server->response_to_data( $response, $embed );
+		$data     = (array) $server->response_to_data( $response, $embed );
 		if ( 'OPTIONS' === $method ) {
 			$memo[ $method ][ $path ] = array(
 				'body'    => $data,
 				'headers' => $response->headers,
 *
 * @since 5.5.0
 * @since 5.6.0 Support the "patternProperties" keyword for objects.
 *              Support the "anyOf" and "oneOf" keywords.
 *
-* @param array|object $data    The response data to modify.
+* @param array|object $response_data The response data to modify.
-* @param array        $schema  The schema for the endpoint used to filter the response.
+* @param array        $schema        The schema for the endpoint used to filter the response.
-* @param string       $context The requested context.
+* @param string       $context       The requested context.
 * @return array|object The filtered response data.
 */
-function rest_filter_response_by_context( $data, $schema, $context ) {
+function rest_filter_response_by_context( $response_data, $schema, $context ) {
 	if ( isset( $schema['anyOf'] ) ) {
-		$matching_schema = rest_find_any_matching_schema( $data, $schema, '' );
+		$matching_schema = rest_find_any_matching_schema( $response_data, $schema, '' );
 		if ( ! is_wp_error( $matching_schema ) ) {
 			if ( ! isset( $schema['type'] ) ) {
 				$schema['type'] = $matching_schema['type'];
 			}
-			$data = rest_filter_response_by_context( $data, $matching_schema, $context );
+			$response_data = rest_filter_response_by_context( $response_data, $matching_schema, $context );
 		}
 	}
 	if ( isset( $schema['oneOf'] ) ) {
-		$matching_schema = rest_find_one_matching_schema( $data, $schema, '', true );
+		$matching_schema = rest_find_one_matching_schema( $response_data, $schema, '', true );
 		if ( ! is_wp_error( $matching_schema ) ) {
 			if ( ! isset( $schema['type'] ) ) {
 				$schema['type'] = $matching_schema['type'];
 			}
-			$data = rest_filter_response_by_context( $data, $matching_schema, $context );
+			$response_data = rest_filter_response_by_context( $response_data, $matching_schema, $context );
 		}
 	}
-	if ( ! is_array( $data ) && ! is_object( $data ) ) {
+	if ( ! is_array( $response_data ) && ! is_object( $response_data ) ) {
-		return $data;
+		return $response_data;
 	}
 	if ( isset( $schema['type'] ) ) {
 		$type = $schema['type'];
 	} elseif ( isset( $schema['properties'] ) ) {
 		$type = 'object'; // Back compat if a developer accidentally omitted the type.
 	} else {
-		return $data;
+		return $response_data;
 	}
 	$is_array_type  = 'array' === $type || ( is_array( $type ) && in_array( 'array', $type, true ) );
 	$is_object_type = 'object' === $type || ( is_array( $type ) && in_array( 'object', $type, true ) );
 	if ( $is_array_type && $is_object_type ) {
-		if ( rest_is_array( $data ) ) {
+		if ( rest_is_array( $response_data ) ) {
 			$is_object_type = false;
 		} else {
 			$is_array_type = false;
 		}
 	}
 	$has_additional_properties = $is_object_type && isset( $schema['additionalProperties'] ) && is_array( $schema['additionalProperties'] );
-	foreach ( $data as $key => $value ) {
+	foreach ( $response_data as $key => $value ) {
 		$check = array();
 		if ( $is_array_type ) {
 			$check = isset( $schema['items'] ) ? $schema['items'] : array();
 		} elseif ( $is_object_type ) {
 		}
 		if ( ! in_array( $context, $check['context'], true ) ) {
 			if ( $is_array_type ) {
 				// All array items share schema, so there's no need to check each one.
-				$data = array();
+				$response_data = array();
 				break;
 			}
-			if ( is_object( $data ) ) {
+			if ( is_object( $response_data ) ) {
-				unset( $data->$key );
+				unset( $response_data->$key );
 			} else {
-				unset( $data[ $key ] );
+				unset( $response_data[ $key ] );
 			}
 		} elseif ( is_array( $value ) || is_object( $value ) ) {
 			$new_value = rest_filter_response_by_context( $value, $check, $context );
-			if ( is_object( $data ) ) {
+			if ( is_object( $response_data ) ) {
-				$data->$key = $new_value;
+				$response_data->$key = $new_value;
 			} else {
-				$data[ $key ] = $new_value;
+				$response_data[ $key ] = $new_value;
 			}
 		}
 	}
-	return $data;
+	return $response_data;
 }
 /**
 * Sets the "additionalProperties" to false by default for all object definitions in the schema.
 *
 /**
 * Converts an error to a response object.
 *
 * This iterates over all error codes and messages to change it into a flat
-* array. This enables simpler client behaviour, as it is represented as a
+* array. This enables simpler client behavior, as it is represented as a
 * list in JSON rather than an object/map.
 *
 * @since 5.7.0
 *
 * @param WP_Error $error WP_Error instance.
 		$data['additional_errors'] = $errors;
 	}
 	return new WP_REST_Response( $data, $status );
 }
+/**
+* Checks whether a REST API endpoint request is currently being handled.
+*
+* This may be a standalone REST API request, or an internal request dispatched from within a regular page load.
+*
+* @since 6.5.0
+*
+* @global WP_REST_Server $wp_rest_server REST server instance.
+*
+* @return bool True if a REST endpoint request is currently being handled, false otherwise.
+*/
+function wp_is_rest_endpoint() {
+	/* @var WP_REST_Server $wp_rest_server */
+	global $wp_rest_server;
+	// Check whether this is a standalone REST request.
+	$is_rest_endpoint = wp_is_serving_rest_request();
+	if ( ! $is_rest_endpoint ) {
+		// Otherwise, check whether an internal REST request is currently being handled.
+		$is_rest_endpoint = isset( $wp_rest_server )
+			&& $wp_rest_server->is_dispatching();
+	}
+	/**
+	 * Filters whether a REST endpoint request is currently being handled.
+	 *
+	 * This may be a standalone REST API request, or an internal request dispatched from within a regular page load.
+	 *
+	 * @since 6.5.0
+	 *
+	 * @param bool $is_request_endpoint Whether a REST endpoint request is currently being handled.
+	 */
+	return (bool) apply_filters( 'wp_is_rest_endpoint', $is_rest_endpoint );
+}

changeset 21	48c4eec2b7e6
parent 19	3d72ae0968f4
child 22	8c2e4d02f4ef