Font Library: font family and font uploads capability checks

lib/compat/wordpress-6.5/fonts/class-wp-rest-font-faces-controller.php

@@ -326,6 +326,14 @@ public function create_item( $request ) {
 			$settings    = $request->get_param( 'font_face_settings' );
 			$file_params = $request->get_file_params();
 
+			if ( ! empty( $file_params ) && ! current_user_can( 'upload_fonts' ) ) {
+				return new WP_Error(
+					'rest_cannot_upload_fonts',
+					__( 'You are not allowed to upload font files.', 'gutenberg' ),
+					array( 'status' => 403 )
+				);
+			}
+
 			// Check that the necessary font face properties are unique.
 			$query = new WP_Query(
 				array(

lib/compat/wordpress-6.5/fonts/fonts.php

@@ -85,31 +85,147 @@ function gutenberg_create_initial_post_types() {
 }
 
 /**
- * Initializes REST routes.
+ * Modify the `delete_post` meta capability for font post types.
+ *
+ * For font families and font faces containing attached font files, file
+ * system access is required by the user in order to delete posts.
  *
- * @since 6.5
+ * @param string[] $caps    The primitive capabilities required for the given capability.
+ * @param string   $cap     The capability being checked.
+ * @param int      $user_id The user ID.
+ * @param array    $args    Context for the capability check.
+ * @return string[] The modified primitive capabilities required for the given capability.
+ */
+function gutenberg_delete_font_post_meta_caps( $caps, $cap, $user_id, $args ) {
+	if ( in_array( 'do_not_allow', $caps, true ) ) {
+		// It's already known that the user is not allowed to perform the requested capability.
+		return $caps;
+	}
+
+	if ( 'delete_post' !== $cap ) {
+		// This filter is only concerned with the 'delete_post' meta capability.
+		return $caps;
+	}
+
+	$post = get_post( $args[0] );
+	if ( ! $post ) {
+		// Do not allow deleting posts that do not exist.
+		$caps[] = 'do_not_allow';
+		return $caps;
+	}
+
+	// Check for font post types.
+	$post_type = get_post_type( $post );
+	if ( 'wp_font_face' === $post_type ) {
+		// Are there any font files associated with this font face?
+		$font_files = get_post_meta( $post->ID, '_wp_font_face_file', false );
+		if ( empty( $font_files ) ) {
+			/*
+			* No font files.
+			*
+			* The user can delete the post based on the 'delete_post' meta capability.
+			*/
+			return $caps;
+		}
+
+		// The user can only delete the post if they can modify the file system.
+		$caps[] = 'upload_fonts';
+		return $caps;
+	}
+
+	if ( 'wp_font_family' === $post_type ) {
+		// Are there any font faces associated with this font family?
+		$font_faces = get_children(
+			array(
+				'post_parent' => $post->ID,
+				'post_type'   => 'wp_font_face',
+			)
+		);
+
+		if ( empty( $font_faces ) ) {
+			/*
+			 * No font faces.
+			 *
+			 * The user can delete the post based on the 'delete_post' meta capability.
+			 */
+			return $caps;
+		}
+
+		// If any of the font faces contain files, the user needs to be able to modify the file system.
+		foreach ( $font_faces as $font_face ) {
+			$font_files = get_post_meta( $font_face->ID, '_wp_font_face_file', false );
+			if ( ! empty( $font_files ) ) {
+				$caps[] = 'upload_fonts';
+				// File system caps are required, so no need to check further.
+				break;
+			}
+		}
+		return $caps;
+	}
+
+	// Return existing caps if the post type is not a font family or font face.
+	return $caps;
+}
+add_filter( 'map_meta_cap', 'gutenberg_delete_font_post_meta_caps', 10, 4 );
+
+/**
+ * Filters the user capabilities to grant the 'upload_fonts' capability as necessary.
+ *
+ * To grant the 'upload_fonts' capability, file modifications must be allowed, the fonts directory must be
+ * writable, and the user must have the 'edit_theme_options' capability.
+ *
+ * @since 6.5.0
+ *
+ * @param  bool[] $allcaps An array of all the user's capabilities.
+ * @return bool[] Filtered array of the user's capabilities.
+ */
+function gutenberg_maybe_grant_upload_font_cap( $allcaps, $caps ) {
+	if ( ! in_array( 'upload_fonts', $caps, true ) ) {
+		return $allcaps;
+	}
+
+	$fonts_dir = wp_get_font_dir()['path'];
+	$post_type = get_post_type_object( 'wp_font_face' );
+	if (
+		wp_is_file_mod_allowed( 'can_upload_fonts' ) &&
+		wp_is_writable( $fonts_dir ) &&
+		current_user_can( $post_type->cap->create_posts )
+	) {
+		$allcaps['upload_fonts'] = true;
+	}
+
+	return $allcaps;
+}
+add_filter( 'user_has_cap', 'gutenberg_maybe_grant_upload_font_cap', 10, 2 );
+
+/**
+ * Initializes REST routes.
  */
 function gutenberg_create_initial_rest_routes() {
-	$font_collections_controller = new WP_REST_Font_Collections_Controller();
-	$font_collections_controller->register_routes();
+	global $wp_version;
+
+	// Runs only if the Font Library is not available in core ( i.e. in core < 6.5-alpha ).
+	if ( version_compare( $wp_version, '6.5-alpha', '<' ) ) {
+		$font_collections_controller = new WP_REST_Font_Collections_Controller();
+		$font_collections_controller->register_routes();
+	}
 }
 
+add_action( 'rest_api_init', 'gutenberg_create_initial_rest_routes' );
+
 /**
  * Initializes REST routes and post types.
- *
- * @since 6.5
  */
 function gutenberg_init_font_library() {
 	global $wp_version;
 
 	// Runs only if the Font Library is not available in core ( i.e. in core < 6.5-alpha ).
 	if ( version_compare( $wp_version, '6.5-alpha', '<' ) ) {
 		gutenberg_create_initial_post_types();
-		gutenberg_create_initial_rest_routes();
 	}
 }
 
-add_action( 'rest_api_init', 'gutenberg_init_font_library' );
+add_action( 'init', 'gutenberg_init_font_library' );
 
 
 if ( ! function_exists( 'wp_register_font_collection' ) ) {
@@ -303,6 +419,21 @@ function _wp_before_delete_font_face( $post_id, $post ) {
 	add_action( 'before_delete_post', '_wp_before_delete_font_face', 10, 2 );
 }
 
+/**
+ * Filters the block editor settings to enable or disable font uploads according to user capability.
+ *
+ * @since 6.5.0
+ *
+ * @param array $settings Block editor settings.
+ * @return array Block editor settings.
+ */
+function gutenberg_font_uploads_settings( $settings ) {
+	$settings['fontUploadsEnabled'] = current_user_can( 'upload_fonts' );
+
+	return $settings;
+}
+add_filter( 'block_editor_settings_all', 'gutenberg_font_uploads_settings' );
+
 // @core-merge: Do not merge this back compat function, it is for supporting a legacy font family format only in Gutenberg.
 /**
  * Convert legacy font family posts to the new format.

packages/edit-site/src/components/global-styles/font-library-modal/font-collection.js

@@ -28,6 +28,8 @@ import {
 	DropdownMenu,
 } from '@wordpress/components';
 import { debounce } from '@wordpress/compose';
+import { useSelect } from '@wordpress/data';
+import { store as editorStore } from '@wordpress/editor';
 import { sprintf, __, _x } from '@wordpress/i18n';
 import {
 	search,
@@ -86,6 +88,11 @@ function FontCollection( { slug } ) {
 		( collection ) => collection.slug === slug
 	);
 
+	const fontUploadsEnabled = useSelect( ( select ) => {
+		const { getEditorSettings } = select( editorStore );
+		return getEditorSettings().fontUploadsEnabled;
+	}, [] );
+
 	useEffect( () => {
 		const handleStorage = () => {
 			setRenderConfirmDialog(
@@ -416,7 +423,12 @@ function FontCollection( { slug } ) {
 						variant="primary"
 						onClick={ handleInstall }
 						isBusy={ isInstalling }
-						disabled={ fontsToInstall.length === 0 || isInstalling }
+						disabled={
+							fontsToInstall.length === 0 ||
+							isInstalling ||
+							( ! fontUploadsEnabled &&
+								selectedFont?.fontFace?.length )
+						}
 						__experimentalIsFocusable
 					>
 						{ __( 'Install' ) }

packages/edit-site/src/components/global-styles/font-library-modal/index.js

@@ -6,6 +6,9 @@ import {
 	Modal,
 	privateApis as componentsPrivateApis,
 } from '@wordpress/components';
+import { store as coreStore } from '@wordpress/core-data';
+import { useSelect } from '@wordpress/data';
+import { store as editorStore } from '@wordpress/editor';
 import { useContext } from '@wordpress/element';
 
 /**
@@ -19,16 +22,15 @@ import { unlock } from '../../../lock-unlock';
 
 const { Tabs } = unlock( componentsPrivateApis );
 
-const DEFAULT_TABS = [
-	{
-		id: 'installed-fonts',
-		title: __( 'Library' ),
-	},
-	{
-		id: 'upload-fonts',
-		title: __( 'Upload' ),
-	},
-];
+const DEFAULT_TAB = {
+	id: 'installed-fonts',
+	title: __( 'Library' ),
+};
+
+const UPLOAD_TAB = {
+	id: 'upload-fonts',
+	title: __( 'Upload' ),
+};
 
 const tabsFromCollections = ( collections ) =>
 	collections.map( ( { slug, name } ) => ( {
@@ -44,11 +46,24 @@ function FontLibraryModal( {
 	defaultTabId = 'installed-fonts',
 } ) {
 	const { collections, setNotice } = useContext( FontLibraryContext );
+	const canUserCreate = useSelect( ( select ) => {
+		const { canUser } = select( coreStore );
+		return canUser( 'create', 'font-families' );
+	}, [] );
+	const fontUploadsEnabled = useSelect( ( select ) => {
+		const { getEditorSettings } = select( editorStore );
+		return getEditorSettings().fontUploadsEnabled;
+	}, [] );
+
+	const tabs = [ DEFAULT_TAB ];
+
+	if ( canUserCreate ) {
+		if ( fontUploadsEnabled ) {
+			tabs.push( UPLOAD_TAB );
+		}
 
-	const tabs = [
-		...DEFAULT_TABS,
-		...tabsFromCollections( collections || [] ),
-	];
+		tabs.push( ...tabsFromCollections( collections || [] ) );
+	}
 
 	// Reset notice when new tab is selected.
 	const onSelect = () => {

packages/edit-site/src/components/global-styles/font-library-modal/installed-fonts.js

@@ -18,6 +18,8 @@ import {
 	Spinner,
 	privateApis as componentsPrivateApis,
 } from '@wordpress/components';
+import { store as coreStore } from '@wordpress/core-data';
+import { useSelect } from '@wordpress/data';
 import { useContext, useEffect, useState } from '@wordpress/element';
 import { __, sprintf } from '@wordpress/i18n';
 import { chevronLeft } from '@wordpress/icons';
@@ -50,8 +52,24 @@ function InstalledFonts() {
 	} = useContext( FontLibraryContext );
 	const [ isConfirmDeleteOpen, setIsConfirmDeleteOpen ] = useState( false );
 
+	const customFontFamilyId =
+		libraryFontSelected?.source === 'custom' && libraryFontSelected?.id;
+
+	const canUserDelete = useSelect(
+		( select ) => {
+			const { canUser } = select( coreStore );
+			return (
+				customFontFamilyId &&
+				canUser( 'delete', 'font-families', customFontFamilyId )
+			);
+		},
+		[ customFontFamilyId ]
+	);
+
 	const shouldDisplayDeleteButton =
-		!! libraryFontSelected && libraryFontSelected?.source !== 'theme';
+		!! libraryFontSelected &&
+		libraryFontSelected?.source !== 'theme' &&
+		canUserDelete;
 
 	const handleUninstallClick = () => {
 		setIsConfirmDeleteOpen( true );

packages/editor/src/store/defaults.js

@@ -10,6 +10,7 @@ import { SETTINGS_DEFAULTS } from '@wordpress/block-editor';
  * @property {boolean}       richEditingEnabled    Whether rich editing is enabled or not
  * @property {boolean}       codeEditingEnabled    Whether code editing is enabled or not
  * @property {boolean}       fontLibraryEnabled    Whether the font library is enabled or not.
+ * @property {boolean}       fontUploadsEnabled    Whether uploading fonts in the font library is enabled or not.
  * @property {boolean}       enableCustomFields    Whether the WordPress custom fields are enabled or not.
  *                                                 true  = the user has opted to show the Custom Fields panel at the bottom of the editor.
  *                                                 false = the user has opted to hide the Custom Fields panel at the bottom of the editor.
@@ -28,6 +29,7 @@ export const EDITOR_SETTINGS_DEFAULTS = {
 	richEditingEnabled: true,
 	codeEditingEnabled: true,
 	fontLibraryEnabled: true,
+	fontUploadsEnabled: true,
 	enableCustomFields: undefined,
 	defaultRenderingMode: 'post-only',
 };