@wordpress/block-library 6.0.25 → 6.1.0

package/src/comment-template/edit.js

@@ -14,6 +14,11 @@ import {
 import { Spinner } from '@wordpress/components';
 import { store as coreStore } from '@wordpress/core-data';
 
+/**
+ * Internal dependencies
+ */
+import { convertToTree } from './util';
+
 const TEMPLATE = [
 	[ 'core/comment-author-avatar' ],
 	[ 'core/comment-author-name' ],
@@ -23,43 +28,140 @@ const TEMPLATE = [
 	[ 'core/comment-edit-link' ],
 ];
 
-function CommentTemplateInnerBlocks() {
-	const innerBlocksProps = useInnerBlocksProps( {}, { template: TEMPLATE } );
-	return <li { ...innerBlocksProps } />;
+/**
+ * Component which renders the inner blocks of the Comment Template.
+ *
+ * @param {Object} props                    Component props.
+ * @param {Array}  [props.comment]          - A comment object.
+ * @param {Array}  [props.activeComment]    - The block that is currently active.
+ * @param {Array}  [props.setActiveComment] - The setter for activeComment.
+ * @param {Array}  [props.firstBlock]       - First comment in the array.
+ * @param {Array}  [props.blocks]           - Array of blocks returned from
+ *                                          getBlocks() in parent .
+ * @return {WPElement}                 		Inner blocks of the Comment Template
+ */
+function CommentTemplateInnerBlocks( {
+	comment,
+	activeComment,
+	setActiveComment,
+	firstBlock,
+	blocks,
+} ) {
+	const { children, ...innerBlocksProps } = useInnerBlocksProps(
+		{},
+		{ template: TEMPLATE }
+	);
+	return (
+		<li { ...innerBlocksProps }>
+			{ comment === ( activeComment || firstBlock ) ? (
+				children
+			) : (
+				<BlockPreview
+					blocks={ blocks }
+					__experimentalLive
+					__experimentalOnClick={ () => setActiveComment( comment ) }
+				/>
+			) }
+			{ comment?.children?.length > 0 ? (
+				<CommentsList
+					comments={ comment.children }
+					activeComment={ activeComment }
+					setActiveComment={ setActiveComment }
+					blocks={ blocks }
+				/>
+			) : null }
+		</li>
+	);
 }
 
+/**
+ * Component that renders a list of (nested) comments. It is called recursively.
+ *
+ * @param {Object} props                    Component props.
+ * @param {Array}  [props.comments]         - Array of comment objects.
+ * @param {Array}  [props.blockProps]       - Props from parent's `useBlockProps()`.
+ * @param {Array}  [props.activeComment]    - The block that is currently active.
+ * @param {Array}  [props.setActiveComment] - The setter for activeComment.
+ * @param {Array}  [props.blocks]           - Array of blocks returned from
+ *                                          getBlocks() in parent .
+ * @return {WPElement}                 		List of comments.
+ */
+const CommentsList = ( {
+	comments,
+	blockProps,
+	activeComment,
+	setActiveComment,
+	blocks,
+} ) => (
+	<ol { ...blockProps }>
+		{ comments &&
+			comments.map( ( comment ) => (
+				<BlockContextProvider
+					key={ comment.commentId }
+					value={ comment }
+				>
+					<CommentTemplateInnerBlocks
+						comment={ comment }
+						activeComment={ activeComment }
+						setActiveComment={ setActiveComment }
+						blocks={ blocks }
+						firstBlock={ comments[ 0 ] }
+					/>
+				</BlockContextProvider>
+			) ) }
+	</ol>
+);
+
 export default function CommentTemplateEdit( {
 	clientId,
-	context: { postId, queryPerPage },
+	context: { postId, 'comments/perPage': perPage, 'comments/order': order },
 } ) {
 	const blockProps = useBlockProps();
 
-	const [ activeBlockContext, setActiveBlockContext ] = useState();
-
-	const { comments, blocks } = useSelect(
+	const [ activeComment, setActiveComment ] = useState();
+	const { commentOrder, commentsPerPage } = useSelect( ( select ) => {
+		const { getSettings } = select( blockEditorStore );
+		return getSettings().__experimentalDiscussionSettings;
+	} );
+	const { rawComments, blocks } = useSelect(
 		( select ) => {
 			const { getEntityRecords } = select( coreStore );
 			const { getBlocks } = select( blockEditorStore );
 
+			const commentQuery = {
+				post: postId,
+				status: 'approve',
+				context: 'embed',
+				order: order || commentOrder,
+			};
+
+			if ( order ) {
+				commentQuery.order = order;
+			}
 			return {
-				comments: getEntityRecords( 'root', 'comment', {
-					post: postId,
-					status: 'approve',
-					per_page: queryPerPage,
-					order: 'asc',
-				} ),
+				rawComments: getEntityRecords(
+					'root',
+					'comment',
+					commentQuery
+				),
 				blocks: getBlocks( clientId ),
 			};
 		},
-		[ queryPerPage, postId, clientId ]
+		[ postId, clientId, order ]
 	);
 
-	const blockContexts = useMemo(
-		() => comments?.map( ( comment ) => ( { commentId: comment.id } ) ),
-		[ comments ]
+	// TODO: Replicate the logic used on the server.
+	perPage = perPage || commentsPerPage;
+	// We convert the flat list of comments to tree.
+	// Then, we show only a maximum of `perPage` number of comments.
+	// This is because passing `per_page` to `getEntityRecords()` does not
+	// take into account nested comments.
+	const comments = useMemo(
+		() => convertToTree( rawComments ).slice( 0, perPage ),
+		[ rawComments, perPage ]
 	);
 
-	if ( ! comments ) {
+	if ( ! rawComments ) {
 		return (
 			<p { ...blockProps }>
 				<Spinner />
@@ -72,29 +174,12 @@ export default function CommentTemplateEdit( {
 	}
 
 	return (
-		<ul { ...blockProps }>
-			{ blockContexts &&
-				blockContexts.map( ( blockContext ) => (
-					<BlockContextProvider
-						key={ blockContext.commentId }
-						value={ blockContext }
-					>
-						{ blockContext ===
-						( activeBlockContext || blockContexts[ 0 ] ) ? (
-							<CommentTemplateInnerBlocks />
-						) : (
-							<li>
-								<BlockPreview
-									blocks={ blocks }
-									__experimentalLive
-									__experimentalOnClick={ () =>
-										setActiveBlockContext( blockContext )
-									}
-								/>
-							</li>
-						) }
-					</BlockContextProvider>
-				) ) }
-		</ul>
+		<CommentsList
+			comments={ comments }
+			blockProps={ blockProps }
+			blocks={ blocks }
+			activeComment={ activeComment }
+			setActiveComment={ setActiveComment }
+		/>
 	);
 }

package/src/comment-template/index.php

@@ -5,6 +5,43 @@
  * @package WordPress
  */
 
+/**
+ * Function that recursively renders a list of nested comments.
+ *
+ * @param WP_Comment[] $comments    The array of comments.
+ * @param WP_Block     $block           Block instance.
+ * @return string
+ */
+function block_core_comment_template_render_comments( $comments, $block ) {
+	$content = '';
+	foreach ( $comments as $comment ) {
+
+		$block_content = ( new WP_Block(
+			$block->parsed_block,
+			array(
+				'commentId' => $comment->comment_ID,
+			)
+		) )->render( array( 'dynamic' => false ) );
+
+		$children = $comment->get_children();
+
+		// If the comment has children, recurse to create the HTML for the nested
+		// comments.
+		if ( ! empty( $children ) ) {
+			$inner_content  = block_core_comment_template_render_comments(
+				$children,
+				$block
+			);
+			$block_content .= sprintf( '<ol>%1$s</ol>', $inner_content );
+		}
+
+		$content .= '<li>' . $block_content . '</li>';
+	}
+
+	return $content;
+
+}
+
 /**
  * Renders the `core/comment-template` block on the server.
  *
@@ -16,37 +53,27 @@
  * defined by the block's inner blocks.
  */
 function render_block_core_comment_template( $attributes, $content, $block ) {
-
-	$post_id = $block->context['postId'];
-
 	// Bail out early if the post ID is not set for some reason.
-	if ( ! isset( $post_id ) ) {
+	if ( empty( $block->context['postId'] ) ) {
 		return '';
 	}
 
-	$number = $block->context['queryPerPage'];
+	$comment_query = new WP_Comment_Query(
+		build_comment_query_vars_from_block( $block )
+	);
 
 	// Get an array of comments for the current post.
-	$comments = get_approved_comments( $post_id, array( 'number' => $number ) );
-
+	$comments = $comment_query->get_comments();
 	if ( count( $comments ) === 0 ) {
 		return '';
 	}
 
-	$content = '';
-	foreach ( $comments as $comment ) {
-		$block_content = ( new WP_Block(
-			$block->parsed_block,
-			array(
-				'commentId' => $comment->comment_ID,
-			)
-		) )->render( array( 'dynamic' => false ) );
-		$content      .= '<li>' . $block_content . '</li>';
-	}
+	$wrapper_attributes = get_block_wrapper_attributes();
 
 	return sprintf(
-		'<ul>%1$s</ul>',
-		$content
+		'<ol %1$s>%2$s</ol>',
+		$wrapper_attributes,
+		block_core_comment_template_render_comments( $comments, $block )
 	);
 }
 

package/src/comment-template/style.scss

@@ -0,0 +1,17 @@
+.wp-block-comment-template {
+	margin-bottom: 0;
+	max-width: 100%;
+	list-style: none;
+	padding: 0;
+
+	li {
+		clear: both;
+	}
+
+	ol {
+		margin-bottom: 0;
+		max-width: 100%;
+		list-style: none;
+		padding-left: 2rem;
+	}
+}

package/src/comment-template/test/index.js

@@ -0,0 +1,45 @@
+/**
+ * Internal dependencies
+ */
+import { convertToTree } from '../util';
+
+describe( 'Convert to tree', () => {
+	it( 'Empty comments', () => {
+		const comments = convertToTree( [] );
+
+		expect( comments ).toEqual( [] );
+	} );
+
+	it( 'Handle comments', () => {
+		const comments = convertToTree( [
+			{ id: 1, parent: 0 },
+			{ id: 2, parent: 0 },
+			{ id: 3, parent: 2 },
+			{ id: 4, parent: 2 },
+			{ id: 5, parent: 4 },
+			{ id: 6, parent: 1 },
+		] );
+
+		expect( comments ).toEqual( [
+			{
+				commentId: 1,
+				children: [
+					{
+						commentId: 6,
+						children: [],
+					},
+				],
+			},
+			{
+				commentId: 2,
+				children: [
+					{ commentId: 3, children: [] },
+					{
+						commentId: 4,
+						children: [ { commentId: 5, children: [] } ],
+					},
+				],
+			},
+		] );
+	} );
+} );

package/src/comment-template/util.js

@@ -0,0 +1,56 @@
+/**
+ *
+ * This function converts a flat list of comment objects with a `parent` property
+ * to a nested list of comment objects with a `children` property. The `children`
+ * property is itself a list of comment objects.
+ *
+ * @example
+ * ```
+ * const comments = [
+ * 	{ id: 1, parent: 0 },
+ * 	{ id: 2, parent: 1 },
+ * 	{ id: 3, parent: 2 },
+ * 	{ id: 4, parent: 1 },
+ * ];
+ * expect( convertToTree( comments ) ).toEqual( [
+ * 	{
+ * 		commentId: 1,
+ * 		children: [
+ * 			{ commentId: 2, children: [ { commentId: 3, children: [] } ] },
+ * 			{ commentId: 4, children: [] },
+ * 		],
+ * 	},
+ * ] );
+ * ```
+ * @typedef {{id: number, parent: number}} Comment
+ * @param {Comment[]} data - List of comment objects.
+ *
+ * @return {Object[]} Nested list of comment objects with a `children` property.
+ */
+export const convertToTree = ( data ) => {
+	const table = {};
+	if ( ! data ) return [];
+
+	// First create a hash table of { [id]: { ...comment, children: [] }}
+	data.forEach( ( item ) => {
+		table[ item.id ] = { commentId: item.id, children: [] };
+	} );
+
+	const tree = [];
+
+	// Iterate over the original comments again
+	data.forEach( ( item ) => {
+		if ( item.parent ) {
+			// If the comment has a "parent", then find that parent in the table that
+			// we have created above and push the current comment to the array of its
+			// children.
+			table[ item.parent ]?.children.push( table[ item.id ] );
+		} else {
+			// Otherwise, if the comment has no parent (also works if parent is 0)
+			// that means that it's a top-level comment so we can find it in the table
+			// and push it to the final tree.
+			tree.push( table[ item.id ] );
+		}
+	} );
+	return tree;
+};

package/src/comments-pagination/block.json

@@ -0,0 +1,37 @@
+{
+	"$schema": "https://schemas.wp.org/trunk/block.json",
+	"apiVersion": 2,
+	"name": "core/comments-pagination",
+	"title": "Comments Pagination",
+	"category": "theme",
+	"parent": [ "core/comments-query-loop" ],
+	"description": "Displays a paginated navigation to next/previous set of comments, when applicable.",
+	"textdomain": "default",
+	"attributes": {
+		"paginationArrow": {
+			"type": "string",
+			"default": "none"
+		}
+	},
+	"providesContext": {
+		"comments/paginationArrow": "paginationArrow"
+	},
+	"supports": {
+		"align": true,
+		"reusable": false,
+		"html": false,
+		"color": {
+			"gradients": true,
+			"link": true
+		},
+		"__experimentalLayout": {
+			"allowSwitching": false,
+			"allowInheriting": false,
+			"default": {
+				"type": "flex"
+			}
+		}
+	},
+	"editorStyle": "wp-block-comments-pagination-editor",
+	"style": "wp-block-comments-pagination"
+}

package/src/comments-pagination/comments-pagination-arrow-controls.js

@@ -0,0 +1,44 @@
+/**
+ * WordPress dependencies
+ */
+import { __, _x } from '@wordpress/i18n';
+import {
+	__experimentalToggleGroupControl as ToggleGroupControl,
+	__experimentalToggleGroupControlOption as ToggleGroupControlOption,
+} from '@wordpress/components';
+
+export function CommentsPaginationArrowControls( { value, onChange } ) {
+	return (
+		<ToggleGroupControl
+			label={ __( 'Arrow' ) }
+			value={ value }
+			onChange={ onChange }
+			help={ __(
+				'A decorative arrow appended to the next and previous comments link.'
+			) }
+			isBlock
+		>
+			<ToggleGroupControlOption
+				value="none"
+				label={ _x(
+					'None',
+					'Arrow option for Comments Pagination Next/Previous blocks'
+				) }
+			/>
+			<ToggleGroupControlOption
+				value="arrow"
+				label={ _x(
+					'Arrow',
+					'Arrow option for Comments Pagination Next/Previous blocks'
+				) }
+			/>
+			<ToggleGroupControlOption
+				value="chevron"
+				label={ _x(
+					'Chevron',
+					'Arrow option for Comments Pagination Next/Previous blocks'
+				) }
+			/>
+		</ToggleGroupControl>
+	);
+}

package/src/comments-pagination/edit.js

@@ -0,0 +1,83 @@
+/**
+ * WordPress dependencies
+ */
+import { __ } from '@wordpress/i18n';
+import {
+	InspectorControls,
+	useBlockProps,
+	useInnerBlocksProps,
+	store as blockEditorStore,
+} from '@wordpress/block-editor';
+import { useSelect } from '@wordpress/data';
+import { getBlockSupport } from '@wordpress/blocks';
+import { PanelBody } from '@wordpress/components';
+
+/**
+ * Internal dependencies
+ */
+import { CommentsPaginationArrowControls } from './comments-pagination-arrow-controls';
+
+const TEMPLATE = [
+	[ 'core/comments-pagination-previous' ],
+	[ 'core/comments-pagination-numbers' ],
+	[ 'core/comments-pagination-next' ],
+];
+
+const getDefaultBlockLayout = ( blockTypeOrName ) => {
+	const layoutBlockSupportConfig = getBlockSupport(
+		blockTypeOrName,
+		'__experimentalLayout'
+	);
+	return layoutBlockSupportConfig?.default;
+};
+
+export default function QueryPaginationEdit( {
+	attributes: { paginationArrow, layout },
+	setAttributes,
+	clientId,
+	name,
+} ) {
+	const usedLayout = layout || getDefaultBlockLayout( name );
+	const hasNextPreviousBlocks = useSelect( ( select ) => {
+		const { getBlocks } = select( blockEditorStore );
+		const innerBlocks = getBlocks( clientId );
+		/**
+		 * Show the `paginationArrow` control only if a
+		 * Comments Pagination Next or Comments Pagination Previous
+		 * block exists.
+		 */
+		return innerBlocks?.find( ( innerBlock ) => {
+			return [
+				'core/comments-pagination-previous',
+				'core/comments-pagination-next',
+			].includes( innerBlock.name );
+		} );
+	}, [] );
+	const blockProps = useBlockProps();
+	const innerBlocksProps = useInnerBlocksProps( blockProps, {
+		template: TEMPLATE,
+		allowedBlocks: [
+			'core/comments-pagination-previous',
+			'core/comments-pagination-numbers',
+			'core/comments-pagination-next',
+		],
+		__experimentalLayout: usedLayout,
+	} );
+	return (
+		<>
+			{ hasNextPreviousBlocks && (
+				<InspectorControls>
+					<PanelBody title={ __( 'Settings' ) }>
+						<CommentsPaginationArrowControls
+							value={ paginationArrow }
+							onChange={ ( value ) => {
+								setAttributes( { paginationArrow: value } );
+							} }
+						/>
+					</PanelBody>
+				</InspectorControls>
+			) }
+			<div { ...innerBlocksProps } />
+		</>
+	);
+}

package/src/comments-pagination/editor.scss

@@ -0,0 +1,34 @@
+$pagination-margin: 0.5em;
+
+// Center flex items. This has an equivalent in style.scss.
+.wp-block[data-align="center"] > .wp-block-comments-pagination {
+	justify-content: center;
+}
+
+.editor-styles-wrapper {
+	.wp-block-comments-pagination {
+		max-width: 100%;
+		&.block-editor-block-list__layout {
+			margin: 0;
+		}
+	}
+}
+
+.wp-block-comments-pagination {
+	> .wp-block-comments-pagination-next,
+	> .wp-block-comments-pagination-previous,
+	> .wp-block-comments-pagination-numbers {
+		// Override editor auto block margins.
+		margin-left: 0;
+		margin-top: $pagination-margin;
+
+		/*rtl:ignore*/
+		margin-right: $pagination-margin;
+		margin-bottom: $pagination-margin;
+
+		&:last-child {
+			/*rtl:ignore*/
+			margin-right: 0;
+		}
+	}
+}

package/src/comments-pagination/index.js

@@ -0,0 +1,20 @@
+/**
+ * WordPress dependencies
+ */
+import { queryPagination as icon } from '@wordpress/icons';
+
+/**
+ * Internal dependencies
+ */
+import metadata from './block.json';
+import edit from './edit';
+import save from './save';
+
+const { name } = metadata;
+export { metadata, name };
+
+export const settings = {
+	icon,
+	edit,
+	save,
+};

package/src/comments-pagination/index.php

@@ -0,0 +1,39 @@
+<?php
+/**
+ * Server-side rendering of the `core/comments-pagination` block.
+ *
+ * @package WordPress
+ */
+
+/**
+ * Renders the `core/comments-pagination` block on the server.
+ *
+ * @param array  $attributes Block attributes.
+ * @param string $content    Block default content.
+ *
+ * @return string Returns the wrapper for the Comments pagination.
+ */
+function render_block_core_comments_pagination( $attributes, $content ) {
+	if ( empty( trim( $content ) ) ) {
+		return '';
+	}
+
+	return sprintf(
+		'<div %1$s>%2$s</div>',
+		get_block_wrapper_attributes(),
+		$content
+	);
+}
+
+/**
+ * Registers the `core/comments-pagination` block on the server.
+ */
+function register_block_core_comments_pagination() {
+	register_block_type_from_metadata(
+		__DIR__ . '/comments-pagination',
+		array(
+			'render_callback' => 'render_block_core_comments_pagination',
+		)
+	);
+}
+add_action( 'init', 'register_block_core_comments_pagination' );

package/src/comments-pagination/save.js

@@ -0,0 +1,8 @@
+/**
+ * WordPress dependencies
+ */
+import { InnerBlocks } from '@wordpress/block-editor';
+
+export default function save() {
+	return <InnerBlocks.Content />;
+}